@pedrohnas/opencode-telegram 0.1.0 → 1.2.0

package/src/event-bus.test.ts

@@ -0,0 +1,175 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { EventBus, type EventHandler } from "./event-bus"
+import { SessionManager } from "./session-manager"
+
+// Helper: create a mock SSE stream from an array of events
+function createMockStream(events: any[]) {
+  async function* generate() {
+    for (const event of events) {
+      yield event
+    }
+  }
+  return { stream: generate() }
+}
+
+// Helper: create a mock SDK with controllable event stream
+function createMockSdk(events: any[]) {
+  return {
+    event: {
+      subscribe: mock(async () => createMockStream(events)),
+    },
+  }
+}
+
+// Extract sessionId from event (same logic as EventBus)
+function makePartEvent(sessionId: string, text: string) {
+  return {
+    type: "message.part.updated",
+    properties: {
+      part: {
+        id: "p1",
+        sessionID: sessionId,
+        messageID: "m1",
+        type: "text",
+        text,
+      },
+    },
+  }
+}
+
+function makeIdleEvent(sessionId: string) {
+  return {
+    type: "session.idle",
+    properties: { sessionID: sessionId },
+  }
+}
+
+function makeErrorEvent(sessionId: string) {
+  return {
+    type: "session.error",
+    properties: { sessionID: sessionId, error: "test error" },
+  }
+}
+
+describe("EventBus", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 100, ttlMs: 60000 })
+  })
+
+  test("routes event to correct chatKey via SessionManager", async () => {
+    // Setup: map chat:1 → session s1
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+
+    const received: any[] = []
+    const handler: EventHandler = (sessionId, chatKey, event) => {
+      received.push({ sessionId, chatKey, type: event.type })
+    }
+
+    const sdk = createMockSdk([makePartEvent("s1", "hello")])
+    const bus = new EventBus({ sdk: sdk as any, sessionManager: sm, onEvent: handler })
+    await bus.start()
+
+    // Wait for stream to be consumed
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(received.length).toBe(1)
+    expect(received[0].sessionId).toBe("s1")
+    expect(received[0].chatKey).toBe("chat:1")
+    expect(received[0].type).toBe("message.part.updated")
+  })
+
+  test("ignores events for unknown sessionIds", async () => {
+    const received: any[] = []
+    const handler: EventHandler = (sessionId, chatKey, event) => {
+      received.push({ sessionId, chatKey })
+    }
+
+    const sdk = createMockSdk([makePartEvent("unknown-session", "hello")])
+    const bus = new EventBus({ sdk: sdk as any, sessionManager: sm, onEvent: handler })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(received.length).toBe(0)
+  })
+
+  test("calls onEvent with sessionId, chatKey, and event", async () => {
+    sm.set("chat:42", { sessionId: "s42", directory: "/tmp" })
+
+    const onEvent = mock((_sid: string, _ck: string, _ev: any) => {})
+    const sdk = createMockSdk([makeIdleEvent("s42")])
+    const bus = new EventBus({ sdk: sdk as any, sessionManager: sm, onEvent })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(onEvent).toHaveBeenCalledTimes(1)
+    const [sid, ck, ev] = onEvent.mock.calls[0]
+    expect(sid).toBe("s42")
+    expect(ck).toBe("chat:42")
+    expect(ev.type).toBe("session.idle")
+  })
+
+  test("handles multiple events for different sessions", async () => {
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+    sm.set("chat:2", { sessionId: "s2", directory: "/tmp" })
+
+    const received: string[] = []
+    const handler: EventHandler = (sessionId, chatKey, event) => {
+      received.push(`${chatKey}:${event.type}`)
+    }
+
+    const sdk = createMockSdk([
+      makePartEvent("s1", "hello"),
+      makeIdleEvent("s2"),
+      makeErrorEvent("s1"),
+    ])
+    const bus = new EventBus({ sdk: sdk as any, sessionManager: sm, onEvent: handler })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 50))
+
+    expect(received).toEqual([
+      "chat:1:message.part.updated",
+      "chat:2:session.idle",
+      "chat:1:session.error",
+    ])
+  })
+
+  test("stop() prevents processing of further events", async () => {
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+
+    const received: any[] = []
+    const handler: EventHandler = (sid, ck, ev) => {
+      received.push(ev.type)
+    }
+
+    // Create a stream that yields events slowly
+    async function* slowStream() {
+      yield makePartEvent("s1", "first")
+      await new Promise((r) => setTimeout(r, 100))
+      yield makePartEvent("s1", "second")
+    }
+
+    const sdk = {
+      event: {
+        subscribe: mock(async () => ({ stream: slowStream() })),
+      },
+    }
+
+    const bus = new EventBus({ sdk: sdk as any, sessionManager: sm, onEvent: handler })
+    await bus.start()
+
+    // Let first event process
+    await new Promise((r) => setTimeout(r, 50))
+    bus.stop()
+
+    // Wait for slow stream
+    await new Promise((r) => setTimeout(r, 200))
+
+    // Should have only the first event
+    expect(received.length).toBe(1)
+  })
+})

package/src/handlers/allowlist.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, mock } from "bun:test"
+import { createAllowlistMiddleware } from "./allowlist"
+
+describe("createAllowlistMiddleware", () => {
+  const createCtx = (userId?: number) => ({
+    from: userId !== undefined ? { id: userId } : undefined,
+  })
+
+  test("empty allowedUsers list blocks all (safe default)", async () => {
+    const mw = createAllowlistMiddleware([])
+    const next = mock(() => Promise.resolve())
+    await mw(createCtx(999) as any, next)
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  test("allowAll=true allows everyone", async () => {
+    const mw = createAllowlistMiddleware([], true)
+    const next = mock(() => Promise.resolve())
+    await mw(createCtx(999) as any, next)
+    expect(next).toHaveBeenCalledTimes(1)
+  })
+
+  test("user ID in list calls next", async () => {
+    const mw = createAllowlistMiddleware([111, 222])
+    const next = mock(() => Promise.resolve())
+    await mw(createCtx(111) as any, next)
+    expect(next).toHaveBeenCalledTimes(1)
+  })
+
+  test("user ID NOT in list does not call next", async () => {
+    const mw = createAllowlistMiddleware([111, 222])
+    const next = mock(() => Promise.resolve())
+    await mw(createCtx(999) as any, next)
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  test("no from on context does not call next", async () => {
+    const mw = createAllowlistMiddleware([111])
+    const next = mock(() => Promise.resolve())
+    await mw({ from: undefined } as any, next)
+    expect(next).not.toHaveBeenCalled()
+  })
+
+  test("multiple users in list all allowed", async () => {
+    const mw = createAllowlistMiddleware([111, 222, 333])
+    for (const id of [111, 222, 333]) {
+      const next = mock(() => Promise.resolve())
+      await mw(createCtx(id) as any, next)
+      expect(next).toHaveBeenCalledTimes(1)
+    }
+  })
+
+  test("callback queries also filtered by from.id", async () => {
+    const mw = createAllowlistMiddleware([111])
+    const next = mock(() => Promise.resolve())
+    // Callback query context still has from
+    await mw({ from: { id: 999 }, callbackQuery: { data: "test" } } as any, next)
+    expect(next).not.toHaveBeenCalled()
+  })
+})

package/src/handlers/allowlist.ts

@@ -0,0 +1,33 @@
+/**
+ * Allowlist middleware — restricts bot access to specific Telegram user IDs.
+ *
+ * Safe default: empty list blocks everyone. The bot owner must explicitly
+ * configure TELEGRAM_ALLOWED_USERS with their Telegram ID(s).
+ *
+ * - allowAll=true (TELEGRAM_ALLOWED_USERS="*") → allow everyone (explicit opt-in)
+ * - allowedUsers=[123,456] → only those IDs
+ * - allowedUsers=[] + allowAll=false → block everyone (safe default)
+ */
+
+import type { MiddlewareFn, Context } from "grammy"
+
+export function createAllowlistMiddleware(
+  allowedUsers: number[],
+  allowAll = false,
+): MiddlewareFn<Context> {
+  if (allowAll) {
+    return (_ctx, next) => next()
+  }
+
+  if (allowedUsers.length === 0) {
+    return () => {} // block everyone — no users configured
+  }
+
+  const allowed = new Set(allowedUsers)
+
+  return (ctx, next) => {
+    const userId = ctx.from?.id
+    if (!userId || !allowed.has(userId)) return
+    return next()
+  }
+}

package/src/handlers/cancel.test.ts

@@ -0,0 +1,105 @@
+import { describe, test, expect, mock } from "bun:test"
+import { handleCancel } from "./cancel"
+import { SessionManager } from "../session-manager"
+import { TurnManager } from "../turn-manager"
+
+function createMockSdk() {
+  return {
+    session: {
+      abort: mock(async () => ({ data: true })),
+      create: mock(async () => ({ data: { id: "s1", directory: "/tmp" } })),
+    },
+  } as any
+}
+
+describe("handleCancel", () => {
+  test("returns 'No active session.' if no session found", async () => {
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = createMockSdk()
+
+    const result = await handleCancel({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    expect(result).toBe("No active session.")
+    expect(sdk.session.abort).not.toHaveBeenCalled()
+  })
+
+  test("returns 'Nothing running.' if no active turn", async () => {
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = createMockSdk()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+
+    const result = await handleCancel({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    expect(result).toBe("Nothing running.")
+    expect(sdk.session.abort).not.toHaveBeenCalled()
+  })
+
+  test("calls sdk.session.abort with sessionID", async () => {
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = createMockSdk()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    tm.start("s1", 123)
+
+    await handleCancel({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    expect(sdk.session.abort).toHaveBeenCalledTimes(1)
+    expect(sdk.session.abort).toHaveBeenCalledWith({ sessionID: "s1" })
+  })
+
+  test("calls turnManager.end after abort", async () => {
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = createMockSdk()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    tm.start("s1", 123)
+
+    await handleCancel({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    // Turn should be cleaned up
+    expect(tm.get("s1")).toBeUndefined()
+  })
+
+  test("returns 'Generation cancelled.' on success", async () => {
+    const sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    const tm = new TurnManager()
+    const sdk = createMockSdk()
+
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    tm.start("s1", 123)
+
+    const result = await handleCancel({
+      chatId: 123,
+      sdk,
+      sessionManager: sm,
+      turnManager: tm,
+    })
+
+    expect(result).toBe("Generation cancelled.")
+  })
+})

package/src/handlers/permissions.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, expect } from "bun:test"
+import {
+  formatPermissionMessage,
+  parsePermissionCallback,
+} from "./permissions"
+
+const samplePermission = {
+  id: "per_abc123def456ghi789jk",
+  sessionID: "ses_xyz",
+  permission: "bash",
+  patterns: ["rm -rf /tmp/test"],
+  metadata: {},
+  always: ["bash:*"],
+}
+
+describe("formatPermissionMessage", () => {
+  test("text contains permission name", () => {
+    const { text } = formatPermissionMessage(samplePermission)
+    expect(text).toContain("bash")
+  })
+
+  test("text contains patterns", () => {
+    const { text } = formatPermissionMessage(samplePermission)
+    expect(text).toContain("rm -rf /tmp/test")
+  })
+
+  test("returns keyboard with 3 buttons", () => {
+    const { reply_markup } = formatPermissionMessage(samplePermission)
+    const buttons = reply_markup.inline_keyboard[0]
+    expect(buttons).toHaveLength(3)
+    expect(buttons[0].text).toContain("Allow")
+    expect(buttons[1].text).toContain("Always")
+    expect(buttons[2].text).toContain("Deny")
+  })
+
+  test("callback data follows perm:{action}:{requestID} pattern", () => {
+    const { reply_markup } = formatPermissionMessage(samplePermission)
+    const buttons = reply_markup.inline_keyboard[0]
+    expect(buttons[0].callback_data).toBe(
+      `perm:once:${samplePermission.id}`,
+    )
+    expect(buttons[1].callback_data).toBe(
+      `perm:always:${samplePermission.id}`,
+    )
+    expect(buttons[2].callback_data).toBe(
+      `perm:deny:${samplePermission.id}`,
+    )
+  })
+})
+
+describe("parsePermissionCallback", () => {
+  test("parses perm:once correctly", () => {
+    const result = parsePermissionCallback("perm:once:per_abc123")
+    expect(result).toEqual({ requestID: "per_abc123", reply: "once" })
+  })
+
+  test("parses perm:always correctly", () => {
+    const result = parsePermissionCallback("perm:always:per_abc123")
+    expect(result).toEqual({ requestID: "per_abc123", reply: "always" })
+  })
+
+  test("parses perm:deny as reject", () => {
+    const result = parsePermissionCallback("perm:deny:per_abc123")
+    expect(result).toEqual({ requestID: "per_abc123", reply: "reject" })
+  })
+
+  test("returns null for invalid data", () => {
+    expect(parsePermissionCallback("invalid:data")).toBeNull()
+    expect(parsePermissionCallback("q:req1:0")).toBeNull()
+    expect(parsePermissionCallback("perm:unknown:req1")).toBeNull()
+  })
+})

package/src/handlers/questions.test.ts

@@ -0,0 +1,107 @@
+import { describe, test, expect } from "bun:test"
+import {
+  formatQuestionMessage,
+  parseQuestionCallback,
+  resolveQuestionAnswer,
+} from "./questions"
+
+const sampleQuestion = {
+  id: "que_abc123def456ghi789jk",
+  sessionID: "ses_xyz",
+  questions: [
+    {
+      question: "Which approach should we use?",
+      header: "Approach",
+      options: [
+        { label: "Option A", description: "First approach" },
+        { label: "Option B", description: "Second approach" },
+        { label: "Option C", description: "Third approach" },
+      ],
+    },
+  ],
+}
+
+describe("formatQuestionMessage", () => {
+  test("returns question text in message", () => {
+    const { text } = formatQuestionMessage(sampleQuestion)
+    expect(text).toContain("Which approach should we use?")
+  })
+
+  test("renders options as 1-per-row buttons", () => {
+    const { reply_markup } = formatQuestionMessage(sampleQuestion)
+    const keyboard = reply_markup.inline_keyboard
+    // 3 option rows + 1 skip row
+    expect(keyboard.length).toBe(4)
+    expect(keyboard[0][0].text).toBe("Option A")
+    expect(keyboard[1][0].text).toBe("Option B")
+    expect(keyboard[2][0].text).toBe("Option C")
+  })
+
+  test("adds Skip button as last row", () => {
+    const { reply_markup } = formatQuestionMessage(sampleQuestion)
+    const keyboard = reply_markup.inline_keyboard
+    const lastRow = keyboard[keyboard.length - 1]
+    expect(lastRow[0].text).toContain("Skip")
+    expect(lastRow[0].callback_data).toBe(
+      `q:${sampleQuestion.id}:skip`,
+    )
+  })
+
+  test("callback data uses q:{requestID}:{index} format", () => {
+    const { reply_markup } = formatQuestionMessage(sampleQuestion)
+    const keyboard = reply_markup.inline_keyboard
+    expect(keyboard[0][0].callback_data).toBe(
+      `q:${sampleQuestion.id}:0`,
+    )
+    expect(keyboard[1][0].callback_data).toBe(
+      `q:${sampleQuestion.id}:1`,
+    )
+    expect(keyboard[2][0].callback_data).toBe(
+      `q:${sampleQuestion.id}:2`,
+    )
+  })
+})
+
+describe("parseQuestionCallback", () => {
+  test("parses selection correctly", () => {
+    const result = parseQuestionCallback("q:que_abc:0")
+    expect(result).toEqual({
+      requestID: "que_abc",
+      action: "select",
+      optionIndex: 0,
+    })
+  })
+
+  test("parses skip correctly", () => {
+    const result = parseQuestionCallback("q:que_abc:skip")
+    expect(result).toEqual({ requestID: "que_abc", action: "skip" })
+  })
+
+  test("returns null for invalid data", () => {
+    expect(parseQuestionCallback("invalid")).toBeNull()
+    expect(parseQuestionCallback("perm:once:req1")).toBeNull()
+    expect(parseQuestionCallback("q:")).toBeNull()
+  })
+})
+
+describe("resolveQuestionAnswer", () => {
+  test("maps index to option label from stored questions", () => {
+    const pending = {
+      type: "question" as const,
+      createdAt: Date.now(),
+      questions: [
+        {
+          options: [
+            { label: "Option A" },
+            { label: "Option B" },
+            { label: "Option C" },
+          ],
+        },
+      ],
+    }
+
+    expect(resolveQuestionAnswer(0, pending)).toEqual(["Option A"])
+    expect(resolveQuestionAnswer(1, pending)).toEqual(["Option B"])
+    expect(resolveQuestionAnswer(2, pending)).toEqual(["Option C"])
+  })
+})