agent-messenger 1.0.0 → 1.2.0

package/e2e/README.md

@@ -0,0 +1,256 @@
+# E2E Tests
+
+End-to-end tests that run every CLI command against real Slack and Discord APIs.
+
+## Prerequisites
+
+Before running E2E tests, you need:
+
+1. **Dedicated Test Workspaces** - Create separate Slack and Discord test workspaces/servers
+   - **Never run E2E tests against your business or personal accounts**
+   - Tests create and delete messages, which could interfere with real work
+
+2. **Test Channels** - Create an `e2e-test` channel in each test workspace/server
+   - Slack: Channel named `e2e-test`
+   - Discord: Text channel named `e2e-test`
+
+3. **Authentication** - Either:
+   - Local credentials from desktop apps (via `auth extract`)
+   - Environment variables (for CI)
+
+## Test Infrastructure
+
+| File | Description |
+|------|-------------|
+| `config.ts` | Hardcoded test workspace/server IDs and validation |
+| `helpers.ts` | CLI runner, JSON parser, message cleanup utilities |
+| `slack.e2e.test.ts` | Slack command tests (23 tests) |
+| `discord.e2e.test.ts` | Discord command tests (20 tests) |
+
+## Running E2E Tests Locally
+
+### Step 1: Extract Credentials
+
+First, make sure the desktop apps (Slack/Discord) are running and logged into your **test** workspaces.
+
+```bash
+# Extract Slack credentials
+agent-slack auth extract
+
+# Extract Discord credentials  
+agent-discord auth extract
+```
+
+### Step 2: Switch to Test Workspace
+
+Ensure you're targeting the correct test workspace:
+
+```bash
+# Verify Slack workspace
+agent-slack workspace current
+# Should show: "Agent Messenger" (T0AC55BSF6E)
+
+# Verify Discord server
+agent-discord server current
+# Should show: "Agent Messenger" (1467039439770357844)
+```
+
+If wrong, switch workspaces:
+
+```bash
+agent-slack workspace switch <test-workspace-id>
+agent-discord server switch <test-server-id>
+```
+
+### Step 3: Run Tests
+
+```bash
+# Run all E2E tests
+bun test e2e/
+
+# Run only Slack tests
+bun test e2e/slack.e2e.test.ts
+
+# Run only Discord tests
+bun test e2e/discord.e2e.test.ts
+
+# Run specific test by name
+bun test e2e/slack.e2e.test.ts --test-name-pattern "message send"
+```
+
+## Running E2E Tests in CI (GitHub Actions)
+
+### Required Secrets
+
+Set these secrets in your GitHub repository settings:
+
+#### Slack Secrets
+
+| Secret | Description | How to Get |
+|--------|-------------|------------|
+| `E2E_SLACK_TOKEN` | Slack auth token (xoxc-...) | `agent-slack auth extract` → check output |
+| `E2E_SLACK_COOKIE` | Slack cookie (xoxd-...) | Same as above |
+| `E2E_SLACK_WORKSPACE_ID` | Test workspace ID | `agent-slack workspace current` |
+| `E2E_SLACK_WORKSPACE_NAME` | Test workspace name | Same as above |
+
+#### Discord Secrets
+
+| Secret | Description | How to Get |
+|--------|-------------|------------|
+| `E2E_DISCORD_TOKEN` | Discord auth token | `agent-discord auth extract` → check output |
+| `E2E_DISCORD_SERVER_ID` | Test server ID | `agent-discord server current` |
+
+### Getting Credentials for CI
+
+Run locally to extract credentials, then copy them to GitHub Secrets:
+
+```bash
+# Slack - extract and view credentials
+agent-slack auth extract
+cat ~/.agent-messenger/slack/credentials.json
+# Copy token and cookie values
+
+# Discord - extract and view credentials
+agent-discord auth extract
+cat ~/.agent-messenger/discord/credentials.json
+# Copy token value
+```
+
+### Workflow Triggers
+
+The E2E workflow (`.github/workflows/e2e.yml`) runs:
+
+- **Manually**: Via `workflow_dispatch` (Actions tab → Run workflow)
+- **On PRs**: When changes are made to `src/`, `e2e/`, or `package.json`
+
+### Manual Trigger Options
+
+When triggering manually, you can select which platform to test:
+
+- `all` - Run both Slack and Discord tests (default)
+- `slack` - Run only Slack tests
+- `discord` - Run only Discord tests
+
+## Test Coverage
+
+### Slack Tests (23 tests)
+
+| Command Group | Tests |
+|---------------|-------|
+| `auth` | status |
+| `workspace` | list, current |
+| `message` | send, list, get, update, delete, thread reply, replies, search |
+| `channel` | list, list --type, info |
+| `user` | list, me, info |
+| `reaction` | add, list, remove |
+| `file` | upload, list, list --channel, info |
+| `snapshot` | default, --channels-only, --users-only, --limit |
+
+### Discord Tests (20 tests)
+
+| Command Group | Tests |
+|---------------|-------|
+| `auth` | status |
+| `server` | list, current, info |
+| `message` | send, list, get*, delete |
+| `channel` | list, info, history |
+| `user` | list, me, info* |
+| `reaction` | add*, list*, remove* |
+| `file` | upload, list |
+| `snapshot` | default, --channels-only, --users-only |
+
+\* Some Discord tests are skipped because they require Bot Token permissions not available to user tokens.
+
+## Troubleshooting
+
+### "Wrong workspace" / "Wrong server" Error
+
+The tests detected you're not in the designated test workspace:
+
+```
+Error: Wrong Slack workspace. Expected: Agent Messenger (T0AC55BSF6E), Got: My Company (TXXXXXX)
+```
+
+**Solution**: Switch to the correct test workspace before running tests.
+
+### Authentication Failed
+
+```
+Error: Slack authentication failed. Please run: agent-messenger slack auth login
+```
+
+**Solution**: 
+1. Make sure the desktop app is running
+2. Run `agent-slack auth extract` or `agent-discord auth extract`
+3. For CI, check that secrets are correctly configured
+
+### Rate Limiting
+
+If tests fail intermittently with rate limit errors, try running fewer tests at once:
+
+```bash
+bun test e2e/slack.e2e.test.ts --test-name-pattern "auth"
+```
+
+The test harness includes automatic delays between API calls, but heavy testing may still hit limits.
+
+### Orphaned Test Messages
+
+If tests crash before cleanup, you may have leftover messages in the `e2e-test` channel. Clean them up manually:
+
+```bash
+# List recent messages
+agent-slack message list e2e-test --limit 20 --pretty
+
+# Delete specific message
+agent-slack message delete e2e-test <timestamp> --force
+```
+
+### CI Environment Variables Not Working
+
+Verify the credential managers are reading env vars:
+
+```bash
+# Test locally with env vars
+E2E_SLACK_TOKEN=xoxc-test E2E_SLACK_COOKIE=xoxd-test bun -e "
+  import { CredentialManager } from './src/platforms/slack/credential-manager.ts';
+  const cm = new CredentialManager();
+  const creds = await cm.getWorkspace();
+  console.log(creds);
+"
+```
+
+If this shows your test credentials, env var support is working.
+
+## Safety Features
+
+1. **Hardcoded Test IDs**: Test workspace/server IDs are hardcoded in `config.ts`. Tests will refuse to run against other workspaces.
+
+2. **Environment Validation**: Before any write operations, tests call `validateSlackEnvironment()` or `validateDiscordEnvironment()` to verify the correct workspace.
+
+3. **Automatic Cleanup**: Tests track created messages and delete them in `afterEach` hooks.
+
+4. **Rate Limiting**: Built-in delays between API calls prevent hitting rate limits.
+
+## Adding New Tests
+
+1. Follow existing patterns in `slack.e2e.test.ts` or `discord.e2e.test.ts`
+2. Use helpers from `helpers.ts` for CLI execution
+3. Track created resources for cleanup in `afterEach`
+4. Add appropriate delays with `waitForRateLimit()`
+
+Example:
+
+```typescript
+test('my new test', async () => {
+  const testId = generateTestId()
+  const { id } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Test ${testId}`)
+  testMessages.push(id)  // Track for cleanup
+  
+  await waitForRateLimit()
+  
+  // Your test assertions here
+  const result = await runCLI('slack', ['some', 'command', id])
+  expect(result.exitCode).toBe(0)
+})
+```

package/e2e/config.ts

@@ -0,0 +1,51 @@
+export const SLACK_TEST_WORKSPACE_ID = 'T0AC55BSF6E'
+export const SLACK_TEST_WORKSPACE_NAME = 'Agent Messenger'
+export const SLACK_TEST_CHANNEL_ID = 'C0ACZKTDDC0'
+export const SLACK_TEST_CHANNEL = 'e2e-test'
+
+// Discord Test Environment
+export const DISCORD_TEST_SERVER_ID = '1467039439770357844'
+export const DISCORD_TEST_SERVER_NAME = 'Agent Messenger'
+export const DISCORD_TEST_CHANNEL_ID = '1467062262996144162'
+export const DISCORD_TEST_CHANNEL = 'e2e-test'
+
+export async function validateSlackEnvironment() {
+  const { runCLI, parseJSON } = await import('./helpers')
+  
+  const result = await runCLI('slack', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Slack authentication failed. Please run: agent-messenger slack auth login')
+  }
+  
+  const data = parseJSON<{ workspace_id: string; workspace_name: string }>(result.stdout)
+  if (data?.workspace_id !== SLACK_TEST_WORKSPACE_ID) {
+    const switchResult = await runCLI('slack', ['workspace', 'switch', SLACK_TEST_WORKSPACE_ID])
+    if (switchResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to switch to test workspace. Expected: ${SLACK_TEST_WORKSPACE_NAME} (${SLACK_TEST_WORKSPACE_ID}). ` +
+        `Make sure you have access to the test workspace.`
+      )
+    }
+  }
+}
+
+export async function validateDiscordEnvironment() {
+  const { runCLI, parseJSON } = await import('./helpers')
+  
+  const result = await runCLI('discord', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Discord authentication failed. Please run: agent-messenger discord auth login')
+  }
+  
+  const currentResult = await runCLI('discord', ['server', 'current'])
+  const data = parseJSON<{ server_id: string; server_name: string }>(currentResult.stdout)
+  if (data?.server_id !== DISCORD_TEST_SERVER_ID) {
+    const switchResult = await runCLI('discord', ['server', 'switch', DISCORD_TEST_SERVER_ID])
+    if (switchResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to switch to test server. Expected: ${DISCORD_TEST_SERVER_NAME} (${DISCORD_TEST_SERVER_ID}). ` +
+        `Make sure you have access to the test server.`
+      )
+    }
+  }
+}

package/e2e/discord.e2e.test.ts

@@ -0,0 +1,252 @@
+import { describe, test, expect, beforeAll, afterEach } from 'bun:test'
+import { 
+  runCLI, parseJSON, generateTestId, createTestMessage, 
+  deleteTestMessage, waitForRateLimit, cleanupMessages 
+} from './helpers'
+import { 
+  DISCORD_TEST_CHANNEL_ID,
+  DISCORD_TEST_SERVER_ID,
+  validateDiscordEnvironment 
+} from './config'
+
+// Track messages created during tests for cleanup
+let testMessages: string[] = []
+
+describe('Discord E2E Tests', () => {
+  beforeAll(async () => {
+    await validateDiscordEnvironment()
+  })
+
+  afterEach(async () => {
+    if (testMessages.length > 0) {
+      await cleanupMessages('discord', DISCORD_TEST_CHANNEL_ID, testMessages)
+      testMessages = []
+    }
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    test('auth status returns authenticated status', async () => {
+      const result = await runCLI('discord', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ authenticated: boolean }>(result.stdout)
+      expect(data?.authenticated).toBe(true)
+    })
+  })
+
+  describe('server', () => {
+    test('server list returns array', async () => {
+      const result = await runCLI('discord', ['server', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ server_id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('server current returns current server', async () => {
+      const result = await runCLI('discord', ['server', 'current'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ server_id: string }>(result.stdout)
+      expect(data?.server_id).toBe(DISCORD_TEST_SERVER_ID)
+    })
+
+    test('server info returns server details', async () => {
+      const result = await runCLI('discord', ['server', 'info', DISCORD_TEST_SERVER_ID])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+    })
+  })
+
+  describe('message', () => {
+    test('message send creates message', async () => {
+      const testId = generateTestId()
+      const result = await runCLI('discord', ['message', 'send', DISCORD_TEST_CHANNEL_ID, `Test message ${testId}`])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      
+      if (data?.id) testMessages.push(data.id)
+    })
+
+    test('message list returns messages array', async () => {
+      const result = await runCLI('discord', ['message', 'list', DISCORD_TEST_CHANNEL_ID, '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test.skip('message get retrieves specific message (requires bot token)', async () => {
+      const testId = generateTestId()
+      const { id } = await createTestMessage('discord', DISCORD_TEST_CHANNEL_ID, `Get test ${testId}`)
+      testMessages.push(id)
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('discord', ['message', 'get', DISCORD_TEST_CHANNEL_ID, id])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ content: string }>(result.stdout)
+      expect(data?.content).toContain(testId)
+    })
+
+    test('message delete removes message', async () => {
+      const testId = generateTestId()
+      const { id } = await createTestMessage('discord', DISCORD_TEST_CHANNEL_ID, `Delete me ${testId}`)
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('discord', ['message', 'delete', DISCORD_TEST_CHANNEL_ID, id, '--force'])
+      expect(result.exitCode).toBe(0)
+    })
+  })
+
+  describe('channel', () => {
+    test('channel list returns channels array', async () => {
+      const result = await runCLI('discord', ['channel', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('channel info returns channel details', async () => {
+      const result = await runCLI('discord', ['channel', 'info', DISCORD_TEST_CHANNEL_ID])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string }>(result.stdout)
+      expect(data?.id).toBe(DISCORD_TEST_CHANNEL_ID)
+    })
+
+    test('channel history returns messages', async () => {
+      const result = await runCLI('discord', ['channel', 'history', DISCORD_TEST_CHANNEL_ID, '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+  })
+
+  describe('user', () => {
+    test.skip('user list returns users array (requires bot token)', async () => {
+      const result = await runCLI('discord', ['user', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('user me returns current user', async () => {
+      const result = await runCLI('discord', ['user', 'me'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string; username: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      expect(data?.username).toBeTruthy()
+    })
+
+    test('user info returns user details', async () => {
+      // First get current user ID
+      const meResult = await runCLI('discord', ['user', 'me'])
+      expect(meResult.exitCode).toBe(0)
+      
+      const me = parseJSON<{ id: string }>(meResult.stdout)
+      expect(me?.id).toBeTruthy()
+       
+       await waitForRateLimit()
+       
+       const result = await runCLI('discord', ['user', 'info', me!.id])
+       expect(result.exitCode).toBe(0)
+       
+       const data = parseJSON<{ id: string }>(result.stdout)
+       expect(data?.id).toBe(me?.id)
+     })
+  })
+
+  describe('reaction', () => {
+    test.skip('reaction add/list/remove lifecycle (requires bot token)', async () => {
+      const testId = generateTestId()
+      const { id } = await createTestMessage('discord', DISCORD_TEST_CHANNEL_ID, `Reaction test ${testId}`)
+      testMessages.push(id)
+      
+      await waitForRateLimit()
+      
+      // Add reaction (using emoji name without colons)
+      const addResult = await runCLI('discord', ['reaction', 'add', DISCORD_TEST_CHANNEL_ID, id, '👍'])
+      expect(addResult.exitCode).toBe(0)
+      
+      await waitForRateLimit()
+      
+      // List reactions
+      const listResult = await runCLI('discord', ['reaction', 'list', DISCORD_TEST_CHANNEL_ID, id])
+      expect(listResult.exitCode).toBe(0)
+      
+      await waitForRateLimit()
+      
+      // Remove reaction
+      const removeResult = await runCLI('discord', ['reaction', 'remove', DISCORD_TEST_CHANNEL_ID, id, '👍'])
+      expect(removeResult.exitCode).toBe(0)
+    }, 15000) // Longer timeout for multiple operations
+  })
+
+  describe('file', () => {
+    test('file list returns files array', async () => {
+      const result = await runCLI('discord', ['file', 'list', DISCORD_TEST_CHANNEL_ID])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('file upload uploads file', async () => {
+      const testId = generateTestId()
+      const testFilePath = `/tmp/discord-e2e-${testId}.txt`
+      await Bun.write(testFilePath, `Discord E2E test file ${testId}`)
+      
+      try {
+        const result = await runCLI('discord', ['file', 'upload', DISCORD_TEST_CHANNEL_ID, testFilePath])
+        expect(result.exitCode).toBe(0)
+        
+        const data = parseJSON<{ id: string }>(result.stdout)
+        expect(data?.id).toBeTruthy()
+        
+        // Track message for cleanup (file uploads create messages)
+        if (data?.id) testMessages.push(data.id)
+      } finally {
+        await Bun.$`rm -f ${testFilePath}`.quiet()
+      }
+    })
+  })
+
+  describe('snapshot', () => {
+    test.skip('snapshot returns full server data (requires bot token)', async () => {
+      const result = await runCLI('discord', ['snapshot', '--limit', '2'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ channels: unknown[]; users: unknown[] }>(result.stdout)
+      expect(data?.channels).toBeDefined()
+      expect(data?.users).toBeDefined()
+    })
+
+    test('snapshot --channels-only returns only channels', async () => {
+      const result = await runCLI('discord', ['snapshot', '--channels-only'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ channels: unknown[] }>(result.stdout)
+      expect(data?.channels).toBeDefined()
+    })
+
+    test.skip('snapshot --users-only returns only users (requires bot token)', async () => {
+      const result = await runCLI('discord', ['snapshot', '--users-only'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ users: unknown[] }>(result.stdout)
+      expect(data?.users).toBeDefined()
+    })
+  })
+})

package/e2e/helpers.ts

@@ -0,0 +1,107 @@
+import { $ } from 'bun'
+
+export interface CLIResult {
+  exitCode: number
+  stdout: string
+  stderr: string
+}
+
+export async function runCLI(platform: string, args: string[]): Promise<CLIResult> {
+  const command = platform === 'slack' ? 'agent-slack' : 'agent-discord'
+  
+  try {
+    const result = await $`${command} ${args}`.quiet()
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    }
+  } catch (error: any) {
+    return {
+      exitCode: error.exitCode || 1,
+      stdout: error.stdout?.toString() || '',
+      stderr: error.stderr?.toString() || '',
+    }
+  }
+}
+
+export function parseJSON<T>(output: string): T | null {
+  try {
+    return JSON.parse(output) as T
+  } catch {
+    return null
+  }
+}
+
+export function generateTestId(): string {
+  return `e2e-${Date.now()}-${Math.random().toString(36).substring(7)}`
+}
+
+export async function createTestMessage(
+  platform: string,
+  channel: string,
+  text: string
+): Promise<{ id: string }> {
+  const result = await runCLI(platform, ['message', 'send', channel, text])
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to create test message: ${result.stderr}`)
+  }
+  
+  const data = parseJSON<{ ts?: string; id?: string }>(result.stdout)
+  const messageId = data?.ts || data?.id
+  if (!messageId) {
+    throw new Error('No message ID returned')
+  }
+  
+  return { id: messageId }
+}
+
+export async function deleteTestMessage(
+  platform: string,
+  channel: string,
+  messageId: string
+): Promise<void> {
+  // For Slack, check for thread replies and delete them first
+  if (platform === 'slack') {
+    try {
+      const repliesResult = await runCLI(platform, ['message', 'replies', channel, messageId])
+      if (repliesResult.exitCode === 0) {
+        const replies = parseJSON<Array<{ ts?: string; id?: string }>>(repliesResult.stdout)
+        if (replies && replies.length > 0) {
+          // Delete replies in reverse order (newest first), skip parent
+          const threadReplies = replies.filter(r => (r.ts || r.id) !== messageId)
+          for (const reply of threadReplies.reverse()) {
+            const replyId = reply.ts || reply.id
+            if (replyId) {
+              await runCLI(platform, ['message', 'delete', channel, replyId, '--force'])
+            }
+          }
+        }
+      }
+    } catch {
+      // Continue with parent deletion even if replies fail
+    }
+  }
+  
+  // Delete the parent message
+  await runCLI(platform, ['message', 'delete', channel, messageId, '--force'])
+}
+
+export async function waitForRateLimit(ms: number = 1000): Promise<void> {
+  await new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export async function cleanupMessages(
+  platform: string,
+  channel: string,
+  messageIds: string[]
+): Promise<void> {
+  for (const id of messageIds) {
+    try {
+      await deleteTestMessage(platform, channel, id)
+      await waitForRateLimit(500)
+    } catch (error) {
+      console.warn(`Failed to cleanup message ${id}:`, error)
+    }
+  }
+}