@pedrohnas/opencode-telegram 0.1.0 → 1.2.0

package/src/handlers/typing.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, mock } from "bun:test"
+import { startTypingLoop } from "./typing"
+
+describe("startTypingLoop", () => {
+  test("calls sendAction immediately on start", () => {
+    const sendAction = mock(async () => {})
+    const ac = new AbortController()
+
+    startTypingLoop(123, sendAction, ac.signal)
+    expect(sendAction).toHaveBeenCalledTimes(1)
+    expect(sendAction).toHaveBeenCalledWith(123, "typing")
+
+    ac.abort()
+  })
+
+  test("calls sendAction again after ~4 seconds", async () => {
+    const sendAction = mock(async () => {})
+    const ac = new AbortController()
+
+    startTypingLoop(123, sendAction, ac.signal)
+    expect(sendAction).toHaveBeenCalledTimes(1)
+
+    // Wait a bit over 4 seconds for the next tick
+    await new Promise((r) => setTimeout(r, 4200))
+
+    expect(sendAction.mock.calls.length).toBeGreaterThanOrEqual(2)
+    ac.abort()
+  })
+
+  test("stops calling when signal is aborted", async () => {
+    const sendAction = mock(async () => {})
+    const ac = new AbortController()
+
+    startTypingLoop(123, sendAction, ac.signal)
+    expect(sendAction).toHaveBeenCalledTimes(1)
+
+    ac.abort()
+
+    // Wait long enough for another tick to fire (if it weren't aborted)
+    await new Promise((r) => setTimeout(r, 4500))
+
+    // Should still be 1 (no more calls after abort)
+    expect(sendAction).toHaveBeenCalledTimes(1)
+  }, 10000)
+
+  test("does not throw if sendAction rejects", async () => {
+    const sendAction = mock(async () => {
+      throw new Error("network error")
+    })
+    const ac = new AbortController()
+
+    // Should not throw
+    startTypingLoop(123, sendAction, ac.signal)
+    expect(sendAction).toHaveBeenCalledTimes(1)
+
+    // Wait for next tick to confirm no unhandled rejection
+    await new Promise((r) => setTimeout(r, 4500))
+    ac.abort()
+  })
+})

package/src/index.ts

@@ -52,6 +52,14 @@ const pendingRequests = new PendingRequests({
   ttlMs: 10 * 60 * 1000, // 10 minutes
 })
 
+// --- Restore sessions from previous bot runs ---
+try {
+  const restored = await sessionManager.restore(sdk)
+  if (restored > 0) console.log(`Restored ${restored} sessions`)
+} catch (err) {
+  console.error("Session restore failed:", err)
+}
+
 // --- Create bot with deps ---
 const bot = createBot(config, { sdk, sessionManager, turnManager, pendingRequests })
 
@@ -249,6 +257,24 @@ const shutdown = async () => {
 process.on("SIGINT", shutdown)
 process.on("SIGTERM", shutdown)
 
+// --- Register Telegram command menu ---
+try {
+  await bot.api.setMyCommands([
+    { command: "start", description: "Welcome message" },
+    { command: "new", description: "New session" },
+    { command: "cancel", description: "Stop generation" },
+    { command: "list", description: "List sessions" },
+    { command: "rename", description: "Rename session" },
+    { command: "delete", description: "Delete session" },
+    { command: "info", description: "Session info" },
+    { command: "history", description: "Recent messages" },
+    { command: "summarize", description: "Summarize session" },
+  ])
+  console.log("Command menu registered")
+} catch (err) {
+  console.error("Failed to register commands:", err)
+}
+
 // --- Start polling ---
 await bot.start({
   onStart: () => console.log("Bot started"),

package/src/pending-requests.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { PendingRequests, type PendingEntry } from "./pending-requests"
+
+describe("PendingRequests", () => {
+  let pr: PendingRequests
+
+  beforeEach(() => {
+    pr = new PendingRequests({ maxEntries: 5, ttlMs: 1000 })
+  })
+
+  test("set() stores and get() retrieves", () => {
+    const entry: PendingEntry = { type: "permission", createdAt: Date.now() }
+    pr.set("req1", entry)
+    expect(pr.get("req1")).toEqual(entry)
+  })
+
+  test("get() returns undefined for unknown requestID", () => {
+    expect(pr.get("unknown")).toBeUndefined()
+  })
+
+  test("delete() removes entry and returns true", () => {
+    pr.set("req1", { type: "permission", createdAt: Date.now() })
+    expect(pr.delete("req1")).toBe(true)
+    expect(pr.get("req1")).toBeUndefined()
+  })
+
+  test("delete() returns false for unknown requestID", () => {
+    expect(pr.delete("unknown")).toBe(false)
+  })
+
+  test("evicts oldest when maxEntries exceeded", () => {
+    for (let i = 1; i <= 6; i++) {
+      pr.set(`req${i}`, { type: "permission", createdAt: Date.now() })
+    }
+    // req1 was evicted (oldest)
+    expect(pr.get("req1")).toBeUndefined()
+    // req6 still exists
+    expect(pr.get("req6")).toBeDefined()
+    expect(pr.size).toBe(5)
+  })
+
+  test("get() returns undefined for expired entries", async () => {
+    pr.set("req1", { type: "permission", createdAt: Date.now() })
+    expect(pr.get("req1")).toBeDefined()
+
+    // Wait for TTL to expire
+    await new Promise((r) => setTimeout(r, 1100))
+    expect(pr.get("req1")).toBeUndefined()
+  })
+
+  test("cleanup() removes all expired entries", async () => {
+    pr.set("req1", { type: "permission", createdAt: Date.now() })
+    pr.set("req2", { type: "question", createdAt: Date.now() })
+
+    await new Promise((r) => setTimeout(r, 1100))
+
+    // Add a fresh one
+    pr.set("req3", { type: "permission", createdAt: Date.now() })
+
+    pr.cleanup()
+    expect(pr.size).toBe(1)
+    expect(pr.get("req3")).toBeDefined()
+  })
+})

package/src/send/chunker.test.ts

@@ -0,0 +1,74 @@
+import { describe, test, expect } from "bun:test"
+import { chunkMessage } from "./chunker"
+
+describe("chunkMessage", () => {
+  test("returns empty array for empty string", () => {
+    expect(chunkMessage("")).toEqual([])
+  })
+
+  test("returns single chunk for short message", () => {
+    const chunks = chunkMessage("hello world")
+    expect(chunks).toEqual(["hello world"])
+  })
+
+  test("returns single chunk at exactly the limit", () => {
+    const text = "a".repeat(4096)
+    const chunks = chunkMessage(text)
+    expect(chunks).toHaveLength(1)
+    expect(chunks[0]).toBe(text)
+  })
+
+  test("splits long message into multiple chunks", () => {
+    const text = "a".repeat(8192)
+    const chunks = chunkMessage(text)
+    expect(chunks.length).toBeGreaterThanOrEqual(2)
+    expect(chunks.join("")).toBe(text)
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(4096)
+    }
+  })
+
+  test("splits at newline boundary when possible", () => {
+    // Create text where a newline appears near the split point
+    const line = "x".repeat(100) + "\n"
+    const text = line.repeat(50) // 50 * 101 = 5050 chars
+    const chunks = chunkMessage(text)
+    expect(chunks.length).toBeGreaterThanOrEqual(2)
+    // Each chunk should end at a newline (except possibly the last)
+    for (let i = 0; i < chunks.length - 1; i++) {
+      expect(chunks[i].endsWith("\n")).toBe(true)
+    }
+  })
+
+  test("never splits inside an HTML tag", () => {
+    // Create text with an HTML tag right at the split boundary
+    const before = "a".repeat(4090)
+    const tag = '<b>bold</b>'
+    const after = "b".repeat(100)
+    const text = before + tag + after
+    const chunks = chunkMessage(text)
+    // The tag should be entirely in one chunk
+    const fullText = chunks.join("")
+    expect(fullText).toBe(text)
+    for (const chunk of chunks) {
+      // No chunk should contain a partial tag (< without matching >)
+      const opens = (chunk.match(/</g) || []).length
+      const closes = (chunk.match(/>/g) || []).length
+      expect(opens).toBe(closes)
+    }
+  })
+
+  test("handles custom limit", () => {
+    const text = "a".repeat(200)
+    const chunks = chunkMessage(text, 100)
+    expect(chunks).toHaveLength(2)
+    expect(chunks[0].length).toBe(100)
+    expect(chunks[1].length).toBe(100)
+  })
+
+  test("preserves all content when chunking", () => {
+    const text = "Hello <b>bold</b> and <code>code</code> text ".repeat(200)
+    const chunks = chunkMessage(text)
+    expect(chunks.join("")).toBe(text)
+  })
+})

package/src/send/draft-stream.test.ts

@@ -0,0 +1,229 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { DraftStream, type DraftStreamDeps } from "./draft-stream"
+
+function createMockDeps(): DraftStreamDeps & {
+  sendMessage: ReturnType<typeof mock>
+  editMessageText: ReturnType<typeof mock>
+} {
+  return {
+    sendMessage: mock(async (_chatId: number, _text: string, _opts?: any) => ({
+      message_id: 42,
+    })),
+    editMessageText: mock(async (_chatId: number, _msgId: number, _text: string, _opts?: any) => {}),
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms))
+}
+
+describe("DraftStream", () => {
+  let deps: ReturnType<typeof createMockDeps>
+  let ac: AbortController
+
+  beforeEach(() => {
+    deps = createMockDeps()
+    ac = new AbortController()
+  })
+
+  // --- Initial send ---
+
+  test("first update sends a new message via sendMessage", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    await ds.update("hello")
+    expect(deps.sendMessage).toHaveBeenCalledTimes(1)
+    ac.abort()
+  })
+
+  test("first update stores messageId from sendMessage response", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    expect(ds.getMessageId()).toBeNull()
+    await ds.update("hello")
+    expect(ds.getMessageId()).toBe(42)
+    ac.abort()
+  })
+
+  test("first update truncates text to 4096 chars", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    const longText = "x".repeat(5000)
+    await ds.update(longText)
+    // The text sent should be truncated
+    const sentText = deps.sendMessage.mock.calls[0][1] as string
+    expect(sentText.length).toBeLessThanOrEqual(4096)
+    ac.abort()
+  })
+
+  test("first update sends with HTML parse_mode", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    await ds.update("hello **bold**")
+    const opts = deps.sendMessage.mock.calls[0][2]
+    expect(opts?.parse_mode).toBe("HTML")
+    ac.abort()
+  })
+
+  // --- Throttled edits ---
+
+  test("second update schedules an edit (not immediate)", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal, 100)
+    await ds.update("hello")
+    await ds.update("hello world")
+    // Edit not called yet (still in throttle window)
+    expect(deps.editMessageText).toHaveBeenCalledTimes(0)
+    ac.abort()
+  })
+
+  test("after throttle delay, editMessageText is called", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("hello world")
+    await sleep(100)
+    expect(deps.editMessageText).toHaveBeenCalledTimes(1)
+    ac.abort()
+  })
+
+  test("multiple rapid updates only result in one edit (latest text wins)", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("v1")
+    await ds.update("v2")
+    await ds.update("v3")
+    await ds.update("v4")
+    await sleep(100)
+    expect(deps.editMessageText).toHaveBeenCalledTimes(1)
+    // The edit should contain the latest text (v4), converted to HTML
+    const editedText = deps.editMessageText.mock.calls[0][2] as string
+    expect(editedText).toContain("v4")
+    ac.abort()
+  })
+
+  test("edit uses HTML parse_mode", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("updated")
+    await sleep(100)
+    const opts = deps.editMessageText.mock.calls[0][3]
+    expect(opts?.parse_mode).toBe("HTML")
+    ac.abort()
+  })
+
+  // --- Error handling ---
+
+  test("message is not modified error is silently ignored", async () => {
+    deps.editMessageText = mock(async () => {
+      throw new Error("Bad Request: message is not modified")
+    })
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("hello") // same text but triggers edit
+    // Force different pending to trigger edit
+    await ds.update("different")
+    await sleep(100)
+    // Should not throw, stream still active
+    expect(ds.isStopped()).toBe(false)
+    ac.abort()
+  })
+
+  test("can't parse entities falls back to plain text edit", async () => {
+    let callCount = 0
+    deps.editMessageText = mock(async (_cid: number, _mid: number, _text: string, opts?: any) => {
+      callCount++
+      if (callCount === 1 && opts?.parse_mode === "HTML") {
+        throw new Error("Bad Request: can't parse entities")
+      }
+    })
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("**broken html")
+    await sleep(100)
+    // Should have retried without parse_mode
+    expect(deps.editMessageText.mock.calls.length).toBeGreaterThanOrEqual(2)
+    expect(ds.hasHtmlFailed()).toBe(true)
+    ac.abort()
+  })
+
+  test("after HTML failure, subsequent edits use plain text", async () => {
+    let callCount = 0
+    deps.editMessageText = mock(async (_cid: number, _mid: number, _text: string, opts?: any) => {
+      callCount++
+      if (callCount === 1 && opts?.parse_mode === "HTML") {
+        throw new Error("Bad Request: can't parse entities")
+      }
+    })
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("update1")
+    await sleep(100)
+    expect(ds.hasHtmlFailed()).toBe(true)
+
+    // Next edit should not use HTML
+    await ds.update("update2")
+    await sleep(100)
+    const lastCall = deps.editMessageText.mock.calls[deps.editMessageText.mock.calls.length - 1]
+    const lastOpts = lastCall[3]
+    expect(lastOpts?.parse_mode).toBeUndefined()
+    ac.abort()
+  })
+
+  test("message to edit not found stops the stream", async () => {
+    deps.editMessageText = mock(async () => {
+      throw new Error("Bad Request: message to edit not found")
+    })
+    const ds = new DraftStream(deps, 123, ac.signal, 50)
+    await ds.update("hello")
+    await ds.update("updated")
+    await sleep(100)
+    expect(ds.isStopped()).toBe(true)
+    ac.abort()
+  })
+
+  test("sendMessage failure on first update keeps messageId null", async () => {
+    deps.sendMessage = mock(async () => {
+      throw new Error("network error")
+    })
+    const ds = new DraftStream(deps, 123, ac.signal)
+    await ds.update("hello")
+    expect(ds.getMessageId()).toBeNull()
+    ac.abort()
+  })
+
+  // --- stop() ---
+
+  test("stop clears pending timer", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal, 200)
+    await ds.update("hello")
+    await ds.update("updated")
+    ds.stop()
+    await sleep(250)
+    // Edit should not have fired
+    expect(deps.editMessageText).toHaveBeenCalledTimes(0)
+  })
+
+  test("after stop, update is a no-op", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    ds.stop()
+    await ds.update("hello")
+    expect(deps.sendMessage).toHaveBeenCalledTimes(0)
+  })
+
+  test("stop sets isStopped to true", () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    expect(ds.isStopped()).toBe(false)
+    ds.stop()
+    expect(ds.isStopped()).toBe(true)
+  })
+
+  // --- AbortSignal ---
+
+  test("aborting signal calls stop automatically", async () => {
+    const ds = new DraftStream(deps, 123, ac.signal)
+    await ds.update("hello")
+    expect(ds.isStopped()).toBe(false)
+    ac.abort()
+    expect(ds.isStopped()).toBe(true)
+  })
+
+  test("already-aborted signal stops immediately on construction", () => {
+    ac.abort()
+    const ds = new DraftStream(deps, 123, ac.signal)
+    expect(ds.isStopped()).toBe(true)
+  })
+})

package/src/send/format.test.ts

@@ -0,0 +1,143 @@
+import { describe, test, expect } from "bun:test"
+import { markdownToTelegramHtml } from "./format"
+
+describe("markdownToTelegramHtml", () => {
+  // --- HTML escaping (must happen FIRST, before any tag insertion) ---
+
+  test("escapes & < > in plain text", () => {
+    expect(markdownToTelegramHtml("A & B < C > D")).toBe(
+      "A &amp; B &lt; C &gt; D",
+    )
+  })
+
+  test("does not double-escape already-escaped HTML", () => {
+    // Input is markdown, not HTML — so "&amp;" in markdown is literal text
+    // and should be escaped to "&amp;amp;"
+    expect(markdownToTelegramHtml("&amp;")).toBe("&amp;amp;")
+  })
+
+  // --- Bold ---
+
+  test("converts **bold** to <b>", () => {
+    expect(markdownToTelegramHtml("**bold**")).toBe("<b>bold</b>")
+  })
+
+  test("converts __bold__ to <b>", () => {
+    expect(markdownToTelegramHtml("__bold__")).toBe("<b>bold</b>")
+  })
+
+  // --- Italic ---
+
+  test("converts *italic* to <i>", () => {
+    expect(markdownToTelegramHtml("*italic*")).toBe("<i>italic</i>")
+  })
+
+  test("converts _italic_ to <i>", () => {
+    expect(markdownToTelegramHtml("_italic_")).toBe("<i>italic</i>")
+  })
+
+  // --- Strikethrough ---
+
+  test("converts ~~strike~~ to <s>", () => {
+    expect(markdownToTelegramHtml("~~strike~~")).toBe("<s>strike</s>")
+  })
+
+  // --- Inline code ---
+
+  test("converts `code` to <code>", () => {
+    expect(markdownToTelegramHtml("`code`")).toBe("<code>code</code>")
+  })
+
+  test("escapes HTML inside inline code", () => {
+    expect(markdownToTelegramHtml("`<div>&</div>`")).toBe(
+      "<code>&lt;div&gt;&amp;&lt;/div&gt;</code>",
+    )
+  })
+
+  // --- Code blocks ---
+
+  test("converts fenced code block without language", () => {
+    expect(markdownToTelegramHtml("```\ncode\n```")).toBe(
+      "<pre><code>code</code></pre>",
+    )
+  })
+
+  test("converts fenced code block with language", () => {
+    expect(markdownToTelegramHtml("```ts\nconst x = 1\n```")).toBe(
+      '<pre><code class="language-ts">const x = 1</code></pre>',
+    )
+  })
+
+  test("escapes HTML inside code blocks", () => {
+    expect(markdownToTelegramHtml("```\n<div>&</div>\n```")).toBe(
+      "<pre><code>&lt;div&gt;&amp;&lt;/div&gt;</code></pre>",
+    )
+  })
+
+  test("preserves newlines inside code blocks", () => {
+    expect(markdownToTelegramHtml("```\nline1\nline2\n```")).toBe(
+      "<pre><code>line1\nline2</code></pre>",
+    )
+  })
+
+  // --- Links ---
+
+  test("converts [text](url) to <a>", () => {
+    expect(markdownToTelegramHtml("[click](https://example.com)")).toBe(
+      '<a href="https://example.com">click</a>',
+    )
+  })
+
+  test("escapes HTML in link text", () => {
+    expect(markdownToTelegramHtml("[A & B](https://example.com)")).toBe(
+      '<a href="https://example.com">A &amp; B</a>',
+    )
+  })
+
+  // --- Nested formatting ---
+
+  test("handles bold + italic nested", () => {
+    const result = markdownToTelegramHtml("**bold *italic***")
+    expect(result).toContain("<b>")
+    expect(result).toContain("<i>")
+    expect(result).toContain("</b>")
+  })
+
+  // --- Edge cases ---
+
+  test("returns empty string for empty input", () => {
+    expect(markdownToTelegramHtml("")).toBe("")
+  })
+
+  test("passes through plain text unchanged (after escaping)", () => {
+    expect(markdownToTelegramHtml("hello world")).toBe("hello world")
+  })
+
+  test("handles multiple paragraphs", () => {
+    const result = markdownToTelegramHtml("paragraph 1\n\nparagraph 2")
+    expect(result).toContain("paragraph 1")
+    expect(result).toContain("paragraph 2")
+  })
+
+  // --- Headings (convert to bold since Telegram has no heading tags) ---
+
+  test("converts headings to bold text", () => {
+    const result = markdownToTelegramHtml("# Heading")
+    expect(result).toContain("<b>Heading</b>")
+  })
+
+  // --- Lists ---
+
+  test("preserves bullet list formatting", () => {
+    const result = markdownToTelegramHtml("- item 1\n- item 2")
+    expect(result).toContain("item 1")
+    expect(result).toContain("item 2")
+  })
+
+  // --- Blockquotes ---
+
+  test("converts blockquotes", () => {
+    const result = markdownToTelegramHtml("> quoted text")
+    expect(result).toContain("quoted text")
+  })
+})

package/src/send/tool-progress.test.ts

@@ -0,0 +1,70 @@
+import { describe, test, expect } from "bun:test"
+import { formatToolStatus } from "./tool-progress"
+
+describe("formatToolStatus", () => {
+  test("returns null for non-tool part", () => {
+    expect(formatToolStatus({ type: "text", text: "hello" })).toBeNull()
+  })
+
+  test("returns running status for tool with status running and title", () => {
+    const result = formatToolStatus({
+      type: "tool",
+      tool: "bash",
+      state: { status: "running", title: "ls -la", time: { start: 1 } },
+    })
+    expect(result).not.toBeNull()
+    expect(result).toContain("Running")
+  })
+
+  test("returns pending status for tool with status pending", () => {
+    const result = formatToolStatus({
+      type: "tool",
+      tool: "edit",
+      state: { status: "pending", input: {} },
+    })
+    expect(result).not.toBeNull()
+    expect(result).toContain("Preparing")
+  })
+
+  test("returns null for completed tool", () => {
+    expect(
+      formatToolStatus({
+        type: "tool",
+        tool: "bash",
+        state: { status: "completed", input: {}, output: "", title: "done", time: { start: 1, end: 2 } },
+      }),
+    ).toBeNull()
+  })
+
+  test("returns null for error tool", () => {
+    expect(
+      formatToolStatus({
+        type: "tool",
+        tool: "bash",
+        state: { status: "error", input: {}, error: "fail", time: { start: 1, end: 2 } },
+      }),
+    ).toBeNull()
+  })
+
+  test("running status includes tool name", () => {
+    const result = formatToolStatus({
+      type: "tool",
+      tool: "bash",
+      state: { status: "running", title: "npm test", time: { start: 1 } },
+    })
+    expect(result).toContain("bash")
+  })
+
+  test("running status includes title text", () => {
+    const result = formatToolStatus({
+      type: "tool",
+      tool: "bash",
+      state: { status: "running", title: "npm test", time: { start: 1 } },
+    })
+    expect(result).toContain("npm test")
+  })
+
+  test("returns null when part.state is undefined", () => {
+    expect(formatToolStatus({ type: "tool", tool: "bash" })).toBeNull()
+  })
+})