opencode-gateway 0.2.3 → 0.2.4

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

package/dist/gateway.js

@@ -1,117 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { loadGatewayConfig } from "./config/gateway";
-import { GatewayCronRuntime } from "./cron/runtime";
-import { TelegramProgressiveSupport } from "./delivery/telegram";
-import { GatewayTextDelivery } from "./delivery/text";
-import { ChannelFileSender } from "./host/file-sender";
-import { ConsoleLoggerHost } from "./host/logger";
-import { GatewayTransportHost } from "./host/transport";
-import { GatewayMailboxRouter } from "./mailbox/router";
-import { GatewayMemoryPromptProvider } from "./memory/prompt";
-import { OpencodeSdkAdapter } from "./opencode/adapter";
-import { OpencodeEventStream } from "./opencode/event-stream";
-import { OpencodeEventHub } from "./opencode/events";
-import { createQuestionClient } from "./questions/client";
-import { GatewayQuestionRuntime } from "./questions/runtime";
-import { GatewayExecutor } from "./runtime/executor";
-import { GatewayMailboxRuntime } from "./runtime/mailbox";
-import { getOrCreateRuntimeSingleton } from "./runtime/runtime-singleton";
-import { GatewaySessionContext } from "./session/context";
-import { resolveConversationKeyForTarget } from "./session/conversation-key";
-import { ChannelSessionSwitcher } from "./session/switcher";
-import { GatewaySystemPromptBuilder } from "./session/system-prompt";
-import { openSqliteStore } from "./store/sqlite";
-import { TelegramBotClient } from "./telegram/client";
-import { TelegramInboundMediaStore } from "./telegram/media";
-import { TelegramPollingService } from "./telegram/poller";
-import { GatewayTelegramRuntime } from "./telegram/runtime";
-export class GatewayPluginRuntime {
-    contract;
-    executor;
-    cron;
-    telegram;
-    files;
-    channelSessions;
-    sessionContext;
-    systemPrompts;
-    constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts) {
-        this.contract = contract;
-        this.executor = executor;
-        this.cron = cron;
-        this.telegram = telegram;
-        this.files = files;
-        this.channelSessions = channelSessions;
-        this.sessionContext = sessionContext;
-        this.systemPrompts = systemPrompts;
-    }
-    status() {
-        const rustStatus = this.contract.gatewayStatus();
-        return {
-            runtimeMode: rustStatus.runtimeMode,
-            supportsTelegram: rustStatus.supportsTelegram,
-            supportsCron: rustStatus.supportsCron,
-            hasWebUi: rustStatus.hasWebUi,
-            cronTimezone: this.cron.timeZone(),
-            cronEnabled: this.cron.isEnabled(),
-            cronPolling: this.cron.isRunning(),
-            cronRunningJobs: this.cron.runningJobs(),
-            telegramEnabled: this.telegram.isEnabled(),
-            telegramPolling: this.telegram.isPolling(),
-            telegramAllowlistMode: this.telegram.allowlistMode(),
-        };
-    }
-}
-export async function createGatewayRuntime(module, input) {
-    const config = await loadGatewayConfig();
-    return await getOrCreateRuntimeSingleton(config.configPath, async () => {
-        await mkdir(config.workspaceDirPath, { recursive: true });
-        const logger = new ConsoleLoggerHost(config.logLevel);
-        if (config.hasLegacyGatewayTimezone) {
-            const suffix = config.legacyGatewayTimezone === null ? "" : ` (${config.legacyGatewayTimezone})`;
-            logger.log("warn", `gateway.timezone${suffix} is ignored; use cron.timezone instead`);
-        }
-        const effectiveCronTimeZone = resolveEffectiveCronTimeZone(module, config);
-        const store = await openSqliteStore(config.stateDbPath);
-        const sessionContext = new GatewaySessionContext(store);
-        const memoryPrompts = new GatewayMemoryPromptProvider(config.memory, logger);
-        const systemPrompts = new GatewaySystemPromptBuilder(sessionContext, memoryPrompts);
-        const telegramClient = config.telegram.enabled ? new TelegramBotClient(config.telegram.botToken) : null;
-        const telegramMediaStore = config.telegram.enabled && telegramClient !== null
-            ? new TelegramInboundMediaStore(telegramClient, config.mediaRootPath)
-            : null;
-        const mailboxRouter = new GatewayMailboxRouter(config.mailbox.routes);
-        const opencodeEvents = new OpencodeEventHub();
-        const opencode = new OpencodeSdkAdapter(input.client, config.workspaceDirPath);
-        const questionClient = createQuestionClient(input.client, input.serverUrl, config.workspaceDirPath);
-        const transport = new GatewayTransportHost(telegramClient, store);
-        const files = new ChannelFileSender(telegramClient);
-        const channelSessions = new ChannelSessionSwitcher(store, sessionContext, mailboxRouter, module, opencode, config.telegram.enabled);
-        const questions = new GatewayQuestionRuntime(questionClient, config.workspaceDirPath, store, sessionContext, transport, telegramClient, logger);
-        const progressiveSupport = new TelegramProgressiveSupport(telegramClient, store, logger);
-        const delivery = new GatewayTextDelivery(transport, store, progressiveSupport);
-        const executor = new GatewayExecutor(module, store, opencode, opencodeEvents, delivery, logger);
-        const mailbox = new GatewayMailboxRuntime(executor, store, logger, config.mailbox, questions);
-        const cron = new GatewayCronRuntime(executor, module, store, logger, config.cron, effectiveCronTimeZone, (target) => resolveConversationKeyForTarget(target, mailboxRouter, module));
-        const eventStream = new OpencodeEventStream(input.client, config.workspaceDirPath, opencodeEvents, [questions], logger);
-        const telegramPolling = config.telegram.enabled && telegramClient !== null && telegramMediaStore !== null
-            ? new TelegramPollingService(telegramClient, mailbox, store, logger, config.telegram, mailboxRouter, telegramMediaStore, questions)
-            : null;
-        const telegram = new GatewayTelegramRuntime(telegramClient, delivery, store, logger, config.telegram, telegramPolling, eventStream);
-        eventStream.start();
-        cron.start();
-        mailbox.start();
-        telegram.start();
-        return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts);
-    });
-}
-function resolveEffectiveCronTimeZone(module, config) {
-    const candidate = config.cron.timezone ?? resolveRuntimeLocalTimeZone();
-    return module.normalizeCronTimeZone(candidate);
-}
-function resolveRuntimeLocalTimeZone() {
-    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    if (typeof timeZone !== "string" || timeZone.trim().length === 0) {
-        throw new Error("runtime local time zone could not be determined");
-    }
-    return timeZone;
-}

package/dist/host/file-sender.js

@@ -1,59 +0,0 @@
-import { stat } from "node:fs/promises";
-import { isAbsolute } from "node:path";
-import { inferLocalFileMimeType, isImageMimeType } from "../media/mime";
-export class ChannelFileSender {
-    telegramClient;
-    constructor(telegramClient) {
-        this.telegramClient = telegramClient;
-    }
-    hasEnabledChannel() {
-        return this.telegramClient !== null;
-    }
-    async sendFile(target, filePath, caption) {
-        const normalizedPath = normalizeAbsoluteFilePath(filePath);
-        await assertRegularFile(normalizedPath);
-        const mimeType = await inferLocalFileMimeType(normalizedPath);
-        if (target.channel !== "telegram") {
-            throw new Error(`unsupported outbound channel: ${target.channel}`);
-        }
-        if (this.telegramClient === null) {
-            throw new Error("telegram transport is not configured");
-        }
-        if (isImageMimeType(mimeType)) {
-            await this.telegramClient.sendPhoto(target.target, normalizedPath, caption, target.topic, mimeType);
-            return {
-                channel: target.channel,
-                target: target.target,
-                topic: target.topic,
-                filePath: normalizedPath,
-                mimeType,
-                deliveryKind: "photo",
-            };
-        }
-        await this.telegramClient.sendDocument(target.target, normalizedPath, caption, target.topic, mimeType);
-        return {
-            channel: target.channel,
-            target: target.target,
-            topic: target.topic,
-            filePath: normalizedPath,
-            mimeType,
-            deliveryKind: "document",
-        };
-    }
-}
-function normalizeAbsoluteFilePath(filePath) {
-    const trimmed = filePath.trim();
-    if (trimmed.length === 0) {
-        throw new Error("file_path must not be empty");
-    }
-    if (!isAbsolute(trimmed)) {
-        throw new Error("file_path must be an absolute path");
-    }
-    return trimmed;
-}
-async function assertRegularFile(filePath) {
-    const metadata = await stat(filePath);
-    if (!metadata.isFile()) {
-        throw new Error(`file_path is not a regular file: ${filePath}`);
-    }
-}

package/dist/host/logger.js

@@ -1,53 +0,0 @@
-const LOG_LEVEL_PRIORITY = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 40,
-};
-export class ConsoleLoggerHost {
-    threshold;
-    constructor(threshold) {
-        this.threshold = threshold;
-    }
-    log(level, message) {
-        if (!shouldLog(level, this.threshold)) {
-            return;
-        }
-        const line = `[gateway:${level}] ${message}`;
-        switch (level) {
-            case "error":
-                console.error(line);
-                return;
-            case "warn":
-                console.warn(line);
-                return;
-            default:
-                console.info(line);
-        }
-    }
-}
-export function parseGatewayLogLevel(value, field) {
-    if (value === undefined) {
-        return "off";
-    }
-    if (typeof value !== "string") {
-        throw new Error(`${field} must be a string when present`);
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "off") {
-        return "off";
-    }
-    if (isBindingLogLevel(normalized)) {
-        return normalized;
-    }
-    throw new Error(`${field} must be one of: off, error, warn, info, debug`);
-}
-function shouldLog(level, threshold) {
-    if (threshold === "off") {
-        return false;
-    }
-    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[threshold];
-}
-function isBindingLogLevel(value) {
-    return value === "debug" || value === "info" || value === "warn" || value === "error";
-}

package/dist/host/transport.js

@@ -1,35 +0,0 @@
-import { recordTelegramSendFailure, recordTelegramSendSuccess } from "../telegram/state";
-import { formatError } from "../utils/error";
-export class GatewayTransportHost {
-    telegramClient;
-    store;
-    constructor(telegramClient, store) {
-        this.telegramClient = telegramClient;
-        this.store = store;
-    }
-    async sendMessage(message) {
-        try {
-            if (message.deliveryTarget.channel !== "telegram") {
-                throw new Error(`unsupported outbound channel: ${message.deliveryTarget.channel}`);
-            }
-            if (this.telegramClient === null) {
-                throw new Error("telegram transport is not configured");
-            }
-            const body = message.body.trim();
-            if (body.length === 0) {
-                throw new Error("telegram outbound message body must not be empty");
-            }
-            await this.telegramClient.sendMessage(message.deliveryTarget.target, body, message.deliveryTarget.topic);
-            recordTelegramSendSuccess(this.store, Date.now());
-            return {
-                errorMessage: null,
-            };
-        }
-        catch (error) {
-            recordTelegramSendFailure(this.store, formatError(error), Date.now());
-            return {
-                errorMessage: formatError(error),
-            };
-        }
-    }
-}

package/dist/mailbox/router.js

@@ -1,16 +0,0 @@
-export class GatewayMailboxRouter {
-    routes;
-    constructor(routes) {
-        this.routes = routes;
-    }
-    resolve(target) {
-        for (const route of this.routes) {
-            if (route.channel === target.channel &&
-                route.target === target.target &&
-                route.topic === (target.topic ?? null)) {
-                return route.mailboxKey;
-            }
-        }
-        return null;
-    }
-}

package/dist/media/mime.js

@@ -1,45 +0,0 @@
-import { open } from "node:fs/promises";
-const FALLBACK_MIME_TYPE = "application/octet-stream";
-export async function inferLocalFileMimeType(filePath) {
-    const bunMimeType = Bun.file(filePath).type.trim();
-    if (bunMimeType.length > 0 && bunMimeType !== FALLBACK_MIME_TYPE) {
-        return bunMimeType;
-    }
-    const header = await readFileHeader(filePath, 16);
-    return inferImageMimeTypeFromHeader(header) ?? (bunMimeType.length > 0 ? bunMimeType : FALLBACK_MIME_TYPE);
-}
-export function isImageMimeType(mimeType) {
-    return mimeType.startsWith("image/");
-}
-async function readFileHeader(filePath, length) {
-    const file = await open(filePath, "r");
-    try {
-        const buffer = new Uint8Array(length);
-        const result = await file.read(buffer, 0, length, 0);
-        return buffer.subarray(0, result.bytesRead);
-    }
-    finally {
-        await file.close();
-    }
-}
-function inferImageMimeTypeFromHeader(header) {
-    if (matchesPrefix(header, [0xff, 0xd8, 0xff])) {
-        return "image/jpeg";
-    }
-    if (matchesPrefix(header, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
-        return "image/png";
-    }
-    if (matchesAsciiPrefix(header, "GIF87a") || matchesAsciiPrefix(header, "GIF89a")) {
-        return "image/gif";
-    }
-    if (matchesAsciiPrefix(header, "RIFF") && matchesAsciiPrefix(header.subarray(8), "WEBP")) {
-        return "image/webp";
-    }
-    return null;
-}
-function matchesPrefix(header, prefix) {
-    return prefix.every((byte, index) => header[index] === byte);
-}
-function matchesAsciiPrefix(header, prefix) {
-    return prefix.split("").every((char, index) => header[index] === char.charCodeAt(0));
-}