linco-connect 1.0.0

package/src/lincoProtocol.js

@@ -0,0 +1,209 @@
+const fs = require('fs');
+
+const LINCO_INBOUND_TYPES = new Set(['ping', 'pong', 'inbound_message', 'danger_confirm', 'permission_response']);
+
+function isLincoMessage(msg) {
+  return msg && typeof msg === 'object' && LINCO_INBOUND_TYPES.has(msg.type);
+}
+
+function toInternal(msg) {
+  if (msg.type === 'inbound_message') {
+    return {
+      _lincoMode: true,
+      type: 'message',
+      text: String(msg.text || '').trim(),
+      attachments: lincoFilesToAttachments(msg.files),
+    };
+  }
+  return { ...msg };
+}
+
+function createLincoAdapter(rawWs, session, config) {
+  const linco = session.linco || {};
+  linco.fullText = linco.fullText || '';
+  linco.streamId = linco.streamId || `linco-stream-${Date.now()}`;
+  session.linco = linco;
+
+  const closed = { current: false };
+
+  return {
+    send(jsonString) {
+      let event;
+      try {
+        event = JSON.parse(jsonString);
+      } catch {
+        event = { type: 'system', text: String(jsonString || '') };
+      }
+      const payload = mapLocalEventToLinco(event, session, config, linco);
+      if (!payload || closed.current) return;
+      const wrapped = wrapLincoEnvelope(payload, config);
+      if (Array.isArray(wrapped)) {
+        for (const item of wrapped) rawWs.send(JSON.stringify(item));
+        return;
+      }
+      rawWs.send(JSON.stringify(wrapped));
+    },
+    rawSend(data) {
+      if (!closed.current) rawWs.send(data);
+    },
+    close() {
+      closed.current = true;
+    },
+    get readyState() {
+      return rawWs.readyState;
+    },
+  };
+}
+
+function wrapLincoEnvelope(payload, config) {
+  const meta = lincoMetaDefaults(config, {});
+  return pruneUndefined({
+    ...payload,
+    from: payload.from || (config.agents ? Object.keys(config.agents)[0] : 'claude'),
+    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,
+  });
+}
+
+function mapLocalEventToLinco(event, session, config, linco) {
+  const meta = lincoMetaDefaults(config, linco || {});
+  const base = {
+    accountId: meta.accountId,
+    agentId: meta.agentId,
+    userId: meta.userId,
+    chatType: meta.chatType,
+    targetType: meta.targetType,
+    targetId: meta.targetId,
+    sessionKey: session.id,
+    streamId: meta.streamId,
+    messageId: meta.messageId,
+  };
+
+  switch (event.type) {
+    case 'assistant_start':
+      linco.fullText = '';
+      linco.streamId = linco.streamId || `linco-stream-${Date.now()}`;
+      return null;
+    case 'assistant_chunk': {
+      const delta = String(event.text || '');
+      linco.fullText = `${linco.fullText || ''}${delta}`;
+      return {
+        ...base,
+        type: 'stream_chunk',
+        mode: 'chunk',
+        streamId: linco.streamId,
+        delta,
+        fullText: linco.fullText,
+        done: false,
+      };
+    }
+    case 'assistant_end':
+      return {
+        ...base,
+        type: 'stream_chunk',
+        mode: 'chunk',
+        streamId: linco.streamId,
+        delta: '',
+        fullText: linco.fullText || '',
+        done: true,
+      };
+    case 'thinking':
+    case 'thinking_clear':
+      return null;
+    case 'system':
+    case 'error':
+      return {
+        ...base,
+        type: 'outbound_message',
+        messageId: `linco-${event.type}-${Date.now()}`,
+        text: event.text || '',
+      };
+    case 'outgoing_attachment':
+      return mapOutgoingAttachment(event, base, session);
+    default:
+      return {
+        ...base,
+        ...event,
+        type: event.type || 'outbound_message',
+      };
+  }
+}
+
+function mapOutgoingAttachment(event, base, session) {
+  const file = event.id ? session.outgoingAttachments?.get(event.id) : null;
+  if (event.error) {
+    return {
+      ...base,
+      type: 'outbound_message',
+      messageId: `linco-file-error-${Date.now()}`,
+      text: event.error,
+    };
+  }
+
+  const payload = {
+    ...base,
+    type: 'outbound_message',
+    messageId: `linco-media-${Date.now()}`,
+    text: `Agent 生成了文件：${event.name || '未命名文件'}`,
+    mediaName: event.name,
+    mediaType: event.mimeType,
+    mediaUrl: event.url,
+  };
+
+  if (file?.path) {
+    payload.mediaUrl = file.path;
+    try {
+      payload.mediaBase64 = fs.readFileSync(file.path).toString('base64');
+    } catch {}
+  }
+
+  return payload;
+}
+
+function lincoFilesToAttachments(files) {
+  if (!Array.isArray(files)) return [];
+  return files.map(file => ({
+    name: file?.name || file?.mediaName || 'attachment',
+    mimeType: file?.type || file?.mimeType || file?.mediaType || '',
+    base64: file?.base64 || file?.mediaBase64 || '',
+  }));
+}
+
+function lincoMetaDefaults(config, meta = {}) {
+  return {
+    accountId: meta.accountId || config.im?.account || 'main',
+    agentId: meta.agentId || config.im?.agentId || 'main',
+    chatType: meta.chatType || 'direct',
+    targetType: meta.targetType || meta.chatType || 'direct',
+    targetId: meta.targetId || meta.userId,
+    userId: meta.userId || meta.targetId,
+    messageId: meta.messageId,
+    streamId: meta.streamId,
+    channel: meta.channel || config.im?.channel || 'linco',
+  };
+}
+
+function buildStreamId(msg) {
+  const messageId = String(msg.messageId || '').trim();
+  if (messageId) return `linco-stream-${messageId}`;
+  return `linco-stream-${Date.now()}`;
+}
+
+function pruneUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+
+module.exports = {
+  isLincoMessage,
+  toInternal,
+  createLincoAdapter,
+  mapLocalEventToLinco,
+  lincoFilesToAttachments,
+  buildStreamId,
+  lincoMetaDefaults,
+  pruneUndefined,
+};

package/src/localAuth.js

@@ -0,0 +1,46 @@
+const crypto = require('crypto');
+const { updateUserConfig } = require('./config');
+
+function ensureLocalToken(config) {
+  if (config.localWeb?.token) return config.localWeb.token;
+
+  const token = crypto.randomBytes(32).toString('hex');
+  updateUserConfig((userConfig) => {
+    userConfig.localWeb = {
+      ...(userConfig.localWeb || {}),
+      token,
+    };
+    return userConfig;
+  }, config.configFile);
+  config.localWeb = { ...(config.localWeb || {}), token };
+  return token;
+}
+
+function requestToken(req, url = null) {
+  const parsedUrl = url || new URL(req.url || '/', 'http://localhost');
+  const queryToken = parsedUrl.searchParams.get('localToken') || parsedUrl.searchParams.get('token');
+  if (queryToken) return queryToken;
+
+  const header = req.headers?.authorization || '';
+  const match = String(header).match(/^Bearer\s+(.+)$/i);
+  return match ? match[1].trim() : '';
+}
+
+function isLocalRequestAuthorized(req, config, url = null) {
+  const token = config.localWeb?.token;
+  return !!token && requestToken(req, url) === token;
+}
+
+function localUrlWithToken(config) {
+  const host = config.host === '0.0.0.0' ? '127.0.0.1' : config.host;
+  const url = new URL(`http://${host}:${config.port}/`);
+  if (config.localWeb?.token) url.searchParams.set('localToken', config.localWeb.token);
+  return url.toString();
+}
+
+module.exports = {
+  ensureLocalToken,
+  isLocalRequestAuthorized,
+  localUrlWithToken,
+  requestToken,
+};

package/src/logger.js

@@ -0,0 +1,137 @@
+const fs = require('fs');
+const path = require('path');
+
+const LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+};
+
+function normalizeLevel(level) {
+  const normalized = String(level || '').trim().toLowerCase();
+  return Object.prototype.hasOwnProperty.call(LEVELS, normalized) ? normalized : 'info';
+}
+
+function localTimestamp() {
+  const d = new Date();
+  const pad = n => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${String(d.getMilliseconds()).padStart(3, '0')}Z`;
+}
+
+function todayStamp() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function formatFields(fields) {
+  return Object.entries(fields)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}=${formatValue(value)}`)
+    .join(' ');
+}
+
+function formatValue(value) {
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  const text = typeof value === 'string' ? value : JSON.stringify(value);
+  return JSON.stringify(text.replace(/[\r\n]+/g, ' '));
+}
+
+function createLogger(config = {}) {
+  const configuredLevel = normalizeLevel(process.env.LOG_LEVEL || config.logLevel);
+  const logsDir = config.logsDir;
+
+  let currentLogDate = '';
+  let currentLogFile = '';
+
+  function shouldLog(level) {
+    return LEVELS[level] >= LEVELS[configuredLevel];
+  }
+
+  function ensureLogsDir() {
+    if (logsDir && !fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
+    }
+  }
+
+  function getLogFile() {
+    const today = todayStamp();
+    return path.join(logsDir, `linco-${today}.log`);
+  }
+
+  function rotateIfNeeded() {
+    const nextFile = getLogFile();
+    if (nextFile !== currentLogFile) {
+      currentLogFile = nextFile;
+      currentLogDate = todayStamp();
+      cleanupOldLogs();
+    }
+  }
+
+  function writeToFile(level, message, fields = {}) {
+    if (!currentLogFile) return;
+    const line = JSON.stringify({
+      ts: localTimestamp(),
+      level,
+      msg: message,
+      ...fields,
+    }) + '\n';
+    try {
+      fs.appendFileSync(currentLogFile, line);
+    } catch {
+      // ignore write failures to avoid crashing the app
+    }
+  }
+
+  function cleanupOldLogs(maxDays = 30) {
+    if (!logsDir) return;
+    try {
+      const entries = fs.readdirSync(logsDir);
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - maxDays);
+      const cutoffStamp = cutoff.toISOString().slice(0, 10);
+
+      for (const entry of entries) {
+        if (!entry.startsWith('linco-') || !entry.endsWith('.log')) continue;
+        const fileDate = entry.slice(7, 17); // extract YYYY-MM-DD
+        if (fileDate < cutoffStamp) {
+          fs.unlinkSync(path.join(logsDir, entry));
+        }
+      }
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+
+  function write(level, message, fields = {}) {
+    if (!shouldLog(level)) return;
+
+    const timestamp = localTimestamp();
+    const suffix = formatFields(fields);
+    const line = `${timestamp} ${level.toUpperCase()} ${message}${suffix ? ` ${suffix}` : ''}`;
+
+    if (logsDir) {
+      ensureLogsDir();
+      rotateIfNeeded();
+      writeToFile(level, message, fields);
+    }
+
+    if (level === 'error') {
+      console.error(line);
+    } else if (level === 'warn') {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+
+  return {
+    debug: (message, fields) => write('debug', message, fields),
+    info: (message, fields) => write('info', message, fields),
+    warn: (message, fields) => write('warn', message, fields),
+    error: (message, fields) => write('error', message, fields),
+  };
+}
+
+module.exports = {
+  createLogger,
+};

package/src/outgoingAttachmentHandler.js

@@ -0,0 +1,204 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('./config');
+const { send } = require('./protocol');
+
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']);
+const TEMP_EXTENSIONS = new Set(['.tmp', '.temp', '.part', '.crdownload']);
+
+function startOutboxWatcher(ws, session, config) {
+  stopOutboxWatcher(session);
+  const outboxDir = getOutboxDir(session, config);
+  ensureDir(outboxDir);
+  session.outgoingAttachments = new Map();
+  seedOutboxSeen(session, config);
+
+  session.outboxTimer = setInterval(() => scanOutbox(ws, session, config), 1000);
+  session.outboxTimer.unref?.();
+  setTimeout(() => scanOutbox(ws, session, config), 600).unref?.();
+}
+
+function stopOutboxWatcher(session) {
+  if (session.outboxTimer) {
+    clearInterval(session.outboxTimer);
+    session.outboxTimer = null;
+  }
+}
+
+function resetOutgoingAttachments(session, config) {
+  session.outgoingAttachments = new Map();
+  seedOutboxSeen(session, config);
+}
+
+function seedOutboxSeen(session, config) {
+  const outboxDir = getOutboxDir(session, config);
+  session.outboxSeen = new Set();
+
+  let entries;
+  try {
+    entries = fs.readdirSync(outboxDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      session.outboxSeen.add(path.resolve(outboxDir, entry.name));
+    }
+  }
+}
+
+function scanOutbox(ws, session, config) {
+  const outboxDir = getOutboxDir(session, config);
+  ensureDir(outboxDir);
+
+  let entries;
+  try {
+    entries = fs.readdirSync(outboxDir, { withFileTypes: true });
+  } catch (err) {
+    console.log(`[${session.id}] scan outbox failed:`, err.message);
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const filePath = path.resolve(outboxDir, entry.name);
+    if (!isInside(filePath, outboxDir)) continue;
+    if (session.outboxSeen.has(filePath)) continue;
+    if (shouldIgnoreFile(entry.name)) continue;
+
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+
+    if (!stat.isFile() || stat.size === 0) continue;
+    if (Date.now() - stat.mtimeMs < 500) continue;
+
+    session.outboxSeen.add(filePath);
+    registerOutgoingAttachment(ws, session, config, filePath, stat.size);
+  }
+}
+
+function registerOutgoingAttachment(ws, session, config, filePath, size) {
+  if (size > config.maxOutgoingAttachmentBytes) {
+    send(ws, 'outgoing_attachment', {
+      error: `文件超过发送大小限制 ${(config.maxOutgoingAttachmentBytes / 1024 / 1024).toFixed(0)}MB`,
+      name: path.basename(filePath),
+      size,
+    });
+    return;
+  }
+
+  const id = crypto.randomBytes(12).toString('hex');
+  const name = path.basename(filePath);
+  const mimeType = mimeFromFilename(name);
+  const kind = IMAGE_EXTENSIONS.has(path.extname(name).toLowerCase()) ? 'image' : 'file';
+
+  session.outgoingAttachments.set(id, {
+    id,
+    name,
+    path: filePath,
+    mimeType,
+    size,
+    kind,
+  });
+
+  const message = {
+    id,
+    name,
+    mimeType,
+    size,
+    kind,
+    url: `/api/session/${encodeURIComponent(session.id)}/outgoing/${encodeURIComponent(id)}?agentType=${encodeURIComponent(session.agentType || 'claude')}`,
+  };
+  console.log(`[${session.id}] outgoing attachment: ${name} (${size} bytes)`);
+  send(ws, 'outgoing_attachment', message);
+}
+
+function getOutgoingAttachment(activeSessions, sessionId, fileId, config, agentType) {
+  const activeKey = agentType ? `${agentType}:${sessionId}` : null;
+  const session = activeKey
+    ? activeSessions.get(activeKey)
+    : activeSessions.get(sessionId) || [...activeSessions.values()].find(candidate => candidate.id === sessionId);
+  if (!session) return null;
+
+  const file = session.outgoingAttachments?.get(fileId);
+  if (!file) return null;
+
+  const outboxDir = getOutboxDir(session, config);
+  const resolved = path.resolve(file.path);
+  if (!isInside(resolved, outboxDir)) return null;
+
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    return null;
+  }
+
+  if (!stat.isFile()) return null;
+  return { ...file, path: resolved, size: stat.size };
+}
+
+function getOutboxDir(session, config) {
+  return session.outboxDir;
+}
+
+function buildOutboxSystemPrompt(session, config) {
+  return `${config.systemPrompt}
+
+工具使用要求：调用 Read 工具读取普通文件时不要传 pages 字段；只有读取 PDF 且需要指定页码时才传 pages，且 pages 不能是空字符串。
+
+如果你需要把文件或图片发送给用户，请将文件保存或复制到以下目录：
+${getOutboxDir(session, config)}
+
+保存完成后，系统会自动把该文件展示在用户对话框中。请使用有意义的文件名，不要把敏感文件放入 outbox，除非用户明确要求。`;
+}
+
+function shouldIgnoreFile(name) {
+  if (name.startsWith('.') && name !== '.gitkeep') return true;
+  if (name.endsWith('~')) return true;
+  return TEMP_EXTENSIONS.has(path.extname(name).toLowerCase());
+}
+
+function mimeFromFilename(name) {
+  switch (path.extname(name).toLowerCase()) {
+    case '.png': return 'image/png';
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg';
+    case '.gif': return 'image/gif';
+    case '.webp': return 'image/webp';
+    case '.svg': return 'image/svg+xml';
+    case '.txt': return 'text/plain; charset=utf-8';
+    case '.md': return 'text/markdown; charset=utf-8';
+    case '.csv': return 'text/csv; charset=utf-8';
+    case '.json': return 'application/json';
+    case '.pdf': return 'application/pdf';
+    case '.doc': return 'application/msword';
+    case '.docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+    case '.xls': return 'application/vnd.ms-excel';
+    case '.xlsx': return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+    case '.sql': return 'application/sql';
+    case '.zip': return 'application/zip';
+    default: return 'application/octet-stream';
+  }
+}
+
+function isInside(filePath, dir) {
+  const relative = path.relative(dir, filePath);
+  return relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+module.exports = {
+  buildOutboxSystemPrompt,
+  getOutboxDir,
+  getOutgoingAttachment,
+  mimeFromFilename,
+  resetOutgoingAttachments,
+  startOutboxWatcher,
+  stopOutboxWatcher,
+};

package/src/protocol.js

@@ -0,0 +1,17 @@
+function send(ws, type, payload = {}) {
+  ws.send(JSON.stringify({ type, ...payload }));
+}
+
+function sendSystem(ws, text) {
+  send(ws, 'system', { text });
+}
+
+function sendError(ws, text) {
+  send(ws, 'error', { text });
+}
+
+module.exports = {
+  send,
+  sendError,
+  sendSystem,
+};

package/src/serverApp.js

@@ -0,0 +1,61 @@
+const { ensureDir, loadConfig } = require('./config');
+const { ensureLocalToken, localUrlWithToken } = require('./localAuth');
+const { createStaticServer } = require('./httpStatic');
+const { startImConnectors } = require('./imConnector');
+const { createLogger } = require('./logger');
+const { attachWebSocketServer } = require('./wsServer');
+
+function startServer(rootDir, options = {}) {
+  const config = options.config || loadConfig(rootDir);
+  config.logger = options.logger || config.logger || createLogger(config);
+  const log = config.logger;
+  ensureLocalToken(config);
+
+  if (config.gitBashEnv) {
+    log.info('git bash detected', { path: config.gitBashEnv });
+  }
+
+  const server = createStaticServer(config);
+  attachWebSocketServer(server, config);
+  const imConnectors = startImConnectors(config);
+
+  server.on('close', () => {
+    log.info('server closing');
+    for (const connector of imConnectors) connector.stop();
+    options.onClose?.(server, config);
+  });
+
+  server.listen(config.port, config.host, () => {
+    ensureDir(config.lincoHome);
+    ensureDir(config.sessionsDir);
+    ensureDir(config.logsDir);
+    const localUrl = localUrlWithToken(config);
+    log.info('server started', {
+      host: config.host,
+      port: config.port,
+      lincoHome: config.lincoHome,
+      sessionsDir: config.sessionsDir,
+      imEnabled: !!config.im?.enabled,
+      agents: Object.entries(config.agents || {}).filter(([, agent]) => agent.enabled).map(([type]) => type),
+    });
+    console.log('🚀 IM + Agent 桥接服务已启动');
+    console.log('');
+    console.log('📋 请复制下面的完整地址到浏览器打开本地测试页：');
+    console.log(localUrl);
+    console.log('');
+    console.log(`   Linco 运行目录: ${config.lincoHome}`);
+    console.log(`   会话目录: ${config.sessionsDir}`);
+    console.log(`   日志级别: ${config.logLevel}`);
+    if (config.im?.enabled) {
+      const enabledAgents = Object.entries(config.agents || {}).filter(([, agent]) => agent.enabled).map(([type]) => type).join(', ');
+      console.log(`   远端 IM: 已启用 (${config.im.channel}/${config.im.account}; agents: ${enabledAgents || 'none'})`);
+    }
+    options.onListening?.(server, config);
+  });
+
+  return server;
+}
+
+module.exports = {
+  startServer,
+};