LobsterAI 运行时集成架构与原理

export interface CoworkRuntime {
  on<U extends keyof CoworkRuntimeEvents>(event: U, listener: CoworkRuntimeEvents[U]): this;
  off<U extends keyof CoworkRuntimeEvents>(event: U, listener: CoworkRuntimeEvents[U]): this;
  startSession(sessionId: string, prompt: string, options?: CoworkStartOptions): Promise<void>;
  continueSession(sessionId: string, prompt: string, options?: CoworkContinueOptions): Promise<void>;
  patchSession?(sessionId: string, patch: OpenClawSessionPatch): Promise<void>;  // 可选
  stopSession(sessionId: string): void;
  stopAllSessions(): void;
  respondToPermission(requestId: string, result: PermissionResult): void;
  isSessionActive(sessionId: string): boolean;
  getSessionConfirmationMode(sessionId: string): 'modal' | 'text' | null;
  onSessionDeleted?(sessionId: string): void;  // 可选
}

export interface CoworkRuntimeEvents {
  message: (sessionId: string, message: CoworkMessage) => void;
  messageUpdate: (sessionId: string, messageId: string, content: string) => void;
  permissionRequest: (sessionId: string, request: PermissionRequest) => void;
  complete: (sessionId: string, claudeSessionId: string | null) => void;
  error: (sessionId: string, error: string) => void;
  sessionStopped: (sessionId: string, ) => void;
}

type RouterDeps = {
  getCurrentEngine: () => CoworkAgentEngine;  // 读取当前引擎配置
  openclawRuntime: CoworkRuntime;             // 单一 runtime 实例
};

coworkEngineRouter = new CoworkEngineRouter({
  getCurrentEngine: resolveCoworkAgentEngine,  // 从 SQLite 读 agentEngine 配置
  openclawRuntime: openClawRuntimeAdapter,     // 唯一的适配器实例
});

用户输入 → Renderer Redux
  → coworkService.startSession()
  → IPC invoke 'cowork:session:start'
  → main.ts handler: ensureOpenClawRunningForCowork()
  → getCoworkEngineRouter().startSession()
  → router: safeResolveEngine() → 选择 runtime
  → runtime.startSession()

handleEngineConfigChanged(nextEngine: CoworkAgentEngine): void {
  if (nextEngine === this.currentEngine) return;
  this.currentEngine = nextEngine;
  // 停止所有活跃 session
  const activeSessionIds = Array.from(this.sessionEngine.keys())
    .filter(sessionId => this.runtime.isSessionActive(sessionId));
  this.stopAllSessions();
  // 向每个被中断的 session 发送 ENGINE_SWITCHED 错误
  activeSessionIds.forEach(sessionId => {
    this.emit('error', sessionId, ENGINE_SWITCHED_CODE);
  });
}

private bindRuntimeEvents(engine: CoworkAgentEngine, runtime: CoworkRuntime): void {
  runtime.on('message', (sessionId, message) => {
    this.sessionEngine.set(sessionId, engine);  // 自动标记引擎归属
    this.emit('message', sessionId, message);
  });
  runtime.on('permissionRequest', (sessionId, request) => {
    this.sessionEngine.set(sessionId, engine);
    this.requestEngine.set(request.requestId, engine);  // 权限请求也标记引擎
    this.requestSession.set(request.requestId, sessionId);
    this.emit('permissionRequest', sessionId, request);
  });
  // ... 其余 4 个事件类似
}

respondToPermission(requestId: string, result: PermissionResult): void {
  const engine = this.requestEngine.get(requestId);
  if (engine) {
    this.runtime.respondToPermission(requestId, result);
    // 清理 map
    return;
  }
  this.runtime.respondToPermission(requestId, result);
}

export const CoworkAgentEngine = {
  OpenClaw: 'openclaw',
  OpenCode: 'opencode',
  Hermes: 'hermes',
} as const;
export type CoworkAgentEngine = typeof CoworkAgentEngine[keyof typeof CoworkAgentEngine];

export const EngineErrorCode = {
  EngineSwitched: 'ENGINE_SWITCHED',
  EngineNotReady: 'ENGINE_NOT_READY',
} as const;

export const CoworkStreamIpcChannel = {
  Message: 'cowork:stream:message',
  MessageUpdate: 'cowork:stream:messageUpdate',
  Permission: 'cowork:stream:permission',
  PermissionDismiss: 'cowork:stream:permissionDismiss',
  Complete: 'cowork:stream:complete',
  Error: 'cowork:stream:error',
  SessionsChanged: 'cowork:sessions:changed',
} as const;

export const EngineLifecycleIpcChannel = {
  getStatus: (engine: CoworkAgentEngine) => `${engine}:engine:getStatus`,
  install: (engine: CoworkAgentEngine) => `${engine}:engine:install`,
  retryInstall: (engine: CoworkAgentEngine) => `${engine}:engine:retryInstall`,
  restartGateway: (engine: CoworkAgentEngine) => `${engine}:engine:restartGateway`,
  onProgress: (engine: CoworkAgentEngine) => `${engine}:engine:onProgress`,
} as const;

type RouterDeps = {
  getCurrentEngine: () => CoworkAgentEngine;
  runtimes: Map<CoworkAgentEngine, CoworkRuntime>;
};

// Router 内部委托查找
class CoworkEngineRouter extends EventEmitter implements CoworkRuntime {
  private getRuntimeForEngine(engine: CoworkAgentEngine): CoworkRuntime {
    const runtime = this.deps.runtimes.get(engine);
    if (!runtime) throw new Error(`Engine "${engine}" not available`);
    return runtime;
  }

  private getRuntimeForSession(sessionId: string): CoworkRuntime {
    const engine = this.sessionEngine.get(sessionId) ?? this.getCurrentEngine();
    return this.getRuntimeForEngine(engine);
  }
}

interface AgentEngineManager {
  getStatus(): AgentEngineStatus;
  ensureReady(): Promise<AgentEngineStatus>;
  start(): Promise<AgentEngineStatus>;
  stop(): Promise<void>;
  restart(): Promise<AgentEngineStatus>;
  isRunning(): boolean;
}

interface AgentEngineStatus {
  phase: EnginePhase;
  version: string | null;
  progressPercent?: number;
  message?: string;
  canRetry: boolean;
}

class OpenCodeRuntimeAdapter extends EventEmitter implements CoworkRuntime {
  // 通信方式取决于 opencode 的接口：
  // - CLI stdin/stdout JSON-RPC → child_process + JSON parsing
  // - HTTP API → fetch + SSE streaming
  // - WebSocket → 与 OpenClaw 类似的 GatewayClient 模式

  startSession(sessionId, prompt, options?) { ... }
  continueSession(sessionId, prompt, options?) { ... }
  stopSession(sessionId) { ... }
  stopAllSessions() { ... }
  respondToPermission(requestId, result) { ... }
  isSessionActive(sessionId) { ... }
  getSessionConfirmationMode(sessionId) { ... }
  // 注意: patchSession 和 onSessionDeleted 可以不实现（可选）
}

const runtimes = new Map<CoworkAgentEngine, CoworkRuntime>();
runtimes.set(CoworkAgentEngine.OpenClaw, openClawRuntimeAdapter);
runtimes.set(CoworkAgentEngine.OpenCode, openCodeRuntimeAdapter);
runtimes.set(CoworkAgentEngine.Hermes, hermesRuntimeAdapter);

const engineManagers = new Map<CoworkAgentEngine, AgentEngineManager>();
engineManagers.set(CoworkAgentEngine.OpenClaw, openClawEngineManager);
engineManagers.set(CoworkAgentEngine.OpenCode, openCodeEngineManager);
engineManagers.set(CoworkAgentEngine.Hermes, hermesEngineManager);

coworkEngineRouter = new CoworkEngineRouter({
  getCurrentEngine: resolveCoworkAgentEngine,
  runtimes,
});

// preload.ts 暴露泛化方法
openclaw: {
  engine: {
    getStatus: () => ipcRenderer.invoke(EngineLifecycleIpcChannel.getStatus(CoworkAgentEngine.OpenClaw)),
    // ...
  }
},
engine: {
  getStatus: (name: CoworkAgentEngine) => ipcRenderer.invoke(EngineLifecycleIpcChannel.getStatus(name)),
  install: (name: CoworkAgentEngine) => ipcRenderer.invoke(EngineLifecycleIpcChannel.install(name)),
  restart: (name: CoworkAgentEngine) => ipcRenderer.invoke(EngineLifecycleIpcChannel.restartGateway(name)),
  onProgress: (name: CoworkAgentEngine, callback) => ...,
}