@celilo/cli 2.2.1 → 3.0.0

package/src/services/build-bus/hook-dispatch.test.ts

@@ -1,18 +1,21 @@
 /**
- * Hook-dispatch tests. The planner is pure (no I/O); the runner
- * spawns bash. We test:
+ * Hook-dispatch tests. The planner is pure (no I/O); the runner goes
+ * through the ordinary hook executor (module-orchestrator-primitives
+ * slice 7). We test:
  *
- *   - planHookDispatch: rule matching, env construction, scriptPath
- *     resolution.
- *   - runHookDispatch: real bash spawn with a fixture script.
+ *   - planHookDispatch: rule matching (match logic unchanged since the
+ *     bash-spawn days).
+ *   - runUpstreamHook: routes a matched entry through runNamedHook with
+ *     the event as the `event` input and the matched entry's definition
+ *     (script + timeout). The seam under the mock is run-named-hook;
+ *     the real executor hop (child spawn, jail, context) is covered
+ *     end-to-end by hook-dispatch-executor.test.ts.
  */
 
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { describe, expect, mock, test } from 'bun:test';
 import type { PublishEvent } from '@celilo/event-bus/build-bus';
-import { type ModuleHookContext, planHookDispatch, runHookDispatch } from './hook-dispatch';
+import type { HookLogger } from '../../hooks/types';
+import { type HookDispatchPlan, planHookDispatch, runUpstreamHook } from './hook-dispatch';
 
 function buildEvent(overrides: Partial<PublishEvent> = {}): PublishEvent {
   return {
@@ -25,24 +28,31 @@ function buildEvent(overrides: Partial<PublishEvent> = {}): PublishEvent {
   };
 }
 
+const SILENT_LOGGER = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+} as unknown as HookLogger;
+
 describe('planHookDispatch', () => {
   test('empty module list → empty plan', () => {
     expect(planHookDispatch(buildEvent(), [])).toEqual([]);
   });
 
   test('module with no matching hooks → empty plan', () => {
-    const modules: ModuleHookContext[] = [
+    const modules = [
       {
         moduleId: 'lunacycle',
         sourcePath: '/modules/lunacycle',
-        hooks: [{ match: { registry: 'celilo-registry' }, script: './reload.sh' }],
+        hooks: [{ match: { registry: 'celilo-registry' }, script: './reload.ts' }],
       },
     ];
     expect(planHookDispatch(buildEvent({ registry: 'npm' }), modules)).toEqual([]);
   });
 
-  test('matching hook → plan with resolved scriptPath + env', () => {
-    const modules: ModuleHookContext[] = [
+  test('matching hook → plan for that module + entry', () => {
+    const modules = [
       {
         moduleId: 'lunacycle',
         sourcePath: '/modules/lunacycle',
@@ -50,36 +60,31 @@ describe('planHookDispatch', () => {
           {
             name: 'rerun-e2e',
             match: { registry: 'npm', package_pattern: '@celilo/*' },
-            script: './hooks/rerun.sh',
+            script: './hooks/rerun.ts',
           },
         ],
       },
     ];
     const plan = planHookDispatch(buildEvent(), modules);
     expect(plan).toHaveLength(1);
-    expect(plan[0].scriptPath).toBe('/modules/lunacycle/hooks/rerun.sh');
-    expect(plan[0].env.CELILO_EVENT_REGISTRY).toBe('npm');
-    expect(plan[0].env.CELILO_EVENT_TAG).toBe('latest');
-    expect(plan[0].env.CELILO_EVENT_PACKAGE_NAME).toBe('@celilo/cli');
-    expect(plan[0].env.CELILO_EVENT_PACKAGE_VERSION).toBe('0.4.0');
-    const payload = JSON.parse(plan[0].env.CELILO_EVENT_PAYLOAD) as PublishEvent;
-    expect(payload.package.name).toBe('@celilo/cli');
+    expect(plan[0].module.moduleId).toBe('lunacycle');
+    expect(plan[0].hook.script).toBe('./hooks/rerun.ts');
   });
 
   test('multiple modules + hooks → one plan entry per match', () => {
-    const modules: ModuleHookContext[] = [
+    const modules = [
       {
         moduleId: 'lunacycle',
         sourcePath: '/modules/lunacycle',
         hooks: [
-          { match: { registry: 'npm', package_pattern: '@celilo/cli' }, script: './a.sh' },
-          { match: { registry: 'npm', package_pattern: '@celilo/e2e' }, script: './b.sh' },
+          { match: { registry: 'npm', package_pattern: '@celilo/cli' }, script: './a.ts' },
+          { match: { registry: 'npm', package_pattern: '@celilo/e2e' }, script: './b.ts' },
         ],
       },
       {
         moduleId: 'mgmt',
         sourcePath: '/modules/mgmt',
-        hooks: [{ match: { registry: 'celilo-registry' }, script: './c.sh' }],
+        hooks: [{ match: { registry: 'celilo-registry' }, script: './c.ts' }],
       },
     ];
     const plan = planHookDispatch(
@@ -88,16 +93,16 @@ describe('planHookDispatch', () => {
     );
     expect(plan).toHaveLength(1);
     expect(plan[0].module.moduleId).toBe('lunacycle');
-    expect(plan[0].hook.script).toBe('./a.sh');
+    expect(plan[0].hook.script).toBe('./a.ts');
   });
 
   test('snake_case package_pattern in manifest maps to camelCase packagePattern in matcher', () => {
     // Documents the YAML↔JS naming bridge.
-    const modules: ModuleHookContext[] = [
+    const modules = [
       {
         moduleId: 'x',
         sourcePath: '/m',
-        hooks: [{ match: { package_pattern: '@celilo/*' }, script: './h.sh' }],
+        hooks: [{ match: { package_pattern: '@celilo/*' }, script: './h.ts' }],
       },
     ];
     expect(planHookDispatch(buildEvent(), modules)).toHaveLength(1);
@@ -107,101 +112,66 @@ describe('planHookDispatch', () => {
   });
 });
 
-describe('runHookDispatch', () => {
-  let scriptDir: string;
-
-  beforeEach(() => {
-    scriptDir = mkdtempSync(join(tmpdir(), 'celilo-hook-dispatch-'));
-  });
-
-  afterEach(() => {
-    rmSync(scriptDir, { recursive: true, force: true });
-  });
+describe('runUpstreamHook (routes through runNamedHook)', () => {
+  const calls: Array<{ moduleId: string; hookName: string; options: Record<string, unknown> }> = [];
 
-  function writeScript(name: string, body: string): string {
-    const path = join(scriptDir, name);
-    writeFileSync(path, body);
-    chmodSync(path, 0o755);
-    return path;
-  }
+  mock.module('../../hooks/run-named-hook', () => ({
+    runNamedHook: async (
+      moduleId: string,
+      hookName: string,
+      _db: unknown,
+      _logger: unknown,
+      options: Record<string, unknown>,
+    ) => {
+      calls.push({ moduleId, hookName, options });
+      return { success: true, outputs: {}, duration: 7 };
+    },
+  }));
 
-  test('runs a script and captures exit 0 + stdout', async () => {
-    const scriptPath = writeScript(
-      'h.sh',
-      '#!/bin/bash\necho "hello $CELILO_EVENT_PACKAGE_NAME"\n',
-    );
-    const result = await runHookDispatch({
-      module: { moduleId: 'm', sourcePath: scriptDir, hooks: [] },
-      hook: { match: {}, script: 'h.sh' },
-      scriptPath,
-      env: {
-        CELILO_EVENT_PAYLOAD: '{}',
-        CELILO_EVENT_REGISTRY: 'npm',
-        CELILO_EVENT_TAG: 'latest',
-        CELILO_EVENT_PACKAGE_NAME: '@celilo/cli',
-        CELILO_EVENT_PACKAGE_VERSION: '0.4.0',
-      },
+  test('passes the event as input and the matched entry as the hook definition', async () => {
+    calls.length = 0;
+    const plan: HookDispatchPlan = {
+      module: { moduleId: 'lunacycle', sourcePath: '/m', hooks: [] },
+      hook: { name: 'rerun-e2e', match: {}, script: './hooks/rerun.ts', timeout: 90_000 },
+    };
+    const event = buildEvent();
+    const result = await runUpstreamHook(plan, event, {
+      db: {} as Parameters<typeof runUpstreamHook>[2]['db'],
+      logger: SILENT_LOGGER,
     });
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout.trim()).toBe('hello @celilo/cli');
-    expect(result.timedOut).toBe(false);
-  });
 
-  test('captures non-zero exit + stderr', async () => {
-    const scriptPath = writeScript('fail.sh', '#!/bin/bash\necho "boom" >&2\nexit 17\n');
-    const result = await runHookDispatch({
-      module: { moduleId: 'm', sourcePath: scriptDir, hooks: [] },
-      hook: { match: {}, script: 'fail.sh' },
-      scriptPath,
-      env: {
-        CELILO_EVENT_PAYLOAD: '{}',
-        CELILO_EVENT_REGISTRY: 'npm',
-        CELILO_EVENT_TAG: 'latest',
-        CELILO_EVENT_PACKAGE_NAME: '@celilo/cli',
-        CELILO_EVENT_PACKAGE_VERSION: '0.4.0',
-      },
+    expect(result).toEqual({
+      module: 'lunacycle',
+      hookName: 'rerun-e2e',
+      success: true,
+      durationMs: expect.any(Number),
     });
-    expect(result.exitCode).toBe(17);
-    expect(result.stderr.trim()).toBe('boom');
+    expect(calls).toHaveLength(1);
+    expect(calls[0].moduleId).toBe('lunacycle');
+    expect(calls[0].hookName).toBe('on_upstream_publish');
+    expect(calls[0].options.inputs).toEqual({ event });
+    expect(calls[0].options.hookDefinition).toEqual({
+      script: './hooks/rerun.ts',
+      timeout: 90_000,
+    });
+    expect(calls[0].options.timeoutMs).toBe(90_000);
   });
 
-  test('respects timeout (kills the script and reports timedOut=true)', async () => {
-    const scriptPath = writeScript('slow.sh', '#!/bin/bash\nsleep 5\n');
-    const result = await runHookDispatch({
-      module: { moduleId: 'm', sourcePath: scriptDir, hooks: [] },
-      hook: { match: {}, script: 'slow.sh', timeout: 1 },
-      scriptPath,
-      env: {
-        CELILO_EVENT_PAYLOAD: '{}',
-        CELILO_EVENT_REGISTRY: 'npm',
-        CELILO_EVENT_TAG: 'latest',
-        CELILO_EVENT_PACKAGE_NAME: '@celilo/cli',
-        CELILO_EVENT_PACKAGE_VERSION: '0.4.0',
+  test('a runNamedHook throw becomes an unsuccessful result, not a rejection', async () => {
+    mock.module('../../hooks/run-named-hook', () => ({
+      runNamedHook: async () => {
+        throw new Error('boom');
       },
-    });
-    expect(result.timedOut).toBe(true);
-    // SIGTERM + 500ms grace → SIGKILL means the inner `sleep` should
-    // be reaped within ~2s of the 1-second timeout firing. Give a
-    // generous 4s ceiling so we're not flaky on slow CI hosts.
-    expect(result.durationMs).toBeLessThan(4000);
-  }, 10000);
-
-  test('records spawn error when the script does not exist', async () => {
-    const result = await runHookDispatch({
-      module: { moduleId: 'm', sourcePath: scriptDir, hooks: [] },
-      hook: { match: {}, script: 'does-not-exist.sh' },
-      scriptPath: join(scriptDir, 'does-not-exist.sh'),
-      env: {
-        CELILO_EVENT_PAYLOAD: '{}',
-        CELILO_EVENT_REGISTRY: 'npm',
-        CELILO_EVENT_TAG: 'latest',
-        CELILO_EVENT_PACKAGE_NAME: '@celilo/cli',
-        CELILO_EVENT_PACKAGE_VERSION: '0.4.0',
+    }));
+    const result = await runUpstreamHook(
+      {
+        module: { moduleId: 'lunacycle', sourcePath: '/m', hooks: [] },
+        hook: { match: {}, script: './hooks/rerun.ts' },
       },
-    });
-    // bash exits with non-zero when the script file doesn't exist
-    // (status 127). Either non-zero exit or a null/spawn-error is
-    // acceptable here; we just want NOT-success.
-    expect(result.exitCode === 0).toBe(false);
+      buildEvent(),
+      { db: {} as never, logger: SILENT_LOGGER },
+    );
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('boom');
   });
 });

package/src/services/build-bus/hook-dispatch.ts

@@ -1,32 +1,39 @@
 /**
  * Hook-dispatch planning + execution for the build bus
- * ([[openspec/changes/build-bus-poll-cd/proposal.md]] Phase 4).
+ * ([[openspec/changes/build-bus-poll-cd/proposal.md]] Phase 4, reshaped by
+ * module-orchestrator-primitives slice 7).
  *
  * Pure: planHookDispatch(event, modules) → HookDispatchPlan[].
- * Decides which module hooks match the event without spawning
- * anything; the executor (runHookDispatch) takes a plan and
- * spawns the actual scripts.
+ * Decides which module hooks match the event; the executor
+ * (runUpstreamHook) takes a plan plus the event and runs the matched
+ * entry through the ORDINARY hook executor — `runNamedHook` →
+ * `invokeHook`, jailed, with the verified PublishEvent as the hook's
+ * `event` input.
  *
- * The hook script gets the event in its environment:
- *   CELILO_EVENT_PAYLOAD          — full PublishEvent as JSON
- *   CELILO_EVENT_REGISTRY         — convenience (also in payload)
- *   CELILO_EVENT_TAG              — convenience
- *   CELILO_EVENT_PACKAGE_NAME     — convenience
- *   CELILO_EVENT_PACKAGE_VERSION  — convenience
+ * There is exactly one hook dispatch path in celilo (tasks.md 7.1):
+ * `apps/celilo/src/hooks/executor.ts`. This module used to carry the
+ * second one — `runHookDispatch` spawned `bash <scriptPath>` detached
+ * with `env: { ...process.env, ...plan.env }`, no jail, no broker — and
+ * slice 7 deleted it. `planHookDispatch`'s match logic is unchanged.
  *
- * Non-zero exit is logged but doesn't gate the receiver — failures
- * are operational signal for the operator, not a publish blocker.
+ * Non-zero hook outcomes are logged by the dispatcher but don't gate the
+ * receiver — failures are operational signal for the operator, not a
+ * publish blocker.
  */
 
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
+import type { HookDefinition } from '@celilo/capabilities';
 import { type PublishEvent, matchesRule } from '@celilo/event-bus/build-bus';
+import { type DbClient, getDb } from '../../db/client';
+import { runNamedHook } from '../../hooks/run-named-hook';
+import type { HookLogger } from '../../hooks/types';
 
 /** Mirrors UpstreamPublishHookSchema in the manifest schema. */
 export interface UpstreamHookEntry {
   name?: string;
   match: { registry?: string; tag?: string; package_pattern?: string };
+  /** Path to a TypeScript `defineHook` script, relative to the module directory. */
   script: string;
+  /** Milliseconds before the hook is killed. */
   timeout?: number;
 }
 
@@ -45,16 +52,15 @@ export interface ModuleHookContext {
 export interface HookDispatchPlan {
   module: ModuleHookContext;
   hook: UpstreamHookEntry;
-  /** Absolute path the executor will spawn. */
-  scriptPath: string;
-  /** Env vars to pass to the script. */
-  env: Record<string, string>;
 }
 
+/** Matches the old bash path's default (600s), in milliseconds. */
+const DEFAULT_TIMEOUT_MS = 600_000;
+
 /**
  * Pure: walk every (module, hook) combination, keep the ones whose
  * match rule fires for this event. Same world → same plan; injects
- * nothing.
+ * nothing. The match logic is unchanged since the bash-spawn days.
  *
  * The manifest's match uses snake_case (`package_pattern`) to match
  * YAML conventions, but the @celilo/event-bus/build-bus matcher
@@ -66,7 +72,6 @@ export function planHookDispatch(
   modules: ModuleHookContext[],
 ): HookDispatchPlan[] {
   const plans: HookDispatchPlan[] = [];
-  const env = buildHookEnv(event);
   for (const module of modules) {
     for (const hook of module.hooks) {
       const rule = {
@@ -75,124 +80,97 @@ export function planHookDispatch(
         packagePattern: hook.match.package_pattern,
       };
       if (!matchesRule(event, rule)) continue;
-      plans.push({
-        module,
-        hook,
-        scriptPath: join(module.sourcePath, hook.script),
-        env,
-      });
+      plans.push({ module, hook });
     }
   }
   return plans;
 }
 
-function buildHookEnv(event: PublishEvent): Record<string, string> {
-  return {
-    CELILO_EVENT_PAYLOAD: JSON.stringify(event),
-    CELILO_EVENT_REGISTRY: event.registry,
-    CELILO_EVENT_TAG: event.tag,
-    CELILO_EVENT_PACKAGE_NAME: event.package.name,
-    CELILO_EVENT_PACKAGE_VERSION: event.package.version,
-  };
-}
-
-const DEFAULT_TIMEOUT_SEC = 600;
-
-export interface HookRunResult {
+export interface UpstreamHookResult {
   module: string;
   hookName: string;
-  scriptPath: string;
-  exitCode: number | null;
+  success: boolean;
+  error?: string;
   durationMs: number;
-  stdout: string;
-  stderr: string;
-  timedOut: boolean;
+}
+
+/** What running one plan entry needs. Injectable so tests don't need a daemon. */
+export interface UpstreamHookDeps {
+  db: DbClient;
+  logger: HookLogger;
 }
 
 /**
- * Run one plan entry. Spawns `bash -c <scriptPath>` so shell features
- * (pipe, redirect, env-var expansion) work inside the hook. Captures
- * stdout/stderr for the operator log; kills the process on timeout.
+ * Run one plan entry through the ordinary executor (module-orchestrator-
+ * primitives slice 7, tasks.md 7.4). The matched entry's script runs as a
+ * `defineHook` under `invokeHook`, jailed, with the verified PublishEvent
+ * as its `event` input — the same path `celilo module run-hook` uses for
+ * every other hook.
  *
  * Doesn't throw — the result carries the outcome. Caller (dispatcher)
  * logs failures and keeps going to the next plan entry.
  */
-export async function runHookDispatch(plan: HookDispatchPlan): Promise<HookRunResult> {
-  const timeoutSec = plan.hook.timeout ?? DEFAULT_TIMEOUT_SEC;
+export async function runUpstreamHook(
+  plan: HookDispatchPlan,
+  event: PublishEvent,
+  deps: UpstreamHookDeps,
+): Promise<UpstreamHookResult> {
   const hookName = plan.hook.name ?? plan.hook.script;
   const startedAt = Date.now();
-
-  return new Promise((resolve) => {
-    // `detached: true` puts bash + its children in their own
-    // process group so the timeout can kill the whole subtree (not
-    // just the bash parent, which would otherwise leave a `sleep`
-    // running). `process.kill(-pid, …)` signals the group.
-    const child = spawn('bash', [plan.scriptPath], {
-      env: { ...process.env, ...plan.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: true,
-    });
-    const pgid = child.pid; // process group leader == its own PID
-
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-    let killTimer: ReturnType<typeof setTimeout> | undefined;
-    const killGroup = (signal: NodeJS.Signals) => {
-      if (pgid == null) return;
-      try {
-        process.kill(-pgid, signal);
-      } catch {
-        // Group already gone — fall back to direct child signal.
-        try {
-          child.kill(signal);
-        } catch {
-          // ignore
-        }
-      }
+  // `HookDefinition.timeout` is milliseconds; the manifest entry declares
+  // milliseconds too (schema: "Milliseconds before the hook is killed").
+  const definition: HookDefinition = {
+    script: plan.hook.script,
+    timeout: plan.hook.timeout ?? DEFAULT_TIMEOUT_MS,
+  };
+  try {
+    const result = await runNamedHook(
+      plan.module.moduleId,
+      'on_upstream_publish',
+      deps.db,
+      deps.logger,
+      {
+        inputs: { event },
+        timeoutMs: definition.timeout,
+        hookDefinition: definition,
+      },
+    );
+    return {
+      module: plan.module.moduleId,
+      hookName,
+      success: result.success,
+      error: result.error,
+      durationMs: Date.now() - startedAt,
     };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      killGroup('SIGTERM');
-      // SIGTERM may not be honored by long-running children
-      // (`sleep`, network waits). Follow up with SIGKILL after a
-      // brief grace period.
-      killTimer = setTimeout(() => killGroup('SIGKILL'), 200);
-    }, timeoutSec * 1000);
+  } catch (error) {
+    return {
+      module: plan.module.moduleId,
+      hookName,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      durationMs: Date.now() - startedAt,
+    };
+  }
+}
 
-    child.stdout?.on('data', (chunk: Buffer) => {
-      stdout += chunk.toString('utf-8');
-    });
-    child.stderr?.on('data', (chunk: Buffer) => {
-      stderr += chunk.toString('utf-8');
-    });
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      if (killTimer) clearTimeout(killTimer);
-      resolve({
-        module: plan.module.moduleId,
-        hookName,
-        scriptPath: plan.scriptPath,
-        exitCode: null,
-        durationMs: Date.now() - startedAt,
-        stdout,
-        stderr: `${stderr}\nspawn error: ${err.message}`,
-        timedOut: false,
-      });
-    });
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      if (killTimer) clearTimeout(killTimer);
-      resolve({
-        module: plan.module.moduleId,
-        hookName,
-        scriptPath: plan.scriptPath,
-        exitCode: code,
-        durationMs: Date.now() - startedAt,
-        stdout,
-        stderr,
-        timedOut,
-      });
-    });
-  });
+/**
+ * Convenience for the dispatcher: deps over the process's database. Tests
+ * inject `runUpstreamHook` instead so they never touch it.
+ */
+export function defaultUpstreamHookDeps(db?: DbClient): UpstreamHookDeps {
+  return {
+    get db() {
+      return db ?? getDb();
+    },
+    logger: consoleLogger(),
+  };
+}
+
+function consoleLogger(): HookLogger {
+  return {
+    info: (message: string) => console.log(message),
+    warn: (message: string) => console.warn(message),
+    error: (message: string) => console.error(message),
+    success: (message: string) => console.log(message),
+  };
 }