agent-messenger 1.3.6 → 1.5.0

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

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import { DiscordClient } from './client'
+import { DiscordCredentialManager } from './credential-manager'
+import { ensureDiscordAuth } from './ensure-auth'
+import { DiscordTokenExtractor } from './token-extractor'
+
+let getTokenSpy: ReturnType<typeof spyOn>
+let extractSpy: ReturnType<typeof spyOn>
+let testAuthSpy: ReturnType<typeof spyOn>
+let listServersSpy: ReturnType<typeof spyOn>
+let saveSpy: ReturnType<typeof spyOn>
+
+beforeEach(() => {
+  getTokenSpy = spyOn(DiscordCredentialManager.prototype, 'getToken').mockResolvedValue(null)
+
+  extractSpy = spyOn(DiscordTokenExtractor.prototype, 'extract').mockResolvedValue({
+    token: 'test-token-123',
+  })
+
+  testAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue({
+    id: 'user-123',
+    username: 'testuser',
+  })
+
+  listServersSpy = spyOn(DiscordClient.prototype, 'listServers').mockResolvedValue([
+    { id: 'server-1', name: 'Server One' },
+    { id: 'server-2', name: 'Server Two' },
+  ])
+
+  saveSpy = spyOn(DiscordCredentialManager.prototype, 'save').mockResolvedValue(undefined)
+})
+
+afterEach(() => {
+  getTokenSpy?.mockRestore()
+  extractSpy?.mockRestore()
+  testAuthSpy?.mockRestore()
+  listServersSpy?.mockRestore()
+  saveSpy?.mockRestore()
+})
+
+describe('ensureDiscordAuth', () => {
+  test('skips extraction when token already exists', async () => {
+    // given
+    getTokenSpy.mockResolvedValue('existing-token')
+
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(extractSpy).not.toHaveBeenCalled()
+  })
+
+  test('extracts and saves credentials when no token', async () => {
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(extractSpy).toHaveBeenCalled()
+    expect(testAuthSpy).toHaveBeenCalled()
+    expect(listServersSpy).toHaveBeenCalled()
+    expect(saveSpy).toHaveBeenCalledWith({
+      token: 'test-token-123',
+      current_server: 'server-1',
+      servers: {
+        'server-1': { server_id: 'server-1', server_name: 'Server One' },
+        'server-2': { server_id: 'server-2', server_name: 'Server Two' },
+      },
+    })
+  })
+
+  test('sets first server as current', async () => {
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(saveSpy).toHaveBeenCalledWith(expect.objectContaining({ current_server: 'server-1' }))
+  })
+
+  test('handles no servers with null current_server', async () => {
+    // given
+    listServersSpy.mockResolvedValue([])
+
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(saveSpy).toHaveBeenCalledWith(expect.objectContaining({ current_server: null, servers: {} }))
+  })
+
+  test('does not save when extraction returns null', async () => {
+    // given
+    extractSpy.mockResolvedValue(null)
+
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(testAuthSpy).not.toHaveBeenCalled()
+    expect(saveSpy).not.toHaveBeenCalled()
+  })
+
+  test('silently handles extraction failure', async () => {
+    // given
+    extractSpy.mockRejectedValue(new Error('Discord not found'))
+
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(saveSpy).not.toHaveBeenCalled()
+  })
+
+  test('silently handles auth validation failure', async () => {
+    // given
+    testAuthSpy.mockRejectedValue(new Error('401 Unauthorized'))
+
+    // when
+    await ensureDiscordAuth()
+
+    // then
+    expect(saveSpy).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,31 @@
+import { DiscordClient } from './client'
+import { DiscordCredentialManager } from './credential-manager'
+import { DiscordTokenExtractor } from './token-extractor'
+
+export async function ensureDiscordAuth(): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const token = await credManager.getToken()
+    if (token) return
+
+    const extractor = new DiscordTokenExtractor()
+    const extracted = await extractor.extract()
+    if (!extracted) return
+
+    const client = new DiscordClient(extracted.token)
+    const authInfo = await client.testAuth()
+    if (!authInfo) return
+
+    const servers = await client.listServers()
+    const serverMap: Record<string, { server_id: string; server_name: string }> = {}
+    for (const server of servers) {
+      serverMap[server.id] = { server_id: server.id, server_name: server.name }
+    }
+
+    await credManager.save({
+      token: extracted.token,
+      current_server: servers[0]?.id ?? null,
+      servers: serverMap,
+    })
+  } catch {}
+}

package/src/platforms/slack/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 {
@@ -17,6 +18,16 @@ import {
   userCommand,
   workspaceCommand,
 } from './commands/index'
+import { ensureSlackAuth } 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()
 
@@ -27,6 +38,11 @@ program
   .option('--pretty', 'Pretty-print JSON output')
   .option('--workspace <id>', 'Use specific workspace')
 
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) return
+  await ensureSlackAuth()
+})
+
 program.addCommand(authCommand)
 program.addCommand(workspaceCommand)
 program.addCommand(messageCommand)

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

@@ -226,6 +226,107 @@ describe('SlackClient', () => {
     })
   })
 
+  describe('resolveChannel', () => {
+    beforeEach(() => resetMocks())
+
+    test('returns channel ID unchanged when input starts with C', async () => {
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      const channel = await client.resolveChannel('C123ABC')
+      expect(channel).toBe('C123ABC')
+    })
+
+    test('returns channel ID unchanged when input starts with D', async () => {
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      const channel = await client.resolveChannel('D123ABC')
+      expect(channel).toBe('D123ABC')
+    })
+
+    test('returns channel ID unchanged when input starts with G', async () => {
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      const channel = await client.resolveChannel('G123ABC')
+      expect(channel).toBe('G123ABC')
+    })
+
+    test('resolves channel name to ID by calling listChannels', async () => {
+      mockWebClient.conversations.list.mockResolvedValue({
+        ok: true,
+        channels: [
+          {
+            id: 'C123',
+            name: 'general',
+            is_private: false,
+            is_archived: false,
+            created: 1234567890,
+            creator: 'U123',
+          },
+        ],
+      })
+
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      // @ts-expect-error - accessing private property for testing
+      client.client = mockWebClient as unknown as WebClient
+
+      const channel = await client.resolveChannel('general')
+      expect(channel).toBe('C123')
+      expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(1)
+    })
+
+    test('strips leading # from channel name', async () => {
+      mockWebClient.conversations.list.mockResolvedValue({
+        ok: true,
+        channels: [
+          {
+            id: 'C123',
+            name: 'general',
+            is_private: false,
+            is_archived: false,
+            created: 1234567890,
+            creator: 'U123',
+          },
+        ],
+      })
+
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      // @ts-expect-error - accessing private property for testing
+      client.client = mockWebClient as unknown as WebClient
+
+      const channel = await client.resolveChannel('#general')
+      expect(channel).toBe('C123')
+      expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(1)
+    })
+
+    test('returns channel ID unchanged when input is #C prefixed ID', async () => {
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      const channel = await client.resolveChannel('#C123ABC')
+      expect(channel).toBe('C123ABC')
+    })
+
+    test("throws SlackError with code 'channel_not_found' when name is not found", async () => {
+      mockWebClient.conversations.list.mockResolvedValue({
+        ok: true,
+        channels: [
+          {
+            id: 'C123',
+            name: 'general',
+            is_private: false,
+            is_archived: false,
+            created: 1234567890,
+            creator: 'U123',
+          },
+        ],
+      })
+
+      const client = new SlackClient('xoxc-token', 'xoxd-cookie')
+      // @ts-expect-error - accessing private property for testing
+      client.client = mockWebClient as unknown as WebClient
+
+      await expect(client.resolveChannel('missing-channel')).rejects.toMatchObject({
+        name: 'SlackError',
+        code: 'channel_not_found',
+      })
+    })
+  })
+
   describe('getMessages', () => {
     beforeEach(() => resetMocks())
 

package/src/platforms/slack/client.ts

@@ -161,6 +161,28 @@ export class SlackClient {
     })
   }
 
+  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 SlackError(
+        `Channel not found: "${channel}". Use channel ID or exact channel name.`,
+        'channel_not_found',
+      )
+    }
+
+    return found.id
+  }
+
   async sendMessage(channel: string, text: string, threadTs?: string): Promise<SlackMessage> {
     return this.withRetry(async () => {
       const response = await this.client.chat.postMessage({

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

@@ -56,6 +56,7 @@ async function infoAction(channel: string, options: { pretty?: boolean }): Promi
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    channel = await client.resolveChannel(channel)
     const ch = await client.getChannel(channel)
 
     const output = {
@@ -86,6 +87,7 @@ async function historyAction(channel: string, options: { limit?: number; pretty?
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    channel = await client.resolveChannel(channel)
     const messages = await client.getMessages(channel, options.limit || 20)
 
     const output = messages.map((msg) => ({

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

@@ -21,6 +21,7 @@ async function uploadAction(
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    channel = await client.resolveChannel(channel)
 
     const filePath = resolve(path)
     const fileBuffer = readFileSync(filePath)
@@ -57,7 +58,8 @@ async function listAction(options: { channel?: string; pretty?: boolean }): Prom
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
-    const files = await client.listFiles(options.channel)
+    const channel = options.channel ? await client.resolveChannel(options.channel) : undefined
+    const files = await client.listFiles(channel)
 
     const output = files.map((file) => ({
       id: file.id,
@@ -115,19 +117,27 @@ async function infoAction(fileId: string, options: { pretty?: boolean }): Promis
 }
 
 export const fileCommand = new Command('file')
-  .description('file commands')
+  .description('File commands')
   .addCommand(
     new Command('upload')
-      .description('upload file to channel')
+      .description('Upload file to channel')
       .argument('<channel>', 'channel ID or name')
       .argument('<path>', 'file path')
       .option('--filename <name>', 'override filename')
+      .option('--pretty', 'Pretty print JSON output')
       .action(uploadAction),
   )
   .addCommand(
     new Command('list')
-      .description('list files in workspace')
+      .description('List files in workspace')
       .option('--channel <id>', 'filter by channel')
+      .option('--pretty', 'Pretty print JSON output')
       .action(listAction),
   )
-  .addCommand(new Command('info').description('show file details').argument('<file>', 'file ID').action(infoAction))
+  .addCommand(
+    new Command('info')
+      .description('Show file details')
+      .argument('<file>', 'file ID')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(infoAction),
+  )

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

@@ -6,7 +6,7 @@ import { CredentialManager } from '../credential-manager'
 import type { SlackMessage } from '../types'
 
 async function sendAction(
-  channel: string,
+  channelInput: string,
   text: string,
   options: { thread?: string; pretty?: boolean },
 ): Promise<void> {
@@ -20,6 +20,7 @@ async function sendAction(
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     const message = await client.sendMessage(channel, text, options.thread)
 
     const output = {
@@ -37,7 +38,7 @@ async function sendAction(
 }
 
 async function listAction(
-  channel: string,
+  channelInput: string,
   options: { limit?: number; thread?: string; pretty?: boolean },
 ): Promise<void> {
   try {
@@ -50,6 +51,7 @@ async function listAction(
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     const limit = options.limit || 20
     const messages = await client.getMessages(channel, limit)
 
@@ -70,7 +72,7 @@ async function listAction(
   }
 }
 
-async function getAction(channel: string, ts: string, options: { pretty?: boolean }): Promise<void> {
+async function getAction(channelInput: string, ts: string, options: { pretty?: boolean }): Promise<void> {
   try {
     const credManager = new CredentialManager()
     const workspace = await credManager.getWorkspace()
@@ -81,6 +83,7 @@ async function getAction(channel: string, ts: string, options: { pretty?: boolea
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     const message = await client.getMessage(channel, ts)
 
     if (!message) {
@@ -105,7 +108,12 @@ async function getAction(channel: string, ts: string, options: { pretty?: boolea
   }
 }
 
-async function updateAction(channel: string, ts: string, text: string, options: { pretty?: boolean }): Promise<void> {
+async function updateAction(
+  channelInput: string,
+  ts: string,
+  text: string,
+  options: { pretty?: boolean },
+): Promise<void> {
   try {
     const credManager = new CredentialManager()
     const workspace = await credManager.getWorkspace()
@@ -116,6 +124,7 @@ async function updateAction(channel: string, ts: string, text: string, options:
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     const message = await client.updateMessage(channel, ts, text)
 
     const output = {
@@ -132,7 +141,7 @@ async function updateAction(channel: string, ts: string, text: string, options:
 }
 
 async function deleteAction(
-  channel: string,
+  channelInput: string,
   ts: string,
   options: { force?: boolean; pretty?: boolean },
 ): Promise<void> {
@@ -151,6 +160,7 @@ async function deleteAction(
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     await client.deleteMessage(channel, ts)
 
     console.log(formatOutput({ deleted: ts }, options.pretty))
@@ -196,7 +206,7 @@ async function searchAction(
 }
 
 async function repliesAction(
-  channel: string,
+  channelInput: string,
   threadTs: string,
   options: { limit?: number; oldest?: string; latest?: string; cursor?: string; pretty?: boolean },
 ): Promise<void> {
@@ -210,6 +220,7 @@ async function repliesAction(
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    const channel = await client.resolveChannel(channelInput)
     const result = await client.getThreadReplies(channel, threadTs, {
       limit: options.limit,
       oldest: options.oldest,

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

@@ -15,6 +15,7 @@ async function addAction(channel: string, ts: string, emoji: string, options: {
     }
 
     const client = new SlackClient(ws.token, ws.cookie)
+    channel = await client.resolveChannel(channel)
     await client.addReaction(channel, ts, emoji)
 
     console.log(
@@ -44,6 +45,7 @@ async function removeAction(channel: string, ts: string, emoji: string, options:
     }
 
     const client = new SlackClient(ws.token, ws.cookie)
+    channel = await client.resolveChannel(channel)
     await client.removeReaction(channel, ts, emoji)
 
     console.log(
@@ -73,6 +75,7 @@ async function listAction(channel: string, ts: string, options: { pretty?: boole
     }
 
     const client = new SlackClient(ws.token, ws.cookie)
+    channel = await client.resolveChannel(channel)
     const message = await client.getMessage(channel, ts)
 
     if (!message) {

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

@@ -32,12 +32,11 @@ async function listAction(options: { pretty?: boolean }): Promise<void> {
   }
 }
 
-const sections = new Command('sections').description('Manage Slack channel sections (sidebar folders)')
-
-sections
-  .command('list')
-  .description('List all channel sections')
-  .option('--pretty', 'Pretty print output')
-  .action(listAction)
-
-export const sectionsCommand = sections
+export const sectionsCommand = new Command('sections')
+  .description('Sidebar section commands')
+  .addCommand(
+    new Command('list')
+      .description('List all channel sections')
+      .option('--pretty', 'Pretty print JSON output')
+      .action(listAction),
+  )

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

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

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

@@ -45,6 +45,7 @@ export async function threadsAction(channel: string, threadTs: string, options:
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    channel = await client.resolveChannel(channel)
     const threadView = await client.getThreadView(channel, threadTs)
 
     const output = {
@@ -72,6 +73,7 @@ export async function markAction(channel: string, ts: string, options: { pretty?
     }
 
     const client = new SlackClient(workspace.token, workspace.cookie)
+    channel = await client.resolveChannel(channel)
     await client.markRead(channel, ts)
 
     console.log(formatOutput({ marked_read: true, channel, ts }, options.pretty))

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

@@ -17,12 +17,12 @@ async function getClient(pretty?: boolean): Promise<SlackClient | null> {
 }
 
 export const userCommand = new Command('user')
-  .description('user commands')
+  .description('User commands')
   .addCommand(
     new Command('list')
-      .description('list workspace users')
-      .option('--include-bots', 'include bot users')
-      .option('--pretty', 'pretty-print JSON output')
+      .description('List workspace users')
+      .option('--include-bots', 'Include bot users')
+      .option('--pretty', 'Pretty print JSON output')
       .action(async (options) => {
         try {
           const client = await getClient(options.pretty)
@@ -51,9 +51,9 @@ export const userCommand = new Command('user')
   )
   .addCommand(
     new Command('info')
-      .description('show user details')
+      .description('Show user details')
       .argument('<user>', 'user ID or username')
-      .option('--pretty', 'pretty-print JSON output')
+      .option('--pretty', 'Pretty print JSON output')
       .action(async (userArg, options) => {
         try {
           const client = await getClient(options.pretty)
@@ -80,8 +80,8 @@ export const userCommand = new Command('user')
   )
   .addCommand(
     new Command('me')
-      .description('show current authenticated user')
-      .option('--pretty', 'pretty-print JSON output')
+      .description('Show current authenticated user')
+      .option('--pretty', 'Pretty print JSON output')
       .action(async (options) => {
         try {
           const client = await getClient(options.pretty)