脚本工具

Claude Code 提供了一系列实用脚本，用于系统配置、环境设置和维护管理。

📜 脚本概览

脚本	功能	用途	频率
setup-mcp.sh	MCP 服务配置	初始化和配置 MCP 服务器	一次性/更新时
setup-dev-mcp.sh	开发环境配置	配置开发模式的 MCP 服务	开发阶段
backup-config.sh	配置备份	备份和恢复系统配置	定期/变更前

setup-mcp.sh

功能说明

MCP 服务设置脚本，用于安装和配置 Model Context Protocol 服务器。

bash

#!/bin/bash
# MCP 服务器设置脚本

# 检查依赖
check_dependencies() {
    echo "检查系统依赖..."
    
    # 检查 Node.js
    if ! command -v node &> /dev/null; then
        echo " Node.js 未安装，请先安装 Node.js 16+"
        exit 1
    fi
    
    # 检查 Python
    if ! command -v python3 &> /dev/null; then
        echo " Python3 未安装，请先安装 Python 3.8+"
        exit 1
    fi
    
    echo " 依赖检查通过"
}

# 安装 MCP 服务器
install_mcp_servers() {
    echo "安装 MCP 服务器..."
    
    # Context7 服务器
    if [ ! -d "$HOME/.mcp/context7" ]; then
        echo "安装 Context7 服务器..."
        mkdir -p $HOME/.mcp/context7
        npm install -g @context7/mcp-server
        echo " Context7 服务器安装完成"
    fi
    
    # Sequential 服务器
    if [ ! -d "$HOME/.mcp/sequential" ]; then
        echo "安装 Sequential 服务器..."
        mkdir -p $HOME/.mcp/sequential
        pip3 install sequential-mcp-server
        echo " Sequential 服务器安装完成"
    fi
    
    # Magic 服务器
    if [ ! -d "$HOME/.mcp/magic" ]; then
        echo "安装 Magic 服务器..."
        mkdir -p $HOME/.mcp/magic
        git clone https://github.com/magic-tools/mcp-server.git $HOME/.mcp/magic
        cd $HOME/.mcp/magic && npm install
        echo " Magic 服务器安装完成"
    fi
    
    # Playwright 服务器
    if [ ! -d "$HOME/.mcp/playwright" ]; then
        echo "安装 Playwright 服务器..."
        mkdir -p $HOME/.mcp/playwright
        npm install -g @playwright/mcp-server
        npx playwright install
        echo " Playwright 服务器安装完成"
    fi
}

# 配置服务器
configure_mcp_servers() {
    echo "配置 MCP 服务器..."
    
    # 创建配置目录
    mkdir -p $HOME/.claude/mcp
    
    # Context7 配置
    cat > $HOME/.claude/mcp/context7.json << EOF
{
  "server": {
    "command": "context7-mcp-server",
    "args": ["--port", "3001"],
    "env": {
      "CONTEXT7_API_KEY": "\${CONTEXT7_API_KEY}",
      "CONTEXT7_CACHE_DIR": "\$HOME/.cache/context7"
    }
  },
  "settings": {
    "auto_activate": true,
    "cache_duration": 3600,
    "max_concurrent": 5
  }
}
EOF
    
    # Sequential 配置
    cat > $HOME/.claude/mcp/sequential.json << EOF
{
  "server": {
    "command": "python3",
    "args": ["-m", "sequential_mcp_server", "--port", "3002"],
    "env": {
      "SEQUENTIAL_LOG_LEVEL": "INFO",
      "SEQUENTIAL_MAX_DEPTH": "5"
    }
  },
  "settings": {
    "complexity_threshold": 0.7,
    "thinking_timeout": 120,
    "max_analysis_depth": 5
  }
}
EOF
    
    # Magic 配置
    cat > $HOME/.claude/mcp/magic.json << EOF
{
  "server": {
    "command": "node",
    "args": ["\$HOME/.mcp/magic/server.js", "--port", "3003"],
    "env": {
      "MAGIC_TOOLS_PATH": "\$HOME/.mcp/magic/tools",
      "MAGIC_LOG_LEVEL": "INFO"
    }
  },
  "settings": {
    "enabled": false,
    "require_confirmation": true,
    "allowed_tools": ["git", "npm", "docker", "kubectl"]
  }
}
EOF
    
    # Playwright 配置
    cat > $HOME/.claude/mcp/playwright.json << EOF
{
  "server": {
    "command": "playwright-mcp-server",
    "args": ["--port", "3004"],
    "env": {
      "PLAYWRIGHT_BROWSERS_PATH": "\$HOME/.cache/ms-playwright",
      "PLAYWRIGHT_HEADLESS": "true"
    }
  },
  "settings": {
    "headless": true,
    "browsers": ["chromium", "firefox", "webkit"],
    "timeout": 30000,
    "viewport": {"width": 1280, "height": 720}
  }
}
EOF
    
    echo " MCP 服务器配置完成"
}

# 启动服务器
start_mcp_servers() {
    echo "启动 MCP 服务器..."
    
    # 创建服务管理脚本
    cat > $HOME/.claude/mcp/start-servers.sh << 'EOF'
#!/bin/bash

# 启动 Context7
echo "启动 Context7 服务器..."
nohup context7-mcp-server --port 3001 > /tmp/context7-mcp.log 2>&1 &
echo $! > /tmp/context7-mcp.pid

# 启动 Sequential
echo "启动 Sequential 服务器..."
nohup python3 -m sequential_mcp_server --port 3002 > /tmp/sequential-mcp.log 2>&1 &
echo $! > /tmp/sequential-mcp.pid

# 启动 Playwright
echo "启动 Playwright 服务器..."
nohup playwright-mcp-server --port 3004 > /tmp/playwright-mcp.log 2>&1 &
echo $! > /tmp/playwright-mcp.pid

echo " MCP 服务器启动完成"
echo "Context7: http://localhost:3001"
echo "Sequential: http://localhost:3002" 
echo "Playwright: http://localhost:3004"
EOF
    
    chmod +x $HOME/.claude/mcp/start-servers.sh
    
    # 创建停止脚本
    cat > $HOME/.claude/mcp/stop-servers.sh << 'EOF'
#!/bin/bash

echo "停止 MCP 服务器..."

# 停止所有服务
for service in context7 sequential playwright; do
    if [ -f "/tmp/${service}-mcp.pid" ]; then
        pid=$(cat /tmp/${service}-mcp.pid)
        if kill -0 $pid 2>/dev/null; then
            kill $pid
            echo " ${service} 服务器已停止"
        fi
        rm -f /tmp/${service}-mcp.pid
    fi
done

echo " 所有 MCP 服务器已停止"
EOF
    
    chmod +x $HOME/.claude/mcp/stop-servers.sh
    
    # 启动服务器
    $HOME/.claude/mcp/start-servers.sh
}

# 验证安装
verify_installation() {
    echo "验证 MCP 服务器安装..."
    
    sleep 5  # 等待服务器启动
    
    # 检查服务器状态
    for port in 3001 3002 3004; do
        if curl -s "http://localhost:$port/health" > /dev/null; then
            echo " 端口 $port 服务器运行正常"
        else
            echo "  端口 $port 服务器可能未正常启动"
        fi
    done
    
    echo " MCP 服务器验证完成"
}

# 主函数
main() {
    echo " Claude Code MCP 服务器设置"
    echo "==============================="
    
    check_dependencies
    install_mcp_servers
    configure_mcp_servers
    start_mcp_servers
    verify_installation
    
    echo ""
    echo " MCP 服务器设置完成！"
    echo ""
    echo "管理命令："
    echo "  启动服务: ~/.claude/mcp/start-servers.sh"
    echo "  停止服务: ~/.claude/mcp/stop-servers.sh"
    echo "  查看日志: tail -f /tmp/*-mcp.log"
    echo ""
    echo "服务地址："
    echo "  Context7:  http://localhost:3001"
    echo "  Sequential: http://localhost:3002"
    echo "  Playwright: http://localhost:3004"
}

# 执行主函数
main "$@"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

使用方法

bash

# 运行安装脚本
chmod +x setup-mcp.sh
./setup-mcp.sh

# 验证安装
claude --mcp-status

# 测试服务
claude --mcp=context7 "测试 Context7 服务"

setup-dev-mcp.sh

功能说明

开发环境专用的 MCP 配置脚本，提供开发者友好的配置选项。

bash

#!/bin/bash
# 开发环境 MCP 设置脚本

setup_dev_environment() {
    echo "设置开发环境..."
    
    # 创建开发配置
    mkdir -p $HOME/.claude/mcp/dev
    
    # 开发模式 Context7 配置
    cat > $HOME/.claude/mcp/dev/context7.json << EOF
{
  "server": {
    "command": "node",
    "args": ["\$HOME/dev/context7-mcp/server.js", "--dev", "--port", "3101"],
    "env": {
      "NODE_ENV": "development",
      "DEBUG": "context7:*",
      "CONTEXT7_DEV_MODE": "true"
    }
  },
  "settings": {
    "auto_activate": true,
    "cache_duration": 300,
    "reload_on_change": true,
    "debug_logging": true
  }
}
EOF
    
    # 开发模式 Sequential 配置
    cat > $HOME/.claude/mcp/dev/sequential.json << EOF
{
  "server": {
    "command": "python3",
    "args": ["-m", "sequential_mcp_server", "--dev", "--port", "3102"],
    "env": {
      "PYTHONPATH": "\$HOME/dev/sequential-mcp",
      "SEQUENTIAL_LOG_LEVEL": "DEBUG",
      "SEQUENTIAL_DEV_MODE": "true"
    }
  },
  "settings": {
    "complexity_threshold": 0.5,
    "thinking_timeout": 60,
    "debug_mode": true,
    "reload_on_change": true
  }
}
EOF
    
    echo " 开发环境配置完成"
}

setup_hot_reload() {
    echo "设置热重载..."
    
    # 创建文件监视脚本
    cat > $HOME/.claude/mcp/dev/watch-and-reload.sh << 'EOF'
#!/bin/bash

# 监视 MCP 服务器代码变更并自动重载
fswatch -o $HOME/dev/context7-mcp/ | while read event; do
    echo "检测到 Context7 代码变更，重启服务器..."
    $HOME/.claude/mcp/stop-servers.sh
    sleep 2
    $HOME/.claude/mcp/start-servers.sh
done &

fswatch -o $HOME/dev/sequential-mcp/ | while read event; do
    echo "检测到 Sequential 代码变更，重启服务器..."
    $HOME/.claude/mcp/stop-servers.sh
    sleep 2
    $HOME/.claude/mcp/start-servers.sh
done &

echo " 热重载监视已启动"
EOF
    
    chmod +x $HOME/.claude/mcp/dev/watch-and-reload.sh
    
    echo " 热重载设置完成"
}

setup_dev_tools() {
    echo "安装开发工具..."
    
    # 安装调试工具
    npm install -g @mcp/debug-tools
    pip3 install mcp-dev-utils
    
    # 创建调试脚本
    cat > $HOME/.claude/mcp/dev/debug-mcp.sh << 'EOF'
#!/bin/bash

echo "MCP 服务器调试工具"
echo "=================="

# 显示服务器状态
echo "服务器状态："
for port in 3101 3102; do
    if curl -s "http://localhost:$port/health" > /dev/null; then
        echo "   端口 $port: 运行中"
    else
        echo "   端口 $port: 停止"
    fi
done

echo ""

# 显示日志摘要
echo "最近日志："
tail -n 10 /tmp/context7-mcp.log | sed 's/^/  Context7: /'
tail -n 10 /tmp/sequential-mcp.log | sed 's/^/  Sequential: /'

echo ""

# 性能统计
echo "性能统计："
echo "  Context7 响应时间: $(curl -w "%{time_total}" -s -o /dev/null http://localhost:3101/ping)s"
echo "  Sequential 响应时间: $(curl -w "%{time_total}" -s -o /dev/null http://localhost:3102/ping)s"
EOF
    
    chmod +x $HOME/.claude/mcp/dev/debug-mcp.sh
    
    echo " 开发工具安装完成"
}

main() {
    echo "  Claude Code MCP 开发环境设置"
    echo "================================="
    
    setup_dev_environment
    setup_hot_reload
    setup_dev_tools
    
    echo ""
    echo " 开发环境设置完成！"
    echo ""
    echo "开发工具："
    echo "  调试信息: ~/.claude/mcp/dev/debug-mcp.sh"
    echo "  热重载: ~/.claude/mcp/dev/watch-and-reload.sh"
    echo "  配置目录: ~/.claude/mcp/dev/"
    echo ""
    echo "开发端口："
    echo "  Context7:  http://localhost:3101"
    echo "  Sequential: http://localhost:3102"
}

main "$@"

backup-config.sh

功能说明

配置备份和恢复脚本，确保系统配置的安全性。

bash

#!/bin/bash
# 配置备份脚本

BACKUP_DIR="$HOME/.claude/backups"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_NAME="claude_config_$TIMESTAMP"

create_backup() {
    echo "创建配置备份..."
    
    # 创建备份目录
    mkdir -p "$BACKUP_DIR/$BACKUP_NAME"
    
    # 备份主配置文件
    if [ -f "$HOME/.claude/settings.json" ]; then
        cp "$HOME/.claude/settings.json" "$BACKUP_DIR/$BACKUP_NAME/"
        echo " 备份 settings.json"
    fi
    
    if [ -f "$HOME/.claude/settings.local.json" ]; then
        cp "$HOME/.claude/settings.local.json" "$BACKUP_DIR/$BACKUP_NAME/"
        echo " 备份 settings.local.json"
    fi
    
    # 备份 MCP 配置
    if [ -d "$HOME/.claude/mcp" ]; then
        cp -r "$HOME/.claude/mcp" "$BACKUP_DIR/$BACKUP_NAME/"
        echo " 备份 MCP 配置"
    fi
    
    # 备份代理配置
    if [ -d "$HOME/.claude/agents" ]; then
        cp -r "$HOME/.claude/agents" "$BACKUP_DIR/$BACKUP_NAME/"
        echo " 备份 agents 配置"
    fi
    
    # 备份项目导向文件
    if [ -d "$HOME/.claude/.ai-rules" ]; then
        cp -r "$HOME/.claude/.ai-rules" "$BACKUP_DIR/$BACKUP_NAME/"
        echo " 备份 .ai-rules"
    fi
    
    # 创建备份清单
    cat > "$BACKUP_DIR/$BACKUP_NAME/manifest.txt" << EOF
Claude Code 配置备份
==================
备份时间: $(date)
备份内容:
- settings.json
- settings.local.json  
- mcp/ (MCP 服务配置)
- agents/ (代理配置)
- .ai-rules/ (项目导向文件)

系统信息:
- OS: $(uname -s)
- 用户: $(whoami)
- Claude Code 版本: $(claude --version 2>/dev/null || echo "未知")
EOF
    
    # 压缩备份
    cd "$BACKUP_DIR"
    tar -czf "${BACKUP_NAME}.tar.gz" "$BACKUP_NAME"
    rm -rf "$BACKUP_NAME"
    
    echo " 配置备份完成: $BACKUP_DIR/${BACKUP_NAME}.tar.gz"
}

restore_backup() {
    local backup_file="$1"
    
    if [ -z "$backup_file" ]; then
        echo "可用的备份文件："
        ls -la "$BACKUP_DIR"/*.tar.gz 2>/dev/null || echo "没有找到备份文件"
        return 1
    fi
    
    if [ ! -f "$backup_file" ]; then
        echo " 备份文件不存在: $backup_file"
        return 1
    fi
    
    echo "恢复配置备份: $backup_file"
    
    # 创建当前配置的备份
    echo "创建当前配置的安全备份..."
    create_backup
    
    # 解压备份文件
    cd "$BACKUP_DIR"
    tar -xzf "$(basename "$backup_file")"
    local extract_dir=$(basename "$backup_file" .tar.gz)
    
    # 恢复配置文件
    if [ -f "$extract_dir/settings.json" ]; then
        cp "$extract_dir/settings.json" "$HOME/.claude/"
        echo " 恢复 settings.json"
    fi
    
    if [ -f "$extract_dir/settings.local.json" ]; then
        cp "$extract_dir/settings.local.json" "$HOME/.claude/"
        echo " 恢复 settings.local.json"
    fi
    
    if [ -d "$extract_dir/mcp" ]; then
        rm -rf "$HOME/.claude/mcp"
        cp -r "$extract_dir/mcp" "$HOME/.claude/"
        echo " 恢复 MCP 配置"
    fi
    
    if [ -d "$extract_dir/agents" ]; then
        rm -rf "$HOME/.claude/agents"
        cp -r "$extract_dir/agents" "$HOME/.claude/"
        echo " 恢复 agents 配置"
    fi
    
    if [ -d "$extract_dir/.ai-rules" ]; then
        rm -rf "$HOME/.claude/.ai-rules"
        cp -r "$extract_dir/.ai-rules" "$HOME/.claude/"
        echo " 恢复 .ai-rules"
    fi
    
    # 清理
    rm -rf "$extract_dir"
    
    echo " 配置恢复完成"
    echo "  请重启 Claude Code 以使配置生效"
}

cleanup_old_backups() {
    echo "清理旧备份..."
    
    # 保留最近30天的备份
    find "$BACKUP_DIR" -name "claude_config_*.tar.gz" -mtime +30 -delete
    
    echo " 旧备份清理完成"
}

list_backups() {
    echo "可用的配置备份："
    echo "=================="
    
    if [ -d "$BACKUP_DIR" ]; then
        ls -la "$BACKUP_DIR"/*.tar.gz 2>/dev/null | while read -r line; do
            filename=$(echo "$line" | awk '{print $9}')
            size=$(echo "$line" | awk '{print $5}')
            date=$(echo "$line" | awk '{print $6, $7, $8}')
            echo "  $(basename "$filename") ($size bytes, $date)"
        done
    else
        echo "  没有找到备份文件"
    fi
}

main() {
    case "${1:-backup}" in
        "backup")
            create_backup
            ;;
        "restore")
            restore_backup "$2"
            ;;
        "list")
            list_backups
            ;;
        "cleanup")
            cleanup_old_backups
            ;;
        *)
            echo "Claude Code 配置备份工具"
            echo "======================="
            echo ""
            echo "用法: $0 [command] [options]"
            echo ""
            echo "命令:"
            echo "  backup          创建配置备份 (默认)"
            echo "  restore <file>  恢复指定备份"
            echo "  list           列出所有备份"
            echo "  cleanup        清理旧备份"
            echo ""
            echo "示例:"
            echo "  $0 backup"
            echo "  $0 restore ~/.claude/backups/claude_config_20240101_120000.tar.gz"
            echo "  $0 list"
            ;;
    esac
}

main "$@"

使用最佳实践

1. 定期备份

bash

# 设置定时备份 (crontab)
0 2 * * * $HOME/.claude/scripts/backup-config.sh backup

# 手动备份
./backup-config.sh backup

2. 开发环境管理

bash

# 切换到开发模式
./setup-dev-mcp.sh

# 启动热重载
~/.claude/mcp/dev/watch-and-reload.sh

# 调试服务状态
~/.claude/mcp/dev/debug-mcp.sh

3. 生产环境部署

bash

# 标准 MCP 安装
./setup-mcp.sh

# 验证服务状态
claude --mcp-status

# 服务管理
~/.claude/mcp/start-servers.sh
~/.claude/mcp/stop-servers.sh

4. 故障恢复

bash

# 列出备份
./backup-config.sh list

# 恢复配置
./backup-config.sh restore backup_file.tar.gz

# 重新初始化 MCP
./setup-mcp.sh

脚本工具 ​

📜 脚本概览 ​

setup-mcp.sh ​

功能说明 ​

使用方法 ​

setup-dev-mcp.sh ​

功能说明 ​

backup-config.sh ​

功能说明 ​

使用最佳实践 ​

1. 定期备份 ​

2. 开发环境管理 ​

3. 生产环境部署 ​

4. 故障恢复 ​

相关资源 ​

脚本工具

📜 脚本概览

setup-mcp.sh

功能说明

使用方法

setup-dev-mcp.sh

功能说明

backup-config.sh

功能说明

使用最佳实践

1. 定期备份

2. 开发环境管理

3. 生产环境部署

4. 故障恢复

相关资源