agent-messenger 2.0.0 → 2.1.0

package/skills/agent-webex/templates/monitor-space.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+#
+# monitor-space.sh - Monitor a Webex space for new messages
+#
+# Usage:
+#   ./monitor-space.sh <space-id> [interval]
+#
+# Arguments:
+#   space-id  - Space ID to monitor (use 'space list' to find IDs)
+#   interval  - Polling interval in seconds (default: 10)
+#
+# Example:
+#   ./monitor-space.sh "Y2lzY29zcGFyazovL..."
+#   ./monitor-space.sh "Y2lzY29zcGFyazovL..." 5
+
+set -euo pipefail
+
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <space-id> [interval]"
+  echo ""
+  echo "Examples:"
+  echo "  $0 'Y2lzY29zcGFyazovL...'       # Monitor space, poll every 10s"
+  echo "  $0 'Y2lzY29zcGFyazovL...' 5     # Monitor space, poll every 5s"
+  echo ""
+  echo "To find space IDs, run: agent-webex space list"
+  exit 1
+fi
+
+SPACE_ID="$1"
+INTERVAL="${2:-10}"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+LAST_ID=""
+FIRST_RUN=true
+
+format_time() {
+  local ts=$1
+  if command -v gdate &> /dev/null; then
+    gdate -d "$ts" "+%Y-%m-%d %H:%M:%S" 2>/dev/null || echo "$ts"
+  else
+    date -d "$ts" "+%Y-%m-%d %H:%M:%S" 2>/dev/null || echo "$ts"
+  fi
+}
+
+truncate_text() {
+  local text=$1
+  local max_length=100
+
+  if [ ${#text} -gt $max_length ]; then
+    echo "${text:0:$max_length}..."
+  else
+    echo "$text"
+  fi
+}
+
+check_messages() {
+  MESSAGES=$(agent-webex message list "$SPACE_ID" --limit 1 2>&1)
+
+  if echo "$MESSAGES" | jq -e '.error' > /dev/null 2>&1; then
+    ERROR_MSG=$(echo "$MESSAGES" | jq -r '.error // "Unknown error"')
+    echo -e "${RED}Error: $ERROR_MSG${NC}"
+
+    if echo "$ERROR_MSG" | grep -Eqi "401|unauthorized"; then
+      echo -e "${RED}Token expired or invalid. Get a new token from https://developer.webex.com${NC}"
+      exit 1
+    fi
+
+    return 1
+  fi
+
+  LATEST_ID=$(echo "$MESSAGES" | jq -r '.[0].id // ""')
+
+  if [ -z "$LATEST_ID" ]; then
+    if [ "$FIRST_RUN" = true ]; then
+      echo -e "${YELLOW}No messages in space yet${NC}"
+    fi
+    FIRST_RUN=false
+    return 0
+  fi
+
+  if [ "$LATEST_ID" != "$LAST_ID" ]; then
+    if [ "$FIRST_RUN" = false ] && [ -n "$LAST_ID" ]; then
+      TEXT=$(echo "$MESSAGES" | jq -r '.[0].text // ""')
+      AUTHOR=$(echo "$MESSAGES" | jq -r '.[0].personEmail // "Unknown"')
+      TIMESTAMP=$(echo "$MESSAGES" | jq -r '.[0].created // ""')
+
+      TIME=$(format_time "$TIMESTAMP")
+
+      echo ""
+      echo -e "${GREEN}----------------------------------------------${NC}"
+      echo -e "${BLUE}New message in space${NC}"
+      echo -e "${GREEN}----------------------------------------------${NC}"
+      echo -e "Time:    $TIME"
+      echo -e "From:    $AUTHOR"
+      echo -e "Message: $(truncate_text "$TEXT")"
+      echo -e "${GREEN}----------------------------------------------${NC}"
+
+      # Uncomment to auto-respond to keywords:
+      # if echo "$TEXT" | grep -qi "status"; then
+      #   agent-webex message send "$SPACE_ID" "All systems operational."
+      # fi
+    fi
+
+    LAST_ID="$LATEST_ID"
+  fi
+
+  FIRST_RUN=false
+  return 0
+}
+
+if ! command -v agent-webex &> /dev/null; then
+  echo -e "${RED}Error: agent-webex not found${NC}"
+  echo ""
+  echo "Install it with:"
+  echo "  npm install -g agent-messenger"
+  exit 1
+fi
+
+echo "Checking authentication..."
+AUTH_STATUS=$(agent-webex auth status 2>&1)
+
+if echo "$AUTH_STATUS" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Not authenticated!${NC}"
+  echo ""
+  echo "Run this to authenticate:"
+  echo "  agent-webex auth login --token <token>"
+  echo ""
+  echo "Get a token at: https://developer.webex.com/docs/getting-started"
+  exit 1
+fi
+
+USER_NAME=$(echo "$AUTH_STATUS" | jq -r '.displayName // "Unknown"')
+echo -e "${GREEN}Authenticated as: $USER_NAME${NC}"
+echo ""
+
+echo "Verifying space..."
+SPACE_INFO=$(agent-webex space info "$SPACE_ID" 2>&1)
+
+if echo "$SPACE_INFO" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Space '$SPACE_ID' not found${NC}"
+  echo ""
+  echo "List available spaces with:"
+  echo "  agent-webex space list"
+  exit 1
+fi
+
+SPACE_TITLE=$(echo "$SPACE_INFO" | jq -r '.title // "Unknown"')
+echo -e "${GREEN}Monitoring: $SPACE_TITLE ($SPACE_ID)${NC}"
+echo ""
+
+echo -e "${YELLOW}Monitoring for new messages (polling every ${INTERVAL}s)...${NC}"
+echo -e "${YELLOW}Press Ctrl+C to stop${NC}"
+echo ""
+
+trap 'echo -e "\n${YELLOW}Monitoring stopped${NC}"; exit 0' INT
+
+while true; do
+  check_messages
+  sleep "$INTERVAL"
+done

package/skills/agent-webex/templates/post-message.sh

@@ -0,0 +1,170 @@
+#!/bin/bash
+#
+# post-message.sh - Send a message to a Webex space with error handling
+#
+# Usage:
+#   ./post-message.sh <space-id> <message>
+#   ./post-message.sh --space-title <title> <message>
+#
+# Example:
+#   ./post-message.sh "Y2lzY29zcGFyazovL..." "Hello from script!"
+#   ./post-message.sh --space-title Engineering "Deployment completed"
+
+set -euo pipefail
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Parse arguments
+SPACE_ID=""
+SPACE_TITLE=""
+MESSAGE=""
+
+if [ "$1" = "--space-title" ]; then
+  if [ $# -lt 3 ]; then
+    echo "Usage: $0 --space-title <title> <message>"
+    echo ""
+    echo "Example:"
+    echo "  $0 --space-title Engineering 'Build completed'"
+    exit 1
+  fi
+  SPACE_TITLE="$2"
+  MESSAGE="$3"
+elif [ $# -lt 2 ]; then
+  echo "Usage: $0 <space-id> <message>"
+  echo "       $0 --space-title <title> <message>"
+  echo ""
+  echo "Examples:"
+  echo "  $0 'Y2lzY29zcGFyazovL...' 'Hello world!'"
+  echo "  $0 --space-title Engineering 'Build completed'"
+  exit 1
+else
+  SPACE_ID="$1"
+  MESSAGE="$2"
+fi
+
+# Function to send message with retry logic
+send_message() {
+  local space_id=$1
+  local message=$2
+  local max_attempts=3
+  local attempt=1
+
+  while [ $attempt -le $max_attempts ]; do
+    echo -e "${YELLOW}Attempt $attempt/$max_attempts...${NC}"
+
+    # Send message and capture result
+    RESULT=$(agent-webex message send "$space_id" "$message" 2>&1)
+
+    # Check if successful (has an 'id' field)
+    if echo "$RESULT" | jq -e '.id' > /dev/null 2>&1; then
+      echo -e "${GREEN}Message sent successfully!${NC}"
+
+      MSG_ID=$(echo "$RESULT" | jq -r '.id')
+
+      echo ""
+      echo "Message details:"
+      echo "  Space: $space_id"
+      echo "  Message ID: $MSG_ID"
+
+      return 0
+    fi
+
+    # Extract error information
+    if echo "$RESULT" | jq -e '.error' > /dev/null 2>&1; then
+      ERROR_MSG=$(echo "$RESULT" | jq -r '.error // "Unknown error"')
+      echo -e "${RED}Failed: $ERROR_MSG${NC}"
+
+      # Don't retry on auth errors
+      if echo "$ERROR_MSG" | grep -Eqi "401|unauthorized|not authenticated"; then
+        echo ""
+        echo "Not authenticated. Run:"
+        echo "  agent-webex auth login --token <token>"
+        return 1
+      fi
+
+      # Don't retry on not-found errors
+      if echo "$ERROR_MSG" | grep -qi "not found"; then
+        echo ""
+        echo "Space '$space_id' not found. Check space ID."
+        echo "List spaces with: agent-webex space list"
+        return 1
+      fi
+    else
+      echo -e "${RED}Unexpected error: $RESULT${NC}"
+    fi
+
+    # Exponential backoff before retry
+    if [ $attempt -lt $max_attempts ]; then
+      SLEEP_TIME=$((attempt * 2))
+      echo "Retrying in ${SLEEP_TIME}s..."
+      sleep $SLEEP_TIME
+    fi
+
+    attempt=$((attempt + 1))
+  done
+
+  echo -e "${RED}Failed after $max_attempts attempts${NC}"
+  return 1
+}
+
+# Check if agent-webex is installed
+if ! command -v agent-webex &> /dev/null; then
+  echo -e "${RED}Error: agent-webex not found${NC}"
+  echo ""
+  echo "Install it with:"
+  echo "  npm install -g agent-messenger"
+  exit 1
+fi
+
+# Check authentication
+echo "Checking authentication..."
+AUTH_STATUS=$(agent-webex auth status 2>&1)
+
+if echo "$AUTH_STATUS" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Not authenticated!${NC}"
+  echo ""
+  echo "Run this to authenticate:"
+  echo "  agent-webex auth login --token <token>"
+  echo ""
+  echo "Get a token at: https://developer.webex.com/docs/getting-started"
+  exit 1
+fi
+
+USER_NAME=$(echo "$AUTH_STATUS" | jq -r '.displayName // "Unknown"')
+echo -e "${GREEN}Authenticated as: $USER_NAME${NC}"
+
+# If space title provided, look up space ID
+if [ -n "$SPACE_TITLE" ]; then
+  echo "Looking up space '$SPACE_TITLE'..."
+  SPACES=$(agent-webex space list 2>&1)
+
+  if echo "$SPACES" | jq -e '.error' > /dev/null 2>&1; then
+    echo -e "${RED}Failed to list spaces${NC}"
+    exit 1
+  fi
+
+  SPACE_ID=$(echo "$SPACES" | jq -r --arg title "$SPACE_TITLE" '.[] | select(.title==$title) | .id')
+
+  if [ -z "$SPACE_ID" ]; then
+    echo -e "${RED}Space '$SPACE_TITLE' not found${NC}"
+    echo ""
+    echo "Available spaces:"
+    echo "$SPACES" | jq -r '.[] | "  \(.title) (\(.id))"'
+    exit 1
+  fi
+
+  echo -e "${GREEN}Found space: $SPACE_ID${NC}"
+fi
+
+echo ""
+
+# Send the message
+echo "Sending message to space $SPACE_ID..."
+echo "Message: $MESSAGE"
+echo ""
+
+send_message "$SPACE_ID" "$MESSAGE"

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.0.0
+version: 2.1.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.0.0
+version: 2.1.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:

package/src/cli.ts

@@ -68,6 +68,10 @@ program.command('channeltalkbot', 'Interact with Channel Talk using API credenti
   executableFile: join(__dirname, 'platforms', 'channeltalkbot', `cli${ext}`),
 })
 
+program.command('webex', 'Interact with Cisco Webex', {
+  executableFile: join(__dirname, 'platforms', 'webex', `cli${ext}`),
+})
+
 program.command('tui', 'Launch unified messenger TUI', {
   executableFile: join(__dirname, 'tui', `cli${ext}`),
 })

package/src/platforms/webex/app-config.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { getWebexAppCredentials } from './app-config'
+
+const ENV_KEYS = [
+  'AGENT_WEBEX_CLIENT_ID',
+  'AGENT_WEBEX_CLIENT_SECRET',
+  'AGENT_MESSENGER_WEBEX_CLIENT_ID',
+  'AGENT_MESSENGER_WEBEX_CLIENT_SECRET',
+] as const
+
+describe('webex app config', () => {
+  let savedEnv: Record<string, string | undefined> = {}
+
+  beforeEach(() => {
+    savedEnv = {}
+    for (const key of ENV_KEYS) {
+      savedEnv[key] = process.env[key]
+      delete process.env[key]
+    }
+  })
+
+  afterEach(() => {
+    for (const key of ENV_KEYS) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key]
+      } else {
+        process.env[key] = savedEnv[key]
+      }
+    }
+  })
+
+  test('returns env credentials when primary env vars are set', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'my-client-id'
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'my-client-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'my-client-id',
+      clientSecret: 'my-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('returns env credentials when legacy env vars are set', () => {
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID = 'legacy-client-id'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET = 'legacy-client-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'legacy-client-id',
+      clientSecret: 'legacy-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('returns builtin credentials when nothing is configured', () => {
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+    expect(result.clientId).toBeTruthy()
+    expect(result.clientSecret).toBeTruthy()
+  })
+
+  test('returns builtin when only clientId is set', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'my-client-id'
+
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+  })
+
+  test('returns builtin when only clientSecret is set', () => {
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'my-client-secret'
+
+    const result = getWebexAppCredentials()
+    expect(result.source).toBe('builtin')
+  })
+
+  test('trims whitespace from clientId and clientSecret', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = '  my-client-id  '
+    process.env.AGENT_WEBEX_CLIENT_SECRET = '  my-client-secret  '
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'my-client-id',
+      clientSecret: 'my-client-secret',
+      source: 'env',
+    })
+  })
+
+  test('primary env takes precedence over legacy env', () => {
+    process.env.AGENT_WEBEX_CLIENT_ID = 'primary-id'
+    process.env.AGENT_WEBEX_CLIENT_SECRET = 'primary-secret'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID = 'legacy-id'
+    process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET = 'legacy-secret'
+
+    expect(getWebexAppCredentials()).toEqual({
+      clientId: 'primary-id',
+      clientSecret: 'primary-secret',
+      source: 'env',
+    })
+  })
+})

package/src/platforms/webex/app-config.ts

@@ -0,0 +1,31 @@
+const BUILTIN_CLIENT_ID = 'C720341c19d8dfb4cab8a5db78be4bc6d5c3983fbe84df94be34c8aa69a695583'
+const BUILTIN_CLIENT_SECRET = 'e90806657443a7f16093c0846690aeeea96cd2b3ed9b79cf544297c526b4f9af'
+
+export interface WebexAppCredentials {
+  clientId: string
+  clientSecret: string
+  source: 'env' | 'builtin'
+}
+
+function parseTrimmed(value: string | undefined): string | undefined {
+  const normalized = value?.trim()
+  return normalized ? normalized : undefined
+}
+
+export function getWebexAppCredentials(): WebexAppCredentials {
+  const envClientId = parseTrimmed(process.env.AGENT_WEBEX_CLIENT_ID)
+  const envClientSecret = parseTrimmed(process.env.AGENT_WEBEX_CLIENT_SECRET)
+
+  if (envClientId && envClientSecret) {
+    return { clientId: envClientId, clientSecret: envClientSecret, source: 'env' }
+  }
+
+  const legacyClientId = parseTrimmed(process.env.AGENT_MESSENGER_WEBEX_CLIENT_ID)
+  const legacyClientSecret = parseTrimmed(process.env.AGENT_MESSENGER_WEBEX_CLIENT_SECRET)
+
+  if (legacyClientId && legacyClientSecret) {
+    return { clientId: legacyClientId, clientSecret: legacyClientSecret, source: 'env' }
+  }
+
+  return { clientId: BUILTIN_CLIENT_ID, clientSecret: BUILTIN_CLIENT_SECRET, source: 'builtin' }
+}

package/src/platforms/webex/cli.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+
+import { spawn } from 'bun'
+
+import pkg from '../../../package.json' with { type: 'json' }
+
+describe('Webex CLI program structure', () => {
+  test('--help shows all commands', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('auth')
+    expect(output).toContain('member')
+    expect(output).toContain('message')
+    expect(output).toContain('snapshot')
+    expect(output).toContain('space')
+  })
+
+  test('--version shows package version', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', '--version'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+    expect(output.trim()).toBe(pkg.version)
+  })
+
+  test('auth login --help shows Device Grant options', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', 'auth', 'login', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('--token')
+    expect(output).toContain('--client-id')
+    expect(output).toContain('--client-secret')
+    expect(output).toContain('--pretty')
+  })
+
+  test('message dm --help shows email argument', async () => {
+    const proc = spawn(['bun', 'run', './src/platforms/webex/cli.ts', 'message', 'dm', '--help'], {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const output = await new Response(proc.stdout).text()
+
+    expect(output).toContain('email')
+    expect(output).toContain('--markdown')
+  })
+})

package/src/platforms/webex/cli.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env bun
+
+import type { Command as CommandType } from 'commander'
+import { Command } from 'commander'
+
+import pkg from '../../../package.json' with { type: 'json' }
+import { authCommand, memberCommand, messageCommand, snapshotCommand, spaceCommand } from './commands'
+import { ensureWebexAuth } 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()
+
+program
+  .name('agent-webex')
+  .description('CLI tool for Cisco Webex communication')
+  .version(pkg.version)
+
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+  if (isAuthCommand(actionCommand)) return
+  await ensureWebexAuth()
+})
+
+program.addCommand(authCommand)
+program.addCommand(memberCommand)
+program.addCommand(messageCommand)
+program.addCommand(snapshotCommand)
+program.addCommand(spaceCommand)
+
+program.parse(process.argv)
+
+export default program