opencode-copilot-account-switcher 0.14.5 → 0.14.7

package/dist/wechat/bind-flow.js

@@ -18,10 +18,10 @@ function toErrorMessage(error) {
     return String(error);
 }
 function pickQrTerminal(value) {
-    return pickFirstNonEmptyString(value?.terminalQr, value?.qrTerminal, value?.qrText, value?.asciiQr);
+    return pickFirstNonEmptyString(value?.qrTerminal);
 }
 function pickQrUrl(value) {
-    return pickFirstNonEmptyString(value?.qrDataUrl, value?.qrUrl, value?.url, value?.loginUrl);
+    return pickFirstNonEmptyString(value?.qrDataUrl);
 }
 function isTimeoutWaitResult(value) {
     return Boolean(value && typeof value === "object" && "status" in value && String(value.status) === "timeout");
@@ -33,6 +33,12 @@ async function rollbackBinding(action, previousOperatorBinding, persistOperatorR
     }
     await clearOperatorBinding().catch(() => { });
 }
+function isSameOperatorBinding(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    return left.wechatAccountId === right.wechatAccountId && left.userId === right.userId && left.boundAt === right.boundAt;
+}
 async function renderQrTerminalDefault(input) {
     return await new Promise((resolve) => {
         qrcodeTerminal.generate(input.value, { small: true }, (output) => {
@@ -57,7 +63,10 @@ export async function runWechatBindFlow(input) {
         const qrTerminal = pickQrTerminal(started);
         const qrUrl = pickQrUrl(started);
         const qrStartMessage = pickFirstNonEmptyString(started?.message, started?.detail, started?.reason);
-        const sessionKey = pickFirstNonEmptyString(started?.sessionKey, started?.key, started?.accountId);
+        const sessionKey = pickFirstNonEmptyString(started?.sessionKey);
+        if (!sessionKey) {
+            throw new Error("missing sessionKey from qr start");
+        }
         if (qrTerminal) {
             await writeLine(qrTerminal);
         }
@@ -78,49 +87,44 @@ export async function runWechatBindFlow(input) {
         if (waited && typeof waited === "object" && "connected" in waited && waited.connected === false) {
             throw new Error("qr login did not complete");
         }
-        const accountId = pickFirstNonEmptyString(waited?.accountId, helpers.latestAccountState?.accountId, (await helpers.accountHelpers.listAccountIds()).at(-1));
+        const accountId = pickFirstNonEmptyString(waited?.accountId);
         if (!accountId) {
             throw new Error("missing accountId after qr login");
         }
         const boundAt = now();
-        const userIdFromWait = pickFirstNonEmptyString(waited?.userId, waited?.openid, waited?.uid);
         const previousOperatorBinding = input.action === "wechat-rebind" ? await loadOperatorBinding() : undefined;
+        const userIdFromWait = pickFirstNonEmptyString(waited?.userId);
         let menuAccount;
         let boundUserId = "";
         let shouldRollbackBinding = false;
+        let attemptedOperatorBinding;
         try {
-            const menuAccountState = accountId
-                ? {
-                    ...(helpers.latestAccountState ?? {
-                        accountId,
-                        token: "",
-                        baseUrl: "https://ilinkai.weixin.qq.com",
-                    }),
-                    accountId,
-                    ...(userIdFromWait ? { userId: userIdFromWait } : {}),
-                    boundAt,
-                }
-                : helpers.latestAccountState;
+            const menuAccountState = {
+                accountId,
+                token: "",
+                baseUrl: "https://ilinkai.weixin.qq.com",
+            };
             menuAccount = await buildOpenClawMenuAccount({
                 latestAccountState: menuAccountState,
                 accountHelpers: helpers.accountHelpers,
             });
-            const userId = pickFirstNonEmptyString(userIdFromWait, menuAccount?.userId);
+            const userId = pickFirstNonEmptyString(menuAccount?.userId, userIdFromWait);
             if (!userId) {
                 throw new Error("missing userId after qr login");
             }
             boundUserId = userId;
-            const operatorBinding = {
+            attemptedOperatorBinding = {
                 wechatAccountId: accountId,
                 userId,
                 boundAt,
             };
-            shouldRollbackBinding = true;
             if (input.action === "wechat-rebind") {
-                await persistOperatorRebinding(operatorBinding);
+                shouldRollbackBinding = true;
+                await persistOperatorRebinding(attemptedOperatorBinding);
             }
             else {
-                await persistOperatorBinding(operatorBinding);
+                shouldRollbackBinding = true;
+                await persistOperatorBinding(attemptedOperatorBinding);
             }
             const settings = await input.readCommonSettings();
             const notifications = settings.wechat?.notifications ?? {
@@ -145,7 +149,15 @@ export async function runWechatBindFlow(input) {
         }
         catch (error) {
             if (shouldRollbackBinding) {
-                await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
+                if (input.action === "wechat-bind") {
+                    const currentOperatorBinding = await loadOperatorBinding().catch(() => undefined);
+                    if (isSameOperatorBinding(currentOperatorBinding, attemptedOperatorBinding)) {
+                        await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
+                    }
+                }
+                else {
+                    await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
+                }
             }
             throw error;
         }

package/dist/wechat/compat/openclaw-account-helpers.d.ts

@@ -0,0 +1,29 @@
+export type WeixinAccountHelpers = {
+    listAccountIds: () => Promise<string[]>;
+    resolveAccount: (accountId: string) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+    describeAccount: (accountIdOrInput: string | {
+        accountId: string;
+    }) => Promise<{
+        accountId: string;
+        enabled: boolean;
+        configured: boolean;
+        name?: string;
+        userId?: string;
+    }>;
+};
+type OpenClawAccountSourceHelpers = {
+    listAccountIds: () => string[] | Promise<string[]>;
+    loadAccount: (accountId: string) => unknown | Promise<unknown>;
+    resolveAccount: (accountId: string) => unknown | Promise<unknown>;
+};
+export declare function createOpenClawAccountHelpers(input: OpenClawAccountSourceHelpers): WeixinAccountHelpers;
+export declare function loadOpenClawAccountHelpers(options?: {
+    accountsModulePath?: string;
+}): Promise<WeixinAccountHelpers>;
+export {};

package/dist/wechat/compat/openclaw-account-helpers.js

@@ -0,0 +1,71 @@
+import { createRequire } from "node:module";
+import { createJiti } from "jiti";
+const OPENCLAW_WEIXIN_ACCOUNTS_MODULE = "@tencent-weixin/openclaw-weixin/src/auth/accounts.ts";
+let accountJitiLoader = null;
+function getAccountJiti() {
+    if (accountJitiLoader) {
+        return accountJitiLoader;
+    }
+    accountJitiLoader = createJiti(import.meta.url, {
+        interopDefault: true,
+        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    });
+    return accountJitiLoader;
+}
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function deriveEnabled(resolved) {
+    return resolved.enabled === true;
+}
+function isConfigured(resolved) {
+    return resolved.configured === true;
+}
+function toAccountId(input) {
+    return typeof input === "string" ? input : input.accountId;
+}
+export function createOpenClawAccountHelpers(input) {
+    const resolveStableAccount = async (accountId) => {
+        const resolved = asObject(await input.resolveAccount(accountId));
+        const stored = asObject(await input.loadAccount(accountId));
+        return {
+            accountId,
+            enabled: deriveEnabled(resolved),
+            configured: isConfigured(resolved),
+            name: typeof resolved.name === "string" ? resolved.name : undefined,
+            userId: typeof stored.userId === "string" ? stored.userId : undefined,
+        };
+    };
+    return {
+        async listAccountIds() {
+            const ids = await input.listAccountIds();
+            return Array.isArray(ids) ? ids.filter((it) => typeof it === "string" && it.length > 0) : [];
+        },
+        async resolveAccount(accountId) {
+            return resolveStableAccount(accountId);
+        },
+        async describeAccount(accountIdOrInput) {
+            return resolveStableAccount(toAccountId(accountIdOrInput));
+        },
+    };
+}
+export async function loadOpenClawAccountHelpers(options = {}) {
+    const require = createRequire(import.meta.url);
+    const accountsModulePath = require.resolve(options.accountsModulePath ?? OPENCLAW_WEIXIN_ACCOUNTS_MODULE);
+    const accountsModule = getAccountJiti()(accountsModulePath);
+    if (typeof accountsModule.listIndexedWeixinAccountIds !== "function" || typeof accountsModule.loadWeixinAccount !== "function") {
+        throw new Error("[wechat-compat] account source helper unavailable");
+    }
+    return createOpenClawAccountHelpers({
+        listAccountIds: () => accountsModule.listIndexedWeixinAccountIds(),
+        loadAccount: (accountId) => accountsModule.loadWeixinAccount(accountId),
+        resolveAccount: async (accountId) => {
+            const stored = asObject(await accountsModule.loadWeixinAccount(accountId));
+            return {
+                accountId,
+                enabled: stored.enabled === false ? false : true,
+                configured: typeof stored.token === "string" && stored.token.trim().length > 0,
+            };
+        },
+    });
+}

package/dist/wechat/compat/openclaw-guided-smoke.d.ts

@@ -102,6 +102,7 @@ export type RunGuidedSmokeOptions = {
     publicHelpersOptions?: OpenClawWeixinPublicHelpersLoaderOptions;
     slashCaptureWaitTimeoutMs?: number;
     slashCapturePollIntervalMs?: number;
+    writeLine?: (line: string) => Promise<void> | void;
 };
 type PreflightData = {
     runId: string;

package/dist/wechat/compat/openclaw-guided-smoke.js

@@ -43,8 +43,11 @@ const DEFAULT_KEY_FIELDS_CHECK = {
 const DEFAULT_SLASH_CAPTURE_WAIT_TIMEOUT_MS = 180_000;
 const DEFAULT_SLASH_CAPTURE_POLL_INTERVAL_MS = 2_000;
 const DEFAULT_PUBLIC_GET_UPDATES_LONG_POLL_TIMEOUT_MS = 35_000;
-function printGuidedPrompt(message) {
-    process.stdout.write(`${message}\n`);
+async function writeLineDefault(line) {
+    process.stdout.write(`${line}\n`);
+}
+async function printGuidedPrompt(message, writeLine) {
+    await writeLine(message);
 }
 function createRunId() {
     return new Date().toISOString().replace(/[:.]/g, "-");
@@ -390,15 +393,18 @@ async function runQrLoginDefault(input) {
         timeoutMs: input.waitTimeoutMs,
         verbose: false,
     }));
-    const qrTerminal = pickFirstString(startResult, ["terminalQr", "qrTerminal", "qrText", "asciiQr"]);
-    const qrUrl = pickFirstString(startResult, ["qrDataUrl", "qrUrl", "url", "loginUrl"]);
-    const sessionKey = pickFirstString(startResult, ["sessionKey", "accountId"]);
+    const qrTerminal = pickFirstString(startResult, ["qrTerminal"]);
+    const qrUrl = pickFirstString(startResult, ["qrDataUrl"]);
+    const sessionKey = pickFirstString(startResult, ["sessionKey"]);
     const qrStartMessage = pickFirstString(startResult, ["message", "detail", "reason"]);
+    if (!sessionKey) {
+        throw new Error("missing sessionKey from qr start");
+    }
     if (qrTerminal) {
-        process.stdout.write(`${qrTerminal}\n`);
+        await input.writeLine(qrTerminal);
     }
     else if (qrUrl) {
-        process.stdout.write(`QR URL fallback: ${qrUrl}\n`);
+        await input.writeLine(`QR URL fallback: ${qrUrl}`);
     }
     else {
         throw new Error(qrStartMessage || "invalid qr login result: missing qr code or qr url");
@@ -625,7 +631,7 @@ async function runDefaultNonSlashVerification(input) {
     };
 }
 export const runDefaultNonSlashVerificationForTest = runDefaultNonSlashVerification;
-async function runSlashSampling(run, captureSlashInbound) {
+async function runSlashSampling(run, captureSlashInbound, writeLine) {
     const harness = createOpenClawSmokeHarness({ mode: "real-account" });
     for (const step of SLASH_SAMPLE_STEPS) {
         const inbound = await captureSlashInbound(step.command);
@@ -648,13 +654,13 @@ async function runSlashSampling(run, captureSlashInbound) {
             };
         }
         if (step.command === "status") {
-            printGuidedPrompt("已收到 `/status`，下一步请发送 `/reply smoke`");
+            await printGuidedPrompt("已收到 `/status`，下一步请发送 `/reply smoke`", writeLine);
         }
         else if (step.command === "reply") {
-            printGuidedPrompt("已收到 `/reply smoke`，下一步请发送 `/allow once`");
+            await printGuidedPrompt("已收到 `/reply smoke`，下一步请发送 `/allow once`", writeLine);
         }
         else {
-            printGuidedPrompt("已收到 `/allow once`，下一步开始发送 10 条普通文本");
+            await printGuidedPrompt("已收到 `/allow once`，下一步开始发送 10 条普通文本", writeLine);
         }
     }
     return { ok: true };
@@ -689,23 +695,13 @@ function normalizeQrLoginResult(result) {
         return null;
     }
     if (candidate.status === "success") {
-        if (typeof candidate.connected === "boolean" && candidate.connected !== true) {
-            return {
-                status: "timeout",
-                qrPrinted: candidate.qrPrinted === true,
-                qrUrl: typeof candidate.qrDataUrl === "string" && candidate.qrDataUrl.trim().length > 0
-                    ? candidate.qrDataUrl
-                    : typeof candidate.qrUrl === "string"
-                        ? candidate.qrUrl
-                        : undefined,
-            };
+        if (candidate.connected !== true) {
+            return null;
         }
         const hasPrintedQr = candidate.qrPrinted === true;
         const qrUrl = typeof candidate.qrDataUrl === "string" && candidate.qrDataUrl.trim().length > 0
             ? candidate.qrDataUrl
-            : typeof candidate.qrUrl === "string" && candidate.qrUrl.trim().length > 0
-                ? candidate.qrUrl
-                : undefined;
+            : undefined;
         const hasQrUrl = Boolean(qrUrl);
         if (!hasPrintedQr && !hasQrUrl) {
             return null;
@@ -713,9 +709,7 @@ function normalizeQrLoginResult(result) {
     }
     const normalizedQrUrl = typeof candidate.qrDataUrl === "string" && candidate.qrDataUrl.trim().length > 0
         ? candidate.qrDataUrl
-        : typeof candidate.qrUrl === "string"
-            ? candidate.qrUrl
-            : undefined;
+        : undefined;
     return {
         status: candidate.status,
         connected: candidate.connected === true ? true : undefined,
@@ -819,6 +813,7 @@ async function completeWithNoGoFinalEvidence(run, input, goNoGoDocPath) {
 export async function runGuidedSmoke(options = {}) {
     const run = createGuidedSmokeRun(options);
     const waitTimeoutMs = options.qrWaitTimeoutMs ?? DEFAULT_QR_WAIT_TIMEOUT_MS;
+    const writeLine = options.writeLine ?? writeLineDefault;
     const slashCaptureState = {};
     const loadOpenClawPublicHelpers = options.loadOpenClawWeixinPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
     let cachedPublicHelpers = null;
@@ -839,7 +834,11 @@ export async function runGuidedSmoke(options = {}) {
     const getDependencyVersions = options.getDependencyVersions ?? resolveDependencyVersionsFromPackageJson;
     const runQrLogin = options.runQrLogin ?? (async (input) => {
         const helpers = await getPublicHelpers();
-        return runQrLoginDefault({ ...input, qrGateway: helpers.qrGateway });
+        return runQrLoginDefault({
+            ...input,
+            qrGateway: helpers.qrGateway,
+            writeLine,
+        });
     });
     const captureSlashInbound = options.captureSlashInbound ?? ((command) => captureSlashInboundDefault(command, {
         state: slashCaptureState,
@@ -957,7 +956,7 @@ export async function runGuidedSmoke(options = {}) {
             }, goNoGoDocPath);
         }
         await writeLoginSuccessEvidence(run, "success", waitTimeoutMs);
-        printGuidedPrompt("二维码登录成功，下一步请发送 `/status`");
+        await printGuidedPrompt("二维码登录成功，下一步请发送 `/status`", writeLine);
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
@@ -971,7 +970,7 @@ export async function runGuidedSmoke(options = {}) {
     }
     let slashSampling;
     try {
-        slashSampling = await runSlashSampling(run, captureSlashInbound);
+        slashSampling = await runSlashSampling(run, captureSlashInbound, writeLine);
     }
     catch (error) {
         return failWithFinalEvidence(run, {
@@ -1053,7 +1052,7 @@ export async function runGuidedSmoke(options = {}) {
                 keyFields: nonSlashVerification.keyFieldsCheck,
             }, goNoGoDocPath);
         }
-        printGuidedPrompt(`普通文本验证进度：${index + 1}/${attempts.length}`);
+        await printGuidedPrompt(`普通文本验证进度：${index + 1}/${attempts.length}`, writeLine);
     }
     const nonSlashPassed = nonSlashVerification.passed === 10 && nonSlashVerification.total === 10;
     if (!nonSlashPassed) {

package/dist/wechat/compat/openclaw-public-entry.d.ts

@@ -0,0 +1,33 @@
+type CompatHostApi = {
+    runtime?: {
+        channelRuntime?: unknown;
+        gateway?: {
+            startAccount?: unknown;
+        };
+    };
+    registerChannel?: (input: unknown) => void;
+    registerCli?: (handler: unknown, options?: unknown) => void;
+};
+type OpenClawWeixinPlugin = {
+    id?: string;
+    register(api: CompatHostApi): void;
+};
+export type OpenClawWeixinPublicEntry = {
+    packageJsonPath: string;
+    packageRoot: string;
+    extensions: string[];
+    entryRelativePath: string;
+    entryAbsolutePath: string;
+};
+export declare function resolveOpenClawWeixinPublicEntry(): Promise<OpenClawWeixinPublicEntry>;
+export declare function loadOpenClawWeixinDefaultExport(): Promise<OpenClawWeixinPlugin>;
+export declare function loadRegisteredWeixinPluginPayloads(): Promise<Array<{
+    plugin?: unknown;
+}>>;
+export declare function loadRegisteredWeixinPluginContext(): Promise<{
+    pluginId: string;
+    payloads: Array<{
+        plugin?: unknown;
+    }>;
+}>;
+export {};

package/dist/wechat/compat/openclaw-public-entry.js

@@ -0,0 +1,73 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createJiti } from "jiti";
+let publicJitiLoader = null;
+function requireField(condition, message) {
+    if (!condition) {
+        throw new Error(`[wechat-compat] ${message}`);
+    }
+}
+function getPublicJiti() {
+    if (publicJitiLoader) {
+        return publicJitiLoader;
+    }
+    publicJitiLoader = createJiti(import.meta.url, {
+        interopDefault: true,
+        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    });
+    return publicJitiLoader;
+}
+export async function resolveOpenClawWeixinPublicEntry() {
+    const require = createRequire(import.meta.url);
+    const packageName = "@tencent-weixin/openclaw-weixin";
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageJsonRaw = await readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonRaw);
+    const extensions = Array.isArray(packageJson.openclaw?.extensions)
+        ? packageJson.openclaw?.extensions.filter((it) => typeof it === "string")
+        : [];
+    requireField(extensions.length > 0, `${packageName} openclaw.extensions[0] is required`);
+    const entryRelativePath = extensions[0];
+    requireField(Boolean(entryRelativePath?.startsWith("./")), `${packageName} openclaw.extensions[0] must start with ./`);
+    const packageRoot = path.dirname(packageJsonPath);
+    const entryAbsolutePath = path.resolve(packageRoot, entryRelativePath);
+    return {
+        packageJsonPath,
+        packageRoot,
+        extensions,
+        entryRelativePath,
+        entryAbsolutePath,
+    };
+}
+export async function loadOpenClawWeixinDefaultExport() {
+    const entry = await resolveOpenClawWeixinPublicEntry();
+    const moduleNamespace = getPublicJiti()(entry.entryAbsolutePath);
+    const plugin = moduleNamespace.default;
+    if (!plugin || typeof plugin !== "object" || typeof plugin.register !== "function") {
+        throw new Error("[wechat-compat] @tencent-weixin/openclaw-weixin public entry default export is missing register(api)");
+    }
+    return plugin;
+}
+export async function loadRegisteredWeixinPluginPayloads() {
+    const context = await loadRegisteredWeixinPluginContext();
+    return context.payloads;
+}
+export async function loadRegisteredWeixinPluginContext() {
+    const payloads = [];
+    const plugin = await loadOpenClawWeixinDefaultExport();
+    plugin.register({
+        runtime: {
+            channelRuntime: { mode: "guided-smoke" },
+            gateway: { startAccount: { source: "guided-smoke" } },
+        },
+        registerChannel(payload) {
+            payloads.push(payload);
+        },
+        registerCli() { },
+    });
+    return {
+        pluginId: typeof plugin.id === "string" && plugin.id.trim().length > 0 ? plugin.id : "wechat-openclaw-weixin",
+        payloads,
+    };
+}

package/dist/wechat/compat/openclaw-public-helpers.d.ts

@@ -1,63 +1,14 @@
+import { loadOpenClawAccountHelpers, type WeixinAccountHelpers } from "./openclaw-account-helpers.js";
+import { loadRegisteredWeixinPluginContext, loadRegisteredWeixinPluginPayloads, resolveOpenClawWeixinPublicEntry, type OpenClawWeixinPublicEntry } from "./openclaw-public-entry.js";
+import { type WeixinQrGateway } from "./openclaw-qr-gateway.js";
+import { loadOpenClawUpdatesAndSendHelpers, type PublicWeixinMessage, type PublicWeixinSendMessage } from "./openclaw-updates-send.js";
+import { loadLatestWeixinAccountState, loadOpenClawSyncBufHelper, type PublicWeixinPersistGetUpdatesBuf } from "./openclaw-sync-buf.js";
 export declare const OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES: {
     readonly stateDir: "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts";
     readonly syncBuf: "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts";
     readonly getUpdates: "@tencent-weixin/openclaw-weixin/src/api/api.ts";
     readonly sendMessageWeixin: "@tencent-weixin/openclaw-weixin/src/messaging/send.ts";
 };
-type WeixinQrGateway = {
-    loginWithQrStart: (input?: unknown) => unknown;
-    loginWithQrWait: (input?: unknown) => unknown;
-};
-export type WeixinAccountHelpers = {
-    listAccountIds: () => Promise<string[]>;
-    resolveAccount: (accountId: string) => Promise<unknown>;
-    describeAccount: (accountIdOrInput: string | {
-        accountId: string;
-    }) => Promise<unknown>;
-};
-export type OpenClawWeixinPublicEntry = {
-    packageJsonPath: string;
-    packageRoot: string;
-    extensions: string[];
-    entryRelativePath: string;
-    entryAbsolutePath: string;
-};
-declare function resolveOpenClawWeixinPublicEntry(): Promise<OpenClawWeixinPublicEntry>;
-declare function loadPublicWeixinAccountHelpers(): Promise<WeixinAccountHelpers>;
-declare function loadLatestWeixinAccountState(): Promise<{
-    accountId: string;
-    token: string;
-    baseUrl: string;
-    getUpdatesBuf?: string;
-} | null>;
-type PublicWeixinMessageItem = {
-    type?: number;
-    text_item?: {
-        text?: string;
-    };
-};
-export type PublicWeixinMessage = {
-    message_id?: number;
-    from_user_id?: string;
-    context_token?: string;
-    create_time_ms?: number;
-    item_list?: PublicWeixinMessageItem[];
-};
-export type PublicWeixinSendMessage = (params: {
-    to: string;
-    text: string;
-    opts: {
-        baseUrl: string;
-        token: string;
-        contextToken?: string;
-    };
-}) => Promise<{
-    messageId: string;
-}>;
-export type PublicWeixinPersistGetUpdatesBuf = (params: {
-    accountId: string;
-    getUpdatesBuf: string;
-}) => Promise<void>;
 export type OpenClawWeixinPublicHelpers = {
     entry: OpenClawWeixinPublicEntry;
     pluginId: string;
@@ -83,29 +34,37 @@ export type OpenClawWeixinPublicHelpers = {
 };
 type OpenClawWeixinPublicHelpersLoaders = {
     resolveOpenClawWeixinPublicEntry?: typeof resolveOpenClawWeixinPublicEntry;
+    loadRegisteredWeixinPluginContext?: typeof loadRegisteredWeixinPluginContext;
+    loadRegisteredWeixinPluginPayloads?: typeof loadRegisteredWeixinPluginPayloads;
+    loadOpenClawQrGateway?: (payloads: Array<{
+        plugin?: unknown;
+    }>) => Promise<{
+        gateway: WeixinQrGateway;
+        pluginId: string;
+    }>;
     loadPublicWeixinQrGateway?: () => Promise<{
         gateway: WeixinQrGateway;
         pluginId?: string;
     }>;
     loadLatestWeixinAccountState?: typeof loadLatestWeixinAccountState;
-    loadPublicWeixinAccountHelpers?: typeof loadPublicWeixinAccountHelpers;
-    loadPublicWeixinHelpers?: typeof loadPublicWeixinHelpers;
-    loadPublicWeixinSendHelper?: typeof loadPublicWeixinSendHelper;
-};
-declare function loadPublicWeixinHelpers(): Promise<{
-    getUpdates: (params: {
-        baseUrl: string;
-        token?: string;
-        get_updates_buf?: string;
-        timeoutMs?: number;
-    }) => Promise<{
-        msgs?: PublicWeixinMessage[];
-        get_updates_buf?: string;
+    loadOpenClawAccountHelpers?: typeof loadOpenClawAccountHelpers;
+    loadOpenClawUpdatesAndSendHelpers?: typeof loadOpenClawUpdatesAndSendHelpers;
+    loadOpenClawSyncBufHelper?: typeof loadOpenClawSyncBufHelper;
+    loadPublicWeixinHelpers?: () => Promise<{
+        getUpdates: (params: {
+            baseUrl: string;
+            token?: string;
+            get_updates_buf?: string;
+            timeoutMs?: number;
+        }) => Promise<{
+            msgs?: PublicWeixinMessage[];
+            get_updates_buf?: string;
+        }>;
     }>;
-}>;
-declare function loadPublicWeixinSendHelper(): Promise<{
-    sendMessageWeixin: PublicWeixinSendMessage;
-}>;
+    loadPublicWeixinSendHelper?: () => Promise<{
+        sendMessageWeixin: PublicWeixinSendMessage;
+    }>;
+};
 export declare function loadOpenClawWeixinPublicHelpers(loaders?: OpenClawWeixinPublicHelpersLoaders): Promise<OpenClawWeixinPublicHelpers>;
 export type OpenClawWeixinPublicHelpersLoaderOptions = OpenClawWeixinPublicHelpersLoaders;
-export {};
+export type { PublicWeixinMessage, PublicWeixinSendMessage, PublicWeixinPersistGetUpdatesBuf };

package/dist/wechat/compat/openclaw-public-helpers.js

@@ -1,244 +1,50 @@
-import { readFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { createJiti } from "jiti";
+import { loadOpenClawAccountHelpers } from "./openclaw-account-helpers.js";
+import { loadRegisteredWeixinPluginContext, resolveOpenClawWeixinPublicEntry, } from "./openclaw-public-entry.js";
+import { loadOpenClawQrGateway } from "./openclaw-qr-gateway.js";
+import { loadOpenClawUpdatesAndSendHelpers, } from "./openclaw-updates-send.js";
+import { loadLatestWeixinAccountState, loadOpenClawSyncBufHelper, } from "./openclaw-sync-buf.js";
 export const OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES = {
     stateDir: "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts",
     syncBuf: "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts",
     getUpdates: "@tencent-weixin/openclaw-weixin/src/api/api.ts",
     sendMessageWeixin: "@tencent-weixin/openclaw-weixin/src/messaging/send.ts",
 };
-let publicJitiLoader = null;
-function requireField(condition, message) {
-    if (!condition) {
-        throw new Error(`[wechat-compat] ${message}`);
-    }
-}
-function getPublicJiti() {
-    if (publicJitiLoader) {
-        return publicJitiLoader;
-    }
-    publicJitiLoader = createJiti(import.meta.url, {
-        interopDefault: true,
-        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
-    });
-    return publicJitiLoader;
-}
-function hasQrLoginMethods(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const candidate = value;
-    return typeof candidate.loginWithQrStart === "function" && typeof candidate.loginWithQrWait === "function";
-}
-function hasAccountHelpers(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const candidate = value;
-    return (typeof candidate.listAccountIds === "function" &&
-        typeof candidate.resolveAccount === "function" &&
-        typeof candidate.describeAccount === "function");
-}
-async function resolveOpenClawWeixinPublicEntry() {
-    const require = createRequire(import.meta.url);
-    const packageName = "@tencent-weixin/openclaw-weixin";
-    const packageJsonPath = require.resolve(`${packageName}/package.json`);
-    const packageJsonRaw = await readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(packageJsonRaw);
-    const extensions = Array.isArray(packageJson.openclaw?.extensions)
-        ? packageJson.openclaw?.extensions.filter((it) => typeof it === "string")
-        : [];
-    requireField(extensions.length > 0, `${packageName} openclaw.extensions[0] is required`);
-    const entryRelativePath = extensions[0];
-    requireField(Boolean(entryRelativePath?.startsWith("./")), `${packageName} openclaw.extensions[0] must start with ./`);
-    const packageRoot = path.dirname(packageJsonPath);
-    const entryAbsolutePath = path.resolve(packageRoot, entryRelativePath);
-    return {
-        packageJsonPath,
-        packageRoot,
-        extensions,
-        entryRelativePath,
-        entryAbsolutePath,
-    };
-}
-async function loadOpenClawWeixinDefaultExport() {
-    const entry = await resolveOpenClawWeixinPublicEntry();
-    const moduleNamespace = getPublicJiti()(entry.entryAbsolutePath);
-    const plugin = moduleNamespace.default;
-    if (!plugin || typeof plugin !== "object" || typeof plugin.register !== "function") {
-        throw new Error("[wechat-compat] @tencent-weixin/openclaw-weixin public entry default export is missing register(api)");
-    }
-    return plugin;
-}
-async function loadPublicWeixinQrGateway() {
-    const registeredPayloads = [];
-    const compatHostApi = {
-        runtime: {
-            channelRuntime: {
-                mode: "guided-smoke",
-            },
-            gateway: {
-                startAccount: {
-                    source: "guided-smoke",
-                },
-            },
-        },
-        registerChannel(payload) {
-            registeredPayloads.push(payload);
-        },
-        registerCli() { },
-    };
-    const plugin = await loadOpenClawWeixinDefaultExport();
-    plugin.register(compatHostApi);
-    for (const payload of registeredPayloads) {
-        const payloadPlugin = payload?.plugin;
-        const gateway = payloadPlugin && typeof payloadPlugin === "object" ? payloadPlugin.gateway : null;
-        if (hasQrLoginMethods(gateway)) {
-            return { gateway, pluginId: plugin.id ?? "unknown" };
-        }
-        if (hasQrLoginMethods(payloadPlugin)) {
-            return { gateway: payloadPlugin, pluginId: plugin.id ?? "unknown" };
-        }
-    }
-    throw new Error("registerChannel did not expose weixin gateway loginWithQrStart/loginWithQrWait");
-}
-async function loadPublicWeixinAccountHelpers() {
-    const registeredPayloads = [];
-    const compatHostApi = {
-        runtime: {
-            channelRuntime: {
-                mode: "guided-smoke",
-            },
-            gateway: {
-                startAccount: {
-                    source: "guided-smoke",
-                },
-            },
-        },
-        registerChannel(payload) {
-            registeredPayloads.push(payload);
-        },
-        registerCli() { },
-    };
-    const plugin = await loadOpenClawWeixinDefaultExport();
-    plugin.register(compatHostApi);
-    for (const payload of registeredPayloads) {
-        const payloadPlugin = payload?.plugin;
-        const configCandidate = payloadPlugin && typeof payloadPlugin === "object"
-            ? payloadPlugin.config
-            : null;
-        if (!hasAccountHelpers(configCandidate)) {
-            continue;
-        }
-        return {
-            listAccountIds: async () => {
-                const result = await Promise.resolve(configCandidate.listAccountIds());
-                return Array.isArray(result) ? result.filter((item) => typeof item === "string") : [];
-            },
-            resolveAccount: async (accountId) => Promise.resolve(configCandidate.resolveAccount(accountId)),
-            describeAccount: async (accountIdOrInput) => Promise.resolve(configCandidate.describeAccount(accountIdOrInput)),
-        };
-    }
-    throw new Error(`${plugin.id ?? "weixin"} registerChannel did not expose config listAccountIds/resolveAccount/describeAccount`);
-}
-async function loadLatestWeixinAccountState() {
-    const require = createRequire(import.meta.url);
-    const stateDirModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.stateDir);
-    const stateDirModule = getPublicJiti()(stateDirModulePath);
-    const stateDir = stateDirModule.resolveStateDir?.();
-    if (!stateDir) {
-        return null;
-    }
-    const accountsIndexPath = path.join(stateDir, "openclaw-weixin", "accounts.json");
-    let accountIds = [];
-    try {
-        const raw = await readFile(accountsIndexPath, "utf8");
-        const parsed = JSON.parse(raw);
-        if (Array.isArray(parsed)) {
-            accountIds = parsed.filter((item) => typeof item === "string" && item.trim().length > 0);
-        }
-    }
-    catch {
-        return null;
-    }
-    const accountId = accountIds.at(-1);
-    if (!accountId) {
-        return null;
-    }
-    try {
-        const accountFilePath = path.join(stateDir, "openclaw-weixin", "accounts", `${accountId}.json`);
-        const accountRaw = await readFile(accountFilePath, "utf8");
-        const account = JSON.parse(accountRaw);
-        const syncBufModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf);
-        const syncBufModule = getPublicJiti()(syncBufModulePath);
-        if (typeof account.token !== "string" || account.token.trim().length === 0) {
-            return null;
-        }
-        const syncBufFilePath = syncBufModule.getSyncBufFilePath?.(accountId);
-        const persistedGetUpdatesBuf = syncBufFilePath ? syncBufModule.loadGetUpdatesBuf?.(syncBufFilePath) : undefined;
-        return {
-            accountId,
-            token: account.token,
-            baseUrl: typeof account.baseUrl === "string" && account.baseUrl.trim().length > 0 ? account.baseUrl : "https://ilinkai.weixin.qq.com",
-            getUpdatesBuf: typeof persistedGetUpdatesBuf === "string" ? persistedGetUpdatesBuf : undefined,
-        };
-    }
-    catch {
-        return null;
-    }
-}
 function missingHelperError(helperName) {
     return new Error(`[wechat-compat] required helper missing: ${helperName}`);
 }
-async function loadPublicWeixinHelpers() {
-    const require = createRequire(import.meta.url);
-    const getUpdatesModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.getUpdates);
-    const getUpdatesModule = getPublicJiti()(getUpdatesModulePath);
-    if (typeof getUpdatesModule.getUpdates !== "function") {
-        throw new Error("public getUpdates helper unavailable");
-    }
-    return {
-        getUpdates: getUpdatesModule.getUpdates,
-    };
-}
-async function loadPublicWeixinSendHelper() {
-    const require = createRequire(import.meta.url);
-    const sendModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.sendMessageWeixin);
-    const sendModule = getPublicJiti()(sendModulePath);
-    if (typeof sendModule.sendMessageWeixin !== "function") {
-        throw new Error("public sendMessageWeixin helper unavailable");
-    }
-    return {
-        sendMessageWeixin: sendModule.sendMessageWeixin,
-    };
-}
-async function loadPublicWeixinSyncBufHelpers() {
-    const require = createRequire(import.meta.url);
-    const syncBufModulePath = require.resolve(OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf);
-    const syncBufModule = getPublicJiti()(syncBufModulePath);
-    if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
-        return {};
-    }
-    return {
-        persistGetUpdatesBuf: async ({ accountId, getUpdatesBuf }) => {
-            const filePath = syncBufModule.getSyncBufFilePath(accountId);
-            syncBufModule.saveGetUpdatesBuf(filePath, getUpdatesBuf);
-        },
-    };
-}
 export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
     const entry = await (loaders.resolveOpenClawWeixinPublicEntry ?? resolveOpenClawWeixinPublicEntry)();
-    const qrGatewayResult = await (loaders.loadPublicWeixinQrGateway ?? loadPublicWeixinQrGateway)();
-    const accountHelpers = await (loaders.loadPublicWeixinAccountHelpers ?? loadPublicWeixinAccountHelpers)();
-    const latestAccountState = await (loaders.loadLatestWeixinAccountState ?? loadLatestWeixinAccountState)();
-    const publicHelpers = await (loaders.loadPublicWeixinHelpers ?? loadPublicWeixinHelpers)();
-    const sendHelper = await (loaders.loadPublicWeixinSendHelper ?? loadPublicWeixinSendHelper)();
-    const syncBufHelpers = await loadPublicWeixinSyncBufHelpers();
+    const qrGatewayResult = loaders.loadPublicWeixinQrGateway
+        ? await loaders.loadPublicWeixinQrGateway()
+        : await (async () => {
+            if (loaders.loadRegisteredWeixinPluginContext) {
+                const context = await loaders.loadRegisteredWeixinPluginContext();
+                return (loaders.loadOpenClawQrGateway ?? loadOpenClawQrGateway)(context.payloads, { pluginId: context.pluginId });
+            }
+            const context = await loadRegisteredWeixinPluginContext();
+            return (loaders.loadOpenClawQrGateway ?? loadOpenClawQrGateway)(context.payloads, { pluginId: context.pluginId });
+        })();
+    const accountHelpers = await (loaders.loadOpenClawAccountHelpers ?? loadOpenClawAccountHelpers)();
+    const latestAccountState = await (loaders.loadLatestWeixinAccountState ?? loadLatestWeixinAccountState)({
+        stateDirModulePath: OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.stateDir,
+        syncBufModulePath: OPENCLAW_WEIXIN_JITI_SRC_HELPER_MODULES.syncBuf,
+    });
+    const updatesSend = loaders.loadOpenClawUpdatesAndSendHelpers
+        ? await loaders.loadOpenClawUpdatesAndSendHelpers()
+        : await (async () => {
+            const defaults = await loadOpenClawUpdatesAndSendHelpers();
+            const maybeUpdates = loaders.loadPublicWeixinHelpers ? await loaders.loadPublicWeixinHelpers() : undefined;
+            const maybeSend = loaders.loadPublicWeixinSendHelper ? await loaders.loadPublicWeixinSendHelper() : undefined;
+            return {
+                getUpdates: loaders.loadPublicWeixinHelpers ? maybeUpdates?.getUpdates : defaults.getUpdates,
+                sendMessageWeixin: loaders.loadPublicWeixinSendHelper ? maybeSend?.sendMessageWeixin : defaults.sendMessageWeixin,
+            };
+        })();
+    const syncBufHelpers = await (loaders.loadOpenClawSyncBufHelper ?? loadOpenClawSyncBufHelper)();
     if (typeof qrGatewayResult?.gateway?.loginWithQrStart !== "function" || typeof qrGatewayResult?.gateway?.loginWithQrWait !== "function") {
         throw missingHelperError("qrGateway");
     }
-    if (typeof publicHelpers?.getUpdates !== "function") {
+    if (typeof updatesSend?.getUpdates !== "function") {
         throw missingHelperError("getUpdates");
     }
     if (typeof accountHelpers?.listAccountIds !== "function" ||
@@ -246,7 +52,7 @@ export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
         typeof accountHelpers?.describeAccount !== "function") {
         throw missingHelperError("accountHelpers");
     }
-    if (typeof sendHelper?.sendMessageWeixin !== "function") {
+    if (typeof updatesSend?.sendMessageWeixin !== "function") {
         throw missingHelperError("sendMessageWeixin");
     }
     return {
@@ -255,8 +61,8 @@ export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
         qrGateway: qrGatewayResult.gateway,
         accountHelpers,
         latestAccountState,
-        getUpdates: publicHelpers.getUpdates,
-        sendMessageWeixin: sendHelper.sendMessageWeixin,
+        getUpdates: updatesSend.getUpdates,
+        sendMessageWeixin: updatesSend.sendMessageWeixin,
         persistGetUpdatesBuf: syncBufHelpers.persistGetUpdatesBuf,
     };
 }

package/dist/wechat/compat/openclaw-qr-gateway.d.ts

@@ -0,0 +1,15 @@
+export type WeixinQrGateway = {
+    loginWithQrStart: (input?: unknown) => unknown;
+    loginWithQrWait: (input?: unknown) => unknown;
+};
+type OpenClawQrGatewayPayload = {
+    plugin?: unknown;
+};
+export declare function createOpenClawQrGateway(source: WeixinQrGateway): WeixinQrGateway;
+export declare function loadOpenClawQrGateway(payloads: OpenClawQrGatewayPayload[], options?: {
+    pluginId?: string;
+}): Promise<{
+    gateway: WeixinQrGateway;
+    pluginId: string;
+}>;
+export {};

package/dist/wechat/compat/openclaw-qr-gateway.js

@@ -0,0 +1,39 @@
+function toObjectInput(input) {
+    return input && typeof input === "object" ? input : {};
+}
+function hasQrLoginMethods(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.loginWithQrStart === "function" && typeof candidate.loginWithQrWait === "function";
+}
+export function createOpenClawQrGateway(source) {
+    return {
+        async loginWithQrStart(input) {
+            return source.loginWithQrStart(toObjectInput(input));
+        },
+        async loginWithQrWait(input) {
+            return source.loginWithQrWait(toObjectInput(input));
+        },
+    };
+}
+export async function loadOpenClawQrGateway(payloads, options = {}) {
+    for (const payload of payloads) {
+        const payloadPlugin = payload?.plugin;
+        const resolvedPluginId = typeof options.pluginId === "string" && options.pluginId.trim().length > 0
+            ? options.pluginId
+            : typeof payloadPlugin?.id === "string" &&
+                String(payloadPlugin.id).trim().length > 0
+                ? String(payloadPlugin.id)
+                : "unknown";
+        const gateway = payloadPlugin && typeof payloadPlugin === "object" ? payloadPlugin.gateway : null;
+        if (hasQrLoginMethods(gateway)) {
+            return {
+                gateway: createOpenClawQrGateway(gateway),
+                pluginId: resolvedPluginId,
+            };
+        }
+    }
+    throw new Error("registerChannel did not expose weixin gateway loginWithQrStart/loginWithQrWait");
+}

package/dist/wechat/compat/openclaw-sync-buf.d.ts

@@ -0,0 +1,24 @@
+export type PublicWeixinPersistGetUpdatesBuf = (params: {
+    accountId: string;
+    getUpdatesBuf: string;
+}) => Promise<void>;
+export declare function createOpenClawSyncBufHelper(input: {
+    getSyncBufFilePath: (accountId: string) => string;
+    saveGetUpdatesBuf: (filePath: string, getUpdatesBuf: string) => void;
+}): {
+    persistGetUpdatesBuf: PublicWeixinPersistGetUpdatesBuf;
+};
+export declare function loadOpenClawSyncBufHelper(options?: {
+    syncBufModulePath?: string;
+}): Promise<{
+    persistGetUpdatesBuf: PublicWeixinPersistGetUpdatesBuf;
+}>;
+export declare function loadLatestWeixinAccountState(options?: {
+    stateDirModulePath?: string;
+    syncBufModulePath?: string;
+}): Promise<{
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    getUpdatesBuf?: string;
+} | null>;

package/dist/wechat/compat/openclaw-sync-buf.js

@@ -0,0 +1,86 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createJiti } from "jiti";
+const OPENCLAW_SYNC_BUF_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts";
+const OPENCLAW_STATE_DIR_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts";
+let syncBufJitiLoader = null;
+function getSyncBufJiti() {
+    if (syncBufJitiLoader) {
+        return syncBufJitiLoader;
+    }
+    syncBufJitiLoader = createJiti(import.meta.url, {
+        interopDefault: true,
+        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    });
+    return syncBufJitiLoader;
+}
+export function createOpenClawSyncBufHelper(input) {
+    return {
+        async persistGetUpdatesBuf({ accountId, getUpdatesBuf }) {
+            const filePath = input.getSyncBufFilePath(accountId);
+            if (typeof filePath !== "string" || filePath.trim().length === 0) {
+                throw new Error("[wechat-compat] sync-buf helper returned invalid file path");
+            }
+            input.saveGetUpdatesBuf(filePath, getUpdatesBuf);
+        },
+    };
+}
+export async function loadOpenClawSyncBufHelper(options = {}) {
+    const require = createRequire(import.meta.url);
+    const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
+    const syncBufModule = getSyncBufJiti()(syncBufModulePath);
+    if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
+        throw new Error("[wechat-compat] sync-buf source helper unavailable");
+    }
+    return createOpenClawSyncBufHelper({
+        getSyncBufFilePath: syncBufModule.getSyncBufFilePath,
+        saveGetUpdatesBuf: syncBufModule.saveGetUpdatesBuf,
+    });
+}
+export async function loadLatestWeixinAccountState(options = {}) {
+    const require = createRequire(import.meta.url);
+    const stateDirModulePath = require.resolve(options.stateDirModulePath ?? OPENCLAW_STATE_DIR_MODULE);
+    const stateDirModule = getSyncBufJiti()(stateDirModulePath);
+    const stateDir = stateDirModule.resolveStateDir?.();
+    if (!stateDir) {
+        return null;
+    }
+    const accountsIndexPath = path.join(stateDir, "openclaw-weixin", "accounts.json");
+    let accountIds = [];
+    try {
+        const raw = await readFile(accountsIndexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            accountIds = parsed.filter((item) => typeof item === "string" && item.trim().length > 0);
+        }
+    }
+    catch {
+        return null;
+    }
+    const accountId = accountIds.at(-1);
+    if (!accountId) {
+        return null;
+    }
+    try {
+        const accountFilePath = path.join(stateDir, "openclaw-weixin", "accounts", `${accountId}.json`);
+        const accountRaw = await readFile(accountFilePath, "utf8");
+        const account = JSON.parse(accountRaw);
+        const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
+        const syncBufModule = getSyncBufJiti()(syncBufModulePath);
+        if (typeof account.token !== "string" || account.token.trim().length === 0) {
+            return null;
+        }
+        const syncBufFilePath = syncBufModule.getSyncBufFilePath?.(accountId);
+        const persistedGetUpdatesBuf = syncBufFilePath ? syncBufModule.loadGetUpdatesBuf?.(syncBufFilePath) : undefined;
+        return {
+            accountId,
+            token: account.token,
+            baseUrl: typeof account.baseUrl === "string" && account.baseUrl.trim().length > 0 ? account.baseUrl : "https://ilinkai.weixin.qq.com",
+            getUpdatesBuf: typeof persistedGetUpdatesBuf === "string" ? persistedGetUpdatesBuf : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wechat/compat/openclaw-updates-send.d.ts

@@ -0,0 +1,47 @@
+type PublicWeixinMessageItem = {
+    type?: number;
+    text_item?: {
+        text?: string;
+    };
+};
+export type PublicWeixinMessage = {
+    message_id?: number;
+    from_user_id?: string;
+    context_token?: string;
+    create_time_ms?: number;
+    item_list?: PublicWeixinMessageItem[];
+};
+export type PublicWeixinSendMessage = (params: {
+    to: string;
+    text: string;
+    opts: {
+        baseUrl: string;
+        token: string;
+        contextToken?: string;
+    };
+}) => Promise<{
+    messageId: string;
+}>;
+type PublicGetUpdates = (params: {
+    baseUrl: string;
+    token?: string;
+    get_updates_buf?: string;
+    timeoutMs?: number;
+}) => Promise<{
+    msgs?: PublicWeixinMessage[];
+    get_updates_buf?: string;
+}>;
+export declare function createOpenClawUpdatesHelper(getUpdates: PublicGetUpdates): {
+    getUpdates: PublicGetUpdates;
+};
+export declare function createOpenClawSendHelper(sendMessageWeixin: PublicWeixinSendMessage): {
+    sendMessageWeixin: PublicWeixinSendMessage;
+};
+export declare function loadOpenClawUpdatesAndSendHelpers(options?: {
+    getUpdatesModulePath?: string;
+    sendMessageWeixinModulePath?: string;
+}): Promise<{
+    getUpdates: PublicGetUpdates;
+    sendMessageWeixin: PublicWeixinSendMessage;
+}>;
+export {};

package/dist/wechat/compat/openclaw-updates-send.js

@@ -0,0 +1,49 @@
+import { createRequire } from "node:module";
+import { createJiti } from "jiti";
+const OPENCLAW_UPDATES_MODULE = "@tencent-weixin/openclaw-weixin/src/api/api.ts";
+const OPENCLAW_SEND_MODULE = "@tencent-weixin/openclaw-weixin/src/messaging/send.ts";
+let updatesSendJitiLoader = null;
+function getUpdatesSendJiti() {
+    if (updatesSendJitiLoader) {
+        return updatesSendJitiLoader;
+    }
+    updatesSendJitiLoader = createJiti(import.meta.url, {
+        interopDefault: true,
+        extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
+    });
+    return updatesSendJitiLoader;
+}
+function toObjectInput(input) {
+    return input && typeof input === "object" ? input : {};
+}
+export function createOpenClawUpdatesHelper(getUpdates) {
+    return {
+        async getUpdates(input) {
+            return getUpdates(toObjectInput(input));
+        },
+    };
+}
+export function createOpenClawSendHelper(sendMessageWeixin) {
+    return {
+        async sendMessageWeixin(input) {
+            return sendMessageWeixin(toObjectInput(input));
+        },
+    };
+}
+export async function loadOpenClawUpdatesAndSendHelpers(options = {}) {
+    const require = createRequire(import.meta.url);
+    const getUpdatesModulePath = require.resolve(options.getUpdatesModulePath ?? OPENCLAW_UPDATES_MODULE);
+    const sendModulePath = require.resolve(options.sendMessageWeixinModulePath ?? OPENCLAW_SEND_MODULE);
+    const getUpdatesModule = getUpdatesSendJiti()(getUpdatesModulePath);
+    const sendModule = getUpdatesSendJiti()(sendModulePath);
+    if (typeof getUpdatesModule.getUpdates !== "function") {
+        throw new Error("public getUpdates helper unavailable");
+    }
+    if (typeof sendModule.sendMessageWeixin !== "function") {
+        throw new Error("public sendMessageWeixin helper unavailable");
+    }
+    return {
+        ...createOpenClawUpdatesHelper(getUpdatesModule.getUpdates),
+        ...createOpenClawSendHelper(sendModule.sendMessageWeixin),
+    };
+}

package/dist/wechat/openclaw-account-adapter.js

@@ -13,20 +13,6 @@ function toBoolean(value) {
     if (typeof value === "boolean") {
         return value;
     }
-    if (value === 1) {
-        return true;
-    }
-    if (value === 0) {
-        return false;
-    }
-    return undefined;
-}
-function firstNumber(...values) {
-    for (const value of values) {
-        if (typeof value === "number" && Number.isFinite(value)) {
-            return value;
-        }
-    }
     return undefined;
 }
 async function tryDescribeAccount(accountHelpers, accountId) {
@@ -55,13 +41,17 @@ export async function buildOpenClawMenuAccount(input) {
     }
     const resolvedRaw = asObject(await input.accountHelpers.resolveAccount(accountId));
     const describedRaw = asObject(await tryDescribeAccount(input.accountHelpers, accountId));
-    const enabled = toBoolean(resolvedRaw.enabled) ?? toBoolean(resolvedRaw.isEnabled) ?? toBoolean(describedRaw.enabled) ?? toBoolean(describedRaw.isEnabled) ?? false;
-    const configured = toBoolean(describedRaw.configured) ?? toBoolean(describedRaw.isConfigured) ?? toBoolean(resolvedRaw.configured) ?? toBoolean(resolvedRaw.isConfigured) ?? false;
-    const userId = firstNonEmptyString(input.latestAccountState?.userId, resolvedRaw.userId, resolvedRaw.user_id, describedRaw.userId, describedRaw.user_id);
-    const boundAt = firstNumber(input.latestAccountState?.boundAt, input.latestAccountState?.savedAt, resolvedRaw.boundAt, resolvedRaw.savedAt, describedRaw.boundAt, describedRaw.savedAt);
+    const enabled = toBoolean(resolvedRaw.enabled) ?? toBoolean(describedRaw.enabled) ?? false;
+    const configured = toBoolean(describedRaw.configured) ?? toBoolean(resolvedRaw.configured) ?? false;
+    const userId = firstNonEmptyString(input.latestAccountState?.userId, resolvedRaw.userId, describedRaw.userId);
+    const boundAt = [
+        input.latestAccountState?.boundAt,
+        resolvedRaw.boundAt,
+        describedRaw.boundAt,
+    ].find((value) => typeof value === "number" && Number.isFinite(value));
     return {
         accountId,
-        name: firstNonEmptyString(resolvedRaw.name, resolvedRaw.displayName, describedRaw.name, describedRaw.displayName),
+        name: firstNonEmptyString(resolvedRaw.name, describedRaw.name),
         enabled,
         configured,
         userId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.14.5",
+  "version": "0.14.7",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -63,8 +63,8 @@
   "dependencies": {
     "@opencode-ai/plugin": "^1.2.26",
     "@opencode-ai/sdk": "^1.2.26",
-    "@tencent-weixin/openclaw-weixin": "^1.0.3",
-    "openclaw": "2026.3.13",
+    "@tencent-weixin/openclaw-weixin": "2.0.1",
+    "openclaw": "2026.3.22",
     "xdg-basedir": "^5.1.0"
   }
 }