@celilo/cli 0.3.21 → 0.3.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "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
@@ -357,7 +394,7 @@ export async function handleSystemUpdate(
         };
   }
 
-  const ops = buildOps();
+  const ops = buildOps(registry);
 
   const result = await runSystemUpdate({
     audit: auditDeps,
@@ -367,10 +404,23 @@ 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,