agent-messenger 2.11.2 → 2.12.1

package/src/platforms/telegrambot/client.ts

@@ -0,0 +1,404 @@
+import { readFile } from 'node:fs/promises'
+
+import type {
+  TelegramBotUser,
+  TelegramChat,
+  TelegramChatFullInfo,
+  TelegramChatMember,
+  TelegramMessage,
+  TelegramReactionType,
+  TelegramUpdate,
+} from './types'
+import { TelegramBotError } from './types'
+
+const BASE_URL = 'https://api.telegram.org'
+const MAX_RETRIES = 3
+const BASE_BACKOFF_MS = 100
+
+interface ApiResponse<T> {
+  ok: boolean
+  result?: T
+  description?: string
+  error_code?: number
+  parameters?: {
+    retry_after?: number
+    migrate_to_chat_id?: number
+  }
+}
+
+export interface SendMessageOptions {
+  parse_mode?: 'HTML' | 'Markdown' | 'MarkdownV2'
+  disable_web_page_preview?: boolean
+  disable_notification?: boolean
+  protect_content?: boolean
+  reply_to_message_id?: number
+  message_thread_id?: number
+}
+
+export interface GetUpdatesOptions {
+  offset?: number
+  limit?: number
+  timeout?: number
+  allowed_updates?: string[]
+}
+
+export interface EditMessageTextChat {
+  chat_id: number | string
+  message_id: number
+  inline_message_id?: never
+}
+
+export interface EditMessageTextInline {
+  inline_message_id: string
+  chat_id?: never
+  message_id?: never
+}
+
+export type EditMessageTextTarget = EditMessageTextChat | EditMessageTextInline
+
+export type BotReactionType = { type: 'emoji'; emoji: string }
+
+export type ChatId = number | string
+
+export class TelegramBotClient {
+  private token: string | null = null
+
+  async login(credentials?: { token: string }): Promise<this> {
+    if (credentials) {
+      if (!credentials.token) {
+        throw new TelegramBotError('Token is required', 'missing_token')
+      }
+      this.token = credentials.token
+      return this
+    }
+
+    const { TelegramBotCredentialManager } = await import('./credential-manager')
+    const credManager = new TelegramBotCredentialManager()
+    const creds = await credManager.getCredentials()
+    if (!creds?.token) {
+      throw new TelegramBotError('No Telegram bot credentials found. Run "auth set <token>" first.', 'no_credentials')
+    }
+    return this.login({ token: creds.token })
+  }
+
+  private ensureAuth(): string {
+    if (!this.token) {
+      throw new TelegramBotError('Not authenticated. Call .login() first.', 'not_authenticated')
+    }
+    return this.token
+  }
+
+  private buildUrl(method: string): string {
+    return `${BASE_URL}/bot${this.ensureAuth()}/${method}`
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+
+  private isAbort(signal: AbortSignal | undefined, error: unknown): boolean {
+    if (signal?.aborted) return true
+    const name = (error as { name?: string } | null)?.name
+    return name === 'AbortError'
+  }
+
+  private throwApiError(method: string, body: ApiResponse<unknown>): never {
+    const code = body.error_code
+    const description = body.description ?? `HTTP error from ${method}`
+    if (code === 401) {
+      throw new TelegramBotError(`Unauthorized: ${description}`, 'unauthorized')
+    }
+    if (code === 409) {
+      throw new TelegramBotError(`Conflict: ${description}`, 'conflict')
+    }
+    if (code === 403) {
+      throw new TelegramBotError(`Forbidden: ${description}`, 'forbidden')
+    }
+    if (code === 400) {
+      throw new TelegramBotError(`Bad Request: ${description}`, 'bad_request')
+    }
+    if (code === 404) {
+      throw new TelegramBotError(`Not Found: ${description}`, 'not_found')
+    }
+    throw new TelegramBotError(description, code !== undefined ? `http_${code}` : 'http_error')
+  }
+
+  private async parseJsonOrRetry<T>(
+    response: Response,
+    method: string,
+    attempt: number,
+  ): Promise<{ body: ApiResponse<T> } | { retry: true }> {
+    try {
+      const body = (await response.json()) as ApiResponse<T>
+      return { body }
+    } catch {
+      // 5xx responses sometimes return HTML/empty bodies; allow retry instead of failing fast.
+      if (response.status >= 500 && attempt < MAX_RETRIES) {
+        return { retry: true }
+      }
+      throw new TelegramBotError(`Invalid JSON response from ${method} (HTTP ${response.status})`, 'invalid_response')
+    }
+  }
+
+  private async call<T>(method: string, params?: Record<string, unknown>, signal?: AbortSignal): Promise<T> {
+    return this.requestJson<T>(method, { method: 'POST', body: params }, signal)
+  }
+
+  private async requestJson<T>(
+    method: string,
+    request: { method: 'POST' | 'GET'; body?: Record<string, unknown> },
+    signal?: AbortSignal,
+  ): Promise<T> {
+    const url = this.buildUrl(method)
+    let lastError: Error | undefined
+
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (signal?.aborted) {
+        throw Object.assign(new Error('Aborted'), { name: 'AbortError' })
+      }
+
+      const init: RequestInit = {
+        method: request.method,
+        headers: { 'Content-Type': 'application/json' },
+        body: request.body ? JSON.stringify(request.body) : undefined,
+        signal,
+      }
+
+      let response: Response
+      try {
+        response = await fetch(url, init)
+      } catch (error) {
+        if (this.isAbort(signal, error)) {
+          throw error instanceof Error ? error : Object.assign(new Error('Aborted'), { name: 'AbortError' })
+        }
+        lastError = error instanceof Error ? error : new Error(String(error))
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+          continue
+        }
+        throw new TelegramBotError(`Network error: ${lastError.message}`, 'network_error')
+      }
+
+      const parsed = await this.parseJsonOrRetry<T>(response, method, attempt)
+      if ('retry' in parsed) {
+        await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+        continue
+      }
+      const { body } = parsed
+
+      if (response.status === 429 || body.error_code === 429) {
+        const retryAfter = body.parameters?.retry_after ?? 1
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(retryAfter * 1000)
+          continue
+        }
+        throw new TelegramBotError(body.description ?? 'Rate limited', 'rate_limited')
+      }
+
+      if (response.status >= 500 && attempt < MAX_RETRIES) {
+        await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+        continue
+      }
+
+      if (!body.ok) {
+        this.throwApiError(method, body)
+      }
+
+      if (body.result === undefined) {
+        return undefined as T
+      }
+      return body.result
+    }
+
+    throw lastError ?? new TelegramBotError('Request failed after retries', 'max_retries')
+  }
+
+  private async callMultipart<T>(method: string, formData: FormData, signal?: AbortSignal): Promise<T> {
+    const url = this.buildUrl(method)
+    let lastError: Error | undefined
+
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (signal?.aborted) {
+        throw Object.assign(new Error('Aborted'), { name: 'AbortError' })
+      }
+
+      let response: Response
+      try {
+        response = await fetch(url, { method: 'POST', body: formData, signal })
+      } catch (error) {
+        if (this.isAbort(signal, error)) {
+          throw error instanceof Error ? error : Object.assign(new Error('Aborted'), { name: 'AbortError' })
+        }
+        lastError = error instanceof Error ? error : new Error(String(error))
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+          continue
+        }
+        throw new TelegramBotError(`Network error: ${lastError.message}`, 'network_error')
+      }
+
+      const parsed = await this.parseJsonOrRetry<T>(response, method, attempt)
+      if ('retry' in parsed) {
+        await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+        continue
+      }
+      const { body } = parsed
+
+      if (response.status === 429 || body.error_code === 429) {
+        const retryAfter = body.parameters?.retry_after ?? 1
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(retryAfter * 1000)
+          continue
+        }
+        throw new TelegramBotError(body.description ?? 'Rate limited', 'rate_limited')
+      }
+
+      if (response.status >= 500 && attempt < MAX_RETRIES) {
+        await this.sleep(BASE_BACKOFF_MS * 2 ** attempt)
+        continue
+      }
+
+      if (!body.ok) {
+        this.throwApiError(method, body)
+      }
+
+      if (body.result === undefined) {
+        return undefined as T
+      }
+      return body.result
+    }
+
+    throw lastError ?? new TelegramBotError('Request failed after retries', 'max_retries')
+  }
+
+  async getMe(): Promise<TelegramBotUser> {
+    return this.call<TelegramBotUser>('getMe')
+  }
+
+  async getChat(chatId: ChatId): Promise<TelegramChatFullInfo> {
+    return this.call<TelegramChatFullInfo>('getChat', { chat_id: chatId })
+  }
+
+  async getChatMember(chatId: ChatId, userId: number): Promise<TelegramChatMember> {
+    return this.call<TelegramChatMember>('getChatMember', { chat_id: chatId, user_id: userId })
+  }
+
+  async getChatMemberCount(chatId: ChatId): Promise<number> {
+    return this.call<number>('getChatMemberCount', { chat_id: chatId })
+  }
+
+  async sendMessage(chatId: ChatId, text: string, options?: SendMessageOptions): Promise<TelegramMessage> {
+    return this.call<TelegramMessage>('sendMessage', { chat_id: chatId, text, ...options })
+  }
+
+  async sendPhoto(
+    chatId: ChatId,
+    photo: string,
+    options?: { caption?: string; parse_mode?: SendMessageOptions['parse_mode'] },
+  ): Promise<TelegramMessage> {
+    return this.call<TelegramMessage>('sendPhoto', { chat_id: chatId, photo, ...options })
+  }
+
+  async sendDocument(
+    chatId: ChatId,
+    filePath: string,
+    options?: { caption?: string; parse_mode?: SendMessageOptions['parse_mode']; signal?: AbortSignal },
+  ): Promise<TelegramMessage> {
+    const fileBuffer = await readFile(filePath)
+    const filename = filePath.split('/').pop() || 'file'
+
+    const formData = new FormData()
+    formData.append('chat_id', String(chatId))
+    formData.append('document', new Blob([new Uint8Array(fileBuffer)]), filename)
+    if (options?.caption !== undefined) formData.append('caption', options.caption)
+    if (options?.parse_mode !== undefined) formData.append('parse_mode', options.parse_mode)
+
+    return this.callMultipart<TelegramMessage>('sendDocument', formData, options?.signal)
+  }
+
+  async forwardMessage(
+    chatId: ChatId,
+    fromChatId: ChatId,
+    messageId: number,
+    options?: { disable_notification?: boolean; protect_content?: boolean; message_thread_id?: number },
+  ): Promise<TelegramMessage> {
+    return this.call<TelegramMessage>('forwardMessage', {
+      chat_id: chatId,
+      from_chat_id: fromChatId,
+      message_id: messageId,
+      ...options,
+    })
+  }
+
+  async editMessageText(
+    target: EditMessageTextTarget,
+    text: string,
+    options?: SendMessageOptions,
+  ): Promise<TelegramMessage | true> {
+    return this.call<TelegramMessage | true>('editMessageText', { ...target, text, ...options })
+  }
+
+  async deleteMessage(chatId: ChatId, messageId: number): Promise<boolean> {
+    return this.call<boolean>('deleteMessage', { chat_id: chatId, message_id: messageId })
+  }
+
+  async setMessageReaction(
+    chatId: ChatId,
+    messageId: number,
+    reaction: BotReactionType[],
+    options?: { is_big?: boolean },
+  ): Promise<boolean> {
+    return this.call<boolean>('setMessageReaction', {
+      chat_id: chatId,
+      message_id: messageId,
+      reaction,
+      ...options,
+    })
+  }
+
+  async setMessageReactionRaw(
+    chatId: ChatId,
+    messageId: number,
+    reaction: TelegramReactionType[],
+    options?: { is_big?: boolean },
+  ): Promise<boolean> {
+    return this.call<boolean>('setMessageReaction', {
+      chat_id: chatId,
+      message_id: messageId,
+      reaction,
+      ...options,
+    })
+  }
+
+  async getUpdates(options?: GetUpdatesOptions, signal?: AbortSignal): Promise<TelegramUpdate[]> {
+    const params: Record<string, unknown> = {}
+    if (options?.offset !== undefined) params.offset = options.offset
+    if (options?.limit !== undefined) params.limit = options.limit
+    if (options?.timeout !== undefined) params.timeout = options.timeout
+    if (options?.allowed_updates !== undefined) params.allowed_updates = options.allowed_updates
+    return this.call<TelegramUpdate[]>('getUpdates', params, signal)
+  }
+
+  async deleteWebhook(options?: { drop_pending_updates?: boolean }): Promise<boolean> {
+    return this.call<boolean>('deleteWebhook', options)
+  }
+
+  async setWebhook(url: string, options?: Record<string, unknown>): Promise<boolean> {
+    return this.call<boolean>('setWebhook', { url, ...options })
+  }
+
+  async resolveChatId(chat: ChatId): Promise<ChatId> {
+    if (typeof chat === 'number') return chat
+    if (/^-?\d+$/.test(chat)) return Number(chat)
+    if (chat.startsWith('@')) return chat
+    return `@${chat}`
+  }
+
+  formatChat(chat: TelegramChat): { id: number; type: string; name: string } {
+    if (chat.title) return { id: chat.id, type: chat.type, name: chat.title }
+    const fullName = [chat.first_name, chat.last_name].filter(Boolean).join(' ')
+    if (fullName) return { id: chat.id, type: chat.type, name: fullName }
+    if (chat.username) return { id: chat.id, type: chat.type, name: chat.username }
+    return { id: chat.id, type: chat.type, name: String(chat.id) }
+  }
+}

package/src/platforms/telegrambot/commands/auth.test.ts

@@ -0,0 +1,244 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { TelegramBotClient } from '../client'
+import { TelegramBotCredentialManager } from '../credential-manager'
+import type { TelegramBotUser } from '../types'
+import { clearAction, listAction, removeAction, setAction, statusAction, useAction } from './auth'
+
+interface MockOptions {
+  user?: TelegramBotUser
+  loginError?: Error
+  getMeError?: Error
+}
+
+function createMockClient(options: MockOptions = {}): TelegramBotClient {
+  const user = options.user ?? {
+    id: 123456,
+    is_bot: true,
+    first_name: 'Test',
+    username: 'testbot',
+  }
+  return {
+    async login(): Promise<TelegramBotClient> {
+      if (options.loginError) throw options.loginError
+      return this as unknown as TelegramBotClient
+    },
+    async getMe(): Promise<TelegramBotUser> {
+      if (options.getMeError) throw options.getMeError
+      return user
+    },
+  } as unknown as TelegramBotClient
+}
+
+describe('auth commands', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `telegrambot-auth-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_TELEGRAMBOT_TOKEN
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  describe('setAction', () => {
+    it('validates and stores bot token using username as bot_id', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+
+      const result = await setAction('123:abc', {
+        _credManager: manager,
+        _clientFactory: () => createMockClient(),
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.bot_id).toBe('testbot')
+      expect(result.bot_name).toBe('testbot')
+
+      const creds = await manager.getCredentials()
+      expect(creds?.token).toBe('123:abc')
+      expect(creds?.bot_id).toBe('testbot')
+    })
+
+    it('uses --bot flag as bot_id', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+
+      const result = await setAction('123:abc', {
+        bot: 'deploy',
+        _credManager: manager,
+        _clientFactory: () => createMockClient(),
+      })
+
+      expect(result.bot_id).toBe('deploy')
+      expect(await manager.getCredentials('deploy')).not.toBeNull()
+    })
+
+    it('falls back to numeric id when username missing', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await setAction('123:abc', {
+        _credManager: manager,
+        _clientFactory: () =>
+          createMockClient({
+            user: { id: 123456, is_bot: true, first_name: 'NoUsername' },
+          }),
+      })
+
+      expect(result.bot_id).toBe('123456')
+    })
+
+    it('rejects non-bot tokens (is_bot: false)', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await setAction('user-token', {
+        _credManager: manager,
+        _clientFactory: () =>
+          createMockClient({
+            user: { id: 123456, is_bot: false, first_name: 'User' },
+          }),
+      })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('not')
+    })
+
+    it('handles client errors', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await setAction('bad', {
+        _credManager: manager,
+        _clientFactory: () =>
+          createMockClient({
+            getMeError: new Error('Unauthorized: invalid token'),
+          }),
+      })
+
+      expect(result.error).toContain('Unauthorized')
+    })
+
+    it('returns error when login itself fails', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await setAction('bad', {
+        _credManager: manager,
+        _clientFactory: () =>
+          createMockClient({
+            loginError: new Error('Token is required'),
+          }),
+      })
+
+      expect(result.error).toBe('Token is required')
+      expect(await manager.getCredentials()).toBeNull()
+    })
+  })
+
+  describe('clearAction', () => {
+    it('removes all stored credentials', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: 't', bot_id: 'b', bot_name: 'B' })
+
+      const result = await clearAction({ _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(await manager.getCredentials()).toBeNull()
+    })
+  })
+
+  describe('statusAction', () => {
+    it('returns no credentials when none set', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await statusAction({ _credManager: manager })
+
+      expect(result.valid).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    it('returns valid status for current bot', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: '123:abc', bot_id: 'mybot', bot_name: 'My Bot' })
+
+      const result = await statusAction({
+        _credManager: manager,
+        _clientFactory: () => createMockClient(),
+      })
+
+      expect(result.valid).toBe(true)
+      expect(result.bot_id).toBe('mybot')
+    })
+
+    it('returns invalid when getMe fails', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: 'bad', bot_id: 'mybot', bot_name: 'My Bot' })
+
+      const result = await statusAction({
+        _credManager: manager,
+        _clientFactory: () =>
+          createMockClient({
+            getMeError: new Error('401'),
+          }),
+      })
+      expect(result.valid).toBe(false)
+    })
+  })
+
+  describe('listAction', () => {
+    it('returns empty list when no bots', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await listAction({ _credManager: manager })
+      expect(result.bots).toEqual([])
+    })
+
+    it('returns all bots with current flag', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: 't1', bot_id: 'a', bot_name: 'A' })
+      await manager.setCredentials({ token: 't2', bot_id: 'b', bot_name: 'B' })
+
+      const result = await listAction({ _credManager: manager })
+      expect(result.bots).toHaveLength(2)
+      expect(result.bots?.find((x) => x.bot_id === 'b')?.is_current).toBe(true)
+    })
+  })
+
+  describe('useAction', () => {
+    it('switches active bot', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: 't1', bot_id: 'a', bot_name: 'A' })
+      await manager.setCredentials({ token: 't2', bot_id: 'b', bot_name: 'B' })
+
+      const result = await useAction('a', { _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(result.bot_id).toBe('a')
+    })
+
+    it('returns error for unknown bot', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await useAction('nope', { _credManager: manager })
+      expect(result.error).toContain('not found')
+    })
+  })
+
+  describe('removeAction', () => {
+    it('removes a stored bot', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      await manager.setCredentials({ token: 't', bot_id: 'a', bot_name: 'A' })
+
+      const result = await removeAction('a', { _credManager: manager })
+
+      expect(result.success).toBe(true)
+      expect(await manager.getCredentials('a')).toBeNull()
+    })
+
+    it('returns error for unknown bot', async () => {
+      const manager = new TelegramBotCredentialManager(tempDir)
+      const result = await removeAction('nope', { _credManager: manager })
+      expect(result.error).toContain('not found')
+    })
+  })
+})