codeksei 0.1.0

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

@@ -0,0 +1,124 @@
+const { redactSensitiveText } = require("./redact");
+const {
+  ACTIVE_LOGIN_TTL_MS,
+  MAX_QR_REFRESH_COUNT,
+  ensureTrailingSlash,
+  finishWeixinLogin,
+  printQrCode,
+} = require("./login-common");
+
+const QR_LONG_POLL_TIMEOUT_MS = 35_000;
+
+async function fetchQrCode(apiBaseUrl, botType) {
+  const base = ensureTrailingSlash(apiBaseUrl);
+  const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, base);
+  const response = await fetch(url.toString());
+  if (!response.ok) {
+    const body = await response.text().catch(() => "(unreadable)");
+    throw new Error(`二维码获取失败: ${response.status} ${response.statusText} ${redactSensitiveText(body)}`);
+  }
+  return response.json();
+}
+
+async function pollQrStatus(apiBaseUrl, qrcode) {
+  const base = ensureTrailingSlash(apiBaseUrl);
+  const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QR_LONG_POLL_TIMEOUT_MS);
+  try {
+    const response = await fetch(url.toString(), {
+      headers: {
+        "iLink-App-ClientVersion": "1",
+      },
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    const rawText = await response.text();
+    if (!response.ok) {
+      throw new Error(`二维码状态轮询失败: ${response.status} ${response.statusText} ${redactSensitiveText(rawText)}`);
+    }
+    return JSON.parse(rawText);
+  } catch (error) {
+    clearTimeout(timer);
+    if (error instanceof Error && error.name === "AbortError") {
+      return { status: "wait" };
+    }
+    throw error;
+  }
+}
+
+async function waitForLegacyWeixinLogin({ apiBaseUrl, botType, timeoutMs }) {
+  let qrResponse = await fetchQrCode(apiBaseUrl, botType);
+  let startedAt = Date.now();
+  let scannedPrinted = false;
+  let refreshCount = 1;
+
+  console.log("使用微信扫描以下二维码，以完成连接：\n");
+  printQrCode(qrResponse.qrcode_img_content);
+  console.log("\n等待连接结果...\n");
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (Date.now() - startedAt > ACTIVE_LOGIN_TTL_MS) {
+      qrResponse = await fetchQrCode(apiBaseUrl, botType);
+      startedAt = Date.now();
+      scannedPrinted = false;
+      refreshCount += 1;
+      if (refreshCount > MAX_QR_REFRESH_COUNT) {
+        throw new Error("二维码多次过期，请重新执行 login");
+      }
+      console.log(`二维码已过期，正在刷新...(${refreshCount}/${MAX_QR_REFRESH_COUNT})\n`);
+      printQrCode(qrResponse.qrcode_img_content);
+    }
+
+    const statusResponse = await pollQrStatus(apiBaseUrl, qrResponse.qrcode);
+    switch (statusResponse.status) {
+      case "wait":
+        process.stdout.write(".");
+        break;
+      case "scaned":
+        if (!scannedPrinted) {
+          process.stdout.write("\n已扫码，请在微信中确认授权...\n");
+          scannedPrinted = true;
+        }
+        break;
+      case "expired":
+        qrResponse = await fetchQrCode(apiBaseUrl, botType);
+        startedAt = Date.now();
+        scannedPrinted = false;
+        refreshCount += 1;
+        if (refreshCount > MAX_QR_REFRESH_COUNT) {
+          throw new Error("二维码多次过期，请重新执行 login");
+        }
+        console.log(`二维码已过期，正在刷新...(${refreshCount}/${MAX_QR_REFRESH_COUNT})\n`);
+        printQrCode(qrResponse.qrcode_img_content);
+        break;
+      case "confirmed":
+        if (!statusResponse.bot_token || !statusResponse.ilink_bot_id) {
+          throw new Error("登录成功但缺少 bot token 或账号 ID");
+        }
+        return {
+          accountId: statusResponse.ilink_bot_id,
+          token: statusResponse.bot_token,
+          baseUrl: statusResponse.baseurl || apiBaseUrl,
+          userId: statusResponse.ilink_user_id || "",
+          routeTag: "",
+        };
+      default:
+        break;
+    }
+  }
+  throw new Error("登录超时，请重新执行 login");
+}
+
+async function runLegacyLoginFlow(config) {
+  console.log("[codeksei] 正在启动微信扫码登录（legacy）...");
+  const result = await waitForLegacyWeixinLogin({
+    apiBaseUrl: config.weixinBaseUrl,
+    botType: config.weixinQrBotType,
+    timeoutMs: 480_000,
+  });
+  finishWeixinLogin(config, result);
+}
+
+module.exports = { runLegacyLoginFlow };

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

@@ -0,0 +1,186 @@
+const {
+  buildCommonHeaders,
+  normalizeProtocolClientVersion,
+  normalizeRouteTag,
+} = require("./protocol");
+const { redactSensitiveText } = require("./redact");
+const {
+  ACTIVE_LOGIN_TTL_MS,
+  MAX_QR_REFRESH_COUNT,
+  ensureTrailingSlash,
+  finishWeixinLogin,
+  printQrCode,
+} = require("./login-common");
+
+const QR_LONG_POLL_TIMEOUT_MS = 35_000;
+
+async function fetchQrCode({ apiBaseUrl, botType, routeTag = "", clientVersion = "" }) {
+  const base = ensureTrailingSlash(apiBaseUrl);
+  const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, base);
+  const response = await fetch(url.toString(), {
+    headers: buildCommonHeaders({ routeTag, clientVersion }),
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "(unreadable)");
+    throw new Error(`二维码获取失败: ${response.status} ${response.statusText} ${redactSensitiveText(body)}`);
+  }
+  return response.json();
+}
+
+async function pollQrStatus({ apiBaseUrl, qrcode, routeTag = "", clientVersion = "" }) {
+  const base = ensureTrailingSlash(apiBaseUrl);
+  const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), QR_LONG_POLL_TIMEOUT_MS);
+  try {
+    const response = await fetch(url.toString(), {
+      headers: buildCommonHeaders({ routeTag, clientVersion }),
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    const rawText = await response.text();
+    if (!response.ok) {
+      throw new Error(`二维码状态轮询失败: ${response.status} ${response.statusText} ${redactSensitiveText(rawText)}`);
+    }
+    return JSON.parse(rawText);
+  } catch (error) {
+    clearTimeout(timer);
+    if (isTransientLongPollError(error)) {
+      return { status: "wait" };
+    }
+    throw error;
+  }
+}
+
+async function waitForV2WeixinLogin({ apiBaseUrl, botType, routeTag = "", clientVersion = "", timeoutMs }) {
+  let qrResponse = await fetchQrCode({ apiBaseUrl, botType, routeTag, clientVersion });
+  let startedAt = Date.now();
+  let refreshCount = 0;
+  let scannedPrinted = false;
+  let pollBaseUrl = apiBaseUrl;
+
+  console.log("使用微信扫描以下二维码，以完成连接：\n");
+  printQrCode(qrResponse.qrcode_img_content);
+  console.log("\n等待连接结果...\n");
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (Date.now() - startedAt > ACTIVE_LOGIN_TTL_MS) {
+      ({ qrResponse, startedAt, refreshCount, scannedPrinted, pollBaseUrl } = await refreshQrCode({
+        reason: "二维码已过期，正在刷新...",
+        apiBaseUrl,
+        botType,
+        routeTag,
+        clientVersion,
+        refreshCount,
+      }));
+    }
+
+    const statusResponse = await pollQrStatus({
+      apiBaseUrl: pollBaseUrl,
+      qrcode: qrResponse.qrcode,
+      routeTag,
+      clientVersion,
+    });
+
+    switch (statusResponse.status) {
+      case "wait":
+        process.stdout.write(".");
+        await sleep(1_000);
+        break;
+      case "scaned":
+        if (!scannedPrinted) {
+          process.stdout.write("\n已扫码，请在微信中确认授权...\n");
+          scannedPrinted = true;
+        }
+        await sleep(1_000);
+        break;
+      case "scaned_but_redirect":
+        // V2 login can hand the QR polling phase off to a redirected host.
+        // If we keep polling the gateway after this point, login looks "stuck"
+        // even though the user already confirmed in WeChat.
+        if (typeof statusResponse.redirect_host === "string" && statusResponse.redirect_host.trim()) {
+          pollBaseUrl = `https://${statusResponse.redirect_host.trim()}`;
+        }
+        await sleep(1_000);
+        break;
+      case "expired":
+        ({ qrResponse, startedAt, refreshCount, scannedPrinted, pollBaseUrl } = await refreshQrCode({
+          reason: "二维码已过期，正在刷新...",
+          apiBaseUrl,
+          botType,
+          routeTag,
+          clientVersion,
+          refreshCount,
+        }));
+        break;
+      case "confirmed":
+        if (!statusResponse.bot_token || !statusResponse.ilink_bot_id) {
+          throw new Error("登录成功但缺少 bot token 或账号 ID");
+        }
+        return {
+          accountId: statusResponse.ilink_bot_id,
+          token: statusResponse.bot_token,
+          baseUrl: statusResponse.baseurl || pollBaseUrl || apiBaseUrl,
+          userId: statusResponse.ilink_user_id || "",
+          routeTag,
+        };
+      default:
+        throw new Error(`二维码状态异常: ${redactSensitiveText(JSON.stringify(statusResponse))}`);
+    }
+  }
+
+  throw new Error("登录超时，请重新执行 login");
+}
+
+async function refreshQrCode({ reason, apiBaseUrl, botType, routeTag, clientVersion, refreshCount }) {
+  const nextRefreshCount = refreshCount + 1;
+  if (nextRefreshCount > MAX_QR_REFRESH_COUNT) {
+    throw new Error("二维码多次过期，请重新执行 login");
+  }
+  const qrResponse = await fetchQrCode({ apiBaseUrl, botType, routeTag, clientVersion });
+  console.log(`${reason}(${nextRefreshCount}/${MAX_QR_REFRESH_COUNT})\n`);
+  printQrCode(qrResponse.qrcode_img_content);
+  return {
+    qrResponse,
+    startedAt: Date.now(),
+    refreshCount: nextRefreshCount,
+    scannedPrinted: false,
+    pollBaseUrl: apiBaseUrl,
+  };
+}
+
+function isTransientLongPollError(error) {
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  const message = String(error?.message || "").toLowerCase();
+  return message.includes("aborted")
+    || message.includes("fetch failed")
+    || message.includes("networkerror")
+    || message.includes("timed out")
+    || error instanceof TypeError;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function runV2LoginFlow(config) {
+  const routeTag = normalizeRouteTag(config.weixinRouteTag);
+  const clientVersion = normalizeProtocolClientVersion(config.weixinProtocolClientVersion);
+  const routeTagLabel = routeTag ? ` routeTag=${routeTag}` : "";
+  console.log(`[codeksei] 正在启动微信扫码登录（v2）...${routeTagLabel}`);
+  const result = await waitForV2WeixinLogin({
+    apiBaseUrl: config.weixinBaseUrl,
+    botType: config.weixinQrBotType,
+    routeTag,
+    clientVersion,
+    timeoutMs: 480_000,
+  });
+  finishWeixinLogin(config, result);
+}
+
+module.exports = {
+  runV2LoginFlow,
+};

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

@@ -0,0 +1,22 @@
+const path = require("path");
+
+const MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+};
+
+function getMimeFromFilename(filePath) {
+  const ext = path.extname(String(filePath || "")).toLowerCase();
+  return MIME_BY_EXT[ext] || "application/octet-stream";
+}
+
+module.exports = { getMimeFromFilename };

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

@@ -0,0 +1,370 @@
+const crypto = require("crypto");
+const fs = require("fs/promises");
+const path = require("path");
+
+const DEFAULT_INBOX_DIR = "inbox";
+const MAX_FILE_NAME_LENGTH = 120;
+
+async function persistIncomingWeixinAttachments({
+  attachments,
+  stateDir,
+  cdnBaseUrl,
+  messageId = "",
+  receivedAt = "",
+}) {
+  const saved = [];
+  const failed = [];
+
+  for (const attachment of Array.isArray(attachments) ? attachments : []) {
+    try {
+      const persisted = await persistSingleAttachment({
+        attachment,
+        stateDir,
+        cdnBaseUrl,
+        messageId,
+        receivedAt,
+      });
+      saved.push(persisted);
+    } catch (error) {
+      failed.push({
+        kind: attachment?.kind || "file",
+        sourceFileName: attachment?.fileName || "",
+        reason: error instanceof Error ? error.message : String(error || "unknown attachment error"),
+      });
+    }
+  }
+
+  return { saved, failed };
+}
+
+async function persistSingleAttachment({ attachment, stateDir, cdnBaseUrl, messageId, receivedAt }) {
+  const download = await downloadAttachmentPayload(attachment, cdnBaseUrl);
+  const plaintext = decodeAttachmentPayload(download.bytes, attachment, download.contentType);
+  const fileName = buildTargetFileName({
+    attachment,
+    plaintext,
+    contentType: download.contentType,
+    messageId,
+  });
+  const targetDir = buildInboxDirectory(stateDir, receivedAt);
+  const absolutePath = await writeUniqueFile(targetDir, fileName, plaintext);
+  const relativePath = path.relative(stateDir, absolutePath).replace(/\\/g, "/");
+
+  return {
+    kind: attachment.kind || "file",
+    sourceFileName: attachment.fileName || "",
+    fileName: path.basename(absolutePath),
+    absolutePath,
+    relativePath,
+    sizeBytes: plaintext.length,
+  };
+}
+
+function buildInboxDirectory(stateDir, receivedAt) {
+  const day = normalizeDateFolder(receivedAt);
+  return path.join(stateDir, DEFAULT_INBOX_DIR, day);
+}
+
+function normalizeDateFolder(receivedAt) {
+  const date = receivedAt ? new Date(receivedAt) : new Date();
+  if (Number.isNaN(date.getTime())) {
+    return new Date().toISOString().slice(0, 10);
+  }
+  return date.toISOString().slice(0, 10);
+}
+
+async function downloadAttachmentPayload(attachment, cdnBaseUrl) {
+  const candidates = buildDownloadCandidates(attachment, cdnBaseUrl);
+  if (!candidates.length) {
+    throw new Error("attachment did not include a supported download reference");
+  }
+
+  let lastError = null;
+  for (const candidate of candidates) {
+    try {
+      const response = await fetch(candidate, {
+        method: "GET",
+        headers: {
+          Accept: "*/*",
+        },
+      });
+      if (!response.ok) {
+        lastError = new Error(`download failed with HTTP ${response.status}`);
+        continue;
+      }
+
+      const arrayBuffer = await response.arrayBuffer();
+      return {
+        bytes: Buffer.from(arrayBuffer),
+        contentType: normalizeContentType(response.headers.get("content-type")),
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError || new Error("attachment download failed");
+}
+
+function buildDownloadCandidates(attachment, cdnBaseUrl) {
+  const candidates = [];
+  const seen = new Set();
+  const directUrls = Array.isArray(attachment?.directUrls) ? attachment.directUrls : [];
+  for (const directUrl of directUrls) {
+    addCandidate(candidates, seen, directUrl);
+  }
+
+  const encryptedQueryParam = normalizeText(attachment?.mediaRef?.encryptQueryParam);
+  if (encryptedQueryParam) {
+    const normalizedCdnBaseUrl = String(cdnBaseUrl || "").replace(/\/+$/g, "");
+    addCandidate(
+      candidates,
+      seen,
+      `${normalizedCdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`
+    );
+
+    const fileKey = normalizeText(attachment?.mediaRef?.fileKey);
+    if (fileKey) {
+      addCandidate(
+        candidates,
+        seen,
+        `${normalizedCdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}&filekey=${encodeURIComponent(fileKey)}`
+      );
+    }
+  }
+
+  return candidates;
+}
+
+function addCandidate(candidates, seen, rawUrl) {
+  const normalizedUrl = normalizeText(rawUrl);
+  if (!normalizedUrl || seen.has(normalizedUrl)) {
+    return;
+  }
+  seen.add(normalizedUrl);
+  candidates.push(normalizedUrl);
+}
+
+function decodeAttachmentPayload(bytes, attachment, contentType) {
+  const encryptType = Number(attachment?.mediaRef?.encryptType);
+  const keyCandidates = buildAesKeyCandidates(attachment);
+  if (encryptType !== 1 || keyCandidates.length === 0) {
+    return bytes;
+  }
+
+  for (const key of keyCandidates) {
+    try {
+      return decryptAesEcb(bytes, key);
+    } catch {
+      // Try the next key encoding variant.
+    }
+  }
+
+  if (looksLikePlainMedia(bytes, contentType)) {
+    return bytes;
+  }
+
+  throw new Error("failed to decrypt attachment payload");
+}
+
+function buildAesKeyCandidates(attachment) {
+  const candidates = [];
+  const seen = new Set();
+  const rawValues = [
+    attachment?.mediaRef?.aesKeyHex,
+    attachment?.mediaRef?.aesKey,
+  ];
+
+  for (const rawValue of rawValues) {
+    const variants = decodeAesKeyVariants(rawValue);
+    for (const variant of variants) {
+      const signature = variant.toString("hex");
+      if (seen.has(signature)) {
+        continue;
+      }
+      seen.add(signature);
+      candidates.push(variant);
+    }
+  }
+
+  return candidates;
+}
+
+function decodeAesKeyVariants(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return [];
+  }
+
+  const candidates = [];
+  if (/^[0-9a-f]{32}$/i.test(normalized)) {
+    candidates.push(Buffer.from(normalized, "hex"));
+  }
+  if (normalized.length === 16) {
+    candidates.push(Buffer.from(normalized, "utf8"));
+  }
+
+  try {
+    const decoded = Buffer.from(normalized, "base64");
+    if (decoded.length === 16) {
+      candidates.push(decoded);
+    } else {
+      const decodedText = decoded.toString("utf8").trim();
+      if (/^[0-9a-f]{32}$/i.test(decodedText)) {
+        candidates.push(Buffer.from(decodedText, "hex"));
+      }
+    }
+  } catch {
+    // Ignore invalid base64 variants.
+  }
+
+  return candidates.filter((candidate) => candidate.length === 16);
+}
+
+function decryptAesEcb(ciphertext, key) {
+  const decipher = crypto.createDecipheriv("aes-128-ecb", key, null);
+  decipher.setAutoPadding(true);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+
+function looksLikePlainMedia(bytes, contentType) {
+  if (!Buffer.isBuffer(bytes) || bytes.length === 0) {
+    return false;
+  }
+
+  if (contentType.startsWith("text/")) {
+    return true;
+  }
+
+  return detectExtensionFromBuffer(bytes) !== "";
+}
+
+function buildTargetFileName({ attachment, plaintext, contentType, messageId }) {
+  const sourceName = sanitizeFileName(attachment?.fileName || "");
+  if (sourceName) {
+    const existingExt = path.extname(sourceName);
+    if (existingExt) {
+      return sourceName;
+    }
+
+    const inferredExt = inferExtension({
+      contentType,
+      plaintext,
+      kind: attachment?.kind,
+    });
+    return `${sourceName}${inferredExt}`;
+  }
+
+  const baseName = sanitizeFileName([
+    attachment?.kind || "file",
+    messageId || Date.now(),
+    String((attachment?.index ?? 0) + 1),
+  ].join("-"));
+  const inferredExt = inferExtension({
+    contentType,
+    plaintext,
+    kind: attachment?.kind,
+  });
+  return `${baseName || "attachment"}${inferredExt}`;
+}
+
+function inferExtension({ contentType, plaintext, kind }) {
+  const contentTypeExt = extensionFromContentType(contentType);
+  if (contentTypeExt) {
+    return contentTypeExt;
+  }
+
+  const bufferExt = detectExtensionFromBuffer(plaintext);
+  if (bufferExt) {
+    return bufferExt;
+  }
+
+  if (kind === "image") {
+    return ".png";
+  }
+  if (kind === "video") {
+    return ".mp4";
+  }
+  return ".bin";
+}
+
+function extensionFromContentType(contentType) {
+  const normalized = normalizeContentType(contentType);
+  const map = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "video/mp4": ".mp4",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+  };
+  return map[normalized] || "";
+}
+
+function detectExtensionFromBuffer(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 4) {
+    return "";
+  }
+
+  if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]))) {
+    return ".png";
+  }
+  if (buffer.subarray(0, 3).equals(Buffer.from([0xFF, 0xD8, 0xFF]))) {
+    return ".jpg";
+  }
+  if (buffer.subarray(0, 4).toString("ascii") === "GIF8") {
+    return ".gif";
+  }
+  if (buffer.subarray(0, 4).toString("ascii") === "RIFF"
+    && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return ".webp";
+  }
+  if (buffer.subarray(4, 8).toString("ascii") === "ftyp") {
+    return ".mp4";
+  }
+  if (buffer.subarray(0, 5).toString("ascii") === "%PDF-") {
+    return ".pdf";
+  }
+  return "";
+}
+
+function sanitizeFileName(value) {
+  const parsed = path.parse(String(value || "").trim().replace(/[<>:"/\\|?*\u0000-\u001F]/g, "-"));
+  const safeBaseName = parsed.name || "attachment";
+  const safeExt = parsed.ext || "";
+  return `${safeBaseName.slice(0, MAX_FILE_NAME_LENGTH)}${safeExt.slice(0, 16)}`;
+}
+
+async function writeUniqueFile(targetDir, fileName, plaintext) {
+  await fs.mkdir(targetDir, { recursive: true });
+  const parsed = path.parse(fileName);
+  const baseName = parsed.name || "attachment";
+  const extension = parsed.ext || "";
+  for (let index = 0; index < 50; index += 1) {
+    const suffix = index === 0 ? "" : `-${index + 1}`;
+    const candidate = path.join(targetDir, `${baseName}${suffix}${extension}`);
+    try {
+      await fs.writeFile(candidate, plaintext, { flag: "wx" });
+      return candidate;
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+
+  throw new Error("unable to allocate a unique attachment file name");
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeContentType(value) {
+  return typeof value === "string" ? value.split(";")[0].trim().toLowerCase() : "";
+}
+
+module.exports = {
+  persistIncomingWeixinAttachments,
+};