@kyan-du/agent-wechat-openclaw 0.12.0 → 0.13.0

package/README.md

@@ -81,19 +81,19 @@ If running alongside OpenClaw on the same Docker network, set `serverUrl` to `ht
 # Pending P1-B (not available yet): openclaw plugins install @kyan-du/agent-wechat-openclaw
 pnpm --filter @kyan-du/agent-wechat-openclaw build
 node scripts/prepare-openclaw-plugin.mjs
-openclaw plugins install -l ./.artifacts/openclaw-extension
+openclaw plugins install ./.artifacts/agent-wechat-openclaw.tgz
 ```
 
 ### 3. Configure the channel
 
-OpenClaw's channel catalog may map `openclaw channels add --channel wechat` to its official Weixin plugin rather than this source plugin. Configure the staged plugin through its schema keys and verify the runtime load explicitly:
+This plugin registers as channel id `agent-wechat`. Do not use `wechat`, `weixin`, or `微信` — OpenClaw's official catalog maps those aliases to `@tencent-weixin/openclaw-weixin`, so outbound and cron delivery never reach this plugin.
 
 ```bash
-openclaw config set channels.wechat.enabled true
-openclaw config set channels.wechat.serverUrl http://localhost:6174
+openclaw config set channels.agent-wechat.enabled true
+openclaw config set channels.agent-wechat.serverUrl http://localhost:6174
 # Optional when the server requires an explicit token:
-openclaw config set channels.wechat.token <token>
-openclaw plugins inspect wechat --runtime
+openclaw config set channels.agent-wechat.token <token>
+openclaw plugins inspect agent-wechat --runtime
 ```
 
 Or edit `~/.openclaw/openclaw.json` directly:
@@ -101,7 +101,7 @@ Or edit `~/.openclaw/openclaw.json` directly:
 ```json
 {
   "channels": {
-    "wechat": {
+    "agent-wechat": {
       "enabled": true,
       "serverUrl": "http://localhost:6174",
       "dmPolicy": "open",
@@ -130,7 +130,7 @@ Ask your bot to log in to WeChat:
 Your bot should generate a QR code image. Alternatively, use the CLI:
 
 ```bash
-openclaw channels login --channel wechat
+openclaw channels login --channel agent-wechat
 ```
 
 ### 6. Scan the QR code
@@ -155,7 +155,7 @@ Once connected, configure how the bot handles direct messages and group chats. Y
 
 ## Configuration Reference
 
-All config lives under `channels.wechat` in OpenClaw's config file:
+All config lives under `channels.agent-wechat` in OpenClaw's config file. `channels.wechat` is still read as a one-release fallback.
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
@@ -185,14 +185,14 @@ cd agent-wechat
 pnpm install && pnpm build
 ```
 
-### Link for local development
+### Install a private source build
 
 ```bash
 node scripts/prepare-openclaw-plugin.mjs
-openclaw plugins install -l ./.artifacts/openclaw-extension
+openclaw plugins install ./.artifacts/agent-wechat-openclaw.tgz
 ```
 
-This stages only the built plugin files and a production manifest, avoiding pnpm workspace symlinks that OpenClaw correctly rejects as escaping the install root. Rebuild and restage after making changes, then restart the gateway.
+This creates a clean npm archive from the built plugin. OpenClaw installs its runtime dependencies, including the platform-specific `sharp` package, without relying on workspace-hoisted modules. Rebuild and repack after making changes, then restart the gateway.
 
 ## Architecture
 

package/dist/index.js

@@ -1102,8 +1102,10 @@ var DEFAULT_CATCH_UP_MAX_AGE_MS = 5 * 6e4;
 var DEFAULT_CATCH_UP_CHAT_BUDGET = 5;
 var DEFAULT_MEDIA_PART_DELAY_MS = 750;
 var DEFAULT_ACCOUNT_ID = "default";
+var OPENCLAW_CHANNEL_ID = "agent-wechat";
 function resolveWeChatAccount(cfg, accountId) {
-  const wechat = cfg.channels?.wechat;
+  const channels = cfg.channels;
+  const wechat = channels?.[OPENCLAW_CHANNEL_ID] ?? channels?.wechat;
   if (!wechat?.serverUrl) return null;
   return {
     accountId: accountId ?? DEFAULT_ACCOUNT_ID,
@@ -6154,7 +6156,7 @@ function normalizeWeChatId(raw) {
   if (!trimmed) {
     return "";
   }
-  return trimmed.replace(/^wechat:/i, "").trim();
+  return trimmed.replace(/^(agent-wechat|wechat):/i, "").trim();
 }
 function normalizeWeChatAllowFrom(values) {
   const normalized = (values ?? []).map((entry) => String(entry).trim()).filter(Boolean).map((entry) => entry === "*" ? "*" : normalizeWeChatId(entry)).filter(Boolean);
@@ -6240,7 +6242,7 @@ function resolveWeChatPolicyContext(params) {
   const requireMention = firstDefined(groupEntry?.requireMention, wildcardEntry?.requireMention, true) !== false;
   const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
   const { groupPolicy: fallbackGroupPolicy } = resolveAllowlistProviderRuntimeGroupPolicy({
-    providerConfigPresent: params.cfg.channels?.wechat !== void 0,
+    providerConfigPresent: params.cfg.channels?.["agent-wechat"] !== void 0 || params.cfg.channels?.wechat !== void 0,
     groupPolicy: normalizeGroupPolicy2(params.account.groupPolicy),
     defaultGroupPolicy: normalizeGroupPolicy2(defaultGroupPolicy)
   });
@@ -6355,6 +6357,310 @@ function nextReconnectState(input) {
   return { reconnect: true, dispatched: input.dispatched };
 }
 
+// src/inbound-media.ts
+import sharp from "sharp";
+var MIME_BY_FORMAT = {
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp",
+  gif: "image/gif",
+  mp3: "audio/mpeg",
+  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",
+  zip: "application/zip",
+  txt: "text/plain"
+};
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+var MAX_IMAGE_PIXELS = 4e7;
+var MAX_IMAGE_DIMENSION = 32768;
+var MAX_DECODED_IMAGE_BYTES = MAX_IMAGE_PIXELS * 4;
+var MAX_GIF_FRAMES = 64;
+var GIF_MAX_DICTIONARY_SIZE = 4096;
+var MAX_GIF_LZW_OPERATIONS = 1e7;
+var IMAGE_DECODE_TIMEOUT_SECONDS = 5;
+var SHARP_INPUT_OPTIONS = {
+  failOn: "warning",
+  limitInputPixels: MAX_IMAGE_PIXELS,
+  limitInputChannels: 5,
+  sequentialRead: true,
+  unlimited: false,
+  page: 0,
+  pages: 1,
+  animated: false
+};
+sharp.cache({ files: 0, items: 0, memory: 32 });
+sharp.concurrency(1);
+function imageMimeFromMagic(buf) {
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
+  if (buf.length >= 8 && buf.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) return "image/png";
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+  if (buf.length >= 6 && (buf.toString("ascii", 0, 6) === "GIF87a" || buf.toString("ascii", 0, 6) === "GIF89a")) return "image/gif";
+  return void 0;
+}
+function validDimensions(width, height) {
+  return Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0 && width <= MAX_IMAGE_DIMENSION && height <= MAX_IMAGE_DIMENSION && width * height <= MAX_IMAGE_PIXELS;
+}
+var SHARP_FORMAT_BY_MIME = {
+  "image/jpeg": "jpeg",
+  "image/png": "png",
+  "image/webp": "webp",
+  "image/gif": "gif"
+};
+function skipGifSubBlocks(buffer, startOffset) {
+  let offset = startOffset;
+  while (offset < buffer.length) {
+    const size = buffer[offset++];
+    if (size === 0) return offset;
+    if (offset + size > buffer.length) return void 0;
+    offset += size;
+  }
+  return void 0;
+}
+var GifCodeReader = class {
+  offset;
+  blockRemaining = 0;
+  datum = 0;
+  bits = 0;
+  ended = false;
+  buffer;
+  constructor(buffer, startOffset) {
+    this.buffer = buffer;
+    this.offset = startOffset;
+  }
+  nextByte() {
+    if (this.ended) return void 0;
+    if (this.blockRemaining === 0) {
+      if (this.offset >= this.buffer.length) return void 0;
+      this.blockRemaining = this.buffer[this.offset++];
+      if (this.blockRemaining === 0) {
+        this.ended = true;
+        return void 0;
+      }
+      if (this.offset + this.blockRemaining > this.buffer.length) return void 0;
+    }
+    this.blockRemaining -= 1;
+    return this.buffer[this.offset++];
+  }
+  read(codeSize) {
+    while (this.bits < codeSize) {
+      const byte = this.nextByte();
+      if (byte === void 0) return void 0;
+      this.datum |= byte << this.bits;
+      this.bits += 8;
+    }
+    const code = this.datum & (1 << codeSize) - 1;
+    this.datum >>>= codeSize;
+    this.bits -= codeSize;
+    return code;
+  }
+  finishSubBlocks() {
+    if (this.ended) return this.offset;
+    this.offset += this.blockRemaining;
+    this.blockRemaining = 0;
+    return skipGifSubBlocks(this.buffer, this.offset);
+  }
+};
+function decodeExactGifLzwPixels(buffer, startOffset, minCodeSize, pixelCount, colorCount, operationBudget) {
+  if (!Number.isInteger(minCodeSize) || minCodeSize < 2 || minCodeSize > 8) return void 0;
+  const clearCode = 1 << minCodeSize;
+  const endCode = clearCode + 1;
+  const prefix = new Uint16Array(GIF_MAX_DICTIONARY_SIZE);
+  const suffix = new Uint8Array(GIF_MAX_DICTIONARY_SIZE);
+  const stack = new Uint8Array(GIF_MAX_DICTIONARY_SIZE + 1);
+  for (let code = 0; code < clearCode; code += 1) suffix[code] = code;
+  const reader = new GifCodeReader(buffer, startOffset);
+  let codeSize = minCodeSize + 1;
+  let available = clearCode + 2;
+  let oldCode = -1;
+  let first = 0;
+  let produced = 0;
+  let sawInitialClear = false;
+  while (produced <= pixelCount && operationBudget.remaining > 0) {
+    operationBudget.remaining -= 1;
+    const next = reader.read(codeSize);
+    if (next === void 0) return void 0;
+    if (!sawInitialClear) {
+      if (next !== clearCode) return void 0;
+      sawInitialClear = true;
+      continue;
+    }
+    if (next === clearCode) {
+      codeSize = minCodeSize + 1;
+      available = clearCode + 2;
+      oldCode = -1;
+      continue;
+    }
+    if (next === endCode) {
+      return produced === pixelCount ? reader.finishSubBlocks() : void 0;
+    }
+    if (next > available || next >= GIF_MAX_DICTIONARY_SIZE) return void 0;
+    if (oldCode === -1) {
+      if (next >= clearCode || next >= colorCount) return void 0;
+      produced += 1;
+      oldCode = next;
+      first = next;
+      continue;
+    }
+    const inCode = next;
+    let code = next;
+    let top = 0;
+    if (code === available) {
+      stack[top++] = first;
+      code = oldCode;
+    } else if (code > available) {
+      return void 0;
+    }
+    let links = 0;
+    while (code >= clearCode + 2) {
+      operationBudget.remaining -= 1;
+      if (operationBudget.remaining < 0 || code >= available || top >= stack.length || links++ >= GIF_MAX_DICTIONARY_SIZE) return void 0;
+      const value = suffix[code];
+      if (value >= colorCount) return void 0;
+      stack[top++] = value;
+      code = prefix[code];
+    }
+    if (code >= clearCode || code >= colorCount || top >= stack.length) return void 0;
+    first = suffix[code];
+    stack[top++] = first;
+    produced += top;
+    if (produced > pixelCount) return void 0;
+    if (available < GIF_MAX_DICTIONARY_SIZE) {
+      prefix[available] = oldCode;
+      suffix[available] = first;
+      available += 1;
+      if (available === 1 << codeSize && codeSize < 12) codeSize += 1;
+    }
+    oldCode = inCode;
+  }
+  return void 0;
+}
+function validateGifLzwStreams(buffer) {
+  if (buffer.length < 14) return false;
+  const canvasWidth = buffer.readUInt16LE(6);
+  const canvasHeight = buffer.readUInt16LE(8);
+  if (!validDimensions(canvasWidth, canvasHeight)) return false;
+  const logicalPacked = buffer[10];
+  const globalColorCount = (logicalPacked & 128) !== 0 ? 1 << (logicalPacked & 7) + 1 : 0;
+  let offset = 13 + globalColorCount * 3;
+  if (offset > buffer.length) return false;
+  let frameCount = 0;
+  const operationBudget = { remaining: MAX_GIF_LZW_OPERATIONS };
+  while (offset < buffer.length) {
+    const marker = buffer[offset++];
+    if (marker === 59) return frameCount > 0 && offset === buffer.length;
+    if (marker === 33) {
+      if (offset >= buffer.length) return false;
+      offset += 1;
+      const nextOffset2 = skipGifSubBlocks(buffer, offset);
+      if (nextOffset2 === void 0) return false;
+      offset = nextOffset2;
+      continue;
+    }
+    if (marker !== 44 || offset + 9 > buffer.length) return false;
+    const left = buffer.readUInt16LE(offset);
+    const top = buffer.readUInt16LE(offset + 2);
+    const width = buffer.readUInt16LE(offset + 4);
+    const height = buffer.readUInt16LE(offset + 6);
+    const packed = buffer[offset + 8];
+    offset += 9;
+    if (!validDimensions(width, height)) return false;
+    if (left + width > canvasWidth || top + height > canvasHeight) return false;
+    frameCount += 1;
+    if (frameCount > MAX_GIF_FRAMES) return false;
+    const localColorCount = (packed & 128) !== 0 ? 1 << (packed & 7) + 1 : 0;
+    if (localColorCount > 0) {
+      offset += localColorCount * 3;
+      if (offset > buffer.length) return false;
+    }
+    const colorCount = localColorCount || globalColorCount;
+    if (colorCount === 0 || offset >= buffer.length) return false;
+    const minCodeSize = buffer[offset++];
+    const nextOffset = decodeExactGifLzwPixels(
+      buffer,
+      offset,
+      minCodeSize,
+      width * height,
+      colorCount,
+      operationBudget
+    );
+    if (nextOffset === void 0) return false;
+    offset = nextOffset;
+  }
+  return false;
+}
+async function validateDecodedImage(buffer, mime) {
+  if (buffer.length > MAX_IMAGE_BYTES) return "MEDIA_IMAGE_TOO_LARGE";
+  if (mime === "image/gif" && !validateGifLzwStreams(buffer)) return "MEDIA_IMAGE_INVALID";
+  try {
+    const metadata = await sharp(buffer, SHARP_INPUT_OPTIONS).timeout({ seconds: IMAGE_DECODE_TIMEOUT_SECONDS }).metadata();
+    const width = metadata.width;
+    const height = metadata.pageHeight ?? metadata.height;
+    if (metadata.format !== SHARP_FORMAT_BY_MIME[mime]) return "MEDIA_IMAGE_INVALID";
+    if (!validDimensions(width, height)) return "MEDIA_IMAGE_TOO_LARGE";
+    const decoded = await sharp(buffer, SHARP_INPUT_OPTIONS).timeout({ seconds: IMAGE_DECODE_TIMEOUT_SECONDS }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    const decodedBytes = decoded.data.length;
+    if (!validDimensions(decoded.info.width, decoded.info.height)) return "MEDIA_IMAGE_TOO_LARGE";
+    if (decodedBytes !== decoded.info.width * decoded.info.height * decoded.info.channels) return "MEDIA_IMAGE_INVALID";
+    if (decodedBytes > MAX_DECODED_IMAGE_BYTES) return "MEDIA_IMAGE_TOO_LARGE";
+    return void 0;
+  } catch {
+    return "MEDIA_IMAGE_INVALID";
+  }
+}
+async function validateInboundMedia(result) {
+  if (!result.data) return { ok: false, code: "MEDIA_EMPTY_DATA" };
+  const normalized = result.data.replace(/\s/g, "");
+  if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) {
+    return { ok: false, code: "MEDIA_INVALID_BASE64" };
+  }
+  const buffer = Buffer.from(normalized, "base64");
+  if (buffer.length === 0) return { ok: false, code: "MEDIA_EMPTY_DATA" };
+  const declared = MIME_BY_FORMAT[result.format.toLowerCase()] ?? `application/${result.format || "octet-stream"}`;
+  if (result.type === "image") {
+    const detected = imageMimeFromMagic(buffer);
+    if (!detected || detected !== declared) return { ok: false, code: "MEDIA_MAGIC_MISMATCH" };
+    const invalidCode = await validateDecodedImage(buffer, detected);
+    if (invalidCode) return { ok: false, code: invalidCode };
+  }
+  return { ok: true, value: { buffer, mime: declared } };
+}
+function safeBodyAfterKnownMediaFailure(baseType, content) {
+  return baseType === 3 ? "[Image unavailable]" : content;
+}
+async function saveValidatedInboundMedia(result, save) {
+  const validated = await validateInboundMedia(result);
+  if (!validated.ok) return validated;
+  try {
+    const saved = await save(validated.value.buffer, validated.value.mime, result.filename);
+    if (!saved?.path || typeof saved.path !== "string" || !saved.path.trim()) {
+      return { ok: false, code: "MEDIA_SAVE_FAILED" };
+    }
+    return { ok: true, path: saved.path, mime: validated.value.mime };
+  } catch {
+    return { ok: false, code: "MEDIA_SAVE_FAILED" };
+  }
+}
+
+// src/inbound-media-poll.ts
+async function pollMedia(client, chatId, localId, log, maxAttempts = 15, intervalMs = 1e3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await client.getMedia(chatId, localId);
+    if (result.type === "unsupported") return null;
+    if (result.data) return result;
+    if (attempt < maxAttempts) {
+      log?.info?.(`[wechat:media] pending attempt=${attempt}/${maxAttempts}`);
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+  return null;
+}
+
 // src/monitor.ts
 var MEDIA_TYPES = /* @__PURE__ */ new Set([3, 34, 43]);
 var HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
@@ -6371,22 +6677,6 @@ function sleep(ms, signal) {
     });
   });
 }
-async function pollMedia(client, chatId, localId, log, maxAttempts = 15, intervalMs = 1e3) {
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const result = await client.getMedia(chatId, localId);
-    if (result.type === "unsupported") {
-      return null;
-    }
-    if (result.data) {
-      return result;
-    }
-    if (attempt < maxAttempts) {
-      log?.info?.(`[media] Attempt ${attempt}/${maxAttempts} for ${chatId}:${localId} returned no data, retrying...`);
-      await new Promise((r) => setTimeout(r, intervalMs));
-    }
-  }
-  return null;
-}
 function enqueueWeChatSystemEvent(text, contextKey) {
   try {
     const core = getWeChatRuntime();
@@ -6657,44 +6947,28 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, lo
       const result = await pollMedia(client, chatId, msg.localId, log);
       if (result && result.data && result.type !== "unsupported") {
         hasMedia = true;
-        log?.info?.(`[wechat:${liveAccount.accountId}] Media result: type=${result.type}, format=${result.format}, hasData=${!!result.data}, filename=${result.filename}`);
-        const mimeMap = {
-          jpeg: "image/jpeg",
-          jpg: "image/jpeg",
-          png: "image/png",
-          gif: "image/gif",
-          mp3: "audio/mpeg",
-          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",
-          zip: "application/zip",
-          txt: "text/plain"
-        };
-        mediaMime = mimeMap[result.format] ?? `application/${result.format || "octet-stream"}`;
-        const buf = Buffer.from(result.data, "base64");
-        const saved = await core.channel.media.saveMediaBuffer(
-          buf,
-          mediaMime,
-          "inbound",
-          void 0,
-          result.filename
+        log?.info?.(`[wechat:media] inbound media received type=${result.type} format=${result.format}`);
+        const saved = await saveValidatedInboundMedia(
+          result,
+          async (buffer, mime, filename) => core.channel.media.saveMediaBuffer(buffer, mime, "inbound", void 0, filename)
         );
-        mediaPath = saved?.path;
-        log?.info?.(`[wechat:${liveAccount.accountId}] Saved media to ${mediaPath}`);
+        if (!saved.ok) {
+          log?.error?.(`[wechat:media] inbound media rejected code=${saved.code}`);
+        } else {
+          mediaMime = saved.mime;
+          mediaPath = saved.path;
+          log?.info?.("[wechat:media] inbound media saved");
+        }
       } else if (MEDIA_TYPES.has(baseType)) {
         hasMedia = true;
-        log?.info?.(`[wechat:${liveAccount.accountId}] Media not available after retries for msg ${msg.localId}`);
+        log?.info?.("[wechat:media] inbound media unavailable after retries");
       }
     } catch (err) {
-      log?.error?.(`[wechat:${liveAccount.accountId}] Media download failed: ${err}`);
+      log?.error?.("[wechat:media] inbound media failed code=MEDIA_DOWNLOAD_FAILED");
     }
   }
   const timestamp = new Date(msg.timestamp).getTime();
-  let rawBody = msg.content || "";
+  let rawBody = mediaPath ? msg.content || "" : safeBodyAfterKnownMediaFailure(baseType, msg.content || "");
   if (mediaPath && mediaMime) {
     if (!rawBody) {
       if (mediaMime.startsWith("audio/")) {
@@ -6762,7 +7036,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
   const mediaPath = mediaMsg?.mediaPath;
   const mediaMime = mediaMsg?.mediaMime;
   log?.info?.(
-    `[wechat:${liveAccount.accountId}] Dispatching segment: ${segment.length} msg(s), last=${msg.localId}${mediaPath ? ` media=${mediaPath}` : ""}`
+    `[wechat:${liveAccount.accountId}] Dispatching segment: ${segment.length} msg(s), last=${msg.localId}${mediaPath ? " media=present" : ""}`
   );
   const hasControlCommand = allowTextCommands && core.channel.commands.isControlCommandMessage(commandBody, cfg);
   const commandAuthorized = await resolveWeChatCommandAuthorization({
@@ -6802,7 +7076,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
   try {
     const route = core.channel.routing.resolveAgentRoute({
       cfg,
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       accountId: liveAccount.accountId,
       peer: {
         kind: isGroup ? "group" : "direct",
@@ -6874,21 +7148,21 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
       RawBody: rawBody,
       CommandBody: commandBody,
       InboundHistory: inboundHistory,
-      From: isGroup ? `wechat:group:${chatId}` : `wechat:${senderId}`,
-      To: `wechat:${chatId}`,
+      From: isGroup ? `${OPENCLAW_CHANNEL_ID}:group:${chatId}` : `${OPENCLAW_CHANNEL_ID}:${senderId}`,
+      To: `${OPENCLAW_CHANNEL_ID}:${chatId}`,
       SessionKey: route.sessionKey,
       AccountId: route.accountId,
       ChatType: isGroup ? "group" : "direct",
       ConversationLabel: fromLabel,
       SenderName: senderName || void 0,
       SenderId: senderId,
-      Provider: "wechat",
-      Surface: "wechat",
-      MessageSid: `wechat:${chatId}:${msg.localId}`,
+      Provider: OPENCLAW_CHANNEL_ID,
+      Surface: OPENCLAW_CHANNEL_ID,
+      MessageSid: `${OPENCLAW_CHANNEL_ID}:${chatId}:${msg.localId}`,
       WasMentioned: isGroup ? mentionGate.effectiveWasMentioned : void 0,
       CommandAuthorized: commandAuthorized,
-      OriginatingChannel: "wechat",
-      OriginatingTo: `wechat:${chatId}`,
+      OriginatingChannel: OPENCLAW_CHANNEL_ID,
+      OriginatingTo: `${OPENCLAW_CHANNEL_ID}:${chatId}`,
       ...mediaPath ? { MediaPath: mediaPath, MediaUrl: mediaPath, MediaType: mediaMime } : {},
       ...msg.reply ? {
         ReplyToBody: msg.reply.content.length > 50 ? msg.reply.content.slice(0, 50) + "..." : msg.reply.content,
@@ -6908,7 +7182,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
     const { onModelSelected, ...prefixOptions } = createChannelReplyPipeline({
       cfg,
       agentId: route.agentId,
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       accountId: liveAccount.accountId
     });
     await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
@@ -6920,7 +7194,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
           const mediaList = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
           const tableMode = core.channel.text.resolveMarkdownTableMode({
             cfg,
-            channel: "wechat",
+            channel: OPENCLAW_CHANNEL_ID,
             accountId: liveAccount.accountId
           });
           const text = core.channel.text.convertMarkdownTables(
@@ -6989,7 +7263,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
       }
     });
     core.channel.activity?.record?.({
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       accountId: liveAccount.accountId,
       direction: "inbound",
       at: timestamp
@@ -7019,7 +7293,7 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
   const core = getWeChatRuntime();
   const liveAccount = resolveWeChatAccount(cfg, account.accountId) ?? account;
   const chatId = chat.username ?? chat.id;
-  const storeAllowFrom = await core.channel.pairing.readAllowFromStore({ channel: "wechat", accountId: liveAccount.accountId, env: process.env }).catch(() => []);
+  const storeAllowFrom = await core.channel.pairing.readAllowFromStore({ channel: OPENCLAW_CHANNEL_ID, accountId: liveAccount.accountId, env: process.env }).catch(() => []);
   const policy = resolveWeChatPolicyContext({
     account: liveAccount,
     cfg,
@@ -7028,7 +7302,7 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
   });
   const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
     cfg,
-    surface: "wechat"
+    surface: OPENCLAW_CHANNEL_ID
   });
   let opened = false;
   const openChatIfNeeded = async () => {
@@ -7278,7 +7552,7 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
     }
     if (decision.action === "defer") {
       log?.info?.(
-        `[wechat:${liveAccount.accountId}] Catch-up hold for ${chatId} (budget ${liveAccount.catchUpChatBudget}); raise channels.wechat.catchUpChatBudget to continue`
+        `[wechat:${liveAccount.accountId}] Catch-up hold for ${chatId} (budget ${liveAccount.catchUpChatBudget}); raise channels.${OPENCLAW_CHANNEL_ID}.catchUpChatBudget to continue`
       );
       return "deferred";
     }
@@ -7344,7 +7618,7 @@ function collectWeChatStatusIssues(accounts) {
   for (const snapshot of accounts) {
     if (snapshot.connected === false) {
       issues.push({
-        channel: "wechat",
+        channel: "agent-wechat",
         accountId: snapshot.accountId,
         kind: "runtime",
         message: snapshot.lastError ? `Cannot reach agent-wechat server: ${snapshot.lastError}` : "Cannot reach agent-wechat server.",
@@ -7352,7 +7626,7 @@ function collectWeChatStatusIssues(accounts) {
       });
     } else if (snapshot.authStatus === "app_not_running") {
       issues.push({
-        channel: "wechat",
+        channel: "agent-wechat",
         accountId: snapshot.accountId,
         kind: "runtime",
         message: "WeChat application is not running. It should restart automatically.",
@@ -7360,11 +7634,11 @@ function collectWeChatStatusIssues(accounts) {
       });
     } else if (snapshot.linked === false) {
       issues.push({
-        channel: "wechat",
+        channel: "agent-wechat",
         accountId: snapshot.accountId,
         kind: "auth",
         message: "WeChat session not authenticated.",
-        fix: "Run: openclaw channels login --channel wechat"
+        fix: "Run: openclaw channels login --channel agent-wechat"
       });
     }
   }
@@ -7783,7 +8057,7 @@ async function sendWeChatText(cfg, to, text) {
     }
     throw new Error(result.error ?? "Send failed");
   }
-  return `wechat:${to}:${Date.now()}`;
+  return `${OPENCLAW_CHANNEL_ID}:${to}:${Date.now()}`;
 }
 async function sendWeChatMedia(cfg, to, text, mediaUrl) {
   const account = resolveWeChatAccount(cfg);
@@ -7796,7 +8070,7 @@ async function sendWeChatMedia(cfg, to, text, mediaUrl) {
       source: "openclaw"
     });
     if (!result.success) throw new Error(result.error ?? "Send failed");
-    return `wechat:${to}:${Date.now()}`;
+    return `${OPENCLAW_CHANNEL_ID}:${to}:${Date.now()}`;
   }
   const fsmod = await import("fs/promises");
   const pathmod = await import("path");
@@ -7833,10 +8107,10 @@ async function sendWeChatMedia(cfg, to, text, mediaUrl) {
     interPartDelayMs: account.mediaPartDelayMs,
     source: "openclaw"
   });
-  return `wechat:${to}:${requestId}`;
+  return `${OPENCLAW_CHANNEL_ID}:${to}:${requestId}`;
 }
 var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
-  id: "wechat",
+  id: OPENCLAW_CHANNEL_ID,
   capabilities: {
     text: true,
     media: true,
@@ -7844,26 +8118,26 @@ var wechatMessageAdapter = createChannelMessageAdapterFromOutbound({
   },
   outbound: {
     sendText: async ({ cfg, to, text }) => ({
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       messageId: await sendWeChatText(cfg, to, text)
     }),
     sendMedia: async ({ cfg, to, text, mediaUrl }) => ({
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       messageId: await sendWeChatMedia(cfg, to, text, mediaUrl)
     })
   }
 });
 var meta = {
-  id: "wechat",
+  id: OPENCLAW_CHANNEL_ID,
   label: "WeChat",
-  selectionLabel: "WeChat (\u5FAE\u4FE1)",
+  selectionLabel: "WeChat (agent-wechat)",
   blurb: "WeChat messaging via agent-wechat container.",
   docsPath: "wechat",
-  aliases: ["weixin"],
+  aliases: [],
   order: 80
 };
 var wechatPlugin = {
-  id: "wechat",
+  id: OPENCLAW_CHANNEL_ID,
   meta,
   gatewayMethods: ["web.login.start", "web.login.wait"],
   capabilities: {
@@ -7873,7 +8147,7 @@ var wechatPlugin = {
     media: true,
     reply: true
   },
-  reload: { configPrefixes: ["channels.wechat"] },
+  reload: { configPrefixes: [`channels.${OPENCLAW_CHANNEL_ID}`, "channels.wechat"] },
   configSchema: {
     schema: {
       type: "object",
@@ -7949,23 +8223,23 @@ var wechatPlugin = {
     },
     isEnabled: (account) => account.enabled && !!account.serverUrl,
     isConfigured: (account) => !!account.serverUrl,
-    unconfiguredReason: () => "No serverUrl configured. Run: openclaw channels setup wechat"
+    unconfiguredReason: () => "No serverUrl configured. Run: openclaw channels setup agent-wechat"
   },
   // ---- Security adapter ----
   security: {
     resolveDmPolicy: ({ account }) => ({
       policy: account.dmPolicy ?? "disabled",
       allowFrom: account.allowFrom ?? [],
-      allowFromPath: "channels.wechat.allowFrom",
-      policyPath: "channels.wechat.dmPolicy",
-      approveHint: "Add the wxid to channels.wechat.allowFrom",
-      normalizeEntry: (raw) => raw.replace(/^wechat:/i, "").trim()
+      allowFromPath: `channels.${OPENCLAW_CHANNEL_ID}.allowFrom`,
+      policyPath: `channels.${OPENCLAW_CHANNEL_ID}.dmPolicy`,
+      approveHint: `Add the wxid to channels.${OPENCLAW_CHANNEL_ID}.allowFrom`,
+      normalizeEntry: (raw) => raw.replace(/^(agent-wechat|wechat):/i, "").trim()
     })
   },
   // ---- Groups adapter ----
   groups: {
     resolveRequireMention: ({ cfg, groupId }) => {
-      const wechat = cfg?.channels?.wechat;
+      const wechat = cfg?.channels?.[OPENCLAW_CHANNEL_ID] ?? cfg?.channels?.wechat;
       if (!wechat) return true;
       if (!groupId) {
         return wechat.groups?.["*"]?.requireMention ?? true;
@@ -7990,10 +8264,10 @@ var wechatPlugin = {
   },
   // ---- Messaging adapter ----
   messaging: {
-    normalizeTarget: (raw) => raw.replace(/^wechat:/i, "").trim() || void 0,
+    normalizeTarget: (raw) => raw.replace(/^(agent-wechat|wechat):/i, "").trim() || void 0,
     targetResolver: {
       looksLikeId: (raw) => {
-        const stripped = raw.replace(/^wechat:/i, "").trim();
+        const stripped = raw.replace(/^(agent-wechat|wechat):/i, "").trim();
         return stripped.includes("@chatroom") || stripped.startsWith("wxid_");
       },
       hint: "WeChat ID (wxid_xxx or xxx@chatroom)"
@@ -8003,11 +8277,11 @@ var wechatPlugin = {
   outbound: {
     deliveryMode: "direct",
     sendText: async ({ cfg, to, text }) => ({
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       messageId: await sendWeChatText(cfg, to, text)
     }),
     sendMedia: async ({ cfg, to, text, mediaUrl }) => ({
-      channel: "wechat",
+      channel: OPENCLAW_CHANNEL_ID,
       messageId: await sendWeChatMedia(cfg, to, text, mediaUrl)
     })
   },
@@ -8034,7 +8308,7 @@ var wechatPlugin = {
         accountId ?? void 0
       );
       if (!account?.serverUrl) {
-        return { message: "No serverUrl configured. Run: openclaw channels setup wechat" };
+        return { message: "No serverUrl configured. Run: openclaw channels setup agent-wechat" };
       }
       const client = new WeChatClient({ baseUrl: account.serverUrl, token: account.token });
       try {
@@ -8075,7 +8349,7 @@ var wechatPlugin = {
       );
       if (!account?.serverUrl) {
         throw new Error(
-          "No serverUrl configured. Run: openclaw channels setup wechat"
+          "No serverUrl configured. Run: openclaw channels setup agent-wechat"
         );
       }
       const client = new WeChatClient({ baseUrl: account.serverUrl, token: account.token });
@@ -8235,8 +8509,8 @@ Error: ${event.message}`);
         ...cfg,
         channels: {
           ...cfg.channels,
-          wechat: {
-            ...cfg.channels?.wechat,
+          [OPENCLAW_CHANNEL_ID]: {
+            ...cfg.channels?.[OPENCLAW_CHANNEL_ID] ?? cfg.channels?.wechat,
             enabled: true,
             serverUrl,
             ...token ? { token } : {}
@@ -8249,7 +8523,7 @@ Error: ${event.message}`);
 
 // index.ts
 var plugin = {
-  id: "wechat",
+  id: OPENCLAW_CHANNEL_ID,
   name: "WeChat",
   description: "WeChat channel via agent-wechat container",
   configSchema: emptyPluginConfigSchema(),

package/openclaw.plugin.json

@@ -1,13 +1,13 @@
 {
-  "id": "wechat",
-  "channels": ["wechat"],
+  "id": "agent-wechat",
+  "channels": ["agent-wechat"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {}
   },
   "channelConfigs": {
-    "wechat": {
+    "agent-wechat": {
       "label": "WeChat",
       "description": "WeChat messaging via agent-wechat container.",
       "schema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyan-du/agent-wechat-openclaw",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "type": "module",
   "files": [
     "dist",
@@ -8,7 +8,7 @@
     "!dist/.release-metafile.json"
   ],
   "scripts": {
-    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --metafile=dist/.release-metafile.json --external:openclaw",
+    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --metafile=dist/.release-metafile.json --external:openclaw --external:sharp",
     "typecheck": "tsc --noEmit",
     "test": "node --test --experimental-strip-types src/*.test.ts"
   },
@@ -24,12 +24,10 @@
       "./dist/index.js"
     ],
     "channel": {
-      "id": "wechat",
+      "id": "agent-wechat",
       "label": "WeChat",
-      "selectionLabel": "WeChat (微信)",
-      "aliases": [
-        "weixin"
-      ],
+      "selectionLabel": "WeChat (agent-wechat)",
+      "aliases": [],
       "order": 80
     },
     "install": {
@@ -48,5 +46,8 @@
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "sharp": "^0.35.3"
   }
 }