@zhin.js/adapter-weixin-ilink 0.1.0

package/src/weixin-inbound.ts

@@ -0,0 +1,257 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { logger } from "./ilink-logger.js";
+import { generateId } from "./ilink-random.js";
+import type { WeixinMessage, MessageItem } from "./ilink-types.js";
+import { MessageItemType } from "./ilink-types.js";
+import { resolveStateDir } from "./credentials.js";
+
+// ---------------------------------------------------------------------------
+// Context token store (in-process cache + disk persistence)
+// ---------------------------------------------------------------------------
+
+/**
+ * contextToken is issued per-message by the Weixin getupdates API and must
+ * be echoed verbatim in every outbound send. The in-memory map is the primary
+ * lookup; a disk-backed file per account ensures tokens survive gateway restarts.
+ */
+const contextTokenStore = new Map<string, string>();
+
+function contextTokenKey(accountId: string, userId: string): string {
+  return `${accountId}:${userId}`;
+}
+
+// ---------------------------------------------------------------------------
+// Disk persistence helpers
+// ---------------------------------------------------------------------------
+
+function resolveContextTokenFilePath(accountId: string): string {
+  return path.join(resolveStateDir(), "context-tokens", `${accountId}.context-tokens.json`);
+}
+
+/** Persist all context tokens for a given account to disk. */
+function persistContextTokens(accountId: string): void {
+  const prefix = `${accountId}:`;
+  const tokens: Record<string, string> = {};
+  for (const [k, v] of contextTokenStore) {
+    if (k.startsWith(prefix)) {
+      tokens[k.slice(prefix.length)] = v;
+    }
+  }
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(tokens, null, 0), "utf-8");
+  } catch (err) {
+    logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
+  }
+}
+
+/**
+ * Restore persisted context tokens for an account into the in-memory map.
+ * Called once during gateway startAccount to survive restarts.
+ */
+export function restoreContextTokens(accountId: string): void {
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    if (!fs.existsSync(filePath)) return;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const tokens = JSON.parse(raw) as Record<string, string>;
+    let count = 0;
+    for (const [userId, token] of Object.entries(tokens)) {
+      if (typeof token === "string" && token) {
+        contextTokenStore.set(contextTokenKey(accountId, userId), token);
+        count++;
+      }
+    }
+    logger.info(`restoreContextTokens: restored ${count} tokens for account=${accountId}`);
+  } catch (err) {
+    logger.warn(`restoreContextTokens: failed to read ${filePath}: ${String(err)}`);
+  }
+}
+
+/** Remove all context tokens for a given account (memory + disk). */
+export function clearContextTokensForAccount(accountId: string): void {
+  const prefix = `${accountId}:`;
+  for (const k of [...contextTokenStore.keys()]) {
+    if (k.startsWith(prefix)) {
+      contextTokenStore.delete(k);
+    }
+  }
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  } catch (err) {
+    logger.warn(`clearContextTokensForAccount: failed to remove ${filePath}: ${String(err)}`);
+  }
+  logger.info(`clearContextTokensForAccount: cleared tokens for account=${accountId}`);
+}
+
+/** Store a context token for a given account+user pair (memory + disk). */
+export function setContextToken(accountId: string, userId: string, token: string): void {
+  const k = contextTokenKey(accountId, userId);
+  logger.debug(`setContextToken: key=${k}`);
+  contextTokenStore.set(k, token);
+  persistContextTokens(accountId);
+}
+
+/** Retrieve the cached context token for a given account+user pair. */
+export function getContextToken(accountId: string, userId: string): string | undefined {
+  const k = contextTokenKey(accountId, userId);
+  const val = contextTokenStore.get(k);
+  logger.debug(
+    `getContextToken: key=${k} found=${val !== undefined} storeSize=${contextTokenStore.size}`,
+  );
+  return val;
+}
+
+/**
+ * Find all accountIds that have an active contextToken for the given userId.
+ * Used to infer the sending bot account from the recipient address when
+ * accountId is not explicitly provided (e.g. cron delivery).
+ *
+ * Returns all matching accountIds (not just the first) so the caller can
+ * detect ambiguity when multiple accounts have sessions with the same user.
+ */
+export function findAccountIdsByContextToken(
+  accountIds: string[],
+  userId: string,
+): string[] {
+  return accountIds.filter((id) => contextTokenStore.has(contextTokenKey(id, userId)));
+}
+
+// ---------------------------------------------------------------------------
+// Message ID generation
+// ---------------------------------------------------------------------------
+
+function generateMessageSid(): string {
+  return generateId("openclaw-weixin");
+}
+
+/** Inbound context passed to the OpenClaw core pipeline (matches MsgContext shape). */
+export type WeixinMsgContext = {
+  Body: string;
+  From: string;
+  To: string;
+  AccountId: string;
+  OriginatingChannel: "openclaw-weixin";
+  OriginatingTo: string;
+  MessageSid: string;
+  Timestamp?: number;
+  Provider: "openclaw-weixin";
+  ChatType: "direct";
+  /** Set by monitor after resolveAgentRoute so dispatchReplyFromConfig uses the correct session. */
+  SessionKey?: string;
+  context_token?: string;
+  MediaUrl?: string;
+  MediaPath?: string;
+  MediaType?: string;
+  /** Raw message body for framework command authorization. */
+  CommandBody?: string;
+  /** Whether the sender is authorized to execute slash commands. */
+  CommandAuthorized?: boolean;
+};
+
+/** Returns true if the message item is a media type (image, video, file, or voice). */
+export function isMediaItem(item: MessageItem): boolean {
+  return (
+    item.type === MessageItemType.IMAGE ||
+    item.type === MessageItemType.VIDEO ||
+    item.type === MessageItemType.FILE ||
+    item.type === MessageItemType.VOICE
+  );
+}
+
+export function bodyFromItemList(itemList?: MessageItem[]): string {
+  if (!itemList?.length) return "";
+  for (const item of itemList) {
+    if (item.type === MessageItemType.TEXT && item.text_item?.text != null) {
+      const text = String(item.text_item.text);
+      const ref = item.ref_msg;
+      if (!ref) return text;
+      // Quoted media is passed as MediaPath; only include the current text as body.
+      if (ref.message_item && isMediaItem(ref.message_item)) return text;
+      // Build quoted context from both title and message_item content.
+      const parts: string[] = [];
+      if (ref.title) parts.push(ref.title);
+      if (ref.message_item) {
+        const refBody = bodyFromItemList([ref.message_item]);
+        if (refBody) parts.push(refBody);
+      }
+      if (!parts.length) return text;
+      return `[引用: ${parts.join(" | ")}]\n${text}`;
+    }
+    // 语音转文字：如果语音消息有 text 字段，直接使用文字内容
+    if (item.type === MessageItemType.VOICE && item.voice_item?.text) {
+      return item.voice_item.text;
+    }
+  }
+  return "";
+}
+
+export type WeixinInboundMediaOpts = {
+  /** Local path to decrypted image file. */
+  decryptedPicPath?: string;
+  /** Local path to transcoded/raw voice file (.wav or .silk). */
+  decryptedVoicePath?: string;
+  /** MIME type for the voice file (e.g. "audio/wav" or "audio/silk"). */
+  voiceMediaType?: string;
+  /** Local path to decrypted file attachment. */
+  decryptedFilePath?: string;
+  /** MIME type for the file attachment (guessed from file_name). */
+  fileMediaType?: string;
+  /** Local path to decrypted video file. */
+  decryptedVideoPath?: string;
+};
+
+/**
+ * Convert a WeixinMessage from getUpdates to the inbound MsgContext for the core pipeline.
+ * Media: only pass MediaPath (local file, after CDN download + decrypt).
+ * We never pass MediaUrl — the upstream CDN URL is encrypted/auth-only.
+ * Priority when multiple media types present: image > video > file > voice.
+ */
+export function weixinMessageToMsgContext(
+  msg: WeixinMessage,
+  accountId: string,
+  opts?: WeixinInboundMediaOpts,
+): WeixinMsgContext {
+  const from_user_id = msg.from_user_id ?? "";
+  const ctx: WeixinMsgContext = {
+    Body: bodyFromItemList(msg.item_list),
+    From: from_user_id,
+    To: from_user_id,
+    AccountId: accountId,
+    OriginatingChannel: "openclaw-weixin",
+    OriginatingTo: from_user_id,
+    MessageSid: generateMessageSid(),
+    Timestamp: msg.create_time_ms,
+    Provider: "openclaw-weixin",
+    ChatType: "direct",
+  };
+  if (msg.context_token) {
+    ctx.context_token = msg.context_token;
+  }
+
+  if (opts?.decryptedPicPath) {
+    ctx.MediaPath = opts.decryptedPicPath;
+    ctx.MediaType = "image/*";
+  } else if (opts?.decryptedVideoPath) {
+    ctx.MediaPath = opts.decryptedVideoPath;
+    ctx.MediaType = "video/mp4";
+  } else if (opts?.decryptedFilePath) {
+    ctx.MediaPath = opts.decryptedFilePath;
+    ctx.MediaType = opts.fileMediaType ?? "application/octet-stream";
+  } else if (opts?.decryptedVoicePath) {
+    ctx.MediaPath = opts.decryptedVoicePath;
+    ctx.MediaType = opts.voiceMediaType ?? "audio/wav";
+  }
+
+  return ctx;
+}
+
+/** Extract the context_token from an inbound WeixinMsgContext. */
+export function getContextTokenFromMsgContext(ctx: WeixinMsgContext): string | undefined {
+  return ctx.context_token;
+}

package/src/weixin-send-media.ts

@@ -0,0 +1,72 @@
+import path from "node:path";
+import type { WeixinApiOptions } from "./ilink-api.js";
+import { logger } from "./ilink-logger.js";
+import { getMimeFromFilename } from "./mime.js";
+import { sendFileMessageWeixin, sendImageMessageWeixin, sendVideoMessageWeixin } from "./weixin-send.js";
+import { uploadFileAttachmentToWeixin, uploadFileToWeixin, uploadVideoToWeixin } from "./upload.js";
+
+/**
+ * Upload a local file and send it as a weixin message, routing by MIME type:
+ *   video/*  → uploadVideoToWeixin        + sendVideoMessageWeixin
+ *   image/*  → uploadFileToWeixin         + sendImageMessageWeixin
+ *   else     → uploadFileAttachmentToWeixin + sendFileMessageWeixin
+ *
+ * Used by both the auto-reply deliver path (monitor.ts) and the outbound
+ * sendMedia path (channel.ts) so they stay in sync.
+ */
+export async function sendWeixinMediaFile(params: {
+  filePath: string;
+  to: string;
+  text: string;
+  opts: WeixinApiOptions & { contextToken?: string };
+  cdnBaseUrl: string;
+}): Promise<{ messageId: string }> {
+  const { filePath, to, text, opts, cdnBaseUrl } = params;
+  const mime = getMimeFromFilename(filePath);
+  const uploadOpts: WeixinApiOptions = { baseUrl: opts.baseUrl, token: opts.token };
+
+  if (mime.startsWith("video/")) {
+    logger.info(`[weixin] sendWeixinMediaFile: uploading video filePath=${filePath} to=${to}`);
+    const uploaded = await uploadVideoToWeixin({
+      filePath,
+      toUserId: to,
+      opts: uploadOpts,
+      cdnBaseUrl,
+    });
+    logger.info(
+      `[weixin] sendWeixinMediaFile: video upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+    );
+    return sendVideoMessageWeixin({ to, text, uploaded, opts });
+  }
+
+  if (mime.startsWith("image/")) {
+    logger.info(`[weixin] sendWeixinMediaFile: uploading image filePath=${filePath} to=${to}`);
+    const uploaded = await uploadFileToWeixin({
+      filePath,
+      toUserId: to,
+      opts: uploadOpts,
+      cdnBaseUrl,
+    });
+    logger.info(
+      `[weixin] sendWeixinMediaFile: image upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+    );
+    return sendImageMessageWeixin({ to, text, uploaded, opts });
+  }
+
+  // File attachment: pdf, doc, zip, etc.
+  const fileName = path.basename(filePath);
+  logger.info(
+    `[weixin] sendWeixinMediaFile: uploading file attachment filePath=${filePath} name=${fileName} to=${to}`,
+  );
+  const uploaded = await uploadFileAttachmentToWeixin({
+    filePath,
+    fileName,
+    toUserId: to,
+    opts: uploadOpts,
+    cdnBaseUrl,
+  });
+  logger.info(
+    `[weixin] sendWeixinMediaFile: file upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`,
+  );
+  return sendFileMessageWeixin({ to, text, fileName, uploaded, opts });
+}

package/src/weixin-send.ts

@@ -0,0 +1,237 @@
+import { sendMessage as sendMessageApi } from "./ilink-api.js";
+import type { WeixinApiOptions } from "./ilink-api.js";
+import { logger } from "./ilink-logger.js";
+import { generateId } from "./ilink-random.js";
+import type { MessageItem, SendMessageReq } from "./ilink-types.js";
+import { MessageItemType, MessageState, MessageType } from "./ilink-types.js";
+import type { UploadedFileInfo } from "./upload.js";
+
+function generateClientId(): string {
+  return generateId("weixin-ilink");
+}
+
+/** Build a SendMessageReq containing a single text message. */
+function buildTextMessageReq(params: {
+  to: string;
+  text: string;
+  contextToken?: string;
+  clientId: string;
+}): SendMessageReq {
+  const { to, text, contextToken, clientId } = params;
+  const item_list: MessageItem[] = text
+    ? [{ type: MessageItemType.TEXT, text_item: { text } }]
+    : [];
+  return {
+    msg: {
+      from_user_id: "",
+      to_user_id: to,
+      client_id: clientId,
+      message_type: MessageType.BOT,
+      message_state: MessageState.FINISH,
+      item_list: item_list.length ? item_list : undefined,
+      context_token: contextToken ?? undefined,
+    },
+  };
+}
+
+/** Build a SendMessageReq from a reply payload (text only; image send uses sendImageMessageWeixin). */
+function buildSendMessageReq(params: {
+  to: string;
+  contextToken?: string;
+  payload: { text?: string };
+  clientId: string;
+}): SendMessageReq {
+  const { to, contextToken, payload, clientId } = params;
+  return buildTextMessageReq({
+    to,
+    text: payload.text ?? "",
+    contextToken,
+    clientId,
+  });
+}
+
+/**
+ * Send a plain text message downstream.
+ */
+export async function sendMessageWeixin(params: {
+  to: string;
+  text: string;
+  opts: WeixinApiOptions & { contextToken?: string };
+}): Promise<{ messageId: string }> {
+  const { to, text, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const clientId = generateClientId();
+  const req = buildSendMessageReq({
+    to,
+    contextToken: opts.contextToken,
+    payload: { text },
+    clientId,
+  });
+  try {
+    await sendMessageApi({
+      baseUrl: opts.baseUrl,
+      token: opts.token,
+      timeoutMs: opts.timeoutMs,
+      body: req,
+    });
+  } catch (err) {
+    logger.error(`sendMessageWeixin: failed to=${to} clientId=${clientId} err=${String(err)}`);
+    throw err;
+  }
+  return { messageId: clientId };
+}
+
+/**
+ * Send one or more MessageItems (optionally preceded by a text caption) downstream.
+ * Each item is sent as its own request so that item_list always has exactly one entry.
+ */
+async function sendMediaItems(params: {
+  to: string;
+  text: string;
+  mediaItem: MessageItem;
+  opts: WeixinApiOptions & { contextToken?: string };
+  label: string;
+}): Promise<{ messageId: string }> {
+  const { to, text, mediaItem, opts, label } = params;
+
+  const items: MessageItem[] = [];
+  if (text) {
+    items.push({ type: MessageItemType.TEXT, text_item: { text } });
+  }
+  items.push(mediaItem);
+
+  let lastClientId = "";
+  for (const item of items) {
+    lastClientId = generateClientId();
+    const req: SendMessageReq = {
+      msg: {
+        from_user_id: "",
+        to_user_id: to,
+        client_id: lastClientId,
+        message_type: MessageType.BOT,
+        message_state: MessageState.FINISH,
+        item_list: [item],
+        context_token: opts.contextToken ?? undefined,
+      },
+    };
+    try {
+      await sendMessageApi({
+        baseUrl: opts.baseUrl,
+        token: opts.token,
+        timeoutMs: opts.timeoutMs,
+        body: req,
+      });
+    } catch (err) {
+      logger.error(
+        `${label}: failed to=${to} clientId=${lastClientId} err=${String(err)}`,
+      );
+      throw err;
+    }
+  }
+
+  logger.info(`${label}: success to=${to} clientId=${lastClientId}`);
+  return { messageId: lastClientId };
+}
+
+/**
+ * Send an image message downstream using a previously uploaded file.
+ * Optionally include a text caption as a separate TEXT item before the image.
+ *
+ * ImageItem fields:
+ *   - media.encrypt_query_param: CDN download param
+ *   - media.aes_key: AES key, base64-encoded
+ *   - mid_size: original ciphertext file size
+ */
+export async function sendImageMessageWeixin(params: {
+  to: string;
+  text: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinApiOptions & { contextToken?: string };
+}): Promise<{ messageId: string }> {
+  const { to, text, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendImageMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  logger.info(
+    `sendImageMessageWeixin: to=${to} filekey=${uploaded.filekey} fileSize=${uploaded.fileSize} aeskey=present`,
+  );
+
+  const imageItem: MessageItem = {
+    type: MessageItemType.IMAGE,
+    image_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      mid_size: uploaded.fileSizeCiphertext,
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: imageItem, opts, label: "sendImageMessageWeixin" });
+}
+
+/**
+ * Send a video message downstream using a previously uploaded file.
+ * VideoItem: media (CDN ref), video_size (ciphertext bytes).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export async function sendVideoMessageWeixin(params: {
+  to: string;
+  text: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinApiOptions & { contextToken?: string };
+}): Promise<{ messageId: string }> {
+  const { to, text, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendVideoMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+
+  const videoItem: MessageItem = {
+    type: MessageItemType.VIDEO,
+    video_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      video_size: uploaded.fileSizeCiphertext,
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: videoItem, opts, label: "sendVideoMessageWeixin" });
+}
+
+/**
+ * Send a file attachment downstream using a previously uploaded file.
+ * FileItem: media (CDN ref), file_name, len (plaintext bytes as string).
+ * Includes an optional text caption sent as a separate TEXT item first.
+ */
+export async function sendFileMessageWeixin(params: {
+  to: string;
+  text: string;
+  fileName: string;
+  uploaded: UploadedFileInfo;
+  opts: WeixinApiOptions & { contextToken?: string };
+}): Promise<{ messageId: string }> {
+  const { to, text, fileName, uploaded, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendFileMessageWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const fileItem: MessageItem = {
+    type: MessageItemType.FILE,
+    file_item: {
+      media: {
+        encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+        aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+        encrypt_type: 1,
+      },
+      file_name: fileName,
+      len: String(uploaded.fileSize),
+    },
+  };
+
+  return sendMediaItems({ to, text, mediaItem: fileItem, opts, label: "sendFileMessageWeixin" });
+}