agent-messenger 2.0.0 → 2.2.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.2.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.2.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/channeltalk/commands/auth.test.ts

@@ -19,8 +19,8 @@ const mockListChannels = mock(() =>
     { id: 'ws-2', name: 'Workspace 2' },
   ]),
 )
-const mockExtract = mock<() => Promise<{ accountCookie: string; sessionCookie: string } | null>>(() =>
-  Promise.resolve({ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }),
+const mockExtract = mock(() =>
+  Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]),
 )
 
 import {
@@ -113,7 +113,7 @@ describe('channel auth commands', () => {
         { id: 'ws-2', name: 'Workspace 2' },
       ]),
     )
-    mockExtract.mockImplementation(() => Promise.resolve({ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }))
+    mockExtract.mockImplementation(() => Promise.resolve([{ accountCookie: 'fresh-account', sessionCookie: 'fresh-session' }]))
   })
 
   describe('extractAction', () => {
@@ -177,7 +177,7 @@ describe('channel auth commands', () => {
     })
 
     test('returns error when token extraction fails', async () => {
-      mockExtract.mockImplementation(() => Promise.resolve(null))
+      mockExtract.mockImplementation(() => Promise.resolve([]))
 
       const result = await extractAction()
 
@@ -192,7 +192,7 @@ describe('channel auth commands', () => {
       const result = await extractAction()
 
       expect(result).toEqual({
-        error: 'No workspaces found for this account.',
+        error: 'No valid credentials found. Make sure Channel Talk desktop app or browser is logged in.',
       })
     })
   })

package/src/platforms/channeltalk/commands/auth.ts

@@ -82,45 +82,51 @@ export async function extractAction(options: ActionOptions = {}): Promise<Extrac
     const extractor = createTokenExtractor()
     const extracted = await extractor.extract()
 
-    if (!extracted) {
+    if (extracted.length === 0) {
       return {
         error: 'No credentials. Make sure Channel Talk desktop app is installed and logged in.',
       }
     }
 
-    const client = await createChannelClient(extracted.accountCookie, extracted.sessionCookie)
-    const account = await client.getAccount()
-    const channels = await client.listChannels()
-
-    if (channels.length === 0) {
-      return { error: 'No workspaces found for this account.' }
-    }
-
-    const previousCurrent = await credManager.getCredentials()
-
-    for (const channel of channels) {
-      await credManager.setCredentials({
-        workspace_id: channel.id,
-        workspace_name: channel.name,
-        account_id: account.id,
-        account_name: account.name,
-        account_cookie: extracted.accountCookie,
-        session_cookie: extracted.sessionCookie,
-      })
+    for (const cookies of extracted) {
+      try {
+        const client = await createChannelClient(cookies.accountCookie, cookies.sessionCookie)
+        const account = await client.getAccount()
+        const channels = await client.listChannels()
+
+        if (channels.length === 0) continue
+
+        const previousCurrent = await credManager.getCredentials()
+
+        for (const channel of channels) {
+          await credManager.setCredentials({
+            workspace_id: channel.id,
+            workspace_name: channel.name,
+            account_id: account.id,
+            account_name: account.name,
+            account_cookie: cookies.accountCookie,
+            session_cookie: cookies.sessionCookie,
+          })
+        }
+
+        const previousStillExists = previousCurrent && channels.some((ch) => ch.id === previousCurrent.workspace_id)
+        const currentId = previousStillExists ? previousCurrent.workspace_id : channels[0].id
+        await credManager.setCurrent(currentId)
+
+        return {
+          success: true,
+          workspaces: channels.map((ch) => ({
+            workspace_id: ch.id,
+            workspace_name: ch.name,
+          })),
+          current_workspace_id: currentId,
+        }
+      } catch {
+        continue
+      }
     }
 
-    const previousStillExists = previousCurrent && channels.some((ch) => ch.id === previousCurrent.workspace_id)
-    const currentId = previousStillExists ? previousCurrent.workspace_id : channels[0].id
-    await credManager.setCurrent(currentId)
-
-    return {
-      success: true,
-      workspaces: channels.map((ch) => ({
-        workspace_id: ch.id,
-        workspace_name: ch.name,
-      })),
-      current_workspace_id: currentId,
-    }
+    return { error: 'No valid credentials found. Make sure Channel Talk desktop app or browser is logged in.' }
   } catch (error: unknown) {
     return { error: (error as Error).message }
   }

package/src/platforms/channeltalk/ensure-auth.test.ts

@@ -17,7 +17,7 @@ const mockGetCredentials = mock<() => Promise<
 >>(() => Promise.resolve(null))
 const mockSetCredentials = mock(() => Promise.resolve())
 const mockSetCurrent = mock(() => Promise.resolve(true))
-const mockExtract = mock(() => Promise.resolve(null))
+const mockExtract = mock(() => Promise.resolve([]))
 const mockGetAccount = mock(() => Promise.resolve({ id: 'acct-1', name: 'Alice' }))
 const mockListChannels = mock(() => Promise.resolve([{ id: 'ws-1', name: 'Workspace 1' }]))
 
@@ -58,17 +58,17 @@ describe('ensureChannelAuth', () => {
     mockGetCredentials.mockImplementation(() => Promise.resolve(null))
     mockSetCredentials.mockImplementation(() => Promise.resolve())
     mockSetCurrent.mockImplementation(() => Promise.resolve(true))
-    mockExtract.mockImplementation(() => Promise.resolve(null))
+    mockExtract.mockImplementation(() => Promise.resolve([]))
     mockGetAccount.mockImplementation(() => Promise.resolve({ id: 'acct-1', name: 'Alice' }))
     mockListChannels.mockImplementation(() => Promise.resolve([{ id: 'ws-1', name: 'Workspace 1' }]))
   })
 
   test('extracts and saves workspaces when no credentials exist', async () => {
     mockExtract.mockImplementation(() =>
-      Promise.resolve({
+      Promise.resolve([{
         accountCookie: 'account-cookie',
         sessionCookie: 'session-cookie',
-      }),
+      }]),
     )
     mockListChannels.mockImplementation(() =>
       Promise.resolve([
@@ -128,10 +128,10 @@ describe('ensureChannelAuth', () => {
     )
     mockGetAccount.mockImplementationOnce(() => Promise.reject(new Error('Unauthorized')))
     mockExtract.mockImplementation(() =>
-      Promise.resolve({
+      Promise.resolve([{
         accountCookie: 'fresh-account',
         sessionCookie: 'fresh-session',
-      }),
+      }]),
     )
 
     await ensureChannelAuth()

package/src/platforms/channeltalk/ensure-auth.ts

@@ -58,11 +58,11 @@ export async function ensureChannelAuth(): Promise<void> {
 
     const extractor = createTokenExtractor()
     const extracted = await extractor.extract()
-    if (!extracted) {
+    if (extracted.length === 0) {
       return
     }
 
-    const client = await createChannelClient(extracted.accountCookie, extracted.sessionCookie)
+    const client = await createChannelClient(extracted[0].accountCookie, extracted[0].sessionCookie)
     const account = await client.getAccount()
     const channels = await client.listChannels()
     if (channels.length === 0) {
@@ -76,8 +76,8 @@ export async function ensureChannelAuth(): Promise<void> {
       workspace_name: currentChannel.name,
       account_id: account.id,
       account_name: account.name,
-      account_cookie: extracted.accountCookie,
-      session_cookie: extracted.sessionCookie,
+      account_cookie: extracted[0].accountCookie,
+      session_cookie: extracted[0].sessionCookie,
     })
 
     for (const channel of otherChannels) {
@@ -86,8 +86,8 @@ export async function ensureChannelAuth(): Promise<void> {
         workspace_name: channel.name,
         account_id: account.id,
         account_name: account.name,
-        account_cookie: extracted.accountCookie,
-        session_cookie: extracted.sessionCookie,
+        account_cookie: extracted[0].accountCookie,
+        session_cookie: extracted[0].sessionCookie,
       })
     }