@pedrohnas/opencode-telegram 0.1.0 → 1.2.0

package/scripts/gen-session.ts

@@ -0,0 +1,49 @@
+/**
+ * Generate a gramjs StringSession for E2E testing.
+ *
+ * Usage:
+ *   TELEGRAM_API_ID=12345 TELEGRAM_API_HASH=abcdef bun run scripts/gen-session.ts
+ *
+ * This will prompt for your phone number and the code Telegram sends.
+ * At the end it prints the session string — copy it to your .env file.
+ */
+import { TelegramClient } from "telegram"
+import { StringSession } from "telegram/sessions"
+import * as readline from "node:readline"
+
+const apiId = Number(process.env.TELEGRAM_API_ID)
+const apiHash = process.env.TELEGRAM_API_HASH ?? ""
+
+if (!apiId || !apiHash) {
+  console.error("Set TELEGRAM_API_ID and TELEGRAM_API_HASH env vars first.")
+  process.exit(1)
+}
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.trim())
+    })
+  })
+}
+
+const session = new StringSession("")
+const client = new TelegramClient(session, apiId, apiHash, {
+  connectionRetries: 3,
+})
+
+await client.start({
+  phoneNumber: () => prompt("Phone number (with country code, e.g. +5511999999999): "),
+  phoneCode: () => prompt("Code from Telegram: "),
+  password: () => prompt("2FA password (if enabled, otherwise press Enter): "),
+  onError: (err) => console.error("Error:", err),
+})
+
+console.log("\n=== Session string (copy this to .env as TELEGRAM_SESSION) ===\n")
+console.log(client.session.save())
+console.log("\n=== Done ===")
+
+await client.disconnect()
+process.exit(0)

package/src/bot.test.ts

@@ -0,0 +1,301 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { createBot, START_MESSAGE, type BotDeps } from "./bot"
+import { SessionManager } from "./session-manager"
+import { TurnManager } from "./turn-manager"
+import { PendingRequests } from "./pending-requests"
+import type { Config } from "./config"
+
+const testConfig: Config = {
+  botToken: "123456:ABC-DEF_test-token",
+  opencodeUrl: "http://127.0.0.1:4096",
+  projectDirectory: "/tmp/test",
+  testEnv: false,
+  allowedUsers: [],
+  allowAllUsers: true,
+  e2e: { apiId: 0, apiHash: "", session: "", botUsername: "" },
+}
+
+// --- Phase 0 tests (unchanged) ---
+
+describe("createBot", () => {
+  test("returns a Bot instance", () => {
+    const bot = createBot(testConfig)
+    expect(bot).toBeDefined()
+    expect(bot.start).toBeFunction()
+    expect(bot.stop).toBeFunction()
+  })
+
+  test("bot has error handler", () => {
+    const bot = createBot(testConfig)
+    expect(bot.errorHandler).toBeDefined()
+  })
+})
+
+describe("START_MESSAGE", () => {
+  test("contains expected text", () => {
+    expect(START_MESSAGE).toContain("OpenCode Telegram Bot")
+    expect(START_MESSAGE).toContain("/new")
+    expect(START_MESSAGE).toContain("/cancel")
+  })
+})
+
+// --- Phase 1 tests: handleMessage and handleNew ---
+
+describe("handleMessage", () => {
+  test("calls sdk.session.prompt with correct parts", async () => {
+    const { handleMessage } = await import("./bot")
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    // Pre-populate session
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+
+    const sdk = {
+      session: { prompt: promptMock, create: mock(async () => ({ data: { id: "s1" } })) },
+    } as any
+
+    await handleMessage({
+      chatId: 123,
+      text: "hello world",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    // Prompt is fire-and-forget — wait a microtick for the promise to resolve
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(promptMock).toHaveBeenCalledTimes(1)
+    const call = promptMock.mock.calls[0]![0] as any
+    expect(call.sessionID).toBe("s1")
+    expect(call.parts[0].type).toBe("text")
+    expect(call.parts[0].text).toBe("hello world")
+  })
+
+  test("creates session automatically for unknown chat", async () => {
+    const { handleMessage } = await import("./bot")
+    const createMock = mock(async () => ({
+      data: { id: "new-s1", directory: "/tmp" },
+    }))
+    const promptMock = mock(async () => ({ data: {} }))
+
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = {
+      session: { create: createMock, prompt: promptMock },
+    } as any
+
+    await handleMessage({
+      chatId: 999,
+      text: "test",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    // Wait for fire-and-forget prompt
+    await new Promise((r) => setTimeout(r, 10))
+
+    // Should have created a session
+    expect(createMock).toHaveBeenCalledTimes(1)
+    // And then prompted it
+    expect(promptMock).toHaveBeenCalledTimes(1)
+  })
+
+  test("starts a turn and returns it", async () => {
+    const { handleMessage } = await import("./bot")
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: mock(async () => ({ data: {} })),
+        create: mock(async () => ({ data: { id: "s1" } })),
+      },
+    } as any
+
+    const result = await handleMessage({
+      chatId: 123,
+      text: "hello",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    expect(result.turn).toBeDefined()
+    expect(result.turn.chatId).toBe(123)
+    expect(result.turn.sessionId).toBe("s1")
+    expect(tm.get("s1")).toBeDefined()
+  })
+})
+
+describe("handleNew", () => {
+  test("removes old session and creates new one", async () => {
+    const { handleNew } = await import("./bot")
+    const createMock = mock(async () => ({
+      data: { id: "new-session", directory: "/tmp" },
+    }))
+
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    sm.set("123", { sessionId: "old-session", directory: "/tmp" })
+
+    const sdk = {
+      session: { create: createMock },
+    } as any
+
+    const result = await handleNew({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+    })
+
+    // Old session mapping removed, new one created
+    expect(sm.get("123")!.sessionId).toBe("new-session")
+    expect(sm.getBySessionId("old-session")).toBeUndefined()
+    expect(createMock).toHaveBeenCalledTimes(1)
+    expect(result.sessionId).toBe("new-session")
+  })
+
+  test("creates session for chat without existing session", async () => {
+    const { handleNew } = await import("./bot")
+    const createMock = mock(async () => ({
+      data: { id: "fresh-session", directory: "/tmp" },
+    }))
+
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const sdk = {
+      session: { create: createMock },
+    } as any
+
+    const result = await handleNew({
+      chatId: 456,
+      sdk,
+      sessionManager: sm,
+    })
+
+    expect(sm.get("456")!.sessionId).toBe("fresh-session")
+    expect(result.sessionId).toBe("fresh-session")
+  })
+})
+
+// --- Phase 4 tests: handleMessage abort, session commands ---
+
+describe("handleMessage — streaming interruption fix", () => {
+  test("calls sdk.session.abort when existing turn present", async () => {
+    const { handleMessage } = await import("./bot")
+    const abortMock = mock(async () => ({}))
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: abortMock,
+      },
+    } as any
+
+    // First message — creates a turn
+    await handleMessage({
+      chatId: 123,
+      text: "first message",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    // Second message — should abort old turn
+    await handleMessage({
+      chatId: 123,
+      text: "second message",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(abortMock).toHaveBeenCalledTimes(1)
+    const abortCall = abortMock.mock.calls[0]![0] as any
+    expect(abortCall.sessionID).toBe("s1")
+  })
+
+  test("does NOT call abort when no existing turn", async () => {
+    const { handleMessage } = await import("./bot")
+    const abortMock = mock(async () => ({}))
+    const promptMock = mock(async () => ({ data: {} }))
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const sdk = {
+      session: {
+        prompt: promptMock,
+        create: mock(async () => ({ data: { id: "s1" } })),
+        abort: abortMock,
+      },
+    } as any
+
+    // First message — no existing turn
+    await handleMessage({
+      chatId: 123,
+      text: "first message",
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    await new Promise((r) => setTimeout(r, 10))
+    expect(abortMock).not.toHaveBeenCalled()
+  })
+})
+
+describe("handleSessionCallback", () => {
+  test("switches session on valid sess: callback", async () => {
+    const { handleSessionCallback } = await import("./bot")
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const sdk = {
+      session: {
+        list: mock(async () => ({
+          data: [
+            { id: "session-full-id-12345", title: "My Session", directory: "/tmp", time: { created: 1000, updated: 2000 } },
+          ],
+        })),
+      },
+    } as any
+
+    const result = await handleSessionCallback({
+      chatKey: "123",
+      sessionPrefix: "session-full-id-1234",
+      sdk,
+      sessionManager: sm,
+    })
+
+    expect(result).toContain("Switched to")
+    expect(result).toContain("My Session")
+    expect(sm.get("123")?.sessionId).toBe("session-full-id-12345")
+  })
+
+  test("returns 'Session not found.' for unknown prefix", async () => {
+    const { handleSessionCallback } = await import("./bot")
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const sdk = {
+      session: {
+        list: mock(async () => ({ data: [] })),
+      },
+    } as any
+
+    const result = await handleSessionCallback({
+      chatKey: "123",
+      sessionPrefix: "nonexistent",
+      sdk,
+      sessionManager: sm,
+    })
+
+    expect(result).toBe("Session not found.")
+  })
+})

package/src/bot.ts

@@ -21,6 +21,16 @@ import {
 } from "./handlers/questions"
 import { startTypingLoop } from "./handlers/typing"
 import { DraftStream } from "./send/draft-stream"
+import { createAllowlistMiddleware } from "./handlers/allowlist"
+import {
+  handleList,
+  handleRename,
+  handleDelete,
+  handleInfo,
+  handleHistory,
+  handleSummarize,
+  parseSessionCallback,
+} from "./handlers/sessions"
 
 export const START_MESSAGE = [
   "OpenCode Telegram Bot",
@@ -40,6 +50,9 @@ export type BotDeps = {
 export function createBot(config: Config, deps?: BotDeps) {
   const bot = new Bot(config.botToken)
 
+  // Allowlist middleware — must be first (blocks unauthorized users)
+  bot.use(createAllowlistMiddleware(config.allowedUsers, config.allowAllUsers))
+
   bot.command("start", async (ctx) => {
     await ctx.reply(START_MESSAGE)
   })
@@ -53,6 +66,42 @@ export function createBot(config: Config, deps?: BotDeps) {
       await ctx.reply("New session started.")
     })
 
+    bot.command("list", async (ctx) => {
+      const result = await handleList({ sdk })
+      await ctx.reply(result.text, { reply_markup: result.reply_markup })
+    })
+
+    bot.command("rename", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const title = ctx.match?.trim() ?? ""
+      const result = await handleRename({ chatKey, title, sdk, sessionManager })
+      await ctx.reply(result)
+    })
+
+    bot.command("delete", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleDelete({ chatKey, sdk, sessionManager })
+      await ctx.reply(result)
+    })
+
+    bot.command("info", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleInfo({ chatKey, sdk, sessionManager })
+      await ctx.reply(result)
+    })
+
+    bot.command("history", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleHistory({ chatKey, sdk, sessionManager })
+      await ctx.reply(result)
+    })
+
+    bot.command("summarize", async (ctx) => {
+      const chatKey = String(ctx.chat.id)
+      const result = await handleSummarize({ chatKey, sdk, sessionManager })
+      await ctx.reply(result)
+    })
+
     bot.command("cancel", async (ctx) => {
       const chatId = ctx.chat.id
       const result = await handleCancel({
@@ -116,6 +165,20 @@ export function createBot(config: Config, deps?: BotDeps) {
         }
         return
       }
+
+      if (data.startsWith("sess:")) {
+        const parsed = parseSessionCallback(data)
+        if (!parsed) return
+        const chatKey = String(ctx.from.id)
+        const result = await handleSessionCallback({
+          chatKey,
+          sessionPrefix: parsed.sessionPrefix,
+          sdk,
+          sessionManager,
+        })
+        await ctx.editMessageText(result)
+        return
+      }
     })
 
     bot.on("message:text", async (ctx) => {
@@ -166,6 +229,15 @@ export async function handleMessage(params: {
   const chatKey = String(chatId)
 
   const entry = await sessionManager.getOrCreate(chatKey, sdk)
+
+  // Streaming interruption fix (N2): abort old server-side prompt
+  const existingTurn = turnManager.get(entry.sessionId)
+  if (existingTurn) {
+    sdk.session.abort({ sessionID: entry.sessionId }).catch((err: unknown) => {
+      console.error("Abort error:", err)
+    })
+  }
+
   const turn = turnManager.start(entry.sessionId, chatId)
 
   // Attach draft stream BEFORE firing the prompt, so SSE events
@@ -186,6 +258,25 @@ export async function handleMessage(params: {
   return { turn }
 }
 
+export async function handleSessionCallback(params: {
+  chatKey: string
+  sessionPrefix: string
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+}): Promise<string> {
+  const { chatKey, sessionPrefix, sdk, sessionManager } = params
+  const result = await sdk.session.list()
+  const sessions = (result as any).data ?? []
+  const match = sessions.find((s: any) => s.id.startsWith(sessionPrefix))
+  if (!match) return "Session not found."
+
+  sessionManager.set(chatKey, {
+    sessionId: match.id,
+    directory: match.directory ?? "",
+  })
+  return `Switched to: ${match.title || match.id}`
+}
+
 export async function handleNew(params: {
   chatId: number
   sdk: OpencodeClient

package/src/config.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import type { Config } from "./config"
+
+describe("loadConfig", () => {
+  const originalEnv = { ...process.env }
+
+  afterEach(() => {
+    // Restore original env
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) {
+        delete process.env[key]
+      }
+    }
+    Object.assign(process.env, originalEnv)
+  })
+
+  test("parses required TELEGRAM_BOT_TOKEN", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    const { loadConfig } = await import("./config")
+    const config = loadConfig()
+    expect(config.botToken).toBe("123:ABC")
+  })
+
+  test("throws when TELEGRAM_BOT_TOKEN is missing", async () => {
+    delete process.env.TELEGRAM_BOT_TOKEN
+    // Re-import to get fresh module
+    const mod = await import("./config?missing")
+    expect(() => mod.loadConfig()).toThrow()
+  })
+
+  test("uses default opencodeUrl when not set", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    const { loadConfig } = await import("./config?defaults")
+    const config = loadConfig()
+    expect(config.opencodeUrl).toBe("http://127.0.0.1:4096")
+  })
+
+  test("uses custom opencodeUrl when set", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.OPENCODE_URL = "http://localhost:9999"
+    const { loadConfig } = await import("./config?custom")
+    const config = loadConfig()
+    expect(config.opencodeUrl).toBe("http://localhost:9999")
+  })
+
+  test("defaults testEnv to false", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    const { loadConfig } = await import("./config?testenv1")
+    const config = loadConfig()
+    expect(config.testEnv).toBe(false)
+  })
+
+  test("sets testEnv to true when TELEGRAM_TEST_ENV=1", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_TEST_ENV = "1"
+    const { loadConfig } = await import("./config?testenv2")
+    const config = loadConfig()
+    expect(config.testEnv).toBe(true)
+  })
+
+  test("parses e2e config with defaults", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    delete process.env.TELEGRAM_API_ID
+    delete process.env.TELEGRAM_API_HASH
+    delete process.env.TELEGRAM_SESSION
+    delete process.env.TELEGRAM_BOT_USERNAME
+    const { loadConfig } = await import("./config?e2e1")
+    const config = loadConfig()
+    expect(config.e2e.apiId).toBe(0)
+    expect(config.e2e.apiHash).toBe("")
+    expect(config.e2e.session).toBe("")
+    expect(config.e2e.botUsername).toBe("")
+  })
+
+  test("parses e2e config from env", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_API_ID = "12345"
+    process.env.TELEGRAM_API_HASH = "abcdef"
+    process.env.TELEGRAM_SESSION = "session123"
+    process.env.TELEGRAM_BOT_USERNAME = "test_bot"
+    const { loadConfig } = await import("./config?e2e2")
+    const config = loadConfig()
+    expect(config.e2e.apiId).toBe(12345)
+    expect(config.e2e.apiHash).toBe("abcdef")
+    expect(config.e2e.session).toBe("session123")
+    expect(config.e2e.botUsername).toBe("test_bot")
+  })
+
+  test("parses TELEGRAM_ALLOWED_USERS as number array", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_ALLOWED_USERS = "111,222,333"
+    const { loadConfig } = await import("./config?allow1")
+    const config = loadConfig()
+    expect(config.allowedUsers).toEqual([111, 222, 333])
+  })
+
+  test("defaults allowedUsers to empty array when not set", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    delete process.env.TELEGRAM_ALLOWED_USERS
+    const { loadConfig } = await import("./config?allow2")
+    const config = loadConfig()
+    expect(config.allowedUsers).toEqual([])
+  })
+
+  test("defaults allowedUsers to empty array when empty string", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_ALLOWED_USERS = ""
+    const { loadConfig } = await import("./config?allow3")
+    const config = loadConfig()
+    expect(config.allowedUsers).toEqual([])
+    expect(config.allowAllUsers).toBe(false)
+  })
+
+  test("TELEGRAM_ALLOWED_USERS='*' sets allowAllUsers=true", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    process.env.TELEGRAM_ALLOWED_USERS = "*"
+    const { loadConfig } = await import("./config?allow4")
+    const config = loadConfig()
+    expect(config.allowAllUsers).toBe(true)
+    expect(config.allowedUsers).toEqual([])
+  })
+
+  test("allowAllUsers defaults to false when not set", async () => {
+    process.env.TELEGRAM_BOT_TOKEN = "123:ABC"
+    delete process.env.TELEGRAM_ALLOWED_USERS
+    const { loadConfig } = await import("./config?allow5")
+    const config = loadConfig()
+    expect(config.allowAllUsers).toBe(false)
+  })
+})

package/src/config.ts

@@ -3,6 +3,8 @@ export type Config = {
   opencodeUrl: string
   projectDirectory: string
   testEnv: boolean
+  allowedUsers: number[]
+  allowAllUsers: boolean
   e2e: {
     apiId: number
     apiHash: string
@@ -17,11 +19,24 @@ export function loadConfig(): Config {
     throw new Error("TELEGRAM_BOT_TOKEN is required")
   }
 
+  const rawAllowed = (process.env.TELEGRAM_ALLOWED_USERS ?? "").trim()
+  const allowAllUsers = rawAllowed === "*"
+  const allowedUsers = allowAllUsers
+    ? []
+    : rawAllowed
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map(Number)
+        .filter((n) => !isNaN(n))
+
   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",
+    allowedUsers,
+    allowAllUsers,
     e2e: {
       apiId: Number(process.env.TELEGRAM_API_ID ?? 0),
       apiHash: process.env.TELEGRAM_API_HASH ?? "",