@celilo/cli 1.6.0 → 1.7.0

package/src/variables/declarative-derivation.test.ts

@@ -691,7 +691,7 @@ describe('applyDeclarativeDerivations', () => {
       expect(context.selfConfig.primary_domain).toBeUndefined();
     });
 
-    test('skips non-string types (handled by config interview instead)', () => {
+    test('derives scalar numeric values from capability data', () => {
       const manifest: ModuleManifest = {
         celilo_contract: '1.0',
         id: 'test-module',
@@ -703,10 +703,10 @@ describe('applyDeclarativeDerivations', () => {
           owns: [
             {
               name: 'port',
-              type: 'number',
+              type: 'integer',
               required: false,
-              source: 'user',
-              derive_from: '$system:port',
+              source: 'capability',
+              derive_from: '$capability:dns_internal.dns.knot_port',
             },
           ],
           imports: [],
@@ -716,16 +716,55 @@ describe('applyDeclarativeDerivations', () => {
       const context: ResolutionContext = {
         moduleId: 'test-module',
         selfConfig: {},
-        systemConfig: { port: '8080' },
+        systemConfig: {},
         systemSecrets: {},
         secrets: {},
-        capabilities: {},
+        capabilities: {
+          dns_internal: { dns: { knot_port: 5353 } },
+        },
+      };
+
+      applyDeclarativeDerivations(manifest, context);
+
+      expect(context.selfConfig.port).toBe('5353');
+    });
+
+    test('continues to skip structured derivations', () => {
+      const manifest: ModuleManifest = {
+        celilo_contract: '1.0',
+        id: 'test-module',
+        name: 'Test Module',
+        version: '1.0.0',
+        requires: { capabilities: [] },
+        provides: { capabilities: [] },
+        variables: {
+          owns: [
+            {
+              name: 'domains',
+              type: 'array',
+              required: false,
+              source: 'capability',
+              derive_from: '$capability:dns_internal.dns.managed_domains',
+            },
+          ],
+          imports: [],
+        },
+      };
+
+      const context: ResolutionContext = {
+        moduleId: 'test-module',
+        selfConfig: {},
+        systemConfig: {},
+        systemSecrets: {},
+        secrets: {},
+        capabilities: {
+          dns_internal: { dns: { managed_domains: ['home.arpa'] } },
+        },
       };
 
       applyDeclarativeDerivations(manifest, context);
 
-      // Non-string variable is skipped — port remains unset
-      expect(context.selfConfig.port).toBeUndefined();
+      expect(context.selfConfig.domains).toBeUndefined();
     });
   });
 

package/src/variables/declarative-derivation.ts

@@ -186,10 +186,12 @@ export function applyDeclarativeDerivations(
       continue;
     }
 
-    // Declarative derivation only resolves string template expressions.
-    // Non-string types (arrays, objects) with derive_from are handled by
-    // the config interview system instead.
-    if (variable.type !== 'string') {
+    // Declarative derivation resolves scalar template expressions. Numeric and
+    // boolean values flow through this resolution context as their string form
+    // and recover their declared type at the module-config / inventory boundary.
+    // Structured arrays and objects still belong to the typed config path: a
+    // template substitution would collapse them to a lossy string.
+    if (variable.type === 'array' || variable.type === 'object') {
       continue;
     }
 

package/src/services/public-web-republish.test.ts

@@ -1,189 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { DbClient } from '../db/client';
-import { modules, webRoutes } from '../db/schema';
-import type { ModuleManifest } from '../manifest/schema';
-import { setupTestDatabase } from '../test-utils/setup-test-db';
-import { providesPublicWeb, republishStaticWebConsumers } from './public-web-republish';
-
-const caddyManifest = {
-  provides: { capabilities: [{ name: 'public_web', version: '3.0.0' }] },
-} as unknown as ModuleManifest;
-
-const plainManifest = { provides: { capabilities: [] } } as unknown as ModuleManifest;
-
-describe('republishStaticWebConsumers', () => {
-  let dir: string;
-  let db: DbClient;
-
-  function seedModule(id: string) {
-    db.insert(modules)
-      .values({ id, name: id, version: '1.0.0', manifestData: {}, sourcePath: `/tmp/${id}` })
-      .run();
-  }
-
-  function seedRoute(
-    moduleId: string,
-    slug: string,
-    path: string,
-    type: 'static' | 'reverse_proxy',
-  ) {
-    db.insert(webRoutes)
-      .values({
-        slug,
-        moduleId,
-        type,
-        path,
-        hostname: 'iamtheinternet.org',
-        targetHost: type === 'reverse_proxy' ? '10.0.20.5' : null,
-        targetPort: type === 'reverse_proxy' ? 8080 : null,
-      })
-      .run();
-  }
-
-  function recordingHook(failFor: string[] = []) {
-    const calls: string[] = [];
-    const runHook = (async (moduleId: string) => {
-      calls.push(moduleId);
-      return failFor.includes(moduleId)
-        ? { success: false, outputs: {}, error: 'boom', duration: 1 }
-        : { success: true, outputs: {}, duration: 1 };
-    }) as unknown as Parameters<typeof republishStaticWebConsumers>[0]['runHook'];
-    return { runHook, calls };
-  }
-
-  beforeEach(async () => {
-    dir = mkdtempSync(join(tmpdir(), 'pwr-'));
-    const dbPath = join(dir, 'celilo.db');
-    process.env.CELILO_DB_PATH = dbPath;
-    db = await setupTestDatabase(dbPath);
-  });
-
-  afterEach(() => {
-    db.$client.close();
-    process.env.CELILO_DB_PATH = undefined;
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  });
-
-  test('providesPublicWeb reads the manifest', () => {
-    expect(providesPublicWeb(caddyManifest)).toBe(true);
-    expect(providesPublicWeb(plainManifest)).toBe(false);
-  });
-
-  test('does not run for a module that is not a public_web provider', async () => {
-    seedModule('hello-foo');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'namecheap',
-      manifest: plainManifest,
-      db,
-      runHook,
-    });
-
-    expect(result).toEqual({ ran: false, republished: [], failures: [] });
-    expect(calls).toEqual([]);
-  });
-
-  test('re-runs on_install for every static consumer', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedModule('hello-bar');
-    seedModule('celilo-website');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-bar', 'bar', '/bar', 'static');
-    seedRoute('celilo-website', 'celilo-website', '/', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(result.ran).toBe(true);
-    expect(calls.sort()).toEqual(['celilo-website', 'hello-bar', 'hello-foo']);
-    expect(result.republished.sort()).toEqual(['celilo-website', 'hello-bar', 'hello-foo']);
-    expect(result.failures).toEqual([]);
-  });
-
-  test('skips reverse-proxy-only consumers (no assets on the provider host)', async () => {
-    seedModule('caddy');
-    seedModule('forgejo');
-    seedModule('hello-foo');
-    seedRoute('forgejo', 'git', '/git', 'reverse_proxy');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    const { runHook, calls } = recordingHook();
-
-    await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual(['hello-foo']);
-  });
-
-  test('never re-runs the provider itself', async () => {
-    seedModule('caddy');
-    // A provider that also owns a static route (a landing page of its own).
-    seedRoute('caddy', 'caddy', '/', 'static');
-    const { runHook, calls } = recordingHook();
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual([]);
-    expect(result.republished).toEqual([]);
-  });
-
-  test('de-duplicates a consumer that owns several static routes', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-foo', 'foo-docs', '/foo/docs', 'static');
-    const { runHook, calls } = recordingHook();
-
-    await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls).toEqual(['hello-foo']);
-  });
-
-  test('one consumer failing does not stop the others', async () => {
-    seedModule('caddy');
-    seedModule('hello-foo');
-    seedModule('hello-bar');
-    seedRoute('hello-foo', 'foo', '/foo', 'static');
-    seedRoute('hello-bar', 'bar', '/bar', 'static');
-    const { runHook, calls } = recordingHook(['hello-foo']);
-
-    const result = await republishStaticWebConsumers({
-      providerModuleId: 'caddy',
-      manifest: caddyManifest,
-      db,
-      runHook,
-    });
-
-    expect(calls.sort()).toEqual(['hello-bar', 'hello-foo']);
-    expect(result.republished).toEqual(['hello-bar']);
-    expect(result.failures).toEqual([{ moduleId: 'hello-foo', error: 'boom' }]);
-  });
-});

package/src/services/public-web-republish.ts

@@ -1,84 +0,0 @@
-/**
- * Restore consumer content after a public_web provider redeploy.
- *
- * A provider redeploy destroys the provider's host and rebuilds it, taking
- * `/srv/www` with it. The consumers' `web_routes` rows survive — they belong to
- * the consumer modules, not the provider — so the rebuilt provider renders
- * `root * /srv/www/<slug>` for directories that no longer exist and every
- * static site 404s. Nothing re-uploaded the assets; an operator had to redeploy
- * each consumer by hand and there was no signal telling them to.
- *
- * The fix is to do exactly what that operator did: after a provider deploy
- * lands, re-run `on_install` for every module holding a STATIC route.
- * `publishStaticSite` is idempotent (it upserts the route and re-tars the
- * source dir), so the re-run re-registers the route and refills the fresh
- * `/srv/www/<slug>`.
- *
- * Reverse-proxy consumers are skipped: they keep no state on the provider host,
- * so re-running them buys nothing and only widens the blast radius.
- *
- * ponytail: re-runs every static consumer unconditionally rather than probing
- * which /srv/www/<slug> directories are actually missing — O(static consumers)
- * per provider deploy, currently a handful. If a large fleet makes provider
- * deploys slow, probe the provider host first and re-run only the misses.
- */
-
-import { eq } from 'drizzle-orm';
-import type { DbClient } from '../db/client';
-import { webRoutes } from '../db/schema';
-import { createConsoleLogger } from '../hooks/logger';
-import { runNamedHook } from '../hooks/run-named-hook';
-import type { ModuleManifest } from '../manifest/schema';
-
-export interface RepublishFailure {
-  moduleId: string;
-  error: string;
-}
-
-export interface RepublishResult {
-  /** False when the deployed module isn't a public_web provider. */
-  ran: boolean;
-  /** Consumer modules whose on_install was re-run successfully. */
-  republished: string[];
-  failures: RepublishFailure[];
-}
-
-export function providesPublicWeb(manifest: ModuleManifest): boolean {
-  return (manifest.provides?.capabilities ?? []).some((c) => c.name === 'public_web');
-}
-
-export interface RepublishDeps {
-  providerModuleId: string;
-  manifest: ModuleManifest;
-  db: DbClient;
-  /** Injectable for tests. */
-  runHook?: typeof runNamedHook;
-}
-
-export async function republishStaticWebConsumers(deps: RepublishDeps): Promise<RepublishResult> {
-  const { providerModuleId, manifest, db, runHook = runNamedHook } = deps;
-
-  if (!providesPublicWeb(manifest)) {
-    return { ran: false, republished: [], failures: [] };
-  }
-
-  const staticRoutes = db.select().from(webRoutes).where(eq(webRoutes.type, 'static')).all();
-  const consumerIds = [
-    ...new Set(staticRoutes.map((r) => r.moduleId).filter((id) => id !== providerModuleId)),
-  ];
-
-  const republished: string[] = [];
-  const failures: RepublishFailure[] = [];
-
-  for (const moduleId of consumerIds) {
-    const logger = createConsoleLogger(moduleId, 'on_install');
-    const result = await runHook(moduleId, 'on_install', db, logger, {});
-    if (result.success) {
-      republished.push(moduleId);
-    } else {
-      failures.push({ moduleId, error: result.error ?? 'unknown error' });
-    }
-  }
-
-  return { ran: true, republished, failures };
-}