agent-messenger 1.2.0 → 1.3.0

package/skills/agent-slackbot/templates/workspace-summary.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+#
+# workspace-summary.sh - Generate a workspace summary via bot token
+#
+# Usage:
+#   ./workspace-summary.sh [--json]
+#
+# Options:
+#   --json  Output raw JSON instead of formatted text
+#
+# Example:
+#   ./workspace-summary.sh
+#   ./workspace-summary.sh --json > summary.json
+
+set -euo pipefail
+
+OUTPUT_JSON=false
+if [ $# -gt 0 ] && [ "$1" = "--json" ]; then
+  OUTPUT_JSON=true
+fi
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+if ! command -v agent-slackbot &> /dev/null; then
+  echo -e "${RED}Error: agent-slackbot not found${NC}" >&2
+  echo "Install: npm install -g agent-messenger" >&2
+  exit 1
+fi
+
+AUTH_STATUS=$(agent-slackbot auth status 2>&1)
+VALID=$(echo "$AUTH_STATUS" | jq -r '.valid // false')
+
+if [ "$VALID" != "true" ]; then
+  echo -e "${RED}Not authenticated! Run: agent-slackbot auth set xoxb-your-token${NC}" >&2
+  exit 1
+fi
+
+WORKSPACE=$(echo "$AUTH_STATUS" | jq -r '.workspace_name // "Unknown"')
+WORKSPACE_ID=$(echo "$AUTH_STATUS" | jq -r '.workspace_id // "Unknown"')
+BOT_NAME=$(echo "$AUTH_STATUS" | jq -r '.user // "Unknown"')
+
+echo -e "${YELLOW}Fetching workspace data...${NC}" >&2
+
+CHANNELS=$(agent-slackbot channel list 2>&1)
+CHANNEL_COUNT=$(echo "$CHANNELS" | jq 'length')
+PUBLIC_COUNT=$(echo "$CHANNELS" | jq '[.[] | select(.is_private == false)] | length')
+PRIVATE_COUNT=$(echo "$CHANNELS" | jq '[.[] | select(.is_private == true)] | length')
+
+USERS=$(agent-slackbot user list 2>&1)
+USER_COUNT=$(echo "$USERS" | jq 'length')
+
+if [ "$OUTPUT_JSON" = true ]; then
+  jq -n \
+    --arg workspace "$WORKSPACE" \
+    --arg workspace_id "$WORKSPACE_ID" \
+    --arg bot "$BOT_NAME" \
+    --argjson channels "$CHANNELS" \
+    --argjson users "$USERS" \
+    '{
+      workspace: { name: $workspace, id: $workspace_id, bot: $bot },
+      channels: $channels,
+      users: $users
+    }'
+  exit 0
+fi
+
+echo ""
+echo -e "${BOLD}${BLUE}Workspace Summary${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo -e "${BOLD}Workspace:${NC} $WORKSPACE"
+echo -e "${BOLD}ID:${NC}        $WORKSPACE_ID"
+echo -e "${BOLD}Bot:${NC}       $BOT_NAME"
+echo ""
+
+echo -e "${BOLD}${CYAN}Channels (${CHANNEL_COUNT} total)${NC}"
+echo -e "  Public:  $PUBLIC_COUNT"
+echo -e "  Private: $PRIVATE_COUNT"
+echo ""
+
+echo -e "${BOLD}${CYAN}Channel List:${NC}"
+echo "$CHANNELS" | jq -r '.[0:10] | .[] | "  #\(.name) (\(.id))"'
+if [ "$CHANNEL_COUNT" -gt 10 ]; then
+  echo "  ... and $((CHANNEL_COUNT - 10)) more"
+fi
+echo ""
+
+echo -e "${BOLD}${CYAN}Users (${USER_COUNT} total)${NC}"
+echo ""
+echo "$USERS" | jq -r '.[0:10] | .[] | "  \(.name) - \(.real_name // "N/A") (\(.id))"'
+if [ "$USER_COUNT" -gt 10 ]; then
+  echo "  ... and $((USER_COUNT - 10)) more"
+fi
+echo ""
+
+echo -e "${BOLD}${CYAN}Quick Actions:${NC}"
+echo ""
+FIRST_CHANNEL=$(echo "$CHANNELS" | jq -r '.[0].id // "C123"')
+FIRST_CHANNEL_NAME=$(echo "$CHANNELS" | jq -r '.[0].name // "general"')
+echo -e "  ${GREEN}# Send message to #$FIRST_CHANNEL_NAME${NC}"
+echo -e "  agent-slackbot message send $FIRST_CHANNEL \"Hello!\""
+echo ""
+echo -e "  ${GREEN}# List recent messages${NC}"
+echo -e "  agent-slackbot message list $FIRST_CHANNEL --limit 10"
+echo ""
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

package/src/platforms/slackbot/cli.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+
+import { Command } from 'commander'
+import pkg from '../../../package.json'
+import {
+  authCommand,
+  channelCommand,
+  messageCommand,
+  reactionCommand,
+  userCommand,
+} from './commands/index'
+
+const program = new Command()
+
+program
+  .name('agent-slackbot')
+  .description('CLI tool for Slack bot integration using bot tokens (xoxb-)')
+  .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
+  .option('--bot <id>', 'Use specific bot (default: current)')
+
+program.addCommand(authCommand)
+program.addCommand(messageCommand)
+program.addCommand(channelCommand)
+program.addCommand(userCommand)
+program.addCommand(reactionCommand)
+
+program.parse(process.argv)
+
+export default program

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

@@ -0,0 +1,282 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackBotClient } from './client'
+import { SlackBotError } from './types'
+
+// Mock the @slack/web-api module
+const mockAuth = {
+  test: mock(() =>
+    Promise.resolve({
+      ok: true,
+      user_id: 'U123',
+      team_id: 'T456',
+      bot_id: 'B789',
+      user: 'testbot',
+      team: 'Test Team',
+    })
+  ),
+}
+const mockConversations = {
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      channels: [
+        {
+          id: 'C123',
+          name: 'general',
+          is_private: false,
+          is_archived: false,
+          created: 1234567890,
+          creator: 'U001',
+        },
+      ],
+    })
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      channel: {
+        id: 'C123',
+        name: 'general',
+        is_private: false,
+        is_archived: false,
+        created: 1234567890,
+        creator: 'U001',
+      },
+    })
+  ),
+  history: mock(() =>
+    Promise.resolve({
+      ok: true,
+      messages: [{ ts: '1234567890.123456', text: 'Hello', type: 'message', user: 'U123' }],
+    })
+  ),
+}
+const mockChat = {
+  postMessage: mock(() =>
+    Promise.resolve({
+      ok: true,
+      ts: '1234567890.123456',
+      message: { text: 'Hello', type: 'message' },
+    })
+  ),
+}
+const mockReactions = {
+  add: mock(() => Promise.resolve({ ok: true })),
+  remove: mock(() => Promise.resolve({ ok: true })),
+}
+const mockUsers = {
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      members: [
+        {
+          id: 'U123',
+          name: 'testuser',
+          real_name: 'Test User',
+          is_admin: false,
+          is_owner: false,
+          is_bot: false,
+          is_app_user: false,
+        },
+      ],
+    })
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      user: {
+        id: 'U123',
+        name: 'testuser',
+        real_name: 'Test User',
+        is_admin: false,
+        is_owner: false,
+        is_bot: false,
+        is_app_user: false,
+      },
+    })
+  ),
+}
+
+mock.module('@slack/web-api', () => ({
+  WebClient: class MockWebClient {
+    auth = mockAuth
+    conversations = mockConversations
+    chat = mockChat
+    reactions = mockReactions
+    users = mockUsers
+  },
+}))
+
+describe('SlackBotClient', () => {
+  beforeEach(() => {
+    // Reset mocks
+    mockAuth.test.mockClear()
+    mockConversations.list.mockClear()
+    mockConversations.info.mockClear()
+    mockConversations.history.mockClear()
+    mockChat.postMessage.mockClear()
+    mockReactions.add.mockClear()
+    mockReactions.remove.mockClear()
+    mockUsers.list.mockClear()
+    mockUsers.info.mockClear()
+  })
+
+  describe('constructor', () => {
+    test('accepts bot tokens (xoxb-)', () => {
+      // when/then: should not throw
+      const client = new SlackBotClient('xoxb-test-token')
+      expect(client).toBeDefined()
+    })
+
+    test('rejects user tokens (xoxp-)', () => {
+      // when/then
+      expect(() => new SlackBotClient('xoxp-user-token')).toThrow(SlackBotError)
+    })
+
+    test('rejects empty token', () => {
+      // when/then
+      expect(() => new SlackBotClient('')).toThrow(SlackBotError)
+    })
+
+    test('rejects non-bot tokens', () => {
+      // when/then
+      expect(() => new SlackBotClient('invalid-token')).toThrow(SlackBotError)
+    })
+  })
+
+  describe('testAuth', () => {
+    test('returns auth info for valid token', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const result = await client.testAuth()
+
+      // then
+      expect(result.user_id).toBe('U123')
+      expect(result.team_id).toBe('T456')
+      expect(result.bot_id).toBe('B789')
+    })
+  })
+
+  describe('postMessage', () => {
+    test('sends message and returns timestamp', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const result = await client.postMessage('C123', 'Hello')
+
+      // then
+      expect(result.ts).toBe('1234567890.123456')
+      expect(result.text).toBe('Hello')
+    })
+  })
+
+  describe('getConversationHistory', () => {
+    test('returns messages', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const messages = await client.getConversationHistory('C123')
+
+      // then
+      expect(messages.length).toBeGreaterThan(0)
+      expect(messages[0].ts).toBe('1234567890.123456')
+    })
+  })
+
+  describe('getMessage', () => {
+    test('returns single message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const message = await client.getMessage('C123', '1234567890.123456')
+
+      // then
+      expect(message).not.toBeNull()
+      expect(message?.ts).toBe('1234567890.123456')
+    })
+  })
+
+  describe('addReaction', () => {
+    test('adds reaction to message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when/then: should not throw
+      await client.addReaction('C123', '1234567890.123456', 'thumbsup')
+      expect(mockReactions.add).toHaveBeenCalled()
+    })
+  })
+
+  describe('removeReaction', () => {
+    test('removes reaction from message', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when/then: should not throw
+      await client.removeReaction('C123', '1234567890.123456', 'thumbsup')
+      expect(mockReactions.remove).toHaveBeenCalled()
+    })
+  })
+
+  describe('listChannels', () => {
+    test('returns list of channels', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channels = await client.listChannels()
+
+      // then
+      expect(channels.length).toBeGreaterThan(0)
+      expect(channels[0].id).toBe('C123')
+      expect(channels[0].name).toBe('general')
+    })
+  })
+
+  describe('getChannelInfo', () => {
+    test('returns channel details', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const channel = await client.getChannelInfo('C123')
+
+      // then
+      expect(channel.id).toBe('C123')
+      expect(channel.name).toBe('general')
+    })
+  })
+
+  describe('listUsers', () => {
+    test('returns list of users', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const users = await client.listUsers()
+
+      // then
+      expect(users.length).toBeGreaterThan(0)
+      expect(users[0].id).toBe('U123')
+    })
+  })
+
+  describe('getUserInfo', () => {
+    test('returns user details', async () => {
+      // given
+      const client = new SlackBotClient('xoxb-test-token')
+
+      // when
+      const user = await client.getUserInfo('U123')
+
+      // then
+      expect(user.id).toBe('U123')
+      expect(user.name).toBe('testuser')
+    })
+  })
+})