opencode-gateway 0.2.3 → 0.2.5

package/dist/cron/runtime.js

@@ -1,402 +0,0 @@
-import { formatError } from "../utils/error";
-const CRON_EFFECTIVE_TIME_ZONE_KEY = "cron.effective_timezone";
-const LEGACY_CRON_TIME_ZONE = "UTC";
-const MAX_STATUS_RUNS = 20;
-export class GatewayCronRuntime {
-    executor;
-    contract;
-    store;
-    logger;
-    config;
-    effectiveTimeZone;
-    resolveConversationKeyForTarget;
-    runningJobIds = new Set();
-    running = false;
-    constructor(executor, contract, store, logger, config, effectiveTimeZone, resolveConversationKeyForTarget) {
-        this.executor = executor;
-        this.contract = contract;
-        this.store = store;
-        this.logger = logger;
-        this.config = config;
-        this.effectiveTimeZone = effectiveTimeZone;
-        this.resolveConversationKeyForTarget = resolveConversationKeyForTarget;
-    }
-    isEnabled() {
-        return this.config.enabled;
-    }
-    isRunning() {
-        return this.running;
-    }
-    runningJobs() {
-        return this.runningJobIds.size;
-    }
-    timeZone() {
-        return this.effectiveTimeZone;
-    }
-    start() {
-        if (!this.config.enabled || this.running) {
-            return;
-        }
-        this.running = true;
-        void this.runLoop().finally(() => {
-            this.running = false;
-        });
-    }
-    listJobs(includeTerminal = false) {
-        const jobs = this.store.listCronJobs();
-        if (includeTerminal) {
-            return jobs;
-        }
-        return jobs.filter((job) => !isTerminalJob(job));
-    }
-    getJobStatus(id, limit = 5) {
-        const job = this.requireJob(normalizeId(id));
-        const runs = this.store.listCronRuns(job.id, clampStatusLimit(limit));
-        return {
-            job,
-            state: deriveJobState(job, runs[0] ?? null),
-            runs,
-        };
-    }
-    upsertJob(input) {
-        const normalized = normalizeUpsertInput(input);
-        const recordedAtMs = Date.now();
-        const nextRunAtMs = computeNextRunAt(this.contract, normalized, recordedAtMs, this.effectiveTimeZone);
-        this.store.upsertCronJob({
-            ...normalized,
-            nextRunAtMs,
-            recordedAtMs,
-        });
-        return this.requireJob(normalized.id);
-    }
-    scheduleOnce(input) {
-        const normalized = normalizeOnceInput(input);
-        const recordedAtMs = Date.now();
-        this.store.upsertCronJob({
-            ...normalized,
-            nextRunAtMs: normalized.runAtMs ?? recordedAtMs,
-            recordedAtMs,
-        });
-        return this.requireJob(normalized.id);
-    }
-    cancelJob(id) {
-        const job = this.store.getCronJob(normalizeId(id));
-        if (job === null || !job.enabled) {
-            return false;
-        }
-        this.store.setCronJobEnabled(job.id, false, Date.now());
-        return true;
-    }
-    async runNow(id) {
-        const job = this.requireJob(normalizeId(id));
-        if (!job.enabled) {
-            throw new Error(`schedule job is not active: ${job.id}`);
-        }
-        if (this.runningJobIds.has(job.id)) {
-            throw new Error(`schedule job is already running: ${job.id}`);
-        }
-        this.runningJobIds.add(job.id);
-        try {
-            return await this.executeJob(job, Date.now(), null);
-        }
-        finally {
-            this.runningJobIds.delete(job.id);
-        }
-    }
-    async runLoop() {
-        await this.reconcileOnce();
-        for (;;) {
-            await this.tickOnce();
-            await sleep(this.config.tickSeconds * 1_000);
-        }
-    }
-    async reconcileOnce(nowMs = Date.now()) {
-        const abandoned = this.store.abandonRunningCronRuns(nowMs);
-        if (abandoned > 0) {
-            this.logger.log("warn", `abandoned ${abandoned} stale cron runs on startup`);
-        }
-        const storedTimeZone = this.readStoredEffectiveTimeZone();
-        const previousTimeZone = storedTimeZone ?? LEGACY_CRON_TIME_ZONE;
-        if (previousTimeZone !== this.effectiveTimeZone) {
-            const message = storedTimeZone === null
-                ? `rebasing enabled cron jobs from legacy ${LEGACY_CRON_TIME_ZONE} semantics to ${this.effectiveTimeZone}`
-                : `cron time zone changed from ${previousTimeZone} to ${this.effectiveTimeZone}; rebasing enabled jobs`;
-            this.logger.log("warn", message);
-            this.rebaseJobs(this.store.listCronJobs().filter((job) => job.enabled && job.kind === "cron"), nowMs);
-        }
-        else {
-            this.rebaseJobs(this.store.listOverdueCronJobs(nowMs), nowMs);
-        }
-        this.store.putStateValue(CRON_EFFECTIVE_TIME_ZONE_KEY, this.effectiveTimeZone, nowMs);
-    }
-    async tickOnce(nowMs = Date.now()) {
-        const capacity = this.config.maxConcurrentRuns - this.runningJobIds.size;
-        if (capacity <= 0) {
-            return;
-        }
-        const dueJobs = this.store.listDueCronJobs(nowMs, capacity);
-        for (const job of dueJobs) {
-            if (this.runningJobIds.has(job.id)) {
-                continue;
-            }
-            this.runningJobIds.add(job.id);
-            void this.executeJob(job, job.nextRunAtMs, nowMs)
-                .catch((error) => {
-                this.logger.log("error", `schedule job ${job.id} failed: ${formatError(error)}`);
-            })
-                .finally(() => {
-                this.runningJobIds.delete(job.id);
-            });
-            if (this.runningJobIds.size >= this.config.maxConcurrentRuns) {
-                return;
-            }
-        }
-    }
-    async executeJob(job, scheduledForMs, nextRunBaseMs) {
-        const startedAtMs = Date.now();
-        if (job.kind === "cron" && nextRunBaseMs !== null) {
-            const nextRunAtMs = computeNextRunAt(this.contract, job, Math.max(nextRunBaseMs, scheduledForMs), this.effectiveTimeZone);
-            this.store.updateCronJobNextRun(job.id, nextRunAtMs, startedAtMs);
-        }
-        else if (job.kind === "once") {
-            this.store.setCronJobEnabled(job.id, false, startedAtMs);
-        }
-        const runId = this.store.insertCronRun(job.id, scheduledForMs, startedAtMs);
-        try {
-            const report = await this.executor.dispatchScheduledJob({
-                jobId: job.id,
-                jobKind: job.kind,
-                conversationKey: conversationKeyForJob(job),
-                prompt: job.prompt,
-                replyTarget: toReplyTarget(job),
-            });
-            this.store.finishCronRun(runId, "succeeded", Date.now(), report.responseText, null);
-            await this.appendScheduleResultToTarget(job, scheduledForMs, {
-                kind: "success",
-                responseText: report.responseText,
-            });
-            return report;
-        }
-        catch (error) {
-            const message = formatError(error);
-            this.store.finishCronRun(runId, "failed", Date.now(), null, message);
-            await this.appendScheduleResultToTarget(job, scheduledForMs, {
-                kind: "failure",
-                errorMessage: message,
-            });
-            throw error;
-        }
-    }
-    async appendScheduleResultToTarget(job, scheduledForMs, outcome) {
-        const replyTarget = toReplyTarget(job);
-        if (replyTarget === null) {
-            return;
-        }
-        try {
-            await this.executor.appendContextToConversation({
-                conversationKey: this.resolveConversationKeyForTarget(replyTarget),
-                replyTarget,
-                body: formatScheduleContextNote(job, scheduledForMs, outcome),
-                recordedAtMs: Date.now(),
-            });
-        }
-        catch (error) {
-            this.logger.log("warn", `failed to append schedule result to ${replyTarget.channel}:${replyTarget.target}: ${formatError(error)}`);
-        }
-    }
-    requireJob(id) {
-        const job = this.store.getCronJob(id);
-        if (job === null) {
-            throw new Error(`unknown schedule job: ${id}`);
-        }
-        return job;
-    }
-    rebaseJobs(jobs, nowMs) {
-        for (const job of jobs) {
-            try {
-                const nextRunAtMs = computeNextRunAt(this.contract, job, nowMs, this.effectiveTimeZone);
-                this.store.updateCronJobNextRun(job.id, nextRunAtMs, nowMs);
-            }
-            catch (error) {
-                this.logger.log("error", `failed to rebase cron job ${job.id}: ${formatError(error)}`);
-            }
-        }
-    }
-    readStoredEffectiveTimeZone() {
-        const stored = this.store.getStateValue(CRON_EFFECTIVE_TIME_ZONE_KEY);
-        if (stored === null) {
-            return null;
-        }
-        try {
-            return this.contract.normalizeCronTimeZone(stored);
-        }
-        catch (error) {
-            this.logger.log("warn", `stored cron time zone is invalid (${stored}); treating as legacy ${LEGACY_CRON_TIME_ZONE}: ${formatError(error)}`);
-            return null;
-        }
-    }
-}
-function normalizeUpsertInput(input) {
-    const id = normalizeId(input.id);
-    const schedule = normalizeRequiredField(input.schedule, "cron schedule");
-    const prompt = normalizeRequiredField(input.prompt, "cron prompt");
-    const deliveryChannel = normalizeOptionalField(input.deliveryChannel);
-    const deliveryTarget = normalizeOptionalField(input.deliveryTarget);
-    const deliveryTopic = normalizeOptionalField(input.deliveryTopic);
-    if ((deliveryChannel === null) !== (deliveryTarget === null)) {
-        throw new Error("cron delivery_channel and delivery_target must be provided together");
-    }
-    if (deliveryChannel === null && deliveryTopic !== null) {
-        throw new Error("cron delivery_topic requires delivery_channel and delivery_target");
-    }
-    if (deliveryChannel !== null && deliveryChannel !== "telegram") {
-        throw new Error(`unsupported cron delivery channel: ${deliveryChannel}`);
-    }
-    return {
-        id,
-        kind: "cron",
-        schedule,
-        runAtMs: null,
-        prompt,
-        enabled: input.enabled,
-        deliveryChannel,
-        deliveryTarget,
-        deliveryTopic,
-        nextRunAtMs: 0,
-        recordedAtMs: 0,
-    };
-}
-function normalizeOnceInput(input) {
-    const id = normalizeId(input.id);
-    const prompt = normalizeRequiredField(input.prompt, "schedule prompt");
-    const deliveryChannel = normalizeOptionalField(input.deliveryChannel);
-    const deliveryTarget = normalizeOptionalField(input.deliveryTarget);
-    const deliveryTopic = normalizeOptionalField(input.deliveryTopic);
-    if ((deliveryChannel === null) !== (deliveryTarget === null)) {
-        throw new Error("schedule delivery_channel and delivery_target must be provided together");
-    }
-    if (deliveryChannel === null && deliveryTopic !== null) {
-        throw new Error("schedule delivery_topic requires delivery_channel and delivery_target");
-    }
-    if (deliveryChannel !== null && deliveryChannel !== "telegram") {
-        throw new Error(`unsupported schedule delivery channel: ${deliveryChannel}`);
-    }
-    const runAtMs = resolveOnceRunAt(input);
-    return {
-        id,
-        kind: "once",
-        schedule: null,
-        runAtMs,
-        prompt,
-        enabled: true,
-        deliveryChannel,
-        deliveryTarget,
-        deliveryTopic,
-        nextRunAtMs: runAtMs,
-        recordedAtMs: 0,
-    };
-}
-function resolveOnceRunAt(input) {
-    if (input.delaySeconds === null && input.runAtMs === null) {
-        throw new Error("schedule_once requires delay_seconds or run_at_ms");
-    }
-    if (input.delaySeconds !== null && input.runAtMs !== null) {
-        throw new Error("schedule_once accepts only one of delay_seconds or run_at_ms");
-    }
-    if (input.runAtMs !== null) {
-        if (!Number.isSafeInteger(input.runAtMs) || input.runAtMs < 0) {
-            throw new Error("schedule run_at_ms must be a non-negative integer");
-        }
-        return input.runAtMs;
-    }
-    const delaySeconds = input.delaySeconds ?? 0;
-    if (!Number.isSafeInteger(delaySeconds) || delaySeconds < 0) {
-        throw new Error("schedule delay_seconds must be a non-negative integer");
-    }
-    return Date.now() + delaySeconds * 1_000;
-}
-function normalizeId(id) {
-    return normalizeRequiredField(id, "schedule id");
-}
-function normalizeRequiredField(value, field) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function normalizeOptionalField(value) {
-    if (value === null) {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function toBindingCronJobSpec(job) {
-    return {
-        id: job.id,
-        schedule: normalizeRequiredField(job.schedule ?? "", "cron schedule"),
-        prompt: job.prompt,
-        deliveryChannel: job.deliveryChannel,
-        deliveryTarget: job.deliveryTarget,
-        deliveryTopic: job.deliveryTopic,
-    };
-}
-function computeNextRunAt(contract, job, afterMs, timeZone) {
-    const nextRunAt = contract.nextCronRunAt(toBindingCronJobSpec(job), afterMs, timeZone);
-    if (!Number.isSafeInteger(nextRunAt) || nextRunAt < 0) {
-        throw new Error(`next cron run at is out of range for JavaScript: ${nextRunAt}`);
-    }
-    return nextRunAt;
-}
-function sleep(durationMs) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, durationMs);
-    });
-}
-function clampStatusLimit(limit) {
-    if (!Number.isSafeInteger(limit) || limit <= 0) {
-        throw new Error("schedule_status limit must be a positive integer");
-    }
-    return Math.min(limit, MAX_STATUS_RUNS);
-}
-function deriveJobState(job, latestRun) {
-    if (latestRun?.status === "running") {
-        return "running";
-    }
-    if (job.enabled) {
-        return "scheduled";
-    }
-    if (latestRun !== null) {
-        return latestRun.status;
-    }
-    return "canceled";
-}
-function isTerminalJob(job) {
-    return !job.enabled;
-}
-function toReplyTarget(job) {
-    if (job.deliveryChannel === null || job.deliveryTarget === null) {
-        return null;
-    }
-    return {
-        channel: job.deliveryChannel,
-        target: job.deliveryTarget,
-        topic: job.deliveryTopic,
-    };
-}
-function conversationKeyForJob(job) {
-    return job.kind === "cron" ? `cron:${job.id}` : `once:${job.id}`;
-}
-function formatScheduleContextNote(job, scheduledForMs, outcome) {
-    const header = [
-        "[Gateway schedule result]",
-        `job_id=${job.id}`,
-        `job_kind=${job.kind}`,
-        `scheduled_for_ms=${scheduledForMs}`,
-    ];
-    if (outcome.kind === "success") {
-        return [...header, "status=succeeded", "", outcome.responseText].join("\n");
-    }
-    return [...header, "status=failed", "", outcome.errorMessage].join("\n");
-}

package/dist/delivery/telegram.js

@@ -1,75 +0,0 @@
-import { readTelegramChatType, recordTelegramChatType, recordTelegramDraftFailure, recordTelegramDraftSuccess, recordTelegramStreamFallback, } from "../telegram/state";
-import { formatError } from "../utils/error";
-export class TelegramProgressiveSupport {
-    client;
-    store;
-    logger;
-    constructor(client, store, logger) {
-        this.client = client;
-        this.store = store;
-        this.logger = logger;
-    }
-    async resolveMode(target, preference) {
-        if (target.channel !== "telegram" || preference === "oneshot") {
-            return "oneshot";
-        }
-        const isPrivateChat = await this.isPrivateChat(target.target);
-        if (preference === "stream") {
-            if (!isPrivateChat) {
-                throw new Error("telegram draft stream is only supported for private chats");
-            }
-            return "progressive";
-        }
-        if (!isPrivateChat) {
-            recordTelegramStreamFallback(this.store, "non_private_chat", Date.now());
-            return "oneshot";
-        }
-        return "progressive";
-    }
-    async sendDraft(target, draftId, text) {
-        if (this.client === null) {
-            throw new Error("telegram transport is not configured");
-        }
-        try {
-            await this.client.sendMessageDraft(target.target, draftId, text, target.topic);
-            recordTelegramDraftSuccess(this.store, Date.now());
-        }
-        catch (error) {
-            const message = formatError(error);
-            recordTelegramDraftFailure(this.store, message, Date.now());
-            recordTelegramStreamFallback(this.store, "draft_send_failed", Date.now());
-            this.logger.log("warn", `telegram draft send failed: ${message}`);
-            throw error;
-        }
-    }
-    startTyping(target) {
-        if (this.client === null) {
-            return;
-        }
-        void this.client.sendChatAction(target.target, "typing", target.topic).catch(() => {
-            // Typing hints are best-effort only.
-        });
-    }
-    async isPrivateChat(chatId) {
-        const cachedChatType = readTelegramChatType(this.store, chatId);
-        if (cachedChatType !== null) {
-            return cachedChatType === "private";
-        }
-        if (this.client === null) {
-            return false;
-        }
-        try {
-            const chat = await this.client.getChat(chatId);
-            recordTelegramChatType(this.store, chatId, chat.type, Date.now());
-            return chat.type === "private";
-        }
-        catch (error) {
-            this.logger.log("warn", `failed to resolve Telegram chat type for ${chatId}: ${formatError(error)}`);
-            return false;
-        }
-    }
-}
-export function createDraftId() {
-    const draftId = crypto.getRandomValues(new Uint32Array(1))[0];
-    return draftId === 0 ? 1 : draftId;
-}

package/dist/delivery/text.js

@@ -1,175 +0,0 @@
-import { recordTelegramPreviewEmit, recordTelegramStreamFallback } from "../telegram/state";
-import { createDraftId } from "./telegram";
-export class GatewayTextDelivery {
-    transport;
-    store;
-    telegramSupport;
-    constructor(transport, store, telegramSupport) {
-        this.transport = transport;
-        this.store = store;
-        this.telegramSupport = telegramSupport;
-    }
-    async open(target, preference) {
-        const [session] = await this.openMany([target], preference);
-        return session;
-    }
-    async openMany(targets, preference) {
-        const uniqueTargets = dedupeTargets(targets);
-        if (uniqueTargets.length === 0) {
-            return [new NoopTextDeliverySession()];
-        }
-        const sessions = await Promise.all(uniqueTargets.map(async (target) => {
-            const mode = await this.telegramSupport.resolveMode(target, preference);
-            if (mode === "progressive") {
-                const session = new ProgressiveTextDeliverySession(target, this.transport, this.telegramSupport, this.store);
-                session.start();
-                return session;
-            }
-            return new OneshotTextDeliverySession(target, this.transport);
-        }));
-        if (sessions.length === 1) {
-            return sessions;
-        }
-        return [new FanoutTextDeliverySession(sessions)];
-    }
-    async sendTest(target, text, preference) {
-        const session = await this.open(target, preference);
-        if (session.mode === "progressive") {
-            await session.preview(text.slice(0, Math.max(1, Math.ceil(text.length / 2))));
-        }
-        return {
-            delivered: await session.finish(text),
-            mode: session.mode,
-        };
-    }
-}
-class NoopTextDeliverySession {
-    mode = "oneshot";
-    async preview(_text) { }
-    async finish(_finalText) {
-        return false;
-    }
-}
-class FanoutTextDeliverySession {
-    sessions;
-    mode;
-    constructor(sessions) {
-        this.sessions = sessions;
-        this.mode = sessions.some((session) => session.mode === "progressive") ? "progressive" : "oneshot";
-    }
-    async preview(text) {
-        await Promise.all(this.sessions.map((session) => session.preview(text)));
-    }
-    async finish(finalText) {
-        const results = await Promise.allSettled(this.sessions.map((session) => session.finish(finalText)));
-        const firstFailure = results.find((result) => result.status === "rejected");
-        if (firstFailure?.status === "rejected") {
-            throw firstFailure.reason;
-        }
-        return results.some((result) => result.status === "fulfilled" && result.value);
-    }
-}
-class OneshotTextDeliverySession {
-    target;
-    transport;
-    mode = "oneshot";
-    constructor(target, transport) {
-        this.target = target;
-        this.transport = transport;
-    }
-    async preview(_text) { }
-    async finish(finalText) {
-        if (finalText === null || finalText.trim().length === 0) {
-            return false;
-        }
-        const ack = await this.transport.sendMessage({
-            deliveryTarget: this.target,
-            body: finalText,
-        });
-        if (ack.errorMessage !== null) {
-            throw new Error(ack.errorMessage);
-        }
-        return true;
-    }
-}
-class ProgressiveTextDeliverySession {
-    target;
-    transport;
-    telegramSupport;
-    store;
-    mode = "progressive";
-    previewFailed = false;
-    previewDelivered = false;
-    closed = false;
-    pendingPreviewCount = 0;
-    pendingPreview = Promise.resolve();
-    draftId = createDraftId();
-    constructor(target, transport, telegramSupport, store) {
-        this.target = target;
-        this.transport = transport;
-        this.telegramSupport = telegramSupport;
-        this.store = store;
-    }
-    start() {
-        this.telegramSupport.startTyping(this.target);
-    }
-    async preview(text) {
-        if (this.previewFailed || this.closed || text.trim().length === 0) {
-            return;
-        }
-        const runPreview = async () => {
-            try {
-                if (this.previewFailed || this.closed) {
-                    return;
-                }
-                try {
-                    recordTelegramPreviewEmit(this.store, Date.now());
-                    await this.telegramSupport.sendDraft(this.target, this.draftId, text);
-                    this.previewDelivered = true;
-                }
-                catch {
-                    this.previewFailed = true;
-                }
-            }
-            finally {
-                this.pendingPreviewCount = Math.max(0, this.pendingPreviewCount - 1);
-            }
-        };
-        this.pendingPreviewCount += 1;
-        this.pendingPreview = this.pendingPreview.then(runPreview, runPreview);
-        await this.pendingPreview;
-    }
-    async finish(finalText) {
-        this.closed = true;
-        if (this.pendingPreviewCount > 0) {
-            await this.pendingPreview;
-        }
-        if (finalText === null || finalText.trim().length === 0) {
-            return false;
-        }
-        if (!this.previewDelivered && !this.previewFailed) {
-            recordTelegramStreamFallback(this.store, "preview_not_established", Date.now());
-        }
-        const ack = await this.transport.sendMessage({
-            deliveryTarget: this.target,
-            body: finalText,
-        });
-        if (ack.errorMessage !== null) {
-            throw new Error(ack.errorMessage);
-        }
-        return true;
-    }
-}
-function dedupeTargets(targets) {
-    const seen = new Set();
-    const unique = [];
-    for (const target of targets) {
-        const key = `${target.channel}:${target.target}:${target.topic ?? ""}`;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        unique.push(target);
-    }
-    return unique;
-}