opencode-copilot-account-switcher 0.13.6 → 0.14.1

package/dist/wechat/wechat-status-runtime.js

@@ -0,0 +1,238 @@
+import { loadOpenClawWeixinPublicHelpers, } from "./compat/openclaw-public-helpers.js";
+import { parseWechatSlashCommand } from "./command-parser.js";
+const DEFAULT_RETRY_DELAY_MS = 1_000;
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 25_000;
+export const DEFAULT_NON_SLASH_REPLY_TEXT = "请使用 slash 命令（/status、/reply、/allow）";
+export const DEFAULT_SLASH_HANDLER_ERROR_REPLY_TEXT = "命令处理失败，请稍后重试。";
+function createAbortError() {
+    const error = new Error("wechat status runtime stopped");
+    error.name = "AbortError";
+    return error;
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function withAbort(promise, signal) {
+    if (signal.aborted) {
+        return Promise.reject(createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(createAbortError());
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
+function sleep(ms, signal) {
+    if (signal.aborted) {
+        return Promise.reject(createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            reject(createAbortError());
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function normalizePositiveInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function extractMessageText(message) {
+    for (const item of message.item_list ?? []) {
+        if (item?.type !== 1) {
+            continue;
+        }
+        if (typeof item.text_item?.text === "string" && item.text_item.text.trim().length > 0) {
+            return item.text_item.text;
+        }
+    }
+    return "";
+}
+function toNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function createWechatStatusRuntime(input = {}) {
+    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
+    const onSlashCommand = input.onSlashCommand ??
+        (async () => {
+            return "/status 处理中";
+        });
+    const onRuntimeError = input.onRuntimeError ?? (() => { });
+    const retryDelayMs = normalizePositiveInteger(input.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+    const longPollTimeoutMs = normalizePositiveInteger(input.longPollTimeoutMs, DEFAULT_LONG_POLL_TIMEOUT_MS);
+    let started = false;
+    let closed = false;
+    let stopController = null;
+    let pollingTask = null;
+    const poll = async (signal) => {
+        let initialized = null;
+        while (!signal.aborted) {
+            try {
+                if (!initialized) {
+                    const helpers = await withAbort(loadPublicHelpers(input.publicHelpersOptions), signal);
+                    const latestAccountState = helpers.latestAccountState;
+                    if (!latestAccountState) {
+                        throw new Error("missing wechat account state");
+                    }
+                    initialized = {
+                        helpers,
+                        accountId: latestAccountState.accountId,
+                        baseUrl: latestAccountState.baseUrl,
+                        token: latestAccountState.token,
+                        getUpdatesBuf: typeof latestAccountState.getUpdatesBuf === "string" ? latestAccountState.getUpdatesBuf : "",
+                    };
+                }
+                const response = await withAbort(initialized.helpers.getUpdates({
+                    baseUrl: initialized.baseUrl,
+                    token: initialized.token,
+                    get_updates_buf: initialized.getUpdatesBuf,
+                    timeoutMs: longPollTimeoutMs,
+                }), signal);
+                // 语义锁定：一旦服务端返回新的 get_updates_buf，立即推进游标；
+                // 后续轮询即便失败，也不会回滚到旧 buf。
+                if (typeof response.get_updates_buf === "string") {
+                    initialized.getUpdatesBuf = response.get_updates_buf;
+                    if (typeof initialized.helpers.persistGetUpdatesBuf === "function") {
+                        try {
+                            await withAbort(initialized.helpers.persistGetUpdatesBuf({
+                                accountId: initialized.accountId,
+                                getUpdatesBuf: response.get_updates_buf,
+                            }), signal);
+                        }
+                        catch (error) {
+                            if (isAbortError(error)) {
+                                return;
+                            }
+                            onRuntimeError(error);
+                        }
+                    }
+                }
+                const messages = Array.isArray(response.msgs) ? response.msgs : [];
+                for (const message of messages) {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    const to = toNonEmptyString(message.from_user_id);
+                    const text = extractMessageText(message);
+                    if (!to || text.trim().length === 0) {
+                        continue;
+                    }
+                    const parsedCommand = parseWechatSlashCommand(text);
+                    let replyText = DEFAULT_NON_SLASH_REPLY_TEXT;
+                    if (parsedCommand) {
+                        try {
+                            replyText = await onSlashCommand({
+                                command: parsedCommand,
+                                text,
+                                message,
+                            });
+                        }
+                        catch (error) {
+                            onRuntimeError(error);
+                            replyText = DEFAULT_SLASH_HANDLER_ERROR_REPLY_TEXT;
+                        }
+                    }
+                    try {
+                        await withAbort(initialized.helpers.sendMessageWeixin({
+                            to,
+                            text: replyText,
+                            opts: {
+                                baseUrl: initialized.baseUrl,
+                                token: initialized.token,
+                                contextToken: toNonEmptyString(message.context_token) ?? undefined,
+                            },
+                        }), signal);
+                    }
+                    catch (error) {
+                        if (isAbortError(error)) {
+                            return;
+                        }
+                        onRuntimeError(error);
+                    }
+                }
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    return;
+                }
+                onRuntimeError(error);
+                if (signal.aborted || closed) {
+                    return;
+                }
+                try {
+                    await sleep(retryDelayMs, signal);
+                }
+                catch (sleepError) {
+                    if (isAbortError(sleepError)) {
+                        return;
+                    }
+                    onRuntimeError(sleepError);
+                }
+            }
+        }
+    };
+    return {
+        start: async () => {
+            if (started) {
+                return;
+            }
+            started = true;
+            closed = false;
+            const controller = new AbortController();
+            stopController = controller;
+            pollingTask = poll(controller.signal);
+        },
+        close: async () => {
+            if (!started) {
+                return;
+            }
+            closed = true;
+            started = false;
+            const controller = stopController;
+            stopController = null;
+            controller?.abort();
+            const task = pollingTask;
+            pollingTask = null;
+            if (task) {
+                await task.catch(() => { });
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.13.6",
+  "version": "0.14.1",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,7 @@
     "auth"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0"
   },
   "files": [
     "dist/",
@@ -46,6 +46,9 @@
     "check:copilot-sync": "node scripts/sync-copilot-upstream.mjs --output src/upstream/copilot-plugin.snapshot.ts --check",
     "sync:codex-snapshot": "node scripts/sync-codex-upstream.mjs --output src/upstream/codex-plugin.snapshot.ts",
     "check:codex-sync": "node scripts/sync-codex-upstream.mjs --output src/upstream/codex-plugin.snapshot.ts --check",
+    "wechat:smoke:self-test": "npm run build && node --input-type=module -e \"import('./dist/wechat/compat/openclaw-smoke.js').then(async (m) => { const results = await m.runOpenClawSmoke('self-test'); console.log(JSON.stringify(results, null, 2)); })\"",
+    "wechat:smoke:real-account": "npm run build && node --input-type=module -e \"import('./dist/wechat/compat/openclaw-smoke.js').then(async (m) => { const dryRun = process.argv.includes('--dry-run'); const results = await m.runOpenClawSmoke('real-account', { dryRun }); console.log(JSON.stringify(results, null, 2)); })\" --",
+    "wechat:smoke:guided": "npm run build && node dist/wechat/compat/openclaw-guided-smoke.js",
     "test": "npm run build && node --test",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
@@ -58,8 +61,10 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@opencode-ai/sdk": "^1.2.26",
     "@opencode-ai/plugin": "^1.2.26",
+    "@opencode-ai/sdk": "^1.2.26",
+    "@tencent-weixin/openclaw-weixin": "^1.0.3",
+    "openclaw": "2026.3.13",
     "xdg-basedir": "^5.1.0"
   }
 }