agent-messenger 2.12.0 → 2.12.1

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

@@ -0,0 +1,220 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+import { formatOutput } from '@/shared/utils/output'
+
+import { TelegramBotClient } from '../client'
+import { TelegramBotCredentialManager } from '../credential-manager'
+import type { ClientFactory } from './shared'
+
+interface ActionOptions {
+  pretty?: boolean
+  bot?: string
+  _credManager?: TelegramBotCredentialManager
+  _clientFactory?: ClientFactory
+}
+
+interface ActionResult {
+  success?: boolean
+  error?: string
+  bot_id?: string
+  bot_name?: string
+  username?: string
+  valid?: boolean
+  bots?: Array<{
+    bot_id: string
+    bot_name: string
+    is_current: boolean
+  }>
+}
+
+export async function setAction(token: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const client = options._clientFactory ? options._clientFactory() : new TelegramBotClient()
+    await client.login({ token })
+    const me = await client.getMe()
+
+    if (!me.is_bot) {
+      return { error: 'Token does not belong to a bot account.' }
+    }
+
+    const botId = options.bot || me.username || String(me.id)
+    const botName = me.username ?? me.first_name
+
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    await credManager.setCredentials({
+      token,
+      bot_id: botId,
+      bot_name: botName,
+    })
+
+    return {
+      success: true,
+      bot_id: botId,
+      bot_name: botName,
+      username: me.username,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function clearAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    await credManager.clearCredentials()
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function statusAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    const creds = await credManager.getCredentials(options.bot)
+
+    if (!creds) {
+      return {
+        valid: false,
+        error: options.bot
+          ? `Bot "${options.bot}" not found. Run "auth list" to see available bots.`
+          : 'No credentials configured. Run "auth set <token>" first.',
+      }
+    }
+
+    let valid = false
+    let botName = creds.bot_name
+    let username: string | undefined
+
+    try {
+      const client = options._clientFactory ? options._clientFactory() : new TelegramBotClient()
+      await client.login({ token: creds.token })
+      const me = await client.getMe()
+      valid = me.is_bot === true
+      botName = me.username ?? me.first_name
+      username = me.username
+    } catch {
+      valid = false
+    }
+
+    return {
+      valid,
+      bot_id: creds.bot_id,
+      bot_name: botName,
+      username,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function listAction(options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    const all = await credManager.listAll()
+
+    return {
+      bots: all.map((b) => ({
+        bot_id: b.bot_id,
+        bot_name: b.bot_name,
+        is_current: b.is_current,
+      })),
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function useAction(botId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    const found = await credManager.setCurrent(botId)
+
+    if (!found) {
+      return { error: `Bot "${botId}" not found. Run "auth list" to see available bots.` }
+    }
+
+    const creds = await credManager.getCredentials()
+    return {
+      success: true,
+      bot_id: creds?.bot_id,
+      bot_name: creds?.bot_name,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function removeAction(botId: string, options: ActionOptions): Promise<ActionResult> {
+  try {
+    const credManager = options._credManager ?? new TelegramBotCredentialManager()
+    const removed = await credManager.removeBot(botId)
+
+    if (!removed) {
+      return { error: `Bot "${botId}" not found. Run "auth list" to see available bots.` }
+    }
+
+    return { success: true }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const authCommand = new Command('auth')
+  .description('Bot authentication commands')
+  .addCommand(
+    new Command('set')
+      .description('Set bot token (validates against Telegram API)')
+      .argument('<token>', 'Bot token from @BotFather')
+      .option('--bot <id>', 'Bot identifier for switching later')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (token: string, opts: { bot?: string; pretty?: boolean }) => {
+        cliOutput(await setAction(token, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('clear')
+      .description('Clear all stored credentials')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await clearAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('status')
+      .description('Show authentication status')
+      .option('--bot <id>', 'Check specific bot (default: current)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { bot?: string; pretty?: boolean }) => {
+        const result = await statusAction(opts)
+        console.log(formatOutput(result, opts.pretty))
+        if (!result.valid) process.exit(1)
+      }),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List all stored bots')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (opts: { pretty?: boolean }) => {
+        cliOutput(await listAction(opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('use')
+      .description('Switch active bot')
+      .argument('<bot>', 'Bot ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (botId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await useAction(botId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove a stored bot')
+      .argument('<bot>', 'Bot ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (botId: string, opts: { pretty?: boolean }) => {
+        cliOutput(await removeAction(botId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,96 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotOption } from './shared'
+import { getClient, parseChatId } from './shared'
+
+interface ChatResult {
+  id?: number
+  type?: string
+  title?: string
+  username?: string
+  first_name?: string
+  last_name?: string
+  description?: string
+  invite_link?: string
+  member_count?: number
+  is_forum?: boolean
+  member?: {
+    user_id: number
+    username?: string
+    status: string
+  }
+  error?: string
+}
+
+export async function infoAction(chat: string, options: BotOption): Promise<ChatResult> {
+  try {
+    const client = await getClient(options)
+    const info = await client.getChat(parseChatId(chat))
+
+    let memberCount = info.member_count
+    if (memberCount === undefined && (info.type === 'group' || info.type === 'supergroup' || info.type === 'channel')) {
+      try {
+        memberCount = await client.getChatMemberCount(info.id)
+      } catch {
+        memberCount = undefined
+      }
+    }
+
+    return {
+      id: info.id,
+      type: info.type,
+      title: info.title,
+      username: info.username,
+      first_name: info.first_name,
+      last_name: info.last_name,
+      description: info.description,
+      invite_link: info.invite_link,
+      member_count: memberCount,
+      is_forum: info.is_forum,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function memberAction(chat: string, userId: string, options: BotOption): Promise<ChatResult> {
+  try {
+    const client = await getClient(options)
+    const member = await client.getChatMember(parseChatId(chat), Number(userId))
+    return {
+      member: {
+        user_id: member.user.id,
+        username: member.user.username,
+        status: member.status,
+      },
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const chatCommand = new Command('chat')
+  .description('Chat commands')
+  .addCommand(
+    new Command('info')
+      .description('Get chat information')
+      .argument('<chat>', 'Chat ID or @username')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (chat: string, opts: BotOption) => {
+        cliOutput(await infoAction(chat, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('member')
+      .description('Get chat member info')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<user-id>', 'User ID (numeric)')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (chat: string, userId: string, opts: BotOption) => {
+        cliOutput(await memberAction(chat, userId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,5 @@
+export { authCommand } from './auth'
+export { chatCommand } from './chat'
+export { messageCommand } from './message'
+export { reactionCommand } from './reaction'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,235 @@
+import { resolve } from 'node:path'
+
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { TelegramMessage } from '../types'
+import type { BotOption } from './shared'
+import { getClient, parseChatId } from './shared'
+
+interface MessageOutput {
+  message_id: number
+  chat_id: number
+  text?: string
+  from?: string
+  date: number
+  edit_date?: number
+  reply_to?: number
+}
+
+interface MessageResult {
+  message?: MessageOutput
+  deleted?: number
+  error?: string
+}
+
+function formatMessage(msg: TelegramMessage): MessageOutput {
+  const fromName = msg.from?.username ?? msg.from?.first_name ?? msg.sender_chat?.title
+  return {
+    message_id: msg.message_id,
+    chat_id: msg.chat.id,
+    text: msg.text ?? msg.caption,
+    from: fromName,
+    date: msg.date,
+    edit_date: msg.edit_date,
+    reply_to: msg.reply_to_message?.message_id,
+  }
+}
+
+export async function sendAction(
+  chat: string,
+  text: string,
+  options: BotOption & {
+    parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2'
+    replyTo?: string
+    silent?: boolean
+    threadId?: string
+  },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendMessage(parseChatId(chat), text, {
+      parse_mode: options.parseMode,
+      reply_to_message_id: options.replyTo ? Number(options.replyTo) : undefined,
+      disable_notification: options.silent,
+      message_thread_id: options.threadId ? Number(options.threadId) : undefined,
+    })
+    return { message: formatMessage(message) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function updateAction(
+  chat: string,
+  messageId: string,
+  text: string,
+  options: BotOption & { parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const result = await client.editMessageText({ chat_id: parseChatId(chat), message_id: Number(messageId) }, text, {
+      parse_mode: options.parseMode,
+    })
+    if (result === true) {
+      return { error: 'editMessageText returned true; expected a Message object for chat-message edits.' }
+    }
+    return { message: formatMessage(result) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function deleteAction(
+  chat: string,
+  messageId: string,
+  options: BotOption & { force?: boolean },
+): Promise<MessageResult> {
+  if (!options.force) {
+    return { error: 'Use --force to confirm deletion' }
+  }
+  try {
+    const client = await getClient(options)
+    await client.deleteMessage(parseChatId(chat), Number(messageId))
+    return { deleted: Number(messageId) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function forwardAction(
+  toChat: string,
+  fromChat: string,
+  messageId: string,
+  options: BotOption & { silent?: boolean; threadId?: string },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.forwardMessage(parseChatId(toChat), parseChatId(fromChat), Number(messageId), {
+      disable_notification: options.silent,
+      message_thread_id: options.threadId ? Number(options.threadId) : undefined,
+    })
+    return { message: formatMessage(message) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function uploadAction(
+  chat: string,
+  filePath: string,
+  options: BotOption & { caption?: string; parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
+): Promise<MessageResult> {
+  try {
+    const client = await getClient(options)
+    const message = await client.sendDocument(parseChatId(chat), resolve(filePath), {
+      caption: options.caption,
+      parse_mode: options.parseMode,
+    })
+    return { message: formatMessage(message) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const messageCommand = new Command('message')
+  .description('Message commands')
+  .addCommand(
+    new Command('send')
+      .description('Send a text message')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<text>', 'Message text')
+      .option('--parse-mode <mode>', 'Parse mode: HTML | Markdown | MarkdownV2')
+      .option('--reply-to <id>', 'Reply to message ID')
+      .option('--silent', 'Send silently (no notification)')
+      .option('--thread-id <id>', 'Forum topic thread ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(
+        async (
+          chat: string,
+          text: string,
+          opts: BotOption & {
+            parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2'
+            replyTo?: string
+            silent?: boolean
+            threadId?: string
+          },
+        ) => {
+          cliOutput(await sendAction(chat, text, opts), opts.pretty)
+        },
+      ),
+  )
+  .addCommand(
+    new Command('update')
+      .description("Edit a message (bot's own messages only)")
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<message-id>', 'Message ID')
+      .argument('<text>', 'New message text')
+      .option('--parse-mode <mode>', 'Parse mode: HTML | Markdown | MarkdownV2')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(
+        async (
+          chat: string,
+          messageId: string,
+          text: string,
+          opts: BotOption & { parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
+        ) => {
+          cliOutput(await updateAction(chat, messageId, text, opts), opts.pretty)
+        },
+      ),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a message')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<message-id>', 'Message ID')
+      .option('--force', 'Confirm deletion')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (chat: string, messageId: string, opts: BotOption & { force?: boolean }) => {
+        cliOutput(await deleteAction(chat, messageId, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('forward')
+      .description('Forward a message from one chat to another')
+      .argument('<to-chat>', 'Destination chat ID or @username')
+      .argument('<from-chat>', 'Source chat ID or @username')
+      .argument('<message-id>', 'Message ID to forward')
+      .option('--silent', 'Forward silently')
+      .option('--thread-id <id>', 'Destination forum topic thread ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(
+        async (
+          toChat: string,
+          fromChat: string,
+          messageId: string,
+          opts: BotOption & { silent?: boolean; threadId?: string },
+        ) => {
+          cliOutput(await forwardAction(toChat, fromChat, messageId, opts), opts.pretty)
+        },
+      ),
+  )
+  .addCommand(
+    new Command('upload')
+      .description('Upload a document to a chat')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<file-path>', 'File path')
+      .option('--caption <text>', 'Caption for the document')
+      .option('--parse-mode <mode>', 'Caption parse mode: HTML | Markdown | MarkdownV2')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(
+        async (
+          chat: string,
+          filePath: string,
+          opts: BotOption & { caption?: string; parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2' },
+        ) => {
+          cliOutput(await uploadAction(chat, filePath, opts), opts.pretty)
+        },
+      ),
+  )

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

@@ -0,0 +1,70 @@
+import { Command } from 'commander'
+
+import { cliOutput } from '@/shared/utils/cli-output'
+
+import type { BotReactionType } from '../client'
+import type { BotOption } from './shared'
+import { getClient, parseChatId } from './shared'
+
+interface ReactionResult {
+  success?: boolean
+  chat_id?: number | string
+  message_id?: number
+  emoji?: string
+  error?: string
+}
+
+export async function setAction(
+  chat: string,
+  messageId: string,
+  emoji: string,
+  options: BotOption & { big?: boolean },
+): Promise<ReactionResult> {
+  try {
+    const client = await getClient(options)
+    const reaction: BotReactionType[] = [{ type: 'emoji', emoji }]
+    await client.setMessageReaction(parseChatId(chat), Number(messageId), reaction, {
+      is_big: options.big,
+    })
+    return { success: true, chat_id: parseChatId(chat), message_id: Number(messageId), emoji }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export async function clearAction(chat: string, messageId: string, options: BotOption): Promise<ReactionResult> {
+  try {
+    const client = await getClient(options)
+    await client.setMessageReaction(parseChatId(chat), Number(messageId), [])
+    return { success: true, chat_id: parseChatId(chat), message_id: Number(messageId) }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+export const reactionCommand = new Command('reaction')
+  .description('Reaction commands')
+  .addCommand(
+    new Command('set')
+      .description('Set a reaction on a message (replaces existing)')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<message-id>', 'Message ID')
+      .argument('<emoji>', 'Emoji (e.g. 👍)')
+      .option('--big', 'Show big animation for the reaction')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (chat: string, messageId: string, emoji: string, opts: BotOption & { big?: boolean }) => {
+        cliOutput(await setAction(chat, messageId, emoji, opts), opts.pretty)
+      }),
+  )
+  .addCommand(
+    new Command('clear')
+      .description('Clear all reactions from a message')
+      .argument('<chat>', 'Chat ID or @username')
+      .argument('<message-id>', 'Message ID')
+      .option('--bot <id>', 'Use specific bot')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (chat: string, messageId: string, opts: BotOption) => {
+        cliOutput(await clearAction(chat, messageId, opts), opts.pretty)
+      }),
+  )

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

@@ -0,0 +1,32 @@
+import { formatOutput } from '@/shared/utils/output'
+
+import { TelegramBotClient } from '../client'
+import { TelegramBotCredentialManager } from '../credential-manager'
+
+export type ClientFactory = () => TelegramBotClient
+
+export interface BotOption {
+  bot?: string
+  pretty?: boolean
+  _credManager?: TelegramBotCredentialManager
+  _clientFactory?: ClientFactory
+}
+
+export async function getClient(options: BotOption): Promise<TelegramBotClient> {
+  const credManager = options._credManager ?? new TelegramBotCredentialManager()
+  const creds = await credManager.getCredentials(options.bot)
+
+  if (!creds) {
+    console.log(formatOutput({ error: 'No credentials. Run "auth set <token>" first.' }, options.pretty))
+    process.exit(1)
+  }
+
+  const client = options._clientFactory ? options._clientFactory() : new TelegramBotClient()
+  return client.login({ token: creds.token })
+}
+
+export function parseChatId(chat: string): number | string {
+  if (/^-?\d+$/.test(chat)) return Number(chat)
+  if (chat.startsWith('@')) return chat
+  return `@${chat}`
+}