Bridge 与远程集成

// bridgeMessaging.ts: JSON 消息协议
type BridgeMessage =
  | BridgeRequest
  | BridgeResponse
  | BridgeNotification;

interface BridgeRequest {
  type: "request";
  id: string;
  method: string;
  params: Record<string, unknown>;
}

interface BridgeResponse {
  type: "response";
  id: string;           // 对应 request.id
  result?: unknown;
  error?: { code: number; message: string };
}

interface BridgeNotification {
  type: "notification";
  method: string;
  params: Record<string, unknown>;
}

// bridgeMain.ts: Bridge 主循环
class BridgeMain {
  private transport: BridgeTransport;
  private handlers = new Map<
    string,
    (params: Record<string, unknown>) => Promise<unknown>
  >();

  async start(port: number): Promise<void> {
    this.transport = await createTransport(port);

    // 注册内置处理器
    this.handlers.set(
      "chat/send", this.handleChatSend.bind(this)
    );
    this.handlers.set(
      "file/read", this.handleFileRead.bind(this)
    );
    this.handlers.set(
      "permission/request",
      this.handlePermission.bind(this)
    );

    // 主消息循环
    while (true) {
      const msg = await this.transport.receive();
      if (msg.type === "request") {
        this.handleRequest(msg);
      }
    }
  }

  private async handleRequest(
    req: BridgeRequest
  ): Promise<void> {
    const handler = this.handlers.get(req.method);
    if (!handler) {
      this.transport.send({
        type: "response",
        id: req.id,
        error: { code: -1, message: "Unknown method" }
      });
      return;
    }

    try {
      const result = await handler(req.params);
      this.transport.send({
        type: "response",
        id: req.id,
        result
      });
    } catch (err) {
      this.transport.send({
        type: "response",
        id: req.id,
        error: {
          code: -1,
          message: String(err)
        }
      });
    }
  }

  // 向 IDE 发送通知（无需响应）
  notify(method: string, params: Record<string, unknown>): void {
    this.transport.send({
      type: "notification",
      method,
      params
    });
  }
}

// jwtUtils.ts: JWT 认证工具
interface JwtPayload {
  sub: string;          // 用户 ID
  deviceId: string;     // 设备指纹
  workspaceId: string;  // 工作区 ID
  exp: number;          // 过期时间
  iat: number;          // 签发时间
}

function createJwt(
  payload: JwtPayload,
  secret: string
): string {
  const header = { alg: "HS256", typ: "JWT" };
  const headerB64 = base64url(JSON.stringify(header));
  const payloadB64 = base64url(JSON.stringify(payload));
  const signature = hmacSHA256(
    headerB64 + "." + payloadB64,
    secret
  );
  return headerB64 + "." + payloadB64 + "." + signature;
}

// trustedDevice.ts: 设备信任
class TrustedDeviceManager {
  private trustedDevices: Set<string>;

  isTrusted(deviceId: string): boolean {
    return this.trustedDevices.has(deviceId);
  }

  async trustDevice(deviceId: string): Promise<void> {
    this.trustedDevices.add(deviceId);
    await this.persistToFile();
  }
}

// workSecret.ts: 工作区密钥
function getWorkSecret(
  workspacePath: string
): string {
  const secretPath = join(
    workspacePath, ".claude", "work_secret"
  );
  if (existsSync(secretPath)) {
    return readFileSync(secretPath, "utf-8");
  }
  // 首次使用，生成新密钥
  const secret = randomBytes(32).toString("hex");
  writeFileSync(secretPath, secret);
  return secret;
}

// utils/teleport/gitBundle.ts: Git 仓库打包
async function createGitBundle(
  repoPath: string
): Promise<Buffer> {
  // 1. 收集未推送的提交
  const unpushed = await execGit(
    repoPath, "log", "--oneline", "@{u}..HEAD"
  );

  // 2. 收集未暂存的更改
  const stashResult = await execGit(
    repoPath, "stash", "create"
  );

  // 3. 创建 bundle
  const bundle = await execGit(
    repoPath, "bundle", "create", "-",
    "--all", "--not", "--remotes"
  );

  return bundle;
}

// utils/teleport/environments.ts: 环境快照
interface EnvironmentSnapshot {
  nodeVersion: string;
  pythonVersion: string;
  envVars: Record<string, string>;
  gitConfig: Record<string, string>;
  installedTools: string[];
  timestamp: number;
}

async function captureEnvironment(): Promise<EnvironmentSnapshot> {
  return {
    nodeVersion: process.version,
    pythonVersion: await getCommandOutput("python3 --version"),
    envVars: filterSafeEnvVars(process.env),
    gitConfig: await getGitConfig(),
    installedTools: await detectInstalledTools(),
    timestamp: Date.now()
  };
}

// utils/computerUse: AI 计算机操控
interface ScreenCapture {
  width: number;
  height: number;
  data: Buffer;         // PNG 图像数据
  timestamp: number;
}

interface ClickAction {
  type: "click";
  x: number;
  y: number;
  button: "left" | "right" | "middle";
}

interface TypeAction {
  type: "type";
  text: string;
  modifiers?: string[];
}

type ComputerAction =
  | ClickAction
  | TypeAction
  | { type: "screenshot" }
  | { type: "scroll"; x: number; y: number; delta: number };

// Computer Use MCP 服务器
class ComputerUseMcpServer {
  getTools(): ToolDefinition[] {
    return [
      {
        name: "computer_screenshot",
        description: "截取当前屏幕截图",
        inputSchema: { type: "object", properties: {} }
      },
      {
        name: "computer_click",
        description: "在指定坐标点击",
        inputSchema: {
          type: "object",
          properties: {
            x: { type: "number" },
            y: { type: "number" },
            button: { type: "string" }
          }
        }
      },
      {
        name: "computer_type",
        description: "输入文本内容",
        inputSchema: {
          type: "object",
          properties: {
            text: { type: "string" }
          }
        }
      }
    ];
  }

  async handleTool(
    name: string,
    params: Record<string, unknown>
  ): Promise<unknown> {
    switch (name) {
      case "computer_screenshot":
        return await captureScreen();
      case "computer_click":
        return await performClick(
          params.x as number,
          params.y as number,
          (params.button as string) || "left"
        );
      case "computer_type":
        return await typeText(params.text as string);
      default:
        throw new Error("Unknown tool: " + name);
    }
  }
}

// remote/RemoteSessionManager.ts: 远程会话管理
class RemoteSessionManager {
  private sessions = new Map<string, RemoteSession>();

  async createSession(
    config: RemoteConfig
  ): Promise<RemoteSession> {
    // 1. 建立 WebSocket 连接
    const ws = new SessionsWebSocket(config.endpoint);
    await ws.connect();

    // 2. JWT 认证
    const token = createJwt({
      sub: config.userId,
      deviceId: config.deviceId,
      workspaceId: config.workspaceId,
      exp: Date.now() + 3600_000,
      iat: Date.now()
    }, config.secret);
    await ws.authenticate(token);

    // 3. 可选: Teleport 环境
    if (config.teleport) {
      const bundle = await createGitBundle(config.repoPath);
      const env = await captureEnvironment();
      await ws.send("teleport", { bundle, env });
    }

    const session: RemoteSession = {
      id: generateSessionId(),
      ws,
      status: "connected",
      createdAt: Date.now()
    };

    this.sessions.set(session.id, session);
    return session;
  }

  // 断线重连
  async reconnect(sessionId: string): Promise<void> {
    const session = this.sessions.get(sessionId);
    if (!session) throw new Error("Session not found");

    await session.ws.reconnect();
    session.status = "connected";
  }
}