@tencent-weixin/openclaw-weixin 1.0.0

package/src/media/mime.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+
+const EXTENSION_TO_MIME: Record<string, string> = {
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  ".mp3": "audio/mpeg",
+  ".ogg": "audio/ogg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mkv": "video/x-matroska",
+  ".avi": "video/x-msvideo",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+};
+
+const MIME_TO_EXTENSION: Record<string, string> = {
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/png": ".png",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/bmp": ".bmp",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "video/webm": ".webm",
+  "video/x-matroska": ".mkv",
+  "video/x-msvideo": ".avi",
+  "audio/mpeg": ".mp3",
+  "audio/ogg": ".ogg",
+  "audio/wav": ".wav",
+  "application/pdf": ".pdf",
+  "application/zip": ".zip",
+  "application/x-tar": ".tar",
+  "application/gzip": ".gz",
+  "text/plain": ".txt",
+  "text/csv": ".csv",
+};
+
+/** Get MIME type from filename extension. Returns "application/octet-stream" for unknown extensions. */
+export function getMimeFromFilename(filename: string): string {
+  const ext = path.extname(filename).toLowerCase();
+  return EXTENSION_TO_MIME[ext] ?? "application/octet-stream";
+}
+
+/** Get file extension from MIME type. Returns ".bin" for unknown types. */
+export function getExtensionFromMime(mimeType: string): string {
+  const ct = mimeType.split(";")[0].trim().toLowerCase();
+  return MIME_TO_EXTENSION[ct] ?? ".bin";
+}
+
+/** Get file extension from Content-Type header or URL path. Returns ".bin" for unknown. */
+export function getExtensionFromContentTypeOrUrl(contentType: string | null, url: string): string {
+  if (contentType) {
+    const ext = getExtensionFromMime(contentType);
+    if (ext !== ".bin") return ext;
+  }
+  const ext = path.extname(new URL(url).pathname).toLowerCase();
+  const knownExts = new Set(Object.keys(EXTENSION_TO_MIME));
+  return knownExts.has(ext) ? ext : ".bin";
+}

package/src/media/silk-transcode.ts

@@ -0,0 +1,74 @@
+import { logger } from "../util/logger.js";
+
+/** Default sample rate for Weixin voice messages. */
+const SILK_SAMPLE_RATE = 24_000;
+
+/**
+ * Wrap raw pcm_s16le bytes in a WAV container.
+ * Mono channel, 16-bit signed little-endian.
+ */
+function pcmBytesToWav(pcm: Uint8Array, sampleRate: number): Buffer {
+  const pcmBytes = pcm.byteLength;
+  const totalSize = 44 + pcmBytes;
+  const buf = Buffer.allocUnsafe(totalSize);
+  let offset = 0;
+
+  buf.write("RIFF", offset);
+  offset += 4;
+  buf.writeUInt32LE(totalSize - 8, offset);
+  offset += 4;
+  buf.write("WAVE", offset);
+  offset += 4;
+
+  buf.write("fmt ", offset);
+  offset += 4;
+  buf.writeUInt32LE(16, offset);
+  offset += 4; // fmt chunk size
+  buf.writeUInt16LE(1, offset);
+  offset += 2; // PCM format
+  buf.writeUInt16LE(1, offset);
+  offset += 2; // mono
+  buf.writeUInt32LE(sampleRate, offset);
+  offset += 4;
+  buf.writeUInt32LE(sampleRate * 2, offset);
+  offset += 4; // byte rate (mono 16-bit)
+  buf.writeUInt16LE(2, offset);
+  offset += 2; // block align
+  buf.writeUInt16LE(16, offset);
+  offset += 2; // bits per sample
+
+  buf.write("data", offset);
+  offset += 4;
+  buf.writeUInt32LE(pcmBytes, offset);
+  offset += 4;
+
+  Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength).copy(buf, offset);
+
+  return buf;
+}
+
+/**
+ * Try to transcode a SILK audio buffer to WAV using silk-wasm.
+ * silk-wasm's decode() returns { data: Uint8Array (pcm_s16le), duration: number }.
+ *
+ * Returns a WAV Buffer on success, or null if silk-wasm is unavailable or decoding fails.
+ * Callers should fall back to passing the raw SILK file when null is returned.
+ */
+export async function silkToWav(silkBuf: Buffer): Promise<Buffer | null> {
+  try {
+    const { decode } = await import("silk-wasm");
+
+    logger.debug(`silkToWav: decoding ${silkBuf.length} bytes of SILK`);
+    const result = await decode(silkBuf, SILK_SAMPLE_RATE);
+    logger.debug(
+      `silkToWav: decoded duration=${result.duration}ms pcmBytes=${result.data.byteLength}`,
+    );
+
+    const wav = pcmBytesToWav(result.data, SILK_SAMPLE_RATE);
+    logger.debug(`silkToWav: WAV size=${wav.length}`);
+    return wav;
+  } catch (err) {
+    logger.warn(`silkToWav: transcode failed, will use raw silk err=${String(err)}`);
+    return null;
+  }
+}

package/src/messaging/debug-mode.ts

@@ -0,0 +1,69 @@
+/**
+ * Per-bot debug mode toggle, persisted to disk so it survives gateway restarts.
+ *
+ * State file: `<stateDir>/openclaw-weixin/debug-mode.json`
+ * Format:     `{ "accounts": { "<accountId>": true, ... } }`
+ *
+ * When enabled, processOneMessage appends a timing summary after each
+ * AI reply is delivered to the user.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+import { resolveStateDir } from "../storage/state-dir.js";
+import { logger } from "../util/logger.js";
+
+interface DebugModeState {
+  accounts: Record<string, boolean>;
+}
+
+function resolveDebugModePath(): string {
+  return path.join(resolveStateDir(), "openclaw-weixin", "debug-mode.json");
+}
+
+function loadState(): DebugModeState {
+  try {
+    const raw = fs.readFileSync(resolveDebugModePath(), "utf-8");
+    const parsed = JSON.parse(raw) as DebugModeState;
+    if (parsed && typeof parsed.accounts === "object") return parsed;
+  } catch {
+    // missing or corrupt — start fresh
+  }
+  return { accounts: {} };
+}
+
+function saveState(state: DebugModeState): void {
+  const filePath = resolveDebugModePath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+}
+
+/** Toggle debug mode for a bot account. Returns the new state. */
+export function toggleDebugMode(accountId: string): boolean {
+  const state = loadState();
+  const next = !state.accounts[accountId];
+  state.accounts[accountId] = next;
+  try {
+    saveState(state);
+  } catch (err) {
+    logger.error(`debug-mode: failed to persist state: ${String(err)}`);
+  }
+  return next;
+}
+
+/** Check whether debug mode is active for a bot account. */
+export function isDebugMode(accountId: string): boolean {
+  return loadState().accounts[accountId] === true;
+}
+
+/**
+ * Reset internal state — only for tests.
+ * @internal
+ */
+export function _resetForTest(): void {
+  try {
+    fs.unlinkSync(resolveDebugModePath());
+  } catch {
+    // ignore if not present
+  }
+}

package/src/messaging/error-notice.ts

@@ -0,0 +1,31 @@
+import { logger } from "../util/logger.js";
+import { sendMessageWeixin } from "./send.js";
+
+/**
+ * Send a plain-text error notice back to the user.
+ * Fire-and-forget: errors are logged but never thrown, so callers stay unaffected.
+ * No-op when contextToken is absent (we have no conversation reference to reply into).
+ */
+export async function sendWeixinErrorNotice(params: {
+  to: string;
+  contextToken: string | undefined;
+  message: string;
+  baseUrl: string;
+  token?: string;
+  errLog: (m: string) => void;
+}): Promise<void> {
+  if (!params.contextToken) {
+    logger.warn(`sendWeixinErrorNotice: no contextToken for to=${params.to}, cannot notify user`);
+    return;
+  }
+  try {
+    await sendMessageWeixin({ to: params.to, text: params.message, opts: {
+      baseUrl: params.baseUrl,
+      token: params.token,
+      contextToken: params.contextToken,
+    }});
+    logger.debug(`sendWeixinErrorNotice: sent to=${params.to}`);
+  } catch (err) {
+    params.errLog(`[weixin] sendWeixinErrorNotice failed to=${params.to}: ${String(err)}`);
+  }
+}

package/src/messaging/inbound.ts

@@ -0,0 +1,171 @@
+import { logger } from "../util/logger.js";
+import { generateId } from "../util/random.js";
+import type { WeixinMessage, MessageItem } from "../api/types.js";
+import { MessageItemType } from "../api/types.js";
+
+// ---------------------------------------------------------------------------
+// Context token store (in-process cache: accountId+userId → contextToken)
+// ---------------------------------------------------------------------------
+
+/**
+ * contextToken is issued per-message by the Weixin getupdates API and must
+ * be echoed verbatim in every outbound send. It is not persisted: the monitor
+ * loop populates this map on each inbound message, and the outbound adapter
+ * reads it back when the agent sends a reply.
+ */
+const contextTokenStore = new Map<string, string>();
+
+function contextTokenKey(accountId: string, userId: string): string {
+  return `${accountId}:${userId}`;
+}
+
+/** Store a context token for a given account+user pair. */
+export function setContextToken(accountId: string, userId: string, token: string): void {
+  const k = contextTokenKey(accountId, userId);
+  logger.debug(`setContextToken: key=${k}`);
+  contextTokenStore.set(k, token);
+}
+
+/** 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;
+}
+
+// ---------------------------------------------------------------------------
+// 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
+  );
+}
+
+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;
+}