diff --git a/scripts/hooks/config-protection.js b/scripts/hooks/config-protection.js index 0eaca95ae..654a102c8 100644 --- a/scripts/hooks/config-protection.js +++ b/scripts/hooks/config-protection.js @@ -15,6 +15,7 @@ const fs = require('fs'); const path = require('path'); +const { showRecoveryHints } = require('../lib/hooks/recovery-hints'); const MAX_STDIN = 1024 * 1024; let raw = ''; @@ -145,10 +146,6 @@ function parseInput(inputOrRaw) { * Exportable run() for in-process execution via run-with-flags.js. * Avoids the ~50-100ms spawnSync overhead when available. */ -function showRecoveryHints() { - return /^(1|true|yes|on|enabled)$/i.test(String(process.env.ECC_SHOW_RECOVERY_HINTS || '')); -} - function run(inputOrRaw, options = {}) { if (options.truncated) { return { diff --git a/scripts/hooks/gateguard-fact-force.js b/scripts/hooks/gateguard-fact-force.js index ee0b988a4..228b6a247 100644 --- a/scripts/hooks/gateguard-fact-force.js +++ b/scripts/hooks/gateguard-fact-force.js @@ -25,6 +25,7 @@ const crypto = require('crypto'); const fs = require('fs'); const path = require('path'); +const { showRecoveryHints } = require('../lib/hooks/recovery-hints'); const { extractCommandSubstitutions, extractSubshellGroups, extractBraceGroups } = require('../lib/shell-substitution'); const { classifyPowerShellDestructiveCommand } = require('../lib/powershell-destructive-command'); const { stripHeredocBodies } = require('./gateguard-heredoc'); @@ -115,13 +116,6 @@ const ROUTINE_POWERSHELL_NARROW_RECOVERY_HINT = const ECC_DISABLE_VALUES = new Set(['0', 'false', 'off', 'disabled', 'disable']); const ECC_ENABLE_VALUES = new Set(['1', 'true', 'on', 'enabled', 'enable', 'yes']); -// A denial is fed back to the agent as untrusted tool text. Naming the env vars -// that disable the guard in that same message hands a bypass to the guarded -// agent (#3844), so the recovery controls are opt-in for human operators. -function showRecoveryHints() { - return ECC_ENABLE_VALUES.has(normalizeEnvValue(process.env.ECC_SHOW_RECOVERY_HINTS)); -} - // SQL keywords remain a phrase check. Quoted strings are stripped before // this regex runs so a commit message mentioning "drop table" stays passive. // `dd if=` used to be a fourth arm here. Matching it as text could not work: diff --git a/scripts/hooks/run-with-flags.js b/scripts/hooks/run-with-flags.js index 8544d3e59..a5cdbb584 100644 --- a/scripts/hooks/run-with-flags.js +++ b/scripts/hooks/run-with-flags.js @@ -13,6 +13,7 @@ const path = require('path'); const { spawnSync } = require('child_process'); const { StringDecoder } = require('string_decoder'); const { isHookEnabled, isDryRun } = require('../lib/hook-flags'); +const { showRecoveryHints } = require('../lib/hooks/recovery-hints'); const { readStdinRaw: readBoundedStdin, resolveMaxStdin } = require('./hook-input'); const { buildPreToolUseAdditionalContext } = require('./pretooluse-visible-output'); const { createHookContextScanner } = require('./hook-input-limits'); @@ -138,12 +139,9 @@ function truncatedInputResult(hookId, maxStdin) { if (failOpen) return null; } - const showRecoveryHints = /^(1|true|yes|on|enabled)$/i.test( - String(process.env.ECC_SHOW_RECOVERY_HINTS || '') - ); return { stdout: '', - stderr: showRecoveryHints + stderr: showRecoveryHints() ? `BLOCKED: Hook input exceeded ${maxStdin} bytes, so ${hookId} could not safely inspect the complete request. Retry with a smaller tool input or explicitly disable this hook.` : `BLOCKED: Hook input exceeded ${maxStdin} bytes, so ${hookId} could not safely inspect the complete request. Retry with a smaller tool input.`, exitCode: 2 diff --git a/scripts/lib/hooks/recovery-hints.js b/scripts/lib/hooks/recovery-hints.js new file mode 100644 index 000000000..7b1e45528 --- /dev/null +++ b/scripts/lib/hooks/recovery-hints.js @@ -0,0 +1,12 @@ +'use strict'; + +// Denial text is tool output the guarded agent reads. Naming the env vars that +// disable a hook hands it a bypass, so recovery instructions are opt-in for +// human operators (#3844). Every hook must parse the switch the same way. +const ENABLE_VALUES = new Set(['1', 'true', 'on', 'enabled', 'enable', 'yes']); + +function showRecoveryHints(value = process.env.ECC_SHOW_RECOVERY_HINTS) { + return ENABLE_VALUES.has(String(value || '').trim().toLowerCase()); +} + +module.exports = { showRecoveryHints }; diff --git a/tests/hooks/config-protection.test.js b/tests/hooks/config-protection.test.js index 6d78bedac..0a682e9d6 100644 --- a/tests/hooks/config-protection.test.js +++ b/tests/hooks/config-protection.test.js @@ -164,6 +164,55 @@ function runTests() { }) ); + results.push( + test('hides the config-protection recovery hint by default', () => { + return withOwnedDirectory(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-config-protect-')), tmpDir => { + const absPath = path.join(tmpDir, '.eslintrc.js'); + fs.writeFileSync(absPath, 'module.exports = {};'); + const result = runHook( + { tool_name: 'Write', tool_input: { file_path: absPath, content: '{}' } }, + { ECC_SHOW_RECOVERY_HINTS: '' } + ); + assert.strictEqual(result.code, 2); + assert.ok(!result.stderr.includes('disable the config-protection hook temporarily'), result.stderr); + }); + }) + ); + + results.push( + test('restores the config-protection recovery hint for normalized truthy values', () => { + return withOwnedDirectory(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-config-protect-')), tmpDir => { + const absPath = path.join(tmpDir, '.eslintrc.js'); + fs.writeFileSync(absPath, 'module.exports = {};'); + for (const value of [' true ', 'enable']) { + const result = runHook( + { tool_name: 'Write', tool_input: { file_path: absPath, content: '{}' } }, + { ECC_SHOW_RECOVERY_HINTS: value } + ); + assert.strictEqual(result.code, 2); + assert.ok(result.stderr.includes('disable the config-protection hook temporarily'), `${value}: ${result.stderr}`); + } + }); + }) + ); + + results.push( + test('hides the truncated-payload recovery hint by default and restores it on demand', () => { + const rawInput = JSON.stringify({ + tool_name: 'Write', + tool_input: { file_path: '.eslintrc.js', content: 'x'.repeat(1024 * 1024 + 2048) } + }); + + const hidden = runHook(rawInput, { ECC_SHOW_RECOVERY_HINTS: '' }); + assert.strictEqual(hidden.code, 2); + assert.ok(!hidden.stderr.includes('disable the config-protection hook temporarily'), hidden.stderr); + + const shown = runHook(rawInput, { ECC_SHOW_RECOVERY_HINTS: ' true ' }); + assert.strictEqual(shown.code, 2); + assert.ok(shown.stderr.includes('disable the config-protection hook temporarily'), shown.stderr); + }) + ); + results.push( test('allows first-time creation of a protected config file', () => { return withOwnedDirectory(fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-config-protect-')), tmpDir => { diff --git a/tests/hooks/gateguard-fact-force.test.js b/tests/hooks/gateguard-fact-force.test.js index ce269a534..7bf4c18e6 100644 --- a/tests/hooks/gateguard-fact-force.test.js +++ b/tests/hooks/gateguard-fact-force.test.js @@ -7721,6 +7721,36 @@ function runTests() { passed++; else failed++; + clearState(); + writeState({ checked: [], last_active: Date.now(), fact_force_denials: 3 }); + if ( + test('condensed default denial omits recovery markers and bypass controls', () => { + const input = { + session_id: TEST_SESSION_ID, + tool_name: 'Edit', + tool_input: { file_path: '/workspace/app/src/recovery-condensed.js', old_string: 'a', new_string: 'b' } + }; + const result = runHook(input, { ECC_SHOW_RECOVERY_HINTS: '' }); + const output = parseOutput(result.stdout); + assert.ok(output && output.hookSpecificOutput, 'expected the condensed denial'); + assert.strictEqual(output.hookSpecificOutput.permissionDecision, 'deny'); + const reason = output.hookSpecificOutput.permissionDecisionReason; + assert.ok(reason.includes('denial #4'), 'expected the condensed denial ordinal'); + for (const leaked of [ + 'Narrow recovery:', + 'Recovery:', + 'ECC_GATEGUARD=off', + 'ECC_DISABLED_HOOKS', + 'GATEGUARD_EXEMPT_GLOBS', + 'GATEGUARD_BASH_ROUTINE_DISABLED' + ]) { + assert.ok(!reason.includes(leaked), `condensed default denial must not contain ${leaked}`); + } + }) + ) + passed++; + else failed++; + const ddResults = runDdRegressionTests(); passed += ddResults.passed; failed += ddResults.failed; diff --git a/tests/hooks/run-with-flags-truncation.test.js b/tests/hooks/run-with-flags-truncation.test.js index 267f9556b..66fb48b1d 100644 --- a/tests/hooks/run-with-flags-truncation.test.js +++ b/tests/hooks/run-with-flags-truncation.test.js @@ -198,6 +198,36 @@ for (const [hookId, toolName, toolInput] of GATEGUARD_TRUNCATION_CASES) { } } +if ( + test('fail-closed truncation hides the disable-hook hint by default', () => { + const result = runRunner( + ['pre:edit-write:gateguard-fact-force', 'scripts/hooks/gateguard-fact-force.js', 'standard,strict'], + oversizedPayload(), + { ...GATEGUARD_ENV_BASELINE, ECC_GATEGUARD: 'on', ECC_SHOW_RECOVERY_HINTS: '' } + ); + assert.strictEqual(result.status, 2); + assert.doesNotMatch(result.stderr, /explicitly disable this hook/); + }) +) + passed++; +else failed++; + +if ( + test('fail-closed truncation restores the disable-hook hint for normalized truthy values', () => { + for (const value of [' true ', 'enable']) { + const result = runRunner( + ['pre:edit-write:gateguard-fact-force', 'scripts/hooks/gateguard-fact-force.js', 'standard,strict'], + oversizedPayload(), + { ...GATEGUARD_ENV_BASELINE, ECC_GATEGUARD: 'on', ECC_SHOW_RECOVERY_HINTS: value } + ); + assert.strictEqual(result.status, 2); + assert.match(result.stderr, /explicitly disable this hook/, `${value}: ${result.stderr}`); + } + }) +) + passed++; +else failed++; + console.log(`\nPassed: ${passed}`); console.log(`Failed: ${failed}\n`); process.exit(failed > 0 ? 1 : 0);