agent-messenger 2.3.0 → 2.5.0

package/src/platforms/whatsappbot/commands/message.test.ts

@@ -0,0 +1,198 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockSendTextMessage = mock(() =>
+  Promise.resolve({
+    messaging_product: 'whatsapp',
+    contacts: [{ input: '+1234567890', wa_id: '1234567890' }],
+    messages: [{ id: 'wamid.test123' }],
+  }),
+)
+
+const mockSendTemplateMessage = mock(() =>
+  Promise.resolve({
+    messaging_product: 'whatsapp',
+    contacts: [{ input: '+1234567890', wa_id: '1234567890' }],
+    messages: [{ id: 'wamid.template123' }],
+  }),
+)
+
+const mockSendReaction = mock(() =>
+  Promise.resolve({
+    messaging_product: 'whatsapp',
+    contacts: [{ input: '+1234567890', wa_id: '1234567890' }],
+    messages: [{ id: 'wamid.reaction123' }],
+  }),
+)
+
+const mockSendImageMessage = mock(() =>
+  Promise.resolve({
+    messaging_product: 'whatsapp',
+    contacts: [{ input: '+1234567890', wa_id: '1234567890' }],
+    messages: [{ id: 'wamid.image123' }],
+  }),
+)
+
+const mockSendDocumentMessage = mock(() =>
+  Promise.resolve({
+    messaging_product: 'whatsapp',
+    contacts: [{ input: '+1234567890', wa_id: '1234567890' }],
+    messages: [{ id: 'wamid.doc123' }],
+  }),
+)
+
+const mockClient = {
+  sendTextMessage: mockSendTextMessage,
+  sendTemplateMessage: mockSendTemplateMessage,
+  sendReaction: mockSendReaction,
+  sendImageMessage: mockSendImageMessage,
+  sendDocumentMessage: mockSendDocumentMessage,
+}
+
+mock.module('./shared', () => ({
+  getClient: async () => mockClient,
+}))
+
+import { sendAction, sendDocumentAction, sendImageAction, sendReactionAction, sendTemplateAction } from './message'
+
+describe('message commands', () => {
+  beforeEach(() => {
+    mockSendTextMessage.mockClear()
+    mockSendTemplateMessage.mockClear()
+    mockSendReaction.mockClear()
+    mockSendImageMessage.mockClear()
+    mockSendDocumentMessage.mockClear()
+  })
+
+  describe('sendAction', () => {
+    test('sends a text message and returns result', async () => {
+      const result = await sendAction('+1234567890', 'Hello!', {})
+
+      expect(result.messaging_product).toBe('whatsapp')
+      expect(result.messages).toHaveLength(1)
+      expect(result.messages?.[0].id).toBe('wamid.test123')
+      expect(mockSendTextMessage).toHaveBeenCalledWith('+1234567890', 'Hello!')
+    })
+
+    test('returns error when client throws', async () => {
+      mockSendTextMessage.mockImplementationOnce(() => Promise.reject(new Error('Network error')))
+
+      const result = await sendAction('+1234567890', 'Hello!', {})
+
+      expect(result.error).toBe('Network error')
+    })
+  })
+
+  describe('sendTemplateAction', () => {
+    test('sends a template message with default language', async () => {
+      const result = await sendTemplateAction('+1234567890', 'hello_world', {})
+
+      expect(result.messaging_product).toBe('whatsapp')
+      expect(result.messages?.[0].id).toBe('wamid.template123')
+      expect(mockSendTemplateMessage).toHaveBeenCalledWith('+1234567890', 'hello_world', 'en_US', undefined)
+    })
+
+    test('sends a template message with custom language', async () => {
+      const result = await sendTemplateAction('+1234567890', 'hello_world', { language: 'pt_BR' })
+
+      expect(mockSendTemplateMessage).toHaveBeenCalledWith('+1234567890', 'hello_world', 'pt_BR', undefined)
+      expect(result.error).toBeUndefined()
+    })
+
+    test('parses and passes components JSON', async () => {
+      const components = [{ type: 'body', parameters: [{ type: 'text', text: 'World' }] }]
+      const result = await sendTemplateAction('+1234567890', 'hello_world', {
+        components: JSON.stringify(components),
+      })
+
+      expect(mockSendTemplateMessage).toHaveBeenCalledWith('+1234567890', 'hello_world', 'en_US', components)
+      expect(result.error).toBeUndefined()
+    })
+
+    test('returns error for invalid components JSON', async () => {
+      const result = await sendTemplateAction('+1234567890', 'hello_world', {
+        components: 'not-valid-json',
+      })
+
+      expect(result.error).toBe('Invalid --components JSON')
+    })
+
+    test('returns error when client throws', async () => {
+      mockSendTemplateMessage.mockImplementationOnce(() => Promise.reject(new Error('Template not found')))
+
+      const result = await sendTemplateAction('+1234567890', 'missing_template', {})
+
+      expect(result.error).toBe('Template not found')
+    })
+  })
+
+  describe('sendReactionAction', () => {
+    test('sends a reaction and returns result', async () => {
+      const result = await sendReactionAction('+1234567890', 'wamid.msg123', '👍', {})
+
+      expect(result.messaging_product).toBe('whatsapp')
+      expect(result.messages?.[0].id).toBe('wamid.reaction123')
+      expect(mockSendReaction).toHaveBeenCalledWith('+1234567890', 'wamid.msg123', '👍')
+    })
+
+    test('returns error when client throws', async () => {
+      mockSendReaction.mockImplementationOnce(() => Promise.reject(new Error('Message not found')))
+
+      const result = await sendReactionAction('+1234567890', 'wamid.bad', '👍', {})
+
+      expect(result.error).toBe('Message not found')
+    })
+  })
+
+  describe('sendImageAction', () => {
+    test('sends an image message and returns result', async () => {
+      const result = await sendImageAction('+1234567890', 'https://example.com/image.jpg', {})
+
+      expect(result.messaging_product).toBe('whatsapp')
+      expect(result.messages?.[0].id).toBe('wamid.image123')
+      expect(mockSendImageMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/image.jpg', undefined)
+    })
+
+    test('passes caption when provided', async () => {
+      const result = await sendImageAction('+1234567890', 'https://example.com/image.jpg', { caption: 'My photo' })
+
+      expect(mockSendImageMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/image.jpg', 'My photo')
+      expect(result.error).toBeUndefined()
+    })
+
+    test('returns error when client throws', async () => {
+      mockSendImageMessage.mockImplementationOnce(() => Promise.reject(new Error('Invalid URL')))
+
+      const result = await sendImageAction('+1234567890', 'bad-url', {})
+
+      expect(result.error).toBe('Invalid URL')
+    })
+  })
+
+  describe('sendDocumentAction', () => {
+    test('sends a document message and returns result', async () => {
+      const result = await sendDocumentAction('+1234567890', 'https://example.com/doc.pdf', {})
+
+      expect(result.messaging_product).toBe('whatsapp')
+      expect(result.messages?.[0].id).toBe('wamid.doc123')
+      expect(mockSendDocumentMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/doc.pdf', undefined, undefined)
+    })
+
+    test('passes filename and caption when provided', async () => {
+      const result = await sendDocumentAction('+1234567890', 'https://example.com/doc.pdf', {
+        filename: 'report.pdf',
+        caption: 'Monthly report',
+      })
+
+      expect(mockSendDocumentMessage).toHaveBeenCalledWith('+1234567890', 'https://example.com/doc.pdf', 'report.pdf', 'Monthly report')
+      expect(result.error).toBeUndefined()
+    })
+
+    test('returns error when client throws', async () => {
+      mockSendDocumentMessage.mockImplementationOnce(() => Promise.reject(new Error('Upload failed')))
+
+      const result = await sendDocumentAction('+1234567890', 'https://example.com/doc.pdf', {})
+
+      expect(result.error).toBe('Upload failed')
+    })
+  })
+})

package/src/platforms/whatsappbot/commands/template.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import type { WhatsAppBotTemplate } from '../types'
+
+const mockTemplates: WhatsAppBotTemplate[] = [
+  {
+    name: 'hello_world',
+    status: 'APPROVED',
+    category: 'UTILITY',
+    language: 'en_US',
+    components: [{ type: 'BODY', text: 'Hello World!' }],
+  },
+  {
+    name: 'order_confirmation',
+    status: 'APPROVED',
+    category: 'TRANSACTIONAL',
+    language: 'en_US',
+    components: [{ type: 'BODY', text: 'Your order {{1}} has been confirmed.' }],
+  },
+]
+
+const mockListTemplates = mock(() => Promise.resolve(mockTemplates))
+const mockGetTemplate = mock((name: string) => {
+  const template = mockTemplates.find((t) => t.name === name)
+  if (!template) {
+    return Promise.reject(new Error(`Template "${name}" not found`))
+  }
+  return Promise.resolve(template)
+})
+
+const mockClient = {
+  listTemplates: mockListTemplates,
+  getTemplate: mockGetTemplate,
+}
+
+mock.module('./shared', () => ({
+  getClient: async () => mockClient,
+}))
+
+import { getAction, listAction } from './template'
+
+describe('template commands', () => {
+  beforeEach(() => {
+    mockListTemplates.mockClear()
+    mockGetTemplate.mockClear()
+  })
+
+  describe('listAction', () => {
+    test('returns all templates', async () => {
+      const result = await listAction({})
+
+      expect(result.templates).toHaveLength(2)
+      expect(result.templates?.[0].name).toBe('hello_world')
+      expect(result.templates?.[1].name).toBe('order_confirmation')
+      expect(mockListTemplates).toHaveBeenCalledWith(undefined)
+    })
+
+    test('passes limit when provided', async () => {
+      const result = await listAction({ limit: '1' })
+
+      expect(mockListTemplates).toHaveBeenCalledWith({ limit: 1 })
+      expect(result.error).toBeUndefined()
+    })
+
+    test('returns error for invalid limit', async () => {
+      const result = await listAction({ limit: 'abc' })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Invalid --limit')
+    })
+
+    test('returns error for zero limit', async () => {
+      const result = await listAction({ limit: '0' })
+
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Invalid --limit')
+    })
+
+    test('returns error when client throws', async () => {
+      mockListTemplates.mockImplementationOnce(() => Promise.reject(new Error('API error')))
+
+      const result = await listAction({})
+
+      expect(result.error).toBe('API error')
+    })
+  })
+
+  describe('getAction', () => {
+    test('returns a specific template by name', async () => {
+      const result = await getAction('hello_world', {})
+
+      expect(result.template).toBeDefined()
+      expect(result.template?.name).toBe('hello_world')
+      expect(result.template?.status).toBe('APPROVED')
+      expect(mockGetTemplate).toHaveBeenCalledWith('hello_world')
+    })
+
+    test('returns error when template not found', async () => {
+      const result = await getAction('nonexistent_template', {})
+
+      expect(result.error).toContain('nonexistent_template')
+    })
+
+    test('returns error when client throws', async () => {
+      mockGetTemplate.mockImplementationOnce(() => Promise.reject(new Error('Network error')))
+
+      const result = await getAction('hello_world', {})
+
+      expect(result.error).toBe('Network error')
+    })
+  })
+})

package/src/platforms/whatsappbot/commands/whoami.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockVerifyToken = mock(() =>
+  Promise.resolve({ verified_name: 'Test Business' }),
+)
+
+mock.module('../client', () => ({
+  WhatsAppBotClient: class MockWhatsAppBotClient {
+    async login(_credentials?: { phoneNumberId: string; accessToken: string }) {
+      return this
+    }
+    verifyToken = mockVerifyToken
+  },
+}))
+
+// Re-import whoamiAction AFTER mock.module so the mock applies
+const { whoamiAction } = await import('./whoami')
+
+import { WhatsAppBotCredentialManager } from '../credential-manager'
+
+describe('whoami command', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `whatsappbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    mockVerifyToken.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+  })
+
+  test('returns phone number id, account name, and verified name', async () => {
+    const manager = new WhatsAppBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      phone_number_id: '12345678901',
+      account_name: 'Test Business',
+      access_token: 'EAAtest-token',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.phone_number_id).toBe('12345678901')
+    expect(result.account_name).toBe('Test Business')
+    expect(result.verified_name).toBe('Test Business')
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns info for specific --account', async () => {
+    const manager = new WhatsAppBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      phone_number_id: '11111111111',
+      account_name: 'Account A',
+      access_token: 'token-a',
+    })
+    await manager.setCredentials({
+      phone_number_id: '22222222222',
+      account_name: 'Account B',
+      access_token: 'token-b',
+    })
+
+    const result = await whoamiAction({ account: '11111111111', _credManager: manager })
+
+    expect(result.phone_number_id).toBe('11111111111')
+    expect(result.account_name).toBe('Account A')
+    expect(result.verified_name).toBe('Test Business')
+  })
+
+  test('returns error when verifyToken fails', async () => {
+    mockVerifyToken.mockImplementationOnce(() => Promise.reject(new Error('Invalid token')))
+
+    const manager = new WhatsAppBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      phone_number_id: '12345678901',
+      account_name: 'Test Business',
+      access_token: 'bad-token',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('Invalid token')
+  })
+
+  test('returns error when no credentials', async () => {
+    const manager = new WhatsAppBotCredentialManager(tempDir)
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('No credentials')
+  })
+})

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

@@ -0,0 +1,57 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { WhatsAppBotClient } from '../client'
+import { WhatsAppBotCredentialManager } from '../credential-manager'
+
+interface WhoamiOptions {
+  account?: string
+  pretty?: boolean
+  _credManager?: WhatsAppBotCredentialManager
+}
+
+interface WhoamiResult {
+  phone_number_id?: string | null
+  account_name?: string | null
+  verified_name?: string
+  error?: string
+}
+
+export async function whoamiAction(options: WhoamiOptions): Promise<WhoamiResult> {
+  try {
+    const credManager = options._credManager ?? new WhatsAppBotCredentialManager()
+    const creds = await credManager.getCredentials(options.account)
+
+    if (!creds) {
+      return { error: 'No credentials. Run "auth set <phone-number-id> <access-token>" first.' }
+    }
+
+    const client = await new WhatsAppBotClient().login({
+      phoneNumberId: creds.phone_number_id,
+      accessToken: creds.access_token,
+    })
+    const verified = await client.verifyToken()
+
+    return {
+      phone_number_id: creds.phone_number_id,
+      account_name: creds.account_name ?? null,
+      verified_name: verified.verified_name,
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) process.exit(1)
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--account <id>', 'Account ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: WhoamiOptions) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/shared/utils/qr.ts

@@ -0,0 +1,92 @@
+import { execSync } from 'node:child_process'
+import { writeFileSync, unlinkSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import QRCode from 'qrcode'
+
+import { info } from './stderr'
+
+export interface QRDisplayOptions {
+  platform: string
+  brandColor: string
+  scanInstruction: string
+}
+
+export async function createQRHtmlFile(url: string, options: QRDisplayOptions): Promise<string | null> {
+  try {
+    const svgString = await QRCode.toString(url, { type: 'svg', margin: 2 })
+    const html = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${options.platform} QR Login</title>
+<style>body{display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;font-family:-apple-system,system-ui,sans-serif;background:${options.brandColor}}
+.card{background:#fff;border-radius:16px;padding:40px;text-align:center;box-shadow:0 4px 24px rgba(0,0,0,.15)}
+h1{margin:0 0 8px;font-size:22px;color:#111}p{margin:0 0 24px;color:#666;font-size:14px}
+svg{width:280px;height:280px}</style></head>
+<body><div class="card"><h1>${options.platform} Login</h1><p>${options.scanInstruction}</p>${svgString}</div></body></html>`
+
+    const htmlPath = join(tmpdir(), `${options.platform.toLowerCase()}-qr-${Date.now()}.html`)
+    writeFileSync(htmlPath, html)
+    setTimeout(() => {
+      try {
+        unlinkSync(htmlPath)
+      } catch {}
+    }, 300_000).unref()
+    return htmlPath
+  } catch {
+    return null
+  }
+}
+
+export function openInBrowser(filePath: string): void {
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`open "${filePath}"`, { stdio: 'ignore' })
+    } else if (process.platform === 'win32') {
+      execSync(`start "" "${filePath}"`, { stdio: 'ignore' })
+    } else {
+      execSync(`xdg-open "${filePath}"`, { stdio: 'ignore' })
+    }
+  } catch {}
+}
+
+export async function renderTerminalQR(data: string): Promise<string> {
+  return QRCode.toString(data, { type: 'terminal', small: true })
+}
+
+export async function displayQR(
+  data: string,
+  options: QRDisplayOptions & {
+    interactive: boolean
+    openBrowser?: boolean
+    formatOutput: (obj: Record<string, unknown>, pretty?: boolean) => string
+    pretty?: boolean
+  },
+): Promise<void> {
+  const shouldOpenBrowser = options.openBrowser ?? options.interactive
+  const htmlPath = await createQRHtmlFile(data, options)
+  if (htmlPath && shouldOpenBrowser) openInBrowser(htmlPath)
+
+  if (options.interactive) {
+    try {
+      const qrAscii = await renderTerminalQR(data)
+      info(`\n${options.scanInstruction}:\n`)
+      info(qrAscii)
+    } catch {
+      info(`\nOpen the QR code in the browser window, or scan this URL:\n${data}\n`)
+    }
+  } else {
+    console.log(
+      options.formatOutput(
+        {
+          next_action: 'scan_qr',
+          qr_url: data,
+          qr_html_path: htmlPath,
+          message: htmlPath
+            ? `QR code opened in browser. ${options.scanInstruction}`
+            : `QR code generated. Open qr_url to scan.`,
+        },
+        options.pretty,
+      ),
+    )
+  }
+}

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

@@ -1,5 +1,6 @@
 import { WhatsAppClient } from '@/platforms/whatsapp/client'
 import { WhatsAppCredentialManager } from '@/platforms/whatsapp/credential-manager'
+import { renderTerminalQR } from '@/shared/utils/qr'
 
 import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './types'
 
@@ -80,35 +81,38 @@ export class WhatsAppAdapter implements PlatformAdapter {
 
   getAuthHint(): AuthHint {
     return {
-      command: 'agent-whatsapp auth login',
-      description: 'Run the command below and link your WhatsApp account using the pairing code.',
+      command: 'agent-whatsapp auth login --qr',
+      description: 'Run the command below and scan the QR code with WhatsApp on your phone.',
     }
   }
 
   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)
+    io.print('Generating QR code...')
+    const accountId = 'qr-default'
+    const existingPaths = this.credManager.getAccountPaths(accountId)
+    const { rm } = await import('node:fs/promises')
+    await rm(existingPaths.auth_dir, { recursive: true, force: true })
     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)
+      const result = await client.connectForQR(async (qr) => {
+        io.print('Scan this QR code with WhatsApp on your phone:')
+        try {
+          const rendered = await renderTerminalQR(qr)
+          io.print(rendered)
+        } catch {
+          io.print(qr)
+        }
+      })
       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...')
+    io.print('Waiting for QR code scan...')
     try {
       await waitForAuth()
     } catch (err) {
@@ -119,14 +123,13 @@ export class WhatsAppAdapter implements PlatformAdapter {
     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 }
+    this.currentAccount = { id: accountId, name: accountId }
   }
 
   private ensureClient(): WhatsAppClient {

package/dist/src/platforms/line/commands/profile.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare const profileCommand: Command;
-//# sourceMappingURL=profile.d.ts.map

package/dist/src/platforms/line/commands/profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../../src/platforms/line/commands/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAoBnC,eAAO,MAAM,cAAc,SAGH,CAAA"}

package/dist/src/platforms/line/commands/profile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.js","sourceRoot":"","sources":["../../../../../src/platforms/line/commands/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAEtC,KAAK,UAAU,aAAa,CAAC,OAA6B;IACxD,IAAI,MAA8B,CAAA;IAClC,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,IAAI,UAAU,EAAE,CAAC,KAAK,EAAE,CAAA;QACvC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,EAAE,CAAA;QACzC,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;IACpD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,WAAW,CAAC,KAAc,CAAC,CAAA;IAC7B,CAAC;YAAS,CAAC;QACT,MAAM,EAAE,KAAK,EAAE,CAAA;IACjB,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC;KACjD,WAAW,CAAC,wBAAwB,CAAC;KACrC,MAAM,CAAC,UAAU,EAAE,0BAA0B,CAAC;KAC9C,MAAM,CAAC,aAAa,CAAC,CAAA"}