@nextclaw/remote 0.1.18 → 0.1.20

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,342 @@ var RemoteRelayBridge = class {
   }
 };
 
+// src/remote-app.adapter.ts
+import WebSocket2 from "ws";
+
+// src/remote-app-stream.ts
+function parseRemoteSseFrame(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 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) {
+    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 response = await this.openStreamResponse(frame, controller);
+      if (!response) {
+        return;
+      }
+      const finalResult = await readRemoteAppStreamResult({
+        response,
+        onEvent: (event) => {
+          this.send({
+            type: "client.stream.event",
+            clientId: frame.clientId,
+            streamId: frame.streamId,
+            event: event.event,
+            payload: event.payload
+          });
+        }
+      });
+      this.send({
+        type: "client.stream.end",
+        clientId: frame.clientId,
+        streamId: frame.streamId,
+        result: finalResult
+      });
+    } 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 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;
+    }
+    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 +750,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 +799,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 +832,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 +867,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.20",
   "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",
-    "@nextclaw/core": "0.9.8",
-    "@nextclaw/server": "0.10.22"
+    "ws": "^8.18.0",
+    "@nextclaw/server": "0.10.24",
+    "@nextclaw/core": "0.9.8"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
+    "@types/ws": "^8.5.14",
     "prettier": "^3.3.3",
     "tsup": "^8.3.5",
     "typescript": "^5.6.3"