@matthesketh/fleet 1.8.0 → 1.11.0

package/dist/commands/freeze.js

@@ -1,64 +1,82 @@
-import { load, save, findApp } from '../core/registry.js';
+import { z } from 'zod';
+import { findApp, withRegistry } from '../core/registry.js';
 import { stopService, disableService, enableService, startService } from '../core/systemd.js';
 import { AppNotFoundError } from '../core/errors.js';
-import { success, error } from '../ui/output.js';
-export function freezeApp(appName, reason) {
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app)
-        throw new AppNotFoundError(appName);
-    if (app.frozenAt) {
-        throw new Error(`App "${appName}" is already frozen (since ${app.frozenAt})`);
-    }
-    stopService(app.serviceName);
-    disableService(app.serviceName);
-    app.frozenAt = new Date().toISOString();
-    if (reason)
-        app.frozenReason = reason;
-    save(reg);
-}
-export function unfreezeApp(appName) {
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app)
-        throw new AppNotFoundError(appName);
-    if (!app.frozenAt) {
-        throw new Error(`App "${appName}" is not frozen`);
-    }
-    delete app.frozenAt;
-    delete app.frozenReason;
-    save(reg);
-    enableService(app.serviceName);
-    startService(app.serviceName);
+import { defineCommand } from '../registry/registry.js';
+export async function freezeApp(appName, reason) {
+    await withRegistry(reg => {
+        const app = findApp(reg, appName);
+        if (!app)
+            throw new AppNotFoundError(appName);
+        if (app.frozenAt) {
+            throw new Error(`App "${appName}" is already frozen (since ${app.frozenAt})`);
+        }
+        stopService(app.serviceName);
+        disableService(app.serviceName);
+        app.frozenAt = new Date().toISOString();
+        if (reason)
+            app.frozenReason = reason;
+        return reg;
+    });
 }
-export function freezeCommand(args) {
-    const appName = args[0];
-    if (!appName) {
-        error('Usage: fleet freeze <app> [reason]');
-        process.exit(1);
-    }
-    const reason = args.slice(1).join(' ') || undefined;
-    try {
-        freezeApp(appName, reason);
-        success(`Frozen ${appName}${reason ? `: ${reason}` : ''}`);
-    }
-    catch (err) {
-        error(err.message);
-        process.exit(1);
-    }
-}
-export function unfreezeCommand(args) {
-    const appName = args[0];
-    if (!appName) {
-        error('Usage: fleet unfreeze <app>');
-        process.exit(1);
-    }
-    try {
-        unfreezeApp(appName);
-        success(`Unfrozen ${appName} — service enabled and started`);
-    }
-    catch (err) {
-        error(err.message);
-        process.exit(1);
+export async function unfreezeApp(appName) {
+    let serviceName = null;
+    await withRegistry(reg => {
+        const app = findApp(reg, appName);
+        if (!app)
+            throw new AppNotFoundError(appName);
+        if (!app.frozenAt) {
+            throw new Error(`App "${appName}" is not frozen`);
+        }
+        delete app.frozenAt;
+        delete app.frozenReason;
+        serviceName = app.serviceName;
+        return reg;
+    });
+    // Service operations run AFTER the lock is released so we don't hold the
+    // registry lock while systemctl is starting things up.
+    if (serviceName) {
+        enableService(serviceName);
+        startService(serviceName);
     }
 }
+export const freezeCommand = defineCommand({
+    name: 'freeze',
+    summary: 'Freeze a crash-looping service (stop + disable)',
+    args: z.object({ app: z.string(), reason: z.string().optional(), yes: z.boolean().default(false) }),
+    destructive: true,
+    async run(args, ctx) {
+        if (!args.yes && !(await ctx.confirm(`Freeze ${args.app}? This stops and disables the service.`))) {
+            return { ok: false, summary: 'cancelled', data: { app: args.app } };
+        }
+        try {
+            await freezeApp(args.app, args.reason);
+        }
+        catch (err) {
+            return { ok: false, summary: err instanceof Error ? err.message : String(err), data: { app: args.app } };
+        }
+        return {
+            ok: true,
+            summary: `froze ${args.app}${args.reason ? `: ${args.reason}` : ''}`,
+            data: { app: args.app },
+        };
+    },
+});
+export const unfreezeCommand = defineCommand({
+    name: 'unfreeze',
+    summary: 'Unfreeze and restart a frozen service',
+    args: z.object({ app: z.string(), yes: z.boolean().default(false) }),
+    destructive: true,
+    async run(args, ctx) {
+        if (!args.yes && !(await ctx.confirm(`Unfreeze ${args.app}? This re-enables and starts the service.`))) {
+            return { ok: false, summary: 'cancelled', data: { app: args.app } };
+        }
+        try {
+            await unfreezeApp(args.app);
+        }
+        catch (err) {
+            return { ok: false, summary: err instanceof Error ? err.message : String(err), data: { app: args.app } };
+        }
+        return { ok: true, summary: `unfroze ${args.app} — service enabled and started`, data: { app: args.app } };
+    },
+});

package/dist/commands/git.js

@@ -105,7 +105,7 @@ async function gitOnboardCmd(args) {
         info('cancelled');
         return;
     }
-    const result = executeOnboard(scenario, r, app.name, app.name, status);
+    const result = await executeOnboard(scenario, r, app.name, app.name, status);
     heading(`Onboarded: ${app.name}`);
     result.steps.forEach(s => success(s));
     info(`repo: ${result.repoUrl}`);
@@ -134,7 +134,7 @@ async function gitOnboardAllCmd(args) {
             continue;
         }
         try {
-            const result = executeOnboard(scenario, r, app.name, app.name, status);
+            const result = await executeOnboard(scenario, r, app.name, app.name, status);
             success(`${app.name}: onboarded (${result.scenario})`);
         }
         catch (err) {

package/dist/commands/health.d.ts

@@ -1 +1,2 @@
-export declare function healthCommand(args: string[]): void;
+import { type HealthResult } from '../core/health.js';
+export declare const healthCommand: import("../registry/types.js").CommandDef<HealthResult[]>;

package/dist/commands/health.js

@@ -1,60 +1,42 @@
+import { z } from 'zod';
 import { load, findApp } from '../core/registry.js';
 import { checkHealth, checkAllHealth } from '../core/health.js';
-import { AppNotFoundError } from '../core/errors.js';
-import { c, icon, heading, table } from '../ui/output.js';
-export function healthCommand(args) {
-    const json = args.includes('--json');
-    const appName = args.find(a => !a.startsWith('-'));
-    const reg = load();
-    if (appName) {
-        const app = findApp(reg, appName);
-        if (!app)
-            throw new AppNotFoundError(appName);
-        const result = checkHealth(app);
-        if (json) {
-            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
-            return;
+import { defineCommand } from '../registry/registry.js';
+export const healthCommand = defineCommand({
+    name: 'health',
+    summary: 'Health checks: systemd + container + HTTP',
+    args: z.object({ app: z.string().optional() }),
+    tui: { view: 'health' },
+    async run(args) {
+        let results;
+        if (args.app) {
+            const app = findApp(load(), args.app);
+            if (!app) {
+                return { ok: false, summary: `app not found: ${args.app}`, data: [] };
+            }
+            results = [checkHealth(app)];
         }
-        heading(`Health: ${app.name}`);
-        const sIcon = result.systemd.ok ? icon.ok : icon.err;
-        process.stdout.write(`  Systemd:    ${sIcon} ${result.systemd.state}\n`);
-        for (const ct of result.containers) {
-            const cIcon = ct.running ? icon.ok : icon.err;
-            process.stdout.write(`  Container:  ${cIcon} ${ct.name} (${ct.health})\n`);
+        else {
+            results = checkAllHealth(load().apps);
         }
-        if (result.http) {
-            const hIcon = result.http.ok ? icon.ok : icon.err;
-            const detail = result.http.ok ? `${result.http.status}` : (result.http.error ?? 'failed');
-            process.stdout.write(`  HTTP:       ${hIcon} ${detail}\n`);
-        }
-        const oColor = result.overall === 'healthy' ? c.green
-            : result.overall === 'degraded' ? c.yellow : c.red;
-        process.stdout.write(`  Overall:    ${oColor}${result.overall}${c.reset}\n\n`);
-        return;
-    }
-    const results = checkAllHealth(reg.apps);
-    if (json) {
-        process.stdout.write(JSON.stringify(results, null, 2) + '\n');
-        return;
-    }
-    heading('Health Check');
-    const rows = results.map(r => {
-        const oIcon = r.overall === 'healthy' ? icon.ok
-            : r.overall === 'degraded' ? icon.warn : icon.err;
-        const sIcon = r.systemd.ok ? icon.ok : icon.err;
-        const cOk = r.containers.filter(ct => ct.running).length;
-        const cTotal = r.containers.length;
-        const httpStatus = r.http
-            ? (r.http.ok ? `${icon.ok} ${r.http.status}` : `${icon.err} fail`)
-            : `${c.dim}-${c.reset}`;
-        return [
-            `${c.bold}${r.app}${c.reset}`,
-            `${sIcon} ${r.systemd.state}`,
-            `${cOk}/${cTotal}`,
-            httpStatus,
-            `${oIcon} ${r.overall}`,
-        ];
-    });
-    table(['APP', 'SYSTEMD', 'CONTAINERS', 'HTTP', 'OVERALL'], rows);
-    process.stdout.write('\n');
-}
+        const healthy = results.filter(r => r.overall === 'healthy').length;
+        const degraded = results.filter(r => r.overall === 'degraded').length;
+        const down = results.filter(r => r.overall === 'down').length;
+        return {
+            ok: true,
+            summary: `${results.length} checked | ${healthy} healthy | ${degraded} degraded | ${down} down`,
+            data: results,
+            render: {
+                kind: 'table',
+                columns: ['APP', 'SYSTEMD', 'CONTAINERS', 'HTTP', 'OVERALL'],
+                rows: results.map(r => [
+                    r.app,
+                    r.systemd.state,
+                    `${r.containers.filter(ct => ct.running).length}/${r.containers.length}`,
+                    r.http ? (r.http.ok ? String(r.http.status ?? 'ok') : 'fail') : '—',
+                    r.overall,
+                ]),
+            },
+        };
+    },
+});

package/dist/commands/init.d.ts

@@ -1 +1,2 @@
-export declare function initCommand(args: string[]): void;
+import type { Registry } from '../core/registry.js';
+export declare const initCommand: import("../registry/types.js").CommandDef<Registry>;

package/dist/commands/init.js

@@ -1,82 +1,92 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { load, save } from '../core/registry.js';
+import { z } from 'zod';
+import { withRegistry } from '../core/registry.js';
 import { discoverServices, parseServiceFile, readServiceFile } from '../core/systemd.js';
 import { listContainers, getContainersByCompose } from '../core/docker.js';
 import { listSites, readConfig, extractPortFromConfig, extractDomainsFromConfig } from '../core/nginx.js';
-import { heading, success, info } from '../ui/output.js';
+import { defineCommand } from '../registry/registry.js';
 const SKIP_SERVICES = ['docker-databases'];
-export function initCommand(args) {
-    const json = args.includes('--json');
-    heading('Fleet Init - Auto-discovering apps');
-    const reg = load();
-    const services = discoverServices();
-    const containers = listContainers();
-    const sites = listSites();
-    info(`Found ${services.length} docker compose services`);
-    info(`Found ${containers.length} running containers`);
-    info(`Found ${sites.length} nginx sites`);
-    let added = 0;
-    for (const serviceName of services) {
-        if (SKIP_SERVICES.includes(serviceName))
-            continue;
-        const content = readServiceFile(serviceName);
-        if (!content)
-            continue;
-        const parsed = parseServiceFile(content);
-        if (!parsed.workingDirectory)
-            continue;
-        const composePath = parsed.workingDirectory;
-        const composeFile = parsed.composeFile;
-        const composeContainers = getContainersByCompose(composePath, composeFile);
-        const port = detectPort(composePath, composeFile, composeContainers, containers);
-        const domains = detectDomains(serviceName, sites, port);
-        const usesSharedDb = detectSharedDb(composePath, composeFile);
-        const type = detectType(composePath, composeFile, domains);
-        const displayName = detectDisplayName(serviceName, content);
-        const app = {
-            name: serviceName,
-            displayName,
-            composePath,
-            composeFile,
-            serviceName,
-            domains,
-            port,
-            usesSharedDb,
-            type,
-            containers: composeContainers.length > 0 ? composeContainers : [serviceName],
-            dependsOnDatabases: parsed.dependsOnDatabases,
-            registeredAt: new Date().toISOString(),
+export const initCommand = defineCommand({
+    name: 'init',
+    summary: 'Auto-discover all existing apps',
+    args: z.object({}),
+    async run(_args, ctx) {
+        ctx.log({ level: 'info', message: 'fleet init — auto-discovering apps' });
+        const services = discoverServices();
+        const containers = listContainers();
+        const sites = listSites();
+        ctx.log({ level: 'info', message: `found ${services.length} compose services, ${containers.length} running containers, ${sites.length} nginx sites` });
+        let added = 0;
+        // assigned inside the withRegistry callback below, which always runs.
+        let discovered;
+        await withRegistry(reg => {
+            for (const serviceName of services) {
+                if (SKIP_SERVICES.includes(serviceName))
+                    continue;
+                const content = readServiceFile(serviceName);
+                if (!content)
+                    continue;
+                const parsed = parseServiceFile(content);
+                if (!parsed.workingDirectory)
+                    continue;
+                const composePath = parsed.workingDirectory;
+                const composeFile = parsed.composeFile;
+                const composeContainers = getContainersByCompose(composePath, composeFile);
+                const port = detectPort(composePath, composeFile, composeContainers, containers);
+                const domains = detectDomains(serviceName, sites, port);
+                const usesSharedDb = detectSharedDb(composePath, composeFile);
+                const type = detectType(composePath, composeFile, domains);
+                const displayName = detectDisplayName(serviceName, content);
+                const app = {
+                    name: serviceName,
+                    displayName,
+                    composePath,
+                    composeFile,
+                    serviceName,
+                    domains,
+                    port,
+                    usesSharedDb,
+                    type,
+                    containers: composeContainers.length > 0 ? composeContainers : [serviceName],
+                    dependsOnDatabases: parsed.dependsOnDatabases,
+                    registeredAt: new Date().toISOString(),
+                };
+                const existing = reg.apps.findIndex(a => a.name === serviceName);
+                if (existing >= 0) {
+                    const prev = reg.apps[existing];
+                    if (prev.healthPath)
+                        app.healthPath = prev.healthPath;
+                    if (prev.gitRepo)
+                        app.gitRepo = prev.gitRepo;
+                    if (prev.gitRemoteUrl)
+                        app.gitRemoteUrl = prev.gitRemoteUrl;
+                    if (prev.gitOnboardedAt)
+                        app.gitOnboardedAt = prev.gitOnboardedAt;
+                    if (prev.secretsManaged)
+                        app.secretsManaged = prev.secretsManaged;
+                    reg.apps[existing] = app;
+                }
+                else {
+                    reg.apps.push(app);
+                }
+                added++;
+                ctx.log({ level: 'info', message: `${serviceName} (${composePath})` });
+            }
+            discovered = reg;
+            return reg;
+        });
+        return {
+            ok: true,
+            summary: `registered ${added} app${added === 1 ? '' : 's'}`,
+            data: discovered,
+            render: {
+                kind: 'table',
+                columns: ['NAME', 'PATH', 'TYPE', 'PORT'],
+                rows: discovered.apps.map(a => [a.name, a.composePath, a.type, a.port?.toString() ?? '—']),
+            },
         };
-        const existing = reg.apps.findIndex(a => a.name === serviceName);
-        if (existing >= 0) {
-            const prev = reg.apps[existing];
-            if (prev.healthPath)
-                app.healthPath = prev.healthPath;
-            if (prev.gitRepo)
-                app.gitRepo = prev.gitRepo;
-            if (prev.gitRemoteUrl)
-                app.gitRemoteUrl = prev.gitRemoteUrl;
-            if (prev.gitOnboardedAt)
-                app.gitOnboardedAt = prev.gitOnboardedAt;
-            if (prev.secretsManaged)
-                app.secretsManaged = prev.secretsManaged;
-            reg.apps[existing] = app;
-        }
-        else {
-            reg.apps.push(app);
-        }
-        added++;
-        success(`${serviceName} (${composePath})`);
-    }
-    save(reg);
-    if (json) {
-        process.stdout.write(JSON.stringify(reg, null, 2) + '\n');
-    }
-    else {
-        info(`Registered ${added} apps`);
-        success('Init complete');
-    }
-}
+    },
+});
 function detectPort(composePath, composeFile, composeContainers, allContainers) {
     const file = composeFile ?? 'docker-compose.yml';
     const fullPath = `${composePath}/${file}`;

package/dist/commands/install-mcp.d.ts

@@ -1 +1,3 @@
-export declare function installMcpCommand(args: string[]): Promise<void>;
+export declare const installMcpCommand: import("../registry/types.js").CommandDef<{
+    installed: boolean;
+}>;

package/dist/commands/install-mcp.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { success, info, warn } from '../ui/output.js';
+import { z } from 'zod';
+import { defineCommand } from '../registry/registry.js';
 const FLEET_DIST = resolve(join(import.meta.dirname, '..', '..', 'dist', 'index.js'));
 function getClaudeConfigPath() {
     const home = process.env.HOME || process.env.USERPROFILE || '/root';
@@ -16,40 +17,58 @@ function loadConfig(path) {
         return {};
     }
 }
-export async function installMcpCommand(args) {
-    const uninstall = args.includes('--uninstall');
-    const configPath = getClaudeConfigPath();
-    const config = loadConfig(configPath);
-    if (uninstall) {
-        if (config.mcpServers?.fleet) {
-            delete config.mcpServers.fleet;
-            if (Object.keys(config.mcpServers).length === 0) {
-                delete config.mcpServers;
+export const installMcpCommand = defineCommand({
+    name: 'install-mcp',
+    summary: 'Install fleet as a Claude Code MCP server',
+    args: z.object({ uninstall: z.boolean().default(false) }),
+    cliOnly: true,
+    async run(args, ctx) {
+        const configPath = getClaudeConfigPath();
+        const config = loadConfig(configPath);
+        if (args.uninstall) {
+            if (config.mcpServers?.fleet) {
+                delete config.mcpServers.fleet;
+                if (Object.keys(config.mcpServers).length === 0) {
+                    delete config.mcpServers;
+                }
+                writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+                return {
+                    ok: true,
+                    summary: 'Removed fleet MCP server from Claude Code',
+                    data: { installed: false },
+                };
             }
-            writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-            success('Removed fleet MCP server from Claude Code');
+            else {
+                return {
+                    ok: true,
+                    summary: 'fleet MCP server not configured — nothing to remove',
+                    data: { installed: false },
+                };
+            }
+        }
+        if (!existsSync(FLEET_DIST)) {
+            ctx.log({ level: 'warn', message: 'dist/index.js not found — run "npm run build" first' });
+        }
+        config.mcpServers = config.mcpServers || {};
+        const existed = !!config.mcpServers.fleet;
+        config.mcpServers.fleet = {
+            command: 'node',
+            args: [FLEET_DIST, 'mcp'],
+        };
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+        let summary;
+        if (existed) {
+            summary = 'Updated fleet MCP server in Claude Code';
         }
         else {
-            info('fleet MCP server not configured — nothing to remove');
+            summary = 'Installed fleet MCP server to Claude Code';
         }
-        return;
-    }
-    if (!existsSync(FLEET_DIST)) {
-        warn('dist/index.js not found — run "npm run build" first');
-    }
-    config.mcpServers = config.mcpServers || {};
-    const existed = !!config.mcpServers.fleet;
-    config.mcpServers.fleet = {
-        command: 'node',
-        args: [FLEET_DIST, 'mcp'],
-    };
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    if (existed) {
-        success('Updated fleet MCP server in Claude Code');
-    }
-    else {
-        success('Installed fleet MCP server to Claude Code');
-    }
-    info(`Config: ${configPath}`);
-    info(`Server: node ${FLEET_DIST} mcp`);
-}
+        ctx.log({ level: 'info', message: `Config: ${configPath}` });
+        ctx.log({ level: 'info', message: `Server: node ${FLEET_DIST} mcp` });
+        return {
+            ok: true,
+            summary,
+            data: { installed: true },
+        };
+    },
+});

package/dist/commands/list.d.ts

@@ -1 +1,2 @@
-export declare function listCommand(args: string[]): void;
+import type { AppEntry } from '../core/registry.js';
+export declare const listCommand: import("../registry/types.js").CommandDef<AppEntry[]>;

package/dist/commands/list.js

@@ -1,20 +1,23 @@
+import { z } from 'zod';
 import { load } from '../core/registry.js';
-import { c, heading, table } from '../ui/output.js';
-export function listCommand(args) {
-    const json = args.includes('--json');
-    const reg = load();
-    if (json) {
-        process.stdout.write(JSON.stringify(reg.apps, null, 2) + '\n');
-        return;
-    }
-    heading(`Registered Apps (${reg.apps.length})`);
-    const rows = reg.apps.map(app => [
-        `${c.bold}${app.name}${c.reset}`,
-        app.serviceName,
-        app.port?.toString() ?? '-',
-        app.type,
-        app.domains.join(', ') || '-',
-    ]);
-    table(['NAME', 'SERVICE', 'PORT', 'TYPE', 'DOMAINS'], rows);
-    process.stdout.write('\n');
-}
+import { defineCommand } from '../registry/registry.js';
+export const listCommand = defineCommand({
+    name: 'list',
+    summary: 'List registered apps',
+    args: z.object({}),
+    async run() {
+        const reg = load();
+        return {
+            ok: true,
+            summary: `${reg.apps.length} app${reg.apps.length === 1 ? '' : 's'} registered`,
+            data: reg.apps,
+            render: {
+                kind: 'table',
+                columns: ['NAME', 'SERVICE', 'PORT', 'TYPE', 'DOMAINS'],
+                rows: reg.apps.map(a => [
+                    a.name, a.serviceName, a.port?.toString() ?? '—', a.type, a.domains.join(', ') || '—',
+                ]),
+            },
+        };
+    },
+});

package/dist/commands/logs.js

@@ -53,7 +53,7 @@ function logsMulti(args) {
     const tail = parseInt(valOf('--tail') ?? valOf('-n') ?? '50', 10) || 50;
     if (!all && !appsCsv && !containersCsv) {
         error('Usage: fleet logs --all [-f] [--since 15m] [--grep err] [--level warn]');
-        error('       fleet logs --apps macpool,shiftfaced [-f]');
+        error('       fleet logs --apps poolside,brewco [-f]');
         error('       fleet logs --containers "*-postgres" [-f]');
         process.exit(1);
     }

package/dist/commands/notify.d.ts

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