opencode-telegram-mirror 0.3.0

package/src/telegram.ts

@@ -0,0 +1,705 @@
+/**
+ * Telegram Bot API client for sending/receiving messages
+ */
+
+import { Result, TaggedError } from "better-result"
+import type { LogFn } from "./log"
+
+export interface TelegramConfig {
+  botToken: string
+  chatId: string // Channel, group, or DM chat ID
+  threadId?: number // Optional thread/topic ID for forum groups
+  log?: LogFn // Optional logger function
+  baseUrl?: string // Optional custom base URL (for testing)
+}
+
+export interface TelegramPhotoSize {
+  file_id: string
+  file_unique_id: string
+  width: number
+  height: number
+  file_size?: number
+}
+
+export interface TelegramMessage {
+  message_id: number
+  from?: {
+    id: number
+    first_name: string
+    username?: string
+    is_bot?: boolean
+  }
+  chat: {
+    id: number
+    type: string
+  }
+  message_thread_id?: number
+  date: number
+  text?: string
+  caption?: string
+  photo?: TelegramPhotoSize[]
+  reply_to_message?: TelegramMessage
+}
+
+export interface CallbackQuery {
+  id: string
+  from: {
+    id: number
+    first_name: string
+    username?: string
+  }
+  message?: TelegramMessage
+  data?: string // Callback data from inline button
+}
+
+export interface TelegramUpdate {
+  update_id: number
+  message?: TelegramMessage
+  callback_query?: CallbackQuery
+}
+
+interface GetUpdatesResponse {
+  ok: boolean
+  result: TelegramUpdate[]
+  error_code?: number
+  description?: string
+}
+
+interface SendMessageResponse {
+  ok: boolean
+  result: TelegramMessage
+  error_code?: number
+  description?: string
+}
+
+// Custom error for fatal Telegram errors (chat not found, etc.)
+export class TelegramFatalError extends TaggedError("TelegramFatalError")<{
+  message: string
+  code: number
+  cause?: unknown
+}>() {}
+
+export class TelegramApiError extends TaggedError("TelegramApiError")<{
+  message: string
+  cause: unknown
+}>() {
+  constructor(args: { cause: unknown }) {
+    const causeMessage = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Telegram API error: ${causeMessage}` })
+  }
+}
+
+export type TelegramResult<T> = Result<T, TelegramFatalError | TelegramApiError>
+
+export interface InlineKeyboardButton {
+  text: string
+  callback_data?: string
+  url?: string
+  web_app?: { url: string }
+}
+
+export interface InlineKeyboardMarkup {
+  inline_keyboard: InlineKeyboardButton[][]
+}
+
+export class TelegramClient {
+  private baseUrl: string
+  private chatId: string
+  private threadId?: number
+  private lastUpdateId = 0
+  private log: LogFn
+
+  constructor(config: TelegramConfig) {
+    this.baseUrl = config.baseUrl ?? `https://api.telegram.org/bot${config.botToken}`
+    this.chatId = config.chatId
+    this.threadId = config.threadId
+    this.log = config.log ?? (() => {})
+  }
+
+  /**
+   * Send a message to the configured chat/thread
+   */
+  async sendMessage(
+    text: string,
+    options?: {
+      replyMarkup?: InlineKeyboardMarkup
+      replyToMessageId?: number
+    }
+  ): Promise<TelegramResult<TelegramMessage | null>> {
+    // Telegram has a 4096 character limit per message
+    const maxLength = 4096
+    const chunks = this.splitMessage(text, maxLength)
+
+    this.log("debug", "Preparing to send message", {
+      textLength: text.length,
+      chunks: chunks.length,
+      chatId: this.chatId,
+      threadId: this.threadId,
+      hasReplyMarkup: !!options?.replyMarkup,
+    })
+
+    let lastMessage: TelegramMessage | null = null
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i]
+      const isLastChunk = i === chunks.length - 1
+
+      const params: Record<string, unknown> = {
+        chat_id: this.chatId,
+        text: chunk,
+        parse_mode: "Markdown",
+      }
+
+      if (this.threadId) {
+        params.message_thread_id = this.threadId
+      }
+
+      if (options?.replyToMessageId) {
+        params.reply_to_message_id = options.replyToMessageId
+      }
+
+      // Only add reply markup to the last chunk
+      if (isLastChunk && options?.replyMarkup) {
+        params.reply_markup = options.replyMarkup
+      }
+
+      this.log("debug", "Sending chunk to Telegram API", {
+        chunkIndex: i,
+        chunkLength: chunk.length,
+        isLastChunk,
+      })
+
+      try {
+        const response = await fetch(`${this.baseUrl}/sendMessage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params),
+        })
+
+        const data = (await response.json()) as SendMessageResponse
+
+        this.log("debug", "Telegram API response", {
+          ok: data.ok,
+          messageId: data.result?.message_id,
+        })
+
+        if (!data.ok) {
+          // Check for fatal errors (chat not found, etc.)
+          if (data.error_code === 400 && data.description?.includes("chat not found")) {
+            this.log("error", "Chat not found - stopping", { chatId: this.chatId, response: data })
+            return Result.err(
+              new TelegramFatalError({ message: `Chat not found: ${this.chatId}`, code: 400 })
+            )
+          }
+
+          this.log("warn", "Markdown failed, retrying without parse_mode", { response: data, text: chunk })
+          // Retry without markdown if it fails (markdown can be finicky)
+          params.parse_mode = undefined
+          const retryResponse = await fetch(`${this.baseUrl}/sendMessage`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+          })
+          const retryData = (await retryResponse.json()) as SendMessageResponse
+          if (retryData.ok) {
+            lastMessage = retryData.result
+            this.log("info", "Message sent successfully (plain text)", {
+              messageId: retryData.result.message_id,
+            })
+          } else {
+            // Check for fatal errors on retry too
+            if (retryData.error_code === 400 && retryData.description?.includes("chat not found")) {
+              this.log("error", "Chat not found - stopping", { chatId: this.chatId, response: retryData })
+              return Result.err(
+                new TelegramFatalError({ message: `Chat not found: ${this.chatId}`, code: 400 })
+              )
+            }
+            this.log("error", "Failed to send message", { response: retryData })
+          }
+        } else {
+          lastMessage = data.result
+          this.log("info", "Message sent successfully", { messageId: data.result.message_id })
+        }
+      } catch (error) {
+        this.log("error", "Error sending message", { error: String(error) })
+        return Result.err(new TelegramApiError({ cause: error }))
+      }
+    }
+
+    if (lastMessage) {
+      return Result.ok(lastMessage)
+    }
+
+    return Result.err(
+      new TelegramApiError({
+        cause: new Error("Failed to send Telegram message"),
+      })
+    )
+  }
+ 
+  /**
+   * Edit an existing message's text and/or reply markup
+   */
+  async editMessage(
+    messageId: number,
+    text: string,
+    options?: { replyMarkup?: InlineKeyboardMarkup }
+  ): Promise<TelegramResult<boolean>> {
+    this.log("debug", "Editing message", { messageId, textLength: text.length })
+
+    const params: Record<string, unknown> = {
+      chat_id: this.chatId,
+      message_id: messageId,
+      text,
+      parse_mode: "Markdown",
+    }
+
+    if (options?.replyMarkup) {
+      params.reply_markup = options.replyMarkup
+    }
+
+    try {
+      const response = await fetch(`${this.baseUrl}/editMessageText`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params),
+      })
+
+      const data = (await response.json()) as { ok: boolean }
+
+      if (!data.ok) {
+        this.log("warn", "Edit with markdown failed, retrying plain", { messageId })
+        // Retry without markdown
+        params.parse_mode = undefined
+        const retryResponse = await fetch(`${this.baseUrl}/editMessageText`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params),
+        })
+        const retryData = (await retryResponse.json()) as { ok: boolean }
+        this.log("debug", "Edit retry result", { messageId, ok: retryData.ok })
+        return Result.ok(retryData.ok)
+      }
+
+      this.log("debug", "Message edited successfully", { messageId })
+      return Result.ok(true)
+    } catch (error) {
+      this.log("error", "Error editing message", { messageId, error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Update a forum topic name
+   */
+  async editForumTopic(threadId: number, name: string): Promise<TelegramResult<boolean>> {
+    this.log("debug", "Editing forum topic", { threadId, nameLength: name.length })
+
+    const params: Record<string, unknown> = {
+      chat_id: this.chatId,
+      message_thread_id: threadId,
+      name,
+    }
+
+    try {
+      const response = await fetch(`${this.baseUrl}/editForumTopic`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params),
+      })
+
+      const data = (await response.json()) as {
+        ok: boolean
+        result?: boolean
+        error_code?: number
+        description?: string
+      }
+
+      if (!data.ok) {
+        this.log("error", "Failed to edit forum topic", { threadId, response: data })
+        return Result.err(new TelegramApiError({ cause: data.description || "Edit forum topic failed" }))
+      }
+
+      this.log("info", "Forum topic edited", { threadId })
+      return Result.ok(true)
+    } catch (error) {
+      this.log("error", "Error editing forum topic", { threadId, error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Answer a callback query (acknowledge button press)
+   */
+  async answerCallbackQuery(
+    callbackQueryId: string,
+    options?: { text?: string; showAlert?: boolean }
+  ): Promise<TelegramResult<boolean>> {
+    this.log("debug", "Answering callback query", { callbackQueryId, text: options?.text })
+
+    const params: Record<string, unknown> = {
+      callback_query_id: callbackQueryId,
+    }
+
+    if (options?.text) {
+      params.text = options.text
+    }
+    if (options?.showAlert) {
+      params.show_alert = options.showAlert
+    }
+
+    try {
+      const response = await fetch(`${this.baseUrl}/answerCallbackQuery`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params),
+      })
+
+      const data = (await response.json()) as { ok: boolean }
+      this.log("debug", "Callback query answered", { ok: data.ok })
+      return Result.ok(data.ok)
+    } catch (error) {
+      this.log("error", "Error answering callback query", { error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Get new updates (messages and callback queries) using long polling
+   */
+  async getUpdates(timeout = 30): Promise<TelegramResult<TelegramUpdate[]>> {
+    try {
+      const params = new URLSearchParams({
+        offset: String(this.lastUpdateId + 1),
+        timeout: String(timeout),
+        allowed_updates: JSON.stringify(["message", "callback_query"]),
+      })
+
+      const response = await fetch(`${this.baseUrl}/getUpdates?${params}`)
+      const data = (await response.json()) as GetUpdatesResponse
+
+      if (!data.ok) {
+        this.log("error", "Failed to get updates from Telegram API", { response: data })
+
+        if (data.error_code === 409) {
+          return Result.err(
+            new TelegramFatalError({
+              message: data.description || "Conflict",
+              code: 409,
+            })
+          )
+        }
+        if (data.error_code === 401) {
+          return Result.err(
+            new TelegramFatalError({
+              message: data.description || "Unauthorized",
+              code: 401,
+            })
+          )
+        }
+
+        return Result.err(new TelegramApiError({ cause: data.description || "Unknown error" }))
+      }
+
+      const updates: TelegramUpdate[] = []
+
+      for (const update of data.result) {
+        this.lastUpdateId = update.update_id
+
+        // Filter messages to our target chat/thread
+        if (update.message) {
+          const msg = update.message
+          const chatMatches = String(msg.chat.id) === this.chatId
+          const threadMatches = this.threadId
+            ? msg.message_thread_id === this.threadId
+            : true
+
+          if (chatMatches && threadMatches) {
+            updates.push(update)
+            this.log("info", "Message matched filter", {
+              updateId: update.update_id,
+              from: msg.from?.username || msg.from?.first_name,
+              preview: msg.text?.slice(0, 50),
+            })
+          }
+        }
+
+        // Include callback queries from our chat
+        if (update.callback_query?.message) {
+          const chatMatches =
+            String(update.callback_query.message.chat.id) === this.chatId
+
+          this.log("debug", "Processing callback query", {
+            updateId: update.update_id,
+            callbackData: update.callback_query.data,
+            chatMatches,
+          })
+
+          if (chatMatches) {
+            updates.push(update)
+            this.log("info", "Callback query matched", {
+              updateId: update.update_id,
+              data: update.callback_query.data,
+            })
+          }
+        }
+      }
+
+      this.log("debug", "Polling complete", {
+        totalReceived: data.result.length,
+        matchedUpdates: updates.length,
+      })
+
+      return Result.ok(updates)
+    } catch (error) {
+      this.log("error", "Error getting updates", { error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Split a long message into chunks that fit Telegram's limit
+   */
+  private splitMessage(text: string, maxLength: number): string[] {
+    if (text.length <= maxLength) {
+      return [text]
+    }
+
+    const chunks: string[] = []
+    let remaining = text
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining)
+        break
+      }
+
+      // Try to split at a newline
+      let splitIndex = remaining.lastIndexOf("\n", maxLength)
+      if (splitIndex === -1 || splitIndex < maxLength / 2) {
+        // Try to split at a space
+        splitIndex = remaining.lastIndexOf(" ", maxLength)
+      }
+      if (splitIndex === -1 || splitIndex < maxLength / 2) {
+        // Force split at maxLength
+        splitIndex = maxLength
+      }
+
+      chunks.push(remaining.slice(0, splitIndex))
+      remaining = remaining.slice(splitIndex).trimStart()
+    }
+
+    return chunks
+  }
+
+  /**
+   * Send typing indicator to show the bot is working
+   * Returns a stop function to cancel the typing indicator
+   */
+  startTyping(intervalMs = 4000): () => void {
+    // Send immediately
+    this.sendTypingAction()
+
+    // Telegram typing indicator lasts ~5 seconds, so refresh every 4 seconds
+    const interval = setInterval(() => {
+      this.sendTypingAction()
+    }, intervalMs)
+
+    return () => {
+      clearInterval(interval)
+    }
+  }
+
+  /**
+   * Send a single typing action
+   */
+  async sendTypingAction(): Promise<TelegramResult<void>> {
+    const params: Record<string, unknown> = {
+      chat_id: this.chatId,
+      action: "typing",
+    }
+
+    if (this.threadId) {
+      params.message_thread_id = this.threadId
+    }
+
+    try {
+      await fetch(`${this.baseUrl}/sendChatAction`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(params),
+      })
+      return Result.ok(undefined)
+    } catch (error) {
+      this.log("debug", "Failed to send typing action", { error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Get bot info to verify the token is valid
+   */
+  async getMe(): Promise<TelegramResult<{ id: number; username: string }>> {
+    const result = await Result.tryPromise({
+      try: async () => {
+        const response = await fetch(`${this.baseUrl}/getMe`)
+        return (await response.json()) as { ok: boolean; result?: { id: number; username: string } }
+      },
+      catch: (error) => new TelegramApiError({ cause: error }),
+    })
+
+    if (result.status === "error") {
+      return Result.err(result.error)
+    }
+
+    if (!result.value.ok || !result.value.result) {
+      return Result.err(new TelegramApiError({ cause: "Invalid bot response" }))
+    }
+
+    return Result.ok(result.value.result)
+  }
+
+  /**
+   * Set bot commands (menu button)
+   */
+  async setMyCommands(
+    commands: Array<{ command: string; description: string }>
+  ): Promise<TelegramResult<boolean>> {
+    this.log("debug", "Setting bot commands", { count: commands.length })
+
+    try {
+      const response = await fetch(`${this.baseUrl}/setMyCommands`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ commands }),
+      })
+
+      const data = (await response.json()) as { ok: boolean; description?: string }
+
+      if (!data.ok) {
+        this.log("error", "Failed to set bot commands", { response: data })
+        return Result.err(new TelegramApiError({ cause: data.description || "Set commands failed" }))
+      }
+
+      this.log("info", "Bot commands set", { commands: commands.map((c) => c.command) })
+      return Result.ok(true)
+    } catch (error) {
+      this.log("error", "Error setting bot commands", { error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Get a file's download URL from Telegram
+   * @param fileId The file_id from a photo/document/etc
+   * @returns The file URL, or null on failure
+   */
+  async getFileUrl(fileId: string): Promise<TelegramResult<string>> {
+    this.log("debug", "Getting file info", { fileId })
+
+    const result = await Result.tryPromise({
+      try: async () => {
+        const response = await fetch(`${this.baseUrl}/getFile?file_id=${encodeURIComponent(fileId)}`)
+        return (await response.json()) as {
+          ok: boolean
+          result?: { file_id: string; file_unique_id: string; file_size?: number; file_path?: string }
+          description?: string
+        }
+      },
+      catch: (error) => new TelegramApiError({ cause: error }),
+    })
+
+    if (result.status === "error") {
+      this.log("error", "Error getting file URL", { fileId, error: result.error.message })
+      return Result.err(result.error)
+    }
+
+    if (!result.value.ok || !result.value.result?.file_path) {
+      this.log("error", "Failed to get file info", { response: result.value })
+      return Result.err(new TelegramApiError({ cause: result.value.description || "Invalid file info" }))
+    }
+
+    // Construct the download URL
+    // Format: https://api.telegram.org/file/bot<token>/<file_path>
+    const downloadUrl = `${this.baseUrl.replace("/bot", "/file/bot")}/${result.value.result.file_path}`
+    this.log("debug", "Got file URL", { fileId, filePath: result.value.result.file_path })
+    return Result.ok(downloadUrl)
+  }
+
+  /**
+   * Download a file from Telegram and return it as a base64 data URL
+   * @param fileId The file_id from a photo/document/etc
+   * @param mimeType The MIME type for the data URL (e.g., "image/jpeg")
+   * @returns The base64 data URL, or null on failure
+   */
+  async downloadFileAsDataUrl(
+    fileId: string,
+    mimeType: string
+  ): Promise<TelegramResult<string>> {
+    const fileUrlResult = await this.getFileUrl(fileId)
+    if (fileUrlResult.status === "error") {
+      return Result.err(fileUrlResult.error)
+    }
+
+    const fileUrl = fileUrlResult.value
+
+    try {
+      this.log("debug", "Downloading file", { fileUrl })
+      const response = await fetch(fileUrl)
+      if (!response.ok) {
+        this.log("error", "Failed to download file", { status: response.status })
+        return Result.err(new TelegramApiError({ cause: `Download failed: ${response.status}` }))
+      }
+
+      const buffer = await response.arrayBuffer()
+      const base64 = Buffer.from(buffer).toString("base64")
+      const dataUrl = `data:${mimeType};base64,${base64}`
+      this.log("debug", "File downloaded", { size: buffer.byteLength })
+      return Result.ok(dataUrl)
+    } catch (error) {
+      this.log("error", "Error downloading file", { error: String(error) })
+      return Result.err(new TelegramApiError({ cause: error }))
+    }
+  }
+
+  /**
+   * Build inline keyboard from options
+   */
+  static buildInlineKeyboard(
+    options: Array<{ label: string; callbackData: string }>,
+    options2?: { columns?: number; addOther?: boolean; otherCallbackData?: string }
+  ): InlineKeyboardMarkup {
+    const columns = options2?.columns ?? 2
+    const keyboard: InlineKeyboardButton[][] = []
+    let currentRow: InlineKeyboardButton[] = []
+
+    for (const opt of options) {
+      currentRow.push({
+        text: opt.label,
+        callback_data: opt.callbackData,
+      })
+
+      if (currentRow.length >= columns) {
+        keyboard.push(currentRow)
+        currentRow = []
+      }
+    }
+
+    // Add remaining buttons
+    if (currentRow.length > 0) {
+      keyboard.push(currentRow)
+    }
+
+    // Add "Other" button for freetext input
+    if (options2?.addOther) {
+      keyboard.push([
+        {
+          text: "Other (type reply)",
+          callback_data: options2.otherCallbackData ?? "other",
+        },
+      ])
+    }
+
+    return { inline_keyboard: keyboard }
+  }
+}