<!-- title: Claude Code事件驱动自动化：Hooks到自愈流水线 -->

# Claude Code事件驱动自动化：Hooks触发到自愈流水线实战

## 概述

本教程面向有一定Claude Code基础的中高级开发者，学习如何将`-p`非交互模式、Hooks生命周期钩子、会话管理与批量处理整合为一条**事件驱动的自动化流水线**。不同于单点使用`-p`命令或单独配置Hooks，本教程聚焦三者联动——让Claude Code像CI系统一样自主感知、响应、修复，构建从代码提交到自动修复的完整闭环。适合需要7×24小时无人值守AI辅助开发的团队。

## 前置条件

- Claude Code ≥ 2.0（`claude --version`确认）
- 熟悉命令行基础操作与Shell脚本
- 了解Git工作流（commit、branch、worktree）
- Node.js ≥ 18（运行Hooks脚本）
- 一个可操作的Git项目

## 一、自动化三件套：架构全景

在深入每个组件之前，先建立整体架构认知。Claude Code的自动化能力由三个核心层构成：

```mermaid
graph TB
    subgraph 触发层["触发层（Hooks）"]
        A[PreToolUse] --> D{路由决策}
        B[PostToolUse] --> D
        C[Notification] --> D
        E[Stop] --> D
        F[SubagentStop] --> D
    end

    subgraph 执行层["执行层（-p Headless）"]
        D --> G[claude -p 单次任务]
        D --> H[claude -p --continue 续接]
        D --> I[claude -p --resume 恢复]
    end

    subgraph 编排层["编排层（Batch + Worktree）"]
        G --> J[串行批处理]
        H --> K[并行Worktree]
        I --> L[条件分支]
    end

    J --> M[结果汇总]
    K --> M
    L --> M

    M -->|反馈| 触发层

    style 触发层 fill:#e1f5fe
    style 执行层 fill:#fff3e0
    style 编排层 fill:#e8f5e9
```

**关键洞察**：三层不是孤立的。Hooks捕获事件后可以触发`-p`命令执行，`-p`执行中的工具调用又会被Hooks拦截，形成递归反馈循环。这正是"事件驱动"的精髓——不是你告诉Claude做什么，而是事件告诉Claude该做什么。

## 二、-p模式深度实战：超越简单命令

### 2.1 基础用法回顾与进阶

`-p`（`--print`）标志将Claude Code从交互式终端工具转变为可编程的命令行工具：

```bash
# 基础：单次问答
claude -p "解释src/auth.ts的认证流程"

# 进阶：指定输出格式
claude -p "列出所有TODO注释" --output-format json

# 进阶：流式JSON输出（适合实时处理）
claude -p "重构数据库模块" --output-format stream-json

# 高级：限制工具和轮次
claude -p "修复lint错误" \
  --allowedTools "Read,Write,Bash" \
  --max-turns 5 \
  --output-format json
```

### 2.2 会话连续性：--continue与--resume

这是构建复杂自动化流水线的关键能力——让AI"记住"上下文：

```bash
# --continue：继续最近一次对话
claude -p "为刚才的重构添加单元测试" --continue

# --resume：恢复指定会话（通过会话ID）
claude -p "继续优化性能" --resume abc123-session-id

# 组合使用：从上次中断处继续，限制轮次防止跑飞
claude -p "继续上次的数据库迁移工作" \
  --continue \
  --max-turns 8 \
  --output-format json
```

**实战技巧**：在自动化脚本中保存会话ID，实现跨脚本调用上下文延续：

```bash
#!/bin/bash
# auto-fix-pipeline.sh — 自动修复流水线

PROJECT_DIR="$1"
SESSION_FILE="/tmp/claude_session_${PROJECT_DIR//\//_}.txt"

# 第一步：分析问题
RESULT=$(claude -p "分析 $PROJECT_DIR 中所有TypeScript编译错误，分类汇总" \
  --output-format json \
  --max-turns 3)

# 提取会话ID（从JSON输出中）
SESSION_ID=$(echo "$RESULT" | jq -r '.session_id // empty')

if [ -n "$SESSION_ID" ]; then
  echo "$SESSION_ID" > "$SESSION_FILE"
fi

# 第二步：基于分析结果自动修复（延续上下文）
if [ -f "$SESSION_FILE" ]; then
  claude -p "根据刚才的分析，按优先级修复错误。每修复一类就运行 tsc --noEmit 验证。" \
    --resume "$(cat "$SESSION_FILE")" \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash"
fi
```

### 2.3 输出格式与管道集成

`--output-format`是自动化集成的核心桥梁：

| 格式 | 适用场景 | 解析方式 |
|------|---------|---------|
| `text` | 人类阅读、简单日志 | 直接输出 |
| `json` | 结构化解析、CI判断 | `jq` 提取字段 |
| `stream-json` | 实时监控、进度跟踪 | 逐行JSON解析 |

```bash
# 在GitHub Actions中使用JSON输出进行决策
REVIEW=$(claude -p "审查本次PR的代码变更，评估风险等级：low/medium/high" \
  --output-format json \
  --max-turns 3)

RISK_LEVEL=$(echo "$REVIEW" | jq -r '.result // "unknown"')

if [ "$RISK_LEVEL" = "high" ]; then
  echo "::warning::AI检测到高风险变更，建议人工审查"
fi
```

### 2.4 system-prompt与allowedTools的安全边界

在自动化场景中，安全边界至关重要：

```bash
# 最小权限原则：只允许读取和搜索
claude -p "检查代码中是否有硬编码的API密钥" \
  --system-prompt "你是安全审计专家。只报告发现，不修改任何文件。" \
  --allowedTools "Read,Grep,Glob" \
  --output-format json

# 受限写入：只允许修改测试文件
claude -p "为所有未覆盖的函数生成单元测试" \
  --allowedTools "Read,Write,Grep,Glob,Bash" \
  --disallowedTools "Edit" \
  --max-turns 15
```

## 三、Hooks深度实战：事件驱动架构

### 3.1 Hooks配置结构与事件类型

Hooks在`settings.json`中配置，定义了Claude Code生命周期各节点的拦截逻辑：

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/pre-bash-guard.js"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/post-write-format.js"
          }
        ]
      }
    ],
    "Notification": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/notify.js"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/on-stop.js"
          }
        ]
      }
    ]
  }
}
```

### 3.2 六大事件类型与拦截场景

```mermaid
sequenceDiagram
    participant User as 用户/脚本
    participant Claude as Claude Code
    participant Hook as Hooks系统
    participant Tool as 工具(Bash/Write等)
    
    User->>Claude: 发送Prompt
    Note over Claude: UserPromptSubmit触发
    
    Claude->>Hook: PreToolUse事件
    Hook-->>Claude: 允许/拒绝/注入
    
    alt 被允许
        Claude->>Tool: 执行工具
        Tool-->>Claude: 工具结果
        Claude->>Hook: PostToolUse事件
        Hook-->>Claude: 后处理完成
    else 被拒绝
        Claude-->>User: 工具被阻止
    end
    
    Note over Claude: 可能触发Notification
    
    Claude-->>User: 最终响应
    Note over Claude: Stop事件触发
    Claude->>Hook: Stop回调
```

| 事件 | 触发时机 | 典型用途 | 返回值影响 |
|------|---------|---------|-----------|
| `PreToolUse` | 工具执行前 | 安全拦截、参数校验 | `exit 2`阻止执行 |
| `PostToolUse` | 工具执行后 | 自动格式化、日志记录 | 注入补充信息 |
| `Notification` | 通知事件时 | 外部告警、Slack推送 | 无阻塞影响 |
| `Stop` | Agent停止时 | 结果汇总、后续触发 | 无阻塞影响 |
| `SubagentStop` | 子Agent停止时 | 结果聚合 | 无阻塞影响 |
| `UserPromptSubmit` | 用户提交Prompt时 | 输入预处理、注入上下文 | 修改prompt内容 |

### 3.3 实战Hook：智能安全守卫

以下是一个完整的PreToolUse Hook，实现智能命令拦截：

```javascript
// ~/.claude/hooks/pre-bash-guard.js
// 从stdin读取JSON输入
let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  const toolName = data.tool_name;   // 如 "Bash"
  const toolInput = data.tool_input; // 如 { command: "rm -rf /" }
  
  if (toolName === 'Bash') {
    const cmd = toolInput.command || '';
    
    // 规则1：阻止危险命令
    const dangerous = [
      /rm\s+-rf\s+\//,
      /git\s+push\s+--force/,
      /DROP\s+TABLE/i,
      /curl.*\|\s*sh/,
      />\s*\/dev\/sd/,
    ];
    
    for (const pattern of dangerous) {
      if (pattern.test(cmd)) {
        console.log(JSON.stringify({
          decision: "block",
          reason: `安全策略阻止：检测到危险命令模式 "${pattern.source}"`
        }));
        process.exit(2); // exit 2 = 阻止工具执行
      }
    }
    
    // 规则2：对生产环境操作要求确认标记
    if (/prod|production/i.test(cmd) && !/DRY_RUN/.test(cmd)) {
      console.log(JSON.stringify({
        decision: "block",
        reason: "生产环境操作需要添加 DRY_RUN 标记确认"
      }));
      process.exit(2);
    }
  }
  
  // 规则3：保护敏感文件
  if (toolName === 'Write' || toolName === 'Edit') {
    const filePath = toolInput.file_path || '';
    const protected = ['.env', 'credentials', 'secret', 'private.key'];
    if (protected.some(p => filePath.toLowerCase().includes(p))) {
      console.log(JSON.stringify({
        decision: "block",
        reason: `禁止修改敏感文件: ${filePath}`
      }));
      process.exit(2);
    }
  }
  
  // 允许通过
  process.exit(0);
});
```

### 3.4 实战Hook：自动格式化与质量门禁

PostToolUse Hook在文件写入后自动执行格式化和lint：

```javascript
// ~/.claude/hooks/post-write-format.js
const { execSync } = require('child_process');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  
  if (data.tool_name === 'Write' || data.tool_name === 'Edit') {
    const filePath = data.tool_input.file_path || '';
    
    // 根据文件类型执行对应格式化
    try {
      if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
        execSync(`npx prettier --write "${filePath}" 2>/dev/null`, { timeout: 10000 });
        execSync(`npx eslint --fix "${filePath}" 2>/dev/null`, { timeout: 10000 });
      } else if (filePath.endsWith('.py')) {
        execSync(`black "${filePath}" 2>/dev/null`, { timeout: 10000 });
        execSync(`isort "${filePath}" 2>/dev/null`, { timeout: 10000 });
      } else if (filePath.endsWith('.go')) {
        execSync(`gofmt -w "${filePath}" 2>/dev/null`, { timeout: 10000 });
      }
      
      // 注入反馈信息（通过stdout返回）
      console.log(JSON.stringify({
        supplemented_output: `\n[自动格式化完成: ${filePath}]`
      }));
    } catch (e) {
      // 格式化失败不影响主流程
      console.error(`格式化警告: ${e.message}`);
    }
  }
  
  process.exit(0);
});
```

### 3.5 实战Hook：Stop事件触发后续自动化

Stop Hook是构建"自愈流水线"的关键——当Agent完成工作时，自动触发下一步：

```javascript
// ~/.claude/hooks/on-stop.js
const { execSync } = require('child_process');
const fs = require('fs');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  const sessionDir = process.cwd();
  
  // 保存会话结果摘要
  const summary = {
    timestamp: new Date().toISOString(),
    transcript_path: data.transcript_path,
    stop_reason: data.stop_reason,
    working_dir: sessionDir
  };
  
  fs.writeFileSync(
    '/tmp/claude-stop-event.json',
    JSON.stringify(summary, null, 2)
  );
  
  // 如果是Git仓库且有变更，自动运行测试
  try {
    const status = execSync('git status --porcelain', { encoding: 'utf-8' });
    if (status.trim().length > 0) {
      // 触发后续-p命令进行验证
      execSync(
        'claude -p "运行项目测试套件验证最近修改是否引入回归。如有失败，分析原因并修复。" ' +
        '--max-turns 8 --allowedTools "Read,Write,Bash,Grep" ' +
        '--output-format json >> /tmp/claude-auto-verify.log 2>&1 &',
        { detached: true, stdio: 'ignore' }
      );
    }
  } catch (e) {
    // 非Git仓库或无变更，跳过
  }
  
  process.exit(0);
});
```

## 四、批量任务编排实战

### 4.1 串行批处理：多仓库统一操作

```bash
#!/bin/bash
# batch-repo-upgrade.sh — 批量升级多个仓库的依赖
set -euo pipefail

REPOS=(
  "/home/dev/project-alpha"
  "/home/dev/project-beta"
  "/home/dev/project-gamma"
)

PROMPT="检查项目中的过期npm依赖，按安全优先级升级。
升级每个依赖后运行 npm test 验证。
如果测试失败，回滚该依赖并记录问题。"

RESULTS=()

for repo in "${REPOS[@]}"; do
  echo "=== 处理: $repo ==="
  
  cd "$repo"
  
  RESULT=$(claude -p "$PROMPT" \
    --allowedTools "Read,Write,Bash,Grep,Glob" \
    --max-turns 15 \
    --output-format json 2>/dev/null)
  
  # 记录结果
  echo "$RESULT" | jq -r '.result // "无输出"' > "/tmp/upgrade_$(basename $repo).txt"
  RESULTS+=("$repo: $(echo "$RESULT" | jq -r '.result // "失败"' | head -c 100)")
  
  echo "--- $repo 完成 ---"
done

echo "====== 汇总报告 ======"
printf '%s\n' "${RESULTS[@]}"
```

### 4.2 并行Worktree批处理：大规模重构

```bash
#!/bin/bash
# parallel-refactor.sh — 并行重构多个模块
set -euo pipefail

MODULES=("auth" "payment" "notification" "analytics" "user")
BASE_BRANCH="main"

# 为每个模块创建隔离的worktree
for module in "${MODULES[@]}"; do
  WORKTREE_PATH=".claude/worktrees/refactor-${module}"
  
  # 创建worktree和分支
  git worktree add "$WORKTREE_PATH" -b "refactor/${module}" HEAD 2>/dev/null || true
  
  # 在每个worktree中并行启动Claude Code
  (
    cd "$WORKTREE_PATH"
    claude -p "重构 ${module} 模块：
    1. 将所有any类型替换为具体类型
    2. 提取重复逻辑到共享工具函数
    3. 添加JSDoc注释
    4. 运行测试确保无回归" \
      --allowedTools "Read,Write,Bash,Grep,Glob" \
      --max-turns 12 \
      --output-format json > "/tmp/refactor_${module}.json" 2>&1
    
    echo "[完成] ${module} 模块重构"
  ) &
done

# 等待所有并行任务完成
wait

echo "====== 全部模块重构完成 ======"

# 汇总结果
for module in "${MODULES[@]}"; do
  RESULT_FILE="/tmp/refactor_${module}.json"
  if [ -f "$RESULT_FILE" ]; then
    STATUS=$(jq -r '.result // "未知"' "$RESULT_FILE" | head -c 200)
    echo "${module}: ${STATUS}"
  fi
done
```

### 4.3 使用/batch命令（Claude Code内置批处理）

Claude Code内置的`/batch`命令提供了声明式的并行执行能力：

```
# 在Claude Code交互会话中使用
/batch
```

`/batch`命令允许你描述多个独立任务，Claude Code会自动将它们分配到并行的工作树中执行。适合以下场景：

- 多文件统一模式修改（如重命名、接口变更）
- 多模块同类重构（如添加错误处理）
- 多服务配置同步更新

**核心优势**：Claude自动判断任务间的依赖关系，将独立任务并行化，有依赖的任务串行化，无需手动编排。

## 五、实战案例：自愈代码质量流水线

以下是一个完整的、可直接运行的自愈流水线——当代码提交后，自动检测问题并尝试修复：

### 5.1 项目结构

```
auto-heal-pipeline/
├── .claude/
│   └── settings.json          # Hooks配置
├── scripts/
│   ├── heal-pipeline.sh       # 主流水线脚本
│   ├── hooks/
│   │   ├── post-write-lint.js # PostToolUse: 自动lint
│   │   └── on-stop-report.js  # Stop: 生成报告
│   └── report/
│       └── template.html      # 报告模板
└── CLAUDE.md                   # 项目指令
```

### 5.2 Hooks配置

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/pre-bash-guard.js"
        }]
      },
      {
        "matcher": "Write",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/pre-write-guard.js"
        }]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/post-write-lint.js"
        }]
      },
      {
        "matcher": "Edit",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/post-write-lint.js"
        }]
      }
    ],
    "Stop": [
      {
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/on-stop-report.js"
        }]
      }
    ]
  }
}
```

### 5.3 主流水线脚本

```bash
#!/bin/bash
# heal-pipeline.sh — 自愈代码质量流水线
set -euo pipefail

PROJECT_DIR="${1:-.}"
MAX_HEAL_ROUNDS=3
LOG_DIR="/tmp/claude-heal-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$LOG_DIR"

echo "🔬 自愈流水线启动 — 目标: $PROJECT_DIR"

cd "$PROJECT_DIR"

# ── 阶段1: 检测 ──
echo "📋 阶段1: 问题检测..."
DETECTION=$(claude -p "执行全面的代码质量检测：
1. 运行 eslint 检查所有源文件，统计错误和警告数量
2. 运行 tsc --noEmit 检查类型错误
3. 运行测试套件，记录失败用例
4. 以JSON格式输出：{ lint_errors: number, type_errors: number, test_failures: string[] }" \
  --allowedTools "Read,Bash,Grep,Glob" \
  --max-turns 5 \
  --output-format json)

echo "$DETECTION" | jq '.' > "$LOG_DIR/detection.json"

LINT_ERRORS=$(echo "$DETECTION" | jq '.result.lint_errors // 0')
TYPE_ERRORS=$(echo "$DETECTION" | jq '.result.type_errors // 0')

echo "  检测结果: Lint错误=${LINT_ERRORS}, 类型错误=${TYPE_ERRORS}"

# ── 阶段2: 自愈循环 ──
ROUND=0
while [ $ROUND -lt $MAX_HEAL_ROUNDS ]; do
  ROUND=$((ROUND + 1))
  echo "🔧 阶段2.${ROUND}: 自愈修复（第${ROUND}轮）..."
  
  HEAL_RESULT=$(claude -p "根据之前的检测结果，修复所有可自动修复的问题。
规则：
- 每修复一类问题后立即运行对应验证命令
- 如果修复引入新问题，立即回滚
- 记录每个修复的详细说明
- 输出JSON：{ fixed: string[], remaining: string[], rolled_back: string[] }" \
    --continue \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash,Grep,Glob" \
    --output-format json)
  
  echo "$HEAL_RESULT" | jq '.' > "$LOG_DIR/heal_round_${ROUND}.json"
  
  FIXED=$(echo "$HEAL_RESULT" | jq '.result.fixed // [] | length')
  REMAINING=$(echo "$HEAL_RESULT" | jq '.result.remaining // [] | length')
  
  echo "  本轮修复: ${FIXED}个, 剩余: ${REMAINING}个"
  
  if [ "$REMAINING" -eq 0 ]; then
    echo "✅ 所有问题已修复!"
    break
  fi
done

# ── 阶段3: 最终验证 ──
echo "✅ 阶段3: 最终验证..."
VERIFY=$(claude -p "运行完整验证：eslint、tsc、全部测试。
输出JSON：{ passed: boolean, details: string }" \
  --continue \
  --max-turns 3 \
  --allowedTools "Read,Bash,Grep,Glob" \
  --output-format json)

PASSED=$(echo "$VERIFY" | jq -r '.result.passed // false')

echo "$VERIFY" | jq '.' > "$LOG_DIR/final_verify.json"

# ── 阶段4: 报告 ──
echo "📊 阶段4: 生成报告..."
cat <<EOF > "$LOG_DIR/report.md"
# 自愈流水线报告

**项目**: $(basename "$PROJECT_DIR")
**时间**: $(date '+%Y-%m-%d %H:%M:%S')
**修复轮次**: ${ROUND}

## 检测结果
- Lint错误: ${LINT_ERRORS}
- 类型错误: ${TYPE_ERRORS}

## 修复结果
$(cat "$LOG_DIR"/heal_round_*.json 2>/dev/null | jq -r '.result.fixed[]? // empty' | sed 's/^/- /')

## 最终状态
$( [ "$PASSED" = "true" ] && echo "✅ 全部通过" || echo "⚠️ 仍有未解决问题" )

## 详细日志
- 检测: $LOG_DIR/detection.json
$(for i in $(seq 1 $ROUND); do echo "- 第${i}轮修复: $LOG_DIR/heal_round_${i}.json"; done)
- 最终验证: $LOG_DIR/final_verify.json
EOF

echo "📄 报告已生成: $LOG_DIR/report.md"
echo "$LOG_DIR/report.md"
```

### 5.4 完整工作流程图

```mermaid
flowchart TB
    Start([流水线启动]) --> Detect[阶段1: 全面检测]

    Detect --> |claude -p --allowedTools Read,Bash| Analyze[ESLint + TSC + Tests]
    Analyze --> ParseResult[解析检测结果JSON]
    ParseResult --> CheckProblems{发现问题?}

    CheckProblems --> |无问题| FinalVerify[阶段3: 最终验证]
    CheckProblems --> |有问题| HealRound[阶段2: 自愈循环]

    HealRound --> |claude -p --continue| Fix[修复 + 逐项验证]
    Fix --> PostHook[PostToolUse Hook: 自动格式化]
    PostHook --> CheckRound{达到最大轮次?}

    CheckRound --> |否| HealRound
    CheckRound --> |是| FinalVerify

    FinalVerify --> |claude -p --continue| VerifyAll[运行全套检查]
    VerifyAll --> StopHook[Stop Hook: 生成报告]
    StopHook --> Report[输出汇总报告]

    Report --> Decision{全部通过?}
    Decision --> |是| Success([✅ 流水线成功])
    Decision --> |否| ManualReview([⚠️ 需人工审查])

    PreHook[PreToolUse Hook: 安全拦截] -.-> |阻止危险操作| Fix
    PreWrite[PreToolUse Hook: 文件保护] -.-> |保护敏感文件| Fix

    style Start fill:#4caf50,color:#fff
    style Success fill:#4caf50,color:#fff
    style ManualReview fill:#ff9800,color:#fff
    style PreHook fill:#f44336,color:#fff
    style PreWrite fill:#f44336,color:#fff
    style PostHook fill:#2196f3,color:#fff
    style StopHook fill:#9c27b0,color:#fff
```

## 六、高级模式：Hooks与-p的递归联动

### 6.1 事件级联模式

最强大的自动化模式是Hooks触发`-p`命令，而`-p`执行中又触发新的Hooks——形成事件级联：

```mermaid
graph LR
    A[Stop事件] -->|Hook脚本| B[触发 claude -p 验证]
    B -->|PostToolUse| C[自动格式化]
    C -->|发现新问题| D[触发 claude -p 修复]
    D -->|Stop事件| E[生成报告]
    E -->|发送通知| F[Slack/邮件]
```

实现要点：

```javascript
// on-stop-cascade.js — Stop事件触发级联
const { exec } = require('child_process');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  
  // 防止无限递归：检查环境变量标记
  if (process.env.CLAUDE_CASCADE_DEPTH > 2) {
    process.exit(0);
  }
  
  // 在后台启动验证Agent
  const env = { 
    ...process.env, 
    CLAUDE_CASCADE_DEPTH: String((parseInt(process.env.CLAUDE_CASCADE_DEPTH || '0') + 1))
  };
  
  exec(
    'claude -p "验证上一次修改的正确性" --max-turns 3 --output-format json',
    { env, timeout: 120000 },
    (err, stdout) => {
      if (!err && stdout) {
        // 可以继续触发通知等后续操作
        const result = JSON.parse(stdout);
        // 发送到外部系统...
      }
    }
  );
  
  process.exit(0);
});
```

### 6.2 条件路由模式

根据Agent输出结果自动决定下一步操作：

```bash
#!/bin/bash
# smart-router.sh — 智能路由脚本

# 第一步：分类
CLASSIFY=$(claude -p "分析当前Git仓库的变更，将它们分为三类：
- REFACTOR: 代码重构（需运行全量测试）
- STYLE: 样式/格式修改（只需lint）
- DOCS: 文档变更（无需测试）
输出JSON：{ category: string, confidence: number }" \
  --allowedTools "Read,Bash,Grep" \
  --max-turns 3 \
  --output-format json)

CATEGORY=$(echo "$CLASSIFY" | jq -r '.result.category // "unknown"')

echo "路由决策: $CATEGORY"

case "$CATEGORY" in
  "REFACTOR")
    echo "执行完整验证流水线..."
    claude -p "运行完整测试套件，包括单元测试、集成测试和E2E测试" \
      --continue --max-turns 10 --allowedTools "Read,Bash"
    ;;
  "STYLE")
    echo "执行轻量验证..."
    claude -p "运行ESLint和Prettier检查" \
      --continue --max-turns 3 --allowedTools "Read,Bash"
    ;;
  "DOCS")
    echo "跳过测试，仅检查链接..."
    claude -p "检查文档中的死链接" \
      --continue --max-turns 3 --allowedTools "Read,Bash,Grep"
    ;;
  *)
    echo "无法分类，执行默认验证..."
    claude -p "运行基本lint和类型检查" \
      --continue --max-turns 5 --allowedTools "Read,Bash"
    ;;
esac
```

### 6.3 定时巡检模式

结合cron实现定时自动化巡检：

```bash
#!/bin/bash
# nightly-patrol.sh — 每夜巡检脚本
# crontab: 0 2 * * * /path/to/nightly-patrol.sh /path/to/project

PROJECT="$1"
DATE=$(date +%Y%m%d)
LOG="/tmp/nightly-patrol-${DATE}.log"

cd "$PROJECT" || exit 1
git pull origin main 2>/dev/null

# 巡检任务列表
claude -p "执行每日代码健康巡检：

1. 检查依赖安全性: npm audit (只报告critical和high)
2. 检查过期依赖: npx npm-check-updates
3. 检查代码复杂度: 找到圈复杂度超过15的函数
4. 检查测试覆盖率: 运行覆盖率报告，标记低于80%的模块
5. 检查TODO/FIXME数量变化: 与上周对比

输出结构化JSON报告。" \
  --allowedTools "Read,Bash,Grep,Glob" \
  --max-turns 8 \
  --output-format json > "$LOG" 2>&1

# 如果有Critical安全问题，发送告警
CRITICAL=$(jq -r '.result.critical_vulnerabilities // 0' "$LOG")
if [ "$CRITICAL" -gt 0 ]; then
  # 发送Slack通知（使用webhook）
  curl -s -X POST "$SLACK_WEBHOOK" \
    -H 'Content-type: application/json' \
    --data "{\"text\":\"🚨 巡检告警: ${CRITICAL}个Critical安全漏洞 - ${PROJECT}\"}" \
    > /dev/null
fi
```

## 七、安全与最佳实践

### 7.1 自动化安全清单

```mermaid
graph TD
    A[自动化安全] --> B[权限最小化]
    A --> C[递归防护]
    A --> D[输出验证]
    A --> E[审计追踪]

    B --> B1["--allowedTools 限定必需工具"]
    B --> B2["--max-turns 限制Agent轮次"]
    B --> B3["--system-prompt 约束行为边界"]

    C --> C1["环境变量标记递归深度"]
    C --> C2["全局超时机制"]
    C --> C3["退出码检测死循环"]

    D --> D1["jq校验JSON输出结构"]
    D --> D2["敏感信息脱敏"]
    D --> D3["错误边界处理"]

    E --> E1["记录所有-p调用日志"]
    E --> E2["Hook执行日志持久化"]
    E --> E3["Git diff审计每次修改"]
```

### 7.2 关键安全原则

**1. 最小权限原则**

```bash
# 错误：给予所有权限
claude -p "修复bug" --dangerously-skip-permissions

# 正确：精确指定所需工具
claude -p "修复bug" \
  --allowedTools "Read,Write,Grep,Bash" \
  --disallowedTools "NotebookEdit" \
  --max-turns 5
```

**2. 防止无限循环**

```bash
# 在Hook脚本中设置深度限制
MAX_DEPTH=${CLAUDE_CASCADE_DEPTH:-0}
if [ "$MAX_DEPTH" -ge 3 ]; then
  echo "级联深度超限，终止"
  exit 0
fi
export CLAUDE_CASCADE_DEPTH=$((MAX_DEPTH + 1))
```

**3. 沙箱执行**

```bash
# 使用Docker容器隔离自动化执行
docker run --rm \
  -v "$(pwd):/workspace" \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  claude-code-auto \
  claude -p "修复所有lint错误" \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash,Grep"
```

### 7.3 调试技巧

```bash
# 开启verbose输出查看完整决策过程
claude -p "分析代码" --verbose --output-format stream-json

# 使用--verbose配合stream-json实时观察Agent思考过程
claude -p "重构模块" --verbose --output-format stream-json 2>&1 | \
  jq -c 'select(.type == "assistant") | .message.content'

# 查看会话历史
claude sessions list

# 查看特定会话的详细日志
claude sessions show <session-id>
```

## 八、训练营适用性评估

| 维度 | 评估 |
|------|------|
| **适合训练营类型** | DevOps自动化训练营、AI辅助开发进阶营、生产级AI Agent构建营 |
| **前置知识要求** | Claude Code基础操作、Shell脚本、Git工作流、Node.js基础 |
| **预计教学时长** | 4-6小时（含实操） |
| **实操占比** | 70%实操 + 30%理论 |
| **分组建议** | 2-3人一组，每组一个真实项目 |
| **考核方式** | 完成一个可运行的自愈流水线，包含检测→修复→验证→报告四个阶段 |
| **常见卡点** | Hooks JSON输入格式解析、递归防护、会话ID传递 |
| **延伸方向** | GitHub Actions集成、Slack/钉钉通知、监控面板 |

## 参考来源

1. [Run Claude Code programmatically - Claude Code Docs](https://code.claude.com/docs/en/headless) — 官方Headless模式文档，-p标志与输出格式完整参考
2. [Hooks reference - Claude Code Docs](https://code.claude.com/docs/en/hooks) — 官方Hooks事件参考，含JSON输入输出Schema和退出码语义
3. [Manage sessions - Claude Code Docs](https://code.claude.com/docs/en/sessions) — 官方会话管理文档，--continue与--resume用法
4. [Using Claude Code Programmatically - GitHub Gist](https://gist.github.com/JacobFV/2c4a75bc6a835d2c1f6c863cfcbdfa5a) — 社区整理的-p模式完整编程指南
5. [Run parallel sessions with worktrees - Claude Code Docs](https://code.claude.com/docs/en/worktrees) — 官方Worktree并行会话文档

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)