@pedrohnas/opencode-telegram 0.1.0 → 1.2.0

package/src/session-manager.test.ts

@@ -0,0 +1,198 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { SessionManager } from "./session-manager"
+
+// Minimal mock SDK that satisfies what SessionManager needs
+function createMockSdk(sessionId: string) {
+  return {
+    session: {
+      create: mock(async () => ({
+        data: { id: sessionId, title: "", directory: "/tmp" },
+      })),
+    },
+  }
+}
+
+describe("SessionManager", () => {
+  let sm: SessionManager
+
+  beforeEach(() => {
+    sm = new SessionManager({ maxEntries: 3, ttlMs: 1000 })
+  })
+
+  test("getOrCreate creates new session on first access", async () => {
+    const sdk = createMockSdk("s1")
+    const entry = await sm.getOrCreate("chat:1", sdk as any)
+    expect(entry.sessionId).toBe("s1")
+    expect(sdk.session.create).toHaveBeenCalledTimes(1)
+  })
+
+  test("getOrCreate returns cached on second access", async () => {
+    const sdk = createMockSdk("s1")
+    await sm.getOrCreate("chat:1", sdk as any)
+    const entry = await sm.getOrCreate("chat:1", sdk as any)
+    expect(entry.sessionId).toBe("s1")
+    expect(sdk.session.create).toHaveBeenCalledTimes(1) // not called again
+  })
+
+  test("get returns entry by chatKey", async () => {
+    const sdk = createMockSdk("s1")
+    await sm.getOrCreate("chat:1", sdk as any)
+    const entry = sm.get("chat:1")
+    expect(entry).toBeDefined()
+    expect(entry!.sessionId).toBe("s1")
+  })
+
+  test("get returns undefined for unknown chatKey", () => {
+    expect(sm.get("unknown")).toBeUndefined()
+  })
+
+  test("getBySessionId reverse lookup", async () => {
+    const sdk = createMockSdk("s1")
+    await sm.getOrCreate("chat:1", sdk as any)
+    const result = sm.getBySessionId("s1")
+    expect(result).toBeDefined()
+    expect(result!.chatKey).toBe("chat:1")
+    expect(result!.entry.sessionId).toBe("s1")
+  })
+
+  test("getBySessionId returns undefined for unknown session", () => {
+    expect(sm.getBySessionId("unknown")).toBeUndefined()
+  })
+
+  test("remove clears both maps", async () => {
+    const sdk = createMockSdk("s1")
+    await sm.getOrCreate("chat:1", sdk as any)
+    sm.remove("chat:1")
+    expect(sm.get("chat:1")).toBeUndefined()
+    expect(sm.getBySessionId("s1")).toBeUndefined()
+  })
+
+  test("evicts oldest when maxEntries exceeded", async () => {
+    for (let i = 1; i <= 4; i++) {
+      await sm.getOrCreate(`chat:${i}`, createMockSdk(`s${i}`) as any)
+    }
+    // chat:1 should be evicted (oldest, max is 3)
+    expect(sm.get("chat:1")).toBeUndefined()
+    expect(sm.getBySessionId("s1")).toBeUndefined()
+    // chat:4 should exist
+    expect(sm.get("chat:4")).toBeDefined()
+    expect(sm.get("chat:4")!.sessionId).toBe("s4")
+  })
+
+  test("getOrCreate refreshes access order (LRU)", async () => {
+    // Fill to capacity: 1, 2, 3
+    for (let i = 1; i <= 3; i++) {
+      await sm.getOrCreate(`chat:${i}`, createMockSdk(`s${i}`) as any)
+    }
+    // Access chat:1 again (refreshes it)
+    await sm.getOrCreate("chat:1", createMockSdk("s1-new") as any)
+    // Add chat:4 — should evict chat:2 (oldest unreferenced), not chat:1
+    await sm.getOrCreate("chat:4", createMockSdk("s4") as any)
+    expect(sm.get("chat:1")).toBeDefined()
+    expect(sm.get("chat:2")).toBeUndefined() // evicted
+    expect(sm.get("chat:4")).toBeDefined()
+  })
+
+  test("expired entries cleaned up by TTL", async () => {
+    await sm.getOrCreate("chat:1", createMockSdk("s1") as any)
+    // Wait for TTL to expire
+    await new Promise((r) => setTimeout(r, 1100))
+    sm.cleanup()
+    expect(sm.get("chat:1")).toBeUndefined()
+    expect(sm.getBySessionId("s1")).toBeUndefined()
+  })
+
+  test("set allows manual session binding", () => {
+    sm.set("chat:1", { sessionId: "manual-1", directory: "/tmp" })
+    const entry = sm.get("chat:1")
+    expect(entry).toBeDefined()
+    expect(entry!.sessionId).toBe("manual-1")
+    expect(sm.getBySessionId("manual-1")).toBeDefined()
+  })
+
+  test("set overwrites previous binding and cleans reverse map", async () => {
+    await sm.getOrCreate("chat:1", createMockSdk("s1") as any)
+    sm.set("chat:1", { sessionId: "s2", directory: "/tmp" })
+    expect(sm.get("chat:1")!.sessionId).toBe("s2")
+    expect(sm.getBySessionId("s1")).toBeUndefined() // old reverse map cleaned
+    expect(sm.getBySessionId("s2")).toBeDefined()
+  })
+
+  test("size tracks current entry count", async () => {
+    expect(sm.size).toBe(0)
+    await sm.getOrCreate("chat:1", createMockSdk("s1") as any)
+    expect(sm.size).toBe(1)
+    await sm.getOrCreate("chat:2", createMockSdk("s2") as any)
+    expect(sm.size).toBe(2)
+    sm.remove("chat:1")
+    expect(sm.size).toBe(1)
+  })
+
+  // --- Phase 4: restore() ---
+
+  function createRestoreSdk(sessions: Array<{ id: string; title: string; directory?: string; archived?: number }>) {
+    return {
+      session: {
+        create: mock(async () => ({ data: { id: "new", title: "", directory: "/tmp" } })),
+        list: mock(async () => ({
+          data: sessions.map((s) => ({
+            id: s.id,
+            title: s.title,
+            directory: s.directory ?? "/tmp",
+            time: { created: 1000, updated: 2000, archived: s.archived },
+          })),
+        })),
+      },
+    }
+  }
+
+  test("restore populates sessions matching 'Telegram {chatId}' pattern", async () => {
+    const sdk = createRestoreSdk([
+      { id: "s1", title: "Telegram 12345" },
+      { id: "s2", title: "Telegram 67890" },
+    ])
+    const count = await sm.restore(sdk as any)
+    expect(count).toBe(2)
+    expect(sm.get("12345")?.sessionId).toBe("s1")
+    expect(sm.get("67890")?.sessionId).toBe("s2")
+  })
+
+  test("restore ignores archived sessions", async () => {
+    const sdk = createRestoreSdk([
+      { id: "s1", title: "Telegram 12345", archived: 9999 },
+    ])
+    const count = await sm.restore(sdk as any)
+    expect(count).toBe(0)
+    expect(sm.get("12345")).toBeUndefined()
+  })
+
+  test("restore ignores sessions without matching title pattern", async () => {
+    const sdk = createRestoreSdk([
+      { id: "s1", title: "My Custom Session" },
+      { id: "s2", title: "Telegram chat" },
+      { id: "s3", title: "Telegram12345" },
+    ])
+    const count = await sm.restore(sdk as any)
+    expect(count).toBe(0)
+  })
+
+  test("restore returns count of restored sessions", async () => {
+    const sdk = createRestoreSdk([
+      { id: "s1", title: "Telegram 111" },
+      { id: "s2", title: "Not matching" },
+      { id: "s3", title: "Telegram 333" },
+    ])
+    const count = await sm.restore(sdk as any)
+    expect(count).toBe(2)
+  })
+
+  test("restore does not overwrite existing mappings", async () => {
+    sm.set("12345", { sessionId: "existing", directory: "/existing" })
+    const sdk = createRestoreSdk([
+      { id: "s1", title: "Telegram 12345" },
+    ])
+    const count = await sm.restore(sdk as any)
+    expect(count).toBe(0)
+    expect(sm.get("12345")?.sessionId).toBe("existing")
+  })
+})

package/src/session-manager.ts

@@ -105,6 +105,29 @@ export class SessionManager {
     }
   }
 
+  async restore(sdk: OpencodeClient): Promise<number> {
+    const result = await sdk.session.list()
+    const sessions = (result as any).data ?? []
+    let restored = 0
+
+    for (const session of sessions) {
+      if (session.time?.archived) continue
+      const match = session.title?.match(/^Telegram (\d+)$/)
+      if (!match) continue
+
+      const chatKey = match[1]
+      if (!this.get(chatKey)) {
+        this.set(chatKey, {
+          sessionId: session.id,
+          directory: session.directory ?? "",
+        })
+        restored++
+      }
+    }
+
+    return restored
+  }
+
   cleanup(): void {
     const now = Date.now()
     for (const [chatKey, entry] of this.map) {

package/src/turn-manager.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+import { TurnManager } from "./turn-manager"
+
+describe("TurnManager", () => {
+  let tm: TurnManager
+
+  beforeEach(() => {
+    tm = new TurnManager()
+  })
+
+  test("start creates a turn with AbortController", () => {
+    const turn = tm.start("s1", 12345)
+    expect(turn).toBeDefined()
+    expect(turn.sessionId).toBe("s1")
+    expect(turn.chatId).toBe(12345)
+    expect(turn.abortController).toBeDefined()
+    expect(turn.abortController.signal.aborted).toBe(false)
+  })
+
+  test("get returns active turn", () => {
+    tm.start("s1", 12345)
+    const turn = tm.get("s1")
+    expect(turn).toBeDefined()
+    expect(turn!.sessionId).toBe("s1")
+  })
+
+  test("get returns undefined for unknown session", () => {
+    expect(tm.get("unknown")).toBeUndefined()
+  })
+
+  test("end aborts controller and removes entry", () => {
+    const turn = tm.start("s1", 12345)
+    tm.end("s1")
+    expect(turn.abortController.signal.aborted).toBe(true)
+    expect(tm.get("s1")).toBeUndefined()
+  })
+
+  test("end clears all timers", () => {
+    const turn = tm.start("s1", 12345)
+    let timerFired = false
+    const timer = setTimeout(() => {
+      timerFired = true
+    }, 50)
+    tm.addTimer("s1", timer)
+    tm.end("s1")
+    // Wait a bit to confirm timer was cleared
+    return new Promise<void>((resolve) => {
+      setTimeout(() => {
+        expect(timerFired).toBe(false)
+        resolve()
+      }, 100)
+    })
+  })
+
+  test("addTimer tracks timer in turn", () => {
+    tm.start("s1", 12345)
+    const timer = setTimeout(() => {}, 1000)
+    tm.addTimer("s1", timer)
+    // Just verify no throw — internals tracked
+    tm.end("s1") // cleans up
+  })
+
+  test("addTimer is noop for unknown session", () => {
+    const timer = setTimeout(() => {}, 1000)
+    // Should not throw
+    tm.addTimer("unknown", timer)
+    clearTimeout(timer)
+  })
+
+  test("abortAll cleans up all active turns", () => {
+    const t1 = tm.start("s1", 111)
+    const t2 = tm.start("s2", 222)
+    tm.abortAll()
+    expect(t1.abortController.signal.aborted).toBe(true)
+    expect(t2.abortController.signal.aborted).toBe(true)
+    expect(tm.get("s1")).toBeUndefined()
+    expect(tm.get("s2")).toBeUndefined()
+  })
+
+  test("start replaces existing turn for same session", () => {
+    const t1 = tm.start("s1", 12345)
+    const t2 = tm.start("s1", 12345)
+    // Old turn should be aborted
+    expect(t1.abortController.signal.aborted).toBe(true)
+    // New turn is active
+    expect(t2.abortController.signal.aborted).toBe(false)
+    expect(tm.get("s1")).toBe(t2)
+  })
+
+  test("accumulatedText starts empty and can be set", () => {
+    const turn = tm.start("s1", 12345)
+    expect(turn.accumulatedText).toBe("")
+    turn.accumulatedText = "hello world"
+    expect(tm.get("s1")!.accumulatedText).toBe("hello world")
+  })
+
+  test("ended turn has no remaining references in manager", () => {
+    tm.start("s1", 12345)
+    tm.end("s1")
+    expect(tm.get("s1")).toBeUndefined()
+    expect(tm.size).toBe(0)
+  })
+
+  test("size tracks active turn count", () => {
+    expect(tm.size).toBe(0)
+    tm.start("s1", 111)
+    expect(tm.size).toBe(1)
+    tm.start("s2", 222)
+    expect(tm.size).toBe(2)
+    tm.end("s1")
+    expect(tm.size).toBe(1)
+  })
+
+  // --- Phase 3: draft + toolSuffix fields ---
+
+  test("new turn has toolSuffix='' and draft=null", () => {
+    const turn = tm.start("s1", 12345)
+    expect(turn.toolSuffix).toBe("")
+    expect(turn.draft).toBeNull()
+  })
+
+  test("draft can be set on turn and accessed", () => {
+    const turn = tm.start("s1", 12345)
+    const fakeDraft = { stop: mock(() => {}), getMessageId: () => 42, update: mock(async () => {}) }
+    turn.draft = fakeDraft
+    expect(tm.get("s1")!.draft).toBe(fakeDraft)
+  })
+
+  test("end calls draft.stop() if draft exists", () => {
+    const turn = tm.start("s1", 12345)
+    const stopFn = mock(() => {})
+    turn.draft = { stop: stopFn, getMessageId: () => 42, update: async () => {} }
+    tm.end("s1")
+    expect(stopFn).toHaveBeenCalledTimes(1)
+  })
+
+  // --- Phase 4: generation counter ---
+
+  test("first turn gets generation=1", () => {
+    const turn = tm.start("s1", 12345)
+    expect(turn.generation).toBe(1)
+  })
+
+  test("second turn for same session gets incremented generation", () => {
+    const t1 = tm.start("s1", 12345)
+    const t2 = tm.start("s1", 12345)
+    expect(t2.generation).toBe(t1.generation + 1)
+  })
+
+  test("different sessions get unique generation values", () => {
+    const t1 = tm.start("s1", 111)
+    const t2 = tm.start("s2", 222)
+    expect(t1.generation).not.toBe(t2.generation)
+  })
+})

package/src/turn-manager.ts

@@ -17,10 +17,12 @@ export type ActiveTurn = {
   toolSuffix: string
   timers: Set<ReturnType<typeof setTimeout>>
   draft: { stop(): void; getMessageId(): number | null; update(text: string): Promise<void> } | null
+  generation: number
 }
 
 export class TurnManager {
   private active = new Map<string, ActiveTurn>()
+  private generationCounter = 0
 
   start(sessionId: string, chatId: number): ActiveTurn {
     // If there's an existing turn, end it first
@@ -29,6 +31,8 @@ export class TurnManager {
       this.endTurn(existing)
     }
 
+    this.generationCounter++
+
     const turn: ActiveTurn = {
       sessionId,
       chatId,
@@ -37,6 +41,7 @@ export class TurnManager {
       toolSuffix: "",
       timers: new Set(),
       draft: null,
+      generation: this.generationCounter,
     }
 
     this.active.set(sessionId, turn)

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/bun/tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "noUncheckedIndexedAccess": false
+  },
+  "exclude": ["**/*.test.ts", "e2e/**"]
+}