@tormentalabs/opencode-telegram-plugin 0.2.0

package/src/handlers/messages.ts

@@ -0,0 +1,163 @@
+import type { Context } from "grammy";
+import { getActiveSessionId, attachSession } from "../state/mode.js";
+import { getChatState } from "../state/store.js";
+import { safeSend } from "../utils/safeSend.js";
+import { escapeHtml } from "../utils/format.js";
+
+// ---------------------------------------------------------------------------
+// Client interface — only the methods used in this file
+// ---------------------------------------------------------------------------
+
+interface SessionSummary {
+  id: string;
+  title: string;
+  createdAt: string;
+}
+
+interface OpenCodeClient {
+  session: {
+    list(): Promise<{ data: SessionSummary[] }>;
+    prompt(params: {
+      path: { id: string };
+      body: {
+        parts: [{ type: "text"; text: string }];
+        model?: { providerID: string; modelID: string };
+        effort?: string;
+      };
+    }): Promise<{ data: { info: unknown; parts: unknown[] } }>;
+  };
+}
+
+let _client: OpenCodeClient | null = null;
+
+export function setClient(client: unknown): void {
+  _client = client as OpenCodeClient;
+}
+
+function getClient(): OpenCodeClient {
+  if (!_client) throw new Error("OpenCode client not initialized");
+  return _client;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Attempt to auto-attach to the most recently created session.
+ * Returns the resolved session ID on success, or null if unavailable.
+ */
+async function tryAutoAttach(chatId: number): Promise<string | null> {
+  try {
+    const { data: sessions } = await getClient().session.list();
+    if (sessions.length === 0) return null;
+
+    const latest = [...sessions].sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+    )[0]!;
+
+    attachSession(chatId, latest.id);
+    return latest.id;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+/**
+ * Handles every plain-text message sent to the bot.
+ *
+ * Flow:
+ *  1. Resolve (or auto-attach to) an active session.
+ *  2. Fire the prompt against the OpenCode SDK — without awaiting the full
+ *     response, because the streaming reply arrives through event hooks
+ *     (message.updated) and is handled by a separate event listener.
+ *  3. Propagate any errors back to the user.
+ */
+export async function handleTextMessage(ctx: Context): Promise<void> {
+  const chatId = ctx.chat?.id;
+  if (!chatId) return;
+
+  const text = ctx.message?.text;
+  if (!text) return;
+
+  // Ignore messages that look like unrecognized commands (e.g. /models, /foo)
+  // — these should not be forwarded as prompts to OpenCode
+  if (text.startsWith("/")) return;
+
+  // ------------------------------------------------------------------
+  // 1. Resolve active session
+  // ------------------------------------------------------------------
+  let sessionId = getActiveSessionId(chatId);
+
+  if (!sessionId) {
+    const autoAttach = process.env["TELEGRAM_AUTO_ATTACH"] !== "false";
+    if (autoAttach) {
+      sessionId = await tryAutoAttach(chatId);
+    }
+  }
+
+  if (!sessionId) {
+    await safeSend(() =>
+      ctx.reply(
+        "No active session.\n" +
+          "Use /attach to connect to an existing session or /new to create one.",
+      ),
+    );
+    return;
+  }
+
+  // ------------------------------------------------------------------
+  // 2. Show typing indicator (best-effort)
+  // ------------------------------------------------------------------
+  try {
+    await ctx.api.sendChatAction(chatId, "typing");
+  } catch {
+    // Non-fatal — the message will still be sent
+  }
+
+  // ------------------------------------------------------------------
+  // 3. Fire the prompt — response streams via event hooks, not here
+  // ------------------------------------------------------------------
+  const capturedSessionId = sessionId; // capture before any async gap
+
+  // Build prompt body with optional model/effort overrides
+  const chatState = getChatState(chatId);
+  const promptBody: {
+    parts: [{ type: "text"; text: string }];
+    model?: { providerID: string; modelID: string };
+    effort?: string;
+  } = { parts: [{ type: "text", text }] };
+
+  if (chatState.selectedModel) {
+    promptBody.model = {
+      providerID: chatState.selectedModel.providerID,
+      modelID: chatState.selectedModel.modelID,
+    };
+  }
+  if (chatState.effort !== "high") {
+    promptBody.effort = chatState.effort;
+  }
+
+  try {
+    void getClient()
+      .session.prompt({
+        path: { id: capturedSessionId },
+        body: promptBody,
+      })
+      .catch(async (err: unknown) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        await safeSend(() =>
+          ctx.reply(`❌ Error sending prompt: ${escapeHtml(msg)}`, { parse_mode: "HTML" }),
+        );
+      });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await safeSend(() =>
+      ctx.reply(`❌ Error sending prompt: ${escapeHtml(msg)}`, { parse_mode: "HTML" }),
+    );
+  }
+}

package/src/hooks/message.ts

@@ -0,0 +1,448 @@
+import type { Api, RawApi } from "grammy";
+import {
+  getAllChatIds,
+  getChatState,
+} from "../state/store.js";
+import { getActiveSessionId } from "../state/mode.js";
+import { markdownToTelegramHtml, stripHtml } from "../utils/format.js";
+import { chunkMessage } from "../utils/chunk.js";
+import { safeSend } from "../utils/safeSend.js";
+import { startTyping } from "../utils/typing.js";
+
+export interface HookContext {
+  api: Api<RawApi>;
+  editIntervalMs: number;
+}
+
+// ---------------------------------------------------------------------------
+// Event shapes (matching actual OpenCode SDK events)
+// ---------------------------------------------------------------------------
+
+export interface MessageUpdatedEvent {
+  type: "message.updated";
+  properties: {
+    info: {
+      id: string;
+      sessionID: string;
+      role: string;
+      [key: string]: unknown;
+    };
+  };
+}
+
+export interface PartUpdatedEvent {
+  type: "message.part.updated";
+  properties: {
+    part: {
+      id: string;
+      sessionID: string;
+      messageID: string;
+      type: string;
+      text?: string;
+      state?: string;
+    };
+  };
+}
+
+export interface PartDeltaEvent {
+  type: "message.part.delta";
+  properties: {
+    sessionID: string;
+    messageID: string;
+    partID: string;
+    field: string;
+    delta: string;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Track assistant message IDs
+// ---------------------------------------------------------------------------
+
+const assistantMessageIds = new Set<string>();
+
+export function handleMessageInfo(event: MessageUpdatedEvent): void {
+  const { info } = event.properties;
+  if (info.role === "assistant") {
+    assistantMessageIds.add(info.id);
+  }
+}
+
+function isAssistantMessage(messageID: string): boolean {
+  return assistantMessageIds.has(messageID);
+}
+
+// ---------------------------------------------------------------------------
+// Per-part accumulated text (built from deltas)
+// ---------------------------------------------------------------------------
+
+const partTextAccumulator = new Map<string, string>();
+
+function appendDelta(partID: string, delta: string): string {
+  const current = partTextAccumulator.get(partID) ?? "";
+  const updated = current + delta;
+  partTextAccumulator.set(partID, updated);
+  return updated;
+}
+
+function clearAccumulated(partID: string): void {
+  partTextAccumulator.delete(partID);
+}
+
+// ---------------------------------------------------------------------------
+// Per-chat streaming context
+// Simple model: store latest text, use setInterval to periodically edit.
+// ---------------------------------------------------------------------------
+
+interface ChatStreamCtx {
+  latestRawText: string;
+  latestHtml: string;
+  isFinal: boolean;
+  editTimer: ReturnType<typeof setInterval> | null;
+  api: Api<RawApi>;
+  editIntervalMs: number;
+  editing: boolean;
+  /** True while the initial sendMessage is in-flight */
+  sending: boolean;
+}
+
+const chatStreamCtx = new Map<number, ChatStreamCtx>();
+
+// Check if a given sctx is still the active context for a chat
+function isActive(chatId: number, sctx: ChatStreamCtx): boolean {
+  return chatStreamCtx.get(chatId) === sctx;
+}
+
+// ---------------------------------------------------------------------------
+// Handle message.part.delta — incremental streaming text
+// ---------------------------------------------------------------------------
+
+export function handlePartDelta(
+  event: PartDeltaEvent,
+  ctx: HookContext,
+): void {
+  const { sessionID, messageID, partID, field, delta } = event.properties;
+  if (field !== "text") return;
+  if (!isAssistantMessage(messageID)) return;
+
+  const fullText = appendDelta(partID, delta);
+  if (!fullText.trim()) return;
+
+  const { api, editIntervalMs } = ctx;
+  const html = markdownToTelegramHtml(fullText);
+
+  for (const chatId of getAllChatIds()) {
+    if (getActiveSessionId(chatId) !== sessionID) continue;
+    updateChatStream(chatId, html, fullText, false, api, editIntervalMs);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Handle message.part.updated — full part snapshot (may be final)
+// ---------------------------------------------------------------------------
+
+export function handlePartUpdated(
+  event: PartUpdatedEvent,
+  ctx: HookContext,
+): void {
+  const { part } = event.properties;
+  if (part.type !== "text") return;
+  if (!isAssistantMessage(part.messageID)) return;
+
+  const rawText = part.text ?? "";
+  if (!rawText.trim()) return;
+
+  const { sessionID, id: partID } = part;
+  const { api, editIntervalMs } = ctx;
+
+  partTextAccumulator.set(partID, rawText);
+
+  const isFinal = part.state === "complete";
+  const html = markdownToTelegramHtml(rawText);
+
+  for (const chatId of getAllChatIds()) {
+    if (getActiveSessionId(chatId) !== sessionID) continue;
+    updateChatStream(chatId, html, rawText, isFinal, api, editIntervalMs);
+  }
+
+  if (isFinal) {
+    clearAccumulated(partID);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Update chat stream context — creates initial send or updates latest text
+// ---------------------------------------------------------------------------
+
+function updateChatStream(
+  chatId: number,
+  html: string,
+  rawText: string,
+  isFinal: boolean,
+  api: Api<RawApi>,
+  editIntervalMs: number,
+): void {
+  let sctx = chatStreamCtx.get(chatId);
+
+  if (!sctx) {
+    // First text — send initial message
+    sctx = {
+      latestRawText: rawText,
+      latestHtml: html,
+      isFinal,
+      editTimer: null,
+      api,
+      editIntervalMs,
+      editing: false,
+      sending: true,
+    };
+    chatStreamCtx.set(chatId, sctx);
+    void sendInitialMessage(chatId, sctx);
+    return;
+  }
+
+  // Update latest text
+  sctx.latestRawText = rawText;
+  sctx.latestHtml = html;
+  if (isFinal) {
+    sctx.isFinal = true;
+    void doFinalEdit(chatId, sctx);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Send the initial message, then start the periodic edit timer
+// ---------------------------------------------------------------------------
+
+async function sendInitialMessage(chatId: number, sctx: ChatStreamCtx): Promise<void> {
+  const chatState = getChatState(chatId);
+
+  if (!chatState.typingStop) {
+    chatState.typingStop = startTyping(sctx.api, chatId);
+  }
+
+  const chunks = chunkMessage(sctx.latestHtml);
+  if (chunks.length === 0) {
+    sctx.sending = false;
+    return;
+  }
+
+  let sentMsg: Awaited<ReturnType<typeof sctx.api.sendMessage>> | null = null;
+  try {
+    sentMsg = await sctx.api.sendMessage(chatId, chunks[0], { parse_mode: "HTML" });
+  } catch {
+    // Fallback to plain text
+    try {
+      sentMsg = await sctx.api.sendMessage(chatId, stripHtml(sctx.latestHtml));
+    } catch {
+      sctx.sending = false;
+      cleanupStream(chatId);
+      return;
+    }
+  }
+
+  // After await: check if this context was cleaned up while we were sending
+  if (!isActive(chatId, sctx)) {
+    sctx.sending = false;
+    return;
+  }
+
+  chatState.stream.messageId = sentMsg.message_id;
+  chatState.stream.state = "SENT";
+  chatState.stream.lastSentText = sctx.latestRawText;
+  sctx.sending = false;
+
+  // Send overflow chunks
+  for (let i = 1; i < chunks.length; i++) {
+    if (!isActive(chatId, sctx)) return;
+    const r = await safeSend(() =>
+      sctx.api.sendMessage(chatId, chunks[i], { parse_mode: "HTML" }),
+    );
+    if (r.ok && r.messageId !== undefined) {
+      chatState.stream.chunks.push(r.messageId);
+    }
+  }
+
+  // After sending overflow: recheck
+  if (!isActive(chatId, sctx)) return;
+
+  // If already final, do one last edit and stop
+  if (sctx.isFinal) {
+    if (sctx.latestRawText !== chatState.stream.lastSentText) {
+      await doEdit(chatId, sctx);
+    }
+    cleanupStream(chatId);
+    return;
+  }
+
+  // Start periodic edit timer (only if still active)
+  if (!isActive(chatId, sctx)) return;
+  sctx.editTimer = setInterval(() => {
+    if (!isActive(chatId, sctx)) {
+      clearInterval(sctx.editTimer!);
+      sctx.editTimer = null;
+      return;
+    }
+    void doEdit(chatId, sctx);
+  }, sctx.editIntervalMs);
+  if (typeof sctx.editTimer === "object" && "unref" in sctx.editTimer) {
+    sctx.editTimer.unref();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Periodic edit — reads latest text and edits the Telegram message
+// ---------------------------------------------------------------------------
+
+async function doEdit(chatId: number, sctx: ChatStreamCtx): Promise<void> {
+  if (sctx.editing || sctx.sending) return;
+  if (!isActive(chatId, sctx)) return;
+  sctx.editing = true;
+
+  try {
+    const chatState = getChatState(chatId);
+    const msgId = chatState.stream.messageId;
+    if (msgId === null) return;
+    if (sctx.latestRawText === chatState.stream.lastSentText) return;
+
+    const editChunks = chunkMessage(sctx.latestHtml);
+    if (editChunks.length === 0) return;
+
+    const editResult = await safeSend(() =>
+      sctx.api.editMessageText(chatId, msgId, editChunks[0], { parse_mode: "HTML" }),
+    );
+
+    if (!editResult.ok && editResult.reason === "parse error") {
+      await safeSend(() =>
+        sctx.api.editMessageText(chatId, msgId, stripHtml(editChunks[0])),
+      );
+    }
+
+    chatState.stream.lastSentText = sctx.latestRawText;
+
+    // Sync overflow chunks
+    for (let i = 1; i < editChunks.length; i++) {
+      const existingId = chatState.stream.chunks[i - 1];
+      if (existingId !== undefined) {
+        const r = await safeSend(() =>
+          sctx.api.editMessageText(chatId, existingId, editChunks[i], { parse_mode: "HTML" }),
+        );
+        if (!r.ok && r.reason === "parse error") {
+          await safeSend(() =>
+            sctx.api.editMessageText(chatId, existingId, stripHtml(editChunks[i])),
+          );
+        }
+      } else {
+        const r = await safeSend(() =>
+          sctx.api.sendMessage(chatId, editChunks[i], { parse_mode: "HTML" }),
+        );
+        if (r.ok && r.messageId !== undefined) {
+          chatState.stream.chunks.push(r.messageId);
+        }
+      }
+    }
+
+    // Delete stale overflow messages
+    const excessStart = editChunks.length - 1;
+    if (excessStart < chatState.stream.chunks.length) {
+      for (let j = chatState.stream.chunks.length - 1; j >= excessStart; j--) {
+        void safeSend(() => sctx.api.deleteMessage(chatId, chatState.stream.chunks[j]));
+      }
+      chatState.stream.chunks.length = Math.max(excessStart, 0);
+    }
+  } finally {
+    sctx.editing = false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Final edit — stop timer, do one last edit, cleanup
+// ---------------------------------------------------------------------------
+
+async function doFinalEdit(chatId: number, sctx: ChatStreamCtx): Promise<void> {
+  if (sctx.editTimer) {
+    clearInterval(sctx.editTimer);
+    sctx.editTimer = null;
+  }
+
+  // Wait for sending/editing to finish (bail if context was cleaned up externally)
+  let waitCount = 0;
+  while (sctx.editing || sctx.sending) {
+    if (!isActive(chatId, sctx) || ++waitCount > 200) return; // 200 × 50ms = 10s max
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  if (!isActive(chatId, sctx)) return;
+
+  const chatState = getChatState(chatId);
+  if (sctx.latestRawText !== chatState.stream.lastSentText && chatState.stream.messageId !== null) {
+    await doEdit(chatId, sctx);
+  }
+
+  if (isActive(chatId, sctx)) {
+    cleanupStream(chatId);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cleanup
+// ---------------------------------------------------------------------------
+
+export function cleanupStream(chatId: number): void {
+  const sctx = chatStreamCtx.get(chatId);
+  if (sctx?.editTimer) {
+    clearInterval(sctx.editTimer);
+  }
+  chatStreamCtx.delete(chatId);
+
+  const chatState = getChatState(chatId);
+  chatState.typingStop?.();
+  chatState.typingStop = null;
+  chatState.stream.state = "FINAL";
+}
+
+/**
+ * Gracefully finalize any active stream for a chat: do one last edit with
+ * the latest accumulated text, then clean up. If no stream is active,
+ * just clean up immediately.
+ */
+export async function gracefulFinalizeStream(chatId: number): Promise<void> {
+  const sctx = chatStreamCtx.get(chatId);
+  if (!sctx) {
+    // No active stream — just clean up store state
+    const chatState = getChatState(chatId);
+    chatState.typingStop?.();
+    chatState.typingStop = null;
+    return;
+  }
+
+  // Mark as final so no new timer ticks produce edits
+  sctx.isFinal = true;
+
+  // Stop timer
+  if (sctx.editTimer) {
+    clearInterval(sctx.editTimer);
+    sctx.editTimer = null;
+  }
+
+  // Wait for in-flight operations
+  let waitCount = 0;
+  while (sctx.editing || sctx.sending) {
+    if (!isActive(chatId, sctx) || ++waitCount > 200) break;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  // Do final edit with latest accumulated text
+  if (isActive(chatId, sctx)) {
+    const chatState = getChatState(chatId);
+    if (
+      chatState.stream.messageId !== null &&
+      sctx.latestRawText !== chatState.stream.lastSentText
+    ) {
+      await doEdit(chatId, sctx);
+    }
+  }
+
+  // Clean up
+  cleanupStream(chatId);
+}

package/src/hooks/permission.ts

@@ -0,0 +1,81 @@
+import type { Api, RawApi } from "grammy";
+import { InlineKeyboard } from "grammy";
+import {
+  getAllChatIds,
+  getChatState,
+  registerCallback,
+  type PendingPermission,
+} from "../state/store.js";
+import { getActiveSessionId } from "../state/mode.js";
+import { escapeHtml } from "../utils/format.js";
+import { safeSend } from "../utils/safeSend.js";
+
+export interface HookContext {
+  api: Api<RawApi>;
+  editIntervalMs: number;
+}
+
+interface PermissionAskedEvent {
+  type: "permission.asked";
+  properties: {
+    sessionID: string;
+    id: string;
+    tool: string;
+    description: string;
+  };
+}
+
+export function handlePermissionAsked(
+  event: PermissionAskedEvent,
+  ctx: HookContext,
+): void {
+  const { sessionID, id: permissionId, tool, description } = event.properties;
+  const { api } = ctx;
+
+  for (const chatId of getAllChatIds()) {
+    if (getActiveSessionId(chatId) !== sessionID) continue;
+
+    const chatState = getChatState(chatId);
+
+    const approveKey = registerCallback("perm_approve", {
+      permissionId,
+      sessionId: sessionID,
+    });
+    const denyKey = registerCallback("perm_deny", {
+      permissionId,
+      sessionId: sessionID,
+    });
+
+    const keyboard = new InlineKeyboard()
+      .text("✅ Approve", approveKey)
+      .text("❌ Deny", denyKey);
+
+    const messageText =
+      `🔐 <b>Permission requested</b>\n\n` +
+      `<b>Tool:</b> <code>${escapeHtml(tool)}</code>\n` +
+      escapeHtml(description);
+
+    void (async () => {
+      const result = await safeSend(() =>
+        api.sendMessage(chatId, messageText, {
+          parse_mode: "HTML",
+          reply_markup: keyboard,
+        }),
+      );
+
+      const telegramMessageId =
+        result.ok && result.messageId !== undefined ? result.messageId : null;
+
+      const pending: PendingPermission = {
+        permissionId,
+        sessionId: sessionID,
+        tool,
+        description,
+        telegramMessageId,
+        timestamp: Date.now(),
+      };
+
+      chatState.pendingPermissions.set(permissionId, pending);
+    })();
+  }
+}