opencode-gateway 0.2.3 → 0.2.4

package/dist/config/memory.js

@@ -1,105 +0,0 @@
-import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
-export async function parseMemoryConfig(value, workspaceDirPath) {
-    const table = readMemoryTable(value);
-    const entries = await readMemoryEntries(table.entries, workspaceDirPath);
-    return { entries };
-}
-function readMemoryTable(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("memory must be a table when present");
-    }
-    return value;
-}
-async function readMemoryEntries(value, workspaceDirPath) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error("memory.entries must be an array when present");
-    }
-    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, workspaceDirPath)));
-}
-async function readMemoryEntry(value, index, workspaceDirPath) {
-    const field = `memory.entries[${index}]`;
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error(`${field} must be a table`);
-    }
-    const entry = value;
-    const displayPath = readRequiredString(entry.path, `${field}.path`);
-    const description = readRequiredString(entry.description, `${field}.description`);
-    const resolvedPath = resolve(workspaceDirPath, displayPath);
-    const metadata = await statPath(resolvedPath, `${field}.path`);
-    if (metadata.isFile()) {
-        ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
-        ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
-        return {
-            kind: "file",
-            path: resolvedPath,
-            displayPath,
-            description,
-            injectContent: readBoolean(entry.inject_content, `${field}.inject_content`, false),
-        };
-    }
-    if (metadata.isDirectory()) {
-        ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
-        return {
-            kind: "directory",
-            path: resolvedPath,
-            displayPath,
-            description,
-            injectMarkdownContents: readBoolean(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
-            globs: readGlobList(entry.globs, `${field}.globs`),
-        };
-    }
-    throw new Error(`${field}.path must point to a regular file or directory`);
-}
-async function statPath(path, field) {
-    try {
-        return await stat(path);
-    }
-    catch (error) {
-        throw new Error(`${field} does not exist: ${path}`, { cause: error });
-    }
-}
-function ensureDirectoryOnlyFieldIsAbsent(value, field) {
-    if (value !== undefined) {
-        throw new Error(`${field} is only valid for directory entries`);
-    }
-}
-function ensureFileOnlyFieldIsAbsent(value, field) {
-    if (value !== undefined) {
-        throw new Error(`${field} is only valid for file entries`);
-    }
-}
-function readBoolean(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "boolean") {
-        throw new Error(`${field} must be a boolean when present`);
-    }
-    return value;
-}
-function readGlobList(value, field) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array when present`);
-    }
-    return value.map((entry, index) => readRequiredString(entry, `${field}[${index}]`));
-}
-function readRequiredString(value, field) {
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}

package/dist/config/paths.js

@@ -1,39 +0,0 @@
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-export const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
-export const OPENCODE_CONFIG_FILE = "opencode.json";
-export const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
-export const OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
-export const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
-export function resolveGatewayConfigPath(env) {
-    const explicit = env.OPENCODE_GATEWAY_CONFIG;
-    if (explicit && explicit.trim().length > 0) {
-        return resolve(explicit);
-    }
-    return join(resolveOpencodeConfigDir(env), GATEWAY_CONFIG_FILE);
-}
-export function resolveOpencodeConfigDir(env) {
-    const explicit = env.OPENCODE_CONFIG_DIR;
-    if (explicit && explicit.trim().length > 0) {
-        return resolve(explicit);
-    }
-    return defaultOpencodeConfigDir(env);
-}
-export function resolveManagedOpencodeConfigDir(env) {
-    return join(resolveConfigHome(env), "opencode-gateway", "opencode");
-}
-export function resolveGatewayWorkspacePath(configPath) {
-    return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
-}
-export function defaultGatewayStateDbPath(env) {
-    return join(resolveDataHome(env), "opencode-gateway", "state.db");
-}
-export function resolveConfigHome(env) {
-    return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-}
-export function resolveDataHome(env) {
-    return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-}
-function defaultOpencodeConfigDir(env) {
-    return join(resolveConfigHome(env), "opencode");
-}

package/dist/config/telegram.js

@@ -1,91 +0,0 @@
-export function parseTelegramConfig(value, env) {
-    const table = readTelegramTable(value);
-    const enabled = readBoolean(table.enabled, "channels.telegram.enabled", false);
-    if (!enabled) {
-        return { enabled: false };
-    }
-    const botTokenEnv = readString(table.bot_token_env, "channels.telegram.bot_token_env", "TELEGRAM_BOT_TOKEN");
-    const pollTimeoutSeconds = readPollTimeoutSeconds(table.poll_timeout_seconds);
-    const allowedChats = readIdentifierList(table.allowed_chats, "channels.telegram.allowed_chats");
-    const allowedUsers = readIdentifierList(table.allowed_users, "channels.telegram.allowed_users");
-    const botToken = env[botTokenEnv]?.trim();
-    if (!botToken) {
-        throw new Error(`Telegram is enabled but ${botTokenEnv} is not set`);
-    }
-    if (allowedChats.length === 0 && allowedUsers.length === 0) {
-        throw new Error("Telegram is enabled but no allowlist entries were configured");
-    }
-    return {
-        enabled: true,
-        botToken,
-        botTokenEnv,
-        pollTimeoutSeconds,
-        allowedChats,
-        allowedUsers,
-    };
-}
-function readTelegramTable(value) {
-    if (value === undefined) {
-        return {};
-    }
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("channels.telegram must be a table when present");
-    }
-    return value;
-}
-function readBoolean(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "boolean") {
-        throw new Error(`${field} must be a boolean when present`);
-    }
-    return value;
-}
-function readString(value, field, fallback) {
-    if (value === undefined) {
-        return fallback;
-    }
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string when present`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function readPollTimeoutSeconds(value) {
-    if (value === undefined) {
-        return 25;
-    }
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-        throw new Error("channels.telegram.poll_timeout_seconds must be an integer when present");
-    }
-    if (value < 1 || value > 50) {
-        throw new Error("channels.telegram.poll_timeout_seconds must be between 1 and 50");
-    }
-    return value;
-}
-function readIdentifierList(value, field) {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array when present`);
-    }
-    return value.map((entry) => normalizeIdentifier(entry, field));
-}
-function normalizeIdentifier(value, field) {
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed.length === 0) {
-            throw new Error(`${field} entries must not be empty`);
-        }
-        return trimmed;
-    }
-    if (typeof value === "number" && Number.isSafeInteger(value)) {
-        return String(value);
-    }
-    throw new Error(`${field} entries must be strings or safe integers`);
-}

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");
-}