@celilo/cli 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1024.0",
-    "@celilo/capabilities": "^0.4.2",
+    "@celilo/capabilities": "^0.5.0",
     "@celilo/cli-display": "^0.1.9",
     "@celilo/event-bus": "^0.1.7",
     "@clack/prompts": "^1.1.0",

package/src/cli/command-registry.ts

@@ -435,6 +435,25 @@ export const COMMANDS: CommandDef[] = [
           },
         ],
       },
+      {
+        name: 'upgrade',
+        description:
+          'Upgrade a module to its latest registry version: update → backup (posture-gated) → deploy → verify. No id = the CD poll: upgrade every auto_upgrade module with a newer version.',
+        args: [
+          {
+            name: 'id',
+            description: 'Module ID (omit to poll all auto_upgrade modules)',
+            completion: 'module_ids',
+          },
+        ],
+        flags: [
+          {
+            name: 'registry',
+            description: 'Registry URL (defaults to configured registry)',
+            takesValue: true,
+          },
+        ],
+      },
       {
         name: 'verify',
         description: 'Verify module integrity (signature + checksums)',

package/src/cli/commands/module-update.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Unit tests for the version-change classifier used by `module update`'s
+ * registry-sweep mode, plus integration tests for `updateOne`'s
+ * `displayVersion` / `quiet` opts that drive the cleaner sweep output.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { eq } from 'drizzle-orm';
+import { type DbClient, getDb } from '../../db/client';
+import { modules } from '../../db/schema';
+import { classifyVersionChange, updateOne } from './module-update';
+
+describe('classifyVersionChange', () => {
+  test('identical versions are up-to-date', () => {
+    expect(classifyVersionChange('1.0.0', '1.0.0')).toBe('up-to-date');
+    expect(classifyVersionChange('1.0.0+3', '1.0.0+3')).toBe('up-to-date');
+    expect(classifyVersionChange('2.4.7+5', '2.4.7+5')).toBe('up-to-date');
+  });
+
+  test('major bump → breaking', () => {
+    expect(classifyVersionChange('1.0.0+3', '2.0.0+1')).toBe('major');
+    expect(classifyVersionChange('1.5.9', '2.0.0')).toBe('major');
+    // Even a tiny step into the next major counts as breaking; the
+    // operator decides whether to take it.
+    expect(classifyVersionChange('1.0.0+9', '2.0.0+0')).toBe('major');
+  });
+
+  test('minor bump → non-breaking', () => {
+    expect(classifyVersionChange('1.0.0+3', '1.1.0+1')).toBe('minor');
+    expect(classifyVersionChange('2.5.0', '2.6.0')).toBe('minor');
+  });
+
+  test('patch bump → non-breaking', () => {
+    expect(classifyVersionChange('1.0.0+3', '1.0.1+1')).toBe('patch');
+    expect(classifyVersionChange('2.5.7', '2.5.8')).toBe('patch');
+  });
+
+  test('revision-only bump (+N) → patch (non-breaking)', () => {
+    // Exact case the user is hitting today: same code, fresh publish.
+    expect(classifyVersionChange('1.0.0+3', '1.0.0+4')).toBe('patch');
+    expect(classifyVersionChange('namecheap-1.0.0', 'namecheap-1.0.0+5')).not.toBe('major');
+    expect(classifyVersionChange('3.1.0+0', '3.1.0+9')).toBe('patch');
+  });
+
+  test('installed ahead of registry → ahead (skip silently)', () => {
+    // Operator pushed locally without publishing — registry is stale.
+    expect(classifyVersionChange('2.0.0+1', '1.5.0+9')).toBe('ahead');
+    expect(classifyVersionChange('1.0.1', '1.0.0')).toBe('ahead');
+    expect(classifyVersionChange('1.0.0+5', '1.0.0+3')).toBe('ahead');
+  });
+
+  test('tolerates `v` / `=` prefixes', () => {
+    expect(classifyVersionChange('v1.0.0+3', 'v1.0.0+4')).toBe('patch');
+    expect(classifyVersionChange('=1.0.0', '=1.1.0')).toBe('minor');
+  });
+
+  test('missing patch / revision segments default to 0', () => {
+    expect(classifyVersionChange('1.0', '1.0.1')).toBe('patch');
+    expect(classifyVersionChange('1.0', '2.0')).toBe('major');
+    expect(classifyVersionChange('1.0.0', '1.0.0+1')).toBe('patch');
+  });
+});
+
+describe('updateOne — displayVersion and quiet', () => {
+  let tempDir: string;
+  let srcDir: string;
+  let installedDir: string;
+  let db: DbClient;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'celilo-upgrade-'));
+    process.env.CELILO_DB_PATH = join(tempDir, 'test.db');
+    process.env.CELILO_ORIGINAL_CWD = tempDir;
+
+    // Pre-installed module landing zone (where files get copied to).
+    installedDir = join(tempDir, 'installed', 'testmod');
+    mkdirSync(installedDir, { recursive: true });
+
+    // "New" source dir we're upgrading from (mimics a registry extract).
+    srcDir = join(tempDir, 'src');
+    mkdirSync(srcDir, { recursive: true });
+    writeFileSync(
+      join(srcDir, 'manifest.yml'),
+      `celilo_contract: "1.0"
+id: testmod
+name: Test Module
+version: 1.0.0
+description: fixture
+`,
+    );
+
+    db = getDb();
+    // Seed the modules table with the "currently installed" record.
+    // We deliberately put a registry-style version string in here so
+    // displayVersion-less upgrades preserve the previousVersion field.
+    db.insert(modules)
+      .values({
+        id: 'testmod',
+        name: 'Test Module',
+        sourcePath: installedDir,
+        version: '1.0.0+5',
+        manifestData: {
+          celilo_contract: '1.0',
+          id: 'testmod',
+          name: 'Test Module',
+          version: '1.0.0',
+        },
+      })
+      .run();
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    process.env.CELILO_DB_PATH = undefined;
+    process.env.CELILO_ORIGINAL_CWD = undefined;
+  });
+
+  test('returns previousVersion + newVersion in the success outcome', async () => {
+    const result = await updateOne(srcDir, db, {}, { quiet: true });
+    expect(result.status).toBe('success');
+    if (result.status !== 'success') return; // narrow for ts
+    expect(result.moduleId).toBe('testmod');
+    expect(result.previousVersion).toBe('1.0.0+5');
+    // No displayVersion supplied → falls back to the new manifest's
+    // semver core (no +N visible to the operator from a path upgrade).
+    expect(result.newVersion).toBe('1.0.0');
+  });
+
+  test('displayVersion is persisted to modules.version (so +N survives)', async () => {
+    // The bug case: registry says 1.0.0+6, manifest says 1.0.0. Without
+    // displayVersion, the +6 was dropped on the floor and `module list`
+    // rolled back to "1.0.0", masking the actual installed revision.
+    const result = await updateOne(srcDir, db, {}, { quiet: true, displayVersion: '1.0.0+6' });
+    expect(result.status).toBe('success');
+    if (result.status !== 'success') return;
+    expect(result.newVersion).toBe('1.0.0+6');
+
+    const row = db.select().from(modules).all()[0];
+    expect(row.version).toBe('1.0.0+6');
+  });
+
+  test('quiet=true suppresses the per-call log lines (caller renders its own)', async () => {
+    // We can't easily intercept @clack's log output without adding test
+    // hooks, so instead we exercise that the call simply succeeds and
+    // returns the structured outcome — the sweep relies on this to
+    // render its own output without duplicates. A non-quiet call
+    // exercises the same code path with the log lines enabled; both
+    // return the same shape.
+    const quietResult = await updateOne(srcDir, db, {}, { quiet: true });
+    expect(quietResult.status).toBe('success');
+    if (quietResult.status !== 'success') return;
+    expect(quietResult.newVersion).toBe('1.0.0');
+  });
+
+  // Regression for the namecheap stale-findings problem: the upgrade
+  // path MUST overwrite manifestData with the new manifest — otherwise
+  // any subsequent audit (or any code path that reads from the DB)
+  // sees the OLD manifest's required vars even after the operator
+  // upgraded to a version that removed them. The user hit this on
+  // celilo-mgmt: namecheap@3.1.1+6 dropped the `domains` variable, but
+  // post-upgrade the audit still complained "required config 'domains'
+  // is not set" because the DB's manifestData hadn't been refreshed.
+  test('persists new manifest to modules.manifestData (not just .version)', async () => {
+    // Write a brand-new manifest.yml in srcDir that REMOVES a
+    // variable the old DB record had. After upgrade, the modules
+    // row's manifestData should reflect the removal.
+    writeFileSync(
+      join(srcDir, 'manifest.yml'),
+      `celilo_contract: "1.0"
+id: testmod
+name: Test Module Renamed
+version: 2.0.0
+description: fixture v2
+variables:
+  owns: []
+  imports: []
+`,
+    );
+    // Simulate the DB starting in a state where manifestData has a
+    // `variables.owns` array — the namecheap-3.1.0 → 3.1.1 case.
+    db.update(modules)
+      .set({
+        manifestData: {
+          celilo_contract: '1.0',
+          id: 'testmod',
+          name: 'Test Module',
+          version: '1.0.0',
+          variables: { owns: [{ name: 'domains', type: 'array', required: true }], imports: [] },
+        },
+      })
+      .where(eq(modules.id, 'testmod'))
+      .run();
+
+    const result = await updateOne(srcDir, db, {}, { quiet: true, displayVersion: '2.0.0+1' });
+    expect(result.status).toBe('success');
+
+    const row = db.select().from(modules).all()[0];
+    // version field updates (this part already worked):
+    expect(row.version).toBe('2.0.0+1');
+    expect(row.name).toBe('Test Module Renamed');
+    // manifestData reflects the NEW manifest — the dropped variable
+    // is gone. This is the regression assertion.
+    const manifest = row.manifestData as {
+      version: string;
+      name: string;
+      variables?: { owns: unknown[] };
+    };
+    expect(manifest.version).toBe('2.0.0');
+    expect(manifest.name).toBe('Test Module Renamed');
+    expect(manifest.variables?.owns ?? []).toEqual([]);
+  });
+
+  // Regression for ISS-0091: `module update` used to skip event-bus
+  // subscription registration (only `module import` did it), so a
+  // refreshed module silently lost its reconcile subscriptions — found
+  // live when caddy's reconcile_routes subscription vanished after a
+  // path-based update.
+  test('registers the new manifest subscriptions on the bus (ISS-0091)', async () => {
+    process.env.EVENT_BUS_DB = join(tempDir, 'events.db');
+    try {
+      writeFileSync(
+        join(srcDir, 'manifest.yml'),
+        `celilo_contract: "1.0"
+id: testmod
+name: Test Module
+version: 1.1.0
+description: fixture with subscriptions
+subscriptions:
+  - name: testmod-tick
+    pattern: timer.tick.15m
+    handler: "true"
+`,
+      );
+      const result = await updateOne(srcDir, db, {}, { quiet: true });
+      expect(result.status).toBe('success');
+
+      const { openBus, defineEvents } = await import('@celilo/event-bus');
+      const bus = openBus({ dbPath: join(tempDir, 'events.db'), events: defineEvents({}) });
+      try {
+        // Subscriber names are scoped `<module-id>.<sub-name>` on the bus.
+        expect(bus.getSubscriberByName('testmod.testmod-tick')).not.toBeNull();
+      } finally {
+        bus.close();
+      }
+    } finally {
+      process.env.EVENT_BUS_DB = undefined;
+    }
+  });
+});