agent-messenger 1.2.0 → 1.3.0

package/src/platforms/slackbot/credential-manager.test.ts

@@ -0,0 +1,264 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { SlackBotCredentialManager } from './credential-manager'
+
+const CREDS_A = {
+  token: 'xoxb-token-a',
+  workspace_id: 'T123',
+  workspace_name: 'Workspace A',
+  bot_id: 'deploy',
+  bot_name: 'Deploy Bot',
+}
+
+const CREDS_B = {
+  token: 'xoxb-token-b',
+  workspace_id: 'T123',
+  workspace_name: 'Workspace A',
+  bot_id: 'alert',
+  bot_name: 'Alert Bot',
+}
+
+const CREDS_C = {
+  token: 'xoxb-token-c',
+  workspace_id: 'T999',
+  workspace_name: 'Workspace B',
+  bot_id: 'deploy',
+  bot_name: 'Deploy Bot (B)',
+}
+
+describe('SlackBotCredentialManager', () => {
+  let tempDir: string
+  let manager: SlackBotCredentialManager
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `slackbot-cred-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    manager = new SlackBotCredentialManager(tempDir)
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    delete process.env.E2E_SLACKBOT_TOKEN
+    delete process.env.E2E_SLACKBOT_WORKSPACE_ID
+    delete process.env.E2E_SLACKBOT_WORKSPACE_NAME
+  })
+
+  describe('load', () => {
+    test('returns empty config when no file exists', async () => {
+      const config = await manager.load()
+
+      expect(config.current).toBeNull()
+      expect(config.workspaces).toEqual({})
+    })
+  })
+
+  describe('save and load', () => {
+    test('persists config to file', async () => {
+      const config = {
+        current: { workspace_id: 'T123', bot_id: 'deploy' },
+        workspaces: {
+          T123: {
+            workspace_id: 'T123',
+            workspace_name: 'Test Workspace',
+            bots: {
+              deploy: { bot_id: 'deploy', bot_name: 'Deploy Bot', token: 'xoxb-test-token' },
+            },
+          },
+        },
+      }
+
+      await manager.save(config)
+      const loaded = await manager.load()
+
+      expect(loaded).toEqual(config)
+    })
+  })
+
+  describe('getCredentials', () => {
+    test('returns null when no credentials exist', async () => {
+      expect(await manager.getCredentials()).toBeNull()
+    })
+
+    test('returns current bot credentials', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      const creds = await manager.getCredentials()
+
+      expect(creds).toEqual(CREDS_A)
+    })
+
+    test('returns specific bot by id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      const creds = await manager.getCredentials('deploy')
+
+      expect(creds).toEqual(CREDS_A)
+    })
+
+    test('returns specific bot by workspace_id/bot_id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_C)
+
+      const creds = await manager.getCredentials('T123/deploy')
+
+      expect(creds).toEqual(CREDS_A)
+    })
+
+    test('returns null for ambiguous bot_id across workspaces', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_C)
+
+      const creds = await manager.getCredentials('deploy')
+
+      expect(creds).toBeNull()
+    })
+
+    test('env vars take precedence over file', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      process.env.E2E_SLACKBOT_TOKEN = 'xoxb-env-token'
+      process.env.E2E_SLACKBOT_WORKSPACE_ID = 'T789'
+      process.env.E2E_SLACKBOT_WORKSPACE_NAME = 'Env Workspace'
+
+      const creds = await manager.getCredentials()
+
+      expect(creds?.token).toBe('xoxb-env-token')
+      expect(creds?.workspace_id).toBe('T789')
+      expect(creds?.bot_id).toBe('env')
+    })
+  })
+
+  describe('setCredentials', () => {
+    test('stores bot and sets as current', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      const config = await manager.load()
+      expect(config.current).toEqual({ workspace_id: 'T123', bot_id: 'deploy' })
+      expect(config.workspaces.T123.bots.deploy.token).toBe('xoxb-token-a')
+    })
+
+    test('stores multiple bots in same workspace', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      const config = await manager.load()
+      expect(Object.keys(config.workspaces.T123.bots)).toEqual(['deploy', 'alert'])
+      expect(config.current).toEqual({ workspace_id: 'T123', bot_id: 'alert' })
+    })
+
+    test('stores bots across workspaces', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_C)
+
+      const config = await manager.load()
+      expect(Object.keys(config.workspaces)).toEqual(['T123', 'T999'])
+    })
+  })
+
+  describe('listAll', () => {
+    test('returns all bots with current flag', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      const all = await manager.listAll()
+
+      expect(all).toHaveLength(2)
+      expect(all.find((b) => b.bot_id === 'deploy')?.is_current).toBe(false)
+      expect(all.find((b) => b.bot_id === 'alert')?.is_current).toBe(true)
+    })
+  })
+
+  describe('setCurrent', () => {
+    test('switches current bot', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      const switched = await manager.setCurrent('deploy')
+
+      expect(switched).toBe(true)
+      const creds = await manager.getCredentials()
+      expect(creds?.bot_id).toBe('deploy')
+    })
+
+    test('returns false for unknown bot', async () => {
+      expect(await manager.setCurrent('nonexistent')).toBe(false)
+    })
+  })
+
+  describe('removeBot', () => {
+    test('removes a bot by id', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      const removed = await manager.removeBot('deploy')
+
+      expect(removed).toBe(true)
+      const config = await manager.load()
+      expect(Object.keys(config.workspaces.T123.bots)).toEqual(['alert'])
+    })
+
+    test('removes workspace when last bot removed', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      await manager.removeBot('deploy')
+
+      const config = await manager.load()
+      expect(config.workspaces.T123).toBeUndefined()
+    })
+
+    test('clears current when current bot removed', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      await manager.removeBot('deploy')
+
+      const config = await manager.load()
+      expect(config.current).toBeNull()
+    })
+
+    test('returns false for unknown bot', async () => {
+      expect(await manager.removeBot('nonexistent')).toBe(false)
+    })
+
+    test('returns false for ambiguous bot_id across workspaces', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_C)
+
+      const removed = await manager.removeBot('deploy')
+
+      expect(removed).toBe(false)
+      const config = await manager.load()
+      expect(config.workspaces.T123.bots.deploy).toBeDefined()
+      expect(config.workspaces.T999.bots.deploy).toBeDefined()
+    })
+  })
+
+  describe('clearCredentials', () => {
+    test('removes all credentials', async () => {
+      await manager.setCredentials(CREDS_A)
+      await manager.setCredentials(CREDS_B)
+
+      await manager.clearCredentials()
+
+      const config = await manager.load()
+      expect(config.current).toBeNull()
+      expect(config.workspaces).toEqual({})
+    })
+  })
+
+  describe('file permissions', () => {
+    test('saves file with secure permissions (600)', async () => {
+      await manager.setCredentials(CREDS_A)
+
+      const credPath = join(tempDir, 'slackbot-credentials.json')
+      const stats = await stat(credPath)
+
+      expect(stats.mode & 0o777).toBe(0o600)
+    })
+  })
+})

package/src/platforms/slackbot/credential-manager.ts

@@ -0,0 +1,218 @@
+import { existsSync } from 'node:fs'
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { SlackBotConfig, SlackBotCredentials, SlackBotWorkspace } from './types'
+
+export class SlackBotCredentialManager {
+  private configDir: string
+  private credentialsPath: string
+
+  constructor(configDir?: string) {
+    this.configDir = configDir ?? join(homedir(), '.config', 'agent-messenger')
+    this.credentialsPath = join(this.configDir, 'slackbot-credentials.json')
+  }
+
+  async load(): Promise<SlackBotConfig> {
+    if (!existsSync(this.credentialsPath)) {
+      return { current: null, workspaces: {} }
+    }
+
+    const content = await readFile(this.credentialsPath, 'utf-8')
+    return JSON.parse(content) as SlackBotConfig
+  }
+
+  async save(config: SlackBotConfig): Promise<void> {
+    await mkdir(this.configDir, { recursive: true })
+    await writeFile(this.credentialsPath, JSON.stringify(config, null, 2))
+    await chmod(this.credentialsPath, 0o600)
+  }
+
+  async getCredentials(botId?: string): Promise<SlackBotCredentials | null> {
+    const config = await this.load()
+
+    if (botId) {
+      return this.findBot(config, botId)
+    }
+
+    const envToken = process.env.E2E_SLACKBOT_TOKEN
+    const envWorkspaceId = process.env.E2E_SLACKBOT_WORKSPACE_ID
+    const envWorkspaceName = process.env.E2E_SLACKBOT_WORKSPACE_NAME
+
+    if (envToken && envWorkspaceId && envWorkspaceName) {
+      return {
+        token: envToken,
+        workspace_id: envWorkspaceId,
+        workspace_name: envWorkspaceName,
+        bot_id: 'env',
+        bot_name: 'env',
+      }
+    }
+
+    if (!config.current) {
+      return null
+    }
+
+    const workspace = config.workspaces[config.current.workspace_id]
+    if (!workspace) return null
+
+    const bot = workspace.bots[config.current.bot_id]
+    if (!bot) return null
+
+    return {
+      token: bot.token,
+      workspace_id: workspace.workspace_id,
+      workspace_name: workspace.workspace_name,
+      bot_id: bot.bot_id,
+      bot_name: bot.bot_name,
+    }
+  }
+
+  private findBot(config: SlackBotConfig, botId: string): SlackBotCredentials | null {
+    // Try "workspace_id/bot_id" format first
+    if (botId.includes('/')) {
+      const [workspaceId, id] = botId.split('/')
+      const workspace = config.workspaces[workspaceId]
+      if (!workspace) return null
+      const bot = workspace.bots[id]
+      if (!bot) return null
+      return {
+        token: bot.token,
+        workspace_id: workspace.workspace_id,
+        workspace_name: workspace.workspace_name,
+        bot_id: bot.bot_id,
+        bot_name: bot.bot_name,
+      }
+    }
+
+    // Search by bot_id across all workspaces — must be unique
+    const matches: SlackBotCredentials[] = []
+    for (const workspace of Object.values(config.workspaces)) {
+      const bot = workspace.bots[botId]
+      if (bot) {
+        matches.push({
+          token: bot.token,
+          workspace_id: workspace.workspace_id,
+          workspace_name: workspace.workspace_name,
+          bot_id: bot.bot_id,
+          bot_name: bot.bot_name,
+        })
+      }
+    }
+
+    if (matches.length === 1) return matches[0]
+    return null
+  }
+
+  async setCredentials(creds: SlackBotCredentials): Promise<void> {
+    const config = await this.load()
+
+    if (!config.workspaces[creds.workspace_id]) {
+      config.workspaces[creds.workspace_id] = {
+        workspace_id: creds.workspace_id,
+        workspace_name: creds.workspace_name,
+        bots: {},
+      }
+    }
+
+    const workspace = config.workspaces[creds.workspace_id]
+    workspace.workspace_name = creds.workspace_name
+    workspace.bots[creds.bot_id] = {
+      bot_id: creds.bot_id,
+      bot_name: creds.bot_name,
+      token: creds.token,
+    }
+
+    config.current = {
+      workspace_id: creds.workspace_id,
+      bot_id: creds.bot_id,
+    }
+
+    await this.save(config)
+  }
+
+  async removeBot(botId: string): Promise<boolean> {
+    const config = await this.load()
+
+    if (botId.includes('/')) {
+      const [workspaceId, id] = botId.split('/')
+      const workspace = config.workspaces[workspaceId]
+      if (!workspace || !workspace.bots[id]) return false
+
+      delete workspace.bots[id]
+      if (Object.keys(workspace.bots).length === 0) {
+        delete config.workspaces[workspaceId]
+      }
+
+      if (config.current?.workspace_id === workspaceId && config.current?.bot_id === id) {
+        config.current = null
+      }
+
+      await this.save(config)
+      return true
+    }
+
+    const matches: { workspace: SlackBotWorkspace }[] = []
+    for (const workspace of Object.values(config.workspaces)) {
+      if (workspace.bots[botId]) {
+        matches.push({ workspace })
+      }
+    }
+
+    if (matches.length !== 1) return false
+
+    const { workspace } = matches[0]
+    delete workspace.bots[botId]
+    if (Object.keys(workspace.bots).length === 0) {
+      delete config.workspaces[workspace.workspace_id]
+    }
+    if (
+      config.current?.workspace_id === workspace.workspace_id &&
+      config.current?.bot_id === botId
+    ) {
+      config.current = null
+    }
+    await this.save(config)
+    return true
+  }
+
+  async setCurrent(botId: string): Promise<boolean> {
+    const config = await this.load()
+    const creds = this.findBot(config, botId)
+    if (!creds) return false
+
+    config.current = {
+      workspace_id: creds.workspace_id,
+      bot_id: creds.bot_id,
+    }
+
+    await this.save(config)
+    return true
+  }
+
+  async listAll(): Promise<Array<SlackBotCredentials & { is_current: boolean }>> {
+    const config = await this.load()
+    const results: Array<SlackBotCredentials & { is_current: boolean }> = []
+
+    for (const workspace of Object.values(config.workspaces)) {
+      for (const bot of Object.values(workspace.bots)) {
+        results.push({
+          token: bot.token,
+          workspace_id: workspace.workspace_id,
+          workspace_name: workspace.workspace_name,
+          bot_id: bot.bot_id,
+          bot_name: bot.bot_name,
+          is_current:
+            config.current?.workspace_id === workspace.workspace_id &&
+            config.current?.bot_id === bot.bot_id,
+        })
+      }
+    }
+
+    return results
+  }
+
+  async clearCredentials(): Promise<void> {
+    await this.save({ current: null, workspaces: {} })
+  }
+}

package/src/platforms/slackbot/index.ts

@@ -0,0 +1,19 @@
+export { SlackBotClient } from './client'
+export { SlackBotCredentialManager } from './credential-manager'
+export {
+  SlackBotConfig,
+  SlackBotConfigSchema,
+  SlackBotCredentials,
+  SlackBotCredentialsSchema,
+  SlackBotError,
+  SlackChannel,
+  SlackChannelSchema,
+  SlackFile,
+  SlackFileSchema,
+  SlackMessage,
+  SlackMessageSchema,
+  SlackReaction,
+  SlackReactionSchema,
+  SlackUser,
+  SlackUserSchema,
+} from './types'

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

@@ -0,0 +1,90 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type SlackBotConfig,
+  SlackBotConfigSchema,
+  type SlackBotCredentials,
+  SlackBotCredentialsSchema,
+  SlackBotError,
+} from './types'
+
+describe('SlackBotError', () => {
+  test('creates error with message and code', () => {
+    const error = new SlackBotError('Token is invalid', 'invalid_auth')
+
+    expect(error.message).toBe('Token is invalid')
+    expect(error.code).toBe('invalid_auth')
+    expect(error.name).toBe('SlackBotError')
+    expect(error instanceof Error).toBe(true)
+  })
+})
+
+describe('SlackBotCredentialsSchema', () => {
+  test('validates correct bot token credentials', () => {
+    const creds: SlackBotCredentials = {
+      token: 'xoxb-123456789-abcdef',
+      workspace_id: 'T12345678',
+      workspace_name: 'test-workspace',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    }
+
+    const result = SlackBotCredentialsSchema.safeParse(creds)
+    expect(result.success).toBe(true)
+  })
+
+  test('rejects user tokens (xoxp-)', () => {
+    const creds = {
+      token: 'xoxp-123456789-abcdef',
+      workspace_id: 'T12345678',
+      workspace_name: 'test-workspace',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    }
+
+    const result = SlackBotCredentialsSchema.safeParse(creds)
+    expect(result.success).toBe(false)
+  })
+
+  test('rejects missing fields', () => {
+    const creds = {
+      token: 'xoxb-123456789-abcdef',
+    }
+
+    const result = SlackBotCredentialsSchema.safeParse(creds)
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('SlackBotConfigSchema', () => {
+  test('validates correct config', () => {
+    const config: SlackBotConfig = {
+      current: { workspace_id: 'T12345678', bot_id: 'deploy' },
+      workspaces: {
+        T12345678: {
+          workspace_id: 'T12345678',
+          workspace_name: 'test-workspace',
+          bots: {
+            deploy: {
+              bot_id: 'deploy',
+              bot_name: 'Deploy Bot',
+              token: 'xoxb-123456789-abcdef',
+            },
+          },
+        },
+      },
+    }
+
+    const result = SlackBotConfigSchema.safeParse(config)
+    expect(result.success).toBe(true)
+  })
+
+  test('validates config with null current', () => {
+    const config: SlackBotConfig = {
+      current: null,
+      workspaces: {},
+    }
+
+    const result = SlackBotConfigSchema.safeParse(config)
+    expect(result.success).toBe(true)
+  })
+})