@xiaohhhh1/canvas-agent 0.4.20 → 0.4.21

package/dist/relay-bridge.d.ts

@@ -1,7 +1,20 @@
 import type { CanvasAgentConfig } from "./config.js";
+export type RelayBridgeStatus = {
+    ready: boolean;
+    lastReadyAt?: string;
+    lastDisconnectAt?: string;
+};
+export type RelayBridgeOptions = {
+    relayUrl?: string;
+    reconnectDelayMs?: number;
+    heartbeatIntervalMs?: number;
+    readyTimeoutMs?: number;
+    livenessTimeoutMs?: number;
+    onStatus?: (status: RelayBridgeStatus) => void;
+};
 /**
  * Keeps an outbound, encrypted connection to the production relay.  The canvas
  * browser can then use same-origin requests instead of directly reaching a
  * loopback HTTP address, which Chromium clients can block before CORS runs.
  */
-export declare function startRelayBridge(config: CanvasAgentConfig): () => void;
+export declare function startRelayBridge(config: CanvasAgentConfig, options?: RelayBridgeOptions): () => void;

package/dist/relay-bridge.js

@@ -9,8 +9,12 @@ const LIVENESS_TIMEOUT_MS = 45_000;
  * browser can then use same-origin requests instead of directly reaching a
  * loopback HTTP address, which Chromium clients can block before CORS runs.
  */
-export function startRelayBridge(config) {
-    const relayUrl = process.env.CANVAS_AGENT_RELAY_URL || DEFAULT_RELAY_URL;
+export function startRelayBridge(config, options = {}) {
+    const relayUrl = options.relayUrl || process.env.CANVAS_AGENT_RELAY_URL || DEFAULT_RELAY_URL;
+    const reconnectDelayMs = options.reconnectDelayMs ?? RECONNECT_DELAY_MS;
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+    const readyTimeoutMs = options.readyTimeoutMs ?? READY_TIMEOUT_MS;
+    const livenessTimeoutMs = options.livenessTimeoutMs ?? LIVENESS_TIMEOUT_MS;
     const subscriptions = new Map();
     let socket = null;
     let stopped = false;
@@ -19,6 +23,9 @@ export function startRelayBridge(config) {
     let reconnectTimer = null;
     let heartbeatTimer = null;
     let readyTimer = null;
+    let lastReadyAt;
+    let lastDisconnectAt;
+    const publishStatus = () => options.onStatus?.({ ready: relayReady, lastReadyAt, lastDisconnectAt });
     const send = (message) => {
         const current = socket;
         if (!relayReady || current?.readyState !== WebSocket.OPEN)
@@ -52,7 +59,13 @@ export function startRelayBridge(config) {
         stopSubscription(clientId);
         const controller = new AbortController();
         subscriptions.set(clientId, controller);
-        void pipeEvents(clientId, config, controller.signal, send).finally(() => {
+        void pipeEvents(clientId, config, controller.signal, send)
+            .catch(() => {
+            // A browser may disappear while the relay subscription is being
+            // established. That is a recoverable client disconnect, not a
+            // process-fatal unhandled rejection.
+        })
+            .finally(() => {
             if (subscriptions.get(clientId) === controller)
                 subscriptions.delete(clientId);
         });
@@ -99,7 +112,7 @@ export function startRelayBridge(config) {
         reconnectTimer = setTimeout(() => {
             reconnectTimer = null;
             connect();
-        }, RECONNECT_DELAY_MS);
+        }, reconnectDelayMs);
     };
     const connect = () => {
         if (stopped || socket)
@@ -107,6 +120,10 @@ export function startRelayBridge(config) {
         try {
             const current = new WebSocket(relayUrl);
             socket = current;
+            // Cover DNS/TCP/TLS/WebSocket handshakes as well as the relay hello.
+            // Starting this timer only after `open` leaves a CONNECTING socket
+            // able to stall forever and prevents every future reconnect.
+            readyTimer = setTimeout(() => current.terminate(), readyTimeoutMs);
             let disconnected = false;
             const disconnect = () => {
                 if (disconnected)
@@ -115,6 +132,8 @@ export function startRelayBridge(config) {
                 if (socket === current)
                     socket = null;
                 relayReady = false;
+                lastDisconnectAt = new Date().toISOString();
+                publishStatus();
                 clearConnectionTimers();
                 abortSubscriptions();
                 scheduleReconnect();
@@ -127,13 +146,14 @@ export function startRelayBridge(config) {
                     current.terminate();
                     return;
                 }
-                readyTimer = setTimeout(() => current.terminate(), READY_TIMEOUT_MS);
             });
             current.on("message", (raw) => {
                 try {
                     const message = JSON.parse(raw.toString());
                     if (message.type === "ready") {
                         relayReady = true;
+                        lastReadyAt = new Date().toISOString();
+                        publishStatus();
                         lastHeartbeatAck = Date.now();
                         if (readyTimer)
                             clearTimeout(readyTimer);
@@ -141,12 +161,12 @@ export function startRelayBridge(config) {
                         if (heartbeatTimer)
                             clearInterval(heartbeatTimer);
                         heartbeatTimer = setInterval(() => {
-                            if (Date.now() - lastHeartbeatAck > LIVENESS_TIMEOUT_MS) {
+                            if (Date.now() - lastHeartbeatAck > livenessTimeoutMs) {
                                 current.terminate();
                                 return;
                             }
                             send({ type: "heartbeat", time: Date.now() });
-                        }, HEARTBEAT_INTERVAL_MS);
+                        }, heartbeatIntervalMs);
                         heartbeatTimer.unref();
                         return;
                     }
@@ -168,6 +188,8 @@ export function startRelayBridge(config) {
         catch {
             socket = null;
             relayReady = false;
+            lastDisconnectAt = new Date().toISOString();
+            publishStatus();
             clearConnectionTimers();
             scheduleReconnect();
         }

package/dist/server/http.js

@@ -33,6 +33,7 @@ export function startHttpServer() {
     };
     const workflows = new WorkflowManager(config, emit);
     const fastmoss = new FastMossIntegration();
+    let relayStatus = { ready: false };
     const app = express();
     app.disable("x-powered-by");
     app.use(express.json({ limit: "30mb" }));
@@ -56,7 +57,7 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION }));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
     app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
     app.use((req, res, next) => {
         if (validToken(req, requestUrl(req, config), config.token))
@@ -285,7 +286,7 @@ export function startHttpServer() {
         console.log("Codex MCP is not installed by this command.");
         console.log("Optional MCP add: codex mcp add infinite-canvas -- npx -y @xiaohhhh1/canvas-agent mcp");
         console.log("Remove manually added MCP: codex mcp remove infinite-canvas");
-        startRelayBridge(config);
+        startRelayBridge(config, { onStatus: (status) => { relayStatus = status; } });
         if (logger.enabled)
             console.log(`Debug log: ${logger.filePath}`);
         logger.info("Canvas Agent started", { url: config.url, workspace: ensureSiteWorkspace(config).workspacePath, debugLog: logger.filePath });

package/package.json

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