@jimiford/webex 0.1.1

package/dist/channel-plugin.js

@@ -0,0 +1,410 @@
+"use strict";
+/**
+ * OpenClaw Channel Plugin for Webex
+ *
+ * Implements the ChannelPlugin interface for OpenClaw's plugin system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webexPlugin = void 0;
+const send_1 = require("./send");
+const webhook_1 = require("./webhook");
+const DEFAULT_ACCOUNT_ID = "default";
+function listWebexAccountIds(cfg) {
+    const section = cfg.channels?.webex;
+    if (!section)
+        return [];
+    const ids = [];
+    // Check for top-level config (default account)
+    if (section.token) {
+        ids.push(DEFAULT_ACCOUNT_ID);
+    }
+    // Check for named accounts
+    if (section.accounts) {
+        for (const id of Object.keys(section.accounts)) {
+            if (id !== DEFAULT_ACCOUNT_ID) {
+                ids.push(id);
+            }
+        }
+    }
+    return ids;
+}
+function resolveWebexAccount(opts) {
+    const { cfg, accountId = DEFAULT_ACCOUNT_ID } = opts;
+    const section = cfg.channels?.webex;
+    if (!section) {
+        return {
+            accountId,
+            enabled: false,
+            configured: false,
+            config: {},
+        };
+    }
+    // Check for named account first
+    const namedAccount = section.accounts?.[accountId];
+    if (namedAccount) {
+        const token = namedAccount.token ?? section.token;
+        const webhookUrl = namedAccount.webhookUrl ?? section.webhookUrl;
+        return {
+            accountId,
+            name: namedAccount.name,
+            enabled: namedAccount.enabled !== false,
+            configured: Boolean(token && webhookUrl),
+            token,
+            webhookUrl,
+            config: {
+                token: token ?? "",
+                webhookUrl: webhookUrl ?? "",
+                webhookSecret: namedAccount.webhookSecret ?? section.webhookSecret,
+                dmPolicy: namedAccount.dmPolicy ?? section.dmPolicy ?? "allow",
+                allowFrom: namedAccount.allowFrom ?? section.allowFrom,
+                apiBaseUrl: namedAccount.apiBaseUrl ?? section.apiBaseUrl,
+                maxRetries: namedAccount.maxRetries ?? section.maxRetries,
+                retryDelayMs: namedAccount.retryDelayMs ?? section.retryDelayMs,
+            },
+        };
+    }
+    // Fall back to top-level config (default account)
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+            accountId,
+            name: section.name,
+            enabled: section.enabled !== false,
+            configured: Boolean(section.token && section.webhookUrl),
+            token: section.token,
+            webhookUrl: section.webhookUrl,
+            config: {
+                token: section.token ?? "",
+                webhookUrl: section.webhookUrl ?? "",
+                webhookSecret: section.webhookSecret,
+                dmPolicy: section.dmPolicy ?? "allow",
+                allowFrom: section.allowFrom,
+                apiBaseUrl: section.apiBaseUrl,
+                maxRetries: section.maxRetries,
+                retryDelayMs: section.retryDelayMs,
+            },
+        };
+    }
+    // Account not found
+    return {
+        accountId,
+        enabled: false,
+        configured: false,
+        config: {},
+    };
+}
+const meta = {
+    id: "webex",
+    label: "Webex",
+    selectionLabel: "Cisco Webex",
+    docsPath: "/channels/webex",
+    docsLabel: "webex",
+    blurb: "Cisco Webex messaging via bot webhooks.",
+    order: 75,
+    aliases: ["cisco-webex"],
+};
+exports.webexPlugin = {
+    id: "webex",
+    meta,
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        threads: true,
+        media: true,
+    },
+    reload: { configPrefixes: ["channels.webex"] },
+    config: {
+        listAccountIds: (cfg) => listWebexAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveWebexAccount({ cfg: cfg, accountId }),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, accountId, enabled }) => {
+            const config = cfg;
+            const section = config.channels?.webex ?? {};
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...config,
+                    channels: {
+                        ...config.channels,
+                        webex: {
+                            ...section,
+                            enabled,
+                        },
+                    },
+                };
+            }
+            return {
+                ...config,
+                channels: {
+                    ...config.channels,
+                    webex: {
+                        ...section,
+                        accounts: {
+                            ...section.accounts,
+                            [accountId]: {
+                                ...section.accounts?.[accountId],
+                                enabled,
+                            },
+                        },
+                    },
+                },
+            };
+        },
+        deleteAccount: ({ cfg, accountId }) => {
+            const config = cfg;
+            const section = config.channels?.webex ?? {};
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                const { token, webhookUrl, webhookSecret, dmPolicy, allowFrom, ...rest } = section;
+                return {
+                    ...config,
+                    channels: {
+                        ...config.channels,
+                        webex: rest,
+                    },
+                };
+            }
+            const accounts = { ...section.accounts };
+            delete accounts[accountId];
+            return {
+                ...config,
+                channels: {
+                    ...config.channels,
+                    webex: {
+                        ...section,
+                        accounts,
+                    },
+                },
+            };
+        },
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            baseUrl: account.config.apiBaseUrl ?? "https://webexapis.com/v1",
+        }),
+        resolveAllowFrom: ({ cfg }) => (cfg.channels?.webex?.allowFrom ?? []).map(String),
+        formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => entry.trim().toLowerCase()),
+    },
+    security: {
+        resolveDmPolicy: ({ account }) => {
+            const policy = account.config.dmPolicy ?? "allow";
+            // Map "allowlisted" to "allowlist" for OpenClaw compatibility
+            const normalizedPolicy = policy === "allowlisted" ? "allowlist" : policy;
+            return {
+                policy: normalizedPolicy,
+                allowFrom: account.config.allowFrom ?? [],
+                policyPath: "channels.webex.dmPolicy",
+                allowFromPath: "channels.webex.allowFrom",
+                approveHint: "Add user ID or email to channels.webex.allowFrom",
+                normalizeEntry: (raw) => raw.trim().toLowerCase(),
+            };
+        },
+    },
+    threading: {
+        resolveReplyToMode: () => "off",
+        buildToolContext: ({ context, hasRepliedRef }) => ({
+            currentChannelId: context.To?.trim() || undefined,
+            currentThreadTs: context.MessageThreadId != null
+                ? String(context.MessageThreadId)
+                : context.ReplyToId,
+            hasRepliedRef,
+        }),
+    },
+    messaging: {
+        normalizeTarget: (raw) => {
+            let normalized = raw.trim();
+            if (!normalized)
+                return undefined;
+            if (normalized.toLowerCase().startsWith("webex:")) {
+                normalized = normalized.slice("webex:".length).trim();
+            }
+            return normalized || undefined;
+        },
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return false;
+                // Webex IDs are base64-encoded and start with a specific prefix
+                if (trimmed.startsWith("Y2lzY29zcGFyazovL3"))
+                    return true;
+                // Also accept emails
+                return trimmed.includes("@");
+            },
+            hint: "<roomId|personId|email>",
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 7000, // Webex has a 7439 byte limit
+        sendText: async ({ to, text, account, replyToId }) => {
+            const sender = new send_1.WebexSender(account.config);
+            const result = await sender.send({
+                to,
+                content: { text },
+                parentId: replyToId,
+            });
+            return {
+                channel: "webex",
+                messageId: result.id,
+                roomId: result.roomId,
+            };
+        },
+        sendMedia: async ({ to, text, mediaUrl, account, replyToId }) => {
+            const sender = new send_1.WebexSender(account.config);
+            const result = await sender.send({
+                to,
+                content: {
+                    text,
+                    files: mediaUrl ? [mediaUrl] : undefined,
+                },
+                parentId: replyToId,
+            });
+            return {
+                channel: "webex",
+                messageId: result.id,
+                roomId: result.roomId,
+            };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+            const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+            if (!lastError)
+                return [];
+            return [
+                {
+                    channel: "webex",
+                    accountId: account.accountId,
+                    kind: "runtime",
+                    message: `Channel error: ${lastError}`,
+                },
+            ];
+        }),
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: (snapshot.configured ?? false),
+            baseUrl: (snapshot.baseUrl ?? null),
+            running: (snapshot.running ?? false),
+            lastStartAt: (snapshot.lastStartAt ?? null),
+            lastStopAt: (snapshot.lastStopAt ?? null),
+            lastError: (snapshot.lastError ?? null),
+        }),
+        probeAccount: async ({ account, timeoutMs }) => {
+            if (!account.configured) {
+                return {
+                    ok: false,
+                    error: "Account not configured",
+                    elapsedMs: 0,
+                };
+            }
+            const start = Date.now();
+            try {
+                const response = await fetch(`${account.config.apiBaseUrl ?? "https://webexapis.com/v1"}/people/me`, {
+                    method: "GET",
+                    headers: {
+                        Authorization: `Bearer ${account.config.token}`,
+                        "Content-Type": "application/json",
+                    },
+                    signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
+                });
+                const elapsedMs = Date.now() - start;
+                if (!response.ok) {
+                    return {
+                        ok: false,
+                        error: `HTTP ${response.status}: ${response.statusText}`,
+                        elapsedMs,
+                    };
+                }
+                return { ok: true, elapsedMs };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err.message : String(err),
+                    elapsedMs: Date.now() - start,
+                };
+            }
+        },
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            baseUrl: account.config.apiBaseUrl ?? "https://webexapis.com/v1",
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            probe,
+            lastProbeAt: runtime?.lastProbeAt ?? null,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { account, runtime, log, setStatus } = ctx;
+            setStatus({
+                accountId: account.accountId,
+                baseUrl: account.config.apiBaseUrl ?? "https://webexapis.com/v1",
+            });
+            log?.info?.(`[${account.accountId}] starting Webex provider (webhook mode)`);
+            // Initialize webhook handler
+            const webhookHandler = new webhook_1.WebexWebhookHandler(account.config);
+            await webhookHandler.initialize();
+            // Register webhooks with Webex
+            try {
+                await webhookHandler.registerWebhooks();
+                log?.info?.(`[${account.accountId}] webhooks registered`);
+            }
+            catch (err) {
+                log?.warn?.(`[${account.accountId}] failed to register webhooks: ${err instanceof Error ? err.message : err}`);
+            }
+            // Register HTTP handler for incoming webhooks
+            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" } };
+                    }
+                },
+            });
+            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);
+            };
+        },
+    },
+};
+//# 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"]}

package/dist/channel.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Webex Channel - Main Channel Logic
+ */
+import type { WebexChannelConfig, WebexChannelPlugin, WebexMessage, WebexWebhook, WebexWebhookPayload, OpenClawEnvelope, OpenClawOutboundMessage, WebhookHandler } from './types';
+import { WebexSender } from './send';
+import { WebexWebhookHandler } from './webhook';
+/**
+ * WebexChannel implements the OpenClaw channel plugin interface for Cisco Webex
+ */
+export declare class WebexChannel implements WebexChannelPlugin {
+    readonly name = "webex";
+    readonly version = "1.0.0";
+    private config;
+    private sender;
+    private webhookHandler;
+    private messageHandlers;
+    private initialized;
+    /**
+     * Initialize the channel with configuration
+     */
+    initialize(config: WebexChannelConfig): Promise<void>;
+    /**
+     * Validate configuration
+     */
+    private validateConfig;
+    /**
+     * Ensure the channel is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Send a message
+     */
+    send(message: OpenClawOutboundMessage): Promise<WebexMessage>;
+    /**
+     * Send a simple text message to a room
+     */
+    sendText(roomId: string, text: string): Promise<WebexMessage>;
+    /**
+     * Send a markdown message to a room
+     */
+    sendMarkdown(roomId: string, markdown: string): Promise<WebexMessage>;
+    /**
+     * Send a direct message to a person
+     */
+    sendDirect(personIdOrEmail: string, text: string): Promise<WebexMessage>;
+    /**
+     * Reply to a message in a thread
+     */
+    reply(roomId: string, parentId: string, text: string): Promise<WebexMessage>;
+    /**
+     * Handle incoming webhook
+     */
+    handleWebhook(payload: WebexWebhookPayload, signature?: string): Promise<OpenClawEnvelope | null>;
+    /**
+     * Register a message handler
+     */
+    onMessage(handler: WebhookHandler): void;
+    /**
+     * Remove a message handler
+     */
+    offMessage(handler: WebhookHandler): void;
+    /**
+     * Notify all registered handlers of a new message
+     */
+    private notifyHandlers;
+    /**
+     * Register webhooks with Webex
+     */
+    registerWebhooks(): Promise<WebexWebhook[]>;
+    /**
+     * Get the sender instance for advanced operations
+     */
+    getSender(): WebexSender;
+    /**
+     * Get the webhook handler instance for advanced operations
+     */
+    getWebhookHandler(): WebexWebhookHandler;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): WebexChannelConfig | null;
+    /**
+     * Check if the channel is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Cleanup and shutdown
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Create a new Webex channel instance
+ */
+export declare function createWebexChannel(): WebexChannel;
+/**
+ * Create and initialize a Webex channel with config
+ */
+export declare function createAndInitialize(config: WebexChannelConfig): Promise<WebexChannel>;