@emotion-machine/claw-messenger 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# @emotion-machine/claw-messenger
+
+iMessage, RCS & SMS channel plugin for [OpenClaw](https://openclaw.ai) — no phone or Mac Mini required. See [Claw Messenger](https://clawmessenger.com) for more details.
+
+## Install
+
+```bash
+openclaw plugins install @emotion-machine/claw-messenger
+```
+
+## Configuration
+
+After installing, add to your OpenClaw config under `channels`:
+
+```json5
+{
+  "channels": {
+    "claw-messenger": {
+      "accounts": {
+        "default": {
+          "enabled": true,
+          "apiKey": "cm_live_XXXXXXXX_YYYYYYYYYYYYYY",
+          "serverUrl": "wss://claw-messenger.onrender.com",
+          "preferredService": "iMessage",  // "iMessage" | "RCS" | "SMS"
+          "dmPolicy": "pairing",           // "open" | "pairing" | "allowlist"
+          "allowFrom": ["+15551234567"]    // only used with "allowlist" policy
+        }
+      }
+    }
+  }
+}
+```
+
+## Features
+
+- **Send & receive** text messages and media (images, video, audio, documents)
+- **iMessage reactions** — love, like, dislike, laugh, emphasize, question (tapback)
+- **Group chats** — send to existing groups or create new ones
+- **Typing indicators** — sent and received
+- **DM security policies** — open, pairing-based approval, or allowlist
+
+## Agent Tools
+
+The plugin registers two tools your agent can call:
+
+| Tool | Description |
+|------|-------------|
+| `claw_messenger_status` | Check connection status, server URL, and preferred service |
+| `claw_messenger_switch_service` | Switch the preferred messaging service at runtime |
+
+## Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/cm-status` | Show connection state, server URL, and preferred service |
+| `/cm-switch <service>` | Switch preferred service (`iMessage`, `RCS`, or `SMS`) |
+
+## Getting Started
+
+1. Sign up at [clawmessenger.com](https://clawmessenger.com)
+2. Create an API key from the dashboard
+3. Install the plugin: `openclaw plugins install @emotion-machine/claw-messenger`
+4. Add the config above with your API key
+5. Start a conversation — your agent can now send and receive messages
+
+## License
+
+UNLICENSED

package/dist/channel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Claw Messenger channel plugin — adapted from channel-linq.
+ * All Linq API interaction is replaced by WebSocket communication to claw-messenger.
+ */
+import { type ChannelPlugin } from "openclaw/plugin-sdk";
+import { type ClawMessengerConfig } from "./config.js";
+interface ResolvedAccount {
+    accountId: string;
+    enabled: boolean;
+    apiKey: string;
+    serverUrl: string;
+    preferredService: string;
+    config: ClawMessengerConfig;
+}
+export declare function getConnectionStatus(): {
+    connected: boolean;
+    serverUrl: string;
+    preferredService: string;
+    accountId: string;
+};
+export declare const clawMessengerPlugin: ChannelPlugin<ResolvedAccount>;
+export {};

package/dist/channel.js

@@ -0,0 +1,505 @@
+/**
+ * Claw Messenger channel plugin — adapted from channel-linq.
+ * All Linq API interaction is replaced by WebSocket communication to claw-messenger.
+ */
+import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, formatPairingApproveHint, normalizeE164, PAIRING_APPROVED_MESSAGE, } from "openclaw/plugin-sdk";
+import { ClawMessengerConfigSchema } from "./config.js";
+import { getRuntime } from "./runtime.js";
+import { WsClient } from "./ws/client.js";
+import { sendText, sendMedia, sendToGroup, sendGroupMedia, sendToNewGroup } from "./outbound/send.js";
+const EMOJI_TO_REACTION = {
+    "❤️": "love", "♥️": "love", "🩷": "love", "💕": "love", "😍": "love",
+    "👍": "like", "👍🏻": "like", "👍🏼": "like", "👍🏽": "like", "👍🏾": "like", "👍🏿": "like",
+    "👎": "dislike", "👎🏻": "dislike", "👎🏼": "dislike", "👎🏽": "dislike", "👎🏾": "dislike", "👎🏿": "dislike",
+    "😂": "laugh", "🤣": "laugh", "😆": "laugh",
+    "‼️": "emphasize", "❗": "emphasize", "❕": "emphasize", "⚡": "emphasize",
+    "❓": "question", "❔": "question", "🤔": "question",
+};
+function emojiToReaction(emoji) {
+    return EMOJI_TO_REACTION[emoji];
+}
+function resolveAccount(cfg, _accountId) {
+    const cloudConfig = (cfg.channels?.["claw-messenger"] ?? {});
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        enabled: cloudConfig.enabled !== false,
+        apiKey: cloudConfig.apiKey ?? "",
+        serverUrl: cloudConfig.serverUrl ?? "wss://claw-messenger.onrender.com",
+        preferredService: cloudConfig.preferredService ?? "iMessage",
+        config: cloudConfig,
+    };
+}
+// -- WS client per account --
+const wsClients = new Map();
+const lastMessageAt = new Map();
+// -- Connection status helper (used by tools & commands in index.ts) --
+export function getConnectionStatus() {
+    const runtime = getRuntime();
+    const cfg = runtime.config.loadConfig();
+    const account = resolveAccount(cfg);
+    const ws = wsClients.get(account.accountId);
+    return {
+        connected: Boolean(ws?.connected),
+        serverUrl: account.serverUrl,
+        preferredService: account.preferredService,
+        accountId: account.accountId,
+    };
+}
+// -- Channel Plugin --
+const meta = {
+    label: "Claw Messenger",
+    selectionLabel: "Claw Messenger (via claw-messenger proxy)",
+    detailLabel: "Claw Messenger",
+    docsPath: "/channels/claw-messenger",
+    docsLabel: "claw-messenger",
+    blurb: "iMessage, RCS & SMS without a Mac or Linq account — via shared claw-messenger proxy.",
+    systemImage: "message.fill",
+};
+export const clawMessengerPlugin = {
+    id: "claw-messenger",
+    meta: {
+        ...meta,
+        aliases: ["claw-messenger"],
+    },
+    pairing: {
+        idLabel: "phoneNumber",
+        notifyApproval: async ({ cfg, id }) => {
+            const account = resolveAccount(cfg);
+            const ws = wsClients.get(account.accountId);
+            if (!ws)
+                throw new Error("Not connected to claw-messenger");
+            await sendText(ws, id, PAIRING_APPROVED_MESSAGE, account.preferredService);
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        reactions: true,
+        threads: true,
+        media: true,
+        nativeCommands: false,
+        blockStreaming: true,
+    },
+    reload: { configPrefixes: ["channels.claw-messenger"] },
+    configSchema: buildChannelConfigSchema(ClawMessengerConfigSchema),
+    config: {
+        listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+        resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, enabled }) => {
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    "claw-messenger": {
+                        ...(cfg.channels?.["claw-messenger"] ?? {}),
+                        enabled,
+                    },
+                },
+            };
+        },
+        deleteAccount: ({ cfg }) => cfg,
+        isConfigured: (account) => Boolean(account.apiKey?.trim()),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: Boolean(account.apiKey?.trim()),
+            serverUrl: account.serverUrl,
+        }),
+        resolveAllowFrom: ({ cfg }) => (resolveAccount(cfg).config.allowFrom ?? []).map(String),
+        formatAllowFrom: ({ allowFrom }) => allowFrom.map((e) => String(e).trim()).filter(Boolean),
+    },
+    security: {
+        resolveDmPolicy: ({ account }) => ({
+            policy: account.config.dmPolicy ?? "pairing",
+            allowFrom: account.config.allowFrom ?? [],
+            policyPath: "channels.claw-messenger.dmPolicy",
+            allowFromPath: "channels.claw-messenger.",
+            approveHint: formatPairingApproveHint("claw-messenger"),
+        }),
+        collectWarnings: ({ cfg }) => {
+            const account = resolveAccount(cfg);
+            const warnings = [];
+            if (account.serverUrl && account.serverUrl.startsWith("ws://")) {
+                warnings.push("Server URL uses insecure ws:// — consider switching to wss://");
+            }
+            return warnings;
+        },
+    },
+    messaging: {
+        normalizeTarget: (target) => {
+            const trimmed = target.trim();
+            if (!trimmed)
+                return null;
+            const normalized = normalizeE164(trimmed);
+            return normalized ?? trimmed;
+        },
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw?.trim();
+                if (!trimmed)
+                    return false;
+                return /^\+?\d{10,15}$/.test(trimmed);
+            },
+            hint: "+1XXXXXXXXXX",
+        },
+    },
+    agentPrompt: {
+        messageToolHints: () => [
+            "You can react to messages using iMessage tapbacks via the react action. Available: love (❤️), like (👍), dislike (👎), laugh (😂), emphasize (‼️), question (❓).",
+            "Use reactions naturally — the way a real person would in iMessage.",
+        ],
+    },
+    actions: {
+        listActions: () => ["send", "react"],
+        handleAction: async ({ action, params, cfg }) => {
+            const account = resolveAccount(cfg);
+            const ws = wsClients.get(account.accountId);
+            if (!ws)
+                throw new Error("Not connected to claw-messenger");
+            if (action === "react") {
+                const messageId = params.messageId;
+                if (!messageId)
+                    throw new Error("messageId is required for react action");
+                const emoji = params.emoji?.trim() ?? "❤️";
+                const remove = params.remove === true;
+                const reactionType = emojiToReaction(emoji) ?? "love";
+                ws.send({
+                    type: "reaction",
+                    messageId,
+                    reactionType,
+                    remove,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ ok: true, action: remove ? "removed" : "added", reaction: reactionType }) }],
+                };
+            }
+            if (action === "send") {
+                const to = params.to;
+                const chatId = params.chatId;
+                const text = params.message ?? "";
+                const mediaUrl = params.media?.trim();
+                if (!text && !mediaUrl)
+                    throw new Error("message or media is required");
+                if (chatId) {
+                    // Send to existing group by chatId
+                    if (mediaUrl) {
+                        const result = await sendGroupMedia(ws, chatId, mediaUrl, text || undefined, account.preferredService);
+                        return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }] };
+                    }
+                    const result = await sendToGroup(ws, chatId, text, account.preferredService);
+                    return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }] };
+                }
+                else if (Array.isArray(to) && to.length > 1) {
+                    // Create new group
+                    const result = await sendToNewGroup(ws, to, text, account.preferredService);
+                    return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }] };
+                }
+                else {
+                    // DM send
+                    const target = (Array.isArray(to) ? to[0] : to)?.trim();
+                    if (!target)
+                        throw new Error("to is required");
+                    if (mediaUrl) {
+                        const result = await sendMedia(ws, target, mediaUrl, text || undefined, account.preferredService);
+                        return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }] };
+                    }
+                    const result = await sendText(ws, target, text, account.preferredService);
+                    return { content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }] };
+                }
+            }
+            throw new Error(`Action ${action} not supported`);
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getRuntime().channel.text.chunkText(text, limit),
+        chunkerMode: "text",
+        textChunkLimit: 10000,
+        sendText: async ({ to, text, cfg }) => {
+            if (!text?.trim())
+                return { channel: "claw-messenger", messageId: "", chatId: "" };
+            const account = resolveAccount(cfg);
+            const ws = wsClients.get(account.accountId);
+            if (!ws)
+                throw new Error("Not connected to claw-messenger");
+            const result = await sendText(ws, to, text, account.preferredService);
+            return { channel: "claw-messenger", ...result };
+        },
+        sendMedia: async ({ to, text, mediaUrl, cfg }) => {
+            const account = resolveAccount(cfg);
+            const ws = wsClients.get(account.accountId);
+            if (!ws)
+                throw new Error("Not connected to claw-messenger");
+            const result = await sendMedia(ws, to, mediaUrl, text || undefined, account.preferredService);
+            return { channel: "claw-messenger", ...result };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: (accounts) => {
+            if (!Array.isArray(accounts))
+                return [];
+            return accounts.flatMap((account) => {
+                const issues = [];
+                if (!account.configured) {
+                    issues.push({
+                        channel: "claw-messenger",
+                        accountId: account.accountId ?? "default",
+                        kind: "config",
+                        message: "API key not configured",
+                    });
+                }
+                return issues;
+            });
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+        }),
+        probeAccount: async ({ account }) => {
+            if (!account.apiKey)
+                return { ok: false, error: "No API key" };
+            const ws = wsClients.get(account.accountId);
+            return { ok: Boolean(ws?.connected), connected: Boolean(ws?.connected) };
+        },
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: Boolean(account.apiKey?.trim()),
+            serverUrl: account.serverUrl,
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            mode: "websocket",
+            probe,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const apiKey = account.apiKey?.trim();
+            const serverUrl = account.serverUrl?.trim();
+            const resolvedAccountId = account.accountId;
+            if (!apiKey)
+                throw new Error("API key not configured");
+            if (!serverUrl)
+                throw new Error("Server URL not configured");
+            const runtime = getRuntime();
+            const ws = new WsClient({
+                serverUrl,
+                apiKey,
+                onConnect: () => {
+                    ctx.log?.info(`[${resolvedAccountId}] Connected to claw-messenger`);
+                    // Send sync request to replay missed messages
+                    const since = lastMessageAt.get(resolvedAccountId);
+                    if (since) {
+                        try {
+                            ws.send({ type: "sync", since });
+                            ctx.log?.info(`[${resolvedAccountId}] Sent sync request (since=${since})`);
+                        }
+                        catch { }
+                    }
+                },
+                onDisconnect: () => {
+                    ctx.log?.warn?.(`[${resolvedAccountId}] Disconnected from claw-messenger`);
+                },
+                onMessage: async (data) => {
+                    if (data.type === "message") {
+                        // Track last message timestamp for sync on reconnect
+                        lastMessageAt.set(resolvedAccountId, new Date().toISOString());
+                        await handleInboundMessage(data, resolvedAccountId, account, ctx);
+                    }
+                    else if (data.type === "reaction") {
+                        const action = data.removed ? "removed" : "added";
+                        ctx.log?.info(`[${resolvedAccountId}] Reaction from ${data.from}: ${data.reactionType} on ${data.messageId} (${action})`);
+                    }
+                    else if (data.type === "typing") {
+                        const state = data.started ? "started" : "stopped";
+                        ctx.log?.info(`[${resolvedAccountId}] Typing ${state} from ${data.from}`);
+                    }
+                    else if (data.type === "status") {
+                        if (data.status === "failed") {
+                            ctx.log?.error?.(`[${resolvedAccountId}] Message ${data.messageId} status: ${data.status}`);
+                        }
+                        else {
+                            ctx.log?.info(`[${resolvedAccountId}] Message ${data.messageId} status: ${data.status}`);
+                        }
+                    }
+                    else if (data.type === "sync.done") {
+                        ctx.log?.info(`[${resolvedAccountId}] Sync complete: ${data.count} messages replayed`);
+                    }
+                    else if (data.type === "error") {
+                        ctx.log?.error?.(`[${resolvedAccountId}] Server error: ${data.message}`);
+                    }
+                },
+                log: (msg) => ctx.log?.debug?.(msg),
+            });
+            ws.connect();
+            wsClients.set(resolvedAccountId, ws);
+            // Handle abort
+            const stopHandler = () => {
+                ctx.log?.info(`[${resolvedAccountId}] Stopping Claw Messenger provider`);
+                ws.stop();
+                wsClients.delete(resolvedAccountId);
+            };
+            ctx.abortSignal?.addEventListener("abort", stopHandler);
+            return {
+                stop: () => {
+                    stopHandler();
+                    ctx.abortSignal?.removeEventListener("abort", stopHandler);
+                },
+            };
+        },
+        logoutAccount: async ({ cfg }) => {
+            const account = resolveAccount(cfg);
+            const ws = wsClients.get(account.accountId);
+            if (ws) {
+                ws.stop();
+                wsClients.delete(account.accountId);
+            }
+            return { cleared: false, loggedOut: true };
+        },
+    },
+};
+// -- Inbound message handler --
+async function handleInboundMessage(data, accountId, account, ctx) {
+    const from = data.from;
+    const text = data.text ?? "";
+    const messageId = data.messageId ?? "";
+    const attachments = data.attachments ?? [];
+    const isGroup = data.isGroup === true;
+    const chatId = data.chatId;
+    const participants = data.participants ?? [];
+    const runtime = getRuntime();
+    const cfg = runtime.config.loadConfig();
+    // Resolve routing — group by chatId, DM by sender phone
+    const route = runtime.channel.routing.resolveAgentRoute({
+        cfg,
+        channel: "claw-messenger",
+        accountId,
+        peer: isGroup
+            ? { kind: "group", id: chatId }
+            : { kind: "dm", id: from },
+    });
+    // Download media
+    const allMedia = [];
+    for (const attachment of attachments) {
+        try {
+            const saved = await runtime.channel.media.fetchRemoteMedia({ url: attachment.url });
+            const stored = await runtime.channel.media.saveMediaBuffer(saved.buffer, saved.contentType ?? attachment.mimeType, "inbound", 10 * 1024 * 1024);
+            allMedia.push({ path: stored.path, contentType: stored.contentType });
+        }
+        catch (err) {
+            ctx.log?.warn?.(`[${accountId}] Failed to download attachment: ${err}`);
+        }
+    }
+    // Build inbound envelope
+    const storePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: route.agentId,
+    });
+    const envelopeOptions = runtime.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const previousTimestamp = runtime.channel.session.readSessionUpdatedAt(storePath, route.sessionKey);
+    const rawBody = text || (allMedia.length > 0 ? "<media:image>" : "");
+    if (!rawBody)
+        return;
+    const body = runtime.channel.reply.formatInboundEnvelope({
+        channel: "Claw Messenger",
+        from,
+        timestamp: Date.now(),
+        body: rawBody,
+        chatType: isGroup ? "group" : "direct",
+        sender: { id: from },
+        previousTimestamp,
+        envelope: envelopeOptions,
+    });
+    const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+        Body: body,
+        RawBody: rawBody,
+        CommandBody: rawBody,
+        From: `claw-messenger:${from}`,
+        To: `claw-messenger:shared`,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: isGroup ? "group" : "direct",
+        ConversationLabel: isGroup ? chatId : from,
+        SenderId: from,
+        Provider: "claw-messenger",
+        Surface: "claw-messenger",
+        MessageSid: messageId,
+        Timestamp: Date.now(),
+        MediaPath: allMedia[0]?.path ?? "",
+        MediaType: allMedia[0]?.contentType,
+        MediaUrl: allMedia[0]?.path ?? "",
+        MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+        MediaUrls: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+        MediaTypes: allMedia.length > 0
+            ? allMedia.map((m) => m.contentType).filter((t) => Boolean(t))
+            : undefined,
+        OriginatingChannel: "claw-messenger",
+        OriginatingTo: isGroup ? `claw-messenger:group:${chatId}` : `claw-messenger:${from}`,
+    });
+    void runtime.channel.session.recordSessionMetaFromInbound({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        ctx: ctxPayload,
+    }).catch(() => { });
+    const ws = wsClients.get(accountId);
+    // Mark as read + start typing (DM only — skip for groups)
+    if (!isGroup && ws) {
+        ws.send({ type: "read", to: from });
+        ws.send({ type: "typing.start", to: from });
+    }
+    // Dispatch to auto-reply
+    try {
+        const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(cfg);
+        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+                responsePrefix: messagesConfig.responsePrefix,
+                deliver: async (payload) => {
+                    const replyText = payload.text ?? "";
+                    const mediaUrls = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+                    if (isGroup && chatId && ws) {
+                        // Group: send by chatId
+                        if (replyText) {
+                            await sendToGroup(ws, chatId, replyText, account.preferredService);
+                        }
+                        for (const url of mediaUrls) {
+                            await sendGroupMedia(ws, chatId, url, undefined, account.preferredService);
+                        }
+                    }
+                    else if (ws) {
+                        // DM: send by phone
+                        if (replyText) {
+                            await sendText(ws, from, replyText, account.preferredService);
+                        }
+                        for (const url of mediaUrls) {
+                            await sendMedia(ws, from, url, undefined, account.preferredService);
+                        }
+                    }
+                },
+                onError: (err) => {
+                    ctx.log?.error?.(`[${accountId}] Reply delivery failed: ${err}`);
+                },
+            },
+            replyOptions: {},
+        });
+    }
+    finally {
+        // Stop typing (DM only)
+        if (!isGroup && ws) {
+            ws.send({ type: "typing.stop", to: from });
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const ClawMessengerConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    apiKey: z.ZodString;
+    serverUrl: z.ZodDefault<z.ZodString>;
+    preferredService: z.ZodDefault<z.ZodEnum<{
+        iMessage: "iMessage";
+        RCS: "RCS";
+        SMS: "SMS";
+    }>>;
+    dmPolicy: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        pairing: "pairing";
+        allowlist: "allowlist";
+    }>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groupPolicy: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        allowlist: "allowlist";
+        disabled: "disabled";
+    }>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ClawMessengerConfig = z.infer<typeof ClawMessengerConfigSchema>;

package/dist/config.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const ClawMessengerConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    apiKey: z.string().describe("Claw-messenger API key (cm_live_...)"),
+    serverUrl: z
+        .string()
+        .default("wss://claw-messenger.onrender.com")
+        .describe("Claw-messenger WebSocket server URL"),
+    preferredService: z
+        .enum(["iMessage", "RCS", "SMS"])
+        .default("iMessage")
+        .describe("Preferred delivery service"),
+    dmPolicy: z.enum(["open", "pairing", "allowlist"]).default("pairing"),
+    allowFrom: z.array(z.string()).optional(),
+    groupPolicy: z.enum(["open", "disabled", "allowlist"]).default("open"),
+    groupAllowFrom: z.array(z.string()).optional(),
+});

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { OpenclawPluginApi } from "openclaw/plugin-sdk";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: any;
+    register(api: OpenclawPluginApi): void;
+};
+export default plugin;