opencode-gateway 0.1.0

package/dist/store/sqlite.js

@@ -0,0 +1,678 @@
+import { Database } from "bun:sqlite";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { migrateGatewayDatabase } from "./migrations";
+export class SqliteStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getSessionBinding(conversationKey) {
+        const row = this.db
+            .query("SELECT session_id FROM session_bindings WHERE conversation_key = ?1;")
+            .get(conversationKey);
+        return row?.session_id ?? null;
+    }
+    putSessionBinding(conversationKey, sessionId, recordedAtMs) {
+        this.db
+            .query(`
+                    INSERT INTO session_bindings (conversation_key, session_id, updated_at_ms)
+                    VALUES (?1, ?2, ?3)
+                    ON CONFLICT(conversation_key) DO UPDATE SET
+                        session_id = excluded.session_id,
+                        updated_at_ms = excluded.updated_at_ms;
+                `)
+            .run(conversationKey, sessionId, recordedAtMs);
+    }
+    putSessionBindingIfUnchanged(conversationKey, expectedSessionId, nextSessionId, recordedAtMs) {
+        const result = expectedSessionId === null
+            ? this.db
+                .query(`
+                              INSERT INTO session_bindings (conversation_key, session_id, updated_at_ms)
+                              VALUES (?1, ?2, ?3)
+                              ON CONFLICT(conversation_key) DO NOTHING;
+                          `)
+                .run(conversationKey, nextSessionId, recordedAtMs)
+            : this.db
+                .query(`
+                              UPDATE session_bindings
+                              SET session_id = ?2,
+                                  updated_at_ms = ?3
+                              WHERE conversation_key = ?1
+                                AND session_id = ?4;
+                          `)
+                .run(conversationKey, nextSessionId, recordedAtMs, expectedSessionId);
+        return result.changes > 0;
+    }
+    deleteSessionBinding(conversationKey) {
+        this.db.query("DELETE FROM session_bindings WHERE conversation_key = ?1;").run(conversationKey);
+    }
+    clearSessionReplyTargets(sessionId) {
+        this.db.query("DELETE FROM session_reply_targets WHERE session_id = ?1;").run(sessionId);
+    }
+    replaceSessionReplyTargets(input) {
+        assertSafeInteger(input.recordedAtMs, "session reply-target recordedAtMs");
+        const deleteTargets = this.db.query("DELETE FROM session_reply_targets WHERE session_id = ?1;");
+        const insertTarget = this.db.query(`
+                INSERT INTO session_reply_targets (
+                    session_id,
+                    ordinal,
+                    conversation_key,
+                    delivery_channel,
+                    delivery_target,
+                    delivery_topic,
+                    updated_at_ms
+                )
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7);
+            `);
+        this.db.transaction((payload) => {
+            deleteTargets.run(payload.sessionId);
+            for (const [ordinal, target] of payload.targets.entries()) {
+                insertTarget.run(payload.sessionId, ordinal, payload.conversationKey, target.channel, target.target, normalizeKeyField(target.topic), payload.recordedAtMs);
+            }
+        })(input);
+    }
+    listSessionReplyTargets(sessionId) {
+        const rows = this.db
+            .query(`
+                    SELECT
+                        session_id,
+                        ordinal,
+                        conversation_key,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        updated_at_ms
+                    FROM session_reply_targets
+                    WHERE session_id = ?1
+                    ORDER BY ordinal ASC;
+                `)
+            .all(sessionId);
+        return rows.map(mapSessionReplyTargetRow);
+    }
+    getDefaultSessionReplyTarget(sessionId) {
+        const row = this.db
+            .query(`
+                    SELECT
+                        session_id,
+                        ordinal,
+                        conversation_key,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        updated_at_ms
+                    FROM session_reply_targets
+                    WHERE session_id = ?1
+                    ORDER BY ordinal ASC
+                    LIMIT 1;
+                `)
+            .get(sessionId);
+        return row ? mapSessionReplyTargetRow(row) : null;
+    }
+    appendJournal(entry) {
+        this.db
+            .query(`
+                    INSERT INTO runtime_journal (kind, recorded_at_ms, conversation_key, payload_json)
+                    VALUES (?1, ?2, ?3, ?4);
+                `)
+            .run(entry.kind, entry.recordedAtMs, entry.conversationKey, JSON.stringify(entry.payload));
+    }
+    replacePendingQuestion(input) {
+        assertSafeInteger(input.recordedAtMs, "pending question recordedAtMs");
+        const deleteQuestion = this.db.query("DELETE FROM pending_questions WHERE request_id = ?1;");
+        const insertQuestion = this.db.query(`
+                INSERT INTO pending_questions (
+                    request_id,
+                    session_id,
+                    delivery_channel,
+                    delivery_target,
+                    delivery_topic,
+                    question_json,
+                    telegram_message_id,
+                    created_at_ms
+                )
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8);
+            `);
+        this.db.transaction((payload) => {
+            deleteQuestion.run(payload.requestId);
+            for (const target of payload.targets) {
+                insertQuestion.run(payload.requestId, payload.sessionId, target.deliveryTarget.channel, target.deliveryTarget.target, normalizeKeyField(target.deliveryTarget.topic), JSON.stringify(payload.questions), target.telegramMessageId, payload.recordedAtMs);
+            }
+        })(input);
+    }
+    deletePendingQuestion(requestId) {
+        this.db.query("DELETE FROM pending_questions WHERE request_id = ?1;").run(requestId);
+    }
+    deletePendingQuestionsForSession(sessionId) {
+        this.db.query("DELETE FROM pending_questions WHERE session_id = ?1;").run(sessionId);
+    }
+    getPendingQuestionForTarget(target) {
+        const row = this.db
+            .query(`
+                    SELECT
+                        id,
+                        request_id,
+                        session_id,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        question_json,
+                        telegram_message_id,
+                        created_at_ms
+                    FROM pending_questions
+                    WHERE delivery_channel = ?1
+                      AND delivery_target = ?2
+                      AND delivery_topic = ?3
+                    ORDER BY created_at_ms ASC, id ASC
+                    LIMIT 1;
+                `)
+            .get(target.channel, target.target, normalizeKeyField(target.topic));
+        return row ? mapPendingQuestionRow(row) : null;
+    }
+    getPendingQuestionForTelegramMessage(target, telegramMessageId) {
+        assertSafeInteger(telegramMessageId, "pending question telegramMessageId");
+        const row = this.db
+            .query(`
+                    SELECT
+                        id,
+                        request_id,
+                        session_id,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        question_json,
+                        telegram_message_id,
+                        created_at_ms
+                    FROM pending_questions
+                    WHERE delivery_channel = ?1
+                      AND delivery_target = ?2
+                      AND delivery_topic = ?3
+                      AND telegram_message_id = ?4
+                    ORDER BY created_at_ms ASC, id ASC
+                    LIMIT 1;
+                `)
+            .get(target.channel, target.target, normalizeKeyField(target.topic), telegramMessageId);
+        return row ? mapPendingQuestionRow(row) : null;
+    }
+    hasMailboxEntry(sourceKind, externalId) {
+        const row = this.db
+            .query(`
+                    SELECT 1 AS present
+                    FROM mailbox_entries
+                    WHERE source_kind = ?1 AND external_id = ?2
+                    LIMIT 1;
+                `)
+            .get(sourceKind, externalId);
+        return row?.present === 1;
+    }
+    enqueueMailboxEntry(input) {
+        assertSafeInteger(input.recordedAtMs, "mailbox recordedAtMs");
+        const insertEntry = this.db.query(`
+                INSERT INTO mailbox_entries (
+                    mailbox_key,
+                    source_kind,
+                    external_id,
+                    sender,
+                    body,
+                    reply_channel,
+                    reply_target,
+                    reply_topic,
+                    created_at_ms
+                )
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+                ON CONFLICT(source_kind, external_id) DO NOTHING;
+            `);
+        const insertAttachment = this.db.query(`
+                INSERT INTO mailbox_entry_attachments (
+                    mailbox_entry_id,
+                    ordinal,
+                    kind,
+                    mime_type,
+                    file_name,
+                    local_path
+                )
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6);
+            `);
+        this.db.transaction((payload) => {
+            const result = insertEntry.run(payload.mailboxKey, payload.sourceKind, payload.externalId, payload.sender, payload.text ?? "", payload.replyChannel, payload.replyTarget, payload.replyTopic, payload.recordedAtMs);
+            if (result.changes === 0) {
+                return;
+            }
+            const entryId = Number(result.lastInsertRowid);
+            for (const [index, attachment] of payload.attachments.entries()) {
+                insertAttachment.run(entryId, index, attachment.kind, attachment.mimeType, attachment.fileName, attachment.localPath);
+            }
+        })(input);
+    }
+    listPendingMailboxKeys() {
+        const rows = this.db
+            .query(`
+                    SELECT DISTINCT mailbox_key
+                    FROM mailbox_entries
+                    ORDER BY mailbox_key ASC;
+                `)
+            .all();
+        return rows.map((row) => row.mailbox_key);
+    }
+    listMailboxEntries(mailboxKey) {
+        const rows = this.db
+            .query(`
+                    SELECT
+                        id,
+                        mailbox_key,
+                        source_kind,
+                        external_id,
+                        sender,
+                        body,
+                        reply_channel,
+                        reply_target,
+                        reply_topic,
+                        created_at_ms
+                    FROM mailbox_entries
+                    WHERE mailbox_key = ?1
+                    ORDER BY id ASC;
+                `)
+            .all(mailboxKey);
+        const attachments = listMailboxAttachments(this.db, rows.map((row) => row.id));
+        return rows.map((row) => mapMailboxEntryRow(row, attachments.get(row.id) ?? []));
+    }
+    deleteMailboxEntries(ids) {
+        if (ids.length === 0) {
+            return;
+        }
+        for (const id of ids) {
+            assertSafeInteger(id, "mailbox entry id");
+        }
+        const placeholders = ids.map((_, index) => `?${index + 1}`).join(", ");
+        this.db.query(`DELETE FROM mailbox_entries WHERE id IN (${placeholders});`).run(...ids);
+    }
+    getTelegramUpdateOffset() {
+        const value = this.getStateValue("telegram.update_offset");
+        if (value === null) {
+            return null;
+        }
+        return parseStoredInteger(value, "stored telegram.update_offset");
+    }
+    putTelegramUpdateOffset(offset, recordedAtMs) {
+        assertSafeInteger(offset, "telegram update offset");
+        this.putStateValue("telegram.update_offset", String(offset), recordedAtMs);
+    }
+    getStateValue(key) {
+        const row = this.db.query("SELECT value FROM kv_state WHERE key = ?1;").get(key);
+        return row?.value ?? null;
+    }
+    putStateValue(key, value, recordedAtMs) {
+        this.db
+            .query(`
+                    INSERT INTO kv_state (key, value, updated_at_ms)
+                    VALUES (?1, ?2, ?3)
+                    ON CONFLICT(key) DO UPDATE SET
+                        value = excluded.value,
+                        updated_at_ms = excluded.updated_at_ms;
+                `)
+            .run(key, value, recordedAtMs);
+    }
+    upsertCronJob(input) {
+        assertSafeInteger(input.nextRunAtMs, "cron next_run_at_ms");
+        assertSafeInteger(input.recordedAtMs, "cron recordedAtMs");
+        this.db
+            .query(`
+                    INSERT INTO cron_jobs (
+                        id,
+                        schedule,
+                        prompt,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        enabled,
+                        next_run_at_ms,
+                        created_at_ms,
+                        updated_at_ms
+                    )
+                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?9)
+                    ON CONFLICT(id) DO UPDATE SET
+                        schedule = excluded.schedule,
+                        prompt = excluded.prompt,
+                        delivery_channel = excluded.delivery_channel,
+                        delivery_target = excluded.delivery_target,
+                        delivery_topic = excluded.delivery_topic,
+                        enabled = excluded.enabled,
+                        next_run_at_ms = excluded.next_run_at_ms,
+                        updated_at_ms = excluded.updated_at_ms;
+                `)
+            .run(input.id, input.schedule, input.prompt, input.deliveryChannel, input.deliveryTarget, input.deliveryTopic, input.enabled ? 1 : 0, input.nextRunAtMs, input.recordedAtMs);
+    }
+    getCronJob(id) {
+        const row = this.db
+            .query(`
+                    SELECT
+                        id,
+                        schedule,
+                        prompt,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        enabled,
+                        next_run_at_ms,
+                        created_at_ms,
+                        updated_at_ms
+                    FROM cron_jobs
+                    WHERE id = ?1;
+                `)
+            .get(id);
+        return row ? mapCronJobRow(row) : null;
+    }
+    listCronJobs() {
+        const rows = this.db
+            .query(`
+                    SELECT
+                        id,
+                        schedule,
+                        prompt,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        enabled,
+                        next_run_at_ms,
+                        created_at_ms,
+                        updated_at_ms
+                    FROM cron_jobs
+                    ORDER BY id ASC;
+                `)
+            .all();
+        return rows.map(mapCronJobRow);
+    }
+    listOverdueCronJobs(nowMs) {
+        assertSafeInteger(nowMs, "cron nowMs");
+        const rows = this.db
+            .query(`
+                    SELECT
+                        id,
+                        schedule,
+                        prompt,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        enabled,
+                        next_run_at_ms,
+                        created_at_ms,
+                        updated_at_ms
+                    FROM cron_jobs
+                    WHERE enabled = 1 AND next_run_at_ms <= ?1
+                    ORDER BY next_run_at_ms ASC, id ASC;
+                `)
+            .all(nowMs);
+        return rows.map(mapCronJobRow);
+    }
+    listDueCronJobs(nowMs, limit) {
+        assertSafeInteger(nowMs, "cron nowMs");
+        assertSafeInteger(limit, "cron due-job limit");
+        const rows = this.db
+            .query(`
+                    SELECT
+                        id,
+                        schedule,
+                        prompt,
+                        delivery_channel,
+                        delivery_target,
+                        delivery_topic,
+                        enabled,
+                        next_run_at_ms,
+                        created_at_ms,
+                        updated_at_ms
+                    FROM cron_jobs
+                    WHERE enabled = 1 AND next_run_at_ms <= ?1
+                    ORDER BY next_run_at_ms ASC, id ASC
+                    LIMIT ?2;
+                `)
+            .all(nowMs, limit);
+        return rows.map(mapCronJobRow);
+    }
+    removeCronJob(id) {
+        const result = this.db.query("DELETE FROM cron_jobs WHERE id = ?1;").run(id);
+        return result.changes > 0;
+    }
+    updateCronJobNextRun(id, nextRunAtMs, recordedAtMs) {
+        assertSafeInteger(nextRunAtMs, "cron next_run_at_ms");
+        assertSafeInteger(recordedAtMs, "cron recordedAtMs");
+        this.db
+            .query(`
+                    UPDATE cron_jobs
+                    SET next_run_at_ms = ?2, updated_at_ms = ?3
+                    WHERE id = ?1;
+                `)
+            .run(id, nextRunAtMs, recordedAtMs);
+    }
+    insertCronRun(jobId, scheduledForMs, startedAtMs) {
+        assertSafeInteger(scheduledForMs, "cron scheduled_for_ms");
+        assertSafeInteger(startedAtMs, "cron started_at_ms");
+        const result = this.db
+            .query(`
+                    INSERT INTO cron_runs (
+                        job_id,
+                        scheduled_for_ms,
+                        started_at_ms,
+                        finished_at_ms,
+                        status,
+                        response_text,
+                        error_message
+                    )
+                    VALUES (?1, ?2, ?3, NULL, 'running', NULL, NULL);
+                `)
+            .run(jobId, scheduledForMs, startedAtMs);
+        return Number(result.lastInsertRowid);
+    }
+    finishCronRun(runId, status, finishedAtMs, responseText, errorMessage) {
+        assertSafeInteger(runId, "cron run id");
+        assertSafeInteger(finishedAtMs, "cron finished_at_ms");
+        this.db
+            .query(`
+                    UPDATE cron_runs
+                    SET
+                        finished_at_ms = ?2,
+                        status = ?3,
+                        response_text = ?4,
+                        error_message = ?5
+                    WHERE id = ?1;
+                `)
+            .run(runId, finishedAtMs, status, responseText, errorMessage);
+    }
+    abandonRunningCronRuns(finishedAtMs) {
+        assertSafeInteger(finishedAtMs, "cron abandoned finished_at_ms");
+        const result = this.db
+            .query(`
+                    UPDATE cron_runs
+                    SET
+                        finished_at_ms = ?1,
+                        status = 'abandoned',
+                        error_message = 'gateway process stopped before this run completed'
+                    WHERE status = 'running';
+                `)
+            .run(finishedAtMs);
+        return result.changes;
+    }
+    close() {
+        this.db.close();
+    }
+}
+function mapCronJobRow(row) {
+    return {
+        id: row.id,
+        schedule: row.schedule,
+        prompt: row.prompt,
+        deliveryChannel: row.delivery_channel,
+        deliveryTarget: row.delivery_target,
+        deliveryTopic: row.delivery_topic,
+        enabled: row.enabled === 1,
+        nextRunAtMs: row.next_run_at_ms,
+        createdAtMs: row.created_at_ms,
+        updatedAtMs: row.updated_at_ms,
+    };
+}
+function mapMailboxEntryRow(row, attachments) {
+    return {
+        id: row.id,
+        mailboxKey: row.mailbox_key,
+        sourceKind: row.source_kind,
+        externalId: row.external_id,
+        sender: row.sender,
+        text: normalizeStoredMailboxText(row.body),
+        attachments,
+        replyChannel: row.reply_channel,
+        replyTarget: row.reply_target,
+        replyTopic: row.reply_topic,
+        createdAtMs: row.created_at_ms,
+    };
+}
+function listMailboxAttachments(db, entryIds) {
+    if (entryIds.length === 0) {
+        return new Map();
+    }
+    for (const entryId of entryIds) {
+        assertSafeInteger(entryId, "mailbox entry id");
+    }
+    const placeholders = entryIds.map((_, index) => `?${index + 1}`).join(", ");
+    const rows = db
+        .query(`
+                SELECT
+                    mailbox_entry_id,
+                    ordinal,
+                    kind,
+                    mime_type,
+                    file_name,
+                    local_path
+                FROM mailbox_entry_attachments
+                WHERE mailbox_entry_id IN (${placeholders})
+                ORDER BY mailbox_entry_id ASC, ordinal ASC;
+            `)
+        .all(...entryIds);
+    const attachments = new Map();
+    for (const row of rows) {
+        const records = attachments.get(row.mailbox_entry_id) ?? [];
+        records.push(mapMailboxEntryAttachmentRow(row));
+        attachments.set(row.mailbox_entry_id, records);
+    }
+    return attachments;
+}
+function mapMailboxEntryAttachmentRow(row) {
+    switch (row.kind) {
+        case "image":
+            return {
+                kind: "image",
+                ordinal: row.ordinal,
+                mimeType: row.mime_type,
+                fileName: row.file_name,
+                localPath: row.local_path,
+            };
+        default:
+            throw new Error(`unsupported mailbox attachment kind: ${row.kind}`);
+    }
+}
+function mapSessionReplyTargetRow(row) {
+    return {
+        channel: row.delivery_channel,
+        target: row.delivery_target,
+        topic: normalizeStoredKeyField(row.delivery_topic),
+    };
+}
+function mapPendingQuestionRow(row) {
+    return {
+        requestId: row.request_id,
+        sessionId: row.session_id,
+        questions: parsePendingQuestions(row.question_json),
+        deliveryTarget: {
+            channel: row.delivery_channel,
+            target: row.delivery_target,
+            topic: normalizeStoredKeyField(row.delivery_topic),
+        },
+        telegramMessageId: row.telegram_message_id,
+        createdAtMs: row.created_at_ms,
+    };
+}
+function parsePendingQuestions(value) {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) {
+        throw new Error("stored pending question payload is invalid");
+    }
+    return parsed.map((question, index) => {
+        if (typeof question !== "object" || question === null) {
+            throw new Error(`stored pending question ${index} is invalid`);
+        }
+        const header = readRequiredStringField(question, "header");
+        const prompt = readRequiredStringField(question, "question");
+        const rawOptions = readArrayField(question, "options");
+        const options = rawOptions.map((option, optionIndex) => {
+            if (typeof option !== "object" || option === null) {
+                throw new Error(`stored pending question option ${index}:${optionIndex} is invalid`);
+            }
+            return {
+                label: readRequiredStringField(option, "label"),
+                description: readRequiredStringField(option, "description"),
+            };
+        });
+        return {
+            header,
+            question: prompt,
+            options,
+            multiple: readBooleanField(question, "multiple", false),
+            custom: readBooleanField(question, "custom", true),
+        };
+    });
+}
+function assertSafeInteger(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${field} is out of range: ${value}`);
+    }
+}
+function parseStoredInteger(value, field) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new Error(`${field} is invalid: ${value}`);
+    }
+    return parsed;
+}
+function normalizeStoredMailboxText(value) {
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? null : trimmed;
+}
+function normalizeKeyField(value) {
+    if (value === null) {
+        return "";
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? "" : trimmed;
+}
+function normalizeStoredKeyField(value) {
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? null : trimmed;
+}
+function readRequiredStringField(value, field) {
+    const raw = value[field];
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        throw new Error(`stored field ${field} is invalid`);
+    }
+    return raw;
+}
+function readArrayField(value, field) {
+    const raw = value[field];
+    if (!Array.isArray(raw)) {
+        throw new Error(`stored field ${field} is invalid`);
+    }
+    return raw;
+}
+function readBooleanField(value, field, fallback) {
+    const raw = value[field];
+    if (raw === undefined) {
+        return fallback;
+    }
+    if (typeof raw !== "boolean") {
+        throw new Error(`stored field ${field} is invalid`);
+    }
+    return raw;
+}
+export async function openSqliteStore(path) {
+    await mkdir(dirname(path), { recursive: true });
+    const db = new Database(path);
+    migrateGatewayDatabase(db);
+    return new SqliteStore(db);
+}