agent-messenger 1.2.0 → 1.3.1

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
-import { handleError } from '../../../shared/utils/error-handler'
-import { formatOutput } from '../../../shared/utils/output'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
 import { SlackClient } from '../client'
 import { CredentialManager } from '../credential-manager'
 
@@ -10,12 +10,7 @@ export async function countsAction(options: { pretty?: boolean }): Promise<void>
     const workspace = await credManager.getWorkspace()
 
     if (!workspace) {
-      console.log(
-        formatOutput(
-          { error: 'No current workspace set. Run "auth extract" first.' },
-          options.pretty
-        )
-      )
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
     }
 
@@ -39,22 +34,13 @@ export async function countsAction(options: { pretty?: boolean }): Promise<void>
   }
 }
 
-export async function threadsAction(
-  channel: string,
-  threadTs: string,
-  options: { pretty?: boolean }
-): Promise<void> {
+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
-        )
-      )
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
     }
 
@@ -75,22 +61,13 @@ export async function threadsAction(
   }
 }
 
-export async function markAction(
-  channel: string,
-  ts: string,
-  options: { pretty?: boolean }
-): Promise<void> {
+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
-        )
-      )
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
     }
 
@@ -109,7 +86,7 @@ export const unreadCommand = new Command('unread')
     new Command('counts')
       .description('Get unread counts for all channels')
       .option('--pretty', 'Pretty print JSON output')
-      .action(countsAction)
+      .action(countsAction),
   )
   .addCommand(
     new Command('threads')
@@ -117,7 +94,7 @@ export const unreadCommand = new Command('unread')
       .argument('<channel>', 'Channel ID or name')
       .argument('<thread_ts>', 'Thread timestamp')
       .option('--pretty', 'Pretty print JSON output')
-      .action(threadsAction)
+      .action(threadsAction),
   )
   .addCommand(
     new Command('mark')
@@ -125,5 +102,5 @@ export const unreadCommand = new Command('unread')
       .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp to mark as read')
       .option('--pretty', 'Pretty print JSON output')
-      .action(markAction)
+      .action(markAction),
   )

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

@@ -50,10 +50,7 @@ describe('User Commands', () => {
       } as unknown as SlackClient
 
       // When: Calling list with all users
-      const result = await (userCommand as any).commands[0].action(
-        { includeBots: false },
-        userCommand
-      )
+      const result = await (userCommand as any).commands[0].action({ includeBots: false }, userCommand)
 
       // Then: Should return users
       expect(result).toBeDefined()

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
-import { handleError } from '../../../shared/utils/error-handler'
-import { formatOutput } from '../../../shared/utils/output'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
 import { SlackClient } from '../client'
 import { CredentialManager } from '../credential-manager'
 
@@ -9,9 +9,7 @@ async function getClient(pretty?: boolean): Promise<SlackClient | null> {
   const workspace = await credManager.getWorkspace()
 
   if (!workspace) {
-    console.log(
-      formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, pretty)
-    )
+    console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, pretty))
     return null
   }
 
@@ -49,7 +47,7 @@ export const userCommand = new Command('user')
         } catch (error) {
           handleError(error as Error)
         }
-      })
+      }),
   )
   .addCommand(
     new Command('info')
@@ -78,7 +76,7 @@ export const userCommand = new Command('user')
         } catch (error) {
           handleError(error as Error)
         }
-      })
+      }),
   )
   .addCommand(
     new Command('me')
@@ -106,5 +104,5 @@ export const userCommand = new Command('user')
         } catch (error) {
           handleError(error as Error)
         }
-      })
+      }),
   )

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

@@ -9,7 +9,7 @@ const testDirs: string[] = []
 function setup(): CredentialManager {
   const testConfigDir = join(
     import.meta.dir,
-    `.test-workspace-config-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    `.test-workspace-config-${Date.now()}-${Math.random().toString(36).slice(2)}`,
   )
   testDirs.push(testConfigDir)
   return new CredentialManager(testConfigDir)

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
-import { handleError } from '../../../shared/utils/error-handler'
-import { formatOutput } from '../../../shared/utils/output'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
 import { CredentialManager } from '../credential-manager'
 
 async function listAction(options: { pretty?: boolean }): Promise<void> {
@@ -44,12 +44,7 @@ async function currentAction(options: { pretty?: boolean }): Promise<void> {
     const workspace = await credManager.getWorkspace()
 
     if (!workspace) {
-      console.log(
-        formatOutput(
-          { error: 'No current workspace set. Run "auth extract" first.' },
-          options.pretty
-        )
-      )
+      console.log(formatOutput({ error: 'No current workspace set. Run "auth extract" first.' }, options.pretty))
       process.exit(1)
     }
 
@@ -87,25 +82,25 @@ export const workspaceCommand = new Command('workspace')
     new Command('list')
       .description('List all workspaces')
       .option('--pretty', 'Pretty print JSON output')
-      .action(listAction)
+      .action(listAction),
   )
   .addCommand(
     new Command('switch')
       .description('Switch to workspace')
       .argument('<id>', 'Workspace ID')
       .option('--pretty', 'Pretty print JSON output')
-      .action(switchAction)
+      .action(switchAction),
   )
   .addCommand(
     new Command('current')
       .description('Show current workspace')
       .option('--pretty', 'Pretty print JSON output')
-      .action(currentAction)
+      .action(currentAction),
   )
   .addCommand(
     new Command('remove')
       .description('Remove workspace')
       .argument('<id>', 'Workspace ID')
       .option('--pretty', 'Pretty print JSON output')
-      .action(removeAction)
+      .action(removeAction),
   )

package/src/platforms/slack/token-extractor-node-test.ts

@@ -22,7 +22,7 @@ try {
     )
   `)
   db.prepare(
-    "INSERT INTO cookies (name, value, host_key, last_access_utc) VALUES ('d', 'xoxd-test-cookie', '.slack.com', 1000)"
+    "INSERT INTO cookies (name, value, host_key, last_access_utc) VALUES ('d', 'xoxd-test-cookie', '.slack.com', 1000)",
   ).run()
   db.close()
 

package/src/platforms/slack/token-extractor.ts

@@ -5,7 +5,7 @@ import { createRequire } from 'node:module'
 import { homedir, tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { ClassicLevel } from 'classic-level'
-import { DerivedKeyCache } from '../../shared/utils/derived-key-cache'
+import { DerivedKeyCache } from '@/shared/utils/derived-key-cache'
 
 const require = createRequire(import.meta.url)
 
@@ -55,7 +55,7 @@ export class TokenExtractor {
           'Data',
           'Library',
           'Application Support',
-          'Slack'
+          'Slack',
         )
         if (existsSync(sandboxedPath)) {
           return sandboxedPath
@@ -306,12 +306,7 @@ export class TokenExtractor {
       } else {
         // Check for 4-byte fragmentation marker pattern
         // Pattern: 0x19 0x0d 0xf0 0xNN (where NN varies)
-        if (
-          i + 3 < chunk.length &&
-          chunk[i] === 0x19 &&
-          chunk[i + 1] === 0x0d &&
-          chunk[i + 2] === 0xf0
-        ) {
+        if (i + 3 < chunk.length && chunk[i] === 0x19 && chunk[i + 1] === 0x0d && chunk[i + 2] === 0xf0) {
           // Skip the 4 garbage bytes and insert a hyphen
           result.push(0x2d) // hyphen
           i += 4
@@ -419,10 +414,7 @@ export class TokenExtractor {
   private readCookieFromDB(dbPath: string): string {
     // Copy the database to a temp file to avoid SQLite lock contention
     // when Slack is running and has a write lock on the Cookies database
-    const tempDbPath = join(
-      tmpdir(),
-      `slack-cookies-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
-    )
+    const tempDbPath = join(tmpdir(), `slack-cookies-${Date.now()}-${Math.random().toString(36).slice(2)}.db`)
 
     try {
       copyFileSync(dbPath, tempDbPath)
@@ -555,13 +547,12 @@ export class TokenExtractor {
       try {
         password = execSync(
           'security find-generic-password -ga "Slack App Store Key" -s "Slack Safe Storage" -w 2>/dev/null',
-          { encoding: 'utf8' }
+          { encoding: 'utf8' },
         ).trim()
       } catch {
-        password = execSync(
-          'security find-generic-password -ga "Slack Key" -s "Slack Safe Storage" -w 2>/dev/null',
-          { encoding: 'utf8' }
-        ).trim()
+        password = execSync('security find-generic-password -ga "Slack Key" -s "Slack Safe Storage" -w 2>/dev/null', {
+          encoding: 'utf8',
+        }).trim()
       }
 
       return pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1')

package/src/platforms/slack/types.ts

@@ -191,7 +191,7 @@ export const SlackMessageSchema = z.object({
       z.object({
         user: z.string(),
         ts: z.string(),
-      })
+      }),
     )
     .optional(),
   edited: z

package/src/platforms/slackbot/cli.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import pkg from '../../../package.json'
+import { authCommand, channelCommand, messageCommand, reactionCommand, userCommand } from './commands/index'
+
+const program = new Command()
+
+program
+  .name('agent-slackbot')
+  .description('CLI tool for Slack bot integration using bot tokens (xoxb-)')
+  .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
+  .option('--bot <id>', 'Use specific bot (default: current)')
+
+program.addCommand(authCommand)
+program.addCommand(messageCommand)
+program.addCommand(channelCommand)
+program.addCommand(userCommand)
+program.addCommand(reactionCommand)
+
+program.parse(process.argv)
+
+export default program

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

@@ -0,0 +1,282 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackBotClient } from './client'
+import { SlackBotError } from './types'
+
+// Mock the @slack/web-api module
+const mockAuth = {
+  test: mock(() =>
+    Promise.resolve({
+      ok: true,
+      user_id: 'U123',
+      team_id: 'T456',
+      bot_id: 'B789',
+      user: 'testbot',
+      team: 'Test Team',
+    }),
+  ),
+}
+const mockConversations = {
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      channels: [
+        {
+          id: 'C123',
+          name: 'general',
+          is_private: false,
+          is_archived: false,
+          created: 1234567890,
+          creator: 'U001',
+        },
+      ],
+    }),
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      channel: {
+        id: 'C123',
+        name: 'general',
+        is_private: false,
+        is_archived: false,
+        created: 1234567890,
+        creator: 'U001',
+      },
+    }),
+  ),
+  history: mock(() =>
+    Promise.resolve({
+      ok: true,
+      messages: [{ ts: '1234567890.123456', text: 'Hello', type: 'message', user: 'U123' }],
+    }),
+  ),
+}
+const mockChat = {
+  postMessage: mock(() =>
+    Promise.resolve({
+      ok: true,
+      ts: '1234567890.123456',
+      message: { text: 'Hello', type: 'message' },
+    }),
+  ),
+}
+const mockReactions = {
+  add: mock(() => Promise.resolve({ ok: true })),
+  remove: mock(() => Promise.resolve({ ok: true })),
+}
+const mockUsers = {
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      members: [
+        {
+          id: 'U123',
+          name: 'testuser',
+          real_name: 'Test User',
+          is_admin: false,
+          is_owner: false,
+          is_bot: false,
+          is_app_user: false,
+        },
+      ],
+    }),
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      user: {
+        id: 'U123',
+        name: 'testuser',
+        real_name: 'Test User',
+        is_admin: false,
+        is_owner: false,
+        is_bot: false,
+        is_app_user: false,
+      },
+    }),
+  ),
+}
+
+mock.module('@slack/web-api', () => ({
+  WebClient: class MockWebClient {
+    auth = mockAuth
+    conversations = mockConversations
+    chat = mockChat
+    reactions = mockReactions
+    users = mockUsers
+  },
+}))
+
+describe('SlackBotClient', () => {
+  beforeEach(() => {
+    // Reset mocks
+    mockAuth.test.mockClear()
+    mockConversations.list.mockClear()
+    mockConversations.info.mockClear()
+    mockConversations.history.mockClear()
+    mockChat.postMessage.mockClear()
+    mockReactions.add.mockClear()
+    mockReactions.remove.mockClear()
+    mockUsers.list.mockClear()
+    mockUsers.info.mockClear()
+  })
+
+  describe('constructor', () => {
+    test('accepts bot tokens (xoxb-)', () => {
+      // when/then: should not throw
+      const client = new SlackBotClient('xoxb-test-token')
+      expect(client).toBeDefined()
+    })
+
+    test('rejects user tokens (xoxp-)', () => {
+      // when/then
+      expect(() => new SlackBotClient('xoxp-user-token')).toThrow(SlackBotError)
+    })
+
+    test('rejects empty token', () => {
+      // when/then
+      expect(() => new SlackBotClient('')).toThrow(SlackBotError)
+    })
+
+    test('rejects non-bot tokens', () => {
+      // when/then
+      expect(() => new SlackBotClient('invalid-token')).toThrow(SlackBotError)
+    })
+  })
+
+  describe('testAuth', () => {
+    test('returns auth info for valid token', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const result = await client.testAuth()
+
+      // then
+      expect(result.user_id).toBe('U123')
+      expect(result.team_id).toBe('T456')
+      expect(result.bot_id).toBe('B789')
+    })
+  })
+
+  describe('postMessage', () => {
+    test('sends message and returns timestamp', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const result = await client.postMessage('C123', 'Hello')
+
+      // then
+      expect(result.ts).toBe('1234567890.123456')
+      expect(result.text).toBe('Hello')
+    })
+  })
+
+  describe('getConversationHistory', () => {
+    test('returns messages', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const messages = await client.getConversationHistory('C123')
+
+      // then
+      expect(messages.length).toBeGreaterThan(0)
+      expect(messages[0].ts).toBe('1234567890.123456')
+    })
+  })
+
+  describe('getMessage', () => {
+    test('returns single message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const message = await client.getMessage('C123', '1234567890.123456')
+
+      // then
+      expect(message).not.toBeNull()
+      expect(message?.ts).toBe('1234567890.123456')
+    })
+  })
+
+  describe('addReaction', () => {
+    test('adds reaction to message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when/then: should not throw
+      await client.addReaction('C123', '1234567890.123456', 'thumbsup')
+      expect(mockReactions.add).toHaveBeenCalled()
+    })
+  })
+
+  describe('removeReaction', () => {
+    test('removes reaction from message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when/then: should not throw
+      await client.removeReaction('C123', '1234567890.123456', 'thumbsup')
+      expect(mockReactions.remove).toHaveBeenCalled()
+    })
+  })
+
+  describe('listChannels', () => {
+    test('returns list of channels', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channels = await client.listChannels()
+
+      // then
+      expect(channels.length).toBeGreaterThan(0)
+      expect(channels[0].id).toBe('C123')
+      expect(channels[0].name).toBe('general')
+    })
+  })
+
+  describe('getChannelInfo', () => {
+    test('returns channel details', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.getChannelInfo('C123')
+
+      // then
+      expect(channel.id).toBe('C123')
+      expect(channel.name).toBe('general')
+    })
+  })
+
+  describe('listUsers', () => {
+    test('returns list of users', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const users = await client.listUsers()
+
+      // then
+      expect(users.length).toBeGreaterThan(0)
+      expect(users[0].id).toBe('U123')
+    })
+  })
+
+  describe('getUserInfo', () => {
+    test('returns user details', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const user = await client.getUserInfo('U123')
+
+      // then
+      expect(user.id).toBe('U123')
+      expect(user.name).toBe('testuser')
+    })
+  })
+})