@pedrohnas/opencode-telegram 0.1.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pedrohnas/opencode-telegram",
+  "version": "0.1.0",
+  "description": "Telegram bot for OpenCode — AI coding assistant via Telegram",
+  "type": "module",
+  "bin": {
+    "opencode-telegram": "./src/index.ts"
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/sdk": "^1.1.53",
+    "grammy": "^1.35.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/bot.ts

@@ -0,0 +1,203 @@
+/**
+ * Grammy bot creation and handler logic.
+ *
+ * Exports:
+ *   - createBot(config, deps?) — creates Grammy Bot with all handlers
+ *   - handleMessage(params) — processes a text message (testable standalone)
+ *   - handleNew(params) — processes /new command (testable standalone)
+ */
+
+import { Bot } from "grammy"
+import type { Config } from "./config"
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import type { SessionManager } from "./session-manager"
+import type { TurnManager, ActiveTurn } from "./turn-manager"
+import type { PendingRequests } from "./pending-requests"
+import { handleCancel } from "./handlers/cancel"
+import { parsePermissionCallback } from "./handlers/permissions"
+import {
+  parseQuestionCallback,
+  resolveQuestionAnswer,
+} from "./handlers/questions"
+import { startTypingLoop } from "./handlers/typing"
+import { DraftStream } from "./send/draft-stream"
+
+export const START_MESSAGE = [
+  "OpenCode Telegram Bot",
+  "",
+  "Send any message to start coding.",
+  "/new — New session",
+  "/cancel — Stop generation",
+].join("\n")
+
+export type BotDeps = {
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  turnManager: TurnManager
+  pendingRequests: PendingRequests
+}
+
+export function createBot(config: Config, deps?: BotDeps) {
+  const bot = new Bot(config.botToken)
+
+  bot.command("start", async (ctx) => {
+    await ctx.reply(START_MESSAGE)
+  })
+
+  if (deps) {
+    const { sdk, sessionManager, turnManager, pendingRequests } = deps
+
+    bot.command("new", async (ctx) => {
+      const chatId = ctx.chat.id
+      await handleNew({ chatId, sdk, sessionManager })
+      await ctx.reply("New session started.")
+    })
+
+    bot.command("cancel", async (ctx) => {
+      const chatId = ctx.chat.id
+      const result = await handleCancel({
+        chatId,
+        sdk,
+        sessionManager,
+        turnManager,
+      })
+      await ctx.reply(result)
+    })
+
+    bot.on("callback_query:data", async (ctx) => {
+      const data = ctx.callbackQuery.data
+      await ctx.answerCallbackQuery()
+
+      if (data.startsWith("perm:")) {
+        const parsed = parsePermissionCallback(data)
+        if (!parsed) return
+
+        const pending = pendingRequests.get(parsed.requestID)
+        if (!pending) {
+          await ctx.editMessageText("This request has expired.")
+          return
+        }
+        pendingRequests.delete(parsed.requestID)
+
+        await sdk.permission.reply({
+          requestID: parsed.requestID,
+          reply: parsed.reply as "once" | "always" | "reject",
+        })
+
+        const label =
+          parsed.reply === "reject"
+            ? "Denied"
+            : `Granted (${parsed.reply})`
+        await ctx.editMessageText(`Permission ${label}`)
+        return
+      }
+
+      if (data.startsWith("q:")) {
+        const parsed = parseQuestionCallback(data)
+        if (!parsed) return
+
+        const pending = pendingRequests.get(parsed.requestID)
+        if (!pending) {
+          await ctx.editMessageText("This question has expired.")
+          return
+        }
+        pendingRequests.delete(parsed.requestID)
+
+        if (parsed.action === "skip") {
+          await sdk.question.reject({ requestID: parsed.requestID })
+          await ctx.editMessageText("Question skipped.")
+        } else {
+          const answer = resolveQuestionAnswer(parsed.optionIndex, pending)
+          await sdk.question.reply({
+            requestID: parsed.requestID,
+            answers: [answer],
+          })
+          await ctx.editMessageText(`Selected: ${answer.join(", ")}`)
+        }
+        return
+      }
+    })
+
+    bot.on("message:text", async (ctx) => {
+      const chatId = ctx.chat.id
+      const text = ctx.message.text.trim()
+      if (!text) return
+
+      const { turn } = await handleMessage({
+        chatId,
+        text,
+        sdk,
+        sessionManager,
+        turnManager,
+        draftDeps: {
+          sendMessage: (id, t, o) =>
+            bot.api.sendMessage(id, t, o as any),
+          editMessageText: (id, m, t, o) =>
+            bot.api.editMessageText(id, m, t, o as any),
+        },
+      })
+
+      startTypingLoop(
+        chatId,
+        (id, action) => bot.api.sendChatAction(id, action as any),
+        turn.abortController.signal,
+      )
+    })
+  }
+
+  bot.catch((err) => {
+    console.error("Bot error:", err.message)
+  })
+
+  return bot
+}
+
+// --- Testable handler functions ---
+
+export async function handleMessage(params: {
+  chatId: number
+  text: string
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  turnManager: TurnManager
+  draftDeps?: import("./send/draft-stream").DraftStreamDeps
+}): Promise<{ turn: ActiveTurn }> {
+  const { chatId, text, sdk, sessionManager, turnManager, draftDeps } = params
+  const chatKey = String(chatId)
+
+  const entry = await sessionManager.getOrCreate(chatKey, sdk)
+  const turn = turnManager.start(entry.sessionId, chatId)
+
+  // Attach draft stream BEFORE firing the prompt, so SSE events
+  // can update the draft immediately as they arrive.
+  if (draftDeps) {
+    turn.draft = new DraftStream(draftDeps, chatId, turn.abortController.signal)
+  }
+
+  // Fire-and-forget: don't block the Grammy handler.
+  // The response comes via SSE events → DraftStream → finalizeResponse.
+  sdk.session.prompt({
+    sessionID: entry.sessionId,
+    parts: [{ type: "text", text }],
+  }).catch((err: unknown) => {
+    console.error("Prompt error:", err)
+  })
+
+  return { turn }
+}
+
+export async function handleNew(params: {
+  chatId: number
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+}) {
+  const { chatId, sdk, sessionManager } = params
+  const chatKey = String(chatId)
+
+  // Remove existing session mapping (session persists on server)
+  sessionManager.remove(chatKey)
+
+  // Create fresh session
+  const entry = await sessionManager.getOrCreate(chatKey, sdk)
+  return entry
+}

package/src/config.ts

@@ -0,0 +1,32 @@
+export type Config = {
+  botToken: string
+  opencodeUrl: string
+  projectDirectory: string
+  testEnv: boolean
+  e2e: {
+    apiId: number
+    apiHash: string
+    session: string
+    botUsername: string
+  }
+}
+
+export function loadConfig(): Config {
+  const botToken = process.env.TELEGRAM_BOT_TOKEN
+  if (!botToken) {
+    throw new Error("TELEGRAM_BOT_TOKEN is required")
+  }
+
+  return {
+    botToken,
+    opencodeUrl: process.env.OPENCODE_URL ?? "http://127.0.0.1:4096",
+    projectDirectory: process.env.OPENCODE_DIRECTORY ?? process.cwd(),
+    testEnv: process.env.TELEGRAM_TEST_ENV === "1",
+    e2e: {
+      apiId: Number(process.env.TELEGRAM_API_ID ?? 0),
+      apiHash: process.env.TELEGRAM_API_HASH ?? "",
+      session: process.env.TELEGRAM_SESSION ?? "",
+      botUsername: process.env.TELEGRAM_BOT_USERNAME ?? "",
+    },
+  }
+}

package/src/event-bus.ts

@@ -0,0 +1,90 @@
+/**
+ * Single SSE connection to the OpenCode server.
+ *
+ * Routes incoming events to the correct Telegram chat by looking up
+ * the sessionId → chatKey mapping via SessionManager.
+ *
+ * Anti-leak design:
+ *   - One connection for ALL sessions (not one per session)
+ *   - AbortController for clean shutdown
+ *   - Auto-reconnect with backoff on stream end
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import type { SessionManager } from "./session-manager"
+
+export type EventHandler = (
+  sessionId: string,
+  chatKey: string,
+  event: any,
+) => void
+
+export type EventBusOptions = {
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  onEvent: EventHandler
+}
+
+export class EventBus {
+  private readonly sdk: OpencodeClient
+  private readonly sessionManager: SessionManager
+  private readonly onEvent: EventHandler
+  private stopped = false
+
+  constructor(opts: EventBusOptions) {
+    this.sdk = opts.sdk
+    this.sessionManager = opts.sessionManager
+    this.onEvent = opts.onEvent
+  }
+
+  async start(): Promise<void> {
+    this.stopped = false
+    this.listen().catch((err) => {
+      if (!this.stopped) {
+        console.error("EventBus stream error:", err)
+      }
+    })
+  }
+
+  stop(): void {
+    this.stopped = true
+  }
+
+  private async listen(): Promise<void> {
+    const result = await this.sdk.event.subscribe()
+    for await (const event of result.stream) {
+      if (this.stopped) break
+
+      const sessionId = extractSessionId(event)
+      if (!sessionId) continue
+
+      const lookup = this.sessionManager.getBySessionId(sessionId)
+      if (!lookup) continue
+
+      try {
+        this.onEvent(sessionId, lookup.chatKey, event)
+      } catch (err) {
+        console.error("EventBus handler error:", err)
+      }
+    }
+  }
+}
+
+/**
+ * Extract sessionID from various event shapes.
+ * Events may have it at:
+ *   - event.properties.part.sessionID (message.part.updated)
+ *   - event.properties.info.sessionID (message.updated)
+ *   - event.properties.sessionID (session.idle, session.error, etc.)
+ */
+function extractSessionId(event: any): string | undefined {
+  const props = event?.properties
+  if (!props) return undefined
+
+  return (
+    props.part?.sessionID ??
+    props.info?.sessionID ??
+    props.sessionID ??
+    undefined
+  )
+}

package/src/handlers/cancel.ts

@@ -0,0 +1,30 @@
+/**
+ * /cancel command handler — aborts the active generation.
+ *
+ * Calls sdk.session.abort() and cleans up the TurnManager.
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import type { SessionManager } from "../session-manager"
+import type { TurnManager } from "../turn-manager"
+
+export async function handleCancel(params: {
+  chatId: number
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  turnManager: TurnManager
+}): Promise<string> {
+  const { chatId, sdk, sessionManager, turnManager } = params
+  const chatKey = String(chatId)
+
+  const entry = sessionManager.get(chatKey)
+  if (!entry) return "No active session."
+
+  const turn = turnManager.get(entry.sessionId)
+  if (!turn) return "Nothing running."
+
+  await sdk.session.abort({ sessionID: entry.sessionId })
+  turnManager.end(entry.sessionId)
+
+  return "Generation cancelled."
+}

package/src/handlers/permissions.ts

@@ -0,0 +1,82 @@
+/**
+ * Permission event → Telegram inline keyboard message.
+ *
+ * Pure functions:
+ *   - formatPermissionMessage(perm) → { text, reply_markup } for sendMessage
+ *   - parsePermissionCallback(data) → { requestID, reply } parsed from callback_data
+ */
+
+export type PermissionEvent = {
+  id: string
+  sessionID: string
+  permission: string
+  patterns: string[]
+  metadata: Record<string, unknown>
+  always: string[]
+  tool?: { messageID: string; callID: string }
+}
+
+type InlineKeyboardButton = {
+  text: string
+  callback_data: string
+}
+
+type InlineKeyboardMarkup = {
+  inline_keyboard: InlineKeyboardButton[][]
+}
+
+export function formatPermissionMessage(perm: PermissionEvent): {
+  text: string
+  reply_markup: InlineKeyboardMarkup
+} {
+  const description = perm.patterns.length > 0
+    ? perm.patterns.join(", ")
+    : perm.permission
+
+  const text = `Permission needed: <b>${escapeHtml(perm.permission)}</b>\n<code>${escapeHtml(description)}</code>`
+
+  return {
+    text,
+    reply_markup: {
+      inline_keyboard: [
+        [
+          { text: "✓ Allow", callback_data: `perm:once:${perm.id}` },
+          { text: "✓ Always", callback_data: `perm:always:${perm.id}` },
+          { text: "✗ Deny", callback_data: `perm:deny:${perm.id}` },
+        ],
+      ],
+    },
+  }
+}
+
+const VALID_ACTIONS = new Set(["once", "always", "deny"])
+
+const ACTION_TO_REPLY: Record<string, "once" | "always" | "reject"> = {
+  once: "once",
+  always: "always",
+  deny: "reject",
+}
+
+export function parsePermissionCallback(
+  data: string,
+): { requestID: string; reply: "once" | "always" | "reject" } | null {
+  if (!data.startsWith("perm:")) return null
+
+  const firstColon = data.indexOf(":")
+  const secondColon = data.indexOf(":", firstColon + 1)
+  if (secondColon === -1) return null
+
+  const action = data.slice(firstColon + 1, secondColon)
+  const requestID = data.slice(secondColon + 1)
+
+  if (!VALID_ACTIONS.has(action) || !requestID) return null
+
+  return { requestID, reply: ACTION_TO_REPLY[action] }
+}
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+}

package/src/handlers/questions.ts

@@ -0,0 +1,107 @@
+/**
+ * Question event → Telegram inline keyboard message.
+ *
+ * Pure functions:
+ *   - formatQuestionMessage(event) → { text, reply_markup }
+ *   - parseQuestionCallback(data) → parsed callback action
+ *   - resolveQuestionAnswer(index, pending) → answer labels array
+ *
+ * Phase 2 MVP: handles first question only (single-select).
+ */
+
+import type { PendingEntry } from "../pending-requests"
+
+export type QuestionOption = {
+  label: string
+  description: string
+}
+
+export type QuestionInfo = {
+  question: string
+  header: string
+  options: QuestionOption[]
+  multiple?: boolean
+  custom?: boolean
+}
+
+export type QuestionEvent = {
+  id: string
+  sessionID: string
+  questions: QuestionInfo[]
+  tool?: { messageID: string; callID: string }
+}
+
+type InlineKeyboardButton = {
+  text: string
+  callback_data: string
+}
+
+type InlineKeyboardMarkup = {
+  inline_keyboard: InlineKeyboardButton[][]
+}
+
+export function formatQuestionMessage(event: QuestionEvent): {
+  text: string
+  reply_markup: InlineKeyboardMarkup
+} {
+  // Phase 2 MVP: handle first question only
+  const q = event.questions[0]
+  const text = q.question
+
+  const optionRows: InlineKeyboardButton[][] = q.options.map((opt, i) => [
+    { text: opt.label, callback_data: `q:${event.id}:${i}` },
+  ])
+
+  // Skip button as last row
+  optionRows.push([
+    { text: "✗ Skip", callback_data: `q:${event.id}:skip` },
+  ])
+
+  return {
+    text,
+    reply_markup: { inline_keyboard: optionRows },
+  }
+}
+
+export type ParsedQuestionCallback =
+  | { requestID: string; action: "select"; optionIndex: number }
+  | { requestID: string; action: "skip" }
+
+export function parseQuestionCallback(
+  data: string,
+): ParsedQuestionCallback | null {
+  if (!data.startsWith("q:")) return null
+
+  // Format: q:{requestID}:{index|skip}
+  const firstColon = data.indexOf(":")
+  const lastColon = data.lastIndexOf(":")
+  if (firstColon === lastColon) return null
+
+  const requestID = data.slice(firstColon + 1, lastColon)
+  const suffix = data.slice(lastColon + 1)
+
+  if (!requestID) return null
+
+  if (suffix === "skip") {
+    return { requestID, action: "skip" }
+  }
+
+  const optionIndex = parseInt(suffix, 10)
+  if (isNaN(optionIndex)) return null
+
+  return { requestID, action: "select", optionIndex }
+}
+
+export function resolveQuestionAnswer(
+  optionIndex: number,
+  pending: PendingEntry,
+): string[] {
+  const questions = pending.questions ?? []
+  const firstQuestion = questions[0]
+  if (!firstQuestion) return []
+
+  const option = firstQuestion.options[optionIndex]
+  if (!option) return []
+
+  return [option.label]
+}

package/src/handlers/typing.ts

@@ -0,0 +1,27 @@
+/**
+ * Typing indicator loop — sends "typing" chat action every 4 seconds.
+ *
+ * Telegram's typing indicator expires after ~5s, so we re-send it
+ * at 4s intervals. Tied to an AbortSignal for automatic cleanup
+ * when the turn ends.
+ */
+
+export function startTypingLoop(
+  chatId: number,
+  sendAction: (chatId: number, action: string) => Promise<unknown>,
+  signal: AbortSignal,
+): void {
+  const send = () => {
+    sendAction(chatId, "typing").catch(() => {})
+  }
+
+  const schedule = () => {
+    if (signal.aborted) return
+    send()
+    const timer = setTimeout(schedule, 4000)
+    const onAbort = () => clearTimeout(timer)
+    signal.addEventListener("abort", onAbort, { once: true })
+  }
+
+  schedule()
+}