agent-messenger 2.0.0 → 2.2.0

package/src/platforms/webex/types.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod'
+
+export interface WebexSpace {
+  id: string
+  title: string
+  type: 'group' | 'direct'
+  isLocked: boolean
+  teamId?: string
+  lastActivity: string
+  created: string
+  creatorId: string
+}
+
+export interface WebexMessage {
+  id: string
+  roomId: string
+  roomType: 'group' | 'direct'
+  text?: string
+  markdown?: string
+  html?: string
+  files?: string[]
+  personId: string
+  personEmail: string
+  created: string
+  parentId?: string
+  mentionedPeople?: string[]
+}
+
+export interface WebexPerson {
+  id: string
+  emails: string[]
+  displayName: string
+  nickName?: string
+  firstName?: string
+  lastName?: string
+  avatar?: string
+  orgId: string
+  type: 'person' | 'bot'
+  created: string
+}
+
+export interface WebexMembership {
+  id: string
+  roomId: string
+  personId: string
+  personEmail: string
+  personDisplayName: string
+  isModerator: boolean
+  created: string
+}
+
+export interface WebexConfig {
+  accessToken: string
+  refreshToken: string
+  expiresAt: number
+  clientId?: string
+  clientSecret?: string
+  tokenType?: 'oauth' | 'manual' | 'extracted'
+  deviceUrl?: string
+}
+
+export class WebexError extends Error {
+  code: string
+
+  constructor(message: string, code: string) {
+    super(message)
+    this.name = 'WebexError'
+    this.code = code
+  }
+}
+
+export const WebexSpaceSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  type: z.enum(['group', 'direct']),
+  isLocked: z.boolean(),
+  teamId: z.string().optional(),
+  lastActivity: z.string(),
+  created: z.string(),
+  creatorId: z.string(),
+})
+
+export const WebexMessageSchema = z.object({
+  id: z.string(),
+  roomId: z.string(),
+  roomType: z.enum(['group', 'direct']),
+  text: z.string().optional(),
+  markdown: z.string().optional(),
+  html: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  personId: z.string(),
+  personEmail: z.string(),
+  created: z.string(),
+  parentId: z.string().optional(),
+  mentionedPeople: z.array(z.string()).optional(),
+})
+
+export const WebexPersonSchema = z.object({
+  id: z.string(),
+  emails: z.array(z.string()),
+  displayName: z.string(),
+  nickName: z.string().optional(),
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  avatar: z.string().optional(),
+  orgId: z.string(),
+  type: z.enum(['person', 'bot']),
+  created: z.string(),
+})
+
+export const WebexMembershipSchema = z.object({
+  id: z.string(),
+  roomId: z.string(),
+  personId: z.string(),
+  personEmail: z.string(),
+  personDisplayName: z.string(),
+  isModerator: z.boolean(),
+  created: z.string(),
+})
+
+export const WebexConfigSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  expiresAt: z.number(),
+  clientId: z.string().optional(),
+  clientSecret: z.string().optional(),
+  tokenType: z.enum(['oauth', 'manual', 'extracted']).optional(),
+  deviceUrl: z.string().optional(),
+})

package/src/platforms/whatsapp/client.ts

@@ -25,10 +25,14 @@ import {
 
 const MAX_MESSAGES_PER_CHAT = 500
 
-function toTimestampMs(ts: number | { toNumber(): number } | null | undefined): number {
+function toTimestampMs(ts: unknown): number {
   if (ts == null) return 0
-  if (typeof ts === 'object') return ts.toNumber() * 1000
-  return ts * 1000
+  if (typeof ts === 'number') return ts * 1000
+  if (typeof ts === 'object' && ts !== null && 'toNumber' in ts && typeof (ts as Record<string, unknown>).toNumber === 'function') {
+    return (ts as { toNumber(): number }).toNumber() * 1000
+  }
+  const n = Number(ts)
+  return Number.isNaN(n) ? 0 : n * 1000
 }
 
 function resolveJid(input: string): string {
@@ -443,8 +447,8 @@ export class WhatsAppClient {
     const sorted = chats.sort((a, b) => {
       const aTime = a.conversationTimestamp
       const bTime = b.conversationTimestamp
-      const aMs = toTimestampMs(aTime as number | { toNumber(): number } | null | undefined)
-      const bMs = toTimestampMs(bTime as number | { toNumber(): number } | null | undefined)
+      const aMs = toTimestampMs(aTime)
+      const bMs = toTimestampMs(bTime)
       return bMs - aMs
     })
 
@@ -474,8 +478,8 @@ export class WhatsAppClient {
 
     const msgs = this.messages.get(resolvedJid) ?? []
     const sorted = [...msgs].sort((a, b) => {
-      const aMs = toTimestampMs(a.messageTimestamp as number | { toNumber(): number } | null | undefined)
-      const bMs = toTimestampMs(b.messageTimestamp as number | { toNumber(): number } | null | undefined)
+      const aMs = toTimestampMs(a.messageTimestamp)
+      const bMs = toTimestampMs(b.messageTimestamp)
       return aMs - bMs
     })
 

package/src/shared/utils/derived-key-cache.ts

@@ -3,7 +3,7 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-export type Platform = 'slack' | 'discord' | 'teams'
+export type Platform = 'slack' | 'discord' | 'teams' | 'webex'
 
 /**
  * Caches derived encryption keys to avoid repeated macOS Keychain prompts.

package/src/shared/utils/error-handler.ts

@@ -1,4 +1,6 @@
-export function handleError(error: Error): void {
-  console.error(JSON.stringify({ error: error.message }))
+import { error } from './stderr'
+
+export function handleError(err: Error): void {
+  error(JSON.stringify({ error: err.message }))
   process.exit(1)
 }

package/src/shared/utils/stderr.ts

@@ -0,0 +1,22 @@
+const isTTY = process.stderr.isTTY ?? false
+
+const RESET = isTTY ? '\x1b[0m' : ''
+const RED = isTTY ? '\x1b[31m' : ''
+const YELLOW = isTTY ? '\x1b[33m' : ''
+const DIM = isTTY ? '\x1b[2m' : ''
+
+export function info(message: string): void {
+  process.stderr.write(`${message}\n`)
+}
+
+export function warn(message: string): void {
+  process.stderr.write(`${YELLOW}${message}${RESET}\n`)
+}
+
+export function error(message: string): void {
+  process.stderr.write(`${RED}${message}${RESET}\n`)
+}
+
+export function debug(message: string): void {
+  process.stderr.write(`${DIM}${message}${RESET}\n`)
+}

package/src/tui/adapters/webex-adapter.ts

@@ -0,0 +1,103 @@
+import { exec } from 'node:child_process'
+
+import { WebexClient } from '@/platforms/webex/client'
+import { WebexCredentialManager } from '@/platforms/webex/credential-manager'
+import { getWebexAppCredentials } from '@/platforms/webex/app-config'
+
+import type { AuthHint, AuthIO, PlatformAdapter, UnifiedChannel, UnifiedMessage } from './types'
+
+export class WebexAdapter implements PlatformAdapter {
+  readonly name = 'Webex'
+
+  private client: WebexClient | null = null
+  private personEmail: string | null = null
+
+  async login(): Promise<void> {
+    const client = new WebexClient()
+    await client.login()
+    const me = await client.testAuth()
+    this.client = client
+    this.personEmail = me.emails[0] ?? null
+  }
+
+  async getChannels(): Promise<UnifiedChannel[]> {
+    this.ensureClient()
+    const spaces = await this.client!.listSpaces()
+    return spaces.map((space) => ({
+      id: space.id,
+      name: space.title,
+    }))
+  }
+
+  async getMessages(channelId: string, limit = 50): Promise<UnifiedMessage[]> {
+    this.ensureClient()
+    const messages = await this.client!.listMessages(channelId, { max: limit })
+    return messages
+      .map((msg) => ({
+        id: msg.id,
+        channelId: msg.roomId,
+        author: msg.personEmail,
+        content: msg.text ?? '',
+        timestamp: msg.created,
+      }))
+      .reverse()
+  }
+
+  async sendMessage(channelId: string, text: string): Promise<void> {
+    this.ensureClient()
+    await this.client!.sendMessage(channelId, text)
+  }
+
+  getAuthHint(): AuthHint {
+    return {
+      command: 'agent-webex auth login',
+      description: 'Authenticate with Cisco Webex using OAuth Device Grant. Run the command below to start.',
+    }
+  }
+
+  async authenticate(io: AuthIO): Promise<void> {
+    const credManager = new WebexCredentialManager()
+    const { clientId, clientSecret } = getWebexAppCredentials()
+
+    io.print('Starting Webex OAuth Device Grant flow...')
+    const device = await credManager.requestDeviceCode(clientId)
+
+    io.print(`\nOpen this URL in your browser:\n  ${device.verificationUriComplete}`)
+    io.print(`\nOr go to ${device.verificationUri} and enter code: ${device.userCode}`)
+    openBrowser(device.verificationUriComplete)
+    io.print('\nWaiting for authorization...')
+
+    const config = await credManager.pollDeviceToken(
+      device.deviceCode,
+      device.interval,
+      device.expiresIn,
+      clientId,
+      clientSecret,
+    )
+    await credManager.saveConfig(config)
+
+    const client = new WebexClient()
+    await client.login({ token: config.accessToken })
+    const me = await client.testAuth()
+    this.client = client
+    this.personEmail = me.emails[0] ?? null
+
+    io.print(`\nAuthenticated as ${me.displayName} (${this.personEmail})`)
+  }
+
+  private ensureClient(): void {
+    if (!this.client) {
+      throw new Error('Not logged in. Call login() first.')
+    }
+  }
+}
+
+function openBrowser(url: string): void {
+  const command =
+    process.platform === 'darwin'
+      ? `open "${url}"`
+      : process.platform === 'win32'
+        ? `start "" "${url}"`
+        : `xdg-open "${url}"`
+  exec(command)
+}

package/src/tui/app.ts

@@ -3,6 +3,7 @@ import blessed from 'blessed'
 import { SlackAdapter } from './adapters/slack-adapter'
 import { DiscordAdapter } from './adapters/discord-adapter'
 import { TeamsAdapter } from './adapters/teams-adapter'
+import { WebexAdapter } from './adapters/webex-adapter'
 import { TelegramAdapter } from './adapters/telegram-adapter'
 import { WhatsAppAdapter } from './adapters/whatsapp-adapter'
 import { LineAdapter } from './adapters/line-adapter'
@@ -38,6 +39,7 @@ export async function createApp(): Promise<void> {
     { adapter: new SlackAdapter(), label: 'Slack', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
     { adapter: new DiscordAdapter(), label: 'Discord', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
     { adapter: new TeamsAdapter(), label: 'Teams', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+    { adapter: new WebexAdapter(), label: 'Webex', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
     { adapter: new TelegramAdapter(), label: 'Telegram', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
     { adapter: new WhatsAppAdapter(), label: 'WhatsApp', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
     { adapter: new LineAdapter(), label: 'LINE', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },