@yanhaidao/wecom 2.4.120 → 2.5.110

package/dist/src/channel.js

@@ -0,0 +1,224 @@
+import { deleteAccountFromConfigSection, setAccountEnabledInConfigSection, } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID, listWecomAccountIds, resolveDerivedPathSummary, resolveDefaultWecomAccountId, resolveWecomAccount, resolveWecomAccountConflict, } from "./config/index.js";
+import { monitorWecomProvider } from "./gateway-monitor.js";
+import { wecomSetupWizard } from "./onboarding.js";
+import { wecomOutbound } from "./outbound.js";
+const meta = {
+    id: "wecom",
+    label: "WeCom (企业微信)",
+    selectionLabel: "WeCom (企业微信)",
+    docsPath: "/channels/wecom",
+    docsLabel: "企业微信",
+    blurb: "企业微信官方推荐三方插件，默认 Bot WS 配置简单，支持主动发消息与 Agent 全能力。",
+    selectionDocsPrefix: "文档：",
+    aliases: ["wechatwork", "wework", "qywx", "企微", "企业微信"],
+    order: 85,
+    quickstartAllowFrom: true,
+};
+function resolveAccountInboundPath(account) {
+    const derivedPaths = resolveDerivedPathSummary(account.accountId);
+    if (account.bot?.primaryTransport === "webhook" && account.bot.webhookConfigured) {
+        return derivedPaths.botWebhook[0];
+    }
+    if (account.agent?.callbackConfigured) {
+        return derivedPaths.agentCallback[0];
+    }
+    return undefined;
+}
+function normalizeWecomMessagingTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (/^wecom-agent(?:-upstream)?:/i.test(trimmed)) {
+        return trimmed;
+    }
+    if (/^(wecom|wechatwork|wework|qywx):(user|group|chat|party|dept|tag|context):/i.test(trimmed)) {
+        return trimmed;
+    }
+    return trimmed.replace(/^(wecom|wechatwork|wework|qywx):/i, "").trim() || undefined;
+}
+export const wecomPlugin = {
+    id: "wecom",
+    meta,
+    setupWizard: wecomSetupWizard,
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        nativeCommands: false,
+        blockStreaming: false,
+    },
+    reload: { configPrefixes: ["channels.wecom"] },
+    // A permissive schema keeps config UX working while preventing startup failures.
+    configSchema: {
+        schema: {
+            type: "object",
+            additionalProperties: true,
+            properties: {},
+        },
+    },
+    config: {
+        listAccountIds: (cfg) => listWecomAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveWecomAccount({ cfg: cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultWecomAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg: cfg,
+            sectionKey: "wecom",
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg: cfg,
+            sectionKey: "wecom",
+            accountId,
+            clearBaseFields: ["bot", "agent"],
+        }),
+        isConfigured: (account, cfg) => {
+            if (!account.configured) {
+                return false;
+            }
+            return !resolveWecomAccountConflict({
+                cfg: cfg,
+                accountId: account.accountId,
+            });
+        },
+        unconfiguredReason: (account, cfg) => resolveWecomAccountConflict({
+            cfg: cfg,
+            accountId: account.accountId,
+        })?.message ?? "not configured",
+        describeAccount: (account, cfg) => {
+            const conflict = resolveWecomAccountConflict({
+                cfg: cfg,
+                accountId: account.accountId,
+            });
+            return {
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured: account.configured && !conflict,
+                webhookPath: resolveAccountInboundPath(account),
+            };
+        },
+        resolveAllowFrom: ({ cfg, accountId }) => {
+            const account = resolveWecomAccount({
+                cfg: cfg,
+                accountId,
+            });
+            // 与其他渠道保持一致：直接返回 allowFrom，空则允许所有人
+            const allowFrom = account.agent?.config.dm?.allowFrom ?? account.bot?.config.dm?.allowFrom ?? [];
+            return allowFrom.map((entry) => String(entry));
+        },
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => String(entry).trim())
+            .filter(Boolean)
+            .map((entry) => entry.toLowerCase()),
+    },
+    // security 配置在 WeCom 中不需要，框架会通过 resolveAllowFrom 自动判断
+    groups: {
+        // WeCom bots are usually mention-gated by the platform in groups already.
+        resolveRequireMention: () => true,
+    },
+    threading: {
+        resolveReplyToMode: () => "off",
+    },
+    messaging: {
+        normalizeTarget: normalizeWecomMessagingTarget,
+        targetResolver: {
+            looksLikeId: (raw) => Boolean(raw.trim()),
+            hint: "<userid|chatid>",
+        },
+    },
+    outbound: {
+        ...wecomOutbound,
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            webhookPath: snapshot.webhookPath ?? null,
+            transport: snapshot.transport ?? null,
+            ownerId: snapshot.ownerId ?? null,
+            health: snapshot.health ?? "idle",
+            ownerDriftAt: snapshot.ownerDriftAt ?? null,
+            connected: snapshot.connected,
+            authenticated: snapshot.authenticated,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+            lastErrorAt: snapshot.lastErrorAt ?? null,
+            lastInboundAt: snapshot.lastInboundAt ?? null,
+            lastOutboundAt: snapshot.lastOutboundAt ?? null,
+            recentInboundSummary: snapshot.recentInboundSummary ?? null,
+            recentOutboundSummary: snapshot.recentOutboundSummary ?? null,
+            recentIssueCategory: snapshot.recentIssueCategory ?? null,
+            recentIssueSummary: snapshot.recentIssueSummary ?? null,
+            transportSessions: snapshot.transportSessions ?? [],
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async () => ({ ok: true }),
+        buildAccountSnapshot: ({ account, runtime, cfg }) => {
+            const conflict = resolveWecomAccountConflict({
+                cfg: cfg,
+                accountId: account.accountId,
+            });
+            return {
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured: account.configured && !conflict,
+                webhookPath: resolveAccountInboundPath(account),
+                primaryTransport: account.bot?.primaryTransport ?? (account.agent ? "agent-callback" : null),
+                transport: runtime?.transport ?? null,
+                ownerId: runtime?.ownerId ?? null,
+                health: runtime?.health ?? "idle",
+                ownerDriftAt: runtime?.ownerDriftAt ?? null,
+                connected: runtime?.connected,
+                authenticated: runtime?.authenticated,
+                running: runtime?.running ?? false,
+                lastStartAt: runtime?.lastStartAt ?? null,
+                lastStopAt: runtime?.lastStopAt ?? null,
+                lastError: runtime?.lastError ?? conflict?.message ?? null,
+                lastErrorAt: runtime?.lastErrorAt ?? null,
+                lastInboundAt: runtime?.lastInboundAt ?? null,
+                lastOutboundAt: runtime?.lastOutboundAt ?? null,
+                recentInboundSummary: runtime?.recentInboundSummary ??
+                    null,
+                recentOutboundSummary: runtime
+                    ?.recentOutboundSummary ?? null,
+                recentIssueCategory: runtime?.recentIssueCategory ??
+                    null,
+                recentIssueSummary: runtime?.recentIssueSummary ??
+                    null,
+                transportSessions: runtime?.transportSessions ?? [],
+                dmPolicy: account.bot?.config.dm?.policy ?? "pairing",
+            };
+        },
+    },
+    gateway: {
+        /**
+         * **startAccount (启动账号)**
+         *
+         * WeCom lifecycle is long-running: keep webhook targets active until
+         * gateway stop/reload aborts the account.
+         */
+        startAccount: monitorWecomProvider,
+        stopAccount: async (ctx) => {
+            ctx.setStatus({
+                accountId: ctx.account.accountId,
+                running: false,
+                lastStopAt: Date.now(),
+            });
+        },
+    },
+};

package/dist/src/config/accounts.js

@@ -0,0 +1,236 @@
+export const DEFAULT_ACCOUNT_ID = "default";
+function toNumber(value) {
+    if (value == null)
+        return undefined;
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function resolveBotAccount(accountId, config, network) {
+    const primaryTransport = config.primaryTransport ?? (config.ws ? "ws" : "webhook");
+    const wsConfigured = Boolean(config.ws?.botId && config.ws?.secret);
+    const webhookConfigured = Boolean(config.webhook?.token && config.webhook?.encodingAESKey);
+    const configured = primaryTransport === "ws" ? wsConfigured : webhookConfigured;
+    return {
+        accountId,
+        configured,
+        primaryTransport,
+        wsConfigured,
+        webhookConfigured,
+        config,
+        network,
+        ws: config.ws
+            ? {
+                botId: config.ws.botId,
+                secret: config.ws.secret,
+            }
+            : undefined,
+        webhook: config.webhook
+            ? {
+                token: config.webhook.token,
+                encodingAESKey: config.webhook.encodingAESKey,
+                receiveId: config.webhook.receiveId?.trim() ?? "",
+            }
+            : undefined,
+        token: config.webhook?.token ?? "",
+        encodingAESKey: config.webhook?.encodingAESKey ?? "",
+        receiveId: config.webhook?.receiveId?.trim() ?? "",
+        botId: config.ws?.botId ?? "",
+        secret: config.ws?.secret ?? "",
+    };
+}
+function resolveAgentAccount(accountId, config, network) {
+    const agentId = toNumber(config.agentId);
+    const callbackConfigured = Boolean(config.token && config.encodingAESKey);
+    const normalizedAgentSecret = config.agentSecret?.trim() || config.corpSecret?.trim() || "";
+    const apiConfigured = Boolean(config.corpId && normalizedAgentSecret && agentId);
+    return {
+        accountId,
+        configured: callbackConfigured || apiConfigured,
+        callbackConfigured,
+        apiConfigured,
+        corpId: config.corpId,
+        corpSecret: normalizedAgentSecret,
+        agentId,
+        token: config.token,
+        encodingAESKey: config.encodingAESKey,
+        config,
+        network,
+    };
+}
+function toResolvedAccount(params) {
+    const bot = params.config.bot
+        ? resolveBotAccount(params.accountId, params.config.bot, params.network)
+        : undefined;
+    const agent = params.config.agent
+        ? resolveAgentAccount(params.accountId, params.config.agent, params.network)
+        : undefined;
+    return {
+        accountId: params.accountId,
+        name: params.name,
+        enabled: params.enabled,
+        configured: Boolean(bot?.configured || agent?.configured),
+        config: params.config,
+        bot,
+        agent,
+    };
+}
+function createMissingResolvedAccount(accountId) {
+    return {
+        accountId,
+        enabled: false,
+        configured: false,
+        config: {},
+    };
+}
+export function detectMode(config) {
+    if (!config || config.enabled === false)
+        return "disabled";
+    if (config.accounts && Object.keys(config.accounts).length > 0) {
+        return "matrix";
+    }
+    if (config.bot || config.agent) {
+        return "legacy";
+    }
+    return "disabled";
+}
+function resolveMatrixAccounts(wecom) {
+    const resolved = {};
+    for (const [rawId, entry] of Object.entries(wecom.accounts ?? {})) {
+        const accountId = rawId.trim();
+        if (!accountId || !entry)
+            continue;
+        resolved[accountId] = toResolvedAccount({
+            accountId,
+            enabled: wecom.enabled !== false && entry.enabled !== false,
+            name: entry.name,
+            config: entry,
+            network: wecom.network,
+        });
+    }
+    return resolved;
+}
+function resolveLegacyAccounts(wecom) {
+    const config = {
+        bot: wecom.bot,
+        agent: wecom.agent,
+    };
+    return {
+        [DEFAULT_ACCOUNT_ID]: toResolvedAccount({
+            accountId: DEFAULT_ACCOUNT_ID,
+            enabled: wecom.enabled !== false,
+            config,
+            network: wecom.network,
+        }),
+    };
+}
+function normalizeKey(value) {
+    return value.trim().toLowerCase();
+}
+function collectWecomAccountConflicts(cfg) {
+    const resolved = resolveWecomAccounts(cfg);
+    const conflicts = new Map();
+    const botOwners = new Map();
+    const agentOwners = new Map();
+    for (const accountId of Object.keys(resolved.accounts).sort((a, b) => a.localeCompare(b))) {
+        const account = resolved.accounts[accountId];
+        if (!account || account.enabled === false)
+            continue;
+        const botId = account.bot?.botId?.trim();
+        if (botId) {
+            const key = normalizeKey(botId);
+            const owner = botOwners.get(key);
+            if (owner && owner !== accountId) {
+                conflicts.set(accountId, {
+                    type: "duplicate_bot_id",
+                    accountId,
+                    ownerAccountId: owner,
+                    message: `Duplicate WeCom botId: account "${accountId}" shares botId with account "${owner}". ` +
+                        "Keep one owner account per botId.",
+                });
+            }
+            else {
+                botOwners.set(key, accountId);
+            }
+        }
+        const corpId = account.agent?.corpId?.trim();
+        const agentId = account.agent?.agentId;
+        if (corpId && typeof agentId === "number") {
+            const key = `${normalizeKey(corpId)}:${agentId}`;
+            const owner = agentOwners.get(key);
+            if (owner && owner !== accountId) {
+                conflicts.set(accountId, {
+                    type: "duplicate_agent_id",
+                    accountId,
+                    ownerAccountId: owner,
+                    message: `Duplicate WeCom agent identity: account "${accountId}" shares corpId/agentId (${corpId}/${agentId}) with account "${owner}". ` +
+                        "Keep one owner account per corpId/agentId pair.",
+                });
+            }
+            else {
+                agentOwners.set(key, accountId);
+            }
+        }
+    }
+    return conflicts;
+}
+export function resolveWecomAccountConflict(params) {
+    return collectWecomAccountConflicts(params.cfg).get(params.accountId);
+}
+export function listWecomAccountIds(cfg) {
+    const wecom = cfg.channels?.wecom;
+    const mode = detectMode(wecom);
+    if (mode === "matrix") {
+        return Object.keys(wecom?.accounts ?? {})
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    if (mode === "legacy") {
+        return [DEFAULT_ACCOUNT_ID];
+    }
+    return [];
+}
+export function resolveDefaultWecomAccountId(cfg) {
+    const wecom = cfg.channels?.wecom;
+    const ids = listWecomAccountIds(cfg);
+    if (wecom?.defaultAccount && ids.includes(wecom.defaultAccount)) {
+        return wecom.defaultAccount;
+    }
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+export function resolveWecomAccounts(cfg) {
+    const wecom = cfg.channels?.wecom ?? {};
+    const mode = detectMode(wecom);
+    const accounts = mode === "matrix" ? resolveMatrixAccounts(wecom) : mode === "legacy" ? resolveLegacyAccounts(wecom) : {};
+    const defaultAccountId = resolveDefaultWecomAccountId(cfg);
+    return {
+        mode,
+        defaultAccountId,
+        accounts,
+        bot: accounts[defaultAccountId]?.bot,
+        agent: accounts[defaultAccountId]?.agent,
+    };
+}
+export function resolveWecomAccount(params) {
+    const resolved = resolveWecomAccounts(params.cfg);
+    const explicitAccountId = params.accountId?.trim();
+    const accountId = explicitAccountId || resolved.defaultAccountId;
+    const direct = resolved.accounts[accountId];
+    if (direct) {
+        return direct;
+    }
+    // Treat the literal "default" as an alias for the configured default account.
+    // This keeps generic onboarding flows working even when the first WeCom account
+    // was created under a custom id like "haidao" instead of a literal "default".
+    if (explicitAccountId === DEFAULT_ACCOUNT_ID) {
+        const fallback = resolved.accounts[resolved.defaultAccountId];
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return createMissingResolvedAccount(accountId);
+}
+export function isWecomEnabled(cfg) {
+    const resolved = resolveWecomAccounts(cfg);
+    return Object.values(resolved.accounts).some((account) => account.enabled && account.configured);
+}

package/dist/src/config/derived-paths.js

@@ -0,0 +1,31 @@
+import { DEFAULT_ACCOUNT_ID } from "./accounts.js";
+import { WEBHOOK_PATHS } from "../types/constants.js";
+export function resolveDerivedPath(params) {
+    const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+    const isDefault = accountId === DEFAULT_ACCOUNT_ID;
+    if (params.transport === "bot-webhook") {
+        return isDefault
+            ? [
+                `${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`,
+                `${WEBHOOK_PATHS.BOT}/${accountId}`,
+                WEBHOOK_PATHS.BOT_PLUGIN,
+                WEBHOOK_PATHS.BOT_ALT,
+                WEBHOOK_PATHS.BOT,
+            ]
+            : [`${WEBHOOK_PATHS.BOT_PLUGIN}/${accountId}`];
+    }
+    return isDefault
+        ? [
+            `${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`,
+            `${WEBHOOK_PATHS.AGENT}/${accountId}`,
+            WEBHOOK_PATHS.AGENT_PLUGIN,
+            WEBHOOK_PATHS.AGENT,
+        ]
+        : [`${WEBHOOK_PATHS.AGENT_PLUGIN}/${accountId}`];
+}
+export function resolveDerivedPathSummary(accountId) {
+    return {
+        botWebhook: resolveDerivedPath({ accountId, transport: "bot-webhook" }),
+        agentCallback: resolveDerivedPath({ accountId, transport: "agent-callback" }),
+    };
+}

package/dist/src/config/index.js

@@ -0,0 +1,7 @@
+export { WecomConfigSchema } from "./schema.js";
+export { DEFAULT_ACCOUNT_ID, detectMode, listWecomAccountIds, resolveDefaultWecomAccountId, resolveWecomAccount, resolveWecomAccountConflict, resolveWecomAccounts, isWecomEnabled, } from "./accounts.js";
+export { resolveWecomRuntimeAccount, resolveWecomRuntimeConfig } from "./runtime-config.js";
+export { resolveDerivedPath, resolveDerivedPathSummary } from "./derived-paths.js";
+export { resolveWecomEgressProxyUrl, resolveWecomEgressProxyUrlFromNetwork, resolveWecomMediaDownloadTimeoutMs, } from "./network.js";
+export { DEFAULT_WECOM_MEDIA_MAX_BYTES, getWecomDefaultMediaLocalRoots, resolveWecomConfiguredMediaLocalRoots, resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots, } from "./media.js";
+export { resolveWecomFailClosedOnDefaultRoute, shouldRejectWecomDefaultRoute } from "./routing.js";

package/dist/src/config/media.js

@@ -0,0 +1,110 @@
+import os from "node:os";
+import path from "node:path";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
+// 默认给一个相对“够用”的上限（80MB），避免视频/较大文件频繁触发失败。
+// 仍保留上限以防止恶意大文件把进程内存打爆（下载实现会读入内存再保存）。
+export const DEFAULT_WECOM_MEDIA_MAX_BYTES = 80 * 1024 * 1024;
+function parsePositiveNumber(value) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+}
+function resolveStateDirForWecomMedia() {
+    const stateOverride = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+    if (stateOverride) {
+        return stateOverride;
+    }
+    return path.join(os.homedir(), ".openclaw");
+}
+function normalizeWecomLocalRoot(root) {
+    const trimmed = root.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return path.resolve(trimmed.replace(/^~(?=\/|$)/, os.homedir()));
+}
+function getWecomCommonUserMediaLocalRoots() {
+    const home = os.homedir();
+    return [
+        path.join(home, "Desktop"),
+        path.join(home, "Documents"),
+        path.join(home, "Downloads"),
+        path.join(home, "Movies"),
+        path.join(home, "Pictures"),
+    ];
+}
+export function getWecomDefaultMediaLocalRoots() {
+    const stateDir = path.resolve(resolveStateDirForWecomMedia());
+    return [
+        path.resolve(resolvePreferredOpenClawTmpDir()),
+        stateDir,
+        path.join(stateDir, "media"),
+        path.join(stateDir, "agents"),
+        path.join(stateDir, "workspace"),
+        path.join(stateDir, "sandboxes"),
+        ...getWecomCommonUserMediaLocalRoots(),
+    ];
+}
+export function resolveWecomConfiguredMediaLocalRoots(cfg) {
+    const rawWecom = cfg.channels?.wecom;
+    const configured = Array.isArray(rawWecom?.media?.localRoots)
+        ? rawWecom.media.localRoots
+        : Array.isArray(rawWecom?.mediaLocalRoots)
+            ? rawWecom.mediaLocalRoots
+            : [];
+    return configured
+        .filter((root) => typeof root === "string")
+        .map(normalizeWecomLocalRoot)
+        .filter((root) => Boolean(root));
+}
+export function resolveWecomMergedMediaLocalRoots(params) {
+    const merged = [];
+    const seen = new Set();
+    const pushRoot = (root) => {
+        const normalized = normalizeWecomLocalRoot(root);
+        if (!normalized || seen.has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        merged.push(normalized);
+    };
+    for (const root of getWecomDefaultMediaLocalRoots()) {
+        pushRoot(root);
+    }
+    for (const root of params.baseRoots ?? []) {
+        pushRoot(root);
+    }
+    for (const root of resolveWecomConfiguredMediaLocalRoots(params.cfg)) {
+        pushRoot(root);
+    }
+    return merged;
+}
+function resolveLegacyWecomMediaMaxBytes(cfg) {
+    const raw = cfg.channels?.wecom?.media?.maxBytes;
+    const bytes = parsePositiveNumber(raw);
+    if (bytes) {
+        return Math.floor(bytes);
+    }
+    return undefined;
+}
+export function resolveWecomMediaMaxBytes(cfg, accountId) {
+    const mediaMaxBytes = resolveChannelMediaMaxBytes({
+        cfg,
+        accountId,
+        resolveChannelLimitMb: ({ cfg, accountId }) => {
+            const wecom = cfg.channels?.wecom;
+            const accountLimitMb = parsePositiveNumber(wecom?.accounts?.[accountId]?.mediaMaxMb);
+            if (accountLimitMb) {
+                return accountLimitMb;
+            }
+            return parsePositiveNumber(wecom?.mediaMaxMb);
+        },
+    });
+    if (mediaMaxBytes) {
+        return mediaMaxBytes;
+    }
+    return resolveLegacyWecomMediaMaxBytes(cfg) ?? DEFAULT_WECOM_MEDIA_MAX_BYTES;
+}

package/dist/src/config/network.js

@@ -0,0 +1,32 @@
+const DEFAULT_WECOM_MEDIA_DOWNLOAD_TIMEOUT_MS = 30_000;
+function parsePositiveInt(value) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return Math.floor(parsed);
+}
+export function resolveWecomEgressProxyUrlFromNetwork(network) {
+    const proxyUrl = network?.egressProxyUrl ??
+        process.env.OPENCLAW_WECOM_EGRESS_PROXY_URL ??
+        process.env.WECOM_EGRESS_PROXY_URL ??
+        process.env.HTTPS_PROXY ??
+        process.env.ALL_PROXY ??
+        process.env.HTTP_PROXY ??
+        "";
+    return proxyUrl.trim() || undefined;
+}
+export function resolveWecomEgressProxyUrl(cfg) {
+    const wecom = cfg.channels?.wecom;
+    return resolveWecomEgressProxyUrlFromNetwork(wecom?.network);
+}
+export function resolveWecomMediaDownloadTimeoutMs(cfg) {
+    const wecom = cfg.channels?.wecom;
+    const timeoutMs = parsePositiveInt(wecom?.media?.downloadTimeoutMs) ??
+        parsePositiveInt(wecom?.mediaDownloadTimeoutMs) ??
+        parsePositiveInt(wecom?.network?.mediaDownloadTimeoutMs) ??
+        parsePositiveInt(wecom?.network?.timeoutMs) ??
+        parsePositiveInt(process.env.OPENCLAW_WECOM_MEDIA_TIMEOUT_MS) ??
+        parsePositiveInt(process.env.WECOM_MEDIA_TIMEOUT_MS);
+    return timeoutMs ?? DEFAULT_WECOM_MEDIA_DOWNLOAD_TIMEOUT_MS;
+}

package/dist/src/config/routing.js

@@ -0,0 +1,20 @@
+import { detectMode } from "./accounts.js";
+/**
+ * 默认策略：
+ * - matrix（多账号）: 开启 fail-closed，防止未绑定账号回退到 main
+ * - legacy（单账号兼容）: 维持历史行为，不强制拦截
+ */
+export function resolveWecomFailClosedOnDefaultRoute(cfg) {
+    const wecom = cfg.channels?.wecom;
+    const explicit = wecom?.routing?.failClosedOnDefaultRoute;
+    if (typeof explicit === "boolean")
+        return explicit;
+    return detectMode(wecom) === "matrix";
+}
+export function shouldRejectWecomDefaultRoute(params) {
+    if (params.matchedBy !== "default")
+        return false;
+    if (params.useDynamicAgent)
+        return false;
+    return resolveWecomFailClosedOnDefaultRoute(params.cfg);
+}

package/dist/src/config/runtime-config.js

@@ -0,0 +1,25 @@
+import { resolveDerivedPathSummary } from "./derived-paths.js";
+import { DEFAULT_ACCOUNT_ID, resolveWecomAccount, resolveWecomAccounts } from "./accounts.js";
+export function resolveWecomRuntimeConfig(cfg) {
+    const raw = cfg.channels?.wecom;
+    const resolved = resolveWecomAccounts(cfg);
+    const accounts = Object.fromEntries(Object.entries(resolved.accounts).map(([accountId, account]) => [
+        accountId,
+        {
+            account,
+            derivedPaths: resolveDerivedPathSummary(accountId),
+        },
+    ]));
+    return {
+        raw,
+        defaultAccountId: resolved.defaultAccountId || DEFAULT_ACCOUNT_ID,
+        accounts,
+    };
+}
+export function resolveWecomRuntimeAccount(params) {
+    const account = resolveWecomAccount(params);
+    return {
+        account,
+        derivedPaths: resolveDerivedPathSummary(account.accountId),
+    };
+}