agent-messenger 2.6.3 → 2.8.0

package/src/platforms/slack/client.test.ts

@@ -1274,15 +1274,37 @@ describe('SlackClient extended methods', () => {
         list: mock_fn(() => Promise.resolve({ ok: true, items: [] })),
       },
       conversations: {
-        create: mock_fn(() => Promise.resolve({ ok: true, channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' } })),
+        create: mock_fn(() =>
+          Promise.resolve({
+            ok: true,
+            channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' },
+          }),
+        ),
         archive: mock_fn(() => Promise.resolve({ ok: true })),
         setTopic: mock_fn(() => Promise.resolve({ ok: true, topic: 'new-topic' })),
         setPurpose: mock_fn(() => Promise.resolve({ ok: true, purpose: 'new-purpose' })),
-        invite: mock_fn(() => Promise.resolve({ ok: true, channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' } })),
-        join: mock_fn(() => Promise.resolve({ ok: true, channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' } })),
+        open: mock_fn(() => Promise.resolve({ ok: true, channel: { id: 'D001' }, already_open: false })),
+        mark: mock_fn(() => Promise.resolve({ ok: true })),
+        invite: mock_fn(() =>
+          Promise.resolve({
+            ok: true,
+            channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' },
+          }),
+        ),
+        join: mock_fn(() =>
+          Promise.resolve({
+            ok: true,
+            channel: { id: 'C001', name: 'test', is_private: false, is_archived: false, created: 0, creator: 'U001' },
+          }),
+        ),
         leave: mock_fn(() => Promise.resolve({ ok: true })),
         list: mock_fn(() => Promise.resolve({ ok: true, channels: [] })),
       },
+      subscriptions: {
+        thread: {
+          getView: mock_fn(() => Promise.resolve({ ok: true, view: {} })),
+        },
+      },
       chat: {
         scheduleMessage: mock_fn(() => Promise.resolve({ ok: true, scheduled_message_id: 'SM001' })),
         scheduledMessages: {
@@ -1290,17 +1312,52 @@ describe('SlackClient extended methods', () => {
         },
         deleteScheduledMessage: mock_fn(() => Promise.resolve({ ok: true })),
         postEphemeral: mock_fn(() => Promise.resolve({ ok: true, message_ts: '123.456' })),
-        getPermalink: mock_fn(() => Promise.resolve({ ok: true, permalink: 'https://slack.com/archives/C001/p123456' })),
+        getPermalink: mock_fn(() =>
+          Promise.resolve({ ok: true, permalink: 'https://slack.com/archives/C001/p123456' }),
+        ),
       },
       users: {
-        lookupByEmail: mock_fn(() => Promise.resolve({ ok: true, user: { id: 'U001', name: 'test', real_name: 'Test User', is_admin: false, is_owner: false, is_bot: false, is_app_user: false } })),
+        lookupByEmail: mock_fn(() =>
+          Promise.resolve({
+            ok: true,
+            user: {
+              id: 'U001',
+              name: 'test',
+              real_name: 'Test User',
+              is_admin: false,
+              is_owner: false,
+              is_bot: false,
+              is_app_user: false,
+            },
+          }),
+        ),
         profile: {
-          get: mock_fn(() => Promise.resolve({ ok: true, profile: { display_name: 'Test', status_text: '', status_emoji: '' } })),
-          set: mock_fn(() => Promise.resolve({ ok: true, profile: { display_name: 'Test', status_text: 'Working', status_emoji: ':computer:' } })),
+          get: mock_fn(() =>
+            Promise.resolve({ ok: true, profile: { display_name: 'Test', status_text: '', status_emoji: '' } }),
+          ),
+          set: mock_fn(() =>
+            Promise.resolve({
+              ok: true,
+              profile: { display_name: 'Test', status_text: 'Working', status_emoji: ':computer:' },
+            }),
+          ),
         },
       },
       reminders: {
-        add: mock_fn(() => Promise.resolve({ ok: true, reminder: { id: 'Rm001', creator: 'U001', text: 'Test', user: 'U001', recurring: false, time: 1700000000, complete_ts: 0 } })),
+        add: mock_fn(() =>
+          Promise.resolve({
+            ok: true,
+            reminder: {
+              id: 'Rm001',
+              creator: 'U001',
+              text: 'Test',
+              user: 'U001',
+              recurring: false,
+              time: 1700000000,
+              complete_ts: 0,
+            },
+          }),
+        ),
         list: mock_fn(() => Promise.resolve({ ok: true, reminders: [] })),
         complete: mock_fn(() => Promise.resolve({ ok: true })),
         delete: mock_fn(() => Promise.resolve({ ok: true })),
@@ -1312,17 +1369,177 @@ describe('SlackClient extended methods', () => {
         list: mock_fn(() => Promise.resolve({ ok: true, emoji: { party_blob: 'https://example.com/party_blob.gif' } })),
       },
       apiCall: mock_fn((method: string) => {
-        if (method === 'bookmarks.add') return Promise.resolve({ ok: true, bookmark: { id: 'Bm001', channel_id: 'C001', title: 'Test', link: 'https://example.com', type: 'link', date_created: 0, date_updated: 0, created_by: 'U001' } })
-        if (method === 'bookmarks.edit') return Promise.resolve({ ok: true, bookmark: { id: 'Bm001', channel_id: 'C001', title: 'Updated', link: 'https://example.com', type: 'link', date_created: 0, date_updated: 1, created_by: 'U001' } })
+        if (method === 'bookmarks.add')
+          return Promise.resolve({
+            ok: true,
+            bookmark: {
+              id: 'Bm001',
+              channel_id: 'C001',
+              title: 'Test',
+              link: 'https://example.com',
+              type: 'link',
+              date_created: 0,
+              date_updated: 0,
+              created_by: 'U001',
+            },
+          })
+        if (method === 'bookmarks.edit')
+          return Promise.resolve({
+            ok: true,
+            bookmark: {
+              id: 'Bm001',
+              channel_id: 'C001',
+              title: 'Updated',
+              link: 'https://example.com',
+              type: 'link',
+              date_created: 0,
+              date_updated: 1,
+              created_by: 'U001',
+            },
+          })
         if (method === 'bookmarks.remove') return Promise.resolve({ ok: true })
         if (method === 'bookmarks.list') return Promise.resolve({ ok: true, bookmarks: [] })
-        if (method === 'usergroups.list') return Promise.resolve({ ok: true, usergroups: [{ id: 'S001', team_id: 'T001', name: 'Engineering', handle: 'engineering', description: 'Eng team', is_external: false, is_usergroup: true, date_create: 100, date_update: 200, date_delete: 0, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: null, prefs: { channels: [], groups: [] }, users: ['U001'], user_count: 1 }] })
-        if (method === 'usergroups.create') return Promise.resolve({ ok: true, usergroup: { id: 'S002', team_id: 'T001', name: 'Marketing', handle: 'marketing', description: '', is_external: false, is_usergroup: true, date_create: 100, date_update: 100, date_delete: 0, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: null, prefs: { channels: [], groups: [] }, users: [], user_count: 0 } })
-        if (method === 'usergroups.update') return Promise.resolve({ ok: true, usergroup: { id: 'S001', team_id: 'T001', name: 'Updated', handle: 'updated', description: 'New desc', is_external: false, is_usergroup: true, date_create: 100, date_update: 300, date_delete: 0, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: null, prefs: { channels: [], groups: [] }, users: ['U001'], user_count: 1 } })
-        if (method === 'usergroups.disable') return Promise.resolve({ ok: true, usergroup: { id: 'S001', team_id: 'T001', name: 'Engineering', handle: 'engineering', description: '', is_external: false, is_usergroup: true, date_create: 100, date_update: 300, date_delete: 400, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: 'U001', prefs: { channels: [], groups: [] }, users: [], user_count: 0 } })
-        if (method === 'usergroups.enable') return Promise.resolve({ ok: true, usergroup: { id: 'S001', team_id: 'T001', name: 'Engineering', handle: 'engineering', description: '', is_external: false, is_usergroup: true, date_create: 100, date_update: 500, date_delete: 0, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: null, prefs: { channels: [], groups: [] }, users: ['U001'], user_count: 1 } })
+        if (method === 'usergroups.list')
+          return Promise.resolve({
+            ok: true,
+            usergroups: [
+              {
+                id: 'S001',
+                team_id: 'T001',
+                name: 'Engineering',
+                handle: 'engineering',
+                description: 'Eng team',
+                is_external: false,
+                is_usergroup: true,
+                date_create: 100,
+                date_update: 200,
+                date_delete: 0,
+                auto_type: null,
+                created_by: 'U001',
+                updated_by: 'U001',
+                deleted_by: null,
+                prefs: { channels: [], groups: [] },
+                users: ['U001'],
+                user_count: 1,
+              },
+            ],
+          })
+        if (method === 'usergroups.create')
+          return Promise.resolve({
+            ok: true,
+            usergroup: {
+              id: 'S002',
+              team_id: 'T001',
+              name: 'Marketing',
+              handle: 'marketing',
+              description: '',
+              is_external: false,
+              is_usergroup: true,
+              date_create: 100,
+              date_update: 100,
+              date_delete: 0,
+              auto_type: null,
+              created_by: 'U001',
+              updated_by: 'U001',
+              deleted_by: null,
+              prefs: { channels: [], groups: [] },
+              users: [],
+              user_count: 0,
+            },
+          })
+        if (method === 'usergroups.update')
+          return Promise.resolve({
+            ok: true,
+            usergroup: {
+              id: 'S001',
+              team_id: 'T001',
+              name: 'Updated',
+              handle: 'updated',
+              description: 'New desc',
+              is_external: false,
+              is_usergroup: true,
+              date_create: 100,
+              date_update: 300,
+              date_delete: 0,
+              auto_type: null,
+              created_by: 'U001',
+              updated_by: 'U001',
+              deleted_by: null,
+              prefs: { channels: [], groups: [] },
+              users: ['U001'],
+              user_count: 1,
+            },
+          })
+        if (method === 'usergroups.disable')
+          return Promise.resolve({
+            ok: true,
+            usergroup: {
+              id: 'S001',
+              team_id: 'T001',
+              name: 'Engineering',
+              handle: 'engineering',
+              description: '',
+              is_external: false,
+              is_usergroup: true,
+              date_create: 100,
+              date_update: 300,
+              date_delete: 400,
+              auto_type: null,
+              created_by: 'U001',
+              updated_by: 'U001',
+              deleted_by: 'U001',
+              prefs: { channels: [], groups: [] },
+              users: [],
+              user_count: 0,
+            },
+          })
+        if (method === 'usergroups.enable')
+          return Promise.resolve({
+            ok: true,
+            usergroup: {
+              id: 'S001',
+              team_id: 'T001',
+              name: 'Engineering',
+              handle: 'engineering',
+              description: '',
+              is_external: false,
+              is_usergroup: true,
+              date_create: 100,
+              date_update: 500,
+              date_delete: 0,
+              auto_type: null,
+              created_by: 'U001',
+              updated_by: 'U001',
+              deleted_by: null,
+              prefs: { channels: [], groups: [] },
+              users: ['U001'],
+              user_count: 1,
+            },
+          })
         if (method === 'usergroups.users.list') return Promise.resolve({ ok: true, users: ['U001', 'U002'] })
-        if (method === 'usergroups.users.update') return Promise.resolve({ ok: true, usergroup: { id: 'S001', team_id: 'T001', name: 'Engineering', handle: 'engineering', description: '', is_external: false, is_usergroup: true, date_create: 100, date_update: 600, date_delete: 0, auto_type: null, created_by: 'U001', updated_by: 'U001', deleted_by: null, prefs: { channels: [], groups: [] }, users: ['U001', 'U003'], user_count: 2 } })
+        if (method === 'usergroups.users.update')
+          return Promise.resolve({
+            ok: true,
+            usergroup: {
+              id: 'S001',
+              team_id: 'T001',
+              name: 'Engineering',
+              handle: 'engineering',
+              description: '',
+              is_external: false,
+              is_usergroup: true,
+              date_create: 100,
+              date_update: 600,
+              date_delete: 0,
+              auto_type: null,
+              created_by: 'U001',
+              updated_by: 'U001',
+              deleted_by: null,
+              prefs: { channels: [], groups: [] },
+              users: ['U001', 'U003'],
+              user_count: 2,
+            },
+          })
         return Promise.resolve({ ok: true })
       }),
     }
@@ -1335,6 +1552,300 @@ describe('SlackClient extended methods', () => {
     return mock(impl)
   }
 
+  describe('mid-surface methods', () => {
+    test('lists DMs and respects includeArchived option', async () => {
+      const { client, mock } = await makeClient()
+      mock.conversations.list.mockResolvedValueOnce({
+        ok: true,
+        channels: [
+          { id: 'D001', user: 'U001', is_mpim: false },
+          { id: 'G001', name: 'project-room', is_mpim: true },
+        ],
+      })
+
+      const dms = await client.listDMs({ includeArchived: true })
+
+      expect(dms).toEqual([
+        { id: 'D001', user: 'U001', is_mpim: false },
+        { id: 'G001', user: 'project-room', is_mpim: true },
+      ])
+      expect(mock.conversations.list).toHaveBeenCalledWith({
+        cursor: undefined,
+        limit: 200,
+        types: 'im,mpim',
+        exclude_archived: false,
+      })
+    })
+
+    test('maps unread counts and totals', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string) => {
+        if (method === 'client.counts') {
+          return Promise.resolve({
+            ok: true,
+            channels: [
+              { id: 'C001', name: 'general', unread_count: 3, mention_count: 1 },
+              { id: 'C002', name: 'random', unread_count: 2, mention_count: 0 },
+            ],
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const counts = await client.getUnreadCounts()
+
+      expect(counts.channels).toEqual([
+        { id: 'C001', name: 'general', unread_count: 3, mention_count: 1 },
+        { id: 'C002', name: 'random', unread_count: 2, mention_count: 0 },
+      ])
+      expect(counts.total_unread).toBe(5)
+      expect(counts.total_mentions).toBe(1)
+    })
+
+    test('maps thread view from subscriptions API', async () => {
+      const { client, mock } = await makeClient()
+      mock.subscriptions.thread.getView.mockResolvedValue({
+        ok: true,
+        view: {
+          channel_id: 'C001',
+          thread_ts: '123.456',
+          unread_count: 4,
+          last_read: '123.455',
+          subscribed: true,
+        },
+      })
+
+      const view = await client.getThreadView('C001', '123.456')
+
+      expect(view).toEqual({
+        channel_id: 'C001',
+        thread_ts: '123.456',
+        unread_count: 4,
+        last_read: '123.455',
+        subscribed: true,
+      })
+      expect(mock.subscriptions.thread.getView).toHaveBeenCalledWith({
+        channel: 'C001',
+        thread_ts: '123.456',
+      })
+    })
+
+    test('marks a channel as read', async () => {
+      const { client, mock } = await makeClient()
+
+      await client.markRead('C001', '123.456')
+
+      expect(mock.conversations.mark).toHaveBeenCalledWith({ channel: 'C001', ts: '123.456' })
+    })
+
+    test('maps activity feed and passes custom options', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string, args?: Record<string, unknown>) => {
+        if (method === 'activity.feed') {
+          expect(args).toEqual({
+            types: 'thread_reply',
+            mode: 'unreads',
+            limit: 10,
+          })
+          return Promise.resolve({
+            ok: true,
+            items: [
+              {
+                id: 'A001',
+                type: 'thread_reply',
+                channel: 'C001',
+                ts: '123.456',
+                text: 'Reply',
+                user: 'U001',
+                created: 1700000000,
+              },
+            ],
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const items = await client.getActivityFeed({ types: 'thread_reply', mode: 'unreads', limit: 10 })
+
+      expect(items).toEqual([
+        {
+          id: 'A001',
+          type: 'thread_reply',
+          channel: 'C001',
+          ts: '123.456',
+          text: 'Reply',
+          user: 'U001',
+          created: 1700000000,
+        },
+      ])
+    })
+
+    test('maps saved items with pagination metadata', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string) => {
+        if (method === 'saved.list') {
+          return Promise.resolve({
+            ok: true,
+            items: [
+              {
+                type: 'message',
+                message: {
+                  ts: '123.456',
+                  text: 'Saved message',
+                  user: 'U001',
+                  username: 'alice',
+                  type: 'message',
+                  thread_ts: '123.400',
+                  reply_count: 2,
+                  replies: [{ user: 'U002', ts: '123.401' }],
+                  edited: { user: 'U003', ts: '123.500' },
+                },
+                channel: { id: 'C001', name: 'general' },
+                date_created: 1700000000,
+              },
+            ],
+            has_more: true,
+            response_metadata: { next_cursor: 'cursor123' },
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const saved = await client.getSavedItems('cursor0')
+
+      expect(saved).toEqual({
+        items: [
+          {
+            type: 'message',
+            message: {
+              ts: '123.456',
+              text: 'Saved message',
+              user: 'U001',
+              username: 'alice',
+              type: 'message',
+              thread_ts: '123.400',
+              reply_count: 2,
+              replies: [{ user: 'U002', ts: '123.401' }],
+              edited: { user: 'U003', ts: '123.500' },
+            },
+            channel: { id: 'C001', name: 'general' },
+            date_created: 1700000000,
+          },
+        ],
+        has_more: true,
+        next_cursor: 'cursor123',
+      })
+    })
+
+    test('maps channel sections', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string) => {
+        if (method === 'users.channelSections.list') {
+          return Promise.resolve({
+            ok: true,
+            channel_sections: [
+              {
+                id: 'S001',
+                name: 'Focus',
+                channel_ids: ['C001', 'C002'],
+                date_created: 100,
+                date_updated: 200,
+              },
+            ],
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const sections = await client.getChannelSections()
+
+      expect(sections).toEqual([
+        {
+          id: 'S001',
+          name: 'Focus',
+          channel_ids: ['C001', 'C002'],
+          date_created: 100,
+          date_updated: 200,
+        },
+      ])
+    })
+
+    test('opens a conversation and returns open status', async () => {
+      const { client, mock } = await makeClient()
+      mock.conversations.open.mockResolvedValue({
+        ok: true,
+        channel: { id: 'D001' },
+        already_open: true,
+      })
+
+      const result = await client.openConversation('U001,U002')
+
+      expect(result).toEqual({ channel_id: 'D001', already_open: true })
+      expect(mock.conversations.open).toHaveBeenCalledWith({ users: 'U001,U002' })
+    })
+
+    test('maps drafts and next cursor', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string) => {
+        if (method === 'drafts.list') {
+          return Promise.resolve({
+            ok: true,
+            drafts: [
+              {
+                id: 'DR001',
+                channel_id: 'C001',
+                message: { text: 'Draft text' },
+                date_created: 100,
+                date_updated: 200,
+              },
+            ],
+            response_metadata: { next_cursor: 'cursor456' },
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const drafts = await client.getDrafts('cursor0')
+
+      expect(drafts).toEqual({
+        drafts: [
+          {
+            id: 'DR001',
+            channel_id: 'C001',
+            message: { text: 'Draft text' },
+            date_created: 100,
+            date_updated: 200,
+          },
+        ],
+        next_cursor: 'cursor456',
+      })
+    })
+
+    test('returns RTM connection info with stored cookie', async () => {
+      const { client, mock } = await makeClient()
+      mock.apiCall.mockImplementation((method: string) => {
+        if (method === 'rtm.connect') {
+          return Promise.resolve({
+            ok: true,
+            url: 'wss://example.slack-msgs.com',
+            self: { id: 'U001' },
+            team: { id: 'T001' },
+          })
+        }
+        return Promise.resolve({ ok: true })
+      })
+
+      const connection = await client.rtmConnect()
+
+      expect(connection).toEqual({
+        url: 'wss://example.slack-msgs.com',
+        cookie: 'xoxd-cookie',
+        self: { id: 'U001' },
+        team: { id: 'T001' },
+      })
+    })
+  })
+
   describe('pinMessage', () => {
     test('calls pins.add with correct args', async () => {
       const { client, mock } = await makeClient()
@@ -1777,7 +2288,11 @@ describe('SlackClient extended methods', () => {
 
     test('calls apiCall with correct params including channels', async () => {
       const { client, mock } = await makeClient()
-      await client.createUsergroup('Marketing', { handle: 'marketing', description: 'Mktg', channels: ['C001', 'C002'] })
+      await client.createUsergroup('Marketing', {
+        handle: 'marketing',
+        description: 'Mktg',
+        channels: ['C001', 'C002'],
+      })
       expect(mock.apiCall).toHaveBeenCalledWith('usergroups.create', {
         name: 'Marketing',
         handle: 'marketing',