Files
ECC/tests/hooks/run-with-flags-truncation.test.js
T

204 lines
7.7 KiB
JavaScript

/**
* Regression tests for #2222: run-with-flags.js must not echo truncated stdin.
*
* Before the fix, every fallthrough path echoed the truncated payload to
* stdout. The harness parses hook stdout as JSON, got a document cut
* mid-stream, and treated the hook as failed — blocking every Edit/Write
* whose hook payload exceeded the 1MB cap.
*/
'use strict';
const assert = require('assert');
const path = require('path');
const { spawnSync } = require('child_process');
const repoRoot = path.join(__dirname, '..', '..');
const runner = path.join(repoRoot, 'scripts', 'hooks', 'run-with-flags.js');
const MAX_STDIN = 1024 * 1024;
function test(name, fn) {
try {
fn();
console.log(` ✓ ${name}`);
return true;
} catch (error) {
console.log(` ✗ ${name}`);
console.log(` Error: ${error.message}`);
return false;
}
}
function runRunner(args, input, env = {}) {
return spawnSync('node', [runner, ...args], {
input,
encoding: 'utf8',
cwd: repoRoot,
env: { ...process.env, ...env },
timeout: 30000,
maxBuffer: 16 * 1024 * 1024,
stdio: ['pipe', 'pipe', 'pipe']
});
}
function oversizedPayload() {
// JSON document that exceeds MAX_STDIN so the runner's stdin cap trips.
return JSON.stringify({
tool_name: 'Write',
tool_input: { file_path: '/tmp/big.md', content: 'x'.repeat(MAX_STDIN + 64 * 1024) }
});
}
console.log('\nrun-with-flags truncation (fail-open) tests:');
let passed = 0;
let failed = 0;
if (
test('oversized payload exits 0 with empty stdout for an enabled hook', () => {
const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], oversizedPayload());
assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}: ${result.stderr}`);
assert.strictEqual(result.stdout, '', `stdout must be empty, got: ${result.stdout.slice(0, 120)}...`);
assert.match(result.stderr, /stdin exceeded \d+ bytes for pre:write:doc-file-warning/);
assert.match(result.stderr, /suppressing raw passthrough/);
})
)
passed++;
else failed++;
if (
test('oversized payload never echoes truncated stdin when hook args are missing', () => {
const result = runRunner([], oversizedPayload());
assert.strictEqual(result.status, 0);
assert.strictEqual(result.stdout, '', 'missing-args path must not echo truncated stdin');
})
)
passed++;
else failed++;
if (
test('oversized payload never echoes truncated stdin for a disabled hook', () => {
const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], oversizedPayload(), { ECC_DISABLED_HOOKS: 'pre:write:doc-file-warning' });
assert.strictEqual(result.status, 0);
assert.strictEqual(result.stdout, '', 'disabled-hook path must not echo truncated stdin');
})
)
passed++;
else failed++;
if (
test('normal-sized no-output hook stays silent', () => {
const payload = JSON.stringify({
tool_name: 'Write',
tool_input: { file_path: '/tmp/small.js', content: 'const x = 1;\n' }
});
const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], payload);
assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}: ${result.stderr}`);
assert.strictEqual(result.stdout, '', 'silent hooks must not echo normal payloads');
})
)
passed++;
else failed++;
if (
test('a security hook can still block on an oversized payload (no blanket skip)', () => {
// config-protection refuses to fail open on truncated payloads. The
// runner must still execute the hook and forward its verdict — only the
// runner's own raw-echo is suppressed.
const payload = JSON.stringify({
tool_name: 'Write',
tool_input: { file_path: '.eslintrc.js', content: 'x'.repeat(MAX_STDIN + 2048) }
});
const result = runRunner(['pre:config-protection', 'scripts/hooks/config-protection.js', 'standard,strict'], payload);
assert.strictEqual(result.status, 2, `expected block exit 2, got ${result.status}: ${result.stderr}`);
assert.strictEqual(result.stdout, '', 'blocked truncated payload must not echo raw input');
})
)
passed++;
else failed++;
if (
test('missing-args path stays silent just under the cap', () => {
const content = 'y'.repeat(MAX_STDIN - 1024);
const payload = JSON.stringify({ tool_name: 'Write', tool_input: { file_path: '/tmp/edge.md', content } });
assert.ok(payload.length < MAX_STDIN, 'fixture must stay under the stdin cap');
const result = runRunner([], payload);
assert.strictEqual(result.status, 0);
assert.strictEqual(result.stdout, '', 'missing-args path must not echo sub-cap payloads');
})
)
passed++;
else failed++;
if (
test('disabled hook stays silent for a >64KB payload', () => {
const payload = JSON.stringify({
tool_name: 'Write',
tool_input: { file_path: '/tmp/medium.md', content: 'z'.repeat(256 * 1024) }
});
const result = runRunner(['pre:write:doc-file-warning', 'scripts/hooks/doc-file-warning.js', 'standard,strict'], payload, { ECC_DISABLED_HOOKS: 'pre:write:doc-file-warning' });
assert.strictEqual(result.status, 0);
assert.strictEqual(result.stdout, '');
})
)
passed++;
else failed++;
function oversizedToolPayload(toolName, toolInput) {
return JSON.stringify({ session_id: 'trunc', tool_name: toolName, tool_input: toolInput, pad: 'p'.repeat(MAX_STDIN + 2048) });
}
// Pin every switch that decides whether the hook runs, so an inherited
// ECC_DISABLED_HOOKS / profile / cap cannot make these pass or fail by accident.
const GATEGUARD_ENV_BASELINE = {
CLAUDE_PLUGIN_ROOT: repoRoot,
ECC_HOOK_CONFIG: path.join(repoRoot, 'tests', 'fixtures', 'no-such-hook-config.json'),
ECC_HOOKS_ENABLED: 'true',
ECC_HOOK_PROFILE: 'standard',
ECC_DISABLED_HOOKS: '',
ECC_DRY_RUN: '',
ECC_HOOK_INPUT_MAX_BYTES: String(MAX_STDIN),
ECC_HOOK_INPUT_TRUNCATED_UPSTREAM: '',
ECC_GATEGUARD: '',
GATEGUARD_DISABLED: ''
};
const GATEGUARD_TRUNCATION_CASES = [
['pre:bash:gateguard-fact-force', 'Bash', { command: 'git reset --hard' }],
['pre:edit-write:gateguard-fact-force', 'Edit', { file_path: '/tmp/a.py', old_string: 'a', new_string: 'b' }],
['pre:powershell:gateguard-fact-force', 'PowerShell', { command: 'Remove-Item -Recurse build' }]
];
for (const [hookId, toolName, toolInput] of GATEGUARD_TRUNCATION_CASES) {
if (
test(`${hookId} fails closed on an oversized payload (#3762)`, () => {
const result = runRunner([hookId, 'scripts/hooks/gateguard-fact-force.js', 'standard,strict'], oversizedToolPayload(toolName, toolInput), GATEGUARD_ENV_BASELINE);
assert.strictEqual(result.status, 2, `expected block exit 2, got ${result.status}: ${result.stderr}`);
assert.ok(result.stderr.includes(`could not safely inspect`), result.stderr);
assert.strictEqual(result.stdout, '', 'blocked truncated payload must not echo raw input');
})
)
passed++;
else failed++;
for (const offEnv of [{ ECC_GATEGUARD: 'off' }, { GATEGUARD_DISABLED: '1' }, { ECC_DISABLED_HOOKS: hookId }]) {
if (
test(`${hookId} oversized payload passes when GateGuard is off via ${Object.keys(offEnv)[0]}`, () => {
const result = runRunner([hookId, 'scripts/hooks/gateguard-fact-force.js', 'standard,strict'], oversizedToolPayload(toolName, toolInput), {
...GATEGUARD_ENV_BASELINE,
...offEnv
});
assert.strictEqual(result.status, 0, `expected exit 0 with GateGuard off, got ${result.status}: ${result.stderr}`);
assert.strictEqual(result.stdout, '');
})
)
passed++;
else failed++;
}
}
console.log(`\nPassed: ${passed}`);
console.log(`Failed: ${failed}\n`);
process.exit(failed > 0 ? 1 : 0);