agent-messenger 1.14.0 → 2.0.0

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

@@ -0,0 +1,33 @@
+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 const emojiCommand = new Command('emoji')
+  .description('Emoji commands')
+  .addCommand(
+    new Command('list')
+      .description('List all custom emoji in workspace')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(async (options) => {
+        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 emoji = await client.listEmoji()
+
+          console.log(formatOutput(emoji, options.pretty))
+        } catch (error) {
+          handleError(error as Error)
+        }
+      }),
+  )

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

@@ -23,7 +23,7 @@ async function uploadAction(
       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 filePath = resolve(path)
@@ -60,7 +60,7 @@ async function listAction(options: { channel?: string; pretty?: boolean }): Prom
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = options.channel ? await client.resolveChannel(options.channel) : undefined
     const files = await client.listFiles(channel)
 
@@ -92,7 +92,7 @@ async function infoAction(fileId: string, options: { pretty?: boolean }): Promis
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const fileData = await client.getFileInfo(fileId)
 
     const output = {
@@ -127,7 +127,7 @@ async function downloadAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const { buffer, file } = await client.downloadFile(fileId)
 
     const safeName = basename(file.name.replace(/\\/g, '/'))
@@ -165,6 +165,25 @@ async function downloadAction(
   }
 }
 
+async function deleteFileAction(fileId: 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 = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    await client.deleteFile(fileId)
+
+    console.log(formatOutput({ success: true, file_id: fileId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const fileCommand = new Command('file')
   .description('File commands')
   .addCommand(
@@ -198,3 +217,10 @@ export const fileCommand = new Command('file')
       .option('--pretty', 'Pretty print JSON output')
       .action(downloadAction),
   )
+  .addCommand(
+    new Command('delete')
+      .description('Delete a file')
+      .argument('<file>', 'file ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(deleteFileAction),
+  )

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

@@ -1,13 +1,18 @@
 export { activityCommand } from './activity'
 export { authCommand } from './auth'
+export { bookmarkCommand } from './bookmark'
 export { channelCommand } from './channel'
 export { draftsCommand } from './drafts'
+export { emojiCommand } from './emoji'
 export { fileCommand } from './file'
 export { messageCommand } from './message'
+export { pinCommand } from './pin'
 export { reactionCommand } from './reaction'
+export { reminderCommand } from './reminder'
 export { savedCommand } from './saved'
 export { sectionsCommand } from './sections'
 export { snapshotCommand } from './snapshot'
 export { unreadCommand } from './unread'
 export { userCommand } from './user'
+export { usergroupCommand } from './usergroup'
 export { workspaceCommand } from './workspace'

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

@@ -21,7 +21,7 @@ async function sendAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = await client.resolveChannel(channelInput)
     const message = await client.sendMessage(channel, text, options.thread)
 
@@ -52,7 +52,7 @@ async function listAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = await client.resolveChannel(channelInput)
     const limit = options.limit || 20
     const messages = await client.getMessages(channel, limit)
@@ -86,7 +86,7 @@ async function getAction(channelInput: string, ts: string, options: { 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 channel = await client.resolveChannel(channelInput)
     const message = await client.getMessage(channel, ts)
 
@@ -129,7 +129,7 @@ async function updateAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = await client.resolveChannel(channelInput)
     const message = await client.updateMessage(channel, ts, text)
 
@@ -165,7 +165,7 @@ async function deleteAction(
       process.exit(0)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = await client.resolveChannel(channelInput)
     await client.deleteMessage(channel, ts)
 
@@ -188,7 +188,7 @@ async function searchAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const results = await client.searchMessages(query, {
       sort: options.sort as 'score' | 'timestamp',
       sortDir: options.sortDir as 'asc' | 'desc',
@@ -225,7 +225,7 @@ async function repliesAction(
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
     const channel = await client.resolveChannel(channelInput)
     const result = await client.getThreadReplies(channel, threadTs, {
       limit: options.limit,
@@ -253,6 +253,126 @@ async function repliesAction(
   }
 }
 
+async function scheduleAction(
+  channelInput: string,
+  text: string,
+  postAt: string,
+  options: { thread?: 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 postAtTimestamp = Number(postAt)
+    if (!Number.isInteger(postAtTimestamp) || postAtTimestamp <= 0) {
+      console.log(formatOutput({ error: 'Invalid post-at value. Use a Unix timestamp in seconds (e.g. 1700000000).' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const channel = await client.resolveChannel(channelInput)
+    const scheduled = await client.scheduleMessage(channel, text, postAtTimestamp, options.thread)
+
+    console.log(formatOutput(scheduled, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function scheduledListAction(options: { channel?: 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 = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const channel = options.channel ? await client.resolveChannel(options.channel) : undefined
+    const messages = await client.listScheduledMessages(channel)
+
+    console.log(formatOutput(messages, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function scheduledDeleteAction(
+  channelInput: string,
+  scheduledMessageId: 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 = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const channel = await client.resolveChannel(channelInput)
+    await client.deleteScheduledMessage(channel, scheduledMessageId)
+
+    console.log(formatOutput({ success: true, channel, scheduled_message_id: scheduledMessageId }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function ephemeralAction(
+  channelInput: string,
+  user: string,
+  text: 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 = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const channel = await client.resolveChannel(channelInput)
+    const messageTs = await client.postEphemeral(channel, user, text)
+
+    console.log(formatOutput({ message_ts: messageTs, channel, user }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function permalinkAction(channelInput: 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 = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
+    const channel = await client.resolveChannel(channelInput)
+    const permalink = await client.getPermalink(channel, ts)
+
+    console.log(formatOutput({ channel, ts, permalink }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const messageCommand = new Command('message')
   .description('Message commands')
   .addCommand(
@@ -342,3 +462,49 @@ export const messageCommand = new Command('message')
         })
       }),
   )
+  .addCommand(
+    new Command('schedule')
+      .description('Schedule a message to be sent later')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<text>', 'Message text')
+      .argument('<post-at>', 'Unix timestamp for when to send')
+      .option('--thread <ts>', 'Thread timestamp for replies')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((channel: string, text: string, postAt: string, options: any) => {
+        scheduleAction(channel, text, postAt, { thread: options.thread, pretty: options.pretty })
+      }),
+  )
+  .addCommand(
+    new Command('scheduled-list')
+      .description('List scheduled messages')
+      .option('--channel <channel>', 'Filter by channel')
+      .option('--pretty', 'Pretty print JSON output')
+      .action((options: any) => {
+        scheduledListAction({ channel: options.channel, pretty: options.pretty })
+      }),
+  )
+  .addCommand(
+    new Command('scheduled-delete')
+      .description('Delete a scheduled message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<scheduled-message-id>', 'Scheduled message ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(scheduledDeleteAction),
+  )
+  .addCommand(
+    new Command('ephemeral')
+      .description('Post an ephemeral message visible only to a specific user')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<user>', 'User ID to show message to')
+      .argument('<text>', 'Message text')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(ephemeralAction),
+  )
+  .addCommand(
+    new Command('permalink')
+      .description('Get a permanent link to a message')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(permalinkAction),
+  )

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

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackPin } from '@/platforms/slack/types'
+
+describe('Pin Commands', () => {
+  let mockClient: Partial<SlackClient>
+
+  beforeEach(() => {
+    mockClient = {
+      pinMessage: mock(async () => {}),
+      unpinMessage: mock(async () => {}),
+      listPins: mock(async (): Promise<SlackPin[]> => [
+        {
+          channel: 'C001',
+          message: {
+            ts: '1234567890.123456',
+            text: 'Pinned message',
+            user: 'U001',
+            type: 'message',
+          },
+          date_created: 1234567890,
+          created_by: 'U001',
+        },
+      ]),
+    }
+  })
+
+  describe('pin add', () => {
+    test('pins a message successfully', async () => {
+      await (mockClient as SlackClient).pinMessage('C001', '1234567890.123456')
+      expect(mockClient.pinMessage).toHaveBeenCalledWith('C001', '1234567890.123456')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.pinMessage = mock(async () => {
+        throw new Error('already_pinned')
+      })
+      await expect((mockClient as SlackClient).pinMessage('C001', '123.456')).rejects.toThrow('already_pinned')
+    })
+  })
+
+  describe('pin remove', () => {
+    test('unpins a message successfully', async () => {
+      await (mockClient as SlackClient).unpinMessage('C001', '1234567890.123456')
+      expect(mockClient.unpinMessage).toHaveBeenCalledWith('C001', '1234567890.123456')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.unpinMessage = mock(async () => {
+        throw new Error('no_pin')
+      })
+      await expect((mockClient as SlackClient).unpinMessage('C001', '123.456')).rejects.toThrow('no_pin')
+    })
+  })
+
+  describe('pin list', () => {
+    test('lists pinned messages', async () => {
+      const pins = await (mockClient as SlackClient).listPins('C001')
+      expect(pins).toHaveLength(1)
+      expect(pins[0].message.text).toBe('Pinned message')
+      expect(pins[0].created_by).toBe('U001')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listPins = mock(async () => {
+        throw new Error('channel_not_found')
+      })
+      await expect((mockClient as SlackClient).listPins('C001')).rejects.toThrow('channel_not_found')
+    })
+  })
+})

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

@@ -0,0 +1,93 @@
+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(channel: string, ts: 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 })
+    channel = await client.resolveChannel(channel)
+    await client.pinMessage(channel, ts)
+
+    console.log(formatOutput({ success: true, channel, ts }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function removeAction(channel: string, ts: 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 })
+    channel = await client.resolveChannel(channel)
+    await client.unpinMessage(channel, ts)
+
+    console.log(formatOutput({ success: true, channel, ts }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function listAction(channel: 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 })
+    channel = await client.resolveChannel(channel)
+    const pins = await client.listPins(channel)
+
+    console.log(formatOutput(pins, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const pinCommand = new Command('pin')
+  .description('Pin commands')
+  .addCommand(
+    new Command('add')
+      .description('Pin a message to a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction),
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Unpin a message from a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List pinned messages in a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

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

@@ -16,7 +16,7 @@ async function addAction(channel: string, ts: string, emoji: string, options: {
       process.exit(1)
     }
 
-    const client = new SlackClient(ws.token, ws.cookie)
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
     channel = await client.resolveChannel(channel)
     await client.addReaction(channel, ts, emoji)
 
@@ -46,7 +46,7 @@ async function removeAction(channel: string, ts: string, emoji: string, options:
       process.exit(1)
     }
 
-    const client = new SlackClient(ws.token, ws.cookie)
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
     channel = await client.resolveChannel(channel)
     await client.removeReaction(channel, ts, emoji)
 
@@ -76,7 +76,7 @@ async function listAction(channel: string, ts: string, options: { pretty?: boole
       process.exit(1)
     }
 
-    const client = new SlackClient(ws.token, ws.cookie)
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
     channel = await client.resolveChannel(channel)
     const message = await client.getMessage(channel, ts)
 

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

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackReminder } from '@/platforms/slack/types'
+
+const sampleReminder: SlackReminder = {
+  id: 'Rm001',
+  creator: 'U001',
+  text: 'Do something important',
+  user: 'U001',
+  recurring: false,
+  time: 1700000000,
+  complete_ts: 0,
+}
+
+describe('Reminder Commands', () => {
+  let mockClient: Partial<SlackClient>
+
+  beforeEach(() => {
+    mockClient = {
+      addReminder: mock(async () => sampleReminder),
+      listReminders: mock(async (): Promise<SlackReminder[]> => [sampleReminder]),
+      completeReminder: mock(async () => {}),
+      deleteReminder: mock(async () => {}),
+    }
+  })
+
+  describe('reminder add', () => {
+    test('adds a reminder successfully', async () => {
+      const result = await (mockClient as SlackClient).addReminder('Do something important', 1700000000)
+      expect(result.id).toBe('Rm001')
+      expect(result.text).toBe('Do something important')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.addReminder = mock(async () => {
+        throw new Error('invalid_time')
+      })
+      await expect((mockClient as SlackClient).addReminder('Do something', 1700000000)).rejects.toThrow('invalid_time')
+    })
+  })
+
+  describe('reminder list', () => {
+    test('lists all reminders', async () => {
+      const reminders = await (mockClient as SlackClient).listReminders()
+      expect(reminders).toHaveLength(1)
+      expect(reminders[0].text).toBe('Do something important')
+      expect(reminders[0].recurring).toBe(false)
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listReminders = mock(async () => {
+        throw new Error('invalid_auth')
+      })
+      await expect((mockClient as SlackClient).listReminders()).rejects.toThrow('invalid_auth')
+    })
+  })
+
+  describe('reminder complete', () => {
+    test('completes a reminder successfully', async () => {
+      await (mockClient as SlackClient).completeReminder('Rm001')
+      expect(mockClient.completeReminder).toHaveBeenCalledWith('Rm001')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.completeReminder = mock(async () => {
+        throw new Error('reminder_not_found')
+      })
+      await expect((mockClient as SlackClient).completeReminder('Rm999')).rejects.toThrow('reminder_not_found')
+    })
+  })
+
+  describe('reminder delete', () => {
+    test('deletes a reminder successfully', async () => {
+      await (mockClient as SlackClient).deleteReminder('Rm001')
+      expect(mockClient.deleteReminder).toHaveBeenCalledWith('Rm001')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.deleteReminder = mock(async () => {
+        throw new Error('reminder_not_found')
+      })
+      await expect((mockClient as SlackClient).deleteReminder('Rm999')).rejects.toThrow('reminder_not_found')
+    })
+  })
+})