agent-messenger 1.14.0 → 2.0.0

package/src/platforms/telegram/my-telegram-org.ts

@@ -0,0 +1,206 @@
+import { TelegramError } from './types'
+
+const MY_TELEGRAM_URL = 'https://my.telegram.org'
+const USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+
+export async function provisionTelegramApp(options: {
+  phone: string
+  promptForCode: () => Promise<string>
+}): Promise<{ api_id: number; api_hash: string }> {
+  const randomHash = await sendProvisioningCode(options.phone)
+  const code = await options.promptForCode()
+  const stelToken = await completeProvisioningLogin(options.phone, randomHash, code)
+  return getOrCreateProvisionedApp(stelToken)
+}
+
+export async function sendProvisioningCode(phone: string): Promise<string> {
+  return sendCode(phone)
+}
+
+export async function completeProvisioningLogin(phone: string, randomHash: string, code: string): Promise<string> {
+  return login(phone, randomHash, code)
+}
+
+export async function getOrCreateProvisionedApp(stelToken: string): Promise<{ api_id: number; api_hash: string }> {
+  return getOrCreateApp(stelToken)
+}
+
+async function sendCode(phone: string): Promise<string> {
+  const response = await fetch(`${MY_TELEGRAM_URL}/auth/send_password`, {
+    method: 'POST',
+    headers: createAjaxHeaders(),
+    body: new URLSearchParams({ phone }),
+  })
+
+  const text = await response.text()
+
+  if (text.includes('Sorry, too many tries')) {
+    throw new TelegramError('Too many attempts. Try again later.', 'rate_limited')
+  }
+
+  let data: unknown
+  try {
+    data = JSON.parse(text)
+  } catch {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  const randomHash = extractRandomHash(data)
+  if (!randomHash) {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  return randomHash
+}
+
+async function login(phone: string, randomHash: string, code: string): Promise<string> {
+  const response = await fetch(`${MY_TELEGRAM_URL}/auth/login`, {
+    method: 'POST',
+    headers: createAjaxHeaders(),
+    body: new URLSearchParams({
+      phone,
+      random_hash: randomHash,
+      password: code,
+    }),
+    redirect: 'manual',
+  })
+
+  const text = await response.text()
+
+  if (text === 'Invalid confirmation code!') {
+    throw new TelegramError('Invalid confirmation code', 'invalid_code')
+  }
+
+  if (text !== 'true') {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  const stelToken = extractCookieValue(response.headers, 'stel_token')
+  if (!stelToken) {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  return stelToken
+}
+
+async function getOrCreateApp(stelToken: string): Promise<{ api_id: number; api_hash: string }> {
+  const response = await fetch(`${MY_TELEGRAM_URL}/apps`, {
+    headers: {
+      Cookie: `stel_token=${stelToken}`,
+      'User-Agent': USER_AGENT,
+    },
+  })
+
+  const html = await response.text()
+
+  if (isAppConfigurationPage(html)) {
+    return extractAppCredentials(html)
+  }
+
+  if (!isCreateApplicationPage(html)) {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  const creationHash = extractCreationHash(html)
+  if (!creationHash) {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  const createResponse = await fetch(`${MY_TELEGRAM_URL}/apps/create`, {
+    method: 'POST',
+    headers: {
+      ...createFormHeaders(),
+      Cookie: `stel_token=${stelToken}`,
+    },
+    body: new URLSearchParams({
+      hash: creationHash,
+      app_title: 'agentmessenger',
+      app_shortname: 'agentmessenger',
+      app_platform: 'other',
+      app_url: '',
+      app_desc: '',
+    }),
+  })
+
+  return extractAppCredentials(await createResponse.text())
+}
+
+function createAjaxHeaders(): Record<string, string> {
+  return {
+    ...createFormHeaders(),
+    Origin: MY_TELEGRAM_URL,
+    'X-Requested-With': 'XMLHttpRequest',
+  }
+}
+
+function createFormHeaders(): Record<string, string> {
+  return {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+    'User-Agent': USER_AGENT,
+  }
+}
+
+function extractRandomHash(data: unknown): string | null {
+  if (!data || typeof data !== 'object') {
+    return null
+  }
+
+  const randomHash = (data as { random_hash?: unknown }).random_hash
+  return typeof randomHash === 'string' && randomHash ? randomHash : null
+}
+
+function extractCookieValue(headers: Headers, cookieName: string): string | null {
+  const cookiePattern = new RegExp(`(?:^|;\\s*)${escapeRegExp(cookieName)}=([^;]+)`)
+  const setCookieHeaders = getSetCookieHeaders(headers)
+
+  for (const header of setCookieHeaders) {
+    const match = header.match(cookiePattern)
+    if (match) {
+      return match[1]
+    }
+  }
+
+  return null
+}
+
+function getSetCookieHeaders(headers: Headers): string[] {
+  const headersWithGetSetCookie = headers as Headers & { getSetCookie?: () => string[] }
+  if (typeof headersWithGetSetCookie.getSetCookie === 'function') {
+    return headersWithGetSetCookie.getSetCookie()
+  }
+
+  const singleHeader = headers.get('set-cookie')
+  return singleHeader ? [singleHeader] : []
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function isAppConfigurationPage(html: string): boolean {
+  return /<title>\s*App configuration\s*<\/title>/i.test(html)
+}
+
+function isCreateApplicationPage(html: string): boolean {
+  return /<title>\s*Create new application\s*<\/title>/i.test(html)
+}
+
+function extractAppCredentials(html: string): { api_id: number; api_hash: string } {
+  const apiIdMatch = html.match(/<span class="form-control input-xlarge uneditable-input"[^>]*><strong>(\d+)<\/strong><\/span>/)
+  const apiHashMatch = html.match(/<span class="form-control input-xlarge uneditable-input"[^>]*>([a-f0-9]{32})<\/span>/)
+
+  if (!apiIdMatch?.[1] || !apiHashMatch?.[1]) {
+    throw new TelegramError('Failed to parse my.telegram.org response', 'parse_error')
+  }
+
+  return {
+    api_id: Number(apiIdMatch[1]),
+    api_hash: apiHashMatch[1],
+  }
+}
+
+function extractCreationHash(html: string): string | null {
+  const hashMatch = html.match(/<input[^>]*name="hash"[^>]*value="([^"]+)"/)
+  return hashMatch?.[1] ?? null
+}

package/src/platforms/telegram/tdlib.ts

@@ -0,0 +1,159 @@
+import { TelegramError } from './types'
+
+interface TdjsonSymbols {
+  td_create_client_id: () => number
+  td_send: (clientId: number, request: string) => void
+  td_receive: (timeout: number) => string | null
+  td_execute: (request: string) => string | null
+}
+
+let cachedKoffi: typeof import('koffi') | undefined
+
+async function getKoffi(): Promise<typeof import('koffi')> {
+  if (cachedKoffi) {
+    return cachedKoffi
+  }
+
+  try {
+    cachedKoffi = await import('koffi')
+    return cachedKoffi
+  } catch {
+    throw new Error('koffi is required for Telegram support. Install it with: bun add koffi prebuilt-tdlib')
+  }
+}
+
+function getLibrarySuffix(): string {
+  if (process.platform === 'darwin') {
+    return 'dylib'
+  }
+
+  if (process.platform === 'win32') {
+    return 'dll'
+  }
+
+  return 'so'
+}
+
+async function getPrebuiltTdjsonPath(): Promise<string | undefined> {
+  try {
+    const mod = (await import('prebuilt-tdlib')) as { getTdjson?: () => string }
+    const tdjson = mod.getTdjson?.()
+    return typeof tdjson === 'string' && tdjson.length > 0 ? tdjson : undefined
+  } catch {
+    return undefined
+  }
+}
+
+async function getTdjsonCandidates(tdlibPath?: string): Promise<string[]> {
+  const suffix = getLibrarySuffix()
+  const candidates = [tdlibPath, process.env.TDLIB_PATH, process.env.TDJSON_PATH, await getPrebuiltTdjsonPath()].filter(
+    (value): value is string => Boolean(value),
+  )
+
+  if (process.platform === 'darwin') {
+    candidates.push(
+      `/opt/homebrew/lib/libtdjson.${suffix}`,
+      `/opt/homebrew/opt/tdlib/lib/libtdjson.${suffix}`,
+      `/usr/local/lib/libtdjson.${suffix}`,
+      `libtdjson.${suffix}`,
+      `tdjson.${suffix}`,
+    )
+  } else if (process.platform === 'linux') {
+    candidates.push(
+      `/usr/local/lib/libtdjson.${suffix}`,
+      `/usr/lib/libtdjson.${suffix}`,
+      `/usr/lib/x86_64-linux-gnu/libtdjson.${suffix}`,
+      `libtdjson.${suffix}`,
+      `tdjson.${suffix}`,
+    )
+  } else {
+    candidates.push(`tdjson.${suffix}`)
+  }
+
+  return Array.from(new Set(candidates))
+}
+
+function getInstallHint(): string {
+  const prebuiltHint =
+    'If you publish this package for bunx users, keep `prebuilt-tdlib` in dependencies so libtdjson is installed automatically.'
+
+  if (process.platform === 'darwin') {
+    return `${prebuiltHint} Otherwise, install TDLib with \`brew install tdlib\`, then set TDLIB_PATH if needed.`
+  }
+
+  if (process.platform === 'linux') {
+    return `${prebuiltHint} Otherwise, install TDLib and make sure libtdjson is on your shared library path, or set TDLIB_PATH.`
+  }
+
+  return `${prebuiltHint} Otherwise, install TDLib and set TDLIB_PATH to the full path of your tdjson shared library.`
+}
+
+async function loadTdjson(tdlibPath?: string): Promise<{ libraryPath: string; symbols: TdjsonSymbols }> {
+  const koffi = await getKoffi()
+  const errors: string[] = []
+
+  for (const candidate of await getTdjsonCandidates(tdlibPath)) {
+    try {
+      const library = koffi.load(candidate)
+
+      return {
+        libraryPath: candidate,
+        symbols: {
+          td_create_client_id: library.func('int td_create_client_id(void)') as TdjsonSymbols['td_create_client_id'],
+          td_send: library.func('void td_send(int client_id, const char* request)') as TdjsonSymbols['td_send'],
+          td_receive: library.func('const char* td_receive(double timeout)') as TdjsonSymbols['td_receive'],
+          td_execute: library.func('const char* td_execute(const char* request)') as TdjsonSymbols['td_execute'],
+        },
+      }
+    } catch (error) {
+      errors.push(`${candidate}: ${(error as Error).message}`)
+    }
+  }
+
+  throw new TelegramError(
+    `Unable to load TDLib shared library.\n${getInstallHint()}\nTried:\n${errors.join('\n')}`,
+    'tdlib_not_found',
+  )
+}
+
+export class TdjsonBinding {
+  readonly libraryPath: string
+  private symbols: TdjsonSymbols
+
+  private constructor(libraryPath: string, symbols: TdjsonSymbols) {
+    this.libraryPath = libraryPath
+    this.symbols = symbols
+    this.execute({ '@type': 'setLogVerbosityLevel', new_verbosity_level: 0 })
+  }
+
+  static async create(tdlibPath?: string): Promise<TdjsonBinding> {
+    const loaded = await loadTdjson(tdlibPath)
+    return new TdjsonBinding(loaded.libraryPath, loaded.symbols)
+  }
+
+  createClientId(): number {
+    return this.symbols.td_create_client_id()
+  }
+
+  send(clientId: number, query: unknown): void {
+    this.symbols.td_send(clientId, JSON.stringify(query))
+  }
+
+  receive(timeoutSeconds: number): any | null {
+    const result = this.symbols.td_receive(timeoutSeconds)
+    if (!result || !result.trim()) {
+      return null
+    }
+
+    return JSON.parse(result)
+  }
+
+  execute(query: unknown): any | null {
+    const result = this.symbols.td_execute(JSON.stringify(query))
+    if (!result || !result.trim()) {
+      return null
+    }
+
+    return JSON.parse(result)
+  }
+}

package/src/platforms/telegram/types.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from 'bun:test'
+import { findFuzzyChats, normalizeChatSearchText } from './chat-utils'
+import { createAccountId, simplifyChat, simplifyMessage, summarizeAuthorizationState } from './types'
+
+describe('telegram type helpers', () => {
+  test('createAccountId normalizes phone numbers', () => {
+    expect(createAccountId('+82 10 1234 5678')).toBe('plus-82-10-1234-5678')
+  })
+
+  test('summarizeAuthorizationState returns next action for wait code', () => {
+    const summary = summarizeAuthorizationState({
+      '@type': 'authorizationStateWaitCode',
+      code_info: {
+        type: { '@type': 'authenticationCodeTypeSms' },
+        phone_number: '+821012345678',
+        timeout: 60,
+      },
+    })
+
+    expect(summary.authenticated).toBe(false)
+    expect(summary.next_action).toBe('provide_code')
+    expect(summary.code_info?.type).toBe('authenticationCodeTypeSms')
+  })
+
+  test('simplifyMessage extracts message text', () => {
+    const message = simplifyMessage({
+      id: 42,
+      chat_id: 1001,
+      date: 1_710_000_000,
+      is_outgoing: true,
+      sender_id: { '@type': 'messageSenderUser', user_id: 99 },
+      content: {
+        '@type': 'messageText',
+        text: {
+          text: 'hello',
+        },
+      },
+    })
+
+    expect(message.id).toBe(42)
+    expect(message.text).toBe('hello')
+    expect(message.sender.type).toBe('user')
+  })
+
+  test('simplifyChat normalizes chat type', () => {
+    const chat = simplifyChat({
+      id: 1001,
+      title: 'General',
+      unread_count: 3,
+      type: { '@type': 'chatTypeSupergroup' },
+      last_message: {
+        id: 42,
+        chat_id: 1001,
+        date: 1_710_000_000,
+        is_outgoing: false,
+        sender_id: { '@type': 'messageSenderChat', chat_id: 1001 },
+        content: {
+          '@type': 'messageText',
+          text: { text: 'latest' },
+        },
+      },
+    })
+
+    expect(chat.type).toBe('supergroup')
+    expect(chat.last_message?.text).toBe('latest')
+  })
+
+  test('normalize and fuzzy search logic can match titles despite spacing differences', () => {
+    expect(normalizeChatSearchText('Project Room')).toBe('projectroom')
+    expect(
+      findFuzzyChats([{ id: 1, title: 'ProjectRoom', type: 'private', unread_count: 0 }], 'Project Room', 10),
+    ).toHaveLength(1)
+  })
+})