agent-messenger 2.10.2 → 2.11.1

package/src/shared/chromium/browsers.ts

@@ -1,6 +1,6 @@
-import { existsSync, readdirSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
 
 import type { BrowserConfig, KeychainVariant } from './types'
 
@@ -39,6 +39,17 @@ export const BROWSER_KEYCHAIN_VARIANTS: KeychainVariant[] = [
   { service: 'Chromium Safe Storage', account: 'Chromium' },
 ]
 
+interface AgentBrowserProfileDiscoveryOptions {
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  homeDir?: string
+  customProfileDirs?: string[]
+}
+
+type AgentBrowserConfig = {
+  profile?: unknown
+}
+
 export function getBrowserBasePath(browser: BrowserConfig, platform: NodeJS.Platform): string | null {
   let relative: string
   switch (platform) {
@@ -70,10 +81,41 @@ export function discoverBrowserProfileDirs(browserBase: string): string[] {
       if (!/^Profile \d+$/i.test(entry.name)) continue
       dirs.push(join(browserBase, entry.name))
     }
-  } catch {}
+  } catch {
+    return dirs
+  }
   return dirs
 }
 
+export function getAgentBrowserProfileDirs(options: AgentBrowserProfileDiscoveryOptions = {}): string[] {
+  const cwd = options.cwd ?? process.cwd()
+  const env = options.env ?? process.env
+  const homeDir = options.homeDir ?? homedir()
+  if (env.AGENT_MESSENGER_DISABLE_AGENT_BROWSER_PROFILE_DISCOVERY === '1') return []
+
+  const profileDirs: string[] = []
+
+  for (const profileDir of options.customProfileDirs ?? []) {
+    addAgentBrowserProfileDir(profileDirs, profileDir, cwd)
+  }
+
+  addAgentBrowserProfileDir(profileDirs, env.AGENT_BROWSER_PROFILE, cwd)
+
+  const configPaths = [
+    join(homeDir, '.agent-browser', 'config.json'),
+    join(cwd, 'agent-browser.json'),
+    env.AGENT_BROWSER_CONFIG,
+  ]
+
+  for (const configPath of configPaths) {
+    if (!configPath) continue
+    const config = readAgentBrowserConfig(configPath)
+    addAgentBrowserProfileDir(profileDirs, config?.profile, dirname(configPath))
+  }
+
+  return dedupePaths(profileDirs.flatMap((profileDir) => [profileDir, ...discoverBrowserProfileDirs(profileDir)]))
+}
+
 export function findLocalStatePath(cookieOrProfilePath: string): string | null {
   const parts = cookieOrProfilePath.split(/[/\\]/)
   for (let levels = 2; levels <= 4; levels++) {
@@ -84,3 +126,30 @@ export function findLocalStatePath(cookieOrProfilePath: string): string | null {
   }
   return null
 }
+
+function readAgentBrowserConfig(configPath: string): AgentBrowserConfig | null {
+  if (!existsSync(configPath)) return null
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8')) as unknown
+    if (!parsed || typeof parsed !== 'object') return null
+    return parsed as AgentBrowserConfig
+  } catch {
+    return null
+  }
+}
+
+function addAgentBrowserProfileDir(dirs: string[], profile: unknown, baseDir: string): void {
+  if (typeof profile !== 'string' || profile.length === 0) return
+  dirs.push(isAbsolute(profile) ? profile : resolve(baseDir, profile))
+}
+
+function dedupePaths(paths: string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const path of paths) {
+    if (seen.has(path)) continue
+    seen.add(path)
+    result.push(path)
+  }
+  return result
+}

package/src/shared/chromium/cli-options.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test'
+
+import { collectBrowserProfileOption } from './cli-options'
+
+describe('collectBrowserProfileOption', () => {
+  it('collects repeated browser profile options', () => {
+    // when
+    const first = collectBrowserProfileOption('/tmp/profile-a')
+    const second = collectBrowserProfileOption('/tmp/profile-b', first)
+
+    // then
+    expect(second).toEqual(['/tmp/profile-a', '/tmp/profile-b'])
+  })
+
+  it('splits comma-separated browser profile options', () => {
+    // when
+    const profiles = collectBrowserProfileOption('/tmp/profile-a, /tmp/profile-b,,')
+
+    // then
+    expect(profiles).toEqual(['/tmp/profile-a', '/tmp/profile-b'])
+  })
+})

package/src/shared/chromium/cli-options.ts

@@ -0,0 +1,12 @@
+export interface BrowserProfileOption {
+  browserProfile?: string[]
+}
+
+export function collectBrowserProfileOption(value: string, previous: string[] = []): string[] {
+  const paths = value
+    .split(',')
+    .map((path) => path.trim())
+    .filter((path) => path.length > 0)
+
+  return [...previous, ...paths]
+}

package/src/shared/chromium/index.ts

@@ -4,8 +4,11 @@ export {
   CHROMIUM_BROWSERS,
   discoverBrowserProfileDirs,
   findLocalStatePath,
+  getAgentBrowserProfileDirs,
   getBrowserBasePath,
 } from './browsers'
 export { ChromiumCookieDecryptor } from './decryptor'
 export type { ChromiumDecryptorOptions } from './decryptor'
 export { ChromiumCookieReader } from './cookie-reader'
+export { collectBrowserProfileOption } from './cli-options'
+export type { BrowserProfileOption } from './cli-options'

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/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,