agent-messenger 2.12.0 → 2.12.1

package/src/platforms/telegrambot/commands/whoami.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: number
+  username?: string
+  first_name?: string
+  last_name?: string
+  is_bot?: boolean
+  can_join_groups?: boolean
+  can_read_all_group_messages?: boolean
+  supports_inline_queries?: boolean
+  error?: string
+}
+
+export async function whoamiAction(options: BotOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const me = await client.getMe()
+    return {
+      id: me.id,
+      username: me.username,
+      first_name: me.first_name,
+      last_name: me.last_name,
+      is_bot: me.is_bot,
+      can_join_groups: me.can_join_groups,
+      can_read_all_group_messages: me.can_read_all_group_messages,
+      supports_inline_queries: me.supports_inline_queries,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--bot <id>', 'Bot ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: BotOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

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

@@ -0,0 +1,196 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { TelegramBotCredentialManager } from './credential-manager'
+
+const CREDS_A = {
+  token: '123456789:ABC-A',
+  bot_id: 'bot-a',
+  bot_name: 'Bot A',
+}
+
+const CREDS_B = {
+  token: '987654321:XYZ-B',
+  bot_id: 'bot-b',
+  bot_name: 'Bot B',
+}
+
+describe('TelegramBotCredentialManager', () => {
+  let tempDir: string
+  let manager: TelegramBotCredentialManager
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `telegrambot-cred-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    await mkdir(tempDir, { recursive: true })
+    manager = new TelegramBotCredentialManager(tempDir)
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    delete process.env.E2E_TELEGRAMBOT_TOKEN
+  })
+
+  describe('load', () => {
+    it('returns empty config when no file exists', async () => {
+      const config = await manager.load()
+      expect(config.current).toBeNull()
+      expect(config.bots).toEqual({})
+    })
+  })
+
+  describe('save and load', () => {
+    it('persists config to file', async () => {
+      const config = {
+        current: { bot_id: 'bot-a' },
+        bots: {
+          'bot-a': { bot_id: 'bot-a', bot_name: 'Bot A', token: '123:abc' },
+        },
+      }
+      await manager.save(config)
+      const loaded = await manager.load()
+      expect(loaded).toEqual(config)
+    })
+  })
+
+  describe('getCredentials', () => {
+    it('returns null when no credentials exist', async () => {
+      expect(await manager.getCredentials()).toBeNull()
+    })
+
+    it('returns current bot credentials', async () => {
+      await manager.setCredentials(CREDS_A)
+      const creds = await manager.getCredentials()
+      expect(creds).toEqual(CREDS_A)
+    })
+
+    it('returns specific bot by id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      const creds = await manager.getCredentials('bot-a')
+      expect(creds).toEqual(CREDS_A)
+    })
+
+    it('returns null for non-existent bot id', async () => {
+      await manager.setCredentials(CREDS_A)
+      const creds = await manager.getCredentials('nope')
+      expect(creds).toBeNull()
+    })
+
+    it('env var takes precedence when no botId specified', async () => {
+      await manager.setCredentials(CREDS_A)
+      process.env.E2E_TELEGRAMBOT_TOKEN = 'env-token'
+      const creds = await manager.getCredentials()
+      expect(creds?.token).toBe('env-token')
+      expect(creds?.bot_id).toBe('env')
+    })
+
+    it('env var ignored when botId explicitly provided', async () => {
+      await manager.setCredentials(CREDS_A)
+      process.env.E2E_TELEGRAMBOT_TOKEN = 'env-token'
+      const creds = await manager.getCredentials('bot-a')
+      expect(creds?.token).toBe(CREDS_A.token)
+    })
+  })
+
+  describe('setCredentials', () => {
+    it('stores bot and sets as current', async () => {
+      await manager.setCredentials(CREDS_A)
+      const config = await manager.load()
+      expect(config.current).toEqual({ bot_id: 'bot-a' })
+      expect(config.bots['bot-a'].token).toBe(CREDS_A.token)
+    })
+
+    it('stores multiple bots', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      const config = await manager.load()
+      expect(Object.keys(config.bots).sort()).toEqual(['bot-a', 'bot-b'])
+      expect(config.current).toEqual({ bot_id: 'bot-b' })
+    })
+
+    it('overwrites existing bot with same id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials({ ...CREDS_A, bot_name: 'Updated' })
+      const config = await manager.load()
+      expect(Object.keys(config.bots)).toHaveLength(1)
+      expect(config.bots['bot-a'].bot_name).toBe('Updated')
+    })
+  })
+
+  describe('listAll', () => {
+    it('returns all bots with current flag', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      const all = await manager.listAll()
+      expect(all).toHaveLength(2)
+      expect(all.find((b) => b.bot_id === 'bot-a')?.is_current).toBe(false)
+      expect(all.find((b) => b.bot_id === 'bot-b')?.is_current).toBe(true)
+    })
+
+    it('returns empty array when no bots exist', async () => {
+      expect(await manager.listAll()).toEqual([])
+    })
+  })
+
+  describe('setCurrent', () => {
+    it('switches current bot', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      const switched = await manager.setCurrent('bot-a')
+      expect(switched).toBe(true)
+      const creds = await manager.getCredentials()
+      expect(creds?.bot_id).toBe('bot-a')
+    })
+
+    it('returns false for unknown bot', async () => {
+      expect(await manager.setCurrent('nope')).toBe(false)
+    })
+  })
+
+  describe('removeBot', () => {
+    it('removes a bot by id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      const removed = await manager.removeBot('bot-a')
+      expect(removed).toBe(true)
+      const config = await manager.load()
+      expect(Object.keys(config.bots)).toEqual(['bot-b'])
+    })
+
+    it('clears current when current bot removed', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.removeBot('bot-a')
+      const config = await manager.load()
+      expect(config.current).toBeNull()
+    })
+
+    it('returns false for unknown bot', async () => {
+      expect(await manager.removeBot('nope')).toBe(false)
+    })
+  })
+
+  describe('clearCredentials', () => {
+    it('removes all credentials', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+      await manager.clearCredentials()
+      const config = await manager.load()
+      expect(config.current).toBeNull()
+      expect(config.bots).toEqual({})
+    })
+  })
+
+  describe('file permissions', () => {
+    it('saves file with secure permissions (600)', async () => {
+      await manager.setCredentials(CREDS_A)
+      const credPath = join(tempDir, 'telegrambot-credentials.json')
+      const stats = await stat(credPath)
+      expect(stats.mode & 0o777).toBe(0o600)
+    })
+  })
+})

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

@@ -0,0 +1,141 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { getConfigDir } from '../../shared/utils/config-dir'
+import type { TelegramBotConfig, TelegramBotCredentials } from './types'
+import { TelegramBotConfigSchema } from './types'
+
+export class TelegramBotCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? getConfigDir()
+    this.credentialsPath = join(this.configDir, 'telegrambot-credentials.json')
+  }
+
+  async load(): Promise<TelegramBotConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, bots: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    const parsed = TelegramBotConfigSchema.safeParse(JSON.parse(content))
+    if (!parsed.success) {
+      return { current: null, bots: {} }
+    }
+    return parsed.data
+  }
+
+  async save(config: TelegramBotConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2), { mode: 0o600 })
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getCredentials(botId?: string): Promise<TelegramBotCredentials | null> {
+    const envToken = process.env.E2E_TELEGRAMBOT_TOKEN
+
+    if (envToken && !botId) {
+      return {
+        token: envToken,
+        bot_id: 'env',
+        bot_name: 'env',
+      }
+    }
+
+    const config = await this.load()
+
+    if (botId) {
+      const bot = config.bots[botId]
+      if (!bot) return null
+      return {
+        token: bot.token,
+        bot_id: bot.bot_id,
+        bot_name: bot.bot_name,
+      }
+    }
+
+    if (!config.current) {
+      return null
+    }
+
+    const bot = config.bots[config.current.bot_id]
+    if (!bot) return null
+
+    return {
+      token: bot.token,
+      bot_id: bot.bot_id,
+      bot_name: bot.bot_name,
+    }
+  }
+
+  async setCredentials(creds: TelegramBotCredentials): Promise<void> {
+    const config = await this.load()
+
+    config.bots[creds.bot_id] = {
+      bot_id: creds.bot_id,
+      bot_name: creds.bot_name,
+      token: creds.token,
+    }
+
+    config.current = {
+      bot_id: creds.bot_id,
+    }
+
+    await this.save(config)
+  }
+
+  async removeBot(botId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.bots[botId]) {
+      return false
+    }
+
+    delete config.bots[botId]
+
+    if (config.current?.bot_id === botId) {
+      config.current = null
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async setCurrent(botId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (!config.bots[botId]) {
+      return false
+    }
+
+    config.current = {
+      bot_id: botId,
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async listAll(): Promise<Array<TelegramBotCredentials & { is_current: boolean }>> {
+    const config = await this.load()
+    const results: Array<TelegramBotCredentials & { is_current: boolean }> = []
+
+    for (const bot of Object.values(config.bots)) {
+      results.push({
+        token: bot.token,
+        bot_id: bot.bot_id,
+        bot_name: bot.bot_name,
+        is_current: config.current?.bot_id === bot.bot_id,
+      })
+    }
+
+    return results
+  }
+
+  async clearCredentials(): Promise<void> {
+    await this.save({ current: null, bots: {} })
+  }
+}

package/src/platforms/telegrambot/index.ts

@@ -0,0 +1,44 @@
+export { TelegramBotClient } from './client'
+export type {
+  BotReactionType,
+  ChatId,
+  EditMessageTextChat,
+  EditMessageTextInline,
+  EditMessageTextTarget,
+  GetUpdatesOptions,
+  SendMessageOptions,
+} from './client'
+export { TelegramBotCredentialManager } from './credential-manager'
+export { TelegramBotListener } from './listener'
+export type {
+  TelegramBotConfig,
+  TelegramBotCredentials,
+  TelegramBotEntry,
+  TelegramBotListenerEventMap,
+  TelegramBotListenerOptions,
+  TelegramBotUser,
+  TelegramCallbackQuery,
+  TelegramChat,
+  TelegramChatFullInfo,
+  TelegramChatMember,
+  TelegramChatMemberUpdated,
+  TelegramDocument,
+  TelegramInlineQuery,
+  TelegramMessage,
+  TelegramMessageEntity,
+  TelegramPhotoSize,
+  TelegramReactionType,
+  TelegramUpdate,
+} from './types'
+export {
+  TelegramBotConfigSchema,
+  TelegramBotCredentialsSchema,
+  TelegramBotEntrySchema,
+  TelegramBotError,
+  TelegramBotUserSchema,
+  TelegramChatSchema,
+  TelegramDocumentSchema,
+  TelegramMessageEntitySchema,
+  TelegramMessageSchema,
+  TelegramPhotoSizeSchema,
+} from './types'