opencode-gateway 0.1.0

package/dist/tools/gateway-status.js

@@ -0,0 +1,25 @@
+import { tool } from "@opencode-ai/plugin";
+export function createGatewayStatusTool(runtime) {
+    return tool({
+        description: "Return the current Rust gateway contract status",
+        args: {},
+        async execute() {
+            return formatGatewayStatus(runtime.status());
+        },
+    });
+}
+function formatGatewayStatus(status) {
+    return [
+        `runtime_mode=${status.runtimeMode}`,
+        `supports_telegram=${status.supportsTelegram}`,
+        `supports_cron=${status.supportsCron}`,
+        `has_web_ui=${status.hasWebUi}`,
+        `cron_timezone=${status.cronTimezone}`,
+        `cron_enabled=${status.cronEnabled}`,
+        `cron_polling=${status.cronPolling}`,
+        `cron_running_jobs=${status.cronRunningJobs}`,
+        `telegram_enabled=${status.telegramEnabled}`,
+        `telegram_polling=${status.telegramPolling}`,
+        `telegram_allowlist_mode=${status.telegramAllowlistMode}`,
+    ].join("\n");
+}

package/dist/tools/telegram-send-test.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayTelegramRuntime } from "../telegram/runtime";
+export declare function createTelegramSendTestTool(runtime: GatewayTelegramRuntime): ToolDefinition;

package/dist/tools/telegram-send-test.js

@@ -0,0 +1,26 @@
+import { tool } from "@opencode-ai/plugin";
+import { formatUnixMsAsUtc } from "./time";
+export function createTelegramSendTestTool(runtime) {
+    return tool({
+        description: "Send a Telegram test message to an explicit chat_id and optional topic",
+        args: {
+            chat_id: tool.schema.string().min(1),
+            topic: tool.schema.string().optional(),
+            text: tool.schema.string().optional(),
+            mode: tool.schema.enum(["auto", "oneshot", "stream"]).optional(),
+        },
+        async execute(args) {
+            return formatTelegramSendTestResult(await runtime.sendTest(args.chat_id, args.topic ?? null, args.text ?? null, args.mode ?? "auto"));
+        },
+    });
+}
+function formatTelegramSendTestResult(result) {
+    return [
+        `chat_id=${result.chatId}`,
+        `topic=${result.topic ?? "none"}`,
+        `mode=${result.mode}`,
+        `sent_at_ms=${result.sentAtMs}`,
+        `sent_at_utc=${formatUnixMsAsUtc(result.sentAtMs)}`,
+        `text=${result.text}`,
+    ].join("\n");
+}

package/dist/tools/telegram-status.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayTelegramRuntime } from "../telegram/runtime";
+export declare function createTelegramStatusTool(runtime: GatewayTelegramRuntime): ToolDefinition;

package/dist/tools/telegram-status.js

@@ -0,0 +1,49 @@
+import { tool } from "@opencode-ai/plugin";
+import { formatOptionalUnixMsAsUtc } from "./time";
+export function createTelegramStatusTool(runtime) {
+    return tool({
+        description: "Return Telegram gateway status, cached health, and a live Bot API probe",
+        args: {},
+        async execute() {
+            return formatTelegramStatus(await runtime.status());
+        },
+    });
+}
+function formatTelegramStatus(status) {
+    return [
+        `enabled=${status.enabled}`,
+        `polling=${status.polling}`,
+        `allowlist_mode=${status.allowlistMode}`,
+        `allowed_chats_count=${status.allowedChatsCount}`,
+        `allowed_users_count=${status.allowedUsersCount}`,
+        `update_offset=${status.updateOffset ?? "none"}`,
+        `last_poll_success_ms=${status.lastPollSuccessMs ?? "none"}`,
+        `last_poll_success_utc=${formatOptionalUnixMsAsUtc(status.lastPollSuccessMs)}`,
+        `last_poll_error_at_ms=${status.lastPollErrorAtMs ?? "none"}`,
+        `last_poll_error=${status.lastPollErrorMessage ?? "none"}`,
+        `last_send_success_ms=${status.lastSendSuccessMs ?? "none"}`,
+        `last_send_success_utc=${formatOptionalUnixMsAsUtc(status.lastSendSuccessMs)}`,
+        `last_send_error_at_ms=${status.lastSendErrorAtMs ?? "none"}`,
+        `last_send_error=${status.lastSendErrorMessage ?? "none"}`,
+        `last_probe_success_ms=${status.lastProbeSuccessMs ?? "none"}`,
+        `last_probe_success_utc=${formatOptionalUnixMsAsUtc(status.lastProbeSuccessMs)}`,
+        `last_probe_error_at_ms=${status.lastProbeErrorAtMs ?? "none"}`,
+        `last_probe_error=${status.lastProbeErrorMessage ?? "none"}`,
+        `live_probe=${status.liveProbe}`,
+        `live_probe_error=${status.liveProbeError ?? "none"}`,
+        `bot_id=${status.liveBotId ?? status.lastBotId ?? "none"}`,
+        `bot_username=${status.liveBotUsername ?? status.lastBotUsername ?? "none"}`,
+        `streaming_enabled=${status.streamingEnabled}`,
+        `opencode_event_stream_connected=${status.opencodeEventStreamConnected}`,
+        `last_event_stream_error=${status.lastEventStreamError ?? "none"}`,
+        `last_draft_success_ms=${status.lastDraftSuccessMs ?? "none"}`,
+        `last_draft_success_utc=${formatOptionalUnixMsAsUtc(status.lastDraftSuccessMs)}`,
+        `last_draft_error_at_ms=${status.lastDraftErrorAtMs ?? "none"}`,
+        `last_draft_error=${status.lastDraftErrorMessage ?? "none"}`,
+        `last_preview_emit_ms=${status.lastPreviewEmitMs ?? "none"}`,
+        `last_preview_emit_utc=${formatOptionalUnixMsAsUtc(status.lastPreviewEmitMs)}`,
+        `last_stream_fallback_at_ms=${status.lastStreamFallbackAtMs ?? "none"}`,
+        `last_stream_fallback_utc=${formatOptionalUnixMsAsUtc(status.lastStreamFallbackAtMs)}`,
+        `last_stream_fallback_reason=${status.lastStreamFallbackReason ?? "none"}`,
+    ].join("\n");
+}

package/dist/tools/time.d.ts

@@ -0,0 +1,3 @@
+export declare function formatUnixMsAsUtc(value: number): string;
+export declare function formatOptionalUnixMsAsUtc(value: number | null): string;
+export declare function formatUnixMsInTimeZone(value: number, timeZone: string): string;

package/dist/tools/time.js

@@ -0,0 +1,25 @@
+export function formatUnixMsAsUtc(value) {
+    return new Date(value).toISOString();
+}
+export function formatOptionalUnixMsAsUtc(value) {
+    return value === null ? "none" : formatUnixMsAsUtc(value);
+}
+export function formatUnixMsInTimeZone(value, timeZone) {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+    const parts = formatter.formatToParts(new Date(value));
+    const values = new Map(parts.map((part) => [part.type, part.value]));
+    return [
+        `${values.get("year")}-${values.get("month")}-${values.get("day")}`,
+        `${values.get("hour")}:${values.get("minute")}:${values.get("second")}`,
+        `[${timeZone}]`,
+    ].join(" ");
+}

package/dist/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function formatError(error: unknown): string;

package/dist/utils/error.js

@@ -0,0 +1,57 @@
+export function formatError(error) {
+    if (error instanceof Error) {
+        const errorLike = error;
+        const nestedMessage = extractNestedDataMessage(errorLike.data);
+        if (nestedMessage !== null) {
+            return nestedMessage;
+        }
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "object" && error !== null) {
+        const errorLike = error;
+        const nestedMessage = extractNestedDataMessage(errorLike.data);
+        if (nestedMessage !== null) {
+            return nestedMessage;
+        }
+        if (typeof errorLike.message === "string" && errorLike.message.length > 0) {
+            const detail = compactObject({
+                name: errorLike.name,
+                code: errorLike.code,
+                status: errorLike.status,
+                cause: errorLike.cause,
+            });
+            return detail === null ? errorLike.message : `${errorLike.message} (${detail})`;
+        }
+        const serialized = safeJsonStringify(error);
+        if (serialized !== null) {
+            return serialized;
+        }
+    }
+    return String(error);
+}
+function extractNestedDataMessage(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const message = value.message;
+    return typeof message === "string" && message.length > 0 ? message : null;
+}
+function compactObject(value) {
+    const entries = Object.entries(value).filter(([, fieldValue]) => fieldValue !== undefined && fieldValue !== null);
+    if (entries.length === 0) {
+        return null;
+    }
+    const serialized = safeJsonStringify(Object.fromEntries(entries));
+    return serialized ?? entries.map(([key, fieldValue]) => `${key}=${String(fieldValue)}`).join(", ");
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}

package/generated/wasm/pkg/opencode_gateway_ffi.d.ts

@@ -0,0 +1,23 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class OpencodeExecutionDriver {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(input: any);
+    observeEvent(observation: any, now_ms: number): any;
+    resume(result: any): any;
+    start(): any;
+}
+
+export function conversationKeyForDeliveryTarget(target: any): string;
+
+export function gatewayStatus(): any;
+
+export function nextCronRunAt(job: any, after_ms: number, time_zone: string): number;
+
+export function normalizeCronTimeZone(time_zone: string): string;
+
+export function prepareCronExecution(job: any): any;
+
+export function prepareInboundExecution(message: any): any;