@pedrohnas/opencode-telegram 0.1.0 → 1.2.0

package/e2e/client.ts

@@ -0,0 +1,24 @@
+import { TelegramClient } from "telegram"
+import { StringSession } from "telegram/sessions"
+
+export type TestClientConfig = {
+  apiId: number
+  apiHash: string
+  session: string
+}
+
+export async function createTestClient(
+  config: TestClientConfig,
+): Promise<TelegramClient> {
+  const client = new TelegramClient(
+    new StringSession(config.session),
+    config.apiId,
+    config.apiHash,
+    {
+      connectionRetries: 3,
+      retryDelay: 1000,
+    },
+  )
+  await client.connect()
+  return client
+}

package/e2e/helpers.ts

@@ -0,0 +1,119 @@
+import type { TelegramClient } from "telegram"
+import { Api } from "telegram/tl"
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms))
+}
+
+/**
+ * Send a message to the bot and wait for a reply.
+ * Polls for new messages from the bot until one arrives after our send time.
+ */
+export async function sendAndWait(
+  client: TelegramClient,
+  botUsername: string,
+  text: string,
+  timeoutMs = 15000,
+): Promise<Api.Message> {
+  // Get the latest message ID before sending, so we only look for newer messages
+  const messagesBefore = await client.getMessages(botUsername, { limit: 1 })
+  const lastIdBefore = messagesBefore[0]?.id ?? 0
+
+  await client.sendMessage(botUsername, { message: text })
+
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    await sleep(1500)
+    const messages = await client.getMessages(botUsername, { limit: 5 })
+    for (const msg of messages) {
+      // Bot messages have .out === false (not sent by us)
+      // Only consider messages with ID greater than what existed before we sent
+      if (!msg.out && msg.id > lastIdBefore) {
+        return msg
+      }
+    }
+  }
+  throw new Error(`Bot did not reply within ${timeoutMs}ms after sending: "${text}"`)
+}
+
+/**
+ * Wait for the next bot reply (without sending anything).
+ */
+export async function waitForBotReply(
+  client: TelegramClient,
+  botUsername: string,
+  timeoutMs = 15000,
+): Promise<Api.Message> {
+  const before = Math.floor(Date.now() / 1000)
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    await sleep(500)
+    const messages = await client.getMessages(botUsername, { limit: 5 })
+    for (const msg of messages) {
+      if (!msg.out && msg.date >= before) {
+        return msg
+      }
+    }
+  }
+  throw new Error(`Bot did not reply within ${timeoutMs}ms`)
+}
+
+/**
+ * Click an inline keyboard button by matching its text.
+ */
+export async function clickInlineButton(
+  client: TelegramClient,
+  botUsername: string,
+  msgId: number,
+  buttonText: string,
+): Promise<void> {
+  const messages = await client.getMessages(botUsername, { ids: [msgId] })
+  const msg = messages[0]
+  if (!msg?.replyMarkup || !(msg.replyMarkup instanceof Api.ReplyInlineMarkup)) {
+    throw new Error("Message has no inline keyboard")
+  }
+
+  for (const row of msg.replyMarkup.rows) {
+    for (const btn of row.buttons) {
+      if (btn.text.includes(buttonText) && btn instanceof Api.KeyboardButtonCallback) {
+        await client.invoke(
+          new Api.messages.GetBotCallbackAnswer({
+            peer: botUsername,
+            msgId,
+            data: btn.data,
+          }),
+        )
+        return
+      }
+    }
+  }
+  throw new Error(`Button "${buttonText}" not found in message ${msgId}`)
+}
+
+/**
+ * Assert that a message's text contains a string or matches a regex.
+ */
+export function assertContains(msg: Api.Message, pattern: string | RegExp): void {
+  const text = msg.text ?? msg.message ?? ""
+  if (typeof pattern === "string") {
+    if (!text.includes(pattern)) {
+      throw new Error(`Expected "${pattern}" in message, got: "${text.slice(0, 200)}"`)
+    }
+  } else {
+    if (!pattern.test(text)) {
+      throw new Error(`Expected ${pattern} to match message, got: "${text.slice(0, 200)}"`)
+    }
+  }
+}
+
+/**
+ * Assert that a message has inline keyboard buttons.
+ */
+export function assertHasButtons(msg: Api.Message): void {
+  if (!msg.replyMarkup || !(msg.replyMarkup instanceof Api.ReplyInlineMarkup)) {
+    throw new Error("Expected inline buttons, got none")
+  }
+  if (msg.replyMarkup.rows.length === 0) {
+    throw new Error("Expected inline buttons, got empty keyboard")
+  }
+}

package/e2e/phase-0.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait, assertContains } from "./helpers"
+
+describe("Phase 0 — Bot Skeleton", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000) // 90s: OpenCode server + bot + gramjs startup
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test("bot responds to /start", async () => {
+    const client = getClient()
+    const reply = await sendAndWait(client, getBotUsername(), "/start")
+    assertContains(reply, "OpenCode Telegram Bot")
+    assertContains(reply, "/new")
+    assertContains(reply, "/cancel")
+  }, 20000)
+
+  test("bot does not crash on unknown command", async () => {
+    const client = getClient()
+    // Send unknown command — bot should not crash
+    // (It may respond via AI or ignore it — either is fine)
+    const reply = await sendAndWait(client, getBotUsername(), "/nonexistent_command_xyz", 30000)
+    // Bot responded without crashing — that's the test
+    expect(reply).toBeDefined()
+  }, 45000)
+})

package/e2e/phase-1.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait, assertContains } from "./helpers"
+
+describe("Phase 1 — Core Loop", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test(
+    "/start still works (regression)",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(client, getBotUsername(), "/start")
+      assertContains(reply, "OpenCode Telegram Bot")
+    },
+    20000,
+  )
+
+  test(
+    "/new creates fresh session",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(client, getBotUsername(), "/new", 30000)
+      assertContains(reply, /session/i)
+    },
+    45000,
+  )
+
+  test(
+    "text message gets AI response",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "Say exactly the word hello and nothing else",
+        60000,
+      )
+      assertContains(reply, /hello/i)
+    },
+    90000,
+  )
+})

package/e2e/phase-2.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, beforeAll, afterAll, expect } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait, assertContains } from "./helpers"
+
+describe("Phase 2 — Interactive Controls", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test(
+    "/start still works (regression)",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(client, getBotUsername(), "/start")
+      assertContains(reply, "OpenCode Telegram Bot")
+    },
+    20000,
+  )
+
+  test(
+    "/cancel with no active turn returns 'Nothing running.'",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Fresh session
+      await sendAndWait(client, bot, "/new", 30000)
+
+      // Cancel with nothing running
+      const reply = await sendAndWait(client, bot, "/cancel", 15000)
+      assertContains(reply, /nothing running/i)
+    },
+    60000,
+  )
+
+  test(
+    "text message still gets AI response (Phase 2 wiring regression)",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "Say exactly the word hello and nothing else",
+        60000,
+      )
+      assertContains(reply, /hello/i)
+    },
+    90000,
+  )
+})

package/e2e/phase-3.test.ts

@@ -0,0 +1,142 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait, assertContains } from "./helpers"
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms))
+}
+
+describe("Phase 3 — Streaming + UX", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test(
+    "response appears before AI finishes (draft streaming)",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Get baseline message ID before sending
+      const before = await client.getMessages(bot, { limit: 1 })
+      const lastIdBefore = before[0]?.id ?? 0
+
+      // Send a prompt that requires a lengthy response (forces streaming)
+      await client.sendMessage(bot, {
+        message:
+          "Write a detailed explanation of how TCP/IP works, covering at least the 4 layers. Be thorough.",
+      })
+
+      // Poll for the draft message to appear (should arrive within seconds, NOT after full response)
+      let draftId: number | null = null
+      let draftText = ""
+      const draftDeadline = Date.now() + 15000
+      while (Date.now() < draftDeadline) {
+        await sleep(1500)
+        const msgs = await client.getMessages(bot, { limit: 5 })
+        const botMsg = msgs.find((m) => !m.out && m.id > lastIdBefore)
+        if (botMsg) {
+          draftId = botMsg.id
+          draftText = botMsg.text ?? botMsg.message ?? ""
+          break
+        }
+      }
+
+      expect(draftId).not.toBeNull()
+      expect(draftText.length).toBeGreaterThan(0)
+
+      // Wait for response to finalize
+      await sleep(8000)
+
+      // Re-fetch the SAME message by ID — it should have been edited (streaming via edit)
+      const updated = await client.getMessages(bot, { ids: [draftId!] })
+      const finalMsg = updated[0]
+      const finalText = finalMsg?.text ?? finalMsg?.message ?? ""
+
+      // Core assertion: same message ID was reused (streaming via edit, not new message)
+      // Note: final text may be shorter than draft (tool suffix gets stripped on finalization)
+      expect(finalMsg?.id).toBe(draftId)
+      expect(finalText.length).toBeGreaterThan(0)
+    },
+    90000,
+  )
+
+  test(
+    "tool call shows progress indicator then completes",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Start fresh session to avoid context carryover
+      await sendAndWait(client, bot, "/new", 30000)
+
+      const before = await client.getMessages(bot, { limit: 1 })
+      const lastIdBefore = before[0]?.id ?? 0
+
+      // Prompt that will trigger a tool call (bash/read)
+      await client.sendMessage(bot, {
+        message: "Run the command: echo 'e2e-tool-test-ok'",
+      })
+
+      // Poll for bot messages — look for the tool indicator or final response
+      let sawToolIndicator = false
+      const deadline = Date.now() + 30000
+      while (Date.now() < deadline) {
+        await sleep(1500)
+        const msgs = await client.getMessages(bot, { limit: 5 })
+        for (const msg of msgs) {
+          if (msg.out || msg.id <= lastIdBefore) continue
+          const text = msg.text ?? msg.message ?? ""
+          // Check for tool progress indicator (⚙) in any snapshot
+          if (text.includes("⚙") || text.includes("Running")) {
+            sawToolIndicator = true
+          }
+          // Check for final result
+          if (text.includes("e2e-tool-test-ok")) {
+            // Tool completed — the response contains the output
+            expect(text).toContain("e2e-tool-test-ok")
+            return
+          }
+        }
+      }
+
+      // If we get here, at least verify the bot responded
+      const finalMsgs = await client.getMessages(bot, { limit: 5 })
+      const botReply = finalMsgs.find((m) => !m.out && m.id > lastIdBefore)
+      expect(botReply).toBeDefined()
+    },
+    60000,
+  )
+
+  test(
+    "regression: /start still works",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(client, getBotUsername(), "/start")
+      assertContains(reply, "OpenCode Telegram Bot")
+    },
+    20000,
+  )
+
+  test(
+    "regression: text message gets AI response",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "Respond with exactly the single word: hello",
+        60000,
+      )
+      // Bot responded — content varies by model config (may be "hello", "Feito", etc.)
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    90000,
+  )
+})

package/e2e/phase-4.test.ts

@@ -0,0 +1,96 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait, assertContains, assertHasButtons } from "./helpers"
+
+describe("Phase 4 — Session Management + Hardening", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test(
+    "/list shows sessions (with inline keyboard after creating one)",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Ensure at least one session exists by sending a message
+      await sendAndWait(client, bot, "Say hello", 60000)
+
+      // Now list sessions
+      const reply = await sendAndWait(client, bot, "/list", 15000)
+      const text = reply.text ?? reply.message ?? ""
+      // Should show session selection or a list
+      expect(text.length).toBeGreaterThan(0)
+      // Should have inline keyboard buttons
+      assertHasButtons(reply)
+    },
+    120000,
+  )
+
+  test(
+    "/info shows session details",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(client, getBotUsername(), "/info", 15000)
+      const text = reply.text ?? reply.message ?? ""
+      // Should contain session info (title, dates, directory)
+      assertContains(reply, /session|directory|created/i)
+    },
+    30000,
+  )
+
+  test(
+    "/rename changes session title",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "/rename E2E Test Session",
+        15000,
+      )
+      assertContains(reply, /renamed/i)
+    },
+    30000,
+  )
+
+  test(
+    "regression: text message gets AI response",
+    async () => {
+      const client = getClient()
+      // Start fresh to avoid context from previous tests
+      await sendAndWait(client, getBotUsername(), "/new", 30000)
+
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "Respond with exactly the single word: hello",
+        60000,
+      )
+      // Bot responded — content varies by model config
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+
+  test(
+    "regression: /new creates fresh session",
+    async () => {
+      const client = getClient()
+      const reply = await sendAndWait(
+        client,
+        getBotUsername(),
+        "/new",
+        15000,
+      )
+      assertContains(reply, /session/i)
+    },
+    30000,
+  )
+})

package/e2e/runner.ts

@@ -0,0 +1,145 @@
+import { spawn, type Subprocess } from "bun"
+import type { TelegramClient } from "telegram"
+import { createTestClient } from "./client"
+import { loadConfig } from "../src/config"
+import { resolve } from "node:path"
+
+let serverProcess: Subprocess | null = null
+let botProcess: Subprocess | null = null
+let testClient: TelegramClient | null = null
+let botUsername = ""
+
+/**
+ * Start OpenCode server + bot as subprocesses and connect the gramjs test client.
+ * Must be called in beforeAll().
+ */
+export async function setup(): Promise<void> {
+  const config = loadConfig()
+
+  if (!config.e2e.apiId || !config.e2e.apiHash || !config.e2e.session) {
+    throw new Error(
+      "E2E tests require TELEGRAM_API_ID, TELEGRAM_API_HASH, and TELEGRAM_SESSION env vars. " +
+        "See .env.example for details.",
+    )
+  }
+
+  if (!config.e2e.botUsername) {
+    throw new Error("E2E tests require TELEGRAM_BOT_USERNAME env var.")
+  }
+
+  botUsername = config.e2e.botUsername
+  const packageDir = import.meta.dir.replace("/e2e", "")
+  const opencodeDir = resolve(packageDir, "../opencode")
+
+  // 1. Start OpenCode server
+  serverProcess = spawn(
+    [process.execPath, "run", "--conditions=browser", "./src/index.ts", "serve", "--port=0"],
+    {
+      cwd: opencodeDir,
+      env: { ...process.env },
+      stdout: "pipe",
+      stderr: "pipe",
+    },
+  )
+
+  const serverUrl = await waitForPattern(
+    serverProcess,
+    /opencode server listening on (https?:\/\/[^\s]+)/,
+    30000,
+    "OpenCode server",
+  )
+
+  console.log(`E2E: OpenCode server at ${serverUrl}`)
+
+  // 2. Start bot with OPENCODE_URL pointing to our server
+  // Use /home/pedro/dev as project dir (has opencode.json with Opus configured)
+  const projectDir = process.env.OPENCODE_DIRECTORY ?? resolve(packageDir, "../../..")
+  botProcess = spawn([process.execPath, "run", "src/index.ts"], {
+    cwd: packageDir,
+    env: { ...process.env, OPENCODE_URL: serverUrl, OPENCODE_DIRECTORY: projectDir, TELEGRAM_ALLOWED_USERS: "*" },
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+
+  await waitForPattern(botProcess, /Bot started/, 30000, "Bot")
+  console.log("E2E: Bot started")
+
+  // 3. Connect gramjs test client
+  testClient = await createTestClient({
+    apiId: config.e2e.apiId,
+    apiHash: config.e2e.apiHash,
+    session: config.e2e.session,
+  })
+}
+
+/**
+ * Stop everything and disconnect the test client.
+ * Must be called in afterAll().
+ */
+export async function teardown(): Promise<void> {
+  if (testClient) {
+    await testClient.disconnect().catch(() => {})
+    testClient = null
+  }
+  if (botProcess) {
+    botProcess.kill()
+    botProcess = null
+  }
+  if (serverProcess) {
+    serverProcess.kill()
+    serverProcess = null
+  }
+}
+
+export function getClient(): TelegramClient {
+  if (!testClient) throw new Error("Test client not initialized. Call setup() first.")
+  return testClient
+}
+
+export function getBotUsername(): string {
+  if (!botUsername) throw new Error("Bot username not set. Call setup() first.")
+  return botUsername
+}
+
+/**
+ * Read stdout of a process until a regex pattern matches.
+ * Uses `for await` on the ReadableStream — reliable with Bun.spawn.
+ * Returns the first capture group if present, otherwise the full match.
+ */
+async function waitForPattern(
+  proc: Subprocess,
+  pattern: RegExp,
+  timeoutMs: number,
+  label: string,
+): Promise<string> {
+  if (!proc.stdout) throw new Error(`${label} process has no stdout`)
+
+  let output = ""
+  const decoder = new TextDecoder()
+
+  // Race the stream against a timeout
+  const result = await Promise.race([
+    (async () => {
+      for await (const chunk of proc.stdout!) {
+        output += decoder.decode(chunk)
+        const match = output.match(pattern)
+        if (match) {
+          return match[1] ?? match[0]
+        }
+      }
+      // Stream ended without match
+      return null
+    })(),
+    new Promise<null>((resolve) =>
+      setTimeout(() => resolve(null), timeoutMs),
+    ),
+  ])
+
+  if (result) return result
+
+  if (proc.exitCode !== null) {
+    throw new Error(`${label} exited with code ${proc.exitCode}. Output: ${output}`)
+  }
+
+  throw new Error(`${label} did not match "${pattern}" within ${timeoutMs}ms. Output: ${output}`)
+}

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@pedrohnas/opencode-telegram",
-  "version": "0.1.0",
-  "description": "Telegram bot for OpenCode — AI coding assistant via Telegram",
+  "version": "1.2.0",
   "type": "module",
-  "bin": {
-    "opencode-telegram": "./src/index.ts"
-  },
-  "files": [
-    "src/**/*.ts",
-    "!src/**/*.test.ts"
-  ],
   "license": "MIT",
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "test": "bun test src/",
+    "test:e2e": "bun test e2e/",
+    "typecheck": "tsgo --noEmit"
+  },
   "dependencies": {
-    "@opencode-ai/sdk": "^1.1.53",
+    "@opencode-ai/sdk": "workspace:*",
     "grammy": "^1.35.0"
   },
-  "engines": {
-    "bun": ">=1.0.0"
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "@typescript/native-preview": "catalog:",
+    "telegram": "^2.26.16"
   }
 }