opencode-oncall 0.1.0

package/dist/wechat/compat/slash-guard.d.ts

@@ -0,0 +1,11 @@
+export declare const STAGE_A_SLASH_ONLY_MESSAGE = "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 type SlashOnlyCommand = "status" | "reply" | "allow";
+export type SlashGuardResult = {
+    accepted: true;
+    command: SlashOnlyCommand;
+    argument: string;
+} | {
+    accepted: false;
+    message: string;
+};
+export declare function guardSlashOnlyInput(input: string): SlashGuardResult;

package/dist/wechat/compat/slash-guard.js

@@ -0,0 +1,24 @@
+export const STAGE_A_SLASH_ONLY_MESSAGE = "PoC 当前仅支持命令型交互，请使用 slash 命令（/status、/reply、/allow）";
+const ALLOWED_COMMANDS = new Set(["status", "reply", "allow"]);
+export function guardSlashOnlyInput(input) {
+    const normalized = input.trim();
+    if (!normalized.startsWith("/")) {
+        return {
+            accepted: false,
+            message: STAGE_A_SLASH_ONLY_MESSAGE,
+        };
+    }
+    const [commandSegment = "", ...rest] = normalized.slice(1).trim().split(/\s+/);
+    const command = commandSegment.toLowerCase();
+    if (!ALLOWED_COMMANDS.has(command)) {
+        return {
+            accepted: false,
+            message: STAGE_A_SLASH_ONLY_MESSAGE,
+        };
+    }
+    return {
+        accepted: true,
+        command,
+        argument: rest.join(" "),
+    };
+}

package/dist/wechat/dead-letter-store.d.ts

@@ -0,0 +1,48 @@
+import { type WechatRequestKind } from "./state-paths.js";
+export type WechatDeadLetterReason = "instanceStale" | "startupCleanup" | "runtimeCleanup" | "manualCleanup" | "futureRecoveryFailed";
+export type WechatDeadLetterRecoveryStatus = "recovered" | "failed";
+export type WechatDeadLetterRecord = {
+    kind: WechatRequestKind;
+    routeKey: string;
+    requestID: string;
+    handle: string;
+    scopeKey?: string;
+    finalStatus: "expired" | "cleaned";
+    reason: WechatDeadLetterReason;
+    createdAt: number;
+    finalizedAt: number;
+    wechatAccountId?: string;
+    userId?: string;
+    instanceID?: string;
+    sessionID?: string;
+    recoveryStatus?: WechatDeadLetterRecoveryStatus;
+    recoveryErrorCode?: string;
+    recoveryErrorMessage?: string;
+    recoveryFailureToken?: string;
+    recoveredAt?: number;
+};
+export declare function writeDeadLetter(record: WechatDeadLetterRecord): Promise<WechatDeadLetterRecord>;
+export declare function readDeadLetter(kind: WechatRequestKind, routeKey: string): Promise<WechatDeadLetterRecord | null>;
+export declare function listDeadLetters(kind?: WechatRequestKind): Promise<WechatDeadLetterRecord[]>;
+export declare function listRecoverableDeadLetters(kind?: WechatRequestKind): Promise<WechatDeadLetterRecord[]>;
+export declare function listDeadLettersByHandle(handle: string, kind?: WechatRequestKind): Promise<WechatDeadLetterRecord[]>;
+export declare function listRecoverableDeadLettersByHandle(handle: string, kind?: WechatRequestKind): Promise<WechatDeadLetterRecord[]>;
+export declare function listRecoveryChainHandles(input: {
+    kind: WechatRequestKind;
+    requestID: string;
+    wechatAccountId?: string;
+    userId?: string;
+}): Promise<string[]>;
+export declare function markDeadLetterRecovered(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    recoveredAt: number;
+}): Promise<WechatDeadLetterRecord>;
+export declare function markDeadLetterRecoveryFailed(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    recoveryErrorCode: string;
+    recoveryErrorMessage: string;
+    recoveryFailureToken?: string;
+}): Promise<WechatDeadLetterRecord>;
+export declare function purgeDeadLettersBefore(cutoffAt: number): Promise<WechatDeadLetterRecord[]>;

package/dist/wechat/dead-letter-store.js

@@ -0,0 +1,224 @@
+import path from "node:path";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { ensureWechatStateLayout, WECHAT_FILE_MODE, wechatDeadLetterKindDir, wechatDeadLetterPath, } from "./state-paths.js";
+import { normalizeHandle } from "./handle.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isDeadLetterReason(value) {
+    return ["instanceStale", "startupCleanup", "runtimeCleanup", "manualCleanup", "futureRecoveryFailed"].includes(value);
+}
+function isDeadLetterRecoveryStatus(value) {
+    return value === "recovered" || value === "failed";
+}
+function assertValidRouteKey(routeKey) {
+    if (!/^[a-z0-9-]+$/.test(routeKey) || routeKey.includes("..")) {
+        throw new Error("invalid dead-letter record format");
+    }
+}
+function normalizeRecord(record) {
+    return {
+        kind: record.kind,
+        routeKey: record.routeKey,
+        requestID: record.requestID,
+        handle: record.handle,
+        ...(isNonEmptyString(record.scopeKey) ? { scopeKey: record.scopeKey } : {}),
+        finalStatus: record.finalStatus,
+        reason: record.reason,
+        createdAt: record.createdAt,
+        finalizedAt: record.finalizedAt,
+        ...(isNonEmptyString(record.wechatAccountId) ? { wechatAccountId: record.wechatAccountId } : {}),
+        ...(isNonEmptyString(record.userId) ? { userId: record.userId } : {}),
+        ...(isNonEmptyString(record.instanceID) ? { instanceID: record.instanceID } : {}),
+        ...(isNonEmptyString(record.sessionID) ? { sessionID: record.sessionID } : {}),
+        ...(isDeadLetterRecoveryStatus(record.recoveryStatus) ? { recoveryStatus: record.recoveryStatus } : {}),
+        ...(record.recoveryStatus === "failed" && isNonEmptyString(record.recoveryErrorCode)
+            ? { recoveryErrorCode: record.recoveryErrorCode }
+            : {}),
+        ...(record.recoveryStatus === "failed" && isNonEmptyString(record.recoveryErrorMessage)
+            ? { recoveryErrorMessage: record.recoveryErrorMessage }
+            : {}),
+        ...(record.recoveryStatus === "failed" && isNonEmptyString(record.recoveryFailureToken)
+            ? { recoveryFailureToken: record.recoveryFailureToken }
+            : {}),
+        ...(isFiniteNumber(record.recoveredAt) ? { recoveredAt: record.recoveredAt } : {}),
+    };
+}
+function toDeadLetterRecord(input) {
+    const parsed = input;
+    if (!parsed ||
+        (parsed.kind !== "question" && parsed.kind !== "permission") ||
+        !isNonEmptyString(parsed.routeKey) ||
+        !isNonEmptyString(parsed.requestID) ||
+        !isNonEmptyString(parsed.handle) ||
+        parsed.finalStatus !== "expired" && parsed.finalStatus !== "cleaned" ||
+        !isDeadLetterReason(parsed.reason) ||
+        !isFiniteNumber(parsed.createdAt) ||
+        !isFiniteNumber(parsed.finalizedAt) ||
+        (parsed.scopeKey !== undefined && !isNonEmptyString(parsed.scopeKey)) ||
+        (parsed.wechatAccountId !== undefined && !isNonEmptyString(parsed.wechatAccountId)) ||
+        (parsed.userId !== undefined && !isNonEmptyString(parsed.userId)) ||
+        (parsed.instanceID !== undefined && !isNonEmptyString(parsed.instanceID)) ||
+        (parsed.sessionID !== undefined && !isNonEmptyString(parsed.sessionID)) ||
+        (parsed.recoveryStatus !== undefined && !isDeadLetterRecoveryStatus(parsed.recoveryStatus)) ||
+        (parsed.recoveryErrorCode !== undefined && !isNonEmptyString(parsed.recoveryErrorCode)) ||
+        (parsed.recoveryErrorMessage !== undefined && !isNonEmptyString(parsed.recoveryErrorMessage)) ||
+        (parsed.recoveryFailureToken !== undefined && !isNonEmptyString(parsed.recoveryFailureToken)) ||
+        (parsed.recoveredAt !== undefined && !isFiniteNumber(parsed.recoveredAt))) {
+        throw new Error("invalid dead-letter record format");
+    }
+    assertValidRouteKey(parsed.routeKey);
+    return normalizeRecord(parsed);
+}
+async function readDeadLetterFile(kind, routeKey) {
+    try {
+        const raw = await readFile(wechatDeadLetterPath(kind, routeKey), "utf8");
+        const record = toDeadLetterRecord(JSON.parse(raw));
+        if (record.kind !== kind) {
+            throw new Error("invalid dead-letter record format");
+        }
+        return record;
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code === "ENOENT")
+            throw error;
+        if (error instanceof Error && error.message === "invalid dead-letter record format")
+            throw error;
+        throw new Error("invalid dead-letter record format");
+    }
+}
+export async function writeDeadLetter(record) {
+    await ensureWechatStateLayout();
+    const normalized = toDeadLetterRecord(record);
+    const filePath = wechatDeadLetterPath(normalized.kind, normalized.routeKey);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(normalized, null, 2), { mode: WECHAT_FILE_MODE });
+    return normalized;
+}
+export async function readDeadLetter(kind, routeKey) {
+    try {
+        return await readDeadLetterFile(kind, routeKey);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function listKind(kind) {
+    try {
+        const entries = await readdir(wechatDeadLetterKindDir(kind));
+        const records = await Promise.all(entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => {
+            const routeKey = entry.slice(0, -5);
+            return readDeadLetterFile(kind, routeKey);
+        }));
+        return records.sort((left, right) => left.finalizedAt - right.finalizedAt);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function listDeadLetters(kind) {
+    if (kind) {
+        return listKind(kind);
+    }
+    const all = await Promise.all([listKind("question"), listKind("permission")]);
+    return all.flat().sort((left, right) => left.finalizedAt - right.finalizedAt);
+}
+function isRecoverableRecord(record) {
+    return (record.reason === "instanceStale"
+        && record.recoveryStatus !== "recovered"
+        && isNonEmptyString(record.wechatAccountId)
+        && isNonEmptyString(record.userId));
+}
+function isRequestKind(value) {
+    return value === "question" || value === "permission";
+}
+export async function listRecoverableDeadLetters(kind) {
+    const all = await listDeadLetters(kind);
+    return all.filter(isRecoverableRecord);
+}
+export async function listDeadLettersByHandle(handle, kind) {
+    const normalizedHandle = normalizeHandle(handle);
+    const all = await listDeadLetters(kind);
+    return all.filter((record) => record.handle === normalizedHandle);
+}
+export async function listRecoverableDeadLettersByHandle(handle, kind) {
+    const normalizedHandle = normalizeHandle(handle);
+    const recoverable = await listRecoverableDeadLetters(kind);
+    return recoverable.filter((record) => record.handle === normalizedHandle);
+}
+export async function listRecoveryChainHandles(input) {
+    if (!isRequestKind(input.kind)
+        || !isNonEmptyString(input.requestID)
+        || (input.wechatAccountId !== undefined
+            && !isNonEmptyString(input.wechatAccountId))
+        || (input.userId !== undefined
+            && !isNonEmptyString(input.userId))) {
+        throw new Error("invalid dead-letter record format");
+    }
+    const all = await listDeadLetters(input.kind);
+    return all
+        .filter((record) => (record.requestID === input.requestID
+        && record.wechatAccountId === input.wechatAccountId
+        && record.userId === input.userId))
+        .map((record) => record.handle);
+}
+export async function markDeadLetterRecovered(input) {
+    if (!isFiniteNumber(input.recoveredAt)) {
+        throw new Error("invalid dead-letter record format");
+    }
+    const current = await readDeadLetterFile(input.kind, input.routeKey);
+    return writeDeadLetter({
+        ...current,
+        recoveryStatus: "recovered",
+        recoveryErrorCode: undefined,
+        recoveryErrorMessage: undefined,
+        recoveryFailureToken: undefined,
+        recoveredAt: input.recoveredAt,
+    });
+}
+export async function markDeadLetterRecoveryFailed(input) {
+    if (!isNonEmptyString(input.recoveryErrorCode)
+        || !isNonEmptyString(input.recoveryErrorMessage)
+        || (input.recoveryFailureToken !== undefined && !isNonEmptyString(input.recoveryFailureToken))) {
+        throw new Error("invalid dead-letter record format");
+    }
+    const current = await readDeadLetterFile(input.kind, input.routeKey);
+    if (current.recoveryStatus === "recovered") {
+        return current;
+    }
+    return writeDeadLetter({
+        ...current,
+        recoveryStatus: "failed",
+        recoveryErrorCode: input.recoveryErrorCode,
+        recoveryErrorMessage: input.recoveryErrorMessage,
+        recoveryFailureToken: input.recoveryFailureToken,
+        recoveredAt: undefined,
+    });
+}
+export async function purgeDeadLettersBefore(cutoffAt) {
+    if (!isFiniteNumber(cutoffAt)) {
+        throw new Error("invalid dead-letter record format");
+    }
+    const deleted = [];
+    for (const kind of ["question", "permission"]) {
+        const records = await listKind(kind);
+        for (const record of records) {
+            if (record.finalizedAt >= cutoffAt) {
+                continue;
+            }
+            await rm(wechatDeadLetterPath(kind, record.routeKey), { force: true });
+            deleted.push(record);
+        }
+    }
+    return deleted;
+}

package/dist/wechat/debug-bundle-collector.d.ts

@@ -0,0 +1,49 @@
+import { type WechatDebugBundleMode } from "./debug-bundle-redaction.js";
+type BundleCategory = "state" | "diagnostics" | "metadata";
+type BundleEntry = {
+    bundlePath: string;
+    category: BundleCategory;
+    content: Buffer;
+    redacted: boolean;
+    sourcePath: string | null;
+    redactedSourcePath?: string | null;
+};
+type BundleManifestEntry = Omit<BundleEntry, "content">;
+type MissingPathEntry = {
+    category: "state" | "diagnostics";
+    relativePath: string;
+};
+type SkippedBundleEntry = {
+    bundlePath: string;
+    category: "state" | "diagnostics";
+    reason: "file-too-large" | "token-temp-file" | "empty-token-file" | "file-disappeared" | "file-read-failed";
+    sourcePath: string | null;
+    redactedSourcePath?: string | null;
+};
+export type WechatDebugBundleManifest = {
+    schemaVersion: 1;
+    mode: WechatDebugBundleMode;
+    exportedAt: string;
+    stateRoot: string;
+    missingPaths: MissingPathEntry[];
+    skippedEntries: SkippedBundleEntry[];
+    entries: BundleManifestEntry[];
+};
+export type WechatDebugBundle = {
+    mode: WechatDebugBundleMode;
+    stateRoot: string;
+    entries: BundleEntry[];
+    manifest: WechatDebugBundleManifest;
+};
+export type CollectWechatDebugBundleOptions = {
+    mode: WechatDebugBundleMode;
+    stateRoot?: string;
+    now?: Date;
+    cwd?: string;
+    pluginVersion?: string;
+    gitHead?: string | null;
+    nodeVersion?: string;
+    platform?: string;
+};
+export declare function collectWechatDebugBundle(options: CollectWechatDebugBundleOptions): Promise<WechatDebugBundle>;
+export {};