🦞 基于 OpenClaw + Claude Code 的
端到端研发自动化系统

# 更新软件包列表
sudo apt update && sudo apt upgrade -y

# 安装基础工具
sudo apt install -y \
    git \
    curl \
    wget \
    vim \
    net-tools \
    jq \
    unzip \
    software-properties-common \
    apt-transport-https \
    ca-certificates \
    gnupg \
    lsb-release

# 使用 NodeSource 安装 Node.js 22
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs

# 验证安装
node --version  # 应显示 v22.x.x
npm --version   # 应显示 10.x.x

# 配置 npm 国内镜像（可选，加速下载）
npm config set registry https://registry.npmmirror.com

# 添加 Docker GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加 Docker 仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

# 启动 Docker 并设置开机自启
sudo systemctl start docker
sudo systemctl enable docker

# 将当前用户加入 docker 组（避免每次使用 sudo）
sudo usermod -aG docker $USER

# 验证安装
docker --version
docker run hello-world

# 下载 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 赋予执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker-compose --version

# 执行官方安装脚本
curl -fsSL https://openclaw.ai/install.sh | bash

# 安装完成后运行新手引导
openclaw onboard --install-daemon

# PowerShell 执行
iwr -useb https://openclaw.ai/install.ps1 | iex

# 使用 npm 全局安装
npm install -g openclaw

# 或使用 pnpm（推荐）
pnpm add -g openclaw

# 国内用户可使用淘宝镜像
npm install -g openclaw --registry=https://registry.npmmirror.com

# 主配置文件位置
~/.openclaw/openclaw.json

# 工作区目录
~/.openclaw/workspace/
├── AGENTS.md          # 指令说明
├── USER.md            # 偏好设置
├── MEMORY.md          # 长期记忆
├── HEARTBEAT.md       # 检查清单
├── SOUL.md            # 人格/语气
└── IDENTITY.md        # 名称/主题

# 认证配置文件
~/.openclaw/agents/<agentId>/auth-profiles.json

# 向量索引存储
~/.openclaw/memory/<cid>.sqlite

# 全局共享技能
~/.openclaw/skills/

# 日志文件
/tmp/openclaw/*.log

# 创建 docker-compose.yml
version: '3.8'
services:
  openclaw:
    image: openclaw/openclaw:latest
    container_name: openclaw
    ports:
      - "18789:18789"
    volumes:
      - ./workspace:/app/workspace
      - ./config:/app/config
    environment:
      - OPENCLAW_MODEL=claude-sonnet-4.5
      - OPENCLAW_API_KEY=${ANTHROPIC_API_KEY}
    restart: unless-stopped

# 启动服务
docker-compose up -d

# 访问 Web UI
# http://localhost:18789

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

# 或使用 Homebrew (macOS)
brew install claude-code

# 配置 API Key
export ANTHROPIC_API_KEY="your-api-key-here"

# 验证安装
claude --version

# ~/.openclaw/openclaw.json
{
  "agents": {
    "coding_agent": {
      "model": "claude-sonnet-4.5",
      "tools": [
        {
          "name": "claude_code",
          "enabled": true,
          "config": {
            "api_key": "${ANTHROPIC_API_KEY}",
            "max_tokens": 8192,
            "temperature": 0.7
          }
        }
      ]
    }
  }
}

# 场景 1: 根据 PRD 生成代码
claude "基于以下 PRD 需求，生成 Python FastAPI 后端代码：
[粘贴 PRD 内容]"

# 场景 2: 代码重构
claude "重构这个函数，提高可读性和性能"

# 场景 3: 生成单元测试
claude "为这个模块编写 pytest 单元测试，覆盖率达到 90%"

# 场景 4: Bug 修复
claude "分析这个错误日志并提供修复方案：
[粘贴错误日志]"

# 创建 Jenkins 数据目录
mkdir -p ~/jenkins_data

# 运行 Jenkins 容器
docker run -d \
  --name jenkins \
  -p 8080:8080 \
  -p 50000:50000 \
  -v ~/jenkins_data:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v $(which docker):/usr/bin/docker \
  jenkins/jenkins:lts-jdk17

# 获取初始管理员密码
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

# 访问 Jenkins Web UI
# http://localhost:8080

pipeline {
    agent any
    
    tools {
        nodejs 'NodeJS-22'
        python 'Python-3.12'
    }
    
    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        IMAGE_NAME = 'myapp'
        KUBE_CONFIG = credentials('kubeconfig')
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }
        
        stage('Install Dependencies') {
            steps {
                sh 'npm ci'
                sh 'pip install -r requirements.txt'
            }
        }
        
        stage('Code Quality') {
            steps {
                sh 'npm run lint'
                sh 'python -m pylint src/'
            }
        }
        
        stage('Unit Test') {
            steps {
                sh 'npm test'
                sh 'pytest tests/unit --cov=src --cov-report=xml'
            }
            post {
                always {
                    junit 'reports/*.xml'
                    publishCoverage adapters: [coberturaAdapter('coverage.xml')]
                }
            }
        }
        
        stage('Build Docker Image') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}")
                }
            }
        }
        
        stage('Integration Test') {
            steps {
                sh 'pytest tests/integration'
                sh 'npm run test:e2e'
            }
        }
        
        stage('Push to Registry') {
            steps {
                script {
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-credentials') {
                        docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}").push()
                        docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}").push('latest')
                    }
                }
            }
        }
        
        stage('Deploy to K8S') {
            steps {
                sh '''
                    kubectl apply -f k8s/deployment.yaml
                    kubectl set image deployment/myapp myapp=${DOCKER_REGISTRY}/${IMAGE_NAME}:${BUILD_NUMBER}
                    kubectl rollout status deployment/myapp
                '''
            }
        }
        
        stage('UI Automation Test') {
            steps {
                sh 'playwright test --reporter=html'
            }
            post {
                always {
                    archiveArtifacts artifacts: 'playwright-report/**/*'
                }
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline completed successfully!'
            // 发送通知（飞书/钉钉/邮件）
        }
        failure {
            echo 'Pipeline failed!'
            // 发送失败通知
        }
    }
}

# 后端服务 Dockerfile (Python)
FROM python:3.12-slim as builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

FROM python:3.12-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# 前端服务 Dockerfile (Node.js)
FROM node:22-alpine as builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-backend
  labels:
    app: myapp
    component: backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      component: backend
  template:
    metadata:
      labels:
        app: myapp
        component: backend
    spec:
      containers:
      - name: backend
        image: registry.example.com/myapp-backend:latest
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-backend-service
spec:
  selector:
    app: myapp
    component: backend
  ports:
  - port: 80
    targetPort: 8000
  type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: myapp-backend-service
            port:
              number: 80

myapp-chart/
├── Chart.yaml
├── values.yaml
├── values-production.yaml
└── templates/
    ├── _helpers.tpl
    ├── deployment.yaml
    ├── service.yaml
    ├── ingress.yaml
    ├── configmap.yaml
    └── secrets.yaml

# 打包 Helm Chart
helm package myapp-chart

# 安装应用
helm install myapp ./myapp-chart -f values-production.yaml

# 升级应用
helm upgrade myapp ./myapp-chart -f values-production.yaml

# 使用 KubeKey 安装 KubeSphere + Kubernetes
curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.13 sh -
chmod +x kk

# 创建集群配置
./kk create config --with-kubernetes v1.28.5 --with-kubesphere v3.4.0

# 编辑 config-sample.yaml 配置节点信息

# 开始安装
./kk create cluster -f config-sample.yaml -y

# 访问 KubeSphere Dashboard
# https://<master-node-ip>:30880

# tests/unit/test_api.py
import pytest
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_main():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

@pytest.mark.asyncio
async def test_create_user():
    response = client.post("/users", json={
        "username": "testuser",
        "email": "test@example.com"
    })
    assert response.status_code == 201
    assert response.json()["username"] == "testuser"

# 运行测试
# pytest tests/unit --cov=src --cov-report=html

# tests/integration/test_workflow.py
import pytest
import requests

BASE_URL = "http://localhost:8000"

def test_full_workflow():
    # 1. 创建用户
    user_response = requests.post(f"{BASE_URL}/users", json={
        "username": "integration_test",
        "email": "test@example.com"
    })
    assert user_response.status_code == 201
    user_id = user_response.json()["id"]
    
    # 2. 创建订单
    order_response = requests.post(f"{BASE_URL}/orders", json={
        "user_id": user_id,
        "product": "test_product"
    })
    assert order_response.status_code == 201
    
    # 3. 查询订单
    get_order = requests.get(f"{BASE_URL}/orders/{order_response.json()['id']}")
    assert get_order.status_code == 200

// tests/e2e/example.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Login Flow', () => {
  test('should login successfully', async ({ page }) => {
    await page.goto('http://localhost:3000/login');
    
    await page.fill('[data-testid="username"]', 'admin');
    await page.fill('[data-testid="password"]', 'password123');
    await page.click('[data-testid="submit"]');
    
    await expect(page).toHaveURL('http://localhost:3000/dashboard');
    await expect(page.locator('text=Welcome')).toBeVisible();
  });

  test('should show validation errors', async ({ page }) => {
    await page.goto('http://localhost:3000/login');
    await page.click('[data-testid="submit"]');
    
    await expect(page.locator('text=Username is required')).toBeVisible();
  });
});

// playwright.config.ts
import type { PlaywrightTestConfig } from '@playwright/test';

const config: PlaywrightTestConfig = {
  projects: [
    { name: 'chromium', use: { browserName: 'chromium' } },
    { name: 'firefox', use: { browserName: 'firefox' } },
    { name: 'webkit', use: { browserName: 'webkit' } },
  ],
  reporter: [['html'], ['junit', { outputFile: 'results.xml' }]],
  use: {
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
};

export default config;

# 使用 OpenClaw 创建新项目
openclaw "创建一个全栈项目，包含：
- 后端：Python FastAPI
- 前端：React + TypeScript
- 数据库：PostgreSQL
- 包含完整的 CI/CD 配置"

# 或手动创建项目结构
mkdir myproject && cd myproject
mkdir -p backend frontend tests docs k8s

# 初始化 Git
git init
git commit --allow-empty -m "Initial commit"

cd backend

# 创建虚拟环境
python -m venv venv
source venv/bin/activate

# 安装依赖
pip install fastapi uvicorn sqlalchemy alembic \
    pytest pytest-cov python-jose passlib

# 生成 requirements.txt
pip freeze > requirements.txt

# 初始化 Alembic 迁移
alembic init alembic

# 创建 FastAPI 主应用
cat > main.py << 'EOF'
from fastapi import FastAPI

app = FastAPI(title="MyApp API")

@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.get("/health")
async def health():
    return {"status": "healthy"}
EOF

cd frontend

# 使用 Vite 创建 React + TypeScript 项目
npm create vite@latest . -- --template react-ts

# 安装依赖
npm install react-router-dom axios @tanstack/react-query

# 安装开发依赖
npm install -D @playwright/test @testing-library/react

# 初始化 Playwright
npx playwright install
npx playwright install-deps

# .env.example (后端)
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
SECRET_KEY=your-secret-key-here
API_PREFIX=/api/v1

# .env.example (前端)
VITE_API_URL=http://localhost:8000/api/v1
VITE_APP_TITLE=My Application

# docker-compose.dev.yml
version: '3.8'
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    ports:
      - "5432:5432"
  
  backend:
    build: ./backend
    ports:
      - "8000:8000"
    depends_on:
      - db
  
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"

# OpenClaw 飞书机器人配置
# ~/.openclaw/channels/feishu.json
{
  "channel": "feishu",
  "app_id": "cli_xxxxxxxxxxxxx",
  "app_secret": "xxxxxxxxxxxxx",
  "webhook_url": "https://open.feishu.cn/open-apis/bot/v2/hook/xxx",
  "approval_enabled": true,
  "approval_nodes": [
    "prd_review",
    "tech_design_review",
    "code_review",
    "deployment_approval"
  ]
}

# 审批通知消息格式
{
  "msg_type": "interactive",
  "card": {
    "elements": [{
      "tag": "div",
      "text": {
        "content": "**待审批**: PRD 文档已生成\n项目：XXX 系统\n请点击查看并审批"
      }
    }],
    "actions": [{
      "tag": "button",
      "text": { "content": "查看详情" },
      "url": "http://jenkins/job/prd-review"
    }]
  }
}

# OpenClaw 日志
openclaw logs --follow

# Docker 容器日志
docker logs -f <container-id>

# Kubernetes Pod 日志
kubectl logs -f <pod-name> -n <namespace>

# Jenkins 构建日志
# 通过 Web UI 查看或 API 获取

# 系统日志
journalctl -u docker -f
journalctl -u kubelet -f