@celilo/cli 0.18.0 → 0.19.0

package/src/services/remote-responder.test.ts

@@ -76,3 +76,73 @@ test('answers responder.probe with kind daemon', async () => {
     responder.close();
   }
 }, 15_000);
+
+/**
+ * When the client can't reach a decider it says so. The responder must relay
+ * that as an error reply — the waiting command then fails loudly instead of the
+ * question quietly resolving to `defaultValue`, which is how a breaking update
+ * came to be recorded as "operator declined".
+ */
+test('an ask that cannot be answered replies with an error, not the default', async () => {
+  const responder = startRemoteResponder({
+    busDbPath,
+    ask: async () => {
+      throw new Error("stdin isn't a terminal and no answer was pre-staged");
+    },
+  });
+
+  const bus = openBus({ dbPath: busDbPath, events: NO_SCHEMAS });
+  try {
+    const replies = (await bus.query(
+      'interview.required.module-upgrade:iptables.apply_breaking' as never,
+      {
+        scope: 'module-upgrade:iptables',
+        key: 'apply_breaking',
+        kind: 'confirm',
+        message: 'Apply breaking update for iptables?',
+        required: true,
+        defaultValue: 'false',
+      } as never,
+      { timeoutMs: 8000, pollIntervalMs: 100, expect: 'first' } as never,
+    )) as BusEvent[];
+
+    expect(replies).toHaveLength(1);
+    const payload = replies[0].payload as { value?: unknown; error?: string };
+    expect(payload.value).toBeUndefined();
+    expect(payload.error).toContain('terminal');
+  } finally {
+    bus.close();
+    responder.close();
+  }
+}, 15_000);
+
+test('forwards the question scope/key so a client can pre-stage an answer', async () => {
+  const asked: WireInterview[] = [];
+  const responder = startRemoteResponder({
+    busDbPath,
+    ask: async (iv) => {
+      asked.push(iv);
+      return true;
+    },
+  });
+
+  const bus = openBus({ dbPath: busDbPath, events: NO_SCHEMAS });
+  try {
+    await bus.query(
+      'interview.required.module-upgrade:iptables.apply_breaking' as never,
+      {
+        scope: 'module-upgrade:iptables',
+        key: 'apply_breaking',
+        kind: 'confirm',
+        message: 'Apply breaking update for iptables?',
+        required: true,
+      } as never,
+      { timeoutMs: 8000, pollIntervalMs: 100, expect: 'first' } as never,
+    );
+    expect(asked[0].scope).toBe('module-upgrade:iptables');
+    expect(asked[0].key).toBe('apply_breaking');
+  } finally {
+    bus.close();
+    responder.close();
+  }
+}, 15_000);

package/src/services/remote-responder.ts

@@ -20,6 +20,9 @@ const NO_SCHEMAS = defineEvents({});
 /** The normalized question handed to the wire (mirrors InterviewMessage). */
 export interface WireInterview {
   id: string;
+  /** The question's stable identity, so a client can pre-stage `<scope>.<key>`. */
+  scope: string;
+  key: string;
   kind: InterviewRequiredPayload['kind'];
   message: string;
   description?: string;
@@ -54,16 +57,30 @@ export function startRemoteResponder(opts: RemoteResponderOptions): RemoteRespon
       return;
     }
 
-    const value = await opts.ask({
-      id: String(event.id),
-      kind: payload.kind,
-      message: payload.message,
-      description: payload.description,
-      defaultValue: payload.defaultValue,
-      placeholder: payload.placeholder,
-      options: payload.options,
-      required: payload.required,
-    });
+    let value: unknown;
+    try {
+      value = await opts.ask({
+        id: String(event.id),
+        scope: payload.scope,
+        key: payload.key,
+        kind: payload.kind,
+        message: payload.message,
+        description: payload.description,
+        defaultValue: payload.defaultValue,
+        placeholder: payload.placeholder,
+        options: payload.options,
+        required: payload.required,
+      });
+    } catch (err) {
+      // The client had no way to answer. Reply with the reason so the waiting
+      // command fails loudly — never let the question decay to its default.
+      bus.emitRaw(
+        `${event.type}.reply`,
+        { error: err instanceof Error ? err.message : String(err) },
+        { replyFor: event.id, emittedBy: me },
+      );
+      return;
+    }
 
     bus.emitRaw(`${event.type}.reply`, { value }, { replyFor: event.id, emittedBy: me });
   });

package/src/services/responder-probe.ts

@@ -14,6 +14,7 @@
 
 import { defineEvents, openBus } from '@celilo/event-bus';
 import { getEventBusPath } from '../config/paths';
+import { InterviewUnansweredError } from './interview-errors';
 
 const NO_SCHEMAS = defineEvents({});
 
@@ -63,7 +64,8 @@ export async function ensureResponderForInterview(queryType: string): Promise<vo
   if (process.stdin.isTTY) return;
   const available = await probeForResponder(getEventBusPath());
   if (available) return;
-  throw new Error(
+  throw new InterviewUnansweredError(
+    queryType,
     `No responder is listening and stdin isn't a TTY, so this interview prompt can't be answered (${queryType}).
 
 Either: