opencode-copilot-account-switcher 0.14.35 → 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,7 @@ 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;
@@ -10,9 +11,10 @@ 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?: {

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

@@ -22,17 +22,37 @@ 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;
 }
@@ -56,16 +76,36 @@ 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;
-    if (hasBunRuntime(options.bunVersion)) {
+    // 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)();

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.14.35",
+  "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"