@celilo/cli 0.3.3 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.3",
+  "version": "0.3.9",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -54,7 +54,7 @@
     "@aws-sdk/client-s3": "^3.1024.0",
     "@celilo/capabilities": "^0.1.10",
     "@celilo/cli-display": "^0.1.6",
-    "@celilo/event-bus": "^0.1.3",
+    "@celilo/event-bus": "^0.1.4",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/cli/command-registry.ts

@@ -182,6 +182,34 @@ export const COMMANDS: CommandDef[] = [
         name: 'resume',
         description: 'Acknowledge halt-on-recovery (alias for repair)',
       },
+      {
+        name: 'respond',
+        description: 'Answer config/secret/ensure prompts for a deploy running in another shell',
+        flags: [
+          {
+            name: 'values',
+            description:
+              'JSON file with config/secrets/ensures map; switches to non-interactive mode',
+            takesValue: true,
+            valueHint: '_files',
+          },
+          {
+            name: 'idle-timeout',
+            description: 'Exit when bus is quiet for this duration (e.g. 30s, 2m)',
+            takesValue: true,
+          },
+          {
+            name: 'max-duration',
+            description: 'Hard ceiling on responder runtime (e.g. 10m)',
+            takesValue: true,
+          },
+          {
+            name: 'emittedBy',
+            description: 'Identifier for the emittedBy audit field on replies',
+            takesValue: true,
+          },
+        ],
+      },
       {
         name: 'install-daemon',
         description: 'Write a systemd/launchd user unit for the dispatcher',
@@ -386,11 +414,6 @@ export const COMMANDS: CommandDef[] = [
         description: 'Deploy module to infrastructure',
         args: [{ name: 'id', description: 'Module ID', completion: 'module_ids' }],
         flags: [
-          {
-            name: 'no-interactive',
-            description: 'Disable progress animation and stream output directly',
-            takesValue: false,
-          },
           { name: 'debug', description: 'Enable debug mode', takesValue: false },
           {
             name: 'preflight',
@@ -403,6 +426,12 @@ export const COMMANDS: CommandDef[] = [
               'Keep all sub-events visible (no collapse-on-success); useful for debugging slow steps',
             takesValue: false,
           },
+          {
+            name: 'stop-after-interview',
+            description:
+              'Exit cleanly after the initial config + secrets interview (no terraform/ansible/hooks). Manual validation of the bus-mediated interview path.',
+            takesValue: false,
+          },
         ],
       },
       {

package/src/cli/commands/events.ts

@@ -258,6 +258,187 @@ export async function handleEventsRepair(): Promise<CommandResult> {
   }
 }
 
+/**
+ * `celilo events respond` — start a responder against the bus and
+ * block. Two modes:
+ *
+ *   - **Interactive (default).** Same code path as the in-deploy
+ *     terminal-responder, but spawned from a separate shell so an
+ *     operator can answer config / secret / ensure prompts for a
+ *     deploy running elsewhere. Blocks on SIGINT/SIGTERM. Use case:
+ *     deploy in shell A; this shell B types the answers.
+ *
+ *   - **Non-interactive (`--values <file>`).** Reads a JSON values
+ *     map from the given file and replies programmatically. Used by
+ *     the `celilo-config-responder` AI subagent and any other
+ *     scripted operator that wants to drive a deploy without typing.
+ *     Exits when the bus has been quiet for `--idle-timeout` (default
+ *     30s) or after `--max-duration` (default 10m), whichever comes
+ *     first. Outputs a final JSON summary on stdout.
+ *
+ * The first reply still wins, so multiple responders racing on the
+ * same query is fine — whoever answers first wins; the rest log a
+ * "stale-reply" event that's audit-only.
+ *
+ * Values-file shape:
+ * ```json
+ * {
+ *   "config":  { "module.key": "value", ... },
+ *   "secrets": { "module.key": "value", ... },
+ *   "ensures": {
+ *     "provider.ensureId": {
+ *       "configValues": { "config.target": "value" },
+ *       "secretValues": { "secret.target": "value" }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export async function handleEventsRespond(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const valuesPath = typeof flags.values === 'string' ? flags.values : undefined;
+  if (valuesPath) {
+    return runProgrammaticResponder(valuesPath, flags);
+  }
+
+  const { startTerminalResponder } = await import('../../services/terminal-responder');
+  const handle = startTerminalResponder();
+  console.error(
+    `[celilo events respond] terminal responder running (pid ${process.pid}). Ctrl-C to stop.`,
+  );
+
+  let stopping = false;
+  const stop = (signal: string) => {
+    if (stopping) return;
+    stopping = true;
+    console.error(`[celilo events respond] received ${signal}, stopping...`);
+    handle.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', () => stop('SIGINT'));
+  process.on('SIGTERM', () => stop('SIGTERM'));
+  await new Promise(() => {}); // hold open
+  return { success: true, message: '' }; // unreachable
+}
+
+/**
+ * Read values JSON, start a programmatic responder, and exit when
+ * the bus is quiet for `--idle-timeout` or after `--max-duration`.
+ * Returns a CommandResult with the summary so the JSON-result CLI
+ * envelope wraps it.
+ */
+async function runProgrammaticResponder(
+  valuesPath: string,
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const { readFileSync } = await import('node:fs');
+  const { startProgrammaticResponder } = await import('../../services/programmatic-responder');
+  const { getDb } = await import('../../db/client');
+  const { getEventBusPath } = await import('../../config/paths');
+
+  let values: import('../../services/programmatic-responder').ResponderValues;
+  try {
+    values = JSON.parse(readFileSync(valuesPath, 'utf-8'));
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read --values file ${valuesPath}: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+
+  const idleTimeoutMs = parseDurationMs(flags['idle-timeout'], 30_000);
+  const maxDurationMs = parseDurationMs(flags['max-duration'], 600_000);
+
+  const db = getDb();
+  const startedAt = Date.now();
+  const handle = startProgrammaticResponder({
+    busDbPath: getEventBusPath(),
+    db,
+    values,
+    onMissing: 'skip',
+    emittedBy: typeof flags.emittedBy === 'string' ? flags.emittedBy : 'cli:respond',
+  });
+
+  console.error(
+    `[celilo events respond] programmatic responder running (pid ${process.pid}, idle ${idleTimeoutMs}ms, max ${maxDurationMs}ms).`,
+  );
+
+  let stopping = false;
+  let stopReason: 'idle' | 'max-duration' | 'signal' = 'idle';
+  const buildSummary = (): { success: true; message: string; data: unknown } => {
+    if (!stopping) {
+      stopping = true;
+      handle.close();
+    }
+    const summary = {
+      exitReason: stopReason,
+      durationMs: Date.now() - startedAt,
+      answered: handle.answered(),
+      missed: handle.missed(),
+    };
+    return { success: true, message: JSON.stringify(summary, null, 2), data: summary };
+  };
+
+  process.on('SIGINT', () => {
+    stopReason = 'signal';
+    const r = buildSummary();
+    console.error(r.message);
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    stopReason = 'signal';
+    const r = buildSummary();
+    console.error(r.message);
+    process.exit(0);
+  });
+
+  // Poll for idle/max-duration. Each tick: if (now - lastActivity) > idle and
+  // we've seen at least one event, exit. If now - start > max-duration,
+  // exit regardless.
+  const pollMs = 500;
+  while (true) {
+    await new Promise((r) => setTimeout(r, pollMs));
+    const now = Date.now();
+    if (now - startedAt > maxDurationMs) {
+      stopReason = 'max-duration';
+      break;
+    }
+    if (handle.eventCount() > 0 && now - handle.lastActivityAt() > idleTimeoutMs) {
+      stopReason = 'idle';
+      break;
+    }
+  }
+
+  return buildSummary();
+}
+
+/**
+ * Parse a duration flag value. Accepts plain milliseconds (e.g.
+ * `30000`), or suffixed values (`30s`, `5m`, `1h`). Falls back to
+ * the default if the flag isn't a string.
+ */
+function parseDurationMs(flag: string | boolean | undefined, defaultMs: number): number {
+  if (typeof flag !== 'string') return defaultMs;
+  const m = flag.match(/^(\d+)(ms|s|m|h)?$/);
+  if (!m) return defaultMs;
+  const n = Number(m[1]);
+  const unit = m[2] ?? 'ms';
+  switch (unit) {
+    case 'ms':
+      return n;
+    case 's':
+      return n * 1000;
+    case 'm':
+      return n * 60_000;
+    case 'h':
+      return n * 3_600_000;
+    default:
+      return defaultMs;
+  }
+}
+
 /**
  * `celilo events install-daemon` — write a systemd user unit (Linux)
  * or launchd plist (macOS) that runs the dispatcher under supervision.

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

@@ -14,7 +14,13 @@ import type { CommandResult } from '../types';
  * Handle module deploy command
  *
  * Usage:
- *   celilo module deploy <module-id> [--no-interactive] [--debug] [--preflight] [--verbose]
+ *   celilo module deploy <module-id> [--debug] [--preflight] [--verbose]
+ *
+ * Note: there is no `--no-interactive` flag. The deploy interview
+ * runs through the bus event system; automation answers via a
+ * responder (Claude subagent, `celilo events respond`, autoresponder
+ * daemon, etc.). When stdin is a TTY the deploy registers a built-in
+ * terminal-responder. See INTERACTIVE_DEPLOYS_VIA_BUS.md.
  *
  * @param args - Command arguments
  * @param flags - Command flags
@@ -29,7 +35,7 @@ export async function handleModuleDeploy(
   if (error) {
     return {
       success: false,
-      error: `${error}\n\nUsage:\n  celilo module deploy <module-id> [--no-interactive] [--preflight]`,
+      error: `${error}\n\nUsage:\n  celilo module deploy <module-id> [--preflight]`,
     };
   }
 
@@ -50,11 +56,11 @@ export async function handleModuleDeploy(
     return preflight.success ? { success: true, message } : { success: false, error: message };
   }
 
-  const noInteractive = hasFlag(flags, 'no-interactive');
   const debug = hasFlag(flags, 'debug');
   const verbose = hasFlag(flags, 'verbose');
+  const stopAfterInterview = hasFlag(flags, 'stop-after-interview');
 
-  const result = await deployModule(moduleId, db, { noInteractive, debug, verbose });
+  const result = await deployModule(moduleId, db, { debug, verbose, stopAfterInterview });
 
   if (!result.success) {
     return {

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

@@ -105,8 +105,8 @@ export async function handleModuleRemove(
   const manifestForHook = module.manifestData as { hooks?: { on_uninstall?: unknown } } | undefined;
   if (manifestForHook?.hooks?.on_uninstall) {
     // Match build-stream's TTY detection: in non-TTY contexts (tests,
-    // pipes, --no-interactive flow) skipAnimation prevents the gauge's
-    // setInterval/raw-stdin handlers from blocking process exit.
+    // pipes, CI) skipAnimation prevents the gauge's setInterval and
+    // raw-stdin handlers from blocking process exit.
     const isInteractive = process.stdout.isTTY && process.stdin.isTTY;
     const gauge = new FuelGauge(`${moduleId}: on_uninstall`, {
       skipAnimation: !isInteractive,

package/src/cli/commands/system-update.ts

@@ -166,7 +166,11 @@ function buildOps(): OrchestratorOps {
     upgrade: async (_id) => ({ ok: true }),
     deploy: async (id) => {
       const db = getDb();
-      const result = await deployModule(id, db, { noInteractive: true });
+      // The deploy interview runs through the bus; if config is
+      // missing the deploy hangs waiting for a responder. system-update
+      // runs against pre-staged modules — config gaps surface via
+      // `celilo events list-pending` and are an operator concern.
+      const result = await deployModule(id, db, {});
       return result.success ? { ok: true } : { ok: false, error: result.error };
     },
     health: async (id) => {

package/src/cli/index.ts

@@ -19,6 +19,7 @@ import {
   handleEventsListPending,
   handleEventsListSubscribers,
   handleEventsRepair,
+  handleEventsRespond,
   handleEventsRun,
   handleEventsShowDaemon,
   handleEventsStatus,
@@ -246,6 +247,7 @@ Subcommands:
   fail <event_id> --error MSG  Mark a running delivery failed
   repair                       Crash-recovery sweep without starting the dispatcher
   resume                       Alias for repair (acknowledges halt-on-recovery)
+  respond                      Run the terminal responder; answer deploy prompts from another shell
   install-daemon               Write a systemd/launchd user unit for the dispatcher
   uninstall-daemon             Remove the installed supervisor unit
   show-daemon                  Print the currently installed unit file
@@ -338,7 +340,9 @@ Subcommands:
   deploy <module-id>                   Deploy module to infrastructure (auto-generates/builds if needed)
     Options:
       --debug                            Run hooks with visible browser (Playwright)
-      --no-interactive                   Fail instead of prompting for missing config
+      --preflight                        Run pre-flight validation only (no deployment)
+      --verbose                          Keep all sub-events visible (no collapse-on-success)
+      --stop-after-interview             Exit after config+secrets interview (no infra/hooks)
 
   health [module-id]                    Run health checks (transitions to VERIFIED on success)
     Options:
@@ -1007,6 +1011,8 @@ export async function runCli(argv: string[]): Promise<CommandResult> {
       case 'repair':
       case 'resume':
         return handleEventsRepair();
+      case 'respond':
+        return handleEventsRespond(parsed.args, parsed.flags);
       case 'install-daemon':
         return handleEventsInstallDaemon(parsed.args, parsed.flags);
       case 'uninstall-daemon':