@crvouga/dev-fleet 0.0.0-stage → 0.2.0

package/src/cli/ui-reports.ts

@@ -0,0 +1,211 @@
+import { record, reportChecks, text } from './ui-data';
+import type { CheckRow, Choice, Session } from './ui-types';
+
+export async function inspectChecks(
+  session: Session,
+  data: unknown
+): Promise<void> {
+  const checks = reportChecks(data);
+  let node = '*';
+  let status = '*';
+  while (true) {
+    const visible = checks.filter(
+      (check) =>
+        (node === '*' || check.node === node) &&
+        (status === '*' || check.status === status)
+    );
+    const choice = await session.prompts.search(
+      `Report · ${visible.length}/${checks.length} checks · node ${node} · status ${status}`,
+      (term) => checkChoices(visible, term)
+    );
+    if (choice === 'back') return;
+    if (choice === 'node') node = await nodeFilter(session, checks);
+    else if (choice === 'status') status = await statusFilter(session);
+    else {
+      const check = visible[Number(choice)];
+      if (check) showCheck(session, check);
+    }
+  }
+}
+
+function checkChoices(checks: CheckRow[], term: string): Choice[] {
+  const choices = checks.flatMap((check, index) => {
+    const name = `${check.status.toUpperCase()} · ${check.node} · ${check.id}`;
+    return `${name} ${check.summary}`.toLowerCase().includes(term.toLowerCase())
+      ? [{ name, value: String(index), description: check.summary }]
+      : [];
+  });
+  return [
+    ...(choices.length
+      ? choices
+      : [
+          {
+            name: 'No matching checks — change search or filters',
+            value: 'none',
+          },
+        ]),
+    { name: 'Filter by node', value: 'node' },
+    { name: 'Filter by status', value: 'status' },
+    { name: 'Back to result', value: 'back' },
+  ];
+}
+
+function nodeFilter(session: Session, checks: CheckRow[]): Promise<string> {
+  return session.prompts.select('Node filter', [
+    { name: 'All nodes', value: '*' },
+    ...[...new Set(checks.map((check) => check.node))].map((node) => ({
+      name: node,
+      value: node,
+    })),
+  ]);
+}
+
+function statusFilter(session: Session): Promise<string> {
+  return session.prompts.select('Status filter', [
+    { name: 'All statuses (including warnings and skips)', value: '*' },
+    ...['fail', 'warn', 'skip', 'pass'].map((status) => ({
+      name: status.toUpperCase(),
+      value: status,
+    })),
+  ]);
+}
+
+function showCheck(session: Session, check: CheckRow): void {
+  session.display.panel(
+    `${check.status.toUpperCase()} · ${check.node} · ${check.id}`,
+    check.summary
+  );
+  session.display.write(
+    `Remedy: ${check.remedy || 'No automated remedy. Review this check manually.'}`
+  );
+  if (check.command)
+    session.display.write(
+      `Suggested operator command (not executed):\n${check.command}`
+    );
+  session.display.write(
+    'Remedies are guidance only. Credentials, SSH and host-key configuration stay operator-owned.'
+  );
+}
+
+export async function inspectDetails(
+  session: Session,
+  data: unknown
+): Promise<void> {
+  const sections = detailSections(data);
+  if (!sections.length) {
+    session.display.write(
+      'No additional safe display fields. Use the reproducible command for the structured document.'
+    );
+    return;
+  }
+  let next = true;
+  while (next) {
+    const selection = await session.prompts.select('Details', [
+      ...sections.map((section, index) => ({
+        name: section.title,
+        value: String(index),
+      })),
+      { name: 'Back to result', value: 'back' },
+    ]);
+    const section = sections[Number(selection)];
+    if (selection === 'back') next = false;
+    else if (section) session.display.panel(section.title, section.body);
+  }
+}
+
+function detailSections(data: unknown): { title: string; body: string }[] {
+  if (!record(data)) return [];
+  const sections = [
+    'help',
+    'guide',
+    'next',
+    'authorize',
+    'path',
+    'sshTemplate',
+    'workspaceCommand',
+    'verifyCommand',
+    'invocation',
+    'discovery',
+  ].flatMap((key) =>
+    typeof data[key] === 'string' ? [{ title: key, body: text(data[key]) }] : []
+  );
+  for (const key of ['steps', 'targets', 'safety', 'examples']) {
+    if (Array.isArray(data[key]))
+      sections.push(
+        ...data[key].flatMap((value: unknown, index: number) =>
+          typeof value === 'string'
+            ? [{ title: `${key} · ${index + 1}`, body: text(value) }]
+            : []
+        )
+      );
+  }
+  if (Array.isArray(data['nodes']))
+    sections.push(...nodeSections(data['nodes']));
+  if (Array.isArray(data['commands']))
+    sections.push(...commandSections(data['commands']));
+  for (const key of ['configuration', 'output', 'coverage']) {
+    if (record(data[key]))
+      sections.push({ title: key, body: safeFields(data[key]) });
+  }
+  if (typeof data['$schema'] === 'string')
+    sections.push({
+      title: 'JSON schema',
+      body: JSON.stringify(data, null, 2),
+    });
+  return sections;
+}
+
+function commandSections(
+  commands: unknown[]
+): { title: string; body: string }[] {
+  return commands.flatMap((command) => {
+    if (!record(command)) return [];
+    return [
+      {
+        title: text(command['id'], 'Command'),
+        body: [
+          text(command['title']),
+          text(command['description']),
+          ...(Array.isArray(command['examples'])
+            ? command['examples'].map((value: unknown) => text(value))
+            : []),
+        ]
+          .filter(Boolean)
+          .join('\n'),
+      },
+    ];
+  });
+}
+
+function safeFields(value: Record<string, unknown>): string {
+  return Object.entries(value)
+    .flatMap(([key, field]) =>
+      typeof field === 'string' ? [`${key}: ${text(field)}`] : []
+    )
+    .join('\n');
+}
+
+function nodeSections(nodes: unknown[]): { title: string; body: string }[] {
+  return nodes.flatMap((node) => {
+    if (!record(node)) return [];
+    const id = text(node['id'], text(node['node'], 'Node'));
+    const body = ['id', 'ssh', 'workspace', 'runtime'].flatMap((key) =>
+      typeof node[key] === 'string' ? [`${key}: ${text(node[key])}`] : []
+    );
+    if (Array.isArray(node['required']))
+      body.push(
+        `required: ${node['required'].map((value: unknown) => text(value)).join(', ') || 'none'}`
+      );
+    return [
+      ...(body.length ? [{ title: id, body: body.join('\n') }] : []),
+      ...detailSections({
+        steps: node['steps'],
+        sshTemplate: node['sshTemplate'],
+        verifyCommand: node['verifyCommand'],
+      }).map((section) => ({
+        title: `${id} · ${section.title}`,
+        body: section.body,
+      })),
+    ];
+  });
+}

package/src/cli/ui-targets.ts

@@ -0,0 +1,100 @@
+import { execute, showOutcome, successful } from './ui-execute';
+import { record, text } from './ui-data';
+import type { Choice, Session } from './ui-types';
+
+export async function chooseTargets(
+  session: Session,
+  action: string
+): Promise<string[] | undefined> {
+  const selection = await session.prompts.select('Choose target scope', [
+    ...(action === 'onboard'
+      ? []
+      : [
+          {
+            name: 'Manager only / local',
+            value: 'local',
+            description:
+              'No roster or SSH required; uses this session workspace.',
+          },
+          {
+            name: allTargetsName(action),
+            value: 'all',
+            description: allTargetsDescription(action),
+          },
+        ]),
+    { name: 'Select roster nodes…', value: 'selected' },
+    { name: 'Back to palette', value: 'back' },
+  ]);
+  if (selection === 'back') return undefined;
+  if (selection === 'local') return ['--local'];
+  if (selection === 'all' && action === 'repair') return [];
+  const nodes = await availableNodes(session);
+  if (!nodes.length) return missingRoster(session, action);
+  if (selection === 'all') return [];
+  const selected = await session.prompts.checkbox(
+    'Select nodes · space to toggle, enter to continue',
+    nodes
+  );
+  if (!selected.length) {
+    session.display.write(
+      'No nodes selected. Nothing ran; returning to the palette.'
+    );
+    return undefined;
+  }
+  return selected.flatMap((id) => ['--node', id]);
+}
+
+async function availableNodes(session: Session): Promise<Choice[]> {
+  const outcome = await execute(
+    session,
+    ['fleet-nodes'],
+    'Reading local roster (no SSH)'
+  );
+  if (!successful(outcome)) {
+    showOutcome(session, outcome);
+    return [];
+  }
+  if (!record(outcome.data) || !Array.isArray(outcome.data['nodes'])) return [];
+  return outcome.data['nodes'].flatMap((node: unknown) => {
+    if (!record(node) || typeof node['id'] !== 'string') return [];
+    return [
+      {
+        name: text(node['id']),
+        value: node['id'],
+        description: `${text(node['ssh'])} · ${text(node['workspace'])}`,
+      },
+    ];
+  });
+}
+
+async function missingRoster(
+  session: Session,
+  action: string
+): Promise<string[] | undefined> {
+  session.display.panel(
+    'Roster needed',
+    [
+      'No usable roster nodes. Run fleet-node-add to register an existing computer.',
+      'Manager-only status works without a roster or SSH. No login, host-key change or repair is automatic.',
+    ].join('\n')
+  );
+  if (action !== 'doctor') return undefined;
+  const choice = await session.prompts.select('Continue without a roster?', [
+    { name: 'Run manager-only diagnostics', value: 'local' },
+    { name: 'Back to palette', value: 'back' },
+  ]);
+  return choice === 'local' ? ['--local'] : undefined;
+}
+
+function allTargetsName(action: string): string {
+  return action === 'repair'
+    ? 'All visible Tailscale computers'
+    : 'All roster nodes';
+}
+
+function allTargetsDescription(action: string): string {
+  if (action === 'doctor') return 'Manager + every configured node; read-only.';
+  return action === 'repair'
+    ? 'Inspect this manager and every visible computer; preview repairs before applying.'
+    : 'Every configured remote checkout.';
+}

package/src/cli/ui-terminal.ts

@@ -0,0 +1,109 @@
+import { checkbox, confirm, input, search, select } from '@inquirer/prompts';
+import { Chalk } from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import { clean } from './ui-data';
+import type { Display, Prompts } from './ui-types';
+
+function plainTerminal(): boolean {
+  return (
+    process.env['NO_COLOR'] !== undefined || process.env['TERM'] === 'dumb'
+  );
+}
+
+function pageSize(): number {
+  return Math.max(3, Math.min(10, (process.stderr.rows || 24) - 10));
+}
+
+export function terminalPrompts(): Prompts {
+  const context = { output: process.stderr, clearPromptOnDone: false };
+  return {
+    select: (message, choices) =>
+      select({ message, choices, pageSize: pageSize(), loop: false }, context),
+    search: (message, source) =>
+      search(
+        {
+          message,
+          source: (term) => source(term ?? ''),
+          pageSize: pageSize(),
+          theme: { style: { highlight: (value: string) => value } },
+        },
+        context
+      ),
+    checkbox: (message, choices) =>
+      checkbox(
+        { message, choices, pageSize: pageSize(), loop: false },
+        context
+      ),
+    input: (message, initial = '', validate = () => true) =>
+      input({ message, default: initial, validate }, context),
+    confirm: (message) => confirm({ message, default: false }, context),
+  };
+}
+
+export function terminalDisplay(): Display {
+  const color = new Chalk({
+    level: !plainTerminal() && process.stderr.isTTY ? 1 : 0,
+  });
+  const write = (message: string): void => {
+    process.stderr.write(`${message}\n`);
+  };
+  return {
+    write,
+    panel: (title, body) => {
+      const content = `${color.bold(clean(title))}\n${body}`;
+      if ((process.stderr.columns || 80) < 48 || plainTerminal()) {
+        write(`\n${content}\n`);
+        return;
+      }
+      write(
+        boxen(content, {
+          padding: 1,
+          borderStyle: 'round',
+          ...(color.level ? { borderColor: 'cyan' as const } : {}),
+          width: Math.min(process.stderr.columns || 80, 96),
+        })
+      );
+    },
+    table: (headers, rows) => drawTable(write, headers, rows),
+    progress: (message) => {
+      const spinner = ora({
+        text: message,
+        stream: process.stderr,
+        isEnabled: Boolean(process.stderr.isTTY) && !plainTerminal(),
+        isSilent: !process.stderr.isTTY || plainTerminal(),
+        discardStdin: false,
+      });
+      if (spinner.isEnabled) spinner.start();
+      else write(`… ${message}`);
+      return {
+        stop: () => {
+          spinner.stop();
+        },
+      };
+    },
+  };
+}
+
+function drawTable(
+  write: (text: string) => void,
+  headers: string[],
+  rows: string[][]
+): void {
+  if ((process.stderr.columns || 80) < 64 || plainTerminal()) {
+    rows.forEach((row) => write(row.map((cell) => clean(cell)).join(' · ')));
+    return;
+  }
+  const width = Math.floor(
+    ((process.stderr.columns || 80) - headers.length * 3 - 1) / headers.length
+  );
+  const table = new Table({
+    head: headers,
+    colWidths: headers.map(() => Math.max(8, width)),
+    wordWrap: true,
+    style: { head: [], border: [] },
+  });
+  table.push(...rows.map((row) => row.map((cell) => clean(cell))));
+  write(table.toString());
+}

package/src/cli/ui-types.ts

@@ -0,0 +1,49 @@
+import type { CommandOutcome, InteractiveOptions } from './contracts';
+
+export interface Choice {
+  name: string;
+  value: string;
+  description?: string;
+  checked?: boolean;
+}
+
+export interface Prompts {
+  select(message: string, choices: Choice[]): Promise<string>;
+  search(message: string, source: (term: string) => Choice[]): Promise<string>;
+  checkbox(message: string, choices: Choice[]): Promise<string[]>;
+  input(
+    message: string,
+    initial?: string,
+    validate?: (value: string) => boolean | string
+  ): Promise<string>;
+  confirm(message: string): Promise<boolean>;
+}
+
+export interface Display {
+  write(text: string): void;
+  panel(title: string, body: string): void;
+  table(headers: string[], rows: string[][]): void;
+  progress(message: string): { stop(): void };
+}
+
+export interface Session {
+  options: InteractiveOptions;
+  prompts: Prompts;
+  display: Display;
+  workspace?: string;
+  config?: string;
+}
+
+export interface CheckRow {
+  node: string;
+  id: string;
+  status: string;
+  summary: string;
+  remedy?: string;
+  command?: string;
+}
+
+export interface Execution {
+  outcome: CommandOutcome;
+  args: string[];
+}

package/src/cli/ui-wizard.ts

@@ -0,0 +1,101 @@
+import { confirmMutation, runWithResults } from './ui-actions';
+import { absolutePath, clean, reproduction } from './ui-data';
+import type { Session } from './ui-types';
+
+const CAPABILITIES = ['github', 'vault', 't3', 'vscode', 'toolchain'];
+
+export async function addNode(session: Session): Promise<void> {
+  showIntro(session);
+  await registerNode(session);
+}
+
+function showIntro(session: Session): void {
+  session.display.panel(
+    'fleet-node-add',
+    [
+      'Register an EXISTING computer in your local secret-free roster.',
+      'Use a previously verified SSH alias. This wizard never connects, provisions, logs in or changes host keys.',
+      'Cancel with Ctrl+C. No write occurs until you approve the preview.',
+    ].join('\n')
+  );
+}
+
+async function registerNode(session: Session): Promise<void> {
+  const id = await session.prompts.input(
+    'Node ID (lowercase, e.g. dev-linux)',
+    '',
+    validId
+  );
+  const alias = await session.prompts.input(
+    'Existing SSH alias / hostname',
+    id,
+    validAlias
+  );
+  const workspace = await session.prompts.input(
+    'Absolute POSIX workspace on the node',
+    '',
+    absolutePath
+  );
+  const runtime = await session.prompts.input(
+    'Optional absolute Node/Bun executable (blank = node on SSH PATH)',
+    '',
+    (value) => value === '' || absolutePath(value)
+  );
+  const capabilities = await session.prompts.checkbox(
+    'Required capabilities · space to toggle',
+    CAPABILITIES.map((capability) => ({
+      name: capability,
+      value: capability,
+      checked: capability !== 'vscode',
+    }))
+  );
+  const args = [
+    'fleet-node-add',
+    '--id',
+    id,
+    '--ssh',
+    alias,
+    '--path',
+    workspace,
+    ...(runtime ? ['--runtime', runtime] : []),
+    '--require',
+    capabilities.join(',') || 'none',
+    '--apply',
+    '--yes',
+  ];
+  session.display.table(
+    ['Field', 'Preview'],
+    [
+      ['ID', clean(id)],
+      ['SSH', clean(alias)],
+      ['Workspace', clean(workspace)],
+      ['Runtime', clean(runtime) || 'node (remote non-login PATH)'],
+      ['Required', capabilities.join(', ') || 'none'],
+    ]
+  );
+  session.display.write(`$ ${reproduction(session, args)}`);
+  if (!(await confirmMutation(session, args))) {
+    session.display.write('Cancelled — no roster was written.');
+    return;
+  }
+  await runWithResults(session, args, 'Saving roster node (no SSH)', {
+    mutation: true,
+  });
+  session.display.write(
+    'Next: fleet-nodes --onboard --node ID for operator-owned SSH / authentication guidance, then fleet-status.'
+  );
+}
+
+function validId(value: string): boolean | string {
+  return (
+    /^[a-z][a-z0-9-]{0,62}$/.test(value) ||
+    'Use 1–63 lowercase letters, digits or hyphens; start with a letter.'
+  );
+}
+
+function validAlias(value: string): boolean | string {
+  return (
+    /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,252}$/.test(value) ||
+    'Use an existing plain SSH alias/hostname; no user@host, options or ports.'
+  );
+}

package/src/cli/ui.ts

@@ -0,0 +1,9 @@
+import type { InteractiveOptions } from './contracts';
+import { runInteractive } from './ui-controller';
+import { terminalDisplay, terminalPrompts } from './ui-terminal';
+
+export async function startInteractive(
+  options: InteractiveOptions
+): Promise<void> {
+  await runInteractive(options, terminalPrompts(), terminalDisplay());
+}

package/src/cli/worker-health-output.ts

@@ -0,0 +1,37 @@
+import type { Report } from '../types';
+import { stableUrls } from './fleet-sync-output';
+
+/** The human command answers what remains; the JSON contract retains all evidence. */
+export function workerHealthText(
+  report: Report,
+  scope: { computers: number; excludedUnmanaged: string[] },
+  dashboardUrl: string | null = null
+): string {
+  const lines = [
+    `Fleet health: ${report.ok ? 'ready' : 'attention required'}`,
+    `Scope: ${scope.computers} canonical workers; ${scope.excludedUnmanaged.length} other computers outside worker scope.`,
+    `Dashboard: ${dashboardUrl ?? 'unavailable; see the dashboard checks below'}`,
+  ];
+  for (const node of report.nodes) {
+    if (
+      node.node === 'tailscale' &&
+      node.checks.every((check) => check.status === 'pass')
+    )
+      continue;
+    const gaps = node.checks.filter(
+      (check) => check.required !== false && check.status !== 'pass'
+    );
+    lines.push(
+      '',
+      `${node.node}: ${gaps.length ? `${gaps.length} remaining` : 'ready'}`
+    );
+    for (const check of gaps) {
+      lines.push(
+        `  ${check.status.toUpperCase()} ${check.id}: ${check.summary}`
+      );
+      if (check.remedy) lines.push(`    Next: ${check.remedy.action}`);
+    }
+  }
+  lines.push('', 'Use --json for the full versioned evidence report.');
+  return stableUrls(lines.join('\n'));
+}