agileflow 2.77.0 → 2.79.0

package/scripts/damage-control/write-tool-damage-control.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * write-tool-damage-control.js - Enforce path protection for Write tool
+ *
+ * This PreToolUse hook runs before every Write tool execution.
+ * It checks the file path against patterns.yaml to block writes
+ * to protected paths.
+ *
+ * Path protection levels:
+ *   zeroAccessPaths: Cannot read, write, edit, or delete
+ *   readOnlyPaths: Can read, cannot write or delete
+ *   noDeletePaths: Can read and write, cannot delete (Write is allowed)
+ *
+ * Exit codes:
+ *   0 = Allow write to proceed
+ *   2 = Block write
+ *
+ * Usage (as PreToolUse hook):
+ *   node .claude/hooks/damage-control/write-tool-damage-control.js
+ *
+ * Environment:
+ *   CLAUDE_TOOL_INPUT - JSON string with tool input (contains "file_path")
+ *   CLAUDE_PROJECT_DIR - Project root directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI colors for output
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+// Exit codes
+const EXIT_ALLOW = 0;
+const EXIT_BLOCK = 2;
+
+/**
+ * Load path protection rules from patterns.yaml
+ */
+function loadPathRules(projectDir) {
+  const locations = [
+    path.join(projectDir, '.claude/hooks/damage-control/patterns.yaml'),
+    path.join(projectDir, '.agileflow/hooks/damage-control/patterns.yaml'),
+    path.join(projectDir, 'patterns.yaml'),
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      try {
+        const content = fs.readFileSync(loc, 'utf8');
+        return parsePathRules(content);
+      } catch (e) {
+        console.error(`Warning: Could not parse ${loc}: ${e.message}`);
+      }
+    }
+  }
+
+  return getDefaultPathRules();
+}
+
+/**
+ * Parse path rules from YAML content
+ */
+function parsePathRules(content) {
+  const rules = {
+    zeroAccessPaths: [],
+    readOnlyPaths: [],
+    noDeletePaths: [],
+  };
+
+  let currentSection = null;
+
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    if (line.trim().startsWith('#') || line.trim() === '') continue;
+
+    if (line.match(/^zeroAccessPaths:/)) {
+      currentSection = 'zeroAccessPaths';
+      continue;
+    }
+    if (line.match(/^readOnlyPaths:/)) {
+      currentSection = 'readOnlyPaths';
+      continue;
+    }
+    if (line.match(/^noDeletePaths:/)) {
+      currentSection = 'noDeletePaths';
+      continue;
+    }
+    if (line.match(/^(bashToolPatterns|askPatterns|agileflowPatterns|config):/)) {
+      currentSection = null;
+      continue;
+    }
+
+    if (currentSection && rules[currentSection]) {
+      const pathMatch = line.match(/^\s+-\s*['"]?(.+?)['"]?\s*$/);
+      if (pathMatch) {
+        rules[currentSection].push(pathMatch[1]);
+      }
+    }
+  }
+
+  return rules;
+}
+
+/**
+ * Default path rules if patterns.yaml not found
+ */
+function getDefaultPathRules() {
+  return {
+    zeroAccessPaths: [
+      '~/.ssh/',
+      '~/.aws/credentials',
+      '.env',
+      '.env.local',
+      '.env.production',
+    ],
+    readOnlyPaths: [
+      '/etc/',
+      '~/.bashrc',
+      '~/.zshrc',
+      'package-lock.json',
+      'yarn.lock',
+      '.git/',
+    ],
+    noDeletePaths: [
+      '.agileflow/',
+      '.claude/',
+      'docs/09-agents/status.json',
+      'CLAUDE.md',
+    ],
+  };
+}
+
+/**
+ * Expand home directory in path
+ */
+function expandHome(filePath) {
+  if (filePath.startsWith('~/')) {
+    return path.join(process.env.HOME || '', filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Check if a file path matches a pattern
+ */
+function pathMatches(filePath, pattern) {
+  const expandedPattern = expandHome(pattern);
+  const normalizedFile = path.normalize(filePath);
+  const normalizedPattern = path.normalize(expandedPattern);
+
+  // Exact match
+  if (normalizedFile === normalizedPattern) return true;
+
+  // Directory prefix match
+  if (pattern.endsWith('/')) {
+    if (normalizedFile.startsWith(normalizedPattern)) return true;
+  }
+
+  // Glob pattern (**)
+  if (pattern.includes('**/')) {
+    const globPart = pattern.split('**/')[1];
+    if (normalizedFile.includes(globPart)) return true;
+  }
+
+  // Wildcard at end
+  if (pattern.endsWith('*')) {
+    const prefix = normalizedPattern.slice(0, -1);
+    if (normalizedFile.startsWith(prefix)) return true;
+  }
+
+  // Basename match
+  if (!pattern.includes('/') && !pattern.includes(path.sep)) {
+    const basename = path.basename(normalizedFile);
+    if (basename === pattern) return true;
+    if (pattern.endsWith('*')) {
+      const patternBase = pattern.slice(0, -1);
+      if (basename.startsWith(patternBase)) return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if file path is protected for writing
+ * Returns: { blocked: boolean, reason: string, level: string }
+ */
+function checkPath(filePath, rules) {
+  // Check zero access paths (blocked completely)
+  for (const pattern of rules.zeroAccessPaths) {
+    if (pathMatches(filePath, pattern)) {
+      return {
+        blocked: true,
+        reason: `Path is in zero-access protected list: ${pattern}`,
+        level: 'zero-access',
+      };
+    }
+  }
+
+  // Check read-only paths (cannot write)
+  for (const pattern of rules.readOnlyPaths) {
+    if (pathMatches(filePath, pattern)) {
+      return {
+        blocked: true,
+        reason: `Path is read-only: ${pattern}`,
+        level: 'read-only',
+      };
+    }
+  }
+
+  // noDeletePaths allows writing, only blocks deletion
+  // so we don't block writes here
+
+  return { blocked: false, reason: null, level: null };
+}
+
+/**
+ * Main entry point
+ */
+function main() {
+  const toolInput = process.env.CLAUDE_TOOL_INPUT;
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+  if (!toolInput) {
+    process.exit(EXIT_ALLOW);
+  }
+
+  let input;
+  try {
+    input = JSON.parse(toolInput);
+  } catch (e) {
+    console.error('Error parsing CLAUDE_TOOL_INPUT:', e.message);
+    process.exit(EXIT_ALLOW);
+  }
+
+  const filePath = input.file_path;
+  if (!filePath) {
+    process.exit(EXIT_ALLOW);
+  }
+
+  // Resolve to absolute path
+  const absolutePath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(projectDir, filePath);
+
+  // Load rules
+  const rules = loadPathRules(projectDir);
+
+  // Check path
+  const result = checkPath(absolutePath, rules);
+
+  if (result.blocked) {
+    console.error(`${c.red}${c.bold}BLOCKED${c.reset}: ${result.reason}`);
+    console.error(`${c.yellow}File: ${filePath}${c.reset}`);
+    console.error(`${c.cyan}This file is protected by damage control (${result.level}).${c.reset}`);
+    process.exit(EXIT_BLOCK);
+  }
+
+  process.exit(EXIT_ALLOW);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { checkPath, loadPathRules, pathMatches };

package/scripts/damage-control-bash.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+/**
+ * damage-control-bash.js - PreToolUse hook for Bash tool
+ *
+ * Validates bash commands against patterns in damage-control-patterns.yaml
+ * before execution. Part of AgileFlow's damage control system.
+ *
+ * Exit codes:
+ *   0 - Allow command (or ask via JSON output)
+ *   2 - Block command
+ *
+ * For "ask" response, output JSON to stdout:
+ *   { "result": "ask", "message": "Confirm this action?" }
+ *
+ * Usage: Configured as PreToolUse hook in .claude/settings.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Color codes for output
+const c = {
+  red: '\x1b[38;5;203m',
+  yellow: '\x1b[38;5;215m',
+  reset: '\x1b[0m',
+  dim: '\x1b[2m'
+};
+
+/**
+ * Find project root by looking for .agileflow directory
+ */
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (fs.existsSync(path.join(dir, '.agileflow'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+/**
+ * Parse simplified YAML for damage control patterns
+ * Only parses the structure we need - not a full YAML parser
+ */
+function parseSimpleYAML(content) {
+  const config = {
+    bashToolPatterns: [],
+    askPatterns: [],
+    agileflowProtections: []
+  };
+
+  let currentSection = null;
+  let currentPattern = null;
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    // Detect section headers
+    if (trimmed === 'bashToolPatterns:') {
+      currentSection = 'bashToolPatterns';
+      currentPattern = null;
+    } else if (trimmed === 'askPatterns:') {
+      currentSection = 'askPatterns';
+      currentPattern = null;
+    } else if (trimmed === 'agileflowProtections:') {
+      currentSection = 'agileflowProtections';
+      currentPattern = null;
+    } else if (trimmed.endsWith(':') && !trimmed.startsWith('-')) {
+      // Other sections we don't care about for bash validation
+      currentSection = null;
+      currentPattern = null;
+    } else if (trimmed.startsWith('- pattern:') && currentSection) {
+      // New pattern entry
+      const patternValue = trimmed.replace('- pattern:', '').trim().replace(/^["']|["']$/g, '');
+      currentPattern = { pattern: patternValue };
+      config[currentSection].push(currentPattern);
+    } else if (trimmed.startsWith('reason:') && currentPattern) {
+      currentPattern.reason = trimmed.replace('reason:', '').trim().replace(/^["']|["']$/g, '');
+    } else if (trimmed.startsWith('flags:') && currentPattern) {
+      currentPattern.flags = trimmed.replace('flags:', '').trim().replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Load patterns configuration from YAML file
+ */
+function loadPatterns(projectRoot) {
+  const configPaths = [
+    path.join(projectRoot, '.agileflow/config/damage-control-patterns.yaml'),
+    path.join(projectRoot, '.agileflow/config/damage-control-patterns.yml'),
+    path.join(projectRoot, '.agileflow/templates/damage-control-patterns.yaml')
+  ];
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        return parseSimpleYAML(content);
+      } catch (e) {
+        // Continue to next path
+      }
+    }
+  }
+
+  // Return empty config if no file found (fail-open)
+  return { bashToolPatterns: [], askPatterns: [], agileflowProtections: [] };
+}
+
+/**
+ * Test command against a single pattern rule
+ */
+function matchesPattern(command, rule) {
+  try {
+    const flags = rule.flags || '';
+    const regex = new RegExp(rule.pattern, flags);
+    return regex.test(command);
+  } catch (e) {
+    // Invalid regex - skip this pattern
+    return false;
+  }
+}
+
+/**
+ * Validate command against all patterns
+ */
+function validateCommand(command, config) {
+  // Check blocked patterns (bashToolPatterns + agileflowProtections)
+  const blockedPatterns = [
+    ...(config.bashToolPatterns || []),
+    ...(config.agileflowProtections || [])
+  ];
+
+  for (const rule of blockedPatterns) {
+    if (matchesPattern(command, rule)) {
+      return {
+        action: 'block',
+        reason: rule.reason || 'Command blocked by damage control'
+      };
+    }
+  }
+
+  // Check ask patterns
+  for (const rule of config.askPatterns || []) {
+    if (matchesPattern(command, rule)) {
+      return {
+        action: 'ask',
+        reason: rule.reason || 'Please confirm this command'
+      };
+    }
+  }
+
+  // Allow by default
+  return { action: 'allow' };
+}
+
+/**
+ * Main function - read input and validate
+ */
+function main() {
+  const projectRoot = findProjectRoot();
+  let inputData = '';
+
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', chunk => {
+    inputData += chunk;
+  });
+
+  process.stdin.on('end', () => {
+    try {
+      // Parse tool input from Claude Code
+      const input = JSON.parse(inputData);
+      const command = input.command || input.tool_input?.command || '';
+
+      if (!command) {
+        // No command to validate - allow
+        process.exit(0);
+      }
+
+      // Load patterns and validate
+      const config = loadPatterns(projectRoot);
+      const result = validateCommand(command, config);
+
+      switch (result.action) {
+        case 'block':
+          // Output error message and block
+          console.error(`${c.red}[BLOCKED]${c.reset} ${result.reason}`);
+          console.error(`${c.dim}Command: ${command.substring(0, 100)}${command.length > 100 ? '...' : ''}${c.reset}`);
+          process.exit(2);
+          break;
+
+        case 'ask':
+          // Output JSON to trigger user confirmation
+          console.log(JSON.stringify({
+            result: 'ask',
+            message: result.reason
+          }));
+          process.exit(0);
+          break;
+
+        case 'allow':
+        default:
+          // Allow command to proceed
+          process.exit(0);
+      }
+    } catch (e) {
+      // Parse error or other issue - fail open
+      // This ensures broken config doesn't block all commands
+      process.exit(0);
+    }
+  });
+
+  // Handle no stdin (direct invocation)
+  process.stdin.on('error', () => {
+    process.exit(0);
+  });
+
+  // Set timeout to prevent hanging
+  setTimeout(() => {
+    process.exit(0);
+  }, 4000);
+}
+
+main();