@matthesketh/fleet 1.8.0 → 1.11.0

package/dist/commands/notify.js

@@ -0,0 +1,51 @@
+import { loadNotifyConfig, sendNotification } from '../core/notify.js';
+import { success, error, warn } from '../ui/output.js';
+const HELP = `fleet notify - send a message via configured notify adapters
+
+Usage:
+  fleet notify <message>
+  fleet notify -                    # read message from stdin
+  echo "msg" | fleet notify -
+
+Reads adapter config from /etc/fleet/notify.json (telegram / bluebubbles).
+Exits 0 if at least one adapter delivered the message, 1 otherwise.
+`;
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8').trim();
+}
+export async function notifyCommand(args) {
+    if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
+        process.stdout.write(HELP);
+        if (args.length === 0)
+            process.exit(1);
+        return;
+    }
+    let message;
+    if (args[0] === '-') {
+        message = await readStdin();
+    }
+    else {
+        message = args.join(' ');
+    }
+    if (!message) {
+        error('Empty message');
+        process.exit(1);
+    }
+    const config = loadNotifyConfig();
+    if (!config) {
+        warn('No notify config at /etc/fleet/notify.json — message not sent');
+        process.exit(1);
+    }
+    const sent = await sendNotification(config, message);
+    if (sent) {
+        success('Notification sent');
+    }
+    else {
+        error('Failed to send notification (no adapter succeeded)');
+        process.exit(1);
+    }
+}

package/dist/commands/patch-systemd.d.ts

@@ -1 +1,7 @@
-export declare function patchSystemdCommand(args: string[]): void;
+interface PatchSystemdData {
+    action: 'patch' | 'rollback';
+    changed: number;
+    skipped: number;
+}
+export declare const patchSystemdCommand: import("../registry/types.js").CommandDef<PatchSystemdData>;
+export {};

package/dist/commands/patch-systemd.js

@@ -1,12 +1,11 @@
 import { copyFileSync, existsSync, renameSync, writeFileSync } from 'node:fs';
+import { z } from 'zod';
 import { load } from '../core/registry.js';
 import { readServiceFile } from '../core/systemd.js';
 import { execSafe } from '../core/exec.js';
-import { success, warn, info, error } from '../ui/output.js';
+import { defineCommand } from '../registry/registry.js';
 const SERVICE_DIR = '/etc/systemd/system';
-export function patchSystemdCommand(args) {
-    if (args.includes('--rollback'))
-        return rollback();
+function runPatch(ctx) {
     const reg = load();
     const dbServiceName = reg.infrastructure.databases.serviceName;
     const appServiceNames = reg.apps.map(a => a.serviceName);
@@ -20,20 +19,20 @@ export function patchSystemdCommand(args) {
     }
     targetMap.set(dbServiceName, { name: dbServiceName, rewriteExecStart: false });
     const targets = Array.from(targetMap.values());
-    info(`Patching ${targets.length} service(s)...`);
+    ctx.log({ level: 'info', message: `patching ${targets.length} service(s)...` });
     let patched = 0;
     let skipped = 0;
     for (const { name, rewriteExecStart } of targets) {
         const path = `${SERVICE_DIR}/${name}.service`;
         const content = readServiceFile(name);
         if (content === null) {
-            warn(`${name}: no service file found, skipping`);
+            ctx.log({ level: 'warn', message: `${name}: no service file found, skipping` });
             skipped++;
             continue;
         }
         let updated = content;
         let changed = false;
-        // Existing behavior: add StartLimitBurst if missing (applies to ALL services including databases)
+        // existing behaviour: add StartLimitBurst if missing (applies to ALL services including databases)
         if (!updated.includes('StartLimitBurst=')) {
             updated = updated.replace(/(\[Service\])/, '$1\nStartLimitBurst=5\nStartLimitIntervalSec=300');
             changed = true;
@@ -45,7 +44,7 @@ export function patchSystemdCommand(args) {
                 updated = updated.replace(/^ExecStart=.*$/m, expectedExecStart);
                 changed = true;
             }
-            // Ensure TimeoutStartSec=900
+            // ensure TimeoutStartSec=900
             if (!updated.includes('TimeoutStartSec=900')) {
                 if (/^TimeoutStartSec=\d+/m.test(updated)) {
                     updated = updated.replace(/^TimeoutStartSec=\d+.*$/m, 'TimeoutStartSec=900');
@@ -57,37 +56,49 @@ export function patchSystemdCommand(args) {
             }
         }
         if (!changed) {
-            info(`${name}: already patched, skipping`);
+            ctx.log({ level: 'info', message: `${name}: already patched, skipping` });
             skipped++;
             continue;
         }
-        // Backup original before overwrite
+        // backup original before overwrite
         try {
             copyFileSync(path, `${path}.bak`);
         }
         catch (err) {
-            warn(`${name}: failed to create .bak (${err instanceof Error ? err.message : String(err)}); skipping for safety`);
+            ctx.log({
+                level: 'warn',
+                message: `${name}: failed to create .bak (${err instanceof Error ? err.message : String(err)}); skipping for safety`,
+            });
             skipped++;
             continue;
         }
         writeFileSync(path, updated);
-        success(`${name}: patched`);
+        ctx.log({ level: 'info', message: `${name}: patched` });
         patched++;
     }
     if (patched === 0) {
-        info('No services needed patching');
-        return;
+        return {
+            ok: true,
+            summary: 'no services needed patching',
+            data: { action: 'patch', changed: 0, skipped },
+        };
     }
-    info('Running systemctl daemon-reload...');
+    ctx.log({ level: 'info', message: 'running systemctl daemon-reload...' });
     const result = execSafe('systemctl', ['daemon-reload']);
-    if (result.ok) {
-        success(`Done — patched ${patched} service(s), skipped ${skipped}`);
-    }
-    else {
-        warn(`daemon-reload failed: ${result.stderr}`);
+    if (!result.ok) {
+        return {
+            ok: false,
+            summary: `patched ${patched} service(s) but daemon-reload failed: ${result.stderr}`,
+            data: { action: 'patch', changed: patched, skipped },
+        };
     }
+    return {
+        ok: true,
+        summary: `patched ${patched} service(s), skipped ${skipped}`,
+        data: { action: 'patch', changed: patched, skipped },
+    };
 }
-function rollback() {
+function runRollback(ctx) {
     const reg = load();
     const serviceNames = [
         ...reg.apps.map(a => a.serviceName),
@@ -104,23 +115,52 @@ function rollback() {
         }
         try {
             renameSync(bak, path);
-            success(`${name}: restored from .bak`);
+            ctx.log({ level: 'info', message: `${name}: restored from .bak` });
             restored++;
         }
         catch (err) {
-            error(`${name}: failed to restore: ${err instanceof Error ? err.message : String(err)}`);
+            ctx.log({
+                level: 'error',
+                message: `${name}: failed to restore: ${err instanceof Error ? err.message : String(err)}`,
+            });
         }
     }
     if (restored === 0) {
-        info('No .bak files found to restore');
-        return;
+        return {
+            ok: true,
+            summary: 'no .bak files found to restore',
+            data: { action: 'rollback', changed: 0, skipped: missing },
+        };
     }
-    info('Running systemctl daemon-reload...');
+    ctx.log({ level: 'info', message: 'running systemctl daemon-reload...' });
     const result = execSafe('systemctl', ['daemon-reload']);
-    if (result.ok) {
-        success(`Done — restored ${restored}, missing ${missing}`);
-    }
-    else {
-        warn(`daemon-reload failed: ${result.stderr}`);
+    if (!result.ok) {
+        return {
+            ok: false,
+            summary: `restored ${restored} but daemon-reload failed: ${result.stderr}`,
+            data: { action: 'rollback', changed: restored, skipped: missing },
+        };
     }
+    return {
+        ok: true,
+        summary: `restored ${restored}, missing ${missing}`,
+        data: { action: 'rollback', changed: restored, skipped: missing },
+    };
 }
+export const patchSystemdCommand = defineCommand({
+    name: 'patch-systemd',
+    summary: 'Add StartLimit settings to all service files',
+    args: z.object({ rollback: z.boolean().default(false), yes: z.boolean().default(false) }),
+    destructive: true,
+    async run(args, ctx) {
+        const verb = args.rollback ? 'roll back' : 'patch';
+        if (!args.yes && !(await ctx.confirm(`${verb} all fleet systemd unit files?`))) {
+            return {
+                ok: false,
+                summary: 'cancelled',
+                data: { action: args.rollback ? 'rollback' : 'patch', changed: 0, skipped: 0 },
+            };
+        }
+        return args.rollback ? runRollback(ctx) : runPatch(ctx);
+    },
+});

package/dist/commands/remove.d.ts

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

package/dist/commands/remove.js

@@ -1,28 +1,39 @@
-import { load, save, findApp, removeApp } from '../core/registry.js';
+import { z } from 'zod';
+import { load, findApp, removeApp, withRegistry } from '../core/registry.js';
 import { stopService, disableService } from '../core/systemd.js';
 import { AppNotFoundError } from '../core/errors.js';
-import { success, error, info, warn } from '../ui/output.js';
-import { confirm } from '../ui/confirm.js';
-export async function removeCommand(args) {
-    const yes = args.includes('-y') || args.includes('--yes');
-    const appName = args.find(a => !a.startsWith('-'));
-    if (!appName) {
-        error('Usage: fleet remove <app>');
-        process.exit(1);
-    }
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app)
-        throw new AppNotFoundError(appName);
-    if (!yes && !await confirm(`Remove ${app.name}? This will stop and disable the service.`)) {
-        info('Cancelled');
-        return;
-    }
-    info(`Stopping ${app.serviceName}...`);
-    stopService(app.serviceName);
-    info(`Disabling ${app.serviceName}...`);
-    disableService(app.serviceName);
-    save(removeApp(reg, app.name));
-    success(`Removed ${app.name} from registry`);
-    warn('Service file not deleted - remove manually if needed');
-}
+import { defineCommand } from '../registry/registry.js';
+export const removeCommand = defineCommand({
+    name: 'remove',
+    summary: 'Stop, disable and deregister an app',
+    args: z.object({ app: z.string(), yes: z.boolean().default(false) }),
+    destructive: 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 } };
+        }
+        if (!args.yes && !(await ctx.confirm(`Remove ${app.name}? This will stop and disable the service.`))) {
+            return { ok: false, summary: 'cancelled', data: { app: app.name } };
+        }
+        // systemctl runs outside the registry lock so we don't hold it while
+        // services stop/disable.
+        stopService(app.serviceName);
+        disableService(app.serviceName);
+        try {
+            await withRegistry(reg => {
+                const fresh = findApp(reg, app.name);
+                if (!fresh)
+                    throw new AppNotFoundError(app.name);
+                return removeApp(reg, fresh.name);
+            });
+        }
+        catch (err) {
+            // a concurrent process removed the app between the unlocked preview and
+            // the locked mutation — surface it as a graceful expected failure.
+            return { ok: false, summary: err instanceof Error ? err.message : String(err), data: { app: app.name } };
+        }
+        ctx.log({ level: 'warn', message: 'service file not deleted — remove manually if needed' });
+        return { ok: true, summary: `removed ${app.name} from registry`, data: { app: app.name } };
+    },
+});

package/dist/commands/restart.d.ts

@@ -1 +1,4 @@
-export declare function restartCommand(args: string[]): void;
+export declare const restartCommand: import("../registry/types.js").CommandDef<{
+    app: string;
+    service: string;
+}>;

package/dist/commands/restart.js

@@ -1,22 +1,19 @@
+import { z } from 'zod';
 import { load, findApp } from '../core/registry.js';
 import { restartService } from '../core/systemd.js';
-import { AppNotFoundError } from '../core/errors.js';
-import { success, error } from '../ui/output.js';
-export function restartCommand(args) {
-    const appName = args[0];
-    if (!appName) {
-        error('Usage: fleet restart <app>');
-        process.exit(1);
-    }
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app)
-        throw new AppNotFoundError(appName);
-    if (restartService(app.serviceName)) {
-        success(`Restarted ${app.name}`);
-    }
-    else {
-        error(`Failed to restart ${app.name}`);
-        process.exit(1);
-    }
-}
+import { defineCommand } from '../registry/registry.js';
+export const restartCommand = defineCommand({
+    name: 'restart',
+    summary: 'Restart an app via systemctl',
+    args: z.object({ app: z.string() }),
+    async run(args) {
+        const app = findApp(load(), args.app);
+        if (!app) {
+            return { ok: false, summary: `app not found: ${args.app}`, data: { app: args.app, service: '' } };
+        }
+        if (!restartService(app.serviceName)) {
+            return { ok: false, summary: `failed to restart ${app.name}`, data: { app: app.name, service: app.serviceName } };
+        }
+        return { ok: true, summary: `restarted ${app.name}`, data: { app: app.name, service: app.serviceName } };
+    },
+});

package/dist/commands/rollback.d.ts

@@ -1 +1,4 @@
-export declare function rollbackCommand(args: string[]): Promise<void>;
+export declare const rollbackCommand: import("../registry/types.js").CommandDef<{
+    app: string;
+    image: string;
+}>;

package/dist/commands/rollback.js

@@ -1,12 +1,8 @@
+import { z } from 'zod';
 import { load, findApp } from '../core/registry.js';
 import { execSafe } from '../core/exec.js';
 import { restartService } from '../core/systemd.js';
-function log(msg) {
-    process.stdout.write(`[rollback] ${msg}\n`);
-}
-function logErr(msg) {
-    process.stderr.write(`[rollback] ${msg}\n`);
-}
+import { defineCommand } from '../registry/registry.js';
 function resolveImageName(composePath, composeFile) {
     const args = ['compose', ...(composeFile ? ['-f', composeFile] : []), 'config', '--images'];
     const r = execSafe('docker', args, { cwd: composePath, timeout: 15_000 });
@@ -20,39 +16,34 @@ function splitImageBase(image) {
         return image;
     return image.slice(0, lastColon);
 }
-export async function rollbackCommand(args) {
-    const appName = args[0];
-    if (!appName) {
-        logErr('Usage: fleet rollback <app>');
-        process.exit(1);
-    }
-    const reg = load();
-    const app = findApp(reg, appName);
-    if (!app) {
-        logErr(`app not found: ${appName}`);
-        process.exit(1);
-    }
-    const image = resolveImageName(app.composePath, app.composeFile);
-    if (!image) {
-        logErr(`could not resolve image name for ${app.name}`);
-        process.exit(1);
-    }
-    const base = splitImageBase(image);
-    const previous = `${base}:fleet-previous`;
-    const latest = image;
-    if (!execSafe('docker', ['image', 'inspect', previous], { timeout: 10_000 }).ok) {
-        logErr(`no previous image found (${previous}) — nothing to roll back to`);
-        process.exit(1);
-    }
-    const tag = execSafe('docker', ['tag', previous, latest], { timeout: 10_000 });
-    if (!tag.ok) {
-        logErr(`docker tag failed: ${tag.stderr || `exit ${tag.exitCode}`}`);
-        process.exit(1);
-    }
-    const ok = restartService(app.serviceName);
-    if (!ok) {
-        logErr(`tag restored but service restart failed for ${app.serviceName}`);
-        process.exit(1);
-    }
-    log(`rolled back ${app.name} to ${previous}`);
-}
+export const rollbackCommand = defineCommand({
+    name: 'rollback',
+    summary: 'Roll back app to previous image',
+    args: z.object({ app: z.string(), yes: z.boolean().default(false) }),
+    destructive: 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, image: '' } };
+        }
+        const image = resolveImageName(app.composePath, app.composeFile);
+        if (!image) {
+            return { ok: false, summary: `could not resolve image name for ${app.name}`, data: { app: app.name, image: '' } };
+        }
+        const previous = `${splitImageBase(image)}:fleet-previous`;
+        if (!execSafe('docker', ['image', 'inspect', previous], { timeout: 10_000 }).ok) {
+            return { ok: false, summary: `no previous image found (${previous}) — nothing to roll back to`, data: { app: app.name, image: '' } };
+        }
+        if (!(args.yes || (await ctx.confirm(`Roll back ${app.name} to ${previous} and restart?`)))) {
+            return { ok: false, summary: 'cancelled', data: { app: app.name, image: previous } };
+        }
+        const tag = execSafe('docker', ['tag', previous, image], { timeout: 10_000 });
+        if (!tag.ok) {
+            return { ok: false, summary: `docker tag failed: ${tag.stderr || `exit ${tag.exitCode}`}`, data: { app: app.name, image: previous } };
+        }
+        if (!restartService(app.serviceName)) {
+            return { ok: false, summary: `tag restored but service restart failed for ${app.serviceName}`, data: { app: app.name, image: previous } };
+        }
+        return { ok: true, summary: `rolled back ${app.name} to ${previous}`, data: { app: app.name, image: previous } };
+    },
+});