linco-connect 1.0.0

package/src/agents/codex.js

@@ -0,0 +1,869 @@
+const { spawn } = require('child_process');
+const { isDangerousCommand } = require('../danger');
+const { send, sendError, sendSystem } = require('../protocol');
+const { persistAgentSessionId, stopAgentProcess: stopSessionProcess, updateAgentSessionHistory } = require('../session');
+const { getOutboxDir } = require('../outgoingAttachmentHandler');
+const { createTextStreamBuffer, appendTextStream, flushTextStream, resetTextStream } = require('../streamBuffer');
+
+function execute(input, ws, session, config) {
+  const textForCheck = stringifyInput(input);
+  if (isDangerousCommand(textForCheck)) {
+    const preview = textForCheck.slice(0, 200);
+    session.pendingDanger = { input };
+    send(ws, 'danger_warning', {
+      text: `⚠️ 检测到可能的危险操作，请确认是否继续执行：
+
+"${preview}${textForCheck.length > 200 ? '...' : ''}"`,
+    });
+    return;
+  }
+
+  if (session.isTurnActive) {
+    if (session.messageQueue.length >= config.maxMessageQueue) {
+      sendError(ws, '消息队列已满，请稍后再试');
+      return;
+    }
+    session.messageQueue.push(input);
+    sendSystem(ws, `Codex 正在处理上一条消息，已加入队列（${session.messageQueue.length}）`);
+    return;
+  }
+
+  const agentConfig = config.agents?.codex || {};
+  const mode = agentConfig.mode === 'exec' ? 'exec' : 'app-server';
+  if (mode === 'exec') {
+    runExecTurn(input, ws, session, config);
+  } else {
+    runAppServerTurn(input, ws, session, config);
+  }
+}
+
+// ─── app-server persistent mode ────────────────────────────────────────
+
+function runAppServerTurn(input, ws, session, config) {
+  session.isTurnActive = true;
+  session.currentInputForNoOutput = input;
+  session.sawPartialAssistantText = false;
+  resetCodexAssistantText(session);
+  session._lastWs = ws;
+  session._lastConfig = config;
+  session._log = config.logger;
+
+  // Add outbox hint when user asks to send files
+  const inputWithOutbox = maybeAddOutboxHint(input, session, config);
+
+  const agentConfig = config.agents?.codex || {};
+  const log = config.logger;
+  log?.info('codex turn start', { mode: 'app-server', bin: agentConfig.bin, agentSessionId: session.agentSessionId });
+
+  ensureAppServer(session, config)
+    .then(() => {
+      session._log?.info('codex app-server ready, ensuring thread');
+      return ensureThread(session);
+    })
+    .then(threadId => {
+      session._log?.info('codex thread ensured', { threadId });
+      sendJsonRpc(session.codexAppServer, {
+        jsonrpc: '2.0',
+        id: nextRpcId(session),
+        method: 'turn/start',
+        params: {
+          threadId,
+          input: buildCodexInput(inputWithOutbox, session.workspace),
+          cwd: session.workspace,
+        },
+      });
+    })
+    .catch(err => {
+      session._log?.error('codex turn error', { message: err.message });
+      if (session.isTurnActive) {
+        sendError(ws, `Codex app-server 错误: ${err.message}`);
+        clearTurnState(session);
+        drainQueue(ws, session, config);
+      }
+    });
+}
+
+function ensureAppServer(session, config) {
+  if (session.codexAppServer && session.codexAppServer.stdin && !session.codexAppServer.stdin.destroyed) {
+    session._log?.info('codex reusing existing app-server');
+    return Promise.resolve();
+  }
+
+  session._log?.info('codex spawning new app-server');
+
+  return new Promise((resolve, reject) => {
+    const agentConfig = config.agents?.codex || {};
+    const bin = agentConfig.bin || 'codex';
+    const child = spawn(bin, ['app-server', '--listen', 'stdio://'], {
+      cwd: session.workspace,
+      env: { ...process.env },
+      shell: process.platform === 'win32',
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    session.codexAppServer = child;
+    session.agentProcess = child;
+    session.codexRpcId = 0;
+    session.codexPendingRequests = new Map();
+    session.stdoutBuffer = '';
+    session.stderrBuffer = '';
+    session.turnCompletedTimerId = null;
+
+    let initialized = false;
+    let initResolve;
+    let initReject;
+    const initPromise = new Promise((res, rej) => {
+      initResolve = res;
+      initReject = rej;
+    });
+
+    const timeout = setTimeout(() => {
+      if (!initialized) {
+        initReject(new Error('Codex app-server 初始化超时'));
+        child.kill();
+      }
+    }, 15000);
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+      session.stdoutBuffer += chunk;
+      const lines = session.stdoutBuffer.split(/\r?\n/);
+      session.stdoutBuffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed);
+          handleAppServerMessage(msg, session);
+        } catch {
+          // ignore unparseable lines
+        }
+      }
+    });
+
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', chunk => {
+      session.stderrBuffer += chunk;
+    });
+
+    child.on('error', err => {
+      if (!initialized) {
+        clearTimeout(timeout);
+        initReject(err);
+      } else {
+        const errWs = session._lastWs;
+        if (errWs) {
+          sendError(errWs, `Codex app-server 错误: ${err.message}`);
+        }
+      }
+    });
+
+    child.on('close', (code, signal) => {
+      if (session.codexAppServer === child) {
+        session.codexAppServer = null;
+      }
+      clearTurnState(session);
+      // drain pending requests
+      for (const [, pending] of session.codexPendingRequests) {
+        pending.reject(new Error(`app-server 已退出，code=${code}`));
+      }
+      session.codexPendingRequests.clear();
+      if (!initialized) {
+        clearTimeout(timeout);
+        initReject(new Error(`Codex app-server 启动失败，退出码: ${code}`));
+      } else {
+        // app-server exited mid-session — drain queue
+        const cfg = session._lastConfig;
+        const errWs = session._lastWs;
+        if (cfg && errWs) drainQueue(errWs, session, cfg);
+      }
+    });
+
+    // send initialize
+    const initId = ++session.codexRpcId;
+    sendJsonRpc(child, {
+      jsonrpc: '2.0',
+      id: initId,
+      method: 'initialize',
+      params: {
+        clientInfo: { name: 'linco', version: '1.0.0' },
+        capabilities: { experimentalApi: true },
+      },
+    });
+
+    session.codexPendingRequests.set(initId, {
+      resolve: (result) => {
+        initialized = true;
+        clearTimeout(timeout);
+        initResolve(result);
+      },
+      reject: (err) => {
+        clearTimeout(timeout);
+        initReject(err);
+      },
+    });
+
+    initPromise.then(resolve, reject);
+  });
+}
+
+function ensureThread(session) {
+  const agentConfig = session._lastConfig?.agents?.codex || {};
+
+  if (session.agentSessionId) {
+    // Resume existing thread after app-server restart
+    const rpcId = nextRpcId(session);
+    return rpcRequest(session, rpcId, 'thread/resume', {
+      threadId: session.agentSessionId,
+      cwd: session.workspace,
+      approvalPolicy: 'untrusted',
+    }).then(result => {
+      return session.agentSessionId;
+    }).catch(err => {
+      // If resume fails, start a new thread
+      session._log?.warn('codex thread resume failed, starting new', { message: err.message });
+      return startNewThread(session, agentConfig);
+    });
+  }
+
+  return startNewThread(session, agentConfig);
+}
+
+function startNewThread(session, agentConfig) {
+  const rpcId = nextRpcId(session);
+  return rpcRequest(session, rpcId, 'thread/start', {
+    cwd: session.workspace,
+    model: agentConfig.model || null,
+    approvalPolicy: 'untrusted',
+  }).then(result => {
+    const threadId = result?.thread?.id || result?.id || result?.threadId;
+    if (threadId) {
+      persistAgentSessionId(session, threadId);
+      return threadId;
+    }
+    // Fallback: wait for thread/started notification
+    return new Promise((resolve, reject) => {
+      const fallback = setTimeout(() => reject(new Error('创建线程超时')), 15000);
+      session._threadStartResolve = (id) => {
+        clearTimeout(fallback);
+        resolve(id);
+      };
+      session._threadStartReject = (err) => {
+        clearTimeout(fallback);
+        reject(err);
+      };
+    });
+  });
+}
+
+function clearTurnState(session) {
+  flushCodexAssistantText(session._lastWs, session);
+  session.isTurnActive = false;
+  session.currentInputForNoOutput = null;
+  if (session.turnCompletedTimerId) {
+    clearTimeout(session.turnCompletedTimerId);
+    session.turnCompletedTimerId = null;
+  }
+}
+
+function ensureCodexStreamState(session) {
+  if (!session.codexStreamState) {
+    session.codexStreamState = createTextStreamBuffer();
+  }
+  return session.codexStreamState;
+}
+
+function appendCodexAssistantText(text, ws, session, ensureAssistantStarted) {
+  const state = ensureCodexStreamState(session);
+  state.onStart = ensureAssistantStarted;
+  appendTextStream(text, ws, state);
+  session.sawPartialAssistantText = true;
+}
+
+function flushCodexAssistantText(ws, session) {
+  flushTextStream(ws, session.codexStreamState);
+}
+
+function resetCodexAssistantText(session) {
+  resetTextStream(ensureCodexStreamState(session));
+}
+
+function nextRpcId(session) {
+  session.codexRpcId = (session.codexRpcId || 0) + 1;
+  return session.codexRpcId;
+}
+
+function rpcRequest(session, id, method, params) {
+  return new Promise((resolve, reject) => {
+    session.codexPendingRequests.set(id, { resolve, reject });
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    });
+  });
+}
+
+function sendJsonRpc(child, message) {
+  if (child.stdin && !child.stdin.destroyed) {
+    child.stdin.write(JSON.stringify(message) + '\n');
+  }
+}
+
+function handleServerRequest(message, session) {
+  const method = message.method || '';
+  const params = message.params || {};
+  const ws = session._lastWs;
+
+  // File change approval — auto-approve but notify user
+  if (method === 'item/fileChange/requestApproval') {
+    session._log?.info('codex auto-approving file change');
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { decision: 'accept' },
+    });
+    return;
+  }
+
+  // Command execution approval — send to frontend for user approval
+  if (method === 'item/commandExecution/requestApproval' || method === 'execCommandApproval') {
+    const cmd = params.command || params.tool || '';
+    session._log?.info('codex command execution approval requested', { method, command: cmd });
+
+    session.pendingPermission = {
+      provider: 'codex',
+      toolName: 'exec',
+      input: cmd,
+      _codexMethod: method,
+      _rpcId: message.id,
+    };
+
+    if (ws) {
+      send(ws, 'tool_call', {
+        id: String(message.id),
+        name: 'exec',
+        input: cmd,
+      });
+      send(ws, 'permission_request', {
+        requestId: String(message.id),
+        toolName: 'exec',
+        input: cmd,
+      });
+    }
+    return;
+  }
+
+  // Permissions approval — auto-grant
+  if (method === 'item/permissions/requestApproval') {
+    session._log?.info('codex auto-granting permissions');
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { permissions: { fileSystem: { entries: [] }, network: { enabled: false } }, scope: 'session' },
+    });
+    return;
+  }
+
+  // Apply patch approval — auto-approve
+  if (method === 'applyPatchApproval') {
+    session._log?.info('codex auto-approving patch');
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { decision: 'approved' },
+    });
+    return;
+  }
+
+  // Generic approval fallback
+  if (method.includes('requestApproval') || method.includes('approval')) {
+    session._log?.info('codex auto-approving', { method });
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { decision: 'accept' },
+    });
+    return;
+  }
+
+  // Tool call from server request
+  if (method === 'item/tool/call') {
+    if (ws) {
+      const toolName = params.name || params.tool || '';
+      send(ws, 'tool_call', {
+        id: String(message.id),
+        name: toolName,
+        input: JSON.stringify(params.input || {}).slice(0, 300),
+      });
+    }
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { ok: true },
+    });
+    return;
+  }
+
+  // Tool user input
+  if (method === 'item/tool/requestUserInput') {
+    session._log?.info('codex tool requesting user input');
+    sendJsonRpc(session.codexAppServer, {
+      jsonrpc: '2.0',
+      id: message.id,
+      result: { continue: true },
+    });
+    return;
+  }
+
+  // Unknown server request — reject
+  session._log?.warn('codex unknown server request', { method, params: JSON.stringify(params).slice(0, 200) });
+  sendJsonRpc(session.codexAppServer, {
+    jsonrpc: '2.0',
+    id: message.id,
+    error: { code: -32601, message: 'method not supported' },
+  });
+}
+
+function handleAppServerMessage(message, session) {
+  const ws = session._lastWs;
+
+  // thread.started notification — resolve ensureThread promise
+  if (message.method === 'thread.started' || message.method === 'thread/start') {
+    const threadId = message.params?.thread?.id || message.params?.id || message.result?.thread?.id;
+    if (threadId) {
+      persistAgentSessionId(session, threadId);
+      if (session._threadStartResolve) {
+        session._threadStartResolve(threadId);
+        session._threadStartResolve = null;
+        session._threadStartReject = null;
+      }
+    }
+    return;
+  }
+
+  // RPC response (has id field matching our pending request)
+  if (message.id != null && session.codexPendingRequests?.has(message.id)) {
+    const pending = session.codexPendingRequests.get(message.id);
+    session.codexPendingRequests.delete(message.id);
+    if (message.error) {
+      session._log?.error('codex RPC error', { id: message.id, error: JSON.stringify(message.error) });
+      pending.reject(new Error(JSON.stringify(message.error)));
+    } else {
+      session._log?.info('codex RPC response', { id: message.id, keys: Object.keys(message.result || {}) });
+      pending.resolve(message.result || message);
+    }
+    return;
+  }
+
+  // Server request (has id but not our pending) — auto-approve
+  if (message.id != null && message.method) {
+    handleServerRequest(message, session);
+    return;
+  }
+
+  // notification
+  const method = message.method || '';
+  const params = message.params || {};
+
+  if (method === 'item/agentMessage/delta' || method.includes('delta')) {
+    const delta = params.delta || '';
+    if (delta) {
+      appendCodexAssistantText(delta, ws, session, () => send(ws, 'assistant_start', {}));
+    }
+    return;
+  }
+
+  if (method === 'item/completed') {
+    // final content fallback if no deltas were emitted
+    const text = extractFinalText(params);
+    if (text && !session.sawPartialAssistantText) {
+      appendCodexAssistantText(text, ws, session, () => send(ws, 'assistant_start', {}));
+    }
+    // Safety fallback: if turn/completed doesn't arrive within 3s,
+    // clear isTurnActive so the next message doesn't get stuck.
+    if (session.turnCompletedTimerId) clearTimeout(session.turnCompletedTimerId);
+    session.turnCompletedTimerId = setTimeout(() => {
+      if (session.isTurnActive) {
+        session.isTurnActive = false;
+        session.currentInputForNoOutput = null;
+        if (session.sawPartialAssistantText) {
+          flushCodexAssistantText(ws, session);
+          send(ws, 'assistant_end', {});
+        }
+        const cfg = session._lastConfig;
+        if (cfg) drainQueue(ws, session, cfg);
+      }
+    }, 3000);
+    return;
+  }
+
+  if (method === 'turn/completed' || method === 'turn.completed') {
+    if (session.turnCompletedTimerId) {
+      clearTimeout(session.turnCompletedTimerId);
+      session.turnCompletedTimerId = null;
+    }
+    updateCodexSessionStats(session, params);
+    clearTurnState(session);
+    if (session.sawPartialAssistantText) {
+      flushCodexAssistantText(ws, session);
+      send(ws, 'assistant_end', {});
+    } else {
+      sendSystem(ws, 'Codex 本次执行没有输出。');
+    }
+    const cfg = session._lastConfig;
+    if (cfg) {
+      drainQueue(ws, session, cfg);
+    }
+    return;
+  }
+
+  if (method === 'error' || method.includes('error')) {
+    sendError(ws, params.message || JSON.stringify(params));
+    clearTurnState(session);
+    return;
+  }
+
+  // tool call notifications
+  if (method === 'tool/start' || method === 'tool_call') {
+    const toolName = params.name || params.tool || '';
+    if (toolName) {
+      send(ws, 'tool_call', {
+        id: params.id || params.toolId || '',
+        name: toolName,
+        input: params.input || params.arguments || {},
+      });
+    }
+    return;
+  }
+
+  if (method === 'tool/completed' || method === 'tool_result') {
+    send(ws, 'tool_result', {
+      id: params.id || params.toolId || '',
+      output: params.output || params.result || '',
+    });
+    return;
+  }
+
+  if (method === 'item/started') {
+    const itemType = params.item?.type || '';
+    session._log?.info('codex item started', { itemType });
+    if (itemType === 'toolCall' || itemType === 'commandExecution') {
+      const toolName = params.item?.name || params.item?.tool || params.item?.command || '';
+      const toolInput = params.item?.input || params.item?.arguments || {};
+      const itemId = params.item?.id || params.itemId || '';
+      if (toolName) {
+        send(ws, 'tool_call', {
+          id: itemId,
+          name: toolName,
+          input: typeof toolInput === 'string' ? toolInput : JSON.stringify(toolInput).slice(0, 300),
+        });
+      }
+    }
+    return;
+  }
+}
+
+function updateCodexSessionStats(session, params = {}) {
+  session.messageCount = (session.messageCount || 0) + 1;
+
+  const usage = params.usage || params.turn?.usage || params.response?.usage;
+  if (usage) {
+    if (!session.usage) {
+      session.usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+    }
+    session.usage.inputTokens += usage.input_tokens || usage.inputTokens || 0;
+    session.usage.outputTokens += usage.output_tokens || usage.outputTokens || 0;
+    session.usage.cacheReadTokens += usage.cache_read_input_tokens || usage.cacheReadTokens || 0;
+    session.usage.cacheCreationTokens += usage.cache_creation_input_tokens || usage.cacheCreationTokens || 0;
+  }
+
+  updateAgentSessionHistory(session);
+}
+
+function extractFinalText(params) {
+  if (typeof params.text === 'string') return params.text;
+  if (typeof params.delta === 'string') return params.delta;
+  if (Array.isArray(params.content)) {
+    return params.content.map(item => typeof item === 'string' ? item : item?.text || '').join('');
+  }
+  if (params.item?.type === 'agent_message' && typeof params.item.text === 'string') {
+    return params.item.text;
+  }
+  return '';
+}
+
+function buildCodexInput(input, workspace) {
+  if (Array.isArray(input)) {
+    const result = [];
+    for (const block of input) {
+      if (typeof block === 'string') {
+        result.push({ type: 'text', text: block });
+      } else if (block?.type === 'text') {
+        result.push({ type: 'text', text: block.text || '' });
+      } else if (block?.type === 'image' && block.path) {
+        // Codex sandbox can only read from workspace — copy image into workspace
+        const fs = require('fs');
+        const path = require('path');
+        const basename = path.basename(block.path);
+        const copyDir = path.join(workspace, '_linco_attachments');
+        const copyPath = path.join(copyDir, basename);
+        try {
+          fs.mkdirSync(copyDir, { recursive: true });
+          fs.copyFileSync(block.path, copyPath);
+        } catch {
+          // If copy fails, fall back to original path
+        }
+        const mediaType = block.source?.media_type || '';
+        result.push({ type: 'text', text: `用户发送了一张图片（${mediaType}），文件已保存到 ${copyPath}，请按需读取` });
+      } else if (block?.type === 'image') {
+        result.push({ type: 'text', text: '[图片附件]' });
+      } else {
+        result.push({ type: 'text', text: JSON.stringify(block) });
+      }
+    }
+    return result;
+  }
+  return [{ type: 'text', text: String(input || '') }];
+}
+
+function maybeAddOutboxHint(input, session, config) {
+  const text = typeof input === 'string' ? input : stringifyInput(input);
+  if (!/发送.*(文件|图片)|把.*(文件|图片).*发|发给我|发送给我|文件发送|发文件|下载文件/.test(text)) {
+    return input;
+  }
+  const outboxDir = getOutboxDir(session, config);
+  const hint = `系统提示：用户正在要求发送文件/图片。请将要发送给用户的最终文件保存或复制到以下 outbox 目录，系统只会自动发送这个目录中的新文件：\n${outboxDir}`;
+  if (Array.isArray(input)) {
+    return [...input, { type: 'text', text: hint }];
+  }
+  return `${text}\n\n${hint}`;
+}
+
+// ─── exec fallback mode ────────────────────────────────────────────────
+
+function runExecTurn(input, ws, session, config) {
+  session.isTurnActive = true;
+  session.currentInputForNoOutput = input;
+  session.sawPartialAssistantText = false;
+  resetCodexAssistantText(session);
+
+  const agentConfig = config.agents?.codex || {};
+  const child = spawn(agentConfig.bin || 'codex', buildExecArgs(session, agentConfig), {
+    cwd: session.workspace,
+    env: { ...process.env },
+    shell: process.platform === 'win32',
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  session.agentProcess = child;
+  session.stdoutBuffer = '';
+  let stderr = '';
+  let assistantStarted = false;
+
+  const ensureAssistantStarted = () => {
+    if (assistantStarted) return;
+    assistantStarted = true;
+    send(ws, 'assistant_start', {});
+  };
+
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', chunk => {
+    session.stdoutBuffer += chunk;
+    const lines = session.stdoutBuffer.split(/\r?\n/);
+    session.stdoutBuffer = lines.pop() || '';
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        handleCodexEvent(JSON.parse(trimmed), ws, session, ensureAssistantStarted);
+      } catch {
+        appendCodexAssistantText(`${trimmed}\n`, ws, session, ensureAssistantStarted);
+      }
+    }
+  });
+
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', chunk => {
+    stderr += chunk;
+  });
+
+  child.on('error', err => {
+    sendError(ws, `Codex 启动失败: ${err.message}`);
+  });
+
+  child.on('close', code => {
+    if (session.agentProcess === child) session.agentProcess = null;
+    session.isTurnActive = false;
+    session.currentInputForNoOutput = null;
+
+    if (session.stdoutBuffer.trim()) {
+      appendCodexAssistantText(`${session.stdoutBuffer.trim()}\n`, ws, session, ensureAssistantStarted);
+      session.stdoutBuffer = '';
+    }
+
+    if (assistantStarted) {
+      flushCodexAssistantText(ws, session);
+      send(ws, 'assistant_end', {});
+    } else if (code !== 0) {
+      sendError(ws, stderr.trim() || `Codex 退出，状态码: ${code}`);
+    } else {
+      sendSystem(ws, 'Codex 本次执行没有输出。');
+    }
+
+    if (code === 0) {
+      updateCodexSessionStats(session);
+    }
+    drainQueue(ws, session, config);
+  });
+
+  child.stdin.end(`${stringifyInput(input)}\n`);
+}
+
+function buildExecArgs(session, agentConfig) {
+  const args = session.agentSessionId
+    ? ['exec', 'resume']
+    : ['exec'];
+  args.push('--json');
+  if (!session.agentSessionId) args.push('--cd', session.workspace);
+  if (agentConfig.model) args.push('--model', agentConfig.model);
+  if (session.agentSessionId) args.push(session.agentSessionId);
+  args.push('-');
+  return args;
+}
+
+// ─── shared helpers ─────────────────────────────────────────────────────
+
+function stringifyInput(input) {
+  if (Array.isArray(input)) {
+    return input.map(block => {
+      if (typeof block === 'string') return block;
+      if (block?.type === 'text') return block.text || '';
+      if (block?.type === 'image') return '[图片附件：Codex 当前适配器暂不直接传入图片内容]';
+      return JSON.stringify(block);
+    }).filter(Boolean).join('\n');
+  }
+  return String(input || '');
+}
+
+function handleCodexEvent(event, ws, session, ensureAssistantStarted) {
+  const type = event.type || event.event || event.kind || '';
+  const threadId = event.thread_id || event.threadId || event.thread?.id;
+  if ((type === 'thread.started' || type === 'thread_started') && threadId) {
+    persistAgentSessionId(session, threadId);
+    return;
+  }
+
+  if (event.thread_id && !session.agentSessionId) {
+    persistAgentSessionId(session, event.thread_id);
+  }
+
+  const text = extractText(event);
+  if (text) {
+    appendCodexAssistantText(text, ws, session, ensureAssistantStarted);
+    return;
+  }
+
+  if (type.includes('error') || type === 'turn.failed') {
+    sendError(ws, event.message || event.error || JSON.stringify(event));
+  }
+}
+
+function extractText(event) {
+  if (typeof event.text === 'string') return event.text;
+  if (typeof event.delta === 'string') return event.delta;
+  if (typeof event.message === 'string' && /message|agent/.test(String(event.type || ''))) return event.message;
+  if (Array.isArray(event.content)) {
+    return event.content.map(item => typeof item === 'string' ? item : item?.text || '').join('');
+  }
+  if (typeof event.item?.text === 'string' && ['agent_message', 'message'].includes(event.item.type)) {
+    return event.item.text;
+  }
+  if (event.item?.type === 'message' && Array.isArray(event.item.content)) {
+    return event.item.content.map(item => item?.text || '').join('');
+  }
+  return '';
+}
+
+function resolvePendingDanger(confirmed, ws, session, config) {
+  const pending = session.pendingDanger;
+  if (!pending) return false;
+  session.pendingDanger = null;
+  if (!confirmed) {
+    sendSystem(ws, '已取消危险操作。');
+    return true;
+  }
+  execute(pending.input, ws, session, config);
+  return true;
+}
+
+function resolvePendingPermission(approved, ws, session, config) {
+  if (!session.pendingPermission) return false;
+
+  const pending = session.pendingPermission;
+  if (pending.provider !== 'codex') return false;
+
+  session.pendingPermission = null;
+  session._log?.info('codex permission response', { approved, toolName: pending.toolName, rpcId: pending._rpcId });
+
+  // Respond to Codex RPC
+  if (pending._codexMethod === 'item/commandExecution/requestApproval' || pending._codexMethod === 'execCommandApproval') {
+    if (approved) {
+      sendJsonRpc(session.codexAppServer, {
+        jsonrpc: '2.0',
+        id: pending._rpcId,
+        result: { decision: 'accept' },
+      });
+      sendSystem(ws, '✅ 已批准命令执行。');
+    } else {
+      sendJsonRpc(session.codexAppServer, {
+        jsonrpc: '2.0',
+        id: pending._rpcId,
+        result: { decision: 'reject' },
+      });
+      sendSystem(ws, '🚫 已拒绝命令执行。');
+    }
+  }
+
+  return true;
+}
+
+function stop(session, options = {}) {
+  if (session.codexAppServer) {
+    try {
+      session.codexAppServer.kill();
+    } catch {
+      // ignore
+    }
+    session.codexAppServer = null;
+  }
+  stopSessionProcess(session, options);
+  clearTurnState(session);
+  if (session.codexPendingRequests) {
+    for (const [, pending] of session.codexPendingRequests) {
+      pending.reject(new Error('用户已停止'));
+    }
+    session.codexPendingRequests.clear();
+  }
+  if (session._threadStartResolve) {
+    session._threadStartResolve = null;
+    session._threadStartReject = null;
+  }
+}
+
+function drainQueue(ws, session, config) {
+  const next = session.messageQueue.shift();
+  if (!next) return;
+  session._lastConfig = config;
+  setImmediate(() => execute(next, ws, session, config));
+}
+
+module.exports = {
+  execute,
+  resolvePendingDanger,
+  resolvePendingPermission,
+  stop,
+};