@haposoft/cafekit 0.18.1 → 0.18.3

package/bin/__tests__/claude-settings.test.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test } = require('node:test');
+const { mergeClaudeSettings } = require('../phases/claude-settings');
+const manifest = require('../../src/claude/migration-manifest.json');
+const template = require('../../src/claude/settings/settings.json');
+
+const MATCHER = 'Read|Write|Edit|MultiEdit|NotebookEdit|Bash|Glob|Grep|mcp__.*';
+const OLD = 'Read|Write|Edit|MultiEdit|Bash|Glob|Grep';
+const templateGroup = template.hooks.PreToolUse[0];
+const privacy = templateGroup.hooks.find(hook => hook.command.includes('/privacy-block.cjs'));
+const inspect = templateGroup.hooks.find(hook => hook.command.includes('/inspect-block.cjs'));
+const group = (matcher, hooks = [privacy, inspect]) => ({ matcher, hooks });
+
+function withSettings(groups, run, dryRun = false) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-claude-settings-'));
+  const previousCwd = process.cwd();
+  try {
+    process.chdir(root);
+    fs.mkdirSync('.claude');
+    const settingsPath = path.join(root, '.claude/settings.json');
+    if (groups) fs.writeFileSync(settingsPath, JSON.stringify({ hooks: { PreToolUse: groups } }, null, 2));
+    const before = fs.existsSync(settingsPath) ? fs.readFileSync(settingsPath, 'utf8') : null;
+    const messages = [];
+    const ctx = {
+      manifest, dryRun, options: {}, results: { updated: 0, errors: 0 },
+      ui: { detail: message => messages.push(message), warn: message => messages.push(message) },
+    };
+    mergeClaudeSettings(ctx, 'claude');
+    const after = fs.readFileSync(settingsPath, 'utf8');
+    run({ before, after, groups: JSON.parse(after).hooks.PreToolUse, messages });
+  } finally {
+    process.chdir(previousCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function assertNoDuplicateCommands(groups) {
+  const commands = groups.flatMap(entry => entry.hooks.map(hook => hook.command));
+  assert.equal(commands.length, new Set(commands).size);
+}
+
+test('(a) claude-settings updates the former matcher for managed privacy and inspect', () => {
+  withSettings([group(OLD)], ({ groups, messages }) => {
+    assert.equal(groups[0].matcher, MATCHER);
+    assert.deepEqual(groups[0].hooks, [privacy, inspect]);
+    assert.ok(messages.some(message => message.includes('matcher updated')));
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(b) claude-settings updates the former matcher without Grep', () => {
+  withSettings([group('Read|Write|Edit|MultiEdit|Bash|Glob')], ({ groups, messages }) => {
+    assert.equal(groups[0].matcher, MATCHER);
+    assert.ok(messages.some(message => message.includes('matcher updated')));
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(c) claude-settings preserves a mixed entry with a user command', () => {
+  const mixed = group(OLD, [privacy, inspect, { type: 'command', command: 'my-linter' }]);
+  withSettings([mixed], ({ groups, messages }) => {
+    assert.deepEqual(groups[0], mixed);
+    assert.equal(messages.some(message => message.includes('matcher updated')), false);
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(d) claude-settings preserves a custom matcher for managed commands', () => {
+  const custom = group('Read|Bash');
+  withSettings([custom], ({ groups, messages }) => {
+    assert.deepEqual(groups[0], custom);
+    assert.equal(messages.some(message => message.includes('matcher updated')), false);
+  });
+});
+
+test('(e) claude-settings installs the template matcher without duplicate entries', () => {
+  withSettings(null, ({ groups }) => {
+    assert.deepEqual(groups, template.hooks.PreToolUse);
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(f) claude-settings updates a split privacy entry without duplicate commands', () => {
+  withSettings([group(OLD, [privacy]), group(MATCHER, [inspect])], ({ groups, messages }) => {
+    assert.equal(groups.length, 2);
+    assert.ok(groups.every(entry => entry.matcher === MATCHER));
+    assert.deepEqual(groups.map(entry => entry.hooks), [[privacy], [inspect]]);
+    assert.ok(messages.some(message => message.includes('matcher updated')));
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(g) claude-settings prunes the retired inspector before updating privacy', () => {
+  const retired = { ...inspect, command: inspect.command.replace('inspect-block.cjs', 'inspector-block.cjs') };
+  withSettings([group(OLD, [retired, privacy])], ({ groups, messages }) => {
+    assert.equal(groups[0].matcher, MATCHER);
+    assert.deepEqual(groups[0].hooks, [privacy, inspect]);
+    assert.ok(messages.some(message => message.includes('matcher updated')));
+    assertNoDuplicateCommands(groups);
+  });
+});
+
+test('(h) claude-settings dry-run reports the matcher update without writing', () => {
+  withSettings([group(OLD)], ({ before, after, messages }) => {
+    assert.equal(after, before);
+    assert.ok(messages.some(message => message.includes('[dry-run] Settings: hook PreToolUse matcher updated')));
+  }, true);
+});
+
+test('(i) claude-settings preserves a null handler without updating the matcher', () => {
+  const entry = group(OLD, [null]);
+  assert.doesNotThrow(() => {
+    withSettings([entry], ({ groups, messages }) => {
+      assert.deepEqual(groups[0], entry);
+      assert.equal(messages.some(message => message.includes('matcher updated')), false);
+    });
+  });
+});

package/bin/__tests__/codex-ask-guard.test.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
+
+test('installed Codex ask guard follows the observed hook payloads', async (t) => {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-ask-guard-test-'));
+  t.after(() => fs.rmSync(temp, { recursive: true, force: true }));
+  const project = path.join(temp, 'project');
+  fs.mkdirSync(project);
+  const install = spawnSync(process.execPath, [path.join(__dirname, '../install.js'),
+    '--platform', 'codex', '--yes'], { cwd: project, encoding: 'utf8' });
+  assert.equal(install.status, 0, install.stderr + install.stdout);
+  const script = path.join(project, '.codex/hooks/ask-guard.cjs');
+  const config = JSON.parse(fs.readFileSync(path.join(project, '.codex/hooks.json'), 'utf8'));
+
+  function fixture() {
+    const stateRoot = fs.mkdtempSync(path.join(temp, 'state-'));
+    const session = crypto.randomUUID();
+    const sessionDir = (id = session) => path.join(stateRoot, sha256(id));
+    function call(event, extra = {}, id = session, override = stateRoot) {
+      return spawnSync(process.execPath, [script], {
+        cwd: project, encoding: 'utf8',
+        env: { ...process.env, CAFEKIT_ASK_GUARD_DIR: override },
+        input: JSON.stringify({ hook_event_name: event, cwd: project, session_id: id, ...extra })
+      });
+    }
+    const prompt = (text, id = session) => call('UserPromptSubmit', { prompt: text }, id);
+    const tool = (name = 'apply_patch', id = session) => call('PreToolUse', {
+      tool_name: name, tool_input: { command: '*** Begin Patch\n*** Update File: src/greet.js\n*** End Patch' }
+    }, id);
+    return { call, prompt, tool, session, stateRoot, sessionDir };
+  }
+
+  await t.test('real installer registers both events and a separate apply_patch group', () => {
+    assert.ok(fs.existsSync(script));
+    const isGuard = (handler) => /ask-guard\.cjs/.test(handler.command || '');
+    assert.ok(config.hooks.UserPromptSubmit.some((group) => group.hooks.some(isGuard)));
+    const group = config.hooks.PreToolUse.find((entry) => entry.hooks.some(isGuard));
+    assert.ok(group);
+    assert.equal(group.matcher, 'apply_patch');
+    assert.equal(group.hooks.length, 1);
+    const windowsPath = Buffer.from(group.hooks[0].commandWindows.split(' ').at(-1), 'base64url').toString('utf8');
+    assert.equal(fs.realpathSync(windowsPath), fs.realpathSync(script));
+  });
+  await t.test('explicit ask denies only its session and logs exactly one private row per denial', () => {
+    const f = fixture();
+    assert.equal(f.prompt('  $cf-ask "Sửa giúp luôn."\n').status, 0);
+    assert.equal(f.tool('apply_patch', crypto.randomUUID()).status, 0);
+    for (let count = 1; count <= 2; count++) {
+      const result = f.tool();
+      assert.equal(result.status, 2, result.stderr);
+      assert.match(result.stderr, /\$cf-fix/);
+      assert.doesNotMatch(result.stderr, /greet|Sửa giúp|Begin Patch/);
+      const rows = fs.readFileSync(path.join(f.sessionDir(), 'denials.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
+      assert.equal(rows.length, count);
+      for (const row of rows) {
+        assert.deepEqual(Object.keys(row).sort(), ['session_id_sha256', 'timestamp', 'tool_name']);
+        assert.equal(row.session_id_sha256, sha256(f.session));
+        assert.equal(row.tool_name, 'apply_patch');
+        assert.ok(Number.isFinite(Date.parse(row.timestamp)));
+      }
+    }
+    assert.equal(fs.existsSync(path.join(project, '.codex/hooks/.logs')), false);
+  });
+  await t.test('next non-ask prompt disables a previously persisted ask flag', () => {
+    const f = fixture();
+    assert.equal(f.prompt('$cf-ask reason').status, 0);
+    assert.equal(f.tool().status, 2);
+    assert.equal(f.prompt('Please fix it now').status, 0);
+    assert.equal(f.tool().status, 0);
+  });
+  await t.test('/cf:ask activates the guard', () => {
+    const f = fixture();
+    assert.equal(f.prompt('/cf:ask reason').status, 0);
+    assert.equal(f.tool().status, 2);
+  });
+  for (const prompt of ['Đừng dùng $cf-ask để sửa', '```\n$cf-ask reason\n```', '$cf-asker reason', '$CF-ASK reason']) {
+    await t.test(`non-invocation stays inactive: ${JSON.stringify(prompt)}`, () => {
+      const f = fixture();
+      assert.equal(f.prompt(prompt).status, 0);
+      assert.equal(f.tool().status, 0);
+    });
+  }
+  await t.test('Bash and Read are allowed during ask', () => {
+    const f = fixture();
+    assert.equal(f.prompt('$cf-ask').status, 0);
+    for (const name of ['Bash', 'Read', 'exec']) assert.equal(f.tool(name).status, 0);
+    assert.equal(f.tool().status, 2);
+  });
+  await t.test('path-like session IDs stay hashed within the state directory', () => {
+    const f = fixture();
+    assert.equal(f.prompt('$cf-ask reason', '../x').status, 0);
+    assert.equal(f.tool('apply_patch', '../x').status, 2);
+    assert.deepEqual(fs.readdirSync(f.stateRoot), [sha256('../x')]);
+    assert.equal(fs.existsSync(path.join(temp, 'x')), false);
+  });
+  await t.test('missing session IDs fail open and record a crash', () => {
+    const f = fixture();
+    assert.equal(f.call('UserPromptSubmit', { prompt: '$cf-ask' }, null).status, 0);
+    assert.equal(f.tool('apply_patch', null).status, 0);
+    const rows = fs.readFileSync(path.join(project, '.codex/hooks/.logs/hook-log.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
+    assert.ok(rows.some((row) => row.hook === 'ask-guard' && row.status === 'crash'));
+    assert.deepEqual(fs.readdirSync(f.stateRoot), []);
+  });
+  await t.test('state I/O errors fail open and record a crash without leaking input', () => {
+    const f = fixture();
+    const invalidRoot = path.join(temp, 'not-a-directory');
+    fs.writeFileSync(invalidRoot, 'file');
+    const result = f.call('PreToolUse', { tool_name: 'apply_patch', tool_input: { command: 'PRIVATE-INPUT' } }, f.session, invalidRoot);
+    assert.equal(result.status, 0);
+    const log = fs.readFileSync(path.join(project, '.codex/hooks/.logs/hook-log.jsonl'), 'utf8');
+    assert.doesNotMatch(log, /PRIVATE-INPUT/);
+    assert.equal(JSON.parse(log.trim().split('\n').at(-1)).hook, 'ask-guard');
+  });
+});

package/bin/__tests__/codex-ask-projection.test.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { test } = require('node:test');
+const { normalizeCodexBody } = require('../lib/codex-install');
+const { splitFrontmatter } = require('../lib/codex-frontmatter');
+
+const ROOT = path.resolve(__dirname, '../..');
+const skillPath = name => path.join(ROOT, 'src/claude/skills', name, 'SKILL.md');
+const readSkill = name => fs.readFileSync(skillPath(name), 'utf8');
+
+test('codex ask projection carries the answer-only instruction after frontmatter', () => {
+  const source = readSkill('ask');
+  const projected = normalizeCodexBody(source, skillPath('ask'));
+  assert.match(projected, /^---\r?\n/);
+  const { frontmatter, body } = splitFrontmatter(projected);
+  assert.equal(frontmatter.name, 'cf-ask');
+  assert.match(projected.slice(0, projected.length - body.length), /^name:\s*cf-ask$/m);
+  const boundary = 'A request to fix or change something is still answered without editing any file; point the user to $cf-fix.';
+  const originalDescription = splitFrontmatter(normalizeCodexBody(source)).frontmatter.description;
+  // A JSON-quoted scalar is valid YAML; verify the serialized value as well as the split header.
+  const description = JSON.parse(projected.match(/^description: (.+)$/m)[1]);
+  assert.equal(description, `${originalDescription} ${boundary}`);
+  assert.equal(frontmatter.description, description);
+  assert.ok(description.length <= 1024);
+  assert.match(body, /^\s*Rule 1 \(Codex\): never edit, create, or delete files in this skill,/);
+  const note = body.trimStart().split('\n\n')[0];
+  assert.match(note, /even when the user says fix it or sửa giúp luôn/);
+  assert.match(note, /Do not run commands that write files/);
+  assert.match(note, /Answer the cause with evidence and tell the user to run \$cf-fix\./);
+  assert.doesNotMatch(`${description}\n${note}`, /\b(?:Write|Edit|Read|Bash|WebSearch|WebFetch|AskUserQuestion)\b/);
+  assert.match(body, /\n\n# Ask Skill\n/);
+
+  for (const name of ['fix', 'develop']) {
+    const otherSource = readSkill(name);
+    const other = normalizeCodexBody(otherSource, skillPath(name));
+    assert.doesNotMatch(other, /Rule 1 \(Codex\):/);
+    assert.equal(splitFrontmatter(other).frontmatter.description,
+      splitFrontmatter(normalizeCodexBody(otherSource)).frontmatter.description);
+    assert.ok(!other.includes(boundary));
+  }
+  for (const sourcePath of ['', 'skills/ask/templates/question.md', 'other-skills/ask/SKILL.md']) {
+    const prompt = normalizeCodexBody(source, sourcePath);
+    assert.doesNotMatch(prompt, /Rule 1 \(Codex\):/);
+    assert.ok(!prompt.includes(boundary));
+    assert.equal(splitFrontmatter(prompt).frontmatter.description, originalDescription);
+  }
+  assert.match(normalizeCodexBody(source, 'C:\\project\\skills\\ask\\SKILL.md'), /Rule 1 \(Codex\):/);
+});

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

@@ -17,7 +17,7 @@ const PACKAGE_ROOT = path.join(__dirname, '../..');
 const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
 const TEMPLATE = path.join(PACKAGE_ROOT, 'src/codex/hooks.json');
 const MANIFEST = require(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.json'));
-const { hookScript } = require(path.join(PACKAGE_ROOT, 'bin/phases/codex-hooks.js'));
+const { hookScript, repairLegacyCodexLaunchers } = require(path.join(PACKAGE_ROOT, 'bin/phases/codex-hooks.js'));
 
 const USER_STOP_COMMAND = 'node "$(git rev-parse --show-toplevel)/scripts/my-own-stop.js"';
 const USER_PRETOOL_COMMAND = 'echo user-owned-pretooluse';
@@ -79,6 +79,17 @@ 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);
@@ -237,3 +248,71 @@ test('hooks.json stays outside the ownership manifest, like settings.json', () =
     );
   });
 });
+
+test('parity regression: foreign hooks with managed basenames stay exact and cannot suppress registration', () => {
+  inTempProject((root) => {
+    fs.mkdirSync(path.join(root, '.codex'));
+    const foreign = { type: 'command', command: `node '${root}/tools/hooks/session.cjs'`, timeout: 17 };
+    const custom = { type: 'command', command: `node '${root}/.codex/hooks/session.cjs' --custom`, timeout: 19 };
+    fs.writeFileSync(hooksPath(root), JSON.stringify({ hooks: { SessionStart: [{ matcher: '*', hooks: [foreign, custom] }] } }));
+    const result = install(root);
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    const handlers = readHooks(root).hooks.SessionStart.flatMap((group) => group.hooks);
+    assert.ok(handlers.some((entry) => JSON.stringify(entry) === JSON.stringify(foreign)), 'foreign hook was rewritten');
+    assert.ok(handlers.some((entry) => JSON.stringify(entry) === JSON.stringify(custom)), 'custom hook was rewritten');
+    assert.equal(handlers.filter((entry) => entry.command?.startsWith('PATH=') && hookScript(entry.command) === 'session.cjs').length, 1);
+  });
+});
+
+test('parity regression: repairing launchers preserves unknown and foreign command shapes', () => {
+  inTempProject((root) => {
+    const commands = [
+      `node '${root}/tools/hooks/check.cjs'`,
+      `node '${root}/tools/hooks/session.cjs'`,
+      `node '${root}/.codex/hooks/user-guard.cjs'`,
+      `node '${root}/.codex/hooks/session.cjs' --custom`,
+    ];
+    const config = { hooks: { Stop: [{ hooks: commands.map((command) => ({ type: 'command', command })) }] } };
+    assert.deepEqual(repairLegacyCodexLaunchers(config, root).config, config);
+    const windowsPrefix = 'node -e "process.argv[1]=Buffer.from(process.argv[1],\'base64url\').toString(\'utf8\');require(\'module\').runMain()" ';
+    const foreignWindows = windowsPrefix + Buffer.from(`${root}/tools/hooks/session.cjs`).toString('base64url');
+    const mixed = { type: 'command', command: 'node ".codex/hooks/session.cjs"', commandWindows: foreignWindows, timeout: 7 };
+    const next = repairLegacyCodexLaunchers({ hooks: { Stop: [{ hooks: [mixed] }] } }, root).config.hooks.Stop[0].hooks[0];
+    assert.equal(next.commandWindows, foreignWindows, 'foreign platform field was rebound');
+    assert.equal(next.timeout, 7);
+    assert.match(next.command, /^PATH=/);
+    for (const commandWindows of [windowsPrefix + 'bad-base64!', foreignWindows + ' --custom']) {
+      const unknown = { hooks: { Stop: [{ hooks: [{ type: 'command', commandWindows }] }] } };
+      assert.deepEqual(repairLegacyCodexLaunchers(unknown, root).config, unknown);
+    }
+  });
+});
+
+test('parity regression: upgrade removes only managed docs startup handlers', () => {
+  inTempProject((root) => {
+    assert.equal(install(root).status, 0);
+    const config = readHooks(root);
+    const managed = { type: 'command', command: `node '${root}/.codex/hooks/docs-sync.cjs'`, timeout: 23 };
+    const foreign = { type: 'command', command: `node '${root}/tools/hooks/docs-sync.cjs'` };
+    const custom = { type: 'command', command: `node '${root}/.codex/hooks/docs-sync.cjs' --custom` };
+    const hybrid = { ...managed, commandWindows: 'echo user-owned-windows-docs' };
+    config.hooks.SessionStart.push({ matcher: '*', hooks: [managed, foreign, custom, hybrid] });
+    config.hooks.Stop.push({ hooks: [{ ...managed }] });
+    fs.writeFileSync(hooksPath(root), JSON.stringify(config));
+    const before = fs.readFileSync(hooksPath(root), 'utf8');
+    const preview = install(root, ['--dry-run']);
+    assert.equal(preview.status, 0, preview.stderr);
+    assert.equal(fs.readFileSync(hooksPath(root), 'utf8'), before);
+    const result = install(root);
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    const upgraded = readHooks(root);
+    const startup = upgraded.hooks.SessionStart.flatMap((group) => group.hooks);
+    assert.ok(!startup.some((entry) => entry.command === managed.command), 'managed docs startup hook survived');
+    assert.ok(!startup.some((entry) => entry.command?.startsWith('PATH=') && hookScript(entry.command) === 'docs-sync.cjs' && !entry.commandWindows), 'managed docs startup launcher survived');
+    assert.ok(startup.some((entry) => entry.command === foreign.command));
+    assert.ok(startup.some((entry) => entry.command === custom.command));
+    assert.ok(startup.some((entry) => entry.commandWindows === hybrid.commandWindows), 'migration removed a foreign platform field');
+    assert.ok(upgraded.hooks.Stop.flatMap((group) => group.hooks).some((entry) => hookScript(entry.command) === 'docs-sync.cjs'));
+    assert.ok(fs.existsSync(path.join(root, '.codex/hooks/docs-sync.cjs')), 'on-demand docs hook was deleted');
+  });
+});