@jimiford/webex 0.1.1

package/dist/send.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Webex Message Sending Module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebexApiRequestError = exports.WebexSender = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+// Rate limit status codes that should trigger retry
+const RETRY_STATUS_CODES = [429, 502, 503, 504];
+class WebexSender {
+    config;
+    apiBaseUrl;
+    retryOptions;
+    constructor(config) {
+        this.config = config;
+        this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;
+        this.retryOptions = {
+            maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+            retryDelayMs: config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
+        };
+    }
+    /**
+     * Send a message to Webex
+     */
+    async send(message) {
+        const request = this.buildMessageRequest(message);
+        return this.createMessage(request);
+    }
+    /**
+     * Send a text message to a room
+     */
+    async sendToRoom(roomId, text, markdown) {
+        return this.createMessage({
+            roomId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a direct message to a person by ID
+     */
+    async sendDirectById(personId, text, markdown) {
+        return this.createMessage({
+            toPersonId: personId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a direct message to a person by email
+     */
+    async sendDirectByEmail(email, text, markdown) {
+        return this.createMessage({
+            toPersonEmail: email,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Send a message with file attachment
+     */
+    async sendWithFile(roomId, text, fileUrl) {
+        return this.createMessage({
+            roomId,
+            text,
+            files: [fileUrl],
+        });
+    }
+    /**
+     * Send a threaded reply
+     */
+    async sendReply(roomId, parentId, text, markdown) {
+        return this.createMessage({
+            roomId,
+            parentId,
+            text,
+            markdown,
+        });
+    }
+    /**
+     * Get a message by ID
+     */
+    async getMessage(messageId) {
+        return this.request({
+            method: 'GET',
+            path: `/messages/${messageId}`,
+        });
+    }
+    /**
+     * Delete a message by ID
+     */
+    async deleteMessage(messageId) {
+        await this.request({
+            method: 'DELETE',
+            path: `/messages/${messageId}`,
+        });
+    }
+    /**
+     * Build a Webex message request from an OpenClaw outbound message
+     */
+    buildMessageRequest(message) {
+        const request = {};
+        // Determine target: roomId, personId, or email
+        const to = message.to;
+        if (to.includes('@')) {
+            request.toPersonEmail = to;
+        }
+        else if (to.startsWith('Y2lzY29zcGFyazovL3')) {
+            // Base64-encoded Webex IDs start with this prefix
+            if (to.includes('ROOM')) {
+                request.roomId = to;
+            }
+            else {
+                request.toPersonId = to;
+            }
+        }
+        else {
+            // Assume it's a roomId if not an email
+            request.roomId = to;
+        }
+        // Set content
+        if (message.content.text) {
+            request.text = message.content.text;
+        }
+        if (message.content.markdown) {
+            request.markdown = message.content.markdown;
+        }
+        if (message.content.files && message.content.files.length > 0) {
+            // Webex only allows one file per message
+            request.files = [message.content.files[0]];
+        }
+        if (message.content.card) {
+            request.attachments = [
+                {
+                    contentType: 'application/vnd.microsoft.card.adaptive',
+                    content: message.content.card,
+                },
+            ];
+        }
+        // Set threading
+        if (message.parentId) {
+            request.parentId = message.parentId;
+        }
+        return request;
+    }
+    /**
+     * Create a message via the Webex API
+     */
+    async createMessage(request) {
+        this.validateMessageRequest(request);
+        return this.request({
+            method: 'POST',
+            path: '/messages',
+            body: request,
+        });
+    }
+    /**
+     * Validate a message request before sending
+     */
+    validateMessageRequest(request) {
+        // Must have a target
+        if (!request.roomId && !request.toPersonId && !request.toPersonEmail) {
+            throw new Error('Message must have a target: roomId, toPersonId, or toPersonEmail');
+        }
+        // Must have content
+        if (!request.text && !request.markdown && !request.files?.length && !request.attachments?.length) {
+            throw new Error('Message must have content: text, markdown, files, or attachments');
+        }
+        // Text has a max size of 7439 bytes
+        if (request.text && Buffer.byteLength(request.text, 'utf8') > 7439) {
+            throw new Error('Message text exceeds maximum size of 7439 bytes');
+        }
+    }
+    /**
+     * Make an API request with retry logic
+     */
+    async request(options) {
+        let lastError = null;
+        let attempt = 0;
+        while (attempt <= this.retryOptions.maxRetries) {
+            try {
+                return await this.executeRequest(options);
+            }
+            catch (error) {
+                lastError = error;
+                attempt++;
+                if (attempt > this.retryOptions.maxRetries) {
+                    break;
+                }
+                if (!this.shouldRetry(error, attempt)) {
+                    break;
+                }
+                // Exponential backoff with jitter
+                const delay = this.calculateBackoff(attempt);
+                await this.sleep(delay);
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+    /**
+     * Execute a single API request
+     */
+    async executeRequest(options) {
+        const url = `${this.apiBaseUrl}${options.path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.config.token}`,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        const response = await (0, node_fetch_1.default)(url, {
+            method: options.method,
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const error = await this.parseErrorResponse(response);
+            throw error;
+        }
+        // DELETE requests return 204 No Content
+        if (response.status === 204) {
+            return undefined;
+        }
+        return response.json();
+    }
+    /**
+     * Parse error response from Webex API
+     */
+    async parseErrorResponse(response) {
+        let errorData = null;
+        try {
+            errorData = await response.json();
+        }
+        catch {
+            // Response body might not be JSON
+        }
+        const message = errorData?.message || `HTTP ${response.status}: ${response.statusText}`;
+        const error = new WebexApiRequestError(message, response.status, errorData?.trackingId, errorData?.errors);
+        return error;
+    }
+    /**
+     * Determine if a request should be retried
+     */
+    shouldRetry(error, attempt) {
+        if (error instanceof WebexApiRequestError) {
+            return RETRY_STATUS_CODES.includes(error.statusCode);
+        }
+        // Retry network errors
+        return error.message.includes('ECONNRESET') ||
+            error.message.includes('ETIMEDOUT') ||
+            error.message.includes('ENOTFOUND');
+    }
+    /**
+     * Calculate backoff delay with exponential backoff and jitter
+     */
+    calculateBackoff(attempt) {
+        const baseDelay = this.retryOptions.retryDelayMs;
+        const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+        const jitter = Math.random() * 0.3 * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, 30000); // Cap at 30 seconds
+    }
+    /**
+     * Sleep for a given number of milliseconds
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.WebexSender = WebexSender;
+/**
+ * Custom error class for Webex API errors
+ */
+class WebexApiRequestError extends Error {
+    statusCode;
+    trackingId;
+    details;
+    constructor(message, statusCode, trackingId, details) {
+        super(message);
+        this.name = 'WebexApiRequestError';
+        this.statusCode = statusCode;
+        this.trackingId = trackingId;
+        this.details = details;
+        // Maintains proper stack trace for where error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, WebexApiRequestError);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: this.statusCode,
+            trackingId: this.trackingId,
+            details: this.details,
+        };
+    }
+}
+exports.WebexApiRequestError = WebexApiRequestError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send.js","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Webex Message Sending Module\n */\n\nimport fetch, { Response } from 'node-fetch';\nimport type {\n  WebexChannelConfig,\n  WebexMessage,\n  CreateMessageRequest,\n  OpenClawOutboundMessage,\n  WebexApiError,\n  RetryOptions,\n  RequestOptions,\n} from './types';\n\nconst DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';\nconst DEFAULT_MAX_RETRIES = 3;\nconst DEFAULT_RETRY_DELAY_MS = 1000;\n\n// Rate limit status codes that should trigger retry\nconst RETRY_STATUS_CODES = [429, 502, 503, 504];\n\nexport class WebexSender {\n  private config: WebexChannelConfig;\n  private apiBaseUrl: string;\n  private retryOptions: RetryOptions;\n\n  constructor(config: WebexChannelConfig) {\n    this.config = config;\n    this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;\n    this.retryOptions = {\n      maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,\n      retryDelayMs: config.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n  }\n\n  /**\n   * Send a message to Webex\n   */\n  async send(message: OpenClawOutboundMessage): Promise<WebexMessage> {\n    const request = this.buildMessageRequest(message);\n    return this.createMessage(request);\n  }\n\n  /**\n   * Send a text message to a room\n   */\n  async sendToRoom(roomId: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a direct message to a person by ID\n   */\n  async sendDirectById(personId: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      toPersonId: personId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a direct message to a person by email\n   */\n  async sendDirectByEmail(email: string, text: string, markdown?: string): Promise<WebexMessage> {\n    return this.createMessage({\n      toPersonEmail: email,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Send a message with file attachment\n   */\n  async sendWithFile(\n    roomId: string,\n    text: string,\n    fileUrl: string\n  ): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      text,\n      files: [fileUrl],\n    });\n  }\n\n  /**\n   * Send a threaded reply\n   */\n  async sendReply(\n    roomId: string,\n    parentId: string,\n    text: string,\n    markdown?: string\n  ): Promise<WebexMessage> {\n    return this.createMessage({\n      roomId,\n      parentId,\n      text,\n      markdown,\n    });\n  }\n\n  /**\n   * Get a message by ID\n   */\n  async getMessage(messageId: string): Promise<WebexMessage> {\n    return this.request<WebexMessage>({\n      method: 'GET',\n      path: `/messages/${messageId}`,\n    });\n  }\n\n  /**\n   * Delete a message by ID\n   */\n  async deleteMessage(messageId: string): Promise<void> {\n    await this.request<void>({\n      method: 'DELETE',\n      path: `/messages/${messageId}`,\n    });\n  }\n\n  /**\n   * Build a Webex message request from an OpenClaw outbound message\n   */\n  private buildMessageRequest(message: OpenClawOutboundMessage): CreateMessageRequest {\n    const request: CreateMessageRequest = {};\n\n    // Determine target: roomId, personId, or email\n    const to = message.to;\n    if (to.includes('@')) {\n      request.toPersonEmail = to;\n    } else if (to.startsWith('Y2lzY29zcGFyazovL3')) {\n      // Base64-encoded Webex IDs start with this prefix\n      if (to.includes('ROOM')) {\n        request.roomId = to;\n      } else {\n        request.toPersonId = to;\n      }\n    } else {\n      // Assume it's a roomId if not an email\n      request.roomId = to;\n    }\n\n    // Set content\n    if (message.content.text) {\n      request.text = message.content.text;\n    }\n    if (message.content.markdown) {\n      request.markdown = message.content.markdown;\n    }\n    if (message.content.files && message.content.files.length > 0) {\n      // Webex only allows one file per message\n      request.files = [message.content.files[0]];\n    }\n    if (message.content.card) {\n      request.attachments = [\n        {\n          contentType: 'application/vnd.microsoft.card.adaptive',\n          content: message.content.card,\n        },\n      ];\n    }\n\n    // Set threading\n    if (message.parentId) {\n      request.parentId = message.parentId;\n    }\n\n    return request;\n  }\n\n  /**\n   * Create a message via the Webex API\n   */\n  private async createMessage(request: CreateMessageRequest): Promise<WebexMessage> {\n    this.validateMessageRequest(request);\n\n    return this.request<WebexMessage>({\n      method: 'POST',\n      path: '/messages',\n      body: request,\n    });\n  }\n\n  /**\n   * Validate a message request before sending\n   */\n  private validateMessageRequest(request: CreateMessageRequest): void {\n    // Must have a target\n    if (!request.roomId && !request.toPersonId && !request.toPersonEmail) {\n      throw new Error('Message must have a target: roomId, toPersonId, or toPersonEmail');\n    }\n\n    // Must have content\n    if (!request.text && !request.markdown && !request.files?.length && !request.attachments?.length) {\n      throw new Error('Message must have content: text, markdown, files, or attachments');\n    }\n\n    // Text has a max size of 7439 bytes\n    if (request.text && Buffer.byteLength(request.text, 'utf8') > 7439) {\n      throw new Error('Message text exceeds maximum size of 7439 bytes');\n    }\n  }\n\n  /**\n   * Make an API request with retry logic\n   */\n  private async request<T>(options: RequestOptions): Promise<T> {\n    let lastError: Error | null = null;\n    let attempt = 0;\n\n    while (attempt <= this.retryOptions.maxRetries) {\n      try {\n        return await this.executeRequest<T>(options);\n      } catch (error) {\n        lastError = error as Error;\n        attempt++;\n\n        if (attempt > this.retryOptions.maxRetries) {\n          break;\n        }\n\n        if (!this.shouldRetry(error as Error, attempt)) {\n          break;\n        }\n\n        // Exponential backoff with jitter\n        const delay = this.calculateBackoff(attempt);\n        await this.sleep(delay);\n      }\n    }\n\n    throw lastError || new Error('Request failed after retries');\n  }\n\n  /**\n   * Execute a single API request\n   */\n  private async executeRequest<T>(options: RequestOptions): Promise<T> {\n    const url = `${this.apiBaseUrl}${options.path}`;\n    const headers: Record<string, string> = {\n      'Authorization': `Bearer ${this.config.token}`,\n      'Content-Type': 'application/json',\n      ...options.headers,\n    };\n\n    const response = await fetch(url, {\n      method: options.method,\n      headers,\n      body: options.body ? JSON.stringify(options.body) : undefined,\n    });\n\n    if (!response.ok) {\n      const error = await this.parseErrorResponse(response);\n      throw error;\n    }\n\n    // DELETE requests return 204 No Content\n    if (response.status === 204) {\n      return undefined as T;\n    }\n\n    return response.json() as Promise<T>;\n  }\n\n  /**\n   * Parse error response from Webex API\n   */\n  private async parseErrorResponse(response: Response): Promise<Error> {\n    let errorData: WebexApiError | null = null;\n\n    try {\n      errorData = await response.json() as WebexApiError;\n    } catch {\n      // Response body might not be JSON\n    }\n\n    const message = errorData?.message || `HTTP ${response.status}: ${response.statusText}`;\n    const error = new WebexApiRequestError(\n      message,\n      response.status,\n      errorData?.trackingId,\n      errorData?.errors\n    );\n\n    return error;\n  }\n\n  /**\n   * Determine if a request should be retried\n   */\n  private shouldRetry(error: Error, attempt: number): boolean {\n    if (error instanceof WebexApiRequestError) {\n      return RETRY_STATUS_CODES.includes(error.statusCode);\n    }\n    // Retry network errors\n    return error.message.includes('ECONNRESET') ||\n           error.message.includes('ETIMEDOUT') ||\n           error.message.includes('ENOTFOUND');\n  }\n\n  /**\n   * Calculate backoff delay with exponential backoff and jitter\n   */\n  private calculateBackoff(attempt: number): number {\n    const baseDelay = this.retryOptions.retryDelayMs;\n    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);\n    const jitter = Math.random() * 0.3 * exponentialDelay;\n    return Math.min(exponentialDelay + jitter, 30000); // Cap at 30 seconds\n  }\n\n  /**\n   * Sleep for a given number of milliseconds\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n\n/**\n * Custom error class for Webex API errors\n */\nexport class WebexApiRequestError extends Error {\n  readonly statusCode: number;\n  readonly trackingId?: string;\n  readonly details?: Array<{ description: string }>;\n\n  constructor(\n    message: string,\n    statusCode: number,\n    trackingId?: string,\n    details?: Array<{ description: string }>\n  ) {\n    super(message);\n    this.name = 'WebexApiRequestError';\n    this.statusCode = statusCode;\n    this.trackingId = trackingId;\n    this.details = details;\n\n    // Maintains proper stack trace for where error was thrown\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, WebexApiRequestError);\n    }\n  }\n\n  toJSON(): object {\n    return {\n      name: this.name,\n      message: this.message,\n      statusCode: this.statusCode,\n      trackingId: this.trackingId,\n      details: this.details,\n    };\n  }\n}\n"]}

package/dist/types.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Webex Channel Plugin Types
+ */
+export type DmPolicy = 'allow' | 'deny' | 'allowlisted' | 'allowlist' | 'pairing';
+export interface WebexChannelConfig {
+    /** Webex Bot access token */
+    token: string;
+    /** Public URL where webhooks will be received */
+    webhookUrl: string;
+    /** Policy for handling direct messages */
+    dmPolicy: DmPolicy;
+    /** List of allowed person IDs or emails (used when dmPolicy is 'allowlisted') */
+    allowFrom?: string[];
+    /** Webhook secret for payload verification */
+    webhookSecret?: string;
+    /** Base URL for Webex API (defaults to https://webexapis.com/v1) */
+    apiBaseUrl?: string;
+    /** Maximum retry attempts for failed requests */
+    maxRetries?: number;
+    /** Retry delay in milliseconds */
+    retryDelayMs?: number;
+}
+export interface WebexPerson {
+    id: string;
+    emails: string[];
+    displayName: string;
+    nickName?: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    orgId: string;
+    created: string;
+    lastModified?: string;
+    type: 'person' | 'bot';
+}
+export interface WebexRoom {
+    id: string;
+    title: string;
+    type: 'direct' | 'group';
+    isLocked: boolean;
+    teamId?: string;
+    lastActivity: string;
+    creatorId: string;
+    created: string;
+    ownerId?: string;
+}
+export interface WebexMessage {
+    id: string;
+    roomId: string;
+    roomType: 'direct' | 'group';
+    toPersonId?: string;
+    toPersonEmail?: string;
+    text?: string;
+    markdown?: string;
+    html?: string;
+    files?: string[];
+    personId: string;
+    personEmail: string;
+    mentionedPeople?: string[];
+    mentionedGroups?: string[];
+    attachments?: WebexAttachment[];
+    created: string;
+    updated?: string;
+    parentId?: string;
+}
+export interface WebexAttachment {
+    contentType: 'application/vnd.microsoft.card.adaptive';
+    content: AdaptiveCard;
+}
+export interface AdaptiveCard {
+    type: 'AdaptiveCard';
+    version: string;
+    body: unknown[];
+    actions?: unknown[];
+}
+export interface WebexWebhook {
+    id: string;
+    name: string;
+    targetUrl: string;
+    resource: WebexWebhookResource;
+    event: WebexWebhookEvent;
+    filter?: string;
+    secret?: string;
+    status: 'active' | 'inactive';
+    created: string;
+    orgId: string;
+    createdBy: string;
+    appId: string;
+    ownedBy: 'creator' | 'org';
+}
+export type WebexWebhookResource = 'messages' | 'memberships' | 'rooms' | 'attachmentActions' | 'meetings' | 'recordings';
+export type WebexWebhookEvent = 'created' | 'updated' | 'deleted' | 'started' | 'ended';
+export interface WebexWebhookPayload {
+    id: string;
+    name: string;
+    targetUrl: string;
+    resource: WebexWebhookResource;
+    event: WebexWebhookEvent;
+    filter?: string;
+    orgId: string;
+    createdBy: string;
+    appId: string;
+    ownedBy: string;
+    status: string;
+    created: string;
+    actorId: string;
+    data: WebexWebhookData;
+}
+export interface WebexWebhookData {
+    id: string;
+    roomId: string;
+    roomType: 'direct' | 'group';
+    personId: string;
+    personEmail: string;
+    created: string;
+    mentionedPeople?: string[];
+    mentionedGroups?: string[];
+    files?: string[];
+}
+export interface CreateMessageRequest {
+    roomId?: string;
+    toPersonId?: string;
+    toPersonEmail?: string;
+    text?: string;
+    markdown?: string;
+    files?: string[];
+    attachments?: WebexAttachment[];
+    parentId?: string;
+}
+export interface CreateWebhookRequest {
+    name: string;
+    targetUrl: string;
+    resource: WebexWebhookResource;
+    event: WebexWebhookEvent;
+    filter?: string;
+    secret?: string;
+}
+export interface WebexApiError {
+    message: string;
+    errors?: Array<{
+        description: string;
+    }>;
+    trackingId: string;
+}
+export interface PaginatedResponse<T> {
+    items: T[];
+}
+export interface OpenClawEnvelope {
+    /** Unique message identifier */
+    id: string;
+    /** Channel identifier */
+    channel: 'webex';
+    /** Conversation/thread identifier */
+    conversationId: string;
+    /** Message author information */
+    author: {
+        id: string;
+        email?: string;
+        displayName?: string;
+        isBot: boolean;
+    };
+    /** Message content */
+    content: {
+        text?: string;
+        markdown?: string;
+        attachments?: OpenClawAttachment[];
+    };
+    /** Message metadata */
+    metadata: {
+        roomType: 'direct' | 'group';
+        roomId: string;
+        timestamp: string;
+        mentions?: string[];
+        parentId?: string;
+        raw: WebexMessage;
+    };
+}
+export interface OpenClawAttachment {
+    type: 'file' | 'card';
+    url?: string;
+    content?: unknown;
+}
+export interface OpenClawOutboundMessage {
+    /** Target conversation ID (roomId) or person ID/email for DMs */
+    to: string;
+    /** Message content */
+    content: {
+        text?: string;
+        markdown?: string;
+        files?: string[];
+        card?: AdaptiveCard;
+    };
+    /** Optional parent message ID for threading */
+    parentId?: string;
+}
+export interface WebexChannelPlugin {
+    name: string;
+    version: string;
+    /** Initialize the channel with configuration */
+    initialize(config: WebexChannelConfig): Promise<void>;
+    /** Send a message */
+    send(message: OpenClawOutboundMessage): Promise<WebexMessage>;
+    /** Handle incoming webhook */
+    handleWebhook(payload: WebexWebhookPayload, signature?: string): Promise<OpenClawEnvelope | null>;
+    /** Register webhooks with Webex */
+    registerWebhooks(): Promise<WebexWebhook[]>;
+    /** Cleanup and shutdown */
+    shutdown(): Promise<void>;
+}
+export interface WebhookHandler {
+    (envelope: OpenClawEnvelope): Promise<void> | void;
+}
+export interface RetryOptions {
+    maxRetries: number;
+    retryDelayMs: number;
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+}
+export interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Webex Channel Plugin Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA;;GAEG","sourcesContent":["/**\n * Webex Channel Plugin Types\n */\n\n// ============================================================================\n// Configuration Types\n// ============================================================================\n\nexport type DmPolicy = 'allow' | 'deny' | 'allowlisted' | 'allowlist' | 'pairing';\n\nexport interface WebexChannelConfig {\n  /** Webex Bot access token */\n  token: string;\n\n  /** Public URL where webhooks will be received */\n  webhookUrl: string;\n\n  /** Policy for handling direct messages */\n  dmPolicy: DmPolicy;\n\n  /** List of allowed person IDs or emails (used when dmPolicy is 'allowlisted') */\n  allowFrom?: string[];\n\n  /** Webhook secret for payload verification */\n  webhookSecret?: string;\n\n  /** Base URL for Webex API (defaults to https://webexapis.com/v1) */\n  apiBaseUrl?: string;\n\n  /** Maximum retry attempts for failed requests */\n  maxRetries?: number;\n\n  /** Retry delay in milliseconds */\n  retryDelayMs?: number;\n}\n\n// ============================================================================\n// Webex API Types\n// ============================================================================\n\nexport interface WebexPerson {\n  id: string;\n  emails: string[];\n  displayName: string;\n  nickName?: string;\n  firstName?: string;\n  lastName?: string;\n  avatar?: string;\n  orgId: string;\n  created: string;\n  lastModified?: string;\n  type: 'person' | 'bot';\n}\n\nexport interface WebexRoom {\n  id: string;\n  title: string;\n  type: 'direct' | 'group';\n  isLocked: boolean;\n  teamId?: string;\n  lastActivity: string;\n  creatorId: string;\n  created: string;\n  ownerId?: string;\n}\n\nexport interface WebexMessage {\n  id: string;\n  roomId: string;\n  roomType: 'direct' | 'group';\n  toPersonId?: string;\n  toPersonEmail?: string;\n  text?: string;\n  markdown?: string;\n  html?: string;\n  files?: string[];\n  personId: string;\n  personEmail: string;\n  mentionedPeople?: string[];\n  mentionedGroups?: string[];\n  attachments?: WebexAttachment[];\n  created: string;\n  updated?: string;\n  parentId?: string;\n}\n\nexport interface WebexAttachment {\n  contentType: 'application/vnd.microsoft.card.adaptive';\n  content: AdaptiveCard;\n}\n\nexport interface AdaptiveCard {\n  type: 'AdaptiveCard';\n  version: string;\n  body: unknown[];\n  actions?: unknown[];\n}\n\nexport interface WebexWebhook {\n  id: string;\n  name: string;\n  targetUrl: string;\n  resource: WebexWebhookResource;\n  event: WebexWebhookEvent;\n  filter?: string;\n  secret?: string;\n  status: 'active' | 'inactive';\n  created: string;\n  orgId: string;\n  createdBy: string;\n  appId: string;\n  ownedBy: 'creator' | 'org';\n}\n\nexport type WebexWebhookResource =\n  | 'messages'\n  | 'memberships'\n  | 'rooms'\n  | 'attachmentActions'\n  | 'meetings'\n  | 'recordings';\n\nexport type WebexWebhookEvent =\n  | 'created'\n  | 'updated'\n  | 'deleted'\n  | 'started'\n  | 'ended';\n\nexport interface WebexWebhookPayload {\n  id: string;\n  name: string;\n  targetUrl: string;\n  resource: WebexWebhookResource;\n  event: WebexWebhookEvent;\n  filter?: string;\n  orgId: string;\n  createdBy: string;\n  appId: string;\n  ownedBy: string;\n  status: string;\n  created: string;\n  actorId: string;\n  data: WebexWebhookData;\n}\n\nexport interface WebexWebhookData {\n  id: string;\n  roomId: string;\n  roomType: 'direct' | 'group';\n  personId: string;\n  personEmail: string;\n  created: string;\n  mentionedPeople?: string[];\n  mentionedGroups?: string[];\n  files?: string[];\n}\n\n// ============================================================================\n// API Request/Response Types\n// ============================================================================\n\nexport interface CreateMessageRequest {\n  roomId?: string;\n  toPersonId?: string;\n  toPersonEmail?: string;\n  text?: string;\n  markdown?: string;\n  files?: string[];\n  attachments?: WebexAttachment[];\n  parentId?: string;\n}\n\nexport interface CreateWebhookRequest {\n  name: string;\n  targetUrl: string;\n  resource: WebexWebhookResource;\n  event: WebexWebhookEvent;\n  filter?: string;\n  secret?: string;\n}\n\nexport interface WebexApiError {\n  message: string;\n  errors?: Array<{\n    description: string;\n  }>;\n  trackingId: string;\n}\n\nexport interface PaginatedResponse<T> {\n  items: T[];\n}\n\n// ============================================================================\n// OpenClaw Envelope Types\n// ============================================================================\n\nexport interface OpenClawEnvelope {\n  /** Unique message identifier */\n  id: string;\n\n  /** Channel identifier */\n  channel: 'webex';\n\n  /** Conversation/thread identifier */\n  conversationId: string;\n\n  /** Message author information */\n  author: {\n    id: string;\n    email?: string;\n    displayName?: string;\n    isBot: boolean;\n  };\n\n  /** Message content */\n  content: {\n    text?: string;\n    markdown?: string;\n    attachments?: OpenClawAttachment[];\n  };\n\n  /** Message metadata */\n  metadata: {\n    roomType: 'direct' | 'group';\n    roomId: string;\n    timestamp: string;\n    mentions?: string[];\n    parentId?: string;\n    raw: WebexMessage;\n  };\n}\n\nexport interface OpenClawAttachment {\n  type: 'file' | 'card';\n  url?: string;\n  content?: unknown;\n}\n\nexport interface OpenClawOutboundMessage {\n  /** Target conversation ID (roomId) or person ID/email for DMs */\n  to: string;\n\n  /** Message content */\n  content: {\n    text?: string;\n    markdown?: string;\n    files?: string[];\n    card?: AdaptiveCard;\n  };\n\n  /** Optional parent message ID for threading */\n  parentId?: string;\n}\n\n// ============================================================================\n// Plugin Types\n// ============================================================================\n\nexport interface WebexChannelPlugin {\n  name: string;\n  version: string;\n\n  /** Initialize the channel with configuration */\n  initialize(config: WebexChannelConfig): Promise<void>;\n\n  /** Send a message */\n  send(message: OpenClawOutboundMessage): Promise<WebexMessage>;\n\n  /** Handle incoming webhook */\n  handleWebhook(payload: WebexWebhookPayload, signature?: string): Promise<OpenClawEnvelope | null>;\n\n  /** Register webhooks with Webex */\n  registerWebhooks(): Promise<WebexWebhook[]>;\n\n  /** Cleanup and shutdown */\n  shutdown(): Promise<void>;\n}\n\nexport interface WebhookHandler {\n  (envelope: OpenClawEnvelope): Promise<void> | void;\n}\n\n// ============================================================================\n// Internal Types\n// ============================================================================\n\nexport interface RetryOptions {\n  maxRetries: number;\n  retryDelayMs: number;\n  shouldRetry?: (error: Error, attempt: number) => boolean;\n}\n\nexport interface RequestOptions {\n  method: 'GET' | 'POST' | 'PUT' | 'DELETE';\n  path: string;\n  body?: unknown;\n  headers?: Record<string, string>;\n}\n"]}

package/dist/webhook.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Webex Webhook Handler Module
+ */
+import type { WebexChannelConfig, WebexWebhookPayload, WebexWebhook, CreateWebhookRequest, OpenClawEnvelope } from './types';
+export declare class WebexWebhookHandler {
+    private config;
+    private apiBaseUrl;
+    private botId;
+    constructor(config: WebexChannelConfig);
+    /**
+     * Initialize the webhook handler (fetch bot info)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Handle an incoming webhook request
+     */
+    handleWebhook(payload: WebexWebhookPayload, signature?: string): Promise<OpenClawEnvelope | null>;
+    /**
+     * Verify webhook signature using HMAC-SHA1
+     */
+    verifySignature(payload: WebexWebhookPayload, signature: string): boolean;
+    /**
+     * Check if the sender is allowed based on DM policy
+     */
+    private isAllowedSender;
+    /**
+     * Fetch full message details from Webex API
+     */
+    private fetchMessage;
+    /**
+     * Normalize a Webex message to OpenClaw envelope format
+     */
+    private normalizeMessage;
+    /**
+     * Register webhooks with Webex
+     */
+    registerWebhooks(): Promise<WebexWebhook[]>;
+    /**
+     * List all webhooks
+     */
+    listWebhooks(): Promise<WebexWebhook[]>;
+    /**
+     * Create a webhook
+     */
+    createWebhook(request: CreateWebhookRequest): Promise<WebexWebhook>;
+    /**
+     * Delete a webhook
+     */
+    deleteWebhook(webhookId: string): Promise<void>;
+    /**
+     * Get bot information
+     */
+    private getBotInfo;
+    /**
+     * Get the bot ID (after initialization)
+     */
+    getBotId(): string | null;
+}
+/**
+ * Custom error for webhook validation failures
+ */
+export declare class WebhookValidationError extends Error {
+    constructor(message: string);
+}