imtoagent 0.2.0

package/modules/agent/codex.ts

@@ -0,0 +1,275 @@
+// Codex Agent 模块
+// 对接 Codex CLI，通过 :18899 Proxy 调用 Provider
+
+import { getProxyUsage, resetProxyUsage } from '../proxy/codex-proxy';
+import { calculateCost } from '../proxy/anthropic-proxy';
+import type { AgentContext } from '../types';
+import { getAppServerManager, type AgentEvent } from './codex-exec-server';
+// ================================================================
+// 类型
+// ================================================================
+interface CodexJsonEvent {
+  type: string;
+  thread_id?: string;
+  item?: { type: string; text?: string; name?: string; arguments?: string; output?: string };
+  text?: string;
+  delta?: string;
+  message?: { content?: { type: string; text?: string }[] };
+  error?: string;
+}
+
+const TOOL_NAMES: Record<string, string> = {
+  Bash: '执行命令', Read: '读取文件', Edit: '编辑文件', Write: '写入文件',
+  Glob: '搜索文件', Grep: '搜索内容', WebSearch: '搜索网页', WebFetch: '抓取网页',
+  NotebookEdit: '编辑 Notebook',
+  // Codex 工具名
+  command_execution: '执行命令', exec_command: '执行命令', write_stdin: '写入文件', update_plan: '更新计划',
+  request_user_input: '请求输入', apply_patch: '应用补丁', view_image: '查看图片',
+  spawn_agent: '启动代理', send_input: '发送输入', resume_agent: '恢复代理',
+  wait_agent: '等待代理', close_agent: '关闭代理',
+};
+
+// ================================================================
+// Codex CLI 调用
+// ================================================================
+function processCodexStream(stdout: string, onTool?: (name: string, args: Record<string, any>) => void): { threadId: string; response: string } {
+  let threadId = '', response = '';
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const evt: CodexJsonEvent = JSON.parse(line);
+      if (evt.type === 'thread.started' && evt.thread_id) {
+        threadId = evt.thread_id;
+      } else if (evt.type === 'item.completed') {
+        if (evt.item?.type === 'agent_message') {
+          response = (response ? response + '\n' : '') + (evt.item.text || '');
+        } else if (TOOL_NAMES[evt.item?.type || ''] && onTool) {
+          onTool(evt.item.type || 'unknown', { command: (evt.item as any).command || '' });
+        }
+      } else if (evt.type === 'error' || evt.type === 'thread.error') {
+        console.error(`[Codex] event error: ${(evt as any).message || (evt as any).error || JSON.stringify(evt)}`);
+      }
+    } catch {}
+  }
+  return { threadId, response };
+}
+
+async function spawnCodexExec(
+  cwd: string, prompt: string,
+  onTool?: (name: string, args: Record<string, any>) => void
+): Promise<{ threadId: string; response: string }> {
+  console.error(`[Codex] spawnExec cwd=${cwd} prompt_len=${prompt.length}`);
+  const child = Bun.spawn(['codex', 'exec', '-p', 'imtoagent', '-s', 'danger-full-access',
+    '--skip-git-repo-check', '--json', prompt], {
+    cwd, stdout: 'pipe', stderr: 'pipe',
+  });
+
+  // 安全读取 stdout/stderr：捕获子进程被 kill 等异常，确保 reject 带 Error 对象
+  let stdout = '', stderr = '';
+  try {
+    [stdout, stderr] = await Promise.all([
+      new Response(child.stdout).text().catch((e: any) => { throw new Error(`stdout 读取失败: ${e?.message || e}`); }),
+      new Response(child.stderr).text().catch((e: any) => { throw new Error(`stderr 读取失败: ${e?.message || e}`); }),
+    ]);
+  } catch (ioErr: any) {
+    // 子进程可能已被 kill，尝试获取退出码
+    try { child.kill('SIGKILL'); } catch {}
+    throw new Error(`codex exec I/O 异常: ${ioErr.message}`);
+  }
+
+  const code = await child.exited.catch(() => -1);
+  console.error(`[Codex] exec exit=${code} stdout_len=${stdout.length} stderr_len=${stderr.length}`);
+  const { threadId, response } = processCodexStream(stdout, onTool);
+  if (code !== 0 || !threadId) throw new Error(`codex exec exit ${code}: ${stderr.slice(0, 300)}`);
+  return { threadId, response };
+}
+
+async function spawnCodexResume(
+  cwd: string, threadId: string, prompt: string,
+  onTool?: (name: string, args: Record<string, any>) => void
+): Promise<{ response: string }> {
+  console.error(`[Codex] spawnResume cwd=${cwd} threadId=${threadId.slice(-8)} prompt_len=${prompt.length}`);
+  const child = Bun.spawn(['codex', 'exec', 'resume', threadId,
+    '--dangerously-bypass-approvals-and-sandbox', '-c', 'model_provider=imtoagent', '-c', 'model=gpt-5.5', '--json', '--skip-git-repo-check', prompt], {
+    cwd, stdout: 'pipe', stderr: 'pipe',
+  });
+
+  let stdout = '', stderr = '';
+  try {
+    [stdout, stderr] = await Promise.all([
+      new Response(child.stdout).text().catch((e: any) => { throw new Error(`stdout 读取失败: ${e?.message || e}`); }),
+      new Response(child.stderr).text().catch((e: any) => { throw new Error(`stderr 读取失败: ${e?.message || e}`); }),
+    ]);
+  } catch (ioErr: any) {
+    try { child.kill('SIGKILL'); } catch {}
+    throw new Error(`codex exec resume I/O 异常: ${ioErr.message}`);
+  }
+
+  const code = await child.exited.catch(() => -1);
+  console.error(`[Codex] resume exit=${code} stdout_len=${stdout.length} stderr_len=${stderr.length}`);
+  if (code !== 0) throw new Error(`codex exec resume exit ${code}: ${stderr.slice(0, 300)}`);
+  return { response: processCodexStream(stdout, onTool).response };
+}
+
+// ================================================================
+// App-Server 路径（优先使用——流式输出 + 长记忆 + 崩溃不丢上下文）
+// ================================================================
+async function runViaAppServer(
+  cwd: string, prompt: string, chatId: string, session: any,
+  onTool: (name: string, args: Record<string, any>) => void,
+  isFresh: boolean
+): Promise<{ threadId: string; response: string; usage: { inputTokens: number; outputTokens: number } }> {
+  const manager = getAppServerManager();
+  const client = await manager.getClient(chatId);
+
+  // app-server 同进程内线程存活
+  // 但进程重启后旧 thread 过期，需要判断代际
+  const currentGen = manager.generation;
+  const threadExpired = session._appServerGen !== currentGen;
+  if (isFresh || !session.codexThreadId || threadExpired) {
+    session.codexThreadId = await client.startThread(cwd);
+    session._appServerGen = currentGen;
+    console.log(`[Codex] app-server 全新线程 thread=${session.codexThreadId.slice(-8)}${threadExpired ? ' (进程重启)' : ''}`);
+  }
+  // 后续消息直接 turn/start（同线程延续上下文）
+
+  await client.sendPrompt(session.codexThreadId, prompt, cwd);
+
+  let response = '';
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  const startTime = Date.now();
+  const MAX_DURATION = 600_000; // 10 分钟总超时
+
+  for await (const event of client.receiveEvents()) {
+    // 超时保护
+    if (Date.now() - startTime > MAX_DURATION) {
+      console.error('[Codex] app-server 任务超时 (10min)');
+      break;
+    }
+
+    switch (event.type) {
+      case 'text_delta':
+        response += event.textDelta || '';
+        break;
+      case 'tool_call':
+        onTool(event.toolName || 'unknown', event.toolInput || {});
+        break;
+      case 'turn_result':
+        // 累加多轮 token（非终端 turn_result 来自每轮的 turn/completed）
+        totalUsage.inputTokens += event.usage?.inputTokens || 0;
+        totalUsage.outputTokens += event.usage?.outputTokens || 0;
+        break;
+      case 'error':
+        throw new Error(`app-server 错误: ${event.error}`);
+    }
+  }
+
+  return { threadId: session.codexThreadId, response, usage: totalUsage };
+}
+
+// ================================================================
+// Codex 模块类
+// ================================================================
+export class CodexAgentModule {
+  private ctx: AgentContext;
+
+  constructor(ctx: AgentContext) {
+    this.ctx = ctx;
+  }
+
+  async handleMessage(chatId: string, text: string, session: any) {
+    const ctx = this.ctx;
+    const cwd = session.cwd || ctx.defaultCwd;
+    console.log(`[${ctx.name}] Codex chat=${chatId.slice(-8)} startFresh=${session.startFresh || false}`);
+
+    const onTool = (name: string, args: Record<string, any>) => {
+      const cmd = args.cmd || args.command || '';
+      const justification = args.justification || args.description || '';
+      const summary = cmd ? cmd.slice(0, 80) : justification.slice(0, 80);
+      ctx.addToolLog(chatId, { name, summary });
+    };
+
+    resetProxyUsage();
+    try {
+      let effectiveText = text;
+      if (session.codexMode === 'plan') {
+        effectiveText = `[模式: 先计划后执行] 请先制定一个清晰的计划，等我确认后再执行。用户请求: ${text}`;
+      }
+
+      const isFresh = session.startFresh || !session.codexThreadId;
+      let response: string;
+      let execServerUsage: { inputTokens: number; outputTokens: number } | null = null;
+
+      session.startFresh = false;
+      await ctx.sendProgress(chatId, '💭 思考中...');
+
+      // 优先尝试 app-server
+      console.error(`[${ctx.name}] DEBUG 进入 app-server 分支, isFresh=${isFresh}, threadId=${session.codexThreadId?.slice(-8)}`);
+      let useExecFallback = false;
+      try {
+        const r = await runViaAppServer(cwd, effectiveText, chatId, session, onTool, isFresh);
+        response = r.response;
+        execServerUsage = r.usage;
+      } catch (appErr: any) {
+        const errMsg = appErr.message || '';
+        console.error(`[${ctx.name}] app-server 失败: ${errMsg}`);
+
+        // thread not found → app-server 进程内线程丢了，尝试重新创建
+        if (errMsg.includes('thread not found') || errMsg.includes('Thread not found')) {
+          try {
+            session.codexThreadId = undefined;
+            const r2 = await runViaAppServer(cwd, effectiveText, chatId, session, onTool, true);
+            response = r2.response;
+            execServerUsage = r2.usage;
+            console.error(`[${ctx.name}] app-server thread 重建成功`);
+          } catch {
+            useExecFallback = true;
+          }
+        } else {
+          useExecFallback = true;
+        }
+      }
+
+      if (useExecFallback) {
+        getAppServerManager().removeClient(chatId);
+        if (isFresh || !session.codexThreadId) {
+          const r = await spawnCodexExec(cwd, effectiveText, onTool);
+          session.codexThreadId = r.threadId;
+          response = r.response;
+          console.log(`[${ctx.name}] 全新会话 thread=${r.threadId.slice(-8)}`);
+        } else {
+          const r = await spawnCodexResume(cwd, session.codexThreadId, effectiveText, onTool);
+          response = r.response;
+        }
+      }
+      ctx.flushToolLog(chatId);
+
+      // 优先使用 app-server 返回的 usage，否则从 proxy 获取
+      const usage = execServerUsage || getProxyUsage();
+      if (usage.inputTokens > 0 || usage.outputTokens > 0) {
+        const cost = calculateCost(ctx.activeModel, usage.inputTokens, usage.outputTokens);
+        ctx.accumulateStats(session, { ...usage, costUSD: cost });
+        await ctx.sendProgress(chatId,
+          `输入 ${usage.inputTokens.toLocaleString()} Token\n输出 ${usage.outputTokens.toLocaleString()} Token\n费用 $${cost.toFixed(4)}`);
+      }
+
+      if (response) {
+        await ctx.sendFormattedReply(chatId, response);
+      }
+      else await ctx.reply(chatId, '✅ 已完成');
+      ctx.persistSession(chatId, session);
+    } catch (e: any) {
+      console.error(`[${ctx.name}] Codex 错误: ${e.message}`);
+      session.codexThreadId = undefined;
+      try {
+        const r = await spawnCodexExec(cwd, text, onTool);
+        session.codexThreadId = r.threadId;
+        if (r.response) {
+          await ctx.sendFormattedReply(chatId, r.response);
+        }
+      } catch (e2: any) {
+        await ctx.reply(chatId, `❌ 处理失败: ${e2.message}`);
+      }
+    }
+  }
+}

package/modules/agent/opencode-adapter.ts

@@ -0,0 +1,308 @@
+// ================================================================
+// OpenCode Agent Adapter — 实现 SDK AgentAdapter 接口
+// ================================================================
+// 职责：对接 opencode serve HTTP API，将 AgentInput 转换为 AgentOutput
+// 多轮循环：OpenCode serve 的 /message 是单轮 API，每次返回可能含
+//   tool_call（服务端已执行），需要客户端发 "继续" 推进直到纯文本响应。
+// ================================================================
+
+import type { AgentAdapter, AgentInput, AgentOutput } from '../core/types';
+import { buildAttachmentHint } from '../core/types';
+import { buildSystemPrompt } from '../prompt-builder';
+import { getDataDir } from '../utils/paths';
+
+// ================================================================
+// OpenCodeAdapter 上下文
+// ================================================================
+
+export interface OpenCodeAdapterContext {
+  imModule?: { getCapabilities(): any } | null;
+  botName: string;
+  /** OpenCode Server URL，默认 http://localhost:4096 */
+  serverUrl?: string;
+  /** 默认模型 */
+  defaultModel?: { providerID: string; modelID: string };
+}
+
+// ================================================================
+// OpenCode Server HTTP 客户端
+// ================================================================
+
+interface OcMessagePart {
+  type: string;
+  text?: string;
+  tool_call?: { name: string; arguments: Record<string, any> };
+  tool_result?: { content: string };
+}
+
+interface OcMessage {
+  info: { id: string; role: string; model?: string };
+  parts: OcMessagePart[];
+}
+
+async function ocCreateSession(serverUrl: string, title: string): Promise<string> {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), 300_000);
+  const res = await fetch(`${serverUrl}/session`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ title }),
+    signal: ac.signal,
+  }).finally(() => clearTimeout(timer));
+  if (!res.ok) throw new Error(`oc create session: ${res.status} ${await res.text()}`);
+  const data = await res.json();
+  return data.id;
+}
+
+async function ocSendPrompt(
+  serverUrl: string,
+  sessionId: string,
+  initialText: string,
+  system: string,
+  defaultModel: { providerID: string; modelID: string },
+  onTool?: (name: string, args: Record<string, any>) => void
+): Promise<{ response: string; toolCalls: Array<{ name: string; summary: string }> }> {
+  const MAX_TURNS = 50;
+  const TURN_TIMEOUT = 300_000;  // 每轮 5 分钟
+  const MAX_DURATION = 600_000;  // 总超时 10 分钟
+  const startTime = Date.now();
+
+  let promptText = initialText;
+  let accumulatedResponse = '';
+  let turn = 0;
+  const allToolCalls: Array<{ name: string; summary: string }> = [];
+
+  while (turn < MAX_TURNS) {
+    if (Date.now() - startTime > MAX_DURATION) {
+      console.error('[OpenCodeAdapter] 任务总超时 (10min)');
+      break;
+    }
+    turn++;
+
+    // 构建请求体：首轮带 system prompt，后续轮只带纯文本推进
+    const body: any = {
+      model: defaultModel,
+      parts: [{ type: 'text', text: promptText }],
+    };
+    if (turn === 1 && system) body.system = system;
+
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), TURN_TIMEOUT);
+    const res = await fetch(`${serverUrl}/session/${sessionId}/message`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    }).finally(() => clearTimeout(timer));
+    if (!res.ok) throw new Error(`oc send prompt (turn ${turn}): ${res.status} ${await res.text()}`);
+
+    const data: OcMessage = await res.json();
+    let hasToolCall = false;
+    let hasText = false;
+
+    for (const part of data.parts || []) {
+      if (part.type === 'text' && part.text) {
+        hasText = true;
+        accumulatedResponse += (accumulatedResponse ? '\n' : '') + part.text;
+      } else if (part.type === 'tool_call' && part.tool_call) {
+        hasToolCall = true;
+        const name = part.tool_call.name;
+        const args = part.tool_call.arguments || {};
+        const summary = args.command || args.cmd || args.file_path || args.query
+          || JSON.stringify(args).slice(0, 80);
+        allToolCalls.push({ name, summary });
+        if (onTool) onTool(name, args);
+        console.log(`[OpenCodeAdapter] 🔧 turn ${turn}: ${name} ${summary.slice(0, 60)}`);
+      }
+    }
+
+    // 有文本回复 → 任务完成（OpenCode 内部已完成多轮 agent loop）
+    if (hasText) {
+      console.log(`[OpenCodeAdapter] ✅ 完成于 turn ${turn}/${MAX_TURNS}`);
+      break;
+    }
+
+    // 无文本且无 tool_call → 空响应，结束
+    if (!hasToolCall) {
+      console.log(`[OpenCodeAdapter] ⚠️ 空响应，结束于 turn ${turn}/${MAX_TURNS}`);
+      break;
+    }
+
+    // 仅有 tool_call 无文本 → OpenCode 无法自行执行，推进下一轮
+    promptText = '继续执行，完成剩余任务';
+  }
+
+  if (turn >= MAX_TURNS) {
+    console.warn(`[OpenCodeAdapter] ⚠️ 达到最大轮次 ${MAX_TURNS}`);
+  }
+
+  return { response: accumulatedResponse, toolCalls: allToolCalls };
+}
+
+async function ocDeleteSession(serverUrl: string, sessionId: string): Promise<void> {
+  await fetch(`${serverUrl}/session/${sessionId}`, { method: 'DELETE' }).catch(() => {});
+}
+
+// ================================================================
+// OpenCodeAdapter — 实现 AgentAdapter
+// ================================================================
+
+export class OpenCodeAdapter implements AgentAdapter {
+  readonly name = 'OpenCode';
+  private ctx: OpenCodeAdapterContext;
+
+  constructor(ctx: OpenCodeAdapterContext) {
+    this.ctx = ctx;
+  }
+
+  async handleMessage(input: AgentInput): Promise<AgentOutput> {
+    const { text, session, systemPrompt: overrideSystemPrompt } = input;
+
+    const serverUrl = this.ctx.serverUrl || 'http://localhost:4096';
+    const defaultModel = this.ctx.defaultModel || { providerID: 'anthropic', modelID: 'claude-sonnet-4-5' };
+    const sessionAny = session as any;
+
+    let effectiveText = text;
+
+    // 附件信息注入：让 Agent 知道用户发送了附件（图片/文件/语音）及本地路径
+    if (input.attachments && input.attachments.length > 0) {
+      effectiveText = buildAttachmentHint(input.attachments) + '\n\n---\n\n' + effectiveText;
+    }
+
+    if (session.codexMode === 'plan') {
+      effectiveText = `[模式: 先计划后执行] 请先制定一个清晰的计划，等我确认后再执行。用户请求: ${effectiveText}`;
+    }
+
+    // 清理标记
+    const shouldClear = session.startFresh;
+    session.startFresh = false;
+
+    // 获取或创建 OpenCode session
+    if (shouldClear || !sessionAny.ocSessionId) {
+      if (sessionAny.ocSessionId) {
+        await ocDeleteSession(serverUrl, sessionAny.ocSessionId);
+        console.log(`[OpenCodeAdapter] 已清除 oc session=${sessionAny.ocSessionId.slice(-8)}`);
+      }
+      sessionAny.ocSessionId = await ocCreateSession(serverUrl, input.chatId);
+      session.metadata.ocSessionId = sessionAny.ocSessionId;
+      console.log(`[OpenCodeAdapter] 新建 oc session=${sessionAny.ocSessionId.slice(-8)}`);
+    }
+
+    // 构建系统提示词
+    const systemPrompt = overrideSystemPrompt || buildSystemPrompt({
+      imModule: this.ctx.imModule || null,
+      botName: this.ctx.botName,
+    });
+    console.log(`[OpenCodeAdapter] 📝 system prompt built (${systemPrompt.length} chars)`);
+
+    // 发送 prompt（多轮循环：自动推进 tool_call → 纯文本响应）
+    const { response, toolCalls } = await ocSendPrompt(
+      serverUrl,
+      sessionAny.ocSessionId,
+      effectiveText,
+      systemPrompt,
+      defaultModel,
+      // onTool 回调：适配器层不依赖外部 ctx，直接记日志
+      (name, args) => {
+        // 工具调用日志由 Runtime 层统一格式化
+      }
+    );
+
+    return {
+      text: response || '✅ 已完成',
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      const serverUrl = this.ctx.serverUrl || 'http://localhost:4096';
+      const res = await fetch(`${serverUrl}/global/health`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// ================================================================
+// OpenCode Server 生命周期管理（模块级，单例）
+// ================================================================
+// IMtoAgent 作为多 Agent 网关，在适配器层管理后端服务进程
+// 未来 ClaudeAdapter / CodexAdapter 也可按需实现各自的 start/stop
+
+let _ocProcess: ReturnType<typeof Bun.spawn> | null = null;
+
+const OC_PORT = 4096;
+const OC_URL = `http://127.0.0.1:${OC_PORT}`;
+
+/** 启动 OpenCode serve 进程（幂等：已有运行中的服务则复用） */
+export async function startOpenCodeServer(): Promise<void> {
+  // 先检查是否已有服务（可能是外部启动的）
+  try {
+    const res = await fetch(`${OC_URL}/global/health`, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      console.log(`[OpenCodeAdapter] 检测到已有服务运行在 ${OC_URL}，复用`);
+      return;
+    }
+  } catch {}
+
+  console.log('[OpenCodeAdapter] 启动 opencode serve...');
+  const child = Bun.spawn(
+    ['opencode', 'serve', '--port', String(OC_PORT), '--hostname', '127.0.0.1'],
+    {
+      cwd: getDataDir(),
+      env: {
+        ...process.env,
+        // 环形通信无需真实 key，但 OpenCode 的 Anthropic provider 要求此变量存在
+        ANTHROPIC_API_KEY: 'imtoagent-local',
+      },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    },
+  );
+
+  // 后台收集日志
+  (async () => {
+    for await (const line of (child.stdout as any)) {
+      console.log(`[OpenCodeAdapter] ${new TextDecoder().decode(line).trim()}`);
+    }
+  })().catch(() => {});
+  (async () => {
+    for await (const line of (child.stderr as any)) {
+      console.log(`[OpenCodeAdapter:err] ${new TextDecoder().decode(line).trim()}`);
+    }
+  })().catch(() => {});
+
+  // 等待健康检查通过（最多 15 秒）
+  const start = Date.now();
+  const timeout = 15000;
+  while (Date.now() - start < timeout) {
+    if (child.exitCode !== undefined && child.exitCode !== null) {
+      throw new Error(`OpenCode 进程异常退出，exitCode=${child.exitCode}`);
+    }
+    try {
+      const res = await fetch(`${OC_URL}/global/health`, { signal: AbortSignal.timeout(2000) });
+      if (res.ok) {
+        _ocProcess = child;
+        console.log(`[OpenCodeAdapter] 服务启动成功 (PID=${child.pid}, ${OC_URL})`);
+        return;
+      }
+    } catch {}
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  // 超时
+  child.kill('SIGTERM');
+  throw new Error(`OpenCode 服务启动超时 (${timeout}ms)`);
+}
+
+/** 停止 OpenCode serve 进程 */
+export async function stopOpenCodeServer(): Promise<void> {
+  if (_ocProcess) {
+    console.log('[OpenCodeAdapter] 停止 OpenCode 服务...');
+    _ocProcess.kill('SIGTERM');
+    await new Promise(r => setTimeout(r, 1000));
+    _ocProcess = null;
+  }
+}