codeksei 0.1.0 → 0.1.1

package/src/adapters/channel/weixin/index.js

@@ -1,605 +1,619 @@
-const crypto = require("crypto");
-const { listWeixinAccounts, resolveSelectedAccount } = require("./account-store");
-const { loadPersistedContextTokens, persistContextToken } = require("./context-token-store");
-const { runV2LoginFlow } = require("./login-v2");
-const {
-  getConfigV2,
-  getUpdatesV2,
-  sendTextV2,
-  sendTypingV2,
-} = require("./api-v2");
-const { createLegacyWeixinChannelAdapter } = require("./legacy");
-const { createInboundFilter } = require("./message-utils-v2");
-const { sendWeixinMediaFile } = require("./media-send");
-const { loadSyncBuffer, saveSyncBuffer } = require("./sync-buffer-store");
-
-const LONG_POLL_TIMEOUT_MS = 35_000;
-const MAX_WEIXIN_CHUNK = 3800;
-const SEND_MESSAGE_CHUNK_INTERVAL_MS = 350;
-const WEIXIN_SEND_CHUNK_LIMIT = 80;
-const WEIXIN_MAX_DELIVERY_MESSAGES = 10;
-const SEND_RETRY_DELAYS_MS = [900, 1800];
-
-function createWeixinChannelAdapter(config) {
-  const variant = normalizeAdapterVariant(config.weixinAdapterVariant);
-  if (variant === "legacy") {
-    return createLegacyWeixinChannelAdapter(config);
-  }
-
-  let selectedAccount = null;
-  let contextTokenCache = null;
-  const inboundFilter = createInboundFilter();
-
-  function ensureAccount() {
-    if (!selectedAccount) {
-      selectedAccount = resolveSelectedAccount(config);
-      contextTokenCache = loadPersistedContextTokens(config, selectedAccount.accountId);
-    }
-    return selectedAccount;
-  }
-
-  function ensureContextTokenCache() {
-    if (!contextTokenCache) {
-      const account = ensureAccount();
-      contextTokenCache = loadPersistedContextTokens(config, account.accountId);
-    }
-    return contextTokenCache;
-  }
-
-  function rememberContextToken(userId, contextToken) {
-    const account = ensureAccount();
-    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
-    const normalizedToken = typeof contextToken === "string" ? contextToken.trim() : "";
-    if (!normalizedUserId || !normalizedToken) {
-      return "";
-    }
-    contextTokenCache = persistContextToken(config, account.accountId, normalizedUserId, normalizedToken);
-    return normalizedToken;
-  }
-
-  function resolveContextToken(userId, explicitToken = "") {
-    const normalizedExplicitToken = typeof explicitToken === "string" ? explicitToken.trim() : "";
-    if (normalizedExplicitToken) {
-      return normalizedExplicitToken;
-    }
-    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
-    if (!normalizedUserId) {
-      return "";
-    }
-    return ensureContextTokenCache()[normalizedUserId] || "";
-  }
-
-  function sendTextChunks({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
-    const account = ensureAccount();
-    const resolvedToken = resolveContextToken(userId, contextToken);
-    if (!resolvedToken) {
-      throw new Error(`缺少 context_token，无法回复用户 ${userId}`);
-    }
-    const content = String(text || "");
-    if (!content.trim()) {
-      return Promise.resolve();
-    }
-    const sendChunks = preserveBlock
-      ? splitUtf8(compactPlainTextForWeixin(content) || "已完成。", MAX_WEIXIN_CHUNK)
-      : packChunksForWeixinDelivery(
-        chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT).length
-          ? chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT)
-          : ["已完成。"],
-        WEIXIN_MAX_DELIVERY_MESSAGES,
-        MAX_WEIXIN_CHUNK
-      );
-    const traceContext = buildWeixinTraceContext(trace, {
-      enabled: config.weixinDeliveryTrace,
-      origin: "adapter.sendText",
-      variant: "v2",
-      preserveBlock,
-      chunkTotal: sendChunks.length,
-    });
-    return sendChunks.reduce((promise, chunk, index) => promise
-      .then(() => {
-        const compactChunk = compactPlainTextForWeixin(chunk) || "已完成。";
-        const clientId = `cb-${crypto.randomUUID()}`;
-        return sendV2TextChunk({
-          baseUrl: account.baseUrl,
-          token: account.token,
-          routeTag: account.routeTag,
-          clientVersion: config.weixinProtocolClientVersion,
-          toUserId: userId,
-          text: compactChunk,
-          contextToken: resolvedToken,
-          clientId,
-          trace: {
-            ...traceContext,
-            chunkIndex: index + 1,
-            chars: compactChunk.length,
-            textHash: hashTraceText(compactChunk),
-            clientId,
-          },
-        });
-      })
-      .then(() => {
-        if (index < sendChunks.length - 1) {
-          return sleep(SEND_MESSAGE_CHUNK_INTERVAL_MS);
-        }
-        return null;
-      }), Promise.resolve());
-  }
-
-  return {
-    describe() {
-      return {
-        id: "weixin",
-        variant: "v2",
-        kind: "channel",
-        stateDir: config.stateDir,
-        baseUrl: config.weixinBaseUrl,
-        accountsDir: config.accountsDir,
-        syncBufferDir: config.syncBufferDir,
-        protocolClientVersion: config.weixinProtocolClientVersion,
-        routeTag: config.weixinRouteTag,
-      };
-    },
-    async login() {
-      await runV2LoginFlow(config);
-    },
-    printAccounts() {
-      const accounts = listWeixinAccounts(config);
-      if (!accounts.length) {
-        console.log("当前没有已保存的微信账号。先执行 `npm run login`。");
-        return;
-      }
-      console.log("已保存账号：");
-      for (const account of accounts) {
-        console.log(`- ${account.accountId}`);
-        console.log(`  userId: ${account.userId || "(unknown)"}`);
-        console.log(`  baseUrl: ${account.baseUrl || config.weixinBaseUrl}`);
-        if (account.routeTag) {
-          console.log(`  routeTag: ${account.routeTag}`);
-        }
-        console.log(`  savedAt: ${account.savedAt || "(unknown)"}`);
-      }
-    },
-    resolveAccount() {
-      return ensureAccount();
-    },
-    getKnownContextTokens() {
-      return { ...ensureContextTokenCache() };
-    },
-    loadSyncBuffer() {
-      const account = ensureAccount();
-      return loadSyncBuffer(config, account.accountId);
-    },
-    saveSyncBuffer(buffer) {
-      const account = ensureAccount();
-      saveSyncBuffer(config, account.accountId, buffer);
-    },
-    rememberContextToken,
-    async getUpdates({ syncBuffer = "", timeoutMs = LONG_POLL_TIMEOUT_MS } = {}) {
-      const account = ensureAccount();
-      const response = await getUpdatesV2({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        getUpdatesBuf: syncBuffer,
-        timeoutMs,
-        routeTag: account.routeTag,
-        clientVersion: config.weixinProtocolClientVersion,
-      });
-      if (typeof response?.get_updates_buf === "string" && response.get_updates_buf.trim()) {
-        this.saveSyncBuffer(response.get_updates_buf.trim());
-      }
-      const messages = Array.isArray(response?.msgs) ? response.msgs : [];
-      for (const message of messages) {
-        const userId = typeof message?.from_user_id === "string" ? message.from_user_id.trim() : "";
-        const contextToken = typeof message?.context_token === "string" ? message.context_token.trim() : "";
-        if (userId && contextToken) {
-          rememberContextToken(userId, contextToken);
-        }
-      }
-      return response;
-    },
-    normalizeIncomingMessage(message) {
-      const account = ensureAccount();
-      return inboundFilter.normalize(message, config, account.accountId);
-    },
-    async sendText({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
-      await sendTextChunks({ userId, text, contextToken, preserveBlock, trace });
-    },
-    async sendTyping({ userId, status = 1, contextToken = "" }) {
-      const account = ensureAccount();
-      const resolvedToken = resolveContextToken(userId, contextToken);
-      if (!resolvedToken) {
-        return;
-      }
-      const configResponse = await getConfigV2({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        routeTag: account.routeTag,
-        clientVersion: config.weixinProtocolClientVersion,
-        ilinkUserId: userId,
-        contextToken: resolvedToken,
-      }).catch(() => null);
-      const typingTicket = typeof configResponse?.typing_ticket === "string"
-        ? configResponse.typing_ticket.trim()
-        : "";
-      if (!typingTicket) {
-        return;
-      }
-      await sendTypingV2({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        routeTag: account.routeTag,
-        clientVersion: config.weixinProtocolClientVersion,
-        body: {
-          ilink_user_id: userId,
-          typing_ticket: typingTicket,
-          status,
-        },
-      });
-    },
-    async sendFile({ userId, filePath, contextToken = "" }) {
-      const account = ensureAccount();
-      const resolvedToken = resolveContextToken(userId, contextToken);
-      if (!resolvedToken) {
-        throw new Error(`缺少 context_token，无法发送文件给用户 ${userId}`);
-      }
-      // Text polling/sending lives on the v2 stack, but attachments intentionally
-      // stay on the legacy media API. The original repo never moved sendFile onto
-      // v2, and live timeline screenshot failures ("getUploadUrl returned no
-      // upload_param") only appeared after we forced media onto the v2 headers.
-      // Keep this split explicit so future "cleanup" work does not silently route
-      // screenshots/files back onto the broken stack.
-      return sendWeixinMediaFile({
-        filePath,
-        to: userId,
-        contextToken: resolvedToken,
-        baseUrl: account.baseUrl,
-        token: account.token,
-        cdnBaseUrl: config.weixinCdnBaseUrl,
-        apiVariant: "legacy",
-        routeTag: account.routeTag,
-        clientVersion: config.weixinProtocolClientVersion,
-      });
-    },
-  };
-}
-
-function normalizeAdapterVariant(value) {
-  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
-  return normalized === "legacy" ? "legacy" : "v2";
-}
-
-function splitUtf8(text, maxRunes) {
-  const runes = Array.from(String(text || ""));
-  if (!runes.length || runes.length <= maxRunes) {
-    return [String(text || "")];
-  }
-  const chunks = [];
-  while (runes.length) {
-    chunks.push(runes.splice(0, maxRunes).join(""));
-  }
-  return chunks;
-}
-
-function compactPlainTextForWeixin(text) {
-  const normalized = String(text || "").replace(/\r\n/g, "\n");
-  return trimOuterBlankLines(normalized.replace(/\n\s*\n+/g, "\n"));
-}
-
-function chunkReplyText(text, limit = 3500) {
-  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
-  if (!normalized.trim()) {
-    return [];
-  }
-
-  const chunks = [];
-  let remaining = normalized;
-  while (remaining.length > limit) {
-    const candidate = remaining.slice(0, limit);
-    const splitIndex = Math.max(
-      candidate.lastIndexOf("\n\n"),
-      candidate.lastIndexOf("\n"),
-      candidate.lastIndexOf("。"),
-      candidate.lastIndexOf(". "),
-      candidate.lastIndexOf(" ")
-    );
-    const cut = splitIndex > limit * 0.4 ? splitIndex + (candidate[splitIndex] === "\n" ? 0 : 1) : limit;
-    const chunk = trimOuterBlankLines(remaining.slice(0, cut));
-    if (chunk.trim()) {
-      chunks.push(chunk);
-    }
-    remaining = trimOuterBlankLines(remaining.slice(cut));
-  }
-  if (remaining) {
-    chunks.push(remaining);
-  }
-  return chunks.filter(Boolean);
-}
-
-function chunkReplyTextForWeixin(text, limit = 80) {
-  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
-  if (!normalized.trim()) {
-    return [];
-  }
-
-  const boundaries = collectStreamingBoundaries(normalized);
-  if (!boundaries.length) {
-    return chunkReplyText(normalized, limit);
-  }
-
-  const units = [];
-  let start = 0;
-  for (const boundary of boundaries) {
-    if (boundary <= start) {
-      continue;
-    }
-    const unit = trimOuterBlankLines(normalized.slice(start, boundary));
-    if (unit) {
-      units.push(unit);
-    }
-    start = boundary;
-  }
-
-  const tail = trimOuterBlankLines(normalized.slice(start));
-  if (tail) {
-    units.push(tail);
-  }
-
-  if (!units.length) {
-    return chunkReplyText(normalized, limit);
-  }
-
-  const chunks = [];
-  for (const unit of units) {
-    if (unit.length <= limit) {
-      chunks.push(unit);
-      continue;
-    }
-    chunks.push(...chunkReplyText(unit, limit));
-  }
-  return chunks.filter(Boolean);
-}
-
-function packChunksForWeixinDelivery(chunks, maxMessages = 10, maxChunkChars = 3800) {
-  const normalizedChunks = Array.isArray(chunks)
-    ? chunks.map((chunk) => compactPlainTextForWeixin(chunk)).filter(Boolean)
-    : [];
-  if (!normalizedChunks.length || normalizedChunks.length <= maxMessages) {
-    return normalizedChunks;
-  }
-
-  const packed = normalizedChunks.slice(0, Math.max(0, maxMessages - 1));
-  const tailChunks = normalizedChunks.slice(Math.max(0, maxMessages - 1));
-  if (!tailChunks.length) {
-    return packed;
-  }
-
-  const tailText = compactPlainTextForWeixin(tailChunks.join("\n")) || "已完成。";
-  if (tailText.length <= maxChunkChars) {
-    packed.push(tailText);
-    return packed;
-  }
-
-  const tailHardChunks = splitUtf8(tailText, maxChunkChars);
-  if (tailHardChunks.length === 1) {
-    packed.push(tailHardChunks[0]);
-    return packed;
-  }
-
-  const preserveCount = Math.max(0, maxMessages - tailHardChunks.length);
-  const preserved = normalizedChunks.slice(0, preserveCount);
-  const rebundledTail = normalizedChunks.slice(preserveCount);
-  const groupedTail = [];
-  let current = "";
-  for (const chunk of rebundledTail) {
-    const joined = current ? `${current}\n${chunk}` : chunk;
-    if (current && joined.length > maxChunkChars) {
-      groupedTail.push(current);
-      current = chunk;
-      continue;
-    }
-    current = joined;
-  }
-  if (current) {
-    groupedTail.push(current);
-  }
-
-  const normalizedGroupedTail = groupedTail.map((item) => compactPlainTextForWeixin(item) || "已完成。");
-  if (preserved.length + normalizedGroupedTail.length <= maxMessages) {
-    return preserved.concat(normalizedGroupedTail);
-  }
-
-  // Never silently drop the tail of a long reply. If grouping by semantic
-  // chunk boundaries still overflows the per-message budget, fall back to hard
-  // UTF-8 splits of the already-joined tail so the full answer is still sent.
-  return preserved.concat(tailHardChunks.slice(0, Math.max(1, maxMessages - preserved.length)));
-}
-
-function collectStreamingBoundaries(text) {
-  const boundaries = new Set();
-
-  const regex = /\n\s*\n+/g;
-  let match = regex.exec(text);
-  while (match) {
-    boundaries.add(match.index + match[0].length);
-    match = regex.exec(text);
-  }
-
-  const listRegex = /\n(?:(?:[-*])\s+|(?:\d+\.)\s+)/g;
-  match = listRegex.exec(text);
-  while (match) {
-    boundaries.add(match.index + 1);
-    match = listRegex.exec(text);
-  }
-
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index];
-    if (!/[。！？!?]/.test(char)) {
-      continue;
-    }
-
-    let end = index + 1;
-    while (end < text.length && /["'”’）)\]」』】]/.test(text[end])) {
-      end += 1;
-    }
-    while (end < text.length && /[\t \n]/.test(text[end])) {
-      end += 1;
-    }
-    boundaries.add(end);
-  }
-
-  return Array.from(boundaries).sort((left, right) => left - right);
-}
-
-async function sendTextChunkWithRetry(send, { trace = null } = {}) {
-  let lastError = null;
-  for (let attempt = 0; attempt <= SEND_RETRY_DELAYS_MS.length; attempt += 1) {
-    const attemptNumber = attempt + 1;
-    try {
-      logWeixinSendTrace("attempt", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-      });
-      const result = await send();
-      logWeixinSendTrace("success", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-      });
-      return result;
-    } catch (error) {
-      lastError = error;
-      const retryable = isRetryableSendError(error);
-      logWeixinSendTrace("error", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-        retryable,
-        error: String(error?.message || error || ""),
-      });
-      if (!retryable || attempt >= SEND_RETRY_DELAYS_MS.length) {
-        throw error;
-      }
-      await sleep(SEND_RETRY_DELAYS_MS[attempt]);
-    }
-  }
-  throw lastError || new Error("sendText chunk failed");
-}
-
-function sendV2TextChunk({
-  sendTextImpl = sendTextV2,
-  baseUrl,
-  token,
-  routeTag = "",
-  clientVersion = "",
-  toUserId,
-  text,
-  contextToken,
-  clientId = "",
-  trace = null,
-}) {
-  const stableClientId = String(clientId || "").trim() || `cb-${crypto.randomUUID()}`;
-  return sendTextChunkWithRetry(
-    () => sendTextImpl({
-      baseUrl,
-      token,
-      routeTag,
-      clientVersion,
-      toUserId,
-      text,
-      contextToken,
-      clientId: stableClientId,
-    }),
-    {
-      trace: buildWeixinTraceContext(trace, {
-        variant: "v2",
-        clientId: stableClientId,
-        chars: String(text || "").length,
-        textHash: hashTraceText(text),
-      }),
-    }
-  );
-}
-
-function isRetryableSendError(error) {
-  const message = String(error?.message || error || "");
-  // `ret=-2` is ambiguous in live WeChat delivery: the API can still return it
-  // after the user-facing message has already landed. Retrying that chunk risks
-  // duplicating the same assistant block in chat, which is worse than surfacing
-  // one degraded turn locally and letting the operator re-send intentionally.
-  return message.includes("AbortError")
-    || message.includes("aborted")
-    || message.includes("fetch failed")
-    || message.includes("ECONNRESET")
-    || message.includes("ETIMEDOUT")
-    || /http 5\d\d/.test(message);
-}
-
-function buildWeixinTraceContext(trace, defaults = {}) {
-  const normalizedTrace = normalizeTraceContext(trace);
-  return {
-    ...defaults,
-    ...normalizedTrace,
-    enabled: Boolean(normalizedTrace.enabled ?? defaults.enabled),
-    traceId: normalizeTraceText(normalizedTrace.traceId)
-      || normalizeTraceText(defaults.traceId)
-      || `wx-${crypto.randomUUID().slice(0, 8)}`,
-  };
-}
-
-function normalizeTraceContext(trace) {
-  if (!trace || typeof trace !== "object") {
-    return {};
-  }
-  return { ...trace };
-}
-
-function normalizeTraceText(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function logWeixinSendTrace(stage, trace) {
-  if (!Boolean(trace?.enabled)) {
-    return;
-  }
-  const parts = [
+const crypto = require("crypto");
+const { listWeixinAccounts, resolveSelectedAccount } = require("./account-store");
+const { loadPersistedContextTokens, persistContextToken } = require("./context-token-store");
+const { runV2LoginFlow } = require("./login-v2");
+const {
+  getConfigV2,
+  getUpdatesV2,
+  sendTextV2,
+  sendTypingV2,
+} = require("./api-v2");
+const { createLegacyWeixinChannelAdapter } = require("./legacy");
+const { createInboundFilter } = require("./message-utils-v2");
+const { sendWeixinMediaFile } = require("./media-send");
+const { loadSyncBuffer, saveSyncBuffer } = require("./sync-buffer-store");
+
+const LONG_POLL_TIMEOUT_MS = 35_000;
+const MAX_WEIXIN_CHUNK = 3800;
+const SEND_MESSAGE_CHUNK_INTERVAL_MS = 350;
+const WEIXIN_SEND_CHUNK_LIMIT = 80;
+const WEIXIN_MAX_DELIVERY_MESSAGES = 10;
+const SEND_RETRY_DELAYS_MS = [900, 1800];
+const AMBIGUOUS_SEND_RETRY_DELAYS_MS = [1200];
+
+function createWeixinChannelAdapter(config) {
+  const variant = normalizeAdapterVariant(config.weixinAdapterVariant);
+  if (variant === "legacy") {
+    return createLegacyWeixinChannelAdapter(config);
+  }
+
+  let selectedAccount = null;
+  let contextTokenCache = null;
+  const inboundFilter = createInboundFilter();
+
+  function ensureAccount() {
+    if (!selectedAccount) {
+      selectedAccount = resolveSelectedAccount(config);
+      contextTokenCache = loadPersistedContextTokens(config, selectedAccount.accountId);
+    }
+    return selectedAccount;
+  }
+
+  function ensureContextTokenCache() {
+    if (!contextTokenCache) {
+      const account = ensureAccount();
+      contextTokenCache = loadPersistedContextTokens(config, account.accountId);
+    }
+    return contextTokenCache;
+  }
+
+  function rememberContextToken(userId, contextToken) {
+    const account = ensureAccount();
+    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
+    const normalizedToken = typeof contextToken === "string" ? contextToken.trim() : "";
+    if (!normalizedUserId || !normalizedToken) {
+      return "";
+    }
+    contextTokenCache = persistContextToken(config, account.accountId, normalizedUserId, normalizedToken);
+    return normalizedToken;
+  }
+
+  function resolveContextToken(userId, explicitToken = "") {
+    const normalizedExplicitToken = typeof explicitToken === "string" ? explicitToken.trim() : "";
+    if (normalizedExplicitToken) {
+      return normalizedExplicitToken;
+    }
+    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
+    if (!normalizedUserId) {
+      return "";
+    }
+    return ensureContextTokenCache()[normalizedUserId] || "";
+  }
+
+  function sendTextChunks({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
+    const account = ensureAccount();
+    const resolvedToken = resolveContextToken(userId, contextToken);
+    if (!resolvedToken) {
+      throw new Error(`缺少 context_token，无法回复用户 ${userId}`);
+    }
+    const content = String(text || "");
+    if (!content.trim()) {
+      return Promise.resolve();
+    }
+    const sendChunks = preserveBlock
+      ? splitUtf8(compactPlainTextForWeixin(content) || "已完成。", MAX_WEIXIN_CHUNK)
+      : packChunksForWeixinDelivery(
+        chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT).length
+          ? chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT)
+          : ["已完成。"],
+        WEIXIN_MAX_DELIVERY_MESSAGES,
+        MAX_WEIXIN_CHUNK
+      );
+    const traceContext = buildWeixinTraceContext(trace, {
+      enabled: config.weixinDeliveryTrace,
+      origin: "adapter.sendText",
+      variant: "v2",
+      preserveBlock,
+      chunkTotal: sendChunks.length,
+    });
+    return sendChunks.reduce((promise, chunk, index) => promise
+      .then(() => {
+        const compactChunk = compactPlainTextForWeixin(chunk) || "已完成。";
+        const clientId = `cb-${crypto.randomUUID()}`;
+        return sendV2TextChunk({
+          baseUrl: account.baseUrl,
+          token: account.token,
+          routeTag: account.routeTag,
+          clientVersion: config.weixinProtocolClientVersion,
+          toUserId: userId,
+          text: compactChunk,
+          contextToken: resolvedToken,
+          clientId,
+          trace: {
+            ...traceContext,
+            chunkIndex: index + 1,
+            chars: compactChunk.length,
+            textHash: hashTraceText(compactChunk),
+            clientId,
+          },
+        });
+      })
+      .then(() => {
+        if (index < sendChunks.length - 1) {
+          return sleep(SEND_MESSAGE_CHUNK_INTERVAL_MS);
+        }
+        return null;
+      }), Promise.resolve());
+  }
+
+  return {
+    describe() {
+      return {
+        id: "weixin",
+        variant: "v2",
+        kind: "channel",
+        stateDir: config.stateDir,
+        baseUrl: config.weixinBaseUrl,
+        accountsDir: config.accountsDir,
+        syncBufferDir: config.syncBufferDir,
+        protocolClientVersion: config.weixinProtocolClientVersion,
+        routeTag: config.weixinRouteTag,
+      };
+    },
+    async login() {
+      await runV2LoginFlow(config);
+    },
+    printAccounts() {
+      const accounts = listWeixinAccounts(config);
+      if (!accounts.length) {
+        console.log("当前没有已保存的微信账号。先执行 `npm run login`。");
+        return;
+      }
+      console.log("已保存账号：");
+      for (const account of accounts) {
+        console.log(`- ${account.accountId}`);
+        console.log(`  userId: ${account.userId || "(unknown)"}`);
+        console.log(`  baseUrl: ${account.baseUrl || config.weixinBaseUrl}`);
+        if (account.routeTag) {
+          console.log(`  routeTag: ${account.routeTag}`);
+        }
+        console.log(`  savedAt: ${account.savedAt || "(unknown)"}`);
+      }
+    },
+    resolveAccount() {
+      return ensureAccount();
+    },
+    getKnownContextTokens() {
+      return { ...ensureContextTokenCache() };
+    },
+    loadSyncBuffer() {
+      const account = ensureAccount();
+      return loadSyncBuffer(config, account.accountId);
+    },
+    saveSyncBuffer(buffer) {
+      const account = ensureAccount();
+      saveSyncBuffer(config, account.accountId, buffer);
+    },
+    rememberContextToken,
+    async getUpdates({ syncBuffer = "", timeoutMs = LONG_POLL_TIMEOUT_MS } = {}) {
+      const account = ensureAccount();
+      const response = await getUpdatesV2({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        getUpdatesBuf: syncBuffer,
+        timeoutMs,
+        routeTag: account.routeTag,
+        clientVersion: config.weixinProtocolClientVersion,
+      });
+      if (typeof response?.get_updates_buf === "string" && response.get_updates_buf.trim()) {
+        this.saveSyncBuffer(response.get_updates_buf.trim());
+      }
+      const messages = Array.isArray(response?.msgs) ? response.msgs : [];
+      for (const message of messages) {
+        const userId = typeof message?.from_user_id === "string" ? message.from_user_id.trim() : "";
+        const contextToken = typeof message?.context_token === "string" ? message.context_token.trim() : "";
+        if (userId && contextToken) {
+          rememberContextToken(userId, contextToken);
+        }
+      }
+      return response;
+    },
+    normalizeIncomingMessage(message) {
+      const account = ensureAccount();
+      return inboundFilter.normalize(message, config, account.accountId);
+    },
+    async sendText({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
+      await sendTextChunks({ userId, text, contextToken, preserveBlock, trace });
+    },
+    async sendTyping({ userId, status = 1, contextToken = "" }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        return;
+      }
+      const configResponse = await getConfigV2({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        routeTag: account.routeTag,
+        clientVersion: config.weixinProtocolClientVersion,
+        ilinkUserId: userId,
+        contextToken: resolvedToken,
+      }).catch(() => null);
+      const typingTicket = typeof configResponse?.typing_ticket === "string"
+        ? configResponse.typing_ticket.trim()
+        : "";
+      if (!typingTicket) {
+        return;
+      }
+      await sendTypingV2({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        routeTag: account.routeTag,
+        clientVersion: config.weixinProtocolClientVersion,
+        body: {
+          ilink_user_id: userId,
+          typing_ticket: typingTicket,
+          status,
+        },
+      });
+    },
+    async sendFile({ userId, filePath, contextToken = "" }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        throw new Error(`缺少 context_token，无法发送文件给用户 ${userId}`);
+      }
+      // Text polling/sending lives on the v2 stack, but attachments intentionally
+      // stay on the legacy media API. The original repo never moved sendFile onto
+      // v2, and live timeline screenshot failures ("getUploadUrl returned no
+      // upload_param") only appeared after we forced media onto the v2 headers.
+      // Keep this split explicit so future "cleanup" work does not silently route
+      // screenshots/files back onto the broken stack.
+      return sendWeixinMediaFile({
+        filePath,
+        to: userId,
+        contextToken: resolvedToken,
+        baseUrl: account.baseUrl,
+        token: account.token,
+        cdnBaseUrl: config.weixinCdnBaseUrl,
+        apiVariant: "legacy",
+        routeTag: account.routeTag,
+        clientVersion: config.weixinProtocolClientVersion,
+      });
+    },
+  };
+}
+
+function normalizeAdapterVariant(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return normalized === "legacy" ? "legacy" : "v2";
+}
+
+function splitUtf8(text, maxRunes) {
+  const runes = Array.from(String(text || ""));
+  if (!runes.length || runes.length <= maxRunes) {
+    return [String(text || "")];
+  }
+  const chunks = [];
+  while (runes.length) {
+    chunks.push(runes.splice(0, maxRunes).join(""));
+  }
+  return chunks;
+}
+
+function compactPlainTextForWeixin(text) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n");
+  return trimOuterBlankLines(normalized.replace(/\n\s*\n+/g, "\n"));
+}
+
+function chunkReplyText(text, limit = 3500) {
+  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
+  if (!normalized.trim()) {
+    return [];
+  }
+
+  const chunks = [];
+  let remaining = normalized;
+  while (remaining.length > limit) {
+    const candidate = remaining.slice(0, limit);
+    const splitIndex = Math.max(
+      candidate.lastIndexOf("\n\n"),
+      candidate.lastIndexOf("\n"),
+      candidate.lastIndexOf("。"),
+      candidate.lastIndexOf(". "),
+      candidate.lastIndexOf(" ")
+    );
+    const cut = splitIndex > limit * 0.4 ? splitIndex + (candidate[splitIndex] === "\n" ? 0 : 1) : limit;
+    const chunk = trimOuterBlankLines(remaining.slice(0, cut));
+    if (chunk.trim()) {
+      chunks.push(chunk);
+    }
+    remaining = trimOuterBlankLines(remaining.slice(cut));
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks.filter(Boolean);
+}
+
+function chunkReplyTextForWeixin(text, limit = 80) {
+  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
+  if (!normalized.trim()) {
+    return [];
+  }
+
+  const boundaries = collectStreamingBoundaries(normalized);
+  if (!boundaries.length) {
+    return chunkReplyText(normalized, limit);
+  }
+
+  const units = [];
+  let start = 0;
+  for (const boundary of boundaries) {
+    if (boundary <= start) {
+      continue;
+    }
+    const unit = trimOuterBlankLines(normalized.slice(start, boundary));
+    if (unit) {
+      units.push(unit);
+    }
+    start = boundary;
+  }
+
+  const tail = trimOuterBlankLines(normalized.slice(start));
+  if (tail) {
+    units.push(tail);
+  }
+
+  if (!units.length) {
+    return chunkReplyText(normalized, limit);
+  }
+
+  const chunks = [];
+  for (const unit of units) {
+    if (unit.length <= limit) {
+      chunks.push(unit);
+      continue;
+    }
+    chunks.push(...chunkReplyText(unit, limit));
+  }
+  return chunks.filter(Boolean);
+}
+
+function packChunksForWeixinDelivery(chunks, maxMessages = 10, maxChunkChars = 3800) {
+  const normalizedChunks = Array.isArray(chunks)
+    ? chunks.map((chunk) => compactPlainTextForWeixin(chunk)).filter(Boolean)
+    : [];
+  if (!normalizedChunks.length) {
+    return normalizedChunks;
+  }
+
+  const groupedChunks = groupChunksWithinBudget(normalizedChunks, maxChunkChars);
+  if (groupedChunks.length <= maxMessages) {
+    return groupedChunks;
+  }
+
+  const fullText = compactPlainTextForWeixin(normalizedChunks.join("\n")) || "已完成。";
+  const hardChunks = splitUtf8(fullText, maxChunkChars);
+  if (hardChunks.length <= maxMessages) {
+    return hardChunks;
+  }
+
+  // `maxMessages` is only a spam guard. If the full reply still needs more
+  // chunks at the hard per-message budget, prefer complete delivery over
+  // silently dropping the tail.
+  return hardChunks;
+}
+
+function groupChunksWithinBudget(chunks, maxChunkChars) {
+  const grouped = [];
+  let current = "";
+
+  for (const rawChunk of Array.isArray(chunks) ? chunks : []) {
+    const normalizedChunk = compactPlainTextForWeixin(rawChunk);
+    if (!normalizedChunk) {
+      continue;
+    }
+
+    const units = normalizedChunk.length > maxChunkChars
+      ? splitUtf8(normalizedChunk, maxChunkChars)
+      : [normalizedChunk];
+
+    for (const unit of units) {
+      if (!current) {
+        current = unit;
+        continue;
+      }
+      const joined = `${current}\n${unit}`;
+      if (joined.length > maxChunkChars) {
+        grouped.push(current);
+        current = unit;
+        continue;
+      }
+      current = joined;
+    }
+  }
+
+  if (current) {
+    grouped.push(current);
+  }
+  return grouped;
+}
+
+function collectStreamingBoundaries(text) {
+  const boundaries = new Set();
+
+  const regex = /\n\s*\n+/g;
+  let match = regex.exec(text);
+  while (match) {
+    boundaries.add(match.index + match[0].length);
+    match = regex.exec(text);
+  }
+
+  const listRegex = /\n(?:(?:[-*])\s+|(?:\d+\.)\s+)/g;
+  match = listRegex.exec(text);
+  while (match) {
+    boundaries.add(match.index + 1);
+    match = listRegex.exec(text);
+  }
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (!/[。！？!?]/.test(char)) {
+      continue;
+    }
+
+    let end = index + 1;
+    while (end < text.length && /["'”’）)\]」』】]/.test(text[end])) {
+      end += 1;
+    }
+    while (end < text.length && /[\t \n]/.test(text[end])) {
+      end += 1;
+    }
+    boundaries.add(end);
+  }
+
+  return Array.from(boundaries).sort((left, right) => left - right);
+}
+
+async function sendTextChunkWithRetry(send, { trace = null } = {}) {
+  let lastError = null;
+  for (let attempt = 0; ; attempt += 1) {
+    const attemptNumber = attempt + 1;
+    try {
+      logWeixinSendTrace("attempt", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+      });
+      const result = await send();
+      logWeixinSendTrace("success", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+      });
+      return result;
+    } catch (error) {
+      lastError = error;
+      const retryDelays = getSendRetryDelaysMs(error);
+      const retryable = attempt < retryDelays.length;
+      logWeixinSendTrace("error", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+        retryable,
+        error: String(error?.message || error || ""),
+      });
+      if (!retryable) {
+        throw error;
+      }
+      await sleep(retryDelays[attempt]);
+    }
+  }
+  throw lastError || new Error("sendText chunk failed");
+}
+
+function sendV2TextChunk({
+  sendTextImpl = sendTextV2,
+  baseUrl,
+  token,
+  routeTag = "",
+  clientVersion = "",
+  toUserId,
+  text,
+  contextToken,
+  clientId = "",
+  trace = null,
+}) {
+  const stableClientId = String(clientId || "").trim() || `cb-${crypto.randomUUID()}`;
+  return sendTextChunkWithRetry(
+    () => sendTextImpl({
+      baseUrl,
+      token,
+      routeTag,
+      clientVersion,
+      toUserId,
+      text,
+      contextToken,
+      clientId: stableClientId,
+    }),
+    {
+      trace: buildWeixinTraceContext(trace, {
+        variant: "v2",
+        clientId: stableClientId,
+        chars: String(text || "").length,
+        textHash: hashTraceText(text),
+      }),
+    }
+  );
+}
+
+function getSendRetryDelaysMs(error) {
+  const message = String(error?.message || error || "");
+  // `ret=-2` is ambiguous: the first attempt may already have landed, or it may
+  // have died before the user ever saw it. Retrying with the same client_id once
+  // keeps the call idempotent enough to avoid visible truncation without turning
+  // one flaky send into a burst of duplicate bubbles.
+  if (message.includes("ret=-2")) {
+    return AMBIGUOUS_SEND_RETRY_DELAYS_MS;
+  }
+  if (message.includes("AbortError")
+    || message.includes("aborted")
+    || message.includes("fetch failed")
+    || message.includes("ECONNRESET")
+    || message.includes("ETIMEDOUT")
+    || /http 5\d\d/.test(message)) {
+    return SEND_RETRY_DELAYS_MS;
+  }
+  return [];
+}
+
+function buildWeixinTraceContext(trace, defaults = {}) {
+  const normalizedTrace = normalizeTraceContext(trace);
+  return {
+    ...defaults,
+    ...normalizedTrace,
+    enabled: Boolean(normalizedTrace.enabled ?? defaults.enabled),
+    traceId: normalizeTraceText(normalizedTrace.traceId)
+      || normalizeTraceText(defaults.traceId)
+      || `wx-${crypto.randomUUID().slice(0, 8)}`,
+  };
+}
+
+function normalizeTraceContext(trace) {
+  if (!trace || typeof trace !== "object") {
+    return {};
+  }
+  return { ...trace };
+}
+
+function normalizeTraceText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function logWeixinSendTrace(stage, trace) {
+  if (!Boolean(trace?.enabled)) {
+    return;
+  }
+  const parts = [
     `[codeksei] weixin send trace stage=${stage}`,
-    `pid=${process.pid}`,
-    `trace=${trace.traceId || "(none)"}`,
-    `origin=${trace.origin || "adapter.sendText"}`,
-    `variant=${trace.variant || "v2"}`,
-    trace.threadId ? `thread=${trace.threadId}` : "",
-    `turn=${trace.turnId || "(pending)"}`,
-    trace.mode ? `mode=${trace.mode}` : "",
-    trace.trigger ? `trigger=${trace.trigger}` : "",
-    `chunk=${trace.chunkIndex || 1}/${trace.chunkTotal || 1}`,
-    `preserveBlock=${trace.preserveBlock ? "1" : "0"}`,
-    `attempt=${trace.attempt || 1}`,
-    trace.retryable === undefined ? "" : `retryable=${trace.retryable ? "1" : "0"}`,
-    `clientId=${trace.clientId || "(none)"}`,
-    `chars=${trace.chars || 0}`,
-    `hash=${trace.textHash || hashTraceText("")}`,
-  ].filter(Boolean);
-  if (trace.error) {
-    parts.push(`error=${JSON.stringify(String(trace.error || ""))}`);
-    console.error(parts.join(" "));
-    return;
-  }
-  console.log(parts.join(" "));
-}
-
-function hashTraceText(text) {
-  return crypto.createHash("sha1").update(String(text || ""), "utf8").digest("hex").slice(0, 12);
-}
-
-function trimOuterBlankLines(text) {
-  return String(text || "")
-    .replace(/^\s*\n+/g, "")
-    .replace(/\n+\s*$/g, "");
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-module.exports = {
-  createWeixinChannelAdapter,
-  sendV2TextChunk,
-};
+    `pid=${process.pid}`,
+    `trace=${trace.traceId || "(none)"}`,
+    `origin=${trace.origin || "adapter.sendText"}`,
+    `variant=${trace.variant || "v2"}`,
+    trace.threadId ? `thread=${trace.threadId}` : "",
+    `turn=${trace.turnId || "(pending)"}`,
+    trace.mode ? `mode=${trace.mode}` : "",
+    trace.trigger ? `trigger=${trace.trigger}` : "",
+    `chunk=${trace.chunkIndex || 1}/${trace.chunkTotal || 1}`,
+    `preserveBlock=${trace.preserveBlock ? "1" : "0"}`,
+    `attempt=${trace.attempt || 1}`,
+    trace.retryable === undefined ? "" : `retryable=${trace.retryable ? "1" : "0"}`,
+    `clientId=${trace.clientId || "(none)"}`,
+    `chars=${trace.chars || 0}`,
+    `hash=${trace.textHash || hashTraceText("")}`,
+  ].filter(Boolean);
+  if (trace.error) {
+    parts.push(`error=${JSON.stringify(String(trace.error || ""))}`);
+    console.error(parts.join(" "));
+    return;
+  }
+  console.log(parts.join(" "));
+}
+
+function hashTraceText(text) {
+  return crypto.createHash("sha1").update(String(text || ""), "utf8").digest("hex").slice(0, 12);
+}
+
+function trimOuterBlankLines(text) {
+  return String(text || "")
+    .replace(/^\s*\n+/g, "")
+    .replace(/\n+\s*$/g, "");
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  createWeixinChannelAdapter,
+  packChunksForWeixinDelivery,
+  sendV2TextChunk,
+};