@nextclaw/remote 0.1.19 → 0.1.20

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}`)
-        });
+      const response = await this.openStreamResponse(frame, controller);
+      if (!response) {
         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."
-        });
-        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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/remote",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "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.8",
-    "@nextclaw/server": "0.10.23"
+    "@nextclaw/server": "0.10.24",
+    "@nextclaw/core": "0.9.8"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",