opencode-telegram-mirror 0.3.0

package/test/mock-server.ts

@@ -0,0 +1,271 @@
+#!/usr/bin/env bun
+/**
+ * Mock server for testing the Telegram mirror bot.
+ * 
+ * Serves two endpoints:
+ * 1. /updates - Mock updates endpoint (replaces Cloudflare DO)
+ * 2. /* - Mock Telegram Bot API (captures all sends)
+ * 
+ * Usage:
+ *   bun run test/mock-server.ts [fixture-file]
+ * 
+ * Environment:
+ *   MOCK_PORT - Port to listen on (default: 3456)
+ */
+
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+
+interface TelegramUpdate {
+  update_id: number
+  chat_id?: string
+  payload: {
+    update_id: number
+    message?: {
+      message_id: number
+      chat: { id: number }
+      text?: string
+      date?: number
+      from?: { id: number; username?: string }
+      message_thread_id?: number
+    }
+    callback_query?: {
+      id: string
+      data?: string
+      message?: { chat: { id: number }; message_id: number }
+    }
+  }
+  received_at?: number
+}
+
+interface CapturedRequest {
+  timestamp: number
+  method: string
+  path: string
+  body: unknown
+}
+
+const PORT = Number(process.env.MOCK_PORT) || 3456
+const fixtureFile = process.argv[2] || "test/fixtures/sample-updates.json"
+
+let updates: TelegramUpdate[] = []
+let updateIndex = 0
+let lastServedUpdateId = 0
+const capturedRequests: CapturedRequest[] = []
+let messageIdCounter = 1000
+
+async function loadFixtures() {
+  try {
+    const content = await readFile(fixtureFile, "utf-8")
+    updates = JSON.parse(content) as TelegramUpdate[]
+    updates.sort((a, b) => a.update_id - b.update_id)
+    console.log(`[mock] Loaded ${updates.length} updates from ${fixtureFile}`)
+  } catch (error) {
+    console.error(`[mock] Failed to load fixtures: ${error}`)
+    updates = []
+  }
+}
+
+function getNextUpdates(since: number, limit = 10): TelegramUpdate[] {
+  const filtered = updates.filter(u => u.update_id > since)
+  const batch = filtered.slice(0, limit)
+  
+  if (batch.length > 0) {
+    lastServedUpdateId = batch[batch.length - 1].update_id
+    console.log(`[mock] Serving ${batch.length} updates (since=${since}, max=${lastServedUpdateId})`)
+  }
+  
+  return batch
+}
+
+function handleUpdatesEndpoint(url: URL): Response {
+  const since = Number(url.searchParams.get("since") || "0")
+  const chatId = url.searchParams.get("chat_id")
+  
+  let batch = getNextUpdates(since)
+  
+  if (chatId) {
+    batch = batch.filter(u => u.chat_id === chatId || String(u.payload.message?.chat?.id) === chatId)
+  }
+  
+  return Response.json({
+    updates: batch.map(u => ({ payload: u.payload })),
+  })
+}
+
+function handleTelegramApi(path: string, body: unknown): Response {
+  const method = path.split("/").pop() || ""
+  
+  capturedRequests.push({
+    timestamp: Date.now(),
+    method,
+    path,
+    body,
+  })
+  
+  console.log(`[mock] Captured Telegram API: ${method}`, JSON.stringify(body).slice(0, 200))
+  
+  switch (method) {
+    case "getMe":
+      return Response.json({
+        ok: true,
+        result: {
+          id: 123456789,
+          is_bot: true,
+          first_name: "TestBot",
+          username: "test_bot",
+        },
+      })
+    
+    case "sendMessage":
+      return Response.json({
+        ok: true,
+        result: {
+          message_id: ++messageIdCounter,
+          chat: { id: (body as { chat_id?: string })?.chat_id || "-1" },
+          date: Math.floor(Date.now() / 1000),
+          text: (body as { text?: string })?.text || "",
+        },
+      })
+    
+    case "editMessageText":
+      return Response.json({ ok: true, result: true })
+    
+    case "editForumTopic":
+      return Response.json({ ok: true, result: true })
+    
+    case "answerCallbackQuery":
+      return Response.json({ ok: true, result: true })
+    
+    case "sendChatAction":
+      return Response.json({ ok: true, result: true })
+    
+    case "setMyCommands":
+      console.log("[mock] Commands registered:", JSON.stringify((body as { commands?: unknown[] })?.commands))
+      return Response.json({ ok: true, result: true })
+    
+    case "getFile":
+      return Response.json({
+        ok: true,
+        result: {
+          file_id: "test_file",
+          file_path: "photos/test.jpg",
+        },
+      })
+    
+    default:
+      console.log(`[mock] Unknown Telegram method: ${method}`)
+      return Response.json({ ok: true, result: {} })
+  }
+}
+
+function handleControlEndpoint(url: URL): Response {
+  const action = url.searchParams.get("action")
+  
+  switch (action) {
+    case "captured":
+      return Response.json({ requests: capturedRequests })
+    
+    case "clear":
+      capturedRequests.length = 0
+      return Response.json({ ok: true })
+    
+    case "reset":
+      updateIndex = 0
+      lastServedUpdateId = 0
+      capturedRequests.length = 0
+      return Response.json({ ok: true })
+    
+    case "inject":
+      return new Response("Use POST to inject updates", { status: 400 })
+    
+    case "status":
+      return Response.json({
+        totalUpdates: updates.length,
+        lastServedUpdateId,
+        capturedRequests: capturedRequests.length,
+      })
+    
+    default:
+      return Response.json({
+        endpoints: {
+          "/updates?since=N": "Get updates (mock DO endpoint)",
+          "/_control?action=captured": "Get captured Telegram API requests",
+          "/_control?action=clear": "Clear captured requests",
+          "/_control?action=reset": "Reset update pointer and captured requests",
+          "/_control?action=status": "Get server status",
+          "POST /_control?action=inject": "Inject a new update",
+          "/sendMessage, /editMessageText, etc": "Mock Telegram Bot API",
+        },
+      })
+  }
+}
+
+async function handleControlPost(url: URL, body: unknown): Promise<Response> {
+  const action = url.searchParams.get("action")
+  
+  if (action === "inject") {
+    const update = body as TelegramUpdate
+    if (!update.update_id || !update.payload) {
+      return Response.json({ error: "Invalid update format" }, { status: 400 })
+    }
+    updates.push(update)
+    updates.sort((a, b) => a.update_id - b.update_id)
+    console.log(`[mock] Injected update ${update.update_id}`)
+    return Response.json({ ok: true, totalUpdates: updates.length })
+  }
+  
+  return Response.json({ error: "Unknown action" }, { status: 400 })
+}
+
+const server = Bun.serve({
+  port: PORT,
+  async fetch(req) {
+    const url = new URL(req.url)
+    const path = url.pathname
+    
+    if (path === "/updates") {
+      return handleUpdatesEndpoint(url)
+    }
+    
+    if (path === "/_control") {
+      if (req.method === "POST") {
+        const body = await req.json()
+        return handleControlPost(url, body)
+      }
+      return handleControlEndpoint(url)
+    }
+    
+    if (req.method === "POST") {
+      try {
+        const body = await req.json()
+        return handleTelegramApi(path, body)
+      } catch {
+        return handleTelegramApi(path, {})
+      }
+    }
+    
+    if (req.method === "GET" && path.includes("/getMe")) {
+      return handleTelegramApi(path, {})
+    }
+    
+    if (req.method === "GET" && path.includes("/getFile")) {
+      return handleTelegramApi(path, {})
+    }
+    
+    return new Response("Not found", { status: 404 })
+  },
+})
+
+loadFixtures().then(() => {
+  console.log(`[mock] Mock server running at http://localhost:${PORT}`)
+  console.log(`[mock] Updates endpoint: http://localhost:${PORT}/updates`)
+  console.log(`[mock] Control endpoint: http://localhost:${PORT}/_control`)
+  console.log(`[mock] Telegram API base: http://localhost:${PORT}`)
+  console.log("")
+  console.log("[mock] Environment variables for the bot:")
+  console.log(`  TELEGRAM_UPDATES_URL=http://localhost:${PORT}/updates`)
+  console.log(`  TELEGRAM_SEND_URL=http://localhost:${PORT}`)
+  console.log("  TELEGRAM_BOT_TOKEN=test:token")
+  console.log("  TELEGRAM_CHAT_ID=-1003546563617")
+})

package/test/run-test.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env bun
+/**
+ * Test runner that starts the mock server and the bot together.
+ * 
+ * Usage:
+ *   bun run test/run-test.ts [fixture-file] [timeout-seconds]
+ */
+
+import { spawn, type Subprocess } from "bun"
+import { setTimeout } from "node:timers/promises"
+import { unlink } from "node:fs/promises"
+
+const MOCK_PORT = 3456
+const fixtureFile = process.argv[2] || "test/fixtures/sample-updates.json"
+const timeoutSeconds = Number(process.argv[3]) || 30
+
+let mockServer: Subprocess | null = null
+let botProcess: Subprocess | null = null
+
+async function waitForServer(url: string, maxAttempts = 20): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(url)
+      if (response.ok) return true
+    } catch {
+      await setTimeout(250)
+    }
+  }
+  return false
+}
+
+async function startMockServer(): Promise<Subprocess> {
+  console.log("[test] Starting mock server...")
+  
+  const proc = spawn({
+    cmd: ["bun", "run", "test/mock-server.ts", fixtureFile],
+    env: {
+      ...process.env,
+      MOCK_PORT: String(MOCK_PORT),
+    },
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  
+  const ready = await waitForServer(`http://localhost:${MOCK_PORT}/_control`)
+  if (!ready) {
+    throw new Error("Mock server failed to start")
+  }
+  
+  console.log("[test] Mock server ready")
+  return proc
+}
+
+async function startBot(): Promise<Subprocess> {
+  console.log("[test] Starting bot...")
+  
+  // Use a startup timestamp before fixture dates to ensure updates pass the filter
+  // Fixtures use dates around 1768590000 (Jan 2026)
+  const startupTimestamp = "1768589000"
+  const testDbPath = "/tmp/telegram-opencode-test.db"
+  
+  const proc = spawn({
+    cmd: ["bun", "run", "src/main.ts", "."],
+    env: {
+      ...process.env,
+      TELEGRAM_UPDATES_URL: `http://localhost:${MOCK_PORT}/updates`,
+      TELEGRAM_SEND_URL: `http://localhost:${MOCK_PORT}`,
+      TELEGRAM_BOT_TOKEN: "test:token",
+      TELEGRAM_CHAT_ID: "-1003546563617",
+      TELEGRAM_DB_PATH: testDbPath,
+      OPENCODE_URL: process.env.OPENCODE_URL || "",
+      STARTUP_TIMESTAMP: startupTimestamp,
+    },
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  
+  console.log("[test] Bot started")
+  return proc
+}
+
+async function getCapturedRequests(): Promise<unknown[]> {
+  const response = await fetch(`http://localhost:${MOCK_PORT}/_control?action=captured`)
+  const data = await response.json() as { requests: unknown[] }
+  return data.requests
+}
+
+async function getServerStatus(): Promise<unknown> {
+  const response = await fetch(`http://localhost:${MOCK_PORT}/_control?action=status`)
+  return response.json()
+}
+
+function cleanup() {
+  console.log("\n[test] Cleaning up...")
+  
+  if (botProcess) {
+    botProcess.kill()
+    botProcess = null
+  }
+  
+  if (mockServer) {
+    mockServer.kill()
+    mockServer = null
+  }
+}
+
+process.on("SIGINT", () => {
+  cleanup()
+  process.exit(0)
+})
+
+process.on("SIGTERM", () => {
+  cleanup()
+  process.exit(0)
+})
+
+async function main() {
+  console.log("[test] === Test Runner Starting ===")
+  console.log(`[test] Fixture: ${fixtureFile}`)
+  console.log(`[test] Timeout: ${timeoutSeconds}s`)
+  console.log("")
+  
+  try {
+    await unlink("/tmp/telegram-opencode-test.db").catch(() => {})
+    mockServer = await startMockServer()
+    
+    await setTimeout(500)
+    
+    botProcess = await startBot()
+    
+    console.log(`[test] Running for ${timeoutSeconds} seconds...`)
+    console.log("[test] Press Ctrl+C to stop early")
+    console.log("")
+    
+    await setTimeout(timeoutSeconds * 1000)
+    
+    console.log("\n[test] === Test Complete ===")
+    
+    const status = await getServerStatus()
+    console.log("[test] Server status:", JSON.stringify(status, null, 2))
+    
+    const captured = await getCapturedRequests()
+    console.log(`[test] Captured ${captured.length} Telegram API requests`)
+    
+    if (captured.length > 0) {
+      console.log("[test] Sample requests:")
+      for (const req of captured.slice(0, 5)) {
+        console.log("  -", JSON.stringify(req).slice(0, 150))
+      }
+    }
+    
+  } catch (error) {
+    console.error("[test] Error:", error)
+    process.exitCode = 1
+  } finally {
+    cleanup()
+  }
+}
+
+main()

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": [
+      "bun-types"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "opensrc"
+  ]
+}