opencode-gateway 0.1.0

package/dist/gateway.js

@@ -0,0 +1,105 @@
+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/noop";
+import { GatewayTransportHost } from "./host/transport";
+import { GatewayMailboxRouter } from "./mailbox/router";
+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 { GatewaySessionContext } from "./session/context";
+import { ChannelSessionSwitcher } from "./session/switcher";
+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;
+    constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext) {
+        this.contract = contract;
+        this.executor = executor;
+        this.cron = cron;
+        this.telegram = telegram;
+        this.files = files;
+        this.channelSessions = channelSessions;
+        this.sessionContext = sessionContext;
+    }
+    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();
+    const logger = new ConsoleLoggerHost();
+    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 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, input.directory);
+    const questionClient = createQuestionClient(input.client, input.serverUrl, input.directory);
+    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, input.directory, 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);
+    const eventStream = new OpencodeEventStream(input.client, input.directory, 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);
+}
+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.d.ts

@@ -0,0 +1,16 @@
+import type { BindingDeliveryTarget } from "../binding";
+import type { TelegramFileSendClientLike } from "../telegram/client";
+export type ChannelFileSendResult = {
+    channel: string;
+    target: string;
+    topic: string | null;
+    filePath: string;
+    mimeType: string;
+    deliveryKind: "photo" | "document";
+};
+export declare class ChannelFileSender {
+    private readonly telegramClient;
+    constructor(telegramClient: TelegramFileSendClientLike | null);
+    hasEnabledChannel(): boolean;
+    sendFile(target: BindingDeliveryTarget, filePath: string, caption: string | null): Promise<ChannelFileSendResult>;
+}

package/dist/host/file-sender.js

@@ -0,0 +1,59 @@
+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/noop.d.ts

@@ -0,0 +1,4 @@
+import type { BindingLoggerHost } from "../binding";
+export declare class ConsoleLoggerHost implements BindingLoggerHost {
+    log(level: string, message: string): void;
+}

package/dist/host/noop.js

@@ -0,0 +1,14 @@
+export class ConsoleLoggerHost {
+    log(level, message) {
+        const line = `[gateway:${level}] ${message}`;
+        if (level === "error") {
+            console.error(line);
+            return;
+        }
+        if (level === "warn") {
+            console.warn(line);
+            return;
+        }
+        console.info(line);
+    }
+}

package/dist/host/transport.d.ts

@@ -0,0 +1,9 @@
+import type { BindingHostAck, BindingOutboundMessage, BindingTransportHost } from "../binding";
+import type { SqliteStore } from "../store/sqlite";
+import type { TelegramSendClientLike } from "../telegram/client";
+export declare class GatewayTransportHost implements BindingTransportHost {
+    private readonly telegramClient;
+    private readonly store;
+    constructor(telegramClient: TelegramSendClientLike | null, store: SqliteStore);
+    sendMessage(message: BindingOutboundMessage): Promise<BindingHostAck>;
+}

package/dist/host/transport.js

@@ -0,0 +1,35 @@
+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/index.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode plugin entrypoint that loads the local wasm binding and exposes the
+ * gateway, cron, and Telegram operational tools.
+ */
+export declare const OpencodeGatewayPlugin: Plugin;
+export default OpencodeGatewayPlugin;

package/dist/index.js

@@ -0,0 +1,52 @@
+import { loadGatewayBindingModule } from "./binding";
+import { createGatewayRuntime } from "./gateway";
+import { createChannelNewSessionTool } from "./tools/channel-new-session";
+import { createChannelSendFileTool } from "./tools/channel-send-file";
+import { createCronListTool } from "./tools/cron-list";
+import { createCronRemoveTool } from "./tools/cron-remove";
+import { createCronRunTool } from "./tools/cron-run";
+import { createCronUpsertTool } from "./tools/cron-upsert";
+import { createGatewayDispatchCronTool } from "./tools/gateway-dispatch-cron";
+import { createGatewayStatusTool } from "./tools/gateway-status";
+import { createTelegramSendTestTool } from "./tools/telegram-send-test";
+import { createTelegramStatusTool } from "./tools/telegram-status";
+/**
+ * OpenCode plugin entrypoint that loads the local wasm binding and exposes the
+ * gateway, cron, and Telegram operational tools.
+ */
+export const OpencodeGatewayPlugin = async (input) => {
+    const gatewayModule = await loadGatewayBindingModule();
+    const runtime = await createGatewayRuntime(gatewayModule, input);
+    const tools = {
+        cron_list: createCronListTool(runtime.cron),
+        cron_remove: createCronRemoveTool(runtime.cron),
+        cron_run: createCronRunTool(runtime.cron),
+        cron_upsert: createCronUpsertTool(runtime.cron),
+        gateway_status: createGatewayStatusTool(runtime),
+        gateway_dispatch_cron: createGatewayDispatchCronTool(runtime.executor),
+    };
+    if (runtime.files.hasEnabledChannel()) {
+        tools.channel_send_file = createChannelSendFileTool(runtime.files, runtime.sessionContext);
+    }
+    if (runtime.channelSessions.hasEnabledChannel()) {
+        tools.channel_new_session = createChannelNewSessionTool(runtime.channelSessions, runtime.sessionContext);
+    }
+    if (runtime.telegram.isEnabled()) {
+        tools.telegram_status = createTelegramStatusTool(runtime.telegram);
+        tools.telegram_send_test = createTelegramSendTestTool(runtime.telegram);
+    }
+    return {
+        tool: tools,
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionId = input.sessionID;
+            if (!sessionId) {
+                return;
+            }
+            const systemPrompt = runtime.sessionContext.buildSystemPrompt(sessionId);
+            if (systemPrompt !== null) {
+                output.system.push(systemPrompt);
+            }
+        },
+    };
+};
+export default OpencodeGatewayPlugin;

package/dist/mailbox/router.d.ts

@@ -0,0 +1,7 @@
+import type { BindingDeliveryTarget } from "../binding";
+import type { GatewayMailboxRouteConfig } from "../config/gateway";
+export declare class GatewayMailboxRouter {
+    private readonly routes;
+    constructor(routes: GatewayMailboxRouteConfig[]);
+    resolve(target: BindingDeliveryTarget): string | null;
+}

package/dist/mailbox/router.js

@@ -0,0 +1,16 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export declare function inferLocalFileMimeType(filePath: string): Promise<string>;
+export declare function isImageMimeType(mimeType: string): boolean;

package/dist/media/mime.js

@@ -0,0 +1,45 @@
+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/opencode/adapter.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BindingOpencodeCommand, BindingOpencodeCommandResult } from "../binding";
+type OpencodeClient = PluginInput["client"];
+export declare class OpencodeSdkAdapter {
+    private readonly client;
+    private readonly directory;
+    constructor(client: OpencodeClient, directory: string);
+    createFreshSession(title: string): Promise<string>;
+    execute(command: BindingOpencodeCommand): Promise<BindingOpencodeCommandResult>;
+    private lookupSession;
+    private createSession;
+    private waitUntilIdle;
+    private appendPrompt;
+    private sendPromptAsync;
+    private awaitPromptResponse;
+    private readMessage;
+    private listMessages;
+}
+export {};