agent-messenger 1.3.6 → 1.5.0

package/src/platforms/slack/ensure-auth.test.ts

@@ -0,0 +1,186 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import { SlackClient } from './client'
+import { CredentialManager } from './credential-manager'
+import { ensureSlackAuth } from './ensure-auth'
+import { TokenExtractor } from './token-extractor'
+
+let getWorkspaceSpy: ReturnType<typeof spyOn>
+let extractSpy: ReturnType<typeof spyOn>
+let testAuthSpy: ReturnType<typeof spyOn>
+let setWorkspaceSpy: ReturnType<typeof spyOn>
+let loadSpy: ReturnType<typeof spyOn>
+let setCurrentWorkspaceSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  getWorkspaceSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue(null)
+
+  extractSpy = spyOn(TokenExtractor.prototype, 'extract').mockResolvedValue([
+    {
+      workspace_id: 'T123',
+      workspace_name: 'test-workspace',
+      token: 'xoxc-test-token',
+      cookie: 'xoxd-test-cookie',
+    },
+  ])
+
+  testAuthSpy = spyOn(SlackClient.prototype, 'testAuth').mockResolvedValue({
+    user_id: 'U123',
+    team_id: 'T123',
+    user: 'testuser',
+    team: 'Test Team',
+  })
+
+  setWorkspaceSpy = spyOn(CredentialManager.prototype, 'setWorkspace').mockResolvedValue(undefined)
+
+  loadSpy = spyOn(CredentialManager.prototype, 'load').mockResolvedValue({
+    current_workspace: null,
+    workspaces: {},
+  })
+
+  setCurrentWorkspaceSpy = spyOn(CredentialManager.prototype, 'setCurrentWorkspace').mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  getWorkspaceSpy?.mockRestore()
+  extractSpy?.mockRestore()
+  testAuthSpy?.mockRestore()
+  setWorkspaceSpy?.mockRestore()
+  loadSpy?.mockRestore()
+  setCurrentWorkspaceSpy?.mockRestore()
+})
+
+describe('ensureSlackAuth', () => {
+  test('skips extraction when credentials already exist', async () => {
+    // given
+    getWorkspaceSpy.mockResolvedValue({
+      workspace_id: 'T123',
+      workspace_name: 'existing',
+      token: 'xoxc-existing',
+      cookie: 'xoxd-existing',
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(extractSpy).not.toHaveBeenCalled()
+  })
+
+  test('extracts and saves credentials when none exist', async () => {
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(extractSpy).toHaveBeenCalled()
+    expect(testAuthSpy).toHaveBeenCalled()
+    expect(setWorkspaceSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspace_id: 'T123',
+        token: 'xoxc-test-token',
+        cookie: 'xoxd-test-cookie',
+        workspace_name: 'Test Team',
+      }),
+    )
+  })
+
+  test('sets first workspace as current when none set', async () => {
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(setCurrentWorkspaceSpy).toHaveBeenCalledWith('T123')
+  })
+
+  test('does not override existing current workspace', async () => {
+    // given
+    loadSpy.mockResolvedValue({
+      current_workspace: 'T999',
+      workspaces: { T999: { workspace_id: 'T999', workspace_name: 'other', token: 't', cookie: 'c' } },
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(setCurrentWorkspaceSpy).not.toHaveBeenCalled()
+  })
+
+  test('handles multiple workspaces', async () => {
+    // given
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'T1', workspace_name: 'ws1', token: 'xoxc-1', cookie: 'xoxd-1' },
+      { workspace_id: 'T2', workspace_name: 'ws2', token: 'xoxc-2', cookie: 'xoxd-2' },
+    ])
+
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(setWorkspaceSpy).toHaveBeenCalledTimes(2)
+    expect(setCurrentWorkspaceSpy).toHaveBeenCalledWith('T1')
+  })
+
+  test('skips invalid workspaces during validation', async () => {
+    // given
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'T-bad', workspace_name: 'bad', token: 'xoxc-bad', cookie: 'xoxd-bad' },
+      { workspace_id: 'T-good', workspace_name: 'good', token: 'xoxc-good', cookie: 'xoxd-good' },
+    ])
+    let callCount = 0
+    testAuthSpy.mockImplementation(() => {
+      callCount++
+      if (callCount === 1) throw new Error('invalid_auth')
+      return Promise.resolve({ user_id: 'U1', team_id: 'T-good', user: 'user', team: 'Good Team' })
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then - only the valid workspace is saved
+    expect(setWorkspaceSpy).toHaveBeenCalledTimes(1)
+    expect(setWorkspaceSpy).toHaveBeenCalledWith(expect.objectContaining({ workspace_id: 'T-good' }))
+    expect(setCurrentWorkspaceSpy).toHaveBeenCalledWith('T-good')
+  })
+
+  test('silently handles extraction failure', async () => {
+    // given
+    extractSpy.mockRejectedValue(new Error('Slack directory not found'))
+
+    // when/then
+    await ensureSlackAuth()
+
+    // then
+    expect(setWorkspaceSpy).not.toHaveBeenCalled()
+  })
+
+  test('does not save when no workspaces extracted', async () => {
+    // given
+    extractSpy.mockResolvedValue([])
+
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(setWorkspaceSpy).not.toHaveBeenCalled()
+    expect(setCurrentWorkspaceSpy).not.toHaveBeenCalled()
+  })
+
+  test('updates workspace_name from auth response', async () => {
+    // given
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'T1', workspace_name: 'old-name', token: 'xoxc-1', cookie: 'xoxd-1' },
+    ])
+    testAuthSpy.mockResolvedValue({
+      user_id: 'U1',
+      team_id: 'T1',
+      user: 'user',
+      team: 'New Team Name',
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then
+    expect(setWorkspaceSpy).toHaveBeenCalledWith(expect.objectContaining({ workspace_name: 'New Team Name' }))
+  })
+})

package/src/platforms/slack/ensure-auth.ts

@@ -0,0 +1,30 @@
+import { SlackClient } from './client'
+import { CredentialManager } from './credential-manager'
+import { TokenExtractor } from './token-extractor'
+
+export async function ensureSlackAuth(): Promise<void> {
+  try {
+    const credManager = new CredentialManager()
+    const workspace = await credManager.getWorkspace()
+    if (workspace) return
+
+    const extractor = new TokenExtractor()
+    const workspaces = await extractor.extract()
+
+    const validWorkspaces = []
+    for (const ws of workspaces) {
+      try {
+        const client = new SlackClient(ws.token, ws.cookie)
+        const authInfo = await client.testAuth()
+        ws.workspace_name = authInfo.team || ws.workspace_name
+        await credManager.setWorkspace(ws)
+        validWorkspaces.push(ws)
+      } catch {}
+    }
+
+    const config = await credManager.load()
+    if (!config.current_workspace && validWorkspaces.length > 0) {
+      await credManager.setCurrentWorkspace(validWorkspaces[0].workspace_id)
+    }
+  } catch {}
+}

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

@@ -252,6 +252,93 @@ describe('SlackBotClient', () => {
     })
   })
 
+  describe('resolveChannel', () => {
+    test('returns channel ID unchanged when it starts with C', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('C123ABC')
+
+      // then
+      expect(channel).toBe('C123ABC')
+      expect(mockConversations.list).not.toHaveBeenCalled()
+    })
+
+    test('returns channel ID unchanged when it starts with D', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('D123ABC')
+
+      // then
+      expect(channel).toBe('D123ABC')
+      expect(mockConversations.list).not.toHaveBeenCalled()
+    })
+
+    test('returns channel ID unchanged when it starts with G', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('G123ABC')
+
+      // then
+      expect(channel).toBe('G123ABC')
+      expect(mockConversations.list).not.toHaveBeenCalled()
+    })
+
+    test('resolves channel name to ID', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('general')
+
+      // then
+      expect(channel).toBe('C123')
+      expect(mockConversations.list).toHaveBeenCalled()
+    })
+
+    test('strips leading # from channel name', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('#general')
+
+      // then
+      expect(channel).toBe('C123')
+      expect(mockConversations.list).toHaveBeenCalled()
+    })
+
+    test('returns channel ID unchanged when input is #C prefixed ID', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.resolveChannel('#C123ABC')
+
+      // then
+      expect(channel).toBe('C123ABC')
+    })
+
+    test('throws channel_not_found error when name is not found', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when/then
+      try {
+        await client.resolveChannel('does-not-exist')
+        throw new Error('Expected resolveChannel to throw')
+      } catch (error) {
+        expect(error).toBeInstanceOf(SlackBotError)
+        expect((error as SlackBotError).code).toBe('channel_not_found')
+      }
+    })
+  })
+
   describe('listUsers', () => {
     test('returns list of users', async () => {
       // given

package/src/platforms/slackbot/client.ts

@@ -261,6 +261,27 @@ export class SlackBotClient {
     })
   }
 
+  async resolveChannel(channel: string): Promise<string> {
+    const normalized = channel.replace(/^#/, '')
+
+    if (/^[CDG][A-Z0-9]+$/.test(normalized)) {
+      return normalized
+    }
+
+    const name = normalized
+    const channels = await this.listChannels()
+    const found = channels.find((ch) => ch.name === name)
+
+    if (!found) {
+      throw new SlackBotError(
+        `Channel not found: "${channel}". Use channel ID or exact channel name.`,
+        'channel_not_found',
+      )
+    }
+
+    return found.id
+  }
+
   async listUsers(options?: { limit?: number; cursor?: string }): Promise<SlackUser[]> {
     const users: SlackUser[] = []
     let cursor: string | undefined = options?.cursor

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

@@ -15,9 +15,10 @@ async function listAction(options: BotOption & { limit?: string }): Promise<void
   }
 }
 
-async function infoAction(channel: string, options: BotOption): Promise<void> {
+async function infoAction(channelInput: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const info = await client.getChannelInfo(channel)
 
     console.log(formatOutput(info, options.pretty))
@@ -39,7 +40,7 @@ export const channelCommand = new Command('channel')
   .addCommand(
     new Command('info')
       .description('Get channel info')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
       .action(infoAction),

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

@@ -3,9 +3,10 @@ import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { type BotOption, getClient } from './shared'
 
-async function sendAction(channel: string, text: string, options: BotOption & { thread?: string }): Promise<void> {
+async function sendAction(channelInput: string, text: string, options: BotOption & { thread?: string }): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const result = await client.postMessage(channel, text, {
       thread_ts: options.thread,
     })
@@ -26,9 +27,10 @@ async function sendAction(channel: string, text: string, options: BotOption & {
   }
 }
 
-async function listAction(channel: string, options: BotOption & { limit?: string }): Promise<void> {
+async function listAction(channelInput: string, options: BotOption & { limit?: string }): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const limit = options.limit ? parseInt(options.limit, 10) : 20
     const messages = await client.getConversationHistory(channel, { limit })
 
@@ -38,9 +40,10 @@ async function listAction(channel: string, options: BotOption & { limit?: string
   }
 }
 
-async function getAction(channel: string, ts: string, options: BotOption): Promise<void> {
+async function getAction(channelInput: string, ts: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const message = await client.getMessage(channel, ts)
 
     if (!message) {
@@ -54,9 +57,10 @@ async function getAction(channel: string, ts: string, options: BotOption): Promi
   }
 }
 
-async function updateAction(channel: string, ts: string, text: string, options: BotOption): Promise<void> {
+async function updateAction(channelInput: string, ts: string, text: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const message = await client.updateMessage(channel, ts, text)
 
     console.log(
@@ -75,7 +79,7 @@ async function updateAction(channel: string, ts: string, text: string, options:
   }
 }
 
-async function deleteAction(channel: string, ts: string, options: BotOption & { force?: boolean }): Promise<void> {
+async function deleteAction(channelInput: string, ts: string, options: BotOption & { force?: boolean }): Promise<void> {
   try {
     if (!options.force) {
       console.log(formatOutput({ warning: 'Use --force to confirm deletion', ts }, options.pretty))
@@ -83,6 +87,7 @@ async function deleteAction(channel: string, ts: string, options: BotOption & {
     }
 
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     await client.deleteMessage(channel, ts)
 
     console.log(formatOutput({ deleted: ts }, options.pretty))
@@ -92,12 +97,13 @@ async function deleteAction(channel: string, ts: string, options: BotOption & {
 }
 
 async function repliesAction(
-  channel: string,
+  channelInput: string,
   threadTs: string,
   options: BotOption & { limit?: string },
 ): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     const limit = options.limit ? parseInt(options.limit, 10) : 100
     const messages = await client.getThreadReplies(channel, threadTs, { limit })
 
@@ -112,7 +118,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('send')
       .description('Send a message to a channel')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .argument('<text>', 'Message text')
       .option('--thread <ts>', 'Thread timestamp for replies')
       .option('--bot <id>', 'Use specific bot')
@@ -122,7 +128,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('list')
       .description('List messages in a channel')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .option('--limit <n>', 'Number of messages to fetch', '20')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
@@ -131,7 +137,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('get')
       .description('Get a single message')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
@@ -140,7 +146,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('update')
       .description('Update a message')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .argument('<text>', 'New message text')
       .option('--bot <id>', 'Use specific bot')
@@ -150,7 +156,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('delete')
       .description('Delete a message')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .argument('<ts>', 'Message timestamp')
       .option('--force', 'Skip confirmation')
       .option('--bot <id>', 'Use specific bot')
@@ -160,7 +166,7 @@ export const messageCommand = new Command('message')
   .addCommand(
     new Command('replies')
       .description('Get thread replies')
-      .argument('<channel>', 'Channel ID')
+      .argument('<channel>', 'Channel ID or name')
       .argument('<thread_ts>', 'Thread timestamp')
       .option('--limit <n>', 'Number of replies to fetch', '100')
       .option('--bot <id>', 'Use specific bot')

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

@@ -3,9 +3,10 @@ import { handleError } from '@/shared/utils/error-handler'
 import { formatOutput } from '@/shared/utils/output'
 import { type BotOption, getClient } from './shared'
 
-async function addAction(channel: string, timestamp: string, emoji: string, options: BotOption): Promise<void> {
+async function addAction(channelInput: string, timestamp: string, emoji: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     await client.addReaction(channel, timestamp, emoji)
 
     console.log(formatOutput({ success: true, channel, timestamp, emoji }, options.pretty))
@@ -14,9 +15,10 @@ async function addAction(channel: string, timestamp: string, emoji: string, opti
   }
 }
 
-async function removeAction(channel: string, timestamp: string, emoji: string, options: BotOption): Promise<void> {
+async function removeAction(channelInput: string, timestamp: string, emoji: string, options: BotOption): Promise<void> {
   try {
     const client = await getClient(options)
+    const channel = await client.resolveChannel(channelInput)
     await client.removeReaction(channel, timestamp, emoji)
 
     console.log(formatOutput({ success: true, channel, timestamp, emoji }, options.pretty))
@@ -30,8 +32,8 @@ export const reactionCommand = new Command('reaction')
   .addCommand(
     new Command('add')
       .description('Add a reaction to a message')
-      .argument('<channel>', 'Channel ID')
-      .argument('<timestamp>', 'Message timestamp')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
       .argument('<emoji>', 'Emoji name (with or without colons)')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')
@@ -40,8 +42,8 @@ export const reactionCommand = new Command('reaction')
   .addCommand(
     new Command('remove')
       .description('Remove a reaction from a message')
-      .argument('<channel>', 'Channel ID')
-      .argument('<timestamp>', 'Message timestamp')
+      .argument('<channel>', 'Channel ID or name')
+      .argument('<ts>', 'Message timestamp')
       .argument('<emoji>', 'Emoji name (with or without colons)')
       .option('--bot <id>', 'Use specific bot')
       .option('--pretty', 'Pretty print JSON output')

package/src/platforms/teams/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 
+import type { Command as CommandType } from 'commander'
 import { Command } from 'commander'
 import pkg from '../../../package.json' with { type: 'json' }
 import {
@@ -12,6 +13,16 @@ import {
   teamCommand,
   userCommand,
 } from './commands'
+import { ensureTeamsAuth } from './ensure-auth'
+
+function isAuthCommand(command: CommandType): boolean {
+  let cmd: CommandType | null = command
+  while (cmd) {
+    if (cmd.name() === 'auth') return true
+    cmd = cmd.parent
+  }
+  return false
+}
 
 const program = new Command()
 
@@ -22,6 +33,11 @@ program
   .option('--pretty', 'Pretty-print JSON output')
   .option('--team <id>', 'Use specific team')
 
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) return
+  await ensureTeamsAuth()
+})
+
 program.addCommand(authCommand)
 program.addCommand(teamCommand)
 program.addCommand(channelCommand)

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

@@ -105,30 +105,30 @@ export async function infoAction(
 }
 
 export const fileCommand = new Command('file')
-  .description('file commands')
+  .description('File commands')
   .addCommand(
     new Command('upload')
-      .description('upload file to channel')
-      .argument('<team>', 'team ID')
-      .argument('<channel>', 'channel ID')
-      .argument('<path>', 'file path')
+      .description('Upload file to channel')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<path>', 'File path')
       .option('--pretty', 'Pretty print JSON output')
       .action(uploadAction),
   )
   .addCommand(
     new Command('list')
-      .description('list files in channel')
-      .argument('<team>', 'team ID')
-      .argument('<channel>', 'channel ID')
+      .description('List files in channel')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(listAction),
   )
   .addCommand(
     new Command('info')
-      .description('show file details')
-      .argument('<team>', 'team ID')
-      .argument('<channel>', 'channel ID')
-      .argument('<file>', 'file ID')
+      .description('Show file details')
+      .argument('<team-id>', 'Team ID')
+      .argument('<channel-id>', 'Channel ID')
+      .argument('<file-id>', 'File ID')
       .option('--pretty', 'Pretty print JSON output')
       .action(infoAction),
   )

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

@@ -91,8 +91,7 @@ export async function snapshotAction(options: {
   }
 }
 
-export const snapshotCommand = new Command()
-  .name('snapshot')
+export const snapshotCommand = new Command('snapshot')
   .description('Get comprehensive team state for AI agents')
   .option('--channels-only', 'Include only channels (exclude messages and members)')
   .option('--users-only', 'Include only members (exclude channels and messages)')