opencode-copilot-account-switcher 0.14.7 → 0.14.9

package/dist/ui/menu.js

@@ -544,7 +544,7 @@ export async function showMenuWithDeps(accounts, input = {}, deps = {}) {
             return { type: "cancel" };
         if (result.type === "wechat-menu") {
             const [commonSettings, operatorBinding] = await Promise.all([
-                input.wechatPrimaryBinding
+                input.wechatPrimaryBinding || input.wechatOperatorBinding
                     ? Promise.resolve(undefined)
                     : (deps.readCommonSettings ?? readCommonSettingsStore)().catch(() => undefined),
                 input.wechatOperatorBinding

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";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import qrcodeTerminal from "qrcode-terminal";
 const DEFAULT_QR_WAIT_TIMEOUT_MS = 480000;
 function pickFirstNonEmptyString(...values) {
@@ -87,10 +88,11 @@ 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);
-        if (!accountId) {
+        const rawAccountId = pickFirstNonEmptyString(waited?.accountId);
+        if (!rawAccountId) {
             throw new Error("missing accountId after qr login");
         }
+        const accountId = normalizeAccountId(rawAccountId);
         const boundAt = now();
         const previousOperatorBinding = input.action === "wechat-rebind" ? await loadOperatorBinding() : undefined;
         const userIdFromWait = pickFirstNonEmptyString(waited?.userId);
@@ -149,13 +151,8 @@ export async function runWechatBindFlow(input) {
         }
         catch (error) {
             if (shouldRollbackBinding) {
-                if (input.action === "wechat-bind") {
-                    const currentOperatorBinding = await loadOperatorBinding().catch(() => undefined);
-                    if (isSameOperatorBinding(currentOperatorBinding, attemptedOperatorBinding)) {
-                        await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
-                    }
-                }
-                else {
+                const currentOperatorBinding = await loadOperatorBinding().catch(() => undefined);
+                if (isSameOperatorBinding(currentOperatorBinding, attemptedOperatorBinding)) {
                     await rollbackBinding(input.action, previousOperatorBinding, persistOperatorRebinding, clearOperatorBinding);
                 }
             }

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

@@ -1,5 +1,5 @@
 import { type QuestionAnswer } from "@opencode-ai/sdk/v2";
-import { type WechatStatusRuntime } from "./wechat-status-runtime.js";
+import { type WechatStatusRuntime, type WechatStatusRuntimeDiagnosticEvent } from "./wechat-status-runtime.js";
 import type { WechatSlashCommand } from "./command-parser.js";
 type BrokerWechatStatusRuntimeLifecycle = {
     start: () => Promise<void>;
@@ -10,9 +10,12 @@ type BrokerWechatStatusRuntimeLifecycleDeps = {
         onSlashCommand: (input: {
             command: import("./command-parser.js").WechatSlashCommand;
         }) => Promise<string>;
+        onDiagnosticEvent: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
     }) => WechatStatusRuntime;
     handleWechatSlashCommand?: (command: import("./command-parser.js").WechatSlashCommand) => Promise<string>;
     onRuntimeError?: (error: unknown) => void;
+    onDiagnosticEvent?: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
+    stateRoot?: string;
 };
 export declare function shouldEnableBrokerWechatStatusRuntime(env?: NodeJS.ProcessEnv): boolean;
 type BrokerWechatSlashHandlerClient = {

package/dist/wechat/broker-entry.js

@@ -1,12 +1,12 @@
 import path from "node:path";
 import process from "node:process";
 import { readFileSync, rmSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, 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";
+import { WECHAT_FILE_MODE, wechatStateRoot, wechatStatusRuntimeDiagnosticsPath } 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);
@@ -52,6 +52,22 @@ async function writeBrokerState(state, stateRoot) {
     const filePath = brokerStatePathForRoot(stateRoot);
     await writeFile(filePath, JSON.stringify(state, null, 2), { mode: WECHAT_FILE_MODE });
 }
+function createWechatStatusRuntimeDiagnosticsFileWriter(input) {
+    return async (event) => {
+        try {
+            await mkdir(input.stateRoot, { recursive: true, mode: 0o700 });
+            const filePath = wechatStatusRuntimeDiagnosticsPath(input.stateRoot);
+            const line = `${JSON.stringify({
+                timestamp: Date.now(),
+                ...event,
+            })}\n`;
+            await appendFile(filePath, line, { encoding: "utf8", mode: WECHAT_FILE_MODE });
+        }
+        catch (error) {
+            input.onRuntimeError(error);
+        }
+    };
+}
 export function shouldEnableBrokerWechatStatusRuntime(env = process.env) {
     void env;
     return true;
@@ -103,6 +119,8 @@ export function createBrokerWechatSlashCommandHandler(input) {
 }
 export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
     const onRuntimeError = deps.onRuntimeError ?? ((error) => console.error(error));
+    const stateRoot = deps.stateRoot ?? wechatStateRoot();
+    const onDiagnosticEvent = deps.onDiagnosticEvent ?? createWechatStatusRuntimeDiagnosticsFileWriter({ stateRoot, onRuntimeError });
     const v2Client = createOpencodeClientV2({
         baseUrl: "http://localhost:4096",
         directory: process.cwd(),
@@ -116,6 +134,7 @@ export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
         ((statusRuntimeDeps) => createWechatStatusRuntime({
             onSlashCommand: async ({ command }) => statusRuntimeDeps.onSlashCommand({ command }),
             onRuntimeError,
+            onDiagnosticEvent: statusRuntimeDeps.onDiagnosticEvent,
         }));
     let runtime = null;
     return {
@@ -125,6 +144,7 @@ export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
             }
             const created = createStatusRuntime({
                 onSlashCommand: async ({ command }) => handleWechatSlashCommand(command),
+                onDiagnosticEvent,
             });
             runtime = created;
             try {

package/dist/wechat/state-paths.d.ts

@@ -3,6 +3,7 @@ export declare const WECHAT_FILE_MODE = 384;
 export type WechatRequestKind = "question" | "permission";
 export declare function wechatStateRoot(): string;
 export declare function brokerStatePath(): string;
+export declare function wechatStatusRuntimeDiagnosticsPath(stateRoot?: string): string;
 export declare function launchLockPath(): string;
 export declare function operatorStatePath(): string;
 export declare function instancesDir(): string;

package/dist/wechat/state-paths.js

@@ -9,6 +9,9 @@ export function wechatStateRoot() {
 export function brokerStatePath() {
     return path.join(wechatStateRoot(), "broker.json");
 }
+export function wechatStatusRuntimeDiagnosticsPath(stateRoot = wechatStateRoot()) {
+    return path.join(stateRoot, "wechat-status-runtime.diagnostics.jsonl");
+}
 export function launchLockPath() {
     return path.join(wechatStateRoot(), "launch.lock");
 }

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

@@ -8,11 +8,28 @@ type SlashCommandHandlerInput = {
     text: string;
     message: PublicWeixinMessage;
 };
+export type WechatStatusRuntimeDiagnosticEvent = {
+    type: "messageSkipped";
+    reason: "missingFromUserId" | "missingText";
+    hasFromUserId: boolean;
+    hasText: boolean;
+} | {
+    type: "slashCommandRecognized";
+    command: WechatSlashCommand;
+    text: string;
+    to: string;
+} | {
+    type: "replySendFailed";
+    to: string;
+    error: string;
+    commandType: WechatSlashCommand["type"] | null;
+};
 type CreateWechatStatusRuntimeInput = {
     loadPublicHelpers?: (options?: OpenClawWeixinPublicHelpersLoaderOptions) => Promise<PublicHelpersForRuntime>;
     publicHelpersOptions?: OpenClawWeixinPublicHelpersLoaderOptions;
     onSlashCommand?: (input: SlashCommandHandlerInput) => Promise<string>;
     onRuntimeError?: (error: unknown) => void;
+    onDiagnosticEvent?: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
     retryDelayMs?: number;
     longPollTimeoutMs?: number;
     shouldReloadState?: (state: {

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

@@ -88,6 +88,15 @@ function toNonEmptyString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
 export function createWechatStatusRuntime(input = {}) {
     const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
     const onSlashCommand = input.onSlashCommand ??
@@ -95,6 +104,7 @@ export function createWechatStatusRuntime(input = {}) {
             return "/status 处理中";
         });
     const onRuntimeError = input.onRuntimeError ?? (() => { });
+    const onDiagnosticEvent = input.onDiagnosticEvent ?? (() => { });
     const retryDelayMs = normalizePositiveInteger(input.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
     const longPollTimeoutMs = normalizePositiveInteger(input.longPollTimeoutMs, DEFAULT_LONG_POLL_TIMEOUT_MS);
     const shouldReloadState = input.shouldReloadState ?? (() => false);
@@ -102,6 +112,13 @@ export function createWechatStatusRuntime(input = {}) {
     let closed = false;
     let stopController = null;
     let pollingTask = null;
+    const emitDiagnosticEvent = (event) => {
+        void Promise.resolve()
+            .then(() => onDiagnosticEvent(event))
+            .catch((error) => {
+            onRuntimeError(error);
+        });
+    };
     const poll = async (signal) => {
         let initialized = null;
         while (!signal.aborted) {
@@ -163,12 +180,34 @@ export function createWechatStatusRuntime(input = {}) {
                     }
                     const to = toNonEmptyString(message.from_user_id);
                     const text = extractMessageText(message);
-                    if (!to || text.trim().length === 0) {
+                    const hasText = text.trim().length > 0;
+                    if (!to) {
+                        emitDiagnosticEvent({
+                            type: "messageSkipped",
+                            reason: "missingFromUserId",
+                            hasFromUserId: false,
+                            hasText,
+                        });
+                        continue;
+                    }
+                    if (!hasText) {
+                        emitDiagnosticEvent({
+                            type: "messageSkipped",
+                            reason: "missingText",
+                            hasFromUserId: true,
+                            hasText: false,
+                        });
                         continue;
                     }
                     const parsedCommand = parseWechatSlashCommand(text);
                     let replyText = DEFAULT_NON_SLASH_REPLY_TEXT;
                     if (parsedCommand) {
+                        emitDiagnosticEvent({
+                            type: "slashCommandRecognized",
+                            command: parsedCommand,
+                            text,
+                            to,
+                        });
                         try {
                             replyText = await onSlashCommand({
                                 command: parsedCommand,
@@ -196,6 +235,12 @@ export function createWechatStatusRuntime(input = {}) {
                         if (isAbortError(error)) {
                             return;
                         }
+                        emitDiagnosticEvent({
+                            type: "replySendFailed",
+                            to,
+                            error: toErrorMessage(error),
+                            commandType: parsedCommand?.type ?? null,
+                        });
                         onRuntimeError(error);
                     }
                 }

package/package.json

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