@emotion-machine/claw-messenger 0.1.6 → 0.1.8

package/dist/channel.d.ts

@@ -1,5 +1,6 @@
 import { type ChannelPlugin } from "openclaw/plugin-sdk";
 import { type ClawMessengerConfig } from "./config.js";
+import { WsClient } from "./ws/client.js";
 interface ResolvedAccount {
     accountId: string;
     enabled: boolean;
@@ -8,6 +9,7 @@ interface ResolvedAccount {
     preferredService: string;
     config: ClawMessengerConfig;
 }
+export declare function getWsClient(accountId: string): WsClient | undefined;
 export declare function getConnectionStatus(): {
     connected: boolean;
     serverUrl: string;

package/dist/channel.js

@@ -1,8 +1,8 @@
-import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, formatPairingApproveHint, normalizeE164, PAIRING_APPROVED_MESSAGE, } from "openclaw/plugin-sdk";
+import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, formatPairingApproveHint, 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";
+import { normalizeDirectTarget, sendText, sendMedia, sendToGroup, sendGroupMedia, sendToNewGroup, } from "./outbound/send.js";
 const EMOJI_TO_REACTION = {
     "❤️": "love", "♥️": "love", "🩷": "love", "💕": "love", "😍": "love",
     "👍": "like", "👍🏻": "like", "👍🏼": "like", "👍🏽": "like", "👍🏾": "like", "👍🏿": "like",
@@ -28,6 +28,9 @@ function resolveAccount(cfg, _accountId) {
 // -- WS client per account --
 const wsClients = new Map();
 const lastMessageAt = new Map();
+export function getWsClient(accountId) {
+    return wsClients.get(accountId);
+}
 // -- Connection status helper (used by tools & commands in index.ts) --
 export function getConnectionStatus() {
     const runtime = getRuntime();
@@ -135,13 +138,7 @@ export const clawMessengerPlugin = {
         },
     },
     messaging: {
-        normalizeTarget: (target) => {
-            const trimmed = target.trim();
-            if (!trimmed)
-                return null;
-            const normalized = normalizeE164(trimmed);
-            return normalized ?? trimmed;
-        },
+        normalizeTarget: (target) => normalizeDirectTarget(target),
         targetResolver: {
             looksLikeId: (raw) => {
                 const trimmed = raw?.trim();

package/dist/index.js

@@ -1,6 +1,6 @@
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { Type } from "@sinclair/typebox";
-import { clawMessengerPlugin, getConnectionStatus, createGroup } from "./channel.js";
+import { clawMessengerPlugin, getConnectionStatus, getWsClient, createGroup } from "./channel.js";
 import { setRuntime, getRuntime } from "./runtime.js";
 const VALID_SERVICES = ["iMessage", "RCS", "SMS"];
 const plugin = {
@@ -82,6 +82,68 @@ const plugin = {
                 }
             },
         });
+        api.registerTool({
+            name: "claw_messenger_diagnose",
+            label: "Claw Messenger Diagnostics",
+            description: "Generate a diagnostic report of recent connection issues, errors, and plugin state. " +
+                "Optionally submits the report to the Claw Messenger server for support analysis.",
+            parameters: Type.Object({
+                submit: Type.Boolean({
+                    description: "If true, submit the report to the server for the Claw Messenger team to review",
+                    default: false,
+                }),
+            }),
+            async execute(_toolCallId, params) {
+                const { submit } = params;
+                const status = getConnectionStatus();
+                const ws = getWsClient(status.accountId);
+                const diagnostics = ws?.getDiagnostics() ?? { errors: [], connectionLog: [] };
+                const report = {
+                    plugin_version: "0.1.7",
+                    node_version: process.version,
+                    connected: status.connected,
+                    server_url: status.serverUrl,
+                    preferred_service: status.preferredService,
+                    errors: diagnostics.errors,
+                    connection_log: diagnostics.connectionLog,
+                };
+                let submitted = false;
+                if (submit && status.connected) {
+                    try {
+                        const runtime = getRuntime();
+                        const cfg = runtime.config.loadConfig();
+                        const account = (cfg.channels?.["claw-messenger"] ?? {});
+                        const apiKey = account.apiKey ?? "";
+                        const serverUrl = account.serverUrl ?? "https://claw-messenger.onrender.com";
+                        const baseUrl = serverUrl.replace("wss://", "https://").replace("ws://", "http://").replace(/\/ws\/?$/, "");
+                        const resp = await fetch(`${baseUrl}/api/diagnostics`, {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                                "Authorization": `Bearer ${apiKey}`,
+                            },
+                            body: JSON.stringify({
+                                plugin_version: report.plugin_version,
+                                node_version: report.node_version,
+                                errors: report.errors,
+                                connection_log: report.connection_log,
+                                metadata: { connected: report.connected, server_url: report.server_url },
+                            }),
+                        });
+                        submitted = resp.ok;
+                    }
+                    catch {
+                        // Submission is best-effort
+                    }
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ ...report, submitted_to_server: submitted }, null, 2),
+                        }],
+                };
+            },
+        });
         // -- Auto-Reply Commands --
         api.registerCommand({
             name: "cm-status",

package/dist/outbound/send.d.ts

@@ -3,6 +3,7 @@ export interface SendResult {
     messageId: string;
     chatId: string;
 }
+export declare function normalizeDirectTarget(target: string): string | null;
 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>;

package/dist/outbound/send.js

@@ -1,3 +1,21 @@
+import { normalizeE164 } from "openclaw/plugin-sdk";
+function stripLegacyNamespacePrefix(target) {
+    let normalized = target.trim();
+    while (normalized.startsWith("claw-messenger:") || normalized.startsWith("linq:")) {
+        if (normalized.startsWith("claw-messenger:")) {
+            normalized = normalized.slice("claw-messenger:".length).trim();
+            continue;
+        }
+        normalized = normalized.slice("linq:".length).trim();
+    }
+    return normalized;
+}
+export function normalizeDirectTarget(target) {
+    const stripped = stripLegacyNamespacePrefix(target);
+    if (!stripped)
+        return null;
+    return normalizeE164(stripped) ?? stripped;
+}
 export async function sendText(ws, to, text, service) {
     return sendMessage(ws, to, [{ type: "text", value: text }], service);
 }
@@ -9,9 +27,13 @@ export async function sendMedia(ws, to, mediaUrl, text, service) {
     return sendMessage(ws, to, parts, service);
 }
 export async function sendMessage(ws, to, parts, service) {
+    const normalizedTarget = normalizeDirectTarget(to);
+    if (!normalizedTarget) {
+        throw new Error("Recipient is required");
+    }
     const resp = await ws.request({
         type: "send",
-        to,
+        to: normalizedTarget,
         parts,
         ...(service ? { service } : {}),
     });
@@ -50,9 +72,15 @@ async function sendGroupMessage(ws, chatId, parts, service) {
     throw new Error(resp.error ?? "Group send failed");
 }
 export async function sendToNewGroup(ws, to, text, service) {
+    const normalizedTargets = to
+        .map((target) => normalizeDirectTarget(target))
+        .filter((target) => Boolean(target));
+    if (normalizedTargets.length < 2) {
+        throw new Error("Group requires at least 2 recipients");
+    }
     const resp = await ws.request({
         type: "send",
-        to,
+        to: normalizedTargets,
         parts: [{ type: "text", value: text }],
         ...(service ? { service } : {}),
     });

package/dist/ws/client.d.ts

@@ -15,6 +15,13 @@ export interface WsClientOptions {
     onDisconnect?: () => void;
     log?: (msg: string) => void;
 }
+interface DiagnosticEntry {
+    ts: string;
+    type: "connect" | "disconnect" | "error" | "evicted" | "pong_timeout" | "send_fail";
+    code?: number;
+    reason?: string;
+    detail?: string;
+}
 export declare class WsClient {
     private ws;
     private opts;
@@ -26,6 +33,8 @@ export declare class WsClient {
     private stopped;
     private correlationCounter;
     private lastPongAt;
+    private diagnosticLog;
+    private errorLog;
     constructor(opts: WsClientOptions);
     connect(): void;
     stop(): void;
@@ -38,6 +47,14 @@ export declare class WsClient {
      */
     send(message: Record<string, unknown>): void;
     get connected(): boolean;
+    /**
+     * Get diagnostic data for error reporting.
+     */
+    getDiagnostics(): {
+        errors: DiagnosticEntry[];
+        connectionLog: DiagnosticEntry[];
+    };
+    private _logDiagnostic;
     private _nextId;
     private _connect;
     private _handleMessage;

package/dist/ws/client.js

@@ -9,6 +9,7 @@
 import WebSocket from "ws";
 const MAX_RECONNECT_DELAY_MS = 30_000;
 const MAX_RECONNECT_ATTEMPTS = 50;
+const MAX_DIAGNOSTIC_ENTRIES = 50;
 const PING_INTERVAL_MS = 30_000;
 const REQUEST_TIMEOUT_MS = 30_000;
 const PONG_TIMEOUT_MS = 10_000;
@@ -28,6 +29,8 @@ export class WsClient {
     stopped = false;
     correlationCounter = 0;
     lastPongAt = 0;
+    diagnosticLog = [];
+    errorLog = [];
     constructor(opts) {
         this.opts = opts;
     }
@@ -76,6 +79,27 @@ export class WsClient {
     get connected() {
         return this.ws?.readyState === WebSocket.OPEN;
     }
+    /**
+     * Get diagnostic data for error reporting.
+     */
+    getDiagnostics() {
+        return {
+            errors: [...this.errorLog],
+            connectionLog: [...this.diagnosticLog],
+        };
+    }
+    _logDiagnostic(entry) {
+        this.diagnosticLog.push(entry);
+        if (this.diagnosticLog.length > MAX_DIAGNOSTIC_ENTRIES) {
+            this.diagnosticLog.shift();
+        }
+        if (entry.type === "error" || entry.type === "evicted" || entry.type === "send_fail" || entry.type === "pong_timeout") {
+            this.errorLog.push(entry);
+            if (this.errorLog.length > MAX_DIAGNOSTIC_ENTRIES) {
+                this.errorLog.shift();
+            }
+        }
+    }
     // -- Internal --
     _nextId() {
         return `corr-${++this.correlationCounter}-${Date.now()}`;
@@ -114,6 +138,7 @@ export class WsClient {
             // counter at 0 and bypass backoff.
             this.lastPongAt = Date.now();
             this.opts.log?.("Connected");
+            this._logDiagnostic({ ts: new Date().toISOString(), type: "connect" });
             // Reject stale pending requests from previous connection
             this._rejectPendingRequests("Connection reset");
             this.opts.onConnect?.();
@@ -143,6 +168,7 @@ export class WsClient {
                 return;
             if (NO_RECONNECT_CODES.has(event.code)) {
                 this.opts.log?.(`Not reconnecting (code=${event.code}: ${event.reason})`);
+                this._logDiagnostic({ ts: new Date().toISOString(), type: "evicted", code: event.code, reason: event.reason });
                 this.stopped = true;
                 return;
             }
@@ -151,10 +177,12 @@ export class WsClient {
                 this.stopped = true;
                 return;
             }
+            this._logDiagnostic({ ts: new Date().toISOString(), type: "disconnect", code: event.code, reason: event.reason });
             this._scheduleReconnect();
         };
         ws.onerror = (event) => {
             this.opts.log?.(`WebSocket error`);
+            this._logDiagnostic({ ts: new Date().toISOString(), type: "error", detail: "WebSocket error event" });
         };
     }
     _handleMessage(data) {
@@ -207,6 +235,7 @@ export class WsClient {
         this._clearPongTimeout();
         this.pongTimeoutTimer = setTimeout(() => {
             this.opts.log?.("Pong timeout — forcing reconnect");
+            this._logDiagnostic({ ts: new Date().toISOString(), type: "pong_timeout" });
             // Force-close to trigger reconnect via onclose
             if (this.ws) {
                 try {

package/openclaw.plugin.json

@@ -5,19 +5,39 @@
   "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" } }
-    }
+    "properties": {}
   },
-  "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" }
+  "channelConfigs": {
+    "claw-messenger": {
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" },
+          "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" } },
+          "groupPolicy": { "type": "string", "enum": ["open", "disabled", "allowlist"] },
+          "groupAllowFrom": { "type": "array", "items": { "type": "string" } }
+        }
+      },
+      "label": "Claw Messenger",
+      "description": "Claw Messenger channel settings for iMessage, RCS, and SMS relay access.",
+      "uiHints": {
+        "": {
+          "label": "Claw Messenger",
+          "help": "Configure your Claw Messenger API key, relay URL, and direct-message access policy here."
+        },
+        "apiKey": { "label": "API Key", "sensitive": true, "placeholder": "cm_live_..." },
+        "serverUrl": { "label": "Server URL", "placeholder": "wss://claw-messenger.onrender.com" },
+        "preferredService": { "label": "Preferred Service" },
+        "dmPolicy": { "label": "DM Policy" },
+        "allowFrom": { "label": "Allow List" },
+        "groupPolicy": { "label": "Group Policy" },
+        "groupAllowFrom": { "label": "Group Allow List" }
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emotion-machine/claw-messenger",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "iMessage, RCS & SMS channel plugin for OpenClaw — no phone or Mac Mini required",
   "type": "module",
   "main": "dist/index.js",