@celilo/cli 0.5.0-alpha.1 → 0.5.0-alpha.11

package/src/cli/commands/backup-restore.ts

@@ -3,10 +3,10 @@
  * Restores from a backup archive, executing the module's on_restore hook.
  */
 
-import * as p from '@clack/prompts';
 import { formatSize, getBackup } from '../../services/backup-metadata';
 import { restoreModuleBackup, restoreSystemStateBackup } from '../../services/backup-restore';
 import { getBackupStorage } from '../../services/backup-storage';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { celiloIntro, celiloOutro } from '../prompts';
 import type { CommandResult } from '../types';
 
@@ -66,13 +66,16 @@ export async function handleBackupRestore(
 
     // Confirm unless --yes
     if (!flags.yes) {
-      const confirmed = await p.confirm({
-        message: 'Proceed with restore?',
-        initialValue: false,
-      });
-
-      if (p.isCancel(confirmed) || !confirmed) {
-        p.cancel('Restore cancelled');
+      const confirmed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `backup-restore:${backupId}`,
+          key: 'proceed',
+          message: 'Proceed with restore?',
+          defaultValue: false,
+        }),
+      );
+
+      if (!confirmed) {
         return { success: false, error: 'Cancelled by user' };
       }
     }

package/src/cli/commands/dns.ts

@@ -0,0 +1,57 @@
+/**
+ * `celilo dns` — operator views over celilo's DNS bookkeeping.
+ *
+ * `registrations` lists the dns_registrations ledger: every (provider,
+ * fqdn) the framework has registered via dns_registrar.registerHost,
+ * with the consumer that asked for it and when it was last re-asserted
+ * by the provider's refresh_registrations hook. Read-only; names only
+ * (module ids), never UUIDs. See
+ * designs/DISPATCHER_DAEMON_AND_TIMER_EVENTS.md (B2b).
+ */
+
+import { getDb } from '../../db/client';
+import { listDnsRegistrations } from '../../services/dns-registrations';
+import type { CommandResult } from '../types';
+
+function formatAge(from: Date | null, now: Date): string {
+  if (!from) return 'never';
+  const mins = Math.floor((now.getTime() - from.getTime()) / 60_000);
+  if (mins < 1) return 'just now';
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
+export async function handleDnsRegistrations(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const db = getDb();
+  const provider = typeof flags.provider === 'string' ? flags.provider : undefined;
+  const rows = listDnsRegistrations(db, { providerModuleId: provider });
+
+  if (rows.length === 0) {
+    const scope = provider ? ` for provider '${provider}'` : '';
+    return {
+      success: true,
+      message: `No DNS registrations recorded${scope}\n\nRegistrations are recorded when a module registers a hostname via the dns_registrar capability (e.g. during deploy).`,
+    };
+  }
+
+  const now = new Date();
+  const header = ['FQDN', 'IP', 'PROVIDER', 'CONSUMER', 'REGISTERED', 'REFRESHED'];
+  const table = rows.map((r) => [
+    r.fqdn,
+    r.ip ?? 'auto',
+    r.providerModuleId,
+    r.consumerModuleId,
+    formatAge(r.registeredAt, now),
+    formatAge(r.refreshedAt, now),
+  ]);
+  const widths = header.map((h, i) => Math.max(h.length, ...table.map((row) => row[i].length)));
+  const render = (row: string[]) => row.map((cell, i) => cell.padEnd(widths[i])).join('  ');
+
+  const lines = [render(header), ...table.map(render)];
+  return { success: true, message: lines.join('\n'), data: rows };
+}

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

@@ -165,20 +165,20 @@ describe('celilo events command handlers', () => {
     });
     setupBus.close();
 
-    const res = await handleEventsReply([String(query.id), '"lunacycle.net"'], {});
+    const res = await handleEventsReply([String(query.id), '"example.net"'], {});
     expect(res.success).toBe(true);
     if (!res.success) throw new Error('expected success');
     const data = res.data as { status: string; family: string; value: unknown };
     expect(data.status).toBe('replied');
     expect(data.family).toBe('config');
-    expect(data.value).toBe('lunacycle.net');
+    expect(data.value).toBe('example.net');
 
     const checkBus = openBus({ dbPath, events: defineEvents({}) });
     const replies = checkBus.recentEvents({ type: 'config.required.lunacycle.domain.reply' });
     checkBus.close();
     expect(replies).toHaveLength(1);
     expect(replies[0].replyFor).toBe(query.id);
-    expect(replies[0].payload).toEqual({ value: 'lunacycle.net' });
+    expect(replies[0].payload).toEqual({ value: 'example.net' });
     expect(replies[0].emittedBy).toBe('claude-config-responder');
   });
 
@@ -229,7 +229,7 @@ describe('celilo events command handlers', () => {
     setupBus.close();
 
     // A bare word isn't valid JSON — the operator must quote strings.
-    const res = await handleEventsReply([String(query.id), 'lunacycle.net'], {});
+    const res = await handleEventsReply([String(query.id), 'example.net'], {});
     expect(res.success).toBe(false);
     if (res.success) throw new Error('expected failure');
     expect(res.error).toContain('Invalid JSON value');

package/src/cli/commands/events.ts

@@ -36,7 +36,12 @@ import { runNamedHook } from '../../hooks/run-named-hook';
 import type { HookName } from '../../hooks/types';
 import type { ModuleManifest } from '../../manifest/schema';
 import type { EnsureRequiredPayload } from '../../services/bus-interview';
-import { installDaemon, readInstalledUnit, uninstallDaemon } from '../../services/events-daemon';
+import {
+  installDaemon,
+  planDaemonInstall,
+  readInstalledUnit,
+  uninstallDaemon,
+} from '../../services/events-daemon';
 import { getArg, hasFlag } from '../parser';
 import type { CommandResult } from '../types';
 
@@ -187,6 +192,34 @@ export async function handleEventsListSubscribers(): Promise<CommandResult> {
   }
 }
 
+/**
+ * `celilo events resync-subscriptions` — rebuild the bus `subscribers` table
+ * from every deployed module's manifest. The reactive layer is registered at
+ * DEPLOY time and lives in the bus, which a restore/migration starts EMPTY — so
+ * after a cutover this re-establishes who-reacts-to-what without redeploying
+ * every module (ISS-0088). Idempotent.
+ */
+export async function handleEventsResyncSubscriptions(): Promise<CommandResult> {
+  try {
+    const { resyncAllSubscriptions } = await import('../../services/module-subscriptions');
+    const result = resyncAllSubscriptions();
+    const lines = [
+      `Re-registered ${result.registered} subscription(s) from ${result.modules} deployed module(s).`,
+    ];
+    if (result.failures.length > 0) {
+      const detail = result.failures.map((f) => `  ${f.moduleId}: ${f.error}`).join('\n');
+      return {
+        success: false,
+        error: `${result.failures.length} module(s) failed to re-register subscriptions:\n${detail}`,
+      };
+    }
+    lines.push('', 'A running dispatcher will now deliver events to these handlers.');
+    return { success: true, message: lines.join('\n'), data: result };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 export async function handleEventsListPending(
   _args: string[],
   flags: Record<string, string | boolean>,
@@ -356,7 +389,7 @@ export async function handleEventsRepair(): Promise<CommandResult> {
   }
 }
 
-const INTERVIEW_FAMILIES = ['config', 'secret', 'ensure', 'aspect'] as const;
+const INTERVIEW_FAMILIES = ['config', 'secret', 'ensure', 'aspect', 'interview'] as const;
 type InterviewFamily = (typeof INTERVIEW_FAMILIES)[number];
 
 /** Classify a query event type into its interview family, or null if it isn't one. */
@@ -365,6 +398,7 @@ function interviewFamily(type: string): InterviewFamily | null {
   if (type.startsWith('secret.required.')) return 'secret';
   if (type.startsWith('ensure.required.')) return 'ensure';
   if (type.startsWith('aspect.required.')) return 'aspect';
+  if (type.startsWith('interview.required.')) return 'interview';
   return null;
 }
 
@@ -395,6 +429,10 @@ function interviewFamily(type: string): InterviewFamily | null {
  *                                base-module aspect, 'false' refuses it (ISS-0027).
  *                                Replies { consented }; the deploy records the
  *                                approval/denial.
+ *   - interview.required.<scope>.<key> → value is the answer itself, shaped per
+ *                                the question's kind ('"node3"', 'true',
+ *                                '["a","b"]'); replies { value }. The generic
+ *                                operator-command interview family (ISS-0127).
  */
 export async function handleEventsReply(
   args: string[],
@@ -406,7 +444,7 @@ export async function handleEventsReply(
     return {
       success: false,
       error: `Usage: celilo events reply <query-event-id> <value-json>
-  e.g. celilo events reply 42 '"lunacycle.net"'`,
+  e.g. celilo events reply 42 '"example.net"'`,
     };
   }
   const queryId = Number(idArg);
@@ -421,7 +459,7 @@ export async function handleEventsReply(
     return {
       success: false,
       error: `Invalid JSON value: ${err instanceof Error ? err.message : String(err)}
-  Encode the answer as JSON, e.g. '"lunacycle.net"', '8080', '["a","b"]'.`,
+  Encode the answer as JSON, e.g. '"example.net"', '8080', '["a","b"]'.`,
     };
   }
 
@@ -443,7 +481,7 @@ export async function handleEventsReply(
       return {
         success: false,
         error: `Event ${queryId} is type '${query.type}', not an interview query.
-  Expected one of: config.required.* / secret.required.* / ensure.required.* / aspect.required.*`,
+  Expected one of: config.required.* / secret.required.* / ensure.required.* / aspect.required.* / interview.required.*`,
       };
     }
 
@@ -463,7 +501,7 @@ export async function handleEventsReply(
       });
     }
 
-    if (family === 'config') {
+    if (family === 'config' || family === 'interview') {
       bus.emitRaw(`${query.type}.reply`, { value }, { replyFor: queryId, emittedBy });
       return jsonResult({ ok: true, status: 'replied', queryId, type: query.type, family, value });
     }
@@ -778,27 +816,46 @@ function parseDurationMs(flag: string | boolean | undefined, defaultMs: number):
   }
 }
 
+function daemonScopeFrom(flags: Record<string, string | boolean>): 'user' | 'system' {
+  return flags.system ? 'system' : 'user';
+}
+
 /**
- * `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.
+ * `celilo events install-daemon` — write a systemd unit (Linux) or
+ * launchd plist (macOS) that runs the dispatcher under supervision.
+ * Default is a per-user unit; `--system` writes the system-scope unit
+ * (/etc/systemd/system, or a /Library/LaunchDaemons LaunchDaemon on
+ * macOS) that survives logout/reboot and runs as the celilo state-dir
+ * owner — the management-plane shape. Writes the file but doesn't
+ * touch supervisor state — the operator (or the celilo-mgmt Ansible
+ * role) runs the enable/bootstrap steps themselves so any change is
+ * visible.
  */
 export async function handleEventsInstallDaemon(
   _args: string[],
   flags: Record<string, string | boolean>,
 ): Promise<CommandResult> {
   try {
-    const result = installDaemon({
+    const options = {
       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,
-    });
+      scope: daemonScopeFrom(flags),
+    };
+    // --print: render-only, raw unit content on stdout. The celilo-mgmt
+    // Ansible role captures this and does the root-owned write itself
+    // (the deb wrapper runs celilo as the unprivileged celilo user, so
+    // a direct --system write would EACCES on /etc/systemd/system).
+    if (flags.print) {
+      const plan = planDaemonInstall(options);
+      return { success: true, message: plan.unitContent, rawOutput: true, data: plan };
+    }
+    const result = installDaemon(options);
     const lines = [
-      `Wrote ${result.platform} unit: ${shortenPath(result.unitPath)}`,
+      `Wrote ${result.platform} ${result.scope} unit: ${shortenPath(result.unitPath)}`,
       `  celilo:   ${shortenPath(result.celiloPath)}`,
       `  bus DB:   ${shortenPath(result.busDbPath)}`,
+      ...(result.runAsUser ? [`  runs as:  ${result.runAsUser}`] : []),
       '',
       'Next steps (run these yourself — install does not touch supervisor state):',
       ...result.nextSteps.map((s) => `  ${s}`),
@@ -813,13 +870,16 @@ export async function handleEventsInstallDaemon(
 }
 
 /**
- * `celilo events uninstall-daemon` — remove the supervisor unit file.
- * Symmetrical: prints the operator-facing disable steps, doesn't run
- * them.
+ * `celilo events uninstall-daemon` — remove the supervisor unit file
+ * (`--system` for the system-scope unit). Symmetrical: prints the
+ * operator-facing disable steps, doesn't run them.
  */
-export async function handleEventsUninstallDaemon(): Promise<CommandResult> {
+export async function handleEventsUninstallDaemon(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
   try {
-    const result = uninstallDaemon();
+    const result = uninstallDaemon({ scope: daemonScopeFrom(flags) });
     const lines = [
       result.removed
         ? `Removed unit: ${shortenPath(result.unitPath)}`
@@ -839,15 +899,20 @@ export async function handleEventsUninstallDaemon(): Promise<CommandResult> {
 
 /**
  * `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.
+ * installed (`--system` for the system-scope unit) 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();
+export async function handleEventsShowDaemon(
+  _args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const scope = daemonScopeFrom(flags);
+  const result = readInstalledUnit({ scope });
   if (!result.exists) {
     return {
       success: true,
-      message: `No supervisor unit installed at ${shortenPath(result.path)}\n\nRun \`celilo events install-daemon\` to create one.`,
+      message: `No supervisor unit installed at ${shortenPath(result.path)}\n\nRun \`celilo events install-daemon${scope === 'system' ? ' --system' : ''}\` to create one.`,
     };
   }
   return {