@emotion-machine/claw-messenger 0.1.5 → 0.1.7

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

@@ -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();

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/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()}`;
@@ -95,6 +119,17 @@ export class WsClient {
         }
         url.searchParams.set("key", this.opts.apiKey);
         this.opts.log?.(`Connecting to ${url.origin}${url.pathname}...`);
+        // Close the previous socket if it's still open, so we don't leak
+        // connections on the server. Set this.ws to null first so the old
+        // socket's onclose handler sees it's stale and skips reconnect.
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+            const oldWs = this.ws;
+            this.ws = null;
+            try {
+                oldWs.close(1000, "Replaced by new connection");
+            }
+            catch { }
+        }
         const ws = new WebSocket(url.toString());
         this.ws = ws;
         ws.onopen = () => {
@@ -103,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?.();
@@ -119,12 +155,20 @@ export class WsClient {
         };
         ws.onclose = (event) => {
             this.opts.log?.(`Disconnected (code=${event.code})`);
+            // Only handle close for the CURRENT socket. If this.ws has been
+            // replaced by a newer connection (or set to null during replacement),
+            // this is a stale socket and we must NOT reconnect.
+            if (ws !== this.ws) {
+                this.opts.log?.("Stale socket closed — ignoring (newer connection exists)");
+                return;
+            }
             this._clearTimers();
             this.opts.onDisconnect?.();
             if (this.stopped)
                 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;
             }
@@ -133,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) {
@@ -189,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/package.json

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