linco-connect 1.0.0

package/src/imConnector.js

@@ -0,0 +1,488 @@
+const { WebSocket } = require('ws');
+const { executeAgentQuery, resolvePendingDanger, resolvePendingPermission } = require('./agentRunner');
+const { handleMessageWithAttachments } = require('./attachmentHandler');
+const { startOutboxWatcher } = require('./outgoingAttachmentHandler');
+const { send, sendError, sendSystem } = require('./protocol');
+const { cleanupSession, createSession } = require('./session');
+const { handleSlashCommand } = require('./slashCommands');
+const {
+  isLincoMessage,
+  mapLocalEventToLinco,
+  lincoFilesToAttachments,
+  buildStreamId,
+  lincoMetaDefaults,
+  pruneUndefined,
+} = require('./lincoProtocol');
+
+function startImConnector(config) {
+  const connectors = startImConnectors(config);
+  return connectors[0] || null;
+}
+
+function startImConnectors(config) {
+  if (!config.im?.enabled) return [];
+  const agents = Object.entries(config.agents || { claude: { enabled: true } })
+    .filter(([, agent]) => agent?.enabled);
+
+  const connectors = agents.map(([agentType, agent]) => {
+    const connector = new ImConnector(config, agentType, agent);
+    connector.start();
+    return connector;
+  });
+
+  return connectors;
+}
+
+class ImConnector {
+  constructor(config, agentType = 'claude', agentConfig = {}) {
+    this.config = config;
+    this.agentType = agentType;
+    this.agentConfig = agentConfig;
+    this.sessions = new Map();
+    this.ws = null;
+    this.stopped = false;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    this.connectTimer = null;
+    this.pendingEvents = [];
+  }
+
+  start() {
+    if (!this.config.im?.appId || !this.config.im?.appSecret) {
+      console.log(`[IM:${this.agentType}] 远端 IM 已启用，但缺少 Linco token，已跳过连接。`);
+      return;
+    }
+
+    this.connect();
+  }
+
+  stop() {
+    this.stopped = true;
+    clearTimeout(this.reconnectTimer);
+    clearTimeout(this.connectTimer);
+    clearInterval(this.heartbeatTimer);
+    this.reconnectTimer = null;
+    this.connectTimer = null;
+    this.heartbeatTimer = null;
+
+    if (this.ws) {
+      const ws = this.ws;
+      if (ws.readyState === WebSocket.OPEN) {
+        this.sendPresence('offline', 'shutdown');
+      }
+      this.ws = null;
+      try {
+        ws.close();
+      } catch {}
+    }
+
+    for (const session of this.sessions.values()) {
+      clearInterval(session.remoteIdleTimer);
+      this.unregisterSession(session);
+      cleanupSession(session);
+    }
+    this.sessions.clear();
+  }
+
+  connect() {
+    if (this.stopped) return;
+
+    let url;
+    try {
+      url = this.buildUrl();
+    } catch (err) {
+      console.log(`[IM:${this.agentType}] 远端 IM 地址无效: ${err.message}`);
+      this.scheduleReconnect();
+      return;
+    }
+
+    console.log(`[IM:${this.agentType}] 正在连接远端 IM: ${safeUrlForLog(url)}`);
+    const ws = new WebSocket(url, {
+      maxPayload: this.config.maxWsPayloadBytes,
+    });
+    this.ws = ws;
+
+    this.connectTimer = setTimeout(() => {
+      if (this.ws === ws && ws.readyState === WebSocket.CONNECTING) {
+        ws.terminate();
+      }
+    }, this.config.im.connectTimeoutMs).unref?.();
+
+    ws.on('open', () => {
+      if (this.ws !== ws) return;
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+      this.reconnectAttempts = 0;
+      console.log(`[IM:${this.agentType}] 远端 IM 已连接。`);
+      this.sendPresence('online');
+      this.flushPendingEvents();
+      this.startHeartbeat();
+    });
+
+    ws.on('message', (data) => {
+      if (this.ws !== ws) return;
+      this.handleRawMessage(data);
+    });
+
+    ws.on('close', () => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+      console.log(`[IM:${this.agentType}] 远端 IM 连接已断开。`);
+      this.scheduleReconnect();
+    });
+
+    ws.on('error', (err) => {
+      if (this.ws !== ws) return;
+      console.log(`[IM:${this.agentType}] 远端 IM 连接错误: ${err.message}`);
+    });
+  }
+
+  buildUrl() {
+    const url = new URL(this.agentConfig.wsUrl || this.config.im.wsUrl);
+    if (url.protocol !== 'wss:' && !this.config.im.allowInsecureWs) {
+      throw new Error('远端 IM 默认要求 wss；本地调试可设置 LINCO_IM_ALLOW_INSECURE_WS=1');
+    }
+    url.searchParams.delete('appId');
+    url.searchParams.delete('appSecret');
+    url.searchParams.set('token', `${this.config.im.appId}:${this.config.im.appSecret}`);
+    return url.toString();
+  }
+
+  startHeartbeat() {
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isOpen()) return;
+      this.sendRemote({ type: 'ping', from: this.agentType, ts: Date.now() });
+    }, this.config.im.heartbeatMs);
+    this.heartbeatTimer.unref?.();
+  }
+
+  scheduleReconnect() {
+    if (this.stopped) return;
+    clearTimeout(this.reconnectTimer);
+
+    const min = this.config.im.reconnectMinMs;
+    const max = this.config.im.reconnectMaxMs;
+    const baseDelay = Math.min(max, min * (2 ** this.reconnectAttempts));
+    const jitter = Math.floor(baseDelay * 0.2 * Math.random());
+    const delay = Math.min(max, baseDelay + jitter);
+    this.reconnectAttempts += 1;
+
+    console.log(`[IM:${this.agentType}] ${delay}ms 后重连远端 IM。`);
+    this.reconnectTimer = setTimeout(() => this.connect(), delay);
+    this.reconnectTimer.unref?.();
+  }
+
+  handleRawMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data.toString());
+    } catch {
+      console.log('[IM] 收到无法解析的消息。');
+      return;
+    }
+
+    if (!isLincoMessage(msg)) return;
+    this.handleMessage(msg);
+  }
+
+  handleMessage(msg) {
+    if (msg.type === 'ping') {
+      this.sendRemote({ type: 'pong', from: this.agentType, ts: Date.now() });
+      return;
+    }
+
+    if (msg.type === 'pong') return;
+
+    if (msg.type === 'inbound_message') {
+      this.handleInboundMessage(msg);
+      return;
+    }
+
+    const sessionKey = lincoSessionKey(msg);
+    if (!sessionKey) return;
+
+    const session = this.sessions.get(sessionKey);
+    if (!session) return;
+    session.lastRemoteActivityAt = Date.now();
+
+    if (msg.type === 'danger_confirm') {
+      if (!resolvePendingDanger(!!msg.approved, session.ws, session, this.config)) {
+        sendError(session.ws, '没有待确认的危险操作');
+      }
+      return;
+    }
+
+    if (!resolvePendingPermission(!!msg.approved, session.ws, session, this.config)) {
+      sendError(session.ws, '没有待确认的工具权限请求');
+    }
+  }
+
+  handleInboundMessage(msg) {
+    const to = String(msg.to || this.agentType);
+    if (!['agent', 'claude', this.agentType].includes(to)) return;
+
+    const sessionKey = lincoSessionKey(msg);
+    if (!sessionKey) {
+      this.sendLincoMessage({ ...lincoMetaFromMessage(msg), type: 'outbound_message', text: '消息缺少 sessionKey' });
+      return;
+    }
+
+    const session = this.getOrCreateSession(sessionKey, msg);
+    if (!session) return;
+    session.lastRemoteActivityAt = Date.now();
+    const linco = lincoMetaFromMessage(msg);
+    linco.streamId = linco.streamId || buildStreamId(msg);
+    linco.fullText = '';
+    session.linco = linco;
+
+    this.handleChatMessage(msg, session);
+  }
+
+  handleChatMessage(msg, session) {
+    const rawText = String(msg.text || '').trim();
+    const attachments = lincoFilesToAttachments(msg.files);
+    const ws = createRemoteAdapter(this, session, session.linco);
+    if (!session.isTurnActive) session.ws = ws;
+
+    if (rawText.startsWith('/') && attachments.length === 0) {
+      if (handleSlashCommand(rawText, ws, session, this.config)) return;
+    }
+
+    handleMessageWithAttachments({ text: rawText, attachments }, ws, session, this.config, executeAgentQuery);
+  }
+
+  getOrCreateSession(sessionKey, msg) {
+    const existing = this.sessions.get(sessionKey);
+    if (existing) return existing;
+
+    let session;
+    try {
+      session = createSession(this.config, { externalSessionId: sessionKey, agentType: this.agentType });
+    } catch (err) {
+      this.sendLincoMessage({ ...lincoMetaFromMessage(msg), type: 'outbound_message', text: `会话初始化失败: ${err.message}` });
+      return null;
+    }
+
+    if (!this.registerSession(session)) {
+      cleanupSession(session);
+      this.sendLincoMessage({ ...lincoMetaFromMessage(msg), type: 'outbound_message', text: '该 sessionKey 已有活动连接' });
+      return null;
+    }
+
+    const linco = lincoMetaFromMessage(msg);
+    linco.streamId = linco.streamId || buildStreamId(msg);
+    linco.fullText = '';
+    session.linco = linco;
+    session.ws = createRemoteAdapter(this, session, linco);
+    session.lastRemoteActivityAt = Date.now();
+    this.sessions.set(session.id, session);
+    startOutboxWatcher(session.ws, session, this.config);
+    this.startIdleTimer(session);
+
+    console.log(`[IM:${this.agentType}] 新远端会话 [${session.id}]，工作目录: ${session.workspace}`);
+    sendSessionInfo(session.ws, session, this.config);
+    sendSystem(session.ws, `已连接到 ${this.agentType} Agent
+工作目录: ${session.workspace}
+输入 /help 查看可用命令`);
+    return session;
+  }
+
+  registerSession(session) {
+    const activeSessions = this.config.activeSessions || new Map();
+    this.config.activeSessions = activeSessions;
+    if (activeSessions.has(session.activeKey)) return false;
+    activeSessions.set(session.activeKey, session);
+    return true;
+  }
+
+  unregisterSession(session) {
+    if (this.config.activeSessions?.get(session.activeKey) === session) {
+      this.config.activeSessions.delete(session.activeKey);
+    }
+  }
+
+  startIdleTimer(session) {
+    clearInterval(session.remoteIdleTimer);
+    session.remoteIdleTimer = setInterval(() => {
+      const idleMs = Date.now() - (session.lastRemoteActivityAt || Date.now());
+      if (idleMs >= this.config.im.idleSessionMs) {
+        this.closeSession(session.id);
+      }
+    }, Math.min(this.config.im.idleSessionMs, 60 * 1000));
+    session.remoteIdleTimer.unref?.();
+  }
+
+  closeSession(sessionKey) {
+    const session = this.sessions.get(sessionKey);
+    if (!session) return;
+
+    clearInterval(session.remoteIdleTimer);
+    this.sessions.delete(sessionKey);
+    this.unregisterSession(session);
+    cleanupSession(session);
+    console.log(`[IM:${this.agentType}] 远端会话结束 [${session.id}]`);
+  }
+
+  sendLincoMessage(payload) {
+    const meta = lincoMetaDefaults(this.config, payload);
+    const message = pruneUndefined({
+      ...payload,
+      from: payload.from || this.agentType,
+      to: payload.to || 'robot',
+      source: payload.source || 'ws',
+      ts: payload.ts || Date.now(),
+      accountId: payload.accountId || meta.accountId,
+      agentId: payload.agentId || meta.agentId,
+      channel: payload.channel || meta.channel,
+    });
+    return this.sendRemote(message);
+  }
+
+  sendPresence(status, reason) {
+    const meta = lincoMetaDefaults(this.config);
+    return this.sendRemote(pruneUndefined({
+      type: 'presence_event',
+      from: this.agentType,
+      to: 'robot',
+      source: 'ws',
+      ts: Date.now(),
+      accountId: meta.accountId,
+      agentId: meta.agentId,
+      channel: meta.channel,
+      status,
+      reason,
+    }));
+  }
+
+  sendRemote(payload) {
+    if (!this.isOpen()) {
+      this.queueRemote(payload);
+      return false;
+    }
+    this.ws.send(JSON.stringify(payload));
+    return true;
+  }
+
+  queueRemote(payload) {
+    if (payload?.type === 'ping' || payload?.type === 'pong') return;
+    this.pendingEvents.push(payload);
+    const maxPendingEvents = this.config.im.maxPendingEvents;
+    if (this.pendingEvents.length > maxPendingEvents) {
+      this.pendingEvents.splice(0, this.pendingEvents.length - maxPendingEvents);
+    }
+  }
+
+  flushPendingEvents() {
+    if (!this.isOpen() || this.pendingEvents.length === 0) return;
+    const pending = this.pendingEvents.splice(0);
+    for (const payload of pending) {
+      this.ws.send(JSON.stringify(payload));
+    }
+  }
+
+  isOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+}
+
+function createRemoteAdapter(connector, session, lincoMeta = session.linco || {}) {
+  const linco = {
+    ...lincoMeta,
+    streamId: lincoMeta.streamId || `linco-stream-${Date.now()}`,
+    fullText: lincoMeta.fullText || '',
+  };
+
+  return {
+    send(jsonString) {
+      let event;
+      try {
+        event = JSON.parse(jsonString);
+      } catch {
+        event = { type: 'system', text: String(jsonString || '') };
+      }
+
+      const payload = mapLocalEventToLinco(event, session, connector.config, linco);
+      if (!payload) return;
+      if (Array.isArray(payload)) {
+        for (const item of payload) connector.sendLincoMessage(item);
+        return;
+      }
+      connector.sendLincoMessage(payload);
+    },
+  };
+}
+
+function sendSessionInfo(ws, session, config) {
+  send(ws, 'session_info', {
+    sessionKey: session.id,
+    storageId: session.storageId,
+    agentType: session.agentType,
+    agentSessionId: session.agentSessionId,
+    workspace: session.workspace,
+    runtime: {
+      dir: session.runtimeDir,
+      attachmentsDir: session.attachmentsDir,
+      outboxDir: session.outboxDir,
+    },
+    upload: {
+      maxCount: config.maxAttachmentCount,
+      maxFileBytes: config.maxAttachmentBytes,
+      maxTotalBytes: config.maxTotalAttachmentBytes,
+      blockedExtensions: config.allowUnsafeAttachments ? [] : config.unsafeAttachmentExtensions,
+    },
+    capabilities: {
+      incomingAttachments: true,
+      multimodalImages: session.agentType === 'claude',
+      outgoingAttachments: true,
+      remoteIm: true,
+      agentType: session.agentType,
+    },
+  });
+}
+
+function lincoSessionKey(msg) {
+  return String(msg.sessionKey || '').trim();
+}
+
+function lincoMetaFromMessage(msg) {
+  const userId = stringOrUndefined(msg.userId || msg.targetId);
+  return pruneUndefined({
+    accountId: stringOrUndefined(msg.accountId),
+    agentId: stringOrUndefined(msg.agentId),
+    chatType: stringOrUndefined(msg.chatType || msg.targetType),
+    targetType: stringOrUndefined(msg.targetType || msg.chatType),
+    targetId: stringOrUndefined(msg.targetId || msg.userId),
+    userId,
+    messageId: stringOrUndefined(msg.messageId),
+    streamId: stringOrUndefined(msg.streamId) || buildStreamId(msg),
+    sessionKey: lincoSessionKey(msg),
+    channel: stringOrUndefined(msg.channel),
+  });
+}
+
+function stringOrUndefined(value) {
+  const text = String(value || '').trim();
+  return text || undefined;
+}
+
+function safeUrlForLog(value) {
+  try {
+    const url = new URL(value);
+    url.searchParams.delete('token');
+    url.searchParams.delete('appSecret');
+    return url.toString();
+  } catch {
+    return '(invalid url)';
+  }
+}
+
+module.exports = {
+  startImConnector,
+  startImConnectors,
+};

package/src/imageHandler.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('./config');
+const { sendError, sendSystem } = require('./protocol');
+
+function handleImageMessage(msg, ws, session, executeAgentQuery) {
+  const { base64, mimeType, text } = msg;
+  if (!base64) {
+    sendError(ws, '❌ 图片数据为空');
+    return;
+  }
+
+  const ext = mimeType?.split('/')[1] || 'png';
+  const imgFile = path.join(session.attachmentsDir, `.upload_${Date.now()}.${ext}`);
+  let imageSize = 0;
+
+  try {
+    ensureDir(session.attachmentsDir);
+    const buffer = Buffer.from(base64, 'base64');
+    imageSize = buffer.length;
+    fs.writeFileSync(imgFile, buffer);
+  } catch (err) {
+    sendError(ws, `❌ 保存图片失败: ${err.message}`);
+    return;
+  }
+
+  sendSystem(ws, `🖼️ 图片已接收 (${(imageSize / 1024).toFixed(1)} KB)`);
+
+  const prompt = text || '请用中文描述这张图片的内容。';
+  executeAgentQuery([
+    { type: 'text', text: `请始终使用中文直接回答用户。不要描述你的内部工具调用、执行步骤或实现细节，除非用户明确询问。\n\n用户请求：\n${prompt}` },
+    { type: 'image', source: { type: 'base64', media_type: mimeType || 'image/png', data: base64 } }
+  ], ws, session);
+}
+
+module.exports = {
+  handleImageMessage,
+};