@jimiford/webex 0.1.1

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"]}

package/openclaw.plugin.json

@@ -0,0 +1,33 @@
+{
+  "id": "webex",
+  "name": "Webex Channel",
+  "description": "Cisco Webex messaging integration for OpenClaw",
+  "channels": ["webex"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  },
+  "uiHints": {
+    "token": {
+      "label": "Bot Access Token",
+      "sensitive": true,
+      "placeholder": "Your Webex bot token"
+    },
+    "webhookUrl": {
+      "label": "Webhook URL",
+      "placeholder": "https://your-domain.com/webhooks/webex"
+    },
+    "webhookSecret": {
+      "label": "Webhook Secret",
+      "sensitive": true,
+      "placeholder": "Optional secret for webhook verification"
+    },
+    "dmPolicy": {
+      "label": "DM Policy"
+    },
+    "allowFrom": {
+      "label": "Allowed Senders"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@jimiford/webex",
+  "version": "0.1.1",
+  "description": "OpenClaw channel plugin for Cisco Webex messaging",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./dist/plugin.js"
+    ],
+    "channel": {
+      "id": "webex",
+      "label": "Webex",
+      "selectionLabel": "Cisco Webex",
+      "docsPath": "/channels/webex",
+      "blurb": "Cisco Webex messaging via bot webhooks.",
+      "aliases": [
+        "cisco-webex"
+      ]
+    },
+    "install": {
+      "npmSpec": "@jimiford/channel-webex",
+      "defaultChoice": "npm"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "openclaw",
+    "webex",
+    "cisco",
+    "channel",
+    "messaging",
+    "bot"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "@openclaw/core": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@openclaw/core": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/node-fetch": "^2.6.9",
+    "@vitest/coverage-v8": "^4.0.18",
+    "openclaw": "^2026.1.30",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}