@pedrohnas/opencode-telegram 0.1.0

package/src/send/format.ts

@@ -0,0 +1,93 @@
+/**
+ * Convert Markdown text to Telegram-compatible HTML.
+ *
+ * Telegram supports a limited subset of HTML:
+ *   <b>, <i>, <s>, <u>, <code>, <pre>, <a href="">, <blockquote>
+ *
+ * Strategy:
+ *   1. Extract code blocks/inline code (protect from formatting)
+ *   2. Escape HTML entities in remaining text
+ *   3. Apply markdown → HTML conversions
+ *   4. Re-insert protected code blocks
+ */
+
+const PLACEHOLDER_PREFIX = "\x00CB"
+const PLACEHOLDER_INLINE = "\x00CI"
+
+export function markdownToTelegramHtml(markdown: string): string {
+  if (!markdown) return ""
+
+  // --- Step 1: Extract and protect code blocks & inline code ---
+  const codeBlocks: string[] = []
+  const inlineCodes: string[] = []
+
+  // Fenced code blocks: ```lang\ncode\n```
+  let text = markdown.replace(
+    /```(\w*)\n([\s\S]*?)```/g,
+    (_, lang, code) => {
+      const escaped = escapeHtml(code.replace(/\n$/, ""))
+      const langAttr = lang ? ` class="language-${lang}"` : ""
+      const html = `<pre><code${langAttr}>${escaped}</code></pre>`
+      codeBlocks.push(html)
+      return `${PLACEHOLDER_PREFIX}${codeBlocks.length - 1}\x00`
+    },
+  )
+
+  // Inline code: `code`
+  text = text.replace(/`([^`]+)`/g, (_, code) => {
+    const html = `<code>${escapeHtml(code)}</code>`
+    inlineCodes.push(html)
+    return `${PLACEHOLDER_INLINE}${inlineCodes.length - 1}\x00`
+  })
+
+  // --- Step 2: Escape HTML in remaining text ---
+  text = escapeHtml(text)
+
+  // --- Step 3: Markdown → HTML conversions ---
+
+  // Headings: # text → <b>text</b> (Telegram has no heading tags)
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>")
+
+  // Bold: **text** or __text__
+  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>")
+  text = text.replace(/__(.+?)__/g, "<b>$1</b>")
+
+  // Italic: *text* or _text_ (but not inside words like file_name)
+  text = text.replace(/(?<!\w)\*([^*]+?)\*(?!\w)/g, "<i>$1</i>")
+  text = text.replace(/(?<!\w)_([^_]+?)_(?!\w)/g, "<i>$1</i>")
+
+  // Strikethrough: ~~text~~
+  text = text.replace(/~~(.+?)~~/g, "<s>$1</s>")
+
+  // Links: [text](url)
+  text = text.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    '<a href="$2">$1</a>',
+  )
+
+  // Blockquotes: > text
+  text = text.replace(/^&gt;\s?(.+)$/gm, "<blockquote>$1</blockquote>")
+
+  // --- Step 4: Re-insert protected code ---
+  text = text.replace(
+    new RegExp(`${escapeRegex(PLACEHOLDER_PREFIX)}(\\d+)\x00`, "g"),
+    (_, idx) => codeBlocks[Number(idx)],
+  )
+  text = text.replace(
+    new RegExp(`${escapeRegex(PLACEHOLDER_INLINE)}(\\d+)\x00`, "g"),
+    (_, idx) => inlineCodes[Number(idx)],
+  )
+
+  return text
+}
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}

package/src/send/tool-progress.ts

@@ -0,0 +1,22 @@
+/**
+ * Format tool call status for display in the streaming draft.
+ *
+ * Returns a suffix string to append to the draft message while a tool
+ * is running/pending, or null if no suffix is needed (completed/error).
+ */
+export function formatToolStatus(part: any): string | null {
+  if (part.type !== "tool") return null
+  if (!part.state) return null
+
+  const tool = part.tool ?? "tool"
+  const { status } = part.state
+
+  if (status === "running" && part.state.title) {
+    return `\n\n---\n⚙ Running ${tool}: ${part.state.title}`
+  }
+  if (status === "pending") {
+    return `\n\n---\n⚙ Preparing ${tool}...`
+  }
+
+  return null
+}

package/src/session-manager.ts

@@ -0,0 +1,143 @@
+/**
+ * LRU-bounded session map: Telegram chatKey ↔ OpenCode sessionId.
+ *
+ * Anti-leak design:
+ *   - Max entries cap (evicts oldest on overflow)
+ *   - TTL-based expiration (cleanup removes stale entries)
+ *   - Reverse map (sessionId → chatKey) for SSE event routing
+ *   - Eviction only removes from memory — sessions persist on OpenCode server
+ */
+
+import type { OpencodeClient } from "@opencode-ai/sdk/v2"
+
+export type SessionEntry = {
+  sessionId: string
+  directory: string
+  createdAt: number
+  lastAccessAt: number
+}
+
+export type SessionManagerOptions = {
+  maxEntries: number
+  ttlMs: number
+}
+
+export class SessionManager {
+  private map = new Map<string, SessionEntry>()
+  private reverseMap = new Map<string, string>() // sessionId → chatKey
+  private readonly maxEntries: number
+  private readonly ttlMs: number
+
+  constructor(opts: SessionManagerOptions) {
+    this.maxEntries = opts.maxEntries
+    this.ttlMs = opts.ttlMs
+  }
+
+  async getOrCreate(
+    chatKey: string,
+    sdk: OpencodeClient,
+  ): Promise<SessionEntry> {
+    const existing = this.map.get(chatKey)
+    if (existing) {
+      // LRU: refresh access order by re-inserting
+      this.map.delete(chatKey)
+      existing.lastAccessAt = Date.now()
+      this.map.set(chatKey, existing)
+      return existing
+    }
+
+    // Create new session via SDK
+    const result = await sdk.session.create({
+      title: `Telegram ${chatKey}`,
+    })
+
+    const session = result.data!
+    const entry: SessionEntry = {
+      sessionId: session.id,
+      directory: session.directory ?? "",
+      createdAt: Date.now(),
+      lastAccessAt: Date.now(),
+    }
+
+    this.insert(chatKey, entry)
+    return entry
+  }
+
+  get(chatKey: string): SessionEntry | undefined {
+    return this.map.get(chatKey)
+  }
+
+  getBySessionId(
+    sessionId: string,
+  ): { chatKey: string; entry: SessionEntry } | undefined {
+    const chatKey = this.reverseMap.get(sessionId)
+    if (!chatKey) return undefined
+    const entry = this.map.get(chatKey)
+    if (!entry) return undefined
+    return { chatKey, entry }
+  }
+
+  set(
+    chatKey: string,
+    init: { sessionId: string; directory: string },
+  ): void {
+    // Clean up old binding if exists
+    const old = this.map.get(chatKey)
+    if (old) {
+      this.reverseMap.delete(old.sessionId)
+    }
+
+    const entry: SessionEntry = {
+      sessionId: init.sessionId,
+      directory: init.directory,
+      createdAt: Date.now(),
+      lastAccessAt: Date.now(),
+    }
+
+    this.insert(chatKey, entry)
+  }
+
+  remove(chatKey: string): void {
+    const entry = this.map.get(chatKey)
+    if (entry) {
+      this.reverseMap.delete(entry.sessionId)
+      this.map.delete(chatKey)
+    }
+  }
+
+  cleanup(): void {
+    const now = Date.now()
+    for (const [chatKey, entry] of this.map) {
+      if (now - entry.lastAccessAt > this.ttlMs) {
+        this.reverseMap.delete(entry.sessionId)
+        this.map.delete(chatKey)
+      }
+    }
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+
+  private insert(chatKey: string, entry: SessionEntry): void {
+    // Remove old binding for this chatKey
+    const old = this.map.get(chatKey)
+    if (old) {
+      this.reverseMap.delete(old.sessionId)
+      this.map.delete(chatKey)
+    }
+
+    // Evict oldest if at capacity
+    while (this.map.size >= this.maxEntries) {
+      const oldest = this.map.keys().next().value
+      if (oldest !== undefined) {
+        const evicted = this.map.get(oldest)
+        if (evicted) this.reverseMap.delete(evicted.sessionId)
+        this.map.delete(oldest)
+      }
+    }
+
+    this.map.set(chatKey, entry)
+    this.reverseMap.set(entry.sessionId, chatKey)
+  }
+}

package/src/turn-manager.ts

@@ -0,0 +1,87 @@
+/**
+ * Per-turn lifecycle manager.
+ *
+ * Each turn (user prompt → AI response) gets:
+ *   - One AbortController (abort() cleans up all listeners + timers)
+ *   - A set of tracked timers (auto-cleared on end)
+ *   - Accumulated text from SSE events (for final send on session.idle)
+ *
+ * Anti-leak: end() or abortAll() guarantees full cleanup.
+ */
+
+export type ActiveTurn = {
+  sessionId: string
+  chatId: number
+  abortController: AbortController
+  accumulatedText: string
+  toolSuffix: string
+  timers: Set<ReturnType<typeof setTimeout>>
+  draft: { stop(): void; getMessageId(): number | null; update(text: string): Promise<void> } | null
+}
+
+export class TurnManager {
+  private active = new Map<string, ActiveTurn>()
+
+  start(sessionId: string, chatId: number): ActiveTurn {
+    // If there's an existing turn, end it first
+    const existing = this.active.get(sessionId)
+    if (existing) {
+      this.endTurn(existing)
+    }
+
+    const turn: ActiveTurn = {
+      sessionId,
+      chatId,
+      abortController: new AbortController(),
+      accumulatedText: "",
+      toolSuffix: "",
+      timers: new Set(),
+      draft: null,
+    }
+
+    this.active.set(sessionId, turn)
+    return turn
+  }
+
+  get(sessionId: string): ActiveTurn | undefined {
+    return this.active.get(sessionId)
+  }
+
+  end(sessionId: string): void {
+    const turn = this.active.get(sessionId)
+    if (turn) {
+      this.endTurn(turn)
+      this.active.delete(sessionId)
+    }
+  }
+
+  addTimer(sessionId: string, timer: ReturnType<typeof setTimeout>): void {
+    const turn = this.active.get(sessionId)
+    if (turn) {
+      turn.timers.add(timer)
+    }
+  }
+
+  abortAll(): void {
+    for (const [sessionId, turn] of this.active) {
+      this.endTurn(turn)
+    }
+    this.active.clear()
+  }
+
+  get size(): number {
+    return this.active.size
+  }
+
+  private endTurn(turn: ActiveTurn): void {
+    // Stop draft stream if active
+    turn.draft?.stop()
+    // Abort all listeners registered with this signal
+    turn.abortController.abort()
+    // Clear all tracked timers
+    for (const timer of turn.timers) {
+      clearTimeout(timer)
+    }
+    turn.timers.clear()
+  }
+}