deepflow 0.1.105 → 0.1.107

package/hooks/df-stdin-migration.test.js

@@ -0,0 +1,106 @@
+/**
+ * Tests for stdin migration (test-hang-fix T2)
+ *
+ * Verifies that all 9 migrated hooks use readStdinIfMain instead of inline
+ * process.stdin.on listeners. The core behavioral guarantee: require()'ing
+ * any hook no longer hangs the process waiting for stdin.
+ *
+ * Detailed behavioral tests for individual hooks live in their own test files.
+ */
+
+'use strict';
+
+const { test, describe, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+// Prevent the test runner from hanging on stdin after all tests complete.
+// The execFileSync calls inherit pipe handles that can keep the event loop alive.
+after(() => { process.stdin.destroy(); });
+
+const HOOKS_DIR = path.resolve(__dirname);
+
+/** All hooks that were migrated to readStdinIfMain */
+const MIGRATED_HOOKS = [
+  'df-command-usage.js',
+  'df-execution-history.js',
+  'df-explore-protocol.js',
+  'df-snapshot-guard.js',
+  'df-statusline.js',
+  'df-subagent-registry.js',
+  'df-tool-usage.js',
+  'df-tool-usage-spike.js',
+  'df-worktree-guard.js',
+];
+
+describe('stdin migration — no-hang on require()', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`require("${hookFile}") completes without hanging`, () => {
+      // Spawn a child that require()s the hook and exits.
+      // If stdin listeners are still inline, this will hang until timeout.
+      const script = `require(${JSON.stringify(hookPath)}); process.exit(0);`;
+      execFileSync(
+        process.execPath,
+        ['-e', script],
+        {
+          encoding: 'utf8',
+          timeout: 3000,  // 3s is generous — require should be <100ms
+        }
+      );
+      // If we reach here, require() didn't hang — that's the assertion.
+      assert.ok(true, `${hookFile} require() completed without timeout`);
+    });
+  }
+});
+
+describe('stdin migration — no inline process.stdin.on', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`${hookFile} has no direct process.stdin.on calls`, () => {
+      const content = fs.readFileSync(hookPath, 'utf8');
+      const matches = content.match(/process\.stdin\.on\s*\(/g);
+      assert.equal(
+        matches,
+        null,
+        `${hookFile} still contains process.stdin.on — migration incomplete`
+      );
+    });
+  }
+});
+
+describe('stdin migration — uses readStdinIfMain', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`${hookFile} imports readStdinIfMain`, () => {
+      const content = fs.readFileSync(hookPath, 'utf8');
+      assert.match(
+        content,
+        /readStdinIfMain/,
+        `${hookFile} does not reference readStdinIfMain`
+      );
+    });
+  }
+});
+
+describe('stdin migration — hook-stdin.js helper', () => {
+  test('hook-stdin.js exports readStdinIfMain function', () => {
+    const lib = require(path.join(HOOKS_DIR, 'lib', 'hook-stdin.js'));
+    assert.equal(typeof lib.readStdinIfMain, 'function');
+  });
+
+  test('readStdinIfMain is a no-op when caller is not main module', () => {
+    const lib = require(path.join(HOOKS_DIR, 'lib', 'hook-stdin.js'));
+    // When we require() hook-stdin from a test, module !== require.main
+    // so calling readStdinIfMain with our own module should be a no-op.
+    let callbackInvoked = false;
+    lib.readStdinIfMain(module, () => { callbackInvoked = true; });
+    // Give a tick for any async listener to fire (there shouldn't be one).
+    assert.equal(callbackInvoked, false, 'callback should not be invoked when not main module');
+  });
+});

package/hooks/df-subagent-registry.js

@@ -4,59 +4,53 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
-let raw = '';
-process.stdin.on('data', d => raw += d);
-process.stdin.on('end', () => {
-  try {
-    const event = JSON.parse(raw);
-    const { session_id, agent_type, agent_id, agent_transcript_path } = event;
+readStdinIfMain(module, (event) => {
+  const { session_id, agent_type, agent_id, agent_transcript_path } = event;
 
-    // Parse subagent transcript to extract real model and token usage
-    let model = 'unknown';
-    let tokens_in = 0, tokens_out = 0, cache_read = 0, cache_creation = 0;
+  // Parse subagent transcript to extract real model and token usage
+  let model = 'unknown';
+  let tokens_in = 0, tokens_out = 0, cache_read = 0, cache_creation = 0;
 
-    if (agent_transcript_path && fs.existsSync(agent_transcript_path)) {
-      const lines = fs.readFileSync(agent_transcript_path, 'utf-8').split('\n');
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const evt = JSON.parse(trimmed);
-          const msg = evt.message || {};
-          const usage = msg.usage || evt.usage;
-          // Extract model from assistant messages
-          const m = msg.model || evt.model;
-          if (m && m !== 'unknown') model = m;
-          // Accumulate tokens
-          if (usage) {
-            tokens_in += usage.input_tokens || 0;
-            tokens_out += usage.output_tokens || 0;
-            cache_read += usage.cache_read_input_tokens || usage.cache_read_tokens || 0;
-            cache_creation += usage.cache_creation_input_tokens || usage.cache_creation_tokens || 0;
-          }
-        } catch { /* skip malformed lines */ }
-      }
+  if (agent_transcript_path && fs.existsSync(agent_transcript_path)) {
+    const lines = fs.readFileSync(agent_transcript_path, 'utf-8').split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const evt = JSON.parse(trimmed);
+        const msg = evt.message || {};
+        const usage = msg.usage || evt.usage;
+        // Extract model from assistant messages
+        const m = msg.model || evt.model;
+        if (m && m !== 'unknown') model = m;
+        // Accumulate tokens
+        if (usage) {
+          tokens_in += usage.input_tokens || 0;
+          tokens_out += usage.output_tokens || 0;
+          cache_read += usage.cache_read_input_tokens || usage.cache_read_tokens || 0;
+          cache_creation += usage.cache_creation_input_tokens || usage.cache_creation_tokens || 0;
+        }
+      } catch { /* skip malformed lines */ }
     }
+  }
 
-    // Strip version suffix from model (e.g. claude-haiku-4-5-20251001 → claude-haiku-4-5)
-    model = model.replace(/-\d{8}$/, '').replace(/\[\d+[km]\]$/i, '');
+  // Strip version suffix from model (e.g. claude-haiku-4-5-20251001 → claude-haiku-4-5)
+  model = model.replace(/-\d{8}$/, '').replace(/\[\d+[km]\]$/i, '');
 
-    const entry = {
-      session_id,
-      agent_type,
-      agent_id,
-      model,
-      tokens_in,
-      tokens_out,
-      cache_read,
-      cache_creation,
-      timestamp: new Date().toISOString()
-    };
+  const entry = {
+    session_id,
+    agent_type,
+    agent_id,
+    model,
+    tokens_in,
+    tokens_out,
+    cache_read,
+    cache_creation,
+    timestamp: new Date().toISOString()
+  };
 
-    const registryPath = path.join(os.homedir(), '.claude', 'subagent-sessions.jsonl');
-    fs.appendFileSync(registryPath, JSON.stringify(entry) + '\n');
-  } catch {
-    process.exit(0);
-  }
+  const registryPath = path.join(os.homedir(), '.claude', 'subagent-sessions.jsonl');
+  fs.appendFileSync(registryPath, JSON.stringify(entry) + '\n');
 });

package/hooks/df-tool-usage-spike.js

@@ -11,31 +11,20 @@
 'use strict';
 
 const fs = require('fs');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    // Write raw payload for inspection
-    fs.writeFileSync('/tmp/df-posttooluse-payload.json', raw);
-
-    // Also append a minimal summary line for quick review
-    const data = JSON.parse(raw);
-    const summary = {
-      hook_event_name: data.hook_event_name,
-      tool_name: data.tool_name,
-      tool_use_id: data.tool_use_id,
-      session_id: data.session_id,
-      cwd: data.cwd,
-      permission_mode: data.permission_mode,
-      tool_input_keys: data.tool_input ? Object.keys(data.tool_input) : [],
-      tool_response_keys: data.tool_response ? Object.keys(data.tool_response) : [],
-      transcript_path: data.transcript_path,
-    };
-    fs.appendFileSync('/tmp/df-posttooluse-summary.jsonl', JSON.stringify(summary) + '\n');
-  } catch (_e) {
-    // Fail silently — never break tool execution
-  }
-  process.exit(0);
+readStdinIfMain(module, (data) => {
+  // Also append a minimal summary line for quick review
+  const summary = {
+    hook_event_name: data.hook_event_name,
+    tool_name: data.tool_name,
+    tool_use_id: data.tool_use_id,
+    session_id: data.session_id,
+    cwd: data.cwd,
+    permission_mode: data.permission_mode,
+    tool_input_keys: data.tool_input ? Object.keys(data.tool_input) : [],
+    tool_response_keys: data.tool_response ? Object.keys(data.tool_response) : [],
+    transcript_path: data.transcript_path,
+  };
+  fs.appendFileSync('/tmp/df-posttooluse-summary.jsonl', JSON.stringify(summary) + '\n');
 });

package/hooks/df-tool-usage.js

@@ -15,6 +15,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 const TOOL_USAGE_LOG = path.join(os.homedir(), '.claude', 'tool-usage.jsonl');
 
@@ -49,56 +50,45 @@ function extractTaskId(cwd) {
   return taskMatch ? taskMatch[1].toUpperCase() : null;
 }
 
-// Read all stdin, then process
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(raw);
-
-    const toolName = data.tool_name || null;
-    const toolResponse = data.tool_response;
-    const cwd = data.cwd || '';
-
-    let activeCommand = null;
-    try {
-      const markerPath = path.join(cwd || process.cwd(), '.deepflow', 'active-command.json');
-      const markerRaw = fs.readFileSync(markerPath, 'utf8');
-      activeCommand = JSON.parse(markerRaw).command || null;
-    } catch (_e) { /* no marker or unreadable — null */ }
+readStdinIfMain(module, (data) => {
+  const toolName = data.tool_name || null;
+  const toolResponse = data.tool_response;
+  const cwd = data.cwd || '';
 
-    // Extract a compact tool_input summary per tool type
-    const ti = data.tool_input || {};
-    let inputSummary = null;
-    if (toolName === 'Bash') inputSummary = ti.command || null;
-    else if (toolName === 'LSP') inputSummary = `${ti.operation || '?'}:${(ti.filePath || '').split('/').pop()}:${ti.line || '?'}`;
-    else if (toolName === 'Read') inputSummary = (ti.file_path || '').split('/').pop() + (ti.offset ? `:${ti.offset}-${ti.offset + (ti.limit || 0)}` : '');
-    else if (toolName === 'Grep') inputSummary = ti.pattern || null;
-    else if (toolName === 'Glob') inputSummary = ti.pattern || null;
-    else if (toolName === 'Agent') inputSummary = `${ti.subagent_type || '?'}/${ti.model || '?'}`;
-    else if (toolName === 'Edit' || toolName === 'Write') inputSummary = (ti.file_path || '').split('/').pop();
+  let activeCommand = null;
+  try {
+    const markerPath = path.join(cwd || process.cwd(), '.deepflow', 'active-command.json');
+    const markerRaw = fs.readFileSync(markerPath, 'utf8');
+    activeCommand = JSON.parse(markerRaw).command || null;
+  } catch (_e) { /* no marker or unreadable — null */ }
 
-    const record = {
-      timestamp: new Date().toISOString(),
-      session_id: data.session_id || null,
-      tool_name: toolName,
-      input: inputSummary,
-      output_size_est_tokens: Math.ceil(JSON.stringify(toolResponse).length / 4),
-      project: cwd ? path.basename(cwd) : null,
-      phase: inferPhase(cwd),
-      task_id: extractTaskId(cwd),
-      active_command: activeCommand,
-    };
+  // Extract a compact tool_input summary per tool type
+  const ti = data.tool_input || {};
+  let inputSummary = null;
+  if (toolName === 'Bash') inputSummary = ti.command || null;
+  else if (toolName === 'LSP') inputSummary = `${ti.operation || '?'}:${(ti.filePath || '').split('/').pop()}:${ti.line || '?'}`;
+  else if (toolName === 'Read') inputSummary = (ti.file_path || '').split('/').pop() + (ti.offset ? `:${ti.offset}-${ti.offset + (ti.limit || 0)}` : '');
+  else if (toolName === 'Grep') inputSummary = ti.pattern || null;
+  else if (toolName === 'Glob') inputSummary = ti.pattern || null;
+  else if (toolName === 'Agent') inputSummary = `${ti.subagent_type || '?'}/${ti.model || '?'}`;
+  else if (toolName === 'Edit' || toolName === 'Write') inputSummary = (ti.file_path || '').split('/').pop();
 
-    const logDir = path.dirname(TOOL_USAGE_LOG);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
+  const record = {
+    timestamp: new Date().toISOString(),
+    session_id: data.session_id || null,
+    tool_name: toolName,
+    input: inputSummary,
+    output_size_est_tokens: Math.ceil(JSON.stringify(toolResponse).length / 4),
+    project: cwd ? path.basename(cwd) : null,
+    phase: inferPhase(cwd),
+    task_id: extractTaskId(cwd),
+    active_command: activeCommand,
+  };
 
-    fs.appendFileSync(TOOL_USAGE_LOG, JSON.stringify(record) + '\n');
-  } catch (_e) {
-    // Fail silently — never break tool execution
+  const logDir = path.dirname(TOOL_USAGE_LOG);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
   }
-  process.exit(0);
+
+  fs.appendFileSync(TOOL_USAGE_LOG, JSON.stringify(record) + '\n');
 });

package/hooks/df-worktree-guard.js

@@ -19,6 +19,7 @@
 'use strict';
 
 const { execFileSync } = require('child_process');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 // Paths that are always allowed regardless of worktree state
 const ALLOWLIST = [
@@ -56,47 +57,38 @@ function dfWorktreeExists(cwd) {
   }
 }
 
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(raw);
-    const toolName = data.tool_name || '';
-
-    // Only guard Write and Edit
-    if (toolName !== 'Write' && toolName !== 'Edit') {
-      process.exit(0);
-    }
+readStdinIfMain(module, (data) => {
+  const toolName = data.tool_name || '';
 
-    const filePath = (data.tool_input && data.tool_input.file_path) || '';
-    const cwd = data.cwd || process.cwd();
+  // Only guard Write and Edit
+  if (toolName !== 'Write' && toolName !== 'Edit') {
+    return;
+  }
 
-    // Allowlisted paths always pass
-    if (isAllowlisted(filePath)) {
-      process.exit(0);
-    }
+  const filePath = (data.tool_input && data.tool_input.file_path) || '';
+  const cwd = data.cwd || process.cwd();
 
-    const branch = currentBranch(cwd);
+  // Allowlisted paths always pass
+  if (isAllowlisted(filePath)) {
+    return;
+  }
 
-    // Only guard when on main/master
-    if (branch !== 'main' && branch !== 'master') {
-      process.exit(0);
-    }
+  const branch = currentBranch(cwd);
 
-    // Block only when a df/* worktree branch exists
-    if (!dfWorktreeExists(cwd)) {
-      process.exit(0);
-    }
+  // Only guard when on main/master
+  if (branch !== 'main' && branch !== 'master') {
+    return;
+  }
 
-    // All conditions met — block the write
-    console.error(
-      `[df-worktree-guard] Blocked ${toolName} to "${filePath}" on main branch ` +
-      `while df/* worktree exists. Make changes inside the worktree branch instead.`
-    );
-    process.exit(1);
-  } catch (_e) {
-    // Parse or unexpected error — fail open so we never break non-deepflow projects
-    process.exit(0);
+  // Block only when a df/* worktree branch exists
+  if (!dfWorktreeExists(cwd)) {
+    return;
   }
+
+  // All conditions met — block the write
+  console.error(
+    `[df-worktree-guard] Blocked ${toolName} to "${filePath}" on main branch ` +
+    `while df/* worktree exists. Make changes inside the worktree branch instead.`
+  );
+  process.exit(1);
 });

package/hooks/lib/hook-stdin.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * Shared stdin helper for deepflow hooks.
+ *
+ * Usage in a hook file:
+ *   const { readStdinIfMain } = require('./lib/hook-stdin');
+ *   readStdinIfMain(module, (data) => { ... });
+ *
+ * The helper checks if the CALLING hook is the main module (i.e. run directly,
+ * not required by a test). This prevents test files from hanging on stdin.
+ */
+
+/**
+ * readStdinIfMain(callerModule, callback)
+ *
+ * @param {NodeModule} callerModule  Pass `module` from the calling hook file.
+ * @param {function(Object): void} callback  Called with the parsed JSON payload.
+ *   If stdin is not valid JSON the process exits 0 without calling callback.
+ */
+function readStdinIfMain(callerModule, callback) {
+  if (require.main !== callerModule) {
+    // Being required (e.g. by a test) — do not read stdin.
+    return;
+  }
+
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { raw += chunk; });
+  process.stdin.on('end', () => {
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch (_e) {
+      // Invalid JSON — exit 0 to avoid breaking Claude Code.
+      process.exit(0);
+    }
+    try {
+      callback(payload);
+    } catch (_e) {
+      // Never break Claude Code on hook errors.
+    }
+    process.exit(0);
+  });
+}
+
+module.exports = { readStdinIfMain };