Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

fix(hooks): preserve complete bounded passthrough payloads

haelyra20b1ba423e89
diff --git a/scripts/hooks/check-console-log.js b/scripts/hooks/check-console-log.js
index 94e60a152..28f3ac6db 100755
--- a/scripts/hooks/check-console-log.js
+++ b/scripts/hooks/check-console-log.js
@@ -26,29 +26,31 @@ const EXCLUDED_PATTERNS = [
/__mocks__\//,
];
-const MAX_STDIN = 1024 * 1024; // 1MB limit
+const MAX_DIRECT_STDIN_BYTES = 16 * 1024 * 1024;
let data = '';
-let truncated = false;
+let stdinBytes = 0;
+let oversized = false;
process.stdin.setEncoding('utf8');
process.stdin.on('data', chunk => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += chunk.substring(0, remaining);
- if (chunk.length > remaining) truncated = true;
- } else {
- truncated = true;
+ if (oversized) return;
+ stdinBytes += Buffer.byteLength(chunk, 'utf8');
+ if (stdinBytes > MAX_DIRECT_STDIN_BYTES) {
+ data = '';
+ oversized = true;
+ return;
}
+ data += chunk;
});
/**
* Echo stdin back (ECC pass-through convention), then exit once the pipe has
- * flushed. Truncated stdin is never echoed: a JSON document cut mid-stream is
- * reported by the harness as a Stop hook JSON validation failure (#2090).
+ * flushed. Direct/legacy entrypoints preserve complete supported payloads up
+ * to 16MiB; the production runner applies its stricter bounded-input policy.
*/
function passThroughAndExit() {
- if (truncated) {
- log('[Hook] check-console-log: stdin exceeded 1MB; suppressing pass-through (fail-open)');
+ if (oversized) {
+ log('[Hook] check-console-log: direct stdin exceeded 16MiB; suppressing pass-through');
process.exit(0);
}
if (!data) {
@@ -85,6 +87,6 @@ process.stdin.on('end', () => {
log(`[Hook] check-console-log error: ${err.message}`);
}
- // Always output the original data (unless truncated)
+ // Always output the complete original data.
passThroughAndExit();
});
diff --git a/scripts/hooks/doc-file-warning.js b/scripts/hooks/doc-file-warning.js
index 40d0282ab..d26a9fa80 100644
--- a/scripts/hooks/doc-file-warning.js
+++ b/scripts/hooks/doc-file-warning.js
@@ -16,7 +16,7 @@
const path = require('path');
const { buildPreToolUseAdditionalContext } = require('./pretooluse-visible-output');
-const MAX_STDIN = 1024 * 1024;
+const MAX_DIRECT_STDIN_BYTES = 16 * 1024 * 1024;
// Known ad-hoc filenames that indicate impulse/scratch files (case-sensitive, uppercase only)
const ADHOC_FILENAMES = /^(NOTES|TODO|SCRATCH|TEMP|DRAFT|BRAINSTORM|SPIKE|DEBUG|WIP)\.(md|txt)$/;
@@ -71,21 +71,29 @@ function run(inputOrRaw, _options = {}) {
/**
* Stdin entrypoint for direct/spawnSync execution: reads the hook payload from
- * stdin (capped at MAX_STDIN), runs the policy, and writes the PreToolUse result
- * to stdout. Must only run when invoked directly, never on require(), so the
- * stdin listeners are not leaked into a parent that loads this hook in-process.
+ * stdin, runs the policy, and writes the PreToolUse result to stdout. Direct
+ * and legacy entrypoints preserve complete supported payloads up to 16MiB;
+ * the production runner applies its stricter bounded-input policy. Must only
+ * run when invoked directly so stdin listeners are not leaked into a parent.
*/
function main() {
let data = '';
+ let stdinBytes = 0;
+ let oversized = false;
process.stdin.setEncoding('utf8');
process.stdin.on('data', c => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += c.substring(0, remaining);
+ if (oversized) return;
+ stdinBytes += Buffer.byteLength(c, 'utf8');
+ if (stdinBytes > MAX_DIRECT_STDIN_BYTES) {
+ data = '';
+ oversized = true;
+ return;
}
+ data += c;
});
process.stdin.on('end', () => {
+ if (oversized) return;
const result = run(data);
if (result.stderr) {
diff --git a/scripts/hooks/post-edit-console-warn.js b/scripts/hooks/post-edit-console-warn.js
index 8002beb93..f2ce096c2 100644
--- a/scripts/hooks/post-edit-console-warn.js
+++ b/scripts/hooks/post-edit-console-warn.js
@@ -11,7 +11,7 @@
const { readFile } = require('../lib/utils');
-const MAX_STDIN = 1024 * 1024; // 1MB limit
+const MAX_DIRECT_STDIN_BYTES = 16 * 1024 * 1024;
function run(data) {
const warnings = [];
try {
@@ -47,14 +47,24 @@ function run(data) {
if (require.main === module) {
let data = '';
+ let stdinBytes = 0;
+ let oversized = false;
process.stdin.setEncoding('utf8');
process.stdin.on('data', chunk => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += chunk.substring(0, remaining);
+ if (oversized) return;
+ stdinBytes += Buffer.byteLength(chunk, 'utf8');
+ if (stdinBytes > MAX_DIRECT_STDIN_BYTES) {
+ data = '';
+ oversized = true;
+ return;
}
+ data += chunk;
});
process.stdin.on('end', () => {
+ if (oversized) {
+ process.exitCode = 0;
+ return;
+ }
const result = run(data);
if (result.stderr) process.stderr.write(`${result.stderr}\n`);
process.stdout.write(result.stdout);
diff --git a/scripts/hooks/post-edit-format.js b/scripts/hooks/post-edit-format.js
index 26a79f939..d79409841 100644
--- a/scripts/hooks/post-edit-format.js
+++ b/scripts/hooks/post-edit-format.js
@@ -25,7 +25,7 @@ const UNSAFE_PATH_CHARS = /[&|<>^%!;`()$]/;
const { findProjectRoot, detectFormatter, resolveFormatterBin } = require('../lib/resolve-formatter');
-const MAX_STDIN = 1024 * 1024; // 1MB limit
+const MAX_DIRECT_STDIN_BYTES = 16 * 1024 * 1024;
/**
* Core logic — exported so run-with-flags.js can call directly
@@ -90,19 +90,28 @@ function run(rawInput) {
// ── stdin entry point (backwards-compatible) ────────────────────
if (require.main === module) {
let data = '';
+ let stdinBytes = 0;
+ let oversized = false;
process.stdin.setEncoding('utf8');
process.stdin.on('data', chunk => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += chunk.substring(0, remaining);
+ if (oversized) return;
+ stdinBytes += Buffer.byteLength(chunk, 'utf8');
+ if (stdinBytes > MAX_DIRECT_STDIN_BYTES) {
+ data = '';
+ oversized = true;
+ return;
}
+ data += chunk;
});
process.stdin.on('end', () => {
+ if (oversized) {
+ process.exit(0);
+ return;
+ }
data = run(data);
- process.stdout.write(data);
- process.exit(0);
+ process.stdout.write(data, () => process.exit(0));
});
}
diff --git a/scripts/hooks/post-edit-typecheck.js b/scripts/hooks/post-edit-typecheck.js
index 18f03b7d0..28640c0ac 100644
--- a/scripts/hooks/post-edit-typecheck.js
+++ b/scripts/hooks/post-edit-typecheck.js
@@ -13,18 +13,28 @@ const { execFileSync } = require("child_process");
const fs = require("fs");
const path = require("path");
-const MAX_STDIN = 1024 * 1024; // 1MB limit
+const MAX_DIRECT_STDIN_BYTES = 16 * 1024 * 1024;
let data = "";
+let stdinBytes = 0;
+let oversized = false;
process.stdin.setEncoding("utf8");
process.stdin.on("data", (chunk) => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += chunk.substring(0, remaining);
+ if (oversized) return;
+ stdinBytes += Buffer.byteLength(chunk, "utf8");
+ if (stdinBytes > MAX_DIRECT_STDIN_BYTES) {
+ data = "";
+ oversized = true;
+ return;
}
+ data += chunk;
});
process.stdin.on("end", () => {
+ if (oversized) {
+ process.exit(0);
+ return;
+ }
try {
const input = JSON.parse(data);
const filePath = input.tool_input?.file_path;
@@ -32,8 +42,8 @@ process.stdin.on("end", () => {
if (filePath && /\.(ts|tsx)$/.test(filePath)) {
const resolvedPath = path.resolve(filePath);
if (!fs.existsSync(resolvedPath)) {
- process.stdout.write(data);
- process.exit(0);
+ process.stdout.write(data, () => process.exit(0));
+ return;
}
// Find nearest tsconfig.json by walking up (max 20 levels to prevent infinite loop)
let dir = path.dirname(resolvedPath);
@@ -91,6 +101,5 @@ process.stdin.on("end", () => {
// Invalid input — pass through
}
- process.stdout.write(data);
- process.exit(0);
+ process.stdout.write(data, () => process.exit(0));
});
diff --git a/tests/hooks/hooks.test.js b/tests/hooks/hooks.test.js
index ce3411b15..32c99a5c9 100644
--- a/tests/hooks/hooks.test.js
+++ b/tests/hooks/hooks.test.js
@@ -4310,9 +4310,13 @@ async function runTests() {
else failed++;
if (
- await asyncTest('source calls process.exit(0) after writing output', async () => {
+ await asyncTest('source exits only after stdout finishes writing', async () => {
const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- assert.ok(formatSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
+ assert.match(
+ formatSource,
+ /process\.stdout\.write\(data,\s*\(\)\s*=>\s*process\.exit\(0\)\)/,
+ 'Should exit from the stdout write callback'
+ );
})
)
passed++;
@@ -4321,7 +4325,7 @@ async function runTests() {
if (
await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- assert.ok(formatSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write to avoid trailing newline');
+ assert.ok(formatSource.includes('process.stdout.write(data,'), 'Should use process.stdout.write to avoid trailing newline');
// Verify no console.log(data) for pass-through (console.error for warnings is OK)
const lines = formatSource.split('\n');
const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
@@ -4334,9 +4338,13 @@ async function runTests() {
console.log('\nRound 29: post-edit-typecheck.js (exit and pass-through):');
if (
- await asyncTest('source calls process.exit(0) after writing output', async () => {
+ await asyncTest('source exits only after stdout finishes writing', async () => {
const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
- assert.ok(tcSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
+ assert.match(
+ tcSource,
+ /process\.stdout\.write\(data,\s*\(\)\s*=>\s*process\.exit\(0\)\)/,
+ 'Should exit from the stdout write callback'
+ );
})
)
passed++;
@@ -4345,7 +4353,7 @@ async function runTests() {
if (
await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
- assert.ok(tcSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write');
+ assert.ok(tcSource.includes('process.stdout.write(data,'), 'Should use process.stdout.write');
const lines = tcSource.split('\n');
const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
assert.strictEqual(passThrough.length, 0, 'Should not use console.log(data) for pass-through');
@@ -5446,18 +5454,17 @@ async function runTests() {
passed++;
else failed++;
- console.log('\nRound 59: check-console-log.js (stdin exceeding 1MB — truncation):');
+ console.log('\nRound 59: check-console-log.js (large stdin pass-through):');
if (
- await asyncTest('suppresses pass-through for oversized stdin (fail-open, #2090)', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit. Echoing the
- // truncated string would emit a JSON document cut mid-stream, which the
- // harness reports as a Stop hook JSON validation failure.
+ await asyncTest('preserves complete oversized stdin (#2924)', async () => {
+ // Direct/legacy entrypoints preserve the protocol payload. Production
+ // wrappers continue to enforce their own bounded-input policy.
const payload = 'x'.repeat(1024 * 1024 + 200000);
const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), payload);
assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- assert.strictEqual(result.stdout, '', 'Truncated stdin must not be echoed (empty stdout = no opinion)');
+ assert.strictEqual(result.stdout, payload, 'stdout should exactly match the complete stdin payload');
})
)
passed++;
@@ -5548,20 +5555,16 @@ async function runTests() {
passed++;
else failed++;
- console.log('\nRound 60: post-edit-console-warn.js (stdin exceeding 1MB — truncation):');
+ console.log('\nRound 60: post-edit-console-warn.js (large stdin pass-through):');
if (
- await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit
+ await asyncTest('preserves complete oversized stdin', async () => {
const payload = 'x'.repeat(1024 * 1024 + 200000);
const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), payload);
assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Data should be truncated — stdout significantly less than input
- assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ assert.strictEqual(result.stdout, payload, 'stdout should exactly match the complete stdin payload');
+ assert.ok(result.stdout.length > 0, 'Should pass through complete data');
})
)
passed++;
@@ -6074,40 +6077,32 @@ Some random content without the expected ### Context to Load section
passed++;
else failed++;
- // ── Round 87: post-edit-format.js and post-edit-typecheck.js stdin overflow (1MB) ──
- console.log('\nRound 87: post-edit-format.js (stdin exceeding 1MB — truncation):');
+ // ── Round 87: post-edit-format.js and post-edit-typecheck.js large stdin pass-through ──
+ console.log('\nRound 87: post-edit-format.js (large stdin pass-through):');
if (
- await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-format)', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 14-22)
+ await asyncTest('preserves complete oversized stdin (post-edit-format)', async () => {
const payload = 'x'.repeat(1024 * 1024 + 200000);
const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), payload);
assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Output should be truncated — significantly less than input
- assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Output should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ assert.strictEqual(result.stdout, payload, 'stdout should exactly match the complete stdin payload');
+ assert.ok(result.stdout.length > 0, 'Should pass through complete data');
})
)
passed++;
else failed++;
- console.log('\nRound 87: post-edit-typecheck.js (stdin exceeding 1MB — truncation):');
+ console.log('\nRound 87: post-edit-typecheck.js (large stdin pass-through):');
if (
- await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-typecheck)', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 16-24)
+ await asyncTest('preserves complete oversized stdin (post-edit-typecheck)', async () => {
const payload = 'x'.repeat(1024 * 1024 + 200000);
const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), payload);
assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Output should be truncated — significantly less than input
- assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Output should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ assert.strictEqual(result.stdout, payload, 'stdout should exactly match the complete stdin payload');
+ assert.ok(result.stdout.length > 0, 'Should pass through complete data');
})
)
passed++;
diff --git a/tests/hooks/passthrough-large-stdin.test.js b/tests/hooks/passthrough-large-stdin.test.js
new file mode 100644
index 000000000..48333fb3d
--- /dev/null
+++ b/tests/hooks/passthrough-large-stdin.test.js
@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * Regression coverage for #2924.
+ *
+ * Legacy direct hook entrypoints that echo stdin must preserve the complete
+ * hook payload. Cutting the input at an arbitrary byte/character boundary
+ * produces invalid JSON, while exiting before stdout drains loses everything
+ * past the platform pipe buffer.
+ */
+
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const repoRoot = path.join(__dirname, '..', '..');
+const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-passthrough-'));
+const DIRECT_STDIN_LIMIT_BYTES = 16 * 1024 * 1024;
+
+const PASSTHROUGH_HOOKS = [
+ 'scripts/hooks/check-console-log.js',
+ 'scripts/hooks/post-edit-typecheck.js',
+ 'scripts/hooks/post-edit-console-warn.js',
+ 'scripts/hooks/post-edit-format.js',
+ 'scripts/hooks/pre-write-doc-warn.js'
+];
+
+const PAYLOADS = [
+ ['1KB payload', 'x'.repeat(1024)],
+ ['200KB payload', 'x'.repeat(200 * 1024)],
+ ['2MB payload', 'x'.repeat(2 * 1024 * 1024)],
+ ['5MB payload', 'x'.repeat(5 * 1024 * 1024)],
+ ['multibyte payload beyond 1MB', '韩'.repeat(600 * 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 hookPayload(padding) {
+ return JSON.stringify({
+ session_id: `passthrough-${process.pid}`,
+ hook_event_name: 'PostToolUse',
+ tool_name: 'Edit',
+ tool_input: { file_path: path.join(workDir, 'fixture.txt') },
+ padding
+ });
+}
+
+function runDirect(script, input) {
+ return spawnSync(process.execPath, [path.join(repoRoot, script)], {
+ input,
+ encoding: 'utf8',
+ cwd: workDir,
+ timeout: 30000,
+ maxBuffer: 32 * 1024 * 1024,
+ stdio: ['pipe', 'pipe', 'pipe']
+ });
+}
+
+console.log('\nPassthrough hook large-stdin tests (#2924):');
+
+let passed = 0;
+let failed = 0;
+
+for (const script of PASSTHROUGH_HOOKS) {
+ for (const [label, padding] of PAYLOADS) {
+ if (
+ test(`${path.basename(script)} preserves the complete ${label}`, () => {
+ const input = hookPayload(padding);
+ const result = runDirect(script, input);
+
+ assert.strictEqual(
+ result.status,
+ 0,
+ `${script}: expected exit 0, got ${result.status}: ${result.stderr}`
+ );
+ assert.ok(
+ result.stdout === input,
+ `${script}: expected ${Buffer.byteLength(input)} bytes, got ${Buffer.byteLength(result.stdout || '')}`
+ );
+ assert.deepStrictEqual(JSON.parse(result.stdout), JSON.parse(input));
+ })
+ ) {
+ passed += 1;
+ } else {
+ failed += 1;
+ }
+ }
+}
+
+const oversizedInputs = [
+ ['ASCII', hookPayload('x'.repeat(DIRECT_STDIN_LIMIT_BYTES))],
+ ['multibyte', hookPayload('韩'.repeat(6 * 1024 * 1024))]
+];
+for (const [encoding, overLimitInput] of oversizedInputs) {
+ for (const script of PASSTHROUGH_HOOKS) {
+ if (
+ test(`${path.basename(script)} suppresses ${encoding} input beyond the 16MiB direct-entrypoint limit`, () => {
+ assert.ok(Buffer.byteLength(overLimitInput) > DIRECT_STDIN_LIMIT_BYTES);
+ const result = runDirect(script, overLimitInput);
+
+ assert.strictEqual(
+ result.status,
+ 0,
+ `${script}: expected exit 0, got ${result.status}: ${result.stderr || result.error || ''}`
+ );
+ assert.ok(result.stdout === '', 'oversized input must not be emitted as truncated JSON');
+ })
+ ) {
+ passed += 1;
+ } else {
+ failed += 1;
+ }
+ }
+}
+
+if (
+ test('post-edit-typecheck.js flushes the nonexistent-TypeScript-file early return', () => {
+ const input = JSON.stringify({
+ hook_event_name: 'PostToolUse',
+ tool_name: 'Edit',
+ tool_input: { file_path: path.join(workDir, 'missing.ts') },
+ padding: 'x'.repeat(2 * 1024 * 1024)
+ });
+ const result = runDirect('scripts/hooks/post-edit-typecheck.js', input);
+
+ assert.strictEqual(result.status, 0, result.stderr);
+ assert.ok(result.stdout === input, 'early return must wait for the complete stdout payload');
+ JSON.parse(result.stdout);
+ })
+) {
+ passed += 1;
+} else {
+ failed += 1;
+}
+
+if (
+ test('pre-write-doc-warn.js returns valid structured output for a large warned payload', () => {
+ const input = JSON.stringify({
+ hook_event_name: 'PreToolUse',
+ tool_name: 'Write',
+ tool_input: { file_path: 'TODO.md', content: 'x'.repeat(2 * 1024 * 1024) }
+ });
+ const result = runDirect('scripts/hooks/pre-write-doc-warn.js', input);
+
+ assert.strictEqual(result.status, 0, result.stderr);
+ const output = JSON.parse(result.stdout);
+ assert.ok(
+ output.hookSpecificOutput.additionalContext.includes('TODO.md'),
+ 'large warned payload should retain the doc warning'
+ );
+ })
+) {
+ passed += 1;
+} else {
+ failed += 1;
+}
+
+try {
+ fs.rmSync(workDir, { recursive: true, force: true });
+} catch {
+ /* best-effort cleanup */
+}
+
+console.log(`\nResults: Passed: ${passed}, Failed: ${failed}\n`);
+process.exit(failed > 0 ? 1 : 0);
diff --git a/tests/hooks/stop-hooks-stdout.test.js b/tests/hooks/stop-hooks-stdout.test.js
index 1de6bb9c2..02a4bf3ce 100644
--- a/tests/hooks/stop-hooks-stdout.test.js
+++ b/tests/hooks/stop-hooks-stdout.test.js
@@ -142,7 +142,6 @@ const STOP_HOOKS = [
// Direct-invocation legacy paths that echo stdin.
const ECHOING_STOP_HOOKS = [
'scripts/hooks/stop-format-typecheck.js',
- 'scripts/hooks/check-console-log.js',
'scripts/hooks/cost-tracker.js',
'scripts/hooks/desktop-notify.js'
];
@@ -316,6 +315,17 @@ for (const script of ECHOING_STOP_HOOKS) {
else failed++;
}
+if (
+ test('check-console-log invoked directly echoes a >1MB payload uncut', () => {
+ const result = runDirect('scripts/hooks/check-console-log.js', oversizedPayload);
+ assert.strictEqual(result.status, 0);
+ assert.strictEqual(result.stdout, oversizedPayload, 'direct pass-through must preserve the complete payload');
+ JSON.parse(result.stdout);
+ })
+)
+ passed++;
+else failed++;
+
if (
test('check-console-log invoked directly echoes a sub-cap >64KB payload uncut', () => {
const result = runDirect('scripts/hooks/check-console-log.js', realisticPayload);
diff --git a/tests/integration/hooks.test.js b/tests/integration/hooks.test.js
index 77b0822d6..677e2b952 100644
--- a/tests/integration/hooks.test.js
+++ b/tests/integration/hooks.test.js
@@ -854,8 +854,8 @@ async function runTests() {
})) passed++; else failed++;
if (await asyncTest('hooks survive stdin exceeding 1MB limit', async () => {
- // The post-edit-console-warn hook reads stdin up to 1MB then passes through
- // Send > 1MB to verify truncation doesn't crash the hook
+ // Direct invocation preserves the complete payload. Send >1MB to verify
+ // the pass-through path remains stable under backpressure.
const oversizedInput = JSON.stringify({
tool_input: { file_path: '/test.js' },
tool_output: { output: 'x'.repeat(1200000) } // ~1.2MB