opencode-copilot-account-switcher 0.14.2 → 0.14.3

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

@@ -19,6 +19,7 @@ type WechatBindFlowInput = {
     resetOperatorBinding?: typeof resetOperatorBinding;
     readCommonSettings: () => Promise<CommonSettingsStore>;
     writeCommonSettings: (settings: CommonSettingsStore) => Promise<void>;
+    writeLine?: (line: string) => Promise<void>;
     now?: () => number;
 };
 export declare function runWechatBindFlow(input: WechatBindFlowInput): Promise<WechatBindFlowResult>;

package/dist/wechat/bind-flow.js

@@ -1,6 +1,7 @@
 import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
 import { loadOpenClawWeixinPublicHelpers } from "./compat/openclaw-public-helpers.js";
 import { buildOpenClawMenuAccount } from "./openclaw-account-adapter.js";
+const DEFAULT_QR_WAIT_TIMEOUT_MS = 480000;
 function pickFirstNonEmptyString(...values) {
     for (const value of values) {
         if (typeof value === "string" && value.trim().length > 0) {
@@ -15,6 +16,22 @@ function toErrorMessage(error) {
     }
     return String(error);
 }
+function pickQrTerminal(value) {
+    return pickFirstNonEmptyString(value?.terminalQr, value?.qrTerminal, value?.qrText, value?.asciiQr);
+}
+function pickQrUrl(value) {
+    return pickFirstNonEmptyString(value?.qrDataUrl, value?.qrUrl, value?.url, value?.loginUrl);
+}
+function isTimeoutWaitResult(value) {
+    return Boolean(value && typeof value === "object" && "status" in value && String(value.status) === "timeout");
+}
+async function rollbackBinding(action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding) {
+    if (action === "wechat-rebind" && previousOperatorBinding) {
+        await persistOperatorRebinding(previousOperatorBinding).catch(() => { });
+        return;
+    }
+    await clearOperatorBinding().catch(() => { });
+}
 export async function runWechatBindFlow(input) {
     const now = input.now ?? Date.now;
     const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
@@ -22,12 +39,33 @@ export async function runWechatBindFlow(input) {
     const persistOperatorRebinding = input.rebindOperator ?? rebindOperator;
     const loadOperatorBinding = input.readOperatorBinding ?? readOperatorBinding;
     const clearOperatorBinding = input.resetOperatorBinding ?? resetOperatorBinding;
+    const writeLine = input.writeLine ?? (async (line) => {
+        process.stdout.write(`${line}\n`);
+    });
     try {
         const helpers = await loadPublicHelpers();
         const started = await Promise.resolve(helpers.qrGateway.loginWithQrStart({ source: "menu", action: input.action }));
-        const sessionKey = pickFirstNonEmptyString(started?.sessionKey, started?.key);
-        const waited = await Promise.resolve(helpers.qrGateway.loginWithQrWait({ timeoutMs: 120000, sessionKey }));
-        const accountId = pickFirstNonEmptyString(helpers.latestAccountState?.accountId, waited?.accountId, (await helpers.accountHelpers.listAccountIds()).at(-1));
+        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);
+        if (qrTerminal) {
+            await writeLine(qrTerminal);
+        }
+        else if (qrUrl) {
+            await writeLine(`QR URL fallback: ${qrUrl}`);
+        }
+        else {
+            throw new Error(qrStartMessage || "invalid qr login result: missing qr code or qr url");
+        }
+        const waited = await Promise.resolve(helpers.qrGateway.loginWithQrWait({ timeoutMs: DEFAULT_QR_WAIT_TIMEOUT_MS, sessionKey }));
+        if (isTimeoutWaitResult(waited)) {
+            throw new Error("qr login timed out before completion");
+        }
+        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 userId = pickFirstNonEmptyString(waited?.userId, waited?.openid, waited?.uid);
         if (!accountId) {
             throw new Error("missing accountId after qr login");
@@ -42,45 +80,53 @@ export async function runWechatBindFlow(input) {
             boundAt,
         };
         const previousOperatorBinding = input.action === "wechat-rebind" ? await loadOperatorBinding() : undefined;
-        if (input.action === "wechat-rebind") {
-            await persistOperatorRebinding(operatorBinding);
-        }
-        else {
-            await persistOperatorBinding(operatorBinding);
-        }
-        const menuAccount = await buildOpenClawMenuAccount({
-            latestAccountState: helpers.latestAccountState,
-            accountHelpers: helpers.accountHelpers,
-        });
-        const settings = await input.readCommonSettings();
-        const notifications = settings.wechat?.notifications ?? {
-            enabled: true,
-            question: true,
-            permission: true,
-            sessionError: true,
-        };
-        settings.wechat = {
-            ...settings.wechat,
-            notifications,
-            primaryBinding: {
-                accountId,
-                userId,
-                name: menuAccount?.name,
-                enabled: menuAccount?.enabled,
-                configured: menuAccount?.configured,
-                boundAt,
-            },
-        };
+        let menuAccount;
         try {
-            await input.writeCommonSettings(settings);
-        }
-        catch (error) {
-            if (input.action === "wechat-rebind" && previousOperatorBinding) {
-                await persistOperatorRebinding(previousOperatorBinding).catch(() => { });
+            if (input.action === "wechat-rebind") {
+                await persistOperatorRebinding(operatorBinding);
             }
             else {
-                await clearOperatorBinding().catch(() => { });
+                await persistOperatorBinding(operatorBinding);
             }
+            const menuAccountState = accountId
+                ? {
+                    ...(helpers.latestAccountState ?? {
+                        accountId,
+                        token: "",
+                        baseUrl: "https://ilinkai.weixin.qq.com",
+                    }),
+                    accountId,
+                    userId,
+                    boundAt,
+                }
+                : helpers.latestAccountState;
+            menuAccount = await buildOpenClawMenuAccount({
+                latestAccountState: menuAccountState,
+                accountHelpers: helpers.accountHelpers,
+            });
+            const settings = await input.readCommonSettings();
+            const notifications = settings.wechat?.notifications ?? {
+                enabled: true,
+                question: true,
+                permission: true,
+                sessionError: true,
+            };
+            settings.wechat = {
+                ...settings.wechat,
+                notifications,
+                primaryBinding: {
+                    accountId,
+                    userId,
+                    name: menuAccount?.name,
+                    enabled: menuAccount?.enabled,
+                    configured: menuAccount?.configured,
+                    boundAt,
+                },
+            };
+            await input.writeCommonSettings(settings);
+        }
+        catch (error) {
+            await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
             throw error;
         }
         return {

package/dist/wechat/broker-entry.d.ts

@@ -1,4 +1,6 @@
+import { type QuestionAnswer } from "@opencode-ai/sdk/v2";
 import { type WechatStatusRuntime } from "./wechat-status-runtime.js";
+import type { WechatSlashCommand } from "./command-parser.js";
 type BrokerWechatStatusRuntimeLifecycle = {
     start: () => Promise<void>;
     close: () => Promise<void>;
@@ -13,5 +15,45 @@ type BrokerWechatStatusRuntimeLifecycleDeps = {
     onRuntimeError?: (error: unknown) => void;
 };
 export declare function shouldEnableBrokerWechatStatusRuntime(env?: NodeJS.ProcessEnv): boolean;
+type BrokerWechatSlashHandlerClient = {
+    question?: {
+        list?: (input?: {
+            directory?: string;
+        }) => Promise<{
+            data?: Array<{
+                id?: string;
+            }>;
+        } | Array<{
+            id?: string;
+        }> | undefined>;
+        reply?: (input: {
+            requestID: string;
+            directory?: string;
+            answers?: Array<QuestionAnswer>;
+        }) => Promise<unknown>;
+    };
+    permission?: {
+        list?: (input?: {
+            directory?: string;
+        }) => Promise<{
+            data?: Array<{
+                id?: string;
+            }>;
+        } | Array<{
+            id?: string;
+        }> | undefined>;
+        reply?: (input: {
+            requestID: string;
+            directory?: string;
+            reply?: "once" | "always" | "reject";
+            message?: string;
+        }) => Promise<unknown>;
+    };
+};
+export declare function createBrokerWechatSlashCommandHandler(input: {
+    handleStatusCommand: () => Promise<string>;
+    client?: BrokerWechatSlashHandlerClient;
+    directory?: string;
+}): (command: WechatSlashCommand) => Promise<string>;
 export declare function createBrokerWechatStatusRuntimeLifecycle(deps?: BrokerWechatStatusRuntimeLifecycleDeps): BrokerWechatStatusRuntimeLifecycle;
 export {};

package/dist/wechat/broker-entry.js

@@ -3,9 +3,11 @@ import process from "node:process";
 import { readFileSync, rmSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import { createOpencodeClient as createOpencodeClientV2 } from "@opencode-ai/sdk/v2";
 import { startBrokerServer } from "./broker-server.js";
 import { WECHAT_FILE_MODE, wechatStateRoot } from "./state-paths.js";
 import { createWechatStatusRuntime } from "./wechat-status-runtime.js";
+const BROKER_WECHAT_RUNTIME_AUTOSTART_DELAY_MS = 1_000;
 async function readPackageVersion() {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
     return readFile(packageJsonPath, "utf8")
@@ -51,17 +53,65 @@ async function writeBrokerState(state, stateRoot) {
     await writeFile(filePath, JSON.stringify(state, null, 2), { mode: WECHAT_FILE_MODE });
 }
 export function shouldEnableBrokerWechatStatusRuntime(env = process.env) {
-    return env.WECHAT_BROKER_ENABLE_STATUS_RUNTIME === "1";
+    void env;
+    return true;
+}
+function unwrapDataArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return Array.isArray(value?.data) ? value.data : [];
+}
+function withOptionalDirectory(input, directory) {
+    if (typeof directory === "string" && directory.trim().length > 0) {
+        return {
+            ...input,
+            directory,
+        };
+    }
+    return input;
+}
+export function createBrokerWechatSlashCommandHandler(input) {
+    return async (command) => {
+        if (command.type === "status") {
+            return input.handleStatusCommand();
+        }
+        if (command.type === "reply") {
+            const questions = unwrapDataArray(await input.client?.question?.list?.(withOptionalDirectory({}, input.directory)));
+            const requestID = typeof questions[0]?.id === "string" ? questions[0].id : undefined;
+            if (!requestID) {
+                return "当前没有待回复问题";
+            }
+            await input.client?.question?.reply?.(withOptionalDirectory({
+                requestID,
+                answers: [[command.text]],
+            }, input.directory));
+            return `已回复问题：${requestID}`;
+        }
+        const permissions = unwrapDataArray(await input.client?.permission?.list?.(withOptionalDirectory({}, input.directory)));
+        const requestID = typeof permissions[0]?.id === "string" ? permissions[0].id : undefined;
+        if (!requestID) {
+            return "当前没有待处理权限请求";
+        }
+        await input.client?.permission?.reply?.(withOptionalDirectory({
+            requestID,
+            reply: command.reply,
+            ...(command.message ? { message: command.message } : {}),
+        }, input.directory));
+        return `已处理权限请求：${requestID} (${command.reply})`;
+    };
 }
 export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
     const onRuntimeError = deps.onRuntimeError ?? ((error) => console.error(error));
-    const handleWechatSlashCommand = deps.handleWechatSlashCommand ??
-        (async (command) => {
-            if (command.type === "status") {
-                return "命令暂未实现：/status";
-            }
-            return `命令暂未实现：/${command.command}`;
-        });
+    const v2Client = createOpencodeClientV2({
+        baseUrl: "http://localhost:4096",
+        directory: process.cwd(),
+    });
+    const handleWechatSlashCommand = deps.handleWechatSlashCommand ?? createBrokerWechatSlashCommandHandler({
+        handleStatusCommand: async () => "命令暂未实现：/status",
+        client: v2Client,
+        directory: process.cwd(),
+    });
     const createStatusRuntime = deps.createStatusRuntime ??
         ((statusRuntimeDeps) => createWechatStatusRuntime({
             onSlashCommand: async ({ command }) => statusRuntimeDeps.onSlashCommand({ command }),
@@ -124,10 +174,19 @@ async function run() {
     };
     await writeBrokerState(state, stateRoot);
     const wechatRuntimeLifecycle = createBrokerWechatStatusRuntimeLifecycle({
-        handleWechatSlashCommand: server.handleWechatSlashCommand,
+        handleWechatSlashCommand: createBrokerWechatSlashCommandHandler({
+            handleStatusCommand: async () => server.handleWechatSlashCommand({ type: "status" }),
+            client: createOpencodeClientV2({
+                baseUrl: "http://localhost:4096",
+                directory: stateRoot,
+            }),
+            directory: stateRoot,
+        }),
     });
     if (shouldEnableBrokerWechatStatusRuntime()) {
-        await wechatRuntimeLifecycle.start();
+        setTimeout(() => {
+            void wechatRuntimeLifecycle.start();
+        }, BROKER_WECHAT_RUNTIME_AUTOSTART_DELAY_MS);
     }
     const ownership = {
         pid: state.pid,

package/dist/wechat/broker-server.js

@@ -506,7 +506,10 @@ export async function startBrokerServer(endpoint) {
             const result = await collectStatus();
             return result.reply;
         }
-        return `命令暂未实现：/${command.command}`;
+        if (command.type === "reply") {
+            return "命令暂未实现：/reply";
+        }
+        return "命令暂未实现：/allow";
     };
     const close = async () => {
         if (closed) {

package/dist/wechat/command-parser.d.ts

@@ -1,7 +1,11 @@
 export type WechatSlashCommand = {
     type: "status";
 } | {
-    type: "unimplemented";
-    command: string;
+    type: "reply";
+    text: string;
+} | {
+    type: "allow";
+    reply: "once" | "always" | "reject";
+    message?: string;
 };
 export declare function parseWechatSlashCommand(input: string): WechatSlashCommand | null;

package/dist/wechat/command-parser.js

@@ -6,11 +6,26 @@ export function parseWechatSlashCommand(input) {
     if (normalized === "/status") {
         return { type: "status" };
     }
-    if (normalized.startsWith("/")) {
-        const command = normalized.slice(1).split(/\s+/, 1)[0];
-        if (command === "reply" || command === "allow") {
-            return { type: "unimplemented", command };
+    if (normalized.startsWith("/reply")) {
+        const text = normalized.slice("/reply".length).trim();
+        if (!text) {
+            return null;
         }
+        return { type: "reply", text };
+    }
+    if (normalized.startsWith("/allow")) {
+        const rest = normalized.slice("/allow".length).trim();
+        if (!rest) {
+            return null;
+        }
+        const [rawReply, ...messageParts] = rest.split(/\s+/);
+        if (rawReply !== "once" && rawReply !== "always" && rawReply !== "reject") {
+            return null;
+        }
+        const message = messageParts.join(" ").trim();
+        return message.length > 0
+            ? { type: "allow", reply: rawReply, message }
+            : { type: "allow", reply: rawReply };
     }
     return null;
 }

package/dist/wechat/wechat-status-runtime.d.ts

@@ -15,6 +15,12 @@ type CreateWechatStatusRuntimeInput = {
     onRuntimeError?: (error: unknown) => void;
     retryDelayMs?: number;
     longPollTimeoutMs?: number;
+    shouldReloadState?: (state: {
+        accountId: string;
+        baseUrl: string;
+        token: string;
+        getUpdatesBuf: string;
+    }) => boolean;
 };
 export type WechatStatusRuntime = {
     start: () => Promise<void>;

package/dist/wechat/wechat-status-runtime.js

@@ -97,6 +97,7 @@ export function createWechatStatusRuntime(input = {}) {
     const onRuntimeError = input.onRuntimeError ?? (() => { });
     const retryDelayMs = normalizePositiveInteger(input.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
     const longPollTimeoutMs = normalizePositiveInteger(input.longPollTimeoutMs, DEFAULT_LONG_POLL_TIMEOUT_MS);
+    const shouldReloadState = input.shouldReloadState ?? (() => false);
     let started = false;
     let closed = false;
     let stopController = null;
@@ -105,6 +106,7 @@ export function createWechatStatusRuntime(input = {}) {
         let initialized = null;
         while (!signal.aborted) {
             try {
+                let justInitialized = false;
                 if (!initialized) {
                     const helpers = await withAbort(loadPublicHelpers(input.publicHelpersOptions), signal);
                     const latestAccountState = helpers.latestAccountState;
@@ -118,6 +120,16 @@ export function createWechatStatusRuntime(input = {}) {
                         token: latestAccountState.token,
                         getUpdatesBuf: typeof latestAccountState.getUpdatesBuf === "string" ? latestAccountState.getUpdatesBuf : "",
                     };
+                    justInitialized = true;
+                }
+                if (!justInitialized && initialized && shouldReloadState({
+                    accountId: initialized.accountId,
+                    baseUrl: initialized.baseUrl,
+                    token: initialized.token,
+                    getUpdatesBuf: initialized.getUpdatesBuf,
+                })) {
+                    initialized = null;
+                    continue;
                 }
                 const response = await withAbort(initialized.helpers.getUpdates({
                     baseUrl: initialized.baseUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",