@hailer/mcp 1.0.29 → 1.1.2

package/.claude/hooks/builder-mode-manager.cjs

@@ -40,21 +40,47 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch (e) {
+  // ENOENT is expected when not in yolo mode - only warn on unexpected errors
+  if (e.code !== 'ENOENT' && !e.message.includes('Unexpected')) {
+    console.error(`[builder-mode-manager] Warning: ${e.message}`);
+  }
+}
 
-const BUILDER_MODE_FILE = '/tmp/.claude-builder-agent-active';
-const AGENT_STACK_FILE = '/tmp/.claude-agent-stack.json';
+const TEMP_DIR = os.tmpdir();
+const BUILDER_MODE_FILE = path.join(TEMP_DIR, '.claude-builder-agent-active');
+const AGENT_STACK_FILE = path.join(TEMP_DIR, '.claude-agent-stack.json');
+const LOCK_FILE = AGENT_STACK_FILE + '.lock';
+const LOCK_TIMEOUT = 5000; // 5 seconds max wait
 
 // Agents that need builder mode (can edit code)
+// Uses partial matching - any subagent_type containing these strings triggers builder mode
 const CODE_EDITING_AGENTS = [
-  'giuseppe',        // Hailer app builder
-  'gunther',         // MCP tool builder
-  'general-purpose', // Can do anything
-  'agent-builder',   // Creates new agents
-  'helga',           // Workspace config (edits workspace/ files)
-  'ingrid',          // Document templates
-  'ada',             // Skills and agent improvements
+  'giuseppe',        // agent-giuseppe-app-builder
+  'gunther',         // agent-gunther-mcp-tools
+  'general-purpose', // general-purpose agent
+  'agent-builder',   // agent-builder-agent-creator
+  'helga',           // agent-helga-workflow-config
+  'ingrid',          // agent-ingrid-doc-templates
+  'ada',             // agent-ada-skill-builder
+  'simple-writer',   // agent-simple-writer
+  'code-simplifier', // agent-code-simplifier
+  'marco',           // agent-marco-mockup-builder
 ];
 
+// NOTE: No in-memory cache - multiple hooks may run concurrently
+// Each hook reads fresh from file to avoid stale reads
+
+// Staleness threshold - remove agents older than this (4 hours - long-running agents need time)
+const AGENT_STALENESS_MS = 4 * 60 * 60 * 1000;
+
 // Read hook input from stdin
 let input = '';
 process.stdin.setEncoding('utf8');
@@ -65,38 +91,128 @@ process.stdin.on('end', () => {
     processHook(data);
   } catch (e) {
     // Invalid JSON - allow to avoid blocking
+    console.error(`[builder-mode-manager] Warning: ${e.message}`);
     console.log(JSON.stringify({ decision: 'allow' }));
     process.exit(0);
   }
 });
 
+function acquireLock() {
+  const start = Date.now();
+  while (Date.now() - start < LOCK_TIMEOUT) {
+    try {
+      fs.mkdirSync(LOCK_FILE);
+      return true;
+    } catch (e) {
+      try {
+        const stat = fs.statSync(LOCK_FILE);
+        if (Date.now() - stat.mtimeMs > 10000) {
+          fs.rmdirSync(LOCK_FILE);
+          continue;
+        }
+      } catch (e2) { /* lock was released between check */ }
+      const waitUntil = Date.now() + 50;
+      while (Date.now() < waitUntil) { /* busy wait */ }
+    }
+  }
+  return false;
+}
+
+function releaseLock() {
+  try { fs.rmdirSync(LOCK_FILE); } catch (e) { /* already released */ }
+}
+
+/**
+ * Remove stale agents from the stack (older than AGENT_STALENESS_MS)
+ * Also clears builderModeEnabledBy if that agent was removed
+ * Returns true if any agents were removed
+ */
+function cleanupStaleAgents(stack) {
+  const now = Date.now();
+  const originalCount = stack.agents.length;
+
+  stack.agents = stack.agents.filter(agent => {
+    // Keep agents without timestamp (backward compatibility - assume current session)
+    if (!agent.startedAt) return true;
+
+    const agentTime = new Date(agent.startedAt).getTime();
+
+    // Remove agents with invalid timestamps (NaN from malformed dates)
+    if (isNaN(agentTime)) {
+      console.error(`[builder-mode-manager] Warning: Invalid timestamp for agent ${agent.type}, removing`);
+      return false;
+    }
+
+    return (now - agentTime) < AGENT_STALENESS_MS;
+  });
+
+  const removed = originalCount - stack.agents.length;
+  if (removed > 0) {
+    console.error(`[builder-mode-manager] Cleaned up ${removed} stale agent(s) from stack`);
+  }
+
+  // Clear builderModeEnabledBy if that agent is no longer in stack OR stack is empty
+  if (stack.builderModeEnabledBy) {
+    const enablerStillActive = stack.agents.some(a => a.type === stack.builderModeEnabledBy);
+    if (!enablerStillActive || stack.agents.length === 0) {
+      stack.builderModeEnabledBy = null;
+    }
+  }
+
+  return removed > 0;
+}
+
 /**
  * Load the agent stack (tracks nested agent calls)
+ * Always reads fresh from file - no caching to avoid race conditions
+ * Automatically cleans up stale agents from previous sessions
  */
 function loadAgentStack() {
   try {
     if (fs.existsSync(AGENT_STACK_FILE)) {
-      return JSON.parse(fs.readFileSync(AGENT_STACK_FILE, 'utf8'));
+      const stack = JSON.parse(fs.readFileSync(AGENT_STACK_FILE, 'utf8'));
+
+      // Clean up stale agents from previous sessions
+      const hadStaleAgents = cleanupStaleAgents(stack);
+
+      // If we cleaned up agents, save the updated stack
+      if (hadStaleAgents) {
+        // Also reset builder mode if no agents remain
+        if (stack.agents.length === 0) {
+          stack.builderModeEnabledBy = null;
+          disableBuilderMode();
+        }
+        saveAgentStack(stack);
+      }
+
+      return stack;
     }
-  } catch {}
+  } catch (e) {
+    console.error(`[builder-mode-manager] Warning: ${e.message}`);
+  }
+
   return { agents: [], builderModeEnabledBy: null };
 }
 
 /**
- * Save the agent stack
+ * Save the agent stack atomically (write to temp, then rename)
  */
 function saveAgentStack(stack) {
-  fs.writeFileSync(AGENT_STACK_FILE, JSON.stringify(stack, null, 2));
+  const tmpFile = AGENT_STACK_FILE + '.tmp-' + process.pid;
+  fs.writeFileSync(tmpFile, JSON.stringify(stack, null, 2), { mode: 0o600 });
+  fs.renameSync(tmpFile, AGENT_STACK_FILE); // Atomic on POSIX
 }
 
 /**
- * Enable builder mode
+ * Enable builder mode (atomic write: temp file + rename)
  */
 function enableBuilderMode(agentName) {
-  fs.writeFileSync(BUILDER_MODE_FILE, JSON.stringify({
+  const tmpFile = BUILDER_MODE_FILE + '.tmp-' + process.pid;
+  fs.writeFileSync(tmpFile, JSON.stringify({
     enabledAt: new Date().toISOString(),
     enabledBy: agentName
-  }));
+  }), { mode: 0o600 });
+  fs.renameSync(tmpFile, BUILDER_MODE_FILE); // Atomic on POSIX
 }
 
 /**
@@ -118,7 +234,7 @@ function isBuilderModeActive() {
 }
 
 function processHook(data) {
-  const { tool_name, tool_input, tool_response, hook_type } = data;
+  const { tool_name, tool_input, tool_response } = data;
 
   // Only handle Task tool
   if (tool_name !== 'Task') {
@@ -133,48 +249,61 @@ function processHook(data) {
     process.exit(0);
   }
 
-  const needsBuilderMode = CODE_EDITING_AGENTS.includes(agentType);
-  const stack = loadAgentStack();
+  const needsBuilderMode = CODE_EDITING_AGENTS.some(name => agentType.includes(name));
 
   // Determine if this is PreToolUse or PostToolUse based on presence of tool_response
   const isPreToolUse = tool_response === undefined;
 
-  if (isPreToolUse) {
-    // === PreToolUse: Agent is about to be spawned ===
-
-    // Push agent onto stack
-    stack.agents.push({
-      type: agentType,
-      startedAt: new Date().toISOString(),
-      needsBuilderMode
-    });
-
-    // Enable builder mode if needed and not already active
-    if (needsBuilderMode && !isBuilderModeActive()) {
-      enableBuilderMode(agentType);
-      stack.builderModeEnabledBy = agentType;
-      console.error(`🔧 Builder mode AUTO-ENABLED for agent: ${agentType}`);
-    }
-
-    saveAgentStack(stack);
-
-  } else {
-    // === PostToolUse: Agent has completed ===
-
-    // Pop the most recent agent from stack
-    const completedAgent = stack.agents.pop();
-
-    // Check if any remaining agents need builder mode
-    const remainingNeedBuilderMode = stack.agents.some(a => a.needsBuilderMode);
-
-    // Disable builder mode if no more agents need it
-    if (isBuilderModeActive() && !remainingNeedBuilderMode) {
-      disableBuilderMode();
-      stack.builderModeEnabledBy = null;
-      console.error(`🔒 Builder mode AUTO-DISABLED (${agentType} completed)`);
+  const locked = acquireLock();
+  try {
+    const stack = loadAgentStack();
+
+    if (isPreToolUse) {
+      // === PreToolUse: Agent is about to be spawned ===
+
+      // Push agent onto stack
+      stack.agents.push({
+        type: agentType,
+        startedAt: new Date().toISOString(),
+        needsBuilderMode
+      });
+
+      // Enable builder mode if needed and not already active
+      if (needsBuilderMode && !isBuilderModeActive()) {
+        enableBuilderMode(agentType);
+        stack.builderModeEnabledBy = agentType;
+        console.error(`🔧 Builder mode AUTO-ENABLED for agent: ${agentType}`);
+      }
+
+      saveAgentStack(stack);
+
+    } else {
+      // === PostToolUse: Agent has completed ===
+
+      // Remove the matching agent from stack (find last one with this type)
+      // Using findLastIndex instead of pop() to handle parallel agents completing out of order
+      const removeIdx = stack.agents.findLastIndex(a => a.type === agentType);
+      if (removeIdx >= 0) {
+        stack.agents.splice(removeIdx, 1);
+      } else {
+        // Agent not found - could be stale or already cleaned up
+        console.error(`[builder-mode-manager] Warning: agent ${agentType} not found in stack, skipping removal`);
+      }
+
+      // Check if any remaining agents need builder mode
+      const remainingNeedBuilderMode = stack.agents.some(a => a.needsBuilderMode);
+
+      // Disable builder mode if no more agents need it
+      if (isBuilderModeActive() && !remainingNeedBuilderMode) {
+        disableBuilderMode();
+        stack.builderModeEnabledBy = null;
+        console.error(`🔒 Builder mode AUTO-DISABLED (${agentType} completed)`);
+      }
+
+      saveAgentStack(stack);
     }
-
-    saveAgentStack(stack);
+  } finally {
+    if (locked) releaseLock();
   }
 
   // Always allow Task tool

package/.claude/hooks/bulk-activity-guard.cjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>bulk-activity-guard</hook-name>
+ *
+ * <purpose>
+ * Confirms before creating many activities at once.
+ * Prevents accidental bulk data creation via Dmitri agent.
+ * </purpose>
+ *
+ * <triggers>
+ * - PreToolUse on mcp__hailer__create_activity
+ * - PreToolUse on mcp__hailer__bulk_create_activities (if exists)
+ * </triggers>
+ *
+ * <thresholds>
+ * - Single call with array > 5 items: Warn
+ * - Tracked calls in short window > 10: Warn
+ * </thresholds>
+ *
+ * <behavior>
+ * 1. Check if bulk creation (array input or rapid sequential calls)
+ * 2. If threshold exceeded, block and require confirmation
+ * 3. Track recent calls in temp file for sequential detection
+ * </behavior>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch (e) {
+  // ENOENT is expected when not in yolo mode - only warn on unexpected errors
+  if (e.code !== 'ENOENT' && !e.message.includes('Unexpected')) {
+    console.error(`[bulk-activity-guard] Warning: ${e.message}`);
+  }
+}
+
+// Skip in subagent context - orchestrator handles confirmation via delegation-bulk-guard
+// Subagents can't use AskUserQuestion or Bash, so blocking them is unrecoverable
+if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SUBAGENT) {
+  // Output allow and exit - orchestrator already confirmed
+  console.log(JSON.stringify({ decision: 'allow' }));
+  process.exit(0);
+}
+
+const TRACKER_FILE = path.join(os.tmpdir(), '.claude-activity-creation-tracker.json');
+const LOCK_FILE = TRACKER_FILE + '.lock';
+const LOCK_TIMEOUT = 5000; // 5 seconds max wait
+const BULK_THRESHOLD = 5;
+const SEQUENTIAL_THRESHOLD = 10;
+const TIME_WINDOW_MS = 60000; // 1 minute window for sequential detection
+
+// Read hook input from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    console.error(`[bulk-activity-guard] Warning: ${e.message}`);
+    console.log(JSON.stringify({ decision: 'allow' }));
+    process.exit(0);
+  }
+});
+
+function outputAllow() {
+  console.log(JSON.stringify({ decision: 'allow' }));
+  process.exit(0);
+}
+
+function outputBlock(message) {
+  console.log(JSON.stringify({
+    decision: 'block',
+    reason: message
+  }));
+  process.exit(0);
+}
+
+function acquireLock() {
+  const start = Date.now();
+  while (Date.now() - start < LOCK_TIMEOUT) {
+    try {
+      fs.mkdirSync(LOCK_FILE);
+      return true;
+    } catch (e) {
+      // Lock exists - check if stale (older than 10 seconds)
+      try {
+        const stat = fs.statSync(LOCK_FILE);
+        if (Date.now() - stat.mtimeMs > 10000) {
+          fs.rmdirSync(LOCK_FILE);
+          continue;
+        }
+      } catch (e2) { /* lock was released between check */ }
+      // Wait 50ms and retry
+      const waitUntil = Date.now() + 50;
+      while (Date.now() < waitUntil) { /* busy wait - hooks are sync */ }
+    }
+  }
+  return false; // Timeout - proceed without lock (fallback)
+}
+
+function releaseLock() {
+  try { fs.rmdirSync(LOCK_FILE); } catch (e) { /* already released */ }
+}
+
+function loadTracker() {
+  try {
+    if (fs.existsSync(TRACKER_FILE)) {
+      return JSON.parse(fs.readFileSync(TRACKER_FILE, 'utf8'));
+    }
+  } catch (e) {
+    console.error(`[bulk-activity-guard] Warning: ${e.message}`);
+  }
+  return { calls: [], confirmed: false, confirmedAt: null };
+}
+
+function saveTracker(tracker) {
+  // Atomic write: write to temp file, then rename
+  const tmpFile = TRACKER_FILE + '.tmp-' + process.pid;
+  fs.writeFileSync(tmpFile, JSON.stringify(tracker, null, 2), { mode: 0o600 });
+  fs.renameSync(tmpFile, TRACKER_FILE); // Atomic on POSIX
+}
+
+function processHook(data) {
+  const { tool_name, tool_input } = data;
+
+  // Only check activity creation tools - exact match to avoid false positives
+  if (!tool_name || (tool_name !== 'mcp__hailer__create_activity' && tool_name !== 'mcp__hailer__bulk_create_activities')) {
+    outputAllow();
+    return;
+  }
+
+  const locked = acquireLock();
+  try {
+    const now = Date.now();
+    const tracker = loadTracker();
+
+    // Clean old calls outside time window
+    tracker.calls = tracker.calls.filter(t => now - t < TIME_WINDOW_MS);
+
+    // Check if recently confirmed (within last 5 minutes)
+    if (tracker.confirmed && tracker.confirmedAt && (now - tracker.confirmedAt) < 300000) {
+      // User recently confirmed bulk creation, allow
+      tracker.calls.push(now);
+      saveTracker(tracker);
+      outputAllow();
+      return;
+    }
+
+    // Reset confirmation if window expired
+    tracker.confirmed = false;
+    tracker.confirmedAt = null;
+
+    // Check for bulk array in input
+    let itemCount = 1;
+    try {
+      if (tool_input?.activities && Array.isArray(tool_input.activities)) {
+        itemCount = tool_input.activities.length;
+      }
+    } catch {}
+
+    // Add current call
+    tracker.calls.push(now);
+    const recentCallCount = tracker.calls.length;
+    saveTracker(tracker);
+
+    // Check thresholds
+    const isBulkArray = itemCount > BULK_THRESHOLD;
+    const isSequentialBulk = recentCallCount > SEQUENTIAL_THRESHOLD;
+
+    if (isBulkArray || isSequentialBulk) {
+      const reason = isBulkArray
+        ? `Creating ${itemCount} activities in one call`
+        : `${recentCallCount} activity creations in the last minute`;
+
+      outputBlock(`
+🚫 BLOCKED: Bulk Activity Creation Detected
+
+**Reason:** ${reason}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CONFIRM WITH USER FIRST
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Use AskUserQuestion to confirm:
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "About to create ${isBulkArray ? itemCount : recentCallCount}+ activities. Continue?",
+    "header": "Bulk Create",
+    "options": [
+      { "label": "Yes, create all", "description": "Proceed with bulk creation" },
+      { "label": "No, stop", "description": "Cancel the operation" }
+    ],
+    "multiSelect": false
+  }]
+}
+\`\`\`
+
+If user confirms, run this to unlock for 5 minutes:
+  Bash: node "${process.argv[1].replace(/'/g, "'\\''")}" --confirm
+
+Then retry the operation.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+    }
+
+    outputAllow();
+  } finally {
+    if (locked) releaseLock();
+  }
+}
+
+// CLI: Confirm bulk creation
+if (process.argv[2] === '--confirm') {
+  const locked = acquireLock();
+  try {
+    const tracker = loadTracker();
+    tracker.confirmed = true;
+    tracker.confirmedAt = Date.now();
+    saveTracker(tracker);
+    console.log('✅ Bulk activity creation confirmed for 5 minutes');
+  } finally {
+    if (locked) releaseLock();
+  }
+  process.exit(0);
+}
+
+// CLI: Reset tracker
+if (process.argv[2] === '--reset') {
+  if (fs.existsSync(TRACKER_FILE)) {
+    fs.unlinkSync(TRACKER_FILE);
+  }
+  console.log('✅ Activity creation tracker reset');
+  process.exit(0);
+}
+
+// CLI: Status
+if (process.argv[2] === '--status') {
+  const tracker = loadTracker();
+  const now = Date.now();
+  const recentCalls = tracker.calls.filter(t => now - t < TIME_WINDOW_MS).length;
+  console.log('Activity Creation Tracker');
+  console.log('=========================');
+  console.log(`Recent calls (1 min): ${recentCalls}`);
+  console.log(`Confirmed: ${tracker.confirmed}`);
+  if (tracker.confirmedAt) {
+    const remaining = Math.max(0, 300000 - (now - tracker.confirmedAt));
+    console.log(`Confirmation expires in: ${Math.round(remaining / 1000)}s`);
+  }
+  process.exit(0);
+}
+
+// CLI: Help
+if (process.argv[2] === '--help' || process.argv[2] === '-h') {
+  console.log(`
+Bulk Activity Guard - Confirms before bulk activity creation
+
+Usage:
+  node bulk-activity-guard.cjs --confirm   Confirm bulk creation for 5 minutes
+  node bulk-activity-guard.cjs --reset     Reset the tracker
+  node bulk-activity-guard.cjs --status    Show current status
+  node bulk-activity-guard.cjs --help      Show this help
+
+Thresholds:
+  - Single call with >${BULK_THRESHOLD} items: Blocked
+  - >${SEQUENTIAL_THRESHOLD} calls in 1 minute: Blocked
+
+As a hook:
+  Reads JSON from stdin with tool_name and tool_input
+  Outputs JSON with decision: "allow" or "block"
+`);
+  process.exit(0);
+}