opencode-gateway 0.2.2 → 0.2.4

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

package/dist/memory/prompt.js

@@ -1,122 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { extname, relative } from "node:path";
-const MARKDOWN_GLOBS = ["**/*.md", "**/*.markdown"];
-const UTF8_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
-export class GatewayMemoryPromptProvider {
-    config;
-    logger;
-    constructor(config, logger) {
-        this.config = config;
-        this.logger = logger;
-    }
-    async buildPrompt() {
-        if (this.config.entries.length === 0) {
-            return null;
-        }
-        const sections = await Promise.all(this.config.entries.map((entry) => this.buildEntrySection(entry)));
-        return ["Gateway memory:", ...sections].join("\n\n");
-    }
-    async buildEntrySection(entry) {
-        const lines = [`Configured path: ${entry.displayPath}`, `Description: ${entry.description}`];
-        const injectedFiles = await collectInjectedFiles(entry, this.logger);
-        for (const file of injectedFiles) {
-            lines.push("");
-            lines.push(`File: ${file.displayPath}`);
-            lines.push(codeFence(file.infoString, file.text));
-        }
-        return lines.join("\n");
-    }
-}
-async function collectInjectedFiles(entry, logger) {
-    if (entry.kind === "file") {
-        if (!entry.injectContent) {
-            return [];
-        }
-        const text = await readTextFile(entry.path, logger);
-        if (text === null) {
-            return [];
-        }
-        return [
-            {
-                displayPath: entry.displayPath,
-                infoString: inferFenceInfoString(entry.path),
-                text,
-            },
-        ];
-    }
-    const filePaths = new Set();
-    if (entry.injectMarkdownContents) {
-        for (const pattern of MARKDOWN_GLOBS) {
-            addMatchingFiles(filePaths, entry.path, pattern);
-        }
-    }
-    for (const pattern of entry.globs) {
-        addMatchingFiles(filePaths, entry.path, pattern);
-    }
-    const injectedFiles = [];
-    for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
-        const text = await readTextFile(filePath, logger);
-        if (text === null) {
-            continue;
-        }
-        injectedFiles.push({
-            displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
-            infoString: inferFenceInfoString(filePath),
-            text,
-        });
-    }
-    return injectedFiles;
-}
-function addMatchingFiles(result, cwd, pattern) {
-    const glob = new Bun.Glob(pattern);
-    for (const match of glob.scanSync({ cwd, absolute: true, onlyFiles: true })) {
-        result.add(match);
-    }
-}
-async function readTextFile(path, logger) {
-    let bytes;
-    try {
-        bytes = await readFile(path);
-    }
-    catch (error) {
-        logger.log("warn", `memory file could not be read and will be skipped: ${path}: ${formatError(error)}`);
-        return null;
-    }
-    let text;
-    try {
-        text = UTF8_TEXT_DECODER.decode(bytes);
-    }
-    catch {
-        logger.log("warn", `memory file is not valid UTF-8 and will be skipped: ${path}`);
-        return null;
-    }
-    if (text.includes("\u0000")) {
-        logger.log("warn", `memory file looks binary and will be skipped: ${path}`);
-        return null;
-    }
-    return text;
-}
-function relativeDisplayPath(rootPath, rootDisplayPath, filePath) {
-    const suffix = relative(rootPath, filePath);
-    if (suffix.length === 0) {
-        return rootDisplayPath;
-    }
-    return `${rootDisplayPath}/${suffix.replaceAll("\\", "/")}`;
-}
-function inferFenceInfoString(path) {
-    const extension = extname(path).slice(1).toLowerCase();
-    if (!/^[a-z0-9_+-]+$/.test(extension)) {
-        return "";
-    }
-    return extension;
-}
-function codeFence(infoString, text) {
-    const language = infoString.length === 0 ? "" : infoString;
-    return [`\`\`\`${language}`, text, "```"].join("\n");
-}
-function formatError(error) {
-    if (error instanceof Error && error.message.trim().length > 0) {
-        return error.message;
-    }
-    return String(error);
-}