agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,125 @@
+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 addAction(
+  text: string,
+  time: string,
+  options: { user?: string; pretty?: boolean },
+): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const timeValue = Number(time)
+    if (!Number.isInteger(timeValue) || timeValue <= 0) {
+      console.log(formatOutput({ error: 'Invalid time value. Use a Unix timestamp in seconds (e.g. 1700000000).' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    const reminder = await client.addReminder(text, timeValue, { user: options.user })
+
+    console.log(formatOutput(reminder, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    const reminders = await client.listReminders()
+
+    console.log(formatOutput(reminders, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function completeAction(reminderId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    await client.completeReminder(reminderId)
+
+    console.log(formatOutput({ success: true, reminder_id: reminderId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function deleteAction(reminderId: string, options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const ws = await credManager.getWorkspace()
+
+    if (!ws) {
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    await client.deleteReminder(reminderId)
+
+    console.log(formatOutput({ success: true, reminder_id: reminderId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const reminderCommand = new Command('reminder')
+  .description('Reminder commands')
+  .addCommand(
+    new Command('add')
+      .description('Add a reminder')
+      .argument('<text>', 'Reminder text')
+      .argument('<time>', 'Unix timestamp for when to remind')
+      .option('--user <user>', 'User ID to remind (defaults to current user)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List all reminders')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )
+  .addCommand(
+    new Command('complete')
+      .description('Mark a reminder as complete')
+      .argument('<reminder-id>', 'Reminder ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(completeAction),
+  )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a reminder')
+      .argument('<reminder-id>', 'Reminder ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteAction),
+  )

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

@@ -16,7 +16,7 @@ async function listAction(options: { limit?: number; cursor?: string; pretty?: b
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const result = await client.getSavedItems(options.cursor)
 
     let items = result.items

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

@@ -16,7 +16,7 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const sections = await client.getChannelSections()
 
     const output = sections.map((section) => ({

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

@@ -149,7 +149,7 @@ afterEach(() => {
 
 test('full snapshot returns workspace, channels, messages, and users', async () => {
   const credManager = new CredentialManager()
-  const client = new SlackClient('xoxc-test', 'test-cookie')
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
   const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
@@ -219,7 +219,7 @@ test('full snapshot returns workspace, channels, messages, and users', async ()
 
 test('snapshot with --channels-only excludes messages and users', async () => {
   const credManager = new CredentialManager()
-  const client = new SlackClient('xoxc-test', 'test-cookie')
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
   const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
@@ -250,7 +250,7 @@ test('snapshot with --channels-only excludes messages and users', async () => {
 
 test('snapshot with --users-only excludes channels and messages', async () => {
   const credManager = new CredentialManager()
-  const client = new SlackClient('xoxc-test', 'test-cookie')
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
   const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()
@@ -280,7 +280,7 @@ test('snapshot with --users-only excludes channels and messages', async () => {
 
 test('snapshot respects --limit option for messages', async () => {
   const credManager = new CredentialManager()
-  const client = new SlackClient('xoxc-test', 'test-cookie')
+  const client = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
 
   const _workspace = await credManager.getWorkspace()
   const auth = await client.testAuth()

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

@@ -23,7 +23,7 @@ async function snapshotAction(options: {
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
 
     const auth = await client.testAuth()
     const messageLimit = options.limit || 20
@@ -89,6 +89,19 @@ async function snapshotAction(options: {
       }))
     }
 
+    if (!options.channelsOnly && !options.usersOnly) {
+      const usergroups = await client.listUsergroups({ includeUsers: true, includeCount: true })
+
+      snapshot.usergroups = usergroups.map((ug) => ({
+        id: ug.id,
+        name: ug.name,
+        handle: ug.handle,
+        description: ug.description,
+        user_count: ug.user_count,
+        users: ug.users,
+      }))
+    }
+
     console.log(formatOutput(snapshot, options.pretty))
   } catch (error) {
     handleError(error as Error)

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

@@ -55,7 +55,7 @@ describe('unread commands', () => {
 
       clientGetUnreadCountsSpy.mockResolvedValue(mockCounts)
 
-      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      const mockClient = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
       const result = await mockClient.getUnreadCounts()
 
       expect(result).toEqual(mockCounts)
@@ -77,7 +77,7 @@ describe('unread commands', () => {
 
       clientGetThreadViewSpy.mockResolvedValue(mockThreadView)
 
-      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      const mockClient = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
       const result = await mockClient.getThreadView('C123', '1234567890.123456')
 
       expect(result).toEqual(mockThreadView)
@@ -88,7 +88,7 @@ describe('unread commands', () => {
 
   describe('markRead', () => {
     it('should mark channel as read', async () => {
-      const mockClient = new SlackClient('xoxc-test', 'test-cookie')
+      const mockClient = await new SlackClient().login({ token: 'xoxc-test', cookie: 'test-cookie' })
       await mockClient.markRead('C123', '1234567890.123456')
 
       expect(clientMarkReadSpy).toHaveBeenCalledWith('C123', '1234567890.123456')

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

@@ -16,7 +16,7 @@ export async function countsAction(options: { pretty?: boolean }): Promise<void>
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const counts = await client.getUnreadCounts()
 
     const output = {
@@ -46,7 +46,7 @@ export async function threadsAction(channel: string, threadTs: string, options:
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     channel = await client.resolveChannel(channel)
     const threadView = await client.getThreadView(channel, threadTs)
 
@@ -74,7 +74,7 @@ export async function markAction(channel: string, ts: string, options: { pretty?
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     channel = await client.resolveChannel(channel)
     await client.markRead(channel, ts)
 

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

@@ -15,7 +15,7 @@ async function getClient(pretty?: boolean): Promise<SlackClient | null> {
     return null
   }
 
-  return new SlackClient(workspace.token, workspace.cookie)
+  return await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
 }
 
 export const userCommand = new Command('user')
@@ -108,3 +108,92 @@ export const userCommand = new Command('user')
         }
       }),
   )
+  .addCommand(
+    new Command('lookup')
+      .description('Look up a user by email')
+      .argument('<email>', 'Email address')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (email, options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+
+          const user = await client.lookupUserByEmail(email)
+
+          const output = {
+            id: user.id,
+            name: user.name,
+            real_name: user.real_name,
+            is_admin: user.is_admin,
+            is_owner: user.is_owner,
+            is_bot: user.is_bot,
+            is_app_user: user.is_app_user,
+            profile: user.profile,
+          }
+
+          console.log(formatOutput(output, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('profile')
+      .description('Get detailed profile for a user')
+      .argument('<user>', 'User ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (userId, options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+
+          const profile = await client.getUserProfile(userId)
+
+          console.log(formatOutput(profile, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('set-status')
+      .description('Set status text and emoji for current user')
+      .argument('<status-text>', 'Status text')
+      .option('--emoji <emoji>', 'Status emoji (without colons)')
+      .option('--expiration <ts>', 'Unix timestamp for status expiration')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (statusText, options) => {
+        try {
+          const client = await getClient(options.pretty)
+          if (!client) return process.exit(1)
+
+          const profile = await client.setUserProfile({
+            status_text: statusText,
+            status_emoji: options.emoji ? `:${options.emoji}:` : undefined,
+            status_expiration: options.expiration
+              ? (() => {
+                  const ts = Number(options.expiration)
+                  if (!Number.isInteger(ts) || ts <= 0) {
+                    console.log(formatOutput({ error: 'Invalid --expiration value. Use a Unix timestamp in seconds.' }, options.pretty))
+                    process.exit(1)
+                  }
+                  return ts
+                })()
+              : undefined,
+          })
+
+          console.log(
+            formatOutput(
+              {
+                status_text: profile.status_text,
+                status_emoji: profile.status_emoji,
+                status_expiration: profile.status_expiration,
+              },
+              options.pretty,
+            ),
+          )
+        } catch (error) {
+          handleError(error as Error)
+        }
+      }),
+  )

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

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackUsergroup } from '@/platforms/slack/types'
+
+const sampleUsergroup: SlackUsergroup = {
+  id: 'S0616NG6M',
+  team_id: 'T0ABC1234',
+  name: 'Marketing Team',
+  handle: 'marketing-team',
+  description: 'Marketing gurus, PR experts and product advocates.',
+  is_external: false,
+  is_usergroup: true,
+  date_create: 1446746793,
+  date_update: 1446746793,
+  date_delete: 0,
+  auto_type: null,
+  created_by: 'U060R4BJ4',
+  updated_by: 'U060R4BJ4',
+  deleted_by: null,
+  prefs: { channels: [], groups: [] },
+  users: ['U060R4BJ4', 'U060RNRCZ'],
+  user_count: 2,
+}
+
+describe('Usergroup Commands', () => {
+  let mockClient: Partial<SlackClient>
+
+  beforeEach(() => {
+    mockClient = {
+      listUsergroups: mock(async (): Promise<SlackUsergroup[]> => [sampleUsergroup]),
+      createUsergroup: mock(async () => sampleUsergroup),
+      updateUsergroup: mock(async () => sampleUsergroup),
+      enableUsergroup: mock(async () => sampleUsergroup),
+      disableUsergroup: mock(async () => ({ ...sampleUsergroup, date_delete: 1700000000 })),
+      listUsergroupMembers: mock(async (): Promise<string[]> => ['U060R4BJ4', 'U060RNRCZ']),
+      updateUsergroupMembers: mock(async () => sampleUsergroup),
+    }
+  })
+
+  describe('usergroup list', () => {
+    test('lists all user groups', async () => {
+      const usergroups = await (mockClient as SlackClient).listUsergroups()
+      expect(usergroups).toHaveLength(1)
+      expect(usergroups[0].name).toBe('Marketing Team')
+      expect(usergroups[0].handle).toBe('marketing-team')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listUsergroups = mock(async () => {
+        throw new Error('invalid_auth')
+      })
+      await expect((mockClient as SlackClient).listUsergroups()).rejects.toThrow('invalid_auth')
+    })
+  })
+
+  describe('usergroup create', () => {
+    test('creates a user group successfully', async () => {
+      const result = await (mockClient as SlackClient).createUsergroup('Marketing Team', {
+        handle: 'marketing-team',
+        description: 'Marketing gurus, PR experts and product advocates.',
+      })
+      expect(result.id).toBe('S0616NG6M')
+      expect(result.name).toBe('Marketing Team')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.createUsergroup = mock(async () => {
+        throw new Error('name_already_exists')
+      })
+      await expect((mockClient as SlackClient).createUsergroup('Duplicate')).rejects.toThrow('name_already_exists')
+    })
+  })
+
+  describe('usergroup update', () => {
+    test('updates a user group successfully', async () => {
+      const result = await (mockClient as SlackClient).updateUsergroup('S0616NG6M', {
+        name: 'Marketing Team',
+        handle: 'marketing-team',
+      })
+      expect(result.id).toBe('S0616NG6M')
+      expect(result.name).toBe('Marketing Team')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.updateUsergroup = mock(async () => {
+        throw new Error('no_such_subteam')
+      })
+      await expect(
+        (mockClient as SlackClient).updateUsergroup('S999', { name: 'Nope' }),
+      ).rejects.toThrow('no_such_subteam')
+    })
+  })
+
+  describe('usergroup enable', () => {
+    test('enables a user group successfully', async () => {
+      const result = await (mockClient as SlackClient).enableUsergroup('S0616NG6M')
+      expect(result.id).toBe('S0616NG6M')
+      expect(result.date_delete).toBe(0)
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.enableUsergroup = mock(async () => {
+        throw new Error('no_such_subteam')
+      })
+      await expect((mockClient as SlackClient).enableUsergroup('S999')).rejects.toThrow('no_such_subteam')
+    })
+  })
+
+  describe('usergroup disable', () => {
+    test('disables a user group successfully', async () => {
+      const result = await (mockClient as SlackClient).disableUsergroup('S0616NG6M')
+      expect(result.id).toBe('S0616NG6M')
+      expect(result.date_delete).toBeGreaterThan(0)
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.disableUsergroup = mock(async () => {
+        throw new Error('no_such_subteam')
+      })
+      await expect((mockClient as SlackClient).disableUsergroup('S999')).rejects.toThrow('no_such_subteam')
+    })
+  })
+
+  describe('usergroup members', () => {
+    test('lists members of a user group', async () => {
+      const users = await (mockClient as SlackClient).listUsergroupMembers('S0616NG6M')
+      expect(users).toHaveLength(2)
+      expect(users).toContain('U060R4BJ4')
+      expect(users).toContain('U060RNRCZ')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listUsergroupMembers = mock(async () => {
+        throw new Error('no_such_subteam')
+      })
+      await expect((mockClient as SlackClient).listUsergroupMembers('S999')).rejects.toThrow('no_such_subteam')
+    })
+  })
+
+  describe('usergroup members-update', () => {
+    test('updates members of a user group', async () => {
+      const result = await (mockClient as SlackClient).updateUsergroupMembers('S0616NG6M', ['U060R4BJ4', 'U060RNRCZ'])
+      expect(result.id).toBe('S0616NG6M')
+      expect(result.users).toHaveLength(2)
+    })
+
+    test('throws error when no users provided', async () => {
+      mockClient.updateUsergroupMembers = mock(async () => {
+        throw new Error('no_users_provided')
+      })
+      await expect((mockClient as SlackClient).updateUsergroupMembers('S0616NG6M', [])).rejects.toThrow(
+        'no_users_provided',
+      )
+    })
+  })
+})