moltbot-wecom 1.0.2 → 2.0.0

package/clawdbot.plugin.json

@@ -0,0 +1,42 @@
+{
+  "id": "wecom",
+  "name": "WeCom",
+  "description": "WeCom (企业微信) channel plugin — WebSocket proxy Smart Bot",
+  "version": "1.0.0",
+  "channels": ["wecom"],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "proxyUrl": {
+        "type": "string",
+        "description": "WebSocket proxy URL (wss://...)"
+      },
+      "proxyToken": {
+        "type": "string",
+        "description": "Token for authenticating with the WebSocket proxy"
+      },
+      "dmPolicy": {
+        "type": "string",
+        "enum": ["pairing", "allowlist", "open", "disabled"],
+        "default": "pairing",
+        "description": "Direct message access policy"
+      },
+      "thinkingThresholdMs": {
+        "type": "number",
+        "default": 0,
+        "description": "Delay in ms before showing 'Thinking...' placeholder (0 to disable)"
+      },
+      "pingIntervalMs": {
+        "type": "number",
+        "default": 30000,
+        "description": "Heartbeat ping interval in milliseconds"
+      },
+      "reconnectDelayMs": {
+        "type": "number",
+        "default": 5000,
+        "description": "Reconnect delay after disconnect in milliseconds"
+      }
+    },
+    "additionalProperties": true
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * WeCom (Enterprise WeChat) channel plugin for Clawdbot/Moltbot.
+ *
+ * Connects WeCom Smart Bot via WebSocket proxy (no public server required).
+ */
+import type { ClawdbotPluginApi } from "clawdbot/plugin-sdk";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        properties: {
+            proxyUrl: {
+                type: "string";
+                description: string;
+            };
+            proxyToken: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: readonly [];
+        additionalProperties: true;
+    };
+    register(api: ClawdbotPluginApi): void;
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAK7D,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;kBAaI,iBAAiB;CAahC,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * WeCom (Enterprise WeChat) channel plugin for Clawdbot/Moltbot.
+ *
+ * Connects WeCom Smart Bot via WebSocket proxy (no public server required).
+ */
+import { wecomDock, wecomPlugin } from "./src/channel.js";
+import { setWeComRuntime } from "./src/runtime.js";
+const plugin = {
+    id: "wecom",
+    name: "WeCom",
+    description: "WeCom (Enterprise WeChat) channel plugin — WebSocket proxy bot",
+    configSchema: {
+        type: "object",
+        properties: {
+            proxyUrl: { type: "string", description: "WebSocket proxy URL" },
+            proxyToken: { type: "string", description: "Proxy authentication token" },
+        },
+        required: [],
+        additionalProperties: true,
+    },
+    register(api) {
+        setWeComRuntime(api.runtime);
+        // If plugin-level config has proxyUrl, start the client eagerly
+        const pluginCfg = api.pluginConfig;
+        if (pluginCfg?.proxyUrl) {
+            api.runtime.log?.info?.(`[wecom] Plugin config detected (proxyUrl=${pluginCfg.proxyUrl.slice(0, 30)}...)`);
+        }
+        api.registerChannel({ plugin: wecomPlugin, dock: wecomDock });
+    },
+};
+export default plugin;

package/dist/src/accounts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WeCom account resolution — multi-account support.
+ */
+import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { ResolvedWeComAccount } from "./types.js";
+/** List all configured WeCom account IDs (falls back to ["default"]). */
+export declare function listWeComAccountIds(cfg: ClawdbotConfig): string[];
+/** Resolve the default account ID. */
+export declare function resolveDefaultWeComAccountId(cfg: ClawdbotConfig): string;
+/** Fully resolve a WeCom account. */
+export declare function resolveWeComAccount(params: {
+    cfg: ClawdbotConfig;
+    accountId?: string | null;
+}): ResolvedWeComAccount;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/src/accounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../../src/accounts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAQpB,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,EAAE,CAIjE;AAED,sCAAsC;AACtC,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAMxE;AA8DD,qCAAqC;AACrC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,GAAG,EAAE,cAAc,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GAAG,oBAAoB,CAevB"}

package/dist/src/accounts.js

@@ -0,0 +1,90 @@
+/**
+ * WeCom account resolution — multi-account support.
+ */
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "clawdbot/plugin-sdk";
+function listConfiguredAccountIds(cfg) {
+    const accounts = cfg.channels?.wecom?.accounts;
+    if (!accounts || typeof accounts !== "object")
+        return [];
+    return Object.keys(accounts).filter(Boolean);
+}
+/** List all configured WeCom account IDs (falls back to ["default"]). */
+export function listWeComAccountIds(cfg) {
+    const ids = listConfiguredAccountIds(cfg);
+    if (ids.length === 0)
+        return [DEFAULT_ACCOUNT_ID];
+    return ids.sort((a, b) => a.localeCompare(b));
+}
+/** Resolve the default account ID. */
+export function resolveDefaultWeComAccountId(cfg) {
+    const wecomConfig = cfg.channels?.wecom;
+    if (wecomConfig?.defaultAccount?.trim())
+        return wecomConfig.defaultAccount.trim();
+    const ids = listWeComAccountIds(cfg);
+    if (ids.includes(DEFAULT_ACCOUNT_ID))
+        return DEFAULT_ACCOUNT_ID;
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountConfig(cfg, accountId) {
+    const accounts = cfg.channels?.wecom?.accounts;
+    if (!accounts || typeof accounts !== "object")
+        return undefined;
+    return accounts[accountId];
+}
+function mergeWeComAccountConfig(cfg, accountId) {
+    const raw = (cfg.channels?.wecom ?? {});
+    const { accounts: _ignored, defaultAccount: _ignored2, ...base } = raw;
+    const account = resolveAccountConfig(cfg, accountId) ?? {};
+    return { ...base, ...account };
+}
+/**
+ * Resolve proxyUrl + proxyToken for an account.
+ * Checks: account config → base config → plugin config → env.
+ */
+function resolveCredentials(cfg, merged) {
+    // From channel config
+    if (merged.proxyUrl?.trim()) {
+        return {
+            proxyUrl: merged.proxyUrl.trim(),
+            proxyToken: merged.proxyToken?.trim() ?? "",
+            source: "config",
+        };
+    }
+    // From plugin config (plugins.entries.wecom.config)
+    const pluginCfg = cfg.plugins;
+    const wecomPluginCfg = pluginCfg?.entries?.wecom?.config;
+    if (wecomPluginCfg?.proxyUrl?.trim()) {
+        return {
+            proxyUrl: wecomPluginCfg.proxyUrl.trim(),
+            proxyToken: wecomPluginCfg.proxyToken?.trim() ?? "",
+            source: "plugin",
+        };
+    }
+    // From environment variables
+    const envProxyUrl = process.env.WECOM_PROXY_URL ?? process.env.PROXY_URL;
+    const envProxyToken = process.env.WECOM_PROXY_TOKEN ?? process.env.PROXY_TOKEN;
+    if (envProxyUrl?.trim()) {
+        return {
+            proxyUrl: envProxyUrl.trim(),
+            proxyToken: envProxyToken?.trim() ?? "",
+            source: "env",
+        };
+    }
+    return { proxyUrl: "", proxyToken: "", source: "none" };
+}
+/** Fully resolve a WeCom account. */
+export function resolveWeComAccount(params) {
+    const { cfg, accountId: rawAccountId } = params;
+    const accountId = normalizeAccountId(rawAccountId);
+    const merged = mergeWeComAccountConfig(cfg, accountId);
+    const credentials = resolveCredentials(cfg, merged);
+    return {
+        accountId,
+        name: merged.name,
+        enabled: merged.enabled !== false,
+        proxyUrl: credentials.proxyUrl,
+        proxyToken: credentials.proxyToken,
+        tokenSource: credentials.source,
+        config: merged,
+    };
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WeCom ChannelPlugin + ChannelDock — core channel integration.
+ */
+import type { ChannelDock, ChannelPlugin } from "clawdbot/plugin-sdk";
+import type { ResolvedWeComAccount } from "./types.js";
+export declare const wecomDock: ChannelDock;
+export declare const wecomPlugin: ChannelPlugin<ResolvedWeComAccount>;
+//# sourceMappingURL=channel.d.ts.map

package/dist/src/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/channel.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAEV,WAAW,EACX,aAAa,EAEd,MAAM,qBAAqB,CAAC;AAgB7B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAuBvD,eAAO,MAAM,SAAS,EAAE,WA0BvB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,oBAAoB,CA6U3D,CAAC"}

package/dist/src/channel.js

@@ -0,0 +1,365 @@
+/**
+ * WeCom ChannelPlugin + ChannelDock — core channel integration.
+ */
+import { applyAccountNameToChannelSection, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, formatPairingApproveHint, migrateBaseNameToDefaultAccount, normalizeAccountId, setAccountEnabledInConfigSection, } from "clawdbot/plugin-sdk";
+import { listWeComAccountIds, resolveDefaultWeComAccountId, resolveWeComAccount, } from "./accounts.js";
+import { probeWeCom } from "./probe.js";
+import { collectWeComStatusIssues } from "./status-issues.js";
+import { startWeComProvider } from "./receive.js";
+const meta = {
+    id: "wecom",
+    label: "WeCom",
+    selectionLabel: "WeCom (企业微信)",
+    docsPath: "/channels/wecom",
+    docsLabel: "wecom",
+    blurb: "WeCom (Enterprise WeChat) Smart Bot with WebSocket proxy.",
+    aliases: ["wechat-work", "qywx", "企微"],
+    order: 86,
+    quickstartAllowFrom: true,
+};
+function normalizeWeComMessagingTarget(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.replace(/^(wecom|wechat-work|qywx):/i, "");
+}
+export const wecomDock = {
+    id: "wecom",
+    capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        blockStreaming: false,
+    },
+    outbound: { textChunkLimit: 2000 },
+    config: {
+        resolveAllowFrom: ({ cfg, accountId }) => (resolveWeComAccount({ cfg: cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => String(entry).trim())
+            .filter(Boolean)
+            .map((entry) => entry.replace(/^(wecom|wechat-work|qywx):/i, ""))
+            .map((entry) => entry.toLowerCase()),
+    },
+    groups: {
+        resolveRequireMention: () => true,
+    },
+    threading: {
+        resolveReplyToMode: () => "off",
+    },
+};
+export const wecomPlugin = {
+    id: "wecom",
+    meta,
+    capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        reactions: false,
+        threads: false,
+        polls: false,
+        nativeCommands: false,
+        blockStreaming: false,
+    },
+    reload: { configPrefixes: ["channels.wecom"] },
+    // Use JSON Schema directly instead of Zod to avoid toJSONSchema dependency
+    configSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            enabled: { type: "boolean" },
+            proxyUrl: { type: "string" },
+            proxyToken: { type: "string" },
+            dmPolicy: { type: "string", enum: ["pairing", "allowlist", "open", "disabled"] },
+            allowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
+            thinkingThresholdMs: { type: "number" },
+            botNames: { type: "array", items: { type: "string" } },
+            pingIntervalMs: { type: "number" },
+            reconnectDelayMs: { type: "number" },
+            accounts: { type: "object", additionalProperties: true },
+            defaultAccount: { type: "string" },
+        },
+        additionalProperties: true,
+    },
+    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: ["proxyUrl", "proxyToken", "name"],
+        }),
+        isConfigured: (account) => Boolean(account.proxyUrl?.trim()),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: Boolean(account.proxyUrl?.trim()),
+            tokenSource: account.tokenSource,
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => (resolveWeComAccount({ cfg: cfg, accountId }).config.allowFrom ?? []).map((entry) => String(entry)),
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => String(entry).trim())
+            .filter(Boolean)
+            .map((entry) => entry.replace(/^(wecom|wechat-work|qywx):/i, ""))
+            .map((entry) => entry.toLowerCase()),
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+            const wecomCfg = cfg.channels?.wecom;
+            const accountsMap = wecomCfg?.accounts;
+            const useAccountPath = Boolean(accountsMap?.[resolvedAccountId]);
+            const basePath = useAccountPath
+                ? `channels.wecom.accounts.${resolvedAccountId}.`
+                : "channels.wecom.";
+            return {
+                policy: account.config.dmPolicy ?? "pairing",
+                allowFrom: account.config.allowFrom ?? [],
+                policyPath: `${basePath}dmPolicy`,
+                allowFromPath: basePath,
+                approveHint: formatPairingApproveHint("wecom"),
+                normalizeEntry: (raw) => raw.replace(/^(wecom|wechat-work|qywx):/i, ""),
+            };
+        },
+    },
+    groups: {
+        resolveRequireMention: () => true,
+    },
+    threading: {
+        resolveReplyToMode: () => "off",
+    },
+    messaging: {
+        normalizeTarget: normalizeWeComMessagingTarget,
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return false;
+                // WeCom user IDs are typically alphanumeric strings
+                return /^[a-zA-Z0-9_-]{6,64}$/.test(trimmed);
+            },
+            hint: "<userId>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async ({ cfg, accountId, query, limit }) => {
+            const account = resolveWeComAccount({ cfg: cfg, accountId });
+            const q = query?.trim().toLowerCase() || "";
+            const peers = Array.from(new Set((account.config.allowFrom ?? [])
+                .map((entry) => String(entry).trim())
+                .filter((entry) => Boolean(entry) && entry !== "*")
+                .map((entry) => entry.replace(/^(wecom|wechat-work|qywx):/i, ""))))
+                .filter((id) => (q ? id.toLowerCase().includes(q) : true))
+                .slice(0, limit && limit > 0 ? limit : undefined)
+                .map((id) => ({ kind: "user", id }));
+            return peers;
+        },
+        listGroups: async () => [],
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg: cfg,
+            channelKey: "wecom",
+            accountId,
+            name: name,
+        }),
+        validateInput: ({ accountId, input }) => {
+            if (!input.proxyUrl) {
+                return "WeCom requires proxyUrl (WebSocket proxy URL).";
+            }
+            return null;
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg: cfg,
+                channelKey: "wecom",
+                accountId,
+                name: input.name,
+            });
+            const next = accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "wecom",
+                })
+                : namedConfig;
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        wecom: {
+                            ...next.channels?.wecom,
+                            enabled: true,
+                            ...(input.proxyUrl ? { proxyUrl: input.proxyUrl } : {}),
+                            ...(input.proxyToken ? { proxyToken: input.proxyToken } : {}),
+                        },
+                    },
+                };
+            }
+            const wecomCfg = (next.channels?.wecom ?? {});
+            const accountsCfg = (wecomCfg.accounts ?? {});
+            const existingAccount = (accountsCfg[accountId] ?? {});
+            return {
+                ...next,
+                channels: {
+                    ...(next.channels ?? {}),
+                    wecom: {
+                        ...wecomCfg,
+                        enabled: true,
+                        accounts: {
+                            ...accountsCfg,
+                            [accountId]: {
+                                ...existingAccount,
+                                enabled: true,
+                                ...(input.proxyUrl ? { proxyUrl: input.proxyUrl } : {}),
+                                ...(input.proxyToken ? { proxyToken: input.proxyToken } : {}),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    pairing: {
+        idLabel: "wecomUserId",
+        normalizeAllowEntry: (entry) => entry.replace(/^(wecom|wechat-work|qywx):/i, ""),
+        notifyApproval: async ({ cfg, id }) => {
+            // WeCom Smart Bot uses passive reply; cannot actively send messages
+            // Approval notification will happen on next user message
+            return;
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => {
+            if (!text)
+                return [];
+            if (limit <= 0 || text.length <= limit)
+                return [text];
+            const chunks = [];
+            let remaining = text;
+            while (remaining.length > limit) {
+                const window = remaining.slice(0, limit);
+                const lastNewline = window.lastIndexOf("\n");
+                const lastSpace = window.lastIndexOf(" ");
+                let breakIdx = lastNewline > 0 ? lastNewline : lastSpace;
+                if (breakIdx <= 0)
+                    breakIdx = limit;
+                const rawChunk = remaining.slice(0, breakIdx);
+                const chunk = rawChunk.trimEnd();
+                if (chunk.length > 0)
+                    chunks.push(chunk);
+                const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+                const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+                remaining = remaining.slice(nextStart).trimStart();
+            }
+            if (remaining.length)
+                chunks.push(remaining);
+            return chunks;
+        },
+        chunkerMode: "text",
+        textChunkLimit: 2000,
+        sendText: async ({ to, text, accountId, cfg }) => {
+            const account = resolveWeComAccount({
+                accountId: accountId ?? undefined,
+                cfg: cfg,
+            });
+            if (!account.proxyUrl) {
+                return { channel: "wecom", ok: false, messageId: "", error: new Error("WeCom proxy not configured") };
+            }
+            // WeCom Smart Bot uses passive reply mode
+            // Active messaging would require direct WeCom API access
+            return {
+                channel: "wecom",
+                ok: false,
+                messageId: "",
+                error: new Error("Active messaging not supported. Use reply flow."),
+            };
+        },
+        sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
+            // WeCom Smart Bot doesn't support media in passive reply mode
+            return {
+                channel: "wecom",
+                ok: false,
+                messageId: "",
+                error: new Error("Media not supported in WeCom Smart Bot mode"),
+            };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: collectWeComStatusIssues,
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            tokenSource: snapshot.tokenSource ?? "none",
+            running: snapshot.running ?? false,
+            mode: "websocket-proxy",
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+            probe: snapshot.probe,
+            lastProbeAt: snapshot.lastProbeAt ?? null,
+        }),
+        probeAccount: async ({ account, timeoutMs }) => probeWeCom(account.proxyUrl, account.proxyToken, timeoutMs),
+        buildAccountSnapshot: ({ account, runtime }) => {
+            const configured = Boolean(account.proxyUrl?.trim());
+            return {
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured,
+                tokenSource: account.tokenSource,
+                running: runtime?.running ?? false,
+                lastStartAt: runtime?.lastStartAt ?? null,
+                lastStopAt: runtime?.lastStopAt ?? null,
+                lastError: runtime?.lastError ?? null,
+                mode: "websocket-proxy",
+                lastInboundAt: runtime?.lastInboundAt ?? null,
+                lastOutboundAt: runtime?.lastOutboundAt ?? null,
+                dmPolicy: account.config.dmPolicy ?? "pairing",
+                proxyUrl: account.proxyUrl ? `${account.proxyUrl.slice(0, 30)}...` : undefined,
+            };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            try {
+                const probe = await probeWeCom(account.proxyUrl, account.proxyToken, 3000);
+                ctx.setStatus({ accountId: account.accountId, probe: probe.ok ? "ok" : "failed" });
+            }
+            catch {
+                // Ignore probe errors during startup
+            }
+            ctx.log?.info(`[${account.accountId}] Starting WeCom provider (proxy=${account.proxyUrl})`);
+            const provider = startWeComProvider({
+                account,
+                config: ctx.cfg,
+                log: {
+                    info: (msg) => ctx.log?.info(msg),
+                    error: (msg) => ctx.log?.error(msg),
+                    warn: (msg) => ctx.log?.warn?.(msg),
+                    debug: (msg) => ctx.log?.debug?.(msg),
+                },
+                abortSignal: ctx.abortSignal,
+                statusSink: (patch) => ctx.setStatus({ accountId: ctx.accountId, ...patch }),
+            });
+            return provider;
+        },
+    },
+};