@nextclaw/remote 0.1.25 → 0.1.27

package/dist/index.d.ts

@@ -163,8 +163,14 @@ declare class RemoteConnector {
         platformClient: RemotePlatformClient;
         relayBridgeFactory?: (localOrigin: string) => RemoteRelayBridge;
         logger?: RemoteLogger;
+        createSocket?: (wsUrl: string) => WebSocket;
+        delayFn?: typeof delay;
+        random?: () => number;
     });
     private get logger();
+    private get delayFn();
+    private get random();
+    private createSocket;
     private connectOnce;
     private handleSocketMessage;
     private parseRelayFrame;

package/dist/index.js

@@ -707,6 +707,74 @@ var RemoteAppAdapter = class {
   }
 };
 
+// src/remote-connector-error.ts
+var TERMINAL_REMOTE_ERROR_PATTERNS = [
+  /invalid or expired token/i,
+  /missing bearer token/i,
+  /token expired/i,
+  /token is invalid/i,
+  /run "nextclaw login"/i,
+  /unexpected server response:\s*400/i,
+  /unexpected server response:\s*401/i,
+  /unexpected server response:\s*403/i,
+  /unexpected server response:\s*404/i,
+  /invalid url/i,
+  /unsupported protocol/i
+];
+function isTerminalRemoteConnectorError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return TERMINAL_REMOTE_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+
+// src/remote-connector-retry.utils.ts
+var BASE_RECONNECT_DELAY_MS = 3e3;
+var MAX_RECONNECT_DELAY_MS = 6e4;
+var RECONNECT_JITTER_RATIO = 0.2;
+var MAX_CONSECUTIVE_RECONNECT_FAILURES = 6;
+function resolveReconnectDelayMs(attempt, random) {
+  const exponentialDelayMs = Math.min(
+    BASE_RECONNECT_DELAY_MS * 2 ** Math.max(0, attempt - 1),
+    MAX_RECONNECT_DELAY_MS
+  );
+  const jitterRatio = (random() * 2 - 1) * RECONNECT_JITTER_RATIO;
+  return Math.max(
+    BASE_RECONNECT_DELAY_MS,
+    Math.round(exponentialDelayMs * (1 + jitterRatio))
+  );
+}
+function formatReconnectDelay(delayMs) {
+  const seconds = delayMs / 1e3;
+  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(1)}s`;
+}
+function buildReconnectHaltedMessage(message) {
+  return `${message} Auto-reconnect stopped after ${MAX_CONSECUTIVE_RECONNECT_FAILURES} consecutive failures to avoid wasting remote requests. Use Remote Access repair or restart the service after checking platform/network availability.`;
+}
+
+// src/remote-connector-websocket-error.utils.ts
+function readRemoteConnectorSocketErrorMessage(event) {
+  const typedEvent = event;
+  if (typeof typedEvent.message === "string") {
+    const directMessage = typedEvent.message.trim();
+    if (directMessage.length > 0) {
+      return directMessage;
+    }
+  }
+  const nestedError = typedEvent.error;
+  if (nestedError instanceof Error && nestedError.message.trim().length > 0) {
+    return nestedError.message.trim();
+  }
+  if (typeof nestedError === "string" && nestedError.trim().length > 0) {
+    return nestedError.trim();
+  }
+  if (typeof nestedError === "object" && nestedError && typeof nestedError.message === "string") {
+    const nestedMessage = nestedError.message.trim();
+    if (nestedMessage.length > 0) {
+      return nestedMessage;
+    }
+  }
+  return "Remote connector websocket failed.";
+}
+
 // src/remote-connector.ts
 var RemoteConnector = class {
   constructor(deps) {
@@ -715,9 +783,18 @@ var RemoteConnector = class {
   get logger() {
     return this.deps.logger ?? console;
   }
+  get delayFn() {
+    return this.deps.delayFn ?? delay;
+  }
+  get random() {
+    return this.deps.random ?? Math.random;
+  }
+  createSocket(wsUrl) {
+    return this.deps.createSocket?.(wsUrl) ?? new WebSocket(wsUrl);
+  }
   async connectOnce(params) {
     return await new Promise((resolve, reject) => {
-      const socket = new WebSocket(params.wsUrl);
+      const socket = this.createSocket(params.wsUrl);
       const appAdapter = new RemoteAppAdapter(params.localOrigin, socket);
       let settled = false;
       let aborted = false;
@@ -783,13 +860,13 @@ var RemoteConnector = class {
         appAdapter.stop();
         finishResolve(aborted ? "aborted" : "closed");
       });
-      socket.addEventListener("error", () => {
+      socket.addEventListener("error", (event) => {
         appAdapter.stop();
         if (aborted) {
           finishResolve("aborted");
           return;
         }
-        finishReject(new Error("Remote connector websocket failed."));
+        finishReject(new Error(readRemoteConnectorSocketErrorMessage(event)));
       });
     });
   }
@@ -869,6 +946,7 @@ var RemoteConnector = class {
     statusStore?.write(next);
   }
   async runCycle(params) {
+    let device = params.device;
     try {
       this.writeRemoteState(params.opts.statusStore, {
         enabled: true,
@@ -879,7 +957,7 @@ var RemoteConnector = class {
         localOrigin: params.context.localOrigin,
         lastError: null
       });
-      const device = await this.ensureDevice({ device: params.device, context: params.context });
+      device = await this.ensureDevice({ device, context: params.context });
       const wsUrl = `${params.context.platformBase.replace(/^http/i, "ws")}/platform/remote/connect?instanceId=${encodeURIComponent(device.id)}&token=${encodeURIComponent(params.context.token)}`;
       const outcome = await this.connectOnce({
         wsUrl,
@@ -902,7 +980,12 @@ var RemoteConnector = class {
           lastError: null
         });
       }
-      return { device, aborted: outcome === "aborted" };
+      return {
+        device,
+        outcome: outcome === "aborted" ? "aborted" : "retry",
+        retryFailure: false,
+        lastError: null
+      };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.writeRemoteState(params.opts.statusStore, {
@@ -915,7 +998,12 @@ var RemoteConnector = class {
         lastError: message
       });
       this.logger.error(`Remote connector error: ${message}`);
-      return { device: params.device, aborted: false };
+      return {
+        device,
+        outcome: isTerminalRemoteConnectorError(error) ? "stop" : "retry",
+        retryFailure: true,
+        lastError: message
+      };
     }
   }
   async run(opts = {}) {
@@ -925,19 +1013,49 @@ var RemoteConnector = class {
     );
     await relayBridge.ensureLocalUiHealthy();
     let device = null;
+    let preserveRuntimeError = false;
+    let consecutiveReconnectFailures = 0;
     while (!opts.signal?.aborted) {
       const cycle = await this.runCycle({ device, context, relayBridge, opts });
       device = cycle.device;
-      if (cycle.aborted || !context.autoReconnect || opts.signal?.aborted) {
+      consecutiveReconnectFailures = cycle.retryFailure ? consecutiveReconnectFailures + 1 : 0;
+      if (cycle.outcome === "stop") {
+        preserveRuntimeError = true;
         break;
       }
-      this.logger.warn("Remote connector disconnected. Reconnecting in 3s...");
+      if (cycle.outcome === "aborted" || !context.autoReconnect || opts.signal?.aborted) {
+        break;
+      }
+      if (cycle.retryFailure && consecutiveReconnectFailures >= MAX_CONSECUTIVE_RECONNECT_FAILURES) {
+        const haltedMessage = buildReconnectHaltedMessage(
+          cycle.lastError ?? "Remote connector websocket failed."
+        );
+        this.writeRemoteState(opts.statusStore, {
+          enabled: true,
+          state: "error",
+          deviceId: device?.id,
+          deviceName: context.displayName,
+          platformBase: context.platformBase,
+          localOrigin: context.localOrigin,
+          lastError: haltedMessage
+        });
+        this.logger.error(`Remote connector error: ${haltedMessage}`);
+        preserveRuntimeError = true;
+        break;
+      }
+      const reconnectDelayMs = resolveReconnectDelayMs(cycle.retryFailure ? consecutiveReconnectFailures : 1, this.random);
+      this.logger.warn(
+        `Remote connector disconnected. Reconnecting in ${formatReconnectDelay(reconnectDelayMs)}...`
+      );
       try {
-        await delay(3e3, opts.signal);
+        await this.delayFn(reconnectDelayMs, opts.signal);
       } catch {
         break;
       }
     }
+    if (preserveRuntimeError) {
+      return;
+    }
     this.writeRemoteState(opts.statusStore, {
       enabled: opts.mode === "service" ? true : Boolean(context.config.remote.enabled),
       state: opts.signal?.aborted ? "disconnected" : "disabled",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/remote",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "private": false,
   "description": "Remote access runtime for NextClaw device registration, relay bridging, and service-managed connectivity.",
   "type": "module",
@@ -30,8 +30,8 @@
   "dependencies": {
     "commander": "^12.1.0",
     "ws": "^8.18.0",
-    "@nextclaw/core": "0.9.11",
-    "@nextclaw/server": "0.10.31"
+    "@nextclaw/server": "0.10.33",
+    "@nextclaw/core": "0.9.11"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",