agent-messenger 1.15.0 → 2.0.0

package/src/tui/adapters/slack-adapter.ts

@@ -0,0 +1,128 @@
+import { SlackClient } from '@/platforms/slack/client'
+import { SlackCredentialManager } from '@/platforms/slack/credential-manager'
+import { SlackListener } from '@/platforms/slack/listener'
+import type { SlackRTMMessageEvent } from '@/platforms/slack/types'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class SlackAdapter implements PlatformAdapter {
+  readonly name = 'Slack'
+
+  private client: SlackClient | null = null
+  private listener: SlackListener | null = null
+  private userMap: Map<string, string> = new Map()
+  private credManager = new SlackCredentialManager()
+  private currentWorkspace: Workspace | null = null
+
+  async login(): Promise<void> {
+    const client = new SlackClient()
+    await client.login()
+    await this.buildUserMap(client)
+
+    const config = await this.credManager.load()
+    if (config.current_workspace && config.workspaces[config.current_workspace]) {
+      const ws = config.workspaces[config.current_workspace]
+      this.currentWorkspace = { id: ws.workspace_id, name: ws.workspace_name }
+    }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    const channels = await client.listChannels()
+    return channels.map((ch) => ({ id: ch.id, name: '#' + ch.name }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    const messages = await client.getMessages(channelId, limit)
+    return messages
+      .map((msg) => ({
+        id: msg.ts,
+        channelId,
+        author: this.userMap.get(msg.user ?? '') || msg.username || msg.user || 'unknown',
+        content: msg.text,
+        timestamp: msg.ts,
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    const client = this.ensureClient()
+    await client.sendMessage(channelId, text)
+  }
+
+  async startListening(onMessage: (msg: UnifiedMessage) => void): Promise<void> {
+    const client = this.ensureClient()
+    const listener = new SlackListener(client)
+    await listener.start()
+    listener.on('message', (event: SlackRTMMessageEvent) => {
+      if (event.subtype) return
+      onMessage({
+        id: event.ts,
+        channelId: event.channel,
+        author: this.userMap.get(event.user ?? '') || event.user || 'unknown',
+        content: event.text ?? '',
+        timestamp: event.ts,
+      })
+    })
+    this.listener = listener
+  }
+
+  stopListening(): void {
+    this.listener?.stop()
+    this.listener = null
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    const config = await this.credManager.load()
+    return Object.values(config.workspaces).map((ws) => ({
+      id: ws.workspace_id,
+      name: ws.workspace_name,
+    }))
+  }
+
+  async switchWorkspace(workspaceId: string): Promise<void> {
+    this.stopListening()
+    const creds = await this.credManager.getWorkspace(workspaceId)
+    if (!creds) throw new Error(`Workspace ${workspaceId} not found`)
+
+    const client = new SlackClient()
+    await client.login({ token: creds.token, cookie: creds.cookie })
+    await this.buildUserMap(client)
+    await this.credManager.setCurrentWorkspace(workspaceId)
+    this.currentWorkspace = { id: creds.workspace_id, name: creds.workspace_name }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentWorkspace
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-slack auth extract',
+      description: 'Log in to the Slack desktop app, then run the command below to extract credentials.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    io.print('Extracting credentials from Slack desktop app...')
+    await this.login()
+  }
+
+  private async buildUserMap(client: SlackClient): Promise<void> {
+    this.client = client
+    const users = await client.listUsers()
+    const map = new Map<string, string>()
+    for (const user of users) {
+      map.set(user.id, user.real_name || user.name)
+    }
+    this.userMap = map
+  }
+
+  private ensureClient(): SlackClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}

package/src/tui/adapters/teams-adapter.ts

@@ -0,0 +1,95 @@
+import { TeamsClient } from '@/platforms/teams/client'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class TeamsAdapter implements PlatformAdapter {
+  readonly name = 'Teams'
+
+  private client: TeamsClient | null = null
+  private teamId: string | null = null
+  private teamName: string | null = null
+  private teams: Workspace[] = []
+
+  async login(): Promise<void> {
+    this.client = new TeamsClient()
+    await this.client.login()
+    const teams = await this.client.listTeams()
+    if (!teams.length) throw new Error('No Teams found')
+    this.teams = teams.map((t) => ({ id: t.id, name: t.name }))
+    this.teamId = teams[0].id
+    this.teamName = teams[0].name
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    this.ensureClient()
+    const channels = await this.client!.listChannels(this.teamId!)
+    return channels.map((ch) => ({
+      id: ch.id,
+      name: ch.name,
+      parentId: this.teamId!,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    this.ensureClient()
+    const messages = await this.client!.getMessages(this.teamId!, channelId, limit)
+    return messages
+      .map((msg) => ({
+        id: msg.id,
+        channelId,
+        author: msg.author.displayName || 'unknown',
+        content: this.stripHtml(msg.content),
+        timestamp: msg.timestamp,
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    this.ensureClient()
+    await this.client!.sendMessage(this.teamId!, channelId, text)
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    return this.teams
+  }
+
+  async switchWorkspace(teamId: string): Promise<void> {
+    const team = this.teams.find((t) => t.id === teamId)
+    if (!team) throw new Error(`Team ${teamId} not found`)
+    this.teamId = team.id
+    this.teamName = team.name
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    if (!this.teamId || !this.teamName) return null
+    return { id: this.teamId, name: this.teamName }
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-teams auth extract',
+      description: 'Log in to the Microsoft Teams desktop app, then run the command below to extract credentials.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    io.print('Extracting credentials from Microsoft Teams desktop app...')
+    await this.login()
+  }
+
+  private ensureClient(): void {
+    if (!this.client || !this.teamId) throw new Error('Not logged in')
+  }
+
+  private stripHtml(html: string): string {
+    return html
+      .replace(/<[^>]*>/g, '')
+      .replace(/&amp;/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/\s+/g, ' ')
+      .trim()
+  }
+}

package/src/tui/adapters/telegram-adapter.ts

@@ -0,0 +1,203 @@
+import { TelegramCredentialManager } from '@/platforms/telegram/credential-manager'
+import { TelegramTdlibClient } from '@/platforms/telegram/client'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class TelegramAdapter implements PlatformAdapter {
+  readonly name = 'Telegram'
+
+  private client: TelegramTdlibClient | null = null
+  private credManager = new TelegramCredentialManager()
+  private currentAccount: Workspace | null = null
+
+  async login(): Promise<void> {
+    const account = await this.credManager.getAccount()
+    if (!account) throw new Error('No Telegram credentials found')
+
+    const paths = this.credManager.getAccountPaths(account.account_id)
+    const client = await TelegramTdlibClient.create(account, paths)
+
+    try {
+      const state = await client.connect()
+      if (state?.['@type'] !== 'authorizationStateReady') {
+        throw new Error('Telegram account not authenticated')
+      }
+    } catch (err) {
+      await client.close().catch(() => {})
+      throw err
+    }
+
+    this.client = client
+    this.currentAccount = { id: account.account_id, name: account.phone_number ?? account.account_id }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    const chats = await client.listChats(50)
+    return chats.map((chat) => ({
+      id: String(chat.id),
+      name: chat.title,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    const messages = await client.listMessages(channelId, limit)
+    return messages
+      .map((msg) => ({
+        id: String(msg.id),
+        channelId: String(msg.chat_id),
+        author: msg.sender.id ? String(msg.sender.id) : 'unknown',
+        content: msg.text ?? '',
+        timestamp: msg.date,
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    const client = this.ensureClient()
+    await client.sendMessage(channelId, text)
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    const accounts = await this.credManager.listAccounts()
+    return accounts.map((acct) => ({
+      id: acct.account_id,
+      name: acct.phone_number ?? acct.account_id,
+    }))
+  }
+
+  async switchWorkspace(accountId: string): Promise<void> {
+    if (this.client) {
+      await this.client.close().catch(() => {})
+      this.client = null
+    }
+
+    const account = await this.credManager.getAccount(accountId)
+    if (!account) throw new Error(`Account ${accountId} not found`)
+
+    const paths = this.credManager.getAccountPaths(account.account_id)
+    const client = await TelegramTdlibClient.create(account, paths)
+
+    try {
+      const state = await client.connect()
+      if (state?.['@type'] !== 'authorizationStateReady') {
+        throw new Error('Telegram account not authenticated')
+      }
+    } catch (err) {
+      await client.close().catch(() => {})
+      throw err
+    }
+
+    this.client = client
+    this.currentAccount = { id: account.account_id, name: account.phone_number ?? account.account_id }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentAccount
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-telegram auth login',
+      description: 'Run the command below and follow the interactive login flow with your phone number.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const { getTelegramAppCredentials } = await import('@/platforms/telegram/app-config')
+    const { provisionTelegramApp } = await import('@/platforms/telegram/my-telegram-org')
+    const { createAccountId } = await import('@/platforms/telegram/types')
+
+    const existing = await this.credManager.getAccount()
+    const defaults = getTelegramAppCredentials()
+    let apiId = existing?.api_id ?? defaults.api_id
+    let apiHash = existing?.api_hash ?? defaults.api_hash
+
+    const phone = await io.prompt('Phone number (e.g. +14155551234)')
+    if (!phone) throw new Error('Phone number is required')
+
+    if (!apiId || !apiHash) {
+      io.print('Provisioning API credentials via my.telegram.org...')
+      io.print('A verification code will be sent to your Telegram account.')
+      try {
+        const app = await provisionTelegramApp({
+          phone,
+          promptForCode: async () => {
+            const code = await io.prompt('Provisioning code (sent to your Telegram app)')
+            if (!code) throw new Error('Code is required')
+            return code
+          },
+        })
+        apiId = app.api_id
+        apiHash = app.api_hash
+        io.print('API credentials obtained.')
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err)
+        io.print(`Auto-provisioning failed: ${detail}`)
+        io.print('Enter credentials manually from https://my.telegram.org/apps')
+        const idStr = await io.prompt('API ID')
+        apiId = Number.parseInt(idStr, 10)
+        if (!apiId || !Number.isFinite(apiId)) throw new Error('Invalid API ID')
+        apiHash = await io.prompt('API hash')
+        if (!apiHash) throw new Error('API hash is required')
+      }
+    }
+
+    const accountId = createAccountId(phone)
+    const now = new Date().toISOString()
+    const account = {
+      account_id: accountId,
+      api_id: apiId,
+      api_hash: apiHash,
+      phone_number: phone,
+      created_at: now,
+      updated_at: now,
+    }
+
+    await this.credManager.setAccount(account)
+    await this.credManager.setCurrent(accountId)
+    const paths = this.credManager.getAccountPaths(accountId)
+
+    const client = await TelegramTdlibClient.create(account, paths)
+
+    try {
+      let result = await client.login({ phone_number: phone })
+
+      while (!result.authenticated && result.next_action) {
+        switch (result.next_action) {
+          case 'provide_code': {
+            const code = await io.prompt('Verification code')
+            result = await client.login({ phone_number: phone, code })
+            break
+          }
+          case 'provide_password': {
+            const hint = result.hint ? ` (hint: ${result.hint})` : ''
+            const password = await io.prompt(`2FA password${hint}`, { secret: true })
+            result = await client.login({ phone_number: phone, password })
+            break
+          }
+          default:
+            throw new Error(`Unexpected auth step: ${result.next_action}`)
+        }
+      }
+
+      if (!result.authenticated) {
+        throw new Error('Authentication did not complete')
+      }
+
+      this.client = client
+      this.currentAccount = { id: accountId, name: phone }
+    } catch (err) {
+      await client.close().catch(() => {})
+      throw err
+    }
+  }
+
+  private ensureClient(): TelegramTdlibClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}

package/src/tui/adapters/types.ts

@@ -0,0 +1,43 @@
+export interface UnifiedChannel {
+  id: string
+  name: string
+  parentId?: string
+}
+
+export interface UnifiedMessage {
+  id: string
+  channelId: string
+  author: string
+  content: string
+  timestamp: string
+}
+
+export interface Workspace {
+  id: string
+  name: string
+}
+
+export interface AuthHint {
+  command: string
+  description: string
+}
+
+export interface AuthIO {
+  print(message: string): void
+  prompt(label: string, options?: { secret?: boolean }): Promise<string>
+}
+
+export interface PlatformAdapter {
+  readonly name: string
+  login(): Promise<void>
+  getChannels(): Promise<UnifiedChannel[]>
+  getMessages(channelId: string, limit?: number): Promise<UnifiedMessage[]>
+  sendMessage(channelId: string, text: string): Promise<void>
+  startListening?(onMessage: (msg: UnifiedMessage) => void): Promise<void>
+  stopListening?(): void
+  getWorkspaces?(): Promise<Workspace[]>
+  switchWorkspace?(workspaceId: string): Promise<void>
+  getCurrentWorkspace?(): Workspace | null
+  getAuthHint(): AuthHint
+  authenticate(io: AuthIO): Promise<void>
+}

package/src/tui/adapters/whatsapp-adapter.ts

@@ -0,0 +1,138 @@
+import { WhatsAppClient } from '@/platforms/whatsapp/client'
+import { WhatsAppCredentialManager } from '@/platforms/whatsapp/credential-manager'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class WhatsAppAdapter implements PlatformAdapter {
+  readonly name = 'WhatsApp'
+
+  private client: WhatsAppClient | null = null
+  private credManager = new WhatsAppCredentialManager()
+  private currentAccount: Workspace | null = null
+
+  async login(): Promise<void> {
+    const client = new WhatsAppClient()
+    await client.login()
+    await client.connect()
+    this.client = client
+
+    const config = await this.credManager.loadConfig()
+    if (config.current && config.accounts[config.current]) {
+      const acct = config.accounts[config.current]
+      this.currentAccount = { id: acct.account_id, name: acct.phone_number ?? acct.account_id }
+    }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    const chats = await client.listChats(50)
+    return chats.map((chat) => ({
+      id: chat.id,
+      name: chat.name || chat.id,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    const messages = await client.getMessages(channelId, limit)
+    return messages.map((msg) => ({
+      id: msg.id,
+      channelId,
+      author: msg.is_outgoing ? 'you' : (msg.from_name ?? msg.from ?? 'unknown'),
+      content: msg.text ?? '',
+      timestamp: msg.timestamp,
+    }))
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    const client = this.ensureClient()
+    await client.sendMessage(channelId, text)
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    const accounts = await this.credManager.listAccounts()
+    return accounts.map((acct) => ({
+      id: acct.account_id,
+      name: acct.phone_number ?? acct.account_id,
+    }))
+  }
+
+  async switchWorkspace(accountId: string): Promise<void> {
+    if (this.client) {
+      await this.client.close().catch(() => {})
+      this.client = null
+    }
+
+    const account = await this.credManager.getAccount(accountId)
+    if (!account) throw new Error(`Account ${accountId} not found`)
+
+    const paths = this.credManager.getAccountPaths(account.account_id)
+    const client = new WhatsAppClient()
+    await client.login({ authDir: paths.auth_dir })
+    await client.connect()
+    this.client = client
+    this.currentAccount = { id: account.account_id, name: account.phone_number ?? account.account_id }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentAccount
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-whatsapp auth login',
+      description: 'Run the command below and link your WhatsApp account using the pairing code.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const { createAccountId } = await import('@/platforms/whatsapp/types')
+
+    const phone = await io.prompt('Phone number (e.g. +12025551234)')
+    if (!phone) throw new Error('Phone number is required')
+
+    io.print('Connecting...')
+    const accountId = createAccountId(phone)
+    const paths = await this.credManager.ensureAccountPaths(accountId)
+    const client = await new WhatsAppClient().login({ authDir: paths.auth_dir })
+
+    let waitForAuth: () => Promise<void>
+    try {
+      const result = await client.connectForPairing(phone)
+      waitForAuth = result.waitForAuth
+      const formatted = result.code.length === 8 ? `${result.code.slice(0, 4)}-${result.code.slice(4)}` : result.code
+      io.print(`Pairing code: ${formatted}`)
+      io.print('Enter this code in WhatsApp > Linked Devices > Link with phone number')
+    } catch (err) {
+      await client.close()
+      throw err
+    }
+
+    io.print('Waiting for confirmation...')
+    try {
+      await waitForAuth()
+    } catch (err) {
+      await client.close()
+      throw err
+    }
+
+    const now = new Date().toISOString()
+    await this.credManager.setAccount({
+      account_id: accountId,
+      phone_number: phone,
+      created_at: now,
+      updated_at: now,
+    })
+    await this.credManager.setCurrent(accountId)
+
+    this.client = client
+    this.currentAccount = { id: accountId, name: phone }
+  }
+
+  private ensureClient(): WhatsAppClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}