agent-messenger 1.0.0 → 1.2.0

package/e2e/slack.e2e.test.ts

@@ -0,0 +1,309 @@
+import { describe, test, expect, beforeAll, afterEach } from 'bun:test'
+import { 
+  runCLI, parseJSON, generateTestId, createTestMessage, 
+  deleteTestMessage, waitForRateLimit, cleanupMessages 
+} from './helpers'
+import { 
+  SLACK_TEST_CHANNEL, SLACK_TEST_CHANNEL_ID,
+  validateSlackEnvironment 
+} from './config'
+
+// Track messages created during tests for cleanup
+let testMessages: string[] = []
+
+describe('Slack E2E Tests', () => {
+  beforeAll(async () => {
+    // Validate we're in the correct workspace
+    await validateSlackEnvironment()
+  })
+
+  afterEach(async () => {
+    if (testMessages.length > 0) {
+      await cleanupMessages('slack', SLACK_TEST_CHANNEL_ID, testMessages)
+      testMessages = []
+    }
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    test('auth status returns authenticated workspace info', async () => {
+      const result = await runCLI('slack', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ workspace_id: string; workspace_name: string }>(result.stdout)
+      expect(data).not.toBeNull()
+      expect(data?.workspace_id).toBeTruthy()
+      expect(data?.workspace_name).toBeTruthy()
+    })
+  })
+
+  describe('workspace', () => {
+    test('workspace list returns array', async () => {
+      const result = await runCLI('slack', ['workspace', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string; name: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('workspace current returns current workspace', async () => {
+      const result = await runCLI('slack', ['workspace', 'current'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ workspace_id: string }>(result.stdout)
+      expect(data?.workspace_id).toBeTruthy()
+    })
+  })
+
+  describe('message', () => {
+    test('message send creates message and returns ts', async () => {
+      const testId = generateTestId()
+      const result = await runCLI('slack', ['message', 'send', SLACK_TEST_CHANNEL_ID, `Test message ${testId}`])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ ts: string }>(result.stdout)
+      expect(data?.ts).toBeTruthy()
+      
+      if (data?.ts) testMessages.push(data.ts)
+    })
+
+    test('message list returns messages array', async () => {
+      const result = await runCLI('slack', ['message', 'list', SLACK_TEST_CHANNEL_ID, '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ ts: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test('message get retrieves specific message', async () => {
+      const testId = generateTestId()
+      const { id: ts } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Get test ${testId}`)
+      testMessages.push(ts)
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('slack', ['message', 'get', SLACK_TEST_CHANNEL_ID, ts])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ text: string }>(result.stdout)
+      expect(data?.text).toContain(testId)
+    })
+
+    test('message update modifies message', async () => {
+      const testId = generateTestId()
+      const { id: ts } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Original ${testId}`)
+      testMessages.push(ts)
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('slack', ['message', 'update', SLACK_TEST_CHANNEL_ID, ts, `Updated ${testId}`])
+      expect(result.exitCode).toBe(0)
+      
+      await waitForRateLimit()
+      const getResult = await runCLI('slack', ['message', 'get', SLACK_TEST_CHANNEL_ID, ts])
+      const data = parseJSON<{ text: string }>(getResult.stdout)
+      expect(data?.text).toContain('Updated')
+    })
+
+    test('message search finds messages', async () => {
+      const result = await runCLI('slack', ['message', 'search', 'test', '--limit', '5'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ ts: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+     test('message send with thread creates reply', async () => {
+       const testId = generateTestId()
+       const { id: parentTs } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Parent ${testId}`)
+       testMessages.push(parentTs)
+       
+       await waitForRateLimit()
+       
+       const result = await runCLI('slack', ['message', 'send', SLACK_TEST_CHANNEL_ID, `Reply ${testId}`, '--thread', parentTs])
+       expect(result.exitCode).toBe(0)
+       
+       const data = parseJSON<{ ts: string; thread_ts: string }>(result.stdout)
+       expect(data?.thread_ts).toBe(parentTs)
+       
+       if (data?.ts) testMessages.push(data.ts)
+     }, 30000)
+
+    test('message replies gets thread replies', async () => {
+      const testId = generateTestId()
+      const { id: parentTs } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Thread parent ${testId}`)
+      testMessages.push(parentTs)
+      
+      await waitForRateLimit()
+      
+      await runCLI('slack', ['message', 'send', SLACK_TEST_CHANNEL_ID, `Thread reply ${testId}`, '--thread', parentTs])
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('slack', ['message', 'replies', SLACK_TEST_CHANNEL_ID, parentTs])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ ts: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+      expect(data?.length).toBeGreaterThanOrEqual(1)
+    })
+
+    test('message delete removes message', async () => {
+      const testId = generateTestId()
+      const { id: ts } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Delete me ${testId}`)
+      
+      await waitForRateLimit()
+      
+      const result = await runCLI('slack', ['message', 'delete', SLACK_TEST_CHANNEL_ID, ts, '--force'])
+      expect(result.exitCode).toBe(0)
+    })
+  })
+
+  describe('channel', () => {
+    test('channel list returns channels array', async () => {
+      const result = await runCLI('slack', ['channel', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string; name: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+      expect(data?.length).toBeGreaterThan(0)
+    })
+
+    test('channel list --type public filters channels', async () => {
+      const result = await runCLI('slack', ['channel', 'list', '--type', 'public'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ is_private: boolean }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+     test('channel info returns channel details', async () => {
+       const result = await runCLI('slack', ['channel', 'info', SLACK_TEST_CHANNEL_ID])
+       expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string; name: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      expect(data?.name).toBe('e2e-test')
+    })
+  })
+
+  describe('user', () => {
+    test('user list returns users array', async () => {
+      const result = await runCLI('slack', ['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('slack', ['user', 'me'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ id: string; name: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      expect(data?.name).toBeTruthy()
+    })
+
+    test('user info returns user details', async () => {
+      // First get current user ID
+      const meResult = await runCLI('slack', ['user', 'me'])
+      const me = parseJSON<{ id: string }>(meResult.stdout)
+      expect(me?.id).toBeTruthy()
+      
+      await waitForRateLimit()
+      
+      // Get user info
+      const result = await runCLI('slack', ['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('reaction add/list/remove lifecycle', async () => {
+      const testId = generateTestId()
+      const { id: ts } = await createTestMessage('slack', SLACK_TEST_CHANNEL_ID, `Reaction test ${testId}`)
+      testMessages.push(ts)
+      
+      await waitForRateLimit(2000)
+      
+      const addResult = await runCLI('slack', ['reaction', 'add', SLACK_TEST_CHANNEL_ID, ts, 'thumbsup'])
+      expect(addResult.exitCode).toBe(0)
+      
+      await waitForRateLimit(2000)
+      
+      const listResult = await runCLI('slack', ['reaction', 'list', SLACK_TEST_CHANNEL_ID, ts])
+      expect(listResult.exitCode).toBe(0)
+      
+      const data = parseJSON<{ reactions: Array<{ name: string }> }>(listResult.stdout)
+      expect(Array.isArray(data?.reactions)).toBe(true)
+      
+      await waitForRateLimit(2000)
+      
+      const removeResult = await runCLI('slack', ['reaction', 'remove', SLACK_TEST_CHANNEL_ID, ts, 'thumbsup'])
+      expect(removeResult.exitCode).toBe(0)
+    }, 15000)
+  })
+
+  describe('file', () => {
+    test('file list returns files array', async () => {
+      const result = await runCLI('slack', ['file', 'list'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<Array<{ id: string }>>(result.stdout)
+      expect(Array.isArray(data)).toBe(true)
+    })
+
+    test.skip('file upload uploads file', async () => {
+      const testId = generateTestId()
+      const testFilePath = `/tmp/slack-e2e-${testId}.txt`
+      await Bun.write(testFilePath, `E2E test file content ${testId}`)
+      
+      try {
+        const result = await runCLI('slack', ['file', 'upload', SLACK_TEST_CHANNEL_ID, testFilePath])
+        expect(result.exitCode).toBe(0)
+        
+        const data = parseJSON<{ id: string }>(result.stdout)
+        expect(data?.id).toBeTruthy()
+        
+        if (data?.id) {
+          await waitForRateLimit()
+          const infoResult = await runCLI('slack', ['file', 'info', data.id])
+          expect(infoResult.exitCode).toBe(0)
+        }
+      } finally {
+        await Bun.$`rm -f ${testFilePath}`.quiet()
+      }
+    })
+  })
+
+  describe('snapshot', () => {
+    test('snapshot returns full workspace data', async () => {
+      const result = await runCLI('slack', ['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('slack', ['snapshot', '--channels-only'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ channels: unknown[] }>(result.stdout)
+      expect(data?.channels).toBeDefined()
+    })
+
+    test('snapshot --users-only returns only users', async () => {
+      const result = await runCLI('slack', ['snapshot', '--users-only'])
+      expect(result.exitCode).toBe(0)
+      
+      const data = parseJSON<{ users: unknown[] }>(result.stdout)
+      expect(data?.users).toBeDefined()
+    })
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-messenger",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Multi-platform messaging CLI for AI agents (Slack, Discord, Teams)",
   "type": "module",
   "module": "dist/cli.js",
@@ -9,11 +9,14 @@
     "agent-messenger": "./src/cli.ts",
     "amsg": "./src/cli.ts",
     "agent-slack": "./src/platforms/slack/cli.ts",
-    "agent-discord": "./src/platforms/discord/cli.ts"
+    "agent-discord": "./src/platforms/discord/cli.ts",
+    "agent-teams": "./src/platforms/teams/cli.ts"
   },
   "scripts": {
-    "build": "tsc && sed -i '' '1s|#!/usr/bin/env bun|#!/usr/bin/env node|' dist/cli.js",
-    "test": "bun test",
+    "build": "tsc",
+    "postbuild": "bun scripts/postbuild.ts",
+    "test": "bun test src/",
+    "test:e2e": "bun test e2e/",
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "format": "biome format --write .",
@@ -32,6 +35,7 @@
     "@types/better-sqlite3": "^7.6.8",
     "@types/bun": "latest",
     "@types/node": "^20.10.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
 }

package/scripts/postbuild.ts

@@ -0,0 +1,15 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+
+const cliFiles = [
+  'dist/src/cli.js',
+  'dist/src/platforms/slack/cli.js',
+  'dist/src/platforms/discord/cli.js',
+]
+
+for (const file of cliFiles) {
+  const content = readFileSync(file, 'utf8')
+  const updated = content.replace('#!/usr/bin/env bun', '#!/usr/bin/env node')
+  writeFileSync(file, updated)
+}
+
+console.log(`Updated shebang in ${cliFiles.length} CLI files`)

package/skills/agent-discord/SKILL.md

@@ -6,7 +6,7 @@ allowed-tools: Bash(agent-discord:*)
 
 # Agent Discord
 
-A TypeScript CLI tool that enables AI agents and humans to interact with Discord servers through a simple command interface. Features seamless token extraction from the Discord desktop app and multi-guild support.
+A TypeScript CLI tool that enables AI agents and humans to interact with Discord servers through a simple command interface. Features seamless token extraction from the Discord desktop app and multi-server support.
 
 ## Quick Start
 
@@ -14,7 +14,7 @@ A TypeScript CLI tool that enables AI agents and humans to interact with Discord
 # Extract credentials from Discord desktop app (zero-config)
 agent-discord auth extract
 
-# Get guild snapshot
+# Get server snapshot
 agent-discord snapshot
 
 # Send a message
@@ -42,20 +42,20 @@ This command:
 - Auto-detects your platform (macOS/Linux/Windows)
 - Extracts user token from Discord desktop app's LevelDB storage
 - Validates token against Discord API before saving
-- Discovers ALL joined guilds (servers)
+- Discovers ALL joined servers
 - Stores credentials securely in `~/.config/agent-messenger/`
 
-### Multi-Guild Support
+### Multi-Server Support
 
 ```bash
-# List all available guilds
-agent-discord guild list
+# List all available servers
+agent-discord server list
 
-# Switch to a different guild
-agent-discord guild switch <guild-id>
+# Switch to a different server
+agent-discord server switch <server-id>
 
-# Show current guild
-agent-discord guild current
+# Show current server
+agent-discord server current
 
 # Check auth status
 agent-discord auth status
@@ -80,12 +80,15 @@ agent-discord message get 1234567890123456789 9876543210987654321
 
 # Delete a message
 agent-discord message delete <channel-id> <message-id> --force
+
+# Acknowledge/mark a message as read
+agent-discord message ack <channel-id> <message-id>
 ```
 
 ### Channel Commands
 
 ```bash
-# List channels in current guild (text channels only)
+# List channels in current server (text channels only)
 agent-discord channel list
 
 # Get channel info
@@ -96,26 +99,26 @@ agent-discord channel info 1234567890123456789
 agent-discord channel history <channel-id> --limit 100
 ```
 
-### Guild Commands
+### Server Commands
 
 ```bash
-# List all guilds
-agent-discord guild list
+# List all servers
+agent-discord server list
 
-# Get guild info
-agent-discord guild info <guild-id>
+# Get server info
+agent-discord server info <server-id>
 
-# Switch active guild
-agent-discord guild switch <guild-id>
+# Switch active server
+agent-discord server switch <server-id>
 
-# Show current guild
-agent-discord guild current
+# Show current server
+agent-discord server current
 ```
 
 ### User Commands
 
 ```bash
-# List guild members
+# List server members
 agent-discord user list
 
 # Get user info
@@ -125,6 +128,69 @@ agent-discord user info <user-id>
 agent-discord user me
 ```
 
+### DM Commands
+
+```bash
+# List DM channels
+agent-discord dm list
+
+# Create a DM channel with a user
+agent-discord dm create <user-id>
+```
+
+### Mention Commands
+
+```bash
+# List recent mentions
+agent-discord mention list
+agent-discord mention list --limit 50
+agent-discord mention list --guild <server-id>
+```
+
+### Friend Commands
+
+```bash
+# List all relationships (friends, blocked, pending requests)
+agent-discord friend list
+agent-discord friend list --pretty
+```
+
+### Note Commands
+
+```bash
+# Get note for a user
+agent-discord note get <user-id>
+
+# Set note for a user
+agent-discord note set <user-id> "Note content"
+```
+
+### Profile Commands
+
+```bash
+# Get detailed user profile
+agent-discord profile get <user-id>
+```
+
+### Member Commands
+
+```bash
+# Search guild members
+agent-discord member search <guild-id> <query>
+agent-discord member search 1234567890123456789 "john" --limit 20
+```
+
+### Thread Commands
+
+```bash
+# Create a thread in a channel
+agent-discord thread create <channel-id> <name>
+agent-discord thread create 1234567890123456789 "Discussion" --auto-archive-duration 1440
+
+# Archive a thread
+agent-discord thread archive <thread-id>
+```
+
 ### Reaction Commands
 
 ```bash
@@ -155,7 +221,7 @@ agent-discord file info <channel-id> <file-id>
 
 ### Snapshot Command
 
-Get comprehensive guild state for AI agents:
+Get comprehensive server state for AI agents:
 
 ```bash
 # Full snapshot
@@ -170,7 +236,7 @@ agent-discord snapshot --limit 10
 ```
 
 Returns JSON with:
-- Guild metadata (id, name)
+- Server metadata (id, name)
 - Channels (id, name, type, topic)
 - Recent messages (id, content, author, timestamp)
 - Members (id, username, global_name)
@@ -202,7 +268,7 @@ agent-discord channel list --pretty
 
 | Feature | Discord | Slack |
 |---------|---------|-------|
-| Server terminology | Guild | Workspace |
+| Server terminology | Server | Workspace |
 | Channel identifiers | Snowflake IDs | Channel name or ID |
 | Message identifiers | Snowflake IDs | Timestamps (ts) |
 | Threads | Thread ID field | Thread timestamp |
@@ -219,7 +285,7 @@ See `references/common-patterns.md` for typical AI agent workflows.
 See `templates/` directory for runnable examples:
 - `post-message.sh` - Send messages with error handling
 - `monitor-channel.sh` - Monitor channel for new messages
-- `guild-summary.sh` - Generate guild summary
+- `server-summary.sh` - Generate server summary
 
 ## Error Handling
 
@@ -233,7 +299,7 @@ All commands return consistent error format:
 
 Common errors:
 - `Not authenticated`: No valid token - run `auth extract`
-- `No current guild set`: Run `guild switch <id>` first
+- `No current server set`: Run `server switch <id>` first
 - `Message not found`: Invalid message ID
 - `Unknown Channel`: Invalid channel ID
 
@@ -245,11 +311,11 @@ Format:
 ```json
 {
   "token": "user_token_here",
-  "current_guild": "1234567890123456789",
-  "guilds": {
+  "current_server": "1234567890123456789",
+  "servers": {
     "1234567890123456789": {
-      "guild_id": "1234567890123456789",
-      "guild_name": "My Server"
+      "server_id": "1234567890123456789",
+      "server_name": "My Server"
     }
   }
 }