agent-messenger 2.10.1 → 2.10.2

package/src/shared/chromium/decryptor.ts

@@ -187,22 +187,43 @@ export class ChromiumCookieDecryptor {
     if (this.platform !== 'win32') return null
     try {
       const b64Input = encrypted.toString('base64')
+      // Silence progress/information/warning streams so PowerShell doesn't emit CLIXML
+      // ("#< CLIXML ...") alongside our base64 payload when modules auto-load on first use.
+      // Wrap the payload in explicit markers so we can recover it even if stray output leaks in.
       const script = [
+        "$ProgressPreference='SilentlyContinue'",
+        "$InformationPreference='SilentlyContinue'",
+        "$WarningPreference='SilentlyContinue'",
         'Add-Type -AssemblyName System.Security',
         `$d=[System.Security.Cryptography.ProtectedData]::Unprotect([Convert]::FromBase64String("${b64Input}"),$null,[System.Security.Cryptography.DataProtectionScope]::CurrentUser)`,
-        '[Convert]::ToBase64String($d)',
+        "Write-Host ('<<<B64>>>'+[Convert]::ToBase64String($d)+'<<<END>>>')",
       ].join(';')
       const encodedCommand = Buffer.from(script, 'utf16le').toString('base64')
-      const result = execSync(`powershell -NoProfile -NonInteractive -EncodedCommand ${encodedCommand}`, {
-        encoding: 'utf8',
-        timeout: 10000,
-      }).trim()
-      return Buffer.from(result, 'base64')
+      const rawResult = execSync(
+        `powershell -NoProfile -NonInteractive -OutputFormat Text -EncodedCommand ${encodedCommand}`,
+        { encoding: 'utf8', timeout: 10000 },
+      )
+      const b64 = ChromiumCookieDecryptor.extractDPAPIPayload(rawResult)
+      if (!b64) return null
+      return Buffer.from(b64, 'base64')
     } catch {
       return null
     }
   }
 
+  /**
+   * Extract the base64-encoded DPAPI payload from PowerShell stdout, stripping any
+   * CLIXML progress-stream contamination or other stray output. Returns null if
+   * no valid payload is found.
+   */
+  static extractDPAPIPayload(stdout: string): string | null {
+    const match = stdout.match(/<<<B64>>>([A-Za-z0-9+/=\r\n]*)<<<END>>>/)
+    if (!match) return null
+    const b64 = match[1].replace(/\s+/g, '')
+    if (!b64) return null
+    return b64
+  }
+
   static stripIntegrityHash(decrypted: Buffer): Buffer {
     if (decrypted.length <= 32) return decrypted
     const hasNonPrintablePrefix = decrypted.subarray(0, 32).some((b) => b < 0x20 || b > 0x7e)

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/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')
   })
 })