opencode-oncall 0.1.0

package/dist/wechat/latest-account-state-store.js

@@ -0,0 +1,38 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { ensureWechatStateLayout, latestAccountStatePath, WECHAT_FILE_MODE } from "./state-paths.js";
+function normalize(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const input = value;
+    const accountId = typeof input.accountId === "string" && input.accountId.trim().length > 0 ? input.accountId : null;
+    const token = typeof input.token === "string" && input.token.trim().length > 0 ? input.token : null;
+    const baseUrl = typeof input.baseUrl === "string" && input.baseUrl.trim().length > 0 ? input.baseUrl : null;
+    if (!accountId || !token || !baseUrl) {
+        return null;
+    }
+    return {
+        accountId,
+        token,
+        baseUrl,
+        ...(typeof input.getUpdatesBuf === "string" && input.getUpdatesBuf.trim().length > 0 ? { getUpdatesBuf: input.getUpdatesBuf } : {}),
+    };
+}
+export async function readWechatLatestAccountState() {
+    try {
+        const raw = await readFile(latestAccountStatePath(), "utf8");
+        return normalize(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeWechatLatestAccountState(input) {
+    await ensureWechatStateLayout();
+    const normalized = normalize(input);
+    if (!normalized) {
+        throw new Error("invalid latest account state");
+    }
+    await writeFile(latestAccountStatePath(), `${JSON.stringify(normalized, null, 2)}\n`, { encoding: "utf8", mode: WECHAT_FILE_MODE });
+    return normalized;
+}

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

@@ -0,0 +1,34 @@
+import { listPendingNotifications, markNotificationFailed, markNotificationResolved, markNotificationSent, purgeTerminalNotificationsBefore } from "./notification-store.js";
+import type { NotificationKind, NotificationRecord } from "./notification-types.js";
+export type WechatNotificationSendInput = {
+    to: string;
+    text: string;
+    contextToken?: string;
+};
+export type WechatNotificationDeliveryFailureInput = {
+    kind: NotificationKind;
+    requestKind?: NotificationRecord["requestKind"];
+    routeKey?: string;
+    scopeKey?: string;
+    wechatAccountId: string;
+    userId: string;
+    registrationEpoch?: string;
+};
+type NotificationStateOps = {
+    listPendingNotifications: typeof listPendingNotifications;
+    markNotificationResolved: typeof markNotificationResolved;
+    markNotificationFailed: typeof markNotificationFailed;
+    markNotificationSent: typeof markNotificationSent;
+    purgeTerminalNotificationsBefore: typeof purgeTerminalNotificationsBefore;
+};
+type CreateWechatNotificationDispatcherInput = {
+    sendMessage: (input: WechatNotificationSendInput) => Promise<unknown>;
+    onDeliveryFailed?: (input: WechatNotificationDeliveryFailureInput) => Promise<void> | void;
+    notificationStateOps?: Partial<NotificationStateOps>;
+};
+type WechatNotificationDispatcher = {
+    drainOutboundMessages: () => Promise<void>;
+};
+export declare function suppressPreparedPendingNotifications(records: NotificationRecord[]): Promise<void>;
+export declare function createWechatNotificationDispatcher(input: CreateWechatNotificationDispatcherInput): WechatNotificationDispatcher;
+export {};

package/dist/wechat/notification-dispatcher.js

@@ -0,0 +1,266 @@
+import { readWechatSettingsStore } from "../settings-store.js";
+import { loadBrokerStateStoreSnapshot, readBrokerDeliveryToken, readBrokerIndexedRequest, } from "./broker-state-store.js";
+import { formatWechatNotificationText } from "./notification-format.js";
+import { listPendingNotifications, markNotificationFailed, markNotificationResolved, markNotificationSent, purgeTerminalNotificationsBefore, } from "./notification-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 shouldSendRecord(record, notifications) {
+    if (!notifications.enabled) {
+        return false;
+    }
+    if (record.kind === "question") {
+        return notifications.question;
+    }
+    if (record.kind === "permission") {
+        return notifications.permission;
+    }
+    if (record.kind === "requestTerminal") {
+        return record.requestKind === "permission"
+            ? notifications.permission
+            : notifications.question;
+    }
+    if (record.kind === "naturalStop") {
+        return notifications.sessionError;
+    }
+    if (record.kind === "sessionError" && record.source === "retryError") {
+        return notifications.retryError;
+    }
+    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") {
+        const tokenState = await readBrokerDeliveryToken({
+            wechatAccountId: record.wechatAccountId,
+            userId: record.userId,
+        }).catch(() => undefined);
+        return Boolean(tokenState &&
+            !tokenState.staleReason &&
+            tokenState.updatedAt > record.createdAt);
+    }
+    if (record.kind === "requestTerminal") {
+        return false;
+    }
+    if (record.kind === "naturalStop") {
+        if (typeof record.handle !== "string" ||
+            record.handle.trim().length === 0) {
+            return false;
+        }
+        const snapshot = await loadBrokerStateStoreSnapshot().catch(() => undefined);
+        if (!snapshot) {
+            return false;
+        }
+        const active = snapshot?.active?.naturalStops?.[record.handle];
+        if (!active || typeof active !== "object") {
+            return true;
+        }
+        if (typeof record.scopeKey === "string" &&
+            record.scopeKey.trim().length > 0) {
+            const activeScopeKey = active.scopeKey ??
+                active.instanceID;
+            return activeScopeKey !== record.scopeKey;
+        }
+        return false;
+    }
+    if (typeof record.routeKey !== "string" ||
+        record.routeKey.trim().length === 0) {
+        return false;
+    }
+    const request = await readBrokerIndexedRequest({
+        kind: record.kind,
+        routeKey: record.routeKey,
+    });
+    if (!request) {
+        return true;
+    }
+    return request.status !== "open";
+}
+function isNotFailWritableStateError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /not pending/i.test(error.message);
+}
+export async function suppressPreparedPendingNotifications(records) {
+    for (const record of records) {
+        try {
+            await markNotificationResolved({
+                idempotencyKey: record.idempotencyKey,
+                resolvedAt: Date.now(),
+                suppressed: true,
+            });
+        }
+        catch (error) {
+            if (!isNotSuppressibleStateError(error)) {
+                throw error;
+            }
+        }
+    }
+}
+export function createWechatNotificationDispatcher(input) {
+    const notificationStateOps = {
+        listPendingNotifications,
+        markNotificationResolved,
+        markNotificationFailed,
+        markNotificationSent,
+        purgeTerminalNotificationsBefore,
+        ...input.notificationStateOps,
+    };
+    const inFlightNotificationIds = new Set();
+    return {
+        drainOutboundMessages: async () => {
+            const retentionMs = toPositiveNumber(process.env.WECHAT_NOTIFICATION_TERMINAL_RETENTION_MS, DEFAULT_NOTIFICATION_TERMINAL_RETENTION_MS);
+            await notificationStateOps.purgeTerminalNotificationsBefore({
+                cutoffAt: Date.now() - retentionMs,
+            });
+            const settings = await readWechatSettingsStore();
+            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 notificationStateOps.listPendingNotifications();
+            for (const record of pending) {
+                if (inFlightNotificationIds.has(record.idempotencyKey)) {
+                    continue;
+                }
+                inFlightNotificationIds.add(record.idempotencyKey);
+                try {
+                    if (await shouldSuppressPendingNotification(record)) {
+                        try {
+                            await notificationStateOps.markNotificationResolved({
+                                idempotencyKey: record.idempotencyKey,
+                                resolvedAt: Date.now(),
+                                suppressed: true,
+                            });
+                        }
+                        catch (error) {
+                            if (!isNotSuppressibleStateError(error)) {
+                                throw error;
+                            }
+                        }
+                        continue;
+                    }
+                    if (!shouldSendRecord(record, notifications)) {
+                        continue;
+                    }
+                    if (record.userId !== targetUserId ||
+                        record.wechatAccountId !== targetAccountId) {
+                        continue;
+                    }
+                    const tokenState = await readBrokerDeliveryToken({
+                        wechatAccountId: record.wechatAccountId,
+                        userId: record.userId,
+                    }).catch(() => undefined);
+                    if (tokenState?.staleReason) {
+                        continue;
+                    }
+                    try {
+                        await input.sendMessage({
+                            to: targetUserId,
+                            text: formatWechatNotificationText(record),
+                            ...(tokenState && !tokenState.staleReason
+                                ? { contextToken: tokenState.contextToken }
+                                : {}),
+                        });
+                    }
+                    catch (error) {
+                        let markFailedError;
+                        let persistedFailed = false;
+                        try {
+                            await notificationStateOps.markNotificationFailed({
+                                idempotencyKey: record.idempotencyKey,
+                                failedAt: Date.now(),
+                                reason: toErrorMessage(error),
+                            });
+                            persistedFailed = true;
+                        }
+                        catch (markError) {
+                            if (!isNotFailWritableStateError(markError)) {
+                                markFailedError = markError;
+                            }
+                        }
+                        if (persistedFailed) {
+                            await input.onDeliveryFailed?.({
+                                kind: record.kind,
+                                requestKind: record.requestKind,
+                                routeKey: record.routeKey,
+                                scopeKey: record.scopeKey,
+                                wechatAccountId: record.wechatAccountId,
+                                userId: record.userId,
+                                registrationEpoch: record.registrationEpoch,
+                            });
+                        }
+                        if (markFailedError) {
+                            throw markFailedError;
+                        }
+                        continue;
+                    }
+                    try {
+                        await notificationStateOps.markNotificationSent({
+                            idempotencyKey: record.idempotencyKey,
+                            sentAt: Date.now(),
+                        });
+                    }
+                    catch (error) {
+                        if (!isNotPendingStateError(error)) {
+                            try {
+                                await notificationStateOps.markNotificationFailed({
+                                    idempotencyKey: record.idempotencyKey,
+                                    failedAt: Date.now(),
+                                    reason: `notification delivered but sent persistence failed: ${toErrorMessage(error)}`,
+                                });
+                            }
+                            catch (markFailedError) {
+                                if (!isNotFailWritableStateError(markFailedError)) {
+                                    throw markFailedError;
+                                }
+                            }
+                        }
+                    }
+                }
+                finally {
+                    inFlightNotificationIds.delete(record.idempotencyKey);
+                }
+            }
+        },
+    };
+}

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

@@ -0,0 +1,15 @@
+import type { NaturalStopTerminalReason, NotificationRecord } from "./notification-types.js";
+import type { BrokerLegacyHandleClosure } from "./broker-state-store.js";
+import type { RequestTerminalReason } from "./request-store.js";
+export declare function formatNaturalStopClosedText(input: {
+    handle?: string;
+    terminalReason?: NaturalStopTerminalReason;
+}): string;
+export declare function formatTerminalRequestClosedText(input: {
+    requestKind: "question" | "permission";
+    handle?: string;
+    terminalReason?: RequestTerminalReason;
+    replacementHandle?: string;
+}): string;
+export declare function formatBrokerLegacyHandleClosureText(input: Pick<BrokerLegacyHandleClosure, "kind" | "handle" | "reason" | "message" | "replacementHandle">): string;
+export declare function formatWechatNotificationText(record: NotificationRecord): string;

package/dist/wechat/notification-format.js

@@ -0,0 +1,196 @@
+function formatHandle(handle, fallback) {
+    if (typeof handle === "string" && handle.trim().length > 0) {
+        return handle;
+    }
+    return fallback;
+}
+function formatQuestionType(mode) {
+    if (mode === "multiple")
+        return "多选";
+    if (mode === "single")
+        return "单选";
+    return "文本";
+}
+function formatQuestionOptions(options = []) {
+    return options.flatMap((option) => [
+        `${option.index}. ${option.label}`,
+        ...(typeof option.description === "string" && option.description.trim().length > 0 ? [option.description.trim()] : []),
+    ]);
+}
+function formatQuestionReplyExamples(handle, mode, allowCustom) {
+    const examples = [];
+    if (mode === "single") {
+        examples.push(`/reply ${handle} 1`);
+    }
+    if (mode === "multiple") {
+        examples.push(`/reply ${handle} 1,2`);
+    }
+    if (mode === "text" || allowCustom) {
+        examples.push(`/reply ${handle} 你的自定义回答`);
+    }
+    if (mode === "multiple" && allowCustom) {
+        examples.push(`/reply ${handle} 1,3; 其他：先灰度再全量`);
+    }
+    return examples;
+}
+function formatPermissionReplySemantics() {
+    return [
+        "once：仅处理这一次",
+        "always：后续同类请求自动允许",
+        "reject：拒绝当前请求",
+    ];
+}
+function formatTerminalReasonLabel(reason) {
+    if (reason === "answered")
+        return "已在电脑端回复";
+    if (reason === "handled")
+        return "已在电脑端处理";
+    if (reason === "rejected")
+        return "已在电脑端拒绝";
+    if (reason === "expired")
+        return "已过期";
+    if (reason === "replaced")
+        return "已被新入口替代";
+    return "已结束";
+}
+function formatTerminalRefusalLabel(requestKind) {
+    return requestKind === "permission" ? "该入口不再接受权限处理。" : "该入口不再接受回复。";
+}
+function formatNaturalStopTerminalReasonLabel(reason) {
+    if (reason === "replied")
+        return "已在微信端补充回复";
+    if (reason === "continued")
+        return "已在电脑端继续处理";
+    if (reason === "expired")
+        return "已过期";
+    return "已结束";
+}
+function toRequestTerminalReason(reason) {
+    if (reason === "answered" || reason === "handled" || reason === "rejected" || reason === "expired" || reason === "replaced") {
+        return reason;
+    }
+    return undefined;
+}
+function toNaturalStopTerminalReason(reason) {
+    if (reason === "replied" || reason === "continued" || reason === "expired") {
+        return reason;
+    }
+    return undefined;
+}
+export function formatNaturalStopClosedText(input) {
+    const handle = formatHandle(input.handle, "s?");
+    return [
+        `中止通知 ${handle} 已结束`,
+        `原因：${formatNaturalStopTerminalReasonLabel(input.terminalReason)}`,
+        "说明：该入口不再接受回复。",
+    ].join("\n");
+}
+function formatSessionErrorText(record) {
+    if (typeof record.action !== "string"
+        || record.action.trim().length === 0
+        || typeof record.redactedSummary !== "string"
+        || record.redactedSummary.trim().length === 0
+        || typeof record.severityAdvice !== "string"
+        || record.severityAdvice.trim().length === 0) {
+        return "检测到会话异常（retry），请在 OpenCode 中检查并处理。";
+    }
+    return [
+        `检测到会话异常（${record.sessionID?.trim() || "session?"}）`,
+        `动作：${record.action.trim()}`,
+        `原因摘要：${record.redactedSummary.trim()}`,
+        `处理建议：${record.severityAdvice.trim()}`,
+    ].join("\n");
+}
+function formatNaturalStopText(record) {
+    if (record.naturalStopTerminalReason) {
+        return formatNaturalStopClosedText({
+            handle: record.handle,
+            terminalReason: record.naturalStopTerminalReason,
+        });
+    }
+    const handle = formatHandle(record.handle, "s?");
+    return [
+        `会话已自然中止（${handle}）`,
+        `原因摘要：${record.redactedSummary?.trim() || "原因摘要不可安全展示"}`,
+        `处理建议：${record.severityAdvice?.trim() || "已停止并等待你的回复"}`,
+        `/reply ${handle} 你的补充内容`,
+        "发送后会把补充说明回到当前会话。",
+    ].join("\n");
+}
+export function formatTerminalRequestClosedText(input) {
+    const handle = formatHandle(input.handle, input.requestKind === "permission" ? "p?" : "q?");
+    const lines = [
+        `${input.requestKind === "permission" ? "权限" : "问题"}入口 ${handle} 已结束`,
+        `原因：${formatTerminalReasonLabel(input.terminalReason)}`,
+        `说明：${formatTerminalRefusalLabel(input.requestKind)}`,
+        ...(input.terminalReason === "replaced" && typeof input.replacementHandle === "string" && input.replacementHandle.trim().length > 0
+            ? [`请改用新入口：${input.replacementHandle.trim()}`]
+            : []),
+    ];
+    return lines.join("\n");
+}
+export function formatBrokerLegacyHandleClosureText(input) {
+    if (typeof input.message === "string" && input.message.trim().length > 0) {
+        return input.message.trim();
+    }
+    if (input.kind === "naturalStop") {
+        return formatNaturalStopClosedText({
+            handle: input.handle,
+            terminalReason: toNaturalStopTerminalReason(input.reason),
+        });
+    }
+    return formatTerminalRequestClosedText({
+        requestKind: input.kind,
+        handle: input.handle,
+        terminalReason: toRequestTerminalReason(input.reason),
+        replacementHandle: input.replacementHandle,
+    });
+}
+export function formatWechatNotificationText(record) {
+    if (record.kind === "question") {
+        const handle = formatHandle(record.handle, "q?");
+        const prompt = record.prompt;
+        if (prompt && "mode" in prompt) {
+            const lines = [
+                `收到新的问题请求（${handle}）`,
+                prompt.title ?? prompt.body ?? "请在 OpenCode 中处理该问题。",
+                prompt.body && prompt.title ? prompt.body : undefined,
+                `类型：${formatQuestionType(prompt.mode)}`,
+                ...formatQuestionOptions(prompt.options),
+                ...formatQuestionReplyExamples(handle, prompt.mode, prompt.custom === true),
+            ].filter(Boolean);
+            return lines.join("\n");
+        }
+        return `收到新的问题请求（${handle}），请在 OpenCode 中处理。`;
+    }
+    if (record.kind === "permission") {
+        const handle = formatHandle(record.handle, "p?");
+        const prompt = record.prompt;
+        if (prompt && !('mode' in prompt)) {
+            const lines = [
+                `收到新的权限请求（${handle}）`,
+                prompt.title ?? "请在 OpenCode 中处理该权限请求。",
+                `类型：${prompt.type ?? "unknown"}`,
+                prompt.description,
+                `/allow ${handle} once`,
+                `/allow ${handle} always`,
+                `/allow ${handle} reject`,
+                ...formatPermissionReplySemantics(),
+            ].filter(Boolean);
+            return lines.join("\n");
+        }
+        return `收到新的权限请求（${handle}），请在 OpenCode 中处理。`;
+    }
+    if (record.kind === "requestTerminal") {
+        return formatTerminalRequestClosedText({
+            requestKind: record.requestKind === "permission" ? "permission" : "question",
+            handle: record.handle,
+            terminalReason: record.terminalReason,
+            replacementHandle: record.replacementHandle,
+        });
+    }
+    if (record.kind === "naturalStop") {
+        return formatNaturalStopText(record);
+    }
+    return formatSessionErrorText(record);
+}

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

@@ -0,0 +1,72 @@
+import type { NaturalStopTerminalReason, NotificationRecord, SessionReplyTarget } from "./notification-types.js";
+type NotificationStoreTestHooks = {
+    beforePersistBackfilledScopeKey?: (input: {
+        record: NotificationRecord;
+        scopeKey: string;
+    }) => Promise<void> | void;
+    afterWriteNotification?: (record: NotificationRecord) => Promise<void> | void;
+};
+export declare function setNotificationStoreTestHooks(hooks: NotificationStoreTestHooks | undefined): void;
+export declare function upsertNotification(input: Omit<NotificationRecord, "status" | "sentAt" | "resolvedAt" | "failedAt" | "suppressedAt" | "failureReason">, options?: {
+    initialStatus?: "pending" | "suppressed";
+    suppressedAt?: number;
+}): 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 findMergeableNotification(input: {
+    kind: "question" | "permission";
+    routeKey: string;
+    handle: string;
+    scopeKey: string;
+    createdAt: number;
+    excludeIdempotencyKey?: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function findSentNotificationByRequest(input: {
+    kind: "question" | "permission";
+    routeKey: string;
+    handle: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function listActiveNaturalStops(input?: {
+    wechatAccountId?: string;
+    userId?: string;
+    scopeKey?: string;
+}): Promise<NotificationRecord[]>;
+export declare function listRetainedNaturalStopHandles(): Promise<string[]>;
+export declare function findActiveNaturalStopByReplyTarget(input: {
+    replyTarget: SessionReplyTarget;
+    wechatAccountId?: string;
+    userId?: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function findActiveNaturalStopByHandle(input: {
+    handle: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function findTerminalNaturalStopByHandle(input: {
+    handle: string;
+}): Promise<NotificationRecord | undefined>;
+export declare function listActiveNaturalStopsForScope(input: {
+    scopeKey: string;
+    wechatAccountId?: string;
+    userId?: string;
+}): Promise<NotificationRecord[]>;
+export declare function markNaturalStopTerminal(input: {
+    idempotencyKey: string;
+    resolvedAt: number;
+    terminalReason: NaturalStopTerminalReason;
+}): Promise<NotificationRecord>;
+export declare function purgeTerminalNotificationsBefore(input: {
+    cutoffAt: number;
+}): Promise<number>;
+export {};