opencode-oncall 0.1.0

package/dist/wechat/token-store.js

@@ -0,0 +1,193 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { WECHAT_FILE_MODE, ensureWechatStateLayout, tokenStatePath } from "./state-paths.js";
+import { loadBrokerStateStoreForMutation, persistBrokerStateStoreSnapshot, readBrokerDeliveryToken, upsertBrokerDeliveryToken, } from "./broker-state-store.js";
+export const NOTIFICATION_DELIVERY_FAILED_STALE_REASON = "notification-delivery-failed";
+const SYNTHETIC_STALE_TOKEN_SOURCE_REF_PREFIX = "synthetic-stale";
+const TOKEN_REPLACE_MAX_ATTEMPTS = 5;
+const TOKEN_REPLACE_RETRY_DELAY_MS = 10;
+function isSafeTokenKeyPart(value) {
+    if (typeof value !== "string")
+        return false;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return false;
+    return !trimmed.includes("/") && !trimmed.includes("\\") && !trimmed.includes("..");
+}
+function toTokenKey(input) {
+    if (!isSafeTokenKeyPart(input.wechatAccountId) || !isSafeTokenKeyPart(input.userId)) {
+        throw new Error("invalid token state format");
+    }
+    return {
+        wechatAccountId: input.wechatAccountId,
+        userId: input.userId,
+    };
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function normalizeTokenState(input) {
+    return {
+        contextToken: input.contextToken,
+        updatedAt: input.updatedAt,
+        source: input.source,
+        ...(input.sourceRef ? { sourceRef: input.sourceRef } : {}),
+        ...(input.staleReason ? { staleReason: input.staleReason } : {}),
+    };
+}
+function isTokenSource(value) {
+    return value === "question" || value === "permission" || value === "message";
+}
+function isRetryableTokenReplaceError(error) {
+    const issue = error;
+    return issue?.code === "EPERM" || issue?.code === "EBUSY";
+}
+function delay(ms) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function replaceTokenStateFile(tempPath, filePath) {
+    let lastError = undefined;
+    for (let attempt = 0; attempt < TOKEN_REPLACE_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            await rename(tempPath, filePath);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === TOKEN_REPLACE_MAX_ATTEMPTS - 1 || !isRetryableTokenReplaceError(error)) {
+                throw error;
+            }
+            await delay(TOKEN_REPLACE_RETRY_DELAY_MS);
+        }
+    }
+    if (lastError)
+        throw lastError;
+}
+function createSyntheticStaleTokenState(input) {
+    return {
+        contextToken: `stale-placeholder:${input.wechatAccountId}:${input.userId}`,
+        updatedAt: Date.now(),
+        source: "question",
+        sourceRef: `${SYNTHETIC_STALE_TOKEN_SOURCE_REF_PREFIX}:${input.staleReason}`,
+        staleReason: input.staleReason,
+    };
+}
+function toTokenState(input) {
+    const parsed = input;
+    if (!parsed ||
+        !isNonEmptyString(parsed.contextToken) ||
+        !isFiniteNumber(parsed.updatedAt) ||
+        !isTokenSource(parsed.source)) {
+        throw new Error("invalid token state format");
+    }
+    if ((parsed.sourceRef !== undefined && !isNonEmptyString(parsed.sourceRef)) ||
+        (parsed.staleReason !== undefined && !isNonEmptyString(parsed.staleReason))) {
+        throw new Error("invalid token state format");
+    }
+    return normalizeTokenState(parsed);
+}
+async function writeTokenState(key, state) {
+    const safeKey = toTokenKey(key);
+    await ensureWechatStateLayout();
+    const filePath = tokenStatePath(safeKey.wechatAccountId, safeKey.userId);
+    const dirPath = path.dirname(filePath);
+    const tempPath = path.join(dirPath, `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+    const serializedState = JSON.stringify(normalizeTokenState(state), null, 2);
+    await mkdir(dirPath, { recursive: true });
+    try {
+        await writeFile(tempPath, serializedState, { mode: WECHAT_FILE_MODE });
+        await replaceTokenStateFile(tempPath, filePath);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true }).catch(() => { });
+        throw error;
+    }
+    const normalized = normalizeTokenState(state);
+    const brokerState = await loadBrokerStateStoreForMutation();
+    upsertBrokerDeliveryToken(brokerState, {
+        ...safeKey,
+        ...normalized,
+    });
+    await persistBrokerStateStoreSnapshot(brokerState);
+    return normalized;
+}
+async function readPersistedTokenStateFile(wechatAccountId, userId) {
+    try {
+        const safeKey = toTokenKey({ wechatAccountId, userId });
+        const raw = await readFile(tokenStatePath(safeKey.wechatAccountId, safeKey.userId), "utf8");
+        return toTokenState(JSON.parse(raw));
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code === "ENOENT")
+            return undefined;
+        if (error instanceof Error && error.message === "invalid token state format")
+            throw error;
+        throw new Error("invalid token state format");
+    }
+}
+export async function readTokenState(wechatAccountId, userId) {
+    const brokerToken = await readBrokerDeliveryToken({ wechatAccountId, userId });
+    if (brokerToken) {
+        return normalizeTokenState({
+            contextToken: brokerToken.contextToken,
+            updatedAt: brokerToken.updatedAt,
+            source: brokerToken.source,
+            sourceRef: brokerToken.sourceRef,
+            staleReason: brokerToken.staleReason,
+        });
+    }
+    const persisted = await readPersistedTokenStateFile(wechatAccountId, userId);
+    if (persisted) {
+        return undefined;
+    }
+    return undefined;
+}
+export function isLiveTokenState(state) {
+    return Boolean(state && !state.staleReason);
+}
+export async function upsertInboundToken(input) {
+    const safeKey = toTokenKey(input);
+    const next = toTokenState({
+        contextToken: input.contextToken,
+        updatedAt: input.updatedAt,
+        source: input.source,
+        sourceRef: input.sourceRef,
+        staleReason: input.staleReason,
+    });
+    return writeTokenState(safeKey, next);
+}
+export async function markTokenStale(input) {
+    const safeKey = toTokenKey(input);
+    if (!isNonEmptyString(input.staleReason)) {
+        throw new Error("invalid token state format");
+    }
+    let current;
+    try {
+        current = await readTokenState(safeKey.wechatAccountId, safeKey.userId);
+        if (!current) {
+            current = await readPersistedTokenStateFile(safeKey.wechatAccountId, safeKey.userId);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "invalid token state format") {
+            current = undefined;
+        }
+        else {
+            throw error;
+        }
+    }
+    return writeTokenState(safeKey, {
+        ...(current ?? createSyntheticStaleTokenState({
+            ...safeKey,
+            staleReason: input.staleReason,
+        })),
+        staleReason: input.staleReason,
+    });
+}

package/dist/wechat/wechat-status-runtime.d.ts

@@ -0,0 +1,89 @@
+import { type OpenClawWeixinPublicHelpers, type OpenClawWeixinPublicHelpersLoaderOptions, type PublicWeixinMessage } from "./compat/openclaw-public-helpers.js";
+import { type WechatSlashCommand } from "./command-parser.js";
+export declare const DEFAULT_NON_SLASH_REPLY_TEXT = "PoC \u5F53\u524D\u4EC5\u652F\u6301\u547D\u4EE4\u578B\u4EA4\u4E92\uFF0C\u8BF7\u4F7F\u7528 slash \u547D\u4EE4\uFF08/status\u3001/reply\u3001/allow\uFF09";
+export declare const DEFAULT_SLASH_HANDLER_ERROR_REPLY_TEXT = "\u547D\u4EE4\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+type RuntimeErrorStage = "loadPublicHelpers" | "getUpdates" | "persistGetUpdatesBuf" | "drainOutboundMessages" | "sendReplyMessage";
+type HelperFailureRetryState = "backing-off";
+type HelperFailureState = {
+    stage: "loadPublicHelpers";
+    consecutiveFailures: number;
+    currentBackoffMs: number;
+    retryState: HelperFailureRetryState;
+    reachedGetUpdates: false;
+    lastFailureAtMs: number;
+    nextRetryAtMs: number;
+};
+type LoadPublicHelpersRuntimeErrorDiagnostic = {
+    type: "runtimeError";
+    stage: "loadPublicHelpers";
+    error: string;
+    consecutiveFailures: number;
+    backoffMs: number;
+    retryState: HelperFailureRetryState;
+    reachedGetUpdates: false;
+};
+type ReachedGetUpdatesRuntimeErrorDiagnostic = {
+    type: "runtimeError";
+    stage: Exclude<RuntimeErrorStage, "loadPublicHelpers">;
+    error: string;
+    reachedGetUpdates: true;
+};
+type PublicHelpersForRuntime = Pick<OpenClawWeixinPublicHelpers, "latestAccountState" | "getUpdates" | "sendMessageWeixin" | "persistGetUpdatesBuf">;
+type SlashCommandHandlerInput = {
+    command: WechatSlashCommand;
+    text: string;
+    message: PublicWeixinMessage;
+};
+type RuntimeSendMessageInput = {
+    to: string;
+    text: string;
+    contextToken?: string;
+};
+type RuntimeDrainOutboundMessagesInput = {
+    sendMessage: (input: RuntimeSendMessageInput) => Promise<void>;
+};
+export type WechatStatusRuntimeDiagnosticEvent = LoadPublicHelpersRuntimeErrorDiagnostic | ReachedGetUpdatesRuntimeErrorDiagnostic | {
+    type: "messageSkipped";
+    reason: "missingFromUserId" | "missingText";
+    hasFromUserId: boolean;
+    hasText: boolean;
+} | {
+    type: "slashCommandRecognized";
+    command: WechatSlashCommand;
+    text: string;
+    to: string;
+} | {
+    type: "replySendFailed";
+    to: string;
+    error: string;
+    commandType: WechatSlashCommand["type"] | null;
+};
+type CreateWechatStatusRuntimeInput = {
+    loadPublicHelpers?: (options?: OpenClawWeixinPublicHelpersLoaderOptions) => Promise<PublicHelpersForRuntime>;
+    publicHelpersOptions?: OpenClawWeixinPublicHelpersLoaderOptions;
+    onSlashCommand?: (input: SlashCommandHandlerInput) => Promise<string>;
+    onRuntimeError?: (error: unknown) => void;
+    onDiagnosticEvent?: (event: WechatStatusRuntimeDiagnosticEvent) => void | Promise<void>;
+    drainOutboundMessages?: (input: RuntimeDrainOutboundMessagesInput) => Promise<void>;
+    retryDelayMs?: number;
+    longPollTimeoutMs?: number;
+    now?: () => number;
+    sleepImpl?: (ms: number, signal: AbortSignal) => Promise<void>;
+    onFailureStateChange?: (state: HelperFailureState | null) => void | Promise<void>;
+    shouldReloadState?: (state: {
+        accountId: string;
+        baseUrl: string;
+        token: string;
+        getUpdatesBuf: string;
+    }) => boolean;
+};
+export type WechatStatusRuntime = {
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+    getDebugFailureStateForTest: () => {
+        helperFailureState: HelperFailureState | null;
+        retainedFailureObjectCount: number;
+    };
+};
+export declare function createWechatStatusRuntime(input?: CreateWechatStatusRuntimeInput): WechatStatusRuntime;
+export {};