agent-messenger 1.0.0 → 1.2.0

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

@@ -0,0 +1,50 @@
+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 }): 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 sections = await client.getChannelSections()
+
+    const output = sections.map((section) => ({
+      id: section.id,
+      name: section.name,
+      channel_count: section.channel_ids.length,
+      channel_ids: section.channel_ids,
+      date_created: section.date_created,
+      date_updated: section.date_updated,
+    }))
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+const sections = new Command('sections').description(
+  'Manage Slack channel sections (sidebar folders)'
+)
+
+sections
+  .command('list')
+  .description('List all channel sections')
+  .option('--pretty', 'Pretty print output')
+  .action(listAction)
+
+export const sectionsCommand = sections

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

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test'
+import { SlackClient } from '../client'
+import { CredentialManager } from '../credential-manager'
+import { countsAction, markAction, threadsAction } from './unread'
+
+let credManagerGetWorkspaceSpy: ReturnType<typeof spyOn>
+let clientGetUnreadCountsSpy: ReturnType<typeof spyOn>
+let clientGetThreadViewSpy: ReturnType<typeof spyOn>
+let clientMarkReadSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  credManagerGetWorkspaceSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue(
+    {
+      workspace_id: 'T123',
+      workspace_name: 'Test Workspace',
+      token: 'xoxc-test',
+      cookie: 'test-cookie',
+    }
+  )
+
+  clientGetUnreadCountsSpy = spyOn(SlackClient.prototype, 'getUnreadCounts').mockResolvedValue({
+    channels: [{ id: 'C123', name: 'general', unread_count: 5, mention_count: 2 }],
+    total_unread: 5,
+    total_mentions: 2,
+  })
+
+  clientGetThreadViewSpy = spyOn(SlackClient.prototype, 'getThreadView').mockResolvedValue({
+    channel_id: 'C123',
+    thread_ts: '1234567890.123456',
+    unread_count: 3,
+    last_read: '1234567890.123450',
+    subscribed: true,
+  })
+
+  clientMarkReadSpy = spyOn(SlackClient.prototype, 'markRead').mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  credManagerGetWorkspaceSpy?.mockRestore()
+  clientGetUnreadCountsSpy?.mockRestore()
+  clientGetThreadViewSpy?.mockRestore()
+  clientMarkReadSpy?.mockRestore()
+})
+
+describe('unread commands', () => {
+  describe('getUnreadCounts', () => {
+    it('should return unread counts', async () => {
+      const mockCounts = {
+        channels: [
+          { id: 'C123', name: 'general', unread_count: 5, mention_count: 2 },
+          { id: 'C456', name: 'random', unread_count: 3, mention_count: 0 },
+        ],
+        total_unread: 8,
+        total_mentions: 2,
+      }
+
+      clientGetUnreadCountsSpy.mockResolvedValue(mockCounts)
+
+      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      const result = await mockClient.getUnreadCounts()
+
+      expect(result).toEqual(mockCounts)
+      expect(result.total_unread).toBe(8)
+      expect(result.total_mentions).toBe(2)
+      expect(result.channels).toHaveLength(2)
+    })
+  })
+
+  describe('getThreadView', () => {
+    it('should return thread subscription details', async () => {
+      const mockThreadView = {
+        channel_id: 'C123',
+        thread_ts: '1234567890.123456',
+        unread_count: 3,
+        last_read: '1234567890.123450',
+        subscribed: true,
+      }
+
+      clientGetThreadViewSpy.mockResolvedValue(mockThreadView)
+
+      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      const result = await mockClient.getThreadView('C123', '1234567890.123456')
+
+      expect(result).toEqual(mockThreadView)
+      expect(result.unread_count).toBe(3)
+      expect(result.subscribed).toBe(true)
+    })
+  })
+
+  describe('markRead', () => {
+    it('should mark channel as read', async () => {
+      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      await mockClient.markRead('C123', '1234567890.123456')
+
+      expect(clientMarkReadSpy).toHaveBeenCalledWith('C123', '1234567890.123456')
+    })
+  })
+
+  describe('CLI commands', () => {
+    it('should handle unread counts command', async () => {
+      const mockConsoleLog = mock(() => {})
+      const originalLog = console.log
+      console.log = mockConsoleLog
+
+      await countsAction({ pretty: false })
+
+      expect(clientGetUnreadCountsSpy).toHaveBeenCalled()
+      expect(mockConsoleLog).toHaveBeenCalled()
+
+      console.log = originalLog
+    })
+
+    it('should handle unread threads command', async () => {
+      const mockConsoleLog = mock(() => {})
+      const originalLog = console.log
+      console.log = mockConsoleLog
+
+      await threadsAction('C123', '1234567890.123456', { pretty: false })
+
+      expect(clientGetThreadViewSpy).toHaveBeenCalledWith('C123', '1234567890.123456')
+      expect(mockConsoleLog).toHaveBeenCalled()
+
+      console.log = originalLog
+    })
+
+    it('should handle mark read command', async () => {
+      const mockConsoleLog = mock(() => {})
+      const originalLog = console.log
+      console.log = mockConsoleLog
+
+      await markAction('C123', '1234567890.123456', { pretty: false })
+
+      expect(clientMarkReadSpy).toHaveBeenCalledWith('C123', '1234567890.123456')
+      expect(mockConsoleLog).toHaveBeenCalled()
+
+      console.log = originalLog
+    })
+  })
+})

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

@@ -0,0 +1,129 @@
+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'
+
+export async function countsAction(options: { 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 counts = await client.getUnreadCounts()
+
+    const output = {
+      total_unread: counts.total_unread,
+      total_mentions: counts.total_mentions,
+      channels: counts.channels.map((ch) => ({
+        id: ch.id,
+        name: ch.name,
+        unread_count: ch.unread_count,
+        mention_count: ch.mention_count,
+      })),
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function threadsAction(
+  channel: string,
+  threadTs: string,
+  options: { 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 threadView = await client.getThreadView(channel, threadTs)
+
+    const output = {
+      channel_id: threadView.channel_id,
+      thread_ts: threadView.thread_ts,
+      unread_count: threadView.unread_count,
+      last_read: threadView.last_read,
+      subscribed: threadView.subscribed,
+    }
+
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export async function markAction(
+  channel: string,
+  ts: string,
+  options: { 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)
+    await client.markRead(channel, ts)
+
+    console.log(formatOutput({ marked_read: true, channel, ts }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const unreadCommand = new Command('unread')
+  .description('Unread message commands')
+  .addCommand(
+    new Command('counts')
+      .description('Get unread counts for all channels')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(countsAction)
+  )
+  .addCommand(
+    new Command('threads')
+      .description('Get thread subscription details')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<thread_ts>', 'Thread timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(threadsAction)
+  )
+  .addCommand(
+    new Command('mark')
+      .description('Mark channel as read up to timestamp')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp to mark as read')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(markAction)
+  )

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[] = [