agent-messenger 1.14.0 → 2.0.0

package/src/platforms/telegram/commands/chat.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { parseLimitOption, withTelegramClient } from './shared'
+
+async function listAction(options: { account?: string; pretty?: boolean; limit?: string }): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+
+    const chats = await withTelegramClient(options, async (client) => client.listChats(limit))
+    console.log(formatOutput(chats, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function searchAction(
+  query: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const chats = await withTelegramClient(options, async (client) => client.searchChats(query, limit))
+    console.log(formatOutput(chats, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function getAction(reference: string, options: { account?: string; pretty?: boolean }): Promise<void> {
+  try {
+    const chat = await withTelegramClient(options, async (client) => client.getChat(reference))
+    console.log(formatOutput(chat, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const chatCommand = new Command('chat')
+  .description('Telegram chat commands')
+  .addCommand(
+    new Command('list')
+      .description('List chats from the main Telegram chat list')
+      .option('--limit <n>', 'Number of chats to fetch', '20')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('search')
+      .description('Search chats by title, username, or known local chat name')
+      .argument('<query>', 'Search query')
+      .option('--limit <n>', 'Number of chats to fetch', '20')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(searchAction),
+  )
+  .addCommand(
+    new Command('get')
+      .description('Get a single chat by ID, @username, or exact title match')
+      .argument('<chat>', 'Chat ID, @username, or title')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(getAction),
+  )

package/src/platforms/telegram/commands/index.ts

@@ -0,0 +1,3 @@
+export { authCommand } from './auth'
+export { chatCommand } from './chat'
+export { messageCommand } from './message'

package/src/platforms/telegram/commands/message.ts

@@ -0,0 +1,51 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { parseLimitOption, withTelegramClient } from './shared'
+
+async function listAction(
+  reference: string,
+  options: { account?: string; pretty?: boolean; limit?: string },
+): Promise<void> {
+  try {
+    const limit = parseLimitOption(options.limit, 20)
+    const messages = await withTelegramClient(options, async (client) => client.listMessages(reference, limit))
+    console.log(formatOutput(messages, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function sendAction(
+  reference: string,
+  text: string,
+  options: { account?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const message = await withTelegramClient(options, async (client) => client.sendMessage(reference, text))
+    console.log(formatOutput(message, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Telegram message commands')
+  .addCommand(
+    new Command('list')
+      .description('List recent messages in a chat')
+      .argument('<chat>', 'Chat ID, @username, or title')
+      .option('--limit <n>', 'Number of messages to fetch', '20')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('send')
+      .description('Send a text message to a chat')
+      .argument('<chat>', 'Chat ID, @username, or title')
+      .argument('<text>', 'Message text')
+      .option('--account <id>', 'Use a specific Telegram account')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(sendAction),
+  )

package/src/platforms/telegram/commands/shared.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, test } from 'bun:test'
+import { TelegramError } from '../types'
+import { parseLimitOption } from './shared'
+
+describe('telegram shared command helpers', () => {
+  test('parseLimitOption accepts normal integer strings', () => {
+    expect(parseLimitOption('10', 20)).toBe(10)
+  })
+
+  test('parseLimitOption rejects malformed numeric prefixes', () => {
+    expect(() => parseLimitOption('10abc', 20)).toThrow(TelegramError)
+    expect(() => parseLimitOption('1.5', 20)).toThrow(TelegramError)
+    expect(() => parseLimitOption('2e3', 20)).toThrow(TelegramError)
+  })
+})

package/src/platforms/telegram/commands/shared.ts

@@ -0,0 +1,50 @@
+import { TelegramTdlibClient } from '../client'
+import { TelegramCredentialManager } from '../credential-manager'
+import { type TelegramAccount, TelegramError } from '../types'
+
+export interface AccountOption {
+  account?: string
+  pretty?: boolean
+}
+
+export function parseLimitOption(rawLimit: string | undefined, defaultValue: number, maxValue: number = 100): number {
+  const trimmed = (rawLimit ?? `${defaultValue}`).trim()
+
+  if (!/^\d+$/.test(trimmed)) {
+    throw new TelegramError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  const parsed = Number.parseInt(trimmed, 10)
+
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > maxValue) {
+    throw new TelegramError(`--limit must be an integer between 1 and ${maxValue}.`, 'invalid_limit')
+  }
+
+  return parsed
+}
+
+export async function withTelegramClient<T>(
+  options: AccountOption,
+  action: (client: TelegramTdlibClient, account: TelegramAccount, manager: TelegramCredentialManager) => Promise<T>,
+): Promise<T> {
+  const manager = new TelegramCredentialManager()
+  const account = await manager.getAccount(options.account)
+
+  if (!account) {
+    throw new TelegramError(
+      options.account
+        ? `Telegram account "${options.account}" not found. Run "agent-telegram auth login" first.`
+        : 'No Telegram account configured. Run "agent-telegram auth login" first.',
+      'missing_account',
+    )
+  }
+
+  const paths = await manager.ensureAccountPaths(account.account_id)
+  const client = await TelegramTdlibClient.create(account, paths)
+
+  try {
+    return await action(client, account, manager)
+  } finally {
+    await client.close({ waitForClosed: false, timeoutMs: 1500 }).catch(() => undefined)
+  }
+}

package/src/platforms/telegram/credential-manager.test.ts

@@ -0,0 +1,152 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { TelegramCredentialManager } from './credential-manager'
+
+const testDirs: string[] = []
+
+function setup(): TelegramCredentialManager {
+  const testConfigDir = join(
+    import.meta.dir,
+    `.test-telegram-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  )
+  testDirs.push(testConfigDir)
+  return new TelegramCredentialManager(testConfigDir)
+}
+
+afterAll(() => {
+  for (const dir of testDirs) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe('TelegramCredentialManager', () => {
+  test('stores and retrieves accounts', async () => {
+    const manager = setup()
+
+    await manager.setAccount({
+      account_id: 'default',
+      api_id: 12345,
+      api_hash: 'hash',
+      phone_number: '+821012345678',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+
+    const account = await manager.getAccount()
+    expect(account?.account_id).toBe('default')
+    expect(account?.phone_number).toBe('+821012345678')
+  })
+
+  test('switches current account', async () => {
+    const manager = setup()
+
+    await manager.setAccount({
+      account_id: 'first',
+      api_id: 1,
+      api_hash: 'hash-1',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+    await manager.setAccount({
+      account_id: 'second',
+      api_id: 2,
+      api_hash: 'hash-2',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+
+    const switched = await manager.setCurrent('second')
+    const current = await manager.getAccount()
+
+    expect(switched).toBe(true)
+    expect(current?.account_id).toBe('second')
+  })
+
+  test('creates account directories', async () => {
+    const manager = setup()
+    const paths = await manager.ensureAccountPaths('+82 10 1234 5678')
+
+    expect(existsSync(paths.account_dir)).toBe(true)
+    expect(existsSync(paths.database_dir)).toBe(true)
+    expect(existsSync(paths.files_dir)).toBe(true)
+    expect(paths.account_dir.endsWith('plus-82-10-1234-5678')).toBe(true)
+  })
+
+  test('saves and loads provisioning state', async () => {
+    const manager = setup()
+    const state = {
+      phone: '+14155551234',
+      random_hash: 'abc123',
+      created_at: new Date().toISOString(),
+    }
+
+    await manager.saveProvisioningState(state)
+    const loaded = await manager.loadProvisioningState()
+
+    expect(loaded).not.toBeNull()
+    expect(loaded!.phone).toBe('+14155551234')
+    expect(loaded!.random_hash).toBe('abc123')
+  })
+
+  test('returns null for expired provisioning state', async () => {
+    const manager = setup()
+    const expiredDate = new Date(Date.now() - 11 * 60 * 1000).toISOString()
+
+    await manager.saveProvisioningState({
+      phone: '+14155551234',
+      random_hash: 'abc123',
+      created_at: expiredDate,
+    })
+
+    const loaded = await manager.loadProvisioningState()
+    expect(loaded).toBeNull()
+  })
+
+  test('clears provisioning state', async () => {
+    const manager = setup()
+
+    await manager.saveProvisioningState({
+      phone: '+14155551234',
+      random_hash: 'abc123',
+      created_at: new Date().toISOString(),
+    })
+
+    await manager.clearProvisioningState()
+    const loaded = await manager.loadProvisioningState()
+    expect(loaded).toBeNull()
+  })
+
+  test('returns null when no provisioning state exists', async () => {
+    const manager = setup()
+    const loaded = await manager.loadProvisioningState()
+    expect(loaded).toBeNull()
+  })
+
+  test('returns null for corrupted created_at in provisioning state', async () => {
+    const manager = setup()
+
+    await manager.saveProvisioningState({
+      phone: '+14155551234',
+      random_hash: 'abc123',
+      created_at: 'not-a-date',
+    })
+
+    const loaded = await manager.loadProvisioningState()
+    expect(loaded).toBeNull()
+  })
+
+  test('clearCredentials also clears provisioning state', async () => {
+    const manager = setup()
+
+    await manager.saveProvisioningState({
+      phone: '+14155551234',
+      random_hash: 'abc123',
+      created_at: new Date().toISOString(),
+    })
+
+    await manager.clearCredentials()
+    const loaded = await manager.loadProvisioningState()
+    expect(loaded).toBeNull()
+  })
+})

package/src/platforms/telegram/credential-manager.ts

@@ -0,0 +1,203 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import {
+  createAccountId,
+  type TelegramAccount,
+  type TelegramAccountPaths,
+  type TelegramConfig,
+  TelegramError,
+  type TelegramProvisioningState,
+} from './types'
+
+const PROVISIONING_STATE_TTL_MS = 10 * 60 * 1000
+
+export class TelegramCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+  private provisioningStatePath: string
+  private tdlibRootDir: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'telegram-credentials.json')
+    this.provisioningStatePath = join(this.configDir, 'telegram-provisioning-state.json')
+    this.tdlibRootDir = join(this.configDir, 'telegram')
+  }
+
+  async loadConfig(): Promise<TelegramConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, accounts: {} }
+    }
+
+    try {
+      const content = await readFile(this.credentialsPath, 'utf-8')
+      return JSON.parse(content) as TelegramConfig
+    } catch {
+      return { current: null, accounts: {} }
+    }
+  }
+
+  async saveConfig(config: TelegramConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    // TODO: Windows does not honor mode 0o600 — consider platform-specific credential storage
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+  }
+
+  async getAccount(accountId?: string): Promise<TelegramAccount | null> {
+    const config = await this.loadConfig()
+
+    if (!accountId) {
+      return config.current ? (config.accounts[config.current] ?? null) : null
+    }
+
+    const direct = config.accounts[accountId]
+    if (direct) {
+      return direct
+    }
+
+    const normalized = createAccountId(accountId)
+    return config.accounts[normalized] ?? null
+  }
+
+  async listAccounts(): Promise<Array<TelegramAccount & { is_current: boolean }>> {
+    const config = await this.loadConfig()
+
+    return Object.values(config.accounts).map((account) => ({
+      ...account,
+      is_current: account.account_id === config.current,
+    }))
+  }
+
+  async setAccount(account: TelegramAccount): Promise<void> {
+    const config = await this.loadConfig()
+    config.accounts[account.account_id] = account
+
+    if (!config.current) {
+      config.current = account.account_id
+    }
+
+    await this.saveConfig(config)
+  }
+
+  async migrateAccount(oldAccountId: string, account: TelegramAccount): Promise<void> {
+    const config = await this.loadConfig()
+    const normalizedOldAccountId = createAccountId(oldAccountId)
+    const oldPaths = this.getAccountPaths(normalizedOldAccountId)
+    const newPaths = this.getAccountPaths(account.account_id)
+
+    if (normalizedOldAccountId !== account.account_id && existsSync(oldPaths.account_dir) && existsSync(newPaths.account_dir)) {
+      throw new TelegramError(
+        `Can't migrate Telegram account data from "${normalizedOldAccountId}" to "${account.account_id}" because the target TDLib directory already exists: ${newPaths.account_dir}`,
+        'account_migration_conflict',
+      )
+    }
+
+    if (normalizedOldAccountId !== account.account_id && existsSync(oldPaths.account_dir) && !existsSync(newPaths.account_dir)) {
+      await mkdir(this.tdlibRootDir, { recursive: true })
+      await rename(oldPaths.account_dir, newPaths.account_dir)
+    }
+
+    delete config.accounts[normalizedOldAccountId]
+    if (oldAccountId !== normalizedOldAccountId) {
+      delete config.accounts[oldAccountId]
+    }
+    config.accounts[account.account_id] = account
+    config.current = account.account_id
+    await this.saveConfig(config)
+  }
+
+  async setCurrent(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    config.current = account.account_id
+    await this.saveConfig(config)
+    return true
+  }
+
+  async removeAccount(accountId: string): Promise<boolean> {
+    const config = await this.loadConfig()
+    const account = config.accounts[accountId] ?? config.accounts[createAccountId(accountId)]
+
+    if (!account) {
+      return false
+    }
+
+    delete config.accounts[account.account_id]
+
+    if (config.current === account.account_id) {
+      config.current = Object.keys(config.accounts)[0] ?? null
+    }
+
+    await this.saveConfig(config)
+    await rm(this.getAccountPaths(account.account_id).account_dir, { recursive: true, force: true })
+    return true
+  }
+
+  async clearCredentials(): Promise<void> {
+    if (existsSync(this.credentialsPath)) {
+      await rm(this.credentialsPath, { force: true })
+    }
+
+    if (existsSync(this.tdlibRootDir)) {
+      await rm(this.tdlibRootDir, { recursive: true, force: true })
+    }
+
+    await this.clearProvisioningState()
+  }
+
+  async saveProvisioningState(state: TelegramProvisioningState): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.provisioningStatePath, JSON.stringify(state, null, 2), { mode: 0o600 })
+  }
+
+  async loadProvisioningState(): Promise<TelegramProvisioningState | null> {
+    if (!existsSync(this.provisioningStatePath)) {
+      return null
+    }
+
+    try {
+      const content = await readFile(this.provisioningStatePath, 'utf-8')
+      const state = JSON.parse(content) as TelegramProvisioningState
+      const createdAtMs = new Date(state.created_at).getTime()
+      const age = Date.now() - createdAtMs
+      if (!Number.isFinite(createdAtMs) || age > PROVISIONING_STATE_TTL_MS) {
+        await this.clearProvisioningState()
+        return null
+      }
+      return state
+    } catch {
+      return null
+    }
+  }
+
+  async clearProvisioningState(): Promise<void> {
+    if (existsSync(this.provisioningStatePath)) {
+      await rm(this.provisioningStatePath, { force: true })
+    }
+  }
+
+  getAccountPaths(accountId: string): TelegramAccountPaths {
+    const safeAccountId = createAccountId(accountId)
+    const accountDir = join(this.tdlibRootDir, safeAccountId)
+
+    return {
+      account_dir: accountDir,
+      database_dir: join(accountDir, 'db'),
+      files_dir: join(accountDir, 'files'),
+    }
+  }
+
+  async ensureAccountPaths(accountId: string): Promise<TelegramAccountPaths> {
+    const paths = this.getAccountPaths(accountId)
+    await mkdir(paths.database_dir, { recursive: true })
+    await mkdir(paths.files_dir, { recursive: true })
+    return paths
+  }
+}