opencode-copilot-account-switcher 0.14.29 → 0.14.30

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

@@ -30,6 +30,15 @@ export type WechatMenuSettings = {
         accounts?: WechatBinding[];
     };
 };
+export type WechatNotificationDispatchSettings = {
+    targetUserId?: string;
+    notifications: {
+        enabled: boolean;
+        question: boolean;
+        permission: boolean;
+        sessionError: boolean;
+    };
+};
 export declare function parseCommonSettingsStore(raw: string): CommonSettingsStore;
 export declare function commonSettingsPath(): string;
 export declare function readCommonSettingsStore(options?: {
@@ -43,3 +52,7 @@ export declare function readCommonSettingsStoreSync(options?: {
 export declare function writeCommonSettingsStore(store: CommonSettingsStore, options?: {
     filePath?: string;
 }): Promise<void>;
+export declare function readWechatNotificationDispatchSettings(options?: {
+    filePath?: string;
+    legacyCopilotFilePath?: string;
+}): Promise<WechatNotificationDispatchSettings>;

package/dist/common-settings-store.js

@@ -201,3 +201,17 @@ export async function writeCommonSettingsStore(store, options) {
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });
 }
+export async function readWechatNotificationDispatchSettings(options) {
+    const settings = await readCommonSettingsStore(options);
+    return {
+        ...(typeof settings.wechat?.primaryBinding?.userId === "string"
+            ? { targetUserId: settings.wechat.primaryBinding.userId }
+            : {}),
+        notifications: settings.wechat?.notifications ?? {
+            enabled: true,
+            question: true,
+            permission: true,
+            sessionError: true,
+        },
+    };
+}

package/dist/wechat/bridge.d.ts

@@ -2,6 +2,7 @@ import type { Message, Part, PermissionRequest, QuestionRequest, Session, Sessio
 import { connect } from "./broker-client.js";
 import { connectOrSpawnBroker } from "./broker-launcher.js";
 import { type SessionDigest } from "./session-digest.js";
+import type { WechatNotificationCandidate } from "./protocol.js";
 type SessionMessages = Array<{
     info: Message;
     parts: Part[];
@@ -57,6 +58,7 @@ export type WechatBridgeInput = {
 };
 export type WechatBridge = {
     collectStatusSnapshot: () => Promise<WechatInstanceStatusSnapshot>;
+    collectNotificationCandidates: () => Promise<WechatNotificationCandidate[]>;
 };
 export type WechatBridgeLifecycleInput = {
     client: WechatBridgeClient;

package/dist/wechat/bridge.js

@@ -5,6 +5,8 @@ import { connect } from "./broker-client.js";
 import { connectOrSpawnBroker } from "./broker-launcher.js";
 import { WECHAT_FILE_MODE, wechatBridgeDiagnosticsPath } from "./state-paths.js";
 import { buildSessionDigest, groupPermissionsBySession, groupQuestionsBySession, pickRecentSessions, } from "./session-digest.js";
+import { readOperatorBinding } from "./operator-store.js";
+import { createHandle, createRouteKey } from "./handle.js";
 const DEFAULT_LIVE_READ_TIMEOUT_MS = 2_000;
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 10_000;
 const PROCESS_INSTANCE_ID = toSafeInstanceID(`wechat-${process.pid}-${randomUUID().slice(0, 8)}`);
@@ -147,11 +149,45 @@ function unwrapSdkReadResult(value, name) {
     return value.data;
 }
 export function createWechatBridge(input) {
-    const collectStatusSnapshot = async () => {
-        const startedAt = Date.now();
+    const retryEventSequenceBySessionID = new Map();
+    const retrySignatureBySessionID = new Map();
+    const isRetryBySessionID = new Map();
+    function toIdempotencyPart(value) {
+        const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        return normalized.length > 0 ? normalized : "na";
+    }
+    function stableStringify(value) {
+        if (value === null || typeof value !== "object") {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+        }
+        const record = value;
+        const keys = Object.keys(record).sort();
+        return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+    }
+    const collectLiveRead = async () => {
         const liveReadTimeoutMs = typeof input.liveReadTimeoutMs === "number" && Number.isFinite(input.liveReadTimeoutMs)
             ? Math.max(1, Math.floor(input.liveReadTimeoutMs))
             : DEFAULT_LIVE_READ_TIMEOUT_MS;
+        const onDiagnosticEvent = input.onDiagnosticEvent;
+        const [sessionListResult, statusResult, questionResult, permissionResult] = await Promise.allSettled([
+            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "session.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.session.list(), "session.list"), liveReadTimeoutMs, "session.list")),
+            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "session.status", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.session.status(), "session.status"), liveReadTimeoutMs, "session.status")),
+            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "question.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.question.list(), "question.list"), liveReadTimeoutMs, "question.list")),
+            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "permission.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.permission.list(), "permission.list"), liveReadTimeoutMs, "permission.list")),
+        ]);
+        return {
+            liveReadTimeoutMs,
+            sessionListResult,
+            statusResult,
+            questionResult,
+            permissionResult,
+        };
+    };
+    const collectStatusSnapshot = async () => {
+        const startedAt = Date.now();
         const unavailable = new Set();
         const onDiagnosticEvent = input.onDiagnosticEvent;
         const activeSessionID = input.getActiveSessionID?.();
@@ -175,12 +211,7 @@ export function createWechatBridge(input) {
             })).catch(() => { });
             return snapshot;
         }
-        const [sessionListResult, statusResult, questionResult, permissionResult] = await Promise.allSettled([
-            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "session.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.session.list(), "session.list"), liveReadTimeoutMs, "session.list")),
-            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "session.status", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.session.status(), "session.status"), liveReadTimeoutMs, "session.status")),
-            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "question.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.question.list(), "question.list"), liveReadTimeoutMs, "question.list")),
-            wrapDiagnosticStage({ instanceID: input.instanceID, stage: "permission.list", onDiagnosticEvent }, () => withTimeout(async () => unwrapSdkReadResult(await input.client.permission.list(), "permission.list"), liveReadTimeoutMs, "permission.list")),
-        ]);
+        const { liveReadTimeoutMs, sessionListResult, statusResult, questionResult, permissionResult, } = await collectLiveRead();
         const sessions = sessionListResult.status === "fulfilled" ? sessionListResult.value : [];
         const recentSessions = isNonEmptyString(activeSessionID)
             ? sessions.filter((session) => session.id === activeSessionID).slice(0, 1)
@@ -236,8 +267,91 @@ export function createWechatBridge(input) {
         })).catch(() => { });
         return snapshot;
     };
+    const collectNotificationCandidates = async () => {
+        const binding = await readOperatorBinding().catch(() => undefined);
+        if (!binding) {
+            return [];
+        }
+        const { questionResult, permissionResult, statusResult } = await collectLiveRead();
+        const candidates = [];
+        const existingHandles = new Set();
+        if (questionResult.status === "fulfilled") {
+            for (const question of questionResult.value) {
+                const routeKey = createRouteKey({
+                    kind: "question",
+                    requestID: question.id,
+                    scopeKey: input.instanceID,
+                });
+                const handle = createHandle("question", existingHandles);
+                existingHandles.add(handle);
+                candidates.push({
+                    idempotencyKey: `question-${toIdempotencyPart(input.instanceID)}-${toIdempotencyPart(question.id)}`,
+                    kind: "question",
+                    requestID: question.id,
+                    createdAt: Date.now(),
+                    routeKey,
+                    handle,
+                });
+            }
+        }
+        if (permissionResult.status === "fulfilled") {
+            for (const permission of permissionResult.value) {
+                const routeKey = createRouteKey({
+                    kind: "permission",
+                    requestID: permission.id,
+                    scopeKey: input.instanceID,
+                });
+                const handle = createHandle("permission", existingHandles);
+                existingHandles.add(handle);
+                candidates.push({
+                    idempotencyKey: `permission-${toIdempotencyPart(input.instanceID)}-${toIdempotencyPart(permission.id)}`,
+                    kind: "permission",
+                    requestID: permission.id,
+                    createdAt: Date.now(),
+                    routeKey,
+                    handle,
+                });
+            }
+        }
+        if (statusResult.status === "fulfilled") {
+            const seenSessionIDs = new Set();
+            for (const [sessionID, status] of Object.entries(statusResult.value)) {
+                seenSessionIDs.add(sessionID);
+                if (status?.type === "retry") {
+                    const signature = stableStringify(status);
+                    const previousWasRetry = isRetryBySessionID.get(sessionID) === true;
+                    const previousSignature = retrySignatureBySessionID.get(sessionID);
+                    if (!previousWasRetry || previousSignature !== signature) {
+                        const nextSequence = (retryEventSequenceBySessionID.get(sessionID) ?? 0) + 1;
+                        retryEventSequenceBySessionID.set(sessionID, nextSequence);
+                    }
+                    isRetryBySessionID.set(sessionID, true);
+                    retrySignatureBySessionID.set(sessionID, signature);
+                    const eventSequence = retryEventSequenceBySessionID.get(sessionID) ?? 1;
+                    candidates.push({
+                        idempotencyKey: `session-error-${toIdempotencyPart(input.instanceID)}-${toIdempotencyPart(sessionID)}-${eventSequence}`,
+                        kind: "sessionError",
+                        createdAt: Date.now(),
+                    });
+                }
+                else {
+                    isRetryBySessionID.set(sessionID, false);
+                    retrySignatureBySessionID.delete(sessionID);
+                }
+            }
+            for (const knownSessionID of isRetryBySessionID.keys()) {
+                if (seenSessionIDs.has(knownSessionID)) {
+                    continue;
+                }
+                isRetryBySessionID.set(knownSessionID, false);
+                retrySignatureBySessionID.delete(knownSessionID);
+            }
+        }
+        return candidates;
+    };
     return {
         collectStatusSnapshot,
+        collectNotificationCandidates,
     };
 }
 export async function createWechatBridgeLifecycle(input, deps = {}) {

package/dist/wechat/broker-client.js

@@ -127,6 +127,21 @@ export async function connect(endpoint, options = {}) {
         };
         socket.write(serializeEnvelope(envelope));
     }
+    function sendSyncWechatNotifications(candidates) {
+        if (!session || candidates.length === 0) {
+            return;
+        }
+        const envelope = {
+            id: nextRequestId("syncWechatNotifications"),
+            type: "syncWechatNotifications",
+            instanceID: session.instanceID,
+            sessionToken: session.sessionToken,
+            payload: {
+                candidates,
+            },
+        };
+        socket.write(serializeEnvelope(envelope));
+    }
     function handleCollectStatus(envelope) {
         const payload = envelope.payload;
         if (!isNonEmptyString(payload.requestId)) {
@@ -203,6 +218,15 @@ export async function connect(endpoint, options = {}) {
                 registeredAt: payload.registeredAt,
                 brokerPid: payload.brokerPid,
             };
+            if (options.bridge?.collectNotificationCandidates) {
+                try {
+                    const candidates = await options.bridge.collectNotificationCandidates();
+                    sendSyncWechatNotifications(candidates);
+                }
+                catch {
+                    // swallow candidate collection errors to keep register path available
+                }
+            }
             return {
                 sessionToken: session.sessionToken,
                 registeredAt: session.registeredAt,
@@ -213,13 +237,21 @@ export async function connect(endpoint, options = {}) {
             if (!session) {
                 throw new Error("missing broker session");
             }
-            return send({
+            const response = await send({
                 id: nextRequestId("heartbeat"),
                 type: "heartbeat",
                 instanceID: session.instanceID,
                 sessionToken: session.sessionToken,
                 payload: {},
             });
+            if (options.bridge?.collectNotificationCandidates) {
+                void Promise.resolve(options.bridge.collectNotificationCandidates())
+                    .then((candidates) => {
+                    sendSyncWechatNotifications(candidates);
+                })
+                    .catch(() => { });
+            }
+            return response;
         },
         getSessionSnapshot() {
             if (!session) {

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

@@ -1,5 +1,6 @@
 import { type QuestionAnswer } from "@opencode-ai/sdk/v2";
 import { type WechatStatusRuntime, type WechatStatusRuntimeDiagnosticEvent } from "./wechat-status-runtime.js";
+import { type WechatNotificationSendInput } from "./notification-dispatcher.js";
 import type { WechatSlashCommand } from "./command-parser.js";
 type BrokerWechatStatusRuntimeLifecycle = {
     start: () => Promise<void>;
@@ -11,7 +12,15 @@ type BrokerWechatStatusRuntimeLifecycleDeps = {
             command: import("./command-parser.js").WechatSlashCommand;
         }) => Promise<string>;
         onDiagnosticEvent: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
+        drainOutboundMessages: (input?: {
+            sendMessage: (input: WechatNotificationSendInput) => Promise<void>;
+        }) => Promise<void>;
     }) => WechatStatusRuntime;
+    createNotificationDispatcher?: (input: {
+        sendMessage: (input: WechatNotificationSendInput) => Promise<void>;
+    }) => {
+        drainOutboundMessages: () => Promise<void>;
+    };
     handleWechatSlashCommand?: (command: import("./command-parser.js").WechatSlashCommand) => Promise<string>;
     onRuntimeError?: (error: unknown) => void;
     onDiagnosticEvent?: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
@@ -20,15 +29,6 @@ type BrokerWechatStatusRuntimeLifecycleDeps = {
 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;
@@ -36,15 +36,6 @@ type BrokerWechatSlashHandlerClient = {
         }) => Promise<unknown>;
     };
     permission?: {
-        list?: (input?: {
-            directory?: string;
-        }) => Promise<{
-            data?: Array<{
-                id?: string;
-            }>;
-        } | Array<{
-            id?: string;
-        }> | undefined>;
         reply?: (input: {
             requestID: string;
             directory?: string;

package/dist/wechat/broker-entry.js

@@ -7,6 +7,9 @@ import { createOpencodeClient as createOpencodeClientV2 } from "@opencode-ai/sdk
 import { startBrokerServer } from "./broker-server.js";
 import { WECHAT_FILE_MODE, wechatStateRoot, wechatStatusRuntimeDiagnosticsPath } from "./state-paths.js";
 import { createWechatStatusRuntime, } from "./wechat-status-runtime.js";
+import { createWechatNotificationDispatcher, } from "./notification-dispatcher.js";
+import { findOpenRequestByHandle, markRequestAnswered, markRequestRejected, } from "./request-store.js";
+import { findSentNotificationByRequest, markNotificationResolved, } from "./notification-store.js";
 const BROKER_WECHAT_RUNTIME_AUTOSTART_DELAY_MS = 1_000;
 async function readPackageVersion() {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
@@ -72,12 +75,6 @@ export function shouldEnableBrokerWechatStatusRuntime(env = process.env) {
     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 {
@@ -87,34 +84,95 @@ function withOptionalDirectory(input, directory) {
     }
     return input;
 }
+function isInvalidHandleError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /invalid handle format|raw requestID cannot be used as handle/i.test(error.message);
+}
 export function createBrokerWechatSlashCommandHandler(input) {
+    const findOpenRequestSafely = async (input) => {
+        try {
+            return await findOpenRequestByHandle(input);
+        }
+        catch (error) {
+            if (isInvalidHandleError(error)) {
+                return undefined;
+            }
+            throw error;
+        }
+    };
+    const resolveNotificationForOpenRequest = async (request) => {
+        try {
+            const sentNotification = await findSentNotificationByRequest({
+                kind: request.kind,
+                routeKey: request.routeKey,
+                handle: request.handle,
+            });
+            if (!sentNotification) {
+                return;
+            }
+            await markNotificationResolved({
+                idempotencyKey: sentNotification.idempotencyKey,
+                resolvedAt: Date.now(),
+            });
+        }
+        catch {
+            // best-effort only: notification resolve failure should not fail slash reply
+        }
+    };
     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 "当前没有待回复问题";
+            const openQuestion = await findOpenRequestSafely({
+                kind: "question",
+                handle: command.handle,
+            });
+            if (!openQuestion) {
+                return `未找到待回复问题：${command.handle}`;
             }
             await input.client?.question?.reply?.(withOptionalDirectory({
-                requestID,
+                requestID: openQuestion.requestID,
                 answers: [[command.text]],
             }, input.directory));
-            return `已回复问题：${requestID}`;
+            await markRequestAnswered({
+                kind: "question",
+                routeKey: openQuestion.routeKey,
+                answeredAt: Date.now(),
+            });
+            await resolveNotificationForOpenRequest(openQuestion);
+            return `已回复问题：${openQuestion.handle}`;
         }
-        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 "当前没有待处理权限请求";
+        const openPermission = await findOpenRequestSafely({
+            kind: "permission",
+            handle: command.handle,
+        });
+        if (!openPermission) {
+            return `未找到待处理权限请求：${command.handle}`;
         }
         await input.client?.permission?.reply?.(withOptionalDirectory({
-            requestID,
+            requestID: openPermission.requestID,
             reply: command.reply,
             ...(command.message ? { message: command.message } : {}),
         }, input.directory));
-        return `已处理权限请求：${requestID} (${command.reply})`;
+        if (command.reply === "reject") {
+            await markRequestRejected({
+                kind: "permission",
+                routeKey: openPermission.routeKey,
+                rejectedAt: Date.now(),
+            });
+        }
+        else {
+            await markRequestAnswered({
+                kind: "permission",
+                routeKey: openPermission.routeKey,
+                answeredAt: Date.now(),
+            });
+        }
+        await resolveNotificationForOpenRequest(openPermission);
+        return `已处理权限请求：${openPermission.handle} (${command.reply})`;
     };
 }
 export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
@@ -135,16 +193,43 @@ export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
             onSlashCommand: async ({ command }) => statusRuntimeDeps.onSlashCommand({ command }),
             onRuntimeError,
             onDiagnosticEvent: statusRuntimeDeps.onDiagnosticEvent,
+            drainOutboundMessages: async (drainInput) => {
+                await statusRuntimeDeps.drainOutboundMessages({
+                    sendMessage: async (message) => {
+                        await drainInput.sendMessage(message);
+                    },
+                });
+            },
         }));
+    const createNotificationDispatcher = deps.createNotificationDispatcher ?? createWechatNotificationDispatcher;
     let runtime = null;
+    let dispatcher = null;
     return {
         start: async () => {
             if (runtime) {
                 return;
             }
+            let runtimeSendMessage = null;
+            dispatcher = createNotificationDispatcher({
+                sendMessage: async (message) => {
+                    if (!runtimeSendMessage) {
+                        throw new Error("wechat runtime send helper unavailable");
+                    }
+                    await runtimeSendMessage(message);
+                },
+            });
             const created = createStatusRuntime({
                 onSlashCommand: async ({ command }) => handleWechatSlashCommand(command),
                 onDiagnosticEvent,
+                drainOutboundMessages: async (runtimeDrainInput) => {
+                    if (runtimeDrainInput?.sendMessage) {
+                        runtimeSendMessage = runtimeDrainInput.sendMessage;
+                    }
+                    if (!dispatcher) {
+                        return;
+                    }
+                    await dispatcher.drainOutboundMessages();
+                },
             });
             runtime = created;
             try {
@@ -160,6 +245,7 @@ export function createBrokerWechatStatusRuntimeLifecycle(deps = {}) {
             }
             const active = runtime;
             runtime = null;
+            dispatcher = null;
             await active.close().catch((error) => {
                 onRuntimeError(error);
             });

package/dist/wechat/broker-server.js

@@ -6,6 +6,10 @@ import { registerConnection, revokeSessionToken, validateSessionToken } from "./
 import { createErrorEnvelope, parseEnvelopeLine, serializeEnvelope, } from "./protocol.js";
 import { WECHAT_DIR_MODE, WECHAT_FILE_MODE, instanceStatePath, instancesDir } from "./state-paths.js";
 import { formatAggregatedStatusReply } from "./status-format.js";
+import { upsertNotification } from "./notification-store.js";
+import { readOperatorBinding } from "./operator-store.js";
+import { createHandle, createRouteKey } from "./handle.js";
+import { findOpenRequestByIdentity, listActiveRequests, upsertRequest } from "./request-store.js";
 const FUTURE_MESSAGE_TYPES = new Set([
     "collectStatus",
     "replyQuestion",
@@ -41,6 +45,7 @@ const instanceIDsBySocket = new Map();
 const snapshotByInstanceID = new Map();
 const snapshotPersistQueueByInstanceID = new Map();
 const pendingCollectStatusByRequestId = new Map();
+let syncWechatNotificationsChain = Promise.resolve();
 function clearRuntimeState() {
     for (const instanceID of registrationByInstanceID.keys()) {
         revokeSessionToken(instanceID);
@@ -50,6 +55,7 @@ function clearRuntimeState() {
     snapshotByInstanceID.clear();
     snapshotPersistQueueByInstanceID.clear();
     pendingCollectStatusByRequestId.clear();
+    syncWechatNotificationsChain = Promise.resolve();
 }
 function toPositiveNumber(rawValue, fallback) {
     if (!isNonEmptyString(rawValue)) {
@@ -77,6 +83,26 @@ function hasStatusSnapshotPayload(payload) {
     const record = asObject(payload);
     return isNonEmptyString(record.requestId) && "snapshot" in record;
 }
+function isWechatNotificationCandidate(value) {
+    const record = asObject(value);
+    if (!isNonEmptyString(record.idempotencyKey) || !isFiniteNumber(record.createdAt)) {
+        return false;
+    }
+    if (record.kind === "sessionError") {
+        return true;
+    }
+    if (record.kind === "question" || record.kind === "permission") {
+        return isNonEmptyString(record.requestID) && isNonEmptyString(record.routeKey) && isNonEmptyString(record.handle);
+    }
+    return false;
+}
+function hasSyncWechatNotificationsPayload(payload) {
+    const record = asObject(payload);
+    if (!Array.isArray(record.candidates)) {
+        return false;
+    }
+    return record.candidates.every((candidate) => isWechatNotificationCandidate(candidate));
+}
 function isSafeInstanceID(instanceID) {
     if (!isNonEmptyString(instanceID)) {
         return false;
@@ -253,6 +279,11 @@ function finalizePendingCollectStatus(requestId) {
         }),
     });
 }
+function queueSyncWechatNotifications(task) {
+    const next = syncWechatNotificationsChain.then(task);
+    syncWechatNotificationsChain = next.catch(() => { });
+    return next;
+}
 async function handleMessage(envelope, socket) {
     const requestId = getRequestId(envelope);
     if (envelope.type === "ping") {
@@ -368,6 +399,81 @@ async function handleMessage(envelope, socket) {
         }
         return;
     }
+    if (envelope.type === "syncWechatNotifications") {
+        if (!requireAuthorized(envelope)) {
+            writeError(socket, "unauthorized", "session token is invalid", requestId);
+            return;
+        }
+        const payload = envelope.payload;
+        if (!hasSyncWechatNotificationsPayload(payload)) {
+            writeError(socket, "invalidMessage", "syncWechatNotifications payload is invalid", requestId);
+            return;
+        }
+        const binding = await readOperatorBinding().catch(() => undefined);
+        if (!binding) {
+            return;
+        }
+        await queueSyncWechatNotifications(async () => {
+            for (const candidate of payload.candidates) {
+                if (candidate.kind === "sessionError") {
+                    await upsertNotification({
+                        idempotencyKey: candidate.idempotencyKey,
+                        kind: "sessionError",
+                        wechatAccountId: binding.wechatAccountId,
+                        userId: binding.userId,
+                        createdAt: candidate.createdAt,
+                    });
+                    continue;
+                }
+                const existingOpen = await findOpenRequestByIdentity({
+                    kind: candidate.kind,
+                    requestID: candidate.requestID,
+                    wechatAccountId: binding.wechatAccountId,
+                    userId: binding.userId,
+                    scopeKey: envelope.instanceID,
+                });
+                let canonicalRouteKey;
+                let canonicalHandle;
+                if (existingOpen) {
+                    canonicalRouteKey = existingOpen.routeKey;
+                    canonicalHandle = existingOpen.handle;
+                }
+                else {
+                    const activeRequests = await listActiveRequests();
+                    const existingHandles = activeRequests
+                        .filter((item) => item.kind === candidate.kind && item.status === "open")
+                        .map((item) => item.handle);
+                    const nextRouteKey = createRouteKey({
+                        kind: candidate.kind,
+                        requestID: candidate.requestID,
+                        scopeKey: envelope.instanceID,
+                    });
+                    const nextHandle = createHandle(candidate.kind, existingHandles);
+                    const created = await upsertRequest({
+                        kind: candidate.kind,
+                        requestID: candidate.requestID,
+                        routeKey: nextRouteKey,
+                        handle: nextHandle,
+                        wechatAccountId: binding.wechatAccountId,
+                        userId: binding.userId,
+                        createdAt: candidate.createdAt,
+                    });
+                    canonicalRouteKey = created.routeKey;
+                    canonicalHandle = created.handle;
+                }
+                await upsertNotification({
+                    idempotencyKey: candidate.idempotencyKey,
+                    kind: candidate.kind,
+                    wechatAccountId: binding.wechatAccountId,
+                    userId: binding.userId,
+                    routeKey: canonicalRouteKey,
+                    handle: canonicalHandle,
+                    createdAt: candidate.createdAt,
+                });
+            }
+        });
+        return;
+    }
     if (FUTURE_MESSAGE_TYPES.has(envelope.type)) {
         if (!requireAuthorized(envelope)) {
             writeError(socket, "unauthorized", "session token is invalid", requestId);

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

@@ -2,9 +2,11 @@ export type WechatSlashCommand = {
     type: "status";
 } | {
     type: "reply";
+    handle: string;
     text: string;
 } | {
     type: "allow";
+    handle: string;
     reply: "once" | "always" | "reject";
     message?: string;
 };