@kyan-du/agent-wechat-openclaw 0.13.3 → 0.14.0

package/dist/index.js

@@ -1079,11 +1079,11 @@ var require_main = __commonJS({
 });
 
 // index.ts
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/plugin-entry";
 
 // src/channel.ts
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID2 } from "openclaw/plugin-sdk/account-id";
-import { createChannelMessageAdapterFromOutbound } from "openclaw/plugin-sdk/channel-message";
+import { createChannelMessageAdapterFromOutbound } from "openclaw/plugin-sdk/channel-outbound";
 
 // src/types.ts
 function normalizeDmPolicy(policy) {
@@ -1155,6 +1155,9 @@ function getWeChatRuntime() {
   return runtime;
 }
 
+// src/monitor.ts
+import { unlink } from "node:fs/promises";
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -5251,6 +5254,23 @@ var chatSchema = external_exports.object({
   unreadCount: external_exports.number().int().nonnegative(),
   isGroup: external_exports.boolean()
 });
+var groupMemberSchema = external_exports.object({
+  memberId: external_exports.string().min(1),
+  displayName: external_exports.string().min(1),
+  groupAlias: external_exports.string().optional(),
+  nickName: external_exports.string().optional()
+});
+var groupMembersPageSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  items: external_exports.array(groupMemberSchema),
+  nextCursor: external_exports.string().nullable().optional(),
+  errorCode: external_exports.string().optional()
+});
+var listGroupMembersParamsSchema = external_exports.object({
+  groupId: external_exports.string().endsWith("@chatroom"),
+  limit: external_exports.number().int().positive().max(100).optional().default(50),
+  cursor: external_exports.string().optional()
+});
 var listChatsParamsSchema = external_exports.object({
   limit: external_exports.number().int().positive().max(100).optional().default(50),
   offset: external_exports.number().int().nonnegative().optional().default(0)
@@ -5277,6 +5297,22 @@ var openChatResultSchema = external_exports.object({
   error: external_exports.string().optional()
 });
 var idempotencyKeySchema = external_exports.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/);
+var forwardedMessageNodeSchema = external_exports.lazy(() => external_exports.object({
+  sender: external_exports.string().optional(),
+  senderId: external_exports.string().optional(),
+  timestamp: external_exports.string().optional(),
+  text: external_exports.string().optional(),
+  messageType: external_exports.number().int().optional(),
+  media: external_exports.string().optional(),
+  children: external_exports.array(forwardedMessageNodeSchema),
+  truncated: external_exports.boolean()
+}));
+var forwardedMessageTreeSchema = external_exports.object({
+  schemaVersion: external_exports.number().int(),
+  title: external_exports.string().optional(),
+  nodes: external_exports.array(forwardedMessageNodeSchema),
+  truncated: external_exports.boolean()
+});
 var messageSchema = external_exports.object({
   localId: external_exports.number().int(),
   serverId: external_exports.number(),
@@ -5285,7 +5321,26 @@ var messageSchema = external_exports.object({
   senderName: external_exports.string().optional(),
   type: external_exports.number().int(),
   content: external_exports.string(),
-  timestamp: external_exports.string()
+  timestamp: external_exports.string(),
+  forwarded: forwardedMessageTreeSchema.optional()
+});
+var mediaReferenceSchema = external_exports.object({
+  localId: external_exports.number().int(),
+  url: external_exports.string().min(1)
+});
+var syncReadStateSchema = external_exports.object({
+  unreadCount: external_exports.number().int().nonnegative(),
+  observedAt: external_exports.string().min(1)
+});
+var chatSyncPageSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  chat: chatSchema.optional(),
+  items: external_exports.array(messageSchema),
+  nextCursor: external_exports.string().optional().nullable(),
+  syncToken: external_exports.string(),
+  readState: syncReadStateSchema,
+  media: external_exports.array(mediaReferenceSchema),
+  errorCode: external_exports.string().optional()
 });
 var listMessagesParamsSchema = external_exports.object({
   chatId: external_exports.string().min(1),
@@ -5311,6 +5366,31 @@ var sendParamsSchema = external_exports.object({
   source: external_exports.string().min(1).max(64).regex(/^[A-Za-z0-9._:-]+$/).optional(),
   similarityConfirmed: external_exports.boolean().optional()
 });
+var deliveryStateSchema = external_exports.enum(["queued", "composing", "submitted", "observed_in_chat", "confirmed", "uncertain", "failed"]);
+var deliveryCauseSchema = external_exports.enum(["send_accepted", "target_sender_and_payload_match", "observation_confirmed", "target_mismatch", "sender_unverified", "payload_mismatch", "pre_commit_failure", "post_commit_uncertain"]);
+var deliveryTransitionSchema = external_exports.object({ from: deliveryStateSchema, to: deliveryStateSchema, at: external_exports.string().datetime(), reason: deliveryCauseSchema });
+var deliveryObservationSchema = external_exports.object({
+  chatId: external_exports.string().trim().min(1).max(512),
+  localId: external_exports.number().int().nonnegative().safe(),
+  serverId: external_exports.number().int().nonnegative().safe(),
+  timestamp: external_exports.string().datetime(),
+  type: external_exports.number().int().nonnegative().safe(),
+  sender: external_exports.string().trim().min(1).max(512),
+  content: external_exports.string().max(1e6)
+}).strict();
+var deliveryAttemptSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  idempotencyKey: idempotencyKeySchema.optional(),
+  senderId: external_exports.string().trim().min(1).max(512),
+  targetChatId: external_exports.string().trim().min(1).max(512),
+  payloadDigest: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  state: deliveryStateSchema,
+  commitAttempted: external_exports.boolean(),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime(),
+  observedLocalId: external_exports.number().int().nonnegative().optional(),
+  transitions: external_exports.array(deliveryTransitionSchema).max(32)
+});
 var sendResultSchema = external_exports.object({
   success: external_exports.boolean(),
   messageId: external_exports.string().optional(),
@@ -5323,11 +5403,13 @@ var getMediaParamsSchema = external_exports.object({
   localId: external_exports.number().int()
 });
 var mediaResultSchema = external_exports.object({
-  type: external_exports.enum(["image", "emoji", "voice", "video", "unsupported"]),
+  type: external_exports.enum(["image", "emoji", "file", "voice", "video", "pending", "unsupported"]),
   data: external_exports.string().optional(),
   url: external_exports.string().optional(),
   format: external_exports.string(),
-  filename: external_exports.string()
+  filename: external_exports.string(),
+  source: external_exports.enum(["original", "thumbnail"]).optional(),
+  errorCode: external_exports.string().optional()
 });
 var agentConfigSchema = external_exports.object({
   maxTurns: external_exports.number().int().positive().default(30),
@@ -5452,6 +5534,12 @@ var WeChatClient = class {
   async openChat(chatId, clearUnreads) {
     return this.post(`/api/chats/${encodeURIComponent(chatId)}/open${qs({ clearUnreads })}`);
   }
+  async listGroupMembersPage(groupId, limit, cursor) {
+    const page = groupMembersPageSchema.parse(await this.get(`/api/groups/${encodeURIComponent(groupId)}/members${qs({ limit, cursor })}`));
+    if (page.errorCode)
+      throw new WeChatHttpError(400, "Bad Request", page.errorCode, page.errorCode);
+    return { ...page, nextCursor: page.nextCursor ?? void 0 };
+  }
   // ---- Contacts ----
   async listContactsPage(limit, cursor) {
     const page = await this.get(`/api/contacts${qs({ limit, cursor })}`);
@@ -5475,6 +5563,17 @@ var WeChatClient = class {
   async listMessages(chatId, limit) {
     return (await this.listMessagesPage(chatId, limit)).items;
   }
+  async syncChat(chatId, options = {}) {
+    const raw = await this.get(`/api/sync/${encodeURIComponent(chatId)}${qs({ limit: options.limit, cursor: options.cursor, since: options.since, from: options.from, to: options.to })}`);
+    if (raw && typeof raw === "object" && typeof raw.errorCode === "string") {
+      const errorCode = raw.errorCode;
+      throw new WeChatHttpError(400, "Bad Request", errorCode, errorCode);
+    }
+    const page = chatSyncPageSchema.parse(raw);
+    if (page.errorCode)
+      throw new WeChatHttpError(400, "Bad Request", page.errorCode, page.errorCode);
+    return { ...page, nextCursor: page.nextCursor ?? void 0 };
+  }
   async getMedia(chatId, localId) {
     return this.get(`/api/messages/${encodeURIComponent(chatId)}/media/${localId}`);
   }
@@ -5558,7 +5657,7 @@ var WeChatClient = class {
 };
 
 // src/monitor.ts
-import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+import { createChannelMessageReplyPipeline as createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
 
 // src/catch-up.ts
 function recoveryCursor(selection) {
@@ -6073,7 +6172,7 @@ function recordResetRetryFailure(state, chatId, now = Date.now()) {
   });
   persist(state);
 }
-function monitorChatsToProcess(chats, state, now = Date.now()) {
+function monitorChatsToProcess(chats, state, now = Date.now(), shouldProcessChat = () => true) {
   const result = /* @__PURE__ */ new Map();
   for (const pending of state.pendingMessageScans.values()) {
     const chatId = pending.chat.username ?? pending.chat.id;
@@ -6081,7 +6180,7 @@ function monitorChatsToProcess(chats, state, now = Date.now()) {
   }
   for (const chat of chats) {
     const chatId = chat.username ?? chat.id;
-    if (chat.unreadCount > 0 || state.pendingMessageScans.has(chatId)) result.set(chatId, chat);
+    if (shouldProcessChat(chat) && (chat.unreadCount > 0 || state.pendingMessageScans.has(chatId))) result.set(chatId, chat);
   }
   return result;
 }
@@ -6366,6 +6465,9 @@ var MIME_BY_FORMAT = {
   webp: "image/webp",
   gif: "image/gif",
   mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
   pdf: "application/pdf",
   doc: "application/msword",
   docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -6374,9 +6476,14 @@ var MIME_BY_FORMAT = {
   ppt: "application/vnd.ms-powerpoint",
   pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
   zip: "application/zip",
-  txt: "text/plain"
+  txt: "text/plain",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime"
 };
 var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+var MAX_FILE_BYTES = 25 * 1024 * 1024;
+var MAX_FILENAME_CHARS = 180;
 var MAX_IMAGE_PIXELS = 4e7;
 var MAX_IMAGE_DIMENSION = 32768;
 var MAX_DECODED_IMAGE_BYTES = MAX_IMAGE_PIXELS * 4;
@@ -6396,6 +6503,29 @@ var SHARP_INPUT_OPTIONS = {
 };
 sharp.cache({ files: 0, items: 0, memory: 32 });
 sharp.concurrency(1);
+function safeInboundFilename(raw) {
+  const base = raw.replace(/\\/g, "/").split("/").pop() ?? "";
+  const cleaned = [...base].filter((char) => char >= " " && char !== "\x7F" && char !== "/" && char !== "\\").slice(0, MAX_FILENAME_CHARS).join("").replace(/^[.\s]+|[.\s]+$/g, "");
+  return cleaned || void 0;
+}
+var SUPPORTED_FILE_FORMATS = /* @__PURE__ */ new Set(["pdf"]);
+function documentMimeFromMagic(buf) {
+  if (buf.length >= 5 && buf.toString("ascii", 0, 5) === "%PDF-") return "application/pdf";
+  return void 0;
+}
+function binaryMimeFromMagic(buf) {
+  if (buf.length >= 3 && buf.subarray(0, 3).equals(Buffer.from("ID3", "ascii"))) return "audio/mpeg";
+  if (buf.length >= 2 && buf[0] === 255 && (buf[1] & 224) === 224) return "audio/mpeg";
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WAVE") return "audio/wav";
+  if (buf.length >= 4 && buf.toString("ascii", 0, 4) === "OggS") return "audio/ogg";
+  if (buf.length >= 12 && buf.toString("ascii", 4, 8) === "ftyp") {
+    const brand = buf.toString("ascii", 8, 12);
+    if (["isom", "iso2", "mp41", "mp42", "avc1"].includes(brand)) return "video/mp4";
+    if (brand === "qt  ") return "video/quicktime";
+  }
+  if (buf.length >= 4 && buf.subarray(0, 4).equals(Buffer.from([26, 69, 223, 163]))) return "video/webm";
+  return void 0;
+}
 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";
@@ -6621,44 +6751,645 @@ async function validateInboundMedia(result) {
   }
   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"}`;
+  const format = result.format.toLowerCase();
+  const declared = MIME_BY_FORMAT[format] ?? "application/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 };
+  } else if (result.type === "voice" || result.type === "video") {
+    if (buffer.length > MAX_FILE_BYTES) return { ok: false, code: "MEDIA_FILE_TOO_LARGE" };
+    const detected = binaryMimeFromMagic(buffer);
+    if (!detected || detected !== declared) return { ok: false, code: "MEDIA_MAGIC_MISMATCH" };
+  } else if (result.type === "file") {
+    if (buffer.length > MAX_FILE_BYTES) return { ok: false, code: "MEDIA_FILE_TOO_LARGE" };
+    if (!safeInboundFilename(result.filename)) return { ok: false, code: "MEDIA_FILENAME_INVALID" };
+    if (!SUPPORTED_FILE_FORMATS.has(format)) return { ok: false, code: "MEDIA_FILE_TYPE_MISMATCH" };
+    if (documentMimeFromMagic(buffer) !== "application/pdf") {
+      return { ok: false, code: "MEDIA_FILE_TYPE_MISMATCH" };
+    }
   }
   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) {
+var RETRYABLE_MEDIA_ERRORS = /* @__PURE__ */ new Set([
+  "MEDIA_NOT_DOWNLOADED",
+  "IMAGE_RESOURCE_UNAVAILABLE",
+  "FILE_NOT_DOWNLOADED",
+  "FILE_NOT_STABLE",
+  "VOICE_NOT_DOWNLOADED",
+  "IMAGE_NOT_STABLE"
+]);
+var DEFAULT_MEDIA_POLL_ATTEMPTS = 30;
+var DEFAULT_MEDIA_POLL_INTERVAL_MS = 1e3;
+function isRetryable(result) {
+  if (result.data !== void 0) return false;
+  if (result.errorCode !== void 0) return RETRYABLE_MEDIA_ERRORS.has(result.errorCode);
+  return result.type === "pending";
+}
+async function pollMedia(client, chatId, localId, log, maxAttempts = DEFAULT_MEDIA_POLL_ATTEMPTS, intervalMs = DEFAULT_MEDIA_POLL_INTERVAL_MS) {
+  let lastResult;
+  const startedAt = Date.now();
   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;
+    lastResult = result;
+    if (result.type === "unsupported") return result;
+    if (result.data || !isRetryable(result)) return result;
     if (attempt < maxAttempts) {
-      log?.info?.(`[wechat:media] pending attempt=${attempt}/${maxAttempts}`);
+      log?.info?.(`[wechat:media] pending attempt=${attempt}/${maxAttempts} elapsedMs=${Date.now() - startedAt}`);
       await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
   }
-  return null;
+  log?.info?.(`[wechat:media] pending exhausted attempts=${maxAttempts} elapsedMs=${Date.now() - startedAt}`);
+  return lastResult ?? null;
+}
+
+// src/monitor-ledger.ts
+import { createHash } from "node:crypto";
+import {
+  closeSync as closeSync3,
+  existsSync as existsSync3,
+  fsyncSync as fsyncSync3,
+  openSync as openSync3
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// src/durable-store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fsyncSync as fsyncSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2, isAbsolute } from "node:path";
+var MAX_DURABLE_JSON_BYTES = 8 * 1024 * 1024;
+var LOCK_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 3e4;
+var DurableStoreError = class extends Error {
+  code = "DURABLE_STORE_IO_FAILED";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DurableStoreError";
+  }
+};
+function assertTrustedPath(path, root) {
+  if (!isAbsolute(path) || path.includes("\0")) {
+    throw new DurableStoreError("durable store paths must be absolute and contain no null bytes");
+  }
+  if (root) {
+    if (!isAbsolute(root) || path !== root && !path.startsWith(`${root}/`)) {
+      throw new DurableStoreError("durable store path is outside the approved state root");
+    }
+    for (const part of path.slice(root.length).split("/")) {
+      if (!part) continue;
+      const candidate = path.slice(0, path.indexOf(part) + part.length);
+      try {
+        if (statSync(candidate).isSymbolicLink()) throw new DurableStoreError("durable store path contains a symlink");
+      } catch (error) {
+        if (error instanceof DurableStoreError) throw error;
+      }
+    }
+  }
+}
+function syncPath2(path) {
+  const fd = openSync2(path, "r");
+  try {
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+}
+function sleepSync(ms) {
+  const buffer = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(buffer), 0, 0, ms);
+}
+function lockPath(path) {
+  return `${path}.lock`;
+}
+function acquireLock(path) {
+  assertTrustedPath(path);
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const lock = lockPath(path);
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  while (Date.now() < deadline) {
+    try {
+      writeFileSync2(lock, JSON.stringify({ version: 1, pid: process.pid, createdAt: Date.now() }), { flag: "wx", mode: 384 });
+      syncPath2(lock);
+      return lock;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw new DurableStoreError(`durable store lock failed: ${path}`, { cause: error });
+      }
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) rmSync2(lock, { force: true });
+      } catch {
+      }
+      sleepSync(10);
+    }
+  }
+  throw new DurableStoreError(`durable store lock timeout: ${path}`);
+}
+function releaseLock(lock) {
+  try {
+    rmSync2(lock, { force: true });
+  } catch {
+  }
+}
+function withDurableJsonLock(path, operation) {
+  const lock = acquireLock(path);
+  try {
+    return operation();
+  } finally {
+    releaseLock(lock);
+  }
+}
+function serialize(value) {
+  const json = JSON.stringify(value);
+  if (Buffer.byteLength(json, "utf8") > MAX_DURABLE_JSON_BYTES) {
+    throw new DurableStoreError(`durable store value exceeds ${MAX_DURABLE_JSON_BYTES} bytes`);
+  }
+  return json;
+}
+function writeDurableJsonLocked(path, value) {
+  const temp = `${path}.tmp-${process.pid}-${randomUUID2()}`;
+  try {
+    writeFileSync2(temp, serialize(value), { mode: 384 });
+    syncPath2(temp);
+    renameSync2(temp, path);
+    syncPath2(dirname2(path));
+  } catch (error) {
+    try {
+      rmSync2(temp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function writeUnlocked(path, value) {
+  writeDurableJsonLocked(path, value);
+}
+function updateDurableJson(path, update, root) {
+  assertTrustedPath(path, root);
+  try {
+    return withDurableJsonLock(path, () => {
+      const current = existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : void 0;
+      const next = update(current);
+      writeUnlocked(path, next);
+      return next;
+    });
+  } catch (error) {
+    if (error instanceof DurableStoreError) throw error;
+    throw new DurableStoreError(`durable store update failed: ${path}`, { cause: error });
+  }
+}
+function readDurableJson(path) {
+  assertTrustedPath(path);
+  if (!existsSync2(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    throw new DurableStoreError(`durable store read failed: ${path}`, { cause: error });
+  }
+}
+function quarantineDurableJson(path, blockerPath3) {
+  assertTrustedPath(path);
+  assertTrustedPath(blockerPath3);
+  const quarantinePath3 = `${path}.corrupt-${Date.now()}-${randomUUID2()}`;
+  const markerPath = `${path}.quarantine`;
+  try {
+    withDurableJsonLock(path, () => {
+      writeDurableJsonLocked(markerPath, { version: 1, quarantine: quarantinePath3, blocker: blockerPath3 });
+      renameSync2(path, quarantinePath3);
+      syncPath2(dirname2(path));
+      writeDurableJsonLocked(blockerPath3, { version: 1, quarantine: quarantinePath3 });
+      rmSync2(markerPath, { force: true });
+      syncPath2(dirname2(path));
+    });
+    return quarantinePath3;
+  } catch (error) {
+    throw new DurableStoreError(`durable store quarantine failed: ${path}`, { cause: error });
+  }
+}
+function recoverDurableQuarantine(path) {
+  const markerPath = `${path}.quarantine`;
+  if (!existsSync2(markerPath)) return;
+  try {
+    const marker = JSON.parse(readFileSync2(markerPath, "utf8"));
+    if (typeof marker.quarantine !== "string" || typeof marker.blocker !== "string") throw new Error("invalid quarantine marker");
+    withDurableJsonLock(path, () => {
+      if (existsSync2(path)) renameSync2(path, marker.quarantine);
+      writeDurableJsonLocked(marker.blocker, { version: 1, quarantine: marker.quarantine });
+      rmSync2(markerPath, { force: true });
+      syncPath2(dirname2(path));
+    });
+  } catch (error) {
+    throw new DurableStoreError(`durable store quarantine recovery failed: ${path}`, { cause: error });
+  }
+}
+
+// src/monitor-ledger.ts
+var MAX_INBOUND_LEDGER_ENTRIES = 1e4;
+var MAX_INBOUND_EVENT_ATTEMPTS = 5;
+var MAX_INBOUND_RETRY_DELAY_MS = 6e4;
+var InboundLedgerStateError = class extends Error {
+  code = "INBOUND_LEDGER_BLOCKED";
+  constructor(message) {
+    super(message);
+    this.name = "InboundLedgerStateError";
+  }
+};
+function statePath(accountId, stateDir) {
+  const root = stateDir ?? process.env.OPENCLAW_STATE_DIR?.trim() ?? join2(homedir2(), ".openclaw");
+  const safeAccount = accountId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return join2(root, "wechat", `inbound-ledger-${safeAccount}.json`);
+}
+function quarantinePath2(path) {
+  return `${path}.corrupt`;
+}
+function blockerPath2(path) {
+  return `${path}.blocked`;
+}
+function validRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const row = value;
+  return typeof row.eventId === "string" && /^[a-f0-9]{64}$/.test(row.eventId) && typeof row.chatId === "string" && row.chatId.length > 0 && row.chatId.length <= 512 && Number.isSafeInteger(row.localId) && typeof row.messageKey === "string" && row.messageKey.length <= 4096 && ["pending", "processing", "processed", "failed", "dead_letter"].includes(String(row.status)) && Number.isSafeInteger(row.attempts) && Number(row.attempts) >= 0 && typeof row.createdAt === "number" && Number.isFinite(row.createdAt) && typeof row.updatedAt === "number" && Number.isFinite(row.updatedAt) && (row.nextRetryAt === void 0 || typeof row.nextRetryAt === "number" && Number.isFinite(row.nextRetryAt)) && (row.lastErrorCode === void 0 || typeof row.lastErrorCode === "string") && (row.outcome === void 0 || ["dispatched", "filtered", "buffered", "read_only", "stale"].includes(String(row.outcome)));
+}
+function validateFile(value) {
+  if (!value || typeof value !== "object") throw new InboundLedgerStateError("inbound ledger is not an object");
+  const row = value;
+  if (row.version !== 1 || !Array.isArray(row.entries) || row.entries.length > MAX_INBOUND_LEDGER_ENTRIES) {
+    throw new InboundLedgerStateError("inbound ledger schema or capacity is invalid");
+  }
+  const entries = row.entries;
+  if (!entries.every(validRecord)) throw new InboundLedgerStateError("inbound ledger contains an invalid event");
+  const ids = new Set(entries.map((entry) => entry.eventId));
+  if (ids.size !== entries.length) throw new InboundLedgerStateError("inbound ledger contains duplicate events");
+  return { version: 1, entries };
+}
+function loadFile(path) {
+  if (existsSync3(blockerPath2(path))) {
+    throw new InboundLedgerStateError(`inbound ledger is blocked: ${blockerPath2(path)}`);
+  }
+  if (!existsSync3(path)) return { version: 1, entries: [] };
+  try {
+    const parsed = readDurableJson(path);
+    if (parsed === void 0) return { version: 1, entries: [] };
+    return validateFile(parsed);
+  } catch (error) {
+    const quarantine = quarantinePath2(path);
+    try {
+      quarantineDurableJson(path, blockerPath2(path));
+    } catch (quarantineError) {
+      throw new InboundLedgerStateError(`inbound ledger quarantine failed: ${String(quarantineError)}`);
+    }
+    throw new InboundLedgerStateError(`inbound ledger quarantined at ${quarantine}: ${String(error)}`);
+  }
+}
+function inboundEventId(accountId, chatId, message) {
+  return createHash("sha256").update(`${accountId}\0${chatId}\0${cursorMessageKey(message)}`).digest("hex");
+}
+var InboundEventLedger = class {
+  path;
+  entries = /* @__PURE__ */ new Map();
+  constructor(accountId, stateDir) {
+    this.path = statePath(accountId, stateDir);
+    recoverDurableQuarantine(this.path);
+    for (const entry of loadFile(this.path).entries) this.entries.set(entry.eventId, entry);
+  }
+  persist() {
+    const localEntries = [...this.entries.values()];
+    const next = updateDurableJson(this.path, (current) => {
+      const merged = new Map((current?.entries ?? []).map((entry) => [entry.eventId, entry]));
+      for (const entry of localEntries) merged.set(entry.eventId, entry);
+      const entries = [...merged.values()].sort((a, b) => a.updatedAt - b.updatedAt || a.eventId.localeCompare(b.eventId));
+      if (entries.length > MAX_INBOUND_LEDGER_ENTRIES) {
+        const retained = entries.filter((entry) => entry.status !== "processed");
+        if (retained.length > MAX_INBOUND_LEDGER_ENTRIES) throw new InboundLedgerStateError("inbound ledger capacity exceeded");
+        return { version: 1, entries: retained };
+      }
+      return { version: 1, entries };
+    });
+    this.entries.clear();
+    for (const entry of next.entries) this.entries.set(entry.eventId, entry);
+  }
+  get(eventId) {
+    const entry = this.entries.get(eventId);
+    return entry ? { ...entry } : void 0;
+  }
+  ensure(accountId, chatId, message, now = Date.now()) {
+    const eventId = inboundEventId(accountId, chatId, message);
+    if (!this.entries.has(eventId)) {
+      this.entries.set(eventId, {
+        eventId,
+        chatId,
+        localId: message.localId,
+        messageKey: cursorMessageKey(message),
+        status: "pending",
+        attempts: 0,
+        createdAt: now,
+        updatedAt: now
+      });
+      this.persist();
+    }
+    return eventId;
+  }
+  shouldProcess(eventId, now = Date.now()) {
+    const entry = this.entries.get(eventId);
+    if (!entry || entry.status === "processed" || entry.status === "dead_letter") return false;
+    return entry.status !== "failed" || (entry.nextRetryAt ?? 0) <= now;
+  }
+  markProcessing(eventId, now = Date.now()) {
+    const entry = this.entries.get(eventId);
+    if (!entry || !this.shouldProcess(eventId, now)) return;
+    entry.status = "processing";
+    entry.attempts += 1;
+    entry.updatedAt = now;
+    entry.nextRetryAt = void 0;
+    this.persist();
+  }
+  markProcessed(eventId, outcome, now = Date.now()) {
+    const entry = this.entries.get(eventId);
+    if (!entry) return;
+    entry.status = "processed";
+    entry.outcome = outcome;
+    entry.updatedAt = now;
+    entry.nextRetryAt = void 0;
+    entry.lastErrorCode = void 0;
+    this.persist();
+  }
+  markFailed(eventId, errorCode, now = Date.now()) {
+    const entry = this.entries.get(eventId);
+    if (!entry) return;
+    entry.updatedAt = now;
+    entry.lastErrorCode = errorCode.slice(0, 128);
+    if (entry.attempts >= MAX_INBOUND_EVENT_ATTEMPTS) {
+      entry.status = "dead_letter";
+      entry.nextRetryAt = void 0;
+    } else {
+      entry.status = "failed";
+      entry.nextRetryAt = now + Math.min(MAX_INBOUND_RETRY_DELAY_MS, 1e3 * 2 ** Math.min(entry.attempts - 1, 6));
+    }
+    this.persist();
+  }
+  list(filter) {
+    return [...this.entries.values()].filter((entry) => (!filter?.chatId || entry.chatId === filter.chatId) && (!filter?.status || entry.status === filter.status) && (!filter?.since || entry.updatedAt >= filter.since)).sort((a, b) => b.updatedAt - a.updatedAt).map((entry) => ({ ...entry }));
+  }
+  markProcessedBatch(eventIds, outcome, now = Date.now()) {
+    for (const eventId of eventIds) this.markProcessed(eventId, outcome, now);
+  }
+  markFailedBatch(eventIds, errorCode, now = Date.now()) {
+    for (const eventId of eventIds) this.markFailed(eventId, errorCode, now);
+  }
+  replay(eventId, now = Date.now()) {
+    const entry = this.entries.get(eventId);
+    if (!entry || entry.status === "processed") return false;
+    entry.status = "pending";
+    entry.updatedAt = now;
+    entry.nextRetryAt = now;
+    entry.lastErrorCode = void 0;
+    this.persist();
+    return true;
+  }
+};
+function loadInboundEventLedger(accountId, stateDir) {
+  return new InboundEventLedger(accountId, stateDir);
+}
+
+// src/media-pipeline.ts
+import { createHash as createHash2 } from "node:crypto";
+import { closeSync as closeSync4, existsSync as existsSync4, fsyncSync as fsyncSync4, mkdirSync as mkdirSync4, openSync as openSync4, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname4, join as join3 } from "node:path";
+import sharp2 from "sharp";
+var MAX_MEDIA_PIPELINE_ENTRIES = 5e3;
+var MEDIA_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+function pipelinePath(accountId, stateDir) {
+  const root = stateDir ?? process.env.OPENCLAW_STATE_DIR?.trim() ?? join3(homedir3(), ".openclaw");
+  const safeAccount = accountId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return join3(root, "wechat", `media-pipeline-${safeAccount}.json`);
+}
+function syncFile(path) {
+  const fd = openSync4(path, "r");
+  try {
+    fsyncSync4(fd);
+  } finally {
+    closeSync4(fd);
+  }
+}
+function syncParent2(path) {
+  syncFile(dirname4(path));
+}
+function writeState(path, file) {
+  mkdirSync4(dirname4(path), { recursive: true, mode: 448 });
+  const temp = `${path}.tmp-${process.pid}`;
+  writeFileSync4(temp, JSON.stringify(file), { mode: 384 });
+  syncFile(temp);
+  renameSync4(temp, path);
+  syncParent2(path);
+}
+function validRecord2(value) {
+  if (!value || typeof value !== "object") return false;
+  const row = value;
+  return typeof row.hash === "string" && /^[a-f0-9]{64}$/.test(row.hash) && (row.status === "processed" || row.status === "failed") && typeof row.type === "string" && typeof row.mime === "string" && Array.isArray(row.stages) && row.stages.every((stage) => ["validated", "deduplicated", "original_saved", "preview_generated", "preview_failed", "extraction_skipped"].includes(String(stage))) && Array.isArray(row.bindings) && row.bindings.length <= 1e3 && row.bindings.every((binding) => {
+    if (!binding || typeof binding !== "object") return false;
+    const item = binding;
+    return typeof item.eventId === "string" && /^[a-f0-9]{64}$/.test(item.eventId) && typeof item.chatId === "string" && item.chatId.length > 0 && item.chatId.length <= 512 && Number.isSafeInteger(item.localId) && typeof item.observedAt === "number" && Number.isFinite(item.observedAt);
+  }) && (row.extraction === "not_configured" || row.extraction === "not_applicable") && typeof row.createdAt === "number" && Number.isFinite(row.createdAt) && typeof row.updatedAt === "number" && Number.isFinite(row.updatedAt);
+}
+function readState(path) {
+  if (!existsSync4(path)) return { version: 1, entries: [] };
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries) || parsed.entries.length > MAX_MEDIA_PIPELINE_ENTRIES || !parsed.entries.every(validRecord2)) throw new Error("invalid media pipeline state");
+    return { version: 1, entries: parsed.entries };
+  } catch (error) {
+    throw new Error(`media pipeline state is invalid: ${String(error)}`);
+  }
+}
+function safeFilename(raw) {
+  const base = raw.replace(/\\/g, "/").split("/").pop() ?? "attachment";
+  const cleaned = [...base].filter((char) => char >= " " && char !== "\x7F").join("").trim();
+  return (cleaned || "attachment").slice(0, 180);
+}
+function previewFilename(filename) {
+  const base = safeFilename(filename).replace(/\.[^.]+$/, "");
+  return `${base || "attachment"}.preview.jpg`;
+}
+var MediaPipeline = class {
+  path;
+  entries = /* @__PURE__ */ new Map();
+  constructor(accountId, stateDir) {
+    this.path = pipelinePath(accountId, stateDir);
+    for (const entry of readState(this.path).entries) this.entries.set(entry.hash, entry);
+  }
+  persist() {
+    const entries = [...this.entries.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    if (entries.length > MAX_MEDIA_PIPELINE_ENTRIES) entries.splice(MAX_MEDIA_PIPELINE_ENTRIES);
+    this.entries.clear();
+    for (const entry of entries) this.entries.set(entry.hash, entry);
+    writeState(this.path, { version: 1, entries });
+  }
+  async removePath(removeMedia, path) {
+    if (!removeMedia || !path) return false;
+    try {
+      await removeMedia(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  copy(row) {
+    return { ...row, stages: [...row.stages], bindings: row.bindings.map((binding) => ({ ...binding })) };
+  }
+  get(hash) {
+    const row = this.entries.get(hash);
+    return row ? this.copy(row) : void 0;
+  }
+  getByEventId(eventId) {
+    const row = [...this.entries.values()].find((entry) => entry.bindings.some((binding) => binding.eventId === eventId));
+    return row ? this.copy(row) : void 0;
+  }
+  list() {
+    return [...this.entries.values()].map((row) => this.copy(row));
+  }
+  async cleanup(options) {
+    const cutoff = (options.now ?? Date.now()) - Math.max(0, options.olderThanMs);
+    const expired = [...this.entries.values()].filter((entry) => entry.updatedAt < cutoff && (entry.originalPath !== void 0 || entry.previewPath !== void 0));
+    let changed = 0;
+    for (const entry of expired) {
+      const originalRemoved = await this.removePath(options.remove, entry.originalPath);
+      const previewRemoved = await this.removePath(options.remove, entry.previewPath);
+      if (originalRemoved) entry.originalPath = void 0;
+      if (previewRemoved) entry.previewPath = void 0;
+      if (originalRemoved || previewRemoved) {
+        entry.updatedAt = options.now ?? Date.now();
+        changed += 1;
+      }
+    }
+    if (changed > 0) this.persist();
+    return changed;
+  }
+  async process(result, binding, saveOriginal, savePreview, removeMedia, now = Date.now()) {
+    const validated = await validateInboundMedia(result);
+    if (!validated.ok) return validated;
+    const { buffer, mime } = validated.value;
+    const hash = createHash2("sha256").update(buffer).digest("hex");
+    const existing = this.entries.get(hash);
+    const observedBinding = { ...binding, observedAt: now };
+    if (existing?.status === "processed" && existing.originalPath) {
+      if (!existing.bindings.some((item) => item.eventId === binding.eventId)) {
+        existing.bindings.push(observedBinding);
+        if (existing.bindings.length > 1e3) existing.bindings.shift();
+        existing.updatedAt = now;
+        this.persist();
+      }
+      return { ok: true, hash, mime: existing.mime, originalPath: existing.originalPath, previewPath: existing.previewPath, record: this.copy(existing) };
+    }
+    const record = {
+      hash,
+      status: "failed",
+      type: result.type,
+      mime,
+      stages: ["validated", "deduplicated"],
+      extraction: result.type === "image" || result.type === "file" ? "not_configured" : "not_applicable",
+      bindings: [...(existing?.bindings ?? []).filter((item) => item.eventId !== binding.eventId), observedBinding].slice(-1e3),
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    };
+    const original = await saveOriginal(buffer, mime, safeFilename(result.filename));
+    if (!original?.path?.trim()) {
+      record.errorCode = "MEDIA_SAVE_FAILED";
+      this.entries.set(hash, record);
+      this.persist();
+      return { ok: false, code: "MEDIA_SAVE_FAILED" };
+    }
+    record.originalPath = original.path;
+    record.stages.push("original_saved");
+    if (result.type === "image") {
+      if (!savePreview) {
+        if (await this.removePath(removeMedia, record.originalPath)) record.originalPath = void 0;
+        record.errorCode = "MEDIA_PREVIEW_FAILED";
+        record.stages.push("preview_failed");
+        this.entries.set(hash, record);
+        this.persist();
+        return { ok: false, code: "MEDIA_PREVIEW_FAILED" };
+      }
+      try {
+        const preview = await sharp2(buffer, { failOn: "warning", limitInputPixels: 4e7 }).rotate().resize({ width: 1024, height: 1024, fit: "inside", withoutEnlargement: true }).jpeg({ quality: 82, progressive: true }).toBuffer();
+        const savedPreview = await savePreview(preview, "image/jpeg", previewFilename(result.filename));
+        if (!savedPreview?.path?.trim()) throw new Error("preview save returned no path");
+        record.previewPath = savedPreview.path;
+        record.stages.push("preview_generated");
+      } catch {
+        if (await this.removePath(removeMedia, record.originalPath)) record.originalPath = void 0;
+        if (await this.removePath(removeMedia, record.previewPath)) record.previewPath = void 0;
+        record.errorCode = "MEDIA_PREVIEW_FAILED";
+        record.stages.push("preview_failed");
+        this.entries.set(hash, record);
+        this.persist();
+        return { ok: false, code: "MEDIA_PREVIEW_FAILED" };
+      }
+    }
+    record.stages.push("extraction_skipped");
+    record.status = "processed";
+    record.updatedAt = now;
+    this.entries.set(hash, record);
+    this.persist();
+    return { ok: true, hash, mime, originalPath: original.path, previewPath: record.previewPath, record: this.copy(record) };
+  }
+};
+function loadMediaPipeline(accountId, stateDir) {
+  return new MediaPipeline(accountId, stateDir);
+}
+
+// src/newsapp.ts
+var NEWSAPP_USERNAME = "newsapp";
+var MAX_NEWSAPP_PREVIEW_CHARS = 4e3;
+function isNewsappChat(chat) {
+  return (chat.username || chat.id) === NEWSAPP_USERNAME;
+}
+var URL_RE = /https?:\/\/[^\s<>，。；！？）】》]+/gi;
+function extractNewsappUrls(text) {
+  return [...new Set(text.match(URL_RE) ?? [])].map(
+    (url) => url.replace(/[),.;!?，。；！？）】》]+$/u, "")
+  );
+}
+function newsappFallbackMessage(chat) {
+  const rawPreview = chat.lastMessagePreview?.trim();
+  const preview = rawPreview?.slice(0, MAX_NEWSAPP_PREVIEW_CHARS);
+  const localId = chat.lastMsgLocalId;
+  if (!preview || typeof localId !== "number" || !Number.isSafeInteger(localId) || localId <= 0) return null;
+  const urls = extractNewsappUrls(preview);
+  const urlBlock = urls.length > 0 ? `
+Links:
+${urls.join("\n")}` : "";
+  return {
+    localId,
+    serverId: localId,
+    chatId: chat.username || chat.id,
+    type: 1,
+    content: `[Tencent News]
+${preview}${urlBlock}`,
+    timestamp: chat.lastActivityAt || `1970-01-01T00:00:${String(localId % 60).padStart(2, "0")}.000Z`,
+    sender: NEWSAPP_USERNAME,
+    senderName: "\u817E\u8BAF\u65B0\u95FB"
+  };
+}
+function shouldBypassNewsappAuthorization(chat) {
+  return isNewsappChat(chat);
 }
 
 // src/monitor.ts
@@ -6695,6 +7426,15 @@ async function startWeChatMonitor(opts) {
   const startupBaselines = /* @__PURE__ */ new Map();
   const chatScanState = { initialScanComplete: false };
   const pendingMessageScans = loadPendingResetRetries(account.accountId);
+  const inboundLedger = loadInboundEventLedger(account.accountId);
+  const mediaPipeline = loadMediaPipeline(account.accountId);
+  const cleanupMedia = async () => {
+    await mediaPipeline.cleanup({
+      olderThanMs: MEDIA_RETENTION_MS,
+      remove: async (path) => unlink(path)
+    }).catch((err) => log?.error?.(`[wechat:${account.accountId}] Media cleanup failed: ${err}`));
+  };
+  let lastMediaCleanup = 0;
   for (const [chatId, pending] of pendingMessageScans) {
     const cursor = pending.messages.reduce(
       (max, message) => Math.max(max, message.localId),
@@ -6708,6 +7448,7 @@ async function startWeChatMonitor(opts) {
     persist: () => persistPendingResetRetries(account.accountId, pendingMessageScans)
   };
   trimPendingResetRetries(retryState);
+  const newsappHandled = /* @__PURE__ */ new Map();
   const groupHistory = /* @__PURE__ */ new Map();
   const GROUP_HISTORY_LIMIT = 50;
   let lastAuthCheck = 0;
@@ -6724,6 +7465,10 @@ async function startWeChatMonitor(opts) {
     try {
       const cfg = getWeChatRuntime().config.current();
       const now = Date.now();
+      if (now - lastMediaCleanup >= MEDIA_RETENTION_MS / 4) {
+        lastMediaCleanup = now;
+        await cleanupMedia();
+      }
       if (now - lastAuthCheck >= account.authPollIntervalMs) {
         lastAuthCheck = now;
         try {
@@ -6810,9 +7555,15 @@ async function startWeChatMonitor(opts) {
           startupBaselines.set(chatId, { localId: 0 });
         }
       }
-      const chatsToProcess = monitorChatsToProcess(chats, retryState);
+      const chatsToProcess = monitorChatsToProcess(
+        chats,
+        retryState,
+        Date.now(),
+        (chat) => !isNewsappChat(chat) || newsappHandled.get(chat.username ?? chat.id) !== `${chat.lastMsgLocalId ?? ""}:${chat.lastMessagePreview?.trim() ?? ""}`
+      );
       for (const chatId of chatsToProcess.keys()) {
-        if (isOfficialAccount(chatId)) chatsToProcess.delete(chatId);
+        if (isOfficialAccount(chatId) && chatId !== "newsapp")
+          chatsToProcess.delete(chatId);
       }
       if (unreadChats.length > 0) {
         log?.info?.(
@@ -6832,6 +7583,8 @@ async function startWeChatMonitor(opts) {
             startupBaselines,
             pendingMessageScans,
             retryState.persist,
+            inboundLedger,
+            mediaPipeline,
             account,
             cfg,
             log,
@@ -6851,6 +7604,12 @@ async function startWeChatMonitor(opts) {
           if (result === "deferred") {
             deferredThisTick += 1;
           }
+          if (isNewsappChat(chat) && result !== "deferred") {
+            newsappHandled.set(
+              chat.username ?? chat.id,
+              `${chat.lastMsgLocalId ?? ""}:${chat.lastMessagePreview?.trim() ?? ""}`
+            );
+          }
         }
       }
       for (const chat of chats) {
@@ -6872,6 +7631,8 @@ async function startWeChatMonitor(opts) {
           startupBaselines,
           pendingMessageScans,
           retryState.persist,
+          inboundLedger,
+          mediaPipeline,
           account,
           cfg,
           log,
@@ -6909,13 +7670,14 @@ async function startWeChatMonitor(opts) {
     }
     await sleep(account.pollIntervalMs, abortSignal);
   }
+  await cleanupMedia();
   setStatus({
     accountId: account.accountId,
     running: false,
     connected: false
   });
 }
-async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, log) {
+async function prepareMessage(client, mediaPipeline, msg, chatId, chat, liveAccount, policy, log) {
   const core = getWeChatRuntime();
   if (msg.isSelf) {
     log?.info?.(`[wechat:${liveAccount.accountId}] Skipping self-sent msg ${msg.localId}`);
@@ -6925,7 +7687,7 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, lo
   const senderId = msg.sender ?? chatId;
   const senderName = msg.senderName ?? msg.sender ?? chat.name;
   const wasMentioned = isGroup && msg.isMentioned === true;
-  const access = resolveWeChatInboundAccessDecision({
+  const access = shouldBypassNewsappAuthorization(chat) ? { allowed: true, reason: "newsapp-system-feed" } : resolveWeChatInboundAccessDecision({
     isGroup,
     senderId,
     policy
@@ -6938,6 +7700,10 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, lo
   }
   let mediaPath;
   let mediaMime;
+  let mediaHash;
+  let mediaPreviewPath;
+  let mediaSource;
+  let mediaErrorCode;
   let hasMedia = false;
   const baseType = msg.type & 2147483647;
   const mayHaveMedia = MEDIA_TYPES.has(baseType) || baseType === 49;
@@ -6947,23 +7713,33 @@ 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;
+        mediaSource = result.source;
         log?.info?.(`[wechat:media] inbound media received type=${result.type} format=${result.format}`);
-        const saved = await saveValidatedInboundMedia(
+        const saved = await mediaPipeline.process(
           result,
-          async (buffer, mime, filename) => core.channel.media.saveMediaBuffer(buffer, mime, "inbound", void 0, filename)
+          { eventId: inboundEventId(liveAccount.accountId, chatId, msg), chatId, localId: msg.localId },
+          async (buffer, mime, filename) => core.channel.media.saveMediaBuffer(buffer, mime, "inbound", void 0, filename),
+          async (buffer, mime, filename) => core.channel.media.saveMediaBuffer(buffer, mime, "inbound", void 0, filename),
+          async (path) => unlink(path)
         );
         if (!saved.ok) {
+          mediaErrorCode = saved.code;
           log?.error?.(`[wechat:media] inbound media rejected code=${saved.code}`);
         } else {
           mediaMime = saved.mime;
-          mediaPath = saved.path;
-          log?.info?.("[wechat:media] inbound media saved");
+          mediaPath = saved.originalPath;
+          mediaHash = saved.hash;
+          mediaPreviewPath = saved.previewPath;
+          log?.info?.(`[wechat:media] inbound media saved hash=${saved.hash}${saved.previewPath ? " preview=present" : ""}`);
         }
-      } else if (MEDIA_TYPES.has(baseType)) {
+      } else if (result?.errorCode || result && result.type !== "unsupported" || MEDIA_TYPES.has(baseType)) {
         hasMedia = true;
-        log?.info?.("[wechat:media] inbound media unavailable after retries");
+        mediaErrorCode = result?.errorCode ?? "MEDIA_DOWNLOAD_UNAVAILABLE";
+        log?.info?.(`[wechat:media] inbound media unavailable code=${mediaErrorCode}`);
       }
     } catch (err) {
+      hasMedia = true;
+      mediaErrorCode = "MEDIA_DOWNLOAD_FAILED";
       log?.error?.("[wechat:media] inbound media failed code=MEDIA_DOWNLOAD_FAILED");
     }
   }
@@ -6981,12 +7757,22 @@ async function prepareMessage(client, msg, chatId, chat, liveAccount, policy, lo
     } else if (!mediaMime.startsWith("image/") && !mediaMime.startsWith("audio/")) {
       rawBody = `[File: ${rawBody}]`;
     }
+  } else if (mediaErrorCode && baseType === 49) {
+    const text = msg.content || "File attachment";
+    rawBody = `${text}
+[Attachment unavailable: ${mediaErrorCode}]`;
+  }
+  if (mediaSource === "thumbnail") {
+    rawBody = rawBody ? `${rawBody}
+[Image source: thumbnail]` : "[Image source: thumbnail]";
   }
   if (msg.reply) {
     const replySender = msg.reply.sender ?? "unknown sender";
     const quotedBody = msg.reply.content.length > 50 ? msg.reply.content.slice(0, 50) + "..." : msg.reply.content;
+    const replyMedia = msg.reply.mediaErrorCode ? `
+[Quoted attachment unavailable: ${msg.reply.mediaErrorCode}]` : "";
     const replyBlock = `[Replying to ${replySender}]
-${quotedBody}
+${quotedBody}${replyMedia}
 [/Replying]`;
     rawBody = rawBody ? `${rawBody}
 
@@ -7001,6 +7787,8 @@ ${replyBlock}` : replyBlock;
     }),
     mediaPath,
     mediaMime,
+    mediaHash,
+    mediaPreviewPath,
     senderName,
     senderId,
     isGroup,
@@ -7163,7 +7951,19 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
       CommandAuthorized: commandAuthorized,
       OriginatingChannel: OPENCLAW_CHANNEL_ID,
       OriginatingTo: `${OPENCLAW_CHANNEL_ID}:${chatId}`,
-      ...mediaPath ? { MediaPath: mediaPath, MediaUrl: mediaPath, MediaType: mediaMime } : {},
+      ...mediaPath ? {
+        // The runtime media consumers read the plural attachment contract. Keep
+        // the legacy singular aliases for older runtimes, but always populate
+        // both forms for downloaded inbound media.
+        MediaPath: mediaPath,
+        MediaUrl: mediaPath,
+        MediaType: mediaMime,
+        MediaPaths: [mediaPath],
+        MediaUrls: [mediaPath],
+        MediaTypes: mediaMime ? [mediaMime] : [],
+        ...mediaMsg?.mediaHash ? { MediaHash: mediaMsg.mediaHash } : {},
+        ...mediaMsg?.mediaPreviewPath ? { MediaPreviewPath: mediaMsg.mediaPreviewPath } : {}
+      } : {},
       ...msg.reply ? {
         ReplyToBody: msg.reply.content.length > 50 ? msg.reply.content.slice(0, 50) + "..." : msg.reply.content,
         ReplyToSender: msg.reply.sender
@@ -7201,7 +8001,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
             payload.text ?? "",
             tableMode
           );
-          if (mediaList.length > 0) {
+          if (mediaList.length > 0 && !isNewsappChat(chat)) {
             const media = [];
             for (const mediaUrl of mediaList) {
               const fsmod = await import("fs/promises");
@@ -7242,7 +8042,7 @@ async function dispatchSegment(segment, client, chatId, chat, liveAccount, polic
               inboundChars: lastMsg.rawBody.length,
               source: "openclaw"
             });
-          } else if (text) {
+          } else if (text && !isNewsappChat(chat)) {
             const result = await client.sendMessage({
               chatId,
               text,
@@ -7289,7 +8089,7 @@ function bufferGroupHistory(groupHistory, chatId, pm, limit) {
     if (first) groupHistory.delete(first);
   }
 }
-async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHandled, startupBaselines, pendingMessageScans, persistRetryState, account, cfg, log, skipOpen, groupHistory, groupHistoryLimit, catchup) {
+async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHandled, startupBaselines, pendingMessageScans, persistRetryState, inboundLedger, mediaPipeline, account, cfg, log, skipOpen, groupHistory, groupHistoryLimit, catchup) {
   const core = getWeChatRuntime();
   const liveAccount = resolveWeChatAccount(cfg, account.accountId) ?? account;
   const chatId = chat.username ?? chat.id;
@@ -7374,12 +8174,22 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
   log?.info?.(
     `[wechat:${liveAccount.accountId}] ${chatId}: fetched ${messages.length} msgs, firstPoll=${firstPoll}, prevLastSeen=${prevLastSeen}, unreadCount=${chat.unreadCount}`
   );
+  if (messages.length === 0 && isNewsappChat(chat)) {
+    const fallback = newsappFallbackMessage(chat);
+    if (fallback) messages = [fallback];
+  }
   if (messages.length === 0) return "skipped";
   const enrichedBaseline = enrichStartupBaselineFromMessages(startupBaseline, messages);
   if (enrichedBaseline) {
     startupBaselines.set(chatId, enrichedBaseline);
   }
-  const selected = selectCursorMessages(
+  const selected = isNewsappChat(chat) ? {
+    firstPoll,
+    prevLastSeen,
+    messages,
+    seedLastSeen: void 0,
+    generationReset: false
+  } : selectCursorMessages(
     chatId,
     chat,
     messages,
@@ -7430,17 +8240,17 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
         chatId
       );
     }
-    if (chat.unreadCount > 0) {
+    if (chat.unreadCount > 0 && !isNewsappChat(chat)) {
       await openChatIfNeeded();
     }
     return "skipped";
   }
-  await openChatIfNeeded();
+  if (!isNewsappChat(chat)) await openChatIfNeeded();
   const catchUpLimits = {
     maxMessages: liveAccount.catchUpMaxMessages,
     maxAgeMs: liveAccount.catchUpMaxAgeMs
   };
-  const isRecovery = firstPoll && startupBaseline === void 0 || skipOpen === true && isCatchUpBatch(newMessages, catchUpLimits);
+  const isRecovery = !isNewsappChat(chat) && (firstPoll && startupBaseline === void 0 || skipOpen === true && isCatchUpBatch(newMessages, catchUpLimits));
   if (isRecovery) {
     const selection = selectCatchUpMessages(
       newMessages,
@@ -7473,13 +8283,20 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
     `[wechat:${liveAccount.accountId}] ${chatId}: ${newMessages.length} new msg(s) to process`
   );
   const processed = [];
+  const eventIds = [];
   for (const msg of newMessages) {
+    const eventId = inboundLedger.ensure(account.accountId, chatId, msg);
+    if (!inboundLedger.shouldProcess(eventId)) continue;
+    inboundLedger.markProcessing(eventId);
+    eventIds.push(eventId);
     log?.info?.(
       `[wechat:${liveAccount.accountId}] Processing msg ${msg.localId}: type=${msg.type}, sender=${msg.sender}, isSelf=${msg.isSelf}, content=${(msg.content || "").slice(0, 50)}`
     );
-    const pm = await prepareMessage(client, msg, chatId, chat, liveAccount, policy, log);
+    const pm = await prepareMessage(client, mediaPipeline, msg, chatId, chat, liveAccount, policy, log);
     if (pm) {
       processed.push(pm);
+    } else {
+      inboundLedger.markProcessed(eventId, "filtered");
     }
   }
   const isGroup = chatId.includes("@chatroom");
@@ -7496,6 +8313,7 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
         log?.info?.(`[wechat:${liveAccount.accountId}] Buffered ${processed.length} msg(s) for group history in ${chatId}`);
         const maxId2 = Math.max(...newMessages.map((m) => m.localId));
         advanceLastSeen(newMessages.filter((message) => message.localId <= maxId2));
+        for (const eventId of eventIds) inboundLedger.markProcessed(eventId, "buffered");
         return "skipped";
       }
       if (hasMention) {
@@ -7562,6 +8380,7 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
       );
       const maxId2 = Math.max(...newMessages.map((m) => m.localId));
       advanceLastSeen(newMessages.filter((message) => message.localId <= maxId2));
+      for (const eventId of eventIds) inboundLedger.markProcessed(eventId, "stale");
       return "skipped";
     }
     const fold = shouldFoldSegments(catchup?.isReconnect ?? false) && !hasControlCommandInWindow;
@@ -7571,6 +8390,13 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
     );
     let allDispatched = true;
     const successfulSegmentLastLocalIds = [];
+    const segmentEventIds = (segment) => {
+      const keys = new Set(segment.map((pm) => pm.msg.localId));
+      return eventIds.filter((eventId) => {
+        const record = inboundLedger.get(eventId);
+        return record !== void 0 && keys.has(record.localId);
+      });
+    };
     for (let i = 0; i < segments.length; i++) {
       const remaining = segments.length - i - 1;
       const dispatched = await dispatchSegment(
@@ -7588,12 +8414,19 @@ async function processUnreadChat(client, chat, lastSeenId, equalCursorUnreadHand
       );
       if (!dispatched) {
         allDispatched = false;
+        inboundLedger.markFailedBatch(segmentEventIds(segments[i]), "DISPATCH_FAILED");
+        const remainingIds = segments.slice(i + 1).flatMap(segmentEventIds);
+        inboundLedger.markFailedBatch(remainingIds, "DISPATCH_NOT_ATTEMPTED");
         break;
       }
+      inboundLedger.markProcessedBatch(segmentEventIds(segments[i]), "dispatched");
       successfulSegmentLastLocalIds.push(
         Math.max(...segments[i].map((pm) => pm.msg.localId))
       );
     }
+    if (allDispatched) {
+      for (const eventId of eventIds) inboundLedger.markProcessed(eventId, "dispatched");
+    }
     if (clearBufferedHistory && allDispatched && groupHistory) {
       groupHistory.set(chatId, []);
     }
@@ -7854,6 +8687,14 @@ function buildOpenClawConfirmedSend(params) {
   };
 }
 
+// src/group-members-consent.ts
+function hasExplicitGroupMemberConsent(params) {
+  return params.confirmed === true;
+}
+function groupMemberErrorCode(error) {
+  return error instanceof WeChatHttpError && error.errorCode ? error.errorCode : "GROUP_MEMBERS_FAILED";
+}
+
 // src/agent-tools.ts
 function createWeChatConfirmedSendTool(account) {
   const client = new WeChatClient({
@@ -7901,6 +8742,52 @@ function createWeChatConfirmedSendTool(account) {
     }
   };
 }
+function createWeChatGroupMembersTool(account) {
+  const client = new WeChatClient({ baseUrl: account.serverUrl, token: account.token });
+  return {
+    label: "WeChat Group Members",
+    name: "wechat_group_members",
+    description: "Read one bounded page of group members by stable group id. This returns personal information; call only when the user explicitly asks for a specific group, and do not echo more fields than needed.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        groupId: { type: "string", description: "Stable group id ending in @chatroom" },
+        limit: { type: "number", minimum: 1, maximum: 50 },
+        cursor: { type: "string" },
+        confirmed: { type: "boolean", description: "Must be true after the user explicitly requests this group's personal member data." }
+      },
+      required: ["groupId", "confirmed"]
+    },
+    execute: async (_toolCallId, params) => {
+      const args = params;
+      const groupId = String(args.groupId ?? "").trim();
+      if (!hasExplicitGroupMemberConsent(args)) {
+        return {
+          content: [{ type: "text", text: "Explicit user confirmation is required before reading group member personal data." }],
+          details: { success: false, errorCode: "EXPLICIT_CONFIRMATION_REQUIRED" }
+        };
+      }
+      const limit = typeof args.limit === "number" ? Math.trunc(args.limit) : 25;
+      try {
+        const page = await client.listGroupMembersPage(
+          groupId,
+          Math.min(50, Math.max(1, limit)),
+          typeof args.cursor === "string" ? args.cursor : void 0
+        );
+        return {
+          content: [{ type: "text", text: `Retrieved ${page.items.length} group member(s).` }],
+          details: page
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: "Group member lookup failed." }],
+          details: { error: true, code: groupMemberErrorCode(error) }
+        };
+      }
+    }
+  };
+}
 function createWeChatLoginTool(account) {
   const client = new WeChatClient({
     baseUrl: account.serverUrl,
@@ -8434,7 +9321,11 @@ Error: ${event.message}`);
   agentTools: (({ cfg }) => {
     const account = resolveWeChatAccount(cfg);
     if (!account?.serverUrl) return [];
-    return [createWeChatLoginTool(account), createWeChatConfirmedSendTool(account)];
+    return [
+      createWeChatLoginTool(account),
+      createWeChatConfirmedSendTool(account),
+      createWeChatGroupMembersTool(account)
+    ];
   }),
   // ---- Directory adapter ----
   directory: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kyan-du/agent-wechat-openclaw",
-  "version": "0.13.3",
+  "version": "0.14.0",
   "type": "module",
   "files": [
     "dist",