opencode-gateway 0.2.3 → 0.2.4

package/dist/questions/format.js

@@ -1,36 +0,0 @@
-export function formatPlainTextQuestion(request) {
-    return [
-        "OpenCode needs additional input before it can continue.",
-        "",
-        ...request.questions.flatMap((question, index) => formatQuestionBlock(question, index)),
-        formatReplyInstructions(request.questions),
-    ].join("\n");
-}
-export function formatQuestionReplyError(request, message) {
-    return [message, "", formatReplyInstructions(request.questions)].join("\n");
-}
-function formatQuestionBlock(question, index) {
-    const label = `Question ${index + 1}: ${question.header}`;
-    const options = question.options.length === 0
-        ? []
-        : [
-            "Options:",
-            ...question.options.map((option, optionIndex) => `${optionIndex + 1}. ${option.label} - ${option.description}`),
-        ];
-    return [label, question.question, ...options, ""];
-}
-function formatReplyInstructions(questions) {
-    if (questions.length === 1) {
-        const question = questions[0];
-        const selectionHint = question.multiple
-            ? "Reply with one line. You may send option numbers or labels separated by commas."
-            : "Reply with one line. You may send an option number, an option label, or custom text.";
-        return ["How to reply:", `- ${selectionHint}`, "- Reply /cancel to reject this question."].join("\n");
-    }
-    return [
-        "How to reply:",
-        "- Reply with one non-empty line per question, in order.",
-        "- Each line may use option numbers, option labels, or custom text when allowed.",
-        "- Reply /cancel to reject this question.",
-    ].join("\n");
-}

package/dist/questions/normalize.js

@@ -1,45 +0,0 @@
-export function normalizeQuestionEvent(event) {
-    if (isQuestionAskedEvent(event)) {
-        return {
-            kind: "asked",
-            request: {
-                requestId: event.properties.id,
-                sessionId: event.properties.sessionID,
-                questions: event.properties.questions.map((question) => ({
-                    header: question.header,
-                    question: question.question,
-                    options: question.options.map((option) => ({
-                        label: option.label,
-                        description: option.description,
-                    })),
-                    multiple: question.multiple === true,
-                    custom: question.custom !== false,
-                })),
-            },
-        };
-    }
-    if (isQuestionResolvedEvent(event)) {
-        return {
-            kind: "resolved",
-            requestId: event.properties.requestID,
-        };
-    }
-    return null;
-}
-function isQuestionAskedEvent(event) {
-    if (event.type !== "question.asked" || typeof event.properties !== "object" || event.properties === null) {
-        return false;
-    }
-    const properties = event.properties;
-    return (typeof properties.id === "string" &&
-        typeof properties.sessionID === "string" &&
-        Array.isArray(properties.questions));
-}
-function isQuestionResolvedEvent(event) {
-    if ((event.type !== "question.replied" && event.type !== "question.rejected") ||
-        typeof event.properties !== "object" ||
-        event.properties === null) {
-        return false;
-    }
-    return typeof event.properties.requestID === "string";
-}

package/dist/questions/parser.js

@@ -1,96 +0,0 @@
-const CANCEL_WORDS = new Set(["/cancel", "cancel", "/reject", "reject"]);
-export function parseQuestionReply(request, text) {
-    if (text === null) {
-        return {
-            kind: "invalid",
-            message: "This question currently accepts text replies only.",
-        };
-    }
-    const trimmed = text.trim();
-    if (trimmed.length === 0) {
-        return {
-            kind: "invalid",
-            message: "Reply text must not be empty.",
-        };
-    }
-    if (CANCEL_WORDS.has(trimmed.toLowerCase())) {
-        return {
-            kind: "reject",
-        };
-    }
-    if (request.questions.length === 1) {
-        const parsedAnswer = parseQuestionLine(request.questions[0], trimmed);
-        return parsedAnswer.kind === "invalid"
-            ? parsedAnswer
-            : {
-                kind: "reply",
-                answers: [parsedAnswer.answer],
-            };
-    }
-    const lines = trimmed
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-    if (lines.length !== request.questions.length) {
-        return {
-            kind: "invalid",
-            message: `Expected ${request.questions.length} non-empty lines, but received ${lines.length}.`,
-        };
-    }
-    const answers = [];
-    for (const [index, question] of request.questions.entries()) {
-        const parsedAnswer = parseQuestionLine(question, lines[index]);
-        if (parsedAnswer.kind === "invalid") {
-            return parsedAnswer;
-        }
-        answers.push(parsedAnswer.answer);
-    }
-    return {
-        kind: "reply",
-        answers,
-    };
-}
-function parseQuestionLine(question, line) {
-    const rawSelections = question.multiple
-        ? line
-            .split(/[,\n]/u)
-            .map((token) => token.trim())
-            .filter((token) => token.length > 0)
-        : [line];
-    if (rawSelections.length === 0) {
-        return {
-            kind: "invalid",
-            message: "At least one answer is required.",
-        };
-    }
-    const answers = [];
-    for (const rawSelection of rawSelections) {
-        const option = resolveOptionSelection(question, rawSelection);
-        if (option !== null) {
-            answers.push(option);
-            continue;
-        }
-        if (!question.custom) {
-            return {
-                kind: "invalid",
-                message: `Answer "${rawSelection}" does not match any allowed option.`,
-            };
-        }
-        answers.push(rawSelection);
-    }
-    return {
-        kind: "answer",
-        answer: answers,
-    };
-}
-function resolveOptionSelection(question, selection) {
-    if (question.options.length === 0) {
-        return null;
-    }
-    const numericIndex = Number.parseInt(selection, 10);
-    if (Number.isSafeInteger(numericIndex) && String(numericIndex) === selection && numericIndex >= 1) {
-        return question.options[numericIndex - 1]?.label ?? null;
-    }
-    const normalized = selection.toLowerCase();
-    return question.options.find((option) => option.label.toLowerCase() === normalized)?.label ?? null;
-}

package/dist/questions/runtime.js

@@ -1,195 +0,0 @@
-import { recordTelegramSendFailure, recordTelegramSendSuccess } from "../telegram/state";
-import { formatError } from "../utils/error";
-import { formatPlainTextQuestion, formatQuestionReplyError } from "./format";
-import { normalizeQuestionEvent } from "./normalize";
-import { parseQuestionReply } from "./parser";
-export class GatewayQuestionRuntime {
-    client;
-    directory;
-    store;
-    sessions;
-    transport;
-    telegramClient;
-    logger;
-    constructor(client, directory, store, sessions, transport, telegramClient, logger) {
-        this.client = client;
-        this.directory = directory;
-        this.store = store;
-        this.sessions = sessions;
-        this.transport = transport;
-        this.telegramClient = telegramClient;
-        this.logger = logger;
-    }
-    handleEvent(event) {
-        const normalized = normalizeQuestionEvent(event);
-        if (normalized === null) {
-            return;
-        }
-        void this.processEvent(normalized).catch((error) => {
-            this.logger.log("warn", `question bridge failed: ${formatError(error)}`);
-        });
-    }
-    async tryHandleInboundMessage(message) {
-        const pending = this.store.getPendingQuestionForTarget(message.deliveryTarget);
-        if (pending === null) {
-            return false;
-        }
-        const parsed = parseQuestionReply(pending, message.text);
-        switch (parsed.kind) {
-            case "invalid":
-                await this.sendPlainText(pending.deliveryTarget, formatQuestionReplyError(pending, parsed.message));
-                return true;
-            case "reject":
-                await this.rejectQuestion(pending.requestId);
-                this.store.deletePendingQuestion(pending.requestId);
-                return true;
-            case "reply":
-                await this.replyQuestion(pending.requestId, parsed.answers);
-                this.store.deletePendingQuestion(pending.requestId);
-                return true;
-        }
-    }
-    async handleTelegramCallbackQuery(query) {
-        if (this.telegramClient === null) {
-            return false;
-        }
-        const pending = this.store.getPendingQuestionForTelegramMessage(query.deliveryTarget, query.messageId);
-        if (pending === null) {
-            await this.telegramClient.answerCallbackQuery(query.callbackQueryId, "This question is no longer pending.");
-            return true;
-        }
-        const answer = resolveCallbackAnswer(query.data, pending);
-        if (answer === null) {
-            await this.telegramClient.answerCallbackQuery(query.callbackQueryId, "This button is no longer valid.");
-            return true;
-        }
-        await this.replyQuestion(pending.requestId, [[answer]]);
-        this.store.deletePendingQuestion(pending.requestId);
-        await this.telegramClient.answerCallbackQuery(query.callbackQueryId, `Sent: ${answer}`);
-        return true;
-    }
-    async processEvent(event) {
-        switch (event.kind) {
-            case "asked":
-                await this.handleQuestionAsked(event.request);
-                return;
-            case "resolved":
-                this.store.deletePendingQuestion(event.requestId);
-                return;
-        }
-    }
-    async handleQuestionAsked(request) {
-        const targets = this.sessions.listReplyTargets(request.sessionId);
-        if (targets.length === 0) {
-            this.logger.log("warn", `question ${request.requestId} has no reply target for session ${request.sessionId}`);
-            return;
-        }
-        const deliveredTargets = [];
-        for (const target of targets) {
-            try {
-                deliveredTargets.push(await this.sendQuestion(target, request));
-            }
-            catch (error) {
-                this.logger.log("warn", `question ${request.requestId} delivery failed for ${target.channel}:${target.target}: ${formatError(error)}`);
-            }
-        }
-        if (deliveredTargets.length === 0) {
-            return;
-        }
-        this.store.replacePendingQuestion({
-            requestId: request.requestId,
-            sessionId: request.sessionId,
-            questions: request.questions,
-            targets: deliveredTargets,
-            recordedAtMs: Date.now(),
-        });
-    }
-    async sendQuestion(target, request) {
-        const nativeKeyboard = buildTelegramInlineKeyboard(request);
-        if (target.channel === "telegram" && nativeKeyboard !== null && this.telegramClient !== null) {
-            try {
-                const sent = await this.telegramClient.sendInteractiveMessage(target.target, formatTelegramNativeQuestion(request), target.topic, nativeKeyboard);
-                recordTelegramSendSuccess(this.store, Date.now());
-                return {
-                    deliveryTarget: target,
-                    telegramMessageId: sent.message_id,
-                };
-            }
-            catch (error) {
-                recordTelegramSendFailure(this.store, formatError(error), Date.now());
-                throw error;
-            }
-        }
-        await this.sendPlainText(target, formatPlainTextQuestion(request));
-        return {
-            deliveryTarget: target,
-            telegramMessageId: null,
-        };
-    }
-    async sendPlainText(target, body) {
-        const ack = await this.transport.sendMessage({
-            deliveryTarget: target,
-            body,
-        });
-        if (ack.errorMessage !== null) {
-            throw new Error(ack.errorMessage);
-        }
-    }
-    async replyQuestion(requestId, answers) {
-        await this.client.question.reply({
-            requestID: requestId,
-            directory: this.directory,
-            answers,
-        }, {
-            responseStyle: "data",
-            throwOnError: true,
-        });
-    }
-    async rejectQuestion(requestId) {
-        await this.client.question.reject({
-            requestID: requestId,
-            directory: this.directory,
-        }, {
-            responseStyle: "data",
-            throwOnError: true,
-        });
-    }
-}
-function buildTelegramInlineKeyboard(request) {
-    if (request.questions.length !== 1) {
-        return null;
-    }
-    const [question] = request.questions;
-    if (question.multiple || question.options.length === 0) {
-        return null;
-    }
-    return {
-        inline_keyboard: question.options.map((option, index) => [
-            {
-                text: option.label,
-                callback_data: `q:${index}`,
-            },
-        ]),
-    };
-}
-function formatTelegramNativeQuestion(request) {
-    const [question] = request.questions;
-    return [
-        "OpenCode needs additional input before it can continue.",
-        "",
-        `${question.header}: ${question.question}`,
-        "",
-        "Tap a button below or reply with text.",
-    ].join("\n");
-}
-function resolveCallbackAnswer(data, pending) {
-    if (data === null || !data.startsWith("q:") || pending.questions.length !== 1) {
-        return null;
-    }
-    const indexText = data.slice(2);
-    const index = Number.parseInt(indexText, 10);
-    if (!Number.isSafeInteger(index) || index < 0) {
-        return null;
-    }
-    return pending.questions[0]?.options[index]?.label ?? null;
-}

package/dist/questions/types.js

@@ -1 +0,0 @@
-export {};

package/dist/runtime/attachments.js

@@ -1,12 +0,0 @@
-import { rm } from "node:fs/promises";
-export async function deleteInboundAttachmentFiles(entries, logger) {
-    const paths = new Set(entries.flatMap((entry) => entry.attachments.map((attachment) => attachment.localPath)));
-    await Promise.all([...paths].map(async (path) => {
-        try {
-            await rm(path, { force: true });
-        }
-        catch (error) {
-            logger.log("warn", `failed to remove cached inbound attachment ${path}: ${String(error)}`);
-        }
-    }));
-}

package/dist/runtime/conversation-coordinator.js

@@ -1,22 +0,0 @@
-export class ConversationCoordinator {
-    tails = new Map();
-    async runExclusive(conversationKey, operation) {
-        const previous = this.tails.get(conversationKey) ?? Promise.resolve();
-        let release;
-        const current = new Promise((resolve) => {
-            release = resolve;
-        });
-        const tail = previous.then(() => current, () => current);
-        this.tails.set(conversationKey, tail);
-        await previous;
-        try {
-            return await operation();
-        }
-        finally {
-            release();
-            if (this.tails.get(conversationKey) === tail) {
-                this.tails.delete(conversationKey);
-            }
-        }
-    }
-}