agent-messenger 1.0.0

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

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'bun:test'
+import { parallelMap } from './concurrency'
+
+describe('parallelMap', () => {
+  test('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 () => {
+    const items = [100, 50, 10]
+    const results = await parallelMap(
+      items,
+      async (delay) => {
+        await new Promise((r) => setTimeout(r, delay))
+        return delay
+      },
+      3
+    )
+    expect(results).toEqual([100, 50, 10])
+  })
+
+  test('respects concurrency limit', async () => {
+    let concurrent = 0
+    let maxConcurrent = 0
+    const items = [1, 2, 3, 4, 5, 6]
+
+    await parallelMap(
+      items,
+      async () => {
+        concurrent++
+        maxConcurrent = Math.max(maxConcurrent, concurrent)
+        await new Promise((r) => setTimeout(r, 10))
+        concurrent--
+      },
+      2
+    )
+
+    expect(maxConcurrent).toBe(2)
+  })
+
+  test('handles empty array', async () => {
+    const results = await parallelMap([], async (n: number) => n * 2)
+    expect(results).toEqual([])
+  })
+
+  test('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/concurrency.ts

@@ -0,0 +1,20 @@
+export async function parallelMap<T, R>(
+  items: T[],
+  fn: (item: T, index: number) => Promise<R>,
+  concurrency = 5
+): Promise<R[]> {
+  const results: R[] = new Array(items.length)
+  let currentIndex = 0
+
+  async function worker(): Promise<void> {
+    while (currentIndex < items.length) {
+      const index = currentIndex++
+      results[index] = await fn(items[index], index)
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
+  await Promise.all(workers)
+
+  return results
+}

package/src/shared/utils/error-handler.ts

@@ -0,0 +1,4 @@
+export function handleError(error: Error): void {
+  console.error(JSON.stringify({ error: error.message }))
+  process.exit(1)
+}

package/src/shared/utils/output.ts

@@ -0,0 +1,3 @@
+export function formatOutput(data: unknown, pretty?: boolean): string {
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data)
+}

package/tests/cli.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test'
+import { spawn } from 'bun'
+import pkg from '../package.json'
+import { handleError } from '../src/shared/utils/error-handler'
+import { formatOutput } from '../src/shared/utils/output'
+
+describe('CLI Framework', () => {
+  describe('formatOutput utility', () => {
+    test('formats JSON without pretty flag', () => {
+      const data = { message: 'hello', count: 42 }
+      const result = formatOutput(data, false)
+      expect(result).toBe('{"message":"hello","count":42}')
+    })
+
+    test('formats JSON with pretty flag', () => {
+      const data = { message: 'hello', count: 42 }
+      const result = formatOutput(data, true)
+      const expected = JSON.stringify(data, null, 2)
+      expect(result).toBe(expected)
+    })
+
+    test('handles arrays', () => {
+      const data = [1, 2, 3]
+      const result = formatOutput(data, false)
+      expect(result).toBe('[1,2,3]')
+    })
+
+    test('handles nested objects with pretty flag', () => {
+      const data = { user: { name: 'Alice', id: 1 } }
+      const result = formatOutput(data, true)
+      expect(result).toContain('"user"')
+      expect(result).toContain('"name"')
+    })
+  })
+
+  describe('handleError utility', () => {
+    test('logs error as JSON and exits', () => {
+      const originalExit = process.exit
+      const originalError = console.error
+      let capturedOutput = ''
+
+      console.error = (msg: string) => {
+        capturedOutput = msg
+      }
+      process.exit = (() => {
+        throw new Error('EXIT_CALLED')
+      }) as never
+
+      try {
+        handleError(new Error('Test error'))
+      } catch (e) {
+        if (e instanceof Error && e.message === 'EXIT_CALLED') {
+          expect(capturedOutput).toContain('Test error')
+          expect(capturedOutput).toContain('error')
+        }
+      }
+
+      console.error = originalError
+      process.exit = originalExit
+    })
+  })
+
+  describe('Slack CLI program structure', () => {
+    test('--help shows all commands and global options', async () => {
+      const proc = spawn(['bun', 'run', './src/platforms/slack/cli.ts', '--help'], {
+        cwd: process.cwd(),
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+
+      const output = await new Response(proc.stdout).text()
+
+      expect(output).toContain('auth')
+      expect(output).toContain('workspace')
+      expect(output).toContain('message')
+      expect(output).toContain('channel')
+      expect(output).toContain('user')
+      expect(output).toContain('reaction')
+      expect(output).toContain('file')
+      expect(output).toContain('snapshot')
+      expect(output).toContain('--pretty')
+      expect(output).toContain('--workspace')
+    })
+
+    test('--version shows package version', async () => {
+      const proc = spawn(['bun', 'run', './src/platforms/slack/cli.ts', '--version'], {
+        cwd: process.cwd(),
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+
+      const output = await new Response(proc.stdout).text()
+      expect(output.trim()).toBe(pkg.version)
+    })
+  })
+})

package/tests/commands/auth.test.ts

@@ -0,0 +1,383 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { mkdirSync, rmSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { CredentialManager } from '../../src/platforms/slack/credential-manager'
+import { type ExtractedWorkspace, TokenExtractor } from '../../src/platforms/slack/token-extractor'
+
+const testConfigDir = join(import.meta.dir, '.test-auth-config')
+const testSlackDir = join(import.meta.dir, '.test-slack-data')
+
+describe('TokenExtractor', () => {
+  let extractor: TokenExtractor
+
+  beforeEach(() => {
+    rmSync(testSlackDir, { recursive: true, force: true })
+    mkdirSync(testSlackDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    rmSync(testSlackDir, { recursive: true, force: true })
+  })
+
+  describe('getSlackDir', () => {
+    test('returns correct path for darwin', () => {
+      // Given: Platform is darwin
+      extractor = new TokenExtractor('darwin')
+
+      // When: getSlackDir is called
+      const dir = extractor.getSlackDir()
+
+      // Then: Should return macOS path (direct or sandboxed depending on what exists)
+      const directPath = join(homedir(), 'Library', 'Application Support', 'Slack')
+      const sandboxedPath = join(
+        homedir(),
+        'Library',
+        'Containers',
+        'com.tinyspeck.slackmacgap',
+        'Data',
+        'Library',
+        'Application Support',
+        'Slack'
+      )
+      expect([directPath, sandboxedPath]).toContain(dir)
+    })
+
+    test('returns correct path for linux', () => {
+      // Given: Platform is linux
+      extractor = new TokenExtractor('linux')
+
+      // When: getSlackDir is called
+      const dir = extractor.getSlackDir()
+
+      // Then: Should return Linux path
+      expect(dir).toBe(join(homedir(), '.config', 'Slack'))
+    })
+
+    test('returns correct path for win32', () => {
+      // Given: Platform is win32
+      extractor = new TokenExtractor('win32')
+
+      // When: getSlackDir is called
+      const dir = extractor.getSlackDir()
+
+      // Then: Should return Windows path
+      expect(dir).toContain('Slack')
+    })
+
+    test('throws error for unsupported platform', () => {
+      // Given: Platform is unsupported
+      // When/Then: Constructor should throw
+      expect(() => new TokenExtractor('freebsd' as NodeJS.Platform)).toThrow('Unsupported platform')
+    })
+  })
+
+  describe('extract', () => {
+    test('throws error when Slack directory does not exist', async () => {
+      // Given: Slack directory does not exist
+      extractor = new TokenExtractor('darwin', '/nonexistent/path')
+
+      // When/Then: extract should throw
+      await expect(extractor.extract()).rejects.toThrow('Slack directory not found')
+    })
+
+    test('returns empty array when no tokens found', async () => {
+      // Given: Slack directory exists but has no tokens
+      mkdirSync(join(testSlackDir, 'storage'), { recursive: true })
+      extractor = new TokenExtractor('darwin', testSlackDir)
+
+      // When: extract is called
+      const result = await extractor.extract()
+
+      // Then: Should return empty array
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('extractTokensFromLevelDB', () => {
+    test('extracts xoxc tokens from LevelDB', async () => {
+      // Given: LevelDB with xoxc token data
+      // This test requires mocking LevelDB - we'll test the integration
+      extractor = new TokenExtractor('darwin', testSlackDir)
+
+      // When: extractTokensFromLevelDB is called
+      // Then: Should extract tokens (mocked in integration test)
+      expect(extractor).toBeDefined()
+    })
+  })
+
+  describe('extractCookieFromSQLite', () => {
+    test('extracts xoxd cookie from SQLite', async () => {
+      // Given: SQLite Cookies database with d cookie
+      // This test requires mocking SQLite - we'll test the integration
+      extractor = new TokenExtractor('darwin', testSlackDir)
+
+      // When: extractCookieFromSQLite is called
+      // Then: Should extract cookie (mocked in integration test)
+      expect(extractor).toBeDefined()
+    })
+  })
+})
+
+describe('Auth Commands Integration', () => {
+  let credManager: CredentialManager
+
+  beforeEach(() => {
+    rmSync(testConfigDir, { recursive: true, force: true })
+    credManager = new CredentialManager(testConfigDir)
+  })
+
+  afterAll(() => {
+    rmSync(testConfigDir, { recursive: true, force: true })
+  })
+
+  describe('auth extract', () => {
+    test('stores extracted workspaces in credential manager', async () => {
+      // Given: Extracted workspaces
+      const workspaces: ExtractedWorkspace[] = [
+        {
+          workspace_id: 'T123',
+          workspace_name: 'acme-corp',
+          token: 'xoxc-123-456',
+          cookie: 'xoxd-abc',
+        },
+        {
+          workspace_id: 'T456',
+          workspace_name: 'side-project',
+          token: 'xoxc-789-012',
+          cookie: 'xoxd-def',
+        },
+      ]
+
+      // When: Workspaces are stored
+      for (const ws of workspaces) {
+        await credManager.setWorkspace(ws)
+      }
+      await credManager.setCurrentWorkspace('T123')
+
+      // Then: All workspaces should be retrievable
+      const config = await credManager.load()
+      expect(Object.keys(config.workspaces)).toHaveLength(2)
+      expect(config.current_workspace).toBe('T123')
+      expect(config.workspaces.T123.token).toBe('xoxc-123-456')
+      expect(config.workspaces.T456.token).toBe('xoxc-789-012')
+    })
+
+    test('sets first workspace as current if none exists', async () => {
+      // Given: No current workspace
+      const workspace: ExtractedWorkspace = {
+        workspace_id: 'T789',
+        workspace_name: 'new-workspace',
+        token: 'xoxc-new',
+        cookie: 'xoxd-new',
+      }
+
+      // When: First workspace is stored
+      await credManager.setWorkspace(workspace)
+      const config = await credManager.load()
+
+      // Then: If no current, should set first as current
+      if (!config.current_workspace) {
+        await credManager.setCurrentWorkspace('T789')
+      }
+
+      const updated = await credManager.load()
+      expect(updated.current_workspace).toBe('T789')
+    })
+  })
+
+  describe('auth logout', () => {
+    test('removes workspace by id', async () => {
+      // Given: A workspace exists
+      await credManager.setWorkspace({
+        workspace_id: 'T-logout',
+        workspace_name: 'to-logout',
+        token: 'xoxc-logout',
+        cookie: 'xoxd-logout',
+      })
+
+      // When: Workspace is removed
+      await credManager.removeWorkspace('T-logout')
+
+      // Then: Workspace should not exist
+      const ws = await credManager.getWorkspace('T-logout')
+      expect(ws).toBeNull()
+    })
+
+    test('removes current workspace and clears current', async () => {
+      // Given: Current workspace is set
+      await credManager.setWorkspace({
+        workspace_id: 'T-current',
+        workspace_name: 'current',
+        token: 'xoxc-current',
+        cookie: 'xoxd-current',
+      })
+      await credManager.setCurrentWorkspace('T-current')
+
+      // When: Current workspace is removed
+      await credManager.removeWorkspace('T-current')
+
+      // Then: Current should be null
+      const config = await credManager.load()
+      expect(config.current_workspace).toBeNull()
+    })
+
+    test('throws error when workspace not found', async () => {
+      // Given: Workspace does not exist
+      // When: Trying to get non-existent workspace
+      const ws = await credManager.getWorkspace('nonexistent')
+
+      // Then: Should return null (command should handle this)
+      expect(ws).toBeNull()
+    })
+  })
+
+  describe('auth status', () => {
+    test('returns current workspace info', async () => {
+      // Given: A current workspace is set
+      await credManager.setWorkspace({
+        workspace_id: 'T-status',
+        workspace_name: 'status-test',
+        token: 'xoxc-status',
+        cookie: 'xoxd-status',
+      })
+      await credManager.setCurrentWorkspace('T-status')
+
+      // When: Getting current workspace
+      const ws = await credManager.getWorkspace()
+
+      // Then: Should return workspace info
+      expect(ws).not.toBeNull()
+      expect(ws?.workspace_id).toBe('T-status')
+      expect(ws?.workspace_name).toBe('status-test')
+    })
+
+    test('returns null when no workspace configured', async () => {
+      // Given: No workspace configured
+      // When: Getting current workspace
+      const ws = await credManager.getWorkspace()
+
+      // Then: Should return null
+      expect(ws).toBeNull()
+    })
+
+    test('validates token with Slack API', async () => {
+      // Given: A workspace with valid credentials
+      // This would require mocking SlackClient.testAuth()
+      // We test the integration pattern here
+
+      const mockTestAuth = mock(() =>
+        Promise.resolve({
+          user_id: 'U123',
+          team_id: 'T123',
+          user: 'testuser',
+          team: 'Test Team',
+        })
+      )
+
+      // When: testAuth is called
+      const result = await mockTestAuth()
+
+      // Then: Should return auth info
+      expect(result.user_id).toBe('U123')
+      expect(result.team_id).toBe('T123')
+      expect(result.user).toBe('testuser')
+      expect(result.team).toBe('Test Team')
+    })
+  })
+})
+
+describe('Platform Detection', () => {
+  test('auto-detects current platform', () => {
+    // Given: Running on current platform
+    const platform = process.platform
+
+    // When: TokenExtractor is created without explicit platform
+    const _extractor = new TokenExtractor()
+
+    // Then: Should use current platform
+    expect(['darwin', 'linux', 'win32']).toContain(platform)
+  })
+})
+
+describe('Output Formatting', () => {
+  test('formats extract output correctly', () => {
+    // Given: Extracted workspaces
+    const output = {
+      workspaces: ['T123/acme-corp', 'T456/side-project'],
+      current: 'T123',
+    }
+
+    // When: Formatted as JSON
+    const json = JSON.stringify(output)
+    const pretty = JSON.stringify(output, null, 2)
+
+    // Then: Should be valid JSON
+    expect(JSON.parse(json)).toEqual(output)
+    expect(pretty).toContain('\n')
+  })
+
+  test('formats status output correctly', () => {
+    // Given: Status info
+    const output = {
+      workspace_id: 'T123',
+      workspace_name: 'acme-corp',
+      user: 'testuser',
+      team: 'Acme Corp',
+      valid: true,
+    }
+
+    // When: Formatted as JSON
+    const json = JSON.stringify(output)
+
+    // Then: Should be valid JSON
+    expect(JSON.parse(json)).toEqual(output)
+  })
+
+  test('formats logout output correctly', () => {
+    // Given: Logout result
+    const output = {
+      removed: 'T123',
+      success: true,
+    }
+
+    // When: Formatted as JSON
+    const json = JSON.stringify(output)
+
+    // Then: Should be valid JSON
+    expect(JSON.parse(json)).toEqual(output)
+  })
+})
+
+describe('Error Handling', () => {
+  test('handles missing Slack installation gracefully', async () => {
+    // Given: Slack is not installed
+    const extractor = new TokenExtractor('darwin', '/nonexistent/slack')
+
+    // When/Then: Should throw descriptive error
+    await expect(extractor.extract()).rejects.toThrow('Slack directory not found')
+  })
+
+  test('handles corrupted LevelDB gracefully', async () => {
+    // Given: Corrupted LevelDB
+    // This would require creating a corrupted LevelDB file
+    // We test that the extractor handles errors gracefully
+    const extractor = new TokenExtractor('darwin', testSlackDir)
+
+    // When: Trying to extract from non-existent storage
+    // Then: Should handle gracefully (return empty or throw)
+    await expect(extractor.extract()).rejects.toThrow()
+  })
+
+  test('handles missing Cookies database gracefully', async () => {
+    // Given: No Cookies database
+    mkdirSync(join(testSlackDir, 'storage'), { recursive: true })
+    const extractor = new TokenExtractor('darwin', testSlackDir)
+
+    // When: Trying to extract
+    const result = await extractor.extract()
+
+    // Then: Should return empty array (no tokens found)
+    expect(result).toEqual([])
+  })
+})