@jimiford/channel-webex 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Webex Channel Plugin Types
+ */
+export type DmPolicy = 'allow' | 'deny' | 'allowlisted';
+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';\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);
+}

package/dist/webhook.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Webex Webhook Handler Module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookValidationError = exports.WebexWebhookHandler = void 0;
+const crypto = __importStar(require("crypto"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';
+class WebexWebhookHandler {
+    config;
+    apiBaseUrl;
+    botId = null;
+    constructor(config) {
+        this.config = config;
+        this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;
+    }
+    /**
+     * Initialize the webhook handler (fetch bot info)
+     */
+    async initialize() {
+        const botInfo = await this.getBotInfo();
+        this.botId = botInfo.id;
+    }
+    /**
+     * Handle an incoming webhook request
+     */
+    async handleWebhook(payload, signature) {
+        // Verify webhook signature if secret is configured
+        if (this.config.webhookSecret && signature) {
+            if (!this.verifySignature(payload, signature)) {
+                throw new WebhookValidationError('Invalid webhook signature');
+            }
+        }
+        // Only handle message created events
+        if (payload.resource !== 'messages' || payload.event !== 'created') {
+            return null;
+        }
+        // Ignore messages from the bot itself
+        if (payload.data.personId === this.botId) {
+            return null;
+        }
+        // Check DM policy
+        if (payload.data.roomType === 'direct') {
+            if (!this.isAllowedSender(payload.data)) {
+                return null;
+            }
+        }
+        // Fetch full message details (webhook only contains IDs)
+        const message = await this.fetchMessage(payload.data.id);
+        // Normalize to OpenClaw envelope
+        return this.normalizeMessage(message);
+    }
+    /**
+     * Verify webhook signature using HMAC-SHA1
+     */
+    verifySignature(payload, signature) {
+        if (!this.config.webhookSecret) {
+            return true;
+        }
+        const hmac = crypto.createHmac('sha1', this.config.webhookSecret);
+        hmac.update(JSON.stringify(payload));
+        const expectedSignature = hmac.digest('hex');
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+    }
+    /**
+     * Check if the sender is allowed based on DM policy
+     */
+    isAllowedSender(data) {
+        switch (this.config.dmPolicy) {
+            case 'allow':
+                return true;
+            case 'deny':
+                return false;
+            case 'allowlisted':
+                if (!this.config.allowFrom || this.config.allowFrom.length === 0) {
+                    return false;
+                }
+                return this.config.allowFrom.includes(data.personId) ||
+                    this.config.allowFrom.includes(data.personEmail);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Fetch full message details from Webex API
+     */
+    async fetchMessage(messageId) {
+        const response = await (0, node_fetch_1.default)(`${this.apiBaseUrl}/messages/${messageId}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch message: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Normalize a Webex message to OpenClaw envelope format
+     */
+    normalizeMessage(message) {
+        const attachments = [];
+        // Convert file attachments
+        if (message.files && message.files.length > 0) {
+            for (const fileUrl of message.files) {
+                attachments.push({
+                    type: 'file',
+                    url: fileUrl,
+                });
+            }
+        }
+        // Convert card attachments
+        if (message.attachments && message.attachments.length > 0) {
+            for (const attachment of message.attachments) {
+                attachments.push({
+                    type: 'card',
+                    content: attachment.content,
+                });
+            }
+        }
+        return {
+            id: message.id,
+            channel: 'webex',
+            conversationId: message.roomId,
+            author: {
+                id: message.personId,
+                email: message.personEmail,
+                displayName: undefined, // Would need additional API call to get
+                isBot: false, // Messages from bot are filtered out earlier
+            },
+            content: {
+                text: message.text,
+                markdown: message.markdown,
+                attachments: attachments.length > 0 ? attachments : undefined,
+            },
+            metadata: {
+                roomType: message.roomType,
+                roomId: message.roomId,
+                timestamp: message.created,
+                mentions: message.mentionedPeople,
+                parentId: message.parentId,
+                raw: message,
+            },
+        };
+    }
+    /**
+     * Register webhooks with Webex
+     */
+    async registerWebhooks() {
+        // First, list existing webhooks and remove duplicates
+        const existing = await this.listWebhooks();
+        const targetUrl = this.config.webhookUrl;
+        // Delete existing webhooks with the same target URL
+        for (const webhook of existing) {
+            if (webhook.targetUrl === targetUrl) {
+                await this.deleteWebhook(webhook.id);
+            }
+        }
+        // Create new webhooks for messages
+        const webhooks = [];
+        // Webhook for new messages
+        const messageCreatedWebhook = await this.createWebhook({
+            name: 'OpenClaw Message Handler',
+            targetUrl,
+            resource: 'messages',
+            event: 'created',
+            secret: this.config.webhookSecret,
+        });
+        webhooks.push(messageCreatedWebhook);
+        return webhooks;
+    }
+    /**
+     * List all webhooks
+     */
+    async listWebhooks() {
+        const response = await (0, node_fetch_1.default)(`${this.apiBaseUrl}/webhooks`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list webhooks: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.items;
+    }
+    /**
+     * Create a webhook
+     */
+    async createWebhook(request) {
+        const response = await (0, node_fetch_1.default)(`${this.apiBaseUrl}/webhooks`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(request),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to create webhook: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Delete a webhook
+     */
+    async deleteWebhook(webhookId) {
+        const response = await (0, node_fetch_1.default)(`${this.apiBaseUrl}/webhooks/${webhookId}`, {
+            method: 'DELETE',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+            },
+        });
+        if (!response.ok && response.status !== 404) {
+            throw new Error(`Failed to delete webhook: ${response.status} ${response.statusText}`);
+        }
+    }
+    /**
+     * Get bot information
+     */
+    async getBotInfo() {
+        const response = await (0, node_fetch_1.default)(`${this.apiBaseUrl}/people/me`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get bot info: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get the bot ID (after initialization)
+     */
+    getBotId() {
+        return this.botId;
+    }
+}
+exports.WebexWebhookHandler = WebexWebhookHandler;
+/**
+ * Custom error for webhook validation failures
+ */
+class WebhookValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WebhookValidationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, WebhookValidationError);
+        }
+    }
+}
+exports.WebhookValidationError = WebhookValidationError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webhook.js","sourceRoot":"","sources":["../src/webhook.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Webex Webhook Handler Module\n */\n\nimport * as crypto from 'crypto';\nimport fetch from 'node-fetch';\nimport type {\n  WebexChannelConfig,\n  WebexWebhookPayload,\n  WebexWebhookData,\n  WebexMessage,\n  WebexWebhook,\n  CreateWebhookRequest,\n  OpenClawEnvelope,\n  OpenClawAttachment,\n  PaginatedResponse,\n} from './types';\n\nconst DEFAULT_API_BASE_URL = 'https://webexapis.com/v1';\n\nexport class WebexWebhookHandler {\n  private config: WebexChannelConfig;\n  private apiBaseUrl: string;\n  private botId: string | null = null;\n\n  constructor(config: WebexChannelConfig) {\n    this.config = config;\n    this.apiBaseUrl = config.apiBaseUrl || DEFAULT_API_BASE_URL;\n  }\n\n  /**\n   * Initialize the webhook handler (fetch bot info)\n   */\n  async initialize(): Promise<void> {\n    const botInfo = await this.getBotInfo();\n    this.botId = botInfo.id;\n  }\n\n  /**\n   * Handle an incoming webhook request\n   */\n  async handleWebhook(\n    payload: WebexWebhookPayload,\n    signature?: string\n  ): Promise<OpenClawEnvelope | null> {\n    // Verify webhook signature if secret is configured\n    if (this.config.webhookSecret && signature) {\n      if (!this.verifySignature(payload, signature)) {\n        throw new WebhookValidationError('Invalid webhook signature');\n      }\n    }\n\n    // Only handle message created events\n    if (payload.resource !== 'messages' || payload.event !== 'created') {\n      return null;\n    }\n\n    // Ignore messages from the bot itself\n    if (payload.data.personId === this.botId) {\n      return null;\n    }\n\n    // Check DM policy\n    if (payload.data.roomType === 'direct') {\n      if (!this.isAllowedSender(payload.data)) {\n        return null;\n      }\n    }\n\n    // Fetch full message details (webhook only contains IDs)\n    const message = await this.fetchMessage(payload.data.id);\n\n    // Normalize to OpenClaw envelope\n    return this.normalizeMessage(message);\n  }\n\n  /**\n   * Verify webhook signature using HMAC-SHA1\n   */\n  verifySignature(payload: WebexWebhookPayload, signature: string): boolean {\n    if (!this.config.webhookSecret) {\n      return true;\n    }\n\n    const hmac = crypto.createHmac('sha1', this.config.webhookSecret);\n    hmac.update(JSON.stringify(payload));\n    const expectedSignature = hmac.digest('hex');\n\n    return crypto.timingSafeEqual(\n      Buffer.from(signature),\n      Buffer.from(expectedSignature)\n    );\n  }\n\n  /**\n   * Check if the sender is allowed based on DM policy\n   */\n  private isAllowedSender(data: WebexWebhookData): boolean {\n    switch (this.config.dmPolicy) {\n      case 'allow':\n        return true;\n      case 'deny':\n        return false;\n      case 'allowlisted':\n        if (!this.config.allowFrom || this.config.allowFrom.length === 0) {\n          return false;\n        }\n        return this.config.allowFrom.includes(data.personId) ||\n               this.config.allowFrom.includes(data.personEmail);\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Fetch full message details from Webex API\n   */\n  private async fetchMessage(messageId: string): Promise<WebexMessage> {\n    const response = await fetch(`${this.apiBaseUrl}/messages/${messageId}`, {\n      method: 'GET',\n      headers: {\n        'Authorization': `Bearer ${this.config.token}`,\n        'Content-Type': 'application/json',\n      },\n    });\n\n    if (!response.ok) {\n      throw new Error(`Failed to fetch message: ${response.status} ${response.statusText}`);\n    }\n\n    return response.json() as Promise<WebexMessage>;\n  }\n\n  /**\n   * Normalize a Webex message to OpenClaw envelope format\n   */\n  private normalizeMessage(message: WebexMessage): OpenClawEnvelope {\n    const attachments: OpenClawAttachment[] = [];\n\n    // Convert file attachments\n    if (message.files && message.files.length > 0) {\n      for (const fileUrl of message.files) {\n        attachments.push({\n          type: 'file',\n          url: fileUrl,\n        });\n      }\n    }\n\n    // Convert card attachments\n    if (message.attachments && message.attachments.length > 0) {\n      for (const attachment of message.attachments) {\n        attachments.push({\n          type: 'card',\n          content: attachment.content,\n        });\n      }\n    }\n\n    return {\n      id: message.id,\n      channel: 'webex',\n      conversationId: message.roomId,\n      author: {\n        id: message.personId,\n        email: message.personEmail,\n        displayName: undefined, // Would need additional API call to get\n        isBot: false, // Messages from bot are filtered out earlier\n      },\n      content: {\n        text: message.text,\n        markdown: message.markdown,\n        attachments: attachments.length > 0 ? attachments : undefined,\n      },\n      metadata: {\n        roomType: message.roomType,\n        roomId: message.roomId,\n        timestamp: message.created,\n        mentions: message.mentionedPeople,\n        parentId: message.parentId,\n        raw: message,\n      },\n    };\n  }\n\n  /**\n   * Register webhooks with Webex\n   */\n  async registerWebhooks(): Promise<WebexWebhook[]> {\n    // First, list existing webhooks and remove duplicates\n    const existing = await this.listWebhooks();\n    const targetUrl = this.config.webhookUrl;\n\n    // Delete existing webhooks with the same target URL\n    for (const webhook of existing) {\n      if (webhook.targetUrl === targetUrl) {\n        await this.deleteWebhook(webhook.id);\n      }\n    }\n\n    // Create new webhooks for messages\n    const webhooks: WebexWebhook[] = [];\n\n    // Webhook for new messages\n    const messageCreatedWebhook = await this.createWebhook({\n      name: 'OpenClaw Message Handler',\n      targetUrl,\n      resource: 'messages',\n      event: 'created',\n      secret: this.config.webhookSecret,\n    });\n    webhooks.push(messageCreatedWebhook);\n\n    return webhooks;\n  }\n\n  /**\n   * List all webhooks\n   */\n  async listWebhooks(): Promise<WebexWebhook[]> {\n    const response = await fetch(`${this.apiBaseUrl}/webhooks`, {\n      method: 'GET',\n      headers: {\n        'Authorization': `Bearer ${this.config.token}`,\n        'Content-Type': 'application/json',\n      },\n    });\n\n    if (!response.ok) {\n      throw new Error(`Failed to list webhooks: ${response.status} ${response.statusText}`);\n    }\n\n    const data = await response.json() as PaginatedResponse<WebexWebhook>;\n    return data.items;\n  }\n\n  /**\n   * Create a webhook\n   */\n  async createWebhook(request: CreateWebhookRequest): Promise<WebexWebhook> {\n    const response = await fetch(`${this.apiBaseUrl}/webhooks`, {\n      method: 'POST',\n      headers: {\n        'Authorization': `Bearer ${this.config.token}`,\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify(request),\n    });\n\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`Failed to create webhook: ${response.status} ${response.statusText} - ${errorText}`);\n    }\n\n    return response.json() as Promise<WebexWebhook>;\n  }\n\n  /**\n   * Delete a webhook\n   */\n  async deleteWebhook(webhookId: string): Promise<void> {\n    const response = await fetch(`${this.apiBaseUrl}/webhooks/${webhookId}`, {\n      method: 'DELETE',\n      headers: {\n        'Authorization': `Bearer ${this.config.token}`,\n      },\n    });\n\n    if (!response.ok && response.status !== 404) {\n      throw new Error(`Failed to delete webhook: ${response.status} ${response.statusText}`);\n    }\n  }\n\n  /**\n   * Get bot information\n   */\n  private async getBotInfo(): Promise<{ id: string; displayName: string; emails: string[] }> {\n    const response = await fetch(`${this.apiBaseUrl}/people/me`, {\n      method: 'GET',\n      headers: {\n        'Authorization': `Bearer ${this.config.token}`,\n        'Content-Type': 'application/json',\n      },\n    });\n\n    if (!response.ok) {\n      throw new Error(`Failed to get bot info: ${response.status} ${response.statusText}`);\n    }\n\n    return response.json() as Promise<{ id: string; displayName: string; emails: string[] }>;\n  }\n\n  /**\n   * Get the bot ID (after initialization)\n   */\n  getBotId(): string | null {\n    return this.botId;\n  }\n}\n\n/**\n * Custom error for webhook validation failures\n */\nexport class WebhookValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'WebhookValidationError';\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, WebhookValidationError);\n    }\n  }\n}\n"]}