@celilo/cli 0.2.1 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -13,7 +13,13 @@
     "schemas/",
     "tsconfig.json"
   ],
-  "keywords": ["celilo", "homelab", "orchestration", "ansible", "terraform"],
+  "keywords": [
+    "celilo",
+    "homelab",
+    "orchestration",
+    "ansible",
+    "terraform"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -46,8 +52,9 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1024.0",
-    "@celilo/capabilities": "^0.1.9",
-    "@celilo/cli-display": "^0.1.4",
+    "@celilo/capabilities": "^0.1.10",
+    "@celilo/cli-display": "^0.1.6",
+    "@celilo/event-bus": "^0.1.0",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/cli/command-registry.ts

@@ -92,6 +92,120 @@ export const COMMANDS: CommandDef[] = [
       },
     ],
   },
+  {
+    name: 'events',
+    description: 'SQLite event-bus operations (status, tail, run dispatcher, etc.)',
+    subcommands: [
+      { name: 'status', description: 'Print bus health as JSON' },
+      {
+        name: 'tail',
+        description: 'Recent events as JSON',
+        flags: [
+          { name: 'type', description: 'Filter by event type', takesValue: true },
+          { name: 'limit', description: 'Max events to return', takesValue: true },
+        ],
+      },
+      { name: 'list-subscribers', description: 'List persistent bus subscribers' },
+      {
+        name: 'list-pending',
+        description: 'List pending deliveries',
+        flags: [
+          {
+            name: 'subscriber',
+            description: 'Restrict to a subscriber by name',
+            takesValue: true,
+          },
+          { name: 'limit', description: 'Max rows to return', takesValue: true },
+        ],
+      },
+      {
+        name: 'drain',
+        description: 'Process pending deliveries once and return',
+        flags: [{ name: 'concurrency', description: 'Max parallel handlers', takesValue: true }],
+      },
+      {
+        name: 'run',
+        description: 'Run the long-running dispatcher in the foreground',
+        flags: [
+          { name: 'poll-ms', description: 'Polling interval in ms', takesValue: true },
+          { name: 'concurrency', description: 'Max parallel handlers', takesValue: true },
+          {
+            name: 'halt-on-recovery',
+            description: 'Refuse to start if a prior crash is detected',
+            takesValue: false,
+          },
+        ],
+      },
+      {
+        name: 'emit',
+        description: 'Emit an event (operator/test path; bypasses schema)',
+        args: [
+          { name: 'type', description: 'Event type' },
+          { name: 'payload', description: 'Payload as JSON (optional)' },
+        ],
+        flags: [
+          { name: 'dedup-key', description: 'Idempotency key', takesValue: true },
+          { name: 'emitted-by', description: 'Audit tag', takesValue: true },
+        ],
+      },
+      {
+        name: 'ack',
+        description: 'Mark a running delivery succeeded',
+        args: [{ name: 'event_id', description: 'Event id from `tail`' }],
+        flags: [
+          {
+            name: 'subscriber',
+            description: 'Subscriber id (auto-detected when running under the dispatcher)',
+            takesValue: true,
+          },
+        ],
+      },
+      {
+        name: 'fail',
+        description: 'Mark a running delivery failed',
+        args: [{ name: 'event_id', description: 'Event id from `tail`' }],
+        flags: [
+          { name: 'error', description: 'Failure message', takesValue: true },
+          {
+            name: 'no-retry',
+            description: 'Abandon immediately instead of retrying',
+            takesValue: false,
+          },
+          { name: 'subscriber', description: 'Subscriber id', takesValue: true },
+        ],
+      },
+      {
+        name: 'repair',
+        description: 'Run the crash-recovery sweep without starting the dispatcher',
+      },
+      {
+        name: 'resume',
+        description: 'Acknowledge halt-on-recovery (alias for repair)',
+      },
+      {
+        name: 'install-daemon',
+        description: 'Write a systemd/launchd user unit for the dispatcher',
+        flags: [
+          {
+            name: 'celilo-path',
+            description: 'Override the celilo binary path (default: Bun.which("celilo"))',
+            takesValue: true,
+            valueHint: '_files',
+          },
+          { name: 'poll-ms', description: 'Polling interval in ms', takesValue: true },
+          { name: 'concurrency', description: 'Max parallel handlers', takesValue: true },
+        ],
+      },
+      {
+        name: 'uninstall-daemon',
+        description: 'Remove the installed supervisor unit',
+      },
+      {
+        name: 'show-daemon',
+        description: 'Print the currently installed unit file',
+      },
+    ],
+  },
   {
     name: 'capability',
     description: 'View registered module capabilities',

package/src/cli/commands/events.test.ts

@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { defineEvents, openBus } from '@celilo/event-bus';
+import {
+  handleEventsAck,
+  handleEventsDrain,
+  handleEventsEmit,
+  handleEventsFail,
+  handleEventsListPending,
+  handleEventsListSubscribers,
+  handleEventsRepair,
+  handleEventsStatus,
+  handleEventsTail,
+} from './events';
+
+describe('celilo events command handlers', () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'events-cmd-test-'));
+    dbPath = join(dir, 'events.db');
+    process.env.EVENT_BUS_DB = dbPath;
+  });
+  afterEach(() => {
+    process.env.EVENT_BUS_DB = undefined;
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it('status reports no_dispatcher on a fresh bus', async () => {
+    const result = await handleEventsStatus();
+    expect(result.success).toBe(true);
+    if (!result.success) throw new Error('expected success');
+    const data = result.data as { status: string };
+    expect(data.status).toBe('no_dispatcher');
+  });
+
+  it('emit + tail roundtrips an event', async () => {
+    const emit = await handleEventsEmit(['custom.event.foo', '{"x":1}'], { 'emitted-by': 'test' });
+    expect(emit.success).toBe(true);
+    const tail = await handleEventsTail([], { limit: '10' });
+    expect(tail.success).toBe(true);
+    if (!tail.success) throw new Error('expected success');
+    const events = tail.data as Array<{ type: string; payload: unknown }>;
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe('custom.event.foo');
+    expect(events[0].payload).toEqual({ x: 1 });
+  });
+
+  it('list-subscribers and list-pending reflect bus state', async () => {
+    const setupBus = openBus({ dbPath, events: defineEvents({}) });
+    setupBus.subscribe({ name: 'test-sub', pattern: 'foo.*', handler: 'echo' });
+    setupBus.emitRaw('foo.bar', { v: 1 });
+    setupBus.close();
+
+    const subs = await handleEventsListSubscribers();
+    expect(subs.success).toBe(true);
+    if (!subs.success) throw new Error('expected success');
+    expect((subs.data as { name: string }[])[0].name).toBe('test-sub');
+
+    const pending = await handleEventsListPending([], {});
+    expect(pending.success).toBe(true);
+    if (!pending.success) throw new Error('expected success');
+    expect(pending.data as unknown[]).toHaveLength(1);
+  });
+
+  it('drain on an empty queue returns processed: 0', async () => {
+    // The CLI drain path opens its own bus, so it can't reach an in-process
+    // onEvent registered on a separate bus instance. Spawn-based handler
+    // exercise lives in the bus library's own integration tests; here we
+    // assert the CLI plumbing returns the bus result shape.
+    const result = await handleEventsDrain([], {});
+    expect(result.success).toBe(true);
+    if (!result.success) throw new Error('expected success');
+    expect((result.data as { processed: number }).processed).toBe(0);
+  });
+
+  it('ack marks a running delivery succeeded', async () => {
+    const setupBus = openBus({ dbPath, events: defineEvents({}) });
+    setupBus.subscribe({ name: 's', pattern: 'foo', handler: 'echo' });
+    setupBus.emitRaw('foo', {});
+    // Force delivery to running state as if the dispatcher had claimed it.
+    setupBus.db.run("UPDATE deliveries SET status = 'running', started_at = ?, attempts = 1", [
+      Date.now(),
+    ]);
+    setupBus.close();
+
+    const ack = await handleEventsAck(['1'], {});
+    expect(ack.success).toBe(true);
+
+    const verify = openBus({ dbPath, events: defineEvents({}) });
+    try {
+      const row = verify.db.query<{ status: string }, []>('SELECT status FROM deliveries').get();
+      expect(row?.status).toBe('succeeded');
+    } finally {
+      verify.close();
+    }
+  });
+
+  it('fail with --no-retry abandons the delivery', async () => {
+    const setupBus = openBus({ dbPath, events: defineEvents({}) });
+    setupBus.subscribe({ name: 's', pattern: 'foo', handler: 'echo' });
+    setupBus.emitRaw('foo', {});
+    setupBus.db.run("UPDATE deliveries SET status = 'running', started_at = ?, attempts = 3", [
+      Date.now(),
+    ]);
+    setupBus.close();
+
+    const result = await handleEventsFail(['1'], { error: 'bad', 'no-retry': true });
+    expect(result.success).toBe(true);
+
+    const verify = openBus({ dbPath, events: defineEvents({}) });
+    try {
+      const row = verify.db.query<{ status: string }, []>('SELECT status FROM deliveries').get();
+      expect(row?.status).toBe('abandoned');
+    } finally {
+      verify.close();
+    }
+  });
+
+  it('ack errors out with no running delivery and no --subscriber', async () => {
+    const setupBus = openBus({ dbPath, events: defineEvents({}) });
+    setupBus.emitRaw('orphan', {});
+    setupBus.close();
+    const result = await handleEventsAck(['1'], {});
+    expect(result.success).toBe(false);
+  });
+
+  it('repair runs the recovery sweep', async () => {
+    const setupBus = openBus({ dbPath, events: defineEvents({}) });
+    setupBus.subscribe({ name: 's', pattern: 'foo', handler: 'echo', timeoutMs: 100 });
+    setupBus.emitRaw('foo', {});
+    const ancient = Date.now() - 60_000;
+    setupBus.db.run("UPDATE deliveries SET status = 'running', started_at = ?, attempts = 1", [
+      ancient,
+    ]);
+    setupBus.db.run(
+      `INSERT INTO dispatcher_heartbeat (dispatcher_id, last_heartbeat, started_at, pid, version)
+         VALUES (?, ?, ?, ?, ?)`,
+      ['ghost', ancient, ancient, 99999, '0.0.0'],
+    );
+    setupBus.close();
+
+    const result = await handleEventsRepair();
+    expect(result.success).toBe(true);
+    if (!result.success) throw new Error('expected success');
+    expect((result.data as { recovered: boolean }).recovered).toBe(true);
+    expect((result.data as { stuckCount: number }).stuckCount).toBe(1);
+  });
+});

package/src/cli/commands/events.ts

@@ -0,0 +1,356 @@
+/**
+ * `celilo events <subcommand>` — operator surface for the SQLite event
+ * bus. Thin wrappers over `@celilo/event-bus`'s programmatic API. The
+ * standalone `event-bus` CLI binary is still available; these commands
+ * exist so operators don't have to set EVENT_BUS_DB or remember a
+ * second tool.
+ *
+ * Subcommands:
+ *   status               bus.health() as JSON
+ *   tail                 recent events
+ *   list-subscribers     persistent subscribers
+ *   list-pending         pending deliveries
+ *   drain                process pending deliveries once
+ *   run                  long-running dispatcher (foreground; SIGINT to stop)
+ *   emit <type> [json]   emit an event (operator/test path; bypasses schema)
+ *   ack <event_id>       mark a running delivery succeeded
+ *   fail <event_id>      mark a running delivery failed
+ *   repair               crash-recovery sweep without starting the dispatcher
+ *   resume               alias for repair (acknowledges halt-on-recovery)
+ */
+
+import {
+  defineEvents,
+  drainOnce,
+  openBus,
+  recoverFromCrash,
+  runDispatcher,
+} from '@celilo/event-bus';
+import { getEventBusPath, shortenPath } from '../../config/paths';
+import { installDaemon, readInstalledUnit, uninstallDaemon } from '../../services/events-daemon';
+import { getArg, hasFlag } from '../parser';
+import type { CommandResult } from '../types';
+
+const NO_SCHEMAS = defineEvents({});
+
+function openCliBus() {
+  return openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+}
+
+function jsonResult(data: unknown): CommandResult {
+  return {
+    success: true,
+    message: JSON.stringify(data, null, 2),
+    data,
+  };
+}
+
+export async function handleEventsStatus(): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    return jsonResult(bus.health());
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsTail(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    const limit = flags.limit ? Number(flags.limit) : 50;
+    const type = typeof flags.type === 'string' ? flags.type : undefined;
+    return jsonResult(bus.recentEvents({ limit, type }));
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsListSubscribers(): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    const rows = bus.db
+      .query<
+        {
+          name: string;
+          pattern: string;
+          handler: string;
+          max_attempts: number;
+          timeout_ms: number;
+        },
+        []
+      >('SELECT name, pattern, handler, max_attempts, timeout_ms FROM subscribers ORDER BY name')
+      .all();
+    return jsonResult(rows);
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsListPending(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    const subscriber = typeof flags.subscriber === 'string' ? flags.subscriber : undefined;
+    const limit = flags.limit ? Number(flags.limit) : 100;
+    return jsonResult(bus.pendingDeliveries({ subscriber, limit }));
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsDrain(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    const concurrency = flags.concurrency ? Number(flags.concurrency) : undefined;
+    const result = await drainOnce(bus, { concurrency });
+    return jsonResult({ ...result, dbPath: shortenPath(getEventBusPath()) });
+  } finally {
+    bus.close();
+  }
+}
+
+/**
+ * Run the long-running dispatcher in the foreground. Blocks until
+ * SIGINT/SIGTERM. Pair with `celilo events status` from another shell
+ * to confirm it's healthy.
+ */
+export async function handleEventsRun(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const bus = openCliBus();
+  const handle = runDispatcher(bus, {
+    pollIntervalMs: flags['poll-ms'] ? Number(flags['poll-ms']) : undefined,
+    concurrency: flags.concurrency ? Number(flags.concurrency) : undefined,
+    haltOnRecovery: hasFlag(flags, 'halt-on-recovery'),
+  });
+  console.error(
+    `[celilo events] dispatcher running (pid ${process.pid}, db ${shortenPath(getEventBusPath())}). Ctrl-C to stop.`,
+  );
+
+  let stopping = false;
+  const stop = async (signal: string) => {
+    if (stopping) return;
+    stopping = true;
+    console.error(`[celilo events] received ${signal}, stopping...`);
+    await handle.stop();
+    bus.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', () => stop('SIGINT'));
+  process.on('SIGTERM', () => stop('SIGTERM'));
+  await new Promise(() => {}); // hold open
+  return { success: true, message: '' }; // unreachable
+}
+
+export async function handleEventsEmit(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const type = getArg(args, 0);
+  if (!type) {
+    return { success: false, error: 'Usage: celilo events emit <type> [<payload-json>]' };
+  }
+  const payloadRaw = getArg(args, 1);
+  let payload: unknown = undefined;
+  if (payloadRaw !== undefined) {
+    try {
+      payload = JSON.parse(payloadRaw);
+    } catch (err) {
+      return {
+        success: false,
+        error: `Invalid JSON payload: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  }
+  const bus = openCliBus();
+  try {
+    const event = bus.emitRaw(type, payload, {
+      dedupKey: typeof flags['dedup-key'] === 'string' ? flags['dedup-key'] : undefined,
+      emittedBy: typeof flags['emitted-by'] === 'string' ? flags['emitted-by'] : 'celilo-cli',
+    });
+    return jsonResult(event);
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsAck(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const eventId = getArg(args, 0);
+  if (!eventId) return { success: false, error: 'Usage: celilo events ack <event_id>' };
+  const eId = Number(eventId);
+  if (!Number.isFinite(eId)) return { success: false, error: 'event_id must be a number' };
+  const bus = openCliBus();
+  try {
+    const subscriberId = resolveSubscriberId(bus, eId, flags);
+    if (subscriberId === null) {
+      return {
+        success: false,
+        error: `No running delivery for event ${eId}; pass --subscriber <id>`,
+      };
+    }
+    bus.markSucceeded({ eventId: eId, subscriberId });
+    return jsonResult({ ok: true, eventId: eId, subscriberId });
+  } finally {
+    bus.close();
+  }
+}
+
+export async function handleEventsFail(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const eventId = getArg(args, 0);
+  if (!eventId)
+    return { success: false, error: 'Usage: celilo events fail <event_id> --error <msg>' };
+  const eId = Number(eventId);
+  if (!Number.isFinite(eId)) return { success: false, error: 'event_id must be a number' };
+  const errorMsg = typeof flags.error === 'string' ? flags.error : 'handler failed';
+  const noRetry = hasFlag(flags, 'no-retry');
+  const bus = openCliBus();
+  try {
+    const subscriberId = resolveSubscriberId(bus, eId, flags);
+    if (subscriberId === null) {
+      return {
+        success: false,
+        error: `No running delivery for event ${eId}; pass --subscriber <id>`,
+      };
+    }
+    if (noRetry) {
+      bus.markFailed({ eventId: eId, subscriberId }, new Error(errorMsg), { abandoned: true });
+    } else {
+      bus.markFailed({ eventId: eId, subscriberId }, new Error(errorMsg));
+    }
+    return jsonResult({ ok: true, eventId: eId, subscriberId, abandoned: noRetry });
+  } finally {
+    bus.close();
+  }
+}
+
+/**
+ * `celilo events repair` / `celilo events resume` — run the
+ * crash-recovery sweep. Resets stuck `running` deliveries to `pending`
+ * so the next dispatcher tick picks them up. `resume` is the
+ * operator-facing alias for the halt-on-recovery acknowledgment flow.
+ */
+export async function handleEventsRepair(): Promise<CommandResult> {
+  const bus = openCliBus();
+  try {
+    const result = recoverFromCrash(bus);
+    return jsonResult({
+      recovered: result.recovered,
+      stuckCount: result.stuckCount,
+      lastHeartbeatAgeMs: result.lastHeartbeatAgeMs,
+    });
+  } finally {
+    bus.close();
+  }
+}
+
+/**
+ * `celilo events install-daemon` — write a systemd user unit (Linux)
+ * or launchd plist (macOS) that runs the dispatcher under supervision.
+ * Writes the file but doesn't touch supervisor state — the operator
+ * runs `systemctl --user enable --now ...` themselves so any change
+ * is visible.
+ */
+export async function handleEventsInstallDaemon(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  try {
+    const result = installDaemon({
+      celiloPath: typeof flags['celilo-path'] === 'string' ? flags['celilo-path'] : undefined,
+      pollMs: flags['poll-ms'] ? Number(flags['poll-ms']) : undefined,
+      concurrency: flags.concurrency ? Number(flags.concurrency) : undefined,
+    });
+    const lines = [
+      `Wrote ${result.platform} unit: ${shortenPath(result.unitPath)}`,
+      `  celilo:   ${shortenPath(result.celiloPath)}`,
+      `  bus DB:   ${shortenPath(result.busDbPath)}`,
+      '',
+      'Next steps (run these yourself — install does not touch supervisor state):',
+      ...result.nextSteps.map((s) => `  ${s}`),
+    ];
+    return { success: true, message: lines.join('\n'), data: result };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * `celilo events uninstall-daemon` — remove the supervisor unit file.
+ * Symmetrical: prints the operator-facing disable steps, doesn't run
+ * them.
+ */
+export async function handleEventsUninstallDaemon(): Promise<CommandResult> {
+  try {
+    const result = uninstallDaemon();
+    const lines = [
+      result.removed
+        ? `Removed unit: ${shortenPath(result.unitPath)}`
+        : `No unit file at ${shortenPath(result.unitPath)} — nothing to remove.`,
+      '',
+      'Next steps:',
+      ...result.nextSteps.map((s) => `  ${s}`),
+    ];
+    return { success: true, message: lines.join('\n'), data: result };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+/**
+ * `celilo events show-daemon` — print whatever unit file is currently
+ * installed so the operator can see exactly what the supervisor will
+ * run, without grepping into platform-specific paths.
+ */
+export async function handleEventsShowDaemon(): Promise<CommandResult> {
+  const result = readInstalledUnit();
+  if (!result.exists) {
+    return {
+      success: true,
+      message: `No supervisor unit installed at ${shortenPath(result.path)}\n\nRun \`celilo events install-daemon\` to create one.`,
+    };
+  }
+  return {
+    success: true,
+    message: `${shortenPath(result.path)}:\n\n${result.content}`,
+    data: { path: result.path, content: result.content },
+  };
+}
+
+function resolveSubscriberId(
+  bus: ReturnType<typeof openCliBus>,
+  eventId: number,
+  flags: Record<string, string | boolean>,
+): number | null {
+  if (typeof flags.subscriber === 'string' || typeof flags.subscriber === 'number') {
+    return Number(flags.subscriber);
+  }
+  const row = bus.db
+    .query<{ subscriber_id: number }, [number]>(
+      `SELECT subscriber_id FROM deliveries
+        WHERE event_id = ? AND status = 'running'
+        ORDER BY started_at DESC LIMIT 1`,
+    )
+    .get(eventId);
+  return row?.subscriber_id ?? null;
+}

package/src/cli/commands/module-remove.ts

@@ -232,6 +232,20 @@ export async function handleModuleRemove(
   // Deallocate IPAM resources (if any)
   await deallocateForModule(moduleId, db);
 
+  // Tear down any event-bus subscriptions the module owned. Cascade-safe:
+  // best-effort, never blocks removal — a stuck bus is no reason to
+  // strand a module in a half-removed state.
+  try {
+    const { unregisterModuleSubscriptions } = await import('../../services/module-subscriptions');
+    const result = unregisterModuleSubscriptions(moduleId);
+    if (result.unregistered > 0) {
+      log.info(`Unregistered ${result.unregistered} event-bus subscription(s) for ${moduleId}`);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log.warn(`Failed to unregister event-bus subscriptions: ${msg}`);
+  }
+
   // Delete module (cascade will remove configs, secrets, capabilities, infrastructure records)
   db.delete(modules).where(eq(modules.id, moduleId)).run();