agent-messenger 2.10.1 → 2.11.0

package/src/shared/utils/cli-output.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
+
+import { cliOutput } from './cli-output'
+
+describe('cliOutput', () => {
+  let logSpy: ReturnType<typeof mock>
+  let exitSpy: ReturnType<typeof mock>
+  let originalLog: typeof console.log
+  let originalExit: typeof process.exit
+
+  beforeEach(() => {
+    originalLog = console.log
+    originalExit = process.exit
+    logSpy = mock(() => {})
+    exitSpy = mock(((_code?: number) => undefined) as never)
+    console.log = logSpy as unknown as typeof console.log
+    process.exit = exitSpy as unknown as typeof process.exit
+  })
+
+  afterEach(() => {
+    console.log = originalLog
+    process.exit = originalExit
+  })
+
+  it('prints compact JSON for success results', () => {
+    cliOutput({ ok: true, value: 42 })
+
+    expect(logSpy).toHaveBeenCalledWith('{"ok":true,"value":42}')
+    expect(exitSpy).not.toHaveBeenCalled()
+  })
+
+  it('prints pretty JSON when pretty=true', () => {
+    cliOutput({ ok: true }, true)
+
+    expect(logSpy).toHaveBeenCalledWith('{\n  "ok": true\n}')
+  })
+
+  it('exits 1 when result.error is set', () => {
+    cliOutput({ error: 'Something went wrong' })
+
+    expect(logSpy).toHaveBeenCalledWith('{"error":"Something went wrong"}')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  it('does not exit when exitOnError=false even with error set', () => {
+    cliOutput({ error: 'Soft fail' }, false, false)
+
+    expect(logSpy).toHaveBeenCalledWith('{"error":"Soft fail"}')
+    expect(exitSpy).not.toHaveBeenCalled()
+  })
+
+  it('does not exit when error is undefined', () => {
+    cliOutput({ error: undefined, success: true })
+
+    expect(exitSpy).not.toHaveBeenCalled()
+  })
+})

package/src/shared/utils/cli-output.ts

@@ -0,0 +1,8 @@
+import { formatOutput } from './output'
+
+export type CliResult = { error?: string } & Record<string, unknown>
+
+export function cliOutput<T extends { error?: string }>(result: T, pretty?: boolean, exitOnError = true): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error && exitOnError) process.exit(1)
+}

package/src/shared/utils/concurrency.test.ts

@@ -1,15 +1,15 @@
-import { describe, expect, test } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 
 import { parallelMap } from './concurrency'
 
 describe('parallelMap', () => {
-  test('processes items in parallel', async () => {
+  it('processes items in parallel', async () => {
     const items = [1, 2, 3, 4, 5]
     const results = await parallelMap(items, async (n) => n * 2)
     expect(results).toEqual([2, 4, 6, 8, 10])
   })
 
-  test('maintains order of results', async () => {
+  it('maintains order of results', async () => {
     const items = [100, 50, 10]
     const results = await parallelMap(
       items,
@@ -22,7 +22,7 @@ describe('parallelMap', () => {
     expect(results).toEqual([100, 50, 10])
   })
 
-  test('respects concurrency limit', async () => {
+  it('respects concurrency limit', async () => {
     let concurrent = 0
     let maxConcurrent = 0
     const items = [1, 2, 3, 4, 5, 6]
@@ -41,12 +41,12 @@ describe('parallelMap', () => {
     expect(maxConcurrent).toBe(2)
   })
 
-  test('handles empty array', async () => {
+  it('handles empty array', async () => {
     const results = await parallelMap([], async (n: number) => n * 2)
     expect(results).toEqual([])
   })
 
-  test('passes index to function', async () => {
+  it('passes index to function', async () => {
     const items = ['a', 'b', 'c']
     const results = await parallelMap(items, async (item, index) => `${item}${index}`)
     expect(results).toEqual(['a0', 'b1', 'c2'])

package/src/shared/utils/derived-key-cache.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
 import { existsSync, mkdirSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -22,12 +22,12 @@ describe('DerivedKeyCache', () => {
   })
 
   describe('get', () => {
-    test('returns null when no cached key exists', async () => {
+    it('returns null when no cached key exists', async () => {
       const result = await cache.get('slack')
       expect(result).toBeNull()
     })
 
-    test('returns cached key when it exists', async () => {
+    it('returns cached key when it exists', async () => {
       // given
       const key = Buffer.from('test-key-16bytes')
       await cache.set('slack', key)
@@ -39,7 +39,7 @@ describe('DerivedKeyCache', () => {
       expect(result).toEqual(key)
     })
 
-    test('returns different keys for different platforms', async () => {
+    it('returns different keys for different platforms', async () => {
       // given
       const slackKey = Buffer.from('slack-key-16byte')
       const discordKey = Buffer.from('discord-key-16by')
@@ -53,7 +53,7 @@ describe('DerivedKeyCache', () => {
   })
 
   describe('set', () => {
-    test('creates cache directory if it does not exist', async () => {
+    it('creates cache directory if it does not exist', async () => {
       // given
       const nestedDir = join(testDir, 'nested', 'cache')
       const nestedCache = new DerivedKeyCache(nestedDir)
@@ -65,7 +65,7 @@ describe('DerivedKeyCache', () => {
       expect(existsSync(nestedDir)).toBe(true)
     })
 
-    test('overwrites existing cached key', async () => {
+    it('overwrites existing cached key', async () => {
       // given
       const oldKey = Buffer.from('old-key-16bytes!')
       const newKey = Buffer.from('new-key-16bytes!')
@@ -80,7 +80,7 @@ describe('DerivedKeyCache', () => {
   })
 
   describe('clear', () => {
-    test('removes cached key for platform', async () => {
+    it('removes cached key for platform', async () => {
       // given
       await cache.set('slack', Buffer.from('test-key'))
 
@@ -91,7 +91,7 @@ describe('DerivedKeyCache', () => {
       expect(await cache.get('slack')).toBeNull()
     })
 
-    test('does not affect other platforms', async () => {
+    it('does not affect other platforms', async () => {
       // given
       const discordKey = Buffer.from('discord-key')
       await cache.set('slack', Buffer.from('slack-key'))
@@ -105,13 +105,13 @@ describe('DerivedKeyCache', () => {
       expect(await cache.get('discord')).toEqual(discordKey)
     })
 
-    test('does not throw when key does not exist', async () => {
+    it('does not throw when key does not exist', async () => {
       await expect(cache.clear('slack')).resolves.toBeUndefined()
     })
   })
 
   describe('clearAll', () => {
-    test('removes all cached keys', async () => {
+    it('removes all cached keys', async () => {
       // given
       await cache.set('slack', Buffer.from('slack-key'))
       await cache.set('discord', Buffer.from('discord-key'))
@@ -126,7 +126,7 @@ describe('DerivedKeyCache', () => {
       expect(await cache.get('teams')).toBeNull()
     })
 
-    test('does not throw when cache directory does not exist', async () => {
+    it('does not throw when cache directory does not exist', async () => {
       // given
       const emptyCache = new DerivedKeyCache(join(testDir, 'nonexistent'))
 

package/src/tui/app.ts

@@ -1,20 +1,89 @@
 import blessed from 'blessed'
 
-import { ChannelTalkAdapter } from './adapters/channeltalk-adapter'
-import { DiscordAdapter } from './adapters/discord-adapter'
-import { InstagramAdapter } from './adapters/instagram-adapter'
-import { KakaoTalkAdapter } from './adapters/kakaotalk-adapter'
-import { LineAdapter } from './adapters/line-adapter'
-import { SlackAdapter } from './adapters/slack-adapter'
-import { TeamsAdapter } from './adapters/teams-adapter'
-import { TelegramAdapter } from './adapters/telegram-adapter'
 import type { AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage, Workspace } from './adapters/types'
-import { WebexAdapter } from './adapters/webex-adapter'
-import { WhatsAppAdapter } from './adapters/whatsapp-adapter'
 import { formatTimestamp } from './utils'
 import { ChannelPicker } from './views/channel-picker'
 import { WorkspacePicker } from './views/workspace-picker'
 
+type PlatformAdapterFactory = () => Promise<PlatformAdapter>
+
+class LazyPlatformAdapter implements PlatformAdapter {
+  readonly name: string
+  private adapter: PlatformAdapter | null = null
+  private loadPromise: Promise<PlatformAdapter> | null = null
+
+  constructor(
+    name: string,
+    private readonly fallbackAuthHint: string,
+    private readonly factory: PlatformAdapterFactory,
+  ) {
+    this.name = name
+  }
+
+  private async load(): Promise<PlatformAdapter> {
+    if (this.adapter) return this.adapter
+    this.loadPromise ??= this.factory()
+      .then((adapter) => {
+        this.adapter = adapter
+        return adapter
+      })
+      .catch((error: unknown) => {
+        this.loadPromise = null
+        throw error
+      })
+    return this.loadPromise
+  }
+
+  async login(): Promise<void> {
+    await (await this.load()).login()
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    return (await this.load()).getChannels()
+  }
+
+  async getMessages(channelId: string, limit?: number): Promise<UnifiedMessage[]> {
+    return (await this.load()).getMessages(channelId, limit)
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    await (await this.load()).sendMessage(channelId, text)
+  }
+
+  async startListening(onMessage: (msg: UnifiedMessage) => void): Promise<void> {
+    const adapter = await this.load()
+    await adapter.startListening?.(onMessage)
+  }
+
+  stopListening(): void {
+    this.adapter?.stopListening?.()
+  }
+
+  async getWorkspaces(): Promise<Workspace[]> {
+    return (await this.load()).getWorkspaces?.() ?? []
+  }
+
+  async switchWorkspace(workspaceId: string): Promise<void> {
+    await (await this.load()).switchWorkspace?.(workspaceId)
+  }
+
+  getCurrentWorkspace(): Workspace | null {
+    return this.adapter?.getCurrentWorkspace?.() ?? null
+  }
+
+  getAuthHint() {
+    return this.adapter?.getAuthHint() ?? { command: this.fallbackAuthHint, description: `Authenticate ${this.name}` }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    await (await this.load()).authenticate(io)
+  }
+}
+
+function lazyAdapter(name: string, fallbackAuthHint: string, factory: PlatformAdapterFactory): PlatformAdapter {
+  return new LazyPlatformAdapter(name, fallbackAuthHint, factory)
+}
+
 type AppMode = 'selection' | 'read' | 'write' | 'auth'
 type NavLevel = 'platform' | 'workspace' | 'channel'
 
@@ -36,7 +105,11 @@ export async function createApp(): Promise<void> {
 
   const platformStates: PlatformState[] = [
     {
-      adapter: new SlackAdapter(),
+      adapter: lazyAdapter(
+        'Slack',
+        'agent-slack auth extract',
+        async () => new (await import('./adapters/slack-adapter')).SlackAdapter(),
+      ),
       label: 'Slack',
       enabled: false,
       channels: null,
@@ -45,7 +118,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new DiscordAdapter(),
+      adapter: lazyAdapter(
+        'Discord',
+        'agent-discord auth extract',
+        async () => new (await import('./adapters/discord-adapter')).DiscordAdapter(),
+      ),
       label: 'Discord',
       enabled: false,
       channels: null,
@@ -54,7 +131,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new TeamsAdapter(),
+      adapter: lazyAdapter(
+        'Teams',
+        'agent-teams auth extract',
+        async () => new (await import('./adapters/teams-adapter')).TeamsAdapter(),
+      ),
       label: 'Teams',
       enabled: false,
       channels: null,
@@ -63,7 +144,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new WebexAdapter(),
+      adapter: lazyAdapter(
+        'Webex',
+        'agent-webex auth extract',
+        async () => new (await import('./adapters/webex-adapter')).WebexAdapter(),
+      ),
       label: 'Webex',
       enabled: false,
       channels: null,
@@ -72,7 +157,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new TelegramAdapter(),
+      adapter: lazyAdapter(
+        'Telegram',
+        'agent-telegram auth login',
+        async () => new (await import('./adapters/telegram-adapter')).TelegramAdapter(),
+      ),
       label: 'Telegram',
       enabled: false,
       channels: null,
@@ -81,7 +170,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new WhatsAppAdapter(),
+      adapter: lazyAdapter(
+        'WhatsApp',
+        'agent-whatsapp auth login',
+        async () => new (await import('./adapters/whatsapp-adapter')).WhatsAppAdapter(),
+      ),
       label: 'WhatsApp',
       enabled: false,
       channels: null,
@@ -90,7 +183,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new LineAdapter(),
+      adapter: lazyAdapter(
+        'LINE',
+        'agent-line auth login',
+        async () => new (await import('./adapters/line-adapter')).LineAdapter(),
+      ),
       label: 'LINE',
       enabled: false,
       channels: null,
@@ -99,7 +196,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new InstagramAdapter(),
+      adapter: lazyAdapter(
+        'Instagram',
+        'agent-instagram auth login',
+        async () => new (await import('./adapters/instagram-adapter')).InstagramAdapter(),
+      ),
       label: 'Instagram',
       enabled: false,
       channels: null,
@@ -108,7 +209,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new KakaoTalkAdapter(),
+      adapter: lazyAdapter(
+        'KakaoTalk',
+        'agent-kakaotalk auth extract',
+        async () => new (await import('./adapters/kakaotalk-adapter')).KakaoTalkAdapter(),
+      ),
       label: 'KakaoTalk',
       enabled: false,
       channels: null,
@@ -117,7 +222,11 @@ export async function createApp(): Promise<void> {
       lastChannelId: null,
     },
     {
-      adapter: new ChannelTalkAdapter(),
+      adapter: lazyAdapter(
+        'Channel Talk',
+        'agent-channeltalk auth extract',
+        async () => new (await import('./adapters/channeltalk-adapter')).ChannelTalkAdapter(),
+      ),
       label: 'Channel Talk',
       enabled: false,
       channels: null,

package/src/tui/utils.test.ts

@@ -1,16 +1,16 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, it, expect } from 'bun:test'
 
 import { formatTimestamp, truncate, fuzzyMatch, stripHtml } from './utils'
 
 describe('formatTimestamp', () => {
-  test("today's date returns HH:MM", () => {
+  it("returns HH:MM for today's date", () => {
     const now = new Date()
     const epochSeconds = (now.getTime() / 1000).toFixed(6)
     const result = formatTimestamp(epochSeconds)
     expect(result).toMatch(/^\d{2}:\d{2}$/)
   })
 
-  test("yesterday's date returns MM/DD HH:MM", () => {
+  it("returns MM/DD HH:MM for yesterday's date", () => {
     const yesterday = new Date()
     yesterday.setDate(yesterday.getDate() - 1)
     const epochSeconds = (yesterday.getTime() / 1000).toFixed(6)
@@ -18,24 +18,24 @@ describe('formatTimestamp', () => {
     expect(result).toMatch(/^\d{2}\/\d{2} \d{2}:\d{2}$/)
   })
 
-  test('ISO 8601 string for today returns HH:MM', () => {
+  it('ISO 8601 string for today returns HH:MM', () => {
     const now = new Date()
     const iso = now.toISOString()
     const result = formatTimestamp(iso)
     expect(result).toMatch(/^\d{2}:\d{2}$/)
   })
 
-  test('ISO 8601 string for past date returns MM/DD HH:MM', () => {
+  it('ISO 8601 string for past date returns MM/DD HH:MM', () => {
     const result = formatTimestamp('2024-03-15T10:30:00Z')
     expect(result).toMatch(/^\d{2}\/\d{2} \d{2}:\d{2}$/)
   })
 
-  test('invalid string returns original', () => {
+  it('invalid string returns original', () => {
     expect(formatTimestamp('not-a-date')).toBe('not-a-date')
     expect(formatTimestamp('abc123')).toBe('abc123')
   })
 
-  test('Slack-style epoch with microseconds', () => {
+  it('formats Slack-style epoch with microseconds as HH:MM', () => {
     const now = new Date()
     const slackTs = `${Math.floor(now.getTime() / 1000)}.123456`
     const result = formatTimestamp(slackTs)
@@ -44,105 +44,105 @@ describe('formatTimestamp', () => {
 })
 
 describe('truncate', () => {
-  test('short string returned unchanged', () => {
+  it('returns short string unchanged', () => {
     expect(truncate('hello', 10)).toBe('hello')
   })
 
-  test('exact length returned unchanged', () => {
+  it('returns string unchanged when length equals maxLen', () => {
     expect(truncate('hello', 5)).toBe('hello')
   })
 
-  test('long string gets truncated with ellipsis', () => {
+  it('long string gets truncated with ellipsis', () => {
     expect(truncate('hello world', 8)).toBe('hello...')
   })
 
-  test('maxLen of 3 truncates without ellipsis', () => {
+  it('truncates without ellipsis when maxLen is 3', () => {
     expect(truncate('hello', 3)).toBe('hel')
   })
 
-  test('maxLen of 1 truncates without ellipsis', () => {
+  it('truncates without ellipsis when maxLen is 1', () => {
     expect(truncate('hello', 1)).toBe('h')
   })
 
-  test('maxLen of 0 returns empty string', () => {
+  it('returns empty string when maxLen is 0', () => {
     expect(truncate('hello', 0)).toBe('')
   })
 
-  test('maxLen of 4 adds ellipsis', () => {
+  it('adds ellipsis when maxLen is 4', () => {
     expect(truncate('hello', 4)).toBe('h...')
   })
 })
 
 describe('fuzzyMatch', () => {
-  test('exact match returns true', () => {
+  it('exact match returns true', () => {
     expect(fuzzyMatch('general', 'general')).toBe(true)
   })
 
-  test('partial match in order returns true', () => {
+  it('partial match in order returns true', () => {
     expect(fuzzyMatch('gnrl', 'general')).toBe(true)
   })
 
-  test('case insensitive match', () => {
+  it('matches case-insensitively', () => {
     expect(fuzzyMatch('GNRL', 'general')).toBe(true)
     expect(fuzzyMatch('gnrl', 'GENERAL')).toBe(true)
   })
 
-  test('empty query returns true', () => {
+  it('empty query returns true', () => {
     expect(fuzzyMatch('', 'anything')).toBe(true)
     expect(fuzzyMatch('', '')).toBe(true)
   })
 
-  test('no match returns false', () => {
+  it('no match returns false', () => {
     expect(fuzzyMatch('xyz', 'general')).toBe(false)
   })
 
-  test('characters out of order returns false', () => {
+  it('characters out of order returns false', () => {
     expect(fuzzyMatch('lrng', 'general')).toBe(false)
   })
 
-  test('query longer than text returns false', () => {
+  it('query longer than text returns false', () => {
     expect(fuzzyMatch('generalgeneral', 'general')).toBe(false)
   })
 })
 
 describe('stripHtml', () => {
-  test('removes simple tags', () => {
+  it('removes simple tags', () => {
     expect(stripHtml('<p>hello</p>')).toBe('hello')
   })
 
-  test('removes nested tags', () => {
+  it('removes nested tags', () => {
     expect(stripHtml('<div><p><strong>hello</strong></p></div>')).toBe('hello')
   })
 
-  test('decodes &amp;', () => {
+  it('decodes &amp;', () => {
     expect(stripHtml('a &amp; b')).toBe('a & b')
   })
 
-  test('decodes &lt; and &gt;', () => {
+  it('decodes &lt; and &gt;', () => {
     expect(stripHtml('&lt;tag&gt;')).toBe('<tag>')
   })
 
-  test('decodes &quot;', () => {
+  it('decodes &quot;', () => {
     expect(stripHtml('say &quot;hello&quot;')).toBe('say "hello"')
   })
 
-  test('decodes &#39;', () => {
+  it('decodes &#39;', () => {
     expect(stripHtml('it&#39;s')).toBe("it's")
   })
 
-  test('collapses multiple whitespace', () => {
+  it('collapses multiple whitespace', () => {
     expect(stripHtml('hello   world')).toBe('hello world')
   })
 
-  test('trims leading and trailing whitespace', () => {
+  it('trims leading and trailing whitespace', () => {
     expect(stripHtml('  hello  ')).toBe('hello')
   })
 
-  test('handles multiple entities and tags together', () => {
+  it('handles multiple entities and tags together', () => {
     expect(stripHtml('<p>Hello &amp; <strong>World</strong></p>')).toBe('Hello & World')
   })
 
-  test('whitespace from tag removal is collapsed', () => {
+  it('collapses whitespace left by tag removal', () => {
     expect(stripHtml('<p>hello</p> <p>world</p>')).toBe('hello world')
   })
 })