@bongos/core 1.24.4 → 1.24.6

package/tests/run_node_reroute.mjs

@@ -0,0 +1,136 @@
+// tests/run_node_reroute.mjs — the hook resolver runs the SESSION's copy of a hook
+// (.claude/hooks/run-node.sh, task 1005015). Claude Code sets $CLAUDE_PROJECT_DIR to the
+// main checkout even in a worktree session, so every hook ran from there; on a stale main
+// checkout that hid the human-task markers (task 1004922) entirely. Each case builds fake
+// checkouts, SPAWNS the real resolver with the real settings.json argument shape, and
+// lets a probe hook report which file ran and what CLAUDE_PROJECT_DIR it saw.
+//
+// The guard hooks run through the resolver too, so the decoy cases matter as much as
+// the happy path: only a linked git worktree OF THIS PROJECT may have its copy run.
+//
+// .claude/hooks/ is package-excluded, so a clean core checkout skips this file
+// (tests/host_topology_skips.mjs carries the allowlist entry).
+//
+// Run:  node tests/run_node_reroute.mjs
+
+import { strict as assert } from 'node:assert';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { skipUnlessPresent } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const RESOLVER = path.join(ROOT, '.claude', 'hooks', 'run-node.sh');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); } catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+skipUnlessPresent(['.claude/hooks/run-node.sh']);
+
+const PROBE = "process.stdout.write(JSON.stringify({ file: __filename, pd: process.env.CLAUDE_PROJECT_DIR }))\n";
+
+// A fake Bongos checkout. `linkTo` makes it a linked worktree of that main checkout the
+// way git does: a .git FILE naming <main>/.git/worktrees/<name>, whose gitdir file points
+// back (git writes forward slashes on every platform). `backTo` forges a wrong back-pointer.
+const fwd = (p) => p.split(path.sep).join('/');
+function checkout(dir, { linkTo = null, backTo = null, core = true, probe = true } = {}) {
+  fs.mkdirSync(path.join(dir, '.claude', 'hooks'), { recursive: true });
+  fs.copyFileSync(RESOLVER, path.join(dir, '.claude', 'hooks', 'run-node.sh'));
+  if (probe) fs.writeFileSync(path.join(dir, '.claude', 'hooks', 'probe.js'), PROBE);
+  if (linkTo) {
+    const admin = path.join(linkTo, '.git', 'worktrees', path.basename(dir));
+    fs.mkdirSync(admin, { recursive: true });
+    fs.writeFileSync(path.join(admin, 'gitdir'), `${fwd(path.join(backTo || dir, '.git'))}\n`);
+    fs.writeFileSync(path.join(dir, '.git'), `gitdir: ${fwd(admin)}\n`);
+  } else {
+    fs.mkdirSync(path.join(dir, '.git'), { recursive: true });
+  }
+  if (core) fs.mkdirSync(path.join(dir, 'src', 'bongos'), { recursive: true });
+  return dir;
+}
+
+// The argument shape settings.json uses: "$CLAUDE_PROJECT_DIR/.claude/hooks/<hook>.js".
+function run({ main, cwd, env = {} }) {
+  const r = spawnSync('sh', [path.join(main, '.claude', 'hooks', 'run-node.sh'), `${main}/.claude/hooks/probe.js`], {
+    cwd,
+    env: { ...process.env, CLAUDE_PROJECT_DIR: main, OTB_NODE_BIN: process.execPath, OTB_HOOKS_FROM_PROJECT_DIR: '', ...env },
+    encoding: 'utf8',
+  });
+  if (r.error) throw r.error;
+  assert.equal(r.status, 0, `resolver exited ${r.status}: ${r.stderr}`);
+  return JSON.parse(r.stdout);
+}
+
+// Windows paths are case-insensitive, and the resolver hands node a lower-case drive.
+const canon = (p) => (process.platform === 'win32' ? fs.realpathSync.native(p).toLowerCase() : fs.realpathSync(p));
+const same = (a, b) => canon(a) === canon(b);
+
+if (spawnSync('sh', ['-c', 'exit 0']).status !== 0) {
+  console.log('SKIP run_node_reroute: no `sh` on PATH');
+  process.exit(0);
+}
+
+// realpath: on Windows os.tmpdir() can be an 8.3 short name (GMK1_P~1), which git never
+// writes and the shell's $PWD never shows, so the fixture's paths would not compare.
+const tmp = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-reroute-')));
+const main = checkout(path.join(tmp, 'main'));
+const MAIN_PROBE = path.join(main, '.claude', 'hooks', 'probe.js');
+const wt = checkout(path.join(main, '.claude', 'worktrees', 'wt'), { linkTo: main });
+fs.mkdirSync(path.join(wt, 'deep', 'er'), { recursive: true });
+const ranMain = (out) => assert.ok(same(out.file, MAIN_PROBE), `ran ${out.file}`);
+
+t('a hook fired from inside a worktree runs the worktree\'s copy, with CLAUDE_PROJECT_DIR pointed at it', () => {
+  const out = run({ main, cwd: path.join(wt, 'deep', 'er') });
+  assert.ok(same(out.file, path.join(wt, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+  assert.ok(same(out.pd, wt), `CLAUDE_PROJECT_DIR was ${out.pd}`);
+});
+
+t('a linked worktree outside the main folder reroutes too', () => {
+  const linked = checkout(path.join(tmp, 'linked'), { linkTo: main });
+  const out = run({ main, cwd: linked });
+  assert.ok(same(out.file, path.join(linked, '.claude', 'hooks', 'probe.js')), `ran ${out.file}`);
+});
+
+t('a hook fired from the main checkout itself runs unchanged', () => {
+  const out = run({ main, cwd: main });
+  ranMain(out);
+  assert.equal(out.pd, main);
+});
+
+t('OTB_HOOKS_FROM_PROJECT_DIR=1 turns the reroute off', () => {
+  ranMain(run({ main, cwd: wt, env: { OTB_HOOKS_FROM_PROJECT_DIR: '1' } }));
+});
+
+t('a worktree that cannot resolve the core (no src/bongos, no node_modules) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'bare'), { linkTo: main, core: false }) }));
+});
+
+t('a worktree whose branch lacks the hook keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'old'), { linkTo: main, probe: false }) }));
+});
+
+t('a folder outside any checkout keeps the main copy', () => {
+  ranMain(run({ main, cwd: fs.mkdtempSync(path.join(os.tmpdir(), 'run-node-loose-')) }));
+});
+
+t('a look-alike with a .git dir and its own hooks (not a worktree) keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy')) }));
+});
+
+t('a decoy whose .git file names a gitdir outside the project keeps the main copy', () => {
+  const other = checkout(path.join(tmp, 'other-main'));
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy2'), { linkTo: other }) }));
+});
+
+t('a decoy pointing into the project whose back-pointer names another folder keeps the main copy', () => {
+  ranMain(run({ main, cwd: checkout(path.join(tmp, 'decoy3'), { linkTo: main, backTo: wt }) }));
+});
+
+fs.rmSync(tmp, { recursive: true, force: true });
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exitCode = failed ? 1 : 0;