@celilo/cli 0.17.0 → 0.19.0

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:

package/src/services/update/orchestrator.test.ts

@@ -76,6 +76,7 @@ const cleanAudit: AuditDeps = {
   moduleConfigs: { modules: [] },
   health: { results: [] },
   backups: { modules: [] },
+  abandonedOperations: { records: [] },
   undeployedModules: { modules: [] },
   unconfiguredModules: { modules: [] },
   servicesCredentials: { results: [] },

package/src/variables/context.ts

@@ -5,6 +5,7 @@ import type { DbClient } from '../db/client';
 import {
   capabilities,
   containerServices,
+  isAllocatableZone,
   machines,
   moduleConfigs,
   moduleInfrastructure,
@@ -391,7 +392,11 @@ export async function buildResolutionContext(
             .get();
           isProxmox = svc?.providerName === 'proxmox';
         }
-        if (isProxmox && zone !== 'external') {
+        // `isAllocatableZone`, not `zone !== 'external'`: that check was written
+        // when `external` was the only zone celilo does not address, and it
+        // silently became wrong the moment `vpn` joined it — a VPN client subnet
+        // is assigned by the tunnel module, so allocating into it would collide.
+        if (isProxmox && isAllocatableZone(zone)) {
           await db.transaction(async (tx) => {
             const existing = await getAllocation(moduleId, tx);
             const allocation = existing ?? (await allocateResources(moduleId, zone, tx));