@nextclaw/remote 0.1.18 → 0.1.19

package/dist/index.d.ts

@@ -153,7 +153,7 @@ declare class RemoteRelayBridge {
     ensureLocalUiHealthy(): Promise<void>;
     forward(frame: RelayRequestFrame, socket: WebSocket): Promise<void>;
     private createForwardHeaders;
-    private requestBridgeCookie;
+    requestBridgeCookie(): Promise<string | null>;
     private sendStreamingResponse;
 }
 

package/dist/index.js

@@ -403,6 +403,331 @@ 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) {
+  const lines = frame.split("\n");
+  let event = "";
+  const dataLines = [];
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (!line || line.startsWith(":")) {
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      event = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (!event) {
+    return null;
+  }
+  const data = dataLines.join("\n");
+  if (!data) {
+    return { event };
+  }
+  try {
+    return {
+      event,
+      payload: JSON.parse(data)
+    };
+  } catch {
+    return {
+      event,
+      payload: data
+    };
+  }
+}
+function readErrorMessage(body, fallback) {
+  if (typeof body === "object" && body && "error" in body) {
+    const typed = body;
+    if (typed.error?.message) {
+      return typed.error.message;
+    }
+  }
+  if (typeof body === "string" && body.trim()) {
+    return body.trim();
+  }
+  return fallback;
+}
+var RemoteAppAdapter = class {
+  constructor(localOrigin, platformSocket) {
+    this.localOrigin = localOrigin;
+    this.platformSocket = platformSocket;
+    this.relayBridge = new RemoteRelayBridge(localOrigin);
+  }
+  relayBridge;
+  activeStreams = /* @__PURE__ */ new Map();
+  localEventSocket = null;
+  eventReconnectTimer = null;
+  shuttingDown = false;
+  async start() {
+    await this.ensureEventSocket();
+  }
+  stop() {
+    this.shuttingDown = true;
+    if (this.eventReconnectTimer) {
+      clearTimeout(this.eventReconnectTimer);
+      this.eventReconnectTimer = null;
+    }
+    this.localEventSocket?.close();
+    this.localEventSocket = null;
+    for (const controller of this.activeStreams.values()) {
+      controller.abort();
+    }
+    this.activeStreams.clear();
+  }
+  async handle(frame) {
+    if (frame.type === "client.request") {
+      await this.handleRequest(frame);
+      return;
+    }
+    if (frame.type === "client.stream.open") {
+      void this.handleStream(frame);
+      return;
+    }
+    if (frame.type === "client.stream.cancel") {
+      this.activeStreams.get(frame.streamId)?.abort();
+      this.activeStreams.delete(frame.streamId);
+    }
+  }
+  async handleRequest(frame) {
+    const bridgeCookie = await this.relayBridge.requestBridgeCookie();
+    const response = await fetch(new URL(frame.target.path, this.localOrigin), {
+      method: frame.target.method,
+      headers: this.createJsonHeaders(bridgeCookie),
+      body: this.buildRequestBody(frame.target)
+    });
+    const body = await this.readResponseBody(response);
+    this.send({
+      type: "client.response",
+      clientId: frame.clientId,
+      id: frame.id,
+      status: response.status,
+      body
+    });
+  }
+  async handleStream(frame) {
+    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."
+        });
+        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) {
+          this.send({
+            type: "client.stream.error",
+            clientId: frame.clientId,
+            streamId: frame.streamId,
+            message: "stream ended without final event"
+          });
+          return;
+        }
+        this.send({
+          type: "client.stream.end",
+          clientId: frame.clientId,
+          streamId: frame.streamId,
+          result: finalResult
+        });
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      if (controller.signal.aborted) {
+        return;
+      }
+      this.send({
+        type: "client.stream.error",
+        clientId: frame.clientId,
+        streamId: frame.streamId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.activeStreams.delete(frame.streamId);
+    }
+  }
+  async ensureEventSocket() {
+    if (this.localEventSocket && this.localEventSocket.readyState === WebSocket2.OPEN) {
+      return;
+    }
+    const bridgeCookie = await this.relayBridge.requestBridgeCookie();
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket2(toWebSocketUrl(this.localOrigin, "/ws"), {
+        headers: bridgeCookie ? { Cookie: bridgeCookie } : void 0
+      });
+      this.localEventSocket = socket;
+      socket.on("open", () => resolve());
+      socket.on("message", (data) => {
+        try {
+          const event = JSON.parse(String(data ?? ""));
+          this.send({
+            type: "client.event",
+            event
+          });
+        } catch (error) {
+          console.error("Failed to parse local ui event:", error);
+        }
+      });
+      socket.on("close", () => {
+        this.localEventSocket = null;
+        if (!this.shuttingDown) {
+          this.scheduleEventReconnect();
+        }
+      });
+      socket.on("error", (error) => {
+        if (!this.shuttingDown) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    });
+  }
+  scheduleEventReconnect() {
+    if (this.eventReconnectTimer) {
+      return;
+    }
+    this.eventReconnectTimer = setTimeout(() => {
+      this.eventReconnectTimer = null;
+      void this.ensureEventSocket().catch(() => void 0);
+    }, 3e3);
+  }
+  buildRequestBody(target) {
+    if (target.method === "GET" || target.method === "HEAD") {
+      return void 0;
+    }
+    if (target.body === void 0) {
+      return void 0;
+    }
+    return new TextEncoder().encode(JSON.stringify(target.body));
+  }
+  createJsonHeaders(bridgeCookie) {
+    const headers = new Headers({
+      "Content-Type": "application/json"
+    });
+    if (bridgeCookie) {
+      headers.set("cookie", bridgeCookie);
+    }
+    return headers;
+  }
+  createStreamHeaders(bridgeCookie) {
+    const headers = this.createJsonHeaders(bridgeCookie);
+    headers.set("Accept", "text/event-stream");
+    return headers;
+  }
+  async readResponseBody(response) {
+    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    const text = await response.text();
+    return text;
+  }
+  send(frame) {
+    if (this.platformSocket.readyState !== WebSocket2.OPEN) {
+      return;
+    }
+    this.platformSocket.send(JSON.stringify(frame));
+  }
+};
+
 // src/remote-connector.ts
 var RemoteConnector = class {
   constructor(deps) {
@@ -414,6 +739,7 @@ var RemoteConnector = class {
   async connectOnce(params) {
     return await new Promise((resolve, reject) => {
       const socket = new WebSocket(params.wsUrl);
+      const appAdapter = new RemoteAppAdapter(params.localOrigin, socket);
       let settled = false;
       let aborted = false;
       const cleanup = () => {
@@ -462,14 +788,24 @@ var RemoteConnector = class {
           lastError: null
         });
         this.logger.info(`\u2713 Remote connector connected: ${redactWsUrl(params.wsUrl)}`);
+        void appAdapter.start().catch((error) => {
+          this.logger.error(`Remote event bridge error: ${error instanceof Error ? error.message : String(error)}`);
+        });
       });
       socket.addEventListener("message", (event) => {
-        this.handleSocketMessage({ data: event.data, relayBridge: params.relayBridge, socket });
+        this.handleSocketMessage({
+          data: event.data,
+          relayBridge: params.relayBridge,
+          appAdapter,
+          socket
+        });
       });
       socket.addEventListener("close", () => {
+        appAdapter.stop();
         finishResolve(aborted ? "aborted" : "closed");
       });
       socket.addEventListener("error", () => {
+        appAdapter.stop();
         if (aborted) {
           finishResolve("aborted");
           return;
@@ -485,11 +821,33 @@ var RemoteConnector = class {
         return;
       }
       try {
-        await params.relayBridge.forward(frame, params.socket);
+        if (frame.type === "request") {
+          await params.relayBridge.forward(frame, params.socket);
+          return;
+        }
+        await params.appAdapter.handle(frame);
       } catch (error) {
+        if (frame.type === "request") {
+          params.socket.send(JSON.stringify({
+            type: "response.error",
+            requestId: frame.requestId,
+            message: error instanceof Error ? error.message : String(error)
+          }));
+          return;
+        }
+        if (frame.type === "client.request") {
+          params.socket.send(JSON.stringify({
+            type: "client.request.error",
+            clientId: frame.clientId,
+            id: frame.id,
+            message: error instanceof Error ? error.message : String(error)
+          }));
+          return;
+        }
         params.socket.send(JSON.stringify({
-          type: "response.error",
-          requestId: frame.requestId,
+          type: "client.stream.error",
+          clientId: frame.clientId,
+          streamId: frame.streamId,
           message: error instanceof Error ? error.message : String(error)
         }));
       }
@@ -498,7 +856,16 @@ var RemoteConnector = class {
   parseRelayFrame(data) {
     try {
       const frame = JSON.parse(String(data ?? ""));
-      return frame.type === "request" ? frame : null;
+      if (typeof frame !== "object" || !frame || typeof frame.type !== "string") {
+        return null;
+      }
+      if (frame.type === "request") {
+        return frame;
+      }
+      if (frame.type === "client.request" || frame.type === "client.stream.open" || frame.type === "client.stream.cancel") {
+        return frame;
+      }
+      return null;
     } catch {
       return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/remote",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "private": false,
   "description": "Remote access runtime for NextClaw device registration, relay bridging, and service-managed connectivity.",
   "type": "module",
@@ -29,11 +29,13 @@
   ],
   "dependencies": {
     "commander": "^12.1.0",
+    "ws": "^8.18.0",
     "@nextclaw/core": "0.9.8",
-    "@nextclaw/server": "0.10.22"
+    "@nextclaw/server": "0.10.23"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
+    "@types/ws": "^8.5.14",
     "prettier": "^3.3.3",
     "tsup": "^8.3.5",
     "typescript": "^5.6.3"