opencode-copilot-account-switcher 0.14.34 → 0.14.36

package/dist/wechat/bind-flow.d.ts

@@ -1,5 +1,5 @@
 import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
-import { loadOpenClawWeixinPublicHelpers } from "./compat/openclaw-public-helpers.js";
+import { loadOpenClawWeixinBindHelpers } from "./compat/openclaw-bind-helpers.js";
 import type { CommonSettingsStore } from "../common-settings-store.js";
 type BindAction = "wechat-bind" | "wechat-rebind";
 type WechatBindFlowResult = {
@@ -12,7 +12,7 @@ type WechatBindFlowResult = {
 };
 type WechatBindFlowInput = {
     action: BindAction;
-    loadPublicHelpers?: typeof loadOpenClawWeixinPublicHelpers;
+    loadPublicHelpers?: typeof loadOpenClawWeixinBindHelpers;
     bindOperator?: typeof bindOperator;
     rebindOperator?: typeof rebindOperator;
     readOperatorBinding?: typeof readOperatorBinding;

package/dist/wechat/bind-flow.js

@@ -1,5 +1,5 @@
 import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
-import { loadOpenClawWeixinPublicHelpers } from "./compat/openclaw-public-helpers.js";
+import { loadOpenClawWeixinBindHelpers } from "./compat/openclaw-bind-helpers.js";
 import { buildOpenClawMenuAccount } from "./openclaw-account-adapter.js";
 import { loadQrCodeTerminal } from "./compat/qrcode-terminal-loader.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
@@ -50,7 +50,7 @@ async function renderQrTerminalDefault(input) {
 }
 export async function runWechatBindFlow(input) {
     const now = input.now ?? Date.now;
-    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
+    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinBindHelpers;
     const persistOperatorBinding = input.bindOperator ?? bindOperator;
     const persistOperatorRebinding = input.rebindOperator ?? rebindOperator;
     const loadOperatorBinding = input.readOperatorBinding ?? readOperatorBinding;

package/dist/wechat/compat/jiti-loader.d.ts

@@ -2,6 +2,8 @@ export type JitiLoader = (path: string) => unknown;
 type CreateJiti = (id: string | URL, options?: Record<string, unknown>) => JitiLoader;
 type JitiImport = (specifier: string) => Promise<unknown> | unknown;
 type JitiResolve = (specifier: string) => string;
+type JitiRequire = (specifier: string) => unknown;
+type ModuleImport = (specifier: string) => Promise<unknown>;
 type JitiNamespace = {
     createJiti?: unknown;
     default?: unknown;
@@ -9,8 +11,17 @@ type JitiNamespace = {
 };
 export declare function resolveCreateJiti(namespace: JitiNamespace): CreateJiti;
 export declare function resolveJitiEsmEntry(resolveImpl?: JitiResolve): string;
+export declare function resolveJitiCjsEntry(resolveImpl?: JitiResolve): string;
+export declare function hasBunRuntime(bunVersion?: string | undefined): boolean;
 export declare function wrapCreateJiti(createJiti: CreateJiti): CreateJiti;
-export declare function loadJiti(importImpl?: JitiImport, resolveImpl?: JitiResolve): Promise<{
+export declare function loadJiti(importImpl?: JitiImport, resolveImpl?: JitiResolve, requireImpl?: JitiRequire): Promise<{
     createJiti: CreateJiti;
 }>;
+export declare function loadModuleWithTsFallback(modulePath: string, options?: {
+    bunVersion?: string | undefined;
+    importImpl?: ModuleImport;
+    loadJitiImpl?: typeof loadJiti;
+    parentURL?: string | URL;
+    jitiOptions?: Record<string, unknown>;
+}): Promise<unknown>;
 export {};

package/dist/wechat/compat/jiti-loader.js

@@ -22,16 +22,40 @@ export function resolveCreateJiti(namespace) {
         isCreateJiti(namespace.default.createJiti)) {
         return namespace.default.createJiti;
     }
-    throw new Error("[wechat-compat] createJiti export unavailable");
+    if (namespace.default &&
+        typeof namespace.default === "object" &&
+        isCreateJiti(namespace.default.default)) {
+        return namespace.default.default;
+    }
+    if (namespace.default &&
+        typeof namespace.default === "object" &&
+        isCreateJiti(namespace.default["module.exports"])) {
+        return namespace.default["module.exports"];
+    }
+    const topLevelKeys = namespace && typeof namespace === "object" ? Object.keys(namespace).join(",") : typeof namespace;
+    const defaultValue = namespace?.default;
+    const defaultKeys = defaultValue && typeof defaultValue === "object" ? Object.keys(defaultValue).join(",") : typeof defaultValue;
+    throw new Error(`[wechat-compat] createJiti export unavailable (keys=${topLevelKeys}; default=${defaultKeys})`);
 }
 export function resolveJitiEsmEntry(resolveImpl = createRequire(import.meta.url).resolve) {
     const packageJsonPath = resolveImpl("jiti/package.json");
-    return pathToFileURL(path.join(path.dirname(packageJsonPath), "dist", "jiti.cjs")).href;
+    return pathToFileURL(path.join(path.dirname(packageJsonPath), "lib", "jiti.cjs")).href;
+}
+export function resolveJitiCjsEntry(resolveImpl = createRequire(import.meta.url).resolve) {
+    const packageJsonPath = resolveImpl("jiti/package.json");
+    return path.join(path.dirname(packageJsonPath), "lib", "jiti.cjs");
 }
 function onJitiError(error) {
     throw error;
 }
 const nativeImport = (id) => import(id);
+const DEFAULT_JITI_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"];
+function isTypeScriptModulePath(modulePath) {
+    return /\.(ts|tsx|mts|cts)$/i.test(modulePath);
+}
+export function hasBunRuntime(bunVersion = process.versions?.bun) {
+    return typeof bunVersion === "string" && bunVersion.length > 0;
+}
 export function wrapCreateJiti(createJiti) {
     const requireFromJiti = createRequire(resolveJitiEsmEntry());
     let transformImpl;
@@ -52,9 +76,43 @@ export function wrapCreateJiti(createJiti) {
         });
     };
 }
-export async function loadJiti(importImpl = (specifier) => import(specifier), resolveImpl = createRequire(import.meta.url).resolve) {
-    const namespace = await Promise.resolve(importImpl(resolveJitiEsmEntry(resolveImpl)));
-    return {
-        createJiti: wrapCreateJiti(resolveCreateJiti(namespace)),
-    };
+export async function loadJiti(importImpl = (specifier) => import(specifier), resolveImpl = createRequire(import.meta.url).resolve, requireImpl = createRequire(import.meta.url)) {
+    try {
+        const required = requireImpl("jiti");
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(required)),
+        };
+    }
+    catch {
+        // Fall back to import() when require-based loading is unavailable.
+    }
+    try {
+        const namespace = await Promise.resolve(importImpl("jiti"));
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(namespace)),
+        };
+    }
+    catch {
+        const namespace = await Promise.resolve(importImpl(resolveJitiEsmEntry(resolveImpl)));
+        return {
+            createJiti: wrapCreateJiti(resolveCreateJiti(namespace)),
+        };
+    }
+}
+export async function loadModuleWithTsFallback(modulePath, options = {}) {
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const importImpl = options.importImpl ?? nativeImport;
+    // Even under Bun, TS entrypoints inside node_modules can transitively hit ESM/CJS
+    // interop edges (for example openclaw -> json5 default import). Jiti keeps that
+    // path stable for the WeChat compat loader.
+    if (hasBunRuntime(options.bunVersion) && !isTypeScriptModulePath(modulePath)) {
+        return await importImpl(moduleUrl);
+    }
+    const { createJiti } = await (options.loadJitiImpl ?? loadJiti)();
+    const loader = createJiti(options.parentURL ?? import.meta.url, {
+        interopDefault: true,
+        extensions: DEFAULT_JITI_EXTENSIONS,
+        ...(options.jitiOptions ?? {}),
+    });
+    return loader(modulePath);
 }

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

@@ -1,17 +1,6 @@
 import { createRequire } from "node:module";
-import { loadJiti } from "./jiti-loader.js";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
 const OPENCLAW_WEIXIN_ACCOUNTS_MODULE = "@tencent-weixin/openclaw-weixin/src/auth/accounts.ts";
-let accountJitiLoader = null;
-async function getAccountJiti() {
-    if (accountJitiLoader) {
-        return accountJitiLoader;
-    }
-    accountJitiLoader = (await loadJiti()).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 : {};
 }
@@ -52,7 +41,7 @@ export function createOpenClawAccountHelpers(input) {
 export async function loadOpenClawAccountHelpers(options = {}) {
     const require = createRequire(import.meta.url);
     const accountsModulePath = require.resolve(options.accountsModulePath ?? OPENCLAW_WEIXIN_ACCOUNTS_MODULE);
-    const accountsModule = (await getAccountJiti())(accountsModulePath);
+    const accountsModule = await loadModuleWithTsFallback(accountsModulePath, { parentURL: import.meta.url });
     if (typeof accountsModule.listIndexedWeixinAccountIds !== "function" || typeof accountsModule.loadWeixinAccount !== "function") {
         throw new Error("[wechat-compat] account source helper unavailable");
     }

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

@@ -0,0 +1,29 @@
+type WeixinBindQrGateway = {
+    loginWithQrStart: (input?: unknown) => Promise<unknown>;
+    loginWithQrWait: (input?: unknown) => Promise<unknown>;
+};
+type WeixinBindAccountHelpers = {
+    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;
+    }>;
+};
+export type OpenClawWeixinBindHelpers = {
+    qrGateway: WeixinBindQrGateway;
+    accountHelpers: WeixinBindAccountHelpers;
+};
+export declare function loadOpenClawWeixinBindHelpers(): Promise<OpenClawWeixinBindHelpers>;
+export {};

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

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const DEFAULT_ILINK_BOT_TYPE = "3";
+const ACTIVE_LOGIN_TTL_MS = 5 * 60_000;
+const QR_LONG_POLL_TIMEOUT_MS = 35_000;
+const activeLogins = new Map();
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function isLoginFresh(login) {
+    return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
+}
+function purgeExpiredLogins() {
+    for (const [sessionKey, login] of activeLogins) {
+        if (!isLoginFresh(login)) {
+            activeLogins.delete(sessionKey);
+        }
+    }
+}
+async function fetchQrCode(apiBaseUrl, botType) {
+    const base = apiBaseUrl.endsWith("/") ? apiBaseUrl : `${apiBaseUrl}/`;
+    const url = new URL(`ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`, base);
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        throw new Error(`Failed to fetch QR code: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+async function pollQrStatus(apiBaseUrl, qrcode) {
+    const base = apiBaseUrl.endsWith("/") ? apiBaseUrl : `${apiBaseUrl}/`;
+    const url = new URL(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, base);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), QR_LONG_POLL_TIMEOUT_MS);
+    try {
+        const response = await fetch(url.toString(), {
+            headers: { "iLink-App-ClientVersion": "1" },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const rawText = await response.text();
+        if (!response.ok) {
+            throw new Error(`Failed to poll QR status: ${response.status} ${response.statusText}`);
+        }
+        const parsed = JSON.parse(rawText);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (error) {
+        clearTimeout(timer);
+        if (error instanceof Error && error.name === "AbortError") {
+            return { status: "wait" };
+        }
+        throw error;
+    }
+}
+function createAccountHelpers() {
+    async function describeAccount(accountId) {
+        return {
+            accountId,
+            enabled: true,
+            configured: false,
+        };
+    }
+    return {
+        async listAccountIds() {
+            return [];
+        },
+        resolveAccount: describeAccount,
+        async describeAccount(accountIdOrInput) {
+            const accountId = typeof accountIdOrInput === "string" ? accountIdOrInput : accountIdOrInput.accountId;
+            return await describeAccount(accountId);
+        },
+    };
+}
+export async function loadOpenClawWeixinBindHelpers() {
+    const accountHelpers = createAccountHelpers();
+    return {
+        qrGateway: {
+            async loginWithQrStart(input) {
+                const params = asObject(input);
+                const sessionKey = asNonEmptyString(params.accountId) ?? randomUUID();
+                const force = params.force === true;
+                purgeExpiredLogins();
+                const existing = activeLogins.get(sessionKey);
+                if (!force && existing && isLoginFresh(existing) && existing.qrcodeUrl) {
+                    return {
+                        qrcodeUrl: existing.qrcodeUrl,
+                        message: "二维码已就绪，请使用微信扫描。",
+                        sessionKey,
+                    };
+                }
+                const qrResponse = await fetchQrCode(DEFAULT_BASE_URL, DEFAULT_ILINK_BOT_TYPE);
+                activeLogins.set(sessionKey, {
+                    sessionKey,
+                    qrcode: qrResponse.qrcode,
+                    qrcodeUrl: qrResponse.qrcode_img_content,
+                    startedAt: Date.now(),
+                });
+                return {
+                    qrDataUrl: qrResponse.qrcode_img_content,
+                    qrcodeUrl: qrResponse.qrcode_img_content,
+                    message: "使用微信扫描以下二维码，以完成连接。",
+                    sessionKey,
+                };
+            },
+            async loginWithQrWait(input) {
+                const params = asObject(input);
+                const sessionKey = asNonEmptyString(params.sessionKey);
+                if (!sessionKey) {
+                    throw new Error("missing sessionKey from qr wait");
+                }
+                let activeLogin = activeLogins.get(sessionKey);
+                if (!activeLogin) {
+                    return { connected: false, message: "当前没有进行中的登录，请先发起登录。" };
+                }
+                if (!isLoginFresh(activeLogin)) {
+                    activeLogins.delete(sessionKey);
+                    return { connected: false, message: "二维码已过期，请重新生成。" };
+                }
+                const timeoutMs = Math.max(asPositiveNumber(params.timeoutMs) ?? 480_000, 1000);
+                const deadline = Date.now() + timeoutMs;
+                while (Date.now() < deadline) {
+                    const statusResponse = await pollQrStatus(DEFAULT_BASE_URL, activeLogin.qrcode);
+                    const status = asNonEmptyString(statusResponse.status);
+                    if (status === "confirmed") {
+                        activeLogins.delete(sessionKey);
+                        return {
+                            connected: true,
+                            accountId: asNonEmptyString(statusResponse.ilink_bot_id),
+                            baseUrl: asNonEmptyString(statusResponse.baseurl),
+                            userId: asNonEmptyString(statusResponse.ilink_user_id),
+                            message: "✅ 与微信连接成功！",
+                        };
+                    }
+                    if (status === "expired") {
+                        activeLogins.delete(sessionKey);
+                        return { connected: false, message: "二维码已过期，请重新生成。" };
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    activeLogin = activeLogins.get(sessionKey) ?? activeLogin;
+                }
+                activeLogins.delete(sessionKey);
+                return { connected: false, message: "登录超时，请重试。" };
+            },
+        },
+        accountHelpers,
+    };
+}

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

@@ -1,23 +1,12 @@
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { loadJiti } from "./jiti-loader.js";
-let publicJitiLoader = null;
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
 function requireField(condition, message) {
     if (!condition) {
         throw new Error(`[wechat-compat] ${message}`);
     }
 }
-async function getPublicJiti() {
-    if (publicJitiLoader) {
-        return publicJitiLoader;
-    }
-    publicJitiLoader = (await loadJiti()).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";
@@ -42,7 +31,7 @@ export async function resolveOpenClawWeixinPublicEntry() {
 }
 export async function loadOpenClawWeixinDefaultExport() {
     const entry = await resolveOpenClawWeixinPublicEntry();
-    const moduleNamespace = (await getPublicJiti())(entry.entryAbsolutePath);
+    const moduleNamespace = await loadModuleWithTsFallback(entry.entryAbsolutePath, { parentURL: import.meta.url });
     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)");

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

@@ -1,20 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
-import { loadJiti } from "./jiti-loader.js";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
 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;
-async function getSyncBufJiti() {
-    if (syncBufJitiLoader) {
-        return syncBufJitiLoader;
-    }
-    syncBufJitiLoader = (await loadJiti()).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 }) {
@@ -29,7 +18,7 @@ export function createOpenClawSyncBufHelper(input) {
 export async function loadOpenClawSyncBufHelper(options = {}) {
     const require = createRequire(import.meta.url);
     const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
-    const syncBufModule = (await getSyncBufJiti())(syncBufModulePath);
+    const syncBufModule = await loadModuleWithTsFallback(syncBufModulePath, { parentURL: import.meta.url });
     if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
         throw new Error("[wechat-compat] sync-buf source helper unavailable");
     }
@@ -41,7 +30,7 @@ export async function loadOpenClawSyncBufHelper(options = {}) {
 export async function loadLatestWeixinAccountState(options = {}) {
     const require = createRequire(import.meta.url);
     const stateDirModulePath = require.resolve(options.stateDirModulePath ?? OPENCLAW_STATE_DIR_MODULE);
-    const stateDirModule = (await getSyncBufJiti())(stateDirModulePath);
+    const stateDirModule = await loadModuleWithTsFallback(stateDirModulePath, { parentURL: import.meta.url });
     const stateDir = stateDirModule.resolveStateDir?.();
     if (!stateDir) {
         return null;
@@ -67,7 +56,7 @@ export async function loadLatestWeixinAccountState(options = {}) {
         const accountRaw = await readFile(accountFilePath, "utf8");
         const account = JSON.parse(accountRaw);
         const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
-        const syncBufModule = (await getSyncBufJiti())(syncBufModulePath);
+        const syncBufModule = await loadModuleWithTsFallback(syncBufModulePath, { parentURL: import.meta.url });
         if (typeof account.token !== "string" || account.token.trim().length === 0) {
             return null;
         }

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

@@ -1,18 +1,7 @@
 import { createRequire } from "node:module";
-import { loadJiti } from "./jiti-loader.js";
+import { loadModuleWithTsFallback } from "./jiti-loader.js";
 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;
-async function getUpdatesSendJiti() {
-    if (updatesSendJitiLoader) {
-        return updatesSendJitiLoader;
-    }
-    updatesSendJitiLoader = (await loadJiti()).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 : {};
 }
@@ -34,9 +23,8 @@ 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 jiti = await getUpdatesSendJiti();
-    const getUpdatesModule = jiti(getUpdatesModulePath);
-    const sendModule = jiti(sendModulePath);
+    const getUpdatesModule = await loadModuleWithTsFallback(getUpdatesModulePath, { parentURL: import.meta.url });
+    const sendModule = await loadModuleWithTsFallback(sendModulePath, { parentURL: import.meta.url });
     if (typeof getUpdatesModule.getUpdates !== "function") {
         throw new Error("public getUpdates helper unavailable");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.14.34",
+  "version": "0.14.36",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -49,6 +49,7 @@
     "wechat:smoke:self-test": "npm run build && node --input-type=module -e \"import('./dist/wechat/compat/openclaw-smoke.js').then(async (m) => { const results = await m.runOpenClawSmoke('self-test'); console.log(JSON.stringify(results, null, 2)); })\"",
     "wechat:smoke:real-account": "npm run build && node --input-type=module -e \"import('./dist/wechat/compat/openclaw-smoke.js').then(async (m) => { const dryRun = process.argv.includes('--dry-run'); const results = await m.runOpenClawSmoke('real-account', { dryRun }); console.log(JSON.stringify(results, null, 2)); })\" --",
     "wechat:smoke:guided": "npm run build && node dist/wechat/compat/openclaw-guided-smoke.js",
+    "test:wechat-real-host-gate": "npm run build && node --test test/wechat-opencode-real-host-gate.test.js",
     "test": "npm run build && node --test",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"