@pedrohnas/opencode-telegram 1.2.1 → 1.3.0

package/e2e/phase-6.5.test.ts

@@ -0,0 +1,239 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import {
+  sendAndWait,
+  assertHasButtons,
+  clickAndWaitEdit,
+} from "./helpers"
+import { Api } from "telegram/tl"
+
+const API_BASE = "http://127.0.0.1:4097"
+
+describe("Phase 6.5 — Production Hardening + Bot Control API", () => {
+  beforeAll(async () => {
+    await setup()
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  // --- /model filtering ---
+
+  test(
+    "/model shows filtered providers (small count, not 86)",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+      const reply = await sendAndWait(client, bot, "/model", 15000)
+      assertHasButtons(reply)
+
+      const markup = reply.replyMarkup as Api.ReplyInlineMarkup
+      const providerCount = markup.rows.length
+      // Should show only connected providers (typically 4-5, never 86)
+      expect(providerCount).toBeGreaterThan(0)
+      expect(providerCount).toBeLessThan(10)
+
+      // Each button should show model count in parentheses
+      const firstText = markup.rows[0].buttons[0].text
+      expect(firstText).toMatch(/\(\d+\)/)
+    },
+    30000,
+  )
+
+  test(
+    "clicking provider shows filtered models (small count per provider)",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      const providerMsg = await sendAndWait(client, bot, "/model", 15000)
+      const markup = providerMsg.replyMarkup as Api.ReplyInlineMarkup
+      const firstButton = markup.rows[0].buttons[0]
+
+      const modelMsg = await clickAndWaitEdit(
+        client,
+        bot,
+        providerMsg.id,
+        firstButton.text,
+      )
+
+      const modelMarkup = modelMsg.replyMarkup as Api.ReplyInlineMarkup
+      // Filtered models: should be small number (e.g. 3-5 per provider, not 22+)
+      // Subtract 1 for Back button
+      const modelCount = modelMarkup.rows.length - 1
+      expect(modelCount).toBeGreaterThan(0)
+      expect(modelCount).toBeLessThan(15)
+    },
+    30000,
+  )
+
+  // --- Bot Control API ---
+
+  test(
+    "GET /api/sessions returns at least 1 session after sending a message",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Ensure we have a session by sending a message
+      await sendAndWait(client, bot, "/new", 30000)
+      await sendAndWait(
+        client,
+        bot,
+        "Respond with exactly the single word: hi",
+        60000,
+      )
+
+      // Now call the Bot Control API
+      const res = await fetch(`${API_BASE}/api/sessions`)
+      expect(res.status).toBe(200)
+      const sessions = await res.json() as any[]
+      expect(sessions.length).toBeGreaterThanOrEqual(1)
+
+      // Each session should have expected fields
+      const session = sessions[0]
+      expect(session.chatId).toBeDefined()
+      expect(session.sessionId).toBeDefined()
+    },
+    120000,
+  )
+
+  test(
+    "POST /api/session/:id/model changes the model override",
+    async () => {
+      // Get a sessionId from the API
+      const sessRes = await fetch(`${API_BASE}/api/sessions`)
+      const sessions = await sessRes.json() as any[]
+      expect(sessions.length).toBeGreaterThan(0)
+      const sessionId = sessions[0].sessionId
+
+      // Get available models to find a valid providerID/modelID
+      const modelsRes = await fetch(`${API_BASE}/api/models`)
+      const providers = await modelsRes.json() as any[]
+      expect(providers.length).toBeGreaterThan(0)
+      const provider = providers[0]
+      expect(provider.models.length).toBeGreaterThan(0)
+      const model = provider.models[0]
+
+      // Set model override
+      const setRes = await fetch(`${API_BASE}/api/session/${sessionId}/model`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ providerID: provider.id, modelID: model.id }),
+      })
+      expect(setRes.status).toBe(200)
+
+      // Verify via GET
+      const getRes = await fetch(`${API_BASE}/api/session/${sessionId}`)
+      const data = await getRes.json() as any
+      expect(data.model).toEqual({ providerID: provider.id, modelID: model.id })
+    },
+    30000,
+  )
+
+  test(
+    "POST /api/session/:id/agent changes the agent override",
+    async () => {
+      const sessRes = await fetch(`${API_BASE}/api/sessions`)
+      const sessions = await sessRes.json() as any[]
+      const sessionId = sessions[0].sessionId
+
+      // Get available agents
+      const agentsRes = await fetch(`${API_BASE}/api/agents`)
+      const agents = await agentsRes.json() as any[]
+      expect(agents.length).toBeGreaterThan(0)
+      const agentName = agents[0].name
+
+      // Set agent override
+      const setRes = await fetch(`${API_BASE}/api/session/${sessionId}/agent`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agent: agentName }),
+      })
+      expect(setRes.status).toBe(200)
+
+      // Verify via GET
+      const getRes = await fetch(`${API_BASE}/api/session/${sessionId}`)
+      const data = await getRes.json() as any
+      expect(data.agent).toBe(agentName)
+    },
+    30000,
+  )
+
+  test(
+    "POST /api/session/:id/new creates a new session",
+    async () => {
+      const sessRes = await fetch(`${API_BASE}/api/sessions`)
+      const sessions = await sessRes.json() as any[]
+      const oldSessionId = sessions[0].sessionId
+
+      // Create new session
+      const newRes = await fetch(`${API_BASE}/api/session/${oldSessionId}/new`, {
+        method: "POST",
+      })
+      expect(newRes.status).toBe(200)
+      const data = await newRes.json() as any
+      expect(data.sessionId).toBeDefined()
+      expect(data.oldSessionId).toBe(oldSessionId)
+      expect(data.sessionId).not.toBe(oldSessionId)
+    },
+    30000,
+  )
+
+  test(
+    "GET /api/models returns providers with filtered models",
+    async () => {
+      const res = await fetch(`${API_BASE}/api/models`)
+      expect(res.status).toBe(200)
+      const providers = await res.json() as any[]
+      expect(providers.length).toBeGreaterThan(0)
+
+      // Each provider should have models
+      for (const p of providers) {
+        expect(p.id).toBeDefined()
+        expect(p.name).toBeDefined()
+        expect(p.models.length).toBeGreaterThan(0)
+        // Each model should have expected fields
+        for (const m of p.models) {
+          expect(m.id).toBeDefined()
+          expect(m.name).toBeDefined()
+        }
+      }
+    },
+    15000,
+  )
+
+  test(
+    "GET /api/agents returns agents",
+    async () => {
+      const res = await fetch(`${API_BASE}/api/agents`)
+      expect(res.status).toBe(200)
+      const agents = await res.json() as any[]
+      expect(agents.length).toBeGreaterThan(0)
+      expect(agents[0].name).toBeDefined()
+    },
+    15000,
+  )
+
+  // --- regression ---
+
+  test(
+    "regression: text message works after API model/agent changes",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      const reply = await sendAndWait(
+        client,
+        bot,
+        "Respond with exactly the single word: pong",
+        60000,
+      )
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+})

package/e2e/phase-6.test.ts

@@ -0,0 +1,302 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { setup, teardown, getClient, getBotUsername } from "./runner"
+import { sendAndWait } from "./helpers"
+import { CustomFile } from "telegram/client/uploads"
+import { deflateSync } from "node:zlib"
+
+/**
+ * Helper: send a file to the bot and wait for a reply.
+ * Uses gramjs client.sendFile() to upload and then polls for bot response.
+ */
+async function sendFileAndWait(
+  client: ReturnType<typeof getClient>,
+  botUsername: string,
+  params: {
+    file: Buffer
+    filename: string
+    caption?: string
+    forceDocument?: boolean
+  },
+  timeoutMs = 60000,
+) {
+  // Get the latest message ID before sending
+  const messagesBefore = await client.getMessages(botUsername, { limit: 1 })
+  const lastIdBefore = messagesBefore[0]?.id ?? 0
+
+  await client.sendFile(botUsername, {
+    file: new CustomFile(params.filename, params.file.length, "", params.file),
+    caption: params.caption,
+    forceDocument: params.forceDocument,
+  })
+
+  // Poll for bot reply
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 1500))
+    const messages = await client.getMessages(botUsername, { limit: 5 })
+    for (const msg of messages) {
+      if (!msg.out && msg.id > lastIdBefore) {
+        return msg
+      }
+    }
+  }
+  throw new Error(`Bot did not reply within ${timeoutMs}ms after sending file`)
+}
+
+describe("Phase 6 — Media & Files", () => {
+  beforeAll(async () => {
+    await setup()
+    // Start fresh session
+    const client = getClient()
+    const bot = getBotUsername()
+    await sendAndWait(client, bot, "/new", 30000)
+  }, 90000)
+
+  afterAll(async () => {
+    await teardown()
+  })
+
+  test(
+    "sending photo gets AI response about the image",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Create a valid 10x10 red PNG using zlib.deflateSync
+      const pngBuffer = createValidPng()
+
+      const reply = await sendFileAndWait(client, bot, {
+        file: pngBuffer,
+        filename: "test-image.png",
+        caption: "What do you see in this image? Respond briefly.",
+      })
+
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+
+  test(
+    "sending document gets AI response",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      // Send a small text file as document
+      const docBuffer = Buffer.from("Hello, this is a test document.\nIt has two lines.")
+
+      const reply = await sendFileAndWait(client, bot, {
+        file: docBuffer,
+        filename: "test-doc.txt",
+        caption: "What does this file contain? Respond briefly.",
+        forceDocument: true,
+      })
+
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+
+  test(
+    "photo with caption includes caption in response context",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+
+      const pngBuffer = createValidPng()
+
+      const reply = await sendFileAndWait(client, bot, {
+        file: pngBuffer,
+        filename: "captioned.png",
+        caption: "Describe the color of this image in one word.",
+      })
+
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+
+  test(
+    "regression: text message still works after media",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+      await sendAndWait(client, bot, "/new", 30000)
+
+      const reply = await sendAndWait(
+        client,
+        bot,
+        "Respond with exactly the single word: pong",
+        60000,
+      )
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+    },
+    120000,
+  )
+
+  test(
+    "regression: no message fragmentation after media then text",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+      await sendAndWait(client, bot, "/new", 30000)
+
+      // 1. Send a photo and wait for response
+      const pngBuffer = createValidPng()
+      const mediaReply = await sendFileAndWait(client, bot, {
+        file: pngBuffer,
+        filename: "test.png",
+        caption: "Describe this briefly in one sentence.",
+      })
+      expect(mediaReply).toBeDefined()
+      const mediaReplyId = mediaReply.id
+
+      // 2. Wait a moment for streaming to fully finish
+      await new Promise((r) => setTimeout(r, 3000))
+
+      // 3. Send text message and wait for response
+      const textReply = await sendAndWait(
+        client,
+        bot,
+        "Respond with exactly the single word: pong",
+        90000,
+      )
+      expect(textReply).toBeDefined()
+      const textReplyId = textReply.id
+
+      // 4. Count bot messages between media reply and text reply
+      // If streaming is fragmented, there will be many messages in between
+      const messages = await client.getMessages(bot, { limit: 20 })
+      const botMessages = messages.filter(
+        (m) => !m.out && m.id > mediaReplyId && m.id <= textReplyId,
+      )
+
+      // Should be exactly 1 message (the text reply).
+      // If fragmented, there would be many intermediate messages.
+      expect(botMessages.length).toBeLessThanOrEqual(2) // Allow 1 for text reply + maybe 1 for tool status
+    },
+    180000,
+  )
+
+  test(
+    "regression: sending text while AI responds to media doesn't fragment",
+    async () => {
+      const client = getClient()
+      const bot = getBotUsername()
+      await sendAndWait(client, bot, "/new", 30000)
+
+      // 1. Send a photo (triggers AI response)
+      const pngBuffer = createValidPng()
+      const messagesBefore = await client.getMessages(bot, { limit: 1 })
+      const lastIdBefore = messagesBefore[0]?.id ?? 0
+
+      await client.sendFile(bot, {
+        file: new CustomFile("interrupt.png", pngBuffer.length, "", pngBuffer),
+        caption: "Write a 3 paragraph essay about colors.",
+      })
+
+      // 2. Wait briefly for streaming to start, then interrupt with text
+      await new Promise((r) => setTimeout(r, 4000))
+
+      const reply = await sendAndWait(
+        client,
+        bot,
+        "Respond with exactly the single word: pong",
+        90000,
+      )
+
+      expect(reply).toBeDefined()
+      const text = reply.text ?? reply.message ?? ""
+      expect(text.length).toBeGreaterThan(0)
+
+      // 3. Count ALL bot messages after our initial send
+      await new Promise((r) => setTimeout(r, 3000))
+      const allMessages = await client.getMessages(bot, { limit: 30 })
+      const botMessagesAfter = allMessages.filter(
+        (m) => !m.out && m.id > lastIdBefore,
+      )
+
+      // Should have at most 3 bot messages:
+      //   1. Draft from photo response (may be edited/finalized)
+      //   2. Possibly aborted/partial photo response
+      //   3. The "pong" text reply
+      // Fragmentation would cause 5+ messages
+      expect(botMessagesAfter.length).toBeLessThanOrEqual(4)
+    },
+    180000,
+  )
+})
+
+/**
+ * Create a valid 10x10 red PNG image using Node's zlib for correct deflate.
+ * Telegram requires properly encoded images — hand-crafted zlib is fragile.
+ */
+function createValidPng(): Buffer {
+  const width = 10
+  const height = 10
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])
+
+  // IHDR: 10x10, 8-bit RGB
+  const ihdrData = Buffer.alloc(13)
+  ihdrData.writeUInt32BE(width, 0)
+  ihdrData.writeUInt32BE(height, 4)
+  ihdrData[8] = 8  // bit depth
+  ihdrData[9] = 2  // color type (RGB)
+  ihdrData[10] = 0 // compression
+  ihdrData[11] = 0 // filter
+  ihdrData[12] = 0 // interlace
+  const ihdr = createPngChunk("IHDR", ihdrData)
+
+  // Raw image data: each row starts with filter byte 0, then RGB pixels
+  const rawRows: Buffer[] = []
+  for (let y = 0; y < height; y++) {
+    const row = Buffer.alloc(1 + width * 3) // filter byte + RGB per pixel
+    row[0] = 0 // filter: None
+    for (let x = 0; x < width; x++) {
+      row[1 + x * 3] = 0xff     // R
+      row[1 + x * 3 + 1] = 0x00 // G
+      row[1 + x * 3 + 2] = 0x00 // B
+    }
+    rawRows.push(row)
+  }
+  const rawImageData = Buffer.concat(rawRows)
+  const compressedData = deflateSync(rawImageData)
+  const idat = createPngChunk("IDAT", compressedData)
+
+  // IEND
+  const iend = createPngChunk("IEND", Buffer.alloc(0))
+
+  return Buffer.concat([signature, ihdr, idat, iend])
+}
+
+function createPngChunk(type: string, data: Buffer): Buffer {
+  const typeBytes = Buffer.from(type, "ascii")
+  const length = Buffer.alloc(4)
+  length.writeUInt32BE(data.length, 0)
+  const combined = Buffer.concat([typeBytes, data])
+
+  const crc = crc32(combined)
+  const crcBuf = Buffer.alloc(4)
+  crcBuf.writeUInt32BE(crc >>> 0, 0)
+
+  return Buffer.concat([length, combined, crcBuf])
+}
+
+function crc32(data: Buffer): number {
+  let crc = ~0
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i]!
+    for (let j = 0; j < 8; j++) {
+      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0)
+    }
+  }
+  return ~crc
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrohnas/opencode-telegram",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -10,8 +10,11 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
+    "@grammyjs/runner": "2.0.3",
+    "@grammyjs/transformer-throttler": "1.2.1",
     "@opencode-ai/sdk": "^1.1.53",
-    "grammy": "^1.35.0"
+    "grammy": "^1.35.0",
+    "hono": "4.11.9"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",