graph TB
    subgraph "客户端设备"
        A[MacBook]
        B[iPad]
        C[手机]
        D[Chromebook]
    end

    subgraph "接入层"
        E[Tailscale VPN]
        F[SSH密钥认证]
        G[Cloudflare Tunnel]
    end

    subgraph "服务端环境"
        H[tmux会话管理]
        I[Claude Code CLI]
        J[项目代码仓库]
    end

    subgraph "基础设施"
        K[家庭服务器]
        L[VPS云主机]
        M[RunPod GPU云]
        N[Docker容器]
    end

    A --> E
    B --> E
    C --> F
    D --> G
    E --> H
    F --> H
    G --> H
    H --> I
    I --> J
    J --> K
    J --> L
    J --> M
    J --> N

# 更新系统
sudo apt update && sudo apt upgrade -y

# 安装Node.js 20+（Claude Code的运行时）
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# 验证版本
node --version  # 需要 >= 20.0.0
npm --version

# 安装Claude Code
npm install -g @anthropic-ai/claude-code

# 验证安装
claude --version

# 设置环境变量（写入shell配置文件持久化）
echo 'export ANTHROPIC_API_KEY="sk-ant-api03-xxxxx"' >> ~/.bashrc
source ~/.bashrc

# 启动Claude Code
claude

# 在本地机器完成OAuth认证后，将token复制到远程服务器
# 本地执行：
claude auth token

# 在远程服务器上：
claude auth login --token <your-token>

# 本地机器生成密钥（如果还没有的话）
ssh-keygen -t ed25519 -C "claude-dev@remote" -f ~/.ssh/claude_remote

# 将公钥复制到远程服务器
ssh-copy-id -i ~/.ssh/claude_remote.pub user@your-server-ip

# 配置SSH config简化连接
cat >> ~/.ssh/config << 'EOF'
Host claude-dev
    HostName your-server-ip
    User your-username
    IdentityFile ~/.ssh/claude_remote
    ServerAliveInterval 60
    ServerAliveCountMax 3
    TCPKeepAlive yes
EOF

# 现在可以直接连接
ssh claude-dev

# SSH连接到服务器
ssh claude-dev

# 进入项目目录
cd ~/my-project

# 启动Claude Code
claude

# 验证远程运行状态——在另一个终端执行
ssh claude-dev "ps aux | grep claude"

# 检查服务器SSH服务状态
sudo systemctl status sshd

# 检查防火墙规则
sudo ufw status
sudo ufw allow 22/tcp

# 检查是否在监听
ss -tlnp | grep :22

# 使用nvm管理Node版本
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
source ~/.bashrc
nvm install 20
nvm use 20

# 避免使用sudo安装npm包
npm config set prefix ~/.npm-global
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
npm install -g @anthropic-ai/claude-code

sequenceDiagram
    participant L as 本地笔记本
    participant S as 远程服务器
    participant T as tmux会话
    participant C as Claude Code

    L->>S: SSH连接
    S->>T: tmux attach
    T->>C: 运行Claude Code

    Note over L: 合上笔记本盖子
    L--xS: SSH断开
    Note over T,C: tmux中的Claude Code继续运行

    Note over L: 打开笔记本
    L->>S: 重新SSH连接
    S->>T: tmux attach
    T-->>L: 恢复完整会话
    Note over L,C: 所有上下文完整保留

# 安装tmux
sudo apt install -y tmux

# 创建优化配置文件
cat > ~/.tmux.conf << 'EOF'
# 前缀键改为Ctrl+a（比默认Ctrl+b更好按）
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# 鼠标支持（可以滚动、点击切换面板）
set -g mouse on

# 256色支持（Claude Code的UI需要）
set -g default-terminal "screen-256color"

# 窗口编号从1开始
set -g base-index 1
setw -g pane-base-index 1

# 分屏快捷键
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# 快速重载配置
bind r source-file ~/.tmux.conf \; display "配置已重载"

# 状态栏显示会话名称
set -g status-right '#[fg=green]#S #[fg=yellow]%H:%M'
EOF

# SSH连接
ssh claude-dev

# 创建名为"myproject"的tmux会话
tmux new -s myproject -d

# 在会话中启动Claude Code
tmux send-keys -t myproject 'cd ~/my-project && claude' Enter

# 连接到会话（可随时断开）
tmux attach -t myproject

# 断开会话（不停止）：按 Ctrl+a 然后按 d
# 重新连接：
tmux attach -t myproject

# 创建多个会话，每个项目一个
tmux new -s frontend -d
tmux new -s backend -d
tmux new -s infra -d

# 在每个会话中启动Claude Code
tmux send-keys -t frontend 'cd ~/frontend && claude' Enter
tmux send-keys -t backend 'cd ~/backend && claude' Enter
tmux send-keys -t infra 'cd ~/infra && claude' Enter

# 在会话之间切换
tmux switch -t frontend
tmux switch -t backend

# 列出所有会话
tmux ls

# 创建会话
tmux new -s dev

# Ctrl+a 然后按 | 垂直分屏
# 左边运行Claude Code，右边运行测试
# 左面板
claude

# 切换到右面板（Ctrl+a 然后方向键）
# 右面板
npm test -- --watch

cat > ~/start-claude-dev.sh << 'SCRIPT'
#!/bin/bash
# Claude Code远程开发环境启动脚本

PROJECTS=("$HOME/project-api" "$HOME/project-web" "$HOME/project-infra")
SESSIONS=("api" "web" "infra")

# 创建tmux会话
for i in "${!SESSIONS[@]}"; do
    session="${SESSIONS[$i]}"
    project="${PROJECTS[$i]}"

    # 检查会话是否已存在
    if ! tmux has-session -t "$session" 2>/dev/null; then
        tmux new-session -d -s "$session" -c "$project"
        tmux send-keys -t "$session" 'claude' Enter
        echo "✓ 启动会话: $session -> $project"
    else
        echo "- 会话已存在: $session"
    fi
done

echo ""
echo "所有会话已就绪。连接方式："
echo "  tmux attach -t api     # 连接API项目"
echo "  tmux attach -t web     # 连接Web项目"
echo "  tmux attach -t infra   # 连接基础设施项目"
echo "  tmux ls                # 查看所有会话"
SCRIPT

chmod +x ~/start-claude-dev.sh

# 创建监控面板
tmux new -s monitor -d

# 上半部分：查看Claude Code进程
tmux send-keys -t monitor 'watch -n 5 "ps aux | grep claude | grep -v grep"' Enter

# 分屏
tmux split-window -v -t monitor

# 下半部分：查看资源使用
tmux send-keys -t monitor 'htop' Enter

# 连接监控面板
tmux attach -t monitor

# Dockerfile.claude-dev
FROM node:20-slim

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    git \
    curl \
    tmux \
    vim \
    python3 \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# 安装Claude Code
RUN npm install -g @anthropic-ai/claude-code

# 创建非root用户（安全最佳实践）
RUN useradd -m -s /bin/bash claude-dev
USER claude-dev
WORKDIR /home/claude-dev/workspace

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD which claude || exit 1

# 默认启动交互式shell
CMD ["/bin/bash"]

# docker-compose.yml
version: '3.8'

services:
  claude-dev:
    build:
      context: .
      dockerfile: Dockerfile.claude-dev
    container_name: claude-dev-env
    volumes:
      # 挂载项目代码（双向同步）
      - ./workspace:/home/claude-dev/workspace
      # 持久化Claude Code配置
      - claude-config:/home/claude-dev/.claude
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    # 资源限制
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 8G
    # SSH端口映射（远程访问用）
    ports:
      - "2222:22"
    # 保持容器运行
    stdin_open: true
    tty: true
    restart: unless-stopped

volumes:
  claude-config:

# 构建并启动
docker compose up -d --build

# 进入容器
docker exec -it claude-dev-env bash

# 在容器内启动Claude Code
claude

# 或者一行命令直接进入Claude Code
docker exec -it claude-dev-env claude

# 查看容器日志
docker compose logs -f claude-dev

# 停止（数据保留在volume中）
docker compose down

# 完全清理（包括数据）
docker compose down -v

# 在容器内安装SSH服务
apt-get update && apt-get install -y openssh-server
echo "claude-dev:your-password" | chpasswd

# 启动SSH
service ssh start

# 从外部连接
ssh -p 2222 claude-dev@your-server-ip

# 挂载SSH密钥（只读）
# 在docker-compose.yml中添加：
volumes:
  - ~/.ssh:/home/claude-dev/.ssh:ro

# 或者使用Git credential helper
git config --global credential.helper store

# 确保容器内用户UID与宿主机匹配
# 修改Dockerfile：
ARG USER_ID=1000
ARG GROUP_ID=1000
RUN useradd -m -u ${USER_ID} -g ${GROUP_ID} claude-dev

#!/bin/bash
# deploy-claude-vps.sh — VPS一键部署Claude Code远程开发环境
# 用法：curl -fsSL <this-script-url> | bash

set -euo pipefail

echo "=== Claude Code VPS一键部署 ==="

# 1. 系统更新
echo "[1/7] 更新系统..."
sudo apt update && sudo apt upgrade -y

# 2. 安装基础工具
echo "[2/7] 安装基础工具..."
sudo apt install -y \
    git curl wget tmux htop \
    build-essential python3 \
    fail2ban ufw

# 3. 安装Node.js
echo "[3/7] 安装Node.js..."
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# 4. 安装Claude Code
echo "[4/7] 安装Claude Code..."
npm install -g @anthropic-ai/claude-code

# 5. 配置防火墙
echo "[5/7] 配置防火墙..."
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp   # SSH
sudo ufw allow from 10.0.0.0/8  # 内网访问
sudo ufw --force enable

# 6. 配置fail2ban防暴力破解
echo "[6/7] 配置fail2ban..."
sudo tee /etc/fail2ban/jail.local > /dev/null << 'EOF'
[sshd]
enabled = true
port = 22
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
findtime = 600
EOF
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

# 7. 创建tmux启动脚本
echo "[7/7] 创建启动脚本..."
cat > ~/start-claude.sh << 'LAUNCH'
#!/bin/bash
SESSION="claude-$(date +%m%d)"
if ! tmux has-session -t "$SESSION" 2>/dev/null; then
    tmux new-session -d -s "$SESSION"
fi
tmux attach -t "$SESSION"
LAUNCH
chmod +x ~/start-claude.sh

echo ""
echo "=== 部署完成 ==="
echo "下一步："
echo "  1. 设置API Key: export ANTHROPIC_API_KEY='your-key'"
echo "  2. 克隆项目: git clone <repo-url> ~/project"
echo "  3. 启动开发: ~/start-claude.sh"

# 1. 禁用密码登录，只允许密钥认证
sudo sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sudo sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config
sudo systemctl restart sshd

# 2. 更改SSH默认端口（减少扫描攻击）
sudo sed -i 's/Port 22/Port 2222/' /etc/ssh/sshd_config
sudo ufw allow 2222/tcp
sudo systemctl restart sshd
# 客户端SSH config也要更新端口

# 3. 创建专用开发用户（不用root）
sudo useradd -m -s /bin/bash claude-dev
sudo usermod -aG sudo claude-dev

# 4. 设置自动安全更新
sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

# Step 1: 在RunPod上创建Pod
# 选择模板：RunPod PyTorch 2.0+
# 选择GPU：RTX 4090或A100（根据需求）
# 开启SSH访问：Enable SSH

# Step 2: SSH连接到Pod
ssh root@<pod-ip> -p <port> -i <your-key>

# Step 3: 安装Claude Code
curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
apt-get install -y nodejs
npm install -g @anthropic-ai/claude-code

# Step 4: 配置认证
export ANTHROPIC_API_KEY="sk-ant-xxxxx"

# Step 5: 启动tmux + Claude Code
tmux new -s gpu-dev
cd /workspace
claude

# 安装runclaude
pip install runclaude

# 配置RunPod API Key
export RUNPOD_API_KEY="your-runpod-key"

# 通过Claude Code Skill自动创建和管理Pod
# 在Claude Code中输入：
# "Create a RunPod pod with RTX 4090, install PyTorch 2.1, and set up my ML project"

# 自动空闲检测脚本
cat > ~/idle-watchdog.sh << 'EOF'
#!/bin/bash
# 检测Claude Code空闲时间，自动通知（不自动关机，避免数据丢失）

IDLE_THRESHOLD=1800  # 30分钟（秒）
LOG_FILE="/var/log/claude-idle.log"

while true; do
    # 检查Claude Code进程
    if ! pgrep -f "claude" > /dev/null; then
        echo "$(date): Claude Code未运行" >> "$LOG_FILE"
    fi

    # 检查GPU利用率
    GPU_UTIL=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits | head -1)
    if [ "$GPU_UTIL" -lt 5 ]; then
        echo "$(date): GPU空闲 ($GPU_UTIL%), 考虑关机节省成本" >> "$LOG_FILE"
    fi

    sleep 300  # 每5分钟检查一次
done
EOF
chmod +x ~/idle-watchdog.sh

# 服务器端安装
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# 本地机器安装
# macOS: brew install tailscale
# 或从App Store安装

# 验证连接
tailscale status

# 通过Tailscale IP连接（不再需要公网IP）
ssh [email protected]

# 安装cloudflared
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg
echo "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/cloudflared.list
sudo apt update && sudo apt install -y cloudflared

# 登录Cloudflare
cloudflared tunnel login

# 创建隧道
cloudflared tunnel create claude-dev
cloudflared tunnel route dns claude-dev dev.yourdomain.com

# 配置隧道
cat > ~/.cloudflared/config.yml << 'EOF'
tunnel: claude-dev
credentials-file: /home/you/.cloudflared/<tunnel-id>.json

ingress:
  - hostname: dev.yourdomain.com
    service: ssh://localhost:22
  - service: http_status:404
EOF

# 启动隧道
cloudflared tunnel run claude-dev

# 服务器端安装
sudo apt install -y mosh

# 客户端安装
# macOS: brew install mosh
# Ubuntu: sudo apt install mosh

# 连接（替代SSH）
mosh claude-dev

# 如果需要指定SSH端口
mosh --ssh="ssh -p 2222" claude-dev

graph LR
    A[购买VPS/GPU云] --> B[安装系统依赖]
    B --> C[安装Claude Code]
    C --> D[配置Tailscale]
    D --> E[配置tmux]
    E --> F[部署项目代码]
    F --> G[编写CLAUDE.md]
    G --> H[启动远程开发]

    subgraph "日常使用流程"
        H --> I[SSH连接]
        I --> J[tmux attach]
        J --> K[继续Claude Code会话]
        K --> L[Ctrl+a d 断开]
        L --> I
    end

#!/bin/bash
# server-setup.sh

# 系统更新
sudo apt update && sudo apt upgrade -y

# 安装开发工具
sudo apt install -y git tmux mosh htop build-essential python3 python3-pip

# 安装Node.js + Claude Code
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
npm install -g @anthropic-ai/claude-code

# 安装Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# 配置tmux
cat > ~/.tmux.conf << 'TMUX'
set -g prefix C-a
set -g mouse on
set -g default-terminal "screen-256color"
set -g base-index 1
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
TMUX

# 设置API Key（替换为你的真实Key）
echo 'export ANTHROPIC_API_KEY="sk-ant-xxxxx"' >> ~/.bashrc
source ~/.bashrc

# 克隆项目
git clone https://github.com/your-org/your-project.git ~/project
cd ~/project

# 创建项目级CLAUDE.md
cat > CLAUDE.md << 'CLAUDE'
# 项目：ML Pipeline

## 项目结构
- src/training/ — 模型训练代码
- src/inference/ — 推理服务
- tests/ — 单元测试
- notebooks/ — 实验笔记本

## 开发规则
- 所有新函数必须有docstring
- 使用Black格式化代码
- 提交前运行: pytest tests/
- GPU训练使用CUDA 12.1

## 常用命令
- 训练: python src/training/train.py --config config.yaml
- 测试: pytest tests/ -v
- 格式化: black src/ tests/
CLAUDE

echo "服务器配置完成！"

# 创建会话
tmux new -s ml-project -d

# 在会话中启动Claude Code
tmux send-keys -t ml-project 'cd ~/project && claude' Enter

# 确保Tailscale已连接
tailscale status

# 获取服务器Tailscale IP（或使用MagicDNS名称）
# ssh user@your-server-name

# 通过Tailscale SSH连接并接入tmux
ssh user@ml-server 'tmux attach -t ml-project'

# Termius/Blink Shell配置
Host: ml-server (Tailscale名称或IP)
User: your-username
Key: 导入SSH私钥

# 连接后执行
tmux attach -t ml-project

# 早晨：从MacBook开始工作
ssh user@ml-server
tmux attach -t ml-project
# ... 使用Claude Code开发 ...
# 合上笔记本（Ctrl+a d 或直接断开）

# 通勤中：从iPad继续
# 打开Termius -> 连接 -> tmux attach
# Claude Code会话完整保留，继续上次的工作

# 晚上：从手机紧急处理
mosh user@ml-server
tmux attach -t ml-project
# 处理完毕后断开

# 项目名

## 远程开发信息
- 服务器：ml-server (Tailscale)
- tmux会话：ml-project
- GPU：NVIDIA RTX 4090
- CUDA：12.1

## 项目结构
...

## 远程开发注意事项
- 长时间运行的任务使用tmux保持
- GPU训练任务用 nvidia-smi 监控
- 代码修改后自动运行测试验证
- 不要在/tmp目录存放重要文件（容器重启会丢失）

# 本地启动会话
claude

# 在Claude Code内部使用remote-control
# 将当前会话移交到远程服务器继续
/remote-control ssh user@server --session current

# 会话状态完整保留：
# - 文件上下文
# - 对话历史
# - 工具状态
# - 工作目录

#!/bin/bash
# parallel-agents.sh — 并行启动多个Claude Code Agent

# 使用git worktree创建隔离的工作目录
REPO_ROOT="$HOME/my-project"
TASKS=("refactor-auth" "add-tests" "update-docs" "fix-logging")

for task in "${TASKS[@]}"; do
    # 为每个任务创建worktree
    cd "$REPO_ROOT"
    git worktree add "$HOME/worktrees/$task" -b "agent/$task" 2>/dev/null || true

    # 创建独立tmux会话
    tmux new-session -d -s "agent-$task" -c "$HOME/worktrees/$task"

    # 在会话中启动Claude Code并执行任务
    tmux send-keys -t "agent-$task" \
        "claude -p 'Work on task: $task. Follow CLAUDE.md rules. Make minimal, focused changes.'" \
        Enter

    echo "✓ Agent启动: $task"
done

echo "所有Agent已启动。监控命令："
echo "  tmux ls                    # 查看所有会话"
echo "  tmux attach -t agent-refactor-auth  # 查看特定Agent"

# 非交互式执行单个任务
claude -p "Add error handling to all API endpoints in src/routes/" \
    --allowedTools "Edit,Read,Bash" \
    --output-format json > result.json

# 批量执行多个任务
cat > tasks.txt << 'EOF'
Refactor the authentication middleware to use JWT
Add unit tests for the payment module
Update all dependencies to latest stable versions
EOF

while IFS= read -r task; do
    echo "执行任务: $task"
    claude -p "$task" --allowedTools "Edit,Read,Bash,Glob,Grep"
    echo "---"
done < tasks.txt

# 创建监控脚本
cat > ~/claude-monitor.sh << 'MONITOR'
#!/bin/bash
ALERT_EMAIL="[email protected]"
CPU_THRESHOLD=90
MEM_THRESHOLD=85

check_resources() {
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d. -f1)
    local mem_usage=$(free | grep Mem | awk '{printf("%.0f", $3/$2 * 100)}')

    if [ "$cpu_usage" -gt "$CPU_THRESHOLD" ] || [ "$mem_usage" -gt "$MEM_THRESHOLD" ]; then
        echo "⚠ 资源告警: CPU=${cpu_usage}%, MEM=${mem_usage}%"
        # 可以集成Slack/Discord通知
    fi

    # 检查Claude Code进程数
    local claude_count=$(pgrep -f "claude" | wc -l)
    echo "$(date): Claude进程数=$claude_count, CPU=${cpu_usage}%, MEM=${mem_usage}%"
}

while true; do
    check_resources
    sleep 60
done
MONITOR
chmod +x ~/claude-monitor.sh

graph TD
    A[需要远程开发?] --> B{有GPU需求?}
    B -->|是| C{训练还是推理?}
    B -->|否| D{团队还是个人?}

    C -->|训练| E[RunPod/Lambda GPU云]
    C -->|推理| F[VPS + Docker]

    D -->|团队| G[共享VPS + Docker]
    D -->|个人| H{在家还是外出?}

    H -->|在家| I[家庭服务器 + Tailscale]
    H -->|频繁外出| J[云VPS + Mosh + tmux]

    E --> K[tmux + nvidia-smi监控]
    F --> L[tmux + Claude Code]
    G --> M[Docker Compose + 共享镜像]
    I --> N[SSH + tmux]
    J --> O[Tailscale + tmux + mosh]