agent-messenger 1.15.0 → 2.0.0

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

@@ -21,7 +21,7 @@ async function listAction(options: {
       process.exit(1)
     }
 
-    const client = new SlackClient(ws.token, ws.cookie)
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
 
     const mode = options.unread ? 'priority_unreads_v1' : 'chrono_reads_and_unreads'
     const limit = options.limit ? parseInt(options.limit, 10) : 20

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

@@ -81,7 +81,7 @@ async function extractAction(options: {
       }
 
       try {
-        const client = new SlackClient(ws.token, ws.cookie)
+        const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
         const authInfo = await client.testAuth()
         ws.workspace_id = authInfo.team_id
         ws.workspace_name = authInfo.team || ws.workspace_name
@@ -202,7 +202,7 @@ async function statusAction(options: { pretty?: boolean }): Promise<void> {
     let valid = false
 
     try {
-      const client = new SlackClient(ws.token, ws.cookie)
+      const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
       authInfo = await client.testAuth()
       valid = true
     } catch {

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

@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+import type { SlackBookmark } from '@/platforms/slack/types'
+
+const sampleBookmark: SlackBookmark = {
+  id: 'Bm001',
+  channel_id: 'C001',
+  title: 'Test Bookmark',
+  link: 'https://example.com',
+  type: 'link',
+  date_created: 1234567890,
+  date_updated: 1234567890,
+  created_by: 'U001',
+}
+
+describe('Bookmark Commands', () => {
+  let mockClient: Partial<SlackClient>
+
+  beforeEach(() => {
+    mockClient = {
+      addBookmark: mock(async () => sampleBookmark),
+      editBookmark: mock(async () => ({ ...sampleBookmark, title: 'Updated Title' })),
+      removeBookmark: mock(async () => {}),
+      listBookmarks: mock(async (): Promise<SlackBookmark[]> => [sampleBookmark]),
+    }
+  })
+
+  describe('bookmark add', () => {
+    test('adds a bookmark successfully', async () => {
+      const result = await (mockClient as SlackClient).addBookmark('C001', 'Test Bookmark', 'https://example.com')
+      expect(result.id).toBe('Bm001')
+      expect(result.title).toBe('Test Bookmark')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.addBookmark = mock(async () => {
+        throw new Error('channel_not_found')
+      })
+      await expect((mockClient as SlackClient).addBookmark('C001', 'T', 'https://example.com')).rejects.toThrow(
+        'channel_not_found',
+      )
+    })
+  })
+
+  describe('bookmark edit', () => {
+    test('edits a bookmark successfully', async () => {
+      const result = await (mockClient as SlackClient).editBookmark('C001', 'Bm001', { title: 'Updated Title' })
+      expect(result.title).toBe('Updated Title')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.editBookmark = mock(async () => {
+        throw new Error('bookmark_not_found')
+      })
+      await expect((mockClient as SlackClient).editBookmark('C001', 'Bm999', { title: 'X' })).rejects.toThrow(
+        'bookmark_not_found',
+      )
+    })
+  })
+
+  describe('bookmark remove', () => {
+    test('removes a bookmark successfully', async () => {
+      await (mockClient as SlackClient).removeBookmark('C001', 'Bm001')
+      expect(mockClient.removeBookmark).toHaveBeenCalledWith('C001', 'Bm001')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.removeBookmark = mock(async () => {
+        throw new Error('bookmark_not_found')
+      })
+      await expect((mockClient as SlackClient).removeBookmark('C001', 'Bm999')).rejects.toThrow('bookmark_not_found')
+    })
+  })
+
+  describe('bookmark list', () => {
+    test('lists bookmarks in a channel', async () => {
+      const bookmarks = await (mockClient as SlackClient).listBookmarks('C001')
+      expect(bookmarks).toHaveLength(1)
+      expect(bookmarks[0].title).toBe('Test Bookmark')
+      expect(bookmarks[0].link).toBe('https://example.com')
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listBookmarks = mock(async () => {
+        throw new Error('channel_not_found')
+      })
+      await expect((mockClient as SlackClient).listBookmarks('C001')).rejects.toThrow('channel_not_found')
+    })
+  })
+})

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

@@ -0,0 +1,148 @@
+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,
+  title: string,
+  link: string,
+  options: { emoji?: string; type?: 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 client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    channel = await client.resolveChannel(channel)
+    const bookmark = await client.addBookmark(channel, title, link, {
+      emoji: options.emoji,
+      type: options.type,
+    })
+
+    console.log(formatOutput(bookmark, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function editAction(
+  channel: string,
+  bookmarkId: string,
+  options: { title?: string; link?: string; emoji?: 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)
+    }
+
+    if (!options.title && !options.link && !options.emoji) {
+      console.log(formatOutput({ error: 'At least one of --title, --link, or --emoji is required.' }, options.pretty))
+      process.exit(1)
+    }
+
+    const client = await new SlackClient().login({ token: ws.token, cookie: ws.cookie })
+    channel = await client.resolveChannel(channel)
+    const bookmark = await client.editBookmark(channel, bookmarkId, {
+      title: options.title,
+      link: options.link,
+      emoji: options.emoji,
+    })
+
+    console.log(formatOutput(bookmark, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function removeAction(channel: string, bookmarkId: 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.removeBookmark(channel, bookmarkId)
+
+    console.log(formatOutput({ success: true, channel, bookmark_id: bookmarkId }, 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 bookmarks = await client.listBookmarks(channel)
+
+    console.log(formatOutput(bookmarks, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const bookmarkCommand = new Command('bookmark')
+  .description('Bookmark commands')
+  .addCommand(
+    new Command('add')
+      .description('Add a bookmark to a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<title>', 'Bookmark title')
+      .argument('<link>', 'Bookmark URL')
+      .option('--emoji <emoji>', 'Emoji for the bookmark')
+      .option('--type <type>', 'Bookmark type (default: link)')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(addAction),
+  )
+  .addCommand(
+    new Command('edit')
+      .description('Edit a bookmark in a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<bookmark-id>', 'Bookmark ID')
+      .option('--title <title>', 'New title')
+      .option('--link <link>', 'New URL')
+      .option('--emoji <emoji>', 'New emoji')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(editAction),
+  )
+  .addCommand(
+    new Command('remove')
+      .description('Remove a bookmark from a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<bookmark-id>', 'Bookmark ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(removeAction),
+  )
+  .addCommand(
+    new Command('list')
+      .description('List bookmarks in a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

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

@@ -8,7 +8,7 @@ describe('Channel Commands', () => {
 
   beforeEach(() => {
     mockClient = {
-      openConversation: mock(async (users: string) => ({
+      openConversation: mock(async (_users: string) => ({
         channel_id: 'D0ABC123',
         already_open: false,
       })),

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

@@ -17,7 +17,7 @@ async function listAction(options: { type?: string; includeArchived?: boolean; p
       process.exit(1)
     }
 
-    const client = new SlackClient(workspace.token, workspace.cookie)
+    const client = await new SlackClient().login({ token: workspace.token, cookie: workspace.cookie })
 
     if (options.type === 'dm') {
       const dms = await client.listDMs({ includeArchived: options.includeArchived })
@@ -68,7 +68,7 @@ async function infoAction(channel: string, options: { pretty?: boolean }): Promi
       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 ch = await client.getChannel(channel)
 
@@ -99,7 +99,7 @@ async function historyAction(channel: string, options: { limit?: number; 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)
     const messages = await client.getMessages(channel, options.limit || 20)
 
@@ -129,7 +129,7 @@ async function openAction(users: string, options: { pretty?: boolean }): Promise
       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.openConversation(users)
 
     console.log(formatOutput(result, options.pretty))
@@ -148,7 +148,7 @@ async function usersAction(channel: string, options: { includeBots?: boolean; pr
       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 memberIds = await client.listChannelMembers(channel)
 
@@ -173,6 +173,178 @@ async function usersAction(channel: string, options: { includeBots?: boolean; pr
   }
 }
 
+async function createAction(
+  name: string,
+  options: { private?: boolean; 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 ch = await client.createChannel(name, options.private)
+
+    console.log(
+      formatOutput(
+        {
+          id: ch.id,
+          name: ch.name,
+          is_private: ch.is_private,
+          is_archived: ch.is_archived,
+          created: ch.created,
+          creator: ch.creator,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function archiveAction(channel: 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 })
+    channel = await client.resolveChannel(channel)
+    await client.archiveChannel(channel)
+
+    console.log(formatOutput({ success: true, channel }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function setTopicAction(channel: string, topic: 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 })
+    channel = await client.resolveChannel(channel)
+    const result = await client.setChannelTopic(channel, topic)
+
+    console.log(formatOutput({ channel, topic: result.topic }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function setPurposeAction(channel: string, purpose: 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 })
+    channel = await client.resolveChannel(channel)
+    const result = await client.setChannelPurpose(channel, purpose)
+
+    console.log(formatOutput({ channel, purpose: result.purpose }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function inviteAction(channel: string, users: 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 })
+    channel = await client.resolveChannel(channel)
+    const ch = await client.inviteToChannel(channel, users)
+
+    console.log(
+      formatOutput(
+        {
+          id: ch.id,
+          name: ch.name,
+          is_private: ch.is_private,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function joinAction(channel: 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 })
+    channel = await client.resolveChannel(channel)
+    const ch = await client.joinChannel(channel)
+
+    console.log(
+      formatOutput(
+        {
+          id: ch.id,
+          name: ch.name,
+          is_private: ch.is_private,
+        },
+        options.pretty,
+      ),
+    )
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+async function leaveAction(channel: 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 })
+    channel = await client.resolveChannel(channel)
+    await client.leaveChannel(channel)
+
+    console.log(formatOutput({ success: true, channel }, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
 export const channelCommand = new Command('channel')
   .description('Channel commands')
   .addCommand(
@@ -218,3 +390,56 @@ export const channelCommand = new Command('channel')
       .option('--pretty', 'Pretty print JSON output')
       .action(usersAction),
   )
+  .addCommand(
+    new Command('create')
+      .description('Create a new channel')
+      .argument('<name>', 'Channel name')
+      .option('--private', 'Create as private channel')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(createAction),
+  )
+  .addCommand(
+    new Command('archive')
+      .description('Archive a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(archiveAction),
+  )
+  .addCommand(
+    new Command('set-topic')
+      .description('Set the topic of a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<topic>', 'New topic text')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(setTopicAction),
+  )
+  .addCommand(
+    new Command('set-purpose')
+      .description('Set the purpose of a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<purpose>', 'New purpose text')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(setPurposeAction),
+  )
+  .addCommand(
+    new Command('invite')
+      .description('Invite users to a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<users>', 'Comma-separated user IDs')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(inviteAction),
+  )
+  .addCommand(
+    new Command('join')
+      .description('Join a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(joinAction),
+  )
+  .addCommand(
+    new Command('leave')
+      .description('Leave a channel')
+      .argument('<channel>', 'Channel ID or name')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(leaveAction),
+  )

package/src/platforms/slack/commands/drafts.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.getDrafts(options.cursor)
 
     let drafts = result.drafts

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

@@ -0,0 +1,32 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { SlackClient } from '@/platforms/slack/client'
+
+describe('Emoji Commands', () => {
+  let mockClient: Partial<SlackClient>
+
+  beforeEach(() => {
+    mockClient = {
+      listEmoji: mock(async (): Promise<Record<string, string>> => ({
+        party_blob: 'https://example.com/party_blob.gif',
+        cool_sunglasses: 'https://example.com/cool_sunglasses.png',
+      })),
+    }
+  })
+
+  describe('emoji list', () => {
+    test('lists custom emoji', async () => {
+      const emoji = await (mockClient as SlackClient).listEmoji()
+      expect(emoji['party_blob']).toBe('https://example.com/party_blob.gif')
+      expect(emoji['cool_sunglasses']).toBe('https://example.com/cool_sunglasses.png')
+      expect(Object.keys(emoji)).toHaveLength(2)
+    })
+
+    test('throws error when API fails', async () => {
+      mockClient.listEmoji = mock(async () => {
+        throw new Error('invalid_auth')
+      })
+      await expect((mockClient as SlackClient).listEmoji()).rejects.toThrow('invalid_auth')
+    })
+  })
+})

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)
+        }
+      }),
+  )