agent-messenger 1.0.0 → 1.2.0

package/src/platforms/slack/commands/activity.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+async function listAction(options: {
+  pretty?: boolean
+  unread?: boolean
+  limit?: string
+  types?: string
+}): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(
+        formatOutput(
+          { error: 'No workspace configured. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(ws.token, ws.cookie)
+
+    const mode = options.unread ? 'priority_unreads_v1' : 'chrono_reads_and_unreads'
+    const limit = options.limit ? parseInt(options.limit, 10) : 20
+
+    const items = await client.getActivityFeed({
+      types: options.types,
+      mode,
+      limit,
+    })
+
+    console.log(
+      formatOutput(
+        {
+          items,
+          count: items.length,
+        },
+        options.pretty
+      )
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const activityCommand = new Command('activity')
+  .description('Activity feed commands')
+  .addCommand(
+    new Command('list')
+      .description('List activity feed items')
+      .option('--pretty', 'Pretty print JSON output')
+      .option('--unread', 'Show only unread activity')
+      .option('--limit <number>', 'Number of items to return (default: 20)')
+      .option(
+        '--types <types>',
+        'Filter by activity types (comma-separated: thread_reply,message_reaction,at_user,at_channel,keyword)'
+      )
+      .action(listAction)
+  )

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/src/platforms/slack/commands/drafts.test.ts

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackClient } from '@/platforms/slack/client'
+
+describe('Drafts Commands', () => {
+  let mockClient: SlackClient
+
+  beforeEach(() => {
+    // Mock SlackClient
+    mockClient = {
+      getDrafts: mock(async (cursor?: string) => ({
+        drafts: [
+          {
+            id: 'D001',
+            channel_id: 'C123',
+            message: {
+              text: 'Draft message 1',
+              blocks: [],
+            },
+            date_created: 1234567890,
+            date_updated: 1234567891,
+          },
+          {
+            id: 'D002',
+            channel_id: 'C456',
+            message: {
+              text: 'Draft message 2',
+              blocks: [],
+            },
+            date_created: 1234567892,
+            date_updated: 1234567893,
+          },
+          {
+            id: 'D003',
+            channel_id: 'C789',
+            message: null,
+            date_created: 1234567894,
+            date_updated: 1234567895,
+          },
+          {
+            id: 'D004',
+            channel_id: 'C999',
+            message: {},
+            date_created: 1234567896,
+            date_updated: 1234567897,
+          },
+        ],
+        next_cursor: cursor ? undefined : 'next_page_cursor',
+      })),
+    } as any
+  })
+
+  describe('drafts list', () => {
+    test('returns drafts', async () => {
+      // Given: Client with drafts
+      // When: Getting drafts
+      const result = await mockClient.getDrafts()
+
+      // Then: Should return drafts array
+      expect(result.drafts).toHaveLength(4)
+      expect(result.drafts[0].id).toBe('D001')
+      expect(result.drafts[0].message?.text).toBe('Draft message 1')
+    })
+
+    test('handles empty message content gracefully', async () => {
+      // Given: Client with drafts including null/empty message
+      // When: Getting drafts
+      const result = await mockClient.getDrafts()
+
+      // Then: Should handle null message
+      expect(result.drafts[2].message).toBeNull()
+
+      // Then: Should handle empty object message
+      expect(result.drafts[3].message).toEqual({})
+    })
+
+    test('pagination with cursor works', async () => {
+      // Given: Client with pagination support
+      // When: Getting first page
+      const firstPage = await mockClient.getDrafts()
+
+      // Then: Should return next_cursor
+      expect(firstPage.next_cursor).toBe('next_page_cursor')
+
+      // When: Getting next page with cursor
+      const secondPage = await mockClient.getDrafts('next_page_cursor')
+
+      // Then: Should not have next_cursor (last page)
+      expect(secondPage.next_cursor).toBeUndefined()
+    })
+
+    test('returns next_cursor for pagination', async () => {
+      // Given: Client with more drafts available
+      // When: Getting drafts
+      const result = await mockClient.getDrafts()
+
+      // Then: Should include next_cursor
+      expect(result.next_cursor).toBeDefined()
+      expect(result.next_cursor).toBe('next_page_cursor')
+    })
+  })
+
+  describe('output formatting', () => {
+    test('formats draft output', async () => {
+      // Given: Drafts from API
+      const result = await mockClient.getDrafts()
+
+      // When: Formatting output
+      const output = result.drafts.map((draft) => ({
+        id: draft.id,
+        channel_id: draft.channel_id,
+        text: draft.message?.text || '',
+        date_created: draft.date_created,
+        date_updated: draft.date_updated,
+      }))
+
+      // Then: Should include draft fields
+      expect(output[0].id).toBe('D001')
+      expect(output[0].text).toBe('Draft message 1')
+    })
+
+    test('handles null message in output', async () => {
+      // Given: Draft with null message
+      const result = await mockClient.getDrafts()
+
+      // When: Formatting output with null message
+      const output = result.drafts.map((draft) => ({
+        id: draft.id,
+        text: draft.message?.text || '',
+      }))
+
+      // Then: Should use empty string for null message
+      expect(output[2].text).toBe('')
+      expect(output[3].text).toBe('')
+    })
+  })
+})

package/src/platforms/slack/commands/drafts.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+async function listAction(options: {
+  limit?: number
+  cursor?: string
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+
+    if (!workspace) {
+      console.log(
+        formatOutput(
+          { error: 'No current workspace set. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(workspace.token, workspace.cookie)
+    const result = await client.getDrafts(options.cursor)
+
+    let drafts = result.drafts
+
+    if (options.limit) {
+      drafts = drafts.slice(0, options.limit)
+    }
+
+    const output = drafts.map((draft) => ({
+      id: draft.id,
+      channel_id: draft.channel_id,
+      text: draft.message?.text || '',
+      date_created: draft.date_created,
+      date_updated: draft.date_updated,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const draftsCommand = new Command('drafts').description('Drafts commands').addCommand(
+  new Command('list')
+    .description('List message drafts')
+    .option('--limit <n>', 'Number of drafts to display')
+    .option('--cursor <cursor>', 'Pagination cursor')
+    .option('--pretty', 'Pretty print JSON output')
+    .action((options) => {
+      listAction({
+        limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        cursor: options.cursor,
+        pretty: options.pretty,
+      })
+    })
+)

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/src/platforms/slack/commands/index.ts

@@ -1,8 +1,13 @@
+export { activityCommand } from './activity'
 export { authCommand } from './auth'
 export { channelCommand } from './channel'
+export { draftsCommand } from './drafts'
 export { fileCommand } from './file'
 export { messageCommand } from './message'
 export { reactionCommand } from './reaction'
+export { savedCommand } from './saved'
+export { sectionsCommand } from './sections'
 export { snapshotCommand } from './snapshot'
+export { unreadCommand } from './unread'
 export { userCommand } from './user'
 export { workspaceCommand } from './workspace'

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/src/platforms/slack/commands/saved.test.ts

@@ -0,0 +1,140 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackSavedItem } from '@/platforms/slack/types'
+
+describe('Saved Commands', () => {
+  let mockClient: SlackClient
+
+  beforeEach(() => {
+    // Mock SlackClient
+    mockClient = {
+      getSavedItems: mock(async (cursor?: string) => {
+        const items: SlackSavedItem[] = [
+          {
+            type: 'message',
+            message: {
+              ts: '1234567890.123456',
+              text: 'Important message to save',
+              user: 'U001',
+              type: 'message',
+            },
+            channel: {
+              id: 'C001',
+              name: 'general',
+            },
+            date_created: 1234567890,
+          },
+          {
+            type: 'message',
+            message: {
+              ts: '1234567891.123456',
+              text: 'Another saved message',
+              user: 'U002',
+              type: 'message',
+            },
+            channel: {
+              id: 'C002',
+              name: 'random',
+            },
+            date_created: 1234567891,
+          },
+        ]
+
+        if (cursor === 'next_page') {
+          return {
+            items: [
+              {
+                type: 'message',
+                message: {
+                  ts: '1234567892.123456',
+                  text: 'Third saved message',
+                  user: 'U003',
+                  type: 'message',
+                },
+                channel: {
+                  id: 'C003',
+                  name: 'dev',
+                },
+                date_created: 1234567892,
+              },
+            ],
+            has_more: false,
+          }
+        }
+
+        return {
+          items,
+          has_more: true,
+          next_cursor: 'next_page',
+        }
+      }),
+    } as any
+  })
+
+  describe('saved list', () => {
+    test('lists saved items', async () => {
+      // Given: SlackClient returns saved items
+      // When: Listing saved items
+      const result = await mockClient.getSavedItems()
+
+      // Then: Should return saved items
+      expect(result.items).toHaveLength(2)
+      expect(result.items[0].message.text).toBe('Important message to save')
+      expect(result.items[1].message.text).toBe('Another saved message')
+      expect(result.has_more).toBe(true)
+      expect(result.next_cursor).toBe('next_page')
+    })
+
+    test('supports pagination with cursor', async () => {
+      // Given: SlackClient returns paginated results
+      // When: Fetching with cursor
+      const result = await mockClient.getSavedItems('next_page')
+
+      // Then: Should return next page
+      expect(result.items).toHaveLength(1)
+      expect(result.items[0].message.text).toBe('Third saved message')
+      expect(result.has_more).toBe(false)
+    })
+
+    test('returns channel information with saved items', async () => {
+      // Given: SlackClient returns saved items with channel info
+      // When: Listing saved items
+      const result = await mockClient.getSavedItems()
+
+      // Then: Should include channel details
+      expect(result.items[0].channel.id).toBe('C001')
+      expect(result.items[0].channel.name).toBe('general')
+      expect(result.items[1].channel.id).toBe('C002')
+      expect(result.items[1].channel.name).toBe('random')
+    })
+
+    test('includes date_created timestamp', async () => {
+      // Given: SlackClient returns saved items
+      // When: Listing saved items
+      const result = await mockClient.getSavedItems()
+
+      // Then: Should include creation timestamp
+      expect(result.items[0].date_created).toBe(1234567890)
+      expect(result.items[1].date_created).toBe(1234567891)
+    })
+  })
+
+  describe('CLI command: saved list', () => {
+    test('supports --limit option', async () => {
+      // Given: CLI command with --limit 50
+      // When: Executing saved list --limit 50
+      // Then: Should pass limit to API (tested via integration)
+      expect(true).toBe(true)
+    })
+
+    test('supports --cursor option for pagination', async () => {
+      // Given: CLI command with --cursor next_page
+      // When: Executing saved list --cursor next_page
+      const result = await mockClient.getSavedItems('next_page')
+
+      // Then: Should fetch next page
+      expect(result.items).toHaveLength(1)
+      expect(result.has_more).toBe(false)
+    })
+  })
+})

package/src/platforms/slack/commands/saved.ts

@@ -0,0 +1,71 @@
+import { Command } from 'commander'
+import { handleError } from '../../../shared/utils/error-handler'
+import { formatOutput } from '../../../shared/utils/output'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+
+async function listAction(options: {
+  limit?: number
+  cursor?: string
+  pretty?: boolean
+}): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+
+    if (!workspace) {
+      console.log(
+        formatOutput(
+          { error: 'No current workspace set. Run "auth extract" first.' },
+          options.pretty
+        )
+      )
+      process.exit(1)
+    }
+
+    const client = new SlackClient(workspace.token, workspace.cookie)
+    const result = await client.getSavedItems(options.cursor)
+
+    let items = result.items
+
+    if (options.limit) {
+      items = items.slice(0, options.limit)
+    }
+
+    const output = {
+      items: items.map((item) => ({
+        type: item.type,
+        message: {
+          ts: item.message.ts,
+          text: item.message.text,
+          user: item.message.user,
+          username: item.message.username,
+          thread_ts: item.message.thread_ts,
+        },
+        channel: item.channel,
+        date_created: item.date_created,
+      })),
+      has_more: result.has_more,
+      next_cursor: result.next_cursor,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const savedCommand = new Command('saved').description('Saved items commands').addCommand(
+  new Command('list')
+    .description('List saved items')
+    .option('--limit <n>', 'Number of items to display')
+    .option('--cursor <cursor>', 'Pagination cursor')
+    .option('--pretty', 'Pretty print JSON output')
+    .action((options) => {
+      listAction({
+        limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        cursor: options.cursor,
+        pretty: options.pretty,
+      })
+    })
+)

package/src/platforms/slack/commands/sections.test.ts

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackClient } from '@/platforms/slack/client'
+
+describe('Sections Commands', () => {
+  let mockClient: SlackClient
+
+  beforeEach(() => {
+    // Mock SlackClient
+    mockClient = {
+      getChannelSections: mock(async () => [
+        {
+          id: 'S001',
+          name: 'Work Projects',
+          channel_ids: ['C001', 'C002', 'C003'],
+          date_created: 1234567890,
+          date_updated: 1234567900,
+        },
+        {
+          id: 'S002',
+          name: 'Personal',
+          channel_ids: ['C004', 'C005'],
+          date_created: 1234567891,
+          date_updated: 1234567901,
+        },
+        {
+          id: 'S003',
+          name: 'Archive',
+          channel_ids: [],
+          date_created: 1234567892,
+          date_updated: 1234567902,
+        },
+      ]),
+    } as any
+  })
+
+  describe('sections list', () => {
+    test('lists all channel sections', async () => {
+      // Given: SlackClient returns channel sections
+      // When: Listing sections
+      const sections = await mockClient.getChannelSections()
+
+      // Then: Should return sections
+      expect(sections).toHaveLength(3)
+      expect(sections[0].name).toBe('Work Projects')
+      expect(sections[1].name).toBe('Personal')
+      expect(sections[2].name).toBe('Archive')
+    })
+
+    test('returns sections with channel IDs', async () => {
+      // Given: SlackClient returns sections with channels
+      // When: Listing sections
+      const sections = await mockClient.getChannelSections()
+
+      // Then: Should include channel IDs
+      expect(sections[0].channel_ids).toHaveLength(3)
+      expect(sections[0].channel_ids).toContain('C001')
+      expect(sections[1].channel_ids).toHaveLength(2)
+    })
+
+    test('returns sections with timestamps', async () => {
+      // Given: SlackClient returns sections
+      // When: Listing sections
+      const sections = await mockClient.getChannelSections()
+
+      // Then: Should include timestamps
+      expect(sections[0].date_created).toBe(1234567890)
+      expect(sections[0].date_updated).toBe(1234567900)
+    })
+
+    test('handles empty sections', async () => {
+      // Given: SlackClient returns section with no channels
+      // When: Listing sections
+      const sections = await mockClient.getChannelSections()
+
+      // Then: Should include empty section
+      expect(sections[2].channel_ids).toHaveLength(0)
+      expect(sections[2].name).toBe('Archive')
+    })
+  })
+})