@xiaohhhh1/canvas-agent 0.4.9 → 0.4.11

package/dist/relay-bridge.js

@@ -2,6 +2,8 @@ import WebSocket from "ws";
 const DEFAULT_RELAY_URL = "wss://canvas.xiaohhhh1.com/api/agent-relay";
 const RECONNECT_DELAY_MS = 3_000;
 const HEARTBEAT_INTERVAL_MS = 15_000;
+const READY_TIMEOUT_MS = 12_000;
+const LIVENESS_TIMEOUT_MS = 45_000;
 /**
  * Keeps an outbound, encrypted connection to the production relay.  The canvas
  * browser can then use same-origin requests instead of directly reaching a
@@ -12,11 +14,35 @@ export function startRelayBridge(config) {
     const subscriptions = new Map();
     let socket = null;
     let stopped = false;
+    let relayReady = false;
+    let lastHeartbeatAck = 0;
     let reconnectTimer = null;
     let heartbeatTimer = null;
+    let readyTimer = null;
     const send = (message) => {
-        if (socket?.readyState === WebSocket.OPEN)
-            socket.send(JSON.stringify(message));
+        const current = socket;
+        if (!relayReady || current?.readyState !== WebSocket.OPEN)
+            return false;
+        try {
+            current.send(JSON.stringify(message));
+            return true;
+        }
+        catch {
+            current.terminate();
+            return false;
+        }
+    };
+    const clearConnectionTimers = () => {
+        if (heartbeatTimer)
+            clearInterval(heartbeatTimer);
+        if (readyTimer)
+            clearTimeout(readyTimer);
+        heartbeatTimer = null;
+        readyTimer = null;
+    };
+    const abortSubscriptions = () => {
+        subscriptions.forEach((controller) => controller.abort());
+        subscriptions.clear();
     };
     const stopSubscription = (clientId) => {
         subscriptions.get(clientId)?.abort();
@@ -67,31 +93,83 @@ export function startRelayBridge(config) {
             // Ignore malformed relay messages. The relay never receives a secret in an error response.
         }
     };
+    const scheduleReconnect = () => {
+        if (stopped || reconnectTimer)
+            return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, RECONNECT_DELAY_MS);
+    };
     const connect = () => {
-        if (stopped)
+        if (stopped || socket)
             return;
         try {
-            socket = new WebSocket(relayUrl);
-            socket.on("open", () => {
-                send({ type: "hello", role: "agent", token: config.token });
-                if (heartbeatTimer)
-                    clearInterval(heartbeatTimer);
-                heartbeatTimer = setInterval(() => send({ type: "heartbeat", time: Date.now() }), HEARTBEAT_INTERVAL_MS);
+            const current = new WebSocket(relayUrl);
+            socket = current;
+            let disconnected = false;
+            const disconnect = () => {
+                if (disconnected)
+                    return;
+                disconnected = true;
+                if (socket === current)
+                    socket = null;
+                relayReady = false;
+                clearConnectionTimers();
+                abortSubscriptions();
+                scheduleReconnect();
+            };
+            current.on("open", () => {
+                try {
+                    current.send(JSON.stringify({ type: "hello", role: "agent", token: config.token }));
+                }
+                catch {
+                    current.terminate();
+                    return;
+                }
+                readyTimer = setTimeout(() => current.terminate(), READY_TIMEOUT_MS);
             });
-            socket.on("message", onMessage);
-            socket.on("close", () => {
-                if (heartbeatTimer)
-                    clearInterval(heartbeatTimer);
-                heartbeatTimer = null;
-                subscriptions.forEach((controller) => controller.abort());
-                subscriptions.clear();
-                if (!stopped)
-                    reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+            current.on("message", (raw) => {
+                try {
+                    const message = JSON.parse(raw.toString());
+                    if (message.type === "ready") {
+                        relayReady = true;
+                        lastHeartbeatAck = Date.now();
+                        if (readyTimer)
+                            clearTimeout(readyTimer);
+                        readyTimer = null;
+                        if (heartbeatTimer)
+                            clearInterval(heartbeatTimer);
+                        heartbeatTimer = setInterval(() => {
+                            if (Date.now() - lastHeartbeatAck > LIVENESS_TIMEOUT_MS) {
+                                current.terminate();
+                                return;
+                            }
+                            send({ type: "heartbeat", time: Date.now() });
+                        }, HEARTBEAT_INTERVAL_MS);
+                        heartbeatTimer.unref();
+                        return;
+                    }
+                    if (message.type === "heartbeat_ack") {
+                        lastHeartbeatAck = Date.now();
+                        return;
+                    }
+                    if (!relayReady)
+                        return;
+                }
+                catch {
+                    return;
+                }
+                onMessage(raw);
             });
-            socket.on("error", () => undefined);
+            current.on("close", disconnect);
+            current.on("error", () => current.terminate());
         }
         catch {
-            reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+            socket = null;
+            relayReady = false;
+            clearConnectionTimers();
+            scheduleReconnect();
         }
     };
     connect();
@@ -99,11 +177,10 @@ export function startRelayBridge(config) {
         stopped = true;
         if (reconnectTimer)
             clearTimeout(reconnectTimer);
-        if (heartbeatTimer)
-            clearInterval(heartbeatTimer);
-        subscriptions.forEach((controller) => controller.abort());
-        subscriptions.clear();
+        clearConnectionTimers();
+        abortSubscriptions();
         socket?.close();
+        socket = null;
     };
 }
 async function pipeEvents(clientId, config, signal, send) {

package/dist/server/supervisor.d.ts

@@ -2,4 +2,4 @@ export declare const AGENT_REPLACED_EXIT_CODE = 75;
 export declare function shouldRestartAgent(code: number | null, stopping: boolean): boolean;
 export declare function shouldReplaceSupervisorLock(ownerPid: number, ageMs: number, ownerAlive: boolean): boolean;
 /** Keep the local HTTP worker alive, but step aside when a newer package replaces it. */
-export declare function startHttpSupervisor(): void;
+export declare function startHttpSupervisor(): undefined;

package/dist/server/supervisor.js

@@ -91,7 +91,7 @@ export function startHttpSupervisor() {
         throw new Error("无法定位 Canvas Agent 启动文件");
     const lockDescriptor = acquireSupervisorLock();
     if (lockDescriptor === undefined)
-        return;
+        return void process.exit(0);
     let child;
     let stopping = false;
     let restartTimer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",