a9a7a328e6
Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD across contents and paths, upstream package/repo coordinates -> @golem15/msd-core and golem15com/msd-core. Deep links into upstream history, sibling upstream packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is. Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line, package/plugin identity, regenerated lockfile, install-tree fixtures, derived registries and benchmark baseline; migration checksum baseline re-locked (MSD keeps its own install state, so no install had applied the old sums); sort-order and regex-escaped expectations in tests adjusted.
403 lines
20 KiB
JavaScript
403 lines
20 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Windsurf/Cascade HOOK-BRIDGE upgrade — ADR-1239 / #2100 Stage 2.
|
|
*
|
|
* Stage 1 (folds) drove Windsurf's install onto the declarative capability
|
|
* descriptor (hostBehaviors) while leaving `hooksSurface: "none"`. Stage 2
|
|
* wires MSD's guard logic into Cascade's native hook bus: `.windsurf/hooks.json`
|
|
* (local) / `~/.codeium/windsurf/hooks.json` (global), with TWO blocking
|
|
* events — `pre_write_code` and `pre_run_command`. Cascade blocks via EXIT
|
|
* CODE 2 (+ a stderr reason), unlike Cursor's stdout-JSON `{ block, reason }`
|
|
* form — so this is a DIFFERENT protocol wired through the SAME infra shape
|
|
* as writeCursorHooksJson/removeCursorHooksJson (mirrors
|
|
* tests/cursor-hooks.test.cjs + tests/cursor-hook-bus-upgrade.test.cjs).
|
|
*
|
|
* Cascade has no context-injection channel (no `additional_context`-style
|
|
* advisory response), so the 4 advisory hooks MSD registers on Cursor
|
|
* (sessionStart, postToolUse, stop, subagentStart/subagentStop) have no
|
|
* Windsurf counterpart and are deliberately NOT ported.
|
|
*
|
|
* Test plan:
|
|
* Guard scripts (spawned directly, real process, real exit codes):
|
|
* G1 pre-write: file resolves to a different git root than cwd -> exit 2 + stderr
|
|
* G2 pre-write: file resolves to the SAME git root as cwd -> exit 0
|
|
* G3 pre-write: malformed JSON on stdin -> fail-open exit 0
|
|
* G4 pre-write: empty stdin -> fail-open exit 0
|
|
* G5 pre-command: a destructive command_line -> exit 2 + stderr
|
|
* G6 pre-command: a benign command_line -> exit 0
|
|
* G8 pre-command: prefixed/evasive rm -rf and force-push refspec forms -> exit 2
|
|
* G9 pre-command: force-push false-positive forms (comment/branch-name-contains) -> exit 0
|
|
* G10 pre-command: ReDoS-guard — oversized rm-shaped payload -> exit 0 in well under 1s
|
|
* G7 pre-command: malformed JSON on stdin -> fail-open exit 0
|
|
* Writer/reconcile (in-process, pure + one real install):
|
|
* W1 writeWindsurfHooksJson installs both scripts + both hooks.json entries
|
|
* W2 reconcileWindsurfHooksJson preserves user-owned entries
|
|
* W3 removeWindsurfHooksJson removes hooks.json when it becomes empty
|
|
* W4 removeWindsurfHooksJson preserves hooks.json when user entries remain
|
|
* W5 WINDSURF_HOOK_EVENTS / WINDSURF_EVENT_SCRIPT_MAP shape
|
|
* W6 hook scripts exist under hooks/
|
|
*/
|
|
|
|
const { test, describe } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const os = require('node:os');
|
|
const { runHook: runHookSeam } = require('./helpers/process-seam.cjs');
|
|
const { gitOrThrow } = require('./helpers/git-fixture.cjs');
|
|
const { QUICK_SPAWN_TIMEOUT_MS } = require('./helpers/timeouts.cjs');
|
|
|
|
const { createTempDir, cleanup } = require('./helpers.cjs');
|
|
|
|
const {
|
|
WINDSURF_HOOK_EVENTS,
|
|
WINDSURF_EVENT_SCRIPT_MAP,
|
|
MSD_WINDSURF_HOOK_MARKER,
|
|
MSD_WINDSURF_PRE_WRITE_HOOK_SCRIPT,
|
|
MSD_WINDSURF_PRE_COMMAND_HOOK_SCRIPT,
|
|
isManagedWindsurfHookEntry,
|
|
reconcileWindsurfHooksJson,
|
|
writeWindsurfHooksJson,
|
|
removeWindsurfHooksJson,
|
|
} = require('../msd-core/bin/lib/runtime-hooks-surface.cjs');
|
|
|
|
const HOOKS_DIR = path.join(__dirname, '..', 'hooks');
|
|
const PRE_WRITE_SCRIPT = path.join(HOOKS_DIR, MSD_WINDSURF_PRE_WRITE_HOOK_SCRIPT);
|
|
const PRE_COMMAND_SCRIPT = path.join(HOOKS_DIR, MSD_WINDSURF_PRE_COMMAND_HOOK_SCRIPT);
|
|
|
|
function runHook(scriptPath, payload, opts = {}) {
|
|
const input = payload === undefined ? '' : (typeof payload === 'string' ? payload : JSON.stringify(payload));
|
|
const r = runHookSeam(scriptPath, [], {
|
|
input,
|
|
timeoutMs: QUICK_SPAWN_TIMEOUT_MS,
|
|
cwd: opts.cwd || os.tmpdir(),
|
|
});
|
|
return { status: r.exitCode, stdout: r.stdout, stderr: r.stderr, signal: r.signal };
|
|
}
|
|
|
|
function initGitRepo(dir) {
|
|
gitOrThrow(['init', '-q', '.'], { cwd: dir });
|
|
gitOrThrow(['config', 'user.email', 'msd-test@example.com'], { cwd: dir });
|
|
gitOrThrow(['config', 'user.name', 'msd-test'], { cwd: dir });
|
|
gitOrThrow(['commit', '--allow-empty', '-q', '-m', 'init'], { cwd: dir });
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Guard scripts — spawned directly, real exit codes
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('msd-windsurf-pre-write.js (pre_write_code guard)', () => {
|
|
test('G1: a write resolving to a DIFFERENT git root than cwd -> exit 2 + stderr reason', (t) => {
|
|
const cwdRepo = createTempDir('msd-windsurf-write-cwd-');
|
|
const otherRepo = createTempDir('msd-windsurf-write-other-');
|
|
t.after(() => { cleanup(cwdRepo); cleanup(otherRepo); });
|
|
initGitRepo(cwdRepo);
|
|
initGitRepo(otherRepo);
|
|
fs.writeFileSync(path.join(otherRepo, 'target.txt'), 'x');
|
|
|
|
const result = runHook(PRE_WRITE_SCRIPT, {
|
|
agent_action_name: 'pre_write_code',
|
|
tool_info: { file_path: path.join(otherRepo, 'target.txt') },
|
|
}, { cwd: cwdRepo });
|
|
|
|
// hooks/msd-windsurf-pre-write.js gives every git probe a 2000 ms budget
|
|
// (SPAWNOPT.timeout) and, by documented design, fails OPEN (exit 0) via
|
|
// hooks/lib/git-probe.js's reportIfUndetermined() (#3911) when the probe
|
|
// cannot be resolved in time — its own header records a macOS CI run
|
|
// landing at 2084ms/2112ms/2177ms, just past the budget. This is NOT a
|
|
// tolerated flake: both halves of the hook's contract are asserted below,
|
|
// and which half applies is decided by the observed probe outcome, not
|
|
// guessed in advance.
|
|
const probeUndetermined = /git probe '[^']+'.*allowing this call because the probe's answer is unknown/.test(result.stderr);
|
|
if (probeUndetermined) {
|
|
assert.equal(result.status, 0, `probe was undetermined, so the hook must fail OPEN (exit 0), got ${result.status} (stderr: ${result.stderr})`);
|
|
} else {
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /differs from the active project root|inside a git internal/);
|
|
}
|
|
});
|
|
|
|
test('G1b: a write inside a DIFFERENT repo\'s .git internals -> exit 2 + stderr reason', (t) => {
|
|
const cwdRepo = createTempDir('msd-windsurf-write-cwd-');
|
|
const otherRepo = createTempDir('msd-windsurf-write-other-');
|
|
t.after(() => { cleanup(cwdRepo); cleanup(otherRepo); });
|
|
initGitRepo(cwdRepo);
|
|
initGitRepo(otherRepo);
|
|
|
|
const result = runHook(PRE_WRITE_SCRIPT, {
|
|
tool_info: { file_path: path.join(otherRepo, '.git', 'config') },
|
|
}, { cwd: cwdRepo });
|
|
|
|
// Same rationale as G1 above: hooks/msd-windsurf-pre-write.js's 2000 ms
|
|
// per-probe budget, its documented fail-open, and hooks/lib/git-probe.js's
|
|
// reportIfUndetermined() (#3911) mean an undetermined probe is a
|
|
// legitimate, documented outcome (CI observed 2084ms/2112ms/2177ms —
|
|
// just past budget), not a flake to be tolerated by loosening the assert.
|
|
const probeUndetermined = /git probe '[^']+'.*allowing this call because the probe's answer is unknown/.test(result.stderr);
|
|
if (probeUndetermined) {
|
|
assert.equal(result.status, 0, `probe was undetermined, so the hook must fail OPEN (exit 0), got ${result.status} (stderr: ${result.stderr})`);
|
|
} else {
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /inside a git internal \(\.git\) directory/);
|
|
}
|
|
});
|
|
|
|
test('G2: a write resolving to the SAME git root as cwd -> exit 0 (allowed)', (t) => {
|
|
const repo = createTempDir('msd-windsurf-write-same-');
|
|
t.after(() => cleanup(repo));
|
|
initGitRepo(repo);
|
|
fs.mkdirSync(path.join(repo, 'sub'));
|
|
|
|
const result = runHook(PRE_WRITE_SCRIPT, {
|
|
tool_info: { file_path: 'sub/new-file.txt' },
|
|
}, { cwd: repo });
|
|
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G3: malformed JSON on stdin -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_WRITE_SCRIPT, 'not-json-at-all{{{');
|
|
assert.equal(result.status, 0);
|
|
});
|
|
|
|
test('G4: empty stdin -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_WRITE_SCRIPT, '');
|
|
assert.equal(result.status, 0);
|
|
});
|
|
|
|
test('missing tool_info.file_path -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_WRITE_SCRIPT, { tool_info: {} });
|
|
assert.equal(result.status, 0);
|
|
});
|
|
});
|
|
|
|
describe('msd-windsurf-pre-command.js (pre_run_command guard)', () => {
|
|
test('G5: a destructive command_line (rm -rf /) -> exit 2 + stderr reason', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'rm -rf /' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /rm -rf targeting the filesystem root/);
|
|
});
|
|
|
|
test('G5b: git push --force targeting a protected branch -> exit 2 + stderr reason', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'git push --force origin main' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /protected branch 'main'/);
|
|
});
|
|
|
|
test('G6: a benign command_line -> exit 0 (allowed)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'npm test' } });
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G6b: rm -rf against an ordinary project path -> exit 0 (allowed, not a root wipe)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'rm -rf /tmp/msd-scratch-dir' } });
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G6c: git push --force to a feature branch -> exit 0 (allowed, not protected)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'git push --force origin feature/123' } });
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G8: sudo-prefixed rm -rf / -> exit 2 (evasion via command prefix)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'sudo rm -rf /' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /rm -rf targeting the filesystem root/);
|
|
});
|
|
|
|
test('G8b: absolute-path rm -rf / (/bin/rm) -> exit 2 (evasion via basename)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: '/bin/rm -rf /' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /rm -rf targeting the filesystem root/);
|
|
});
|
|
|
|
test('G8c: git push -f origin HEAD:main -> exit 2 (refspec targeting protected branch)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'git push -f origin HEAD:main' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /protected branch 'main'/);
|
|
});
|
|
|
|
test('G8d: git push origin +main -> exit 2 (+-prefixed force refspec)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'git push origin +main' } });
|
|
assert.equal(result.status, 2, `expected exit 2, got ${result.status} (stderr: ${result.stderr})`);
|
|
assert.match(result.stderr, /protected branch 'main'/);
|
|
});
|
|
|
|
test('G9: git push --force to a feature branch with a trailing comment mentioning main -> exit 0 (not a false positive)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, {
|
|
tool_info: { command_line: 'git push --force origin feature/foo # deploy to main' },
|
|
});
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G9b: git push --force to feature/main-fix -> exit 0 (branch name only CONTAINS "main", not a false positive)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'git push --force origin feature/main-fix' } });
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G9c: env-prefixed benign command -> exit 0 (env prefix alone is not destructive)', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: 'env FOO=1 npm test' } });
|
|
assert.equal(result.status, 0, `expected exit 0, got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G10: ReDoS-guard — a 200000+-char rm -rf-shaped payload is handled without catastrophic backtracking (length cap)', () => {
|
|
const payload = `rm -${'r'.repeat(200000)}!`;
|
|
// The ReDoS guard is `runHook`'s seam `timeoutMs: 10000`: catastrophic
|
|
// backtracking on this payload would run for minutes, so the hook is
|
|
// SIGKILL'd and returns a non-zero status — the exit-0 assertion below IS
|
|
// the ReDoS check. (The prior `elapsedMs < 1000` wall-clock assertion was
|
|
// redundant with that and flaked on a loaded bench at ~1.1s — CLAUDE.md:
|
|
// do not assert on wall-clock time.)
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: { command_line: payload } });
|
|
assert.equal(result.status, 0, `expected exit 0 (length-capped allow, no ReDoS timeout), got ${result.status} (stderr: ${result.stderr})`);
|
|
});
|
|
|
|
test('G7: malformed JSON on stdin -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, 'not-json-at-all{{{');
|
|
assert.equal(result.status, 0);
|
|
});
|
|
|
|
test('empty stdin -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, '');
|
|
assert.equal(result.status, 0);
|
|
});
|
|
|
|
test('missing tool_info.command_line -> fail-open exit 0', () => {
|
|
const result = runHook(PRE_COMMAND_SCRIPT, { tool_info: {} });
|
|
assert.equal(result.status, 0);
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// W5/W6: constants + on-disk scripts
|
|
// ---------------------------------------------------------------------------
|
|
|
|
test('W5: WINDSURF_HOOK_EVENTS is exactly the 2 wired Cascade events', () => {
|
|
assert.deepEqual([...WINDSURF_HOOK_EVENTS].sort(), ['pre_run_command', 'pre_write_code']);
|
|
});
|
|
|
|
test('W5b: WINDSURF_EVENT_SCRIPT_MAP maps every event to a .js script', () => {
|
|
for (const ev of WINDSURF_HOOK_EVENTS) {
|
|
const script = WINDSURF_EVENT_SCRIPT_MAP[ev];
|
|
assert.ok(typeof script === 'string' && script.endsWith('.js'), `${ev} must map to a .js script, got: ${script}`);
|
|
}
|
|
});
|
|
|
|
test('W6: both hook scripts exist under hooks/', () => {
|
|
assert.ok(fs.existsSync(PRE_WRITE_SCRIPT), 'hooks/msd-windsurf-pre-write.js must exist');
|
|
assert.ok(fs.existsSync(PRE_COMMAND_SCRIPT), 'hooks/msd-windsurf-pre-command.js must exist');
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// W1: writeWindsurfHooksJson — direct writer call
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('writeWindsurfHooksJson', () => {
|
|
test('W1: installs both scripts and both hooks.json entries with the marker', (t) => {
|
|
const targetDir = createTempDir('msd-windsurf-writer-');
|
|
t.after(() => cleanup(targetDir));
|
|
const src = path.join(__dirname, '..');
|
|
|
|
const result = writeWindsurfHooksJson(targetDir, src, { platform: process.platform });
|
|
assert.equal(result.hooksJsonPath, path.join(targetDir, 'hooks.json'));
|
|
assert.ok(result.changed, 'first write must report changed=true');
|
|
|
|
assert.ok(fs.existsSync(path.join(targetDir, 'hooks', MSD_WINDSURF_PRE_WRITE_HOOK_SCRIPT)), 'pre-write script must be installed');
|
|
assert.ok(fs.existsSync(path.join(targetDir, 'hooks', MSD_WINDSURF_PRE_COMMAND_HOOK_SCRIPT)), 'pre-command script must be installed');
|
|
|
|
const written = JSON.parse(fs.readFileSync(result.hooksJsonPath, 'utf8'));
|
|
assert.ok(written.hooks && typeof written.hooks === 'object', 'hooks.json must have a nested hooks table');
|
|
for (const ev of WINDSURF_HOOK_EVENTS) {
|
|
assert.ok(Array.isArray(written.hooks[ev]), `hooks.json must have a ${ev} array`);
|
|
assert.equal(written.hooks[ev].length, 1, `${ev} must have exactly 1 managed entry`);
|
|
assert.equal(written.hooks[ev][0][MSD_WINDSURF_HOOK_MARKER], true, `${ev} entry must carry the MSD managed marker`);
|
|
assert.equal(typeof written.hooks[ev][0].command, 'string', `${ev} entry command must be a bare string (Cascade shape, not Cursor's {type,command})`);
|
|
assert.equal(written.hooks[ev][0].type, undefined, `${ev} entry must NOT have Cursor's 'type' field`);
|
|
}
|
|
});
|
|
|
|
test('W1b: is idempotent (second write reports changed=false)', (t) => {
|
|
const targetDir = createTempDir('msd-windsurf-writer-idem-');
|
|
t.after(() => cleanup(targetDir));
|
|
const src = path.join(__dirname, '..');
|
|
|
|
writeWindsurfHooksJson(targetDir, src, { platform: process.platform });
|
|
const second = writeWindsurfHooksJson(targetDir, src, { platform: process.platform });
|
|
assert.equal(second.changed, false, 're-running the writer with no changes must report changed=false');
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// W2/W3/W4: reconcileWindsurfHooksJson / removeWindsurfHooksJson
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('reconcileWindsurfHooksJson / removeWindsurfHooksJson', () => {
|
|
function managedEntry(command) {
|
|
return { command, [MSD_WINDSURF_HOOK_MARKER]: true };
|
|
}
|
|
function userEntry(command) {
|
|
return { command };
|
|
}
|
|
|
|
test('W2: preserves user-owned entries across both events', (t) => {
|
|
const dir = createTempDir('msd-windsurf-reconcile-');
|
|
t.after(() => cleanup(dir));
|
|
const hooksJsonPath = path.join(dir, 'hooks.json');
|
|
fs.writeFileSync(hooksJsonPath, JSON.stringify({
|
|
hooks: {
|
|
pre_write_code: [userEntry('echo user-write-hook')],
|
|
pre_run_command: [userEntry('echo user-command-hook')],
|
|
},
|
|
}, null, 2) + '\n');
|
|
|
|
const managedEntries = {
|
|
pre_write_code: managedEntry('node /msd/pre-write.js'),
|
|
pre_run_command: managedEntry('node /msd/pre-command.js'),
|
|
};
|
|
reconcileWindsurfHooksJson(hooksJsonPath, managedEntries);
|
|
|
|
const written = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8'));
|
|
assert.equal(written.hooks.pre_write_code.length, 2, 'pre_write_code: 1 user + 1 managed');
|
|
assert.equal(written.hooks.pre_run_command.length, 2, 'pre_run_command: 1 user + 1 managed');
|
|
assert.ok(written.hooks.pre_write_code.some((e) => e.command === 'echo user-write-hook'));
|
|
assert.ok(written.hooks.pre_write_code.some((e) => isManagedWindsurfHookEntry(e)));
|
|
});
|
|
|
|
test('W3: removeWindsurfHooksJson removes hooks.json when it becomes empty', (t) => {
|
|
const dir = createTempDir('msd-windsurf-remove-empty-');
|
|
t.after(() => cleanup(dir));
|
|
const hooksJsonPath = path.join(dir, 'hooks.json');
|
|
reconcileWindsurfHooksJson(hooksJsonPath, {
|
|
pre_write_code: managedEntry('node /msd/pre-write.js'),
|
|
pre_run_command: managedEntry('node /msd/pre-command.js'),
|
|
});
|
|
assert.ok(fs.existsSync(hooksJsonPath));
|
|
|
|
const result = removeWindsurfHooksJson(dir);
|
|
assert.equal(result.changed, true);
|
|
assert.equal(fs.existsSync(hooksJsonPath), false, 'empty hooks.json must be removed');
|
|
});
|
|
|
|
test('W4: removeWindsurfHooksJson preserves hooks.json when user entries remain', (t) => {
|
|
const dir = createTempDir('msd-windsurf-remove-preserve-');
|
|
t.after(() => cleanup(dir));
|
|
const hooksJsonPath = path.join(dir, 'hooks.json');
|
|
fs.writeFileSync(hooksJsonPath, JSON.stringify({
|
|
hooks: {
|
|
pre_write_code: [
|
|
managedEntry('node /msd/pre-write.js'),
|
|
userEntry('echo user-write-hook'),
|
|
],
|
|
},
|
|
}, null, 2) + '\n');
|
|
|
|
removeWindsurfHooksJson(dir);
|
|
|
|
assert.ok(fs.existsSync(hooksJsonPath), 'hooks.json must remain (user entries present)');
|
|
const written = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8'));
|
|
assert.equal(written.hooks.pre_write_code.length, 1);
|
|
assert.equal(written.hooks.pre_write_code[0].command, 'echo user-write-hook');
|
|
});
|
|
});
|