@celilo/cli 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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.0",
+    "@celilo/event-bus": "^0.1.3",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/services/config-interview.ts

@@ -442,29 +442,13 @@ export async function interviewForMissingConfig(
           payload,
         );
 
-        // The reply.value is typed per payload.type; the terminal-
-        // responder coerces strings to numbers/bools/json-as-array etc.
-        // For storage, we still need a string + an optional valueJson
-        // for non-scalar types. Match what `module config set` does.
-        value = typeof reply.value === 'string' ? reply.value : JSON.stringify(reply.value);
-
-        await db
-          .insert(moduleConfigs)
-          .values({
-            moduleId,
-            key: variable.name,
-            value,
-            valueJson: null,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          })
-          .onConflictDoUpdate({
-            target: [moduleConfigs.moduleId, moduleConfigs.key],
-            set: {
-              value,
-              updatedAt: new Date(),
-            },
-          });
+        // Persist via writeModuleConfigKey so the (string value,
+        // typed valueJson) pair is set correctly. Downstream readers
+        // (validate_config hooks, capability resolvers) deserialize
+        // typed values from valueJson — earlier I was only writing
+        // value with valueJson:null, which broke `array`/`object`
+        // typed configs that consumers expected to be JSON-parsed.
+        await writeModuleConfigKey(moduleId, variable.name, reply.value, db);
 
         configured.push(variable.name);
       }

package/src/services/terminal-responder.ts

@@ -54,50 +54,70 @@ export function startTerminalResponder(): TerminalResponderHandle {
   // re-fire (e.g. validation re-emit) doesn't double-prompt.
   const handled = new Set<number>();
 
-  const watch = bus.watch('config.required.**', async (event) => {
+  // Pattern matches exactly `config.required.<module>.<key>` (4 dot
+  // segments). The reply we emit is `config.required.<m>.<k>.reply`
+  // (5 segments) — wouldn't match — but `**` would have matched, and
+  // we'd recursively try to prompt for our own reply event. The
+  // explicit replyFor === null check below is defense in depth in
+  // case any responder ever emits a reply with the same shape.
+  const watch = bus.watch('config.required.*.*', async (event) => {
+    // Reply events carry replyFor; queries don't. Skip anything that
+    // looks like a reply, even if it accidentally matches the pattern.
+    if (event.replyFor !== null) return;
     if (handled.has(event.id)) return;
     handled.add(event.id);
 
     const payload = event.payload as ConfigRequiredPayload;
-    try {
-      const message = payload.description
-        ? `${payload.module}.${payload.key} — ${payload.description}:`
-        : `${payload.module}.${payload.key}:`;
-
-      const value = await promptText({
-        message,
-        validate: (val) => {
-          if (payload.required && (!val || val.trim() === '')) {
-            return 'This field is required';
-          }
-          if (payload.pattern && val) {
-            const re = new RegExp(payload.pattern);
-            if (!re.test(val)) return `Value must match: ${payload.pattern}`;
-          }
-        },
-      });
-
-      // Coerce to the declared type. clack returns string; the
-      // responder honors the type contract so the deploy doesn't
-      // have to second-guess the reply shape.
-      const coerced = coerceValue(value, payload.type);
-
-      bus.emitRaw(
-        `${event.type}.reply`,
-        { value: coerced },
-        {
-          replyFor: event.id,
-          emittedBy: me,
-        },
+    // Defensive: if the payload is malformed (no module/key), don't
+    // render a "undefined.undefined:" prompt — log and skip.
+    if (!payload || typeof payload.module !== 'string' || typeof payload.key !== 'string') {
+      log.warn(
+        `Terminal responder skipped malformed event ${event.type} (id ${event.id}): missing module/key`,
       );
-    } catch (err) {
-      // Reply with an error-shaped payload so the deploy can surface
-      // it cleanly. The deploy can decide whether to re-emit (for
-      // recoverable errors) or fail.
-      const message = err instanceof Error ? err.message : String(err);
-      log.warn(`Terminal responder error for ${event.type}: ${message}`);
-      bus.emitRaw(`${event.type}.reply`, { error: message }, { replyFor: event.id, emittedBy: me });
+      return;
     }
+
+    const message = payload.description
+      ? `${payload.module}.${payload.key} — ${payload.description}:`
+      : `${payload.module}.${payload.key}:`;
+
+    // Hint shown next to the prompt. For non-string types, tell the
+    // user what shape we're expecting so they don't get a coercion
+    // failure mid-deploy.
+    const typeHint = describeTypeHint(payload.type);
+
+    const value = await promptText({
+      message: typeHint ? `${message}  (${typeHint})` : message,
+      validate: (val) => {
+        if (payload.required && (!val || val.trim() === '')) {
+          return 'This field is required';
+        }
+        if (payload.pattern && val) {
+          const re = new RegExp(payload.pattern);
+          if (!re.test(val)) return `Value must match: ${payload.pattern}`;
+        }
+        // Type-shape validation runs HERE, at submit time, so clack
+        // re-prompts on bad input rather than letting a malformed
+        // value through that fails post-submit.
+        try {
+          coerceValue(val, payload.type);
+        } catch (err) {
+          return err instanceof Error ? err.message : String(err);
+        }
+      },
+    });
+
+    // Already validated above; coerce can't throw here.
+    const coerced = coerceValue(value, payload.type);
+
+    bus.emitRaw(
+      `${event.type}.reply`,
+      { value: coerced },
+      {
+        replyFor: event.id,
+        emittedBy: me,
+      },
+    );
   });
 
   return {
@@ -108,7 +128,37 @@ export function startTerminalResponder(): TerminalResponderHandle {
   };
 }
 
-function coerceValue(raw: string, type: ConfigRequiredPayload['type']): unknown {
+/**
+ * Short hint shown in the prompt for non-string types so the operator
+ * isn't guessing what shape we want. Returns null for plain strings —
+ * no hint needed.
+ */
+function describeTypeHint(type: ConfigRequiredPayload['type']): string | null {
+  switch (type) {
+    case 'string':
+      return null;
+    case 'integer':
+      return 'integer';
+    case 'number':
+      return 'number';
+    case 'boolean':
+      return 'true/false/yes/no/y/n/1/0';
+    case 'array':
+      return 'JSON array, e.g. ["a","b"]';
+    case 'object':
+      return 'JSON object, e.g. {"k":"v"}';
+    default:
+      return null;
+  }
+}
+
+function coerceValue(raw: string | undefined, type: ConfigRequiredPayload['type']): unknown {
+  // clack returns undefined when the user cancels (Ctrl+C). Bubble
+  // that up as an error so validate sees it and the responder can
+  // skip the reply rather than emit a malformed one.
+  if (raw === undefined) {
+    throw new Error('Cancelled');
+  }
   switch (type) {
     case 'string':
       return raw;