codeksei 0.1.0

package/src/adapters/channel/weixin/media-send.js

@@ -0,0 +1,331 @@
+const crypto = require("crypto");
+const path = require("path");
+const fs = require("fs/promises");
+
+const { getUploadUrl, sendMessage } = require("./api");
+const { getUploadUrlV2, sendMessageV2 } = require("./api-v2");
+const { getMimeFromFilename } = require("./media-mime");
+
+const WEIXIN_MEDIA_TYPE = {
+  IMAGE: 1,
+  VIDEO: 2,
+  FILE: 3,
+};
+
+function encryptAesEcb(plaintext, key) {
+  const cipher = crypto.createCipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+
+function aesEcbPaddedSize(plaintextSize) {
+  return Math.ceil((plaintextSize + 1) / 16) * 16;
+}
+
+function buildCdnUploadUrl({ cdnBaseUrl, uploadParam, filekey }) {
+  return `${cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(filekey)}`;
+}
+
+async function uploadBufferToCdn({ buf, uploadParam, filekey, cdnBaseUrl, aeskey }) {
+  const ciphertext = encryptAesEcb(buf, aeskey);
+  const cdnUrl = buildCdnUploadUrl({ cdnBaseUrl, uploadParam, filekey });
+  const response = await fetch(cdnUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/octet-stream" },
+    body: new Uint8Array(ciphertext),
+  });
+  if (response.status !== 200) {
+    const errMsg = response.headers.get("x-error-message") || await response.text();
+    throw new Error(`CDN upload failed: ${errMsg || response.status}`);
+  }
+  const downloadParam = response.headers.get("x-encrypted-param") || "";
+  if (!downloadParam) {
+    throw new Error("CDN upload response missing x-encrypted-param header");
+  }
+  return { downloadParam };
+}
+
+async function uploadMediaToWeixin({ filePath, toUserId, opts, cdnBaseUrl, mediaType, getUploadUrlImpl }) {
+  const plaintext = await fs.readFile(filePath);
+  const rawsize = plaintext.length;
+  const rawfilemd5 = crypto.createHash("md5").update(plaintext).digest("hex");
+  const filesize = aesEcbPaddedSize(rawsize);
+  const filekey = crypto.randomBytes(16).toString("hex");
+  const aeskey = crypto.randomBytes(16);
+
+  const uploadUrlResp = await getUploadUrlImpl({
+    ...opts,
+    filekey,
+    media_type: mediaType,
+    to_user_id: toUserId,
+    rawsize,
+    rawfilemd5,
+    filesize,
+    no_need_thumb: true,
+    aeskey: aeskey.toString("hex"),
+  });
+
+  const uploadParam = uploadUrlResp?.upload_param || "";
+  if (!uploadParam) {
+    throw new Error("getUploadUrl returned no upload_param");
+  }
+
+  const { downloadParam } = await uploadBufferToCdn({
+    buf: plaintext,
+    uploadParam,
+    filekey,
+    cdnBaseUrl,
+    aeskey,
+  });
+
+  return {
+    downloadEncryptedQueryParam: downloadParam,
+    aeskey: aeskey.toString("hex"),
+    fileSize: rawsize,
+    fileSizeCiphertext: filesize,
+  };
+}
+
+function buildMediaRef(uploaded) {
+  return {
+    encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+    aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+    encrypt_type: 1,
+  };
+}
+
+async function sendMediaItem({ to, item, contextToken, baseUrl, token, routeTag = "", clientVersion = "", sendMessageImpl }) {
+  await sendMessageImpl({
+    baseUrl,
+    token,
+    routeTag,
+    clientVersion,
+    body: {
+      msg: {
+        from_user_id: "",
+        to_user_id: to,
+        client_id: crypto.randomUUID(),
+        message_type: 2,
+        message_state: 2,
+        item_list: [item],
+        context_token: contextToken,
+      },
+    },
+  });
+}
+
+function resolveWeixinMediaApi(apiVariant) {
+  if (String(apiVariant || "").trim().toLowerCase() === "v2") {
+    // Upload URL lookup and the final sendmessage call must stay on the same
+    // v2 header stack as text polling/sending, or routed sessions may split
+    // across gateways after login and fail only on attachments.
+    return {
+      getUploadUrlImpl: getUploadUrlV2,
+      sendMessageImpl: sendMessageV2,
+    };
+  }
+  return {
+    getUploadUrlImpl: getUploadUrl,
+    sendMessageImpl: sendMessage,
+  };
+}
+
+async function sendWeixinMediaFile({
+  filePath,
+  to,
+  contextToken,
+  baseUrl,
+  token,
+  cdnBaseUrl,
+  apiVariant = "legacy",
+  routeTag = "",
+  clientVersion = "",
+  mediaApiOverride = null,
+  mediaApiFallbackOverride = null,
+}) {
+  if (!contextToken) {
+    throw new Error("sendWeixinMediaFile requires contextToken");
+  }
+
+  const mime = getMimeFromFilename(filePath);
+  const uploadOpts = { baseUrl, token, routeTag, clientVersion };
+  const primaryMediaApi = mediaApiOverride || resolveWeixinMediaApi(apiVariant);
+  const fallbackMediaApi = mediaApiFallbackOverride
+    || (mediaApiOverride ? null : resolveFallbackWeixinMediaApi(apiVariant));
+  const { getUploadUrlImpl, sendMessageImpl } = primaryMediaApi;
+
+  if (mime.startsWith("image/")) {
+    try {
+      const uploaded = await uploadMediaToWeixin({
+        filePath,
+        toUserId: to,
+        opts: uploadOpts,
+        cdnBaseUrl,
+        mediaType: WEIXIN_MEDIA_TYPE.IMAGE,
+        getUploadUrlImpl,
+      });
+      await sendMediaItem({
+        to,
+        contextToken,
+        baseUrl,
+        token,
+        routeTag,
+        clientVersion,
+        sendMessageImpl,
+        item: {
+          type: 2,
+          image_item: {
+            media: buildMediaRef(uploaded),
+            aeskey: uploaded.aeskey,
+            mid_size: uploaded.fileSizeCiphertext,
+            hd_size: uploaded.fileSizeCiphertext,
+          },
+        },
+      });
+      return { kind: "image", fileName: path.basename(filePath) };
+    } catch (error) {
+      if (!isMissingUploadParamError(error)) {
+        throw error;
+      }
+      // Some WeChat routed sessions refuse image upload params but still accept
+      // generic file uploads. Falling back keeps screenshot delivery alive
+      // instead of failing the whole "send back the screenshot" flow.
+      return sendFileFallback({
+        filePath,
+        to,
+        contextToken,
+        baseUrl,
+        token,
+        routeTag,
+        clientVersion,
+        uploadOpts,
+        cdnBaseUrl,
+        primaryMediaApi,
+        fallbackMediaApi,
+        fallbackFrom: "image",
+      });
+    }
+  }
+
+  if (mime.startsWith("video/")) {
+    const uploaded = await uploadMediaToWeixin({
+      filePath,
+      toUserId: to,
+      opts: uploadOpts,
+      cdnBaseUrl,
+      mediaType: WEIXIN_MEDIA_TYPE.VIDEO,
+      getUploadUrlImpl,
+    });
+    await sendMediaItem({
+      to,
+      contextToken,
+      baseUrl,
+      token,
+      routeTag,
+      clientVersion,
+      sendMessageImpl,
+      item: {
+        type: 5,
+        video_item: {
+          media: buildMediaRef(uploaded),
+          video_size: uploaded.fileSizeCiphertext,
+        },
+      },
+    });
+    return { kind: "video", fileName: path.basename(filePath) };
+  }
+
+  return sendFileFallback({
+    filePath,
+    to,
+    contextToken,
+    baseUrl,
+    token,
+    routeTag,
+    clientVersion,
+    uploadOpts,
+    cdnBaseUrl,
+    primaryMediaApi,
+    fallbackMediaApi,
+    fallbackFrom: "",
+  });
+}
+
+function isMissingUploadParamError(error) {
+  return String(error?.message || error || "").includes("getUploadUrl returned no upload_param");
+}
+
+function resolveFallbackWeixinMediaApi(apiVariant) {
+  const normalized = String(apiVariant || "").trim().toLowerCase();
+  return normalized === "legacy" ? null : resolveWeixinMediaApi("legacy");
+}
+
+async function sendFileFallback({
+  filePath,
+  to,
+  contextToken,
+  baseUrl,
+  token,
+  routeTag,
+  clientVersion,
+  uploadOpts,
+  cdnBaseUrl,
+  primaryMediaApi,
+  fallbackMediaApi = null,
+  fallbackFrom = "",
+}) {
+  const strategies = [
+    { label: "primary", api: primaryMediaApi },
+    { label: "fallback", api: fallbackMediaApi },
+  ].filter((entry) => entry.api);
+
+  let lastError = null;
+  for (let index = 0; index < strategies.length; index += 1) {
+    const { label, api } = strategies[index];
+    try {
+      const uploaded = await uploadMediaToWeixin({
+        filePath,
+        toUserId: to,
+        opts: uploadOpts,
+        cdnBaseUrl,
+        mediaType: WEIXIN_MEDIA_TYPE.FILE,
+        getUploadUrlImpl: api.getUploadUrlImpl,
+      });
+      await sendMediaItem({
+        to,
+        contextToken,
+        baseUrl,
+        token,
+        routeTag,
+        clientVersion,
+        sendMessageImpl: api.sendMessageImpl,
+        item: {
+          type: 4,
+          file_item: {
+            media: buildMediaRef(uploaded),
+            file_name: path.basename(filePath),
+            len: String(uploaded.fileSize),
+          },
+        },
+      });
+      return {
+        kind: "file",
+        fileName: path.basename(filePath),
+        fallbackFrom: fallbackFrom || undefined,
+        uploadStrategy: label,
+      };
+    } catch (error) {
+      lastError = error;
+      if (!isMissingUploadParamError(error) || index >= strategies.length - 1) {
+        throw error;
+      }
+      console.warn(
+        `[codeksei] weixin media upload fallback `
+        + `file=${path.basename(filePath)} reason=${String(error.message || error)}`
+      );
+    }
+  }
+
+  throw lastError || new Error("weixin media upload failed");
+}
+
+module.exports = { sendWeixinMediaFile };

package/src/adapters/channel/weixin/message-utils-v2.js

@@ -0,0 +1,282 @@
+const MESSAGE_TYPE_USER = 1;
+const MESSAGE_TYPE_BOT = 2;
+const MESSAGE_ITEM_TEXT = 1;
+const MESSAGE_ITEM_IMAGE = 2;
+const MESSAGE_ITEM_VOICE = 3;
+const MESSAGE_ITEM_FILE = 4;
+const MESSAGE_ITEM_VIDEO = 5;
+const DEDUP_TTL_MS = 5 * 60_000;
+
+function createInboundFilter() {
+  const seen = new Map();
+
+  return {
+    normalize(message, config, accountId) {
+      if (!message || typeof message !== "object") {
+        return null;
+      }
+      const messageType = Number(message.message_type);
+      if (messageType === MESSAGE_TYPE_BOT) {
+        return null;
+      }
+      if (messageType !== 0 && messageType !== MESSAGE_TYPE_USER) {
+        return null;
+      }
+
+      const senderId = normalizeText(message.from_user_id);
+      if (!senderId) {
+        return null;
+      }
+
+      const createdAtMs = normalizeMessageTimestampMs(message);
+
+      const dedupKey = buildDedupKey(message, senderId, createdAtMs);
+      pruneSeen(seen);
+      if (dedupKey && seen.has(dedupKey)) {
+        return null;
+      }
+      if (dedupKey) {
+        seen.set(dedupKey, Date.now());
+      }
+
+      const itemList = Array.isArray(message.item_list) ? message.item_list : [];
+      const text = bodyFromItemList(itemList);
+      const attachments = extractAttachmentItems(itemList);
+      if (!text && !attachments.length) {
+        return null;
+      }
+
+      return {
+        provider: "weixin",
+        accountId,
+        workspaceId: config.workspaceId,
+        senderId,
+        chatId: senderId,
+        messageId: normalizeMessageId(message),
+        threadKey: normalizeText(message.session_id),
+        text,
+        attachments,
+        contextToken: normalizeText(message.context_token),
+        receivedAt: createdAtMs > 0 ? new Date(createdAtMs).toISOString() : new Date().toISOString(),
+      };
+    },
+  };
+}
+
+function bodyFromItemList(items) {
+  if (!Array.isArray(items) || !items.length) {
+    return "";
+  }
+  for (const item of items) {
+    const itemType = Number(item?.type);
+    if (itemType === MESSAGE_ITEM_TEXT) {
+      const text = normalizeText(item?.text_item?.text);
+      if (!text) {
+        continue;
+      }
+      const ref = item?.ref_msg;
+      if (!ref || !ref.message_item || isMediaItemType(Number(ref.message_item.type))) {
+        return text;
+      }
+      const parts = [];
+      const refTitle = normalizeText(ref.title);
+      if (refTitle) {
+        parts.push(refTitle);
+      }
+      const refBody = bodyFromItemList([ref.message_item]);
+      if (refBody) {
+        parts.push(refBody);
+      }
+      if (!parts.length) {
+        return text;
+      }
+      return `[引用: ${parts.join(" | ")}]\n${text}`;
+    }
+    if (itemType === MESSAGE_ITEM_VOICE) {
+      const voiceText = normalizeText(item?.voice_item?.text);
+      if (voiceText) {
+        return voiceText;
+      }
+    }
+  }
+  return "";
+}
+
+function isMediaItemType(type) {
+  return type === MESSAGE_ITEM_IMAGE || type === MESSAGE_ITEM_VOICE || type === MESSAGE_ITEM_FILE || type === MESSAGE_ITEM_VIDEO;
+}
+
+function extractAttachmentItems(itemList) {
+  if (!Array.isArray(itemList) || !itemList.length) {
+    return [];
+  }
+
+  const attachments = [];
+  for (let index = 0; index < itemList.length; index += 1) {
+    const normalized = normalizeAttachmentItem(itemList[index], index);
+    if (normalized) {
+      attachments.push(normalized);
+    }
+  }
+  return attachments;
+}
+
+function normalizeAttachmentItem(item, index) {
+  const itemType = Number(item?.type);
+  const payload = resolveAttachmentPayload(itemType, item);
+  if (!payload) {
+    return null;
+  }
+
+  const media = payload.media && typeof payload.media === "object"
+    ? payload.media
+    : {};
+
+  return {
+    kind: payload.kind,
+    itemType,
+    index,
+    fileName: normalizeText(
+      payload.body?.file_name
+      || payload.body?.filename
+      || item?.file_name
+      || item?.filename
+    ),
+    sizeBytes: parseOptionalInt(
+      payload.body?.len
+      || payload.body?.file_size
+      || payload.body?.size
+      || payload.body?.video_size
+      || item?.len
+    ),
+    directUrls: collectStringValues([
+      payload.body?.url,
+      payload.body?.download_url,
+      payload.body?.cdn_url,
+      media?.url,
+      media?.download_url,
+      media?.cdn_url,
+    ]),
+    mediaRef: {
+      encryptQueryParam: normalizeText(
+        media?.encrypt_query_param
+        || media?.encrypted_query_param
+        || payload.body?.encrypt_query_param
+        || payload.body?.encrypted_query_param
+        || item?.encrypt_query_param
+        || item?.encrypted_query_param
+      ),
+      aesKey: normalizeText(
+        media?.aes_key
+        || payload.body?.aes_key
+        || item?.aes_key
+      ),
+      aesKeyHex: normalizeText(
+        payload.body?.aeskey
+        || payload.body?.aes_key_hex
+        || item?.aeskey
+      ),
+      encryptType: Number(
+        media?.encrypt_type
+        ?? payload.body?.encrypt_type
+        ?? item?.encrypt_type
+        ?? 1
+      ),
+      fileKey: normalizeText(
+        media?.filekey
+        || payload.body?.filekey
+        || item?.filekey
+      ),
+    },
+    rawItem: item,
+  };
+}
+
+function resolveAttachmentPayload(itemType, item) {
+  if (itemType === MESSAGE_ITEM_IMAGE && item?.image_item && typeof item.image_item === "object") {
+    return { kind: "image", body: item.image_item, media: item.image_item.media };
+  }
+  if (itemType === MESSAGE_ITEM_FILE && item?.file_item && typeof item.file_item === "object") {
+    return { kind: "file", body: item.file_item, media: item.file_item.media };
+  }
+  if (itemType === MESSAGE_ITEM_VIDEO && item?.video_item && typeof item.video_item === "object") {
+    return { kind: "video", body: item.video_item, media: item.video_item.media };
+  }
+  return null;
+}
+
+function collectStringValues(values) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const normalized = normalizeText(value);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+function parseOptionalInt(value) {
+  if (value == null || value === "") {
+    return 0;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function normalizeMessageId(message) {
+  const raw = message?.message_id;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return String(raw);
+  }
+  if (typeof raw === "string") {
+    return raw.trim();
+  }
+  return "";
+}
+
+function normalizeMessageTimestampMs(message) {
+  const rawMs = Number(message?.create_time_ms);
+  if (Number.isFinite(rawMs) && rawMs > 0) {
+    return rawMs;
+  }
+  const rawSeconds = Number(message?.create_time);
+  if (Number.isFinite(rawSeconds) && rawSeconds > 0) {
+    return rawSeconds * 1000;
+  }
+  return 0;
+}
+
+function buildDedupKey(message, senderId, createdAtMs) {
+  const seq = normalizeNumeric(message?.seq);
+  const messageId = normalizeNumeric(message?.message_id);
+  const clientId = normalizeText(message?.client_id);
+  const parts = [senderId, messageId, seq, createdAtMs || 0, clientId];
+  return parts.join("|");
+}
+
+function normalizeNumeric(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? String(num) : "0";
+}
+
+function pruneSeen(seen) {
+  const now = Date.now();
+  for (const [key, timestamp] of seen.entries()) {
+    if (now - timestamp > DEDUP_TTL_MS) {
+      seen.delete(key);
+    }
+  }
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  createInboundFilter,
+  bodyFromItemList,
+};