fengming 0.3.4 → 0.3.5

package/dist/send-media-cOciBxcg.js

@@ -0,0 +1,2072 @@
+import { n as resolvePreferredFengMingTmpDir } from "./tmp-fengming-dir-0p6iJKE-.js";
+import { n as normalizeAccountId } from "./account-id-B0YIFDpA.js";
+import { t as getGlobalHookRunner, u as fireAndForgetHook } from "./hook-runner-global-lWQvOg8l.js";
+import { d as toPluginMessageSentEvent, l as toPluginMessageContext, t as buildCanonicalSentMessageHookContext } from "./message-hook-mappers-Lw-1gD5K.js";
+import "./infra-runtime-BFrpRc_V.js";
+import "./plugin-runtime-B3XMLJka.js";
+import "./hook-runtime-Djc3mfS0.js";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import crypto, { createCipheriv, createDecipheriv } from "node:crypto";
+//#region extensions/weixin/src/storage/state-dir.ts
+/** Resolve the OpenClaw state directory (mirrors core logic in src/infra). */
+function resolveStateDir() {
+	return process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path.join(os.homedir(), ".openclaw");
+}
+//#endregion
+//#region extensions/weixin/src/util/logger.ts
+/**
+* Plugin logger — writes JSON lines to the main openclaw log file:
+*   <tmpDir>/openclaw-YYYY-MM-DD.log
+* Same file and format used by all other channels.
+*/
+const MAIN_LOG_DIR = resolvePreferredFengMingTmpDir();
+const SUBSYSTEM = "gateway/channels/openclaw-weixin";
+const RUNTIME = "node";
+const RUNTIME_VERSION = process.versions.node;
+const HOSTNAME = os.hostname() || "unknown";
+const PARENT_NAMES = ["openclaw"];
+/** tslog-compatible level IDs (higher = more severe). */
+const LEVEL_IDS = {
+	TRACE: 1,
+	DEBUG: 2,
+	INFO: 3,
+	WARN: 4,
+	ERROR: 5,
+	FATAL: 6
+};
+const DEFAULT_LOG_LEVEL = "INFO";
+function resolveMinLevel() {
+	const env = process.env.OPENCLAW_LOG_LEVEL?.toUpperCase();
+	if (env && env in LEVEL_IDS) return LEVEL_IDS[env];
+	return LEVEL_IDS[DEFAULT_LOG_LEVEL];
+}
+let minLevelId = resolveMinLevel();
+/** Shift a Date into local time so toISOString() renders local clock digits. */
+function toLocalISO(now) {
+	const offsetMs = -now.getTimezoneOffset() * 6e4;
+	const sign = offsetMs >= 0 ? "+" : "-";
+	const abs = Math.abs(now.getTimezoneOffset());
+	const offStr = `${sign}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`;
+	return new Date(now.getTime() + offsetMs).toISOString().replace("Z", offStr);
+}
+function localDateKey(now) {
+	return toLocalISO(now).slice(0, 10);
+}
+function resolveMainLogPath() {
+	const dateKey = localDateKey(/* @__PURE__ */ new Date());
+	return path.join(MAIN_LOG_DIR, `openclaw-${dateKey}.log`);
+}
+let logDirEnsured = false;
+function buildLoggerName(accountId) {
+	return accountId ? `${SUBSYSTEM}/${accountId}` : SUBSYSTEM;
+}
+function writeLog(level, message, accountId) {
+	if ((LEVEL_IDS[level] ?? LEVEL_IDS.INFO) < minLevelId) return;
+	const now = /* @__PURE__ */ new Date();
+	const loggerName = buildLoggerName(accountId);
+	const prefixedMessage = accountId ? `[${accountId}] ${message}` : message;
+	const entry = JSON.stringify({
+		"0": loggerName,
+		"1": prefixedMessage,
+		_meta: {
+			runtime: RUNTIME,
+			runtimeVersion: RUNTIME_VERSION,
+			hostname: HOSTNAME,
+			name: loggerName,
+			parentNames: PARENT_NAMES,
+			date: now.toISOString(),
+			logLevelId: LEVEL_IDS[level] ?? LEVEL_IDS.INFO,
+			logLevelName: level
+		},
+		time: toLocalISO(now)
+	});
+	try {
+		if (!logDirEnsured) {
+			fs.mkdirSync(MAIN_LOG_DIR, { recursive: true });
+			logDirEnsured = true;
+		}
+		fs.appendFileSync(resolveMainLogPath(), `${entry}\n`, "utf-8");
+	} catch {}
+}
+/** Creates a logger instance, optionally bound to a specific account. */
+function createLogger(accountId) {
+	return {
+		info(message) {
+			writeLog("INFO", message, accountId);
+		},
+		debug(message) {
+			writeLog("DEBUG", message, accountId);
+		},
+		warn(message) {
+			writeLog("WARN", message, accountId);
+		},
+		error(message) {
+			writeLog("ERROR", message, accountId);
+		},
+		withAccount(id) {
+			return createLogger(id);
+		},
+		getLogFilePath() {
+			return resolveMainLogPath();
+		},
+		close() {}
+	};
+}
+const logger = createLogger();
+//#endregion
+//#region extensions/weixin/src/auth/pairing.ts
+/**
+* Resolve the framework credentials directory (mirrors core resolveOAuthDir).
+* Path: $OPENCLAW_OAUTH_DIR || $OPENCLAW_STATE_DIR/credentials || ~/.openclaw/credentials
+*/
+function resolveCredentialsDir() {
+	const override = process.env.OPENCLAW_OAUTH_DIR?.trim();
+	if (override) return override;
+	return path.join(resolveStateDir(), "credentials");
+}
+/**
+* Sanitize a channel/account key for safe use in filenames (mirrors core safeChannelKey).
+*/
+function safeKey(raw) {
+	const trimmed = raw.trim().toLowerCase();
+	if (!trimmed) throw new Error("invalid key for allowFrom path");
+	const safe = trimmed.replace(/[\\/:*?"<>|]/g, "_").replace(/\.\./g, "_");
+	if (!safe || safe === "_") throw new Error("invalid key for allowFrom path");
+	return safe;
+}
+/**
+* Resolve the framework allowFrom file path for a given account.
+* Mirrors: `resolveAllowFromPath(channel, env, accountId)` from core.
+* Path: `<credDir>/openclaw-weixin-<accountId>-allowFrom.json`
+*/
+function resolveFrameworkAllowFromPath(accountId) {
+	const base = safeKey("openclaw-weixin");
+	const safeAccount = safeKey(accountId);
+	return path.join(resolveCredentialsDir(), `${base}-${safeAccount}-allowFrom.json`);
+}
+/**
+* Read the framework allowFrom list for an account (user IDs authorized via pairing).
+* Returns an empty array when the file is missing or unreadable.
+*/
+function readFrameworkAllowFromList(accountId) {
+	const filePath = resolveFrameworkAllowFromPath(accountId);
+	try {
+		if (!fs.existsSync(filePath)) return [];
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed.allowFrom)) return parsed.allowFrom.filter((id) => typeof id === "string" && id.trim() !== "");
+	} catch {}
+	return [];
+}
+//#endregion
+//#region extensions/weixin/src/auth/accounts.ts
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+/**
+* Pattern-based reverse of normalizeWeixinAccountId for known weixin ID suffixes.
+* Used only as a compatibility fallback when loading accounts / sync bufs stored
+* under the old raw ID.
+* e.g. "b0f5860fdecb-im-bot" → "b0f5860fdecb@im.bot"
+*/
+function deriveRawAccountId(normalizedId) {
+	if (normalizedId.endsWith("-im-bot")) return `${normalizedId.slice(0, -7)}@im.bot`;
+	if (normalizedId.endsWith("-im-wechat")) return `${normalizedId.slice(0, -10)}@im.wechat`;
+}
+function resolveWeixinStateDir() {
+	return path.join(resolveStateDir(), "openclaw-weixin");
+}
+function resolveAccountIndexPath() {
+	return path.join(resolveWeixinStateDir(), "accounts.json");
+}
+/** Returns all accountIds registered via QR login. */
+function listIndexedWeixinAccountIds() {
+	const filePath = resolveAccountIndexPath();
+	try {
+		if (!fs.existsSync(filePath)) return [];
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.filter((id) => typeof id === "string" && id.trim() !== "");
+	} catch {
+		return [];
+	}
+}
+/** Add accountId to the persistent index (no-op if already present). */
+function registerWeixinAccountId(accountId) {
+	const dir = resolveWeixinStateDir();
+	fs.mkdirSync(dir, { recursive: true });
+	const existing = listIndexedWeixinAccountIds();
+	if (existing.includes(accountId)) return;
+	const updated = [...existing, accountId];
+	fs.writeFileSync(resolveAccountIndexPath(), JSON.stringify(updated, null, 2), "utf-8");
+}
+/** Remove accountId from the persistent index. */
+function unregisterWeixinAccountId(accountId) {
+	const existing = listIndexedWeixinAccountIds();
+	const updated = existing.filter((id) => id !== accountId);
+	if (updated.length !== existing.length) fs.writeFileSync(resolveAccountIndexPath(), JSON.stringify(updated, null, 2), "utf-8");
+}
+/**
+* Remove stale accounts that share the same userId as the newly-bound account.
+* Called after a successful QR login to ensure only the latest account remains
+* for a given WeChat user, preventing ambiguous contextToken matches.
+*
+* @param onClearContextTokens callback to clear context tokens for the removed account
+*/
+function clearStaleAccountsForUserId(currentAccountId, userId, onClearContextTokens) {
+	if (!userId) return;
+	const allIds = listIndexedWeixinAccountIds();
+	for (const id of allIds) {
+		if (id === currentAccountId) continue;
+		if (loadWeixinAccount(id)?.userId?.trim() === userId) {
+			logger.info(`clearStaleAccountsForUserId: removing stale account=${id} (same userId=${userId})`);
+			onClearContextTokens?.(id);
+			clearWeixinAccount(id);
+			unregisterWeixinAccountId(id);
+		}
+	}
+}
+function resolveAccountsDir() {
+	return path.join(resolveWeixinStateDir(), "accounts");
+}
+function resolveAccountPath(accountId) {
+	return path.join(resolveAccountsDir(), `${accountId}.json`);
+}
+/**
+* Legacy single-file token: `credentials/openclaw-weixin/credentials.json` (pre per-account files).
+*/
+function loadLegacyToken() {
+	const legacyPath = path.join(resolveStateDir(), "credentials", "openclaw-weixin", "credentials.json");
+	try {
+		if (!fs.existsSync(legacyPath)) return void 0;
+		const raw = fs.readFileSync(legacyPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.token === "string" ? parsed.token : void 0;
+	} catch {
+		return;
+	}
+}
+function readAccountFile(filePath) {
+	try {
+		if (fs.existsSync(filePath)) return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {}
+	return null;
+}
+/** Load account data by ID, with compatibility fallbacks. */
+function loadWeixinAccount(accountId) {
+	const primary = readAccountFile(resolveAccountPath(accountId));
+	if (primary) return primary;
+	const rawId = deriveRawAccountId(accountId);
+	if (rawId) {
+		const compat = readAccountFile(resolveAccountPath(rawId));
+		if (compat) return compat;
+	}
+	const token = loadLegacyToken();
+	if (token) return { token };
+	return null;
+}
+/**
+* Persist account data after QR login (merges into existing file).
+* - token: overwritten when provided.
+* - baseUrl: stored when non-empty; resolveWeixinAccount falls back to DEFAULT_BASE_URL.
+* - userId: set when `update.userId` is provided; omitted from file when cleared to empty.
+*/
+function saveWeixinAccount(accountId, update) {
+	const dir = resolveAccountsDir();
+	fs.mkdirSync(dir, { recursive: true });
+	const existing = loadWeixinAccount(accountId) ?? {};
+	const token = update.token?.trim() || existing.token;
+	const baseUrl = update.baseUrl?.trim() || existing.baseUrl;
+	const userId = update.userId !== void 0 ? update.userId.trim() || void 0 : existing.userId?.trim() || void 0;
+	const data = {
+		...token ? {
+			token,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString()
+		} : {},
+		...baseUrl ? { baseUrl } : {},
+		...userId ? { userId } : {}
+	};
+	const filePath = resolveAccountPath(accountId);
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+	try {
+		fs.chmodSync(filePath, 384);
+	} catch {}
+}
+/**
+* Remove all files associated with an account:
+*   - accounts/{accountId}.json                  (credentials)
+*   - accounts/{accountId}.sync.json             (getUpdates sync buf)
+*   - accounts/{accountId}.context-tokens.json   (context tokens on disk)
+*   - credentials/openclaw-weixin-{accountId}-allowFrom.json (authorized users)
+*/
+function clearWeixinAccount(accountId) {
+	const dir = resolveAccountsDir();
+	const accountFiles = [
+		`${accountId}.json`,
+		`${accountId}.sync.json`,
+		`${accountId}.context-tokens.json`
+	];
+	for (const file of accountFiles) try {
+		fs.unlinkSync(path.join(dir, file));
+	} catch {}
+	try {
+		fs.unlinkSync(resolveFrameworkAllowFromPath(accountId));
+	} catch {}
+}
+/**
+* Resolve the openclaw.json config file path.
+* Checks OPENCLAW_CONFIG env var, then state dir.
+*/
+function resolveConfigPath() {
+	const envPath = process.env.OPENCLAW_CONFIG?.trim();
+	if (envPath) return envPath;
+	return path.join(resolveStateDir(), "openclaw.json");
+}
+/**
+* Read `routeTag` from openclaw.json (for callers without an `FengMingConfig` object).
+* Checks per-account `channels.<id>.accounts[accountId].routeTag` first, then section-level
+* `channels.<id>.routeTag`. Matches `feat_weixin_extension` behavior; channel key is `"openclaw-weixin"`.
+*
+* The config is cached after the first read since routeTag does not change at runtime.
+*/
+let cachedRouteTagSection;
+function loadRouteTagSection() {
+	if (cachedRouteTagSection !== void 0) return cachedRouteTagSection;
+	try {
+		const configPath = resolveConfigPath();
+		if (!fs.existsSync(configPath)) {
+			cachedRouteTagSection = null;
+			return null;
+		}
+		const raw = fs.readFileSync(configPath, "utf-8");
+		const section = JSON.parse(raw).channels?.["openclaw-weixin"] ?? null;
+		cachedRouteTagSection = section;
+		return section;
+	} catch {
+		cachedRouteTagSection = null;
+		return null;
+	}
+}
+function loadConfigRouteTag(accountId) {
+	const section = loadRouteTagSection();
+	if (!section) return void 0;
+	if (accountId) {
+		const tag = section.accounts?.[accountId]?.routeTag;
+		if (typeof tag === "number") return String(tag);
+		if (typeof tag === "string" && tag.trim()) return tag.trim();
+	}
+	if (typeof section.routeTag === "number") return String(section.routeTag);
+	return typeof section.routeTag === "string" && section.routeTag.trim() ? section.routeTag.trim() : void 0;
+}
+/**
+* Read `botAgent` from `channels.openclaw-weixin.botAgent` in openclaw.json.
+* Returns the raw configured string (caller is responsible for sanitization)
+* or undefined when not set. Reuses the cached channel section.
+*/
+function loadConfigBotAgent() {
+	const section = loadRouteTagSection();
+	if (!section) return void 0;
+	const value = section.botAgent;
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+/**
+* Bump `channels.openclaw-weixin.channelConfigUpdatedAt` in openclaw.json on each successful login
+* so the gateway reloads config from disk (no empty `accounts: {}` placeholder).
+*/
+async function triggerWeixinChannelReload() {
+	try {
+		const { loadConfig, writeConfigFile } = await import("./plugin-sdk/config-runtime.js");
+		const cfg = loadConfig();
+		const channels = cfg.channels ?? {};
+		const existing = channels["openclaw-weixin"] ?? {};
+		await writeConfigFile({
+			...cfg,
+			channels: {
+				...channels,
+				"openclaw-weixin": {
+					...existing,
+					channelConfigUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			}
+		});
+		logger.info("triggerWeixinChannelReload: wrote channel config to openclaw.json");
+	} catch (err) {
+		logger.warn(`triggerWeixinChannelReload: failed to update config: ${String(err)}`);
+	}
+}
+/** List accountIds from the index file (written at QR login). */
+function listWeixinAccountIds(_cfg) {
+	return listIndexedWeixinAccountIds();
+}
+/** Resolve a weixin account by ID, merging config and stored credentials. */
+function resolveWeixinAccount(cfg, accountId) {
+	const raw = accountId?.trim();
+	if (!raw) throw new Error("weixin: accountId is required (no default account)");
+	const id = normalizeAccountId(raw);
+	const section = cfg.channels?.["openclaw-weixin"];
+	const accountCfg = section?.accounts?.[id] ?? section ?? {};
+	const accountData = loadWeixinAccount(id);
+	const token = accountData?.token?.trim() || void 0;
+	return {
+		accountId: id,
+		baseUrl: accountData?.baseUrl?.trim() || "https://ilinkai.weixin.qq.com",
+		cdnBaseUrl: accountCfg.cdnBaseUrl?.trim() || "https://novac2c.cdn.weixin.qq.com/c2c",
+		token,
+		enabled: accountCfg.enabled !== false,
+		configured: Boolean(token),
+		name: accountCfg.name?.trim() || void 0
+	};
+}
+//#endregion
+//#region extensions/weixin/src/util/redact.ts
+const DEFAULT_BODY_MAX_LEN = 200;
+const DEFAULT_TOKEN_PREFIX_LEN = 6;
+/**
+* Truncate a string, appending a length indicator when trimmed.
+* Returns `""` for empty/undefined input.
+*/
+function truncate(s, max) {
+	if (!s) return "";
+	if (s.length <= max) return s;
+	return `${s.slice(0, max)}…(len=${s.length})`;
+}
+/**
+* Redact a token/secret: show only the first few chars + total length.
+* Returns `"(none)"` when absent.
+*/
+function redactToken(token, prefixLen = DEFAULT_TOKEN_PREFIX_LEN) {
+	if (!token) return "(none)";
+	if (token.length <= prefixLen) return `****(len=${token.length})`;
+	return `${token.slice(0, prefixLen)}…(len=${token.length})`;
+}
+/**
+* Truncate a JSON body string to `maxLen` chars for safe logging.
+* Redacts known sensitive fields before truncating.
+*/
+function redactBody(body, maxLen = DEFAULT_BODY_MAX_LEN) {
+	if (!body) return "(empty)";
+	const redacted = body.replace(/"(context_token|bot_token|token|authorization|Authorization)"\s*:\s*"[^"]*"/g, "\"$1\":\"<redacted>\"");
+	if (redacted.length <= maxLen) return redacted;
+	return `${redacted.slice(0, maxLen)}…(truncated, totalLen=${redacted.length})`;
+}
+/**
+* Strip query string (which often contains signatures/tokens) from a URL,
+* keeping only origin + pathname.
+*/
+function redactUrl(rawUrl) {
+	try {
+		const u = new URL(rawUrl);
+		const base = `${u.origin}${u.pathname}`;
+		return u.search ? `${base}?<redacted>` : base;
+	} catch {
+		return truncate(rawUrl, 80);
+	}
+}
+//#endregion
+//#region extensions/weixin/src/api/api.ts
+/**
+* Identify whether a parsed package.json belongs to this plugin.
+*
+* The walk-up search may pass through unrelated `package.json` files
+* (e.g. nested `node_modules/<dep>/package.json`); only ours is accepted.
+*/
+function isOwnPackageJson(parsed) {
+	if (parsed.ilink_appid !== void 0) return true;
+	return typeof parsed.name === "string" && parsed.name.includes("openclaw-weixin");
+}
+/**
+* Walk up from `startDir` searching for the plugin's own `package.json`.
+*
+* Resilient to differing layouts between dev (TS source under `src/`) and
+* publish (compiled output under `dist/src/`) by not assuming a fixed depth.
+*/
+function readPackageJsonFromDir(startDir) {
+	try {
+		let dir = startDir;
+		const { root } = path.parse(dir);
+		while (dir && dir !== root) {
+			const candidate = path.join(dir, "package.json");
+			if (fs.existsSync(candidate)) try {
+				const parsed = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+				if (isOwnPackageJson(parsed)) return parsed;
+			} catch {}
+			dir = path.dirname(dir);
+		}
+	} catch {}
+	return {};
+}
+function readPackageJson() {
+	return readPackageJsonFromDir(path.dirname(fileURLToPath(import.meta.url)));
+}
+const pkg = readPackageJson();
+const CHANNEL_VERSION = pkg.version ?? "unknown";
+/** iLink-App-Id: 直接读取 package.json 顶层 ilink_appid 字段。 */
+const ILINK_APP_ID = pkg.ilink_appid ?? "";
+/**
+* iLink-App-ClientVersion: uint32 encoded as 0x00MMNNPP
+* High 8 bits fixed to 0; remaining bits: major<<16 | minor<<8 | patch.
+* e.g. "1.0.11" -> 0x0001000B = 65547
+*/
+function buildClientVersion(version) {
+	const parts = version.split(".").map((p) => parseInt(p, 10));
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	const patch = parts[2] ?? 0;
+	return (major & 255) << 16 | (minor & 255) << 8 | patch & 255;
+}
+const ILINK_APP_CLIENT_VERSION = buildClientVersion(pkg.version ?? "0.0.0");
+/**
+* Default `bot_agent` value used when the upstream app does not declare one.
+* Mirrors the role of HTTP `User-Agent`'s implicit "no UA" fallback.
+*/
+const DEFAULT_BOT_AGENT = "凤鸣";
+/** Maximum length (bytes) of the sanitized `bot_agent` string. */
+const BOT_AGENT_MAX_LEN = 256;
+/**
+* Sanitize a user-supplied `botAgent` config value into a wire-safe string.
+*
+* Grammar (UA-style):
+*   bot_agent = product *( SP product )
+*   product   = name "/" version [ SP "(" comment ")" ]
+*   name      = 1*32( ALPHA / DIGIT / "_" / "." / "-" )
+*   version   = 1*32( ALPHA / DIGIT / "_" / "." / "+" / "-" )
+*   comment   = 1*64( printable ASCII minus "(" ")" )
+*
+* Tokens that fail to parse are dropped silently (no partial tokens kept).
+* Returns `DEFAULT_BOT_AGENT` when the input is empty / all tokens dropped /
+* the result exceeds the length cap after truncation.
+*/
+function sanitizeBotAgent(raw) {
+	if (!raw || typeof raw !== "string") return DEFAULT_BOT_AGENT;
+	const trimmed = raw.trim();
+	if (!trimmed) return DEFAULT_BOT_AGENT;
+	const productRe = /^[A-Za-z0-9_.\-]{1,32}\/[A-Za-z0-9_.+\-]{1,32}$/;
+	const commentCharRe = /^[\x20-\x27\x2A-\x7E]{1,64}$/;
+	const rawTokens = trimmed.split(/\s+/);
+	const tokens = [];
+	for (let i = 0; i < rawTokens.length; i += 1) {
+		const tok = rawTokens[i];
+		if (tok.startsWith("(") && !tok.endsWith(")")) {
+			let acc = tok;
+			while (i + 1 < rawTokens.length && !acc.endsWith(")")) {
+				i += 1;
+				acc += " " + rawTokens[i];
+			}
+			tokens.push(acc);
+		} else tokens.push(tok);
+	}
+	const accepted = [];
+	let pendingProduct = null;
+	for (const tok of tokens) {
+		if (tok.startsWith("(") && tok.endsWith(")")) {
+			const inner = tok.slice(1, -1);
+			if (pendingProduct && commentCharRe.test(inner)) {
+				accepted.push(`${pendingProduct} (${inner})`);
+				pendingProduct = null;
+			} else if (pendingProduct) {
+				accepted.push(pendingProduct);
+				pendingProduct = null;
+			}
+			continue;
+		}
+		if (pendingProduct) {
+			accepted.push(pendingProduct);
+			pendingProduct = null;
+		}
+		if (productRe.test(tok)) pendingProduct = tok;
+	}
+	if (pendingProduct) accepted.push(pendingProduct);
+	if (accepted.length === 0) return DEFAULT_BOT_AGENT;
+	const joined = accepted.join(" ");
+	if (Buffer.byteLength(joined, "utf-8") <= BOT_AGENT_MAX_LEN) return joined;
+	const truncated = [];
+	let len = 0;
+	for (const t of accepted) {
+		const add = (truncated.length === 0 ? 0 : 1) + Buffer.byteLength(t, "utf-8");
+		if (len + add > BOT_AGENT_MAX_LEN) break;
+		truncated.push(t);
+		len += add;
+	}
+	return truncated.length > 0 ? truncated.join(" ") : DEFAULT_BOT_AGENT;
+}
+/** Build the `base_info` payload included in every API request. */
+function buildBaseInfo() {
+	return {
+		channel_version: CHANNEL_VERSION,
+		bot_agent: sanitizeBotAgent(loadConfigBotAgent())
+	};
+}
+/** Default timeout for long-poll getUpdates requests. */
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35e3;
+/** Default timeout for regular API requests (sendMessage, getUploadUrl). */
+const DEFAULT_API_TIMEOUT_MS = 15e3;
+/** Default timeout for lightweight API requests (getConfig, sendTyping). */
+const DEFAULT_CONFIG_TIMEOUT_MS = 1e4;
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+/** X-WECHAT-UIN header: random uint32 -> decimal string -> base64. */
+function randomWechatUin() {
+	const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+	return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+/** Build headers shared by both GET and POST requests. */
+function buildCommonHeaders() {
+	const headers = {
+		"iLink-App-Id": ILINK_APP_ID,
+		"iLink-App-ClientVersion": String(ILINK_APP_CLIENT_VERSION)
+	};
+	const routeTag = loadConfigRouteTag();
+	if (routeTag) headers.SKRouteTag = routeTag;
+	return headers;
+}
+function buildHeaders(opts) {
+	const headers = {
+		"Content-Type": "application/json",
+		AuthorizationType: "ilink_bot_token",
+		"X-WECHAT-UIN": randomWechatUin(),
+		...buildCommonHeaders()
+	};
+	if (opts.token?.trim()) headers.Authorization = `Bearer ${opts.token.trim()}`;
+	logger.debug(`requestHeaders: ${JSON.stringify({
+		...headers,
+		Authorization: headers.Authorization ? "Bearer ***" : void 0
+	})}`);
+	return headers;
+}
+/**
+* GET fetch wrapper: send a GET request to a Weixin API endpoint.
+* When `timeoutMs` is set, the request is aborted after that many milliseconds.
+* Query parameters should already be encoded in `endpoint`.
+* Returns the raw response text on success; throws on HTTP error or (if used) timeout abort.
+*/
+async function apiGetFetch(params) {
+	const base = ensureTrailingSlash(params.baseUrl);
+	const url = new URL(params.endpoint, base);
+	const hdrs = buildCommonHeaders();
+	logger.debug(`GET ${redactUrl(url.toString())}`);
+	const timeoutMs = params.timeoutMs;
+	const controller = timeoutMs != null && timeoutMs > 0 ? new AbortController() : void 0;
+	const t = controller != null && timeoutMs != null ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+	try {
+		const res = await fetch(url.toString(), {
+			method: "GET",
+			headers: hdrs,
+			...controller ? { signal: controller.signal } : {}
+		});
+		if (t !== void 0) clearTimeout(t);
+		const rawText = await res.text();
+		logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+		if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`);
+		return rawText;
+	} catch (err) {
+		if (t !== void 0) clearTimeout(t);
+		throw err;
+	}
+}
+/**
+* Combine an internal timeout controller with an optional external abort signal.
+* This lets gateway channel-stop aborts cancel in-flight long-poll requests
+* immediately while preserving the existing timeout-driven AbortError path.
+*/
+function combineAbortSignals(params) {
+	const { internal, external } = params;
+	if (!external) return {
+		signal: internal?.signal,
+		cleanup: () => {}
+	};
+	if (!internal) return {
+		signal: external,
+		cleanup: () => {}
+	};
+	if (external.aborted) {
+		internal.abort();
+		return {
+			signal: internal.signal,
+			cleanup: () => {}
+		};
+	}
+	const onExternalAbort = () => internal.abort();
+	external.addEventListener("abort", onExternalAbort, { once: true });
+	return {
+		signal: internal.signal,
+		cleanup: () => external.removeEventListener("abort", onExternalAbort)
+	};
+}
+/**
+* Common fetch wrapper: POST JSON to a Weixin API endpoint.
+* When `timeoutMs` is provided, the request is aborted after that many milliseconds.
+* When omitted, no client-side timeout is applied (relies on OS/TCP stack).
+* Returns the raw response text on success; throws on HTTP error or timeout.
+*
+* When `abortSignal` is provided, an external abort (e.g. gateway channel stop)
+* cancels the in-flight request immediately instead of waiting for `timeoutMs`.
+*/
+async function apiPostFetch(params) {
+	const base = ensureTrailingSlash(params.baseUrl);
+	const url = new URL(params.endpoint, base);
+	const hdrs = buildHeaders({ token: params.token });
+	logger.debug(`POST ${redactUrl(url.toString())} body=${redactBody(params.body)}`);
+	const controller = params.timeoutMs !== void 0 ? new AbortController() : void 0;
+	const t = controller != null && params.timeoutMs !== void 0 ? setTimeout(() => controller.abort(), params.timeoutMs) : void 0;
+	const { signal, cleanup } = combineAbortSignals({
+		internal: controller,
+		external: params.abortSignal
+	});
+	try {
+		const res = await fetch(url.toString(), {
+			method: "POST",
+			headers: hdrs,
+			body: params.body,
+			...signal ? { signal } : {}
+		});
+		if (t !== void 0) clearTimeout(t);
+		const rawText = await res.text();
+		logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+		if (!res.ok) throw new Error(`${params.label} ${res.status}: ${rawText}`);
+		return rawText;
+	} catch (err) {
+		if (t !== void 0) clearTimeout(t);
+		throw err;
+	} finally {
+		cleanup();
+	}
+}
+/**
+* Long-poll getUpdates. Server should hold the request until new messages or timeout.
+*
+* On client-side timeout (no server response within timeoutMs), returns an empty response
+* with ret=0 so the caller can simply retry. This is normal for long-poll.
+*/
+async function getUpdates(params) {
+	const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+	try {
+		const rawText = await apiPostFetch({
+			baseUrl: params.baseUrl,
+			endpoint: "ilink/bot/getupdates",
+			body: JSON.stringify({
+				get_updates_buf: params.get_updates_buf ?? "",
+				base_info: buildBaseInfo()
+			}),
+			token: params.token,
+			timeoutMs: timeout,
+			label: "getUpdates",
+			abortSignal: params.abortSignal
+		});
+		return JSON.parse(rawText);
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			if (params.abortSignal?.aborted) logger.debug(`getUpdates: aborted by external signal`);
+			else logger.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+			return {
+				ret: 0,
+				msgs: [],
+				get_updates_buf: params.get_updates_buf
+			};
+		}
+		throw err;
+	}
+}
+/** Get a pre-signed CDN upload URL for a file. */
+async function getUploadUrl(params) {
+	const rawText = await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/getuploadurl",
+		body: JSON.stringify({
+			filekey: params.filekey,
+			media_type: params.media_type,
+			to_user_id: params.to_user_id,
+			rawsize: params.rawsize,
+			rawfilemd5: params.rawfilemd5,
+			filesize: params.filesize,
+			thumb_rawsize: params.thumb_rawsize,
+			thumb_rawfilemd5: params.thumb_rawfilemd5,
+			thumb_filesize: params.thumb_filesize,
+			no_need_thumb: params.no_need_thumb,
+			aeskey: params.aeskey,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+		label: "getUploadUrl"
+	});
+	return JSON.parse(rawText);
+}
+/** Send a single message downstream. */
+async function sendMessage(params) {
+	await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/sendmessage",
+		body: JSON.stringify({
+			...params.body,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+		label: "sendMessage"
+	});
+}
+/** Fetch bot config (includes typing_ticket) for a given user. */
+async function getConfig(params) {
+	const rawText = await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/getconfig",
+		body: JSON.stringify({
+			ilink_user_id: params.ilinkUserId,
+			context_token: params.contextToken,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "getConfig"
+	});
+	return JSON.parse(rawText);
+}
+/** Send a typing indicator to a user. */
+async function sendTyping(params) {
+	await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/sendtyping",
+		body: JSON.stringify({
+			...params.body,
+			base_info: buildBaseInfo()
+		}),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "sendTyping"
+	});
+}
+/**
+* Notify Weixin that this channel client is stopping (gateway shutdown / channel stop).
+* Uses a standalone timeout (not the gateway abort signal) so the request can finish
+* after OpenClaw has already aborted the long-poll.
+*/
+async function notifyStop(params) {
+	const rawText = await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/msg/notifystop",
+		body: JSON.stringify({ base_info: buildBaseInfo() }),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "notifyStop"
+	});
+	return JSON.parse(rawText);
+}
+/**
+* Notify Weixin that this channel client is starting (gateway startup / channel start).
+*/
+async function notifyStart(params) {
+	const rawText = await apiPostFetch({
+		baseUrl: params.baseUrl,
+		endpoint: "ilink/bot/msg/notifystart",
+		body: JSON.stringify({ base_info: buildBaseInfo() }),
+		token: params.token,
+		timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+		label: "notifyStart"
+	});
+	return JSON.parse(rawText);
+}
+//#endregion
+//#region extensions/weixin/src/api/session-guard.ts
+const SESSION_PAUSE_DURATION_MS = 3600 * 1e3;
+const pauseUntilMap = /* @__PURE__ */ new Map();
+/** Pause all inbound/outbound API calls for `accountId` for one hour. */
+function pauseSession(accountId) {
+	const until = Date.now() + SESSION_PAUSE_DURATION_MS;
+	pauseUntilMap.set(accountId, until);
+	logger.info(`session-guard: paused accountId=${accountId} until=${new Date(until).toISOString()} (${SESSION_PAUSE_DURATION_MS / 1e3}s)`);
+}
+/** Returns `true` when the bot is still within its one-hour cooldown window. */
+function isSessionPaused(accountId) {
+	const until = pauseUntilMap.get(accountId);
+	if (until === void 0) return false;
+	if (Date.now() >= until) {
+		pauseUntilMap.delete(accountId);
+		return false;
+	}
+	return true;
+}
+/** Milliseconds remaining until the pause expires (0 when not paused). */
+function getRemainingPauseMs(accountId) {
+	const until = pauseUntilMap.get(accountId);
+	if (until === void 0) return 0;
+	const remaining = until - Date.now();
+	if (remaining <= 0) {
+		pauseUntilMap.delete(accountId);
+		return 0;
+	}
+	return remaining;
+}
+/** Throw if the session is currently paused. Call before any API request. */
+function assertSessionActive(accountId) {
+	if (isSessionPaused(accountId)) {
+		const remainingMin = Math.ceil(getRemainingPauseMs(accountId) / 6e4);
+		throw new Error(`session paused for accountId=${accountId}, ${remainingMin} min remaining (errcode -14)`);
+	}
+}
+//#endregion
+//#region extensions/weixin/src/cdn/aes-ecb.ts
+/**
+* Shared AES-128-ECB crypto utilities for CDN upload and download.
+*/
+/** Encrypt buffer with AES-128-ECB (PKCS7 padding is default). */
+function encryptAesEcb(plaintext, key) {
+	const cipher = createCipheriv("aes-128-ecb", key, null);
+	return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+/** Decrypt buffer with AES-128-ECB (PKCS7 padding). */
+function decryptAesEcb(ciphertext, key) {
+	const decipher = createDecipheriv("aes-128-ecb", key, null);
+	return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+/** Compute AES-128-ECB ciphertext size (PKCS7 padding to 16-byte boundary). */
+function aesEcbPaddedSize(plaintextSize) {
+	return Math.ceil((plaintextSize + 1) / 16) * 16;
+}
+//#endregion
+//#region extensions/weixin/src/cdn/cdn-url.ts
+/** Build a CDN download URL from encrypt_query_param. */
+function buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl) {
+	return `${cdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`;
+}
+/** Build a CDN upload URL from upload_param and filekey. */
+function buildCdnUploadUrl(params) {
+	return `${params.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(params.uploadParam)}&filekey=${encodeURIComponent(params.filekey)}`;
+}
+//#endregion
+//#region extensions/weixin/src/cdn/cdn-upload.ts
+/** Maximum retry attempts for CDN upload. */
+const UPLOAD_MAX_RETRIES = 3;
+/**
+* Upload one buffer to the Weixin CDN with AES-128-ECB encryption.
+* Returns the download encrypted_query_param from the CDN response.
+* Retries up to UPLOAD_MAX_RETRIES times on server errors; client errors (4xx) abort immediately.
+*/
+async function uploadBufferToCdn(params) {
+	const { buf, uploadFullUrl, uploadParam, filekey, cdnBaseUrl, label, aeskey } = params;
+	const ciphertext = encryptAesEcb(buf, aeskey);
+	const trimmedFull = uploadFullUrl?.trim();
+	let cdnUrl;
+	if (trimmedFull) cdnUrl = trimmedFull;
+	else if (uploadParam) cdnUrl = buildCdnUploadUrl({
+		cdnBaseUrl,
+		uploadParam,
+		filekey
+	});
+	else throw new Error(`${label}: CDN upload URL missing (need upload_full_url or upload_param)`);
+	logger.debug(`${label}: CDN POST url=${redactUrl(cdnUrl)} ciphertextSize=${ciphertext.length}`);
+	let downloadParam;
+	let lastError;
+	for (let attempt = 1; attempt <= UPLOAD_MAX_RETRIES; attempt++) try {
+		const res = await fetch(cdnUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/octet-stream" },
+			body: new Uint8Array(ciphertext)
+		});
+		if (res.status >= 400 && res.status < 500) {
+			const errMsg = res.headers.get("x-error-message") ?? await res.text();
+			logger.error(`${label}: CDN client error attempt=${attempt} status=${res.status} errMsg=${errMsg}`);
+			throw new Error(`CDN upload client error ${res.status}: ${errMsg}`);
+		}
+		if (res.status !== 200) {
+			const errMsg = res.headers.get("x-error-message") ?? `status ${res.status}`;
+			logger.error(`${label}: CDN server error attempt=${attempt} status=${res.status} errMsg=${errMsg}`);
+			throw new Error(`CDN upload server error: ${errMsg}`);
+		}
+		downloadParam = res.headers.get("x-encrypted-param") ?? void 0;
+		if (!downloadParam) {
+			logger.error(`${label}: CDN response missing x-encrypted-param header attempt=${attempt}`);
+			throw new Error("CDN upload response missing x-encrypted-param header");
+		}
+		logger.debug(`${label}: CDN upload success attempt=${attempt}`);
+		break;
+	} catch (err) {
+		lastError = err;
+		if (err instanceof Error && err.message.includes("client error")) throw err;
+		if (attempt < UPLOAD_MAX_RETRIES) logger.error(`${label}: attempt ${attempt} failed, retrying... err=${String(err)}`);
+		else logger.error(`${label}: all ${UPLOAD_MAX_RETRIES} attempts failed err=${String(err)}`);
+	}
+	if (!downloadParam) throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error(`CDN upload failed after ${UPLOAD_MAX_RETRIES} attempts`);
+	return { downloadParam };
+}
+//#endregion
+//#region extensions/weixin/src/media/mime.ts
+const EXTENSION_TO_MIME = {
+	".pdf": "application/pdf",
+	".doc": "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".xls": "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".ppt": "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	".txt": "text/plain",
+	".csv": "text/csv",
+	".zip": "application/zip",
+	".tar": "application/x-tar",
+	".gz": "application/gzip",
+	".mp3": "audio/mpeg",
+	".ogg": "audio/ogg",
+	".wav": "audio/wav",
+	".mp4": "video/mp4",
+	".mov": "video/quicktime",
+	".webm": "video/webm",
+	".mkv": "video/x-matroska",
+	".avi": "video/x-msvideo",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp"
+};
+const MIME_TO_EXTENSION = {
+	"image/jpeg": ".jpg",
+	"image/jpg": ".jpg",
+	"image/png": ".png",
+	"image/gif": ".gif",
+	"image/webp": ".webp",
+	"image/bmp": ".bmp",
+	"video/mp4": ".mp4",
+	"video/quicktime": ".mov",
+	"video/webm": ".webm",
+	"video/x-matroska": ".mkv",
+	"video/x-msvideo": ".avi",
+	"audio/mpeg": ".mp3",
+	"audio/ogg": ".ogg",
+	"audio/wav": ".wav",
+	"application/pdf": ".pdf",
+	"application/zip": ".zip",
+	"application/x-tar": ".tar",
+	"application/gzip": ".gz",
+	"text/plain": ".txt",
+	"text/csv": ".csv"
+};
+/** Get MIME type from filename extension. Returns "application/octet-stream" for unknown extensions. */
+function getMimeFromFilename(filename) {
+	return EXTENSION_TO_MIME[path.extname(filename).toLowerCase()] ?? "application/octet-stream";
+}
+/** Get file extension from MIME type. Returns ".bin" for unknown types. */
+function getExtensionFromMime(mimeType) {
+	return MIME_TO_EXTENSION[mimeType.split(";")[0].trim().toLowerCase()] ?? ".bin";
+}
+/** Get file extension from Content-Type header or URL path. Returns ".bin" for unknown. */
+function getExtensionFromContentTypeOrUrl(contentType, url) {
+	if (contentType) {
+		const ext = getExtensionFromMime(contentType);
+		if (ext !== ".bin") return ext;
+	}
+	const ext = path.extname(new URL(url).pathname).toLowerCase();
+	return new Set(Object.keys(EXTENSION_TO_MIME)).has(ext) ? ext : ".bin";
+}
+//#endregion
+//#region extensions/weixin/src/util/random.ts
+/**
+* Generate a prefixed unique ID using timestamp + crypto random bytes.
+* Format: `{prefix}:{timestamp}-{8-char hex}`
+*/
+function generateId(prefix) {
+	return `${prefix}:${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+}
+/**
+* Generate a temporary file name with random suffix.
+* Format: `{prefix}-{timestamp}-{8-char hex}{ext}`
+*/
+function tempFileName(prefix, ext) {
+	return `${prefix}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}${ext}`;
+}
+//#endregion
+//#region extensions/weixin/src/api/types.ts
+/** proto: UploadMediaType */
+const UploadMediaType = {
+	IMAGE: 1,
+	VIDEO: 2,
+	FILE: 3,
+	VOICE: 4
+};
+const MessageType = {
+	NONE: 0,
+	USER: 1,
+	BOT: 2
+};
+const MessageItemType = {
+	NONE: 0,
+	TEXT: 1,
+	IMAGE: 2,
+	VOICE: 3,
+	FILE: 4,
+	VIDEO: 5,
+	TOOL_CALL_START: 11,
+	TOOL_CALL_RESULT: 12
+};
+const MessageState = {
+	NEW: 0,
+	GENERATING: 1,
+	FINISH: 2
+};
+/** Typing status: 1 = typing (default), 2 = cancel typing. */
+const TypingStatus = {
+	TYPING: 1,
+	CANCEL: 2
+};
+//#endregion
+//#region extensions/weixin/src/cdn/upload.ts
+/**
+* Download a remote media URL (image, video, file) to a local temp file in destDir.
+* Returns the local file path; extension is inferred from Content-Type / URL.
+*/
+async function downloadRemoteImageToTemp(url, destDir) {
+	logger.debug(`downloadRemoteImageToTemp: fetching url=${url}`);
+	const res = await fetch(url);
+	if (!res.ok) {
+		const msg = `remote media download failed: ${res.status} ${res.statusText} url=${url}`;
+		logger.error(`downloadRemoteImageToTemp: ${msg}`);
+		throw new Error(msg);
+	}
+	const buf = Buffer.from(await res.arrayBuffer());
+	logger.debug(`downloadRemoteImageToTemp: downloaded ${buf.length} bytes`);
+	await fs$1.mkdir(destDir, { recursive: true });
+	const ext = getExtensionFromContentTypeOrUrl(res.headers.get("content-type"), url);
+	const name = tempFileName("weixin-remote", ext);
+	const filePath = path.join(destDir, name);
+	await fs$1.writeFile(filePath, buf);
+	logger.debug(`downloadRemoteImageToTemp: saved to ${filePath} ext=${ext}`);
+	return filePath;
+}
+/**
+* Common upload pipeline: read file → hash → gen aeskey → getUploadUrl → uploadBufferToCdn → return info.
+*/
+async function uploadMediaToCdn(params) {
+	const { filePath, toUserId, opts, cdnBaseUrl, mediaType, label } = params;
+	const plaintext = await fs$1.readFile(filePath);
+	const rawsize = plaintext.length;
+	const rawfilemd5 = crypto.createHash("md5").update(plaintext).digest("hex");
+	const filesize = aesEcbPaddedSize(rawsize);
+	const filekey = crypto.randomBytes(16).toString("hex");
+	const aeskey = crypto.randomBytes(16);
+	logger.debug(`${label}: file=${filePath} rawsize=${rawsize} filesize=${filesize} md5=${rawfilemd5} filekey=${filekey}`);
+	const uploadUrlResp = await getUploadUrl({
+		...opts,
+		filekey,
+		media_type: mediaType,
+		to_user_id: toUserId,
+		rawsize,
+		rawfilemd5,
+		filesize,
+		no_need_thumb: true,
+		aeskey: aeskey.toString("hex")
+	});
+	const uploadFullUrl = uploadUrlResp.upload_full_url?.trim();
+	const uploadParam = uploadUrlResp.upload_param;
+	if (!uploadFullUrl && !uploadParam) {
+		logger.error(`${label}: getUploadUrl returned no upload URL (need upload_full_url or upload_param), resp=${JSON.stringify(uploadUrlResp)}`);
+		throw new Error(`${label}: getUploadUrl returned no upload URL`);
+	}
+	const { downloadParam: downloadEncryptedQueryParam } = await uploadBufferToCdn({
+		buf: plaintext,
+		uploadFullUrl: uploadFullUrl || void 0,
+		uploadParam: uploadParam ?? void 0,
+		filekey,
+		cdnBaseUrl,
+		aeskey,
+		label: `${label}[orig filekey=${filekey}]`
+	});
+	return {
+		filekey,
+		downloadEncryptedQueryParam,
+		aeskey: aeskey.toString("hex"),
+		fileSize: rawsize,
+		fileSizeCiphertext: filesize
+	};
+}
+/** Upload a local image file to the Weixin CDN with AES-128-ECB encryption. */
+async function uploadFileToWeixin(params) {
+	return uploadMediaToCdn({
+		...params,
+		mediaType: UploadMediaType.IMAGE,
+		label: "uploadFileToWeixin"
+	});
+}
+/** Upload a local video file to the Weixin CDN. */
+async function uploadVideoToWeixin(params) {
+	return uploadMediaToCdn({
+		...params,
+		mediaType: UploadMediaType.VIDEO,
+		label: "uploadVideoToWeixin"
+	});
+}
+/**
+* Upload a local file attachment (non-image, non-video) to the Weixin CDN.
+* Uses media_type=FILE; no thumbnail required.
+*/
+async function uploadFileAttachmentToWeixin(params) {
+	return uploadMediaToCdn({
+		...params,
+		mediaType: UploadMediaType.FILE,
+		label: "uploadFileAttachmentToWeixin"
+	});
+}
+//#endregion
+//#region extensions/weixin/src/messaging/inbound.ts
+/**
+* contextToken is issued per-message by the Weixin getupdates API and must
+* be echoed verbatim in every outbound send. The in-memory map is the primary
+* lookup; a disk-backed file per account ensures tokens survive gateway restarts.
+*/
+const contextTokenStore = /* @__PURE__ */ new Map();
+function contextTokenKey(accountId, userId) {
+	return `${accountId}:${userId}`;
+}
+function resolveContextTokenFilePath(accountId) {
+	return path.join(resolveStateDir(), "openclaw-weixin", "accounts", `${accountId}.context-tokens.json`);
+}
+/** Persist all context tokens for a given account to disk. */
+function persistContextTokens(accountId) {
+	const prefix = `${accountId}:`;
+	const tokens = {};
+	for (const [k, v] of contextTokenStore) if (k.startsWith(prefix)) tokens[k.slice(prefix.length)] = v;
+	const filePath = resolveContextTokenFilePath(accountId);
+	try {
+		const dir = path.dirname(filePath);
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(filePath, JSON.stringify(tokens, null, 0), "utf-8");
+	} catch (err) {
+		logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
+	}
+}
+/**
+* Restore persisted context tokens for an account into the in-memory map.
+* Called once during gateway startAccount to survive restarts.
+*/
+function restoreContextTokens(accountId) {
+	const filePath = resolveContextTokenFilePath(accountId);
+	try {
+		if (!fs.existsSync(filePath)) return;
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const tokens = JSON.parse(raw);
+		let count = 0;
+		for (const [userId, token] of Object.entries(tokens)) if (typeof token === "string" && token) {
+			contextTokenStore.set(contextTokenKey(accountId, userId), token);
+			count++;
+		}
+		logger.info(`restoreContextTokens: restored ${count} tokens for account=${accountId}`);
+	} catch (err) {
+		logger.warn(`restoreContextTokens: failed to read ${filePath}: ${String(err)}`);
+	}
+}
+/** Remove all context tokens for a given account (memory + disk). */
+function clearContextTokensForAccount(accountId) {
+	const prefix = `${accountId}:`;
+	for (const k of [...contextTokenStore.keys()]) if (k.startsWith(prefix)) contextTokenStore.delete(k);
+	const filePath = resolveContextTokenFilePath(accountId);
+	try {
+		if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+	} catch (err) {
+		logger.warn(`clearContextTokensForAccount: failed to remove ${filePath}: ${String(err)}`);
+	}
+	logger.info(`clearContextTokensForAccount: cleared tokens for account=${accountId}`);
+}
+/** Store a context token for a given account+user pair (memory + disk). */
+function setContextToken(accountId, userId, token) {
+	const k = contextTokenKey(accountId, userId);
+	logger.debug(`setContextToken: key=${k}`);
+	contextTokenStore.set(k, token);
+	persistContextTokens(accountId);
+}
+/** Retrieve the cached context token for a given account+user pair. */
+function getContextToken(accountId, userId) {
+	const k = contextTokenKey(accountId, userId);
+	const val = contextTokenStore.get(k);
+	logger.debug(`getContextToken: key=${k} found=${val !== void 0} storeSize=${contextTokenStore.size}`);
+	return val;
+}
+/**
+* Find all accountIds that have an active contextToken for the given userId.
+* Used to infer the sending bot account from the recipient address when
+* accountId is not explicitly provided (e.g. cron delivery).
+*
+* Returns all matching accountIds (not just the first) so the caller can
+* detect ambiguity when multiple accounts have sessions with the same user.
+*/
+function findAccountIdsByContextToken(accountIds, userId) {
+	return accountIds.filter((id) => contextTokenStore.has(contextTokenKey(id, userId)));
+}
+function generateMessageSid() {
+	return generateId("openclaw-weixin");
+}
+/** Returns true if the message item is a media type (image, video, file, or voice). */
+function isMediaItem(item) {
+	return item.type === MessageItemType.IMAGE || item.type === MessageItemType.VIDEO || item.type === MessageItemType.FILE || item.type === MessageItemType.VOICE;
+}
+function bodyFromItemList(itemList) {
+	if (!itemList?.length) return "";
+	for (const item of itemList) {
+		if (item.type === MessageItemType.TEXT && item.text_item?.text != null) {
+			const text = String(item.text_item.text);
+			const ref = item.ref_msg;
+			if (!ref) return text;
+			if (ref.message_item && isMediaItem(ref.message_item)) return text;
+			const parts = [];
+			if (ref.title) parts.push(ref.title);
+			if (ref.message_item) {
+				const refBody = bodyFromItemList([ref.message_item]);
+				if (refBody) parts.push(refBody);
+			}
+			if (!parts.length) return text;
+			return `[引用: ${parts.join(" | ")}]\n${text}`;
+		}
+		if (item.type === MessageItemType.VOICE && item.voice_item?.text) return item.voice_item.text;
+	}
+	return "";
+}
+/**
+* Convert a WeixinMessage from getUpdates to the inbound MsgContext for the core pipeline.
+* Media: only pass MediaPath (local file, after CDN download + decrypt).
+* We never pass MediaUrl — the upstream CDN URL is encrypted/auth-only.
+* Priority when multiple media types present: image > video > file > voice.
+*/
+function weixinMessageToMsgContext(msg, accountId, opts) {
+	const from_user_id = msg.from_user_id ?? "";
+	const ctx = {
+		Body: bodyFromItemList(msg.item_list),
+		From: from_user_id,
+		To: from_user_id,
+		AccountId: accountId,
+		OriginatingChannel: "openclaw-weixin",
+		OriginatingTo: from_user_id,
+		MessageSid: generateMessageSid(),
+		Timestamp: msg.create_time_ms,
+		Provider: "openclaw-weixin",
+		ChatType: "direct"
+	};
+	if (msg.context_token) ctx.context_token = msg.context_token;
+	if (opts?.decryptedPicPath) {
+		ctx.MediaPath = opts.decryptedPicPath;
+		ctx.MediaType = "image/*";
+	} else if (opts?.decryptedVideoPath) {
+		ctx.MediaPath = opts.decryptedVideoPath;
+		ctx.MediaType = "video/mp4";
+	} else if (opts?.decryptedFilePath) {
+		ctx.MediaPath = opts.decryptedFilePath;
+		ctx.MediaType = opts.fileMediaType ?? "application/octet-stream";
+	} else if (opts?.decryptedVoicePath) {
+		ctx.MediaPath = opts.decryptedVoicePath;
+		ctx.MediaType = opts.voiceMediaType ?? "audio/wav";
+	}
+	return ctx;
+}
+/** Extract the context_token from an inbound WeixinMsgContext. */
+function getContextTokenFromMsgContext(ctx) {
+	return ctx.context_token;
+}
+//#endregion
+//#region extensions/weixin/src/messaging/outbound-hooks.ts
+const CHANNEL_ID = "openclaw-weixin";
+/**
+* Run message_sending hook before sending.
+* Returns the (possibly modified) text content plus a cancelled flag.
+* Hook errors are caught and logged — sending proceeds regardless.
+*/
+async function applyWeixinMessageSendingHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("message_sending")) return {
+		cancelled: false,
+		text: params.text
+	};
+	try {
+		const hookResult = await hookRunner.runMessageSending({
+			to: params.to,
+			content: params.text,
+			metadata: {
+				channel: CHANNEL_ID,
+				accountId: params.accountId,
+				runId: params.runId,
+				...params.mediaUrl ? { mediaUrls: [params.mediaUrl] } : {}
+			}
+		}, {
+			channelId: CHANNEL_ID,
+			accountId: params.accountId
+		});
+		if (hookResult?.cancel) return {
+			cancelled: true,
+			text: params.text
+		};
+		return {
+			cancelled: false,
+			text: hookResult?.content ?? params.text
+		};
+	} catch (err) {
+		logger.warn(`message_sending hook error, proceeding with send: ${String(err)}`);
+		return {
+			cancelled: false,
+			text: params.text
+		};
+	}
+}
+/**
+* Fire message_sent hook (fire-and-forget) after a send attempt.
+*/
+function emitWeixinMessageSent(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("message_sent")) return;
+	const canonical = buildCanonicalSentMessageHookContext({
+		to: params.to,
+		content: params.content,
+		success: params.success,
+		error: params.error,
+		channelId: CHANNEL_ID,
+		accountId: params.accountId,
+		conversationId: params.to,
+		runId: params.runId
+	});
+	fireAndForgetHook(Promise.resolve(hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "weixin: message_sent plugin hook failed");
+}
+//#endregion
+//#region extensions/weixin/src/messaging/markdown-filter.ts
+/**
+* Streaming markdown filter — character-level state machine that strips
+* unsupported markdown syntax on-the-fly.
+*
+* Outputs as much filtered text as possible on each `feed()` call, only
+* holding back the minimum characters needed for pattern disambiguation
+* (e.g. a trailing `*` that might become `***`).
+*
+* Constructs passed through (not filtered):
+* - Code fences (```)
+* - Inline code (`)
+* - Tables (|...|)
+* - Horizontal rules (---, ***, ___)
+* - Bold (**)
+* - Italic/bold-italic wrapping non-CJK content
+*
+* Constructs filtered (markers stripped, content kept):
+* - Italic/bold-italic wrapping CJK content
+* - Headings H5/H6 (#####, ######)
+* - Images (![alt](url)) — removed entirely
+*
+* States:
+* - **sol** (start-of-line): checks for line-start patterns (```, >, #####, indent)
+* - **body**: scans for inline patterns (![, ~~, ***) and outputs safe chars
+* - **fence**: inside a fenced code block, passes through until closing ```
+* - **inline**: accumulating content inside an inline marker pair
+*/
+var StreamingMarkdownFilter = class StreamingMarkdownFilter {
+	constructor() {
+		this.buf = "";
+		this.fence = false;
+		this.sol = true;
+		this.inl = null;
+	}
+	feed(delta) {
+		this.buf += delta;
+		return this.pump(false);
+	}
+	flush() {
+		return this.pump(true);
+	}
+	pump(eof) {
+		let out = "";
+		while (this.buf) {
+			const sLen = this.buf.length;
+			const sSol = this.sol;
+			const sFence = this.fence;
+			const sInl = this.inl;
+			if (this.fence) out += this.pumpFence(eof);
+			else if (this.inl) out += this.pumpInline(eof);
+			else if (this.sol) out += this.pumpSOL(eof);
+			else out += this.pumpBody(eof);
+			if (this.buf.length === sLen && this.sol === sSol && this.fence === sFence && this.inl === sInl) break;
+		}
+		if (eof && this.inl) {
+			out += ({
+				image: "![",
+				bold3: "***",
+				italic: "*",
+				ubold3: "___",
+				uitalic: "_"
+			}[this.inl.type] ?? "") + this.inl.acc;
+			this.inl = null;
+		}
+		return out;
+	}
+	/** Inside a code fence: pass content and markers through verbatim. */
+	pumpFence(eof) {
+		if (this.sol) {
+			if (this.buf.length < 3 && !eof) return "";
+			if (this.buf.startsWith("```")) {
+				const nl = this.buf.indexOf("\n", 3);
+				if (nl !== -1) {
+					this.fence = false;
+					const line = this.buf.slice(0, nl + 1);
+					this.buf = this.buf.slice(nl + 1);
+					this.sol = true;
+					return line;
+				}
+				if (eof) {
+					this.fence = false;
+					const line = this.buf;
+					this.buf = "";
+					return line;
+				}
+				return "";
+			}
+			this.sol = false;
+		}
+		const nl = this.buf.indexOf("\n");
+		if (nl !== -1) {
+			const chunk = this.buf.slice(0, nl + 1);
+			this.buf = this.buf.slice(nl + 1);
+			this.sol = true;
+			return chunk;
+		}
+		const chunk = this.buf;
+		this.buf = "";
+		return chunk;
+	}
+	/** At start of line: detect and consume line-start patterns, then transition to body. */
+	pumpSOL(eof) {
+		const b = this.buf;
+		if (b[0] === "\n") {
+			this.buf = b.slice(1);
+			return "\n";
+		}
+		if (b[0] === "`") {
+			if (b.length < 3 && !eof) return "";
+			if (b.startsWith("```")) {
+				const nl = b.indexOf("\n", 3);
+				if (nl !== -1) {
+					this.fence = true;
+					const line = b.slice(0, nl + 1);
+					this.buf = b.slice(nl + 1);
+					this.sol = true;
+					return line;
+				}
+				if (eof) {
+					this.buf = "";
+					return b;
+				}
+				return "";
+			}
+			this.sol = false;
+			return "";
+		}
+		if (b[0] === ">") {
+			this.sol = false;
+			return "";
+		}
+		if (b[0] === "#") {
+			let n = 0;
+			while (n < b.length && b[n] === "#") n++;
+			if (n === b.length && !eof) return "";
+			if (n >= 5 && n <= 6 && n < b.length && b[n] === " ") {
+				this.buf = b.slice(n + 1);
+				this.sol = false;
+				return "";
+			}
+			this.sol = false;
+			return "";
+		}
+		if (b[0] === " " || b[0] === "	") {
+			if (b.search(/[^ \t]/) === -1 && !eof) return "";
+			this.sol = false;
+			return "";
+		}
+		if (b[0] === "-" || b[0] === "*" || b[0] === "_") {
+			const ch = b[0];
+			let j = 0;
+			while (j < b.length && (b[j] === ch || b[j] === " ")) j++;
+			if (j === b.length && !eof) return "";
+			if (j === b.length || b[j] === "\n") {
+				let count = 0;
+				for (let k = 0; k < j; k++) if (b[k] === ch) count++;
+				if (count >= 3) {
+					if (j < b.length) {
+						this.buf = b.slice(j + 1);
+						this.sol = true;
+						return b.slice(0, j + 1);
+					}
+					this.buf = "";
+					return b;
+				}
+			}
+			this.sol = false;
+			return "";
+		}
+		this.sol = false;
+		return "";
+	}
+	/** Scan line body for inline pattern triggers; output safe chars eagerly. */
+	pumpBody(eof) {
+		let out = "";
+		let i = 0;
+		while (i < this.buf.length) {
+			const c = this.buf[i];
+			if (c === "\n") {
+				out += this.buf.slice(0, i + 1);
+				this.buf = this.buf.slice(i + 1);
+				this.sol = true;
+				return out;
+			}
+			if (c === "!" && i + 1 < this.buf.length && this.buf[i + 1] === "[") {
+				out += this.buf.slice(0, i);
+				this.buf = this.buf.slice(i + 2);
+				this.inl = {
+					type: "image",
+					acc: ""
+				};
+				return out;
+			}
+			if (c === "~") {
+				i++;
+				continue;
+			}
+			if (c === "*") {
+				if (i + 2 < this.buf.length && this.buf[i + 1] === "*" && this.buf[i + 2] === "*") {
+					out += this.buf.slice(0, i);
+					this.buf = this.buf.slice(i + 3);
+					this.inl = {
+						type: "bold3",
+						acc: ""
+					};
+					return out;
+				}
+				if (i + 1 < this.buf.length && this.buf[i + 1] === "*") {
+					i += 2;
+					continue;
+				}
+				if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== "\n") {
+					out += this.buf.slice(0, i);
+					this.buf = this.buf.slice(i + 1);
+					this.inl = {
+						type: "italic",
+						acc: ""
+					};
+					return out;
+				}
+				i++;
+				continue;
+			}
+			if (c === "_") {
+				if (i + 2 < this.buf.length && this.buf[i + 1] === "_" && this.buf[i + 2] === "_") {
+					out += this.buf.slice(0, i);
+					this.buf = this.buf.slice(i + 3);
+					this.inl = {
+						type: "ubold3",
+						acc: ""
+					};
+					return out;
+				}
+				if (i + 1 < this.buf.length && this.buf[i + 1] === "_") {
+					i += 2;
+					continue;
+				}
+				if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== "\n") {
+					out += this.buf.slice(0, i);
+					this.buf = this.buf.slice(i + 1);
+					this.inl = {
+						type: "uitalic",
+						acc: ""
+					};
+					return out;
+				}
+				i++;
+				continue;
+			}
+			i++;
+		}
+		let hold = 0;
+		if (!eof) {
+			if (this.buf.endsWith("**")) hold = 2;
+			else if (this.buf.endsWith("__")) hold = 2;
+			else if (this.buf.endsWith("*")) hold = 1;
+			else if (this.buf.endsWith("_")) hold = 1;
+			else if (this.buf.endsWith("!")) hold = 1;
+		}
+		out += this.buf.slice(0, this.buf.length - hold);
+		this.buf = hold > 0 ? this.buf.slice(-hold) : "";
+		return out;
+	}
+	/** Accumulate inline content until closing marker is found. */
+	pumpInline(_eof) {
+		if (!this.inl) return "";
+		this.inl.acc += this.buf;
+		this.buf = "";
+		switch (this.inl.type) {
+			case "bold3": {
+				const idx = this.inl.acc.indexOf("***");
+				if (idx !== -1) {
+					const content = this.inl.acc.slice(0, idx);
+					this.buf = this.inl.acc.slice(idx + 3);
+					this.inl = null;
+					if (StreamingMarkdownFilter.containsCJK(content)) return content;
+					return `***${content}***`;
+				}
+				return "";
+			}
+			case "ubold3": {
+				const idx = this.inl.acc.indexOf("___");
+				if (idx !== -1) {
+					const content = this.inl.acc.slice(0, idx);
+					this.buf = this.inl.acc.slice(idx + 3);
+					this.inl = null;
+					if (StreamingMarkdownFilter.containsCJK(content)) return content;
+					return `___${content}___`;
+				}
+				return "";
+			}
+			case "italic":
+				for (let j = 0; j < this.inl.acc.length; j++) {
+					if (this.inl.acc[j] === "\n") {
+						const r = "*" + this.inl.acc.slice(0, j + 1);
+						this.buf = this.inl.acc.slice(j + 1);
+						this.inl = null;
+						this.sol = true;
+						return r;
+					}
+					if (this.inl.acc[j] === "*") {
+						if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "*") {
+							j++;
+							continue;
+						}
+						const content = this.inl.acc.slice(0, j);
+						this.buf = this.inl.acc.slice(j + 1);
+						this.inl = null;
+						if (StreamingMarkdownFilter.containsCJK(content)) return content;
+						return `*${content}*`;
+					}
+				}
+				return "";
+			case "uitalic":
+				for (let j = 0; j < this.inl.acc.length; j++) {
+					if (this.inl.acc[j] === "\n") {
+						const r = "_" + this.inl.acc.slice(0, j + 1);
+						this.buf = this.inl.acc.slice(j + 1);
+						this.inl = null;
+						this.sol = true;
+						return r;
+					}
+					if (this.inl.acc[j] === "_") {
+						if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "_") {
+							j++;
+							continue;
+						}
+						const content = this.inl.acc.slice(0, j);
+						this.buf = this.inl.acc.slice(j + 1);
+						this.inl = null;
+						if (StreamingMarkdownFilter.containsCJK(content)) return content;
+						return `_${content}_`;
+					}
+				}
+				return "";
+			case "image": {
+				const cb = this.inl.acc.indexOf("]");
+				if (cb === -1) return "";
+				if (cb + 1 >= this.inl.acc.length) return "";
+				if (this.inl.acc[cb + 1] !== "(") {
+					const r = "![" + this.inl.acc.slice(0, cb + 1);
+					this.buf = this.inl.acc.slice(cb + 1);
+					this.inl = null;
+					return r;
+				}
+				const cp = this.inl.acc.indexOf(")", cb + 2);
+				if (cp !== -1) {
+					this.buf = this.inl.acc.slice(cp + 1);
+					this.inl = null;
+					return "";
+				}
+				return "";
+			}
+		}
+		return "";
+	}
+	static containsCJK(text) {
+		return /[\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF]/.test(text);
+	}
+};
+//#endregion
+//#region extensions/weixin/src/messaging/send.ts
+function generateClientId() {
+	return generateId("openclaw-weixin");
+}
+/** Build a SendMessageReq containing a single text message. */
+function buildTextMessageReq(params) {
+	const { to, text, contextToken, runId, clientId } = params;
+	const item_list = text ? [{
+		type: MessageItemType.TEXT,
+		text_item: { text }
+	}] : [];
+	return { msg: {
+		from_user_id: "",
+		to_user_id: to,
+		client_id: clientId,
+		message_type: MessageType.BOT,
+		message_state: MessageState.FINISH,
+		item_list: item_list.length ? item_list : void 0,
+		context_token: contextToken ?? void 0,
+		run_id: runId ?? void 0
+	} };
+}
+/** Build a SendMessageReq from a reply payload (text only; image send uses sendImageMessageWeixin). */
+function buildSendMessageReq(params) {
+	const { to, contextToken, runId, payload, clientId } = params;
+	return buildTextMessageReq({
+		to,
+		text: payload.text ?? "",
+		contextToken,
+		runId,
+		clientId
+	});
+}
+/**
+* Send a plain text message downstream.
+*/
+async function sendMessageWeixin(params) {
+	const { to, text, opts } = params;
+	if (!opts.contextToken) logger.warn(`sendMessageWeixin: contextToken missing for to=${to}, sending without context`);
+	const clientId = generateClientId();
+	const req = buildSendMessageReq({
+		to,
+		contextToken: opts.contextToken,
+		runId: opts.runId,
+		payload: { text },
+		clientId
+	});
+	try {
+		await sendMessage({
+			baseUrl: opts.baseUrl,
+			token: opts.token,
+			timeoutMs: opts.timeoutMs,
+			body: req
+		});
+	} catch (err) {
+		logger.error(`sendMessageWeixin: failed to=${to} clientId=${clientId} err=${String(err)}`);
+		throw err;
+	}
+	return { messageId: clientId };
+}
+/** Send a single structured MessageItem downstream. */
+async function sendMessageItemWeixin(params) {
+	const { to, item, opts } = params;
+	if (!opts.contextToken) logger.warn(`sendMessageItemWeixin: contextToken missing for to=${to}, sending without context`);
+	const clientId = params.clientId ?? generateClientId();
+	const req = { msg: {
+		from_user_id: "",
+		to_user_id: to,
+		client_id: clientId,
+		message_type: MessageType.BOT,
+		message_state: MessageState.FINISH,
+		item_list: [item],
+		context_token: opts.contextToken ?? void 0,
+		run_id: opts.runId
+	} };
+	try {
+		await sendMessage({
+			baseUrl: opts.baseUrl,
+			token: opts.token,
+			timeoutMs: opts.timeoutMs,
+			body: req
+		});
+	} catch (err) {
+		logger.error(`${params.label ?? "sendMessageItemWeixin"}: failed to=${to} clientId=${clientId} err=${String(err)}`);
+		throw err;
+	}
+	return { messageId: clientId };
+}
+/**
+* Send one or more MessageItems (optionally preceded by a text caption) downstream.
+* Each item is sent as its own request so that item_list always has exactly one entry.
+*/
+async function sendMediaItems(params) {
+	const { to, text, mediaItem, opts, label } = params;
+	const runId = opts.runId;
+	const items = [];
+	if (text) items.push({
+		type: MessageItemType.TEXT,
+		text_item: { text }
+	});
+	items.push(mediaItem);
+	let lastClientId = "";
+	for (const item of items) {
+		lastClientId = generateClientId();
+		const req = { msg: {
+			from_user_id: "",
+			to_user_id: to,
+			client_id: lastClientId,
+			message_type: MessageType.BOT,
+			message_state: MessageState.FINISH,
+			item_list: [item],
+			context_token: opts.contextToken ?? void 0,
+			run_id: runId
+		} };
+		try {
+			await sendMessage({
+				baseUrl: opts.baseUrl,
+				token: opts.token,
+				timeoutMs: opts.timeoutMs,
+				body: req
+			});
+		} catch (err) {
+			logger.error(`${label}: failed to=${to} clientId=${lastClientId} err=${String(err)}`);
+			throw err;
+		}
+	}
+	logger.info(`${label}: success to=${to} clientId=${lastClientId}`);
+	return { messageId: lastClientId };
+}
+/**
+* Send an image message downstream using a previously uploaded file.
+* Optionally include a text caption as a separate TEXT item before the image.
+*
+* ImageItem fields:
+*   - media.encrypt_query_param: CDN download param
+*   - media.aes_key: AES key, base64-encoded
+*   - mid_size: original ciphertext file size
+*/
+async function sendImageMessageWeixin(params) {
+	const { to, text, uploaded, opts } = params;
+	if (!opts.contextToken) logger.warn(`sendImageMessageWeixin: contextToken missing for to=${to}, sending without context`);
+	logger.info(`sendImageMessageWeixin: to=${to} filekey=${uploaded.filekey} fileSize=${uploaded.fileSize} aeskey=present`);
+	return sendMediaItems({
+		to,
+		text,
+		mediaItem: {
+			type: MessageItemType.IMAGE,
+			image_item: {
+				media: {
+					encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+					aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+					encrypt_type: 1
+				},
+				mid_size: uploaded.fileSizeCiphertext
+			}
+		},
+		opts,
+		label: "sendImageMessageWeixin"
+	});
+}
+/**
+* Send a video message downstream using a previously uploaded file.
+* VideoItem: media (CDN ref), video_size (ciphertext bytes).
+* Includes an optional text caption sent as a separate TEXT item first.
+*/
+async function sendVideoMessageWeixin(params) {
+	const { to, text, uploaded, opts } = params;
+	if (!opts.contextToken) logger.warn(`sendVideoMessageWeixin: contextToken missing for to=${to}, sending without context`);
+	return sendMediaItems({
+		to,
+		text,
+		mediaItem: {
+			type: MessageItemType.VIDEO,
+			video_item: {
+				media: {
+					encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+					aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+					encrypt_type: 1
+				},
+				video_size: uploaded.fileSizeCiphertext
+			}
+		},
+		opts,
+		label: "sendVideoMessageWeixin"
+	});
+}
+/**
+* Send a file attachment downstream using a previously uploaded file.
+* FileItem: media (CDN ref), file_name, len (plaintext bytes as string).
+* Includes an optional text caption sent as a separate TEXT item first.
+*/
+async function sendFileMessageWeixin(params) {
+	const { to, text, fileName, uploaded, opts } = params;
+	if (!opts.contextToken) logger.warn(`sendFileMessageWeixin: contextToken missing for to=${to}, sending without context`);
+	return sendMediaItems({
+		to,
+		text,
+		mediaItem: {
+			type: MessageItemType.FILE,
+			file_item: {
+				media: {
+					encrypt_query_param: uploaded.downloadEncryptedQueryParam,
+					aes_key: Buffer.from(uploaded.aeskey).toString("base64"),
+					encrypt_type: 1
+				},
+				file_name: fileName,
+				len: String(uploaded.fileSize)
+			}
+		},
+		opts,
+		label: "sendFileMessageWeixin"
+	});
+}
+//#endregion
+//#region extensions/weixin/src/messaging/send-media.ts
+/**
+* Upload a local file and send it as a weixin message, routing by MIME type:
+*   video/*  → uploadVideoToWeixin        + sendVideoMessageWeixin
+*   image/*  → uploadFileToWeixin         + sendImageMessageWeixin
+*   else     → uploadFileAttachmentToWeixin + sendFileMessageWeixin
+*
+* Used by both the auto-reply deliver path (monitor.ts) and the outbound
+* sendMedia path (channel.ts) so they stay in sync.
+*/
+async function sendWeixinMediaFile(params) {
+	const { filePath, to, text, opts, cdnBaseUrl } = params;
+	const mime = getMimeFromFilename(filePath);
+	const uploadOpts = {
+		baseUrl: opts.baseUrl,
+		token: opts.token
+	};
+	if (mime.startsWith("video/")) {
+		logger.info(`[weixin] sendWeixinMediaFile: uploading video filePath=${filePath} to=${to}`);
+		const uploaded = await uploadVideoToWeixin({
+			filePath,
+			toUserId: to,
+			opts: uploadOpts,
+			cdnBaseUrl
+		});
+		logger.info(`[weixin] sendWeixinMediaFile: video upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`);
+		return sendVideoMessageWeixin({
+			to,
+			text,
+			uploaded,
+			opts
+		});
+	}
+	if (mime.startsWith("image/")) {
+		logger.info(`[weixin] sendWeixinMediaFile: uploading image filePath=${filePath} to=${to}`);
+		const uploaded = await uploadFileToWeixin({
+			filePath,
+			toUserId: to,
+			opts: uploadOpts,
+			cdnBaseUrl
+		});
+		logger.info(`[weixin] sendWeixinMediaFile: image upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`);
+		return sendImageMessageWeixin({
+			to,
+			text,
+			uploaded,
+			opts
+		});
+	}
+	const fileName = path.basename(filePath);
+	logger.info(`[weixin] sendWeixinMediaFile: uploading file attachment filePath=${filePath} name=${fileName} to=${to}`);
+	const uploaded = await uploadFileAttachmentToWeixin({
+		filePath,
+		fileName,
+		toUserId: to,
+		opts: uploadOpts,
+		cdnBaseUrl
+	});
+	logger.info(`[weixin] sendWeixinMediaFile: file upload done filekey=${uploaded.filekey} size=${uploaded.fileSize}`);
+	return sendFileMessageWeixin({
+		to,
+		text,
+		fileName,
+		uploaded,
+		opts
+	});
+}
+//#endregion
+export { sendTyping as A, registerWeixinAccountId as B, pauseSession as C, getUpdates as D, getConfig as E, clearStaleAccountsForUserId as F, logger as G, saveWeixinAccount as H, deriveRawAccountId as I, resolveStateDir as K, listIndexedWeixinAccountIds as L, redactToken as M, CDN_BASE_URL as N, notifyStart as O, DEFAULT_BASE_URL as P, listWeixinAccountIds as R, getRemainingPauseMs as S, apiPostFetch as T, triggerWeixinChannelReload as U, resolveWeixinAccount as V, readFrameworkAllowFromList as W, TypingStatus as _, applyWeixinMessageSendingHook as a, decryptAesEcb as b, findAccountIdsByContextToken as c, isMediaItem as d, restoreContextTokens as f, MessageItemType as g, downloadRemoteImageToTemp as h, StreamingMarkdownFilter as i, redactBody as j, notifyStop as k, getContextToken as l, weixinMessageToMsgContext as m, sendMessageItemWeixin as n, emitWeixinMessageSent as o, setContextToken as p, sendMessageWeixin as r, clearContextTokensForAccount as s, sendWeixinMediaFile as t, getContextTokenFromMsgContext as u, getMimeFromFilename as v, apiGetFetch as w, assertSessionActive as x, buildCdnDownloadUrl as y, loadWeixinAccount as z };