opencode-copilot-account-switcher 0.14.28 → 0.14.30

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;
 };

package/dist/wechat/command-parser.js

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

package/dist/wechat/handle.d.ts

@@ -2,6 +2,7 @@ import type { WechatRequestKind } from "./state-paths.js";
 export declare function createRouteKey(input: {
     kind: WechatRequestKind;
     requestID: string;
+    scopeKey?: string;
 }): string;
 export declare function normalizeHandle(input: string): string;
 export declare function assertValidHandleInput(input: string): void;

package/dist/wechat/handle.js

@@ -8,7 +8,12 @@ function normalizeRequestID(requestID) {
 }
 export function createRouteKey(input) {
     const normalized = normalizeRequestID(input.requestID);
-    const digest = crypto.createHash("sha1").update(`${input.kind}:${normalized}`).digest("hex").slice(0, 12);
+    const normalizedScope = typeof input.scopeKey === "string" ? input.scopeKey.trim().toLowerCase() : "";
+    const digest = crypto
+        .createHash("sha1")
+        .update(`${input.kind}:${normalized}:${normalizedScope}`)
+        .digest("hex")
+        .slice(0, 12);
     return `${input.kind}-${digest}`;
 }
 export function normalizeHandle(input) {

package/dist/wechat/notification-dispatcher.d.ts

@@ -0,0 +1,12 @@
+export type WechatNotificationSendInput = {
+    to: string;
+    text: string;
+};
+type CreateWechatNotificationDispatcherInput = {
+    sendMessage: (input: WechatNotificationSendInput) => Promise<unknown>;
+};
+type WechatNotificationDispatcher = {
+    drainOutboundMessages: () => Promise<void>;
+};
+export declare function createWechatNotificationDispatcher(input: CreateWechatNotificationDispatcherInput): WechatNotificationDispatcher;
+export {};

package/dist/wechat/notification-dispatcher.js

@@ -0,0 +1,143 @@
+import { readCommonSettingsStore } from "../common-settings-store.js";
+import { listPendingNotifications, markNotificationResolved, markNotificationFailed, markNotificationSent, purgeTerminalNotificationsBefore, } from "./notification-store.js";
+import { formatWechatNotificationText } from "./notification-format.js";
+import { findRequestByRouteKey } from "./request-store.js";
+const DEFAULT_NOTIFICATION_TERMINAL_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+function toPositiveNumber(rawValue, fallback) {
+    if (typeof rawValue !== "string" || rawValue.trim().length === 0) {
+        return fallback;
+    }
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+}
+function shouldSendKind(kind, notifications) {
+    if (!notifications.enabled) {
+        return false;
+    }
+    if (kind === "question") {
+        return notifications.question;
+    }
+    if (kind === "permission") {
+        return notifications.permission;
+    }
+    return notifications.sessionError;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+function isNotPendingStateError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /not pending/i.test(error.message);
+}
+function isNotSuppressibleStateError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /not pending|neither pending nor sent/i.test(error.message);
+}
+async function shouldSuppressPendingNotification(record) {
+    if (record.kind === "sessionError") {
+        return false;
+    }
+    if (typeof record.routeKey !== "string" || record.routeKey.trim().length === 0) {
+        return false;
+    }
+    const request = await findRequestByRouteKey({
+        kind: record.kind,
+        routeKey: record.routeKey,
+    });
+    if (!request) {
+        return false;
+    }
+    return request.status !== "open";
+}
+export function createWechatNotificationDispatcher(input) {
+    return {
+        drainOutboundMessages: async () => {
+            const retentionMs = toPositiveNumber(process.env.WECHAT_NOTIFICATION_TERMINAL_RETENTION_MS, DEFAULT_NOTIFICATION_TERMINAL_RETENTION_MS);
+            await purgeTerminalNotificationsBefore({
+                cutoffAt: Date.now() - retentionMs,
+            });
+            const settings = await readCommonSettingsStore();
+            const notifications = settings.wechat?.notifications;
+            const targetUserId = settings.wechat?.primaryBinding?.userId;
+            const targetAccountId = settings.wechat?.primaryBinding?.accountId;
+            if (!notifications) {
+                return;
+            }
+            if (typeof targetUserId !== "string" || targetUserId.trim().length === 0) {
+                return;
+            }
+            if (typeof targetAccountId !== "string" || targetAccountId.trim().length === 0) {
+                return;
+            }
+            const pending = await listPendingNotifications();
+            for (const record of pending) {
+                if (await shouldSuppressPendingNotification(record)) {
+                    try {
+                        await markNotificationResolved({
+                            idempotencyKey: record.idempotencyKey,
+                            resolvedAt: Date.now(),
+                            suppressed: true,
+                        });
+                    }
+                    catch (error) {
+                        if (!isNotSuppressibleStateError(error)) {
+                            throw error;
+                        }
+                    }
+                    continue;
+                }
+                if (!shouldSendKind(record.kind, notifications)) {
+                    continue;
+                }
+                if (record.userId !== targetUserId || record.wechatAccountId !== targetAccountId) {
+                    continue;
+                }
+                try {
+                    await input.sendMessage({
+                        to: targetUserId,
+                        text: formatWechatNotificationText(record),
+                    });
+                }
+                catch (error) {
+                    try {
+                        await markNotificationFailed({
+                            idempotencyKey: record.idempotencyKey,
+                            failedAt: Date.now(),
+                            reason: toErrorMessage(error),
+                        });
+                    }
+                    catch (markError) {
+                        if (!isNotPendingStateError(markError)) {
+                            throw markError;
+                        }
+                    }
+                    continue;
+                }
+                try {
+                    await markNotificationSent({
+                        idempotencyKey: record.idempotencyKey,
+                        sentAt: Date.now(),
+                    });
+                }
+                catch (error) {
+                    if (!isNotPendingStateError(error)) {
+                        throw error;
+                    }
+                }
+            }
+        },
+    };
+}

package/dist/wechat/notification-format.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationRecord } from "./notification-types.js";
+export declare function formatWechatNotificationText(record: NotificationRecord): string;

package/dist/wechat/notification-format.js

@@ -0,0 +1,17 @@
+function formatHandle(handle, fallback) {
+    if (typeof handle === "string" && handle.trim().length > 0) {
+        return handle;
+    }
+    return fallback;
+}
+export function formatWechatNotificationText(record) {
+    if (record.kind === "question") {
+        const handle = formatHandle(record.handle, "q?");
+        return `收到新的问题请求（${handle}），请在 OpenCode 中处理。`;
+    }
+    if (record.kind === "permission") {
+        const handle = formatHandle(record.handle, "p?");
+        return `收到新的权限请求（${handle}），请在 OpenCode 中处理。`;
+    }
+    return "检测到会话异常（retry），请在 OpenCode 中检查并处理。";
+}

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

@@ -0,0 +1,25 @@
+import { type NotificationKind, type NotificationRecord } from "./notification-types.js";
+export declare function upsertNotification(input: Omit<NotificationRecord, "status" | "sentAt" | "resolvedAt" | "failedAt" | "suppressedAt" | "failureReason">): Promise<NotificationRecord>;
+export declare function markNotificationSent(input: {
+    idempotencyKey: string;
+    sentAt: number;
+}): Promise<NotificationRecord>;
+export declare function markNotificationResolved(input: {
+    idempotencyKey: string;
+    resolvedAt: number;
+    suppressed?: boolean;
+}): Promise<NotificationRecord>;
+export declare function markNotificationFailed(input: {
+    idempotencyKey: string;
+    failedAt: number;
+    reason: string;
+}): Promise<NotificationRecord>;
+export declare function listPendingNotifications(): Promise<NotificationRecord[]>;
+export declare function findSentNotificationByRequest(input: {
+    kind: Exclude<NotificationKind, "sessionError">;
+    routeKey: string;
+    handle: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function purgeTerminalNotificationsBefore(input: {
+    cutoffAt: number;
+}): Promise<number>;