@celilo/cli 0.3.21 → 0.3.23

package/package.json

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

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

@@ -108,7 +108,7 @@ export function classifyVersionChange(installed: string, latest: string): Versio
  * the standard upgradeOne path against it. Cleans the temp file in a
  * finally block so a mid-flight failure doesn't leak a tar.zst on disk.
  */
-async function fetchAndUpgrade(
+export async function fetchAndUpgrade(
   client: RegistryClient,
   moduleId: string,
   version: string,

package/src/cli/commands/system-update.ts

@@ -15,6 +15,7 @@
  * lives in `services/update/orchestrator.ts`.
  */
 
+import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -38,6 +39,16 @@ import {
 import type { SystemUpdateResult } from '../../services/update/types';
 import { getFlag, hasFlag } from '../parser';
 import type { CommandResult } from '../types';
+import { fetchAndUpgrade } from './module-upgrade';
+
+/**
+ * Packages we manage via the global bun install. The self-update step
+ * runs `bun update -g` against all of these in one shot, so operators
+ * never have to remember the three-package incantation.
+ *
+ * Ordering matters cosmetically only — bun resolves them all together.
+ */
+const MANAGED_PACKAGES = ['@celilo/cli', '@celilo/event-bus', '@celilo/e2e'] as const;
 
 function readInstalledCliVersion(): string {
   const here = dirname(fileURLToPath(import.meta.url));
@@ -141,16 +152,14 @@ async function buildSnapshots(
  *
  * - `backup` calls `createModuleBackup`. Modules without an
  *   `on_backup` hook return ok (nothing to back up; not an error).
- * - `upgrade` is a no-op for now — the in-place upgrade path lives
- *   in `module import <name>` and needs a refactor before the
- *   orchestrator can drive it cleanly. Deploy will re-converge
- *   against whatever's installed, which is the right behavior for
- *   "redeploy what's there."
+ * - `upgrade` fetches the latest version from the registry and runs
+ *   the in-place upgrade (`fetchAndUpgrade` from module-upgrade.ts).
+ *   Same code path that `module update` uses for its sweep mode.
  * - `deploy` calls `deployModule`.
  * - `health` calls `runModuleHealthCheck`.
  * - `snapshotCeliloDb` calls `createSystemStateBackup`.
  */
-function buildOps(): OrchestratorOps {
+function buildOps(registry: RegistryClient): OrchestratorOps {
   return {
     backup: async (moduleId, _updateId) => {
       const db = getDb();
@@ -163,7 +172,35 @@ function buildOps(): OrchestratorOps {
       const result = await createModuleBackup(moduleId);
       return result.success ? { ok: true } : { ok: false, error: result.error };
     },
-    upgrade: async (_id) => ({ ok: true }),
+    // Fetch the latest version from the registry and run the in-place
+    // upgrade (file-copy + DB update + capability re-register, preserving
+    // configs/secrets/infra). Reuses the same path `module update` runs
+    // for its sweep mode, so behavior is consistent regardless of which
+    // entry point the operator uses.
+    upgrade: async (moduleId) => {
+      const db = getDb();
+      try {
+        const entries = await registry.getIndex(moduleId);
+        if (entries.length === 0) {
+          return { ok: false, error: `${moduleId}: not in registry` };
+        }
+        const latest = registry.latestVersion(entries);
+        if (!latest) {
+          return { ok: false, error: `${moduleId}: no non-yanked version` };
+        }
+        const result = await fetchAndUpgrade(registry, moduleId, latest.vers, db, {});
+        if (result.status === 'success') return { ok: true };
+        if (result.status === 'failed') return { ok: false, error: result.error };
+        // 'skipped' isn't expected here (the module IS installed), but
+        // surface it as a non-fatal so the orchestrator can decide.
+        return { ok: false, error: `unexpected skip: ${result.reason}` };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    },
     deploy: async (id) => {
       const db = getDb();
       // The deploy interview runs through the bus; if config is
@@ -181,8 +218,23 @@ function buildOps(): OrchestratorOps {
       return { status: r.status, detail: r.error };
     },
     snapshotCeliloDb: async (_updateId) => {
-      const result = await createSystemStateBackup();
-      return result.success ? { ok: true } : { ok: false, error: result.error };
+      // resolveStorage throws when no default backup storage is configured
+      // (or it isn't verified). Catch here so the orchestrator gets a
+      // clean { ok: false, error } shape — the alternative is the throw
+      // escapes runSystemUpdate and surfaces as an unhandled stack trace.
+      // The handleSystemUpdate pre-flight already catches the common
+      // "no storage configured" case with a friendly message; this is
+      // a belt-and-suspenders for any other throw path resolveStorage
+      // takes (e.g. storage exists but isn't verified).
+      try {
+        const result = await createSystemStateBackup();
+        return result.success ? { ok: true } : { ok: false, error: result.error };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
     },
   };
 }
@@ -357,7 +409,50 @@ export async function handleSystemUpdate(
         };
   }
 
-  const ops = buildOps();
+  // Decide whether the celilo-db snapshot is even needed for this run.
+  // If nothing's changing at the module level, there's nothing to roll
+  // back to — taking a snapshot would be pointless work, and on a fresh
+  // box (no storage configured yet) it would actively fail. Treat the
+  // "nothing-to-update" case as implicit --no-backup.
+  const hasModuleUpdates = [...snapshots.values()].some(
+    (s) => s.latestVersion && s.latestVersion !== s.installedVersion,
+  );
+  const effectiveNoBackup = noBackup || !hasModuleUpdates;
+
+  // Pre-flight the storage check so a missing default doesn't reach the
+  // orchestrator's snapshot hook (where the throw would surface as a
+  // hostile stack trace). Skip when we're already not going to backup.
+  if (!effectiveNoBackup) {
+    const { getDefaultBackupStorage } = await import('../../services/backup-storage');
+    const storage = getDefaultBackupStorage();
+    if (!storage) {
+      return {
+        success: false,
+        error: `No default backup storage configured.
+
+celilo system update snapshots the celilo DB before applying module
+updates as a safety net. Configure backup storage first:
+
+  celilo storage add local
+
+Or skip the safety net entirely (the CLI self-update still runs):
+
+  celilo system update --no-backup`,
+      };
+    }
+    if (!storage.verified) {
+      return {
+        success: false,
+        error: `Default backup storage '${storage.storageId}' is not verified.
+
+Run:  celilo storage verify ${storage.storageId}
+
+Then re-run system update.`,
+      };
+    }
+  }
+
+  const ops = buildOps(registry);
 
   const result = await runSystemUpdate({
     audit: auditDeps,
@@ -367,13 +462,26 @@ export async function handleSystemUpdate(
     selfUpdate: {
       installedVersion: readInstalledCliVersion(),
       fetcher: fetchLatestCliVersion,
-      updater: async () => ({
-        ok: false,
-        stderr: 'self-update wiring lands in Phase 5',
-      }),
+      // Refresh ALL managed @celilo/* packages in one bun-update call.
+      // The orchestrator only tracks @celilo/cli's from/to versions,
+      // but we sweep event-bus and e2e along with it so operators
+      // don't have to type the three-package incantation themselves.
+      // Failures from `bun update` propagate as stderr; the orchestrator
+      // surfaces them in the run summary.
+      updater: async () => {
+        const r = spawnSync('bun', ['update', '-g', ...MANAGED_PACKAGES], {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          encoding: 'utf-8',
+        });
+        if (r.status === 0) return { ok: true, stderr: '' };
+        return {
+          ok: false,
+          stderr: (r.stderr ?? '').trim() || `bun update -g exited ${r.status}`,
+        };
+      },
     },
     progress: { emit() {} },
-    noBackup,
+    noBackup: effectiveNoBackup,
     allowDestructive,
     onlyModule,
   });