opencode-copilot-account-switcher 0.14.0 → 0.14.2

package/dist/common-settings-actions.d.ts

@@ -1,5 +1,5 @@
 import type { CommonSettingsStore } from "./common-settings-store.js";
-export type CommonSettingsActionType = "toggle-loop-safety" | "toggle-loop-safety-provider-scope" | "toggle-experimental-slash-commands" | "toggle-network-retry" | "toggle-wechat-notifications" | "toggle-wechat-question-notify" | "toggle-wechat-permission-notify" | "toggle-wechat-session-error-notify";
+export type CommonSettingsActionType = "toggle-loop-safety" | "toggle-loop-safety-provider-scope" | "toggle-experimental-slash-commands" | "toggle-network-retry" | "wechat-bind" | "wechat-rebind" | "wechat-unbind" | "toggle-wechat-notifications" | "toggle-wechat-question-notify" | "toggle-wechat-permission-notify" | "toggle-wechat-session-error-notify";
 type WriteMeta = {
     reason?: string;
     source?: string;

package/dist/common-settings-actions.js

@@ -1,5 +1,20 @@
 export async function applyCommonSettingsAction(input) {
     const settings = await input.readSettings();
+    const existingNotifications = settings.wechat?.notifications;
+    const notifications = {
+        enabled: existingNotifications?.enabled !== false,
+        question: existingNotifications?.question !== false,
+        permission: existingNotifications?.permission !== false,
+        sessionError: existingNotifications?.sessionError !== false,
+    };
+    if (!settings.wechat) {
+        settings.wechat = {
+            notifications,
+        };
+    }
+    else if (!settings.wechat.notifications) {
+        settings.wechat.notifications = notifications;
+    }
     if (input.action.type === "toggle-loop-safety") {
         settings.loopSafetyEnabled = settings.loopSafetyEnabled !== true;
         await input.writeSettings(settings, {
@@ -39,7 +54,7 @@ export async function applyCommonSettingsAction(input) {
         return true;
     }
     if (input.action.type === "toggle-wechat-notifications") {
-        settings.wechatNotificationsEnabled = settings.wechatNotificationsEnabled !== true;
+        settings.wechat.notifications.enabled = settings.wechat.notifications.enabled !== true;
         await input.writeSettings(settings, {
             reason: "toggle-wechat-notifications",
             source: "applyCommonSettingsAction",
@@ -48,7 +63,7 @@ export async function applyCommonSettingsAction(input) {
         return true;
     }
     if (input.action.type === "toggle-wechat-question-notify") {
-        settings.wechatQuestionNotifyEnabled = settings.wechatQuestionNotifyEnabled !== true;
+        settings.wechat.notifications.question = settings.wechat.notifications.question !== true;
         await input.writeSettings(settings, {
             reason: "toggle-wechat-question-notify",
             source: "applyCommonSettingsAction",
@@ -57,7 +72,7 @@ export async function applyCommonSettingsAction(input) {
         return true;
     }
     if (input.action.type === "toggle-wechat-permission-notify") {
-        settings.wechatPermissionNotifyEnabled = settings.wechatPermissionNotifyEnabled !== true;
+        settings.wechat.notifications.permission = settings.wechat.notifications.permission !== true;
         await input.writeSettings(settings, {
             reason: "toggle-wechat-permission-notify",
             source: "applyCommonSettingsAction",
@@ -66,7 +81,7 @@ export async function applyCommonSettingsAction(input) {
         return true;
     }
     if (input.action.type === "toggle-wechat-session-error-notify") {
-        settings.wechatSessionErrorNotifyEnabled = settings.wechatSessionErrorNotifyEnabled !== true;
+        settings.wechat.notifications.sessionError = settings.wechat.notifications.sessionError !== true;
         await input.writeSettings(settings, {
             reason: "toggle-wechat-session-error-notify",
             source: "applyCommonSettingsAction",
@@ -74,5 +89,8 @@ export async function applyCommonSettingsAction(input) {
         });
         return true;
     }
+    if (input.action.type === "wechat-bind" || input.action.type === "wechat-rebind" || input.action.type === "wechat-unbind") {
+        return true;
+    }
     return false;
 }

package/dist/common-settings-store.d.ts

@@ -4,11 +4,32 @@ export type CommonSettingsStore = {
     networkRetryEnabled?: boolean;
     experimentalSlashCommandsEnabled?: boolean;
     experimentalStatusSlashCommandEnabled?: boolean;
+    wechat?: WechatMenuSettings;
     wechatNotificationsEnabled?: boolean;
     wechatQuestionNotifyEnabled?: boolean;
     wechatPermissionNotifyEnabled?: boolean;
     wechatSessionErrorNotifyEnabled?: boolean;
 };
+export type WechatBinding = {
+    accountId: string;
+    userId?: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt?: number;
+};
+export type WechatMenuSettings = {
+    primaryBinding?: WechatBinding;
+    notifications: {
+        enabled: boolean;
+        question: boolean;
+        permission: boolean;
+        sessionError: boolean;
+    };
+    future?: {
+        accounts?: WechatBinding[];
+    };
+};
 export declare function parseCommonSettingsStore(raw: string): CommonSettingsStore;
 export declare function commonSettingsPath(): string;
 export declare function readCommonSettingsStore(options?: {

package/dist/common-settings-store.js

@@ -3,9 +3,68 @@ import { promises as fs } from "node:fs";
 import { readFileSync } from "node:fs";
 import { commonSettingsPath as defaultCommonSettingsPath, legacyCopilotStorePath } from "./store-paths.js";
 import { parseStore } from "./store.js";
+function normalizeWechatBinding(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const value = input;
+    if (typeof value.accountId !== "string" || value.accountId.length === 0)
+        return undefined;
+    const binding = { accountId: value.accountId };
+    if (typeof value.userId === "string")
+        binding.userId = value.userId;
+    if (typeof value.name === "string")
+        binding.name = value.name;
+    if (typeof value.enabled === "boolean")
+        binding.enabled = value.enabled;
+    if (typeof value.configured === "boolean")
+        binding.configured = value.configured;
+    if (typeof value.boundAt === "number" && Number.isFinite(value.boundAt))
+        binding.boundAt = value.boundAt;
+    return binding;
+}
+function normalizeWechatSettings(source) {
+    const wechatValue = source.wechat && typeof source.wechat === "object"
+        ? source.wechat
+        : undefined;
+    const notificationsValue = wechatValue?.notifications && typeof wechatValue.notifications === "object"
+        ? wechatValue.notifications
+        : undefined;
+    const futureValue = wechatValue?.future && typeof wechatValue.future === "object"
+        ? wechatValue.future
+        : undefined;
+    const enabled = typeof notificationsValue?.enabled === "boolean"
+        ? notificationsValue.enabled
+        : source.wechatNotificationsEnabled !== false;
+    const question = typeof notificationsValue?.question === "boolean"
+        ? notificationsValue.question
+        : source.wechatQuestionNotifyEnabled !== false;
+    const permission = typeof notificationsValue?.permission === "boolean"
+        ? notificationsValue.permission
+        : source.wechatPermissionNotifyEnabled !== false;
+    const sessionError = typeof notificationsValue?.sessionError === "boolean"
+        ? notificationsValue.sessionError
+        : source.wechatSessionErrorNotifyEnabled !== false;
+    const primaryBinding = normalizeWechatBinding(wechatValue?.primaryBinding);
+    const accounts = Array.isArray(futureValue?.accounts)
+        ? futureValue.accounts
+            .map((account) => normalizeWechatBinding(account))
+            .filter((account) => Boolean(account))
+        : undefined;
+    return {
+        ...(primaryBinding ? { primaryBinding } : {}),
+        notifications: {
+            enabled,
+            question,
+            permission,
+            sessionError,
+        },
+        ...(accounts ? { future: { accounts } } : {}),
+    };
+}
 function normalizeCommonSettingsStore(input) {
     const source = input ?? {};
     const legacySlashCommandsEnabled = source.experimentalStatusSlashCommandEnabled;
+    const wechat = normalizeWechatSettings(source);
     return {
         ...(source.loopSafetyEnabled !== false ? { loopSafetyEnabled: true } : { loopSafetyEnabled: false }),
         loopSafetyProviderScope: source.loopSafetyProviderScope === "all-models" ? "all-models" : "copilot-only",
@@ -15,12 +74,7 @@ function normalizeCommonSettingsStore(input) {
             : legacySlashCommandsEnabled === false
                 ? false
                 : true,
-        ...(source.wechatNotificationsEnabled === false ? { wechatNotificationsEnabled: false } : { wechatNotificationsEnabled: true }),
-        ...(source.wechatQuestionNotifyEnabled === false ? { wechatQuestionNotifyEnabled: false } : { wechatQuestionNotifyEnabled: true }),
-        ...(source.wechatPermissionNotifyEnabled === false ? { wechatPermissionNotifyEnabled: false } : { wechatPermissionNotifyEnabled: true }),
-        ...(source.wechatSessionErrorNotifyEnabled === false
-            ? { wechatSessionErrorNotifyEnabled: false }
-            : { wechatSessionErrorNotifyEnabled: true }),
+        wechat,
     };
 }
 function parsePartialCommonSettingsStore(raw) {
@@ -41,6 +95,9 @@ function parsePartialCommonSettingsStore(raw) {
     if (parsed.experimentalStatusSlashCommandEnabled === true || parsed.experimentalStatusSlashCommandEnabled === false) {
         partial.experimentalStatusSlashCommandEnabled = parsed.experimentalStatusSlashCommandEnabled;
     }
+    if (parsed.wechat && typeof parsed.wechat === "object") {
+        partial.wechat = parsed.wechat;
+    }
     if (parsed.wechatNotificationsEnabled === true || parsed.wechatNotificationsEnabled === false) {
         partial.wechatNotificationsEnabled = parsed.wechatNotificationsEnabled;
     }
@@ -73,6 +130,7 @@ function mergeCommonSettings(current, legacy) {
         networkRetryEnabled: current.networkRetryEnabled ?? legacy.networkRetryEnabled,
         experimentalSlashCommandsEnabled: current.experimentalSlashCommandsEnabled ?? legacy.experimentalSlashCommandsEnabled,
         experimentalStatusSlashCommandEnabled: current.experimentalStatusSlashCommandEnabled ?? legacy.experimentalStatusSlashCommandEnabled,
+        wechat: current.wechat,
         wechatNotificationsEnabled: current.wechatNotificationsEnabled ?? legacy.wechatNotificationsEnabled,
         wechatQuestionNotifyEnabled: current.wechatQuestionNotifyEnabled ?? legacy.wechatQuestionNotifyEnabled,
         wechatPermissionNotifyEnabled: current.wechatPermissionNotifyEnabled ?? legacy.wechatPermissionNotifyEnabled,
@@ -138,10 +196,7 @@ export async function writeCommonSettingsStore(store, options) {
         loopSafetyProviderScope: normalized.loopSafetyProviderScope,
         networkRetryEnabled: normalized.networkRetryEnabled,
         experimentalSlashCommandsEnabled: normalized.experimentalSlashCommandsEnabled,
-        wechatNotificationsEnabled: normalized.wechatNotificationsEnabled,
-        wechatQuestionNotifyEnabled: normalized.wechatQuestionNotifyEnabled,
-        wechatPermissionNotifyEnabled: normalized.wechatPermissionNotifyEnabled,
-        wechatSessionErrorNotifyEnabled: normalized.wechatSessionErrorNotifyEnabled,
+        wechat: normalized.wechat,
     };
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });

package/dist/plugin.js

@@ -33,6 +33,10 @@ function toSharedRuntimeAction(action) {
         return { type: "provider", name: "toggle-experimental-slash-commands" };
     if (action.type === "toggle-network-retry")
         return { type: "provider", name: "toggle-network-retry" };
+    if (action.type === "wechat-bind")
+        return { type: "provider", name: "wechat-bind" };
+    if (action.type === "wechat-rebind")
+        return { type: "provider", name: "wechat-rebind" };
     return undefined;
 }
 export async function configureDefaultAccountGroup(store, selectors) {

package/dist/providers/codex-menu-adapter.js

@@ -7,6 +7,7 @@ import { recoverInvalidCodexAccount } from "../codex-invalid-account.js";
 import { readAuth } from "../store.js";
 import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
 import { applyCommonSettingsAction } from "../common-settings-actions.js";
+import { runWechatBindFlow } from "../wechat/bind-flow.js";
 function pickName(input) {
     const accountId = input.accountId?.trim();
     if (accountId)
@@ -382,8 +383,13 @@ export function createCodexMenuAdapter(inputDeps) {
                 });
                 return false;
             }
-            if (action.name === "wechat-bind") {
-                return true;
+            if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                await runWechatBindFlow({
+                    action: action.name,
+                    readCommonSettings,
+                    writeCommonSettings,
+                });
+                return false;
             }
             return false;
         },

package/dist/providers/copilot-menu-adapter.js

@@ -5,6 +5,7 @@ import { getGitHubToken, normalizeDomain } from "../copilot-api-helpers.js";
 import { listAssignableAccountsForModel, listKnownCopilotModels, rewriteModelAccountAssignments, } from "../model-account-map.js";
 import { applyMenuAction, persistAccountSwitch } from "../plugin-actions.js";
 import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
+import { runWechatBindFlow } from "../wechat/bind-flow.js";
 import { select, selectMany } from "../ui/select.js";
 import { authPath, readAuth, readStore } from "../store.js";
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
@@ -740,8 +741,13 @@ export function createCopilotMenuAdapter(inputDeps) {
                 });
                 return false;
             }
-            if (action.name === "wechat-bind") {
-                return true;
+            if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                await runWechatBindFlow({
+                    action: action.name,
+                    readCommonSettings,
+                    writeCommonSettings,
+                });
+                return false;
             }
             if (action.name === "list-models") {
                 const modelID = await select([

package/dist/ui/menu.d.ts

@@ -1,5 +1,7 @@
 import { select, type MenuItem } from "./select.js";
 import { confirm } from "./confirm.js";
+import { type CommonSettingsStore } from "../common-settings-store.js";
+import { type OperatorBinding } from "../wechat/operator-store.js";
 export type AccountStatus = "active" | "expired" | "unknown";
 export interface AccountInfo {
     name: string;
@@ -69,8 +71,12 @@ export type MenuAction = {
     type: "toggle-experimental-slash-commands";
 } | {
     type: "toggle-network-retry";
+} | {
+    type: "wechat-menu";
 } | {
     type: "wechat-bind";
+} | {
+    type: "wechat-rebind";
 } | {
     type: "toggle-wechat-notifications";
 } | {
@@ -94,6 +100,42 @@ export type MenuAction = {
 };
 export type MenuLanguage = "zh" | "en";
 export type MenuProvider = "copilot" | "codex";
+export type MenuWechatPrimaryBinding = {
+    accountId: string;
+    userId?: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt?: number;
+};
+export type MenuWechatOperatorBinding = {
+    wechatAccountId: string;
+    userId: string;
+    boundAt: number;
+};
+export type ShowMenuInput = {
+    provider?: MenuProvider;
+    refresh?: {
+        enabled: boolean;
+        minutes: number;
+    };
+    lastQuotaRefresh?: number;
+    modelAccountAssignmentCount?: number;
+    defaultAccountGroupCount?: number;
+    loopSafetyEnabled?: boolean;
+    loopSafetyProviderScope?: "copilot-only" | "all-models";
+    networkRetryEnabled?: boolean;
+    wechatNotificationsEnabled?: boolean;
+    wechatQuestionNotifyEnabled?: boolean;
+    wechatPermissionNotifyEnabled?: boolean;
+    wechatSessionErrorNotifyEnabled?: boolean;
+    wechatPrimaryBinding?: MenuWechatPrimaryBinding;
+    wechatOperatorBinding?: MenuWechatOperatorBinding;
+    syntheticAgentInitiatorEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    capabilities?: Partial<MenuCapabilities>;
+    language?: MenuLanguage;
+};
 type MenuCapabilities = {
     importAuth: boolean;
     quota: boolean;
@@ -172,56 +214,20 @@ export declare function buildMenuItems(input: {
     wechatQuestionNotifyEnabled?: boolean;
     wechatPermissionNotifyEnabled?: boolean;
     wechatSessionErrorNotifyEnabled?: boolean;
+    wechatPrimaryBinding?: MenuWechatPrimaryBinding;
+    wechatOperatorBinding?: MenuWechatOperatorBinding;
     syntheticAgentInitiatorEnabled?: boolean;
     experimentalSlashCommandsEnabled?: boolean;
     capabilities?: Partial<MenuCapabilities>;
     language?: MenuLanguage;
 }): MenuItem<MenuAction>[];
-export declare function showMenu(accounts: AccountInfo[], input?: {
-    provider?: MenuProvider;
-    refresh?: {
-        enabled: boolean;
-        minutes: number;
-    };
-    lastQuotaRefresh?: number;
-    modelAccountAssignmentCount?: number;
-    defaultAccountGroupCount?: number;
-    loopSafetyEnabled?: boolean;
-    loopSafetyProviderScope?: "copilot-only" | "all-models";
-    networkRetryEnabled?: boolean;
-    wechatNotificationsEnabled?: boolean;
-    wechatQuestionNotifyEnabled?: boolean;
-    wechatPermissionNotifyEnabled?: boolean;
-    wechatSessionErrorNotifyEnabled?: boolean;
-    syntheticAgentInitiatorEnabled?: boolean;
-    experimentalSlashCommandsEnabled?: boolean;
-    capabilities?: Partial<MenuCapabilities>;
-    language?: MenuLanguage;
-}): Promise<MenuAction>;
-export declare function showMenuWithDeps(accounts: AccountInfo[], input?: {
-    provider?: MenuProvider;
-    refresh?: {
-        enabled: boolean;
-        minutes: number;
-    };
-    lastQuotaRefresh?: number;
-    modelAccountAssignmentCount?: number;
-    defaultAccountGroupCount?: number;
-    loopSafetyEnabled?: boolean;
-    loopSafetyProviderScope?: "copilot-only" | "all-models";
-    networkRetryEnabled?: boolean;
-    wechatNotificationsEnabled?: boolean;
-    wechatQuestionNotifyEnabled?: boolean;
-    wechatPermissionNotifyEnabled?: boolean;
-    wechatSessionErrorNotifyEnabled?: boolean;
-    syntheticAgentInitiatorEnabled?: boolean;
-    experimentalSlashCommandsEnabled?: boolean;
-    capabilities?: Partial<MenuCapabilities>;
-    language?: MenuLanguage;
-}, deps?: {
+export declare function showMenu(accounts: AccountInfo[], input?: ShowMenuInput): Promise<MenuAction>;
+export declare function showMenuWithDeps(accounts: AccountInfo[], input?: ShowMenuInput, deps?: {
     select?: typeof select;
     confirm?: typeof confirm;
     showAccountActions?: typeof showAccountActions;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    readOperatorBinding?: () => Promise<OperatorBinding | undefined>;
 }): Promise<MenuAction>;
 export declare function buildAccountActionItems(account: AccountInfo, input?: {
     provider?: MenuProvider;

package/dist/ui/menu.js

@@ -1,6 +1,8 @@
 import { ANSI } from "./ansi.js";
 import { select } from "./select.js";
 import { confirm } from "./confirm.js";
+import { readCommonSettingsStore } from "../common-settings-store.js";
+import { readOperatorBinding } from "../wechat/operator-store.js";
 function defaultMenuCapabilities(provider) {
     if (provider === "codex") {
         return {
@@ -337,6 +339,12 @@ export function buildMenuItems(input) {
             hint: copy.retryHint,
             disabled: !capabilities.networkRetry,
         },
+        {
+            label: copy.wechatNotificationsHeading,
+            value: { type: "wechat-menu" },
+            color: "cyan",
+            disabled: !capabilities.wechatNotificationsMenu,
+        },
     ];
     const providerSettings = [
         { label: copy.providerSettingsHeading, value: { type: "cancel" }, kind: "heading" },
@@ -356,39 +364,6 @@ export function buildMenuItems(input) {
             hint: copy.syntheticInitiatorHint,
         });
     }
-    const wechatNotifications = [
-        { label: copy.wechatNotificationsHeading, value: { type: "cancel" }, kind: "heading" },
-        {
-            label: copy.wechatBind,
-            value: { type: "wechat-bind" },
-            color: "cyan",
-            disabled: !capabilities.wechatNotificationsMenu,
-        },
-        {
-            label: wechatNotificationsEnabled ? copy.wechatNotificationsOn : copy.wechatNotificationsOff,
-            value: { type: "toggle-wechat-notifications" },
-            color: "cyan",
-            disabled: !capabilities.wechatNotificationsMenu,
-        },
-        {
-            label: wechatQuestionNotifyEnabled ? copy.wechatQuestionNotifyOn : copy.wechatQuestionNotifyOff,
-            value: { type: "toggle-wechat-question-notify" },
-            color: "cyan",
-            disabled: !capabilities.wechatNotificationsMenu,
-        },
-        {
-            label: wechatPermissionNotifyEnabled ? copy.wechatPermissionNotifyOn : copy.wechatPermissionNotifyOff,
-            value: { type: "toggle-wechat-permission-notify" },
-            color: "cyan",
-            disabled: !capabilities.wechatNotificationsMenu,
-        },
-        {
-            label: wechatSessionErrorNotifyEnabled ? copy.wechatSessionErrorNotifyOn : copy.wechatSessionErrorNotifyOff,
-            value: { type: "toggle-wechat-session-error-notify" },
-            color: "cyan",
-            disabled: !capabilities.wechatNotificationsMenu,
-        },
-    ];
     return [
         ...providerActions,
         { label: "", value: { type: "cancel" }, separator: true },
@@ -396,8 +371,6 @@ export function buildMenuItems(input) {
         { label: "", value: { type: "cancel" }, separator: true },
         ...providerSettings,
         { label: "", value: { type: "cancel" }, separator: true },
-        ...wechatNotifications,
-        { label: "", value: { type: "cancel" }, separator: true },
         { label: copy.accountsHeading, value: { type: "cancel" }, kind: "heading" },
         ...input.accounts.map((account) => {
             const statusBadge = getStatusBadge(account.status);
@@ -427,9 +400,114 @@ export function buildMenuItems(input) {
         { label: copy.removeAll, value: { type: "remove-all" }, color: "red" },
     ];
 }
+function buildWechatSubmenuItems(copy, input) {
+    const backLabel = input.language === "en" ? "Back" : "返回上级";
+    const effectiveBinding = input.wechatPrimaryBinding
+        ? {
+            accountId: input.wechatPrimaryBinding.accountId,
+            userId: input.wechatPrimaryBinding.userId,
+            name: input.wechatPrimaryBinding.name,
+            enabled: input.wechatPrimaryBinding.enabled,
+            configured: input.wechatPrimaryBinding.configured,
+            boundAt: input.wechatPrimaryBinding.boundAt,
+        }
+        : input.wechatOperatorBinding
+            ? {
+                accountId: input.wechatOperatorBinding.wechatAccountId,
+                userId: input.wechatOperatorBinding.userId,
+                boundAt: input.wechatOperatorBinding.boundAt,
+            }
+            : undefined;
+    const bindActionType = effectiveBinding ? "wechat-rebind" : "wechat-bind";
+    const bindingRows = [];
+    if (effectiveBinding) {
+        const boundAtText = effectiveBinding.boundAt
+            ? new Date(effectiveBinding.boundAt).toLocaleString()
+            : "unknown";
+        bindingRows.push({ label: input.language === "en" ? "Current binding" : "当前绑定账号", value: { type: "cancel" }, kind: "heading" }, {
+            label: `accountId: ${effectiveBinding.accountId}`,
+            value: { type: "cancel" },
+            disabled: true,
+        }, ...(effectiveBinding.name
+            ? [{ label: `name: ${effectiveBinding.name}`, value: { type: "cancel" }, disabled: true }]
+            : []), ...(effectiveBinding.userId
+            ? [{ label: `userId: ${effectiveBinding.userId}`, value: { type: "cancel" }, disabled: true }]
+            : []), {
+            label: `enabled: ${effectiveBinding.enabled === true ? "true" : "false"}`,
+            value: { type: "cancel" },
+            disabled: true,
+        }, {
+            label: `configured: ${effectiveBinding.configured === true ? "true" : "false"}`,
+            value: { type: "cancel" },
+            disabled: true,
+        }, {
+            label: `boundAt: ${boundAtText}`,
+            value: { type: "cancel" },
+            disabled: true,
+        }, { label: "", value: { type: "cancel" }, separator: true });
+    }
+    return [
+        { label: backLabel, value: { type: "cancel" } },
+        { label: "", value: { type: "cancel" }, separator: true },
+        ...bindingRows,
+        { label: copy.wechatNotificationsHeading, value: { type: "cancel" }, kind: "heading" },
+        {
+            label: copy.wechatBind,
+            value: { type: bindActionType },
+            color: "cyan",
+            disabled: !input.capabilities.wechatNotificationsMenu,
+        },
+        {
+            label: input.wechatNotificationsEnabled ? copy.wechatNotificationsOn : copy.wechatNotificationsOff,
+            value: { type: "toggle-wechat-notifications" },
+            color: "cyan",
+            disabled: !input.capabilities.wechatNotificationsMenu,
+        },
+        {
+            label: input.wechatQuestionNotifyEnabled ? copy.wechatQuestionNotifyOn : copy.wechatQuestionNotifyOff,
+            value: { type: "toggle-wechat-question-notify" },
+            color: "cyan",
+            disabled: !input.capabilities.wechatNotificationsMenu,
+        },
+        {
+            label: input.wechatPermissionNotifyEnabled ? copy.wechatPermissionNotifyOn : copy.wechatPermissionNotifyOff,
+            value: { type: "toggle-wechat-permission-notify" },
+            color: "cyan",
+            disabled: !input.capabilities.wechatNotificationsMenu,
+        },
+        {
+            label: input.wechatSessionErrorNotifyEnabled ? copy.wechatSessionErrorNotifyOn : copy.wechatSessionErrorNotifyOff,
+            value: { type: "toggle-wechat-session-error-notify" },
+            color: "cyan",
+            disabled: !input.capabilities.wechatNotificationsMenu,
+        },
+    ];
+}
 export async function showMenu(accounts, input = {}) {
     return showMenuWithDeps(accounts, input);
 }
+function pickPrimaryBindingFromSettings(settings) {
+    const primary = settings?.wechat?.primaryBinding;
+    if (!primary?.accountId)
+        return undefined;
+    return {
+        accountId: primary.accountId,
+        userId: primary.userId,
+        name: primary.name,
+        enabled: primary.enabled,
+        configured: primary.configured,
+        boundAt: primary.boundAt,
+    };
+}
+function pickOperatorBinding(binding) {
+    if (!binding)
+        return undefined;
+    return {
+        wechatAccountId: binding.wechatAccountId,
+        userId: binding.userId,
+        boundAt: binding.boundAt,
+    };
+}
 export async function showMenuWithDeps(accounts, input = {}, deps = {}) {
     const selectMenu = deps.select ?? select;
     const confirmAction = deps.confirm ?? confirm;
@@ -464,6 +542,38 @@ export async function showMenuWithDeps(accounts, input = {}, deps = {}) {
         });
         if (!result)
             return { type: "cancel" };
+        if (result.type === "wechat-menu") {
+            const [commonSettings, operatorBinding] = await Promise.all([
+                input.wechatPrimaryBinding
+                    ? Promise.resolve(undefined)
+                    : (deps.readCommonSettings ?? readCommonSettingsStore)().catch(() => undefined),
+                input.wechatOperatorBinding
+                    ? Promise.resolve(undefined)
+                    : (deps.readOperatorBinding ?? readOperatorBinding)().catch(() => undefined),
+            ]);
+            const wechatItems = buildWechatSubmenuItems(copy, {
+                wechatNotificationsEnabled: input.wechatNotificationsEnabled !== false,
+                wechatQuestionNotifyEnabled: input.wechatQuestionNotifyEnabled !== false,
+                wechatPermissionNotifyEnabled: input.wechatPermissionNotifyEnabled !== false,
+                wechatSessionErrorNotifyEnabled: input.wechatSessionErrorNotifyEnabled !== false,
+                wechatPrimaryBinding: input.wechatPrimaryBinding ?? pickPrimaryBindingFromSettings(commonSettings),
+                wechatOperatorBinding: input.wechatOperatorBinding ?? pickOperatorBinding(operatorBinding),
+                capabilities: {
+                    ...defaultMenuCapabilities(provider),
+                    ...input.capabilities,
+                },
+                language: currentLanguage,
+            });
+            const wechatResult = await selectMenu(wechatItems, {
+                message: copy.wechatNotificationsHeading,
+                subtitle: copy.menuSubtitle,
+                clearScreen: true,
+            });
+            if (!wechatResult || wechatResult.type === "cancel") {
+                continue;
+            }
+            return wechatResult;
+        }
         if (result.type === "toggle-language") {
             currentLanguage = currentLanguage === "zh" ? "en" : "zh";
             continue;

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

@@ -0,0 +1,25 @@
+import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
+import { loadOpenClawWeixinPublicHelpers } from "./compat/openclaw-public-helpers.js";
+import type { CommonSettingsStore } from "../common-settings-store.js";
+type BindAction = "wechat-bind" | "wechat-rebind";
+type WechatBindFlowResult = {
+    accountId: string;
+    userId: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt: number;
+};
+type WechatBindFlowInput = {
+    action: BindAction;
+    loadPublicHelpers?: typeof loadOpenClawWeixinPublicHelpers;
+    bindOperator?: typeof bindOperator;
+    rebindOperator?: typeof rebindOperator;
+    readOperatorBinding?: typeof readOperatorBinding;
+    resetOperatorBinding?: typeof resetOperatorBinding;
+    readCommonSettings: () => Promise<CommonSettingsStore>;
+    writeCommonSettings: (settings: CommonSettingsStore) => Promise<void>;
+    now?: () => number;
+};
+export declare function runWechatBindFlow(input: WechatBindFlowInput): Promise<WechatBindFlowResult>;
+export {};

package/dist/wechat/bind-flow.js

@@ -0,0 +1,101 @@
+import { bindOperator, readOperatorBinding, rebindOperator, resetOperatorBinding } from "./operator-store.js";
+import { loadOpenClawWeixinPublicHelpers } from "./compat/openclaw-public-helpers.js";
+import { buildOpenClawMenuAccount } from "./openclaw-account-adapter.js";
+function pickFirstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return error.message;
+    }
+    return String(error);
+}
+export async function runWechatBindFlow(input) {
+    const now = input.now ?? Date.now;
+    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
+    const persistOperatorBinding = input.bindOperator ?? bindOperator;
+    const persistOperatorRebinding = input.rebindOperator ?? rebindOperator;
+    const loadOperatorBinding = input.readOperatorBinding ?? readOperatorBinding;
+    const clearOperatorBinding = input.resetOperatorBinding ?? resetOperatorBinding;
+    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 userId = pickFirstNonEmptyString(waited?.userId, waited?.openid, waited?.uid);
+        if (!accountId) {
+            throw new Error("missing accountId after qr login");
+        }
+        if (!userId) {
+            throw new Error("missing userId after qr login");
+        }
+        const boundAt = now();
+        const operatorBinding = {
+            wechatAccountId: accountId,
+            userId,
+            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,
+            },
+        };
+        try {
+            await input.writeCommonSettings(settings);
+        }
+        catch (error) {
+            if (input.action === "wechat-rebind" && previousOperatorBinding) {
+                await persistOperatorRebinding(previousOperatorBinding).catch(() => { });
+            }
+            else {
+                await clearOperatorBinding().catch(() => { });
+            }
+            throw error;
+        }
+        return {
+            accountId,
+            userId,
+            name: menuAccount?.name,
+            enabled: menuAccount?.enabled,
+            configured: menuAccount?.configured,
+            boundAt,
+        };
+    }
+    catch (error) {
+        if (input.action === "wechat-rebind") {
+            throw new Error(`wechat rebind failed: ${toErrorMessage(error)}`);
+        }
+        throw new Error(`wechat bind failed: ${toErrorMessage(error)}`);
+    }
+}

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

@@ -8,6 +8,13 @@ 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;
@@ -16,6 +23,7 @@ export type OpenClawWeixinPublicEntry = {
     entryAbsolutePath: string;
 };
 declare function resolveOpenClawWeixinPublicEntry(): Promise<OpenClawWeixinPublicEntry>;
+declare function loadPublicWeixinAccountHelpers(): Promise<WeixinAccountHelpers>;
 declare function loadLatestWeixinAccountState(): Promise<{
     accountId: string;
     token: string;
@@ -54,6 +62,7 @@ export type OpenClawWeixinPublicHelpers = {
     entry: OpenClawWeixinPublicEntry;
     pluginId: string;
     qrGateway: WeixinQrGateway;
+    accountHelpers: WeixinAccountHelpers;
     latestAccountState: {
         accountId: string;
         token: string;
@@ -79,6 +88,7 @@ type OpenClawWeixinPublicHelpersLoaders = {
         pluginId?: string;
     }>;
     loadLatestWeixinAccountState?: typeof loadLatestWeixinAccountState;
+    loadPublicWeixinAccountHelpers?: typeof loadPublicWeixinAccountHelpers;
     loadPublicWeixinHelpers?: typeof loadPublicWeixinHelpers;
     loadPublicWeixinSendHelper?: typeof loadPublicWeixinSendHelper;
 };

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

@@ -31,6 +31,15 @@ function hasQrLoginMethods(value) {
     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";
@@ -94,6 +103,45 @@ async function loadPublicWeixinQrGateway() {
     }
     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);
@@ -182,6 +230,7 @@ async function loadPublicWeixinSyncBufHelpers() {
 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)();
@@ -192,6 +241,11 @@ export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
     if (typeof publicHelpers?.getUpdates !== "function") {
         throw missingHelperError("getUpdates");
     }
+    if (typeof accountHelpers?.listAccountIds !== "function" ||
+        typeof accountHelpers?.resolveAccount !== "function" ||
+        typeof accountHelpers?.describeAccount !== "function") {
+        throw missingHelperError("accountHelpers");
+    }
     if (typeof sendHelper?.sendMessageWeixin !== "function") {
         throw missingHelperError("sendMessageWeixin");
     }
@@ -199,6 +253,7 @@ export async function loadOpenClawWeixinPublicHelpers(loaders = {}) {
         entry,
         pluginId: typeof qrGatewayResult.pluginId === "string" && qrGatewayResult.pluginId.length > 0 ? qrGatewayResult.pluginId : "unknown",
         qrGateway: qrGatewayResult.gateway,
+        accountHelpers,
         latestAccountState,
         getUpdates: publicHelpers.getUpdates,
         sendMessageWeixin: sendHelper.sendMessageWeixin,

package/dist/wechat/openclaw-account-adapter.d.ts

@@ -0,0 +1,30 @@
+export type OpenClawWeixinAccountHelpers = {
+    listAccountIds: () => Promise<string[]>;
+    resolveAccount: (accountId: string) => Promise<unknown>;
+    describeAccount: (accountIdOrInput: string | {
+        accountId: string;
+    }) => Promise<unknown>;
+};
+export type OpenClawLatestAccountState = {
+    accountId: string;
+    token: string;
+    baseUrl: string;
+    getUpdatesBuf?: string;
+    userId?: string;
+    savedAt?: number;
+    boundAt?: number;
+};
+export type OpenClawMenuAccount = {
+    accountId: string;
+    name?: string;
+    enabled: boolean;
+    configured: boolean;
+    userId?: string;
+    boundAt?: number;
+};
+type BuildOpenClawMenuAccountInput = {
+    latestAccountState: OpenClawLatestAccountState | null;
+    accountHelpers: OpenClawWeixinAccountHelpers;
+};
+export declare function buildOpenClawMenuAccount(input: BuildOpenClawMenuAccountInput): Promise<OpenClawMenuAccount | null>;
+export {};

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

@@ -0,0 +1,70 @@
+function asObject(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function firstNonEmptyString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+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) {
+    try {
+        const byString = await accountHelpers.describeAccount(accountId);
+        if (byString !== undefined) {
+            return byString;
+        }
+    }
+    catch {
+        // fallback to object input
+    }
+    try {
+        return await accountHelpers.describeAccount({ accountId });
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function buildOpenClawMenuAccount(input) {
+    const fallbackAccountId = firstNonEmptyString(input.latestAccountState?.accountId);
+    const accountIds = await input.accountHelpers.listAccountIds();
+    const accountId = firstNonEmptyString(fallbackAccountId, accountIds.at(-1));
+    if (!accountId) {
+        return null;
+    }
+    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);
+    return {
+        accountId,
+        name: firstNonEmptyString(resolvedRaw.name, resolvedRaw.displayName, describedRaw.name, describedRaw.displayName),
+        enabled,
+        configured,
+        userId,
+        boundAt,
+    };
+}

package/dist/wechat/operator-store.d.ts

@@ -5,4 +5,5 @@ export type OperatorBinding = {
 };
 export declare function readOperatorBinding(): Promise<OperatorBinding | undefined>;
 export declare function bindOperator(input: OperatorBinding): Promise<OperatorBinding>;
+export declare function rebindOperator(input: OperatorBinding): Promise<OperatorBinding>;
 export declare function resetOperatorBinding(): Promise<void>;

package/dist/wechat/operator-store.js

@@ -47,6 +47,16 @@ export async function bindOperator(input) {
     await writeFile(operatorStatePath(), JSON.stringify(next, null, 2), { mode: WECHAT_FILE_MODE });
     return next;
 }
+export async function rebindOperator(input) {
+    const next = toBinding(input);
+    if (!isValidBinding(next)) {
+        throw new Error("invalid operator binding format");
+    }
+    await ensureWechatStateLayout();
+    await mkdir(path.dirname(operatorStatePath()), { recursive: true });
+    await writeFile(operatorStatePath(), JSON.stringify(next, null, 2), { mode: WECHAT_FILE_MODE });
+    return next;
+}
 export async function resetOperatorBinding() {
     try {
         await unlink(operatorStatePath());

package/package.json

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