agent-messenger 1.0.0 → 1.1.0

package/{tests → src/platforms/slack}/cli.test.ts

@@ -1,8 +1,8 @@
 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'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import pkg from '../../../package.json'
 
 describe('CLI Framework', () => {
   describe('formatOutput utility', () => {

package/{tests/slack-client.test.ts → src/platforms/slack/client.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from 'bun:test'
 import type { WebClient } from '@slack/web-api'
-import { SlackClient, SlackError } from '../src/platforms/slack/client'
+import { SlackClient, SlackError } from '@/platforms/slack/client'
 
 const mockWebClient: any = {
   conversations: {

package/{tests → src/platforms/slack}/commands/auth.test.ts

@@ -2,8 +2,8 @@ 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'
+import { CredentialManager } from '@/platforms/slack/credential-manager'
+import { type ExtractedWorkspace, TokenExtractor } from '@/platforms/slack/token-extractor'
 
 const testConfigDir = join(import.meta.dir, '.test-auth-config')
 const testSlackDir = join(import.meta.dir, '.test-slack-data')
@@ -74,8 +74,9 @@ describe('TokenExtractor', () => {
 
   describe('extract', () => {
     test('throws error when Slack directory does not exist', async () => {
-      // Given: Slack directory does not exist
-      extractor = new TokenExtractor('darwin', '/nonexistent/path')
+      // Given: Slack directory does not exist (use unique path to avoid any collision)
+      const nonExistentPath = `/tmp/nonexistent-slack-${Date.now()}-${Math.random()}`
+      extractor = new TokenExtractor('darwin', nonExistentPath)
 
       // When/Then: extract should throw
       await expect(extractor.extract()).rejects.toThrow('Slack directory not found')
@@ -124,6 +125,7 @@ describe('Auth Commands Integration', () => {
 
   beforeEach(() => {
     rmSync(testConfigDir, { recursive: true, force: true })
+    mkdirSync(testConfigDir, { recursive: true })
     credManager = new CredentialManager(testConfigDir)
   })
 
@@ -350,23 +352,33 @@ describe('Output Formatting', () => {
 })
 
 describe('Error Handling', () => {
+  beforeEach(() => {
+    rmSync(testSlackDir, { recursive: true, force: true })
+    mkdirSync(testSlackDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    rmSync(testSlackDir, { recursive: true, force: true })
+  })
+
   test('handles missing Slack installation gracefully', async () => {
-    // Given: Slack is not installed
-    const extractor = new TokenExtractor('darwin', '/nonexistent/slack')
+    // Given: Slack is not installed (use unique path)
+    const nonExistentPath = `/tmp/nonexistent-slack-${Date.now()}-${Math.random()}`
+    const extractor = new TokenExtractor('darwin', nonExistentPath)
 
     // 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
+  test('handles empty Slack directory gracefully', async () => {
+    // Given: Slack directory exists but has no data
     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()
+    // When: Trying to extract from empty directory
+    const result = await extractor.extract()
+
+    // Then: Should return empty array
+    expect(result).toEqual([])
   })
 
   test('handles missing Cookies database gracefully', async () => {

package/{tests → src/platforms/slack}/commands/channel.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from 'bun:test'
-import { SlackClient } from '../../src/platforms/slack/client'
-import type { SlackChannel } from '../../src/platforms/slack/types'
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackChannel } from '@/platforms/slack/types'
 
 describe('Channel Commands', () => {
   let mockClient: SlackClient

package/{tests → src/platforms/slack}/commands/file.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from 'bun:test'
-import { SlackClient } from '../../src/platforms/slack/client'
-import type { SlackFile } from '../../src/platforms/slack/types'
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackFile } from '@/platforms/slack/types'
 
 describe('File Commands', () => {
   let mockClient: SlackClient

package/{tests → src/platforms/slack}/commands/message.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from 'bun:test'
-import { SlackClient } from '../../src/platforms/slack/client'
-import type { SlackMessage } from '../../src/platforms/slack/types'
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackMessage } from '@/platforms/slack/types'
 
 describe('Message Commands', () => {
   let mockClient: SlackClient

package/{tests → src/platforms/slack}/commands/reaction.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, mock, test } from 'bun:test'
 import { Command } from 'commander'
-import { reactionCommand } from '../../src/platforms/slack/commands/reaction'
+import { reactionCommand } from '@/platforms/slack/commands/reaction'
 
 describe('reaction command', () => {
   describe('add subcommand', () => {

package/{tests → src/platforms/slack}/commands/snapshot.test.ts

@@ -1,113 +1,10 @@
-import { expect, mock, test } from 'bun:test'
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
 import { SlackClient } from '@/platforms/slack/client'
 import { snapshotCommand } from '@/platforms/slack/commands/snapshot'
 import { CredentialManager } from '@/platforms/slack/credential-manager'
 import type { SlackChannel, SlackMessage, SlackUser } from '@/platforms/slack/types'
 
-mock.module('@/platforms/slack/credential-manager', () => ({
-  CredentialManager: class {
-    async getWorkspace() {
-      return {
-        workspace_id: 'T123',
-        workspace_name: 'Test Workspace',
-        token: 'xoxc-test',
-        cookie: 'test-cookie',
-      }
-    }
-  },
-}))
-
-mock.module('@/platforms/slack/client', () => ({
-  SlackClient: class {
-    async testAuth() {
-      return {
-        user_id: 'U123',
-        team_id: 'T123',
-        user: 'testuser',
-        team: 'Test Workspace',
-      }
-    }
-    async listChannels(): Promise<SlackChannel[]> {
-      return [
-        {
-          id: 'C123',
-          name: 'general',
-          is_private: false,
-          is_archived: false,
-          created: 1234567890,
-          creator: 'U123',
-          topic: { value: 'General discussion', creator: 'U123', last_set: 1234567890 },
-          purpose: { value: 'General channel', creator: 'U123', last_set: 1234567890 },
-        },
-        {
-          id: 'C456',
-          name: 'random',
-          is_private: false,
-          is_archived: false,
-          created: 1234567891,
-          creator: 'U123',
-          topic: { value: 'Random stuff', creator: 'U123', last_set: 1234567891 },
-          purpose: { value: 'Random channel', creator: 'U123', last_set: 1234567891 },
-        },
-      ]
-    }
-    async getMessages(_channel: string, _limit?: number): Promise<SlackMessage[]> {
-      return [
-        {
-          ts: '1234567890.000100',
-          text: 'Hello world',
-          type: 'message',
-          user: 'U123',
-          username: 'testuser',
-          thread_ts: undefined,
-          reply_count: 0,
-          edited: undefined,
-        },
-        {
-          ts: '1234567890.000200',
-          text: 'Second message',
-          type: 'message',
-          user: 'U456',
-          username: 'otheruser',
-          thread_ts: undefined,
-          reply_count: 0,
-          edited: undefined,
-        },
-      ]
-    }
-    async listUsers(): Promise<SlackUser[]> {
-      return [
-        {
-          id: 'U123',
-          name: 'alice',
-          real_name: 'Alice Smith',
-          is_admin: true,
-          is_owner: false,
-          is_bot: false,
-          is_app_user: false,
-          profile: {
-            email: 'alice@example.com',
-            title: 'Engineer',
-          },
-        },
-        {
-          id: 'U456',
-          name: 'bob',
-          real_name: 'Bob Jones',
-          is_admin: false,
-          is_owner: false,
-          is_bot: false,
-          is_app_user: false,
-          profile: {
-            email: 'bob@example.com',
-            title: 'Designer',
-          },
-        },
-      ]
-    }
-  },
-}))
-
+// Test the command structure (no mocks needed)
 test('snapshot command exports correctly', () => {
   expect(snapshotCommand).toBeDefined()
   expect(typeof snapshotCommand).toBe('object')
@@ -136,6 +33,121 @@ test('snapshot command has --limit option', () => {
   expect(hasLimit).toBe(true)
 })
 
+// Test snapshot logic using spyOn (no global mock pollution)
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let clientListChannelsSpy: ReturnType<typeof spyOn>
+let clientListUsersSpy: ReturnType<typeof spyOn>
+let clientGetMessagesSpy: ReturnType<typeof spyOn>
+
+const mockChannels: SlackChannel[] = [
+  {
+    id: 'C123',
+    name: 'general',
+    is_private: false,
+    is_archived: false,
+    created: 1234567890,
+    creator: 'U123',
+    topic: { value: 'General discussion', creator: 'U123', last_set: 1234567890 },
+    purpose: { value: 'General channel', creator: 'U123', last_set: 1234567890 },
+  },
+  {
+    id: 'C456',
+    name: 'random',
+    is_private: false,
+    is_archived: false,
+    created: 1234567891,
+    creator: 'U123',
+    topic: { value: 'Random stuff', creator: 'U123', last_set: 1234567891 },
+    purpose: { value: 'Random channel', creator: 'U123', last_set: 1234567891 },
+  },
+]
+
+const mockMessages: SlackMessage[] = [
+  {
+    ts: '1234567890.000100',
+    text: 'Hello world',
+    type: 'message',
+    user: 'U123',
+    username: 'testuser',
+    thread_ts: undefined,
+    reply_count: 0,
+    edited: undefined,
+  },
+  {
+    ts: '1234567890.000200',
+    text: 'Second message',
+    type: 'message',
+    user: 'U456',
+    username: 'otheruser',
+    thread_ts: undefined,
+    reply_count: 0,
+    edited: undefined,
+  },
+]
+
+const mockUsers: SlackUser[] = [
+  {
+    id: 'U123',
+    name: 'alice',
+    real_name: 'Alice Smith',
+    is_admin: true,
+    is_owner: false,
+    is_bot: false,
+    is_app_user: false,
+    profile: {
+      email: 'alice@example.com',
+      title: 'Engineer',
+    },
+  },
+  {
+    id: 'U456',
+    name: 'bob',
+    real_name: 'Bob Jones',
+    is_admin: false,
+    is_owner: false,
+    is_bot: false,
+    is_app_user: false,
+    profile: {
+      email: 'bob@example.com',
+      title: 'Designer',
+    },
+  },
+]
+
+beforeEach(() => {
+  // Spy on CredentialManager.prototype.getWorkspace
+  credManagerSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue({
+    workspace_id: 'T123',
+    workspace_name: 'Test Workspace',
+    token: 'xoxc-test',
+    cookie: 'test-cookie',
+  })
+
+  // Spy on SlackClient.prototype methods
+  clientTestAuthSpy = spyOn(SlackClient.prototype, 'testAuth').mockResolvedValue({
+    user_id: 'U123',
+    team_id: 'T123',
+    user: 'testuser',
+    team: 'Test Workspace',
+  })
+
+  clientListChannelsSpy = spyOn(SlackClient.prototype, 'listChannels').mockResolvedValue(
+    mockChannels
+  )
+  clientListUsersSpy = spyOn(SlackClient.prototype, 'listUsers').mockResolvedValue(mockUsers)
+  clientGetMessagesSpy = spyOn(SlackClient.prototype, 'getMessages').mockResolvedValue(mockMessages)
+})
+
+afterEach(() => {
+  // Restore all spies
+  credManagerSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  clientListChannelsSpy?.mockRestore()
+  clientListUsersSpy?.mockRestore()
+  clientGetMessagesSpy?.mockRestore()
+})
+
 test('full snapshot returns workspace, channels, messages, and users', async () => {
   const credManager = new CredentialManager()
   const client = new SlackClient('xoxc-test', 'test-cookie')

package/{tests → src/platforms/slack}/commands/user.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'bun:test'
-import { SlackClient } from '../../src/platforms/slack/client'
-import { userCommand } from '../../src/platforms/slack/commands/user'
-import type { SlackUser } from '../../src/platforms/slack/types'
+import { SlackClient } from '@/platforms/slack/client'
+import { userCommand } from '@/platforms/slack/commands/user'
+import type { SlackUser } from '@/platforms/slack/types'
 
 // Mock users
 const mockUsers: SlackUser[] = [