@daolmedo/openclaw-twilio-whatsapp 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/channels/plugins/types.plugin.js").ChannelConfigSchema;
+    register: (api: import("openclaw/plugins/types.js").OpenClawPluginApi) => void;
+    channelPlugin: import("openclaw/plugin-sdk/channel-core.js").ChannelPlugin<import("./src/accounts.js").ResolvedTwilioAccount>;
+    setChannelRuntime?: (runtime: import("openclaw/plugin-sdk/channel-core.js").PluginRuntime) => void;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,333 @@
+// index.ts
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core.js";
+
+// src/accounts.ts
+var getChannelConfig = (cfg) => cfg.channels && cfg.channels["twilio-whatsapp"] ? cfg.channels["twilio-whatsapp"] : void 0;
+function listTwilioAccountIds(cfg) {
+  const ch = getChannelConfig(cfg);
+  return Object.keys(ch?.accounts ?? {});
+}
+function resolveTwilioAccount(cfg, accountId) {
+  const ch = getChannelConfig(cfg);
+  const id = accountId ?? "default";
+  const entry = ch?.accounts?.[id];
+  if (!entry) {
+    throw new Error(
+      `[twilio-whatsapp] No account configured for accountId="${id}". Add channels.twilio-whatsapp.accounts.${id} to openclaw.json.`
+    );
+  }
+  return {
+    accountId: id,
+    accountSid: entry.accountSid,
+    authToken: entry.authToken,
+    phoneNumber: entry.phoneNumber
+  };
+}
+function findTwilioAccountByPhoneNumber(cfg, phoneNumber) {
+  const ch = getChannelConfig(cfg);
+  if (!ch?.accounts) return void 0;
+  for (const [id, entry] of Object.entries(ch.accounts)) {
+    const normalized = normalizePhoneNumber(entry.phoneNumber);
+    if (normalized === normalizePhoneNumber(phoneNumber)) {
+      return { accountId: id, ...entry };
+    }
+  }
+  return void 0;
+}
+function normalizePhoneNumber(phone) {
+  return phone.replace(/^whatsapp:/, "").replace(/\s+/g, "");
+}
+
+// src/send.ts
+import twilio from "twilio";
+async function sendTwilioWhatsappMessage(opts) {
+  const client = twilio(opts.accountSid, opts.authToken);
+  const from = opts.from.startsWith("whatsapp:") ? opts.from : `whatsapp:${opts.from}`;
+  const to = opts.to.startsWith("whatsapp:") ? opts.to : `whatsapp:${opts.to}`;
+  const msg = await client.messages.create({
+    from,
+    to,
+    ...opts.body ? { body: opts.body } : {},
+    ...opts.mediaUrl ? { mediaUrl: [opts.mediaUrl] } : {}
+  });
+  return msg.sid;
+}
+
+// src/outbound-adapter.ts
+async function deliver(ctx) {
+  const account = resolveTwilioAccount(ctx.cfg, ctx.accountId);
+  const sid = await sendTwilioWhatsappMessage({
+    accountSid: account.accountSid,
+    authToken: account.authToken,
+    from: account.phoneNumber,
+    to: ctx.to,
+    body: ctx.text || void 0,
+    mediaUrl: ctx.mediaUrl
+  });
+  return sid;
+}
+var twilioWhatsappOutbound = {
+  deliveryMode: "direct",
+  async sendText(ctx) {
+    const messageId = await deliver(ctx);
+    return {
+      channel: "twilio-whatsapp",
+      messageId
+    };
+  },
+  async sendMedia(ctx) {
+    const messageId = await deliver(ctx);
+    return {
+      channel: "twilio-whatsapp",
+      messageId
+    };
+  }
+};
+
+// src/runtime-store.ts
+var phoneToRuntime = /* @__PURE__ */ new Map();
+function setRuntimeForPhoneNumber(phoneNumber, runtime) {
+  phoneToRuntime.set(phoneNumber, runtime);
+}
+function clearRuntimeForPhoneNumber(phoneNumber) {
+  phoneToRuntime.delete(phoneNumber);
+}
+function getRuntimeForPhoneNumber(phoneNumber) {
+  return phoneToRuntime.get(phoneNumber);
+}
+
+// src/channel.ts
+var twilioWhatsappPlugin = {
+  id: "twilio-whatsapp",
+  meta: {
+    id: "twilio-whatsapp",
+    label: "Twilio WhatsApp",
+    selectionLabel: "WhatsApp (Twilio)",
+    docsPath: "/channels/twilio-whatsapp",
+    blurb: "WhatsApp messaging via Twilio Business API",
+    markdownCapable: false,
+    showInSetup: true,
+    showConfigured: true
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    media: true
+  },
+  config: {
+    listAccountIds: listTwilioAccountIds,
+    resolveAccount(cfg, accountId) {
+      return resolveTwilioAccount(cfg, accountId);
+    },
+    isConfigured(account) {
+      return Boolean(account.accountSid && account.authToken && account.phoneNumber);
+    },
+    describeAccount(account) {
+      return {
+        accountId: account.accountId,
+        configured: Boolean(account.accountSid && account.authToken && account.phoneNumber),
+        name: `WhatsApp ${account.phoneNumber}`
+      };
+    },
+    hasConfiguredState({ cfg }) {
+      return listTwilioAccountIds(cfg).length > 0;
+    }
+  },
+  outbound: twilioWhatsappOutbound,
+  gateway: {
+    async startAccount(ctx) {
+      const account = ctx.account;
+      const phoneNumber = normalizePhoneNumber(account.phoneNumber);
+      if (!ctx.channelRuntime) {
+        console.error(
+          `[twilio-whatsapp] channelRuntime not provided for account ${ctx.accountId}. Inbound dispatch will not work.`
+        );
+        return;
+      }
+      setRuntimeForPhoneNumber(phoneNumber, {
+        cfg: ctx.cfg,
+        accountId: ctx.accountId,
+        channelRuntime: ctx.channelRuntime
+      });
+      ctx.setStatus({
+        accountId: ctx.accountId,
+        running: true,
+        connected: true,
+        configured: true,
+        name: `WhatsApp ${account.phoneNumber}`,
+        webhookPath: "/twilio/whatsapp/events"
+      });
+      console.log(
+        `[twilio-whatsapp] Account ${ctx.accountId} started, listening on /twilio/whatsapp/events for ${account.phoneNumber}`
+      );
+      await new Promise((_, reject) => {
+        ctx.abortSignal.addEventListener("abort", () => reject(new Error("aborted")));
+      }).catch(() => {
+        clearRuntimeForPhoneNumber(phoneNumber);
+        ctx.setStatus({
+          accountId: ctx.accountId,
+          running: false,
+          connected: false
+        });
+        console.log(`[twilio-whatsapp] Account ${ctx.accountId} stopped`);
+      });
+    }
+  }
+};
+
+// src/http-routes.ts
+import { dispatchInboundDirectDmWithRuntime } from "openclaw/plugin-sdk/direct-dm.js";
+
+// src/webhook.ts
+import twilio2 from "twilio";
+function verifyTwilioSignature(params) {
+  try {
+    const parsed = Object.fromEntries(new URLSearchParams(params.rawBody));
+    return twilio2.validateRequest(params.authToken, params.signature, params.url, parsed);
+  } catch {
+    return false;
+  }
+}
+function parseTwilioWebhook(rawBody) {
+  const p = Object.fromEntries(new URLSearchParams(rawBody));
+  const numMedia = parseInt(p["NumMedia"] ?? "0", 10);
+  const media = Array.from({ length: numMedia }, (_, i) => ({
+    url: p[`MediaUrl${i}`] ?? "",
+    contentType: p[`MediaContentType${i}`] ?? "application/octet-stream"
+  }));
+  return {
+    from: (p["From"] ?? "").replace("whatsapp:", ""),
+    to: (p["To"] ?? "").replace("whatsapp:", ""),
+    body: p["Body"] ?? "",
+    waId: p["WaId"] ?? "",
+    profileName: p["ProfileName"] ?? "",
+    messageSid: p["MessageSid"] ?? "",
+    media,
+    repliedToSid: p["OriginalRepliedMessageSid"]
+  };
+}
+
+// src/http-routes.ts
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function twimlOk(res) {
+  res.writeHead(200, { "Content-Type": "text/xml; charset=utf-8" });
+  res.end('<?xml version="1.0" encoding="UTF-8"?><Response/>');
+}
+function twimlError(res, status, message) {
+  res.writeHead(status, { "Content-Type": "text/xml; charset=utf-8" });
+  res.end(
+    `<?xml version="1.0" encoding="UTF-8"?><Response><Message>${message}</Message></Response>`
+  );
+}
+function registerTwilioWhatsappHttpRoutes(api) {
+  api.registerHttpRoute({
+    path: "/twilio/whatsapp/events",
+    auth: "plugin",
+    handler: async (req, res) => {
+      const rawBody = await readBody(req);
+      const headers = req.headers;
+      const signature = String(headers["x-twilio-signature"] ?? "");
+      const webhookUrl = String(headers["x-twilio-webhook-url"] ?? "");
+      const fields = parseTwilioWebhook(rawBody);
+      const toPhone = normalizePhoneNumber(fields.to);
+      const stored = getRuntimeForPhoneNumber(toPhone);
+      if (!stored) {
+        console.error(`[twilio-whatsapp] No runtime found for To=${fields.to}`);
+        twimlError(res, 404, "No agent bound to this number");
+        return true;
+      }
+      const account = findTwilioAccountByPhoneNumber(stored.cfg, toPhone);
+      if (!account) {
+        console.error(`[twilio-whatsapp] Account not found for phone=${toPhone}`);
+        twimlError(res, 404, "Account not found");
+        return true;
+      }
+      if (webhookUrl && signature) {
+        const valid = verifyTwilioSignature({
+          authToken: account.authToken,
+          signature,
+          url: webhookUrl,
+          rawBody
+        });
+        if (!valid) {
+          console.error("[twilio-whatsapp] Invalid Twilio signature");
+          twimlError(res, 403, "Forbidden");
+          return true;
+        }
+      } else {
+        console.warn("[twilio-whatsapp] Skipping sig verification \u2014 headers missing");
+      }
+      const fromPhone = normalizePhoneNumber(fields.from);
+      const senderAddress = `whatsapp:${fromPhone}`;
+      const recipientAddress = `whatsapp:${toPhone}`;
+      const conversationLabel = fields.profileName || fromPhone;
+      const messageText = fields.body.trim();
+      const hasMedia = fields.media.length > 0;
+      if (!messageText && !hasMedia) {
+        twimlOk(res);
+        return true;
+      }
+      const bodyForAgent = hasMedia ? [messageText, ...fields.media.map((m) => `[Media: ${m.url}]`)].filter(Boolean).join("\n") : messageText;
+      twimlOk(res);
+      dispatchInboundDirectDmWithRuntime({
+        cfg: stored.cfg,
+        runtime: { channel: stored.channelRuntime },
+        channel: "twilio-whatsapp",
+        channelLabel: "WhatsApp",
+        accountId: account.accountId,
+        peer: { kind: "direct", id: fromPhone },
+        senderId: fromPhone,
+        senderAddress,
+        recipientAddress,
+        conversationLabel,
+        rawBody: messageText,
+        bodyForAgent,
+        messageId: fields.messageSid,
+        timestamp: Date.now(),
+        commandAuthorized: true,
+        deliver: async (payload) => {
+          const text = payload.text ?? "";
+          const mediaUrl = payload.mediaUrl ?? payload.mediaUrls?.[0];
+          if (!text && !mediaUrl) return;
+          await sendTwilioWhatsappMessage({
+            accountSid: account.accountSid,
+            authToken: account.authToken,
+            from: toPhone,
+            to: fromPhone,
+            body: text || void 0,
+            mediaUrl
+          });
+        },
+        onRecordError: (err) => {
+          console.error("[twilio-whatsapp] Session record error:", err);
+        },
+        onDispatchError: (err, info) => {
+          console.error(`[twilio-whatsapp] Dispatch error (${info.kind}):`, err);
+        }
+      }).catch((err) => {
+        console.error("[twilio-whatsapp] Unhandled dispatch error:", err);
+      });
+      return true;
+    }
+  });
+}
+
+// index.ts
+var index_default = defineChannelPluginEntry({
+  id: "twilio-whatsapp",
+  name: "Twilio WhatsApp",
+  description: "WhatsApp channel via Twilio Business API (ISV)",
+  plugin: twilioWhatsappPlugin,
+  registerFull(api) {
+    registerTwilioWhatsappHttpRoutes(api);
+  }
+});
+export {
+  index_default as default
+};

package/dist/src/accounts.d.ts

@@ -0,0 +1,11 @@
+import type { OpenClawConfig } from "openclaw/channels/plugins/types.js";
+export type ResolvedTwilioAccount = {
+    accountId: string;
+    accountSid: string;
+    authToken: string;
+    phoneNumber: string;
+};
+export declare function listTwilioAccountIds(cfg: OpenClawConfig): string[];
+export declare function resolveTwilioAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedTwilioAccount;
+export declare function findTwilioAccountByPhoneNumber(cfg: OpenClawConfig, phoneNumber: string): ResolvedTwilioAccount | undefined;
+export declare function normalizePhoneNumber(phone: string): string;

package/dist/src/accounts.js

@@ -0,0 +1,38 @@
+const getChannelConfig = (cfg) => cfg.channels &&
+    cfg.channels["twilio-whatsapp"]
+    ? cfg.channels["twilio-whatsapp"]
+    : undefined;
+export function listTwilioAccountIds(cfg) {
+    const ch = getChannelConfig(cfg);
+    return Object.keys(ch?.accounts ?? {});
+}
+export function resolveTwilioAccount(cfg, accountId) {
+    const ch = getChannelConfig(cfg);
+    const id = accountId ?? "default";
+    const entry = ch?.accounts?.[id];
+    if (!entry) {
+        throw new Error(`[twilio-whatsapp] No account configured for accountId="${id}". ` +
+            `Add channels.twilio-whatsapp.accounts.${id} to openclaw.json.`);
+    }
+    return {
+        accountId: id,
+        accountSid: entry.accountSid,
+        authToken: entry.authToken,
+        phoneNumber: entry.phoneNumber,
+    };
+}
+export function findTwilioAccountByPhoneNumber(cfg, phoneNumber) {
+    const ch = getChannelConfig(cfg);
+    if (!ch?.accounts)
+        return undefined;
+    for (const [id, entry] of Object.entries(ch.accounts)) {
+        const normalized = normalizePhoneNumber(entry.phoneNumber);
+        if (normalized === normalizePhoneNumber(phoneNumber)) {
+            return { accountId: id, ...entry };
+        }
+    }
+    return undefined;
+}
+export function normalizePhoneNumber(phone) {
+    return phone.replace(/^whatsapp:/, "").replace(/\s+/g, "");
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelPlugin } from "openclaw/channels/plugins/types.js";
+import { type ResolvedTwilioAccount } from "./accounts.js";
+export declare const twilioWhatsappPlugin: ChannelPlugin<ResolvedTwilioAccount>;

package/dist/src/channel.js

@@ -0,0 +1,76 @@
+import { listTwilioAccountIds, normalizePhoneNumber, resolveTwilioAccount, } from "./accounts.js";
+import { twilioWhatsappOutbound } from "./outbound-adapter.js";
+import { clearRuntimeForPhoneNumber, setRuntimeForPhoneNumber } from "./runtime-store.js";
+export const twilioWhatsappPlugin = {
+    id: "twilio-whatsapp",
+    meta: {
+        id: "twilio-whatsapp",
+        label: "Twilio WhatsApp",
+        selectionLabel: "WhatsApp (Twilio)",
+        docsPath: "/channels/twilio-whatsapp",
+        blurb: "WhatsApp messaging via Twilio Business API",
+        markdownCapable: false,
+        showInSetup: true,
+        showConfigured: true,
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        media: true,
+    },
+    config: {
+        listAccountIds: listTwilioAccountIds,
+        resolveAccount(cfg, accountId) {
+            return resolveTwilioAccount(cfg, accountId);
+        },
+        isConfigured(account) {
+            return Boolean(account.accountSid && account.authToken && account.phoneNumber);
+        },
+        describeAccount(account) {
+            return {
+                accountId: account.accountId,
+                configured: Boolean(account.accountSid && account.authToken && account.phoneNumber),
+                name: `WhatsApp ${account.phoneNumber}`,
+            };
+        },
+        hasConfiguredState({ cfg }) {
+            return listTwilioAccountIds(cfg).length > 0;
+        },
+    },
+    outbound: twilioWhatsappOutbound,
+    gateway: {
+        async startAccount(ctx) {
+            const account = ctx.account;
+            const phoneNumber = normalizePhoneNumber(account.phoneNumber);
+            if (!ctx.channelRuntime) {
+                console.error(`[twilio-whatsapp] channelRuntime not provided for account ${ctx.accountId}. ` +
+                    "Inbound dispatch will not work.");
+                return;
+            }
+            setRuntimeForPhoneNumber(phoneNumber, {
+                cfg: ctx.cfg,
+                accountId: ctx.accountId,
+                channelRuntime: ctx.channelRuntime,
+            });
+            ctx.setStatus({
+                accountId: ctx.accountId,
+                running: true,
+                connected: true,
+                configured: true,
+                name: `WhatsApp ${account.phoneNumber}`,
+                webhookPath: "/twilio/whatsapp/events",
+            });
+            console.log(`[twilio-whatsapp] Account ${ctx.accountId} started, listening on /twilio/whatsapp/events for ${account.phoneNumber}`);
+            await new Promise((_, reject) => {
+                ctx.abortSignal.addEventListener("abort", () => reject(new Error("aborted")));
+            }).catch(() => {
+                clearRuntimeForPhoneNumber(phoneNumber);
+                ctx.setStatus({
+                    accountId: ctx.accountId,
+                    running: false,
+                    connected: false,
+                });
+                console.log(`[twilio-whatsapp] Account ${ctx.accountId} stopped`);
+            });
+        },
+    },
+};

package/dist/src/http-routes.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugins/types.js";
+export declare function registerTwilioWhatsappHttpRoutes(api: OpenClawPluginApi): void;

package/dist/src/http-routes.js

@@ -0,0 +1,117 @@
+import { dispatchInboundDirectDmWithRuntime } from "openclaw/plugin-sdk/direct-dm.js";
+import { findTwilioAccountByPhoneNumber, normalizePhoneNumber, } from "./accounts.js";
+import { parseTwilioWebhook, verifyTwilioSignature } from "./webhook.js";
+import { sendTwilioWhatsappMessage } from "./send.js";
+import { getRuntimeForPhoneNumber } from "./runtime-store.js";
+async function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+function twimlOk(res) {
+    res.writeHead(200, { "Content-Type": "text/xml; charset=utf-8" });
+    res.end('<?xml version="1.0" encoding="UTF-8"?><Response/>');
+}
+function twimlError(res, status, message) {
+    res.writeHead(status, { "Content-Type": "text/xml; charset=utf-8" });
+    res.end(`<?xml version="1.0" encoding="UTF-8"?><Response><Message>${message}</Message></Response>`);
+}
+export function registerTwilioWhatsappHttpRoutes(api) {
+    api.registerHttpRoute({
+        path: "/twilio/whatsapp/events",
+        auth: "plugin",
+        handler: async (req, res) => {
+            const rawBody = await readBody(req);
+            const headers = req.headers;
+            const signature = String(headers["x-twilio-signature"] ?? "");
+            const webhookUrl = String(headers["x-twilio-webhook-url"] ?? "");
+            const fields = parseTwilioWebhook(rawBody);
+            const toPhone = normalizePhoneNumber(fields.to);
+            const stored = getRuntimeForPhoneNumber(toPhone);
+            if (!stored) {
+                console.error(`[twilio-whatsapp] No runtime found for To=${fields.to}`);
+                twimlError(res, 404, "No agent bound to this number");
+                return true;
+            }
+            const account = findTwilioAccountByPhoneNumber(stored.cfg, toPhone);
+            if (!account) {
+                console.error(`[twilio-whatsapp] Account not found for phone=${toPhone}`);
+                twimlError(res, 404, "Account not found");
+                return true;
+            }
+            if (webhookUrl && signature) {
+                const valid = verifyTwilioSignature({
+                    authToken: account.authToken,
+                    signature,
+                    url: webhookUrl,
+                    rawBody,
+                });
+                if (!valid) {
+                    console.error("[twilio-whatsapp] Invalid Twilio signature");
+                    twimlError(res, 403, "Forbidden");
+                    return true;
+                }
+            }
+            else {
+                console.warn("[twilio-whatsapp] Skipping sig verification — headers missing");
+            }
+            const fromPhone = normalizePhoneNumber(fields.from);
+            const senderAddress = `whatsapp:${fromPhone}`;
+            const recipientAddress = `whatsapp:${toPhone}`;
+            const conversationLabel = fields.profileName || fromPhone;
+            const messageText = fields.body.trim();
+            const hasMedia = fields.media.length > 0;
+            if (!messageText && !hasMedia) {
+                twimlOk(res);
+                return true;
+            }
+            const bodyForAgent = hasMedia
+                ? [messageText, ...fields.media.map((m) => `[Media: ${m.url}]`)].filter(Boolean).join("\n")
+                : messageText;
+            twimlOk(res);
+            dispatchInboundDirectDmWithRuntime({
+                cfg: stored.cfg,
+                runtime: { channel: stored.channelRuntime },
+                channel: "twilio-whatsapp",
+                channelLabel: "WhatsApp",
+                accountId: account.accountId,
+                peer: { kind: "direct", id: fromPhone },
+                senderId: fromPhone,
+                senderAddress,
+                recipientAddress,
+                conversationLabel,
+                rawBody: messageText,
+                bodyForAgent,
+                messageId: fields.messageSid,
+                timestamp: Date.now(),
+                commandAuthorized: true,
+                deliver: async (payload) => {
+                    const text = payload.text ?? "";
+                    const mediaUrl = payload.mediaUrl ?? payload.mediaUrls?.[0];
+                    if (!text && !mediaUrl)
+                        return;
+                    await sendTwilioWhatsappMessage({
+                        accountSid: account.accountSid,
+                        authToken: account.authToken,
+                        from: toPhone,
+                        to: fromPhone,
+                        body: text || undefined,
+                        mediaUrl,
+                    });
+                },
+                onRecordError: (err) => {
+                    console.error("[twilio-whatsapp] Session record error:", err);
+                },
+                onDispatchError: (err, info) => {
+                    console.error(`[twilio-whatsapp] Dispatch error (${info.kind}):`, err);
+                },
+            }).catch((err) => {
+                console.error("[twilio-whatsapp] Unhandled dispatch error:", err);
+            });
+            return true;
+        },
+    });
+}

package/dist/src/outbound-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelOutboundAdapter } from "openclaw/channels/plugins/types.adapters.js";
+export declare const twilioWhatsappOutbound: ChannelOutboundAdapter;

package/dist/src/outbound-adapter.js

@@ -0,0 +1,31 @@
+import { resolveTwilioAccount } from "./accounts.js";
+import { sendTwilioWhatsappMessage } from "./send.js";
+async function deliver(ctx) {
+    const account = resolveTwilioAccount(ctx.cfg, ctx.accountId);
+    const sid = await sendTwilioWhatsappMessage({
+        accountSid: account.accountSid,
+        authToken: account.authToken,
+        from: account.phoneNumber,
+        to: ctx.to,
+        body: ctx.text || undefined,
+        mediaUrl: ctx.mediaUrl,
+    });
+    return sid;
+}
+export const twilioWhatsappOutbound = {
+    deliveryMode: "direct",
+    async sendText(ctx) {
+        const messageId = await deliver(ctx);
+        return {
+            channel: "twilio-whatsapp",
+            messageId,
+        };
+    },
+    async sendMedia(ctx) {
+        const messageId = await deliver(ctx);
+        return {
+            channel: "twilio-whatsapp",
+            messageId,
+        };
+    },
+};

package/dist/src/runtime-store.d.ts

@@ -0,0 +1,9 @@
+import type { OpenClawConfig } from "openclaw/channels/plugins/types.js";
+export type StoredTwilioRuntime = {
+    cfg: OpenClawConfig;
+    accountId: string;
+    channelRuntime: NonNullable<import("openclaw/channels/plugins/types.adapters.js").ChannelGatewayContext["channelRuntime"]>;
+};
+export declare function setRuntimeForPhoneNumber(phoneNumber: string, runtime: StoredTwilioRuntime): void;
+export declare function clearRuntimeForPhoneNumber(phoneNumber: string): void;
+export declare function getRuntimeForPhoneNumber(phoneNumber: string): StoredTwilioRuntime | undefined;

package/dist/src/runtime-store.js

@@ -0,0 +1,10 @@
+const phoneToRuntime = new Map();
+export function setRuntimeForPhoneNumber(phoneNumber, runtime) {
+    phoneToRuntime.set(phoneNumber, runtime);
+}
+export function clearRuntimeForPhoneNumber(phoneNumber) {
+    phoneToRuntime.delete(phoneNumber);
+}
+export function getRuntimeForPhoneNumber(phoneNumber) {
+    return phoneToRuntime.get(phoneNumber);
+}

package/dist/src/send.d.ts

@@ -0,0 +1,8 @@
+export declare function sendTwilioWhatsappMessage(opts: {
+    accountSid: string;
+    authToken: string;
+    from: string;
+    to: string;
+    body?: string;
+    mediaUrl?: string;
+}): Promise<string>;

package/dist/src/send.js

@@ -0,0 +1,13 @@
+import twilio from "twilio";
+export async function sendTwilioWhatsappMessage(opts) {
+    const client = twilio(opts.accountSid, opts.authToken);
+    const from = opts.from.startsWith("whatsapp:") ? opts.from : `whatsapp:${opts.from}`;
+    const to = opts.to.startsWith("whatsapp:") ? opts.to : `whatsapp:${opts.to}`;
+    const msg = await client.messages.create({
+        from,
+        to,
+        ...(opts.body ? { body: opts.body } : {}),
+        ...(opts.mediaUrl ? { mediaUrl: [opts.mediaUrl] } : {}),
+    });
+    return msg.sid;
+}

package/dist/src/webhook.d.ts

@@ -0,0 +1,20 @@
+export type ParsedTwilioWebhook = {
+    from: string;
+    to: string;
+    body: string;
+    waId: string;
+    profileName: string;
+    messageSid: string;
+    media: Array<{
+        url: string;
+        contentType: string;
+    }>;
+    repliedToSid?: string;
+};
+export declare function verifyTwilioSignature(params: {
+    authToken: string;
+    signature: string;
+    url: string;
+    rawBody: string;
+}): boolean;
+export declare function parseTwilioWebhook(rawBody: string): ParsedTwilioWebhook;

package/dist/src/webhook.js

@@ -0,0 +1,28 @@
+import twilio from "twilio";
+export function verifyTwilioSignature(params) {
+    try {
+        const parsed = Object.fromEntries(new URLSearchParams(params.rawBody));
+        return twilio.validateRequest(params.authToken, params.signature, params.url, parsed);
+    }
+    catch {
+        return false;
+    }
+}
+export function parseTwilioWebhook(rawBody) {
+    const p = Object.fromEntries(new URLSearchParams(rawBody));
+    const numMedia = parseInt(p["NumMedia"] ?? "0", 10);
+    const media = Array.from({ length: numMedia }, (_, i) => ({
+        url: p[`MediaUrl${i}`] ?? "",
+        contentType: p[`MediaContentType${i}`] ?? "application/octet-stream",
+    }));
+    return {
+        from: (p["From"] ?? "").replace("whatsapp:", ""),
+        to: (p["To"] ?? "").replace("whatsapp:", ""),
+        body: p["Body"] ?? "",
+        waId: p["WaId"] ?? "",
+        profileName: p["ProfileName"] ?? "",
+        messageSid: p["MessageSid"] ?? "",
+        media,
+        repliedToSid: p["OriginalRepliedMessageSid"],
+    };
+}

package/openclaw.plugin.json

@@ -0,0 +1,42 @@
+{
+  "id": "twilio-whatsapp",
+  "name": "Twilio WhatsApp",
+  "description": "WhatsApp channel via Twilio Business API (ISV/WABA)",
+  "version": "1.0.0",
+  "channels": ["twilio-whatsapp"],
+  "channelConfigs": {
+    "twilio-whatsapp": {
+      "label": "Twilio WhatsApp",
+      "description": "WhatsApp messaging via Twilio ISV Business Account",
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "dmPolicy": { "type": "string" },
+          "allowFrom": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "accountSid": { "type": "string" },
+                "authToken": { "type": "string" },
+                "phoneNumber": { "type": "string" }
+              },
+              "required": ["accountSid", "authToken", "phoneNumber"]
+            }
+          }
+        }
+      }
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@daolmedo/openclaw-twilio-whatsapp",
+  "version": "1.0.0",
+  "description": "Twilio WhatsApp channel plugin for OpenClaw (Cody ISV)",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "build": "esbuild index.ts --bundle --platform=node --format=esm --external:openclaw --external:openclaw/* --external:twilio --outfile=dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "twilio": "^5.4.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.0",
+    "typescript": "^5.4.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "channel": {
+      "id": "twilio-whatsapp",
+      "label": "Twilio WhatsApp"
+    },
+    "install": {
+      "minHostVersion": ">=2026.3.24-beta.2"
+    }
+  }
+}