@pedrohnas/opencode-telegram 0.1.0

package/src/index.ts

@@ -0,0 +1,255 @@
+/**
+ * Entry point for the OpenCode Telegram Bot.
+ *
+ * 1. Initializes SDK (spawns server or connects to existing)
+ * 2. Creates Grammy bot with all handlers
+ * 3. Starts EventBus (single SSE connection)
+ * 4. Routes events → formatted Telegram responses
+ * 5. Graceful shutdown on SIGINT/SIGTERM
+ */
+
+import { loadConfig } from "./config"
+import { initSdk } from "./sdk"
+import { createBot } from "./bot"
+import { SessionManager } from "./session-manager"
+import { TurnManager } from "./turn-manager"
+import { EventBus } from "./event-bus"
+import { PendingRequests } from "./pending-requests"
+import { markdownToTelegramHtml } from "./send/format"
+import { chunkMessage } from "./send/chunker"
+import { formatPermissionMessage } from "./handlers/permissions"
+import { formatQuestionMessage } from "./handlers/questions"
+import { formatToolStatus } from "./send/tool-progress"
+import type { ActiveTurn } from "./turn-manager"
+
+const config = loadConfig()
+
+// --- Initialize SDK ---
+// If OPENCODE_URL is set, connect to it; otherwise spawn a local server
+const externalUrl = process.env.OPENCODE_URL
+if (externalUrl) {
+  console.log(`Connecting to OpenCode server at ${externalUrl}...`)
+} else {
+  console.log(`Starting OpenCode server for ${config.projectDirectory}...`)
+}
+const sdkHandle = await initSdk({
+  opencodeUrl: externalUrl,
+  projectDirectory: config.projectDirectory,
+})
+const sdk = sdkHandle.client
+console.log(`OpenCode server at ${sdkHandle.url}`)
+
+// --- Create managers ---
+const sessionManager = new SessionManager({
+  maxEntries: 500,
+  ttlMs: 30 * 60 * 1000, // 30 minutes
+})
+
+const turnManager = new TurnManager()
+
+const pendingRequests = new PendingRequests({
+  maxEntries: 200,
+  ttlMs: 10 * 60 * 1000, // 10 minutes
+})
+
+// --- Create bot with deps ---
+const bot = createBot(config, { sdk, sessionManager, turnManager, pendingRequests })
+
+// --- Response sender (format + chunk + send) ---
+async function sendFormattedResponse(chatId: number, markdown: string) {
+  const html = markdownToTelegramHtml(markdown)
+  const chunks = chunkMessage(html)
+  for (const chunk of chunks) {
+    try {
+      await bot.api.sendMessage(chatId, chunk, { parse_mode: "HTML" })
+    } catch (err) {
+      // HTML parse error → retry as plain text
+      if (/can't parse entities/i.test(String(err))) {
+        const plainChunks = chunkMessage(markdown)
+        for (const plain of plainChunks) {
+          await bot.api.sendMessage(chatId, plain)
+        }
+        return
+      }
+      throw err
+    }
+  }
+}
+
+// --- Finalize response (draft stream → final formatted message) ---
+async function finalizeResponse(chatId: number, turn: ActiveTurn) {
+  turn.draft?.stop()
+  const text = turn.accumulatedText
+  if (!text) return
+
+  const draftMsgId = turn.draft?.getMessageId() ?? null
+  const html = markdownToTelegramHtml(text)
+  const chunks = chunkMessage(html)
+
+  if (chunks.length === 1 && draftMsgId) {
+    // Single chunk — edit draft to final version
+    try {
+      await bot.api.editMessageText(chatId, draftMsgId, html, {
+        parse_mode: "HTML",
+      })
+    } catch (err) {
+      const msg = String(err)
+      if (/message is not modified/i.test(msg)) return
+      if (/can't parse entities/i.test(msg)) {
+        try {
+          await bot.api.editMessageText(
+            chatId,
+            draftMsgId,
+            text.slice(0, 4096),
+          )
+        } catch {
+          // Give up editing — send as new message
+          await sendFormattedResponse(chatId, text)
+        }
+        return
+      }
+      if (
+        /message to edit not found/i.test(msg) ||
+        /MESSAGE_ID_INVALID/i.test(msg)
+      ) {
+        await sendFormattedResponse(chatId, text)
+        return
+      }
+      throw err
+    }
+  } else if (draftMsgId) {
+    // Multiple chunks — delete draft and send all
+    await bot.api.deleteMessage(chatId, draftMsgId).catch(() => {})
+    await sendFormattedResponse(chatId, text)
+  } else {
+    // No draft was ever sent — send normally
+    await sendFormattedResponse(chatId, text)
+  }
+}
+
+// --- EventBus: route SSE events → Telegram ---
+const eventBus = new EventBus({
+  sdk,
+  sessionManager,
+  onEvent: (sessionId, chatKey, event) => {
+    const chatId = Number(chatKey.split(":")[0])
+
+    switch (event.type) {
+      case "message.part.updated": {
+        const part = event.properties.part
+        const turn = turnManager.get(sessionId)
+        if (!turn) break
+
+        if (part.type === "text") {
+          // Replace accumulated text (SDK sends full text, not deltas)
+          turn.accumulatedText = part.text
+          turn.toolSuffix = ""
+          turn.draft?.update(part.text).catch((err: unknown) =>
+            console.error("Draft update error:", err),
+          )
+        } else if (part.type === "tool") {
+          const suffix = formatToolStatus(part)
+          if (suffix) {
+            turn.toolSuffix = suffix
+            if (turn.accumulatedText) {
+              turn.draft
+                ?.update(turn.accumulatedText + suffix)
+                .catch((err: unknown) =>
+                  console.error("Draft tool update error:", err),
+                )
+            }
+          }
+        }
+        break
+      }
+
+      case "session.idle": {
+        const turn = turnManager.get(sessionId)
+        if (turn) {
+          finalizeResponse(chatId, turn).catch((err) => {
+            console.error("Error finalizing response:", err)
+          })
+        }
+        turnManager.end(sessionId)
+        break
+      }
+
+      case "session.error": {
+        const error = event.properties.error
+        const msg =
+          typeof error === "string"
+            ? error
+            : error?.data?.message ?? "Unknown error"
+        bot.api
+          .sendMessage(chatId, `Error: ${msg}`)
+          .catch((err) => console.error("Error sending error message:", err))
+        turnManager.end(sessionId)
+        break
+      }
+
+      case "permission.asked": {
+        const perm = event.properties
+        const { text, reply_markup } = formatPermissionMessage(perm)
+        pendingRequests.set(perm.id, {
+          type: "permission",
+          createdAt: Date.now(),
+        })
+        bot.api
+          .sendMessage(chatId, text, { parse_mode: "HTML", reply_markup })
+          .catch((err) =>
+            console.error("Error sending permission message:", err),
+          )
+        break
+      }
+
+      case "question.asked": {
+        const q = event.properties
+        if (q.questions && q.questions.length > 0) {
+          pendingRequests.set(q.id, {
+            type: "question",
+            createdAt: Date.now(),
+            questions: q.questions.map((qq: any) => ({
+              options: qq.options,
+            })),
+          })
+          const { text, reply_markup } = formatQuestionMessage(q)
+          bot.api
+            .sendMessage(chatId, text, { reply_markup })
+            .catch((err) =>
+              console.error("Error sending question message:", err),
+            )
+        }
+        break
+      }
+    }
+  },
+})
+
+// --- Start everything ---
+await eventBus.start()
+console.log("EventBus listening for SSE events")
+
+// Periodic TTL cleanup
+const cleanupInterval = setInterval(() => {
+  sessionManager.cleanup()
+  pendingRequests.cleanup()
+}, 5 * 60 * 1000)
+
+// --- Graceful shutdown ---
+const shutdown = async () => {
+  console.log("Shutting down...")
+  clearInterval(cleanupInterval)
+  eventBus.stop()
+  turnManager.abortAll()
+  await bot.stop()
+  sdkHandle.cleanup()
+  process.exit(0)
+}
+
+process.on("SIGINT", shutdown)
+process.on("SIGTERM", shutdown)
+
+// --- Start polling ---
+await bot.start({
+  onStart: () => console.log("Bot started"),
+})

package/src/pending-requests.ts

@@ -0,0 +1,73 @@
+/**
+ * Bounded Map<requestID, PendingEntry> with TTL.
+ *
+ * Stores pending permission and question requests so that:
+ * - Questions can resolve option index → label when callback is clicked
+ * - Double-click protection (delete on first use)
+ * - TTL expiry guard (stale buttons get "expired" message)
+ *
+ * Anti-leak: bounded by maxEntries + TTL cleanup.
+ */
+
+export type PendingEntry = {
+  type: "permission" | "question"
+  createdAt: number
+  questions?: Array<{ options: Array<{ label: string }> }>
+}
+
+export type PendingRequestsOptions = {
+  maxEntries: number
+  ttlMs: number
+}
+
+export class PendingRequests {
+  private map = new Map<string, PendingEntry>()
+  private readonly maxEntries: number
+  private readonly ttlMs: number
+
+  constructor(opts: PendingRequestsOptions) {
+    this.maxEntries = opts.maxEntries
+    this.ttlMs = opts.ttlMs
+  }
+
+  set(requestID: string, entry: PendingEntry): void {
+    // Evict oldest if at capacity
+    while (this.map.size >= this.maxEntries) {
+      const oldest = this.map.keys().next().value
+      if (oldest !== undefined) {
+        this.map.delete(oldest)
+      }
+    }
+    this.map.set(requestID, entry)
+  }
+
+  get(requestID: string): PendingEntry | undefined {
+    const entry = this.map.get(requestID)
+    if (!entry) return undefined
+
+    // Check TTL
+    if (Date.now() - entry.createdAt > this.ttlMs) {
+      this.map.delete(requestID)
+      return undefined
+    }
+
+    return entry
+  }
+
+  delete(requestID: string): boolean {
+    return this.map.delete(requestID)
+  }
+
+  cleanup(): void {
+    const now = Date.now()
+    for (const [id, entry] of this.map) {
+      if (now - entry.createdAt > this.ttlMs) {
+        this.map.delete(id)
+      }
+    }
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+}

package/src/sdk.ts

@@ -0,0 +1,113 @@
+/**
+ * SDK client factory.
+ *
+ * Two modes:
+ *   1. OPENCODE_URL set → connect to existing server (production/manual)
+ *   2. OPENCODE_URL not set → spawn local server from monorepo source (dev)
+ *
+ * Returns { client, cleanup } where cleanup stops the spawned server (if any).
+ */
+
+import { createOpencodeClient, type OpencodeClient } from "@opencode-ai/sdk/v2"
+import { spawn as nodeSpawn } from "node:child_process"
+import { resolve } from "node:path"
+
+export type SdkHandle = {
+  client: OpencodeClient
+  url: string
+  cleanup: () => void
+}
+
+export async function initSdk(opts: {
+  opencodeUrl?: string
+  projectDirectory: string
+}): Promise<SdkHandle> {
+  if (opts.opencodeUrl) {
+    // Connect to existing server
+    const client = createOpencodeClient({
+      baseUrl: opts.opencodeUrl,
+      directory: opts.projectDirectory,
+    })
+    return { client, url: opts.opencodeUrl, cleanup: () => {} }
+  }
+
+  // Spawn local server from monorepo source
+  const { url, proc } = await spawnOpencodeServer(opts.projectDirectory)
+  const client = createOpencodeClient({
+    baseUrl: url,
+    directory: opts.projectDirectory,
+  })
+  return {
+    client,
+    url,
+    cleanup: () => proc.kill(),
+  }
+}
+
+async function spawnOpencodeServer(projectDirectory: string): Promise<{
+  url: string
+  proc: ReturnType<typeof nodeSpawn>
+}> {
+  // CWD must be the opencode package (for module resolution)
+  // The project directory is passed via the SDK client's x-opencode-directory header
+  const monorepoRoot = resolve(import.meta.dir, "../../..")
+  const opencodeDir = resolve(monorepoRoot, "packages/opencode")
+
+  const proc = nodeSpawn(
+    process.execPath,
+    ["run", "--conditions=browser", "./src/index.ts", "serve", "--port=0"],
+    {
+      cwd: opencodeDir,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  )
+
+  const url = await waitForServerUrl(proc, 30000)
+  return { url, proc }
+}
+
+async function waitForServerUrl(
+  proc: ReturnType<typeof nodeSpawn>,
+  timeoutMs: number,
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let output = ""
+    const timeout = setTimeout(() => {
+      reject(
+        new Error(
+          `OpenCode server did not start within ${timeoutMs}ms. Output: ${output}`,
+        ),
+      )
+    }, timeoutMs)
+
+    proc.stdout?.on("data", (chunk: Buffer) => {
+      output += chunk.toString()
+      const match = output.match(
+        /opencode server listening on (https?:\/\/[^\s]+)/,
+      )
+      if (match) {
+        clearTimeout(timeout)
+        resolve(match[1])
+      }
+    })
+
+    proc.stderr?.on("data", (chunk: Buffer) => {
+      output += chunk.toString()
+    })
+
+    proc.on("exit", (code) => {
+      clearTimeout(timeout)
+      reject(
+        new Error(
+          `OpenCode server exited with code ${code}. Output: ${output}`,
+        ),
+      )
+    })
+
+    proc.on("error", (err) => {
+      clearTimeout(timeout)
+      reject(err)
+    })
+  })
+}

package/src/send/chunker.ts

@@ -0,0 +1,59 @@
+/**
+ * Split an HTML message into chunks that fit Telegram's 4096-char limit.
+ *
+ * Strategy:
+ *   1. Try to split at the last newline before the limit
+ *   2. If no newline, split at the last space
+ *   3. Never split inside an HTML tag (< ... >)
+ *   4. As a last resort, split at the limit
+ */
+
+const DEFAULT_LIMIT = 4096
+
+export function chunkMessage(html: string, limit = DEFAULT_LIMIT): string[] {
+  if (!html) return []
+  if (html.length <= limit) return [html]
+
+  const chunks: string[] = []
+  let remaining = html
+
+  while (remaining.length > 0) {
+    if (remaining.length <= limit) {
+      chunks.push(remaining)
+      break
+    }
+
+    let splitAt = findSplitPoint(remaining, limit)
+    chunks.push(remaining.slice(0, splitAt))
+    remaining = remaining.slice(splitAt)
+  }
+
+  return chunks
+}
+
+function findSplitPoint(text: string, limit: number): number {
+  // Try newline first (best visual break)
+  const lastNewline = text.lastIndexOf("\n", limit)
+  if (lastNewline > limit * 0.5) {
+    return lastNewline + 1 // include the newline in the current chunk
+  }
+
+  // Try space
+  const lastSpace = text.lastIndexOf(" ", limit)
+  if (lastSpace > limit * 0.5) {
+    return lastSpace + 1
+  }
+
+  // Ensure we don't split inside an HTML tag
+  let splitAt = limit
+  const tagStart = text.lastIndexOf("<", splitAt)
+  if (tagStart !== -1) {
+    const tagEnd = text.indexOf(">", tagStart)
+    if (tagEnd === -1 || tagEnd >= splitAt) {
+      // We'd be splitting inside a tag — move split before the tag
+      splitAt = tagStart
+    }
+  }
+
+  return splitAt
+}

package/src/send/draft-stream.ts

@@ -0,0 +1,161 @@
+/**
+ * DraftStream — streams AI response text via Telegram message edits.
+ *
+ * On first text update: sends a new message (the "draft").
+ * On subsequent updates: edits the draft (throttled at ~400ms).
+ * On stop/abort: clears timers, no more edits.
+ *
+ * Anti-leak:
+ *   - AbortSignal integration (auto-stop on turn end/cancel)
+ *   - No Grammy context stored — only chatId + deps
+ *   - Timer tracked and cleared on stop
+ */
+
+import { markdownToTelegramHtml } from "./format"
+
+export type DraftStreamDeps = {
+  sendMessage: (
+    chatId: number,
+    text: string,
+    opts?: { parse_mode?: string },
+  ) => Promise<{ message_id: number }>
+  editMessageText: (
+    chatId: number,
+    messageId: number,
+    text: string,
+    opts?: { parse_mode?: string },
+  ) => Promise<unknown>
+}
+
+export class DraftStream {
+  private messageId: number | null = null
+  private lastText = ""
+  private lastSentAt = 0
+  private pending = ""
+  private timer: ReturnType<typeof setTimeout> | null = null
+  private stopped = false
+  private flushing = false
+  private _htmlFailed = false
+  readonly throttleMs: number
+
+  constructor(
+    private readonly deps: DraftStreamDeps,
+    private readonly chatId: number,
+    signal: AbortSignal,
+    throttleMs = 400,
+  ) {
+    this.throttleMs = throttleMs
+
+    if (signal.aborted) {
+      this.stopped = true
+    } else {
+      signal.addEventListener("abort", () => this.stop(), { once: true })
+    }
+  }
+
+  async update(text: string): Promise<void> {
+    if (this.stopped || !text.trim()) return
+    this.pending = text
+
+    if (this.messageId === null) {
+      // First update — send initial message
+      const truncated = text.slice(0, 4096)
+      try {
+        const html = markdownToTelegramHtml(truncated)
+        const msg = await this.deps.sendMessage(this.chatId, html, {
+          parse_mode: "HTML",
+        })
+        this.messageId = msg.message_id
+        this.lastText = truncated
+        this.lastSentAt = Date.now()
+      } catch {
+        // sendMessage failed — messageId stays null
+      }
+      return
+    }
+
+    this.scheduleFlush()
+  }
+
+  private scheduleFlush(): void {
+    if (this.timer !== null) return
+    const elapsed = Date.now() - this.lastSentAt
+    const delay = Math.max(0, this.throttleMs - elapsed)
+    this.timer = setTimeout(() => this.flush(), delay)
+  }
+
+  private async flush(): Promise<void> {
+    this.timer = null
+    if (this.stopped || this.messageId === null) return
+
+    this.flushing = true
+    const text = this.pending.slice(0, 4096)
+
+    if (text === this.lastText) {
+      this.flushing = false
+      return
+    }
+
+    try {
+      if (this._htmlFailed) {
+        await this.deps.editMessageText(this.chatId, this.messageId, text)
+      } else {
+        const html = markdownToTelegramHtml(text)
+        await this.deps.editMessageText(this.chatId, this.messageId, html, {
+          parse_mode: "HTML",
+        })
+      }
+    } catch (err) {
+      const msg = String(err)
+
+      if (/message is not modified/i.test(msg)) {
+        // Ignore — text didn't actually change
+      } else if (/can't parse entities/i.test(msg)) {
+        this._htmlFailed = true
+        // Retry as plain text
+        try {
+          await this.deps.editMessageText(this.chatId, this.messageId!, text)
+        } catch {
+          // Give up on this edit
+        }
+      } else if (
+        /message to edit not found/i.test(msg) ||
+        /MESSAGE_ID_INVALID/i.test(msg)
+      ) {
+        this.stopped = true
+        this.flushing = false
+        return
+      }
+      // Other errors: log and continue
+    }
+
+    this.lastText = text
+    this.lastSentAt = Date.now()
+    this.flushing = false
+
+    // If pending changed during flush, schedule another
+    if (this.pending.slice(0, 4096) !== text) {
+      this.scheduleFlush()
+    }
+  }
+
+  stop(): void {
+    this.stopped = true
+    if (this.timer !== null) {
+      clearTimeout(this.timer)
+      this.timer = null
+    }
+  }
+
+  getMessageId(): number | null {
+    return this.messageId
+  }
+
+  isStopped(): boolean {
+    return this.stopped
+  }
+
+  hasHtmlFailed(): boolean {
+    return this._htmlFailed
+  }
+}