cc-viewer 1.6.288 → 1.6.289

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="/assets/index-C_SecKTB.js"></script>
+  <script type="module" crossorigin src="/assets/index-CwWxkILC.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-Dx8tRqWW.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-CYU_jFNR.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-9MfaZIbX.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.288",
+  "version": "1.6.289",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",
@@ -102,16 +102,23 @@
     "vite": "^6.3.5"
   },
   "dependencies": {
+    "@larksuiteoapi/node-sdk": "1.66.0",
+    "@wecom/aibot-node-sdk": "1.0.7",
     "adm-zip": "^0.5.17",
     "dingtalk-stream": "2.1.5",
+    "discord.js": "14.26.4",
     "dompurify": "^3.3.3",
     "node-pty": "^1.1.0",
     "undici": "^7.22.0",
-    "ws": "^8.19.0"
+    "ws": "^8.21.0"
   },
   "optionalDependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.91"
   },
+  "overrides": {
+    "axios": "^1.16.1",
+    "qs": "^6.15.2"
+  },
   "c8": {
     "include": [
       "server/**/*.js",

package/server/i18n.js

@@ -639,6 +639,42 @@ const i18nData = {
   "server.dingtalk.skipPermBlocked": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
   "server.dingtalk.injectFailed": { "zh": "注入失败（会话已结束或不可用），请确认 Claude 会话仍在运行。", "en": "Injection failed (session ended or unavailable) — check the Claude session is still running." },
   "server.dingtalk.queueFull": { "zh": "消息队列已满，已丢弃该消息，请稍后再发。", "en": "Message queue is full; this message was dropped. Try again later." },
+  "server.feishu.replyChunkTitle": { "zh": "Claude", "en": "Claude" },
+  "server.feishu.truncated": { "zh": "（回复过长已截断，完整内容请见 Web 界面）", "en": "(reply truncated — see the web UI for the full content)" },
+  "server.feishu.noTextReply": { "zh": "（本轮无文本回复）", "en": "(no text reply this turn)" },
+  "server.feishu.interrupted": { "zh": "已中断当前回合。", "en": "Interrupted the current turn." },
+  "server.feishu.noSession": { "zh": "当前没有活跃的 Claude 会话，无法处理。", "en": "No active Claude session — cannot process." },
+  "server.feishu.notBound": { "zh": "该会话未绑定到本机，已忽略。", "en": "This conversation is not bound; ignored." },
+  "server.feishu.notAuthorized": { "zh": "你不在允许的发送人白名单内。", "en": "You are not in the allowed sender list." },
+  "server.feishu.busyQueued": { "zh": "Claude 正在忙，你的消息已排队。", "en": "Claude is busy; your message is queued." },
+  "server.feishu.skipPermWarning": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.feishu.skipPermBlocked": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.feishu.injectFailed": { "zh": "注入失败（会话已结束或不可用），请确认 Claude 会话仍在运行。", "en": "Injection failed (session ended or unavailable) — check the Claude session is still running." },
+  "server.feishu.queueFull": { "zh": "消息队列已满，已丢弃该消息，请稍后再发。", "en": "Message queue is full; this message was dropped. Try again later." },
+  "server.wecom.replyChunkTitle": { "zh": "Claude", "en": "Claude" },
+  "server.wecom.truncated": { "zh": "（回复过长已截断，完整内容请见 Web 界面）", "en": "(reply truncated — see the web UI for the full content)" },
+  "server.wecom.noTextReply": { "zh": "（本轮无文本回复）", "en": "(no text reply this turn)" },
+  "server.wecom.interrupted": { "zh": "已中断当前回合。", "en": "Interrupted the current turn." },
+  "server.wecom.noSession": { "zh": "当前没有活跃的 Claude 会话，无法处理。", "en": "No active Claude session — cannot process." },
+  "server.wecom.notBound": { "zh": "该会话未绑定到本机，已忽略。", "en": "This conversation is not bound; ignored." },
+  "server.wecom.notAuthorized": { "zh": "你不在允许的发送人白名单内。", "en": "You are not in the allowed sender list." },
+  "server.wecom.busyQueued": { "zh": "Claude 正在忙，你的消息已排队。", "en": "Claude is busy; your message is queued." },
+  "server.wecom.skipPermWarning": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.wecom.skipPermBlocked": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.wecom.injectFailed": { "zh": "注入失败（会话已结束或不可用），请确认 Claude 会话仍在运行。", "en": "Injection failed (session ended or unavailable) — check the Claude session is still running." },
+  "server.wecom.queueFull": { "zh": "消息队列已满，已丢弃该消息，请稍后再发。", "en": "Message queue is full; this message was dropped. Try again later." },
+  "server.discord.replyChunkTitle": { "zh": "Claude", "en": "Claude" },
+  "server.discord.truncated": { "zh": "（回复过长已截断，完整内容请见 Web 界面）", "en": "(reply truncated — see the web UI for the full content)" },
+  "server.discord.noTextReply": { "zh": "（本轮无文本回复）", "en": "(no text reply this turn)" },
+  "server.discord.interrupted": { "zh": "已中断当前回合。", "en": "Interrupted the current turn." },
+  "server.discord.noSession": { "zh": "当前没有活跃的 Claude 会话，无法处理。", "en": "No active Claude session — cannot process." },
+  "server.discord.notBound": { "zh": "该会话未绑定到本机，已忽略。", "en": "This conversation is not bound; ignored." },
+  "server.discord.notAuthorized": { "zh": "你不在允许的发送人白名单内。", "en": "You are not in the allowed sender list." },
+  "server.discord.busyQueued": { "zh": "Claude 正在忙，你的消息已排队。", "en": "Claude is busy; your message is queued." },
+  "server.discord.skipPermWarning": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.discord.skipPermBlocked": { "zh": "收到，正在思考", "en": "Got it, thinking…" },
+  "server.discord.injectFailed": { "zh": "注入失败（会话已结束或不可用），请确认 Claude 会话仍在运行。", "en": "Injection failed (session ended or unavailable) — check the Claude session is still running." },
+  "server.discord.queueFull": { "zh": "消息队列已满，已丢弃该消息，请稍后再发。", "en": "Message queue is full; this message was dropped. Try again later." },
   "update.updating": {
     "zh": "正在更新到 v{version}...",
     "en": "Updating to v{version}...",

package/server/lib/adapters/dingtalk-adapter.js

@@ -0,0 +1,129 @@
+// DingTalk adapter — the platform-specific half of the DingTalk bridge. The generic
+// orchestration (dedup, access control, queue, inject, chunk, turn-end reply) lives in
+// server/lib/im-bridge-core.js; this module only knows DingTalk's Stream client, ACK protocol,
+// inbound payload shape, access-token fetch, and proactive App API send endpoints.
+import { registerAdapter } from '../im-bridge-core.js';
+import { t } from '../../i18n.js';
+
+// ─── test seam: a fake Stream client factory (zero dingtalk-stream / network) ───
+let clientFactory = null;
+export function __setClientFactory(fn) { clientFactory = fn; }
+
+// ─── DingTalk App API (proactive send; the inbound sessionWebhook is expired by reply time) ───
+const TOKEN_URL = 'https://api.dingtalk.com/v1.0/oauth2/accessToken';
+const GROUP_SEND_URL = 'https://api.dingtalk.com/v1.0/robot/groupMessages/send';
+const OTO_SEND_URL = 'https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend';
+
+async function getAccessToken(cfg, ctx) {
+  const tc = ctx.store.tokenCache;
+  if (tc && tc.appKey === cfg.appKey && tc.expiresAt > Date.now() + 300_000) {
+    return tc.accessToken;
+  }
+  const r = await ctx.fetch(TOKEN_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ appKey: cfg.appKey, appSecret: cfg.appSecret }),
+  });
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok || !j.accessToken) throw new Error(`token ${r.status}: ${j.message || j.code || 'failed'}`);
+  ctx.store.tokenCache = { appKey: cfg.appKey, accessToken: j.accessToken, expiresAt: Date.now() + (j.expireIn || 7200) * 1000 };
+  return j.accessToken;
+}
+
+/** Normalize a DingTalk TOPIC_ROBOT callback into the core's inbound shape. Returns null for
+ *  an unparseable payload (the core skips it). */
+function normalizeInbound(res) {
+  let msg;
+  try { msg = JSON.parse(res?.data ?? '{}'); } catch { return null; }
+  const conversationId = msg.conversationId;
+  const conversationType = msg.conversationType;
+  const senderStaffId = msg.senderStaffId;
+  const robotCode = msg.robotCode || msg.chatbotUserId;
+  return {
+    text: msg.text?.content ?? '',
+    conversationId,
+    isGroup: String(conversationType) === '2',
+    senderId: senderStaffId,
+    msgId: res?.headers?.messageId,
+    // opaque platform extras carried back to sendOne
+    target: { conversationId, conversationType, robotCode, senderStaffId },
+  };
+}
+
+const dingtalkAdapter = {
+  id: 'dingtalk',
+  i18nNs: 'server.dingtalk',
+  allowListField: 'allowStaffIds',
+  capabilities: { inboundAck: true, sdkManagesToken: false },
+  rateLimit: { max: 18, windowMs: 60_000 }, // stay under DingTalk's 20/min
+
+  hasCreds(cfg) { return !!(cfg.appKey && cfg.appSecret); },
+  statusFields(cfg) { return { appKeyTail: cfg?.appKey?.slice(-4) || '' }; },
+
+  async connect(cfg, hooks) {
+    let client;
+    if (clientFactory) {
+      client = clientFactory({ clientId: cfg.appKey, clientSecret: cfg.appSecret });
+      if (typeof client.registerCallbackListener === 'function') {
+        client.registerCallbackListener('__test__', (res) => hooks.onInbound(normalizeInbound(res), res));
+      }
+    } else {
+      const mod = await import('dingtalk-stream');
+      const { DWClient, TOPIC_ROBOT } = mod;
+      client = new DWClient({ clientId: cfg.appKey, clientSecret: cfg.appSecret });
+      client.registerCallbackListener(TOPIC_ROBOT, (res) => hooks.onInbound(normalizeInbound(res), res));
+    }
+    await client.connect?.();
+    return client;
+  },
+
+  async disconnect(client) {
+    try { await client?.disconnect?.(); } catch { /* best-effort */ }
+  },
+
+  // ackCtx is the raw `res`; `client` is the live Stream client (passed by the core).
+  ack(res, client) {
+    try {
+      const id = res?.headers?.messageId;
+      if (!id || !client) return;
+      if (typeof client.socketCallBackResponse === 'function') {
+        client.socketCallBackResponse(id, { success: true });
+      } else if (typeof client.send === 'function') {
+        client.send(id, JSON.stringify({ status: 'SUCCESS', message: 'OK' }));
+      }
+    } catch { /* best-effort; ack failure only risks a redelivery, caught by dedup */ }
+  },
+
+  async sendOne(cfg, target, content, ctx) {
+    const token = await getAccessToken(cfg, ctx);
+    const msgParam = JSON.stringify({ title: t('server.dingtalk.replyChunkTitle'), text: content });
+    const isGroup = String(target.conversationType) === '2';
+    const url = isGroup ? GROUP_SEND_URL : OTO_SEND_URL;
+    const body = isGroup
+      ? { robotCode: target.robotCode, openConversationId: target.conversationId, msgKey: 'sampleMarkdown', msgParam }
+      : { robotCode: target.robotCode, userIds: [target.senderStaffId].filter(Boolean), msgKey: 'sampleMarkdown', msgParam };
+    const r = await ctx.fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'x-acs-dingtalk-access-token': token },
+      body: JSON.stringify(body),
+    });
+    if (!r.ok) {
+      const j = await r.json().catch(() => ({}));
+      throw new Error(`send ${r.status}: ${j.message || j.code || 'failed'}`);
+    }
+  },
+
+  async testConnection(cfg, ctx) {
+    try {
+      ctx.store.tokenCache = null; // force a fresh fetch
+      await getAccessToken(cfg, ctx);
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, detail: String(e?.message || e) };
+    }
+  },
+};
+
+registerAdapter(dingtalkAdapter);
+
+export default dingtalkAdapter;

package/server/lib/adapters/discord-adapter.js

@@ -0,0 +1,140 @@
+// Discord adapter — the platform-specific half of the Discord bridge. The generic orchestration
+// (dedup, access control, queue, inject, chunk, turn-end reply) lives in server/lib/im-bridge-core.js;
+// this module only knows discord.js's Gateway client, inbound message shape, and outbound send.
+//
+// Uses discord.js v14: the bot dials OUT to Discord's Gateway WebSocket (no public URL). Credential is
+// a single bot token. Per the multi-IM model it responds to ALL messages in the bound conversation
+// (a guild channel or a DM); only the bot/self loop-guard applies. Reply lands ~10s after the turn.
+//
+// Distilled from LangBot's Discord adapter: enable the privileged MESSAGE_CONTENT intent; loop-guard
+// `author.bot || author.id === self`; DM vs guild by `inGuild()`, reply target = channel.
+//
+// Console prerequisite (no code equivalent — surfaced in the UI help): in the Discord Developer Portal,
+// create an app + bot, ENABLE the Message Content Intent (else message.content is silently empty), copy
+// the bot token, and invite the bot with the `bot`+`applications.commands` scopes and View/Send perms.
+import { registerAdapter } from '../im-bridge-core.js';
+
+// ─── test seam: a fake discord.js factory (zero real gateway / socket) ───
+let sdkFactory = null;
+export function __setClientFactory(fn) { sdkFactory = fn; }
+
+async function loadSdk() {
+  if (sdkFactory) return sdkFactory();
+  return import('discord.js');
+}
+
+const CONNECT_PROBE_MS = 12_000; // internal connect guard (< core CONNECT_TIMEOUT_MS)
+const DISCORD_MAX = 2_000;       // hard per-message limit
+
+/** Normalize a discord.js Message into the core's inbound shape. The bot/self loop-guard runs in the
+ *  event handler (before this). */
+function normalizeInbound(message) {
+  const isGroup = typeof message.inGuild === 'function' ? message.inGuild() : !!message.guild;
+  const senderId = message.author?.id || '';
+  const channelId = message.channelId;
+  // Strip a leading bot mention (<@123> / <@!123>) so "@bot do X" injects as "do X".
+  const text = String(message.content ?? '').replace(/^<@!?\d+>\s*/, '');
+  return {
+    text,
+    conversationId: channelId,
+    isGroup,
+    senderId,
+    msgId: message.id,
+    // For a DM, channels.fetch(channelId) is broken on a partial DM channel (CHANNEL_RECIPIENT_REQUIRED),
+    // so carry the user id and reply via users.fetch().createDM(). Guild channels fetch reliably by id.
+    target: { conversationId: channelId, channelId, userId: isGroup ? null : senderId },
+  };
+}
+
+const discordAdapter = {
+  id: 'discord',
+  i18nNs: 'server.discord',
+  allowListField: 'allowUserIds',
+  capabilities: { inboundAck: false },
+  // Discord allows ~5 messages / 5s per channel; cap conservatively.
+  rateLimit: { max: 5, windowMs: 5_000 },
+
+  hasCreds(cfg) { return !!cfg.botToken; },
+  // Discord's only credential is the token (a secret) — exposing any tail would leak secret material.
+  statusFields() { return {}; },
+
+  async connect(cfg, hooks, ctx) {
+    const mod = await loadSdk();
+    const { Client, GatewayIntentBits, Partials, Events } = mod;
+    const client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent, // privileged — must also be enabled in the Dev Portal
+        GatewayIntentBits.DirectMessages,
+      ],
+      partials: [Partials.Channel], // REQUIRED to receive DMs (DM channels are uncached)
+    });
+    ctx.store.client = client;
+    // Persistent error listener for the life of the client: a Node EventEmitter that emits 'error'
+    // with NO listener throws and crashes the process. The connect-window once('error') below is
+    // consumed on resolve, so without this a later gateway 'error' would be fatal. Swallow (the
+    // gateway auto-reconnects; connection state surfaces via the bridge status).
+    client.on('error', () => { /* swallowed — see comment */ });
+    client.on(Events.MessageCreate, (message) => {
+      // Loop-guard: ignore the bot's own messages (Discord redelivers our send as a new event) and
+      // all other bots. author.bot covers self; the id check is belt-and-suspenders.
+      if (message.author?.bot || message.author?.id === client.user?.id) return;
+      hooks.onInbound(normalizeInbound(message), null);
+    });
+    // login() resolves only the handshake start and REJECTS (as a promise) on a bad token — route that
+    // into the same promise, else a bad token hangs to the timeout. ClientReady signals fully-ready.
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (fn, arg) => { if (settled) return; settled = true; clearTimeout(timer); fn(arg); };
+      const timer = setTimeout(() => { try { client.destroy(); } catch { /* best-effort */ } finish(reject, new Error('connect timeout')); }, CONNECT_PROBE_MS);
+      if (typeof timer.unref === 'function') timer.unref();
+      client.once(Events.ClientReady, () => finish(resolve, client));
+      client.once('error', (e) => { try { client.destroy(); } catch { /* best-effort */ } finish(reject, new Error(String(e?.message || e))); });
+      client.login(cfg.botToken).catch((e) => { try { client.destroy(); } catch { /* best-effort */ } finish(reject, new Error(String(e?.message || e))); });
+    });
+  },
+
+  async disconnect(client, ctx) {
+    try { client?.removeAllListeners?.(); } catch { /* best-effort */ }
+    try { await client?.destroy?.(); } catch { /* best-effort */ }
+    if (ctx?.store) ctx.store.client = null;
+  },
+
+  ack() { /* no-op (Discord has no inbound ack; loop-guard + msgId dedup handle redelivery) */ },
+
+  async sendOne(cfg, target, content, ctx) {
+    const client = ctx.store.client;
+    if (!client) throw new Error('discord client not connected');
+    let channel;
+    if (target.userId) {
+      // DM: reconstruct via the user (channels.fetch on a partial DM channel throws #9624).
+      const user = await client.users.fetch(target.userId);
+      channel = await user.createDM();
+    } else {
+      channel = await client.channels.fetch(target.channelId);
+    }
+    if (!channel || typeof channel.send !== 'function') throw new Error(`channel not sendable: ${target.channelId}`);
+    // Hard-split at Discord's 2000-char limit (defense: maxChunkChars clamps up to 5000, > the limit).
+    for (let i = 0; i < content.length; i += DISCORD_MAX) {
+      await channel.send(content.slice(i, i + DISCORD_MAX));
+    }
+  },
+
+  async testConnection(cfg, ctx) {
+    // Validate the token via REST without opening a gateway (and without the privileged intent).
+    try {
+      const r = await ctx.fetch('https://discord.com/api/v10/users/@me', {
+        headers: { Authorization: `Bot ${cfg.botToken}` },
+      });
+      if (r.ok) return { ok: true };
+      return { ok: false, detail: `HTTP ${r.status}` };
+    } catch (e) {
+      return { ok: false, detail: String(e?.message || e) };
+    }
+  },
+};
+
+registerAdapter(discordAdapter);
+
+export default discordAdapter;

package/server/lib/adapters/feishu-adapter.js

@@ -0,0 +1,133 @@
+// Feishu/Lark adapter — the platform-specific half of the Feishu bridge. The generic
+// orchestration (dedup, access control, queue, inject, chunk, turn-end reply) lives in
+// server/lib/im-bridge-core.js; this module only knows Feishu's WebSocket long-connection event
+// client, inbound payload shape, and outbound send.
+//
+// Inbound uses the official SDK's WSClient long-connection (NOT a webhook) so it works on
+// loopback with no public URL — mirroring how DingTalk uses dingtalk-stream. The SDK's
+// Lark.Client auto-acquires & caches the tenant_access_token for outbound, so (unlike DingTalk)
+// we never hand-roll an outbound token; testConnection is the only place that fetches one by hand.
+//
+// Console prerequisite (no code equivalent — surfaced to the user in the UI/README): the custom
+// app must set Event Subscription to "long connection", subscribe `im.message.receive_v1`, grant
+// the `im:message` send scope, and be published.
+import { registerAdapter } from '../im-bridge-core.js';
+
+// ─── test seam: a fake SDK factory ({ Client, WSClient, EventDispatcher, Domain, LoggerLevel })
+// so unit tests never import the real SDK or open a socket. ───
+let sdkFactory = null;
+export function __setClientFactory(fn) { sdkFactory = fn; }
+
+const TOKEN_PATH = '/open-apis/auth/v3/tenant_access_token/internal';
+function tokenHost(region) {
+  return region === 'lark' ? 'https://open.larksuite.com' : 'https://open.feishu.cn';
+}
+
+async function loadSdk() {
+  if (sdkFactory) return sdkFactory();
+  return import('@larksuiteoapi/node-sdk');
+}
+
+/** Normalize an `im.message.receive_v1` event into the core's inbound shape. Returns null when
+ *  the payload is unusable (the core skips it). */
+function normalizeInbound(data) {
+  const msg = data?.message;
+  if (!msg) return null;
+  let text = '';
+  if (msg.message_type === 'text') {
+    let content;
+    try { content = JSON.parse(msg.content || '{}'); } catch { content = {}; }
+    // Strip Feishu @-mention placeholders (`@_user_1`) the platform injects into group text.
+    text = String(content.text || '').replace(/@_user_\d+/g, '').trim();
+  }
+  const isGroup = msg.chat_type === 'group';
+  const sid = data.sender?.sender_id || {};
+  const senderId = sid.open_id || sid.user_id || sid.union_id || '';
+  return {
+    text,
+    conversationId: msg.chat_id,
+    isGroup,
+    senderId,
+    msgId: msg.message_id,
+    // In a group, reply to the chat; in a p2p, reply to the sender. receive_id_type tells the
+    // send API which id space `receiveId` is in.
+    target: isGroup
+      ? { conversationId: msg.chat_id, receiveId: msg.chat_id, receiveIdType: 'chat_id' }
+      : { conversationId: msg.chat_id, receiveId: senderId, receiveIdType: 'open_id' },
+  };
+}
+
+const feishuAdapter = {
+  id: 'feishu',
+  i18nNs: 'server.feishu',
+  allowListField: 'allowUserIds',
+  capabilities: { inboundAck: false, sdkManagesToken: true },
+  // Feishu IM send limits are generous (≈1000/min/app); cap conservatively.
+  rateLimit: { max: 50, windowMs: 60_000 },
+
+  hasCreds(cfg) { return !!(cfg.appId && cfg.appSecret); },
+  statusFields(cfg) { return { appKeyTail: cfg?.appId?.slice(-4) || '' }; },
+
+  async connect(cfg, hooks, ctx) {
+    const Lark = await loadSdk();
+    const domain = cfg.region === 'lark' ? Lark.Domain.Lark : Lark.Domain.Feishu;
+    const base = { appId: cfg.appId, appSecret: cfg.appSecret, domain };
+    // Outbound client (auto-manages the tenant_access_token cache).
+    ctx.store.sendClient = new Lark.Client(base);
+    // Inbound long-connection event client. wsConfig is REQUIRED — omitting PingInterval/PingTimeout
+    // makes start() throw or hang on some SDK builds.
+    const ws = new Lark.WSClient({
+      ...base,
+      loggerLevel: Lark.LoggerLevel ? Lark.LoggerLevel.warn : undefined, // warn: avoid noisy info-level stdout
+      wsConfig: { PingInterval: 30, PingTimeout: 5 },
+    });
+    const dispatcher = new Lark.EventDispatcher({}).register({
+      'im.message.receive_v1': async (data) => hooks.onInbound(normalizeInbound(data), null),
+    });
+    await ws.start({ eventDispatcher: dispatcher });
+    return ws;
+  },
+
+  async disconnect(ws) {
+    // Branch on method presence, not return value — a void-returning stop() must not also call close().
+    try {
+      if (typeof ws?.stop === 'function') await ws.stop();
+      else if (typeof ws?.close === 'function') await ws.close();
+    } catch { /* best-effort */ }
+  },
+
+  // Feishu long-connection has no app-level inbound ACK (the SDK handles transport acking).
+  ack() { /* no-op */ },
+
+  async sendOne(cfg, target, content, ctx) {
+    const client = ctx.store.sendClient;
+    if (!client) throw new Error('feishu send client not initialized');
+    const r = await client.im.v1.message.create({
+      params: { receive_id_type: target.receiveIdType },
+      data: { receive_id: target.receiveId, msg_type: 'text', content: JSON.stringify({ text: content }) },
+    });
+    if (r && typeof r.code === 'number' && r.code !== 0) {
+      throw new Error(`send ${r.code}: ${r.msg || 'failed'}`);
+    }
+  },
+
+  async testConnection(cfg, ctx) {
+    try {
+      const r = await ctx.fetch(tokenHost(cfg.region) + TOKEN_PATH, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json; charset=utf-8' },
+        body: JSON.stringify({ app_id: cfg.appId, app_secret: cfg.appSecret }),
+      });
+      const j = await r.json().catch(() => ({}));
+      // Feishu returns HTTP 200 with a non-zero `code` on bad creds — check the body code.
+      if (!r.ok || j.code !== 0) return { ok: false, detail: j.msg || `token ${r.status}: ${j.code ?? 'failed'}` };
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, detail: String(e?.message || e) };
+    }
+  },
+};
+
+registerAdapter(feishuAdapter);
+
+export default feishuAdapter;

package/server/lib/adapters/wecom-adapter.js

@@ -0,0 +1,146 @@
+// 企业微信 (WeCom) adapter — the platform-specific half of the WeCom bridge. The generic
+// orchestration (dedup, access control, queue, inject, chunk, turn-end reply) lives in
+// server/lib/im-bridge-core.js; this module only knows WeCom's smart-robot long-connection client,
+// inbound frame shape, and outbound send.
+//
+// Uses the 企业微信智能机器人长连接 (Smart Robot long-connection) mode via @wecom/aibot-node-sdk:
+// an OUTBOUND WebSocket (wss://openws.work.weixin.qq.com) authed with botId + secret — so it works
+// on loopback with no public URL, no trusted-IP whitelist, and no WXBizMsgCrypt in our code (the
+// SDK handles auth/heartbeat/reconnect). Replies use the proactive sendMessage (our reply lands
+// ~10s after the turn, well past the 5s synchronous reply window; the 24h proactive window covers it).
+//
+// Console prerequisite (no code equivalent — surfaced in the UI help/README): create a 智能机器人,
+// set its API 接收模式 to 长连接, copy the botId + secret, and add the bot to a chat.
+import { registerAdapter } from '../im-bridge-core.js';
+
+// ─── test seam: a fake SDK factory (zero real SDK / socket) ───
+let sdkFactory = null;
+export function __setClientFactory(fn) { sdkFactory = fn; }
+
+async function loadSdk() {
+  if (sdkFactory) return sdkFactory();
+  return import('@wecom/aibot-node-sdk');
+}
+function resolveWSClient(mod) {
+  const ns = mod.default ?? mod;
+  return ns.WSClient ?? mod.WSClient;
+}
+
+const CONNECT_PROBE_MS = 12_000; // internal connect guard (< core CONNECT_TIMEOUT_MS) to avoid a leaked reconnect loop
+const TEST_PROBE_MS = 8_000;
+
+/** Normalize a WeCom `message.text` WsFrame into the core's inbound shape. Returns null for an
+ *  unusable frame (the core skips it). */
+function normalizeInbound(frame) {
+  const b = frame?.body;
+  if (!b) return null;
+  const isGroup = b.chattype === 'group';
+  const senderId = b.from?.userid || '';
+  const receiveId = isGroup ? b.chatid : senderId; // group → chatid, single → sender userid
+  // A group frame missing chatid (chatid is optional in the SDK types) has no reply target — drop
+  // it rather than bind/send to undefined.
+  if (!receiveId) return null;
+  return {
+    text: b.text?.content ?? '',
+    conversationId: receiveId,
+    isGroup,
+    senderId,
+    msgId: b.msgid,
+    target: { conversationId: receiveId, receiveId },
+  };
+}
+
+const wecomAdapter = {
+  id: 'wecom',
+  i18nNs: 'server.wecom',
+  allowListField: 'allowUserIds',
+  capabilities: { inboundAck: false },
+  // WeCom proactive-push limit is 30/min·1000/hr per conversation; cap conservatively.
+  rateLimit: { max: 30, windowMs: 60_000 },
+
+  hasCreds(cfg) { return !!(cfg.botId && cfg.secret); },
+  statusFields(cfg) { return { botIdTail: cfg?.botId?.slice(-4) || '' }; },
+
+  async connect(cfg, hooks, ctx) {
+    const mod = await loadSdk();
+    const WSClient = resolveWSClient(mod);
+    const client = new WSClient({ botId: cfg.botId, secret: cfg.secret });
+    ctx.store.client = client; // single client for inbound + outbound (sendOne reads it)
+    client.on('message.text', (frame) => hooks.onInbound(normalizeInbound(frame), null));
+    // connect() is synchronous; resolve once the WS handshake authenticates so the core's
+    // `connected` flag and CONNECT_TIMEOUT_MS race are meaningful (bad creds → lastError, not a
+    // false "connected"). Reject (and tear down) on error or an internal timeout.
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try { client.disconnect(); } catch { /* best-effort */ }
+        reject(new Error('connect timeout'));
+      }, CONNECT_PROBE_MS);
+      if (typeof timer.unref === 'function') timer.unref();
+      client.on('authenticated', () => { if (settled) return; settled = true; clearTimeout(timer); resolve(client); });
+      client.on('error', (e) => {
+        if (settled) return;
+        settled = true; clearTimeout(timer);
+        // Tear down before rejecting — else the SDK keeps auto-reconnecting/retrying auth in the
+        // background even though the bridge reports not-running.
+        try { client.disconnect(); } catch { /* best-effort */ }
+        reject(new Error(String(e?.message || e)));
+      });
+      client.connect();
+    });
+  },
+
+  async disconnect(client, ctx) {
+    try { client?.removeAllListeners?.(); } catch { /* best-effort */ }
+    try { client?.disconnect?.(); } catch { /* best-effort */ }
+    if (ctx?.store) ctx.store.client = null;
+  },
+
+  // Long-connection has no app-level inbound ACK (the SDK handles transport); rely on msgid dedup.
+  ack() { /* no-op */ },
+
+  async sendOne(cfg, target, content, ctx) {
+    const client = ctx.store.client;
+    if (!client) throw new Error('wecom client not connected');
+    const res = await client.sendMessage(target.receiveId, { msgtype: 'markdown', markdown: { content } });
+    if (res && typeof res.errcode === 'number' && res.errcode !== 0) {
+      throw new Error(`send ${res.errcode}: ${res.errmsg || 'failed'}`);
+    }
+  },
+
+  async testConnection(cfg) {
+    // No REST validate endpoint exists for the smart-robot mode — auth is in the WS handshake. Open
+    // a throwaway probe and wait for 'authenticated'. NOTE: WeCom allows one connection per bot, so
+    // testing while the live bridge is connected to the same bot briefly kicks it (the bridge then
+    // auto-reconnects). maxReconnectAttempts:0 keeps the probe from spinning a backoff loop.
+    let client;
+    try {
+      const mod = await loadSdk();
+      const WSClient = resolveWSClient(mod);
+      client = new WSClient({ botId: cfg.botId, secret: cfg.secret, maxReconnectAttempts: 0 });
+    } catch (e) {
+      return { ok: false, detail: String(e?.message || e) };
+    }
+    return await new Promise((resolve) => {
+      let settled = false;
+      const done = (res) => {
+        if (settled) return;
+        settled = true;
+        try { client.removeAllListeners?.(); } catch { /* best-effort */ }
+        try { client.disconnect?.(); } catch { /* best-effort */ }
+        resolve(res);
+      };
+      const timer = setTimeout(() => done({ ok: false, detail: 'timeout' }), TEST_PROBE_MS);
+      if (typeof timer.unref === 'function') timer.unref();
+      client.on('authenticated', () => { clearTimeout(timer); done({ ok: true }); });
+      client.on('error', (e) => { clearTimeout(timer); done({ ok: false, detail: String(e?.message || e) }); });
+      try { client.connect(); } catch (e) { clearTimeout(timer); done({ ok: false, detail: String(e?.message || e) }); }
+    });
+  },
+};
+
+registerAdapter(wecomAdapter);
+
+export default wecomAdapter;