Remote Execute Claude
使用 Claude Code 调试远程边缘设备（不具备claude code使用条件）的完整工具集，用于提高在边缘设备上问题分析和调试效率。本地编辑，远程运行，让 AI 辅助开发边缘设备、嵌入式系统和远程服务器。
📂 工具目录结构
/Users/admin/bin/remote_execute_claude/ # 工具安装目录
├── quickstart.sh # 一键安装向导（推荐）
├── setup_environment.sh # 安装依赖工具
├── setup_ssh.sh # 配置 SSH 连接和远程设备
├── create_project.sh # 创建项目并生成配置
├── remote_toolkit.sh # 主工具脚本（模板）
├── templates/ # 模板文件
│ └── CLAUDE.md.template # Claude Code 上下文模板
└── devices/ # 设备配置（自动生成）
└── *.conf # 远程设备连接信息使用流程：
- 在工具目录运行安装脚本（
quickstart.sh或分步安装） - 配置远程设备连接（
setup_ssh.sh） - 创建项目（
create_project.sh）→ 工具会复制到项目目录 - 在项目目录使用
./remote_toolkit.sh命令
📋 目录
📋 功能特性
✅ 无缝同步 - 自动同步本地和远程文件，只传输变更部分
✅ 远程执行 - 在远程设备上执行命令并查看结果
✅ 实时监控 - 监控文件变化并自动同步（watch 模式）
✅ 日志查看 - 实时查看远程设备日志文件
✅ Claude Code 集成 - 完美配合 Claude Code 使用
✅ 跨平台 - 支持 macOS 和 Linux
✅ 安全连接 - 使用 SSH 密钥认证
✅ 智能过滤 - 自动排除不需要同步的文件
🚀 快速开始
一键安装（推荐）
bash
cd /Users/admin/bin/remote_execute_claude
./quickstart.sh快速向导会自动完成：环境安装 → SSH 配置 → 项目创建。
手动安装（三步）
bash
# 1. 安装依赖工具（rsync, jq, fswatch/inotify-tools）
./setup_environment.sh
# 2. 配置 SSH 密钥和远程设备连接
./setup_ssh.sh
# 输入：设备昵称、IP、用户名、端口
# 3. 创建项目
./create_project.sh
# 选择设备，设置本地和远程路径开始使用
bash
# 终端 1 - 启动自动同步
cd ~/my-project
./remote_toolkit.sh watch
# 终端 2 - 启动 Claude Code
cd ~/my-project
claude🔧 配置远程设备
什么是远程设备？
远程设备是指需要远程连接的目标机器，例如：
- 🍓 树莓派（Raspberry Pi）
- 🤖 边缘计算设备（Jetson Nano 等）
- 📟 嵌入式系统（工控机、开发板）
- 🖥️ 远程服务器（Linux 服务器）
配置步骤详解
方式一：使用 quickstart.sh（推荐）
运行快速向导时会自动引导你完成设备配置：
bash
cd /Users/admin/bin/remote_execute_claude
./quickstart.sh向导会询问：
- 设备昵称 ：给设备起个名字，如
raspberry-pi、edge-device-1 - 设备 IP ：远程设备的 IP 地址，如
192.168.1.100 - 用户名 ：SSH 登录用户，如
pi、ubuntu、root - SSH 端口 ：默认
22，自定义端口需要修改
方式二：单独配置设备
bash
cd /Users/admin/bin/remote_execute_claude
./setup_ssh.sh脚本会自动完成：
- ✅ 生成 SSH 密钥对（如果不存在）
- ✅ 将公钥复制到远程设备（免密登录）
- ✅ 配置
~/.ssh/config文件 - ✅ 启用连接复用（提升同步速度）
- ✅ 测试连接是否成功
- ✅ 保存设备配置到
devices/设备名.conf
配置多个设备
可以配置多个远程设备，在不同项目中使用：
bash
# 配置第一个设备
./setup_ssh.sh
# 输入：rpi-1, 192.168.1.100, pi
# 配置第二个设备
./setup_ssh.sh
# 输入：rpi-2, 192.168.1.101, pi
# 配置生产服务器
./setup_ssh.sh
# 输入：prod-server, 10.0.0.50, ubuntu配置完成后，设备信息保存在 devices/ 目录。
验证配置
bash
# 测试 SSH 连接（使用配置的昵称）
ssh raspberry-pi
# 如果能免密登录成功，说明配置正确🚀 在项目中使用
创建项目并关联设备
配置好远程设备后，需要为每个项目创建配置：
bash
cd /Users/admin/bin/remote_execute_claude
./create_project.sh向导会询问：
-
选择远程设备
已配置的设备： 1) raspberry-pi (192.168.1.100) 2) edge-device-1 (192.168.1.101) 选择: 1 -
本地项目目录
本地项目目录: ~/my-iot-project- 可以输入已存在的目录
- 或输入新目录名（会自动创建）
-
远程项目路径
远程项目路径: /home/pi/my-iot-project- 远程设备上的目标目录
- 脚本会自动在远程创建此目录
-
自定义排除项（可选）
额外排除的文件: *.tmp *.bak
项目创建后的目录结构
~/my-iot-project/ # 你的项目目录
├── .remote-config.json # 远程配置文件
├── remote_toolkit.sh # 工具脚本（从工具目录复制）
├── CLAUDE.md # Claude Code 上下文
├── README.md # 项目说明
├── .gitignore # Git 忽略规则
└── [你的代码文件] # 开始编写代码在项目目录中使用工具
进入项目目录后，所有操作都通过 ./remote_toolkit.sh 完成：
bash
cd ~/my-iot-project
# 查看设备连接状态
./remote_toolkit.sh status
# 启动自动同步（推荐在开发时保持运行）
./remote_toolkit.sh watch
# 手动同步文件
./remote_toolkit.sh sync-to
# 远程执行代码
./remote_toolkit.sh exec "python main.py"
# 查看远程日志
./remote_toolkit.sh logs "app.log"
# 读取远程文件
./remote_toolkit.sh read "config.yaml"
# 进入远程终端
./remote_toolkit.sh shell切换项目使用不同设备
每个项目都有独立的 .remote-config.json，可以连接不同的远程设备：
bash
# 项目 A 使用树莓派
cd ~/project-a
cat .remote-config.json
# "host": "raspberry-pi"
# 项目 B 使用边缘设备
cd ~/project-b
cat .remote-config.json
# "host": "edge-device-1"🎯 核心命令
remote_toolkit.sh 命令速查
| 命令 | 说明 | 示例 |
|---|---|---|
status |
查看远程设备连接状态 | ./remote_toolkit.sh status |
sync-to |
手动同步本地 → 远程 | ./remote_toolkit.sh sync-to |
sync-from |
同步远程 → 本地（自动备份） | ./remote_toolkit.sh sync-from |
watch |
⭐ 自动监控并实时同步 | ./remote_toolkit.sh watch |
exec "命令" |
⭐ 在远程执行命令 | ./remote_toolkit.sh exec "python main.py" |
read "文件" |
读取远程文件内容 | ./remote_toolkit.sh read "config.yaml" |
logs "文件" |
实时查看远程日志 | ./remote_toolkit.sh logs "app.log" |
shell |
打开远程交互式终端 | ./remote_toolkit.sh shell |
常用命令示例
bash
# 开发时：启动自动同步（推荐持续运行）
./remote_toolkit.sh watch
# 在远程执行代码
./remote_toolkit.sh exec "python main.py"
./remote_toolkit.sh exec "npm test"
./remote_toolkit.sh exec "pytest tests/ -v"
# 安装依赖
./remote_toolkit.sh exec "pip install -r requirements.txt"
./remote_toolkit.sh exec "npm install"
# 查看日志和文件
./remote_toolkit.sh logs "app.log"
./remote_toolkit.sh read "config.yaml"
# 获取远程生成的数据
./remote_toolkit.sh sync-from
# 检查连接状态
./remote_toolkit.sh status💼 典型工作流
场景 1：AI 辅助开发（推荐）
bash
# 终端 1：启动自动同步
cd ~/my-project
./remote_toolkit.sh watch
# 终端 2：启动 Claude Code
claude
# 告诉 Claude 你的需求，它会：
# 1. 编辑代码（自动同步到远程）
# 2. 调用 ./remote_toolkit.sh exec 执行测试
# 3. 查看日志分析问题
# 4. 根据结果继续优化场景 2：开发 Python 应用
bash
# 安装依赖
./remote_toolkit.sh exec "pip install -r requirements.txt"
# 运行程序
./remote_toolkit.sh exec "python main.py"
# 运行测试
./remote_toolkit.sh exec "pytest tests/ -v"
# 实时查看日志
./remote_toolkit.sh logs "app.log"场景 3：调试错误
bash
# 查看错误日志
./remote_toolkit.sh read "logs/error.log"
# 或实时监控
./remote_toolkit.sh logs "logs/error.log"
# 修改代码后重新运行
./remote_toolkit.sh exec "python main.py --debug"场景 4：获取远程数据
bash
# 运行数据处理
./remote_toolkit.sh exec "python process_data.py"
# 拉取到本地（自动备份）
./remote_toolkit.sh sync-from🤖 Claude Code 集成
为什么要配合 Claude Code？
本工具专为 Claude Code 设计，让 AI 能够：
- ✅ 在本地编辑代码
- ✅ 自动同步到远程设备
- ✅ 远程执行并查看结果
- ✅ 根据反馈迭代优化
使用方式
bash
# 1. 启动自动同步（终端 1）
./remote_toolkit.sh watch
# 2. 启动 Claude（终端 2）
claude无需手动说明项目背景！CLAUDE.md 会自动生成，Claude 会自动理解：
- 本地只用于编辑
- 远程用于执行
- 如何调用 remote_toolkit.sh
示例对话
你说：
实现一个 HTTP 服务器，监听 8080 端口，提供 /api/status 接口Claude 会自动：
- 创建/编辑代码文件（自动同步到远程）
- 调用
./remote_toolkit.sh exec "python server.py"测试 - 查看日志分析问题
- 迭代优化直到正常运行
你说：
程序报错了，帮我修复Claude 会自动：
- 调用
./remote_toolkit.sh read "logs/error.log"查看错误 - 分析问题并修改代码
- 重新测试验证修复
⚙️ 配置文件详解
1. 项目配置文件：.remote-config.json
位置 ：项目根目录（如 ~/my-project/.remote-config.json）
作用 ：定义项目与远程设备的连接信息和同步规则
生成 ：运行 create_project.sh 时自动创建
配置示例
json
{
"host": "raspberry-pi", // 远程设备昵称
"user": "pi", // SSH 登录用户
"port": 22, // SSH 端口
"project_path": "/home/pi/my-project", // 远程项目路径
"exclude": [ // 不同步的文件
"node_modules", "__pycache__", ".git", "venv",
"*.pyc", "*.log", ".DS_Store",
"CLAUDE.md", "README.md", "remote_toolkit.sh",
".remote-config.json", ".backup"
]
}字段详解
| 字段 | 说明 | 如何填写 |
|---|---|---|
host |
远程设备昵称 | 必须与 setup_ssh.sh 配置的设备名一致 |
user |
SSH 登录用户 | 树莓派通常是 pi，Ubuntu 是 ubuntu |
port |
SSH 端口 | 默认 22，自定义端口需修改 |
project_path |
远程项目目录 | 绝对路径，如 /home/pi/project |
exclude |
排除同步的文件 | 支持通配符，如 *.log、node_modules/ |
修改配置
bash
# 方式 1: 直接编辑
vim .remote-config.json
# 方式 2: 使用 jq 命令
jq '.project_path = "/new/path"' .remote-config.json > .tmp
mv .tmp .remote-config.json
# 方式 3: 让 Claude Code 修改
# 在 Claude 中说："修改 .remote-config.json，将远程路径改为 /new/path"切换远程设备
如果想让项目连接到不同的远程设备：
bash
# 修改 host 字段为其他已配置的设备
jq '.host = "edge-device-2"' .remote-config.json > .tmp
mv .tmp .remote-config.json
# 验证连接
./remote_toolkit.sh status2. 设备配置文件：devices/*.conf
位置 ：/Users/admin/bin/remote_execute_claude/devices/
作用 ：保存已配置的远程设备信息
生成 ：运行 setup_ssh.sh 时自动创建
配置示例
bash
# devices/raspberry-pi.conf
DEVICE_NAME="raspberry-pi"
DEVICE_HOST="192.168.1.100"
DEVICE_USER="pi"
DEVICE_PORT="22"
SSH_KEY_PATH="$HOME/.ssh/raspberry_pi_key"说明：
- 每个设备一个
.conf文件 - 文件名与设备昵称对应
- 被
create_project.sh读取，用于创建项目配置
3. SSH 配置文件：~/.ssh/config
位置 ：~/.ssh/config
作用 ：SSH 客户端配置，实现免密登录和连接复用
生成 ：运行 setup_ssh.sh 时自动添加
配置示例
ssh-config
Host raspberry-pi
HostName 192.168.1.100
User pi
Port 22
IdentityFile ~/.ssh/raspberry_pi_key
ServerAliveInterval 60
ServerAliveCountMax 3
ControlMaster auto
ControlPath ~/.ssh/sockets/%r@%h-%p
ControlPersist 600重要配置说明：
| 配置项 | 说明 | 作用 |
|---|---|---|
Host |
设备昵称 | 使用 ssh raspberry-pi 连接 |
HostName |
实际 IP 地址 | 真实连接目标 |
IdentityFile |
SSH 私钥路径 | 免密登录 |
ControlMaster |
连接复用 | 提升 rsync 同步速度 3-5 倍 |
ControlPersist |
保持连接 | 10 分钟内无需重连 |
4. 项目目录结构
~/my-project/ # 项目根目录
├── .remote-config.json # 项目配置（不同步到远程）
├── remote_toolkit.sh # 工具脚本（不同步）
├── CLAUDE.md # Claude 上下文（不同步）
├── README.md # 项目说明（不同步）
├── .gitignore # Git 忽略规则
├── .backup/ # 自动备份目录（不同步）
│
├── src/ # 源代码（会同步）
│ ├── main.py
│ └── utils.py
├── tests/ # 测试代码（会同步）
│ └── test_main.py
├── requirements.txt # 依赖列表（会同步）
└── config.yaml # 配置文件（会同步）文件同步规则
| 文件类型 | 是否同步 | 原因 |
|---|---|---|
| 工具文件（CLAUDE.md、remote_toolkit.sh 等） | ❌ 否 | 仅本地使用 |
| 版本控制（.git/） | ❌ 否 | 远程不需要 |
| 依赖目录（node_modules/、venv/） | ❌ 否 | 在远程重新安装 |
| 源代码、配置文件 | ✅ 是 | 需要在远程运行 |
重要：工具文件不会同步到远程，保持远程目录干净。
5. 完整配置关系图
┌─────────────────────────────────────────────────────────┐
│ 工具目录: /Users/admin/bin/remote_execute_claude/ │
│ ├── devices/raspberry-pi.conf (设备信息) │
│ └── setup_ssh.sh → 配置 ~/.ssh/config │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ SSH 配置: ~/.ssh/config │
│ Host raspberry-pi │
│ HostName 192.168.1.100 │
│ IdentityFile ~/.ssh/raspberry_pi_key │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 项目配置: ~/my-project/.remote-config.json │
│ { │
│ "host": "raspberry-pi", ← 引用 SSH 配置 │
│ "project_path": "/home/pi/my-project" │
│ } │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 使用工具: ./remote_toolkit.sh │
│ 读取 .remote-config.json → 通过 SSH 连接远程设备 │
└─────────────────────────────────────────────────────────┘6. 常见配置场景
场景 1：添加自定义排除规则
编辑 .remote-config.json，在 exclude 数组中添加：
json
{
"exclude": [
// ... 默认规则 ...
"data/large_dataset.csv", // 排除大数据文件
"*.tmp", // 排除临时文件
"build/", // 排除构建目录
".pytest_cache/" // 排除测试缓存
]
}场景 2：更改远程项目路径
bash
# 方式 1: 编辑配置
vim .remote-config.json
# 修改 "project_path": "/new/path"
# 方式 2: 使用命令
jq '.project_path = "/home/pi/new-project"' .remote-config.json > .tmp
mv .tmp .remote-config.json
# 在远程创建新目录
./remote_toolkit.sh exec "mkdir -p /home/pi/new-project"
# 同步文件
./remote_toolkit.sh sync-to场景 3：项目关联不同设备
bash
# 假设已配置两个设备：raspberry-pi 和 jetson-nano
# 切换到 jetson-nano
jq '.host = "jetson-nano"' .remote-config.json > .tmp
mv .tmp .remote-config.json
# 需要同时更新远程路径和用户
jq '.user = "nvidia"' .remote-config.json > .tmp
mv .tmp .remote-config.json
# 验证配置
./remote_toolkit.sh status❓ 常见问题
Q: 可以同时连接多个远程设备吗？
A : 可以。配置多个设备后，编辑 .remote-config.json 中的 host 字段即可切换。
Q: watch 模式会占用很多资源吗？
A: 不会。使用系统内核级文件监控 API（macOS FSEvents / Linux inotify），CPU 占用 < 1%，内存 < 10MB。
Q: 支持 Windows 吗？
A : 推荐使用 WSL2（完全支持）。Git Bash 可用但不支持 watch 模式。
Q: 能否加密传输？
A: 已经加密。rsync 通过 SSH 传输，SSH 本身提供加密，无需额外配置。
Q: 同步失败如何恢复？
A : sync-from 会自动备份到 .backup/ 目录。查看备份文件：ls .backup/
🎉 开始使用
bash
# 一键开始
cd /Users/admin/bin/remote_execute_claude
./quickstart.sh
# 享受 AI 辅助的远程开发！适用场景：树莓派、嵌入式系统、边缘设备、远程服务器开发
开发愉快！ 🚀
工具文件源码
1. quickstart.sh
bas
#!/bin/bash
# ============================================
# Remote Execute Claude - 快速开始向导
# ============================================
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m'
clear
cat << "EOF"
____ _ _____ _
| _ \ ___ _ __ ___ ___ | |_ ___ | ____|_ _____ ___ _ _| |_ ___
| |_) / _ \ '_ ` _ \ / _ \| __/ _ \ | _| \ \/ / _ \/ __| | | | __/ _ \
| _ < __/ | | | | | (_) | || __/ | |___ > < __/ (__| |_| | || __/
|_| \_\___|_| |_| |_|\___/ \__\___| |_____/_/\_\___|\___|\__,_|\__\___|
____ _ _
/ ___| | __ _ _ _ __| | ___
| | | |/ _` | | | |/ _` |/ _ \
| |___| | (_| | |_| | (_| | __/
\____|_|\__,_|\__,_|\__,_|\___|
EOF
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}${GREEN}Remote Execute Claude - 快速开始向导${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${CYAN}这个向导将帮助你快速配置远程开发环境。${NC}"
echo ""
echo -e "${YELLOW}需要完成的步骤：${NC}"
echo -e " ${GREEN}1.${NC} 安装必要的环境工具"
echo -e " ${GREEN}2.${NC} 配置 SSH 密钥和连接"
echo -e " ${GREEN}3.${NC} 创建项目并初始化配置"
echo ""
read -p "$(echo -e ${YELLOW}准备开始？按任意键继续...${NC})" -n 1 -r
echo ""
echo ""
# ============================================
# 步骤 1: 环境安装
# ============================================
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}${GREEN}步骤 1/3: 环境安装${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${CYAN}检查并安装必要的工具...${NC}"
echo ""
./setup_environment.sh
if [ $? -ne 0 ]; then
echo ""
echo -e "${RED}❌ 环境安装失败${NC}"
echo -e "${YELLOW}请检查错误信息并重试${NC}"
exit 1
fi
echo ""
read -p "$(echo -e ${YELLOW}步骤 1 完成！按任意键继续...${NC})" -n 1 -r
echo ""
echo ""
# ============================================
# 步骤 2: SSH 配置
# ============================================
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}${GREEN}步骤 2/3: SSH 配置${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${CYAN}配置远程设备的 SSH 连接...${NC}"
echo ""
./setup_ssh.sh
if [ $? -ne 0 ]; then
echo ""
echo -e "${RED}❌ SSH 配置失败${NC}"
echo -e "${YELLOW}请检查错误信息并重试${NC}"
exit 1
fi
echo ""
read -p "$(echo -e ${YELLOW}步骤 2 完成！按任意键继续...${NC})" -n 1 -r
echo ""
echo ""
# ============================================
# 步骤 3: 项目创建
# ============================================
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}${GREEN}步骤 3/3: 创建项目${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${CYAN}创建项目配置...${NC}"
echo ""
./create_project.sh
if [ $? -ne 0 ]; then
echo ""
echo -e "${RED}❌ 项目创建失败${NC}"
echo -e "${YELLOW}请检查错误信息并重试${NC}"
exit 1
fi
# ============================================
# 完成
# ============================================
clear
cat << "EOF"
____ _ _
/ ___| _ _ ___ ___ ___ ___ | |_ ___ ___| |
\___ \| | | |/ __/ __/ _ \/ __|| __/ _ \/ __| |
___) | |_| | (_| (_| __/\__ \| || __/\__ \_|
|____/ \__,_|\___\___\___||___/ \__\___||___(_)
EOF
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${BOLD}${GREEN}✅ 所有配置完成！${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${CYAN}🎉 恭喜！你已经完成了所有设置。${NC}"
echo ""
echo -e "${GREEN}接下来的步骤：${NC}"
echo ""
echo -e "${YELLOW}1. 进入项目目录${NC}"
echo -e " ${CYAN}cd [你的项目目录]${NC}"
echo ""
echo -e "${YELLOW}2. 查看远程设备状态${NC}"
echo -e " ${CYAN}./remote_toolkit.sh status${NC}"
echo ""
echo -e "${YELLOW}3. 开启自动同步模式（推荐）${NC}"
echo -e " ${CYAN}./remote_toolkit.sh watch${NC}"
echo ""
echo -e "${YELLOW}4. 在新终端启动 Claude Code${NC}"
echo -e " ${CYAN}claude${NC}"
echo ""
echo -e "${YELLOW}5. 告诉 Claude Code：${NC}"
echo -e "${CYAN} \"我正在使用远程边缘设备开发。${NC}"
echo -e "${CYAN} 使用 ./remote_toolkit.sh 与远程设备交互。${NC}"
echo -e "${CYAN} 自动同步已启动。${NC}"
echo -e "${CYAN} ${NC}"
echo -e "${CYAN} 可用命令：${NC}"
echo -e "${CYAN} - ./remote_toolkit.sh exec [命令] - 远程执行${NC}"
echo -e "${CYAN} - ./remote_toolkit.sh logs [文件] - 查看日志${NC}"
echo -e "${CYAN} - ./remote_toolkit.sh read [文件] - 读取文件${NC}"
echo -e "${CYAN} ${NC}"
echo -e "${CYAN} 当前任务：[描述你的任务]\"${NC}"
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${GREEN}📚 查看完整文档：${NC}"
echo -e " ${CYAN}cat /Users/admin/bin/remote_execute_claude/README.md${NC}"
echo ""
echo -e "${GREEN}🆘 需要帮助？${NC}"
echo -e " ${CYAN}./remote_toolkit.sh help${NC}"
echo ""
echo -e "${BOLD}${GREEN}祝你开发愉快！🚀${NC}"
echo ""2. setup_environment.sh
bash
#!/bin/bash
# ============================================
# Remote Execute Claude - 环境安装脚本
# ============================================
set -e # 遇到错误立即退出
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}Remote Execute Claude - 环境安装${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 检测操作系统
detect_os() {
if [[ "$OSTYPE" == "darwin"* ]]; then
echo "macos"
elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
echo "linux"
else
echo "unknown"
fi
}
OS=$(detect_os)
echo -e "${BLUE}📋 检测到操作系统: ${OS}${NC}"
echo ""
# 检查工具是否已安装
check_tool() {
local tool=$1
if command -v "$tool" &> /dev/null; then
echo -e "${GREEN}✅ ${tool} 已安装 - $(${tool} --version 2>&1 | head -n 1)${NC}"
return 0
else
echo -e "${YELLOW}⚠️ ${tool} 未安装${NC}"
return 1
fi
}
# 安装工具 - macOS
install_tool_macos() {
local tool=$1
echo -e "${BLUE}📦 正在安装 ${tool}...${NC}"
# 检查 Homebrew
if ! command -v brew &> /dev/null; then
echo -e "${RED}❌ Homebrew 未安装！${NC}"
echo -e "${YELLOW}请先安装 Homebrew: https://brew.sh${NC}"
echo -e "${YELLOW}或运行: /bin/bash -c \"\$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"${NC}"
exit 1
fi
brew install "$tool"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ ${tool} 安装成功${NC}"
else
echo -e "${RED}❌ ${tool} 安装失败${NC}"
exit 1
fi
}
# 安装工具 - Linux
install_tool_linux() {
local tool=$1
local package=$2 # 某些工具的包名可能不同
echo -e "${BLUE}📦 正在安装 ${tool}...${NC}"
# 检测包管理器
if command -v apt-get &> /dev/null; then
sudo apt-get update
sudo apt-get install -y "${package:-$tool}"
elif command -v yum &> /dev/null; then
sudo yum install -y "${package:-$tool}"
else
echo -e "${RED}❌ 未检测到支持的包管理器 (apt-get 或 yum)${NC}"
exit 1
fi
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ ${tool} 安装成功${NC}"
else
echo -e "${RED}❌ ${tool} 安装失败${NC}"
exit 1
fi
}
# 检查并安装必需工具
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第一步: 检查必需工具${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
TOOLS_TO_INSTALL=()
# 检查 rsync
if ! check_tool "rsync"; then
TOOLS_TO_INSTALL+=("rsync")
fi
echo ""
# 检查 jq
if ! check_tool "jq"; then
TOOLS_TO_INSTALL+=("jq")
fi
echo ""
# 检查文件监控工具
if [[ "$OS" == "macos" ]]; then
if ! check_tool "fswatch"; then
TOOLS_TO_INSTALL+=("fswatch")
fi
elif [[ "$OS" == "linux" ]]; then
if ! check_tool "inotifywait"; then
TOOLS_TO_INSTALL+=("inotify-tools")
fi
fi
echo ""
# 检查 ssh
if ! check_tool "ssh"; then
echo -e "${RED}❌ SSH 未安装！这是必需的工具。${NC}"
exit 1
fi
echo ""
# 安装缺失的工具
if [ ${#TOOLS_TO_INSTALL[@]} -eq 0 ]; then
echo -e "${GREEN}🎉 所有必需工具已安装！${NC}"
else
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${YELLOW}第二步: 安装缺失工具${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${YELLOW}需要安装: ${TOOLS_TO_INSTALL[*]}${NC}"
echo ""
read -p "是否继续安装？(y/n) " -n 1 -r
echo ""
if [[ $REPLY =~ ^[Yy]$ ]]; then
for tool in "${TOOLS_TO_INSTALL[@]}"; do
if [[ "$OS" == "macos" ]]; then
install_tool_macos "$tool"
elif [[ "$OS" == "linux" ]]; then
# 特殊处理 inotifywait (包名是 inotify-tools)
if [[ "$tool" == "inotify-tools" ]]; then
install_tool_linux "inotifywait" "inotify-tools"
else
install_tool_linux "$tool"
fi
fi
echo ""
done
else
echo -e "${YELLOW}⚠️ 安装已取消${NC}"
exit 0
fi
fi
# 验证安装
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第三步: 验证安装${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
ALL_OK=true
# 验证必需工具
echo -e "${BLUE}验证必需工具...${NC}"
echo ""
for tool in rsync jq ssh; do
if check_tool "$tool"; then
echo ""
else
ALL_OK=false
fi
done
# 验证文件监控工具
if [[ "$OS" == "macos" ]]; then
if check_tool "fswatch"; then
echo ""
else
ALL_OK=false
fi
elif [[ "$OS" == "linux" ]]; then
if check_tool "inotifywait"; then
echo ""
else
ALL_OK=false
fi
fi
# 创建 SSH sockets 目录
echo -e "${BLUE}创建 SSH sockets 目录...${NC}"
mkdir -p ~/.ssh/sockets
echo -e "${GREEN}✅ ~/.ssh/sockets 已创建${NC}"
echo ""
# 最终结果
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
if [ "$ALL_OK" = true ]; then
echo -e "${GREEN}✅ 环境安装完成！${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${GREEN}下一步操作:${NC}"
echo -e " 1. 配置 SSH 密钥: ${YELLOW}./setup_ssh.sh${NC}"
echo -e " 2. 创建项目配置: ${YELLOW}./create_project.sh${NC}"
echo -e " 3. 开始使用工具: ${YELLOW}./remote_toolkit.sh${NC}"
echo ""
echo -e "${BLUE}工具目录: /Users/admin/bin/remote_execute_claude${NC}"
else
echo -e "${RED}❌ 环境安装未完成，请检查错误信息${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
exit 1
fi3. setup_ssh.sh
bash
#!/bin/bash
# ============================================
# Remote Execute Claude - SSH 配置脚本
# ============================================
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}Remote Execute Claude - SSH 配置${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 默认配置
SSH_KEY_NAME="edge_device_key"
SSH_KEY_PATH="$HOME/.ssh/${SSH_KEY_NAME}"
SSH_CONFIG_FILE="$HOME/.ssh/config"
# 获取用户输入
echo -e "${YELLOW}请输入远程设备信息:${NC}"
echo ""
# 读取设备昵称
read -p "设备昵称 (例如: edge-device): " DEVICE_NAME
if [ -z "$DEVICE_NAME" ]; then
echo -e "${RED}❌ 设备昵称不能为空${NC}"
exit 1
fi
# 读取 IP 地址
read -p "设备 IP 地址: " DEVICE_IP
if [ -z "$DEVICE_IP" ]; then
echo -e "${RED}❌ IP 地址不能为空${NC}"
exit 1
fi
# 读取用户名
read -p "SSH 用户名: " DEVICE_USER
if [ -z "$DEVICE_USER" ]; then
echo -e "${RED}❌ 用户名不能为空${NC}"
exit 1
fi
# 读取端口（默认 22）
read -p "SSH 端口 (默认 22): " DEVICE_PORT
DEVICE_PORT=${DEVICE_PORT:-22}
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}配置信息确认${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "设备昵称: ${GREEN}${DEVICE_NAME}${NC}"
echo -e "IP 地址: ${GREEN}${DEVICE_IP}${NC}"
echo -e "用户名: ${GREEN}${DEVICE_USER}${NC}"
echo -e "端口: ${GREEN}${DEVICE_PORT}${NC}"
echo -e "SSH 密钥: ${GREEN}${SSH_KEY_PATH}${NC}"
echo ""
read -p "确认以上信息正确？(y/n) " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${YELLOW}⚠️ 配置已取消${NC}"
exit 0
fi
# 创建 SSH 目录
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第一步: 准备 SSH 环境${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
mkdir -p ~/.ssh
chmod 700 ~/.ssh
mkdir -p ~/.ssh/sockets
echo -e "${GREEN}✅ SSH 目录已准备${NC}"
# 检查是否已存在密钥
if [ -f "$SSH_KEY_PATH" ]; then
echo ""
echo -e "${YELLOW}⚠️ SSH 密钥已存在: ${SSH_KEY_PATH}${NC}"
read -p "是否重新生成？这会覆盖现有密钥 (y/n) " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${BLUE}使用现有密钥${NC}"
SKIP_KEYGEN=true
else
rm -f "${SSH_KEY_PATH}" "${SSH_KEY_PATH}.pub"
SKIP_KEYGEN=false
fi
else
SKIP_KEYGEN=false
fi
# 生成 SSH 密钥
if [ "$SKIP_KEYGEN" = false ]; then
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第二步: 生成 SSH 密钥${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
ssh-keygen -t ed25519 -f "$SSH_KEY_PATH" -C "edge-device-access" -N ""
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ SSH 密钥生成成功${NC}"
else
echo -e "${RED}❌ SSH 密钥生成失败${NC}"
exit 1
fi
fi
# 复制公钥到远程设备
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第三步: 复制公钥到远程设备${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${YELLOW}请输入远程设备的 SSH 密码（只需要这一次）${NC}"
ssh-copy-id -i "${SSH_KEY_PATH}.pub" -p ${DEVICE_PORT} ${DEVICE_USER}@${DEVICE_IP}
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ 公钥复制成功${NC}"
else
echo -e "${RED}❌ 公钥复制失败${NC}"
echo -e "${YELLOW}请检查:${NC}"
echo -e " 1. 远程设备 IP 地址是否正确"
echo -e " 2. 用户名是否正确"
echo -e " 3. 端口是否正确"
echo -e " 4. 远程设备是否允许 SSH 连接"
exit 1
fi
# 测试连接
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第四步: 测试 SSH 连接${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${BLUE}测试无密码登录...${NC}"
ssh -i "$SSH_KEY_PATH" -p ${DEVICE_PORT} ${DEVICE_USER}@${DEVICE_IP} "echo '连接成功！'"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ SSH 连接测试成功${NC}"
else
echo -e "${RED}❌ SSH 连接测试失败${NC}"
exit 1
fi
# 配置 SSH config
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第五步: 配置 SSH config${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 检查是否已存在配置
if grep -q "Host ${DEVICE_NAME}" "$SSH_CONFIG_FILE" 2>/dev/null; then
echo -e "${YELLOW}⚠️ SSH config 中已存在 ${DEVICE_NAME} 配置${NC}"
read -p "是否覆盖？(y/n) " -n 1 -r
echo ""
if [[ $REPLY =~ ^[Yy]$ ]]; then
# 删除旧配置
sed -i.bak "/Host ${DEVICE_NAME}/,/^$/d" "$SSH_CONFIG_FILE"
echo -e "${YELLOW}已删除旧配置${NC}"
else
echo -e "${BLUE}保留现有配置${NC}"
SKIP_SSH_CONFIG=true
fi
else
SKIP_SSH_CONFIG=false
fi
if [ "$SKIP_SSH_CONFIG" = false ]; then
# 添加新配置
cat >> "$SSH_CONFIG_FILE" <<EOF
Host ${DEVICE_NAME}
HostName ${DEVICE_IP}
User ${DEVICE_USER}
Port ${DEVICE_PORT}
IdentityFile ${SSH_KEY_PATH}
ServerAliveInterval 60
ServerAliveCountMax 3
ControlMaster auto
ControlPath ~/.ssh/sockets/%r@%h-%p
ControlPersist 600
EOF
echo -e "${GREEN}✅ SSH config 配置完成${NC}"
fi
# 测试简化连接
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第六步: 测试简化连接${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${BLUE}现在可以使用简化命令连接:${NC}"
echo -e "${YELLOW}ssh ${DEVICE_NAME}${NC}"
echo ""
echo -e "${BLUE}测试中...${NC}"
ssh ${DEVICE_NAME} "echo '简化连接成功！'"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ 简化连接测试成功${NC}"
else
echo -e "${RED}❌ 简化连接测试失败${NC}"
exit 1
fi
# 保存配置到文件
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}第七步: 保存设备配置${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
DEVICE_CONFIG_FILE="/Users/admin/bin/remote_execute_claude/devices/${DEVICE_NAME}.conf"
mkdir -p "/Users/admin/bin/remote_execute_claude/devices"
cat > "$DEVICE_CONFIG_FILE" <<EOF
# 远程设备配置 - ${DEVICE_NAME}
# 生成时间: $(date)
DEVICE_NAME="${DEVICE_NAME}"
DEVICE_IP="${DEVICE_IP}"
DEVICE_USER="${DEVICE_USER}"
DEVICE_PORT="${DEVICE_PORT}"
SSH_KEY_PATH="${SSH_KEY_PATH}"
EOF
echo -e "${GREEN}✅ 设备配置已保存到: ${DEVICE_CONFIG_FILE}${NC}"
# 完成
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}✅ SSH 配置完成！${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${GREEN}配置摘要:${NC}"
echo -e " 设备昵称: ${YELLOW}${DEVICE_NAME}${NC}"
echo -e " 连接地址: ${YELLOW}${DEVICE_USER}@${DEVICE_IP}:${DEVICE_PORT}${NC}"
echo -e " 简化命令: ${YELLOW}ssh ${DEVICE_NAME}${NC}"
echo -e " 配置文件: ${YELLOW}${DEVICE_CONFIG_FILE}${NC}"
echo ""
echo -e "${GREEN}下一步:${NC}"
echo -e " 创建项目配置: ${YELLOW}./create_project.sh${NC}"
echo ""4. create_project.sh
bash
#!/bin/bash
# ============================================
# Remote Execute Claude - 项目配置脚本
# ============================================
set -e
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}Remote Execute Claude - 项目配置${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
TOOLKIT_DIR="/Users/admin/bin/remote_execute_claude"
# 检查是否有已配置的设备
DEVICES_DIR="${TOOLKIT_DIR}/devices"
if [ ! -d "$DEVICES_DIR" ] || [ -z "$(ls -A $DEVICES_DIR 2>/dev/null)" ]; then
echo -e "${RED}❌ 未找到已配置的设备${NC}"
echo -e "${YELLOW}请先运行: ./setup_ssh.sh 配置远程设备${NC}"
exit 1
fi
# 列出可用设备
echo -e "${BLUE}可用的远程设备:${NC}"
echo ""
device_count=0
declare -a device_names
declare -a device_files
for conf_file in "$DEVICES_DIR"/*.conf; do
if [ -f "$conf_file" ]; then
device_count=$((device_count + 1))
source "$conf_file"
device_names+=("$DEVICE_NAME")
device_files+=("$conf_file")
echo -e " ${GREEN}[$device_count]${NC} ${DEVICE_NAME} (${DEVICE_USER}@${DEVICE_IP})"
fi
done
echo ""
# 选择设备
if [ $device_count -eq 1 ]; then
SELECTED_INDEX=0
echo -e "${BLUE}自动选择设备: ${device_names[0]}${NC}"
else
read -p "请选择设备 [1-${device_count}]: " selection
SELECTED_INDEX=$((selection - 1))
if [ $SELECTED_INDEX -lt 0 ] || [ $SELECTED_INDEX -ge $device_count ]; then
echo -e "${RED}❌ 无效的选择${NC}"
exit 1
fi
fi
# 加载选中的设备配置
source "${device_files[$SELECTED_INDEX]}"
echo -e "${GREEN}✅ 已选择设备: ${DEVICE_NAME}${NC}"
echo ""
# 获取项目信息
echo -e "${YELLOW}请输入项目信息:${NC}"
echo ""
# 项目目录
read -p "本地项目目录 (例如: ~/my_edge_project): " PROJECT_DIR
PROJECT_DIR="${PROJECT_DIR/#\~/$HOME}" # 展开 ~ 符号
if [ -z "$PROJECT_DIR" ]; then
echo -e "${RED}❌ 项目目录不能为空${NC}"
exit 1
fi
# 创建目录（如果不存在）
if [ ! -d "$PROJECT_DIR" ]; then
read -p "目录不存在，是否创建？(y/n) " -n 1 -r
echo ""
if [[ $REPLY =~ ^[Yy]$ ]]; then
mkdir -p "$PROJECT_DIR"
echo -e "${GREEN}✅ 已创建目录: ${PROJECT_DIR}${NC}"
else
echo -e "${RED}❌ 项目目录不存在${NC}"
exit 1
fi
fi
# 远程项目路径
read -p "远程项目路径 (例如: /home/user/project): " REMOTE_PATH
if [ -z "$REMOTE_PATH" ]; then
echo -e "${RED}❌ 远程路径不能为空${NC}"
exit 1
fi
# 询问是否在远程创建目录
echo ""
read -p "是否在远程设备上创建项目目录？(y/n) " -n 1 -r
echo ""
if [[ $REPLY =~ ^[Yy]$ ]]; then
echo -e "${BLUE}在远程设备上创建目录: ${REMOTE_PATH}${NC}"
ssh ${DEVICE_NAME} "mkdir -p ${REMOTE_PATH}"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ 远程目录创建成功${NC}"
else
echo -e "${RED}❌ 远程目录创建失败${NC}"
exit 1
fi
fi
# 配置排除项
echo ""
echo -e "${YELLOW}配置同步排除项（多个用空格分隔，按回车跳过使用默认值）${NC}"
echo -e "${BLUE}默认排除: node_modules __pycache__ .git venv *.pyc *.log .DS_Store${NC}"
echo -e "${BLUE} CLAUDE.md README.md remote_toolkit.sh (本地工具文件)${NC}"
read -p "自定义排除项: " CUSTOM_EXCLUDES
# 合并排除项（包含本地工具文件）
DEFAULT_EXCLUDES=("node_modules" "__pycache__" ".git" "venv" "*.pyc" "*.log" ".DS_Store" "*.swp" "CLAUDE.md" "README.md" "remote_toolkit.sh" ".remote-config.json" ".backup")
if [ -n "$CUSTOM_EXCLUDES" ]; then
IFS=' ' read -ra ADDITIONAL_EXCLUDES <<< "$CUSTOM_EXCLUDES"
EXCLUDE_ARRAY=("${DEFAULT_EXCLUDES[@]}" "${ADDITIONAL_EXCLUDES[@]}")
else
EXCLUDE_ARRAY=("${DEFAULT_EXCLUDES[@]}")
fi
# 确认信息
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}项目配置信息确认${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "远程设备: ${GREEN}${DEVICE_NAME}${NC}"
echo -e "本地目录: ${GREEN}${PROJECT_DIR}${NC}"
echo -e "远程路径: ${GREEN}${REMOTE_PATH}${NC}"
echo -e "排除项: ${GREEN}${EXCLUDE_ARRAY[*]}${NC}"
echo ""
read -p "确认以上信息正确？(y/n) " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${YELLOW}⚠️ 配置已取消${NC}"
exit 0
fi
# 创建配置文件
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}创建项目配置文件${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
CONFIG_FILE="${PROJECT_DIR}/.remote-config.json"
# 生成 JSON 格式的排除项数组
EXCLUDE_JSON="["
for i in "${!EXCLUDE_ARRAY[@]}"; do
if [ $i -gt 0 ]; then
EXCLUDE_JSON+=","
fi
EXCLUDE_JSON+="\"${EXCLUDE_ARRAY[$i]}\""
done
EXCLUDE_JSON+="]"
# 创建配置文件
cat > "$CONFIG_FILE" <<EOF
{
"host": "${DEVICE_NAME}",
"user": "${DEVICE_USER}",
"port": ${DEVICE_PORT},
"project_path": "${REMOTE_PATH}",
"exclude": ${EXCLUDE_JSON}
}
EOF
echo -e "${GREEN}✅ 配置文件已创建: ${CONFIG_FILE}${NC}"
# 复制工具脚本到项目目录
echo ""
echo -e "${BLUE}复制工具脚本到项目目录...${NC}"
cp "${TOOLKIT_DIR}/remote_toolkit.sh" "${PROJECT_DIR}/"
chmod +x "${PROJECT_DIR}/remote_toolkit.sh"
echo -e "${GREEN}✅ 工具脚本已复制${NC}"
# 创建 .gitignore
echo ""
echo -e "${BLUE}创建 .gitignore...${NC}"
GITIGNORE_FILE="${PROJECT_DIR}/.gitignore"
if [ -f "$GITIGNORE_FILE" ]; then
echo -e "${YELLOW}⚠️ .gitignore 已存在${NC}"
else
cat > "$GITIGNORE_FILE" <<EOF
# Remote Execute Claude
.remote-config.json
.backup/
.backup.old/
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
venv/
ENV/
env/
# Node
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# IDE
.vscode/
.idea/
*.swp
*.swo
*~
# OS
.DS_Store
Thumbs.db
# Logs
*.log
logs/
EOF
echo -e "${GREEN}✅ .gitignore 已创建${NC}"
fi
# 创建 README
echo ""
echo -e "${BLUE}创建项目 README...${NC}"
README_FILE="${PROJECT_DIR}/README.md"
if [ -f "$README_FILE" ]; then
echo -e "${YELLOW}⚠️ README.md 已存在，跳过${NC}"
else
cat > "$README_FILE" <<EOF
# Remote Edge Device Project
该项目使用 Remote Execute Claude 工具进行远程开发和调试。
## 远程设备信息
- **设备名称**: ${DEVICE_NAME}
- **远程路径**: ${REMOTE_PATH}
## 使用方法
### 查看状态
\`\`\`bash
./remote_toolkit.sh status
\`\`\`
### 同步到远程
\`\`\`bash
./remote_toolkit.sh sync-to
\`\`\`
### 从远程同步
\`\`\`bash
./remote_toolkit.sh sync-from
\`\`\`
### 自动监控并同步
\`\`\`bash
./remote_toolkit.sh watch
\`\`\`
### 远程执行命令
\`\`\`bash
./remote_toolkit.sh exec "python main.py"
\`\`\`
### 读取远程文件
\`\`\`bash
./remote_toolkit.sh read "config.yaml"
\`\`\`
### 查看远程日志
\`\`\`bash
./remote_toolkit.sh logs "app.log"
\`\`\`
### 打开远程 Shell
\`\`\`bash
./remote_toolkit.sh shell
\`\`\`
## Claude Code 集成
在 Claude Code 中使用时，告诉 AI：
\`\`\`
我正在使用远程边缘设备进行开发。
配置信息在 .remote-config.json 中。
使用 ./remote_toolkit.sh 工具与远程设备交互。
可用命令：
- ./remote_toolkit.sh exec [命令] - 远程执行
- ./remote_toolkit.sh sync-to - 同步到远程
- ./remote_toolkit.sh watch - 自动同步（开发时使用）
当前任务：[描述你的任务]
\`\`\`
## 配置文件
配置文件位于 \`.remote-config.json\`，包含：
- 远程设备连接信息
- 同步排除项
**注意**: 该文件已添加到 .gitignore，不会被提交到版本控制。
EOF
echo -e "${GREEN}✅ README.md 已创建${NC}"
fi
# 创建 CLAUDE.md
echo ""
echo -e "${BLUE}创建 CLAUDE.md（Claude Code 自动识别）...${NC}"
CLAUDE_FILE="${PROJECT_DIR}/CLAUDE.md"
if [ -f "$CLAUDE_FILE" ]; then
echo -e "${YELLOW}⚠️ CLAUDE.md 已存在，跳过${NC}"
else
# 读取模板并替换变量
TEMPLATE_FILE="${TOOLKIT_DIR}/templates/CLAUDE.md.template"
if [ -f "$TEMPLATE_FILE" ]; then
# 使用 sed 替换模板中的变量
sed -e "s|{{DEVICE_NAME}}|${DEVICE_NAME}|g" \
-e "s|{{REMOTE_PATH}}|${REMOTE_PATH}|g" \
"$TEMPLATE_FILE" > "$CLAUDE_FILE"
echo -e "${GREEN}✅ CLAUDE.md 已创建${NC}"
echo -e "${CYAN} Claude Code 会自动读取此文件了解项目背景${NC}"
else
# 如果模板不存在，使用内联版本
cat > "$CLAUDE_FILE" <<'CLAUDEEOF'
# 项目背景：远程边缘设备开发
## 🎯 核心信息
本项目运行在**远程边缘设备**上，本地环境不具备运行条件。
**重要**:
- 本地只用于代码编辑
- 所有执行、测试都在远程设备上进行
- 文件修改会自动同步到远程设备（如果 watch 模式启动）
## 📡 远程设备配置
CLAUDEEOF
# 追加设备信息
cat >> "$CLAUDE_FILE" <<EOF
- **设备名称**: ${DEVICE_NAME}
- **远程路径**: ${REMOTE_PATH}
- **连接方式**: SSH (配置已完成)
- **同步状态**: 自动同步（watch 模式）或手动同步
配置文件位于: \`.remote-config.json\`
## 🛠️ 可用工具
### 核心命令：remote_toolkit.sh
所有与远程设备的交互都通过 \`./remote_toolkit.sh\` 进行：
\`\`\`bash
# 基本操作
./remote_toolkit.sh status # 查看远程设备状态
./remote_toolkit.sh sync-to # 同步到远程
./remote_toolkit.sh sync-from # 从远程同步
./remote_toolkit.sh watch # 自动监控并同步
# 远程执行
./remote_toolkit.sh exec "命令" # 在远程设备上执行命令
./remote_toolkit.sh read "文件" # 读取远程文件
./remote_toolkit.sh logs "日志" # 查看远程日志
./remote_toolkit.sh shell # 打开远程终端
\`\`\`
## 📋 标准工作流程
1. **本地编辑**: 使用 Read、Write、Edit 工具正常编辑文件
2. **自动同步**: 如果 watch 模式运行中，修改会自动同步
3. **远程执行**: 使用 \`exec\` 命令在远程设备上运行和测试
4. **查看结果**: 使用 \`logs\` 或 \`read\` 查看输出和日志
## 💡 最佳实践
### ✅ 应该做的
1. **使用本地工具编辑文件** - 使用 Read、Write、Edit 工具修改代码
2. **远程执行所有运行命令** - \`./remote_toolkit.sh exec "python main.py"\`
3. **使用 read 查看远程文件** - \`./remote_toolkit.sh read "config.yaml"\`
### ❌ 不应该做的
1. **不要在本地执行项目代码** - 本地环境不支持
2. **不要假设本地环境可用** - 所有测试和运行都在远程进行
3. **不要直接在远程修改文件** - 应该在本地修改后同步
## 🔧 常见任务示例
\`\`\`bash
# Python 项目
./remote_toolkit.sh exec "pip install -r requirements.txt"
./remote_toolkit.sh exec "python main.py"
./remote_toolkit.sh exec "pytest tests/ -v"
# Node.js 项目
./remote_toolkit.sh exec "npm install"
./remote_toolkit.sh exec "npm start"
./remote_toolkit.sh exec "npm test"
# 查看日志
./remote_toolkit.sh logs "app.log"
# 读取配置
./remote_toolkit.sh read "config.yaml"
\`\`\`
## 🚨 重要提醒
1. **文件会自动同步**: 在 watch 模式下，本地文件修改后会自动同步到远程
2. **执行在远程**: 所有代码执行、测试都在远程设备上进行
3. **日志在远程**: 程序输出的日志文件在远程设备上
---
**记住**: 本地是编辑环境，远程是运行环境。保持这个清晰的分离！
EOF
echo -e "${GREEN}✅ CLAUDE.md 已创建${NC}"
echo -e "${CYAN} Claude Code 会自动读取此文件了解项目背景${NC}"
fi
fi
# 初始化 git（如果需要）
echo ""
read -p "是否初始化 Git 仓库？(y/n) " -n 1 -r
echo ""
if [[ $REPLY =~ ^[Yy]$ ]]; then
cd "$PROJECT_DIR"
if [ -d ".git" ]; then
echo -e "${YELLOW}⚠️ Git 仓库已存在${NC}"
else
git init
echo -e "${GREEN}✅ Git 仓库已初始化${NC}"
fi
fi
# 测试连接
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}测试远程连接${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
cd "$PROJECT_DIR"
./remote_toolkit.sh status
# 完成
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}✅ 项目配置完成！${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
echo -e "${GREEN}项目目录:${NC} ${YELLOW}${PROJECT_DIR}${NC}"
echo ""
echo -e "${GREEN}快速开始:${NC}"
echo -e " 1. 进入项目目录: ${YELLOW}cd ${PROJECT_DIR}${NC}"
echo -e " 2. 查看状态: ${YELLOW}./remote_toolkit.sh status${NC}"
echo -e " 3. 开启自动同步: ${YELLOW}./remote_toolkit.sh watch${NC}"
echo -e " 4. 启动 Claude: ${YELLOW}claude${NC}"
echo ""
echo -e "${BLUE}详细使用说明请查看: ${PROJECT_DIR}/README.md${NC}"
echo ""5. remote_toolkit.sh
bash
#!/bin/bash
# ============================================
# Remote Execute Claude - 主工具脚本
# ============================================
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m'
# 配置文件
CONFIG_FILE=".remote-config.json"
# 检查配置文件是否存在
if [ ! -f "$CONFIG_FILE" ]; then
echo -e "${RED}❌ 错误: $CONFIG_FILE 未找到${NC}"
echo -e "${YELLOW}请先运行项目配置脚本创建配置文件${NC}"
echo -e "${BLUE}提示: /Users/admin/bin/remote_execute_claude/create_project.sh${NC}"
exit 1
fi
# 检查 jq 是否安装
if ! command -v jq &> /dev/null; then
echo -e "${RED}❌ 错误: jq 未安装${NC}"
echo -e "${YELLOW}请先运行环境安装脚本${NC}"
echo -e "${BLUE}提示: /Users/admin/bin/remote_execute_claude/setup_environment.sh${NC}"
exit 1
fi
# 解析配置
REMOTE_HOST=$(jq -r '.host' $CONFIG_FILE)
REMOTE_USER=$(jq -r '.user' $CONFIG_FILE)
REMOTE_PORT=$(jq -r '.port' $CONFIG_FILE)
REMOTE_PATH=$(jq -r '.project_path' $CONFIG_FILE)
# 构建排除参数
EXCLUDE_ARGS=""
while IFS= read -r exclude; do
EXCLUDE_ARGS="$EXCLUDE_ARGS --exclude=$exclude"
done < <(jq -r '.exclude[]' $CONFIG_FILE)
# 函数: 检查远程连接
check_connection() {
if ssh -p $REMOTE_PORT -o ConnectTimeout=5 ${REMOTE_USER}@${REMOTE_HOST} "exit" 2>/dev/null; then
return 0
else
return 1
fi
}
# 函数: 同步到远程
sync_to_remote() {
echo -e "${BLUE}📤 同步 本地 → 远程...${NC}"
echo ""
rsync -avz --progress \
-e "ssh -p $REMOTE_PORT" \
$EXCLUDE_ARGS \
--delete \
./ ${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PATH}/
local exit_code=$?
echo ""
if [ $exit_code -eq 0 ]; then
echo -e "${GREEN}✅ 同步完成 (本地 → 远程)${NC}"
echo -e "${CYAN}时间: $(date '+%Y-%m-%d %H:%M:%S')${NC}"
else
echo -e "${RED}❌ 同步失败${NC}"
return 1
fi
}
# 函数: 从远程同步
sync_from_remote() {
echo -e "${BLUE}📥 同步 远程 → 本地...${NC}"
echo ""
# 创建备份
echo -e "${YELLOW}💾 创建本地备份...${NC}"
if [ -d ".backup" ]; then
rm -rf .backup.old 2>/dev/null
mv .backup .backup.old 2>/dev/null
fi
mkdir -p .backup
rsync -a ./ .backup/ $EXCLUDE_ARGS 2>/dev/null
echo -e "${GREEN}✅ 备份已创建: .backup/${NC}"
echo ""
rsync -avz --progress \
-e "ssh -p $REMOTE_PORT" \
$EXCLUDE_ARGS \
${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PATH}/ ./
local exit_code=$?
echo ""
if [ $exit_code -eq 0 ]; then
echo -e "${GREEN}✅ 同步完成 (远程 → 本地)${NC}"
echo -e "${YELLOW}💾 备份位置: .backup/${NC}"
echo -e "${CYAN}时间: $(date '+%Y-%m-%d %H:%M:%S')${NC}"
else
echo -e "${RED}❌ 同步失败${NC}"
return 1
fi
}
# 函数: 执行远程命令
remote_exec() {
local cmd="$@"
echo -e "${BLUE}🚀 远程执行: ${CYAN}${cmd}${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"cd ${REMOTE_PATH} && $cmd"
local exit_code=$?
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
if [ $exit_code -eq 0 ]; then
echo -e "${GREEN}✅ 命令执行成功 (退出码: 0)${NC}"
else
echo -e "${RED}❌ 命令执行失败 (退出码: ${exit_code})${NC}"
fi
return $exit_code
}
# 函数: 读取远程文件
remote_read() {
local file_path="$1"
if [ -z "$file_path" ]; then
echo -e "${RED}❌ 错误: 请指定文件路径${NC}"
echo -e "${YELLOW}用法: $0 read <文件路径>${NC}"
return 1
fi
echo -e "${BLUE}📄 读取远程文件: ${CYAN}${file_path}${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"cat ${REMOTE_PATH}/${file_path}"
local exit_code=$?
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
if [ $exit_code -ne 0 ]; then
echo -e "${RED}❌ 读取文件失败${NC}"
return 1
fi
}
# 函数: 监控文件变化并自动同步 (Linux)
watch_sync_linux() {
echo -e "${GREEN}👁️ 监控文件变化 (Linux inotify 模式)${NC}"
echo -e "${YELLOW}按 Ctrl+C 停止监控${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 初始同步
echo -e "${BLUE}执行初始同步...${NC}"
sync_to_remote
echo ""
echo -e "${GREEN}⏳ 等待文件变化...${NC}"
echo ""
while inotifywait -r -e modify,create,delete,move \
--exclude '(\.git|\.backup|node_modules|__pycache__|\.pyc$|\.log$)' \
. 2>/dev/null; do
echo ""
echo -e "${YELLOW}📝 检测到文件变化${NC}"
sync_to_remote
echo ""
echo -e "${GREEN}⏳ 等待下一次变化...${NC}"
echo ""
done
}
# 函数: 监控文件变化并自动同步 (macOS)
watch_sync_macos() {
echo -e "${GREEN}👁️ 监控文件变化 (macOS fswatch 模式)${NC}"
echo -e "${YELLOW}按 Ctrl+C 停止监控${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 初始同步
echo -e "${BLUE}执行初始同步...${NC}"
sync_to_remote
echo ""
echo -e "${GREEN}⏳ 等待文件变化...${NC}"
echo ""
fswatch -o \
--exclude='\.git/' \
--exclude='\.backup/' \
--exclude='node_modules/' \
--exclude='__pycache__/' \
--exclude='\.pyc$' \
--exclude='\.log$' \
. | while read f; do
echo ""
echo -e "${YELLOW}📝 检测到文件变化${NC}"
sync_to_remote
echo ""
echo -e "${GREEN}⏳ 等待下一次变化...${NC}"
echo ""
done
}
# 函数: 监控包装器
watch_sync() {
if command -v fswatch &> /dev/null; then
watch_sync_macos
elif command -v inotifywait &> /dev/null; then
watch_sync_linux
else
echo -e "${RED}❌ 未找到文件监控工具${NC}"
echo -e "${YELLOW}macOS: brew install fswatch${NC}"
echo -e "${YELLOW}Linux: apt-get install inotify-tools${NC}"
exit 1
fi
}
# 函数: 查看远程日志
remote_logs() {
local log_pattern="${1:-*.log}"
echo -e "${BLUE}📋 查看远程日志: ${CYAN}${log_pattern}${NC}"
echo -e "${YELLOW}按 Ctrl+C 停止${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"tail -f ${REMOTE_PATH}/${log_pattern}"
}
# 函数: 打开远程 Shell
remote_shell() {
echo -e "${BLUE}🖥️ 打开远程 Shell${NC}"
echo -e "${CYAN}工作目录: ${REMOTE_PATH}${NC}"
echo -e "${YELLOW}输入 'exit' 或按 Ctrl+D 退出${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
ssh -p $REMOTE_PORT -t ${REMOTE_USER}@${REMOTE_HOST} \
"cd ${REMOTE_PATH} && exec \$SHELL -l"
}
# 函数: 显示状态
show_status() {
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo -e "${GREEN}Remote Execute Claude - 状态${NC}"
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
echo ""
# 基本信息
echo -e "${CYAN}配置信息:${NC}"
echo -e " 设备: ${GREEN}${REMOTE_HOST}${NC}"
echo -e " 用户: ${GREEN}${REMOTE_USER}${NC}"
echo -e " 端口: ${GREEN}${REMOTE_PORT}${NC}"
echo -e " 远程路径: ${GREEN}${REMOTE_PATH}${NC}"
echo ""
# 检查连接
echo -e "${CYAN}连接状态:${NC}"
if check_connection; then
echo -e " ${GREEN}✅ 连接正常${NC}"
# 获取远程信息
echo ""
echo -e "${CYAN}远程设备信息:${NC}"
# 操作系统
OS_INFO=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"uname -s 2>/dev/null || echo 'Unknown'")
echo -e " 操作系统: ${GREEN}${OS_INFO}${NC}"
# 磁盘使用
DISK_INFO=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"df -h ${REMOTE_PATH} 2>/dev/null | tail -1 | awk '{print \$5 \" used, \" \$4 \" free\"}' || echo 'N/A'")
echo -e " 磁盘使用: ${GREEN}${DISK_INFO}${NC}"
# 项目目录大小
REMOTE_SIZE=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"du -sh ${REMOTE_PATH} 2>/dev/null | awk '{print \$1}' || echo 'N/A'")
echo -e " 项目大小: ${GREEN}${REMOTE_SIZE}${NC}"
else
echo -e " ${RED}❌ 无法连接${NC}"
echo ""
echo -e "${YELLOW}请检查:${NC}"
echo -e " 1. 远程设备是否在线"
echo -e " 2. SSH 服务是否运行"
echo -e " 3. 网络连接是否正常"
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
return 1
fi
echo ""
echo -e "${CYAN}本地项目:${NC}"
LOCAL_FILES=$(find . -type f $EXCLUDE_ARGS 2>/dev/null | wc -l | xargs)
LOCAL_SIZE=$(du -sh . 2>/dev/null | awk '{print $1}')
echo -e " 文件数量: ${GREEN}${LOCAL_FILES}${NC}"
echo -e " 项目大小: ${GREEN}${LOCAL_SIZE}${NC}"
echo ""
echo -e "${CYAN}远程项目:${NC}"
REMOTE_FILES=$(ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"cd ${REMOTE_PATH} && find . -type f 2>/dev/null | wc -l" | xargs)
echo -e " 文件数量: ${GREEN}${REMOTE_FILES}${NC}"
echo -e " 项目大小: ${GREEN}${REMOTE_SIZE}${NC}"
echo ""
echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}
# 函数: 设置远程目录
setup_remote() {
echo -e "${BLUE}🔧 设置远程项目目录${NC}"
echo ""
echo -e "${YELLOW}在远程设备上创建目录: ${REMOTE_PATH}${NC}"
ssh -p $REMOTE_PORT ${REMOTE_USER}@${REMOTE_HOST} \
"mkdir -p ${REMOTE_PATH}"
if [ $? -eq 0 ]; then
echo -e "${GREEN}✅ 远程目录创建成功${NC}"
else
echo -e "${RED}❌ 远程目录创建失败${NC}"
return 1
fi
}
# 函数: 显示帮助
show_help() {
cat <<EOF
${GREEN}Remote Execute Claude - 远程开发工具${NC}
${BLUE}用法:${NC}
$0 <命令> [选项]
${BLUE}命令:${NC}
${GREEN}status${NC} 显示连接和同步状态
${GREEN}setup${NC} 在远程设备上创建项目目录
${GREEN}sync-to${NC} 同步本地文件到远程设备
${GREEN}sync-from${NC} 从远程设备同步文件到本地（会创建备份）
${GREEN}watch${NC} 监控文件变化并自动同步（Ctrl+C 停止）
${GREEN}exec <命令>${NC} 在远程设备上执行命令
${GREEN}read <文件>${NC} 读取远程文件内容
${GREEN}logs [模式]${NC} 查看远程日志文件（默认: *.log）
${GREEN}shell${NC} 打开远程 Shell 会话
${GREEN}help${NC} 显示此帮助信息
${BLUE}示例:${NC}
$0 status # 查看状态
$0 sync-to # 同步到远程
$0 watch # 启动自动同步
$0 exec "python main.py" # 执行 Python 脚本
$0 exec "pip install -r requirements.txt" # 安装依赖
$0 read "config.yaml" # 读取配置文件
$0 logs "app.log" # 查看应用日志
$0 shell # 打开远程终端
${BLUE}配置:${NC}
配置文件: ${YELLOW}.remote-config.json${NC}
修改配置后重新运行相应命令即可生效
${BLUE}Claude Code 集成:${NC}
在 Claude Code 中使用此工具，告诉 AI：
"我正在使用远程边缘设备开发。
使用 ./remote_toolkit.sh 与远程设备交互。
可用命令：
- ./remote_toolkit.sh exec [命令] - 远程执行
- ./remote_toolkit.sh sync-to - 同步到远程
- ./remote_toolkit.sh watch - 自动同步模式
当前任务：[描述任务]"
${BLUE}提示:${NC}
- 开发时建议使用 watch 模式，文件会自动同步
- sync-from 会自动创建本地备份到 .backup/ 目录
- 使用 shell 命令可以进入远程设备进行交互式操作
EOF
}
# 主命令分发
case "$1" in
status)
show_status
;;
setup)
if check_connection; then
setup_remote
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
sync-to)
if check_connection; then
sync_to_remote
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
sync-from)
if check_connection; then
sync_from_remote
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
exec)
if check_connection; then
shift
if [ -z "$1" ]; then
echo -e "${RED}❌ 错误: 请指定要执行的命令${NC}"
echo -e "${YELLOW}用法: $0 exec <命令>${NC}"
exit 1
fi
remote_exec "$@"
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
read)
if check_connection; then
remote_read "$2"
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
watch)
if check_connection; then
watch_sync
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
logs)
if check_connection; then
remote_logs "$2"
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
shell)
if check_connection; then
remote_shell
else
echo -e "${RED}❌ 无法连接到远程设备${NC}"
exit 1
fi
;;
help|--help|-h|"")
show_help
;;
*)
echo -e "${RED}❌ 未知命令: $1${NC}"
echo ""
show_help
exit 1
;;
esac6. CLAUDE.md.template
bash
# 项目背景：远程边缘设备开发
## 🎯 核心信息
本项目运行在**远程边缘设备**上，本地环境不具备运行条件。
**重要**:
- 本地只用于代码编辑
- 所有执行、测试都在远程设备上进行
- 文件修改会自动同步到远程设备（如果 watch 模式启动）
## 📡 远程设备配置
- **设备名称**: {{DEVICE_NAME}}
- **远程路径**: {{REMOTE_PATH}}
- **连接方式**: SSH (配置已完成)
- **同步状态**: 自动同步（watch 模式）或手动同步
配置文件位于: `.remote-config.json`
## 🛠️ 可用工具
### 核心命令：remote_toolkit.sh
所有与远程设备的交互都通过 `./remote_toolkit.sh` 进行：
``bash
# 基本操作
./remote_toolkit.sh status # 查看远程设备状态
./remote_toolkit.sh sync-to # 同步到远程
./remote_toolkit.sh sync-from # 从远程同步
./remote_toolkit.sh watch # 自动监控并同步
# 远程执行
./remote_toolkit.sh exec "命令" # 在远程设备上执行命令
./remote_toolkit.sh read "文件" # 读取远程文件
./remote_toolkit.sh logs "日志" # 查看远程日志
./remote_toolkit.sh shell # 打开远程终端
``
## 📋 工作流程
### 标准开发流程
1. **本地编辑**: 使用 Read、Write、Edit 工具正常编辑文件
2. **自动同步**: 如果 watch 模式运行中，修改会自动同步
3. **远程执行**: 使用 `exec` 命令在远程设备上运行和测试
4. **查看结果**: 使用 `logs` 或 `read` 查看输出和日志
### 示例工作流
**场景 1: 修改代码并测试**
``bash
# 1. 修改代码（使用 Write 或 Edit 工具）
# 2. 代码自动同步到远程（watch 模式）
# 3. 远程执行测试
./remote_toolkit.sh exec "python main.py"
# 4. 查看日志
./remote_toolkit.sh logs "app.log"
``
**场景 2: 调试问题**
``bash
# 1. 读取远程日志查看错误
./remote_toolkit.sh read "logs/error.log"
# 2. 修改代码修复问题
# 3. 同步并测试
./remote_toolkit.sh exec "python main.py"
``
**场景 3: 安装依赖**
``bash
# 在远程设备上安装 Python 包
./remote_toolkit.sh exec "pip install requests"
./remote_toolkit.sh exec "pip install -r requirements.txt"
``
## 💡 最佳实践
### ✅ 应该做的
1. **使用本地工具编辑文件**
- 使用 Read、Write、Edit 工具修改代码
- 文件会自动同步到远程（watch 模式下）
2. **远程执行所有运行命令**
``bash
./remote_toolkit.sh exec "python script.py"
./remote_toolkit.sh exec "pytest tests/"
./remote_toolkit.sh exec "npm start"
``
3. **使用 read 查看远程文件**
``bash
./remote_toolkit.sh read "config.yaml"
./remote_toolkit.sh read "logs/app.log"
``
4. **修改前先同步最新代码**
``bash
./remote_toolkit.sh sync-from # 获取远程最新版本
``
### ❌ 不应该做的
1. **不要在本地执行项目代码**
- ❌ 不要: `python main.py`（本地环境不支持）
- ✅ 应该: `./remote_toolkit.sh exec "python main.py"`
2. **不要假设本地环境可用**
- 本地可能缺少依赖、库、数据等
- 所有测试和运行都在远程进行
3. **不要直接在远程修改文件**
- 应该在本地修改后同步
- 保持"本地编辑 → 同步 → 远程执行"的流程
## 🔧 常见任务参考
### Python 项目
``bash
# 安装依赖
./remote_toolkit.sh exec "pip install -r requirements.txt"
# 运行主程序
./remote_toolkit.sh exec "python main.py"
# 运行测试
./remote_toolkit.sh exec "pytest tests/ -v"
# 查看 Python 版本
./remote_toolkit.sh exec "python --version"
# 检查已安装的包
./remote_toolkit.sh exec "pip list"
``
### Node.js 项目
``bash
# 安装依赖
./remote_toolkit.sh exec "npm install"
# 运行项目
./remote_toolkit.sh exec "npm start"
# 运行测试
./remote_toolkit.sh exec "npm test"
# 查看 Node 版本
./remote_toolkit.sh exec "node --version"
``
### Docker 项目
``bash
# 构建镜像
./remote_toolkit.sh exec "docker build -t myapp ."
# 运行容器
./remote_toolkit.sh exec "docker run -d -p 8080:8080 myapp"
# 查看容器
./remote_toolkit.sh exec "docker ps"
# 查看日志
./remote_toolkit.sh exec "docker logs container_id"
``
### 系统操作
``bash
# 查看系统信息
./remote_toolkit.sh exec "uname -a"
# 查看磁盘使用
./remote_toolkit.sh exec "df -h"
# 查看进程
./remote_toolkit.sh exec "ps aux | grep python"
# 查看端口占用
./remote_toolkit.sh exec "netstat -tulpn | grep 8080"
``
## 🐛 问题排查
### 如果代码没有同步
``bash
# 手动同步到远程
./remote_toolkit.sh sync-to
# 检查同步状态
./remote_toolkit.sh status
``
### 如果远程执行失败
``bash
# 检查远程连接
./remote_toolkit.sh status
# 查看详细错误
./remote_toolkit.sh exec "python main.py 2>&1"
# 查看日志文件
./remote_toolkit.sh logs "error.log"
``
### 如果需要交互式操作
``bash
# 打开远程 Shell
./remote_toolkit.sh shell
# 然后在远程终端中交互操作
``
## 📦 项目结构
``
项目目录/
├── .remote-config.json # 远程设备配置（本地工具文件，不同步）
├── remote_toolkit.sh # 远程工具脚本（本地工具文件，不同步）
├── CLAUDE.md # 本文件（本地工具文件，不同步）
├── .gitignore # Git 忽略文件
├── README.md # 项目说明（本地文档，不同步）
├── .backup/ # 同步备份（自动创建）
└── [项目文件] # 你的代码文件（会同步到远程）
``
**注意**: CLAUDE.md、README.md、remote_toolkit.sh 等工具文件仅保留在本地，不会同步到远程设备。
## 🚨 重要提醒
1. **文件会自动同步**: 在 watch 模式下，本地文件修改后会自动同步到远程（工具文件除外）
2. **执行在远程**: 所有代码执行、测试都在远程设备上进行
3. **日志在远程**: 程序输出的日志文件在远程设备上
4. **配置已完成**: SSH 连接和密钥已配置好，无需手动处理
5. **本地工具文件**: CLAUDE.md、README.md、remote_toolkit.sh 仅保留在本地
## 📞 获取帮助
``bash
# 查看所有可用命令
./remote_toolkit.sh help
# 查看当前状态
./remote_toolkit.sh status
``
---
**记住**: 本地是编辑环境，远程是运行环境。保持这个清晰的分离！7. 配置文件案例
以高通芯片为例：
gaotong.conf
bash
# 远程设备配置 - gaotong
DEVICE_NAME="gaotong"
DEVICE_IP="填写边缘设备ip"
DEVICE_USER="用户名"
DEVICE_PORT="边缘设备ssh远程端口"
SSH_KEY_PATH="本地电脑ssh key"
# 例如："/Users/admin/.ssh/edge_device_key"