opencode-oncall 0.1.0

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

@@ -0,0 +1,518 @@
+import { loadOpenClawWeixinPublicHelpers, } from "./compat/openclaw-public-helpers.js";
+import { STAGE_A_SLASH_ONLY_MESSAGE } from "./compat/slash-guard.js";
+import { parseWechatSlashCommand } from "./command-parser.js";
+import { redactDebugBundleText } from "./debug-bundle-redaction.js";
+import { upsertInboundToken } from "./token-store.js";
+const DEFAULT_RETRY_DELAY_MS = 1_000;
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 25_000;
+const MAX_HELPER_FAILURE_BACKOFF_MS = 30_000;
+export const DEFAULT_NON_SLASH_REPLY_TEXT = STAGE_A_SLASH_ONLY_MESSAGE;
+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 computeHelperFailureBackoffMs(retryDelayMs, consecutiveFailures) {
+    return Math.min(retryDelayMs * 2 ** Math.max(0, consecutiveFailures - 1), MAX_HELPER_FAILURE_BACKOFF_MS);
+}
+function cloneHelperFailureState(state) {
+    if (!state) {
+        return null;
+    }
+    return { ...state };
+}
+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;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+function sanitizeRuntimeDiagnosticError(error) {
+    return redactDebugBundleText(error, "diagnostics/wechat-status-runtime.runtime-error.txt");
+}
+function toRuntimeDiagnosticError(error) {
+    return sanitizeRuntimeDiagnosticError(toErrorMessage(error));
+}
+function toInboundTokenSource(command) {
+    if (command?.type === "reply") {
+        return "question";
+    }
+    if (command?.type === "allow") {
+        return "permission";
+    }
+    return "message";
+}
+export function createWechatStatusRuntime(input = {}) {
+    const loadPublicHelpers = input.loadPublicHelpers ?? loadOpenClawWeixinPublicHelpers;
+    const onSlashCommand = input.onSlashCommand ??
+        (async () => {
+            return "/status 处理中";
+        });
+    const onRuntimeError = input.onRuntimeError ?? (() => { });
+    const onDiagnosticEvent = input.onDiagnosticEvent ?? (() => { });
+    const retryDelayMs = normalizePositiveInteger(input.retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+    const longPollTimeoutMs = normalizePositiveInteger(input.longPollTimeoutMs, DEFAULT_LONG_POLL_TIMEOUT_MS);
+    const now = input.now ?? Date.now;
+    const sleepImpl = input.sleepImpl ?? sleep;
+    const onFailureStateChange = input.onFailureStateChange ?? (() => { });
+    const shouldReloadState = input.shouldReloadState ?? (() => false);
+    const drainOutboundMessages = input.drainOutboundMessages;
+    let started = false;
+    let closed = false;
+    let stopController = null;
+    let pollingTask = null;
+    let outboundDrainTask = null;
+    let helperFailureState = null;
+    let activeRuntimeState = null;
+    let inFlightDrain = null;
+    const retainedHelperFailureObjects = new Set();
+    const emitDiagnosticEvent = (event) => {
+        void Promise.resolve()
+            .then(() => onDiagnosticEvent(event))
+            .catch((error) => {
+            onRuntimeError(error);
+        });
+    };
+    const emitFailureStateChange = (state) => {
+        const snapshot = cloneHelperFailureState(state);
+        void Promise.resolve()
+            .then(() => onFailureStateChange(snapshot))
+            .catch((error) => {
+            onRuntimeError(error);
+        });
+    };
+    const replaceHelperFailureState = (nextState) => {
+        if (helperFailureState) {
+            retainedHelperFailureObjects.delete(helperFailureState);
+        }
+        helperFailureState = nextState;
+        if (helperFailureState) {
+            retainedHelperFailureObjects.add(helperFailureState);
+        }
+        emitFailureStateChange(helperFailureState);
+    };
+    const clearHelperFailureState = () => {
+        if (!helperFailureState && retainedHelperFailureObjects.size === 0) {
+            return;
+        }
+        replaceHelperFailureState(null);
+    };
+    const drainOutboundWithState = async (initialized, signal) => {
+        if (!drainOutboundMessages) {
+            return;
+        }
+        await withAbort(drainOutboundMessages({
+            sendMessage: async (message) => {
+                await initialized.helpers.sendMessageWeixin({
+                    to: message.to,
+                    text: message.text,
+                    opts: {
+                        baseUrl: initialized.baseUrl,
+                        token: initialized.token,
+                        ...(typeof message.contextToken === "string" && message.contextToken.trim().length > 0
+                            ? { contextToken: message.contextToken }
+                            : {}),
+                    },
+                });
+            },
+        }), signal);
+    };
+    const drainCurrentOutboundMessages = async (signal) => {
+        if (!drainOutboundMessages || !activeRuntimeState) {
+            return;
+        }
+        if (inFlightDrain) {
+            return inFlightDrain;
+        }
+        const currentState = activeRuntimeState;
+        const currentDrain = drainOutboundWithState(currentState, signal)
+            .catch((error) => {
+            if (isAbortError(error)) {
+                return;
+            }
+            emitRuntimeErrorDiagnostic("drainOutboundMessages", error);
+            onRuntimeError(error);
+        })
+            .finally(() => {
+            if (inFlightDrain === currentDrain) {
+                inFlightDrain = null;
+            }
+        });
+        inFlightDrain = currentDrain;
+        return currentDrain;
+    };
+    const pollOutboundMessages = async (signal) => {
+        if (!drainOutboundMessages) {
+            return;
+        }
+        while (!signal.aborted) {
+            await drainCurrentOutboundMessages(signal);
+            try {
+                await sleepImpl(retryDelayMs, signal);
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    return;
+                }
+                onRuntimeError(error);
+            }
+        }
+    };
+    const noteLoadPublicHelpersFailure = () => {
+        const consecutiveFailures = (helperFailureState?.consecutiveFailures ?? 0) + 1;
+        const currentBackoffMs = computeHelperFailureBackoffMs(retryDelayMs, consecutiveFailures);
+        const lastFailureAtMs = now();
+        const nextState = {
+            stage: "loadPublicHelpers",
+            consecutiveFailures,
+            currentBackoffMs,
+            retryState: "backing-off",
+            reachedGetUpdates: false,
+            lastFailureAtMs,
+            nextRetryAtMs: lastFailureAtMs + currentBackoffMs,
+        };
+        replaceHelperFailureState(nextState);
+        return nextState;
+    };
+    const emitRuntimeErrorDiagnostic = (stage, error, options) => {
+        const runtimeError = toRuntimeDiagnosticError(error);
+        if (stage === "loadPublicHelpers") {
+            emitDiagnosticEvent({
+                type: "runtimeError",
+                stage,
+                error: runtimeError,
+                consecutiveFailures: options?.consecutiveFailures ?? 1,
+                backoffMs: options?.backoffMs ?? retryDelayMs,
+                retryState: options?.retryState ?? "backing-off",
+                reachedGetUpdates: false,
+            });
+            return;
+        }
+        emitDiagnosticEvent({
+            type: "runtimeError",
+            stage,
+            error: runtimeError,
+            reachedGetUpdates: true,
+        });
+    };
+    const poll = async (signal) => {
+        let initialized = null;
+        while (!signal.aborted) {
+            let nextRetryDelayMs = retryDelayMs;
+            try {
+                let justInitialized = false;
+                if (!initialized) {
+                    try {
+                        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 : "",
+                        };
+                        activeRuntimeState = initialized;
+                        clearHelperFailureState();
+                        justInitialized = true;
+                    }
+                    catch (error) {
+                        if (isAbortError(error)) {
+                            return;
+                        }
+                        const failureState = noteLoadPublicHelpersFailure();
+                        nextRetryDelayMs = failureState.currentBackoffMs;
+                        emitRuntimeErrorDiagnostic("loadPublicHelpers", error, {
+                            consecutiveFailures: failureState.consecutiveFailures,
+                            backoffMs: failureState.currentBackoffMs,
+                            retryState: failureState.retryState,
+                        });
+                        throw error;
+                    }
+                }
+                if (!justInitialized && initialized && shouldReloadState({
+                    accountId: initialized.accountId,
+                    baseUrl: initialized.baseUrl,
+                    token: initialized.token,
+                    getUpdatesBuf: initialized.getUpdatesBuf,
+                })) {
+                    initialized = null;
+                    activeRuntimeState = null;
+                    continue;
+                }
+                let response;
+                try {
+                    response = await withAbort(initialized.helpers.getUpdates({
+                        baseUrl: initialized.baseUrl,
+                        token: initialized.token,
+                        get_updates_buf: initialized.getUpdatesBuf,
+                        timeoutMs: longPollTimeoutMs,
+                    }), signal);
+                }
+                catch (error) {
+                    if (isAbortError(error)) {
+                        return;
+                    }
+                    emitRuntimeErrorDiagnostic("getUpdates", error);
+                    throw error;
+                }
+                // 语义锁定：一旦服务端返回新的 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;
+                            }
+                            emitRuntimeErrorDiagnostic("persistGetUpdatesBuf", error);
+                            onRuntimeError(error);
+                        }
+                    }
+                }
+                const messages = Array.isArray(response.msgs) ? response.msgs : [];
+                await drainCurrentOutboundMessages(signal);
+                for (const message of messages) {
+                    if (signal.aborted) {
+                        return;
+                    }
+                    const to = toNonEmptyString(message.from_user_id);
+                    const text = extractMessageText(message);
+                    const hasText = text.trim().length > 0;
+                    if (!to) {
+                        emitDiagnosticEvent({
+                            type: "messageSkipped",
+                            reason: "missingFromUserId",
+                            hasFromUserId: false,
+                            hasText,
+                        });
+                        continue;
+                    }
+                    if (!hasText) {
+                        emitDiagnosticEvent({
+                            type: "messageSkipped",
+                            reason: "missingText",
+                            hasFromUserId: true,
+                            hasText: false,
+                        });
+                        continue;
+                    }
+                    const parsedCommand = parseWechatSlashCommand(text);
+                    const inboundContextToken = toNonEmptyString(message.context_token) ?? undefined;
+                    let replyText = DEFAULT_NON_SLASH_REPLY_TEXT;
+                    if (parsedCommand) {
+                        if (inboundContextToken) {
+                            try {
+                                await upsertInboundToken({
+                                    wechatAccountId: initialized.accountId,
+                                    userId: to,
+                                    contextToken: inboundContextToken,
+                                    updatedAt: Date.now(),
+                                    source: toInboundTokenSource(parsedCommand),
+                                });
+                            }
+                            catch (error) {
+                                onRuntimeError(error);
+                            }
+                        }
+                        emitDiagnosticEvent({
+                            type: "slashCommandRecognized",
+                            command: parsedCommand,
+                            text,
+                            to,
+                        });
+                        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;
+                        }
+                        emitDiagnosticEvent({
+                            type: "replySendFailed",
+                            to,
+                            error: toErrorMessage(error),
+                            commandType: parsedCommand?.type ?? null,
+                        });
+                        emitRuntimeErrorDiagnostic("sendReplyMessage", error);
+                        onRuntimeError(error);
+                    }
+                }
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    return;
+                }
+                onRuntimeError(error);
+                if (signal.aborted || closed) {
+                    return;
+                }
+                try {
+                    await sleepImpl(nextRetryDelayMs, signal);
+                }
+                catch (sleepError) {
+                    if (isAbortError(sleepError)) {
+                        return;
+                    }
+                    onRuntimeError(sleepError);
+                }
+            }
+        }
+    };
+    return {
+        start: async () => {
+            if (started) {
+                return;
+            }
+            clearHelperFailureState();
+            started = true;
+            closed = false;
+            const controller = new AbortController();
+            stopController = controller;
+            pollingTask = poll(controller.signal);
+            outboundDrainTask = pollOutboundMessages(controller.signal);
+        },
+        close: async () => {
+            if (!started) {
+                clearHelperFailureState();
+                return;
+            }
+            closed = true;
+            started = false;
+            const controller = stopController;
+            stopController = null;
+            controller?.abort();
+            const task = pollingTask;
+            pollingTask = null;
+            const drainTask = outboundDrainTask;
+            outboundDrainTask = null;
+            if (task) {
+                await task.catch(() => { });
+            }
+            if (drainTask) {
+                await drainTask.catch(() => { });
+            }
+            activeRuntimeState = null;
+            inFlightDrain = null;
+            clearHelperFailureState();
+        },
+        getDebugFailureStateForTest: () => {
+            return {
+                helperFailureState: cloneHelperFailureState(helperFailureState),
+                retainedFailureObjectCount: retainedHelperFailureObjects.size,
+            };
+        },
+    };
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "opencode-oncall",
+  "version": "0.1.0",
+  "description": "Remote on-call UX plugin for OpenCode over WeChat",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "type": "module",
+  "license": "MPL-2.0",
+  "author": "jiwangyihao",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiwangyihao/opencode-oncall.git"
+  },
+  "homepage": "https://github.com/jiwangyihao/opencode-oncall#readme",
+  "bugs": {
+    "url": "https://github.com/jiwangyihao/opencode-oncall/issues"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "oncall",
+    "wechat",
+    "remote-control"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prebuild": "node scripts/clean-dist.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "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:wechat-real-host-gate": "npm run build && node --test test/wechat-opencode-real-host-gate.test.js",
+    "test:serial:wechat-status-flow:early": "node scripts/run-status-flow-phase.mjs early",
+    "test:serial:wechat-ws-core": "node --test --test-concurrency=1 test/wechat-ws-protocol.test.js test/wechat-broker-state-store.test.js test/wechat-broker-ws-lifecycle.test.js",
+    "test:serial:wechat-broker-lifecycle": "node --test --test-concurrency=1 test/wechat-broker-lifecycle.test.js",
+    "test:serial:wechat-notification-flow": "node --test --test-concurrency=1 test/wechat-notification-flow.test.js test/wechat-notification-dispatcher.test.js test/wechat-notification-store.test.js",
+    "test:serial:wechat-openclaw-task3": "node --test --test-concurrency=1 test/wechat-openclaw-task3.test.js",
+    "test:serial:plugin": "node --test --test-concurrency=1 test/index-exports.test.js test/wechat-plugin-entry.test.js test/wechat-plugin-hooks-status.test.js",
+    "test:serial:wechat-status-flow:late": "node scripts/run-status-flow-phase.mjs late",
+    "test:parallel:shard": "node --test test/package-boundary.test.js test/wechat-bind-flow.test.js test/wechat-debug-bundle.test.js test/wechat-dead-letter-store.test.js test/wechat-jiti-loader.test.js test/wechat-menu-actions.test.js test/wechat-migration.test.js test/wechat-openclaw-account-helpers.test.js test/wechat-openclaw-guided-smoke.test.js test/wechat-openclaw-public-helpers.test.js test/wechat-openclaw-qr-gateway.test.js test/wechat-openclaw-smoke.test.js test/wechat-openclaw-sync-buf.test.js test/wechat-openclaw-updates-send.test.js test/wechat-operator-store.test.js test/wechat-plugin-hooks-status.test.js test/wechat-qrcode-terminal-loader.test.js test/wechat-request-store.test.js test/wechat-session-digest.test.js test/wechat-state-paths.test.js test/wechat-state-root.test.js test/wechat-surface-driver.test.js test/wechat-token-store-atomic-write.test.js test/wechat-token-store.test.js",
+    "test": "npm run build && npm run test:serial:wechat-status-flow:early && npm run test:serial:wechat-ws-core && npm run test:serial:wechat-broker-lifecycle && npm run test:serial:wechat-notification-flow && npm run test:serial:wechat-openclaw-task3 && npm run test:serial:plugin && npm run test:serial:wechat-status-flow:late && npm run test:parallel:shard",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.2.26",
+    "@opencode-ai/sdk": "^1.2.26",
+    "@tencent-weixin/openclaw-weixin": "2.0.1",
+    "fflate": "^0.8.2",
+    "openclaw": "2026.3.22",
+    "xdg-basedir": "^5.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.0.0"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  }
+}