@celilo/cli 0.5.0 → 0.6.0

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

@@ -41,7 +41,7 @@ import {
 import type { SystemUpdateResult } from '../../services/update/types';
 import { getFlag, hasFlag } from '../parser';
 import type { CommandResult } from '../types';
-import { fetchAndUpgrade } from './module-upgrade';
+import { fetchAndUpdate } from './module-update';
 
 /**
  * Packages we manage via the global bun install. The self-update step
@@ -275,7 +275,7 @@ async function buildSnapshots(
  * - `backup` calls `createModuleBackup`. Modules without an
  *   `on_backup` hook return ok (nothing to back up; not an error).
  * - `upgrade` fetches the latest version from the registry and runs
- *   the in-place upgrade (`fetchAndUpgrade` from module-upgrade.ts).
+ *   the in-place upgrade (`fetchAndUpdate` from module-upgrade.ts).
  *   Same code path that `module update` uses for its sweep mode.
  * - `deploy` calls `deployModule`.
  * - `health` calls `runModuleHealthCheck`.
@@ -314,7 +314,7 @@ function buildOps(registry: RegistryClient, wasDeployed: Set<string>): Orchestra
         if (!latest) {
           return { ok: false, error: `${moduleId}: no non-yanked version` };
         }
-        const result = await fetchAndUpgrade(registry, moduleId, latest.vers, db, {});
+        const result = await fetchAndUpdate(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

package/src/cli/completion.ts

@@ -141,6 +141,7 @@ export async function getCompletions(words: string[], current: number): Promise<
       'remove',
       'search',
       'update',
+      'upgrade',
       'verify',
       'audit',
       'backup',

package/src/cli/index.ts

@@ -63,6 +63,7 @@ import { handleModuleShowConfig, handleModuleShowZone } from './commands/module-
 import { handleModuleStatus } from './commands/module-status';
 import { handleModuleTerraformUnlock } from './commands/module-terraform-unlock';
 import { handleModuleTypesCheck, handleModuleTypesGenerate } from './commands/module-types';
+import { handleModuleUpdate } from './commands/module-update';
 import { handleModuleUpgrade } from './commands/module-upgrade';
 import { moduleVerify } from './commands/module-verify';
 import { handlePackage } from './commands/package';
@@ -1266,6 +1267,8 @@ export async function runCli(argv: string[]): Promise<CommandResult> {
       case 'remove':
         return handleModuleRemove(parsed.args, parsed.flags);
       case 'update':
+        return handleModuleUpdate(parsed.args, parsed.flags);
+      case 'upgrade':
         return handleModuleUpgrade(parsed.args, parsed.flags);
       case 'audit':
         return moduleAudit(parsed.args);

package/src/hooks/capability-loader.ts

@@ -63,9 +63,13 @@ const CAPABILITY_MODULE_MAP: Record<string, { script: string; legacyFactoryName:
     script: 'scripts/idp-functions.ts',
     legacyFactoryName: 'createIdp',
   },
-  git_forge: {
-    script: 'scripts/git-forge-functions.ts',
-    legacyFactoryName: 'createForgejoGitForge',
+  source_forge: {
+    script: 'scripts/source-forge-functions.ts',
+    legacyFactoryName: 'createForgejoSourceForge',
+  },
+  registry_publish: {
+    script: 'scripts/registry-publish-functions.ts',
+    legacyFactoryName: 'default',
   },
   dhcp_server: {
     script: 'scripts/dhcp-server-functions.ts',

package/src/manifest/schema.ts

@@ -237,7 +237,9 @@ export type ComputedField = z.infer<typeof ComputedFieldSchema>;
 export const CapabilityProviderSchema = z.object({
   name: z.string().min(1),
   version: z.string().min(1),
-  data: z.record(z.unknown()),
+  // A purely imperative capability (functions-only, no cross-module data —
+  // e.g. registry_publish) carries no `data` block; default to {}.
+  data: z.record(z.unknown()).default({}),
   /**
    * Computed fields, merged into the capability's data namespace at access
    * time. A consumer reads `$capability:<name>.<computed-field>` exactly like

package/src/services/deploy-posture.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from 'bun:test';
+import { classifyVersionDelta, parseVersion, resolveDeployPosture } from './deploy-posture';
+
+describe('parseVersion', () => {
+  test('parses major.minor.patch+build', () => {
+    expect(parseVersion('1.2.3+28')).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      prerelease: '',
+      build: '28',
+    });
+  });
+
+  test('parses a prerelease', () => {
+    expect(parseVersion('0.5.0-alpha.9')).toEqual({
+      major: 0,
+      minor: 5,
+      patch: 0,
+      prerelease: 'alpha.9',
+      build: '',
+    });
+  });
+
+  test('tolerates a bare version', () => {
+    expect(parseVersion('2.0.0')).toEqual({
+      major: 2,
+      minor: 0,
+      patch: 0,
+      prerelease: '',
+      build: '',
+    });
+  });
+});
+
+describe('classifyVersionDelta (highest-order component that changed)', () => {
+  test('major / minor / patch', () => {
+    expect(classifyVersionDelta('1.0.0', '2.0.0')).toBe('major');
+    expect(classifyVersionDelta('1.0.0', '1.1.0')).toBe('minor');
+    expect(classifyVersionDelta('1.0.0', '1.0.1')).toBe('patch');
+  });
+
+  test('build-metadata-only change is a revision', () => {
+    expect(classifyVersionDelta('1.0.1+27', '1.0.1+28')).toBe('revision');
+  });
+
+  test('prerelease-only change counts as patch (still fast)', () => {
+    expect(classifyVersionDelta('0.5.0-alpha.8', '0.5.0-alpha.9')).toBe('patch');
+  });
+
+  test('identical versions → none', () => {
+    expect(classifyVersionDelta('1.0.1+28', '1.0.1+28')).toBe('none');
+  });
+
+  test('highest-order wins when several components differ', () => {
+    expect(classifyVersionDelta('1.0.1+5', '1.1.0+1')).toBe('minor');
+  });
+});
+
+describe('resolveDeployPosture (precedence)', () => {
+  test('default by-semver: revision + patch ⇒ fast', () => {
+    expect(resolveDeployPosture({ installed: '1.0.1+1', next: '1.0.1+2' }).posture).toBe('fast');
+    expect(resolveDeployPosture({ installed: '1.0.1', next: '1.0.2' }).posture).toBe('fast');
+  });
+
+  test('default by-semver: minor + major ⇒ safe', () => {
+    expect(resolveDeployPosture({ installed: '1.0.0', next: '1.1.0' }).posture).toBe('safe');
+    expect(resolveDeployPosture({ installed: '1.0.0', next: '2.0.0' }).posture).toBe('safe');
+  });
+
+  test('per-release deploy_posture overrides the semver default', () => {
+    // a minor bump would default to safe; the release pins fast.
+    const r = resolveDeployPosture({ installed: '1.0.0', next: '1.1.0', releasePosture: 'fast' });
+    expect(r.posture).toBe('fast');
+    expect(r.reason).toContain('release deploy_posture');
+  });
+
+  test('module always-safe is a hard floor — beats a per-release fast', () => {
+    const r = resolveDeployPosture({
+      installed: '1.0.1',
+      next: '1.0.2',
+      releasePosture: 'fast',
+      modulePolicy: 'always-safe',
+    });
+    expect(r.posture).toBe('safe');
+    expect(r.reason).toContain('always-safe');
+  });
+
+  test('module always-fast forces fast on a minor bump (when no release override)', () => {
+    expect(
+      resolveDeployPosture({ installed: '1.0.0', next: '1.1.0', modulePolicy: 'always-fast' })
+        .posture,
+    ).toBe('fast');
+  });
+
+  test('a per-release safe still beats always-fast (release intent wins below the floor)', () => {
+    expect(
+      resolveDeployPosture({
+        installed: '1.0.1',
+        next: '1.0.2',
+        releasePosture: 'safe',
+        modulePolicy: 'always-fast',
+      }).posture,
+    ).toBe('safe');
+  });
+});

package/src/services/deploy-posture.ts

@@ -0,0 +1,87 @@
+/**
+ * Deploy posture — fast vs. safe — for `celilo module upgrade` (ISS-0138,
+ * v2/BUILD_BUS.md).
+ *
+ * CD is CI-driven, so no operator is present to pass `--no-backup`. The posture
+ * (fast = skip backup + extended verify; safe = backup + full verify) is
+ * DERIVED, with this precedence:
+ *   1. per-module `upgrade_policy: always-safe` — a hard floor (always safe).
+ *   2. per-release `deploy_posture` stamped in the .netapp release metadata.
+ *   3. per-module `upgrade_policy: always-fast`.
+ *   4. default: the semver delta of installed → next (revision/patch = fast;
+ *      minor/major = safe).
+ *
+ * celilo reads version NUMBERS, never changesets — the default needs only the
+ * versions. All functions here are pure (Rule 10).
+ */
+
+export type DeployPosture = 'fast' | 'safe';
+export type VersionDelta = 'none' | 'revision' | 'patch' | 'minor' | 'major';
+export type UpgradePolicy = 'by-semver' | 'always-safe' | 'always-fast';
+
+export interface ParsedVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  /** prerelease tag, e.g. "alpha.2"; '' when absent. */
+  prerelease: string;
+  /** build metadata — celilo's `+N` registry revision; '' when absent. */
+  build: string;
+}
+
+/** Parse a celilo module version: `major.minor.patch[-prerelease][+build]`. */
+export function parseVersion(version: string): ParsedVersion {
+  const [coreAndPre = '', build = ''] = version.split('+');
+  const [core = '', prerelease = ''] = coreAndPre.split('-');
+  const parts = core.split('.');
+  const num = (i: number) => Number.parseInt(parts[i] ?? '', 10) || 0;
+  return { major: num(0), minor: num(1), patch: num(2), prerelease, build };
+}
+
+/**
+ * Classify the delta between an installed version and the next one by the
+ * highest-order component that changed. Assumes `next` >= `installed` (the poll
+ * only upgrades). A prerelease-only change counts as `patch` (still fast); a
+ * build-metadata-only change (`+N`) is `revision`.
+ */
+export function classifyVersionDelta(installed: string, next: string): VersionDelta {
+  const a = parseVersion(installed);
+  const b = parseVersion(next);
+  if (a.major !== b.major) return 'major';
+  if (a.minor !== b.minor) return 'minor';
+  if (a.patch !== b.patch) return 'patch';
+  if (a.prerelease !== b.prerelease) return 'patch';
+  if (a.build !== b.build) return 'revision';
+  return 'none';
+}
+
+/**
+ * Resolve the deploy posture for an upgrade. Precedence: `always-safe` floor →
+ * per-release override → `always-fast` → semver-delta default. Returns the
+ * posture plus a short reason for operator-visible logging.
+ */
+export function resolveDeployPosture(opts: {
+  installed: string;
+  next: string;
+  releasePosture?: DeployPosture | null;
+  modulePolicy?: UpgradePolicy;
+}): { posture: DeployPosture; reason: string } {
+  const policy = opts.modulePolicy ?? 'by-semver';
+
+  if (policy === 'always-safe') {
+    return { posture: 'safe', reason: 'module upgrade_policy=always-safe' };
+  }
+  if (opts.releasePosture) {
+    return {
+      posture: opts.releasePosture,
+      reason: `release deploy_posture=${opts.releasePosture}`,
+    };
+  }
+  if (policy === 'always-fast') {
+    return { posture: 'fast', reason: 'module upgrade_policy=always-fast' };
+  }
+
+  const delta = classifyVersionDelta(opts.installed, opts.next);
+  const posture: DeployPosture = delta === 'minor' || delta === 'major' ? 'safe' : 'fast';
+  return { posture, reason: `semver delta=${delta}` };
+}

package/src/services/module-subscriptions.test.ts

@@ -1,9 +1,12 @@
 import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { defineEvents, openBus } from '@celilo/event-bus';
+import { parse as parseYaml } from 'yaml';
 import { closeDb, getDb } from '../db/client';
+import { ModuleManifestSchema } from '../manifest/schema';
 import { ModuleSubscriptionSchema } from '../manifest/schema';
 import type { ModuleManifest } from '../manifest/schema';
 import { setupTestDatabase as migrateDbFile } from '../test-utils/setup-test-db';
@@ -341,3 +344,30 @@ describe('resyncAllSubscriptions (ISS-0088)', () => {
     expect(subscriberNames()).toEqual(['caddy.reconcile']);
   });
 });
+
+describe('build-bus registry-poll wiring (ISS-0139)', () => {
+  // The CD poll is wired as a celilo-mgmt manifest subscription so it registers
+  // ONLY on the management host. Guard the exact handler/pattern against drift.
+  const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
+
+  it('celilo-mgmt subscribes the registry poll to timer.tick.15m', () => {
+    const manifestPath = join(REPO_ROOT, 'modules', 'celilo-mgmt', 'manifest.yml');
+    const manifest = ModuleManifestSchema.parse(parseYaml(readFileSync(manifestPath, 'utf-8')));
+
+    const poll = manifest.subscriptions?.find((s) => s.name === 'registry-poll');
+    expect(poll).toBeDefined();
+    expect(poll?.pattern).toBe('timer.tick.15m');
+    // A literal handler command (the CLI poll), not a hook — see manifest comment.
+    expect(poll?.handler).toBe('celilo module upgrade');
+    expect(poll?.hook).toBeUndefined();
+
+    const resolved = resolveSubscription(
+      // biome-ignore lint/style/noNonNullAssertion: asserted defined above
+      poll!,
+      'celilo-mgmt',
+      '/modules/celilo-mgmt',
+    );
+    expect(resolved.name).toBe('celilo-mgmt.registry-poll');
+    expect(resolved.handler).toBe('celilo module upgrade');
+  });
+});