@pedrohnas/opencode-telegram 1.2.1 → 1.3.1

package/src/event-bus.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeEach, mock } from "bun:test"
-import { EventBus, type EventHandler } from "./event-bus"
+import { EventBus, computeDelay, DEFAULT_BACKOFF, type EventHandler } from "./event-bus"
 import { SessionManager } from "./session-manager"
 
 // Helper: create a mock SSE stream from an array of events
@@ -73,6 +73,7 @@ describe("EventBus", () => {
 
     // Wait for stream to be consumed
     await new Promise((r) => setTimeout(r, 50))
+    bus.stop()
 
     expect(received.length).toBe(1)
     expect(received[0].sessionId).toBe("s1")
@@ -91,6 +92,7 @@ describe("EventBus", () => {
     await bus.start()
 
     await new Promise((r) => setTimeout(r, 50))
+    bus.stop()
 
     expect(received.length).toBe(0)
   })
@@ -104,6 +106,7 @@ describe("EventBus", () => {
     await bus.start()
 
     await new Promise((r) => setTimeout(r, 50))
+    bus.stop()
 
     expect(onEvent).toHaveBeenCalledTimes(1)
     const [sid, ck, ev] = onEvent.mock.calls[0]
@@ -130,6 +133,7 @@ describe("EventBus", () => {
     await bus.start()
 
     await new Promise((r) => setTimeout(r, 50))
+    bus.stop()
 
     expect(received).toEqual([
       "chat:1:message.part.updated",
@@ -173,3 +177,335 @@ describe("EventBus", () => {
     expect(received.length).toBe(1)
   })
 })
+
+describe("EventBus reconnect", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 100, ttlMs: 60000 })
+  })
+
+  test("reconnects after stream ends", async () => {
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+
+    const received: string[] = []
+    const handler: EventHandler = (_sid, _ck, event) => {
+      received.push(event.type)
+    }
+
+    let callCount = 0
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          callCount++
+          if (callCount === 1) {
+            return createMockStream([makePartEvent("s1", "first")])
+          }
+          if (callCount === 2) {
+            return createMockStream([makeIdleEvent("s1")])
+          }
+          // Third call: block forever (simulates stable connection)
+          return {
+            stream: (async function* () {
+              await new Promise(() => {}) // never resolves
+            })(),
+          }
+        }),
+      },
+    }
+
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: handler,
+      backoff: { initialDelayMs: 10, maxDelayMs: 100, jitter: 0 },
+      _sleep: async () => {
+        await new Promise((r) => setTimeout(r, 5))
+      },
+    })
+    await bus.start()
+
+    // Wait for reconnect cycle to reach third subscribe
+    await new Promise((r) => setTimeout(r, 200))
+    bus.stop()
+
+    expect(received).toContain("message.part.updated")
+    expect(received).toContain("session.idle")
+    expect(callCount).toBe(3)
+  })
+
+  test("does NOT reconnect after stop() is called", async () => {
+    let subscribeCalls = 0
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          subscribeCalls++
+          return createMockStream([])
+        }),
+      },
+    }
+
+    let sleepCalled = false
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: () => {},
+      backoff: { initialDelayMs: 50, maxDelayMs: 100, jitter: 0 },
+      _sleep: async (ms) => {
+        sleepCalled = true
+        // Stop during sleep — should cancel reconnect
+        bus.stop()
+        await new Promise((r) => setTimeout(r, ms))
+      },
+    })
+    await bus.start()
+
+    // Wait for stream to end, sleep to start, and stop to take effect
+    await new Promise((r) => setTimeout(r, 200))
+
+    expect(sleepCalled).toBe(true)
+    // Only the initial subscribe should have been called (no reconnect after stop)
+    expect(subscribeCalls).toBe(1)
+  })
+
+  test("backoff delay increases on consecutive failures", async () => {
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          throw new Error("connection refused")
+        }),
+      },
+    }
+
+    const sleepCalls: number[] = []
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: () => {},
+      backoff: { initialDelayMs: 100, maxDelayMs: 10000, backoffFactor: 2, jitter: 0 },
+      _sleep: async (ms) => {
+        sleepCalls.push(ms)
+        if (sleepCalls.length >= 4) bus.stop()
+        await new Promise((r) => setTimeout(r, 5))
+      },
+    })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 200))
+
+    // Each delay should be larger than the previous
+    expect(sleepCalls.length).toBeGreaterThanOrEqual(3)
+    for (let i = 1; i < sleepCalls.length; i++) {
+      expect(sleepCalls[i]).toBeGreaterThan(sleepCalls[i - 1])
+    }
+  })
+
+  test("jitter adds randomness to delay", () => {
+    const config = { initialDelayMs: 1000, maxDelayMs: 30000, backoffFactor: 1.8, jitter: 0.25 }
+    const delays = new Set<number>()
+    for (let i = 0; i < 20; i++) {
+      delays.add(Math.round(computeDelay(config, 0)))
+    }
+    // With jitter, we should get multiple different values
+    expect(delays.size).toBeGreaterThan(1)
+  })
+
+  test("max delay is capped at maxDelayMs", () => {
+    const config = { initialDelayMs: 1000, maxDelayMs: 5000, backoffFactor: 10, jitter: 0 }
+    // attempt 5 → base would be 1000 * 10^5 = 100_000_000, but capped at 5000
+    const delay = computeDelay(config, 5)
+    expect(delay).toBe(5000)
+  })
+
+  test("reconnects after subscribe() throws an error", async () => {
+    let callCount = 0
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          callCount++
+          if (callCount === 1) throw new Error("network error")
+          // Block forever on success (simulates stable connection)
+          return {
+            stream: (async function* () {
+              await new Promise(() => {})
+            })(),
+          }
+        }),
+      },
+    }
+
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: () => {},
+      backoff: { initialDelayMs: 10, maxDelayMs: 100, jitter: 0 },
+      _sleep: async () => {
+        await new Promise((r) => setTimeout(r, 5))
+      },
+    })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 200))
+    bus.stop()
+
+    // Should have retried after the error
+    expect(callCount).toBe(2)
+  })
+
+  test("reconnects after stream throws mid-iteration", async () => {
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+
+    const received: string[] = []
+    let callCount = 0
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          callCount++
+          if (callCount === 1) {
+            // Stream that throws after yielding one event
+            async function* brokenStream() {
+              yield makePartEvent("s1", "before-error")
+              throw new Error("stream broke")
+            }
+            return { stream: brokenStream() }
+          }
+          // Yields event then blocks forever
+          async function* stableStream() {
+            yield makeIdleEvent("s1")
+            await new Promise(() => {}) // never resolves
+          }
+          return { stream: stableStream() }
+        }),
+      },
+    }
+
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: (_sid, _ck, ev) => received.push(ev.type),
+      backoff: { initialDelayMs: 10, maxDelayMs: 100, jitter: 0 },
+      _sleep: async () => {
+        await new Promise((r) => setTimeout(r, 5))
+      },
+    })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 200))
+    bus.stop()
+
+    expect(received).toContain("message.part.updated")
+    expect(received).toContain("session.idle")
+    expect(callCount).toBe(2)
+  })
+
+  test("continues processing events after reconnecting", async () => {
+    sm.set("chat:1", { sessionId: "s1", directory: "/tmp" })
+
+    const received: string[] = []
+    let callCount = 0
+    const sdk = {
+      event: {
+        subscribe: mock(async () => {
+          callCount++
+          if (callCount === 1) {
+            return createMockStream([makePartEvent("s1", "stream1")])
+          }
+          if (callCount === 2) {
+            return createMockStream([
+              makePartEvent("s1", "stream2-a"),
+              makeIdleEvent("s1"),
+            ])
+          }
+          // Block forever on third call
+          return {
+            stream: (async function* () {
+              await new Promise(() => {})
+            })(),
+          }
+        }),
+      },
+    }
+
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: (_sid, _ck, ev) => received.push(ev.type),
+      backoff: { initialDelayMs: 10, maxDelayMs: 100, jitter: 0 },
+      _sleep: async () => {
+        await new Promise((r) => setTimeout(r, 5))
+      },
+    })
+    await bus.start()
+
+    await new Promise((r) => setTimeout(r, 200))
+    bus.stop()
+
+    // Events from both streams should be processed
+    expect(received.filter((t) => t === "message.part.updated").length).toBe(2)
+    expect(received).toContain("session.idle")
+  })
+
+  test("stop() during reconnect delay cancels the reconnect", async () => {
+    const sdk = {
+      event: {
+        subscribe: mock(async () => createMockStream([])),
+      },
+    }
+
+    let sleepStarted = false
+    const bus = new EventBus({
+      sdk: sdk as any,
+      sessionManager: sm,
+      onEvent: () => {},
+      backoff: { initialDelayMs: 5000, maxDelayMs: 5000, jitter: 0 },
+      _sleep: async (ms) => {
+        sleepStarted = true
+        await new Promise((r) => setTimeout(r, ms))
+      },
+    })
+    await bus.start()
+
+    // Wait for first stream to end and sleep to begin
+    await new Promise((r) => setTimeout(r, 50))
+    expect(sleepStarted).toBe(true)
+
+    const callsBefore = (sdk.event.subscribe as any).mock.calls.length
+    bus.stop()
+
+    // Wait — should NOT reconnect
+    await new Promise((r) => setTimeout(r, 200))
+    expect((sdk.event.subscribe as any).mock.calls.length).toBe(callsBefore)
+  })
+})
+
+describe("computeDelay", () => {
+  test("returns initialDelayMs for attempt 0 with no jitter", () => {
+    const delay = computeDelay({ ...DEFAULT_BACKOFF, jitter: 0 }, 0)
+    expect(delay).toBe(DEFAULT_BACKOFF.initialDelayMs)
+  })
+
+  test("increases delay with each attempt", () => {
+    const config = { initialDelayMs: 100, maxDelayMs: 10000, backoffFactor: 2, jitter: 0 }
+    expect(computeDelay(config, 0)).toBe(100)
+    expect(computeDelay(config, 1)).toBe(200)
+    expect(computeDelay(config, 2)).toBe(400)
+    expect(computeDelay(config, 3)).toBe(800)
+  })
+
+  test("caps at maxDelayMs", () => {
+    const config = { initialDelayMs: 100, maxDelayMs: 300, backoffFactor: 2, jitter: 0 }
+    expect(computeDelay(config, 0)).toBe(100)
+    expect(computeDelay(config, 1)).toBe(200)
+    expect(computeDelay(config, 2)).toBe(300) // would be 400, capped
+    expect(computeDelay(config, 10)).toBe(300)
+  })
+
+  test("jitter keeps delay within expected range", () => {
+    const config = { initialDelayMs: 1000, maxDelayMs: 30000, backoffFactor: 1, jitter: 0.25 }
+    for (let i = 0; i < 50; i++) {
+      const delay = computeDelay(config, 0)
+      expect(delay).toBeGreaterThanOrEqual(750)  // 1000 - 25%
+      expect(delay).toBeLessThanOrEqual(1250)     // 1000 + 25%
+    }
+  })
+})

package/src/event-bus.ts

@@ -7,7 +7,7 @@
  * Anti-leak design:
  *   - One connection for ALL sessions (not one per session)
  *   - AbortController for clean shutdown
- *   - Auto-reconnect with backoff on stream end
+ *   - Auto-reconnect with exponential backoff on stream end/error
  */
 
 import type { OpencodeClient } from "@opencode-ai/sdk/v2"
@@ -19,35 +19,101 @@ export type EventHandler = (
   event: any,
 ) => void
 
+export type BackoffConfig = {
+  initialDelayMs: number
+  maxDelayMs: number
+  backoffFactor: number
+  jitter: number // 0-1, e.g. 0.25 for ±25%
+}
+
+export const DEFAULT_BACKOFF: BackoffConfig = {
+  initialDelayMs: 2000,
+  maxDelayMs: 30000,
+  backoffFactor: 1.8,
+  jitter: 0.25,
+}
+
 export type EventBusOptions = {
   sdk: OpencodeClient
   sessionManager: SessionManager
   onEvent: EventHandler
+  backoff?: Partial<BackoffConfig>
+  /** Exposed for testing — override to track delay calls */
+  _sleep?: (ms: number) => Promise<void>
 }
 
 export class EventBus {
   private readonly sdk: OpencodeClient
   private readonly sessionManager: SessionManager
   private readonly onEvent: EventHandler
+  private readonly backoff: BackoffConfig
+  private readonly sleep: (ms: number) => Promise<void>
   private stopped = false
+  private sleepReject: ((err: Error) => void) | null = null
 
   constructor(opts: EventBusOptions) {
     this.sdk = opts.sdk
     this.sessionManager = opts.sessionManager
     this.onEvent = opts.onEvent
+    this.backoff = { ...DEFAULT_BACKOFF, ...opts.backoff }
+    this.sleep = opts._sleep ?? defaultSleep
   }
 
   async start(): Promise<void> {
     this.stopped = false
-    this.listen().catch((err) => {
+    this.reconnectLoop().catch((err) => {
       if (!this.stopped) {
-        console.error("EventBus stream error:", err)
+        console.error("EventBus reconnect loop error:", err)
       }
     })
   }
 
   stop(): void {
     this.stopped = true
+    // Break out of sleep if currently waiting
+    if (this.sleepReject) {
+      this.sleepReject(new Error("stopped"))
+      this.sleepReject = null
+    }
+  }
+
+  private async reconnectLoop(): Promise<void> {
+    let attempt = 0
+
+    while (!this.stopped) {
+      try {
+        await this.listen()
+        // Stream ended normally — reset attempt counter on successful connection
+        // (we got at least to the point of iterating)
+      } catch (err) {
+        if (this.stopped) return
+        console.error(`EventBus connection error (attempt ${attempt + 1}):`, err)
+      }
+
+      if (this.stopped) return
+
+      const delay = computeDelay(this.backoff, attempt)
+      console.log(`EventBus reconnecting in ${Math.round(delay)}ms (attempt ${attempt + 1})`)
+
+      try {
+        await this.cancellableSleep(delay)
+      } catch {
+        // Cancelled by stop()
+        return
+      }
+
+      attempt++
+    }
+  }
+
+  private async cancellableSleep(ms: number): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.sleepReject = reject
+      this.sleep(ms).then(() => {
+        this.sleepReject = null
+        resolve()
+      })
+    })
   }
 
   private async listen(): Promise<void> {
@@ -70,6 +136,20 @@ export class EventBus {
   }
 }
 
+export function computeDelay(config: BackoffConfig, attempt: number): number {
+  const base = Math.min(
+    config.maxDelayMs,
+    config.initialDelayMs * Math.pow(config.backoffFactor, attempt),
+  )
+  const jitterRange = base * config.jitter
+  const jitterOffset = (Math.random() * 2 - 1) * jitterRange
+  return Math.max(0, base + jitterOffset)
+}
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
 /**
  * Extract sessionID from various event shapes.
  * Events may have it at:

package/src/handlers/agents.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { SessionManager } from "../session-manager"
+import {
+  parseAgentCallback,
+  formatAgentList,
+  handleAgent,
+  handleAgentSelect,
+} from "./agents"
+
+// --- parseAgentCallback ---
+
+describe("parseAgentCallback", () => {
+  test("parses agent name", () => {
+    expect(parseAgentCallback("agt:code")).toEqual({ name: "code" })
+  })
+
+  test("parses reset action", () => {
+    expect(parseAgentCallback("agt:reset")).toEqual({ action: "reset" })
+  })
+
+  test("returns null for non-agt prefix", () => {
+    expect(parseAgentCallback("invalid")).toBeNull()
+  })
+
+  test("returns null for empty after prefix", () => {
+    expect(parseAgentCallback("agt:")).toBeNull()
+  })
+})
+
+// --- formatAgentList ---
+
+describe("formatAgentList", () => {
+  test("formats 2 agents as rows + reset row", () => {
+    const agents = [
+      { name: "code", description: "Code agent" },
+      { name: "build", description: "Build agent" },
+    ]
+    const result = formatAgentList(agents)
+    // 2 agent rows + 1 reset row
+    expect(result.reply_markup.inline_keyboard.length).toBe(3)
+    expect(result.reply_markup.inline_keyboard[0][0].text).toBe("code")
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("agt:code")
+    const lastRow = result.reply_markup.inline_keyboard[2]
+    expect(lastRow[0].callback_data).toBe("agt:reset")
+  })
+
+  test("filters hidden agents", () => {
+    const agents = [
+      { name: "code", hidden: false },
+      { name: "secret", hidden: true },
+    ]
+    const result = formatAgentList(agents)
+    // 1 agent row + 1 reset row
+    expect(result.reply_markup.inline_keyboard.length).toBe(2)
+    expect(result.reply_markup.inline_keyboard[0][0].text).toBe("code")
+  })
+
+  test("returns 'No agents' when all hidden or empty", () => {
+    const result = formatAgentList([])
+    expect(result.text).toContain("No agents")
+    // Still has reset row
+    expect(result.reply_markup.inline_keyboard.length).toBe(1)
+    expect(result.reply_markup.inline_keyboard[0][0].callback_data).toBe("agt:reset")
+  })
+})
+
+// --- handleAgent ---
+
+describe("handleAgent", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+  })
+
+  test("fetches agents and returns keyboard", async () => {
+    const sdk = {
+      app: {
+        agents: mock(async () => ({
+          data: [
+            { name: "code", description: "Code agent" },
+            { name: "build", description: "Build agent" },
+          ],
+        })),
+      },
+    }
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+    const result = await handleAgent({ sdk: sdk as any, sessionManager: sm, chatKey: "123" })
+    expect(result.reply_markup.inline_keyboard.length).toBeGreaterThan(0)
+    expect(sdk.app.agents).toHaveBeenCalledTimes(1)
+  })
+})
+
+// --- handleAgentSelect ---
+
+describe("handleAgentSelect", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 10, ttlMs: 60000 })
+    sm.set("123", { sessionId: "s1", directory: "/tmp" })
+  })
+
+  test("stores override in sessionManager", async () => {
+    const result = await handleAgentSelect({
+      chatKey: "123",
+      agentName: "code",
+      sessionManager: sm,
+    })
+    expect(sm.get("123")?.agentOverride).toBe("code")
+    expect(result).toContain("code")
+  })
+
+  test("returns error when no active session", async () => {
+    const result = await handleAgentSelect({
+      chatKey: "999",
+      agentName: "code",
+      sessionManager: sm,
+    })
+    expect(result).toContain("No active session")
+  })
+})