@haposoft/cafekit 0.18.3 → 0.18.4

package/README.md

@@ -2,7 +2,7 @@
 
 > Native spec-driven workflow and runtime bundle for Claude Code and Codex CLI.
 
-[![Version](https://img.shields.io/badge/version-0.18.3-blue.svg)](https://github.com/haposoft/cafekit)
+[![Version](https://img.shields.io/badge/version-0.18.4-blue.svg)](https://github.com/haposoft/cafekit)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Claude%20Code](https://img.shields.io/badge/Claude%20Code-Native-orange.svg)](https://claude.ai/code)
 [![Codex%20CLI](https://img.shields.io/badge/Codex%20CLI-Native-111111.svg)](https://developers.openai.com/codex)

package/bin/__tests__/adv-skill.test.js

@@ -75,11 +75,10 @@ function assertLinksResolve(baseDir, file) {
   return links.length;
 }
 
-test('manifest requires adv in alphabetical position', () => {
+test('manifest requires adv', () => {
   // Without the entry the installer never copies the skill and nothing else fails.
   const required = loadClaudeMigrationManifest().skills.required;
   assert.equal(required.includes('adv'), true);
-  assert.deepEqual([...required], [...required].sort());
 });
 
 test('frontmatter carries the catalog identity, manual-only invocation, and a routable description', () => {

package/bin/__tests__/claude-plugin-build.test.js

@@ -29,10 +29,10 @@ before(async () => {
 
 after(() => fs.rmSync(work, { recursive: true, force: true }));
 
-test('inventory: 17 in-scope skills, 14 agents, no excluded component', () => {
+test('inventory: 18 in-scope skills, 14 agents, no excluded component', () => {
   const skills = fs.readdirSync(path.join(tree, 'skills')).sort();
   const agents = fs.readdirSync(path.join(tree, 'agents')).map((f) => f.replace(/\.md$/, '')).sort();
-  assert.equal(skills.length, 17);
+  assert.equal(skills.length, 18);
   assert.equal(agents.length, 14);
   for (const name of lib.EXCLUDED_SKILLS) assert.ok(!skills.includes(name), `excluded skill shipped: ${name}`);
   for (const name of lib.EXCLUDED_AGENTS) assert.ok(!agents.includes(name), `excluded agent shipped: ${name}`);

package/bin/__tests__/codex-hook-runtime-fixture.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { codexRuntimeLayout } = require('../phases/codex-runtime');
+
+// Groups the installer materializes under .codex that Codex hooks load at run time.
+const HOOK_RUNTIME_GROUPS = new Set(['hooks', 'schema', 'shared-lib']);
+
+/**
+ * Lay the Codex hook runtime into `<root>/.codex` exactly as the installer does,
+ * driven by the canonical layout so a new hook or shared library cannot be missed.
+ * Returns the hooks directory.
+ */
+function installCodexHookRuntime(root) {
+  const runtimeRoot = path.join(root, '.codex');
+  for (const entry of codexRuntimeLayout()) {
+    if (!HOOK_RUNTIME_GROUPS.has(entry.group)) continue;
+    const target = path.join(runtimeRoot, entry.dest);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(entry.src, target);
+  }
+  return path.join(runtimeRoot, 'hooks');
+}
+
+module.exports = { installCodexHookRuntime };

package/bin/__tests__/codex-hooks-ownership.test.js

@@ -79,17 +79,6 @@ function addUserHooks(root) {
   fs.writeFileSync(hooksPath(root), `${JSON.stringify(config, null, 2)}\n`);
 }
 
-test('a fresh install registers the precompact capture hook', () => {
-  inTempProject((root) => {
-    assert.ok(managedScripts().PreCompact?.includes('precompact.cjs'));
-    const result = install(root);
-    assert.equal(result.status, 0, result.stderr);
-    const scripts = (readHooks(root).hooks.PreCompact || []).flatMap(group => group.hooks || []).map(handler => hookScript(handler.command));
-    assert.ok(scripts.includes('precompact.cjs'));
-    assert.ok(fs.existsSync(path.join(root, '.codex/hooks/precompact.cjs')));
-  });
-});
-
 test('a fresh install registers every CafeKit hook under its own event', () => {
   inTempProject((root) => {
     const result = install(root);
@@ -103,7 +92,10 @@ test('a fresh install registers every CafeKit hook under its own event', () => {
         .filter(Boolean);
       for (const script of scripts) {
         assert.ok(registered.includes(script), `${script} missing from ${eventName}`);
+        assert.ok(fs.existsSync(path.join(root, '.codex/hooks', script)), `${script} not installed`);
       }
+      const template = JSON.parse(fs.readFileSync(TEMPLATE, 'utf8')).hooks[eventName];
+      assert.deepEqual(installed.hooks[eventName].map((group) => group.matcher), template.map((group) => group.matcher));
     }
   });
 });
@@ -119,6 +111,11 @@ test('a reinstall preserves user-added hooks instead of overwriting them', () =>
     const commands = allCommands(readHooks(root));
     assert.ok(commands.includes(USER_STOP_COMMAND), 'user Stop hook was erased by the reinstall');
     assert.ok(commands.includes(USER_PRETOOL_COMMAND), 'user PreToolUse hook was erased by the reinstall');
+    const after = readHooks(root).hooks;
+    const userGroup = (event, command) => after[event].find((group) => group.hooks.some((handler) => handler.command === command));
+    assert.deepEqual(userGroup('Stop', USER_STOP_COMMAND), { matcher: '*', hooks: [{ type: 'command', command: USER_STOP_COMMAND }] });
+    assert.deepEqual(userGroup('PreToolUse', USER_PRETOOL_COMMAND), { matcher: 'Bash', hooks: [{ type: 'command', command: USER_PRETOOL_COMMAND }] });
+    assert.doesNotMatch(second.stdout + second.stderr, /matcher preserved/);
   });
 });
 

package/bin/__tests__/codex-hooks.test.js

@@ -7,6 +7,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawnSync, spawn } = require('node:child_process');
 const { test } = require('node:test');
+const { installCodexHookRuntime } = require('./codex-hook-runtime-fixture.cjs');
 
 const OLD_INSPECTION_MATCHER = 'Bash|exec_command|apply_patch|Edit|Write|Read|Glob|Grep|mcp__.*|shell';
 const NEW_INSPECTION_MATCHER = 'Bash|exec_command|shell|apply_patch|mcp__.*|collaborationspawn_agent|collaborationwait_agent';
@@ -44,31 +45,6 @@ test('upgrade preserves a mixed user group and warns', () => matcherFixture(f =>
   assert.ok(f.read().hooks.PreToolUse[0].hooks.some(h => h.command === 'echo user-owned'));
   assert.ok(f.warnings.some(line => /matcher.*preserv/i.test(line)));
 }));
-test('reinstall keeps purely user groups unchanged without matcher warnings', () => matcherFixture(f => {
-  const userPre = { matcher: 'Bash', hooks: [{ command: 'my-linter' }] };
-  const userPost = { hooks: [{ command: 'my-logger' }] };
-  f.config.hooks = { PreToolUse: [userPre], PostToolUse: [userPost] }; f.save();
-  const installs = Array.from({ length: 2 }, () => {
-    const result = spawnSync(process.execPath, [path.resolve(__dirname, '../install.js'), '--platform', 'codex', '-y'], {
-      cwd: f.root, encoding: 'utf8',
-    });
-    return { result, config: f.read() };
-  });
-  for (const { result, config } of installs) {
-    assert.equal(result.status, 0, result.stderr);
-    for (const [event, original] of [['PreToolUse', userPre], ['PostToolUse', userPost]]) {
-      const group = config.hooks[event].find(g => g.hooks.some(h => h.command === original.hooks[0].command));
-      assert.equal(JSON.stringify(group), JSON.stringify(original));
-    }
-    assert.doesNotMatch(result.stdout + result.stderr, /matcher preserved/);
-  }
-}));
-test('fresh hook registration uses every template matcher', () => matcherFixture(f => {
-  f.merge();
-  for (const [event, groups] of Object.entries(f.config.hooks)) {
-    assert.deepEqual(f.read().hooks[event].map(g => g.matcher), groups.map(g => g.matcher));
-  }
-}));
 test('upgrade preserves a user-selected managed matcher and warns', () => matcherFixture(f => {
   f.config.hooks.PreToolUse[0].matcher = 'Read|Grep'; f.save(); f.merge();
   assert.equal(f.read().hooks.PreToolUse[0].matcher, 'Read|Grep');
@@ -93,12 +69,18 @@ const { stateDir: codexStateDir } = require(
   path.join(CODEX_HOOKS, 'lib', 'state-store.cjs')
 );
 
+// A hook child that never exits must fail its test, not hang the whole suite.
+const HOOK_TIMEOUT_MS = 30000;
+
 function runHook(file, cwd, payload) {
-  return spawnSync(process.execPath, [file], {
+  const result = spawnSync(process.execPath, [file], {
     cwd,
     input: JSON.stringify(payload),
-    encoding: 'utf8'
+    encoding: 'utf8',
+    timeout: HOOK_TIMEOUT_MS
   });
+  assert.equal(result.error, undefined, `${path.basename(file)} did not exit: ${result.error?.message}`);
+  return result;
 }
 
 function runtimeContext(root, feature = 'auth', session = 'session-a') {
@@ -145,26 +127,7 @@ function inHookFixture(run, options = {}) {
   const hooks = path.join(root, '.codex', 'hooks');
   let deferred = false;
   try {
-    fs.cpSync(CODEX_HOOKS, hooks, { recursive: true });
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/spec-touch.cjs'), path.join(hooks, 'lib/spec-touch.cjs'));
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/secret-keywords.cjs'), path.join(hooks, 'lib/secret-keywords.cjs'));
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/update-check.cjs'), path.join(hooks, 'lib/update-check.cjs'));
-    fs.copyFileSync(
-      path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/inspect-paths.cjs'),
-      path.join(hooks, 'lib/inspect-paths.cjs'),
-    );
-    fs.copyFileSync(
-      path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/privacy-command-analysis.cjs'),
-      path.join(hooks, 'lib/privacy-command-analysis.cjs'),
-    );
-    fs.copyFileSync(
-      path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/privacy-paths.cjs'),
-      path.join(hooks, 'lib/privacy-paths.cjs'),
-    );
-    fs.copyFileSync(
-      path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-path-safety.cjs'),
-      path.join(hooks, 'lib/runtime-path-safety.cjs'),
-    );
+    installCodexHookRuntime(root);
     fs.mkdirSync(path.join(root, '.codex', 'scripts'), { recursive: true });
     if (options.policy !== 'missing') {
       if (options.policy === 'malformed') {
@@ -216,15 +179,7 @@ function inNoCommitCodexFixture(run) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-codex-no-commit-'));
   const hooks = path.join(root, '.codex/hooks');
   try {
-    fs.cpSync(CODEX_HOOKS, hooks, { recursive: true });
-    for (const name of ['privacy-paths.cjs', 'privacy-command-analysis.cjs']) {
-      fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib', name), path.join(hooks, 'lib', name));
-    }
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/spec-touch.cjs'), path.join(hooks, 'lib/spec-touch.cjs'));
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/secret-keywords.cjs'), path.join(hooks, 'lib/secret-keywords.cjs'));
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/update-check.cjs'), path.join(hooks, 'lib/update-check.cjs'));
-    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-path-safety.cjs'),
-      path.join(hooks, 'lib/runtime-path-safety.cjs'));
+    installCodexHookRuntime(root);
     const scripts = path.join(root, '.codex/scripts');
     fs.mkdirSync(scripts, { recursive: true });
     for (const name of ['workflow-policy.cjs', 'provenance.cjs', 'spec-receipt.cjs', 'spec-resolver.cjs']) {
@@ -539,7 +494,7 @@ for (const method of ['spawnSync', 'execFileSync']) {
 }
 `);
       const result = spawnSync(process.execPath, [path.join(hooks, 'spec-state.cjs')], {
-        cwd: root, encoding: 'utf8',
+        cwd: root, encoding: 'utf8', timeout: HOOK_TIMEOUT_MS,
         env: { ...process.env, NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --require ${JSON.stringify(preload)}` },
         input: JSON.stringify({ cwd: root, featureName: 'auth', hook_event_name: 'UserPromptSubmit',
           session_id: 'one-snapshot', prompt: 'Continue specs/auth' }),
@@ -754,7 +709,7 @@ test('Codex secret guardrail runs from source with its shared keyword shim', ()
   delete env.CLAUDE_PROJECT_DIR;
   delete env.PROJECT_ROOT;
   const result = spawnSync(process.execPath, [path.join(CODEX_HOOKS, 'secret-output-guardrail.cjs')], {
-    cwd: PACKAGE_ROOT, env, encoding: 'utf8', input: JSON.stringify({ prompt: 'Explain secret handling.' }),
+    cwd: PACKAGE_ROOT, env, encoding: 'utf8', timeout: HOOK_TIMEOUT_MS, input: JSON.stringify({ prompt: 'Explain secret handling.' }),
   });
   assert.equal(result.status, 0);
   assert.equal(result.stderr, '');
@@ -855,7 +810,7 @@ test('Codex compact releases only its own rules reservation', () => {
 test('Codex precompact ignores empty stdin without recording a crash', () => {
   inHookFixture((root, hooks) => {
     const result = spawnSync(process.execPath, [path.join(hooks, 'precompact.cjs')], {
-      cwd: root, input: '', encoding: 'utf8',
+      cwd: root, input: '', encoding: 'utf8', timeout: HOOK_TIMEOUT_MS,
     });
     assert.equal(result.status, 0);
     assert.equal(result.stderr, '');
@@ -900,7 +855,8 @@ function sessionWithoutUpdateNetwork(root, hooks, session_id) {
     throw new Error('network disabled in update test');
   };\n`);
   const result = spawnSync(process.execPath, ['--require', preload, path.join(hooks, 'session.cjs')], {
-    cwd: root, encoding: 'utf8', input: JSON.stringify({ cwd: root, hook_event_name: 'SessionStart', source: 'startup', session_id }),
+    cwd: root, encoding: 'utf8', timeout: HOOK_TIMEOUT_MS,
+    input: JSON.stringify({ cwd: root, hook_event_name: 'SessionStart', source: 'startup', session_id }),
   });
   assert.equal(fs.existsSync(marker), false, 'the cached update check must not attempt a network request');
   return result;
@@ -976,7 +932,7 @@ function shortPrivacyFixture(check) {
       hook_event_name: 'PreToolUse', tool_name: 'Bash', tool_input: { command: `cat ${file}` } });
     const block = (file, id) => runHook(path.join(hooks, 'privacy-block.cjs'), root, payload(file, id));
     const submit = (prompt, session_id = session, env = process.env) => spawnSync(process.execPath,
-      [path.join(hooks, 'privacy-approval.cjs')], { cwd: root, encoding: 'utf8', env,
+      [path.join(hooks, 'privacy-approval.cjs')], { cwd: root, encoding: 'utf8', env, timeout: HOOK_TIMEOUT_MS,
         input: JSON.stringify({ cwd: root, session_id, hook_event_name: 'UserPromptSubmit', prompt }) });
     const files = prefix => fs.existsSync(dir) ? fs.readdirSync(dir).filter(name => name.startsWith(prefix)) : [];
     const id = result => {
@@ -1682,6 +1638,7 @@ test('empty or forged Codex hook authority fails closed', () => {
         env: { ...process.env },
         input,
         encoding: 'utf8',
+        timeout: HOOK_TIMEOUT_MS,
       });
       assert.equal(result.status, 0, `${JSON.stringify(input)}: ${result.stderr}`);
       assert.equal(result.stderr, '');
@@ -2390,7 +2347,37 @@ test('Codex hook-context canonicalizes symlink project root (regression)', () =>
   });
 });
 
-test('Codex resolver and state reject symlink escape', () => {
+test('Codex session state refuses a symlinked state path and writes nothing outside the project', () => {
+  inHookFixture((root, hooks) => {
+    const stateStore = require(path.join(hooks, 'lib', 'state-store.cjs'));
+    const sessionId = 'sess-symlink';
+    const dir = stateStore.stateDir(root, sessionId);
+    const sessionState = path.dirname(dir);
+    // A repository can commit either the shared state folder or one session folder as a link.
+    for (const link of [sessionState, dir]) {
+      const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-state-outside-'));
+      try {
+        fs.rmSync(sessionState, { recursive: true, force: true });
+        fs.mkdirSync(path.dirname(link), { recursive: true });
+        fs.symlinkSync(outside, link);
+        let called = false;
+        const ok = stateStore.withStateLock(root, sessionId, (stateDir) => {
+          called = true;
+          stateStore.writeData(stateDir, { todos: [] });
+        });
+        assert.equal(ok, false, `${path.relative(root, link)} link must be refused`);
+        assert.equal(called, false);
+        assert.deepEqual(fs.readdirSync(outside), [], 'nothing may be written outside the project');
+      } finally {
+        fs.rmSync(sessionState, { recursive: true, force: true });
+        fs.rmSync(outside, { recursive: true, force: true });
+      }
+    }
+    assert.equal(stateStore.withStateLock(root, sessionId, () => {}), true, 'a plain state folder still locks');
+  });
+});
+
+test('Codex resolver rejects symlink escape', () => {
   inHookFixture((root, hooks) => {
     const specUtils = require(path.join(hooks, 'lib', 'spec-utils.cjs'));
     const resolverPath = path.join(root, '.codex', 'scripts', 'spec-resolver.cjs');
@@ -2418,23 +2405,6 @@ test('Codex resolver and state reject symlink escape', () => {
       );
       fs.rmSync(outsideScripts, { recursive: true, force: true });
     }
-    // State dir symlink escape: create symlink for session-state dir
-    const stateStore = require(path.join(hooks, 'lib', 'state-store.cjs'));
-    const sessionId = 'sess-symlink';
-    const dir = stateStore.stateDir(root, sessionId);
-    fs.mkdirSync(path.dirname(dir), { recursive: true });
-    // Create a symlink that points outside project
-    const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'outside-'));
-    try {
-      if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
-      fs.symlinkSync(outside, dir);
-      // withStateLock should handle symlink safely (no crash, no write outside)
-      const ok = stateStore.withStateLock(root, sessionId, () => {});
-      assert.equal(typeof ok, 'boolean');
-    } finally {
-      try { fs.unlinkSync(dir); } catch {}
-      fs.rmSync(outside, { recursive: true, force: true });
-    }
   });
 });
 

package/bin/__tests__/codex-implicit-policy.test.js

@@ -55,8 +55,8 @@ function catalog(root, script, skillsRoot) {
   return JSON.parse(result.stdout);
 }
 
-test('the explicit-only skills are vibe and adv', () => {
-  assert.deepEqual(explicitOnly.sort(), ['adv', 'vibe']);
+test('the explicit-only skills are adv, toaa and vibe', () => {
+  assert.deepEqual(explicitOnly.sort(), ['adv', 'toaa', 'vibe']);
 });
 
 test('a Codex install writes the policy file for every explicit-only skill, owned, and for no other skill', () => {

package/bin/__tests__/codex-native-hook-boundaries.test.js

@@ -6,16 +6,14 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const { test } = require('node:test');
+const { installCodexHookRuntime } = require('./codex-hook-runtime-fixture.cjs');
 const SOURCE = path.resolve(__dirname, '../../src');
 
 function fixture(run) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-native-boundaries-'));
   const hooks = path.join(root, '.codex/hooks');
   try {
-    fs.cpSync(path.join(SOURCE, 'codex/hooks'), hooks, { recursive: true });
-    for (const name of ['runtime-path-safety', 'privacy-command-analysis', 'privacy-paths', 'secret-keywords', 'inspect-paths', 'update-check']) {
-      fs.copyFileSync(path.join(SOURCE, `claude/hooks/lib/${name}.cjs`), path.join(hooks, `lib/${name}.cjs`));
-    }
+    installCodexHookRuntime(root);
     fs.cpSync(path.join(SOURCE, 'claude/scripts'), path.join(root, '.codex/scripts'), { recursive: true });
     fs.writeFileSync(path.join(root, '.gitignore'), '.codex/\n');
     for (const args of [['init', '-q'], ['config', 'user.email', 'probe@example.invalid'], ['config', 'user.name', 'Probe'], ['add', '.gitignore'], ['commit', '-qm', 'base']]) {