@celilo/cli 0.3.19 → 0.3.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

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

@@ -28,7 +28,16 @@ import { log } from '../prompts';
 import type { CommandResult } from '../types';
 
 type UpgradeOutcome =
-  | { status: 'success'; moduleId: string }
+  | {
+      status: 'success';
+      moduleId: string;
+      /** Version that was on disk before the upgrade (manifest.yml semver). */
+      previousVersion: string;
+      /** Version that's now installed. Includes +N revision when known
+       *  (registry-driven upgrades pass the canonical "1.0.0+5" form;
+       *  path-driven upgrades fall back to the manifest semver). */
+      newVersion: string;
+    }
   | { status: 'failed'; moduleId: string; error: string }
   // `skipped` means the path expanded from a glob but isn't an
   // upgradable target — either no manifest at all (probably a non-
@@ -37,6 +46,18 @@ type UpgradeOutcome =
   // `celilo module update modules/*` does what users expect.
   | { status: 'skipped'; moduleId: string; reason: string };
 
+/**
+ * Tunables for `upgradeOne`. Quiet mode silences the per-call log
+ * lines so callers driving a batch (the registry sweep) can render
+ * their own structured output without duplicates. `displayVersion`
+ * lets the registry caller carry the canonical `+N` revision through
+ * to both the DB column and the success log.
+ */
+interface UpgradeOpts {
+  quiet?: boolean;
+  displayVersion?: string;
+}
+
 /**
  * Parse a celilo version string into [major, minor, patch, revision].
  * Celilo's published versions look like `1.0.0+3` — semver core plus a
@@ -108,7 +129,18 @@ async function fetchAndUpgrade(
   try {
     // Registry packages are pre-verified at publish time; skip the
     // signature check here to match `module import`'s registry path.
-    return await upgradeOne(tmpPath, db, { ...flags, 'skip-verify': true });
+    // `quiet: true` suppresses upgradeOne's per-call log lines so the
+    // sweep can render its own structured per-module output without
+    // duplicates. `displayVersion: version` carries the registry's
+    // canonical "X.Y.Z+N" through to both the DB column and the success
+    // log line — without it, output would say "v1.0.0 → v1.0.0" because
+    // the manifest semver doesn't include the +N revision.
+    return await upgradeOne(
+      tmpPath,
+      db,
+      { ...flags, 'skip-verify': true },
+      { quiet: true, displayVersion: version },
+    );
   } finally {
     try {
       await unlink(tmpPath);
@@ -123,6 +155,7 @@ async function upgradeOne(
   sourcePath: string,
   db: ReturnType<typeof getDb>,
   flags: Record<string, string | boolean> = {},
+  opts: UpgradeOpts = {},
 ): Promise<UpgradeOutcome> {
   const originalCwd = process.env.CELILO_ORIGINAL_CWD || process.cwd();
   const importPath = resolve(originalCwd, sourcePath);
@@ -162,7 +195,7 @@ async function upgradeOne(
           error: verifyResult.error || 'Package verification failed',
         };
       }
-    } else {
+    } else if (!opts.quiet) {
       log.warn('Skipping package signature verification (--skip-verify)');
     }
   }
@@ -207,8 +240,17 @@ async function upgradeOne(
     };
   }
 
-  const oldManifest = module.manifestData as ModuleManifest;
-  log.info(`Upgrading ${moduleId}: v${oldManifest.version} → v${newManifest.version}`);
+  // Old version comes from the DB so we capture whatever was last
+  // recorded (which IS the registry-versioned form, e.g. "1.0.0+5",
+  // for registry-driven installs/upgrades).
+  const previousVersion = module.version;
+  // New version: prefer the caller-supplied display version (registry's
+  // canonical "X.Y.Z+N"), fall back to the manifest semver core when
+  // upgrading from a local path.
+  const newVersion = opts.displayVersion ?? newManifest.version;
+  if (!opts.quiet) {
+    log.info(`Upgrading ${moduleId}: ${previousVersion} → ${newVersion}`);
+  }
 
   // Copy new module files, preserving generated output and state
   const installedPath = module.sourcePath;
@@ -226,11 +268,13 @@ async function upgradeOne(
   // Clean up temp dir if we extracted a .netapp
   if (tempDir) await cleanupTempDir(tempDir);
 
-  // Update manifest in database
+  // Update manifest in database. We persist the display version (with
+  // +N when known) so subsequent `module list` / `module update` calls
+  // see the same version string the registry reported.
   db.update(modules)
     .set({
       manifestData: newManifest as unknown as Record<string, unknown>,
-      version: newManifest.version,
+      version: newVersion,
       name: newManifest.name,
     })
     .where(eq(modules.id, moduleId))
@@ -241,13 +285,18 @@ async function upgradeOne(
 
   if (newManifest.provides?.capabilities && newManifest.provides.capabilities.length > 0) {
     const regResult = await registerModuleCapabilities(moduleId, newManifest, db.$client);
-    if (!regResult.success) {
+    if (!regResult.success && !opts.quiet) {
+      // Capability re-registration warnings are useful when upgrading
+      // from a path (operator iterating on dev module); for the
+      // registry sweep, the caller will surface them itself if needed.
       log.warn(`  ${moduleId}: capability re-registration warning: ${regResult.error}`);
     }
   }
 
-  log.success(`Upgraded ${moduleId} (v${oldManifest.version} → v${newManifest.version})`);
-  return { status: 'success', moduleId };
+  if (!opts.quiet) {
+    log.success(`Upgraded ${moduleId} (${previousVersion} → ${newVersion})`);
+  }
+  return { status: 'success', moduleId, previousVersion, newVersion };
 }
 
 /**
@@ -411,17 +460,18 @@ async function runRegistrySweep(
 
   if (nonBreaking.length > 0) {
     log.info(`Auto-applying ${nonBreaking.length} non-breaking update(s):`);
-    for (const plan of nonBreaking) {
-      console.log(
-        `  ↑ ${plan.moduleId.padEnd(30)} ${plan.installedVersion} → ${plan.targetVersion}  (${plan.classification})`,
-      );
-    }
     for (const plan of nonBreaking) {
       const result = await fetchAndUpgrade(client, plan.moduleId, plan.targetVersion, db, flags);
       if (result.status === 'failed') {
         failed.push({ moduleId: plan.moduleId, error: result.error });
+        console.log(
+          `  ✗ ${plan.moduleId.padEnd(30)} ${plan.installedVersion} → ${plan.targetVersion}  (${plan.classification}, FAILED)`,
+        );
       } else if (result.status === 'success') {
         appliedNonBreaking++;
+        console.log(
+          `  ✓ ${plan.moduleId.padEnd(30)} ${result.previousVersion} → ${result.newVersion}  (${plan.classification})`,
+        );
       }
       // status === 'skipped' shouldn't happen for registry-fetched packages
       // (we know the module is installed; the package definitely has a
@@ -453,8 +503,14 @@ async function runRegistrySweep(
       const result = await fetchAndUpgrade(client, plan.moduleId, plan.targetVersion, db, flags);
       if (result.status === 'failed') {
         failed.push({ moduleId: plan.moduleId, error: result.error });
+        console.log(
+          `  ✗ ${plan.moduleId.padEnd(30)} ${plan.installedVersion} → ${plan.targetVersion}  (major, FAILED)`,
+        );
       } else if (result.status === 'success') {
         appliedBreaking++;
+        console.log(
+          `  ✓ ${plan.moduleId.padEnd(30)} ${result.previousVersion} → ${result.newVersion}  (major)`,
+        );
       }
     }
   }

package/src/services/deploy-validation.ts

@@ -29,6 +29,9 @@ export interface ValidationResult {
     options?: Array<{ value: string; label: string; hint?: string }>;
     per_selection?: { key_pattern: string; prompt: string; type?: string; derive_from?: string };
     generate?: { method: string; length: number; encoding: string };
+    /** For `type: string-map` only — labels shown in the add-loop prompt. */
+    key_label?: string;
+    value_label?: string;
   }>;
 }
 
@@ -383,6 +386,9 @@ async function findMissingRequiredVariables(
     type?: string;
     options?: Array<{ value: string; label: string; hint?: string }>;
     per_selection?: { key_pattern: string; prompt: string; type?: string; derive_from?: string };
+    generate?: { method: string; length: number; encoding: string };
+    key_label?: string;
+    value_label?: string;
   }>
 > {
   const missing: Array<{
@@ -394,6 +400,8 @@ async function findMissingRequiredVariables(
     options?: Array<{ value: string; label: string; hint?: string }>;
     per_selection?: { key_pattern: string; prompt: string; type?: string; derive_from?: string };
     generate?: { method: string; length: number; encoding: string };
+    key_label?: string;
+    value_label?: string;
   }> = [];
 
   // Check declared variables (user config, capability, system, infrastructure)
@@ -460,6 +468,12 @@ async function findMissingRequiredVariables(
           source: 'secret',
           description: secret.description,
           generate: secret.generate,
+          // Pass through manifest-declared type + add-loop labels so the
+          // bus payload can drive the right responder UX (e.g. string-map
+          // gets the per-key add-loop instead of the JSON-blob prompt).
+          type: secret.type,
+          key_label: secret.key_label,
+          value_label: secret.value_label,
         });
       }
     }