@nextclaw/remote 0.1.19 → 0.1.21

package/dist/index.js

@@ -405,17 +405,9 @@ var RemoteRelayBridge = class {
 
 // src/remote-app.adapter.ts
 import WebSocket2 from "ws";
-function toWebSocketUrl(origin, path) {
-  const normalizedOrigin = origin.replace(/\/$/, "");
-  if (normalizedOrigin.startsWith("https://")) {
-    return `${normalizedOrigin.replace(/^https:/, "wss:")}${path}`;
-  }
-  if (normalizedOrigin.startsWith("http://")) {
-    return `${normalizedOrigin.replace(/^http:/, "ws:")}${path}`;
-  }
-  return `${normalizedOrigin}${path}`;
-}
-function parseSseFrame(frame) {
+
+// src/remote-app-stream.ts
+function parseRemoteSseFrame(frame) {
   const lines = frame.split("\n");
   let event = "";
   const dataLines = [];
@@ -440,16 +432,100 @@ function parseSseFrame(frame) {
     return { event };
   }
   try {
-    return {
-      event,
-      payload: JSON.parse(data)
-    };
+    return { event, payload: JSON.parse(data) };
   } catch {
-    return {
-      event,
-      payload: data
-    };
+    return { event, payload: data };
+  }
+}
+function readRemoteStreamError(payload, fallback) {
+  if (typeof payload === "object" && payload && "error" in payload) {
+    const typed = payload;
+    if (typed.error?.message) {
+      return typed.error.message;
+    }
+  }
+  if (typeof payload === "string" && payload.trim()) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function processRemoteStreamFrame(params) {
+  const frame = parseRemoteSseFrame(params.rawFrame);
+  if (!frame) {
+    return;
   }
+  if (frame.event === "final") {
+    params.setFinalResult(frame.payload);
+    return;
+  }
+  if (frame.event === "error") {
+    throw new Error(readRemoteStreamError(frame.payload, "stream failed"));
+  }
+  params.onEvent(frame);
+}
+function flushRemoteStreamFrames(params) {
+  let boundary = params.bufferState.value.indexOf("\n\n");
+  while (boundary !== -1) {
+    processRemoteStreamFrame({
+      rawFrame: params.bufferState.value.slice(0, boundary),
+      onEvent: params.onEvent,
+      setFinalResult: params.setFinalResult
+    });
+    params.bufferState.value = params.bufferState.value.slice(boundary + 2);
+    boundary = params.bufferState.value.indexOf("\n\n");
+  }
+}
+async function readRemoteAppStreamResult(params) {
+  const reader = params.response.body?.getReader();
+  if (!reader) {
+    throw new Error("SSE response body unavailable.");
+  }
+  const decoder = new TextDecoder();
+  const bufferState = { value: "" };
+  let finalResult = void 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      bufferState.value += decoder.decode(value, { stream: true });
+      flushRemoteStreamFrames({
+        bufferState,
+        onEvent: params.onEvent,
+        setFinalResult: (nextValue) => {
+          finalResult = nextValue;
+        }
+      });
+    }
+    if (bufferState.value.trim()) {
+      processRemoteStreamFrame({
+        rawFrame: bufferState.value,
+        onEvent: params.onEvent,
+        setFinalResult: (nextValue) => {
+          finalResult = nextValue;
+        }
+      });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (finalResult === void 0) {
+    throw new Error("stream ended without final event");
+  }
+  return finalResult;
+}
+
+// src/remote-app.adapter.ts
+function toWebSocketUrl(origin, path) {
+  const normalizedOrigin = origin.replace(/\/$/, "");
+  if (normalizedOrigin.startsWith("https://")) {
+    return `${normalizedOrigin.replace(/^https:/, "wss:")}${path}`;
+  }
+  if (normalizedOrigin.startsWith("http://")) {
+    return `${normalizedOrigin.replace(/^http:/, "ws:")}${path}`;
+  }
+  return `${normalizedOrigin}${path}`;
 }
 function readErrorMessage(body, fallback) {
   if (typeof body === "object" && body && "error" in body) {
@@ -524,113 +600,28 @@ var RemoteAppAdapter = class {
     const controller = new AbortController();
     this.activeStreams.set(frame.streamId, controller);
     try {
-      const bridgeCookie = await this.relayBridge.requestBridgeCookie();
-      const response = await fetch(new URL(frame.target.path, this.localOrigin), {
-        method: frame.target.method,
-        headers: this.createStreamHeaders(bridgeCookie),
-        body: this.buildRequestBody(frame.target),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        const errorBody = await this.readResponseBody(response);
-        this.send({
-          type: "client.stream.error",
-          clientId: frame.clientId,
-          streamId: frame.streamId,
-          message: readErrorMessage(errorBody, `HTTP ${response.status}`)
-        });
-        return;
-      }
-      const reader = response.body?.getReader();
-      if (!reader) {
-        this.send({
-          type: "client.stream.error",
-          clientId: frame.clientId,
-          streamId: frame.streamId,
-          message: "SSE response body unavailable."
-        });
+      const response = await this.openStreamResponse(frame, controller);
+      if (!response) {
         return;
       }
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let finalResult;
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) {
-            break;
-          }
-          buffer += decoder.decode(value, { stream: true });
-          let boundary = buffer.indexOf("\n\n");
-          while (boundary !== -1) {
-            const frameEvent = parseSseFrame(buffer.slice(0, boundary));
-            buffer = buffer.slice(boundary + 2);
-            if (frameEvent) {
-              if (frameEvent.event === "final") {
-                finalResult = frameEvent.payload;
-              } else if (frameEvent.event === "error") {
-                this.send({
-                  type: "client.stream.error",
-                  clientId: frame.clientId,
-                  streamId: frame.streamId,
-                  message: readErrorMessage(frameEvent.payload, "stream failed")
-                });
-                return;
-              } else {
-                this.send({
-                  type: "client.stream.event",
-                  clientId: frame.clientId,
-                  streamId: frame.streamId,
-                  event: frameEvent.event,
-                  payload: frameEvent.payload
-                });
-              }
-            }
-            boundary = buffer.indexOf("\n\n");
-          }
-        }
-        if (buffer.trim()) {
-          const frameEvent = parseSseFrame(buffer);
-          if (frameEvent) {
-            if (frameEvent.event === "final") {
-              finalResult = frameEvent.payload;
-            } else if (frameEvent.event === "error") {
-              this.send({
-                type: "client.stream.error",
-                clientId: frame.clientId,
-                streamId: frame.streamId,
-                message: readErrorMessage(frameEvent.payload, "stream failed")
-              });
-              return;
-            } else {
-              this.send({
-                type: "client.stream.event",
-                clientId: frame.clientId,
-                streamId: frame.streamId,
-                event: frameEvent.event,
-                payload: frameEvent.payload
-              });
-            }
-          }
-        }
-        if (finalResult === void 0) {
+      const finalResult = await readRemoteAppStreamResult({
+        response,
+        onEvent: (event) => {
           this.send({
-            type: "client.stream.error",
+            type: "client.stream.event",
             clientId: frame.clientId,
             streamId: frame.streamId,
-            message: "stream ended without final event"
+            event: event.event,
+            payload: event.payload
           });
-          return;
         }
-        this.send({
-          type: "client.stream.end",
-          clientId: frame.clientId,
-          streamId: frame.streamId,
-          result: finalResult
-        });
-      } finally {
-        reader.releaseLock();
-      }
+      });
+      this.send({
+        type: "client.stream.end",
+        clientId: frame.clientId,
+        streamId: frame.streamId,
+        result: finalResult
+      });
     } catch (error) {
       if (controller.signal.aborted) {
         return;
@@ -645,6 +636,26 @@ var RemoteAppAdapter = class {
       this.activeStreams.delete(frame.streamId);
     }
   }
+  async openStreamResponse(frame, controller) {
+    const bridgeCookie = await this.relayBridge.requestBridgeCookie();
+    const response = await fetch(new URL(frame.target.path, this.localOrigin), {
+      method: frame.target.method,
+      headers: this.createStreamHeaders(bridgeCookie),
+      body: this.buildRequestBody(frame.target),
+      signal: controller.signal
+    });
+    if (response.ok) {
+      return response;
+    }
+    const errorBody = await this.readResponseBody(response);
+    this.send({
+      type: "client.stream.error",
+      clientId: frame.clientId,
+      streamId: frame.streamId,
+      message: readErrorMessage(errorBody, `HTTP ${response.status}`)
+    });
+    return null;
+  }
   async ensureEventSocket() {
     if (this.localEventSocket && this.localEventSocket.readyState === WebSocket2.OPEN) {
       return;
@@ -728,6 +739,19 @@ 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
+];
+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.ts
 var RemoteConnector = class {
   constructor(deps) {
@@ -923,7 +947,7 @@ var RemoteConnector = class {
           lastError: null
         });
       }
-      return { device, aborted: outcome === "aborted" };
+      return { device, outcome: outcome === "aborted" ? "aborted" : "retry" };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.writeRemoteState(params.opts.statusStore, {
@@ -936,7 +960,10 @@ var RemoteConnector = class {
         lastError: message
       });
       this.logger.error(`Remote connector error: ${message}`);
-      return { device: params.device, aborted: false };
+      return {
+        device: params.device,
+        outcome: isTerminalRemoteConnectorError(error) ? "stop" : "retry"
+      };
     }
   }
   async run(opts = {}) {
@@ -946,10 +973,15 @@ var RemoteConnector = class {
     );
     await relayBridge.ensureLocalUiHealthy();
     let device = null;
+    let preserveRuntimeError = false;
     while (!opts.signal?.aborted) {
       const cycle = await this.runCycle({ device, context, relayBridge, opts });
       device = cycle.device;
-      if (cycle.aborted || !context.autoReconnect || opts.signal?.aborted) {
+      if (cycle.outcome === "stop") {
+        preserveRuntimeError = true;
+        break;
+      }
+      if (cycle.outcome === "aborted" || !context.autoReconnect || opts.signal?.aborted) {
         break;
       }
       this.logger.warn("Remote connector disconnected. Reconnecting in 3s...");
@@ -959,6 +991,9 @@ var RemoteConnector = class {
         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.19",
+  "version": "0.1.21",
   "private": false,
   "description": "Remote access runtime for NextClaw device registration, relay bridging, and service-managed connectivity.",
   "type": "module",
@@ -31,7 +31,7 @@
     "commander": "^12.1.0",
     "ws": "^8.18.0",
     "@nextclaw/core": "0.9.8",
-    "@nextclaw/server": "0.10.23"
+    "@nextclaw/server": "0.10.25"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",