opencode-gateway 0.2.3 → 0.2.5

package/dist/telegram/state.js

@@ -1,149 +0,0 @@
-const TELEGRAM_UPDATE_OFFSET_KEY = "telegram.update_offset";
-const TELEGRAM_LAST_POLL_SUCCESS_MS_KEY = "telegram.last_poll_success_ms";
-const TELEGRAM_LAST_POLL_STARTED_MS_KEY = "telegram.last_poll_started_ms";
-const TELEGRAM_LAST_POLL_COMPLETED_MS_KEY = "telegram.last_poll_completed_ms";
-const TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY = "telegram.last_poll_error_at_ms";
-const TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY = "telegram.last_poll_error_message";
-const TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY = "telegram.last_poll_timeout_at_ms";
-const TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY = "telegram.last_poll_timeout_message";
-const TELEGRAM_LAST_SEND_SUCCESS_MS_KEY = "telegram.last_send_success_ms";
-const TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY = "telegram.last_send_error_at_ms";
-const TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY = "telegram.last_send_error_message";
-const TELEGRAM_LAST_PROBE_SUCCESS_MS_KEY = "telegram.last_probe_success_ms";
-const TELEGRAM_LAST_PROBE_ERROR_AT_MS_KEY = "telegram.last_probe_error_at_ms";
-const TELEGRAM_LAST_PROBE_ERROR_MESSAGE_KEY = "telegram.last_probe_error_message";
-const TELEGRAM_LAST_BOT_ID_KEY = "telegram.last_bot_id";
-const TELEGRAM_LAST_BOT_USERNAME_KEY = "telegram.last_bot_username";
-const TELEGRAM_LAST_DRAFT_SUCCESS_MS_KEY = "telegram.last_draft_success_ms";
-const TELEGRAM_LAST_DRAFT_ERROR_AT_MS_KEY = "telegram.last_draft_error_at_ms";
-const TELEGRAM_LAST_DRAFT_ERROR_MESSAGE_KEY = "telegram.last_draft_error_message";
-const TELEGRAM_LAST_PREVIEW_EMIT_MS_KEY = "telegram.last_preview_emit_ms";
-const TELEGRAM_LAST_STREAM_FALLBACK_AT_MS_KEY = "telegram.last_stream_fallback_at_ms";
-const TELEGRAM_LAST_STREAM_FALLBACK_REASON_KEY = "telegram.last_stream_fallback_reason";
-export function readTelegramHealthSnapshot(store) {
-    return {
-        updateOffset: readStoredInteger(store, TELEGRAM_UPDATE_OFFSET_KEY),
-        lastPollSuccessMs: readStoredInteger(store, TELEGRAM_LAST_POLL_SUCCESS_MS_KEY),
-        lastPollStartedMs: readStoredInteger(store, TELEGRAM_LAST_POLL_STARTED_MS_KEY),
-        lastPollCompletedMs: readStoredInteger(store, TELEGRAM_LAST_POLL_COMPLETED_MS_KEY),
-        lastPollErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY),
-        lastPollErrorMessage: readStoredText(store, TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY),
-        lastPollTimeoutAtMs: readStoredInteger(store, TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY),
-        lastPollTimeoutMessage: readStoredText(store, TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY),
-        lastSendSuccessMs: readStoredInteger(store, TELEGRAM_LAST_SEND_SUCCESS_MS_KEY),
-        lastSendErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY),
-        lastSendErrorMessage: readStoredText(store, TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY),
-        lastProbeSuccessMs: readStoredInteger(store, TELEGRAM_LAST_PROBE_SUCCESS_MS_KEY),
-        lastProbeErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_PROBE_ERROR_AT_MS_KEY),
-        lastProbeErrorMessage: readStoredText(store, TELEGRAM_LAST_PROBE_ERROR_MESSAGE_KEY),
-        lastBotId: readStoredText(store, TELEGRAM_LAST_BOT_ID_KEY),
-        lastBotUsername: readStoredText(store, TELEGRAM_LAST_BOT_USERNAME_KEY),
-        lastDraftSuccessMs: readStoredInteger(store, TELEGRAM_LAST_DRAFT_SUCCESS_MS_KEY),
-        lastDraftErrorAtMs: readStoredInteger(store, TELEGRAM_LAST_DRAFT_ERROR_AT_MS_KEY),
-        lastDraftErrorMessage: readStoredText(store, TELEGRAM_LAST_DRAFT_ERROR_MESSAGE_KEY),
-        lastPreviewEmitMs: readStoredInteger(store, TELEGRAM_LAST_PREVIEW_EMIT_MS_KEY),
-        lastStreamFallbackAtMs: readStoredInteger(store, TELEGRAM_LAST_STREAM_FALLBACK_AT_MS_KEY),
-        lastStreamFallbackReason: readStoredFallbackReason(store),
-    };
-}
-export function recordTelegramPollStarted(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_POLL_STARTED_MS_KEY, String(recordedAtMs), recordedAtMs);
-}
-export function recordTelegramPollCompleted(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_POLL_COMPLETED_MS_KEY, String(recordedAtMs), recordedAtMs);
-}
-export function recordTelegramPollSuccess(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_POLL_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY, "", recordedAtMs);
-}
-export function recordTelegramPollFailure(store, message, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_POLL_ERROR_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_ERROR_MESSAGE_KEY, message, recordedAtMs);
-}
-export function recordTelegramPollTimeout(store, message, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_POLL_TIMEOUT_MESSAGE_KEY, message, recordedAtMs);
-    recordTelegramPollFailure(store, message, recordedAtMs);
-}
-export function recordTelegramSendSuccess(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_SEND_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY, "", recordedAtMs);
-}
-export function recordTelegramSendFailure(store, message, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_SEND_ERROR_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_SEND_ERROR_MESSAGE_KEY, message, recordedAtMs);
-}
-export function recordTelegramProbeSuccess(store, bot, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_PROBE_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_PROBE_ERROR_AT_MS_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_PROBE_ERROR_MESSAGE_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_BOT_ID_KEY, String(bot.id), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_BOT_USERNAME_KEY, bot.username ?? "", recordedAtMs);
-}
-export function recordTelegramProbeFailure(store, message, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_PROBE_ERROR_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_PROBE_ERROR_MESSAGE_KEY, message, recordedAtMs);
-}
-export function recordTelegramDraftSuccess(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_DRAFT_SUCCESS_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_DRAFT_ERROR_AT_MS_KEY, "", recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_DRAFT_ERROR_MESSAGE_KEY, "", recordedAtMs);
-}
-export function recordTelegramDraftFailure(store, message, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_DRAFT_ERROR_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_DRAFT_ERROR_MESSAGE_KEY, message, recordedAtMs);
-}
-export function recordTelegramPreviewEmit(store, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_PREVIEW_EMIT_MS_KEY, String(recordedAtMs), recordedAtMs);
-}
-export function recordTelegramStreamFallback(store, reason, recordedAtMs) {
-    store.putStateValue(TELEGRAM_LAST_STREAM_FALLBACK_AT_MS_KEY, String(recordedAtMs), recordedAtMs);
-    store.putStateValue(TELEGRAM_LAST_STREAM_FALLBACK_REASON_KEY, reason, recordedAtMs);
-}
-export function readTelegramChatType(store, chatId) {
-    const value = readStoredText(store, telegramChatTypeKey(chatId));
-    return value === null ? null : value;
-}
-export function recordTelegramChatType(store, chatId, chatType, recordedAtMs) {
-    store.putStateValue(telegramChatTypeKey(chatId), chatType, recordedAtMs);
-}
-function telegramChatTypeKey(chatId) {
-    return `telegram.chat_type:${chatId}`;
-}
-function readStoredInteger(store, key) {
-    const value = store.getStateValue(key);
-    if (value === null || value.length === 0) {
-        return null;
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new Error(`stored ${key} is invalid: ${value}`);
-    }
-    return parsed;
-}
-function readStoredText(store, key) {
-    const value = store.getStateValue(key);
-    if (value === null || value.length === 0) {
-        return null;
-    }
-    return value;
-}
-function readStoredFallbackReason(store) {
-    const value = readStoredText(store, TELEGRAM_LAST_STREAM_FALLBACK_REASON_KEY);
-    if (value === null) {
-        return null;
-    }
-    switch (value) {
-        case "non_private_chat":
-        case "progressive_handle_unavailable":
-        case "draft_send_failed":
-        case "preview_not_established":
-            return value;
-        default:
-            throw new Error(`stored ${TELEGRAM_LAST_STREAM_FALLBACK_REASON_KEY} is invalid: ${value}`);
-    }
-}

package/dist/telegram/types.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/channel-new-session.js

@@ -1,27 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { resolveToolDeliveryTarget } from "./channel-target";
-export function createChannelNewSessionTool(switcher, sessions) {
-    return tool({
-        description: "Create a fresh OpenCode session for a channel route and switch future inbound messages to it. When called from a channel-backed session, channel, target, and topic default to the current reply target.",
-        args: {
-            channel: tool.schema.string().min(1).optional(),
-            target: tool.schema.string().min(1).optional(),
-            topic: tool.schema.string().optional(),
-            title: tool.schema.string().optional(),
-        },
-        async execute(args, context) {
-            return formatChannelSessionSwitchResult(await switcher.createAndSwitchSession(resolveToolDeliveryTarget(args, context.sessionID, sessions), args.title ?? null));
-        },
-    });
-}
-function formatChannelSessionSwitchResult(result) {
-    return [
-        `channel=${result.channel}`,
-        `target=${result.target}`,
-        `topic=${result.topic ?? "none"}`,
-        `conversation_key=${result.conversationKey}`,
-        `previous_session_id=${result.previousSessionId ?? "none"}`,
-        `new_session_id=${result.newSessionId}`,
-        `effective_on=${result.effectiveOn}`,
-    ].join("\n");
-}

package/dist/tools/channel-send-file.js

@@ -1,27 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { resolveToolDeliveryTarget } from "./channel-target";
-export function createChannelSendFileTool(sender, sessions) {
-    return tool({
-        description: "Send a local absolute-path file to a channel target. When called from a channel-backed session, channel, target, and topic default to the current reply target.",
-        args: {
-            channel: tool.schema.string().min(1).optional(),
-            target: tool.schema.string().min(1).optional(),
-            topic: tool.schema.string().optional(),
-            file_path: tool.schema.string().min(1),
-            caption: tool.schema.string().optional(),
-        },
-        async execute(args, context) {
-            return formatChannelFileSendResult(await sender.sendFile(resolveToolDeliveryTarget(args, context.sessionID, sessions), args.file_path, args.caption ?? null));
-        },
-    });
-}
-function formatChannelFileSendResult(result) {
-    return [
-        `channel=${result.channel}`,
-        `target=${result.target}`,
-        `topic=${result.topic ?? "none"}`,
-        `file_path=${result.filePath}`,
-        `mime_type=${result.mimeType}`,
-        `delivery_kind=${result.deliveryKind}`,
-    ].join("\n");
-}

package/dist/tools/channel-target.js

@@ -1,34 +0,0 @@
-export function resolveToolDeliveryTarget(args, sessionId, sessions) {
-    const fallback = sessionId ? sessions.getDefaultReplyTarget(sessionId) : null;
-    const channel = normalizeRequired(args.channel ?? fallback?.channel ?? null, "channel");
-    const target = normalizeRequired(args.target ?? fallback?.target ?? null, "target");
-    const topic = normalizeOptional(args.topic ?? fallback?.topic ?? null);
-    return {
-        channel,
-        target,
-        topic,
-    };
-}
-export function resolveOptionalToolDeliveryTarget(args, sessionId, sessions) {
-    if (args.channel === undefined && args.target === undefined && args.topic === undefined) {
-        return sessionId ? sessions.getDefaultReplyTarget(sessionId) : null;
-    }
-    return resolveToolDeliveryTarget(args, sessionId, sessions);
-}
-function normalizeRequired(value, field) {
-    if (value === null) {
-        throw new Error(`${field} is required when the current session has no default reply target`);
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function normalizeOptional(value) {
-    if (value === null) {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}

package/dist/tools/cron-run.js

@@ -1,20 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-export function createCronRunTool(runtime) {
-    return tool({
-        description: "Run one persisted gateway schedule job immediately without changing its schedule metadata.",
-        args: {
-            id: tool.schema.string().min(1),
-        },
-        async execute(args) {
-            return formatRuntimeReport(await runtime.runNow(args.id));
-        },
-    });
-}
-function formatRuntimeReport(report) {
-    return [
-        `conversation_key=${report.conversationKey}`,
-        `response_text=${report.responseText}`,
-        `delivered=${report.delivered}`,
-        `recorded_at_ms=${report.recordedAtMs}`,
-    ].join("\n");
-}

package/dist/tools/cron-upsert.js

@@ -1,51 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { resolveOptionalToolDeliveryTarget } from "./channel-target";
-import { formatUnixMsAsUtc, formatUnixMsInTimeZone } from "./time";
-export function createCronUpsertTool(runtime, sessions) {
-    return tool({
-        description: "Create or replace a recurring gateway cron job. When called from a channel-backed session, delivery defaults to the current reply target.",
-        args: {
-            id: tool.schema.string().min(1),
-            schedule: tool.schema.string().min(1),
-            prompt: tool.schema.string().min(1),
-            enabled: tool.schema.boolean().optional(),
-            delivery_channel: tool.schema.string().optional(),
-            delivery_target: tool.schema.string().optional(),
-            delivery_topic: tool.schema.string().optional(),
-        },
-        async execute(args, context) {
-            const deliveryTarget = resolveOptionalToolDeliveryTarget({
-                channel: args.delivery_channel,
-                target: args.delivery_target,
-                topic: args.delivery_topic,
-            }, context.sessionID, sessions);
-            const timeZone = runtime.timeZone();
-            const job = runtime.upsertJob({
-                id: args.id,
-                schedule: args.schedule,
-                prompt: args.prompt,
-                enabled: args.enabled ?? true,
-                deliveryChannel: deliveryTarget?.channel ?? null,
-                deliveryTarget: deliveryTarget?.target ?? null,
-                deliveryTopic: deliveryTarget?.topic ?? null,
-            });
-            return [
-                `id=${job.id}`,
-                `kind=${job.kind}`,
-                `enabled=${job.enabled}`,
-                `schedule=${job.schedule}`,
-                `timezone=${timeZone}`,
-                `next_run_at_ms=${job.nextRunAtMs}`,
-                `next_run_at_local=${formatUnixMsInTimeZone(job.nextRunAtMs, timeZone)}`,
-                `next_run_at_utc=${formatUnixMsAsUtc(job.nextRunAtMs)}`,
-                `delivery=${formatDelivery(job.deliveryChannel, job.deliveryTarget, job.deliveryTopic)}`,
-            ].join("\n");
-        },
-    });
-}
-function formatDelivery(channel, target, topic) {
-    if (channel === null || target === null) {
-        return "none";
-    }
-    return topic === null ? `${channel}:${target}` : `${channel}:${target}:topic:${topic}`;
-}

package/dist/tools/gateway-dispatch-cron.js

@@ -1,33 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-export function createGatewayDispatchCronTool(executor) {
-    return tool({
-        description: "Dispatch one gateway cron-style prompt through the gateway runtime",
-        args: {
-            id: tool.schema.string().min(1),
-            schedule: tool.schema.string().min(1),
-            prompt: tool.schema.string().min(1),
-        },
-        async execute(args) {
-            const report = await executor.dispatchCronJob(toCronJobSpec(args));
-            return formatRuntimeReport(report);
-        },
-    });
-}
-function toCronJobSpec(args) {
-    return {
-        id: args.id,
-        schedule: args.schedule,
-        prompt: args.prompt,
-        deliveryChannel: null,
-        deliveryTarget: null,
-        deliveryTopic: null,
-    };
-}
-function formatRuntimeReport(report) {
-    return [
-        `conversation_key=${report.conversationKey}`,
-        `response_text=${report.responseText}`,
-        `delivered=${report.delivered}`,
-        `recorded_at_ms=${report.recordedAtMs}`,
-    ].join("\n");
-}

package/dist/tools/gateway-status.js

@@ -1,25 +0,0 @@
-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/schedule-cancel.js

@@ -1,12 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-export function createScheduleCancelTool(runtime) {
-    return tool({
-        description: "Cancel a persisted gateway schedule job without deleting its run history.",
-        args: {
-            id: tool.schema.string().min(1),
-        },
-        async execute(args) {
-            return runtime.cancelJob(args.id) ? `canceled=${args.id}` : `inactive=${args.id}`;
-        },
-    });
-}

package/dist/tools/schedule-format.js

@@ -1,48 +0,0 @@
-import { formatUnixMsAsUtc, formatUnixMsInTimeZone } from "./time";
-export function formatScheduleJob(job, timeZone) {
-    const lines = [`id=${job.id}`, `kind=${job.kind}`, `enabled=${job.enabled}`];
-    if (job.kind === "cron") {
-        lines.push(`schedule=${job.schedule}`);
-        lines.push(`timezone=${timeZone}`);
-        lines.push(`next_run_at_ms=${job.nextRunAtMs}`);
-        lines.push(`next_run_at_local=${formatUnixMsInTimeZone(job.nextRunAtMs, timeZone)}`);
-        lines.push(`next_run_at_utc=${formatUnixMsAsUtc(job.nextRunAtMs)}`);
-    }
-    else {
-        lines.push(`run_at_ms=${job.runAtMs ?? "none"}`);
-        if (job.runAtMs !== null) {
-            lines.push(`run_at_local=${formatUnixMsInTimeZone(job.runAtMs, timeZone)}`);
-            lines.push(`run_at_utc=${formatUnixMsAsUtc(job.runAtMs)}`);
-        }
-    }
-    lines.push(`delivery=${formatDelivery(job.deliveryChannel, job.deliveryTarget, job.deliveryTopic)}`);
-    lines.push(`prompt=${job.prompt}`);
-    return lines.join("\n");
-}
-export function formatScheduleStatus(status, timeZone) {
-    const lines = [formatScheduleJob(status.job, timeZone), `state=${status.state}`];
-    if (status.runs.length === 0) {
-        lines.push("runs=none");
-        return lines.join("\n");
-    }
-    lines.push("");
-    lines.push(...status.runs.map((run, index) => formatRun(run, index + 1)));
-    return lines.join("\n");
-}
-function formatRun(run, ordinal) {
-    return [
-        `run[${ordinal}].id=${run.id}`,
-        `run[${ordinal}].status=${run.status}`,
-        `run[${ordinal}].scheduled_for_ms=${run.scheduledForMs}`,
-        `run[${ordinal}].started_at_ms=${run.startedAtMs}`,
-        `run[${ordinal}].finished_at_ms=${run.finishedAtMs ?? "none"}`,
-        `run[${ordinal}].response_text=${run.responseText ?? "none"}`,
-        `run[${ordinal}].error_message=${run.errorMessage ?? "none"}`,
-    ].join("\n");
-}
-function formatDelivery(channel, target, topic) {
-    if (channel === null || target === null) {
-        return "none";
-    }
-    return topic === null ? `${channel}:${target}` : `${channel}:${target}:topic:${topic}`;
-}

package/dist/tools/schedule-list.js

@@ -1,17 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { formatScheduleJob } from "./schedule-format";
-export function createScheduleListTool(runtime) {
-    return tool({
-        description: "List persisted gateway schedule jobs, including recurring cron jobs and one-shot timers.",
-        args: {
-            include_terminal: tool.schema.boolean().optional(),
-        },
-        async execute(args) {
-            const jobs = runtime.listJobs(args.include_terminal ?? false);
-            if (jobs.length === 0) {
-                return "no scheduled jobs";
-            }
-            return jobs.map((job) => formatScheduleJob(job, runtime.timeZone())).join("\n\n");
-        },
-    });
-}

package/dist/tools/schedule-once.js

@@ -1,43 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { resolveOptionalToolDeliveryTarget } from "./channel-target";
-import { formatScheduleJob } from "./schedule-format";
-export function createScheduleOnceTool(runtime, sessions) {
-    return tool({
-        description: "Schedule a one-shot gateway job. When called from a channel-backed session, delivery defaults to the current reply target.",
-        args: {
-            id: tool.schema.string().min(1),
-            prompt: tool.schema.string().min(1),
-            delay_seconds: tool.schema.number().optional(),
-            run_at_ms: tool.schema.number().optional(),
-            delivery_channel: tool.schema.string().optional(),
-            delivery_target: tool.schema.string().optional(),
-            delivery_topic: tool.schema.string().optional(),
-        },
-        async execute(args, context) {
-            const deliveryTarget = resolveOptionalToolDeliveryTarget({
-                channel: args.delivery_channel,
-                target: args.delivery_target,
-                topic: args.delivery_topic,
-            }, context.sessionID, sessions);
-            const job = runtime.scheduleOnce({
-                id: args.id,
-                prompt: args.prompt,
-                delaySeconds: normalizeOptionalInteger(args.delay_seconds, "delay_seconds"),
-                runAtMs: normalizeOptionalInteger(args.run_at_ms, "run_at_ms"),
-                deliveryChannel: deliveryTarget?.channel ?? null,
-                deliveryTarget: deliveryTarget?.target ?? null,
-                deliveryTopic: deliveryTarget?.topic ?? null,
-            });
-            return formatScheduleJob(job, runtime.timeZone());
-        },
-    });
-}
-function normalizeOptionalInteger(value, field) {
-    if (value === undefined) {
-        return null;
-    }
-    if (!Number.isSafeInteger(value)) {
-        throw new Error(`${field} must be an integer`);
-    }
-    return value;
-}

package/dist/tools/schedule-status.js

@@ -1,23 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { formatScheduleStatus } from "./schedule-format";
-export function createScheduleStatusTool(runtime) {
-    return tool({
-        description: "Inspect one persisted gateway schedule job and its recent run history.",
-        args: {
-            id: tool.schema.string().min(1),
-            limit: tool.schema.number().optional(),
-        },
-        async execute(args) {
-            return formatScheduleStatus(runtime.getJobStatus(args.id, normalizeOptionalLimit(args.limit)), runtime.timeZone());
-        },
-    });
-}
-function normalizeOptionalLimit(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!Number.isSafeInteger(value)) {
-        throw new Error("limit must be an integer");
-    }
-    return value;
-}

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

@@ -1,26 +0,0 @@
-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.js

@@ -1,49 +0,0 @@
-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.js

@@ -1,25 +0,0 @@
-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(" ");
-}