@pedrohnas/opencode-telegram 1.2.0 → 1.3.0

package/src/handlers/agents.ts

@@ -0,0 +1,93 @@
+/**
+ * Agent selection handlers — list agents → select → store override.
+ *
+ * Exports:
+ *   - parseAgentCallback(data) — parse "agt:" callback data
+ *   - formatAgentList(agents) — inline keyboard of agents
+ *   - handleAgent(params) — fetch agents, return keyboard
+ *   - handleAgentSelect(params) — store agent override in SessionEntry
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+import type { SessionManager } from "../session-manager"
+
+// --- Pure functions ---
+
+export type AgentCallbackResult =
+  | { name: string }
+  | { action: "reset" }
+
+export function parseAgentCallback(data: string): AgentCallbackResult | null {
+  if (!data.startsWith("agt:")) return null
+  const rest = data.slice(4)
+  if (!rest) return null
+
+  if (rest === "reset") return { action: "reset" }
+  return { name: rest }
+}
+
+export function formatAgentList(agents: any[]): {
+  text: string
+  reply_markup: { inline_keyboard: any[][] }
+} {
+  const visible = agents.filter((a) => !a.hidden)
+  const resetRow = [{ text: "Reset to default", callback_data: "agt:reset" }]
+
+  if (visible.length === 0) {
+    return {
+      text: "No agents available.",
+      reply_markup: { inline_keyboard: [resetRow] },
+    }
+  }
+
+  const rows = visible.map((a) => [
+    { text: a.name, callback_data: `agt:${a.name}` },
+  ])
+
+  rows.push(resetRow)
+
+  return {
+    text: "Select an agent:",
+    reply_markup: { inline_keyboard: rows },
+  }
+}
+
+// --- Async handlers ---
+
+export async function handleAgent(params: {
+  sdk: OpencodeClient
+  sessionManager: SessionManager
+  chatKey: string
+}): Promise<{ text: string; reply_markup: { inline_keyboard: any[][] } }> {
+  const { sdk, sessionManager, chatKey } = params
+  const result = await sdk.app.agents()
+  const agents = (result as any).data ?? []
+  const entry = sessionManager.get(chatKey)
+  const currentText = entry?.agentOverride
+    ? `Current agent: ${entry.agentOverride}`
+    : "Using default agent."
+
+  const list = formatAgentList(agents)
+
+  return {
+    text: `${currentText}\n\n${list.text}`,
+    reply_markup: list.reply_markup,
+  }
+}
+
+export async function handleAgentSelect(params: {
+  chatKey: string
+  agentName: string
+  sessionManager: SessionManager
+}): Promise<string> {
+  const { chatKey, agentName, sessionManager } = params
+  const entry = sessionManager.get(chatKey)
+  if (!entry) return "No active session."
+
+  sessionManager.set(chatKey, {
+    ...entry,
+    agentOverride: agentName,
+  })
+
+  return `Agent set to: ${agentName}`
+}

package/src/handlers/media.test.ts

@@ -0,0 +1,264 @@
+import { describe, test, expect, mock } from "bun:test"
+import {
+  bufferToDataUrl,
+  buildFilePart,
+  buildMediaParts,
+  getMimeFromFileName,
+  extractFileRef,
+  downloadTelegramFile,
+} from "./media"
+
+// --- bufferToDataUrl ---
+
+describe("bufferToDataUrl", () => {
+  test("converts buffer to correct data URL format", () => {
+    const buf = Buffer.from("hello world")
+    const result = bufferToDataUrl(buf, "text/plain")
+    expect(result).toBe(`data:text/plain;base64,${buf.toString("base64")}`)
+  })
+
+  test("handles empty buffer", () => {
+    const buf = Buffer.alloc(0)
+    const result = bufferToDataUrl(buf, "application/octet-stream")
+    expect(result).toBe("data:application/octet-stream;base64,")
+  })
+
+  test("handles different MIME types", () => {
+    const buf = Buffer.from([0xff, 0xd8, 0xff])
+    expect(bufferToDataUrl(buf, "image/jpeg")).toStartWith("data:image/jpeg;base64,")
+    expect(bufferToDataUrl(buf, "application/pdf")).toStartWith("data:application/pdf;base64,")
+    expect(bufferToDataUrl(buf, "audio/ogg")).toStartWith("data:audio/ogg;base64,")
+  })
+})
+
+// --- buildFilePart ---
+
+describe("buildFilePart", () => {
+  test("creates FilePartInput with correct fields", () => {
+    const buf = Buffer.from("test")
+    const result = buildFilePart({ buffer: buf, mime: "image/png", filename: "test.png" })
+    expect(result.type).toBe("file")
+    expect(result.mime).toBe("image/png")
+    expect(result.filename).toBe("test.png")
+    expect(result.url).toContain("data:image/png;base64,")
+  })
+
+  test("URL is a valid data URL", () => {
+    const buf = Buffer.from("data")
+    const result = buildFilePart({ buffer: buf, mime: "text/plain", filename: "f.txt" })
+    expect(result.url).toMatch(/^data:[^;]+;base64,.+$/)
+  })
+})
+
+// --- buildMediaParts ---
+
+describe("buildMediaParts", () => {
+  test("without caption returns [FilePartInput] only", () => {
+    const parts = buildMediaParts({
+      buffer: Buffer.from("img"),
+      mime: "image/jpeg",
+      filename: "photo.jpg",
+    })
+    expect(parts).toHaveLength(1)
+    expect(parts[0]!.type).toBe("file")
+  })
+
+  test("with caption returns [TextPartInput, FilePartInput]", () => {
+    const parts = buildMediaParts({
+      buffer: Buffer.from("img"),
+      mime: "image/jpeg",
+      filename: "photo.jpg",
+      caption: "What is this?",
+    })
+    expect(parts).toHaveLength(2)
+    expect(parts[0]!.type).toBe("text")
+    expect((parts[0] as any).text).toBe("What is this?")
+    expect(parts[1]!.type).toBe("file")
+  })
+
+  test("empty caption treated as no caption", () => {
+    const parts = buildMediaParts({
+      buffer: Buffer.from("img"),
+      mime: "image/jpeg",
+      filename: "photo.jpg",
+      caption: "",
+    })
+    expect(parts).toHaveLength(1)
+    expect(parts[0]!.type).toBe("file")
+  })
+})
+
+// --- getMimeFromFileName ---
+
+describe("getMimeFromFileName", () => {
+  test(".jpg → image/jpeg", () => {
+    expect(getMimeFromFileName("photo.jpg")).toBe("image/jpeg")
+  })
+
+  test(".pdf → application/pdf", () => {
+    expect(getMimeFromFileName("doc.pdf")).toBe("application/pdf")
+  })
+
+  test(".py → text/x-python", () => {
+    expect(getMimeFromFileName("script.py")).toBe("text/x-python")
+  })
+
+  test("unknown extension → application/octet-stream", () => {
+    expect(getMimeFromFileName("data.xyz123")).toBe("application/octet-stream")
+  })
+})
+
+// --- extractFileRef ---
+
+describe("extractFileRef", () => {
+  test("photo message picks last (highest res) photo", () => {
+    const msg = {
+      photo: [
+        { file_id: "small", file_unique_id: "s", width: 100, height: 100 },
+        { file_id: "medium", file_unique_id: "m", width: 320, height: 320 },
+        { file_id: "large", file_unique_id: "l", width: 1280, height: 1280 },
+      ],
+    }
+    const ref = extractFileRef(msg as any)
+    expect(ref).not.toBeNull()
+    expect(ref!.fileId).toBe("large")
+    expect(ref!.mime).toBe("image/jpeg")
+  })
+
+  test("document message returns file_id + file_name + mime_type", () => {
+    const msg = {
+      document: {
+        file_id: "doc123",
+        file_unique_id: "d",
+        file_name: "report.pdf",
+        mime_type: "application/pdf",
+      },
+    }
+    const ref = extractFileRef(msg as any)
+    expect(ref).not.toBeNull()
+    expect(ref!.fileId).toBe("doc123")
+    expect(ref!.filename).toBe("report.pdf")
+    expect(ref!.mime).toBe("application/pdf")
+  })
+
+  test("voice message returns file_id with audio/ogg mime", () => {
+    const msg = {
+      voice: { file_id: "voice1", file_unique_id: "v", duration: 5 },
+    }
+    const ref = extractFileRef(msg as any)
+    expect(ref).not.toBeNull()
+    expect(ref!.fileId).toBe("voice1")
+    expect(ref!.mime).toBe("audio/ogg")
+  })
+
+  test("audio message returns file_id + mime_type", () => {
+    const msg = {
+      audio: {
+        file_id: "audio1",
+        file_unique_id: "a",
+        duration: 120,
+        mime_type: "audio/mpeg",
+      },
+    }
+    const ref = extractFileRef(msg as any)
+    expect(ref).not.toBeNull()
+    expect(ref!.fileId).toBe("audio1")
+    expect(ref!.mime).toBe("audio/mpeg")
+  })
+
+  test("video message returns file_id with video/mp4 mime", () => {
+    const msg = {
+      video: {
+        file_id: "vid1",
+        file_unique_id: "v",
+        width: 1920,
+        height: 1080,
+        duration: 30,
+      },
+    }
+    const ref = extractFileRef(msg as any)
+    expect(ref).not.toBeNull()
+    expect(ref!.fileId).toBe("vid1")
+    expect(ref!.mime).toBe("video/mp4")
+  })
+
+  test("message with no media returns null", () => {
+    const msg = { text: "hello" }
+    const ref = extractFileRef(msg as any)
+    expect(ref).toBeNull()
+  })
+})
+
+// --- downloadTelegramFile ---
+
+describe("downloadTelegramFile", () => {
+  test("downloads and returns buffer + mime + filename", async () => {
+    const mockGetFile = mock(async () => ({
+      file_path: "photos/photo.jpg",
+      file_size: 1024,
+    }))
+
+    const fileContent = Buffer.from("fake image data")
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = mock(async () => ({
+      ok: true,
+      headers: new Headers({ "content-type": "image/jpeg" }),
+      arrayBuffer: async () => fileContent.buffer.slice(
+        fileContent.byteOffset,
+        fileContent.byteOffset + fileContent.byteLength,
+      ),
+    })) as any
+
+    try {
+      const result = await downloadTelegramFile({
+        fileId: "abc123",
+        token: "BOT_TOKEN",
+        getFile: mockGetFile,
+        filename: "photo.jpg",
+        mime: "image/jpeg",
+      })
+
+      expect(result).not.toBeNull()
+      expect(result!.mime).toBe("image/jpeg")
+      expect(result!.filename).toBe("photo.jpg")
+      expect(result!.buffer.length).toBeGreaterThan(0)
+      expect(mockGetFile).toHaveBeenCalledWith("abc123")
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
+  test("returns null when file_path is missing", async () => {
+    const mockGetFile = mock(async () => ({
+      file_path: undefined,
+      file_size: 0,
+    }))
+
+    const result = await downloadTelegramFile({
+      fileId: "abc123",
+      token: "BOT_TOKEN",
+      getFile: mockGetFile,
+      filename: "photo.jpg",
+      mime: "image/jpeg",
+    })
+
+    expect(result).toBeNull()
+  })
+
+  test("returns null when file_size > 20MB", async () => {
+    const mockGetFile = mock(async () => ({
+      file_path: "photos/big.jpg",
+      file_size: 25 * 1024 * 1024, // 25MB
+    }))
+
+    const result = await downloadTelegramFile({
+      fileId: "abc123",
+      token: "BOT_TOKEN",
+      getFile: mockGetFile,
+      filename: "big.jpg",
+      mime: "image/jpeg",
+    })
+
+    expect(result).toBeNull()
+  })
+})

package/src/handlers/media.ts

@@ -0,0 +1,168 @@
+/**
+ * Media file handling: download from Telegram, convert to data URLs,
+ * and build SDK-compatible part arrays.
+ */
+
+const MAX_FILE_SIZE = 20 * 1024 * 1024 // 20MB — Telegram Bot API limit
+
+const MIME_MAP: Record<string, string> = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".mp3": "audio/mpeg",
+  ".ogg": "audio/ogg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".csv": "text/csv",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".ts": "text/typescript",
+  ".py": "text/x-python",
+  ".rs": "text/x-rust",
+  ".go": "text/x-go",
+  ".java": "text/x-java",
+  ".c": "text/x-c",
+  ".cpp": "text/x-c++",
+  ".h": "text/x-c",
+  ".rb": "text/x-ruby",
+  ".sh": "text/x-shellscript",
+  ".yaml": "text/yaml",
+  ".yml": "text/yaml",
+  ".toml": "text/toml",
+}
+
+export function bufferToDataUrl(buffer: Buffer, mime: string): string {
+  return `data:${mime};base64,${buffer.toString("base64")}`
+}
+
+export function buildFilePart(params: {
+  buffer: Buffer
+  mime: string
+  filename: string
+}): { type: "file"; mime: string; url: string; filename: string } {
+  return {
+    type: "file",
+    mime: params.mime,
+    url: bufferToDataUrl(params.buffer, params.mime),
+    filename: params.filename,
+  }
+}
+
+export function buildMediaParts(params: {
+  buffer: Buffer
+  mime: string
+  filename: string
+  caption?: string
+}): Array<{ type: "text"; text: string } | { type: "file"; mime: string; url: string; filename: string }> {
+  const filePart = buildFilePart(params)
+  if (params.caption && params.caption.trim()) {
+    return [{ type: "text", text: params.caption }, filePart]
+  }
+  return [filePart]
+}
+
+export function getMimeFromFileName(filename: string): string {
+  const dot = filename.lastIndexOf(".")
+  if (dot === -1) return "application/octet-stream"
+  const ext = filename.slice(dot).toLowerCase()
+  return MIME_MAP[ext] ?? "application/octet-stream"
+}
+
+type TelegramMessage = {
+  photo?: Array<{ file_id: string; [k: string]: unknown }>
+  document?: {
+    file_id: string
+    file_name?: string
+    mime_type?: string
+    [k: string]: unknown
+  }
+  voice?: { file_id: string; [k: string]: unknown }
+  audio?: {
+    file_id: string
+    mime_type?: string
+    file_name?: string
+    [k: string]: unknown
+  }
+  video?: {
+    file_id: string
+    mime_type?: string
+    [k: string]: unknown
+  }
+  [k: string]: unknown
+}
+
+export function extractFileRef(
+  msg: TelegramMessage,
+): { fileId: string; filename?: string; mime?: string } | null {
+  if (msg.photo && msg.photo.length > 0) {
+    const largest = msg.photo[msg.photo.length - 1]!
+    return { fileId: largest.file_id, mime: "image/jpeg" }
+  }
+
+  if (msg.document) {
+    return {
+      fileId: msg.document.file_id,
+      filename: msg.document.file_name,
+      mime: msg.document.mime_type,
+    }
+  }
+
+  if (msg.voice) {
+    return { fileId: msg.voice.file_id, mime: "audio/ogg" }
+  }
+
+  if (msg.audio) {
+    return {
+      fileId: msg.audio.file_id,
+      filename: msg.audio.file_name,
+      mime: msg.audio.mime_type ?? "audio/mpeg",
+    }
+  }
+
+  if (msg.video) {
+    return {
+      fileId: msg.video.file_id,
+      mime: msg.video.mime_type ?? "video/mp4",
+    }
+  }
+
+  return null
+}
+
+export async function downloadTelegramFile(params: {
+  fileId: string
+  token: string
+  getFile: (fileId: string) => Promise<{ file_path?: string; file_size?: number }>
+  filename?: string
+  mime?: string
+}): Promise<{ buffer: Buffer; mime: string; filename: string } | null> {
+  const file = await params.getFile(params.fileId)
+
+  if (!file.file_path) return null
+  if (file.file_size && file.file_size > MAX_FILE_SIZE) return null
+
+  const url = `https://api.telegram.org/file/bot${params.token}/${file.file_path}`
+  const res = await fetch(url)
+  const buffer = Buffer.from(await res.arrayBuffer())
+
+  const mime =
+    params.mime ??
+    res.headers.get("content-type") ??
+    "application/octet-stream"
+
+  const filename =
+    params.filename ?? file.file_path.split("/").pop() ?? "file"
+
+  return { buffer, mime, filename }
+}