opencode-oncall 0.1.0

package/dist/wechat/question-interaction.js

@@ -0,0 +1,180 @@
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function normalizeQuestionPromptSummary(input) {
+    const record = input;
+    const mode = record.mode === "multiple" ? "multiple" : record.mode === "single" ? "single" : record.mode === "text" ? "text" : undefined;
+    if (!mode) {
+        throw new Error("invalid request prompt format");
+    }
+    const options = Array.isArray(record.options)
+        ? record.options.map((option) => {
+            const item = option;
+            if (!isFiniteNumber(item.index) || !isNonEmptyString(item.label) || !isNonEmptyString(item.value)) {
+                throw new Error("invalid request prompt format");
+            }
+            return {
+                index: item.index,
+                label: item.label,
+                value: item.value,
+                ...(isNonEmptyString(item.description) ? { description: item.description.trim() } : {}),
+            };
+        })
+        : undefined;
+    return {
+        ...(isNonEmptyString(record.title) ? { title: record.title.trim() } : {}),
+        ...(isNonEmptyString(record.body) ? { body: record.body.trim() } : {}),
+        mode,
+        ...(record.custom === true ? { custom: true } : {}),
+        ...(options && options.length > 0 ? { options } : {}),
+    };
+}
+function normalizePermissionPromptSummary(input) {
+    const record = input;
+    return {
+        ...(isNonEmptyString(record.title) ? { title: record.title.trim() } : {}),
+        ...(isNonEmptyString(record.type) ? { type: record.type.trim() } : {}),
+        ...(isNonEmptyString(record.description) ? { description: record.description.trim() } : {}),
+    };
+}
+export function normalizeRequestPromptSummary(kind, input) {
+    if (input === undefined) {
+        return undefined;
+    }
+    return kind === "question" ? normalizeQuestionPromptSummary(input) : normalizePermissionPromptSummary(input);
+}
+export function extractQuestionPromptSummary(question) {
+    const first = Array.isArray(question.questions) ? question.questions[0] : undefined;
+    if (!first) {
+        return undefined;
+    }
+    const mode = first.multiple === true ? "multiple" : Array.isArray(first.options) && first.options.length > 0 ? "single" : "text";
+    const options = Array.isArray(first.options)
+        ? first.options
+            .filter((option) => isNonEmptyString(option?.label))
+            .map((option, index) => ({
+            index: index + 1,
+            label: option.label.trim(),
+            value: option.label.trim(),
+            ...(isNonEmptyString(option?.description) ? { description: option.description.trim() } : {}),
+        }))
+        : undefined;
+    return normalizeQuestionPromptSummary({
+        title: isNonEmptyString(first.header) ? first.header : undefined,
+        body: isNonEmptyString(first.question) ? first.question : undefined,
+        mode,
+        custom: first.custom !== false,
+        options,
+    });
+}
+export function extractPermissionPromptSummary(permission) {
+    const metadata = typeof permission.metadata === "object" && permission.metadata !== null
+        ? permission.metadata
+        : {};
+    const type = isNonEmptyString(metadata.type) ? metadata.type : undefined;
+    const description = Array.isArray(permission.patterns) && permission.patterns.length > 0
+        ? permission.patterns.join(", ")
+        : undefined;
+    return normalizePermissionPromptSummary({
+        title: isNonEmptyString(permission.permission) ? permission.permission : undefined,
+        type,
+        description,
+    });
+}
+function findOptionValue(options, token) {
+    const index = Number(token);
+    if (!Number.isInteger(index)) {
+        throw new Error("回复格式无效，请按题目提示填写选项编号");
+    }
+    const match = options.find((option) => option.index === index);
+    if (!match) {
+        throw new Error(`选项编号超出范围：${token}`);
+    }
+    return match.value;
+}
+function splitMultipleChoiceTokens(raw) {
+    return raw.split(",").map((token) => token.trim()).filter(Boolean);
+}
+function maybeParseMultipleChoiceValues(raw, options) {
+    if (options.length === 0) {
+        return undefined;
+    }
+    const tokens = splitMultipleChoiceTokens(raw);
+    if (tokens.length === 0 || tokens.some((token) => !/^\d+$/.test(token))) {
+        return undefined;
+    }
+    return parseMultipleChoiceValues(raw, options, true);
+}
+function parseMultipleChoiceValues(raw, options, allowCustom) {
+    const tokens = splitMultipleChoiceTokens(raw);
+    if (tokens.length === 0) {
+        throw new Error("多选题请使用逗号分隔的选项编号");
+    }
+    const seen = new Set();
+    const values = [];
+    for (const token of tokens) {
+        if (!/^\d+$/.test(token)) {
+            throw new Error(allowCustom === true
+                ? "多选题请使用逗号分隔的选项编号，或直接输入自定义回答"
+                : "该问题不支持自定义回复，请按题目提示填写选项编号");
+        }
+        if (seen.has(token)) {
+            throw new Error(`选项编号不能重复：${token}`);
+        }
+        seen.add(token);
+        values.push(findOptionValue(options, token));
+    }
+    return values;
+}
+export function buildQuestionAnswersFromReply(prompt, rawText) {
+    const text = rawText.trim();
+    if (!text) {
+        throw new Error("回复内容不能为空");
+    }
+    if (!prompt) {
+        return [[text]];
+    }
+    const separatorIndex = text.indexOf(";");
+    const left = separatorIndex >= 0 ? text.slice(0, separatorIndex).trim() : "";
+    const right = separatorIndex >= 0 ? text.slice(separatorIndex + 1).trim() : "";
+    const options = prompt.options ?? [];
+    const mixedChoiceValues = separatorIndex >= 0 ? maybeParseMultipleChoiceValues(left, options) : undefined;
+    if (mixedChoiceValues) {
+        if (prompt.mode !== "multiple" || prompt.custom !== true) {
+            throw new Error("当前题型不支持“编号 + 自定义补充”，请按题目提示回复");
+        }
+        const customText = right.replace(/^其他：\s*/u, "").trim();
+        if (!customText) {
+            throw new Error("混合回复格式无效，请使用“编号; 自定义补充”");
+        }
+        return [[...mixedChoiceValues, customText]];
+    }
+    if (prompt.mode === "text") {
+        return [[text]];
+    }
+    if (options.length === 0) {
+        return [[text]];
+    }
+    if (prompt.mode === "single") {
+        if (prompt.custom === true && !/^\d+$/.test(text)) {
+            return [[text]];
+        }
+        if (!/^\d+$/.test(text)) {
+            throw new Error(prompt.custom === true
+                ? "单选题请回复单个选项编号，或直接输入自定义回答"
+                : "该问题不支持自定义回复，请按题目提示填写选项编号");
+        }
+        return [[findOptionValue(options, text)]];
+    }
+    if (prompt.custom === true) {
+        const choiceValues = maybeParseMultipleChoiceValues(text, options);
+        if (!choiceValues) {
+            return [[text]];
+        }
+        return [choiceValues];
+    }
+    return [parseMultipleChoiceValues(text, options, false)];
+}

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

@@ -0,0 +1,108 @@
+import { type WechatRequestKind } from "./state-paths.js";
+import { type RequestPromptSummary } from "./question-interaction.js";
+export type RequestStatus = "open" | "answered" | "rejected" | "expired" | "cleaned";
+export type RequestTerminalReason = "answered" | "handled" | "rejected" | "expired" | "replaced";
+export type RequestRecord = {
+    kind: WechatRequestKind;
+    requestID: string;
+    routeKey: string;
+    handle: string;
+    scopeKey?: string;
+    prompt?: RequestPromptSummary;
+    wechatAccountId: string;
+    userId: string;
+    status: RequestStatus;
+    createdAt: number;
+    answeredAt?: number;
+    rejectedAt?: number;
+    expiredAt?: number;
+    cleanedAt?: number;
+    terminalReason?: RequestTerminalReason;
+    replacementHandle?: string;
+    terminalResultSent?: boolean;
+};
+export declare function upsertRequest(input: Omit<RequestRecord, "status" | "answeredAt" | "rejectedAt" | "expiredAt" | "cleanedAt">): Promise<RequestRecord>;
+export declare function expireOpenRequestsForScope(input: {
+    scopeKey: string;
+    expiredAt: number;
+}): Promise<RequestRecord[]>;
+export declare function markRequestAnswered(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    answeredAt: number;
+}): Promise<RequestRecord>;
+export declare function markRequestRejected(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    rejectedAt: number;
+}): Promise<RequestRecord>;
+export declare function markRequestExpired(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    expiredAt: number;
+}): Promise<RequestRecord>;
+export type PreparedRecoveryRequestReopen = {
+    originalRequest: RequestRecord;
+    nextHandle: string;
+    nextRouteKey: string;
+};
+export declare function allocateFreshRecoveryHandle(input: {
+    kind: WechatRequestKind;
+    bannedHandles?: string[];
+}): Promise<string>;
+export declare function prepareRecoveryRequestReopen(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    recoveredAt: number;
+    bannedHandles?: string[];
+}): Promise<PreparedRecoveryRequestReopen>;
+export declare function commitPreparedRecoveryRequestReopen(prepared: PreparedRecoveryRequestReopen): Promise<RequestRecord>;
+export declare function rollbackPreparedRecoveryRequestReopen(prepared: PreparedRecoveryRequestReopen): Promise<void>;
+export declare function recoverRequestFromDeadLetter(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    recoveredAt: number;
+    excludedHandles?: string[];
+}): Promise<RequestRecord>;
+export declare function markCleaned(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    cleanedAt: number;
+}): Promise<RequestRecord>;
+export declare function purgeCleanedBefore(input: {
+    cutoffAt: number;
+}): Promise<number>;
+export declare function purgeCleanedRequestsBefore(input: {
+    cutoffAt: number;
+}): Promise<RequestRecord[]>;
+export declare function listActiveRequests(): Promise<RequestRecord[]>;
+export declare function findOpenRequestByHandle(input: {
+    kind: WechatRequestKind;
+    handle: string;
+}): Promise<RequestRecord | undefined>;
+export declare function findTerminalRequestByHandle(input: {
+    kind: WechatRequestKind;
+    handle: string;
+}): Promise<RequestRecord | undefined>;
+export declare function findOpenRequestByIdentity(input: {
+    kind: WechatRequestKind;
+    requestID: string;
+    wechatAccountId: string;
+    userId: string;
+    scopeKey?: string;
+}): Promise<RequestRecord | undefined>;
+export declare function findRequestByRouteKey(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+}): Promise<RequestRecord | undefined>;
+export declare function markTerminalMetadata(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    terminalReason: RequestTerminalReason;
+    replacementHandle?: string;
+}): Promise<RequestRecord>;
+export declare function markTerminalResultSent(input: {
+    kind: WechatRequestKind;
+    routeKey: string;
+    sentAt: number;
+}): Promise<RequestRecord>;