linco-connect 1.0.0

package/src/claudeRunner.js

@@ -0,0 +1,564 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { isDangerousCommand } = require('./danger');
+const { buildOutboxSystemPrompt, getOutboxDir } = require('./outgoingAttachmentHandler');
+const { send, sendError, sendSystem } = require('./protocol');
+const { appendTextStream, flushTextStream, resetTextStream } = require('./streamBuffer');
+const { persistClaudeSessionId, stopAgentProcess, updateAgentSessionHistory } = require('./session');
+
+function executeClaudeQuery(input, ws, session, config) {
+  const textForCheck = typeof input === 'string' ? input : extractText(input);
+
+  if (isDangerousCommand(textForCheck)) {
+    config.logger?.warn('dangerous command detected', { sessionId: session.id, chars: textForCheck.length });
+    const preview = textForCheck.slice(0, 200);
+    send(ws, 'danger_warning', {
+      text: `⚠️ 检测到可能的危险操作，请确认是否继续执行：\n\n"${preview}${textForCheck.length > 200 ? '...' : ''}"`
+    });
+
+    session.pendingDanger = {
+      kind: 'message',
+      resolve: () => enqueueClaudeQuery(input, ws, session, config),
+    };
+    return;
+  }
+
+  enqueueClaudeQuery(input, ws, session, config);
+}
+
+function enqueueClaudeQuery(input, ws, session, config) {
+  if (session.isTurnActive) {
+    if (session.messageQueue.length >= config.maxMessageQueue) {
+      config.logger?.warn('message queue full', {
+        sessionId: session.id,
+        queueLength: session.messageQueue.length,
+        maxQueue: config.maxMessageQueue,
+      });
+      sendError(ws, '❌ 消息队列已满，请稍后再发送。');
+      return;
+    }
+    session.messageQueue.push({ input, ws, config });
+    config.logger?.info('message queued', {
+      sessionId: session.id,
+      queueLength: session.messageQueue.length,
+      maxQueue: config.maxMessageQueue,
+    });
+    sendSystem(ws, `⏳ Claude 正在回复，已加入队列（${session.messageQueue.length}）`);
+    return;
+  }
+
+  sendClaudeQuery(input, ws, session, config);
+}
+
+function sendClaudeQuery(input, ws, session, config) {
+  const child = ensureClaudeProcess(ws, session, config);
+  if (!child) return;
+
+  const payload = buildClaudePayload(input, session, config);
+  const resumeId = session.agentSessionId || session.claudeSessionId;
+  config.logger?.info('claude turn started', {
+    sessionId: session.id,
+    chars: extractText(input).length,
+    resumeId: resumeId || '(new session)',
+    workspace: session.workspace,
+  });
+  session.isTurnActive = true;
+  session.currentInputForNoOutput = input;
+  resetStreamForTurn(session);
+  sendSystem(ws, `🤔 Claude 正在思考... (resume: ${resumeId || 'new'})`);
+
+  try {
+    writeClaudeJson(session, payload);
+  } catch (err) {
+    config.logger?.error('claude stdin write failed', { sessionId: session.id, error: err.message });
+    session.isTurnActive = false;
+    session.currentInputForNoOutput = null;
+    sendError(ws, `❌ 发送消息到 Claude 失败: ${err.message}`);
+  }
+}
+
+function ensureClaudeProcess(ws, session, config) {
+  if (session.claudeProcess && session.claudeProcess.exitCode === null && !session.claudeProcess.killed) {
+    return session.claudeProcess;
+  }
+
+  const args = [
+    '--input-format', 'stream-json',
+    '--output-format', 'stream-json',
+    '--include-partial-messages',
+    '--permission-prompt-tool', 'stdio',
+    '--verbose',
+    '--append-system-prompt', buildOutboxSystemPrompt(session, config),
+  ];
+
+  if (config.claudeAddRuntimeDir !== false && session.runtimeDir) {
+    args.push('--add-dir', session.runtimeDir);
+  }
+
+  const resumeSessionId = session.agentSessionId || session.claudeSessionId;
+  if (resumeSessionId) {
+    args.push('--resume', resumeSessionId);
+  }
+
+  const env = { ...process.env };
+  if (config.gitBashEnv) {
+    env.CLAUDE_CODE_GIT_BASH_PATH = config.gitBashEnv;
+  }
+  delete env.CLAUDECODE;
+
+  const spawnTarget = resolveClaudeSpawnTarget(config.claudeBin);
+  config.logger?.info('claude process starting', {
+    sessionId: session.id,
+    cwd: session.workspace,
+    command: config.claudeBin,
+    spawnCommand: spawnTarget.command,
+    resume: !!resumeSessionId,
+    resumeSessionId: resumeSessionId || '(none)',
+    fullCommand: `${spawnTarget.command} ${args.join(' ')}`,
+  });
+
+  const child = spawn(spawnTarget.command, args, {
+    cwd: session.workspace,
+    env,
+    shell: spawnTarget.shell,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+
+  session.claudeProcess = child;
+  session.agentProcess = child;
+  session.stdoutBuffer = '';
+
+  child.stdout.on('data', (chunk) => {
+    if (session.claudeProcess !== child) return;
+
+    // Check first line for session_id to verify resume worked
+    if (session._checkingResume) {
+      session._checkingResume = false;
+    } else {
+      const raw = chunk.toString();
+      const firstLine = raw.split('\n').find(l => l.trim());
+      if (firstLine) {
+        try {
+          const parsed = JSON.parse(firstLine);
+          if (parsed.type === 'system' && parsed.subtype === 'init') {
+            session._checkingResume = true;
+            const actualId = parsed.session_id;
+            const expectedId = resumeSessionId;
+            config.logger?.info('claude session initialized', {
+              sessionId: session.id,
+              expectedResumeId: expectedId || '(none)',
+              actualSessionId: actualId,
+              resumed: actualId === expectedId,
+            });
+          }
+        } catch (e) {}
+      }
+    }
+
+    handleClaudeStdoutData(chunk, ws, session, config);
+  });
+
+  child.stderr.on('data', (data) => {
+    if (session.claudeProcess !== child) return;
+    const errText = data.toString().trim();
+    if (errText) {
+      config.logger?.warn('claude stderr', { sessionId: session.id, stderr: errText });
+    }
+  });
+
+  child.on('close', (code) => {
+    config.logger?.info('claude process closed', { sessionId: session.id, code });
+    if (session.claudeProcess !== child) return;
+    session.claudeProcess = null;
+    flushAssistantText(ws, session);
+    if (session.isTurnActive) {
+      session.isTurnActive = false;
+      session.currentInputForNoOutput = null;
+      sendError(ws, code === 0 || code === null ? '⚠️ Claude 会话已结束。' : `❌ Claude 进程退出，退出码: ${code}`);
+      drainMessageQueue(ws, session, config);
+    }
+  });
+
+  child.on('error', (err) => {
+    config.logger?.error('claude process spawn error', { sessionId: session.id, error: err.message });
+    if (session.claudeProcess !== child) return;
+    session.claudeProcess = null;
+    session.isTurnActive = false;
+    session.currentInputForNoOutput = null;
+    flushAssistantText(ws, session);
+    sendError(ws, `❌ 无法启动 Claude: ${err.message}\n请确认已安装 Claude Code 并设置好 API 密钥。`);
+  });
+
+  return child;
+}
+
+function resolveClaudeSpawnTarget(command) {
+  if (process.platform !== 'win32') {
+    return { command, shell: false };
+  }
+
+  const normalized = path.normalize(command || '');
+  if (normalized.toLowerCase().endsWith('.cmd')) {
+    const exe = path.join(path.dirname(normalized), 'node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe');
+    if (fs.existsSync(exe)) {
+      return { command: exe, shell: false };
+    }
+  }
+
+  return { command, shell: true };
+}
+
+function writeClaudeJson(session, payload) {
+  const child = session.claudeProcess;
+  if (!child || child.killed || child.exitCode !== null || child.stdin.destroyed) {
+    throw new Error('Claude 进程未运行');
+  }
+  child.stdin.write(JSON.stringify(payload) + '\n');
+}
+
+function handleClaudeStdoutData(chunk, ws, session, config) {
+  session.stdoutBuffer += chunk.toString();
+  const lines = session.stdoutBuffer.split('\n');
+  session.stdoutBuffer = lines.pop() || '';
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      handleClaudeMessage(JSON.parse(line), ws, session, config);
+    } catch (err) {
+      config.logger?.warn('claude stream-json parse failed', { sessionId: session.id, error: err.message });
+    }
+  }
+}
+
+function buildClaudePayload(input, session, config) {
+  return {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: addOutboxHint(addStyleHint(input, config), session, config),
+    },
+  };
+}
+
+function addStyleHint(input, config) {
+  const text = extractText(input).trim();
+  if (!text || text.startsWith('/')) return input;
+
+  const hint = `系统样式要求：${config.systemPrompt}`;
+
+  if (Array.isArray(input)) {
+    return [...input, { type: 'text', text: hint }];
+  }
+
+  return `${String(input || '')}\n\n${hint}`;
+}
+
+function addOutboxHint(input, session, config) {
+  const text = extractText(input);
+  if (!shouldAddOutboxHint(text)) return input;
+
+  const hint = `系统提示：用户正在要求发送文件/图片。请将要发送给用户的最终文件保存或复制到以下 outbox 目录，系统只会自动发送这个目录中的新文件：\n${getOutboxDir(session, config)}`;
+
+  if (Array.isArray(input)) {
+    return [...input, { type: 'text', text: hint }];
+  }
+
+  return `${String(input || '')}\n\n${hint}`;
+}
+
+function shouldAddOutboxHint(text) {
+  return /发送.*(文件|图片)|把.*(文件|图片).*发|发给我|发送给我|文件发送|发文件|下载文件/.test(text);
+}
+
+function handleClaudeMessage(parsed, ws, session, config) {
+  updateClaudeSessionId(parsed, session);
+
+  switch (parsed.type) {
+    case 'stream_event':
+      handleStreamEvent(parsed, ws, session);
+      break;
+    case 'assistant':
+      handleAssistantMessage(parsed, ws, session, config);
+      break;
+    case 'user':
+      handleUserMessage(parsed, ws, session, config);
+      break;
+    case 'result':
+      flushAssistantText(ws, session);
+      if (session.streamState.assistantStarted) {
+        send(ws, 'assistant_end');
+      } else {
+        sendSystem(ws, noOutputMessage(session));
+      }
+      if (parsed.usage) {
+        const u = parsed.usage;
+        if (!session.usage) {
+          session.usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+        }
+        if (u.input_tokens) session.usage.inputTokens += u.input_tokens;
+        if (u.output_tokens) session.usage.outputTokens += u.output_tokens;
+        if (u.cache_read_input_tokens) session.usage.cacheReadTokens += u.cache_read_input_tokens;
+        if (u.cache_creation_input_tokens) session.usage.cacheCreationTokens += u.cache_creation_input_tokens;
+      }
+      session.messageCount = (session.messageCount || 0) + 1;
+      updateAgentSessionHistory(session);
+      config.logger?.info('claude turn completed', {
+        sessionId: session.id,
+        queueLength: session.messageQueue.length,
+        usage: session.usage,
+        messageCount: session.messageCount,
+      });
+      session.isTurnActive = false;
+      session.currentInputForNoOutput = null;
+      drainMessageQueue(ws, session, config);
+      break;
+    case 'control_request':
+      handleControlRequest(parsed, ws, session, config);
+      break;
+    case 'control_cancel_request':
+      if (session.pendingPermission?.requestId === parsed.request_id) {
+        session.pendingPermission = null;
+      }
+      break;
+  }
+}
+
+function noOutputMessage(session) {
+  const input = session.currentInputForNoOutput;
+  const text = extractText(input).trim();
+  if (text.startsWith('/')) {
+    return '✅ 操作完成，但 Claude Code 没有返回可展示内容。部分原生斜杠命令在 Linco 的 stream-json 模式下可能只在 CLI/TUI 内部生效。';
+  }
+  return '✅ 操作完成（无输出）';
+}
+
+function updateClaudeSessionId(parsed, session) {
+  if (parsed.session_id) {
+    persistClaudeSessionId(session, parsed.session_id);
+  }
+}
+
+function handleStreamEvent(parsed, ws, session) {
+  const event = parsed.event || {};
+  if (event.type !== 'content_block_delta') return;
+
+  const delta = event.delta || {};
+  if (delta.type === 'text_delta' && delta.text) {
+    session.sawPartialAssistantText = true;
+    appendAssistantText(delta.text, ws, session);
+  }
+}
+
+function handleAssistantMessage(parsed, ws, session, config) {
+  const content = parsed.message?.content;
+  if (!Array.isArray(content)) return;
+
+  for (const block of content) {
+    if (block.type === 'text' && block.text) {
+      if (!session.sawPartialAssistantText) {
+        appendAssistantText(block.text, ws, session);
+      }
+    } else if (block.type === 'tool_use') {
+      config.logger?.info('claude tool use', {
+        sessionId: session.id,
+        toolName: block.name || 'tool',
+        toolUseId: block.id || '',
+      });
+      send(ws, 'tool_call', {
+        id: block.id || '',
+        name: block.name || 'tool',
+        input: formatJson(block.input),
+      });
+    }
+  }
+}
+
+function handleUserMessage(parsed, ws, session, config) {
+  const content = parsed.message?.content;
+  if (!Array.isArray(content)) return;
+
+  for (const block of content) {
+    if (block.type === 'tool_result') {
+      config.logger?.info('claude tool result', {
+        sessionId: session.id,
+        toolUseId: block.tool_use_id || '',
+        isError: !!block.is_error,
+      });
+      send(ws, 'tool_result', {
+        toolUseId: block.tool_use_id || '',
+        isError: !!block.is_error,
+        output: formatToolResult(block.content),
+      });
+    }
+  }
+}
+
+function appendAssistantText(text, ws, session) {
+  appendTextStream(text, ws, session.streamState);
+}
+
+function flushAssistantText(ws, session) {
+  flushTextStream(ws, session.streamState);
+}
+
+function resetStreamForTurn(session) {
+  session.streamState.onStart = (startWs) => {
+    send(startWs, 'thinking_clear');
+    send(startWs, 'assistant_start');
+  };
+  resetTextStream(session.streamState);
+  session.sawPartialAssistantText = false;
+  session._checkingResume = false;
+}
+
+function handleControlRequest(parsed, ws, session, config) {
+  const requestID = parsed.request_id;
+  const request = parsed.request || {};
+  if (request.subtype !== 'can_use_tool') return;
+
+  const toolName = request.tool_name || 'tool';
+  const input = sanitizeToolInput(toolName, request.input || {});
+  const inputText = summarizeInput(input);
+
+  session.pendingPermission = {
+    requestId: requestID,
+    toolName,
+    input,
+  };
+
+  config.logger?.info('permission request received', {
+    sessionId: session.id,
+    requestId: requestID,
+    toolName,
+  });
+
+  send(ws, 'permission_request', {
+    requestId: requestID,
+    toolName,
+    input: inputText,
+  });
+}
+
+function respondPermission(session, approved) {
+  const pending = session.pendingPermission;
+  if (!pending) return false;
+
+  const response = approved
+    ? { behavior: 'allow', updatedInput: pending.input || {} }
+    : { behavior: 'deny', message: 'The user denied this tool use. Stop and wait for the user\'s instructions.' };
+
+  writeClaudeJson(session, {
+    type: 'control_response',
+    response: {
+      subtype: 'success',
+      request_id: pending.requestId,
+      response,
+    },
+  });
+  session.pendingPermission = null;
+  return true;
+}
+
+function resolvePendingPermission(approved, ws, session, config) {
+  if (!session.pendingPermission) return false;
+
+  try {
+    const pending = session.pendingPermission;
+    respondPermission(session, approved);
+    config.logger?.info('permission response sent', {
+      sessionId: session.id,
+      requestId: pending?.requestId,
+      toolName: pending?.toolName,
+      approved,
+    });
+    sendSystem(ws, approved ? '✅ 已批准工具使用。' : '🚫 已拒绝工具使用。');
+  } catch (err) {
+    sendError(ws, `❌ 回复权限请求失败: ${err.message}`);
+  }
+  return true;
+}
+
+function resolvePendingDanger(approved, ws, session, config) {
+  if (!session.pendingDanger) return false;
+
+  const { resolve } = session.pendingDanger;
+  session.pendingDanger = null;
+
+  config.logger?.info('danger confirmation resolved', { sessionId: session.id, approved });
+
+  if (approved) {
+    sendSystem(ws, '⚠️ 危险操作已批准，执行中...');
+    resolve();
+  } else {
+    sendSystem(ws, '🚫 已取消危险操作');
+  }
+  return true;
+}
+
+function drainMessageQueue(ws, session, config) {
+  if (session.isTurnActive || session.pendingPermission) return;
+  const next = session.messageQueue.shift();
+  if (!next) return;
+  config.logger?.info('message dequeued', { sessionId: session.id, queueLength: session.messageQueue.length });
+  sendClaudeQuery(next.input, next.ws || ws, session, next.config || config);
+}
+
+function extractText(input) {
+  if (!Array.isArray(input)) return String(input || '');
+  return input
+    .filter(block => block?.type === 'text')
+    .map(block => block.text || '')
+    .join('\n');
+}
+
+function formatJson(value) {
+  if (value === undefined) return '';
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+function formatToolResult(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map(item => {
+      if (typeof item === 'string') return item;
+      if (item?.type === 'text') return item.text || '';
+      return formatJson(item);
+    }).filter(Boolean).join('\n');
+  }
+  return formatJson(content);
+}
+
+function sanitizeToolInput(toolName, input) {
+  if (toolName !== 'Read' || !input || typeof input !== 'object' || Array.isArray(input)) return input;
+  if (input.pages !== '') return input;
+
+  const sanitized = { ...input };
+  delete sanitized.pages;
+  return sanitized;
+}
+
+function summarizeInput(input) {
+  try {
+    const text = JSON.stringify(input, null, 2);
+    return text.length > 1200 ? text.slice(0, 1200) + '\n...' : text;
+  } catch {
+    return String(input);
+  }
+}
+
+module.exports = {
+  buildClaudePayload,
+  execute: executeClaudeQuery,
+  executeClaudeQuery,
+  flushAssistantText,
+  resolvePendingDanger,
+  resolvePendingPermission,
+  stop: stopAgentProcess,
+};