@jimiford/webex 0.1.1 → 0.1.3

package/README.md

@@ -309,6 +309,52 @@ WEBHOOK_SECRET=your_webhook_secret
 
 The plugin includes automatic retry with exponential backoff for rate-limited requests. Adjust `maxRetries` and `retryDelayMs` in config if needed.
 
+## Security Considerations
+
+When connecting a Webex bot to OpenClaw, keep these security implications in mind:
+
+### Access Control
+
+- **DM Policy**: The `dmPolicy` setting controls who can interact with your bot:
+  - `allow`: Anyone can message the bot and receive responses (use with caution)
+  - `deny`: The bot won't respond to direct messages
+  - `allowlisted`: Only users in the `allowFrom` list receive responses
+- **Recommendation**: Use `allowlisted` in production and explicitly specify trusted users
+
+### Bot Token Permissions
+
+- The bot access token can read messages sent to the bot and send replies
+- Keep your token secret — never commit it to version control
+- Rotate tokens periodically via the [Webex Developer Portal](https://developer.webex.com)
+
+### Webhook Security
+
+- **Always use a webhook secret** in production to verify incoming requests
+- The `webhookSecret` enables HMAC-SHA1 signature verification
+- Without verification, attackers could send fake webhook payloads to your endpoint
+
+### Network Exposure
+
+- Your webhook endpoint must be publicly accessible for Webex to deliver messages
+- Use HTTPS in production (required by Webex)
+- Consider IP allowlisting if your infrastructure supports it
+- For development, tools like ngrok create temporary public URLs
+
+### OpenClaw Agent Access
+
+- Messages received by the bot flow through your OpenClaw agent
+- The agent has access to whatever tools you've configured (file access, web browsing, etc.)
+- Treat bot conversations with the same security considerations as direct OpenClaw access
+- Review your agent's tool permissions and workspace access
+
+### Best Practices
+
+1. Start with `dmPolicy: 'deny'` or `dmPolicy: 'allowlisted'` and explicitly allow trusted users
+2. Always configure a `webhookSecret` for production deployments
+3. Monitor bot activity through Webex admin tools and OpenClaw logs
+4. Use separate bots for development and production environments
+5. Regularly audit the `allowFrom` list
+
 ## License
 
 MIT

package/dist/channel-plugin.d.ts

@@ -3,8 +3,11 @@
  *
  * Implements the ChannelPlugin interface for OpenClaw's plugin system.
  */
-import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ChannelPlugin, PluginRuntime } from "openclaw/plugin-sdk";
+import { WebexWebhookHandler } from "./webhook";
 import type { WebexChannelConfig } from "./types";
+export declare function setPluginRuntime(runtime: PluginRuntime): void;
 /** Resolved account configuration */
 export interface ResolvedWebexAccount {
     accountId: string;
@@ -15,4 +18,17 @@ export interface ResolvedWebexAccount {
     token?: string;
     webhookUrl?: string;
 }
+/** Webhook target registration for HTTP handler */
+type WebexWebhookTarget = {
+    account: ResolvedWebexAccount;
+    config: WebexChannelConfig;
+    webhookHandler: WebexWebhookHandler;
+};
+export declare function registerWebexWebhookTarget(path: string, target: WebexWebhookTarget): () => void;
+/**
+ * Create the webhook handler with access to the plugin runtime.
+ * Returns a handler function that can process incoming Webex webhook requests.
+ */
+export declare function createWebhookHandler(): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 export declare const webexPlugin: ChannelPlugin<ResolvedWebexAccount>;
+export {};

package/dist/channel-plugin.js

@@ -6,9 +6,163 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webexPlugin = void 0;
+exports.setPluginRuntime = setPluginRuntime;
+exports.registerWebexWebhookTarget = registerWebexWebhookTarget;
+exports.createWebhookHandler = createWebhookHandler;
 const send_1 = require("./send");
 const webhook_1 = require("./webhook");
+// Store the plugin runtime for use in HTTP handlers
+let pluginRuntime = null;
+function setPluginRuntime(runtime) {
+    pluginRuntime = runtime;
+}
 const DEFAULT_ACCOUNT_ID = "default";
+const webhookTargets = new Map();
+function normalizeWebhookPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "/";
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    if (withSlash.length > 1 && withSlash.endsWith("/")) {
+        return withSlash.slice(0, -1);
+    }
+    return withSlash;
+}
+function registerWebexWebhookTarget(path, target) {
+    const key = normalizeWebhookPath(path);
+    webhookTargets.set(key, target);
+    return () => {
+        webhookTargets.delete(key);
+    };
+}
+async function readJsonBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    return await new Promise((resolve) => {
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                resolve({ ok: false, error: "payload too large" });
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            try {
+                const body = Buffer.concat(chunks).toString("utf-8");
+                const parsed = JSON.parse(body);
+                resolve({ ok: true, value: parsed });
+            }
+            catch {
+                resolve({ ok: false, error: "invalid json" });
+            }
+        });
+        req.on("error", (err) => {
+            resolve({ ok: false, error: err.message });
+        });
+    });
+}
+/**
+ * Create the webhook handler with access to the plugin runtime.
+ * Returns a handler function that can process incoming Webex webhook requests.
+ */
+function createWebhookHandler() {
+    return async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const path = normalizeWebhookPath(url.pathname);
+        // Check if path matches /webhooks/webex/*
+        if (!path.startsWith("/webhooks/webex/")) {
+            return false;
+        }
+        const target = webhookTargets.get(path);
+        if (!target) {
+            return false;
+        }
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            res.setHeader("Allow", "POST");
+            res.end("Method Not Allowed");
+            return true;
+        }
+        const body = await readJsonBody(req, 1024 * 1024);
+        if (!body.ok) {
+            res.statusCode = body.error === "payload too large" ? 413 : 400;
+            res.end(body.error ?? "invalid payload");
+            return true;
+        }
+        const { account, webhookHandler } = target;
+        try {
+            const signature = req.headers["x-spark-signature"];
+            const payload = body.value;
+            const envelope = await webhookHandler.handleWebhook(payload, signature);
+            if (envelope && pluginRuntime) {
+                // Load config using the plugin runtime (cast to any for internal API access)
+                const runtime = pluginRuntime;
+                const cfg = runtime.config?.loadConfig?.() ?? {};
+                // Build the context payload for OpenClaw's message pipeline
+                const ctxPayload = {
+                    Body: envelope.content.text ?? "",
+                    RawBody: envelope.content.text ?? "",
+                    CommandBody: envelope.content.text ?? "",
+                    From: `webex:${envelope.author.id}`,
+                    To: `webex:${envelope.conversationId}`,
+                    SessionKey: `agent:main:webex:${envelope.conversationId}`,
+                    AccountId: account.accountId,
+                    ChatType: envelope.metadata.roomType === "direct" ? "direct" : "group",
+                    SenderName: envelope.author.displayName ?? envelope.author.email ?? envelope.author.id,
+                    SenderId: envelope.author.id,
+                    Provider: "webex",
+                    Surface: "webex",
+                    MessageSid: envelope.id,
+                    Timestamp: envelope.metadata.timestamp,
+                    OriginatingChannel: "webex",
+                    OriginatingTo: `webex:${envelope.conversationId}`,
+                    MessageThreadId: envelope.metadata.parentId,
+                };
+                // Use the plugin runtime's dispatch function (cast to any for internal API)
+                const dispatchReply = runtime.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher;
+                if (dispatchReply) {
+                    // Create a sender for replies
+                    const sender = new send_1.WebexSender(account.config);
+                    await dispatchReply({
+                        ctx: ctxPayload,
+                        cfg,
+                        dispatcherOptions: {
+                            deliver: async (payload) => {
+                                if (payload.text) {
+                                    await sender.send({
+                                        to: envelope.conversationId,
+                                        content: { text: payload.text },
+                                        parentId: envelope.metadata.parentId,
+                                    });
+                                }
+                            },
+                            onError: (err) => {
+                                console.error(`[webex:${account.accountId}] reply dispatch error: ${err.message}`);
+                            },
+                        },
+                        replyOptions: {},
+                    });
+                }
+                else {
+                    console.warn(`[webex:${account.accountId}] dispatchReply not available in plugin runtime`);
+                }
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ ok: true }));
+            return true;
+        }
+        catch (err) {
+            console.error(`[webex:${account.accountId}] webhook error: ${err instanceof Error ? err.message : err}`);
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Internal error" }));
+            return true;
+        }
+    };
+}
 function listWebexAccountIds(cfg) {
     const section = cfg.channels?.webex;
     if (!section)
@@ -364,47 +518,20 @@ exports.webexPlugin = {
             catch (err) {
                 log?.warn?.(`[${account.accountId}] failed to register webhooks: ${err instanceof Error ? err.message : err}`);
             }
-            // Register HTTP handler for incoming webhooks
+            // Register webhook target for HTTP handler
             const webhookPath = `/webhooks/webex/${account.accountId}`;
-            runtime.http.registerHandler({
-                method: "POST",
-                path: webhookPath,
-                handler: async (req) => {
-                    try {
-                        const signature = req.headers["x-spark-signature"];
-                        const payload = req.body;
-                        const envelope = await webhookHandler.handleWebhook(payload, signature);
-                        if (envelope) {
-                            // Forward to OpenClaw's message pipeline
-                            await runtime.messaging.handleInbound({
-                                channel: "webex",
-                                accountId: account.accountId,
-                                senderId: envelope.author.id,
-                                senderEmail: envelope.author.email,
-                                conversationId: envelope.conversationId,
-                                messageId: envelope.id,
-                                text: envelope.content.text ?? "",
-                                roomType: envelope.metadata.roomType,
-                                threadId: envelope.metadata.parentId,
-                                timestamp: new Date(envelope.metadata.timestamp),
-                                raw: envelope.metadata.raw,
-                            });
-                        }
-                        return { status: 200, body: { ok: true } };
-                    }
-                    catch (err) {
-                        log?.error?.(`[${account.accountId}] webhook error: ${err instanceof Error ? err.message : err}`);
-                        return { status: 500, body: { error: "Internal error" } };
-                    }
-                },
+            const unregister = registerWebexWebhookTarget(webhookPath, {
+                account,
+                config: account.config,
+                webhookHandler,
             });
             log?.info?.(`[${account.accountId}] HTTP webhook handler registered at ${webhookPath}`);
             // Return cleanup function
             return async () => {
                 log?.info?.(`[${account.accountId}] stopping Webex provider`);
-                runtime.http.unregisterHandler(webhookPath);
+                unregister();
             };
         },
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"channel-plugin.js","sourceRoot":"","sources":["../src/channel-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenClaw Channel Plugin for Webex\n *\n * Implements the ChannelPlugin interface for OpenClaw's plugin system.\n */\n\nimport type {\n  ChannelPlugin,\n  PluginRuntime,\n  HttpRequest,\n} from \"openclaw/plugin-sdk\";\n\nimport { WebexSender } from \"./send\";\nimport { WebexWebhookHandler } from \"./webhook\";\nimport type { WebexChannelConfig, WebexWebhookPayload } from \"./types\";\n\n/** Resolved account configuration */\nexport interface ResolvedWebexAccount {\n  accountId: string;\n  name?: string;\n  enabled: boolean;\n  configured: boolean;\n  config: WebexChannelConfig;\n  token?: string;\n  webhookUrl?: string;\n}\n\n/** Core config type for accessing channels.webex */\ninterface CoreConfig {\n  channels?: {\n    webex?: WebexChannelSection;\n    defaults?: {\n      groupPolicy?: string;\n    };\n  };\n}\n\ninterface WebexChannelSection {\n  enabled?: boolean;\n  name?: string;\n  token?: string;\n  webhookUrl?: string;\n  webhookSecret?: string;\n  dmPolicy?: \"allow\" | \"deny\" | \"allowlisted\" | \"pairing\";\n  allowFrom?: string[];\n  apiBaseUrl?: string;\n  maxRetries?: number;\n  retryDelayMs?: number;\n  accounts?: Record<string, WebexAccountConfig>;\n}\n\ninterface WebexAccountConfig {\n  enabled?: boolean;\n  name?: string;\n  token?: string;\n  webhookUrl?: string;\n  webhookSecret?: string;\n  dmPolicy?: \"allow\" | \"deny\" | \"allowlisted\" | \"pairing\";\n  allowFrom?: string[];\n  apiBaseUrl?: string;\n  maxRetries?: number;\n  retryDelayMs?: number;\n}\n\nconst DEFAULT_ACCOUNT_ID = \"default\";\n\nfunction listWebexAccountIds(cfg: CoreConfig): string[] {\n  const section = cfg.channels?.webex;\n  if (!section) return [];\n\n  const ids: string[] = [];\n\n  // Check for top-level config (default account)\n  if (section.token) {\n    ids.push(DEFAULT_ACCOUNT_ID);\n  }\n\n  // Check for named accounts\n  if (section.accounts) {\n    for (const id of Object.keys(section.accounts)) {\n      if (id !== DEFAULT_ACCOUNT_ID) {\n        ids.push(id);\n      }\n    }\n  }\n\n  return ids;\n}\n\nfunction resolveWebexAccount(opts: {\n  cfg: CoreConfig;\n  accountId?: string;\n}): ResolvedWebexAccount {\n  const { cfg, accountId = DEFAULT_ACCOUNT_ID } = opts;\n  const section = cfg.channels?.webex;\n\n  if (!section) {\n    return {\n      accountId,\n      enabled: false,\n      configured: false,\n      config: {} as WebexChannelConfig,\n    };\n  }\n\n  // Check for named account first\n  const namedAccount = section.accounts?.[accountId];\n\n  if (namedAccount) {\n    const token = namedAccount.token ?? section.token;\n    const webhookUrl = namedAccount.webhookUrl ?? section.webhookUrl;\n\n    return {\n      accountId,\n      name: namedAccount.name,\n      enabled: namedAccount.enabled !== false,\n      configured: Boolean(token && webhookUrl),\n      token,\n      webhookUrl,\n      config: {\n        token: token ?? \"\",\n        webhookUrl: webhookUrl ?? \"\",\n        webhookSecret: namedAccount.webhookSecret ?? section.webhookSecret,\n        dmPolicy: namedAccount.dmPolicy ?? section.dmPolicy ?? \"allow\",\n        allowFrom: namedAccount.allowFrom ?? section.allowFrom,\n        apiBaseUrl: namedAccount.apiBaseUrl ?? section.apiBaseUrl,\n        maxRetries: namedAccount.maxRetries ?? section.maxRetries,\n        retryDelayMs: namedAccount.retryDelayMs ?? section.retryDelayMs,\n      },\n    };\n  }\n\n  // Fall back to top-level config (default account)\n  if (accountId === DEFAULT_ACCOUNT_ID) {\n    return {\n      accountId,\n      name: section.name,\n      enabled: section.enabled !== false,\n      configured: Boolean(section.token && section.webhookUrl),\n      token: section.token,\n      webhookUrl: section.webhookUrl,\n      config: {\n        token: section.token ?? \"\",\n        webhookUrl: section.webhookUrl ?? \"\",\n        webhookSecret: section.webhookSecret,\n        dmPolicy: section.dmPolicy ?? \"allow\",\n        allowFrom: section.allowFrom,\n        apiBaseUrl: section.apiBaseUrl,\n        maxRetries: section.maxRetries,\n        retryDelayMs: section.retryDelayMs,\n      },\n    };\n  }\n\n  // Account not found\n  return {\n    accountId,\n    enabled: false,\n    configured: false,\n    config: {} as WebexChannelConfig,\n  };\n}\n\nconst meta = {\n  id: \"webex\",\n  label: \"Webex\",\n  selectionLabel: \"Cisco Webex\",\n  docsPath: \"/channels/webex\",\n  docsLabel: \"webex\",\n  blurb: \"Cisco Webex messaging via bot webhooks.\",\n  order: 75,\n  aliases: [\"cisco-webex\"],\n};\n\nexport const webexPlugin: ChannelPlugin<ResolvedWebexAccount> = {\n  id: \"webex\",\n  meta,\n\n  capabilities: {\n    chatTypes: [\"direct\", \"group\"],\n    threads: true,\n    media: true,\n  },\n\n  reload: { configPrefixes: [\"channels.webex\"] },\n\n  config: {\n    listAccountIds: (cfg) => listWebexAccountIds(cfg as CoreConfig),\n\n    resolveAccount: (cfg, accountId) =>\n      resolveWebexAccount({ cfg: cfg as CoreConfig, accountId }),\n\n    defaultAccountId: () => DEFAULT_ACCOUNT_ID,\n\n    setAccountEnabled: ({ cfg, accountId, enabled }) => {\n      const config = cfg as CoreConfig;\n      const section = config.channels?.webex ?? {};\n\n      if (accountId === DEFAULT_ACCOUNT_ID) {\n        return {\n          ...config,\n          channels: {\n            ...config.channels,\n            webex: {\n              ...section,\n              enabled,\n            },\n          },\n        };\n      }\n\n      return {\n        ...config,\n        channels: {\n          ...config.channels,\n          webex: {\n            ...section,\n            accounts: {\n              ...section.accounts,\n              [accountId]: {\n                ...section.accounts?.[accountId],\n                enabled,\n              },\n            },\n          },\n        },\n      };\n    },\n\n    deleteAccount: ({ cfg, accountId }) => {\n      const config = cfg as CoreConfig;\n      const section = config.channels?.webex ?? {};\n\n      if (accountId === DEFAULT_ACCOUNT_ID) {\n        const { token, webhookUrl, webhookSecret, dmPolicy, allowFrom, ...rest } = section;\n        return {\n          ...config,\n          channels: {\n            ...config.channels,\n            webex: rest,\n          },\n        };\n      }\n\n      const accounts = { ...section.accounts };\n      delete accounts[accountId];\n\n      return {\n        ...config,\n        channels: {\n          ...config.channels,\n          webex: {\n            ...section,\n            accounts,\n          },\n        },\n      };\n    },\n\n    isConfigured: (account) => account.configured,\n\n    describeAccount: (account) => ({\n      accountId: account.accountId,\n      name: account.name,\n      enabled: account.enabled,\n      configured: account.configured,\n      baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n    }),\n\n    resolveAllowFrom: ({ cfg }) =>\n      ((cfg as CoreConfig).channels?.webex?.allowFrom ?? []).map(String),\n\n    formatAllowFrom: ({ allowFrom }) =>\n      allowFrom.map((entry) => entry.trim().toLowerCase()),\n  },\n\n  security: {\n    resolveDmPolicy: ({ account }) => {\n      const policy = account.config.dmPolicy ?? \"allow\";\n      // Map \"allowlisted\" to \"allowlist\" for OpenClaw compatibility\n      const normalizedPolicy = policy === \"allowlisted\" ? \"allowlist\" : policy;\n\n      return {\n        policy: normalizedPolicy as \"allow\" | \"deny\" | \"allowlist\" | \"pairing\",\n        allowFrom: account.config.allowFrom ?? [],\n        policyPath: \"channels.webex.dmPolicy\",\n        allowFromPath: \"channels.webex.allowFrom\",\n        approveHint: \"Add user ID or email to channels.webex.allowFrom\",\n        normalizeEntry: (raw) => raw.trim().toLowerCase(),\n      };\n    },\n  },\n\n  threading: {\n    resolveReplyToMode: () => \"off\",\n    buildToolContext: ({ context, hasRepliedRef }) => ({\n      currentChannelId: context.To?.trim() || undefined,\n      currentThreadTs: context.MessageThreadId != null\n        ? String(context.MessageThreadId)\n        : context.ReplyToId,\n      hasRepliedRef,\n    }),\n  },\n\n  messaging: {\n    normalizeTarget: (raw: string) => {\n      let normalized = raw.trim();\n      if (!normalized) return undefined;\n      if (normalized.toLowerCase().startsWith(\"webex:\")) {\n        normalized = normalized.slice(\"webex:\".length).trim();\n      }\n      return normalized || undefined;\n    },\n    targetResolver: {\n      looksLikeId: (raw) => {\n        const trimmed = raw.trim();\n        if (!trimmed) return false;\n        // Webex IDs are base64-encoded and start with a specific prefix\n        if (trimmed.startsWith(\"Y2lzY29zcGFyazovL3\")) return true;\n        // Also accept emails\n        return trimmed.includes(\"@\");\n      },\n      hint: \"<roomId|personId|email>\",\n    },\n  },\n\n  outbound: {\n    deliveryMode: \"direct\",\n    textChunkLimit: 7000, // Webex has a 7439 byte limit\n\n    sendText: async ({ to, text, account, replyToId }) => {\n      const sender = new WebexSender(account.config);\n\n      const result = await sender.send({\n        to,\n        content: { text },\n        parentId: replyToId,\n      });\n\n      return {\n        channel: \"webex\",\n        messageId: result.id,\n        roomId: result.roomId,\n      };\n    },\n\n    sendMedia: async ({ to, text, mediaUrl, account, replyToId }) => {\n      const sender = new WebexSender(account.config);\n\n      const result = await sender.send({\n        to,\n        content: {\n          text,\n          files: mediaUrl ? [mediaUrl] : undefined,\n        },\n        parentId: replyToId,\n      });\n\n      return {\n        channel: \"webex\",\n        messageId: result.id,\n        roomId: result.roomId,\n      };\n    },\n  },\n\n  status: {\n    defaultRuntime: {\n      accountId: DEFAULT_ACCOUNT_ID,\n      running: false,\n      lastStartAt: null,\n      lastStopAt: null,\n      lastError: null,\n    },\n\n    collectStatusIssues: (accounts) =>\n      accounts.flatMap((account) => {\n        const lastError = typeof account.lastError === \"string\" ? account.lastError.trim() : \"\";\n        if (!lastError) return [];\n        return [\n          {\n            channel: \"webex\",\n            accountId: account.accountId,\n            kind: \"runtime\" as const,\n            message: `Channel error: ${lastError}`,\n          },\n        ];\n      }),\n\n    buildChannelSummary: ({ snapshot }) => ({\n      configured: (snapshot.configured ?? false) as boolean,\n      baseUrl: (snapshot.baseUrl ?? null) as string | null,\n      running: (snapshot.running ?? false) as boolean,\n      lastStartAt: (snapshot.lastStartAt ?? null) as Date | null,\n      lastStopAt: (snapshot.lastStopAt ?? null) as Date | null,\n      lastError: (snapshot.lastError ?? null) as string | null,\n    }),\n\n    probeAccount: async ({ account, timeoutMs }) => {\n      if (!account.configured) {\n        return {\n          ok: false,\n          error: \"Account not configured\",\n          elapsedMs: 0,\n        };\n      }\n\n      const start = Date.now();\n      try {\n        const response = await fetch(\n          `${account.config.apiBaseUrl ?? \"https://webexapis.com/v1\"}/people/me`,\n          {\n            method: \"GET\",\n            headers: {\n              Authorization: `Bearer ${account.config.token}`,\n              \"Content-Type\": \"application/json\",\n            },\n            signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,\n          }\n        );\n\n        const elapsedMs = Date.now() - start;\n\n        if (!response.ok) {\n          return {\n            ok: false,\n            error: `HTTP ${response.status}: ${response.statusText}`,\n            elapsedMs,\n          };\n        }\n\n        return { ok: true, elapsedMs };\n      } catch (err) {\n        return {\n          ok: false,\n          error: err instanceof Error ? err.message : String(err),\n          elapsedMs: Date.now() - start,\n        };\n      }\n    },\n\n    buildAccountSnapshot: ({ account, runtime, probe }) => ({\n      accountId: account.accountId,\n      name: account.name,\n      enabled: account.enabled,\n      configured: account.configured,\n      baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n      running: runtime?.running ?? false,\n      lastStartAt: runtime?.lastStartAt ?? null,\n      lastStopAt: runtime?.lastStopAt ?? null,\n      lastError: runtime?.lastError ?? null,\n      probe,\n      lastProbeAt: runtime?.lastProbeAt ?? null,\n    }),\n  },\n\n  gateway: {\n    startAccount: async (ctx) => {\n      const { account, runtime, log, setStatus } = ctx;\n\n      setStatus({\n        accountId: account.accountId,\n        baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n      });\n\n      log?.info?.(\n        `[${account.accountId}] starting Webex provider (webhook mode)`\n      );\n\n      // Initialize webhook handler\n      const webhookHandler = new WebexWebhookHandler(account.config);\n      await webhookHandler.initialize();\n\n      // Register webhooks with Webex\n      try {\n        await webhookHandler.registerWebhooks();\n        log?.info?.(`[${account.accountId}] webhooks registered`);\n      } catch (err) {\n        log?.warn?.(\n          `[${account.accountId}] failed to register webhooks: ${err instanceof Error ? err.message : err}`\n        );\n      }\n\n      // Register HTTP handler for incoming webhooks\n      const webhookPath = `/webhooks/webex/${account.accountId}`;\n\n      runtime.http.registerHandler({\n        method: \"POST\",\n        path: webhookPath,\n        handler: async (req) => {\n          try {\n            const signature = req.headers[\"x-spark-signature\"] as string | undefined;\n            const payload = req.body as WebexWebhookPayload;\n\n            const envelope = await webhookHandler.handleWebhook(payload, signature);\n\n            if (envelope) {\n              // Forward to OpenClaw's message pipeline\n              await runtime.messaging.handleInbound({\n                channel: \"webex\",\n                accountId: account.accountId,\n                senderId: envelope.author.id,\n                senderEmail: envelope.author.email,\n                conversationId: envelope.conversationId,\n                messageId: envelope.id,\n                text: envelope.content.text ?? \"\",\n                roomType: envelope.metadata.roomType,\n                threadId: envelope.metadata.parentId,\n                timestamp: new Date(envelope.metadata.timestamp),\n                raw: envelope.metadata.raw,\n              });\n            }\n\n            return { status: 200, body: { ok: true } };\n          } catch (err) {\n            log?.error?.(\n              `[${account.accountId}] webhook error: ${err instanceof Error ? err.message : err}`\n            );\n            return { status: 500, body: { error: \"Internal error\" } };\n          }\n        },\n      });\n\n      log?.info?.(\n        `[${account.accountId}] HTTP webhook handler registered at ${webhookPath}`\n      );\n\n      // Return cleanup function\n      return async () => {\n        log?.info?.(`[${account.accountId}] stopping Webex provider`);\n        runtime.http.unregisterHandler(webhookPath);\n      };\n    },\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"channel-plugin.js","sourceRoot":"","sources":["../src/channel-plugin.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAgBH,4CAEC;AAuED,gEASC;AAkCD,oDA4GC;AAvOD,iCAAqC;AACrC,uCAAgD;AAGhD,oDAAoD;AACpD,IAAI,aAAa,GAAyB,IAAI,CAAC;AAE/C,SAAgB,gBAAgB,CAAC,OAAsB;IACrD,aAAa,GAAG,OAAO,CAAC;AAC1B,CAAC;AAkDD,MAAM,kBAAkB,GAAG,SAAS,CAAC;AASrC,MAAM,cAAc,GAAG,IAAI,GAAG,EAA8B,CAAC;AAE7D,SAAS,oBAAoB,CAAC,GAAW;IACvC,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,IAAI,CAAC,OAAO;QAAE,OAAO,GAAG,CAAC;IACzB,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,EAAE,CAAC;IACpE,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACpD,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAgB,0BAA0B,CACxC,IAAY,EACZ,MAA0B;IAE1B,MAAM,GAAG,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACvC,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,GAAG,EAAE;QACV,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,YAAY,CAAC,GAAoB,EAAE,QAAgB;IAChE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QACnC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;YAC/B,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC;YACtB,IAAI,KAAK,GAAG,QAAQ,EAAE,CAAC;gBACrB,OAAO,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC;gBACnD,GAAG,CAAC,OAAO,EAAE,CAAC;gBACd,OAAO;YACT,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;YACjB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBACrD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAChC,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACvC,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;YAChD,CAAC;QACH,CAAC,CAAC,CAAC;QACH,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YACtB,OAAO,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,SAAgB,oBAAoB;IAClC,OAAO,KAAK,EAAE,GAAoB,EAAE,GAAmB,EAAoB,EAAE;QAC3E,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,EAAE,kBAAkB,CAAC,CAAC;QACxD,MAAM,IAAI,GAAG,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAEhD,0CAA0C;QAC1C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACzC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC1B,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC/B,GAAG,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACb,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,KAAK,mBAAmB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;YAChE,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,iBAAiB,CAAC,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC;QAE3C,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAuB,CAAC;YACzE,MAAM,OAAO,GAAG,IAAI,CAAC,KAA4B,CAAC;YAElD,MAAM,QAAQ,GAAG,MAAM,cAAc,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAExE,IAAI,QAAQ,IAAI,aAAa,EAAE,CAAC;gBAC9B,6EAA6E;gBAC7E,MAAM,OAAO,GAAG,aAAoB,CAAC;gBACrC,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC;gBAEjD,4DAA4D;gBAC5D,MAAM,UAAU,GAAG;oBACjB,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE;oBACjC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE;oBACpC,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE;oBACxC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE;oBACnC,EAAE,EAAE,SAAS,QAAQ,CAAC,cAAc,EAAE;oBACtC,UAAU,EAAE,oBAAoB,QAAQ,CAAC,cAAc,EAAE;oBACzD,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO;oBACtE,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;oBACtF,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE;oBAC5B,QAAQ,EAAE,OAAO;oBACjB,OAAO,EAAE,OAAO;oBAChB,UAAU,EAAE,QAAQ,CAAC,EAAE;oBACvB,SAAS,EAAE,QAAQ,CAAC,QAAQ,CAAC,SAAS;oBACtC,kBAAkB,EAAE,OAAO;oBAC3B,aAAa,EAAE,SAAS,QAAQ,CAAC,cAAc,EAAE;oBACjD,eAAe,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ;iBAC5C,CAAC;gBAEF,4EAA4E;gBAC5E,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,wCAAwC,CAAC;gBAEvF,IAAI,aAAa,EAAE,CAAC;oBAClB,8BAA8B;oBAC9B,MAAM,MAAM,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBAE/C,MAAM,aAAa,CAAC;wBAClB,GAAG,EAAE,UAAU;wBACf,GAAG;wBACH,iBAAiB,EAAE;4BACjB,OAAO,EAAE,KAAK,EAAE,OAA0C,EAAE,EAAE;gCAC5D,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;oCACjB,MAAM,MAAM,CAAC,IAAI,CAAC;wCAChB,EAAE,EAAE,QAAQ,CAAC,cAAc;wCAC3B,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE;wCAC/B,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,QAAQ;qCACrC,CAAC,CAAC;gCACL,CAAC;4BACH,CAAC;4BACD,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE;gCACtB,OAAO,CAAC,KAAK,CAAC,UAAU,OAAO,CAAC,SAAS,2BAA2B,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;4BACrF,CAAC;yBACF;wBACD,YAAY,EAAE,EAAE;qBACjB,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,UAAU,OAAO,CAAC,SAAS,iDAAiD,CAAC,CAAC;gBAC7F,CAAC;YACH,CAAC;YAED,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;YAClD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACtC,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CACX,UAAU,OAAO,CAAC,SAAS,oBAAoB,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAC1F,CAAC;YACF,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC;YACrB,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;YAClD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC;YACrD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,mBAAmB,CAAC,GAAe;IAC1C,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;IACpC,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IAExB,MAAM,GAAG,GAAa,EAAE,CAAC;IAEzB,+CAA+C;IAC/C,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IAC/B,CAAC;IAED,2BAA2B;IAC3B,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrB,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC/C,IAAI,EAAE,KAAK,kBAAkB,EAAE,CAAC;gBAC9B,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,mBAAmB,CAAC,IAG5B;IACC,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,kBAAkB,EAAE,GAAG,IAAI,CAAC;IACrD,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;IAEpC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;YACL,SAAS;YACT,OAAO,EAAE,KAAK;YACd,UAAU,EAAE,KAAK;YACjB,MAAM,EAAE,EAAwB;SACjC,CAAC;IACJ,CAAC;IAED,gCAAgC;IAChC,MAAM,YAAY,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC;IAEnD,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;QAClD,MAAM,UAAU,GAAG,YAAY,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;QAEjE,OAAO;YACL,SAAS;YACT,IAAI,EAAE,YAAY,CAAC,IAAI;YACvB,OAAO,EAAE,YAAY,CAAC,OAAO,KAAK,KAAK;YACvC,UAAU,EAAE,OAAO,CAAC,KAAK,IAAI,UAAU,CAAC;YACxC,KAAK;YACL,UAAU;YACV,MAAM,EAAE;gBACN,KAAK,EAAE,KAAK,IAAI,EAAE;gBAClB,UAAU,EAAE,UAAU,IAAI,EAAE;gBAC5B,aAAa,EAAE,YAAY,CAAC,aAAa,IAAI,OAAO,CAAC,aAAa;gBAClE,QAAQ,EAAE,YAAY,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO;gBAC9D,SAAS,EAAE,YAAY,CAAC,SAAS,IAAI,OAAO,CAAC,SAAS;gBACtD,UAAU,EAAE,YAAY,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU;gBACzD,UAAU,EAAE,YAAY,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU;gBACzD,YAAY,EAAE,YAAY,CAAC,YAAY,IAAI,OAAO,CAAC,YAAY;aAChE;SACF,CAAC;IACJ,CAAC;IAED,kDAAkD;IAClD,IAAI,SAAS,KAAK,kBAAkB,EAAE,CAAC;QACrC,OAAO;YACL,SAAS;YACT,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,OAAO,EAAE,OAAO,CAAC,OAAO,KAAK,KAAK;YAClC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;YACxD,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,MAAM,EAAE;gBACN,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE;gBAC1B,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,EAAE;gBACpC,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,OAAO;gBACrC,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,YAAY,EAAE,OAAO,CAAC,YAAY;aACnC;SACF,CAAC;IACJ,CAAC;IAED,oBAAoB;IACpB,OAAO;QACL,SAAS;QACT,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,EAAwB;KACjC,CAAC;AACJ,CAAC;AAED,MAAM,IAAI,GAAG;IACX,EAAE,EAAE,OAAO;IACX,KAAK,EAAE,OAAO;IACd,cAAc,EAAE,aAAa;IAC7B,QAAQ,EAAE,iBAAiB;IAC3B,SAAS,EAAE,OAAO;IAClB,KAAK,EAAE,yCAAyC;IAChD,KAAK,EAAE,EAAE;IACT,OAAO,EAAE,CAAC,aAAa,CAAC;CACzB,CAAC;AAEW,QAAA,WAAW,GAAwC;IAC9D,EAAE,EAAE,OAAO;IACX,IAAI;IAEJ,YAAY,EAAE;QACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC9B,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,IAAI;KACZ;IAED,MAAM,EAAE,EAAE,cAAc,EAAE,CAAC,gBAAgB,CAAC,EAAE;IAE9C,MAAM,EAAE;QACN,cAAc,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAiB,CAAC;QAE/D,cAAc,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,CACjC,mBAAmB,CAAC,EAAE,GAAG,EAAE,GAAiB,EAAE,SAAS,EAAE,CAAC;QAE5D,gBAAgB,EAAE,GAAG,EAAE,CAAC,kBAAkB;QAE1C,iBAAiB,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,EAAE;YACjD,MAAM,MAAM,GAAG,GAAiB,CAAC;YACjC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC;YAE7C,IAAI,SAAS,KAAK,kBAAkB,EAAE,CAAC;gBACrC,OAAO;oBACL,GAAG,MAAM;oBACT,QAAQ,EAAE;wBACR,GAAG,MAAM,CAAC,QAAQ;wBAClB,KAAK,EAAE;4BACL,GAAG,OAAO;4BACV,OAAO;yBACR;qBACF;iBACF,CAAC;YACJ,CAAC;YAED,OAAO;gBACL,GAAG,MAAM;gBACT,QAAQ,EAAE;oBACR,GAAG,MAAM,CAAC,QAAQ;oBAClB,KAAK,EAAE;wBACL,GAAG,OAAO;wBACV,QAAQ,EAAE;4BACR,GAAG,OAAO,CAAC,QAAQ;4BACnB,CAAC,SAAS,CAAC,EAAE;gCACX,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC;gCAChC,OAAO;6BACR;yBACF;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QAED,aAAa,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE;YACpC,MAAM,MAAM,GAAG,GAAiB,CAAC;YACjC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC;YAE7C,IAAI,SAAS,KAAK,kBAAkB,EAAE,CAAC;gBACrC,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;gBACnF,OAAO;oBACL,GAAG,MAAM;oBACT,QAAQ,EAAE;wBACR,GAAG,MAAM,CAAC,QAAQ;wBAClB,KAAK,EAAE,IAAI;qBACZ;iBACF,CAAC;YACJ,CAAC;YAED,MAAM,QAAQ,GAAG,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACzC,OAAO,QAAQ,CAAC,SAAS,CAAC,CAAC;YAE3B,OAAO;gBACL,GAAG,MAAM;gBACT,QAAQ,EAAE;oBACR,GAAG,MAAM,CAAC,QAAQ;oBAClB,KAAK,EAAE;wBACL,GAAG,OAAO;wBACV,QAAQ;qBACT;iBACF;aACF,CAAC;QACJ,CAAC;QAED,YAAY,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU;QAE7C,eAAe,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAC7B,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,0BAA0B;SACjE,CAAC;QAEF,gBAAgB,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAC5B,CAAE,GAAkB,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC;QAEpE,eAAe,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CACjC,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;KACvD;IAED,QAAQ,EAAE;QACR,eAAe,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;YAC/B,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,IAAI,OAAO,CAAC;YAClD,8DAA8D;YAC9D,MAAM,gBAAgB,GAAG,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC;YAEzE,OAAO;gBACL,MAAM,EAAE,gBAA8D;gBACtE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE;gBACzC,UAAU,EAAE,yBAAyB;gBACrC,aAAa,EAAE,0BAA0B;gBACzC,WAAW,EAAE,kDAAkD;gBAC/D,cAAc,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE;aAClD,CAAC;QACJ,CAAC;KACF;IAED,SAAS,EAAE;QACT,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK;QAC/B,gBAAgB,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC;YACjD,gBAAgB,EAAE,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,SAAS;YACjD,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,IAAI;gBAC9C,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC;gBACjC,CAAC,CAAC,OAAO,CAAC,SAAS;YACrB,aAAa;SACd,CAAC;KACH;IAED,SAAS,EAAE;QACT,eAAe,EAAE,CAAC,GAAW,EAAE,EAAE;YAC/B,IAAI,UAAU,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;YAC5B,IAAI,CAAC,UAAU;gBAAE,OAAO,SAAS,CAAC;YAClC,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAClD,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;YACxD,CAAC;YACD,OAAO,UAAU,IAAI,SAAS,CAAC;QACjC,CAAC;QACD,cAAc,EAAE;YACd,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE;gBACnB,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;gBAC3B,IAAI,CAAC,OAAO;oBAAE,OAAO,KAAK,CAAC;gBAC3B,gEAAgE;gBAChE,IAAI,OAAO,CAAC,UAAU,CAAC,oBAAoB,CAAC;oBAAE,OAAO,IAAI,CAAC;gBAC1D,qBAAqB;gBACrB,OAAO,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC/B,CAAC;YACD,IAAI,EAAE,yBAAyB;SAChC;KACF;IAED,QAAQ,EAAE;QACR,YAAY,EAAE,QAAQ;QACtB,cAAc,EAAE,IAAI,EAAE,8BAA8B;QAEpD,QAAQ,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE;YACnD,MAAM,MAAM,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAE/C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC;gBAC/B,EAAE;gBACF,OAAO,EAAE,EAAE,IAAI,EAAE;gBACjB,QAAQ,EAAE,SAAS;aACpB,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,SAAS,EAAE,MAAM,CAAC,EAAE;gBACpB,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC;QACJ,CAAC;QAED,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE;YAC9D,MAAM,MAAM,GAAG,IAAI,kBAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAE/C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC;gBAC/B,EAAE;gBACF,OAAO,EAAE;oBACP,IAAI;oBACJ,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS;iBACzC;gBACD,QAAQ,EAAE,SAAS;aACpB,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,SAAS,EAAE,MAAM,CAAC,EAAE;gBACpB,MAAM,EAAE,MAAM,CAAC,MAAM;aACtB,CAAC;QACJ,CAAC;KACF;IAED,MAAM,EAAE;QACN,cAAc,EAAE;YACd,SAAS,EAAE,kBAAkB;YAC7B,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,IAAI;YACjB,UAAU,EAAE,IAAI;YAChB,SAAS,EAAE,IAAI;SAChB;QAED,mBAAmB,EAAE,CAAC,QAAQ,EAAE,EAAE,CAChC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxF,IAAI,CAAC,SAAS;gBAAE,OAAO,EAAE,CAAC;YAC1B,OAAO;gBACL;oBACE,OAAO,EAAE,OAAO;oBAChB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,IAAI,EAAE,SAAkB;oBACxB,OAAO,EAAE,kBAAkB,SAAS,EAAE;iBACvC;aACF,CAAC;QACJ,CAAC,CAAC;QAEJ,mBAAmB,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;YACtC,UAAU,EAAE,CAAC,QAAQ,CAAC,UAAU,IAAI,KAAK,CAAY;YACrD,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,IAAI,IAAI,CAAkB;YACpD,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,IAAI,KAAK,CAAY;YAC/C,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,IAAI,IAAI,CAAgB;YAC1D,UAAU,EAAE,CAAC,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAgB;YACxD,SAAS,EAAE,CAAC,QAAQ,CAAC,SAAS,IAAI,IAAI,CAAkB;SACzD,CAAC;QAEF,YAAY,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE;YAC7C,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;gBACxB,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,KAAK,EAAE,wBAAwB;oBAC/B,SAAS,EAAE,CAAC;iBACb,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,0BAA0B,YAAY,EACtE;oBACE,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE;wBACP,aAAa,EAAE,UAAU,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE;wBAC/C,cAAc,EAAE,kBAAkB;qBACnC;oBACD,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;iBAC/D,CACF,CAAC;gBAEF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;gBAErC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;oBACjB,OAAO;wBACL,EAAE,EAAE,KAAK;wBACT,KAAK,EAAE,QAAQ,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,UAAU,EAAE;wBACxD,SAAS;qBACV,CAAC;gBACJ,CAAC;gBAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;YACjC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;oBACvD,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK;iBAC9B,CAAC;YACJ,CAAC;QACH,CAAC;QAED,oBAAoB,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;YACtD,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,0BAA0B;YAChE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,KAAK;YAClC,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,IAAI;YACzC,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,IAAI;YACvC,SAAS,EAAE,OAAO,EAAE,SAAS,IAAI,IAAI;YACrC,KAAK;YACL,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,IAAI;SAC1C,CAAC;KACH;IAED,OAAO,EAAE;QACP,YAAY,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;YAC1B,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC;YAEjD,SAAS,CAAC;gBACR,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,0BAA0B;aACjE,CAAC,CAAC;YAEH,GAAG,EAAE,IAAI,EAAE,CACT,IAAI,OAAO,CAAC,SAAS,0CAA0C,CAChE,CAAC;YAEF,6BAA6B;YAC7B,MAAM,cAAc,GAAG,IAAI,6BAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC/D,MAAM,cAAc,CAAC,UAAU,EAAE,CAAC;YAElC,+BAA+B;YAC/B,IAAI,CAAC;gBACH,MAAM,cAAc,CAAC,gBAAgB,EAAE,CAAC;gBACxC,GAAG,EAAE,IAAI,EAAE,CAAC,IAAI,OAAO,CAAC,SAAS,uBAAuB,CAAC,CAAC;YAC5D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,GAAG,EAAE,IAAI,EAAE,CACT,IAAI,OAAO,CAAC,SAAS,kCAAkC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAClG,CAAC;YACJ,CAAC;YAED,2CAA2C;YAC3C,MAAM,WAAW,GAAG,mBAAmB,OAAO,CAAC,SAAS,EAAE,CAAC;YAE3D,MAAM,UAAU,GAAG,0BAA0B,CAAC,WAAW,EAAE;gBACzD,OAAO;gBACP,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,cAAc;aACf,CAAC,CAAC;YAEH,GAAG,EAAE,IAAI,EAAE,CACT,IAAI,OAAO,CAAC,SAAS,wCAAwC,WAAW,EAAE,CAC3E,CAAC;YAEF,0BAA0B;YAC1B,OAAO,KAAK,IAAI,EAAE;gBAChB,GAAG,EAAE,IAAI,EAAE,CAAC,IAAI,OAAO,CAAC,SAAS,2BAA2B,CAAC,CAAC;gBAC9D,UAAU,EAAE,CAAC;YACf,CAAC,CAAC;QACJ,CAAC;KACF;CACF,CAAC","sourcesContent":["/**\n * OpenClaw Channel Plugin for Webex\n *\n * Implements the ChannelPlugin interface for OpenClaw's plugin system.\n */\n\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\n\nimport type {\n  ChannelPlugin,\n  PluginRuntime,\n} from \"openclaw/plugin-sdk\";\n\nimport { WebexSender } from \"./send\";\nimport { WebexWebhookHandler } from \"./webhook\";\nimport type { WebexChannelConfig, WebexWebhookPayload } from \"./types\";\n\n// Store the plugin runtime for use in HTTP handlers\nlet pluginRuntime: PluginRuntime | null = null;\n\nexport function setPluginRuntime(runtime: PluginRuntime): void {\n  pluginRuntime = runtime;\n}\n\n/** Resolved account configuration */\nexport interface ResolvedWebexAccount {\n  accountId: string;\n  name?: string;\n  enabled: boolean;\n  configured: boolean;\n  config: WebexChannelConfig;\n  token?: string;\n  webhookUrl?: string;\n}\n\n/** Core config type for accessing channels.webex */\ninterface CoreConfig {\n  channels?: {\n    webex?: WebexChannelSection;\n    defaults?: {\n      groupPolicy?: string;\n    };\n  };\n}\n\ninterface WebexChannelSection {\n  enabled?: boolean;\n  name?: string;\n  token?: string;\n  webhookUrl?: string;\n  webhookSecret?: string;\n  dmPolicy?: \"allow\" | \"deny\" | \"allowlisted\" | \"pairing\";\n  allowFrom?: string[];\n  apiBaseUrl?: string;\n  maxRetries?: number;\n  retryDelayMs?: number;\n  accounts?: Record<string, WebexAccountConfig>;\n}\n\ninterface WebexAccountConfig {\n  enabled?: boolean;\n  name?: string;\n  token?: string;\n  webhookUrl?: string;\n  webhookSecret?: string;\n  dmPolicy?: \"allow\" | \"deny\" | \"allowlisted\" | \"pairing\";\n  allowFrom?: string[];\n  apiBaseUrl?: string;\n  maxRetries?: number;\n  retryDelayMs?: number;\n}\n\nconst DEFAULT_ACCOUNT_ID = \"default\";\n\n/** Webhook target registration for HTTP handler */\ntype WebexWebhookTarget = {\n  account: ResolvedWebexAccount;\n  config: WebexChannelConfig;\n  webhookHandler: WebexWebhookHandler;\n};\n\nconst webhookTargets = new Map<string, WebexWebhookTarget>();\n\nfunction normalizeWebhookPath(raw: string): string {\n  const trimmed = raw.trim();\n  if (!trimmed) return \"/\";\n  const withSlash = trimmed.startsWith(\"/\") ? trimmed : `/${trimmed}`;\n  if (withSlash.length > 1 && withSlash.endsWith(\"/\")) {\n    return withSlash.slice(0, -1);\n  }\n  return withSlash;\n}\n\nexport function registerWebexWebhookTarget(\n  path: string,\n  target: WebexWebhookTarget\n): () => void {\n  const key = normalizeWebhookPath(path);\n  webhookTargets.set(key, target);\n  return () => {\n    webhookTargets.delete(key);\n  };\n}\n\nasync function readJsonBody(req: IncomingMessage, maxBytes: number): Promise<{ ok: boolean; value?: unknown; error?: string }> {\n  const chunks: Buffer[] = [];\n  let total = 0;\n  return await new Promise((resolve) => {\n    req.on(\"data\", (chunk: Buffer) => {\n      total += chunk.length;\n      if (total > maxBytes) {\n        resolve({ ok: false, error: \"payload too large\" });\n        req.destroy();\n        return;\n      }\n      chunks.push(chunk);\n    });\n    req.on(\"end\", () => {\n      try {\n        const body = Buffer.concat(chunks).toString(\"utf-8\");\n        const parsed = JSON.parse(body);\n        resolve({ ok: true, value: parsed });\n      } catch {\n        resolve({ ok: false, error: \"invalid json\" });\n      }\n    });\n    req.on(\"error\", (err) => {\n      resolve({ ok: false, error: err.message });\n    });\n  });\n}\n\n/**\n * Create the webhook handler with access to the plugin runtime.\n * Returns a handler function that can process incoming Webex webhook requests.\n */\nexport function createWebhookHandler(): (req: IncomingMessage, res: ServerResponse) => Promise<boolean> {\n  return async (req: IncomingMessage, res: ServerResponse): Promise<boolean> => {\n    const url = new URL(req.url ?? \"/\", \"http://localhost\");\n    const path = normalizeWebhookPath(url.pathname);\n\n    // Check if path matches /webhooks/webex/*\n    if (!path.startsWith(\"/webhooks/webex/\")) {\n      return false;\n    }\n\n    const target = webhookTargets.get(path);\n    if (!target) {\n      return false;\n    }\n\n    if (req.method !== \"POST\") {\n      res.statusCode = 405;\n      res.setHeader(\"Allow\", \"POST\");\n      res.end(\"Method Not Allowed\");\n      return true;\n    }\n\n    const body = await readJsonBody(req, 1024 * 1024);\n    if (!body.ok) {\n      res.statusCode = body.error === \"payload too large\" ? 413 : 400;\n      res.end(body.error ?? \"invalid payload\");\n      return true;\n    }\n\n    const { account, webhookHandler } = target;\n\n    try {\n      const signature = req.headers[\"x-spark-signature\"] as string | undefined;\n      const payload = body.value as WebexWebhookPayload;\n\n      const envelope = await webhookHandler.handleWebhook(payload, signature);\n\n      if (envelope && pluginRuntime) {\n        // Load config using the plugin runtime (cast to any for internal API access)\n        const runtime = pluginRuntime as any;\n        const cfg = runtime.config?.loadConfig?.() ?? {};\n        \n        // Build the context payload for OpenClaw's message pipeline\n        const ctxPayload = {\n          Body: envelope.content.text ?? \"\",\n          RawBody: envelope.content.text ?? \"\",\n          CommandBody: envelope.content.text ?? \"\",\n          From: `webex:${envelope.author.id}`,\n          To: `webex:${envelope.conversationId}`,\n          SessionKey: `agent:main:webex:${envelope.conversationId}`,\n          AccountId: account.accountId,\n          ChatType: envelope.metadata.roomType === \"direct\" ? \"direct\" : \"group\",\n          SenderName: envelope.author.displayName ?? envelope.author.email ?? envelope.author.id,\n          SenderId: envelope.author.id,\n          Provider: \"webex\",\n          Surface: \"webex\",\n          MessageSid: envelope.id,\n          Timestamp: envelope.metadata.timestamp,\n          OriginatingChannel: \"webex\",\n          OriginatingTo: `webex:${envelope.conversationId}`,\n          MessageThreadId: envelope.metadata.parentId,\n        };\n\n        // Use the plugin runtime's dispatch function (cast to any for internal API)\n        const dispatchReply = runtime.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher;\n        \n        if (dispatchReply) {\n          // Create a sender for replies\n          const sender = new WebexSender(account.config);\n          \n          await dispatchReply({\n            ctx: ctxPayload,\n            cfg,\n            dispatcherOptions: {\n              deliver: async (payload: { text?: string; media?: string }) => {\n                if (payload.text) {\n                  await sender.send({\n                    to: envelope.conversationId,\n                    content: { text: payload.text },\n                    parentId: envelope.metadata.parentId,\n                  });\n                }\n              },\n              onError: (err: Error) => {\n                console.error(`[webex:${account.accountId}] reply dispatch error: ${err.message}`);\n              },\n            },\n            replyOptions: {},\n          });\n        } else {\n          console.warn(`[webex:${account.accountId}] dispatchReply not available in plugin runtime`);\n        }\n      }\n\n      res.statusCode = 200;\n      res.setHeader(\"Content-Type\", \"application/json\");\n      res.end(JSON.stringify({ ok: true }));\n      return true;\n    } catch (err) {\n      console.error(\n        `[webex:${account.accountId}] webhook error: ${err instanceof Error ? err.message : err}`\n      );\n      res.statusCode = 500;\n      res.setHeader(\"Content-Type\", \"application/json\");\n      res.end(JSON.stringify({ error: \"Internal error\" }));\n      return true;\n    }\n  };\n}\n\nfunction listWebexAccountIds(cfg: CoreConfig): string[] {\n  const section = cfg.channels?.webex;\n  if (!section) return [];\n\n  const ids: string[] = [];\n\n  // Check for top-level config (default account)\n  if (section.token) {\n    ids.push(DEFAULT_ACCOUNT_ID);\n  }\n\n  // Check for named accounts\n  if (section.accounts) {\n    for (const id of Object.keys(section.accounts)) {\n      if (id !== DEFAULT_ACCOUNT_ID) {\n        ids.push(id);\n      }\n    }\n  }\n\n  return ids;\n}\n\nfunction resolveWebexAccount(opts: {\n  cfg: CoreConfig;\n  accountId?: string;\n}): ResolvedWebexAccount {\n  const { cfg, accountId = DEFAULT_ACCOUNT_ID } = opts;\n  const section = cfg.channels?.webex;\n\n  if (!section) {\n    return {\n      accountId,\n      enabled: false,\n      configured: false,\n      config: {} as WebexChannelConfig,\n    };\n  }\n\n  // Check for named account first\n  const namedAccount = section.accounts?.[accountId];\n\n  if (namedAccount) {\n    const token = namedAccount.token ?? section.token;\n    const webhookUrl = namedAccount.webhookUrl ?? section.webhookUrl;\n\n    return {\n      accountId,\n      name: namedAccount.name,\n      enabled: namedAccount.enabled !== false,\n      configured: Boolean(token && webhookUrl),\n      token,\n      webhookUrl,\n      config: {\n        token: token ?? \"\",\n        webhookUrl: webhookUrl ?? \"\",\n        webhookSecret: namedAccount.webhookSecret ?? section.webhookSecret,\n        dmPolicy: namedAccount.dmPolicy ?? section.dmPolicy ?? \"allow\",\n        allowFrom: namedAccount.allowFrom ?? section.allowFrom,\n        apiBaseUrl: namedAccount.apiBaseUrl ?? section.apiBaseUrl,\n        maxRetries: namedAccount.maxRetries ?? section.maxRetries,\n        retryDelayMs: namedAccount.retryDelayMs ?? section.retryDelayMs,\n      },\n    };\n  }\n\n  // Fall back to top-level config (default account)\n  if (accountId === DEFAULT_ACCOUNT_ID) {\n    return {\n      accountId,\n      name: section.name,\n      enabled: section.enabled !== false,\n      configured: Boolean(section.token && section.webhookUrl),\n      token: section.token,\n      webhookUrl: section.webhookUrl,\n      config: {\n        token: section.token ?? \"\",\n        webhookUrl: section.webhookUrl ?? \"\",\n        webhookSecret: section.webhookSecret,\n        dmPolicy: section.dmPolicy ?? \"allow\",\n        allowFrom: section.allowFrom,\n        apiBaseUrl: section.apiBaseUrl,\n        maxRetries: section.maxRetries,\n        retryDelayMs: section.retryDelayMs,\n      },\n    };\n  }\n\n  // Account not found\n  return {\n    accountId,\n    enabled: false,\n    configured: false,\n    config: {} as WebexChannelConfig,\n  };\n}\n\nconst meta = {\n  id: \"webex\",\n  label: \"Webex\",\n  selectionLabel: \"Cisco Webex\",\n  docsPath: \"/channels/webex\",\n  docsLabel: \"webex\",\n  blurb: \"Cisco Webex messaging via bot webhooks.\",\n  order: 75,\n  aliases: [\"cisco-webex\"],\n};\n\nexport const webexPlugin: ChannelPlugin<ResolvedWebexAccount> = {\n  id: \"webex\",\n  meta,\n\n  capabilities: {\n    chatTypes: [\"direct\", \"group\"],\n    threads: true,\n    media: true,\n  },\n\n  reload: { configPrefixes: [\"channels.webex\"] },\n\n  config: {\n    listAccountIds: (cfg) => listWebexAccountIds(cfg as CoreConfig),\n\n    resolveAccount: (cfg, accountId) =>\n      resolveWebexAccount({ cfg: cfg as CoreConfig, accountId }),\n\n    defaultAccountId: () => DEFAULT_ACCOUNT_ID,\n\n    setAccountEnabled: ({ cfg, accountId, enabled }) => {\n      const config = cfg as CoreConfig;\n      const section = config.channels?.webex ?? {};\n\n      if (accountId === DEFAULT_ACCOUNT_ID) {\n        return {\n          ...config,\n          channels: {\n            ...config.channels,\n            webex: {\n              ...section,\n              enabled,\n            },\n          },\n        };\n      }\n\n      return {\n        ...config,\n        channels: {\n          ...config.channels,\n          webex: {\n            ...section,\n            accounts: {\n              ...section.accounts,\n              [accountId]: {\n                ...section.accounts?.[accountId],\n                enabled,\n              },\n            },\n          },\n        },\n      };\n    },\n\n    deleteAccount: ({ cfg, accountId }) => {\n      const config = cfg as CoreConfig;\n      const section = config.channels?.webex ?? {};\n\n      if (accountId === DEFAULT_ACCOUNT_ID) {\n        const { token, webhookUrl, webhookSecret, dmPolicy, allowFrom, ...rest } = section;\n        return {\n          ...config,\n          channels: {\n            ...config.channels,\n            webex: rest,\n          },\n        };\n      }\n\n      const accounts = { ...section.accounts };\n      delete accounts[accountId];\n\n      return {\n        ...config,\n        channels: {\n          ...config.channels,\n          webex: {\n            ...section,\n            accounts,\n          },\n        },\n      };\n    },\n\n    isConfigured: (account) => account.configured,\n\n    describeAccount: (account) => ({\n      accountId: account.accountId,\n      name: account.name,\n      enabled: account.enabled,\n      configured: account.configured,\n      baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n    }),\n\n    resolveAllowFrom: ({ cfg }) =>\n      ((cfg as CoreConfig).channels?.webex?.allowFrom ?? []).map(String),\n\n    formatAllowFrom: ({ allowFrom }) =>\n      allowFrom.map((entry) => entry.trim().toLowerCase()),\n  },\n\n  security: {\n    resolveDmPolicy: ({ account }) => {\n      const policy = account.config.dmPolicy ?? \"allow\";\n      // Map \"allowlisted\" to \"allowlist\" for OpenClaw compatibility\n      const normalizedPolicy = policy === \"allowlisted\" ? \"allowlist\" : policy;\n\n      return {\n        policy: normalizedPolicy as \"allow\" | \"deny\" | \"allowlist\" | \"pairing\",\n        allowFrom: account.config.allowFrom ?? [],\n        policyPath: \"channels.webex.dmPolicy\",\n        allowFromPath: \"channels.webex.allowFrom\",\n        approveHint: \"Add user ID or email to channels.webex.allowFrom\",\n        normalizeEntry: (raw) => raw.trim().toLowerCase(),\n      };\n    },\n  },\n\n  threading: {\n    resolveReplyToMode: () => \"off\",\n    buildToolContext: ({ context, hasRepliedRef }) => ({\n      currentChannelId: context.To?.trim() || undefined,\n      currentThreadTs: context.MessageThreadId != null\n        ? String(context.MessageThreadId)\n        : context.ReplyToId,\n      hasRepliedRef,\n    }),\n  },\n\n  messaging: {\n    normalizeTarget: (raw: string) => {\n      let normalized = raw.trim();\n      if (!normalized) return undefined;\n      if (normalized.toLowerCase().startsWith(\"webex:\")) {\n        normalized = normalized.slice(\"webex:\".length).trim();\n      }\n      return normalized || undefined;\n    },\n    targetResolver: {\n      looksLikeId: (raw) => {\n        const trimmed = raw.trim();\n        if (!trimmed) return false;\n        // Webex IDs are base64-encoded and start with a specific prefix\n        if (trimmed.startsWith(\"Y2lzY29zcGFyazovL3\")) return true;\n        // Also accept emails\n        return trimmed.includes(\"@\");\n      },\n      hint: \"<roomId|personId|email>\",\n    },\n  },\n\n  outbound: {\n    deliveryMode: \"direct\",\n    textChunkLimit: 7000, // Webex has a 7439 byte limit\n\n    sendText: async ({ to, text, account, replyToId }) => {\n      const sender = new WebexSender(account.config);\n\n      const result = await sender.send({\n        to,\n        content: { text },\n        parentId: replyToId,\n      });\n\n      return {\n        channel: \"webex\",\n        messageId: result.id,\n        roomId: result.roomId,\n      };\n    },\n\n    sendMedia: async ({ to, text, mediaUrl, account, replyToId }) => {\n      const sender = new WebexSender(account.config);\n\n      const result = await sender.send({\n        to,\n        content: {\n          text,\n          files: mediaUrl ? [mediaUrl] : undefined,\n        },\n        parentId: replyToId,\n      });\n\n      return {\n        channel: \"webex\",\n        messageId: result.id,\n        roomId: result.roomId,\n      };\n    },\n  },\n\n  status: {\n    defaultRuntime: {\n      accountId: DEFAULT_ACCOUNT_ID,\n      running: false,\n      lastStartAt: null,\n      lastStopAt: null,\n      lastError: null,\n    },\n\n    collectStatusIssues: (accounts) =>\n      accounts.flatMap((account) => {\n        const lastError = typeof account.lastError === \"string\" ? account.lastError.trim() : \"\";\n        if (!lastError) return [];\n        return [\n          {\n            channel: \"webex\",\n            accountId: account.accountId,\n            kind: \"runtime\" as const,\n            message: `Channel error: ${lastError}`,\n          },\n        ];\n      }),\n\n    buildChannelSummary: ({ snapshot }) => ({\n      configured: (snapshot.configured ?? false) as boolean,\n      baseUrl: (snapshot.baseUrl ?? null) as string | null,\n      running: (snapshot.running ?? false) as boolean,\n      lastStartAt: (snapshot.lastStartAt ?? null) as Date | null,\n      lastStopAt: (snapshot.lastStopAt ?? null) as Date | null,\n      lastError: (snapshot.lastError ?? null) as string | null,\n    }),\n\n    probeAccount: async ({ account, timeoutMs }) => {\n      if (!account.configured) {\n        return {\n          ok: false,\n          error: \"Account not configured\",\n          elapsedMs: 0,\n        };\n      }\n\n      const start = Date.now();\n      try {\n        const response = await fetch(\n          `${account.config.apiBaseUrl ?? \"https://webexapis.com/v1\"}/people/me`,\n          {\n            method: \"GET\",\n            headers: {\n              Authorization: `Bearer ${account.config.token}`,\n              \"Content-Type\": \"application/json\",\n            },\n            signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,\n          }\n        );\n\n        const elapsedMs = Date.now() - start;\n\n        if (!response.ok) {\n          return {\n            ok: false,\n            error: `HTTP ${response.status}: ${response.statusText}`,\n            elapsedMs,\n          };\n        }\n\n        return { ok: true, elapsedMs };\n      } catch (err) {\n        return {\n          ok: false,\n          error: err instanceof Error ? err.message : String(err),\n          elapsedMs: Date.now() - start,\n        };\n      }\n    },\n\n    buildAccountSnapshot: ({ account, runtime, probe }) => ({\n      accountId: account.accountId,\n      name: account.name,\n      enabled: account.enabled,\n      configured: account.configured,\n      baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n      running: runtime?.running ?? false,\n      lastStartAt: runtime?.lastStartAt ?? null,\n      lastStopAt: runtime?.lastStopAt ?? null,\n      lastError: runtime?.lastError ?? null,\n      probe,\n      lastProbeAt: runtime?.lastProbeAt ?? null,\n    }),\n  },\n\n  gateway: {\n    startAccount: async (ctx) => {\n      const { account, runtime, log, setStatus } = ctx;\n\n      setStatus({\n        accountId: account.accountId,\n        baseUrl: account.config.apiBaseUrl ?? \"https://webexapis.com/v1\",\n      });\n\n      log?.info?.(\n        `[${account.accountId}] starting Webex provider (webhook mode)`\n      );\n\n      // Initialize webhook handler\n      const webhookHandler = new WebexWebhookHandler(account.config);\n      await webhookHandler.initialize();\n\n      // Register webhooks with Webex\n      try {\n        await webhookHandler.registerWebhooks();\n        log?.info?.(`[${account.accountId}] webhooks registered`);\n      } catch (err) {\n        log?.warn?.(\n          `[${account.accountId}] failed to register webhooks: ${err instanceof Error ? err.message : err}`\n        );\n      }\n\n      // Register webhook target for HTTP handler\n      const webhookPath = `/webhooks/webex/${account.accountId}`;\n\n      const unregister = registerWebexWebhookTarget(webhookPath, {\n        account,\n        config: account.config,\n        webhookHandler,\n      });\n\n      log?.info?.(\n        `[${account.accountId}] HTTP webhook handler registered at ${webhookPath}`\n      );\n\n      // Return cleanup function\n      return async () => {\n        log?.info?.(`[${account.accountId}] stopping Webex provider`);\n        unregister();\n      };\n    },\n  },\n};\n"]}

package/dist/plugin.js

@@ -16,8 +16,11 @@ const channel_plugin_1 = require("./channel-plugin");
  * It registers the Webex channel with the plugin system.
  */
 function register(api) {
+    // Store the plugin runtime for use in HTTP handlers
+    (0, channel_plugin_1.setPluginRuntime)(api.runtime);
     api.registerChannel({ plugin: channel_plugin_1.webexPlugin });
+    api.registerHttpHandler((0, channel_plugin_1.createWebhookHandler)());
 }
 // Export the plugin ID for reference
 exports.id = "webex";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7O0dBS0c7OztBQVdILDJCQUVDO0FBVkQscURBQStDO0FBRS9DOzs7OztHQUtHO0FBQ0gsU0FBd0IsUUFBUSxDQUFDLEdBQXNCO0lBQ3JELEdBQUcsQ0FBQyxlQUFlLENBQUMsRUFBRSxNQUFNLEVBQUUsNEJBQVcsRUFBRSxDQUFDLENBQUM7QUFDL0MsQ0FBQztBQUVELHFDQUFxQztBQUN4QixRQUFBLEVBQUUsR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE9wZW5DbGF3IFdlYmV4IENoYW5uZWwgUGx1Z2luXG4gKlxuICogTWFpbiBlbnRyeSBwb2ludCBmb3IgdGhlIE9wZW5DbGF3IHBsdWdpbiBzeXN0ZW0uXG4gKiBFeHBvcnRzIGEgZGVmYXVsdCBmdW5jdGlvbiB0aGF0IHJlZ2lzdGVycyB0aGUgV2ViZXggY2hhbm5lbC5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IE9wZW5DbGF3UGx1Z2luQXBpIH0gZnJvbSBcIm9wZW5jbGF3L3BsdWdpbi1zZGtcIjtcbmltcG9ydCB7IHdlYmV4UGx1Z2luIH0gZnJvbSBcIi4vY2hhbm5lbC1wbHVnaW5cIjtcblxuLyoqXG4gKiBPcGVuQ2xhdyBwbHVnaW4gcmVnaXN0cmF0aW9uIGZ1bmN0aW9uLlxuICpcbiAqIFRoaXMgaXMgdGhlIGVudHJ5IHBvaW50IHRoYXQgT3BlbkNsYXcgY2FsbHMgd2hlbiBsb2FkaW5nIHRoZSBwbHVnaW4uXG4gKiBJdCByZWdpc3RlcnMgdGhlIFdlYmV4IGNoYW5uZWwgd2l0aCB0aGUgcGx1Z2luIHN5c3RlbS5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gcmVnaXN0ZXIoYXBpOiBPcGVuQ2xhd1BsdWdpbkFwaSk6IHZvaWQge1xuICBhcGkucmVnaXN0ZXJDaGFubmVsKHsgcGx1Z2luOiB3ZWJleFBsdWdpbiB9KTtcbn1cblxuLy8gRXhwb3J0IHRoZSBwbHVnaW4gSUQgZm9yIHJlZmVyZW5jZVxuZXhwb3J0IGNvbnN0IGlkID0gXCJ3ZWJleFwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7O0dBS0c7OztBQVdILDJCQU1DO0FBZEQscURBQXVGO0FBRXZGOzs7OztHQUtHO0FBQ0gsU0FBd0IsUUFBUSxDQUFDLEdBQXNCO0lBQ3JELG9EQUFvRDtJQUNwRCxJQUFBLGlDQUFnQixFQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUU5QixHQUFHLENBQUMsZUFBZSxDQUFDLEVBQUUsTUFBTSxFQUFFLDRCQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQzdDLEdBQUcsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFBLHFDQUFvQixHQUFFLENBQUMsQ0FBQztBQUNsRCxDQUFDO0FBRUQscUNBQXFDO0FBQ3hCLFFBQUEsRUFBRSxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogT3BlbkNsYXcgV2ViZXggQ2hhbm5lbCBQbHVnaW5cbiAqXG4gKiBNYWluIGVudHJ5IHBvaW50IGZvciB0aGUgT3BlbkNsYXcgcGx1Z2luIHN5c3RlbS5cbiAqIEV4cG9ydHMgYSBkZWZhdWx0IGZ1bmN0aW9uIHRoYXQgcmVnaXN0ZXJzIHRoZSBXZWJleCBjaGFubmVsLlxuICovXG5cbmltcG9ydCB0eXBlIHsgT3BlbkNsYXdQbHVnaW5BcGkgfSBmcm9tIFwib3BlbmNsYXcvcGx1Z2luLXNka1wiO1xuaW1wb3J0IHsgd2ViZXhQbHVnaW4sIGNyZWF0ZVdlYmhvb2tIYW5kbGVyLCBzZXRQbHVnaW5SdW50aW1lIH0gZnJvbSBcIi4vY2hhbm5lbC1wbHVnaW5cIjtcblxuLyoqXG4gKiBPcGVuQ2xhdyBwbHVnaW4gcmVnaXN0cmF0aW9uIGZ1bmN0aW9uLlxuICpcbiAqIFRoaXMgaXMgdGhlIGVudHJ5IHBvaW50IHRoYXQgT3BlbkNsYXcgY2FsbHMgd2hlbiBsb2FkaW5nIHRoZSBwbHVnaW4uXG4gKiBJdCByZWdpc3RlcnMgdGhlIFdlYmV4IGNoYW5uZWwgd2l0aCB0aGUgcGx1Z2luIHN5c3RlbS5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gcmVnaXN0ZXIoYXBpOiBPcGVuQ2xhd1BsdWdpbkFwaSk6IHZvaWQge1xuICAvLyBTdG9yZSB0aGUgcGx1Z2luIHJ1bnRpbWUgZm9yIHVzZSBpbiBIVFRQIGhhbmRsZXJzXG4gIHNldFBsdWdpblJ1bnRpbWUoYXBpLnJ1bnRpbWUpO1xuICBcbiAgYXBpLnJlZ2lzdGVyQ2hhbm5lbCh7IHBsdWdpbjogd2ViZXhQbHVnaW4gfSk7XG4gIGFwaS5yZWdpc3Rlckh0dHBIYW5kbGVyKGNyZWF0ZVdlYmhvb2tIYW5kbGVyKCkpO1xufVxuXG4vLyBFeHBvcnQgdGhlIHBsdWdpbiBJRCBmb3IgcmVmZXJlbmNlXG5leHBvcnQgY29uc3QgaWQgPSBcIndlYmV4XCI7XG4iXX0=

package/dist/send.js

@@ -112,12 +112,23 @@ class WebexSender {
             request.toPersonEmail = to;
         }
         else if (to.startsWith('Y2lzY29zcGFyazovL3')) {
-            // Base64-encoded Webex IDs start with this prefix
-            if (to.includes('ROOM')) {
-                request.roomId = to;
+            // Base64-encoded Webex IDs - decode to check type
+            try {
+                const decoded = Buffer.from(to, 'base64').toString('utf-8');
+                if (decoded.includes('/ROOM/')) {
+                    request.roomId = to;
+                }
+                else if (decoded.includes('/PEOPLE/')) {
+                    request.toPersonId = to;
+                }
+                else {
+                    // Default to roomId for other types
+                    request.roomId = to;
+                }
             }
-            else {
-                request.toPersonId = to;
+            catch {
+                // If decode fails, assume it's a roomId
+                request.roomId = to;
             }
         }
         else {
@@ -301,4 +312,4 @@ class WebexApiRequestError extends Error {
     }
 }
 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"]}
+//# 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 - decode to check type\n      try {\n        const decoded = Buffer.from(to, 'base64').toString('utf-8');\n        if (decoded.includes('/ROOM/')) {\n          request.roomId = to;\n        } else if (decoded.includes('/PEOPLE/')) {\n          request.toPersonId = to;\n        } else {\n          // Default to roomId for other types\n          request.roomId = to;\n        }\n      } catch {\n        // If decode fails, assume it's a roomId\n        request.roomId = 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/openclaw.plugin.json

@@ -6,28 +6,90 @@
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
-    "properties": {}
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "description": "Enable the Webex channel",
+        "default": false
+      },
+      "token": {
+        "type": "string",
+        "description": "Webex bot access token from developer.webex.com"
+      },
+      "webhookUrl": {
+        "type": "string",
+        "description": "Public URL for receiving Webex webhooks"
+      },
+      "webhookSecret": {
+        "type": "string",
+        "description": "Secret for verifying webhook signatures (recommended)"
+      },
+      "dmPolicy": {
+        "type": "string",
+        "enum": ["allow", "deny", "allowlisted", "pairing"],
+        "description": "Policy for handling direct messages",
+        "default": "deny"
+      },
+      "allowFrom": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "List of allowed person IDs or emails (when dmPolicy is allowlisted)"
+      },
+      "apiBaseUrl": {
+        "type": "string",
+        "description": "Custom Webex API base URL",
+        "default": "https://webexapis.com/v1"
+      },
+      "maxRetries": {
+        "type": "number",
+        "description": "Maximum retry attempts for failed API calls",
+        "default": 3
+      },
+      "retryDelayMs": {
+        "type": "number",
+        "description": "Delay between retries in milliseconds",
+        "default": 1000
+      }
+    },
+    "required": ["token", "webhookUrl"]
   },
   "uiHints": {
     "token": {
       "label": "Bot Access Token",
       "sensitive": true,
-      "placeholder": "Your Webex bot token"
+      "placeholder": "Your Webex bot token from developer.webex.com"
     },
     "webhookUrl": {
       "label": "Webhook URL",
-      "placeholder": "https://your-domain.com/webhooks/webex"
+      "placeholder": "https://your-domain.com/webhooks/webex/default"
     },
     "webhookSecret": {
       "label": "Webhook Secret",
       "sensitive": true,
-      "placeholder": "Optional secret for webhook verification"
+      "placeholder": "Strong random secret for webhook verification"
     },
     "dmPolicy": {
-      "label": "DM Policy"
+      "label": "DM Policy",
+      "options": [
+        { "value": "allow", "label": "Allow all" },
+        { "value": "deny", "label": "Deny all" },
+        { "value": "allowlisted", "label": "Allowlist only" },
+        { "value": "pairing", "label": "Pairing required" }
+      ]
     },
     "allowFrom": {
-      "label": "Allowed Senders"
+      "label": "Allowed Senders",
+      "placeholder": "Person ID or email address"
+    },
+    "apiBaseUrl": {
+      "label": "API Base URL",
+      "placeholder": "https://webexapis.com/v1"
+    },
+    "maxRetries": {
+      "label": "Max Retries"
+    },
+    "retryDelayMs": {
+      "label": "Retry Delay (ms)"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jimiford/webex",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenClaw channel plugin for Cisco Webex messaging",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",