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: address PR review comments on block-no-verify hook

Ke Wang809e0fa0a918
diff --git a/hooks/hooks.json b/hooks/hooks.json
index 8cba1b8f9..cdd2584dc 100644
--- a/hooks/hooks.json
+++ b/hooks/hooks.json
@@ -7,7 +7,7 @@
"hooks": [
{
"type": "command",
- "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/run-with-flags.js\" \"pre:bash:block-no-verify\" \"scripts/hooks/block-no-verify.js\" \"standard,strict\""
+ "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/run-with-flags.js\" \"pre:bash:block-no-verify\" \"scripts/hooks/block-no-verify.js\" \"minimal,standard,strict\""
}
],
"description": "Block git hook-bypass flag to protect pre-commit, commit-msg, and pre-push hooks from being skipped",
diff --git a/scripts/hooks/block-no-verify.js b/scripts/hooks/block-no-verify.js
index 1ac0bc424..864b62893 100644
--- a/scripts/hooks/block-no-verify.js
+++ b/scripts/hooks/block-no-verify.js
@@ -76,6 +76,8 @@ function findGit(input, start) {
/**
* Detect which git subcommand (commit, push, etc.) is being invoked.
+ * Returns { command, offset } where offset is the position right after the
+ * subcommand keyword, so callers can scope flag checks to only that portion.
*/
function detectGitCommand(input) {
let start = 0;
@@ -88,18 +90,58 @@ function detectGitCommand(input) {
continue;
}
- for (const cmd of GIT_COMMANDS_WITH_NO_VERIFY) {
- const cmdIdx = input.indexOf(cmd, git.idx + git.len);
- if (cmdIdx === -1) continue;
+ // Find the first matching subcommand token after "git".
+ // We pick the one closest to "git" so that argument values like
+ // "git push origin commit" don't misclassify "commit" as the subcommand.
+ let bestCmd = null;
+ let bestIdx = Infinity;
- const before = cmdIdx > 0 ? input[cmdIdx - 1] : ' ';
- const after = input[cmdIdx + cmd.length] || ' ';
- if (!/\s/.test(before)) continue;
- if (!/[\s;&#|>)\]}"']/.test(after) && after !== '') continue;
- if (/[;|]/.test(input.slice(git.idx + git.len, cmdIdx))) continue;
- if (isInComment(input, cmdIdx)) continue;
+ for (const cmd of GIT_COMMANDS_WITH_NO_VERIFY) {
+ let searchPos = git.idx + git.len;
+ while (searchPos < input.length) {
+ const cmdIdx = input.indexOf(cmd, searchPos);
+ if (cmdIdx === -1) break;
+
+ const before = cmdIdx > 0 ? input[cmdIdx - 1] : ' ';
+ const after = input[cmdIdx + cmd.length] || ' ';
+ if (!/\s/.test(before)) { searchPos = cmdIdx + 1; continue; }
+ if (!/[\s;&#|>)\]}"']/.test(after) && after !== '') { searchPos = cmdIdx + 1; continue; }
+ if (/[;|]/.test(input.slice(git.idx + git.len, cmdIdx))) break;
+ if (isInComment(input, cmdIdx)) { searchPos = cmdIdx + 1; continue; }
+
+ // Verify this token is the first non-flag word after "git" — i.e. the
+ // actual subcommand, not an argument value to a different subcommand.
+ const gap = input.slice(git.idx + git.len, cmdIdx);
+ const tokens = gap.trim().split(/\s+/).filter(Boolean);
+ // Every token before the candidate must be a flag or a flag argument.
+ // Git global flags like -c take a value argument (e.g. -c key=value).
+ let onlyFlagsAndArgs = true;
+ let expectFlagArg = false;
+ for (const t of tokens) {
+ if (expectFlagArg) { expectFlagArg = false; continue; }
+ if (t.startsWith('-')) {
+ // -c is a git global flag that takes the next token as its argument
+ if (t === '-c' || t === '-C' || t === '--work-tree' || t === '--git-dir' ||
+ t === '--namespace' || t === '--super-prefix') {
+ expectFlagArg = true;
+ }
+ continue;
+ }
+ onlyFlagsAndArgs = false;
+ break;
+ }
+ if (!onlyFlagsAndArgs) { searchPos = cmdIdx + 1; continue; }
+
+ if (cmdIdx < bestIdx) {
+ bestIdx = cmdIdx;
+ bestCmd = cmd;
+ }
+ break;
+ }
+ }
- return cmd;
+ if (bestCmd) {
+ return { command: bestCmd, offset: bestIdx + bestCmd.length };
}
start = git.idx + git.len;
@@ -109,13 +151,17 @@ function detectGitCommand(input) {
/**
* Check if the input contains a --no-verify flag for a specific git command.
+ * Only inspects the portion of the input starting at `offset` (the position
+ * right after the detected subcommand keyword) so that flags belonging to
+ * earlier commands in a chain are not falsely matched.
*/
-function hasNoVerifyFlag(input, command) {
- if (/--no-verify\b/.test(input)) return true;
+function hasNoVerifyFlag(input, command, offset) {
+ const region = input.slice(offset);
+ if (/--no-verify\b/.test(region)) return true;
// For commit, -n is shorthand for --no-verify
if (command === 'commit') {
- if (/\s-n(?:\s|$)/.test(input) || /\s-n[a-zA-Z]/.test(input)) return true;
+ if (/\s-n(?:\s|$)/.test(region) || /\s-n[a-zA-Z]/.test(region)) return true;
}
return false;
@@ -132,10 +178,12 @@ function hasHooksPathOverride(input) {
* Check a command string for git hook bypass attempts.
*/
function checkCommand(input) {
- const gitCommand = detectGitCommand(input);
- if (!gitCommand) return { blocked: false };
+ const detected = detectGitCommand(input);
+ if (!detected) return { blocked: false };
- if (hasNoVerifyFlag(input, gitCommand)) {
+ const { command: gitCommand, offset } = detected;
+
+ if (hasNoVerifyFlag(input, gitCommand, offset)) {
return {
blocked: true,
reason: `BLOCKED: --no-verify flag is not allowed with git ${gitCommand}. Git hooks must not be bypassed.`,
@@ -197,23 +245,25 @@ function run(rawInput) {
module.exports = { run };
-// Stdin fallback for spawnSync execution
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => {
- if (raw.length < MAX_STDIN) {
- const remaining = MAX_STDIN - raw.length;
- raw += chunk.substring(0, remaining);
- }
-});
+// Stdin fallback for spawnSync execution — only when invoked directly, not via require()
+if (require.main === module) {
+ process.stdin.setEncoding('utf8');
+ process.stdin.on('data', chunk => {
+ if (raw.length < MAX_STDIN) {
+ const remaining = MAX_STDIN - raw.length;
+ raw += chunk.substring(0, remaining);
+ }
+ });
-process.stdin.on('end', () => {
- const command = extractCommand(raw);
- const result = checkCommand(command);
+ process.stdin.on('end', () => {
+ const command = extractCommand(raw);
+ const result = checkCommand(command);
- if (result.blocked) {
- process.stderr.write(result.reason + '\n');
- process.exit(2);
- }
+ if (result.blocked) {
+ process.stderr.write(result.reason + '\n');
+ process.exit(2);
+ }
- process.stdout.write(raw);
-});
+ process.stdout.write(raw);
+ });
+}
diff --git a/tests/hooks/block-no-verify.test.js b/tests/hooks/block-no-verify.test.js
new file mode 100644
index 000000000..de6e4aca0
--- /dev/null
+++ b/tests/hooks/block-no-verify.test.js
@@ -0,0 +1,132 @@
+/**
+ * Tests for scripts/hooks/block-no-verify.js via run-with-flags.js
+ */
+
+const assert = require('assert');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const runner = path.join(__dirname, '..', '..', 'scripts', 'hooks', 'run-with-flags.js');
+
+function test(name, fn) {
+ try {
+ fn();
+ console.log(` \u2713 ${name}`);
+ return true;
+ } catch (error) {
+ console.log(` \u2717 ${name}`);
+ console.log(` Error: ${error.message}`);
+ return false;
+ }
+}
+
+function runHook(input, env = {}) {
+ const rawInput = typeof input === 'string' ? input : JSON.stringify(input);
+ const result = spawnSync('node', [runner, 'pre:bash:block-no-verify', 'scripts/hooks/block-no-verify.js', 'minimal,standard,strict'], {
+ input: rawInput,
+ encoding: 'utf8',
+ env: {
+ ...process.env,
+ ECC_HOOK_PROFILE: 'standard',
+ ...env
+ },
+ timeout: 15000,
+ stdio: ['pipe', 'pipe', 'pipe']
+ });
+
+ return {
+ code: Number.isInteger(result.status) ? result.status : 1,
+ stdout: result.stdout || '',
+ stderr: result.stderr || ''
+ };
+}
+
+let passed = 0;
+let failed = 0;
+
+console.log('\nblock-no-verify hook tests');
+console.log('─'.repeat(50));
+
+// --- Basic allow/block ---
+
+if (test('allows plain git commit', () => {
+ const r = runHook({ tool_input: { command: 'git commit -m "hello"' } });
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('blocks --no-verify on git commit', () => {
+ const r = runHook({ tool_input: { command: 'git commit --no-verify -m "msg"' } });
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+ assert.ok(r.stderr.includes('BLOCKED'), `stderr should contain BLOCKED: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('blocks -n shorthand on git commit', () => {
+ const r = runHook({ tool_input: { command: 'git commit -n -m "msg"' } });
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+ assert.ok(r.stderr.includes('BLOCKED'), `stderr should contain BLOCKED: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('blocks core.hooksPath override', () => {
+ const r = runHook({ tool_input: { command: 'git -c core.hooksPath=/dev/null commit -m "msg"' } });
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+ assert.ok(r.stderr.includes('core.hooksPath'), `stderr should mention core.hooksPath: ${r.stderr}`);
+})) passed++; else failed++;
+
+// --- Chained command false positive prevention (Comment 2) ---
+
+if (test('does not false-positive on -n belonging to git log in a chain', () => {
+ const r = runHook({ tool_input: { command: 'git log -n 10 && git commit -m "msg"' } });
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('does not false-positive on --no-verify in a prior non-git command', () => {
+ const r = runHook({ tool_input: { command: 'echo --no-verify && git commit -m "msg"' } });
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('still blocks --no-verify on the git commit part of a chain', () => {
+ const r = runHook({ tool_input: { command: 'git log -n 5 && git commit --no-verify -m "msg"' } });
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+})) passed++; else failed++;
+
+// --- Subcommand detection (Comment 4) ---
+
+if (test('does not misclassify "commit" as subcommand when it is an argument to push', () => {
+ // "git push origin commit" — "commit" is a refspec arg, not the subcommand
+ const r = runHook({ tool_input: { command: 'git push origin commit' } });
+ // This should detect "push" as the subcommand, not "commit"
+ // Either way it should not block since there's no --no-verify
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+// --- Blocks on push --no-verify ---
+
+if (test('blocks --no-verify on git push', () => {
+ const r = runHook({ tool_input: { command: 'git push --no-verify' } });
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+ assert.ok(r.stderr.includes('git push'), `stderr should mention git push: ${r.stderr}`);
+})) passed++; else failed++;
+
+// --- Non-git commands pass through ---
+
+if (test('allows non-git commands', () => {
+ const r = runHook({ tool_input: { command: 'npm test' } });
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+// --- Plain text input (not JSON) ---
+
+if (test('handles plain text input', () => {
+ const r = runHook('git commit -m "hello"');
+ assert.strictEqual(r.code, 0, `expected exit 0, got ${r.code}: ${r.stderr}`);
+})) passed++; else failed++;
+
+if (test('blocks plain text input with --no-verify', () => {
+ const r = runHook('git commit --no-verify -m "msg"');
+ assert.strictEqual(r.code, 2, `expected exit 2, got ${r.code}`);
+})) passed++; else failed++;
+
+console.log('─'.repeat(50));
+console.log(`Passed: ${passed} Failed: ${failed}`);
+
+process.exit(failed > 0 ? 1 : 0);