codeksei 0.1.0

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

@@ -0,0 +1,567 @@
+const crypto = require("crypto");
+const { listWeixinAccounts } = require("./account-store");
+const { resolveSelectedAccount } = require("./account-store");
+const { loadPersistedContextTokens, persistContextToken } = require("./context-token-store");
+const { runLegacyLoginFlow } = require("./login-legacy");
+const { getConfig, getUpdates, sendMessage, sendTyping } = require("./api");
+const { sendWeixinMediaFile } = require("./media-send");
+const { normalizeWeixinIncomingMessage } = require("./message-utils");
+const { loadSyncBuffer, saveSyncBuffer } = require("./sync-buffer-store");
+
+const LONG_POLL_TIMEOUT_MS = 35_000;
+const SEND_MESSAGE_CHUNK_INTERVAL_MS = 350;
+const WEIXIN_SEND_CHUNK_LIMIT = 80;
+const MAX_WEIXIN_CHUNK = 3800;
+const WEIXIN_MAX_DELIVERY_MESSAGES = 10;
+const SEND_RETRY_DELAYS_MS = [900, 1800];
+
+function createLegacyWeixinChannelAdapter(config) {
+  let selectedAccount = null;
+  let contextTokenCache = null;
+
+  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] || "";
+  }
+
+  return {
+    describe() {
+      return {
+        id: "weixin",
+        variant: "legacy",
+        kind: "channel",
+        stateDir: config.stateDir,
+        baseUrl: config.weixinBaseUrl,
+        accountsDir: config.accountsDir,
+        syncBufferDir: config.syncBufferDir,
+      };
+    },
+    async login() {
+      await runLegacyLoginFlow(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 getUpdates({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        get_updates_buf: syncBuffer,
+        timeoutMs,
+      });
+      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 normalizeWeixinIncomingMessage(message, config, account.accountId);
+    },
+    async sendText({ 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 || "");
+      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: "legacy",
+        preserveBlock,
+        chunkTotal: sendChunks.length,
+      });
+      for (let index = 0; index < sendChunks.length; index += 1) {
+        const compactChunk = compactPlainTextForWeixin(sendChunks[index]) || "已完成。";
+        const clientId = crypto.randomUUID();
+        await sendLegacyTextChunk({
+          baseUrl: account.baseUrl,
+          token: account.token,
+          toUserId: userId,
+          text: compactChunk,
+          contextToken: resolvedToken,
+          clientId,
+          trace: {
+            ...traceContext,
+            chunkIndex: index + 1,
+            chars: compactChunk.length,
+            textHash: hashTraceText(compactChunk),
+            clientId,
+          },
+        });
+        if (index < sendChunks.length - 1) {
+          await sleep(SEND_MESSAGE_CHUNK_INTERVAL_MS);
+        }
+      }
+    },
+    async sendTyping({ userId, status = 1, contextToken = "" }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        return;
+      }
+      const configResponse = await getConfig({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        ilinkUserId: userId,
+        contextToken: resolvedToken,
+      }).catch(() => null);
+      const typingTicket = typeof configResponse?.typing_ticket === "string"
+        ? configResponse.typing_ticket.trim()
+        : "";
+      if (!typingTicket) {
+        return;
+      }
+      await sendTyping({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        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}`);
+      }
+      return sendWeixinMediaFile({
+        filePath,
+        to: userId,
+        contextToken: resolvedToken,
+        baseUrl: account.baseUrl,
+        token: account.token,
+        cdnBaseUrl: config.weixinCdnBaseUrl,
+      });
+    },
+  };
+}
+
+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 sendLegacyTextChunk({
+  sendMessageImpl = sendMessage,
+  baseUrl,
+  token,
+  toUserId,
+  text,
+  contextToken,
+  clientId = "",
+  trace = null,
+}) {
+  const stableClientId = String(clientId || "").trim() || crypto.randomUUID();
+  return sendTextChunkWithRetry(
+    () => sendMessageImpl({
+      baseUrl,
+      token,
+      body: {
+        msg: {
+          client_id: stableClientId,
+          from_user_id: "",
+          to_user_id: toUserId,
+          message_type: 2,
+          message_state: 2,
+          item_list: [
+            {
+              type: 1,
+              text_item: { text: String(text || "") },
+            },
+          ],
+          context_token: contextToken,
+        },
+      },
+    }),
+    {
+      trace: buildWeixinTraceContext(trace, {
+        variant: "legacy",
+        clientId: stableClientId,
+        chars: String(text || "").length,
+        textHash: hashTraceText(text),
+      }),
+    }
+  );
+}
+
+function isRetryableSendError(error) {
+  const message = String(error?.message || error || "");
+  // Legacy sendmessage shows the same live ambiguity as v2: `ret=-2` can mean
+  // "client saw an error even though WeChat already accepted the message".
+  // Do not auto-retry it, or one failed bridge turn can fan out into duplicate
+  // bubbles on the user side.
+  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 = [
+    `[codeksei] weixin send trace stage=${stage}`,
+    `pid=${process.pid}`,
+    `trace=${trace.traceId || "(none)"}`,
+    `origin=${trace.origin || "adapter.sendText"}`,
+    `variant=${trace.variant || "legacy"}`,
+    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 = {
+  createLegacyWeixinChannelAdapter,
+  sendLegacyTextChunk,
+};

package/src/adapters/channel/weixin/login-common.js

@@ -0,0 +1,63 @@
+const qrcodeTerminal = require("qrcode-terminal");
+const {
+  deleteWeixinAccount,
+  listWeixinAccounts,
+  saveWeixinAccount,
+} = require("./account-store");
+const { clearPersistedContextTokens } = require("./context-token-store");
+
+const ACTIVE_LOGIN_TTL_MS = 5 * 60_000;
+const MAX_QR_REFRESH_COUNT = 3;
+
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+function printQrCode(url) {
+  try {
+    qrcodeTerminal.generate(url, { small: true });
+    console.log("如果二维码未能成功展示，请用浏览器打开以下链接扫码：");
+    console.log(url);
+  } catch {
+    console.log(url);
+  }
+}
+
+function cleanupStaleAccountsForUserId(config, activeAccount) {
+  const activeUserId = typeof activeAccount?.userId === "string" ? activeAccount.userId.trim() : "";
+  if (!activeUserId) {
+    return [];
+  }
+  const staleAccounts = listWeixinAccounts(config).filter((account) => (
+    account.accountId !== activeAccount.accountId
+    && typeof account.userId === "string"
+    && account.userId.trim() === activeUserId
+  ));
+  for (const staleAccount of staleAccounts) {
+    deleteWeixinAccount(config, staleAccount.accountId);
+    clearPersistedContextTokens(config, staleAccount.accountId);
+    console.log(`[codeksei] removed stale account ${staleAccount.accountId} for userId ${activeUserId}`);
+  }
+  return staleAccounts;
+}
+
+function finishWeixinLogin(config, result) {
+  const account = saveWeixinAccount(config, result.accountId, result);
+  cleanupStaleAccountsForUserId(config, account);
+  console.log("\n✅ 与微信连接成功！");
+  console.log(`accountId: ${account.accountId}`);
+  console.log(`userId: ${account.userId || "(unknown)"}`);
+  console.log(`baseUrl: ${account.baseUrl}`);
+  if (account.routeTag) {
+    console.log(`routeTag: ${account.routeTag}`);
+  }
+  return account;
+}
+
+module.exports = {
+  ACTIVE_LOGIN_TTL_MS,
+  MAX_QR_REFRESH_COUNT,
+  ensureTrailingSlash,
+  finishWeixinLogin,
+  printQrCode,
+};