@emotion-machine/claw-messenger 0.1.0

package/dist/index.js

@@ -0,0 +1,109 @@
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { Type } from "@sinclair/typebox";
+import { clawMessengerPlugin, getConnectionStatus } from "./channel.js";
+import { setRuntime, getRuntime } from "./runtime.js";
+const VALID_SERVICES = ["iMessage", "RCS", "SMS"];
+const plugin = {
+    id: "claw-messenger",
+    name: "Claw Messenger",
+    description: "iMessage, RCS & SMS without a Mac or Linq account — via shared claw-messenger proxy",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setRuntime(api.runtime);
+        api.registerChannel({ plugin: clawMessengerPlugin });
+        // -- Agent Tools --
+        api.registerTool({
+            name: "claw_messenger_status",
+            label: "Claw Messenger Status",
+            description: "Check claw-messenger connection status and account info",
+            parameters: Type.Object({}),
+            async execute() {
+                const status = getConnectionStatus();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+                };
+            },
+        });
+        api.registerTool({
+            name: "claw_messenger_switch_service",
+            label: "Switch Messaging Service",
+            description: "Switch the preferred messaging service for future outbound messages (iMessage, RCS, or SMS)",
+            parameters: Type.Object({
+                service: Type.Union([Type.Literal("iMessage"), Type.Literal("RCS"), Type.Literal("SMS")], { description: "The messaging service to switch to" }),
+            }),
+            async execute(_toolCallId, params) {
+                const { service } = params;
+                if (!VALID_SERVICES.includes(service)) {
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({ error: `Invalid service "${service}". Must be one of: ${VALID_SERVICES.join(", ")}` }) }],
+                    };
+                }
+                const runtime = getRuntime();
+                const cfg = runtime.config.loadConfig();
+                const updated = {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        "claw-messenger": {
+                            ...(cfg.channels?.["claw-messenger"] ?? {}),
+                            preferredService: service,
+                        },
+                    },
+                };
+                await runtime.config.writeConfigFile(updated);
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ ok: true, preferredService: service }) }],
+                };
+            },
+        });
+        // -- Auto-Reply Commands --
+        api.registerCommand({
+            name: "cm-status",
+            label: "Claw Messenger Status",
+            description: "Show claw-messenger connection state, server URL, and preferred service",
+            acceptsArgs: false,
+            async handler() {
+                const s = getConnectionStatus();
+                return {
+                    text: [
+                        `Connected: ${s.connected ? "yes" : "no"}`,
+                        `Server: ${s.serverUrl}`,
+                        `Preferred Service: ${s.preferredService}`,
+                        `Account: ${s.accountId}`,
+                    ].join("\n"),
+                };
+            },
+        });
+        api.registerCommand({
+            name: "cm-switch",
+            label: "Switch Messaging Service",
+            description: "Switch the preferred messaging service (iMessage, RCS, SMS)",
+            acceptsArgs: true,
+            async handler(ctx) {
+                const arg = ctx.args?.trim();
+                if (!arg) {
+                    return { text: `Usage: /cm-switch <service>\nValid services: ${VALID_SERVICES.join(", ")}` };
+                }
+                const match = VALID_SERVICES.find((s) => s.toLowerCase() === arg.toLowerCase());
+                if (!match) {
+                    return { text: `Invalid service "${arg}". Must be one of: ${VALID_SERVICES.join(", ")}` };
+                }
+                const runtime = getRuntime();
+                const cfg = runtime.config.loadConfig();
+                const updated = {
+                    ...cfg,
+                    channels: {
+                        ...cfg.channels,
+                        "claw-messenger": {
+                            ...(cfg.channels?.["claw-messenger"] ?? {}),
+                            preferredService: match,
+                        },
+                    },
+                };
+                await runtime.config.writeConfigFile(updated);
+                return { text: `Preferred service switched to ${match}` };
+            },
+        });
+    },
+};
+export default plugin;

package/dist/outbound/send.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Send messages via WebSocket to claw-messenger -> Linq -> iMessage.
+ * Replaces direct Linq API calls from channel-linq/src/outbound/send.ts.
+ */
+import type { WsClient } from "../ws/client.js";
+export interface SendResult {
+    messageId: string;
+    chatId: string;
+}
+export declare function sendText(ws: WsClient, to: string, text: string, service?: string): Promise<SendResult>;
+export declare function sendMedia(ws: WsClient, to: string, mediaUrl: string, text?: string, service?: string): Promise<SendResult>;
+export declare function sendMessage(ws: WsClient, to: string, parts: Array<Record<string, unknown>>, service?: string): Promise<SendResult>;
+export declare function sendToGroup(ws: WsClient, chatId: string, text: string, service?: string): Promise<SendResult>;
+export declare function sendGroupMedia(ws: WsClient, chatId: string, mediaUrl: string, text?: string, service?: string): Promise<SendResult>;
+export declare function sendToNewGroup(ws: WsClient, to: string[], text: string, service?: string): Promise<SendResult>;

package/dist/outbound/send.js

@@ -0,0 +1,70 @@
+/**
+ * Send messages via WebSocket to claw-messenger -> Linq -> iMessage.
+ * Replaces direct Linq API calls from channel-linq/src/outbound/send.ts.
+ */
+export async function sendText(ws, to, text, service) {
+    return sendMessage(ws, to, [{ type: "text", value: text }], service);
+}
+export async function sendMedia(ws, to, mediaUrl, text, service) {
+    const parts = [];
+    if (text)
+        parts.push({ type: "text", value: text });
+    parts.push({ type: "media", url: mediaUrl });
+    return sendMessage(ws, to, parts, service);
+}
+export async function sendMessage(ws, to, parts, service) {
+    const resp = await ws.request({
+        type: "send",
+        to,
+        parts,
+        ...(service ? { service } : {}),
+    });
+    if (resp.ok) {
+        return {
+            messageId: resp.messageId ?? "",
+            chatId: "",
+        };
+    }
+    throw new Error(resp.error ?? "Send failed");
+}
+// -- Group send functions --
+export async function sendToGroup(ws, chatId, text, service) {
+    return sendGroupMessage(ws, chatId, [{ type: "text", value: text }], service);
+}
+export async function sendGroupMedia(ws, chatId, mediaUrl, text, service) {
+    const parts = [];
+    if (text)
+        parts.push({ type: "text", value: text });
+    parts.push({ type: "media", url: mediaUrl });
+    return sendGroupMessage(ws, chatId, parts, service);
+}
+async function sendGroupMessage(ws, chatId, parts, service) {
+    const resp = await ws.request({
+        type: "send",
+        chatId,
+        parts,
+        ...(service ? { service } : {}),
+    });
+    if (resp.ok) {
+        return {
+            messageId: resp.messageId ?? "",
+            chatId,
+        };
+    }
+    throw new Error(resp.error ?? "Group send failed");
+}
+export async function sendToNewGroup(ws, to, text, service) {
+    const resp = await ws.request({
+        type: "send",
+        to,
+        parts: [{ type: "text", value: text }],
+        ...(service ? { service } : {}),
+    });
+    if (resp.ok) {
+        return {
+            messageId: resp.messageId ?? "",
+            chatId: resp.chatId ?? "",
+        };
+    }
+    throw new Error(resp.error ?? "Group creation failed");
+}

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+export declare function setRuntime(next: PluginRuntime): void;
+export declare function getRuntime(): PluginRuntime;

package/dist/runtime.js

@@ -0,0 +1,10 @@
+let runtime = null;
+export function setRuntime(next) {
+    runtime = next;
+}
+export function getRuntime() {
+    if (!runtime) {
+        throw new Error("Claw Messenger runtime not initialized");
+    }
+    return runtime;
+}

package/dist/ws/client.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WebSocket client with reconnection and request/response correlation.
+ * Connects to claw-messenger server with API key auth.
+ */
+type MessageHandler = (message: Record<string, unknown>) => void;
+export interface WsClientOptions {
+    serverUrl: string;
+    apiKey: string;
+    onMessage: MessageHandler;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    log?: (msg: string) => void;
+}
+export declare class WsClient {
+    private ws;
+    private opts;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private pingTimer;
+    private pongTimeoutTimer;
+    private pendingRequests;
+    private stopped;
+    private correlationCounter;
+    private lastPongAt;
+    constructor(opts: WsClientOptions);
+    connect(): void;
+    stop(): void;
+    /**
+     * Send a message and wait for a correlated response (e.g., send -> send.result).
+     */
+    request(message: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Send a message without waiting for a response.
+     */
+    send(message: Record<string, unknown>): void;
+    get connected(): boolean;
+    private _nextId;
+    private _connect;
+    private _handleMessage;
+    private _send;
+    private _startPing;
+    private _schedulePongTimeout;
+    private _clearPongTimeout;
+    private _rejectPendingRequests;
+    private _scheduleReconnect;
+    private _clearTimers;
+}
+export {};

package/dist/ws/client.js

@@ -0,0 +1,208 @@
+/**
+ * WebSocket client with reconnection and request/response correlation.
+ * Connects to claw-messenger server with API key auth.
+ */
+const MAX_RECONNECT_DELAY_MS = 30_000;
+const PING_INTERVAL_MS = 30_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+const PONG_TIMEOUT_MS = 10_000;
+export class WsClient {
+    ws = null;
+    opts;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    pingTimer = null;
+    pongTimeoutTimer = null;
+    pendingRequests = new Map();
+    stopped = false;
+    correlationCounter = 0;
+    lastPongAt = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    connect() {
+        this.stopped = false;
+        this._connect();
+    }
+    stop() {
+        this.stopped = true;
+        this._clearTimers();
+        if (this.ws) {
+            try {
+                this.ws.close(1000, "Client stopping");
+            }
+            catch { }
+            this.ws = null;
+        }
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            pending.reject(new Error("Client stopped"));
+            clearTimeout(pending.timer);
+        }
+        this.pendingRequests.clear();
+    }
+    /**
+     * Send a message and wait for a correlated response (e.g., send -> send.result).
+     */
+    async request(message) {
+        const id = message.id ?? this._nextId();
+        message.id = id;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request ${id} timed out`));
+            }, REQUEST_TIMEOUT_MS);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            this._send(message);
+        });
+    }
+    /**
+     * Send a message without waiting for a response.
+     */
+    send(message) {
+        this._send(message);
+    }
+    get connected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    // -- Internal --
+    _nextId() {
+        return `corr-${++this.correlationCounter}-${Date.now()}`;
+    }
+    _connect() {
+        if (this.stopped)
+            return;
+        const url = new URL(this.opts.serverUrl);
+        // Ensure ws/wss scheme
+        if (url.protocol === "https:")
+            url.protocol = "wss:";
+        if (url.protocol === "http:")
+            url.protocol = "ws:";
+        // Add /ws path if not already there
+        if (!url.pathname.endsWith("/ws")) {
+            url.pathname = url.pathname.replace(/\/$/, "") + "/ws";
+        }
+        url.searchParams.set("key", this.opts.apiKey);
+        this.opts.log?.(`Connecting to ${url.origin}${url.pathname}...`);
+        const ws = new WebSocket(url.toString());
+        this.ws = ws;
+        ws.onopen = () => {
+            this.reconnectAttempt = 0;
+            this.lastPongAt = Date.now();
+            this.opts.log?.("Connected");
+            // Reject stale pending requests from previous connection
+            this._rejectPendingRequests("Connection reset");
+            this.opts.onConnect?.();
+            this._startPing();
+        };
+        ws.onmessage = (event) => {
+            try {
+                const data = JSON.parse(String(event.data));
+                this._handleMessage(data);
+            }
+            catch (err) {
+                this.opts.log?.(`Failed to parse message: ${err}`);
+            }
+        };
+        ws.onclose = (event) => {
+            this.opts.log?.(`Disconnected (code=${event.code})`);
+            this._clearTimers();
+            this.opts.onDisconnect?.();
+            if (!this.stopped) {
+                this._scheduleReconnect();
+            }
+        };
+        ws.onerror = (event) => {
+            this.opts.log?.(`WebSocket error`);
+        };
+    }
+    _handleMessage(data) {
+        // Check if this is a response to a pending request
+        const id = data.id;
+        if (id && this.pendingRequests.has(id)) {
+            const pending = this.pendingRequests.get(id);
+            this.pendingRequests.delete(id);
+            clearTimeout(pending.timer);
+            pending.resolve(data);
+            return;
+        }
+        // Server-initiated ping — respond with pong
+        if (data.type === "ping") {
+            try {
+                this._send({ type: "pong" });
+            }
+            catch { }
+            this.lastPongAt = Date.now();
+            return;
+        }
+        // Pong response to our ping
+        if (data.type === "pong") {
+            this.lastPongAt = Date.now();
+            this._clearPongTimeout();
+            return;
+        }
+        // Pass to handler
+        this.opts.onMessage(data);
+    }
+    _send(message) {
+        if (this.ws?.readyState !== WebSocket.OPEN) {
+            throw new Error("WebSocket not connected");
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    _startPing() {
+        this._clearTimers();
+        this.pingTimer = setInterval(() => {
+            try {
+                this._send({ type: "ping" });
+                this._schedulePongTimeout();
+            }
+            catch { }
+        }, PING_INTERVAL_MS);
+    }
+    _schedulePongTimeout() {
+        this._clearPongTimeout();
+        this.pongTimeoutTimer = setTimeout(() => {
+            this.opts.log?.("Pong timeout — forcing reconnect");
+            // Force-close to trigger reconnect via onclose
+            if (this.ws) {
+                try {
+                    this.ws.close(4000, "Pong timeout");
+                }
+                catch { }
+            }
+        }, PONG_TIMEOUT_MS);
+    }
+    _clearPongTimeout() {
+        if (this.pongTimeoutTimer) {
+            clearTimeout(this.pongTimeoutTimer);
+            this.pongTimeoutTimer = null;
+        }
+    }
+    _rejectPendingRequests(reason) {
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(reason));
+        }
+        this.pendingRequests.clear();
+    }
+    _scheduleReconnect() {
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempt), MAX_RECONNECT_DELAY_MS);
+        this.opts.log?.(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt + 1})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectAttempt++;
+            this._connect();
+        }, delay);
+    }
+    _clearTimers() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this._clearPongTimeout();
+    }
+}

package/openclaw.plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "claw-messenger",
+  "description": "Integrate Claw Messenger to send and receive messages across multiple platforms including iMessage, RCS, and SMS.",
+  "channels": ["claw-messenger"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "apiKey": { "type": "string" },
+      "serverUrl": { "type": "string" },
+      "preferredService": { "type": "string", "enum": ["iMessage", "RCS", "SMS"] },
+      "dmPolicy": { "type": "string", "enum": ["open", "pairing", "allowlist"] },
+      "allowFrom": { "type": "array", "items": { "type": "string" } }
+    }
+  },
+  "uiHints": {
+    "apiKey": { "label": "API Key", "sensitive": true, "placeholder": "cm_live_..." },
+    "serverUrl": { "label": "Server URL", "placeholder": "ws://claw-messenger.onrender.com" },
+    "preferredService": { "label": "Preferred Service" },
+    "dmPolicy": { "label": "DM Policy" },
+    "allowFrom": { "label": "Allow List" }
+  }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@emotion-machine/claw-messenger",
+  "version": "0.1.0",
+  "description": "iMessage, RCS & SMS channel plugin for OpenClaw — no phone or Mac Mini required",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "homepage": "https://clawmessenger.com",
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "imessage",
+    "rcs",
+    "sms",
+    "emotion-machine",
+    "claw-messenger"
+  ],
+  "files": [
+    "dist/",
+    "src/types/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepare": "test -d dist || npm run build",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "channel": {
+      "id": "claw-messenger",
+      "label": "Claw Messenger",
+      "selectionLabel": "Claw Messenger",
+      "blurb": "iMessage, RCS & SMS support for OpenClaw - no phone or Mac Mini required",
+      "order": 51,
+      "aliases": [
+        "claw-messenger"
+      ],
+      "systemImage": "message.fill"
+    },
+    "install": {
+      "npmSpec": "@emotion-machine/claw-messenger",
+      "defaultChoice": "npm"
+    }
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.48",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED"
+}