agent-messenger 2.6.3 → 2.8.0

package/src/shared/chromium/browsers.test.ts

@@ -0,0 +1,274 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  BROWSER_KEYCHAIN_VARIANTS,
+  CHROMIUM_BROWSERS,
+  discoverBrowserProfileDirs,
+  findLocalStatePath,
+  getBrowserBasePath,
+} from './browsers'
+
+describe('browsers', () => {
+  const tempDirs: string[] = []
+  const originalLocalAppData = process.env.LOCALAPPDATA
+
+  afterEach(() => {
+    process.env.LOCALAPPDATA = originalLocalAppData
+
+    for (const tempDir of tempDirs.splice(0)) {
+      if (existsSync(tempDir)) {
+        rmSync(tempDir, { recursive: true, force: true })
+      }
+    }
+  })
+
+  describe('CHROMIUM_BROWSERS', () => {
+    test('has 7 browsers', () => {
+      expect(CHROMIUM_BROWSERS).toHaveLength(7)
+    })
+
+    test('includes major supported browsers', () => {
+      const browserNames = CHROMIUM_BROWSERS.map((browser) => browser.name)
+
+      expect(browserNames).toEqual(expect.arrayContaining(['Chrome', 'Edge', 'Arc', 'Brave', 'Vivaldi', 'Chromium']))
+    })
+
+    test('Arc has empty linux path', () => {
+      expect(CHROMIUM_BROWSERS.find((browser) => browser.name === 'Arc')?.linux).toBe('')
+    })
+  })
+
+  describe('BROWSER_KEYCHAIN_VARIANTS', () => {
+    test('has 7 keychain variants', () => {
+      expect(BROWSER_KEYCHAIN_VARIANTS).toHaveLength(7)
+    })
+
+    test('each variant has service and account properties', () => {
+      for (const variant of BROWSER_KEYCHAIN_VARIANTS) {
+        expect(variant.service).toBeString()
+        expect(variant.account).toBeString()
+      }
+    })
+
+    test('includes known safe storage services', () => {
+      const services = BROWSER_KEYCHAIN_VARIANTS.map((variant) => variant.service)
+
+      expect(services).toEqual(expect.arrayContaining(['Chrome Safe Storage', 'Microsoft Edge Safe Storage']))
+    })
+  })
+
+  describe('getBrowserBasePath', () => {
+    test('returns darwin path with Library/Application Support prefix', () => {
+      // given
+      const chrome = CHROMIUM_BROWSERS.find((browser) => browser.name === 'Chrome')!
+
+      // when
+      const path = getBrowserBasePath(chrome, 'darwin')
+
+      // then
+      expect(path).not.toBeNull()
+      expect(path).toContain(join('Library', 'Application Support'))
+      expect(path).toEndWith(join('Google', 'Chrome'))
+    })
+
+    test('returns linux path with .config prefix', () => {
+      // given
+      const chrome = CHROMIUM_BROWSERS.find((browser) => browser.name === 'Chrome')!
+
+      // when
+      const path = getBrowserBasePath(chrome, 'linux')
+
+      // then
+      expect(path).not.toBeNull()
+      expect(path).toContain(join('.config', 'google-chrome'))
+    })
+
+    test('returns win32 path with LOCALAPPDATA prefix', () => {
+      // given
+      const localAppData = mkdtempSync(join(tmpdir(), 'browser-localappdata-'))
+      tempDirs.push(localAppData)
+      process.env.LOCALAPPDATA = localAppData
+      const chrome = CHROMIUM_BROWSERS.find((browser) => browser.name === 'Chrome')!
+
+      // when
+      const path = getBrowserBasePath(chrome, 'win32')
+
+      // then
+      expect(path).toBe(join(localAppData, 'Google', 'Chrome', 'User Data'))
+    })
+
+    test('returns null for unsupported platform', () => {
+      // given
+      const chrome = CHROMIUM_BROWSERS.find((browser) => browser.name === 'Chrome')!
+
+      // when
+      const path = getBrowserBasePath(chrome, 'freebsd' as NodeJS.Platform)
+
+      // then
+      expect(path).toBeNull()
+    })
+
+    test('returns null when browser has empty path for platform', () => {
+      // given
+      const arc = CHROMIUM_BROWSERS.find((browser) => browser.name === 'Arc')!
+
+      // when
+      const path = getBrowserBasePath(arc, 'linux')
+
+      // then
+      expect(path).toBeNull()
+    })
+  })
+
+  describe('discoverBrowserProfileDirs', () => {
+    test('always includes Default dir even when base does not exist', () => {
+      // given
+      const browserBase = join(tmpdir(), `missing-browser-base-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+
+      // when
+      const dirs = discoverBrowserProfileDirs(browserBase)
+
+      // then
+      expect(dirs).toEqual([join(browserBase, 'Default')])
+    })
+
+    test('discovers Profile 1 and Profile 2 dirs when they exist', () => {
+      // given
+      const browserBase = mkdtempSync(join(tmpdir(), 'browser-profiles-'))
+      tempDirs.push(browserBase)
+      mkdirSync(join(browserBase, 'Profile 1'))
+      mkdirSync(join(browserBase, 'Profile 2'))
+
+      // when
+      const dirs = discoverBrowserProfileDirs(browserBase)
+
+      // then
+      expect(dirs).toEqual([
+        join(browserBase, 'Default'),
+        join(browserBase, 'Profile 1'),
+        join(browserBase, 'Profile 2'),
+      ])
+    })
+
+    test('ignores non-profile directories', () => {
+      // given
+      const browserBase = mkdtempSync(join(tmpdir(), 'browser-non-profile-'))
+      tempDirs.push(browserBase)
+      mkdirSync(join(browserBase, 'Cache'))
+      mkdirSync(join(browserBase, 'Extensions'))
+      mkdirSync(join(browserBase, 'Profile 1'))
+
+      // when
+      const dirs = discoverBrowserProfileDirs(browserBase)
+
+      // then
+      expect(dirs).toEqual([join(browserBase, 'Default'), join(browserBase, 'Profile 1')])
+    })
+
+    test('ignores files that match profile pattern', () => {
+      // given
+      const browserBase = mkdtempSync(join(tmpdir(), 'browser-profile-files-'))
+      tempDirs.push(browserBase)
+      writeFileSync(join(browserBase, 'Profile 1'), '')
+      mkdirSync(join(browserBase, 'Profile 2'))
+
+      // when
+      const dirs = discoverBrowserProfileDirs(browserBase)
+
+      // then
+      expect(dirs).toEqual([join(browserBase, 'Default'), join(browserBase, 'Profile 2')])
+    })
+
+    test('returns only Default when base directory is empty', () => {
+      // given
+      const browserBase = mkdtempSync(join(tmpdir(), 'browser-empty-'))
+      tempDirs.push(browserBase)
+
+      // when
+      const dirs = discoverBrowserProfileDirs(browserBase)
+
+      // then
+      expect(dirs).toEqual([join(browserBase, 'Default')])
+    })
+  })
+
+  describe('findLocalStatePath', () => {
+    test('returns null when no Local State exists at any level', () => {
+      // given
+      const rootDir = mkdtempSync(join(tmpdir(), 'browser-local-state-missing-'))
+      tempDirs.push(rootDir)
+      const cookiePath = join(rootDir, 'Browser', 'Default', 'Network', 'Cookies')
+      mkdirSync(join(rootDir, 'Browser', 'Default', 'Network'), { recursive: true })
+
+      // when
+      const path = findLocalStatePath(cookiePath)
+
+      // then
+      expect(path).toBeNull()
+    })
+
+    test('finds Local State 2 levels up from cookie path', () => {
+      // given
+      const rootDir = mkdtempSync(join(tmpdir(), 'browser-local-state-two-'))
+      tempDirs.push(rootDir)
+      const profileDir = join(rootDir, 'Browser', 'Default')
+      const cookiePath = join(profileDir, 'Network', 'Cookies')
+      mkdirSync(join(profileDir, 'Network'), { recursive: true })
+      writeFileSync(join(profileDir, 'Local State'), '')
+
+      // when
+      const path = findLocalStatePath(cookiePath)
+
+      // then
+      expect(path).toBe(join(profileDir, 'Local State'))
+    })
+
+    test('finds Local State 3 levels up from cookie path', () => {
+      // given
+      const rootDir = mkdtempSync(join(tmpdir(), 'browser-local-state-three-'))
+      tempDirs.push(rootDir)
+      const browserDir = join(rootDir, 'Browser')
+      const cookiePath = join(browserDir, 'Default', 'Network', 'Cookies')
+      mkdirSync(join(browserDir, 'Default', 'Network'), { recursive: true })
+      writeFileSync(join(browserDir, 'Local State'), '')
+
+      // when
+      const path = findLocalStatePath(cookiePath)
+
+      // then
+      expect(path).toBe(join(browserDir, 'Local State'))
+    })
+
+    test('returns null for path with too few segments', () => {
+      // given
+      const cookiePath = 'Cookies'
+
+      // when
+      const path = findLocalStatePath(cookiePath)
+
+      // then
+      expect(path).toBeNull()
+    })
+
+    test('finds the first match when multiple levels could match', () => {
+      // given
+      const rootDir = mkdtempSync(join(tmpdir(), 'browser-local-state-first-'))
+      tempDirs.push(rootDir)
+      const browserDir = join(rootDir, 'Browser')
+      const profileDir = join(browserDir, 'Default')
+      const cookiePath = join(profileDir, 'Network', 'Cookies')
+      mkdirSync(join(profileDir, 'Network'), { recursive: true })
+      writeFileSync(join(profileDir, 'Local State'), '')
+      writeFileSync(join(browserDir, 'Local State'), '')
+
+      // when
+      const path = findLocalStatePath(cookiePath)
+
+      // then
+      expect(path).toBe(join(profileDir, 'Local State'))
+    })
+  })
+})

package/src/shared/chromium/browsers.ts

@@ -0,0 +1,86 @@
+import { existsSync, readdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { BrowserConfig, KeychainVariant } from './types'
+
+export const CHROMIUM_BROWSERS: BrowserConfig[] = [
+  {
+    name: 'Chrome',
+    darwin: join('Google', 'Chrome'),
+    linux: 'google-chrome',
+    win32: join('Google', 'Chrome', 'User Data'),
+  },
+  {
+    name: 'Chrome Canary',
+    darwin: join('Google', 'Chrome Canary'),
+    linux: 'google-chrome-unstable',
+    win32: join('Google', 'Chrome SxS', 'User Data'),
+  },
+  { name: 'Edge', darwin: 'Microsoft Edge', linux: 'microsoft-edge', win32: join('Microsoft', 'Edge', 'User Data') },
+  { name: 'Arc', darwin: join('Arc', 'User Data'), linux: '', win32: join('Arc', 'User Data') },
+  {
+    name: 'Brave',
+    darwin: join('BraveSoftware', 'Brave-Browser'),
+    linux: join('BraveSoftware', 'Brave-Browser'),
+    win32: join('BraveSoftware', 'Brave-Browser', 'User Data'),
+  },
+  { name: 'Vivaldi', darwin: 'Vivaldi', linux: 'vivaldi', win32: join('Vivaldi', 'User Data') },
+  { name: 'Chromium', darwin: 'Chromium', linux: 'chromium', win32: join('Chromium', 'User Data') },
+]
+
+export const BROWSER_KEYCHAIN_VARIANTS: KeychainVariant[] = [
+  { service: 'Chrome Safe Storage', account: 'Chrome' },
+  { service: 'Chrome Canary Safe Storage', account: 'Chrome Canary' },
+  { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
+  { service: 'Arc Safe Storage', account: 'Arc' },
+  { service: 'Brave Safe Storage', account: 'Brave' },
+  { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
+  { service: 'Chromium Safe Storage', account: 'Chromium' },
+]
+
+export function getBrowserBasePath(browser: BrowserConfig, platform: NodeJS.Platform): string | null {
+  let relative: string
+  switch (platform) {
+    case 'darwin':
+      relative = browser.darwin
+      if (!relative) return null
+      return join(homedir(), 'Library', 'Application Support', relative)
+    case 'linux':
+      relative = browser.linux
+      if (!relative) return null
+      return join(homedir(), '.config', relative)
+    case 'win32':
+      relative = browser.win32
+      if (!relative) return null
+      return join(process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local'), relative)
+    default:
+      return null
+  }
+}
+
+export function discoverBrowserProfileDirs(browserBase: string): string[] {
+  const dirs: string[] = []
+  dirs.push(join(browserBase, 'Default'))
+  if (!existsSync(browserBase)) return dirs
+  try {
+    const entries = readdirSync(browserBase, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      if (!/^Profile \d+$/i.test(entry.name)) continue
+      dirs.push(join(browserBase, entry.name))
+    }
+  } catch {}
+  return dirs
+}
+
+export function findLocalStatePath(cookieOrProfilePath: string): string | null {
+  const parts = cookieOrProfilePath.split(/[/\\]/)
+  for (let levels = 2; levels <= 4; levels++) {
+    if (parts.length < levels) break
+    const base = parts.slice(0, parts.length - levels).join('/')
+    const candidate = join(base, 'Local State')
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}

package/src/shared/chromium/cookie-reader.test.ts

@@ -0,0 +1,274 @@
+import { Database } from 'bun:sqlite'
+import { afterEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { ChromiumCookieReader } from './cookie-reader'
+
+function createTestCookieDb(
+  dbPath: string,
+  rows: Array<{ name: string; value: string; encrypted_value: Buffer | null }>,
+): void {
+  const db = new Database(dbPath)
+  db.run('CREATE TABLE cookies (name TEXT, value TEXT, encrypted_value BLOB)')
+  const stmt = db.prepare('INSERT INTO cookies (name, value, encrypted_value) VALUES (?, ?, ?)')
+  for (const row of rows) {
+    stmt.run(row.name, row.value, row.encrypted_value)
+  }
+  db.close()
+}
+
+describe('ChromiumCookieReader', () => {
+  const tempDirs: string[] = []
+
+  afterEach(() => {
+    for (const tempDir of tempDirs.splice(0)) {
+      if (existsSync(tempDir)) {
+        rmSync(tempDir, { recursive: true, force: true })
+      }
+    }
+  })
+
+  describe('queryAll', () => {
+    test('returns all matching rows from a real SQLite database', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [
+        { name: 'session', value: 'abc123', encrypted_value: null },
+        { name: 'token', value: 'xyz789', encrypted_value: null },
+      ])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryAll<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies ORDER BY name ASC',
+      )
+
+      // then
+      expect(result).toEqual([
+        { name: 'session', value: 'abc123' },
+        { name: 'token', value: 'xyz789' },
+      ])
+    })
+
+    test('returns empty array when database file does not exist', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'missing.db')
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryAll<{ name: string }>(dbPath, 'SELECT name FROM cookies')
+
+      // then
+      expect(result).toEqual([])
+    })
+
+    test('returns empty array when query matches no rows', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [{ name: 'session', value: 'abc123', encrypted_value: null }])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryAll<{ name: string }>(dbPath, 'SELECT name FROM cookies WHERE name = ?', [
+        'missing',
+      ])
+
+      // then
+      expect(result).toEqual([])
+    })
+
+    test('supports parameterized queries with params', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [
+        { name: 'session', value: 'abc123', encrypted_value: null },
+        { name: 'token', value: 'xyz789', encrypted_value: null },
+      ])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryAll<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies WHERE name = ?',
+        ['token'],
+      )
+
+      // then
+      expect(result).toEqual([{ name: 'token', value: 'xyz789' }])
+    })
+
+    test('cleans up temp file after query', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [{ name: 'session', value: 'abc123', encrypted_value: null }])
+      const reader = new ChromiumCookieReader()
+      const originalDateNow = Date.now
+      const originalMathRandom = Math.random
+      Date.now = () => 1234567890
+      Math.random = () => 0
+      const expectedTempPath = join(tmpdir(), 'chromium-cookies-1234567890-.db')
+
+      try {
+        // when
+        await reader.queryAll<{ name: string }>(dbPath, 'SELECT name FROM cookies')
+
+        // then
+        expect(existsSync(expectedTempPath)).toBe(false)
+      } finally {
+        Date.now = originalDateNow
+        Math.random = originalMathRandom
+      }
+    })
+  })
+
+  describe('queryFirst', () => {
+    test('returns first matching row from a real SQLite database', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [
+        { name: 'session', value: 'abc123', encrypted_value: null },
+        { name: 'token', value: 'xyz789', encrypted_value: null },
+      ])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryFirst<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies ORDER BY name ASC',
+      )
+
+      // then
+      expect(result).toEqual({ name: 'session', value: 'abc123' })
+    })
+
+    test('returns null when database file does not exist', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'missing.db')
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryFirst<{ name: string }>(dbPath, 'SELECT name FROM cookies')
+
+      // then
+      expect(result).toBeNull()
+    })
+
+    test('returns null when query matches no rows', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [{ name: 'session', value: 'abc123', encrypted_value: null }])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryFirst<{ name: string }>(dbPath, 'SELECT name FROM cookies WHERE name = ?', [
+        'missing',
+      ])
+
+      // then
+      expect(result).toBeNull()
+    })
+
+    test('supports parameterized queries with params', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [
+        { name: 'session', value: 'abc123', encrypted_value: null },
+        { name: 'token', value: 'xyz789', encrypted_value: null },
+      ])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryFirst<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies WHERE name = ?',
+        ['token'],
+      )
+
+      // then
+      expect(result).toEqual({ name: 'token', value: 'xyz789' })
+    })
+  })
+
+  describe('edge cases', () => {
+    test('handles multiple calls to same reader instance', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [
+        { name: 'session', value: 'abc123', encrypted_value: null },
+        { name: 'token', value: 'xyz789', encrypted_value: null },
+      ])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const allRows = await reader.queryAll<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies ORDER BY name ASC',
+      )
+      const firstRow = await reader.queryFirst<{ name: string; value: string }>(
+        dbPath,
+        'SELECT name, value FROM cookies WHERE name = ?',
+        ['token'],
+      )
+
+      // then
+      expect(allRows).toEqual([
+        { name: 'session', value: 'abc123' },
+        { name: 'token', value: 'xyz789' },
+      ])
+      expect(firstRow).toEqual({ name: 'token', value: 'xyz789' })
+    })
+
+    test('returns empty array for malformed SQL without throwing', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [{ name: 'session', value: 'abc123', encrypted_value: null }])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryAll<{ name: string }>(dbPath, 'SELECT FROM cookies')
+
+      // then
+      expect(result).toEqual([])
+    })
+
+    test('returns null for malformed SQL without throwing', async () => {
+      // given
+      const tempDir = mkdtempSync(join(tmpdir(), 'chromium-cookie-reader-'))
+      tempDirs.push(tempDir)
+      const dbPath = join(tempDir, 'Cookies')
+      createTestCookieDb(dbPath, [{ name: 'session', value: 'abc123', encrypted_value: null }])
+      const reader = new ChromiumCookieReader()
+
+      // when
+      const result = await reader.queryFirst<{ name: string }>(dbPath, 'SELECT FROM cookies')
+
+      // then
+      expect(result).toBeNull()
+    })
+  })
+})