palz-connector 1.5.0 → 1.5.2

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "palz-connector",
   "name": "Palz Connector Channel",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Palz IM 接入 OpenClaw",
   "channels": [
     "palz-connector"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palz-connector",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "type": "module",
   "main": "index.js",
   "description": "Palz IM 接入 OpenClaw — 模块化架构，基于 OpenClaw Runtime 消息管道",

package/src/config.js

@@ -9,6 +9,9 @@
  */
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 const DEFAULT_ACCOUNT_ID = "__default__";
 const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000;
 const DEFAULT_CONFIG_FILENAME = "palz-connector.config.json";

package/src/monitor.js

@@ -8,6 +8,9 @@ import WebSocket from "ws";
 import { handlePalzMessage } from "./bot.js";
 import { reportPalzActivity } from "./activity.js";
 import { tracer, extractTraceparentContext, SpanStatusCode } from "./tracing.js";
+const WS_CONNECT_TIMEOUT_MS = 15_000;
+const WS_PING_INTERVAL_MS = 30_000;
+const WS_PONG_TIMEOUT_MS = 70_000;
 export async function monitorPalzProvider(params) {
     const { cfg, config, runtime, abortSignal, accountId } = params;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
@@ -24,6 +27,7 @@ export async function monitorPalzProvider(params) {
         let reconnectDelay = 1000;
         let reconnectTimer = null;
         let currentWs = null;
+        let disposeCurrentSocket = null;
         let consecutive4002 = 0;
         const MAX_CONSECUTIVE_4002 = 10;
         const MAX_RECONNECT_DELAY_MS = 16_000;
@@ -33,6 +37,10 @@ export async function monitorPalzProvider(params) {
                 clearTimeout(reconnectTimer);
                 reconnectTimer = null;
             }
+            if (disposeCurrentSocket) {
+                disposeCurrentSocket();
+                disposeCurrentSocket = null;
+            }
             if (currentWs) {
                 currentWs.removeAllListeners();
                 if (currentWs.readyState === WebSocket.OPEN || currentWs.readyState === WebSocket.CLOSING) {
@@ -91,15 +99,29 @@ export async function monitorPalzProvider(params) {
             currentWs = ws;
             let connectedAt = 0;
             let pingInterval = null;
+            let connectTimeout = null;
+            let lastPingAt = 0;
+            let lastPongAt = Date.now();
             let messageCount = 0;
             let ended = false;
+            const disposeSocketTimers = () => {
+                if (connectTimeout) {
+                    clearTimeout(connectTimeout);
+                    connectTimeout = null;
+                }
+                if (pingInterval) {
+                    clearInterval(pingInterval);
+                    pingInterval = null;
+                }
+            };
+            disposeCurrentSocket = disposeSocketTimers;
             const handleSocketEnd = (code, reasonStr) => {
                 if (ended)
                     return;
                 ended = true;
-                if (pingInterval) {
-                    clearInterval(pingInterval);
-                    pingInterval = null;
+                disposeSocketTimers();
+                if (disposeCurrentSocket === disposeSocketTimers) {
+                    disposeCurrentSocket = null;
                 }
                 if (closed)
                     return;
@@ -133,18 +155,47 @@ export async function monitorPalzProvider(params) {
                 log(`palz[${accountId}]: disconnected (code=${code}, reason=${reasonStr}, uptime=${Math.round(stableMs / 1000)}s, msgs=${messageCount}), reconnecting in ${reconnectDelay}ms`);
                 scheduleReconnect();
             };
+            connectTimeout = setTimeout(() => {
+                if (ws.readyState !== WebSocket.CONNECTING)
+                    return;
+                error(`palz[${accountId}]: WebSocket connect timeout after ${WS_CONNECT_TIMEOUT_MS}ms`);
+                ws.terminate();
+                handleSocketEnd(1006, `connect timeout ${WS_CONNECT_TIMEOUT_MS}ms`);
+            }, WS_CONNECT_TIMEOUT_MS);
             ws.on("open", () => {
+                if (connectTimeout) {
+                    clearTimeout(connectTimeout);
+                    connectTimeout = null;
+                }
                 connectedAt = Date.now();
+                lastPongAt = connectedAt;
                 consecutive4002 = 0;
                 log(`palz[${accountId}]: WebSocket connected, bot_id=${config.botId}`);
                 pingInterval = setInterval(() => {
                     if (ws.readyState === WebSocket.OPEN) {
+                        const timeSinceLastPong = Date.now() - lastPongAt;
+                        if (timeSinceLastPong > WS_PONG_TIMEOUT_MS) {
+                            error(`palz[${accountId}]: WebSocket pong timeout after ${timeSinceLastPong}ms, terminating`);
+                            ws.terminate();
+                            handleSocketEnd(1006, `pong timeout ${timeSinceLastPong}ms`);
+                            return;
+                        }
                         try {
+                            lastPingAt = Date.now();
                             ws.ping();
+                            log(`palz[${accountId}]: [WS_HEARTBEAT] ping sent, last_pong_ago=${timeSinceLastPong}ms`);
+                        }
+                        catch (err) {
+                            error(`palz[${accountId}]: [WS_HEARTBEAT] ping failed: ${err.message ?? err}`);
                         }
-                        catch { }
                     }
-                }, 30_000);
+                }, WS_PING_INTERVAL_MS);
+            });
+            ws.on("pong", () => {
+                const now = Date.now();
+                const rttMs = lastPingAt > 0 ? now - lastPingAt : null;
+                lastPongAt = now;
+                log(`palz[${accountId}]: [WS_HEARTBEAT] pong received${rttMs === null ? "" : `, rtt=${rttMs}ms`}`);
             });
             ws.on("message", (data) => {
                 const receivedAt = new Date();

package/src/send.js

@@ -6,6 +6,7 @@
  */
 import { tracer, trace, SpanStatusCode, buildTraceparentHeader } from "./tracing.js";
 import { contentPartsToOpenAIContent } from "./content.js";
+const SEND_TIMEOUT_MS = 10_000;
 let msgSeq = 0;
 function nextMsgId() {
     return `bot_reply_${Date.now()}_${++msgSeq}`;
@@ -83,13 +84,32 @@ async function _sendToPalzIMInner(params) {
         headers["Traceparent"] = traceparent;
     }
     const startMs = Date.now();
-    const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: reqBodyStr,
-    });
-    const elapsedMs = Date.now() - startMs;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), SEND_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: reqBodyStr,
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const elapsedMs = Date.now() - startMs;
+        const reason = err?.name === "AbortError" ? `timeout ${SEND_TIMEOUT_MS}ms` : (err?.message ?? String(err));
+        const failLog = `[HTTP_RES] ERROR elapsed=${elapsedMs}ms reason=${reason}`;
+        console.error(`palz-send: ${failLog}`);
+        span?.addEvent(failLog);
+        throw err?.name === "AbortError"
+            ? new Error(`Palz send timeout after ${SEND_TIMEOUT_MS}ms`)
+            : err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
     const rawText = await response.text().catch(() => "");
+    const elapsedMs = Date.now() - startMs;
     let body = null;
     try {
         body = JSON.parse(rawText);