opencode-copilot-account-switcher 0.13.6 → 0.14.1

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 {
@@ -15,6 +17,7 @@ function defaultMenuCapabilities(provider) {
             experimentalSlashCommands: true,
             networkRetry: true,
             syntheticAgentInitiator: false,
+            wechatNotificationsMenu: true,
         };
     }
     return {
@@ -29,6 +32,7 @@ function defaultMenuCapabilities(provider) {
         experimentalSlashCommands: true,
         networkRetry: true,
         syntheticAgentInitiator: true,
+        wechatNotificationsMenu: true,
     };
 }
 export function getMenuCopy(language = "zh", provider = "copilot") {
@@ -67,6 +71,16 @@ export function getMenuCopy(language = "zh", provider = "copilot") {
                 syntheticInitiatorOn: "Send synthetic messages as agent: On",
                 syntheticInitiatorOff: "Send synthetic messages as agent: Off",
                 syntheticInitiatorHint: "Changes upstream behavior; misuse may increase billing risk or trigger abuse signals",
+                wechatNotificationsHeading: "WeChat notifications",
+                wechatBind: "Bind / Rebind WeChat",
+                wechatNotificationsOn: "WeChat notifications: On",
+                wechatNotificationsOff: "WeChat notifications: Off",
+                wechatQuestionNotifyOn: "Question notifications: On",
+                wechatQuestionNotifyOff: "Question notifications: Off",
+                wechatPermissionNotifyOn: "Permission notifications: On",
+                wechatPermissionNotifyOff: "Permission notifications: Off",
+                wechatSessionErrorNotifyOn: "Session error notifications: On",
+                wechatSessionErrorNotifyOff: "Session error notifications: Off",
                 accountsHeading: "Accounts",
                 dangerHeading: "Danger zone",
                 removeAll: "Remove all accounts",
@@ -105,6 +119,16 @@ export function getMenuCopy(language = "zh", provider = "copilot") {
             syntheticInitiatorOn: "synthetic 消息按 agent 身份发送：已开启",
             syntheticInitiatorOff: "synthetic 消息按 agent 身份发送：已关闭",
             syntheticInitiatorHint: "会改变与 upstream 的默认行为；误用可能带来异常计费或 abuse 风险",
+            wechatNotificationsHeading: "微信通知",
+            wechatBind: "绑定 / 重绑微信",
+            wechatNotificationsOn: "微信通知总开关：已开启",
+            wechatNotificationsOff: "微信通知总开关：已关闭",
+            wechatQuestionNotifyOn: "问题通知：已开启",
+            wechatQuestionNotifyOff: "问题通知：已关闭",
+            wechatPermissionNotifyOn: "权限通知：已开启",
+            wechatPermissionNotifyOff: "权限通知：已关闭",
+            wechatSessionErrorNotifyOn: "会话错误通知：已开启",
+            wechatSessionErrorNotifyOff: "会话错误通知：已关闭",
             accountsHeading: "账号",
             dangerHeading: "危险操作",
             removeAll: "删除全部账号",
@@ -144,6 +168,16 @@ export function getMenuCopy(language = "zh", provider = "copilot") {
             syntheticInitiatorOn: "Send synthetic messages as agent: On",
             syntheticInitiatorOff: "Send synthetic messages as agent: Off",
             syntheticInitiatorHint: "Changes upstream behavior; misuse may increase billing risk or trigger abuse signals",
+            wechatNotificationsHeading: "WeChat notifications",
+            wechatBind: "Bind / Rebind WeChat",
+            wechatNotificationsOn: "WeChat notifications: On",
+            wechatNotificationsOff: "WeChat notifications: Off",
+            wechatQuestionNotifyOn: "Question notifications: On",
+            wechatQuestionNotifyOff: "Question notifications: Off",
+            wechatPermissionNotifyOn: "Permission notifications: On",
+            wechatPermissionNotifyOff: "Permission notifications: Off",
+            wechatSessionErrorNotifyOn: "Session error notifications: On",
+            wechatSessionErrorNotifyOff: "Session error notifications: Off",
             accountsHeading: "Accounts",
             dangerHeading: "Danger zone",
             removeAll: "Remove all accounts",
@@ -182,6 +216,16 @@ export function getMenuCopy(language = "zh", provider = "copilot") {
         syntheticInitiatorOn: "synthetic 消息按 agent 身份发送：已开启",
         syntheticInitiatorOff: "synthetic 消息按 agent 身份发送：已关闭",
         syntheticInitiatorHint: "会改变与 upstream 的默认行为；误用可能带来异常计费或 abuse 风险",
+        wechatNotificationsHeading: "微信通知",
+        wechatBind: "绑定 / 重绑微信",
+        wechatNotificationsOn: "微信通知总开关：已开启",
+        wechatNotificationsOff: "微信通知总开关：已关闭",
+        wechatQuestionNotifyOn: "问题通知：已开启",
+        wechatQuestionNotifyOff: "问题通知：已关闭",
+        wechatPermissionNotifyOn: "权限通知：已开启",
+        wechatPermissionNotifyOff: "权限通知：已关闭",
+        wechatSessionErrorNotifyOn: "会话错误通知：已开启",
+        wechatSessionErrorNotifyOff: "会话错误通知：已关闭",
         accountsHeading: "账号",
         dangerHeading: "危险操作",
         removeAll: "删除全部账号",
@@ -228,6 +272,10 @@ export function buildMenuItems(input) {
     const quotaHint = input.lastQuotaRefresh ? `last ${formatRelativeTime(input.lastQuotaRefresh)}` : undefined;
     const loopSafetyProviderScope = input.loopSafetyProviderScope ?? "copilot-only";
     const experimentalSlashCommandsEnabled = input.experimentalSlashCommandsEnabled !== false;
+    const wechatNotificationsEnabled = input.wechatNotificationsEnabled !== false;
+    const wechatQuestionNotifyEnabled = input.wechatQuestionNotifyEnabled !== false;
+    const wechatPermissionNotifyEnabled = input.wechatPermissionNotifyEnabled !== false;
+    const wechatSessionErrorNotifyEnabled = input.wechatSessionErrorNotifyEnabled !== false;
     const providerActions = [
         { label: copy.actionsHeading, value: { type: "cancel" }, kind: "heading" },
         { label: copy.switchLanguageLabel, value: { type: "toggle-language" }, color: "cyan" },
@@ -291,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" },
@@ -346,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;
@@ -367,6 +526,10 @@ export async function showMenuWithDeps(accounts, input = {}, deps = {}) {
             loopSafetyEnabled: input.loopSafetyEnabled === true,
             loopSafetyProviderScope: input.loopSafetyProviderScope,
             networkRetryEnabled: input.networkRetryEnabled === true,
+            wechatNotificationsEnabled: input.wechatNotificationsEnabled,
+            wechatQuestionNotifyEnabled: input.wechatQuestionNotifyEnabled,
+            wechatPermissionNotifyEnabled: input.wechatPermissionNotifyEnabled,
+            wechatSessionErrorNotifyEnabled: input.wechatSessionErrorNotifyEnabled,
             syntheticAgentInitiatorEnabled: input.syntheticAgentInitiatorEnabled === true,
             experimentalSlashCommandsEnabled: input.experimentalSlashCommandsEnabled,
             capabilities: input.capabilities,
@@ -379,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/bridge.d.ts

@@ -0,0 +1,69 @@
+import type { Message, Part, PermissionRequest, QuestionRequest, Session, SessionStatus, Todo } from "@opencode-ai/sdk/v2";
+import { connect } from "./broker-client.js";
+import { connectOrSpawnBroker } from "./broker-launcher.js";
+import { type SessionDigest } from "./session-digest.js";
+type SessionMessages = Array<{
+    info: Message;
+    parts: Part[];
+}>;
+type SessionLite = Pick<Session, "id" | "title" | "directory" | "time">;
+type WechatBridgeClient = {
+    session: {
+        list: () => Promise<SessionLite[]>;
+        status: () => Promise<Record<string, SessionStatus | undefined>>;
+        todo: (sessionID: string) => Promise<Todo[]>;
+        messages: (sessionID: string) => Promise<SessionMessages>;
+    };
+    question: {
+        list: () => Promise<QuestionRequest[]>;
+    };
+    permission: {
+        list: () => Promise<PermissionRequest[]>;
+    };
+};
+export type InstanceUnavailableKind = "sessionStatus" | "questionList" | "permissionList";
+export type WechatInstanceStatusSnapshot = {
+    instanceID: string;
+    instanceName: string;
+    pid: number;
+    projectName?: string;
+    directory: string;
+    collectedAt: number;
+    sessions: SessionDigest[];
+    unavailable?: InstanceUnavailableKind[];
+};
+export type WechatBridgeInput = {
+    instanceID: string;
+    instanceName: string;
+    pid: number;
+    projectName?: string;
+    directory: string;
+    client: WechatBridgeClient;
+    liveReadTimeoutMs?: number;
+};
+export type WechatBridge = {
+    collectStatusSnapshot: () => Promise<WechatInstanceStatusSnapshot>;
+};
+export type WechatBridgeLifecycleInput = {
+    client: WechatBridgeClient;
+    project?: {
+        id?: string;
+        name?: string;
+    };
+    directory?: string;
+    serverUrl?: URL;
+    statusCollectionEnabled?: boolean;
+    heartbeatIntervalMs?: number;
+};
+export type WechatBridgeLifecycle = {
+    close: () => Promise<void>;
+};
+type WechatBridgeLifecycleDeps = {
+    connectOrSpawnBrokerImpl?: typeof connectOrSpawnBroker;
+    connectImpl?: typeof connect;
+    setIntervalImpl?: typeof setInterval;
+    clearIntervalImpl?: typeof clearInterval;
+};
+export declare function createWechatBridge(input: WechatBridgeInput): WechatBridge;
+export declare function createWechatBridgeLifecycle(input: WechatBridgeLifecycleInput, deps?: WechatBridgeLifecycleDeps): Promise<WechatBridgeLifecycle>;
+export {};

package/dist/wechat/bridge.js

@@ -0,0 +1,180 @@
+import { connect } from "./broker-client.js";
+import { connectOrSpawnBroker } from "./broker-launcher.js";
+import { buildSessionDigest, groupPermissionsBySession, groupQuestionsBySession, pickRecentSessions, } from "./session-digest.js";
+const DEFAULT_LIVE_READ_TIMEOUT_MS = 2_000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 10_000;
+function toSafeInstanceID(input) {
+    const normalized = input.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (normalized.length === 0) {
+        return `wechat-${process.pid}`;
+    }
+    return normalized.slice(0, 64);
+}
+function toProjectName(project) {
+    if (typeof project?.name === "string" && project.name.trim().length > 0) {
+        return project.name.trim();
+    }
+    if (typeof project?.id === "string" && project.id.trim().length > 0) {
+        return project.id.trim();
+    }
+    return undefined;
+}
+function toDirectory(inputDirectory) {
+    if (typeof inputDirectory === "string" && inputDirectory.trim().length > 0) {
+        return inputDirectory;
+    }
+    return process.cwd();
+}
+function toInstanceName(projectName, directory) {
+    if (projectName) {
+        return projectName;
+    }
+    const parts = directory.split(/[\\/]+/).filter((part) => part.length > 0);
+    return parts.at(-1) ?? `wechat-${process.pid}`;
+}
+function toInstanceID(projectName, directory) {
+    const seed = projectName ?? directory;
+    return toSafeInstanceID(seed);
+}
+function withTimeout(task, timeoutMs, name) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error(`${name} timed out in ${timeoutMs}ms`));
+        }, timeoutMs);
+        void Promise.resolve()
+            .then(task)
+            .then((value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+export function createWechatBridge(input) {
+    const collectStatusSnapshot = async () => {
+        const liveReadTimeoutMs = typeof input.liveReadTimeoutMs === "number" && Number.isFinite(input.liveReadTimeoutMs)
+            ? Math.max(1, Math.floor(input.liveReadTimeoutMs))
+            : DEFAULT_LIVE_READ_TIMEOUT_MS;
+        const unavailable = new Set();
+        const [sessionListResult, statusResult, questionResult, permissionResult] = await Promise.allSettled([
+            withTimeout(() => input.client.session.list(), liveReadTimeoutMs, "session.list"),
+            withTimeout(() => input.client.session.status(), liveReadTimeoutMs, "session.status"),
+            withTimeout(() => input.client.question.list(), liveReadTimeoutMs, "question.list"),
+            withTimeout(() => input.client.permission.list(), liveReadTimeoutMs, "permission.list"),
+        ]);
+        const sessions = sessionListResult.status === "fulfilled" ? sessionListResult.value : [];
+        const recentSessions = pickRecentSessions(sessions, 3);
+        if (sessionListResult.status === "rejected") {
+            unavailable.add("sessionStatus");
+        }
+        const statusBySession = statusResult.status === "fulfilled"
+            ? statusResult.value
+            : (unavailable.add("sessionStatus"), {});
+        const questionsBySession = questionResult.status === "fulfilled"
+            ? groupQuestionsBySession(questionResult.value)
+            : (unavailable.add("questionList"), groupQuestionsBySession([]));
+        const permissionsBySession = permissionResult.status === "fulfilled"
+            ? groupPermissionsBySession(permissionResult.value)
+            : (unavailable.add("permissionList"), groupPermissionsBySession([]));
+        const sessionDigests = await Promise.all(recentSessions.map(async (session) => {
+            const [todoResult, messagesResult] = await Promise.allSettled([
+                withTimeout(() => input.client.session.todo(session.id), liveReadTimeoutMs, `session.todo:${session.id}`),
+                withTimeout(() => input.client.session.messages(session.id), liveReadTimeoutMs, `session.messages:${session.id}`),
+            ]);
+            const sessionUnavailable = [];
+            const todos = todoResult.status === "fulfilled" ? todoResult.value : (sessionUnavailable.push("todo"), []);
+            const messages = messagesResult.status === "fulfilled"
+                ? messagesResult.value
+                : (sessionUnavailable.push("messages"), []);
+            return buildSessionDigest({
+                session,
+                statusBySession,
+                questionsBySession,
+                permissionsBySession,
+                todos,
+                messages,
+                unavailable: sessionUnavailable,
+            });
+        }));
+        return {
+            instanceID: input.instanceID,
+            instanceName: input.instanceName,
+            pid: input.pid,
+            projectName: input.projectName,
+            directory: input.directory,
+            collectedAt: Date.now(),
+            sessions: sessionDigests,
+            unavailable: unavailable.size > 0 ? [...unavailable] : undefined,
+        };
+    };
+    return {
+        collectStatusSnapshot,
+    };
+}
+export async function createWechatBridgeLifecycle(input, deps = {}) {
+    if (input.statusCollectionEnabled !== true) {
+        return {
+            close: async () => { },
+        };
+    }
+    const connectOrSpawnBrokerImpl = deps.connectOrSpawnBrokerImpl ?? connectOrSpawnBroker;
+    const connectImpl = deps.connectImpl ?? connect;
+    const setIntervalImpl = deps.setIntervalImpl ?? setInterval;
+    const clearIntervalImpl = deps.clearIntervalImpl ?? clearInterval;
+    const directory = toDirectory(input.directory);
+    const projectName = toProjectName(input.project);
+    const instanceID = toInstanceID(projectName, directory);
+    const bridge = createWechatBridge({
+        instanceID,
+        instanceName: toInstanceName(projectName, directory),
+        pid: process.pid,
+        projectName,
+        directory,
+        client: input.client,
+    });
+    const broker = await connectOrSpawnBrokerImpl();
+    const brokerClient = await connectImpl(broker.endpoint, { bridge });
+    try {
+        await brokerClient.registerInstance({
+            instanceID,
+            pid: process.pid,
+        });
+    }
+    catch (error) {
+        await brokerClient.close().catch(() => { });
+        throw error;
+    }
+    const heartbeatIntervalMs = typeof input.heartbeatIntervalMs === "number" && Number.isFinite(input.heartbeatIntervalMs)
+        ? Math.max(1_000, Math.floor(input.heartbeatIntervalMs))
+        : DEFAULT_HEARTBEAT_INTERVAL_MS;
+    const timer = setIntervalImpl(() => {
+        void brokerClient.heartbeat().catch(() => { });
+    }, heartbeatIntervalMs);
+    let closed = false;
+    return {
+        close: async () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            clearIntervalImpl(timer);
+            await brokerClient.close().catch(() => { });
+        },
+    };
+}