agent-messenger 1.14.0 → 2.0.0

package/src/platforms/whatsappbot/types.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod'
+
+export interface WhatsAppBotAccountEntry {
+  phone_number_id: string
+  account_name: string
+  access_token: string
+}
+
+export interface WhatsAppBotConfig {
+  current: { account_id: string } | null
+  accounts: Record<string, WhatsAppBotAccountEntry>
+}
+
+export interface WhatsAppBotCredentials {
+  phone_number_id: string
+  account_name: string
+  access_token: string
+}
+
+export interface WhatsAppBotMessageResponse {
+  messaging_product: string
+  contacts: Array<{ input: string; wa_id: string }>
+  messages: Array<{ id: string }>
+}
+
+export interface WhatsAppBotTemplateComponent {
+  type: string
+  format?: string
+  text?: string
+  example?: unknown
+  buttons?: unknown[]
+}
+
+export interface WhatsAppBotTemplate {
+  name: string
+  status: string
+  category: string
+  language: string
+  components: WhatsAppBotTemplateComponent[]
+}
+
+export class WhatsAppBotError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'WhatsAppBotError'
+    this.code = code
+  }
+}
+
+export const WhatsAppBotAccountEntrySchema = z.object({
+  phone_number_id: z.string(),
+  account_name: z.string(),
+  access_token: z.string(),
+})
+
+export const WhatsAppBotConfigSchema = z.object({
+  current: z
+    .object({
+      account_id: z.string(),
+    })
+    .nullable(),
+  accounts: z.record(z.string(), WhatsAppBotAccountEntrySchema),
+})
+
+export const WhatsAppBotCredentialsSchema = z.object({
+  phone_number_id: z.string(),
+  account_name: z.string(),
+  access_token: z.string(),
+})

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

@@ -0,0 +1,102 @@
+import { ChannelClient } from '@/platforms/channeltalk/client'
+import { ChannelCredentialManager } from '@/platforms/channeltalk/credential-manager'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class ChannelTalkAdapter implements PlatformAdapter {
+  readonly name = 'Channel Talk'
+
+  private client: ChannelClient | null = null
+  private credManager = new ChannelCredentialManager()
+  private currentWorkspace: Workspace | null = null
+  private channelId: string | null = null
+
+  async login(): Promise<void> {
+    const client = new ChannelClient()
+    await client.login()
+    this.client = client
+
+    const creds = await this.credManager.getCredentials()
+    if (creds) {
+      this.currentWorkspace = { id: creds.workspace_id, name: creds.workspace_name }
+      this.channelId = creds.workspace_id
+    }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    if (!this.channelId) return []
+
+    const groups = await client.listGroups(this.channelId)
+    return groups.map((group) => ({
+      id: group.id,
+      name: group.name || group.title || group.id,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    if (!this.channelId) return []
+
+    const messages = await client.getGroupMessages(this.channelId, channelId, { limit })
+    return messages
+      .map((msg) => ({
+        id: msg.id,
+        channelId,
+        author: msg.personId ?? 'unknown',
+        content: ChannelClient.extractText(msg),
+        timestamp: msg.createdAt ? new Date(msg.createdAt).toISOString() : new Date().toISOString(),
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    const client = this.ensureClient()
+    if (!this.channelId) return
+
+    const blocks = ChannelClient.wrapTextInBlocks(text)
+    await client.sendGroupMessage(this.channelId, channelId, blocks)
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    const all = await this.credManager.listAll()
+    return all.map((ws) => ({
+      id: ws.workspace_id,
+      name: ws.workspace_name,
+    }))
+  }
+
+  async switchWorkspace(workspaceId: string): Promise<void> {
+    const creds = await this.credManager.getCredentials(workspaceId)
+    if (!creds) throw new Error(`Workspace ${workspaceId} not found`)
+
+    const client = new ChannelClient()
+    await client.login({ accountCookie: creds.account_cookie, sessionCookie: creds.session_cookie ?? undefined })
+    this.client = client
+    this.currentWorkspace = { id: creds.workspace_id, name: creds.workspace_name }
+    this.channelId = creds.workspace_id
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentWorkspace
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-channeltalk auth extract',
+      description: 'Log in to the Channel Talk desktop app, then run the command below to extract credentials.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    io.print('Extracting credentials from Channel Talk desktop app...')
+    await this.login()
+  }
+
+  private ensureClient(): ChannelClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}

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

@@ -0,0 +1,112 @@
+import { DiscordClient } from '@/platforms/discord/client'
+import { DiscordListener } from '@/platforms/discord/listener'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class DiscordAdapter implements PlatformAdapter {
+  readonly name = 'Discord'
+
+  private client: DiscordClient | null = null
+  private listener: DiscordListener | null = null
+  private serverId: string | null = null
+  private serverName: string | null = null
+  private servers: Workspace[] = []
+
+  async login(): Promise<void> {
+    const client = new DiscordClient()
+    await client.login()
+    const servers = await client.listServers()
+    if (servers.length === 0) {
+      throw new Error('No Discord servers found')
+    }
+    this.client = client
+    this.servers = servers.map((s) => ({ id: s.id, name: s.name }))
+    this.serverId = servers[0].id
+    this.serverName = servers[0].name
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    this.ensureClient()
+    const channels = await this.client!.listChannels(this.serverId!)
+    return channels
+      .filter((ch) => ch.type === 0)
+      .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+      .map((ch) => ({ id: ch.id, name: '#' + ch.name, parentId: this.serverId! }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    this.ensureClient()
+    const messages = await this.client!.getMessages(channelId, limit)
+    return messages
+      .map((msg) => ({
+        id: msg.id,
+        channelId: msg.channel_id,
+        author: msg.author.username,
+        content: msg.content,
+        timestamp: msg.timestamp,
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    this.ensureClient()
+    await this.client!.sendMessage(channelId, text)
+  }
+
+  async startListening(onMessage: (msg: UnifiedMessage) => void): Promise<void> {
+    this.ensureClient()
+    const listener = new DiscordListener(this.client!)
+    await listener.start()
+    listener.on('message_create', (event) => {
+      if (event.guild_id !== this.serverId) return
+      onMessage({
+        id: event.id,
+        channelId: event.channel_id,
+        author: event.author.username,
+        content: event.content,
+        timestamp: event.timestamp,
+      })
+    })
+    this.listener = listener
+  }
+
+  stopListening(): void {
+    this.listener?.stop()
+    this.listener = null
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    return this.servers
+  }
+
+  async switchWorkspace(serverId: string): Promise<void> {
+    this.stopListening()
+    const server = this.servers.find((s) => s.id === serverId)
+    if (!server) throw new Error(`Server ${serverId} not found`)
+    this.serverId = server.id
+    this.serverName = server.name
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    if (!this.serverId || !this.serverName) return null
+    return { id: this.serverId, name: this.serverName }
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-discord auth extract',
+      description: 'Log in to the Discord desktop app, then run the command below to extract credentials.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    io.print('Extracting credentials from Discord desktop app...')
+    await this.login()
+  }
+
+  private ensureClient(): void {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+  }
+}

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

@@ -0,0 +1,132 @@
+import { InstagramClient } from '@/platforms/instagram/client'
+import { InstagramCredentialManager } from '@/platforms/instagram/credential-manager'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class InstagramAdapter implements PlatformAdapter {
+  readonly name = 'Instagram'
+
+  private client: InstagramClient | null = null
+  private credManager = new InstagramCredentialManager()
+  private currentAccount: Workspace | null = null
+
+  async login(): Promise<void> {
+    const client = new InstagramClient()
+    await client.login()
+    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.username ?? 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: msg.thread_id,
+      author: msg.is_outgoing ? 'you' : (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.username ?? acct.account_id,
+    }))
+  }
+
+  async switchWorkspace(accountId: string): Promise<void> {
+    const client = new InstagramClient()
+    await client.login(undefined, accountId)
+    this.client = client
+
+    const account = await this.credManager.getAccount(accountId)
+    this.currentAccount = { id: accountId, name: account?.username ?? accountId }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentAccount
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-instagram auth login',
+      description: 'Run the command below and log in with your Instagram username and password.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const { createAccountId } = await import('@/platforms/instagram/types')
+
+    const username = await io.prompt('Instagram username')
+    if (!username) throw new Error('Username is required')
+    const password = await io.prompt('Password', { secret: true })
+    if (!password) throw new Error('Password is required')
+
+    io.print('Logging in...')
+    const accountId = createAccountId(username)
+    const paths = await this.credManager.ensureAccountPaths(accountId)
+
+    const client = new InstagramClient(this.credManager)
+    client.setSessionPath(paths.session_path)
+
+    const result = await client.authenticate(username, password)
+
+    let userId = result.userId
+    if (result.requiresTwoFactor) {
+      const twoFactorId = (result.twoFactorInfo?.['two_factor_identifier'] as string) ?? ''
+      const code = await io.prompt('Verification code')
+      if (!code) throw new Error('Verification code is required')
+      const tfResult = await client.twoFactorLogin(username, code, twoFactorId)
+      userId = tfResult.userId || userId
+    } else if (result.challengeRequired && result.challengePath) {
+      io.print('Security challenge required. Sending verification code via email...')
+      await client.challengeSendCode(result.challengePath, 'email')
+      const code = await io.prompt('Verification code (check your email)')
+      if (!code) throw new Error('Verification code is required')
+      const challengeResult = await client.challengeSubmitCode(result.challengePath, code)
+      userId = challengeResult.userId || userId
+    }
+
+    const now = new Date().toISOString()
+    await this.credManager.setAccount({
+      account_id: accountId,
+      username,
+      pk: userId,
+      created_at: now,
+      updated_at: now,
+    })
+    await this.credManager.setCurrent(accountId)
+
+    this.client = client
+    this.currentAccount = { id: accountId, name: username }
+  }
+
+  private ensureClient(): InstagramClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}

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

@@ -0,0 +1,163 @@
+import { KakaoTalkClient } from '@/platforms/kakaotalk/client'
+import { KakaoCredentialManager } from '@/platforms/kakaotalk/credential-manager'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class KakaoTalkAdapter implements PlatformAdapter {
+  readonly name = 'KakaoTalk'
+
+  private client: KakaoTalkClient | null = null
+  private credManager = new KakaoCredentialManager()
+  private currentAccount: Workspace | null = null
+
+  async login(): Promise<void> {
+    const previousClient = this.client
+    const client = new KakaoTalkClient()
+    await client.login()
+    this.client = client
+    previousClient?.close()
+
+    const config = await this.credManager.load()
+    if (config.current_account && config.accounts[config.current_account]) {
+      const acct = config.accounts[config.current_account]
+      this.currentAccount = { id: acct.account_id, name: acct.account_id }
+    }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    const chats = await client.getChats()
+    return chats.map((chat) => ({
+      id: chat.chat_id,
+      name: chat.display_name || `Chat ${chat.chat_id}`,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    const messages = await client.getMessages(channelId, { count: limit })
+    return messages.map((msg) => ({
+      id: msg.log_id,
+      channelId,
+      author: String(msg.author_id),
+      content: msg.message ?? '',
+      timestamp: String(msg.sent_at),
+    }))
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    const client = this.ensureClient()
+    await client.sendMessage(channelId, text)
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    const config = await this.credManager.load()
+    return Object.values(config.accounts).map((acct) => ({
+      id: acct.account_id,
+      name: acct.account_id,
+    }))
+  }
+
+  async switchWorkspace(accountId: string): Promise<void> {
+    this.client?.close()
+    const creds = await this.credManager.getAccount(accountId)
+    if (!creds) throw new Error(`Account ${accountId} not found`)
+
+    const client = new KakaoTalkClient()
+    await client.login({ oauthToken: creds.oauth_token, userId: creds.user_id, deviceUuid: creds.device_uuid })
+    this.client = client
+    this.currentAccount = { id: creds.account_id, name: creds.account_id }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentAccount
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-kakaotalk auth login',
+      description: 'Run the command below and log in with your Kakao account credentials.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const { loginFlow, generateDeviceUuid } = await import('@/platforms/kakaotalk/auth/kakao-login')
+    const { KakaoTokenExtractor } = await import('@/platforms/kakaotalk/token-extractor')
+
+    const existing = await this.credManager.getAccount()
+    const pendingState = await this.credManager.loadPendingLogin()
+    const savedDeviceUuid = pendingState?.device_uuid ?? existing?.device_uuid ?? generateDeviceUuid()
+
+    let email: string | undefined
+    let password: string | undefined
+
+    io.print('Checking for cached credentials...')
+    try {
+      const extractor = new KakaoTokenExtractor()
+      const cached = await extractor.extract()
+      if (cached?.login_form_body) {
+        const params = new URLSearchParams(cached.login_form_body)
+        email = params.get('email') ?? undefined
+        const cachedPassword = params.get('password') ?? undefined
+        const isHashed = cachedPassword && /^[0-9a-f]{128}$/.test(cachedPassword)
+        if (!isHashed) password = cachedPassword
+        if (email) io.print(`Found cached credentials for ${email}`)
+      }
+    } catch {}
+
+    if (!email) {
+      email = await io.prompt('KakaoTalk email')
+      if (!email) throw new Error('Email is required')
+    }
+    if (!password) {
+      password = await io.prompt('Password', { secret: true })
+      if (!password) throw new Error('Password is required')
+    }
+
+    io.print('Logging in...')
+    const result = await loginFlow({
+      email,
+      password,
+      deviceType: 'tablet',
+      force: false,
+      savedDeviceUuid,
+      onPasscodeDisplay: (code) => {
+        io.print(`Enter this code on your phone: ${code}`)
+        io.print('Waiting for confirmation...')
+      },
+    })
+
+    if (!result.authenticated || !result.credentials) {
+      throw new Error(result.message ?? result.error ?? 'Authentication failed')
+    }
+
+    const now = new Date().toISOString()
+    await this.credManager.setAccount({
+      account_id: result.credentials.user_id || 'default',
+      oauth_token: result.credentials.access_token,
+      user_id: result.credentials.user_id,
+      refresh_token: result.credentials.refresh_token,
+      device_uuid: result.credentials.device_uuid,
+      device_type: result.credentials.device_type,
+      created_at: now,
+      updated_at: now,
+    })
+    await this.credManager.setCurrentAccount(result.credentials.user_id || 'default')
+
+    const client = new KakaoTalkClient()
+    await client.login({
+      oauthToken: result.credentials.access_token,
+      userId: result.credentials.user_id,
+      deviceUuid: result.credentials.device_uuid,
+    })
+    this.client = client
+    this.currentAccount = { id: result.credentials.user_id, name: email }
+  }
+
+  private ensureClient(): KakaoTalkClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}

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

@@ -0,0 +1,109 @@
+import { LineClient } from '@/platforms/line/client'
+import { LineCredentialManager } from '@/platforms/line/credential-manager'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
+
+export class LineAdapter implements PlatformAdapter {
+  readonly name = 'LINE'
+
+  private client: LineClient | null = null
+  private credManager = new LineCredentialManager()
+  private currentAccount: Workspace | null = null
+
+  async login(): Promise<void> {
+    const client = new LineClient()
+    await client.login()
+    this.client = client
+
+    const config = await this.credManager.load()
+    if (config.current_account && config.accounts[config.current_account]) {
+      const acct = config.accounts[config.current_account]
+      this.currentAccount = { id: acct.account_id, name: acct.display_name ?? acct.account_id }
+    }
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    const client = this.ensureClient()
+    const chats = await client.getChats({ limit: 50 })
+    return chats.map((chat) => ({
+      id: chat.chat_id,
+      name: chat.display_name || chat.chat_id,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    const client = this.ensureClient()
+    const messages = await client.getMessages(channelId, { count: limit })
+    return messages.map((msg) => ({
+      id: msg.message_id,
+      channelId,
+      author: msg.author_id ?? 'unknown',
+      content: msg.text ?? '',
+      timestamp: msg.sent_at,
+    }))
+  }
+
+  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.display_name ?? acct.account_id,
+    }))
+  }
+
+  async switchWorkspace(accountId: string): Promise<void> {
+    const creds = await this.credManager.getAccount(accountId)
+    if (!creds) throw new Error(`Account ${accountId} not found`)
+
+    const client = new LineClient()
+    await client.login(creds)
+    this.client = client
+    this.currentAccount = { id: creds.account_id, name: creds.display_name ?? creds.account_id }
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.currentAccount
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-line auth login',
+      description: 'Run the command below and scan the QR code with your LINE mobile app.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const client = new LineClient(this.credManager)
+
+    io.print('Generating QR code...')
+    const result = await client.loginWithQR({
+      onQRUrl: (url) => {
+        io.print('Scan this URL with the LINE mobile app:')
+        io.print(url)
+      },
+      onPincode: (pin) => {
+        io.print(`Enter this PIN in the LINE mobile app: ${pin}`)
+      },
+    })
+
+    if (!result.authenticated) {
+      throw new Error('Authentication failed')
+    }
+
+    this.client = client
+    const accountId = result.account_id ?? 'default'
+    this.currentAccount = { id: accountId, name: result.display_name ?? accountId }
+  }
+
+  private ensureClient(): LineClient {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+    return this.client
+  }
+}