opencode-copilot-account-switcher 0.14.29 → 0.14.31

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/compat/jiti-loader.d.ts

@@ -1,11 +1,12 @@
 export type JitiLoader = (path: string) => unknown;
 type CreateJiti = (id: string | URL, options?: Record<string, unknown>) => JitiLoader;
+type JitiImport = (specifier: string) => Promise<unknown> | unknown;
 type JitiNamespace = {
     createJiti?: unknown;
     default?: unknown;
 };
 export declare function resolveCreateJiti(namespace: JitiNamespace): CreateJiti;
-export declare function loadJiti(requireImpl?: NodeRequire): {
+export declare function loadJiti(importImpl?: JitiImport): Promise<{
     createJiti: CreateJiti;
-};
+}>;
 export {};

package/dist/wechat/compat/jiti-loader.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 function isCreateJiti(value) {
     return typeof value === "function";
 }
@@ -19,8 +18,8 @@ export function resolveCreateJiti(namespace) {
     }
     throw new Error("[wechat-compat] createJiti export unavailable");
 }
-export function loadJiti(requireImpl = createRequire(import.meta.url)) {
-    const namespace = requireImpl("jiti");
+export async function loadJiti(importImpl = (specifier) => import(specifier)) {
+    const namespace = await Promise.resolve(importImpl("jiti"));
     return {
         createJiti: resolveCreateJiti(namespace),
     };

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

@@ -2,11 +2,11 @@ import { createRequire } from "node:module";
 import { loadJiti } from "./jiti-loader.js";
 const OPENCLAW_WEIXIN_ACCOUNTS_MODULE = "@tencent-weixin/openclaw-weixin/src/auth/accounts.ts";
 let accountJitiLoader = null;
-function getAccountJiti() {
+async function getAccountJiti() {
     if (accountJitiLoader) {
         return accountJitiLoader;
     }
-    accountJitiLoader = loadJiti().createJiti(import.meta.url, {
+    accountJitiLoader = (await loadJiti()).createJiti(import.meta.url, {
         interopDefault: true,
         extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
     });
@@ -52,7 +52,7 @@ export function createOpenClawAccountHelpers(input) {
 export async function loadOpenClawAccountHelpers(options = {}) {
     const require = createRequire(import.meta.url);
     const accountsModulePath = require.resolve(options.accountsModulePath ?? OPENCLAW_WEIXIN_ACCOUNTS_MODULE);
-    const accountsModule = getAccountJiti()(accountsModulePath);
+    const accountsModule = (await getAccountJiti())(accountsModulePath);
     if (typeof accountsModule.listIndexedWeixinAccountIds !== "function" || typeof accountsModule.loadWeixinAccount !== "function") {
         throw new Error("[wechat-compat] account source helper unavailable");
     }

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

@@ -8,11 +8,11 @@ function requireField(condition, message) {
         throw new Error(`[wechat-compat] ${message}`);
     }
 }
-function getPublicJiti() {
+async function getPublicJiti() {
     if (publicJitiLoader) {
         return publicJitiLoader;
     }
-    publicJitiLoader = loadJiti().createJiti(import.meta.url, {
+    publicJitiLoader = (await loadJiti()).createJiti(import.meta.url, {
         interopDefault: true,
         extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
     });
@@ -42,7 +42,7 @@ export async function resolveOpenClawWeixinPublicEntry() {
 }
 export async function loadOpenClawWeixinDefaultExport() {
     const entry = await resolveOpenClawWeixinPublicEntry();
-    const moduleNamespace = getPublicJiti()(entry.entryAbsolutePath);
+    const moduleNamespace = (await getPublicJiti())(entry.entryAbsolutePath);
     const plugin = moduleNamespace.default;
     if (!plugin || typeof plugin !== "object" || typeof plugin.register !== "function") {
         throw new Error("[wechat-compat] @tencent-weixin/openclaw-weixin public entry default export is missing register(api)");

package/dist/wechat/compat/openclaw-sync-buf.js

@@ -5,11 +5,11 @@ import { loadJiti } from "./jiti-loader.js";
 const OPENCLAW_SYNC_BUF_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/sync-buf.ts";
 const OPENCLAW_STATE_DIR_MODULE = "@tencent-weixin/openclaw-weixin/src/storage/state-dir.ts";
 let syncBufJitiLoader = null;
-function getSyncBufJiti() {
+async function getSyncBufJiti() {
     if (syncBufJitiLoader) {
         return syncBufJitiLoader;
     }
-    syncBufJitiLoader = loadJiti().createJiti(import.meta.url, {
+    syncBufJitiLoader = (await loadJiti()).createJiti(import.meta.url, {
         interopDefault: true,
         extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
     });
@@ -29,7 +29,7 @@ export function createOpenClawSyncBufHelper(input) {
 export async function loadOpenClawSyncBufHelper(options = {}) {
     const require = createRequire(import.meta.url);
     const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
-    const syncBufModule = getSyncBufJiti()(syncBufModulePath);
+    const syncBufModule = (await getSyncBufJiti())(syncBufModulePath);
     if (typeof syncBufModule.getSyncBufFilePath !== "function" || typeof syncBufModule.saveGetUpdatesBuf !== "function") {
         throw new Error("[wechat-compat] sync-buf source helper unavailable");
     }
@@ -41,7 +41,7 @@ export async function loadOpenClawSyncBufHelper(options = {}) {
 export async function loadLatestWeixinAccountState(options = {}) {
     const require = createRequire(import.meta.url);
     const stateDirModulePath = require.resolve(options.stateDirModulePath ?? OPENCLAW_STATE_DIR_MODULE);
-    const stateDirModule = getSyncBufJiti()(stateDirModulePath);
+    const stateDirModule = (await getSyncBufJiti())(stateDirModulePath);
     const stateDir = stateDirModule.resolveStateDir?.();
     if (!stateDir) {
         return null;
@@ -67,7 +67,7 @@ export async function loadLatestWeixinAccountState(options = {}) {
         const accountRaw = await readFile(accountFilePath, "utf8");
         const account = JSON.parse(accountRaw);
         const syncBufModulePath = require.resolve(options.syncBufModulePath ?? OPENCLAW_SYNC_BUF_MODULE);
-        const syncBufModule = getSyncBufJiti()(syncBufModulePath);
+        const syncBufModule = (await getSyncBufJiti())(syncBufModulePath);
         if (typeof account.token !== "string" || account.token.trim().length === 0) {
             return null;
         }

package/dist/wechat/compat/openclaw-updates-send.js

@@ -3,11 +3,11 @@ import { loadJiti } from "./jiti-loader.js";
 const OPENCLAW_UPDATES_MODULE = "@tencent-weixin/openclaw-weixin/src/api/api.ts";
 const OPENCLAW_SEND_MODULE = "@tencent-weixin/openclaw-weixin/src/messaging/send.ts";
 let updatesSendJitiLoader = null;
-function getUpdatesSendJiti() {
+async function getUpdatesSendJiti() {
     if (updatesSendJitiLoader) {
         return updatesSendJitiLoader;
     }
-    updatesSendJitiLoader = loadJiti().createJiti(import.meta.url, {
+    updatesSendJitiLoader = (await loadJiti()).createJiti(import.meta.url, {
         interopDefault: true,
         extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"],
     });
@@ -34,8 +34,9 @@ export async function loadOpenClawUpdatesAndSendHelpers(options = {}) {
     const require = createRequire(import.meta.url);
     const getUpdatesModulePath = require.resolve(options.getUpdatesModulePath ?? OPENCLAW_UPDATES_MODULE);
     const sendModulePath = require.resolve(options.sendMessageWeixinModulePath ?? OPENCLAW_SEND_MODULE);
-    const getUpdatesModule = getUpdatesSendJiti()(getUpdatesModulePath);
-    const sendModule = getUpdatesSendJiti()(sendModulePath);
+    const jiti = await getUpdatesSendJiti();
+    const getUpdatesModule = jiti(getUpdatesModulePath);
+    const sendModule = jiti(sendModulePath);
     if (typeof getUpdatesModule.getUpdates !== "function") {
         throw new Error("public getUpdates helper unavailable");
     }

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