@matthesketh/fleet 1.8.1 → 1.11.1

package/dist/commands/boot-start.js

@@ -1,51 +1,43 @@
+import { z } from 'zod';
 import { load, findApp } from '../core/registry.js';
 import { refresh } from '../core/boot-refresh.js';
 import { composeUp } from '../core/docker.js';
-function log(msg) {
-    process.stdout.write(`[boot-start] ${msg}\n`);
-}
-function logErr(msg) {
-    process.stderr.write(`[boot-start] ${msg}\n`);
-}
-export async function bootStartCommand(args) {
-    const appName = args[0];
-    if (!appName) {
-        logErr('Usage: fleet boot-start <app>');
-        process.exit(1);
-    }
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app) {
-        logErr(`app not found: ${appName}`);
-        process.exit(1);
-    }
-    // Refresh is best-effort. Any error — sync or async — is caught here and logged,
-    // then compose up ALWAYS runs. This is the fail-safe contract for boot.
-    try {
-        const result = await refresh(app);
-        switch (result.kind) {
-            case 'refreshed':
-                log(`refreshed ${app.name} head=${result.head} built=${result.built}`);
-                break;
-            case 'no-change':
-                log(`no-change ${app.name} head=${result.head}`);
-                break;
-            case 'skipped':
-                log(`skipped ${app.name} reason=${result.reason}`);
-                break;
-            case 'failed-safe':
-                log(`failed-safe ${app.name} step=${result.step} detail=${result.detail}`);
-                break;
+import { defineCommand } from '../registry/registry.js';
+export const bootStartCommand = defineCommand({
+    name: 'boot-start',
+    summary: 'Start an app respecting boot-order dependencies',
+    args: z.object({ app: z.string() }),
+    cliOnly: true,
+    async run(args, ctx) {
+        const app = findApp(load(), args.app);
+        if (!app) {
+            return { ok: false, summary: `app not found: ${args.app}`, data: { app: args.app } };
         }
-    }
-    catch (err) {
-        log(`failed-safe ${app.name} step=outer-catch detail=${err instanceof Error ? err.message : String(err)}`);
-    }
-    // compose up — the only step whose exit code matters
-    const ok = composeUp(app.composePath, app.composeFile);
-    if (!ok) {
-        logErr(`compose up failed for ${app.name}`);
-        process.exit(1);
-    }
-    log(`up ${app.name}`);
-}
+        // refresh is best-effort — any error (sync or async) is logged and compose
+        // up always runs. this is the fail-safe contract for boot.
+        try {
+            const result = await refresh(app);
+            switch (result.kind) {
+                case 'refreshed':
+                    ctx.log({ level: 'info', message: `refreshed ${app.name} head=${result.head} built=${result.built}` });
+                    break;
+                case 'no-change':
+                    ctx.log({ level: 'info', message: `no-change ${app.name} head=${result.head}` });
+                    break;
+                case 'skipped':
+                    ctx.log({ level: 'info', message: `skipped ${app.name} reason=${result.reason}` });
+                    break;
+                case 'failed-safe':
+                    ctx.log({ level: 'warn', message: `failed-safe ${app.name} step=${result.step} detail=${result.detail}` });
+                    break;
+            }
+        }
+        catch (err) {
+            ctx.log({ level: 'warn', message: `failed-safe ${app.name} step=outer-catch detail=${err instanceof Error ? err.message : String(err)}` });
+        }
+        if (!composeUp(app.composePath, app.composeFile)) {
+            return { ok: false, summary: `compose up failed for ${app.name}`, data: { app: app.name } };
+        }
+        return { ok: true, summary: `up ${app.name}`, data: { app: app.name } };
+    },
+});

package/dist/commands/completions.d.ts

@@ -0,0 +1,6 @@
+export type Shell = 'bash' | 'zsh' | 'fish';
+export interface CompletionsData {
+    shell: Shell;
+    script: string;
+}
+export declare const completionsCommand: import("../registry/types.js").CommandDef<CompletionsData>;

package/dist/commands/completions.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { allCommands, defineCommand } from '../registry/registry.js';
+// commands still living in the legacy switch in cli.ts. tracked separately
+// from the registry so completions stay accurate during the migration;
+// shrinks toward [] as each migration commit lands.
+const LEGACY_COMMANDS = [
+    'logs', 'egress', 'deps', 'audit', 'testflight', 'deploy', 'nginx', 'secrets',
+    'git', 'watchdog', 'guard', 'backup', 'routines', 'routine-run',
+    'tui', 'dashboard', 'mcp',
+];
+/** lazy-import loadRegistry to dodge the circular: registry/index imports this
+ *  module (to register the command), and this module needs the registry to be
+ *  populated before allCommands() is called. importing index at call-time
+ *  lets node finish evaluating both modules first. */
+async function collectCommandNames() {
+    const { loadRegistry } = await import('../registry/index.js');
+    loadRegistry();
+    const registered = allCommands().map(c => c.name);
+    return Array.from(new Set([...registered, ...LEGACY_COMMANDS])).sort();
+}
+function bashScript(names) {
+    // tab completion entry-point — sourced from ~/.bashrc:
+    //   eval "$(fleet completions bash)"
+    return `# fleet bash completions — install with: eval "$(fleet completions bash)"
+_fleet_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${names.join(' ')}" -- "$cur") )
+  fi
+  return 0
+}
+complete -F _fleet_completions fleet
+`;
+}
+function zshScript(names) {
+    return `# fleet zsh completions — install with: eval "$(fleet completions zsh)"
+_fleet() {
+  local -a commands
+  commands=(${names.map(n => `'${n}'`).join(' ')})
+  if [ \${CURRENT} -eq 2 ]; then
+    _describe 'command' commands
+  fi
+}
+compdef _fleet fleet
+`;
+}
+function fishScript(names) {
+    // fish reads completions from ~/.config/fish/completions/fleet.fish:
+    //   fleet completions fish > ~/.config/fish/completions/fleet.fish
+    const lines = names.map(n => `complete -c fleet -f -n '__fish_use_subcommand' -a '${n}'`);
+    return `# fleet fish completions — install with:
+#   fleet completions fish > ~/.config/fish/completions/fleet.fish
+${lines.join('\n')}
+`;
+}
+export const completionsCommand = defineCommand({
+    name: 'completions',
+    summary: 'Emit shell completion script for bash, zsh, or fish',
+    cliOnly: true,
+    args: z.object({
+        shell: z.enum(['bash', 'zsh', 'fish']),
+    }),
+    async run(args, _ctx) {
+        const names = await collectCommandNames();
+        let script;
+        switch (args.shell) {
+            case 'bash':
+                script = bashScript(names);
+                break;
+            case 'zsh':
+                script = zshScript(names);
+                break;
+            case 'fish':
+                script = fishScript(names);
+                break;
+        }
+        return {
+            ok: true,
+            summary: script,
+            data: { shell: args.shell, script },
+        };
+    },
+});

package/dist/commands/config.d.ts

@@ -0,0 +1,16 @@
+import { type OperatorConfig, type OperatorField } from '../core/operator.js';
+export interface ConfigData {
+    action: 'show' | 'get' | 'set';
+    path: string;
+    config?: OperatorConfig;
+    field?: OperatorField;
+    value?: string;
+}
+export declare const configCommand: import("../registry/types.js").CommandDef<ConfigData>;
+export interface WhoamiData {
+    username: string;
+    domain: string;
+    githubOrg: string;
+    homeDir: string;
+}
+export declare const whoamiCommand: import("../registry/types.js").CommandDef<WhoamiData>;

package/dist/commands/config.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { loadOperator, operatorPath, saveOperator, OPERATOR_FIELDS, } from '../core/operator.js';
+import { defineCommand } from '../registry/registry.js';
+function isOperatorField(name) {
+    return OPERATOR_FIELDS.includes(name);
+}
+export const configCommand = defineCommand({
+    name: 'config',
+    summary: 'Show or update the operator identity config (data/operator.json)',
+    args: z.object({
+        action: z.enum(['show', 'get', 'set']).default('show'),
+        field: z.string().optional(),
+        value: z.string().optional(),
+    }),
+    async run(args, _ctx) {
+        const path = operatorPath();
+        if (args.action === 'show') {
+            const cfg = loadOperator();
+            return {
+                ok: true,
+                summary: `operator: ${cfg.username} @ ${cfg.domain} (github ${cfg.githubOrg})`,
+                data: { action: 'show', path, config: cfg },
+                render: {
+                    kind: 'keyValue',
+                    pairs: [
+                        ['path', path],
+                        ['username', cfg.username],
+                        ['homeDir', cfg.homeDir],
+                        ['domain', cfg.domain],
+                        ['githubOrg', cfg.githubOrg],
+                    ],
+                },
+            };
+        }
+        if (args.action === 'get') {
+            if (!args.field) {
+                return { ok: false, summary: 'fleet config get <field>', data: { action: 'get', path } };
+            }
+            if (!isOperatorField(args.field)) {
+                return {
+                    ok: false,
+                    summary: `unknown field: ${args.field} (known: ${OPERATOR_FIELDS.join(', ')})`,
+                    data: { action: 'get', path },
+                };
+            }
+            const cfg = loadOperator();
+            const value = cfg[args.field];
+            return {
+                ok: true,
+                summary: value,
+                data: { action: 'get', path, field: args.field, value },
+            };
+        }
+        // action === 'set'
+        if (!args.field || !args.value) {
+            return {
+                ok: false,
+                summary: 'fleet config set <field> <value>',
+                data: { action: 'set', path },
+            };
+        }
+        if (!isOperatorField(args.field)) {
+            return {
+                ok: false,
+                summary: `unknown field: ${args.field} (known: ${OPERATOR_FIELDS.join(', ')})`,
+                data: { action: 'set', path },
+            };
+        }
+        const cfg = loadOperator();
+        const next = { ...cfg, [args.field]: args.value };
+        saveOperator(next);
+        return {
+            ok: true,
+            summary: `set ${args.field}=${args.value}`,
+            data: { action: 'set', path, field: args.field, value: args.value, config: next },
+        };
+    },
+});
+export const whoamiCommand = defineCommand({
+    name: 'whoami',
+    summary: 'Print the operator identity in one line',
+    args: z.object({}),
+    async run(_args, _ctx) {
+        const cfg = loadOperator();
+        return {
+            ok: true,
+            summary: `${cfg.username} @ ${cfg.domain} (github ${cfg.githubOrg}, home ${cfg.homeDir})`,
+            data: {
+                username: cfg.username,
+                domain: cfg.domain,
+                githubOrg: cfg.githubOrg,
+                homeDir: cfg.homeDir,
+            },
+        };
+    },
+});

package/dist/commands/deploy.js

@@ -6,6 +6,7 @@ import { startService, restartService, getServiceStatus } from '../core/systemd.
 import { FleetError } from '../core/errors.js';
 import { success, error, info, warn, heading } from '../ui/output.js';
 import { addCommand } from './add.js';
+import { makeCliContext } from '../registry/context.js';
 import { execGit } from '../core/exec.js';
 import { getProjectRoot } from '../core/git.js';
 import { recordBuiltCommit } from '../core/boot-refresh.js';
@@ -26,7 +27,7 @@ export async function deployCommand(args) {
     let app = reg.apps.find(a => a.composePath.startsWith(fullPath));
     if (!app) {
         info('App not registered, running add first...');
-        await addCommand([...args]);
+        await addCommand.run({ dir: fullPath, 'dry-run': dryRun, yes }, makeCliContext());
         reg = load();
         app = reg.apps.find(a => a.composePath.startsWith(fullPath));
         if (!app)
@@ -47,7 +48,7 @@ export async function deployCommand(args) {
         const root = getProjectRoot(app.composePath);
         const head = execGit(['rev-parse', 'HEAD'], { cwd: root, timeout: 10_000 });
         if (head.ok && head.stdout.trim()) {
-            recordBuiltCommit(app.name, head.stdout.trim());
+            await recordBuiltCommit(app.name, head.stdout.trim());
         }
     }
     catch {

package/dist/commands/deps.js

@@ -130,11 +130,15 @@ async function depsFix(args) {
         return;
     }
     const result = createDepsPr(app, findings, dryRun);
+    if (result.error) {
+        error(result.error);
+        process.exit(1);
+    }
     if (dryRun) {
         heading(`Dry run: ${app.name}`);
         info(`Would create branch: ${result.branch}`);
         for (const bump of result.bumps) {
-            info(`  ${bump.file}: ${bump.search} -> ${bump.replace}`);
+            info(`  ${bump.file}: ${bump.searchRegex.source} -> ${bump.replace}`);
         }
         return;
     }

package/dist/commands/doctor.d.ts

@@ -0,0 +1,32 @@
+import { load as loadRegistry } from '../core/registry.js';
+import { loadOperator } from '../core/operator.js';
+export type CheckStatus = 'ok' | 'warn' | 'fail';
+export interface DoctorCheck {
+    name: string;
+    status: CheckStatus;
+    detail: string;
+}
+export interface DoctorData {
+    checks: DoctorCheck[];
+    summary: {
+        ok: number;
+        warn: number;
+        fail: number;
+    };
+}
+interface SystemRunner {
+    exec: (cmd: string, args: string[]) => {
+        ok: boolean;
+        stdout: string;
+        stderr: string;
+    };
+    exists: (path: string) => boolean;
+    loadRegistry: () => ReturnType<typeof loadRegistry>;
+    loadOperator: () => ReturnType<typeof loadOperator>;
+    vaultInitialised: () => boolean;
+    vaultSealed: () => boolean;
+}
+/** core check runner. exported so tests can drive the pure list. */
+export declare function runChecks(runner: SystemRunner): DoctorData;
+export declare const doctorCommand: import("../registry/types.js").CommandDef<DoctorData>;
+export {};

package/dist/commands/doctor.js

@@ -0,0 +1,186 @@
+import { existsSync } from 'node:fs';
+import { z } from 'zod';
+import { execSafe } from '../core/exec.js';
+import { isInitialized, isSealed } from '../core/secrets.js';
+import { load as loadRegistry } from '../core/registry.js';
+import { loadOperator } from '../core/operator.js';
+import { defineCommand } from '../registry/registry.js';
+/** real implementations of every external probe — split out so the test suite
+ *  can swap them with deterministic stubs. */
+function realRunner() {
+    return {
+        exec: (cmd, args) => {
+            const r = execSafe(cmd, args, { timeout: 5_000 });
+            return { ok: r.ok, stdout: r.stdout, stderr: r.stderr };
+        },
+        exists: existsSync,
+        loadRegistry,
+        loadOperator,
+        vaultInitialised: isInitialized,
+        vaultSealed: isSealed,
+    };
+}
+// minimum supported component versions. systemd 240 introduced
+// LoadCredentialEncrypted (used by the v2 secrets agent). docker compose v2
+// is the minimum the rest of fleet assumes. node 20 is the baseline.
+const MIN_NODE_MAJOR = 20;
+const MIN_DOCKER_COMPOSE_MAJOR = 2;
+const MIN_SYSTEMD = 240;
+function checkNode(runner) {
+    const major = parseInt(process.versions.node.split('.')[0], 10);
+    if (Number.isNaN(major) || major < MIN_NODE_MAJOR) {
+        return { name: 'node', status: 'fail', detail: `node ${process.versions.node} < ${MIN_NODE_MAJOR}` };
+    }
+    // suppress the warning about unused runner parameter in this branch
+    void runner;
+    return { name: 'node', status: 'ok', detail: process.versions.node };
+}
+function checkAge(runner) {
+    if (!runner.exec('which', ['age']).ok) {
+        return { name: 'age', status: 'fail', detail: 'age not on PATH (apt install age)' };
+    }
+    const v = runner.exec('age', ['--version']);
+    return { name: 'age', status: 'ok', detail: v.stdout || 'present' };
+}
+function checkDockerCompose(runner) {
+    const r = runner.exec('docker', ['compose', 'version']);
+    if (!r.ok) {
+        return { name: 'docker compose', status: 'fail', detail: 'docker compose v2 not available' };
+    }
+    // sample stdout: "docker compose version v2.27.0"
+    const m = r.stdout.match(/v?(\d+)\.(\d+)/);
+    if (!m) {
+        return { name: 'docker compose', status: 'warn', detail: `unable to parse version: ${r.stdout}` };
+    }
+    const major = parseInt(m[1], 10);
+    if (major < MIN_DOCKER_COMPOSE_MAJOR) {
+        return { name: 'docker compose', status: 'fail', detail: `${r.stdout} < v${MIN_DOCKER_COMPOSE_MAJOR}` };
+    }
+    return { name: 'docker compose', status: 'ok', detail: r.stdout };
+}
+function checkSystemd(runner) {
+    const r = runner.exec('systemctl', ['--version']);
+    if (!r.ok) {
+        return { name: 'systemd', status: 'fail', detail: 'systemctl not available' };
+    }
+    const m = r.stdout.match(/systemd (\d+)/);
+    if (!m) {
+        return { name: 'systemd', status: 'warn', detail: `unable to parse version: ${r.stdout.split('\n')[0]}` };
+    }
+    const v = parseInt(m[1], 10);
+    if (v < MIN_SYSTEMD) {
+        return {
+            name: 'systemd',
+            status: 'warn',
+            detail: `systemd ${v} < ${MIN_SYSTEMD} (LoadCredentialEncrypted needs 240+; v2 secrets won't work)`,
+        };
+    }
+    return { name: 'systemd', status: 'ok', detail: `systemd ${v}` };
+}
+function checkRegistry(runner) {
+    try {
+        const reg = runner.loadRegistry();
+        return {
+            name: 'registry',
+            status: 'ok',
+            detail: `${reg.apps.length} app(s) registered`,
+        };
+    }
+    catch (err) {
+        return {
+            name: 'registry',
+            status: 'fail',
+            detail: `parse failed: ${err.message}`,
+        };
+    }
+}
+function checkOperator(runner) {
+    try {
+        const op = runner.loadOperator();
+        return {
+            name: 'operator config',
+            status: 'ok',
+            detail: `${op.username} @ ${op.domain} (github: ${op.githubOrg})`,
+        };
+    }
+    catch (err) {
+        return {
+            name: 'operator config',
+            status: 'fail',
+            detail: err.message,
+        };
+    }
+}
+function checkVault(runner) {
+    if (!runner.vaultInitialised()) {
+        return { name: 'secrets vault', status: 'warn', detail: 'vault not initialised (run: fleet secrets init)' };
+    }
+    const sealed = runner.vaultSealed();
+    return {
+        name: 'secrets vault',
+        status: 'ok',
+        detail: sealed ? 'initialised, sealed' : 'initialised, unsealed',
+    };
+}
+function checkOrphans(runner) {
+    try {
+        const reg = runner.loadRegistry();
+        const orphans = reg.apps.filter(a => !runner.exists(a.composePath));
+        if (orphans.length === 0) {
+            return { name: 'registered apps on disk', status: 'ok', detail: 'all composePath entries exist' };
+        }
+        return {
+            name: 'registered apps on disk',
+            status: 'warn',
+            detail: `${orphans.length} orphan(s): ${orphans.map(a => a.name).join(', ')}`,
+        };
+    }
+    catch {
+        // registry parse already reported separately — don't double-fail.
+        return { name: 'registered apps on disk', status: 'warn', detail: 'skipped (registry unreadable)' };
+    }
+}
+/** core check runner. exported so tests can drive the pure list. */
+export function runChecks(runner) {
+    const checks = [
+        checkNode(runner),
+        checkAge(runner),
+        checkDockerCompose(runner),
+        checkSystemd(runner),
+        checkRegistry(runner),
+        checkOperator(runner),
+        checkVault(runner),
+        checkOrphans(runner),
+    ];
+    const summary = {
+        ok: checks.filter(c => c.status === 'ok').length,
+        warn: checks.filter(c => c.status === 'warn').length,
+        fail: checks.filter(c => c.status === 'fail').length,
+    };
+    return { checks, summary };
+}
+const STATUS_LABEL = {
+    ok: 'OK',
+    warn: 'WARN',
+    fail: 'FAIL',
+};
+export const doctorCommand = defineCommand({
+    name: 'doctor',
+    summary: 'Preflight: host requirements, registry, vault, operator config, orphan apps',
+    args: z.object({}),
+    async run(_args, _ctx) {
+        const data = runChecks(realRunner());
+        return {
+            ok: data.summary.fail === 0,
+            summary: data.summary.fail === 0
+                ? `doctor: ${data.summary.ok} ok, ${data.summary.warn} warn, 0 fail`
+                : `doctor: ${data.summary.fail} fail, ${data.summary.warn} warn, ${data.summary.ok} ok`,
+            data,
+            render: {
+                kind: 'table',
+                columns: ['CHECK', 'STATUS', 'DETAIL'],
+                rows: data.checks.map(c => [c.name, STATUS_LABEL[c.status], c.detail]),
+            },
+        };
+    },
+});

package/dist/commands/egress.d.ts

@@ -1 +1 @@
-export declare function egressCommand(args: string[]): void;
+export declare function egressCommand(args: string[]): Promise<void>;

package/dist/commands/egress.js

@@ -1,8 +1,8 @@
-import { load, save, findApp } from '../core/registry.js';
+import { load, findApp, withRegistry } from '../core/registry.js';
 import { snapshotEgress, addEgressAllow } from '../core/egress.js';
 import { AppNotFoundError } from '../core/errors.js';
 import { c, error, heading, info, success, table, warn } from '../ui/output.js';
-export function egressCommand(args) {
+export async function egressCommand(args) {
     const sub = args[0];
     switch (sub) {
         case 'observe': return egressObserve(args.slice(1));
@@ -89,18 +89,21 @@ function egressShow(args) {
     }
     info('Note: v1 is observe/shadow only — no packets are actually dropped.');
 }
-function egressAllow(args) {
+async function egressAllow(args) {
     const positional = args.filter(a => !a.startsWith('-'));
     const [appName, host] = positional;
     if (!appName || !host) {
         error('Usage: fleet egress allow <app> <host[:port] | *.host | cidr>');
         process.exit(1);
     }
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app)
-        throw new AppNotFoundError(appName);
-    const updated = addEgressAllow(app, host);
-    save(reg);
-    success(`${appName} allow → ${host}  (now ${updated.length} entries)`);
+    let entryCount = 0;
+    await withRegistry(reg => {
+        const app = findApp(reg, appName);
+        if (!app)
+            throw new AppNotFoundError(appName);
+        const updated = addEgressAllow(app, host);
+        entryCount = updated.length;
+        return reg;
+    });
+    success(`${appName} allow → ${host}  (now ${entryCount} entries)`);
 }

package/dist/commands/freeze.d.ts

@@ -1,4 +1,8 @@
-export declare function freezeApp(appName: string, reason?: string): void;
-export declare function unfreezeApp(appName: string): void;
-export declare function freezeCommand(args: string[]): void;
-export declare function unfreezeCommand(args: string[]): void;
+export declare function freezeApp(appName: string, reason?: string): Promise<void>;
+export declare function unfreezeApp(appName: string): Promise<void>;
+export declare const freezeCommand: import("../registry/types.js").CommandDef<{
+    app: string;
+}>;
+export declare const unfreezeCommand: import("../registry/types.js").CommandDef<{
+    app: string;
+}>;