openclaw-navigator 5.4.2 → 5.5.1

package/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * openclaw-navigator v5.4.2
+ * openclaw-navigator v5.5.1
  *
  * One-command bridge + tunnel for the Navigator browser.
  * Starts a local bridge, creates a Cloudflare tunnel automatically,
@@ -1116,51 +1116,183 @@ function handleRequest(req, res) {
     return;
   }
 
-  // ── Reverse proxy: /api/* → OC Gateway (localhost:ocGatewayPort) ──────────
-  // ALL /api/* requests go to the OC gateway EXCEPT:
-  //   - /api/auth/* → falls through to web UI (NextAuth login/session)
-  //   - /api/sessions/respond + /api/sessions/stream → handled locally above
-  // The OC web UI frontend expects /api/agents, /api/sessions/*, /api/chat/*,
-  // etc. to reach the gateway. Only /api/auth/* is a Next.js API route.
-  if (path.startsWith("/api/") && !path.startsWith("/api/auth/") && path !== "/api/auth") {
-    const targetURL = `${path}${url.search}`;
-
-    const proxyOpts = {
-      hostname: "127.0.0.1",
-      port: ocGatewayPort,
-      path: targetURL,
-      method: req.method,
-      headers: {
-        ...req.headers,
-        host: `127.0.0.1:${ocGatewayPort}`,
-      },
-    };
-
-    const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
-      const headers = { ...proxyRes.headers };
-      headers["access-control-allow-origin"] = "*";
-      headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, OPTIONS";
-      headers["access-control-allow-headers"] = "Content-Type, Authorization";
-      res.writeHead(proxyRes.statusCode ?? 502, headers);
-      proxyRes.pipe(res, { end: true });
-    });
+  // ── Smart proxy: /api/sessions/send → OC Gateway + SSE bridge ───────────
+  // This is the main chat send endpoint. The gateway may return:
+  //   (a) JSON: { ok, response, message, ... } — pass through + broadcast
+  //   (b) SSE: text/event-stream with data lines — collect + broadcast + return JSON
+  // Either way, the response is also broadcast via WebSocket so Navigator's
+  // chat pane (OCChatService) gets it via both HTTP and WS.
+  if (path === "/api/sessions/send" && req.method === "POST") {
+    readBody(req)
+      .then((bodyStr) => {
+        const proxyOpts = {
+          hostname: "127.0.0.1",
+          port: ocGatewayPort,
+          path: `${path}${url.search}`,
+          method: "POST",
+          headers: {
+            ...req.headers,
+            host: `127.0.0.1:${ocGatewayPort}`,
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(bodyStr),
+          },
+        };
+
+        const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
+          const contentType = (proxyRes.headers["content-type"] || "").toLowerCase();
+          const isSSE = contentType.includes("text/event-stream");
+
+          if (isSSE) {
+            // ── SSE response: collect stream, broadcast chunks, return JSON ──
+            let fullText = "";
+            let buffer = "";
+
+            proxyRes.setEncoding("utf-8");
+            proxyRes.on("data", (chunk) => {
+              buffer += chunk;
+              // Parse SSE lines
+              const lines = buffer.split("\n");
+              buffer = lines.pop() || ""; // keep incomplete line
+              for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                  const raw = line.slice(6).trim();
+                  if (raw === "[DONE]") {
+                    continue;
+                  }
+                  try {
+                    const evt = JSON.parse(raw);
+                    // Extract text from common SSE shapes
+                    const text =
+                      evt.text || evt.content || evt.delta?.text || evt.delta?.content || "";
+                    if (text) {
+                      fullText += text;
+                      broadcastToWS({
+                        type: "chat.delta",
+                        text: fullText,
+                        delta: text,
+                        sessionKey: "main",
+                        timestamp: Date.now(),
+                      });
+                    }
+                  } catch {
+                    // Non-JSON SSE line — treat as plain text
+                    if (raw && raw !== "[DONE]") {
+                      fullText += raw;
+                    }
+                  }
+                }
+              }
+            });
+
+            proxyRes.on("end", () => {
+              // Process any remaining buffer
+              if (buffer.startsWith("data: ")) {
+                const raw = buffer.slice(6).trim();
+                if (raw && raw !== "[DONE]") {
+                  try {
+                    const evt = JSON.parse(raw);
+                    fullText += evt.text || evt.content || evt.delta?.text || "";
+                  } catch {
+                    fullText += raw;
+                  }
+                }
+              }
+
+              if (fullText) {
+                // Broadcast final via WebSocket
+                broadcastToWS({
+                  type: "chat.final",
+                  text: fullText,
+                  content: fullText,
+                  sessionKey: "main",
+                  role: "assistant",
+                  timestamp: Date.now(),
+                });
+                console.log(`  ${DIM}SSE→WS bridge: ${fullText.substring(0, 80)}...${RESET}`);
+              }
+
+              // Return clean JSON to the caller (OCChatService)
+              sendJSON(res, 200, {
+                ok: true,
+                response: fullText || null,
+                format: "sse-bridged",
+                delivered: wsClients.size,
+              });
+            });
+
+            proxyRes.on("error", () => {
+              sendJSON(res, 502, { ok: false, error: "SSE stream error from gateway" });
+            });
+          } else {
+            // ── JSON response: collect body, broadcast if it has a response, pass through ──
+            const chunks = [];
+            proxyRes.on("data", (c) => chunks.push(c));
+            proxyRes.on("end", () => {
+              const body = Buffer.concat(chunks).toString("utf-8");
+              let jsonBody;
+              try {
+                jsonBody = JSON.parse(body);
+              } catch {
+                // Not JSON — pass through raw
+                const headers = { ...proxyRes.headers };
+                headers["access-control-allow-origin"] = "*";
+                res.writeHead(proxyRes.statusCode ?? 200, headers);
+                res.end(body);
+                return;
+              }
+
+              // If the gateway returned an inline response, broadcast it via WebSocket
+              const inlineResponse =
+                jsonBody.response || jsonBody.message || jsonBody.answer || jsonBody.text || "";
+              if (inlineResponse) {
+                broadcastToWS({
+                  type: "chat.final",
+                  text: inlineResponse,
+                  content: inlineResponse,
+                  sessionKey: "main",
+                  role: "assistant",
+                  timestamp: Date.now(),
+                });
+                console.log(
+                  `  ${DIM}Inline response→WS: ${inlineResponse.substring(0, 80)}...${RESET}`,
+                );
+              }
+
+              sendJSON(res, proxyRes.statusCode ?? 200, jsonBody);
+            });
+          }
+        });
 
-    proxyReq.on("error", (err) => {
-      sendJSON(res, 502, {
-        ok: false,
-        error: `OC Gateway not reachable on port ${ocGatewayPort}`,
-        detail: err.message,
-        hint:
-          "Make sure the OC gateway is running on port " +
-          ocGatewayPort +
-          " (openclaw gateway start)",
-      });
-    });
+        proxyReq.on("error", (err) => {
+          sendJSON(res, 502, {
+            ok: false,
+            error: `OC Gateway not reachable on port ${ocGatewayPort}`,
+            detail: err.message,
+          });
+        });
 
-    req.pipe(proxyReq, { end: true });
+        proxyReq.write(bodyStr);
+        proxyReq.end();
+      })
+      .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
     return;
   }
 
+  // ── /api/* routing strategy ──────────────────────────────────────────────
+  // NO direct gateway proxy for /api/* here. The web UI (Next.js on port 4000)
+  // has its own /api/* routes that act as a BFF (Backend for Frontend) —
+  // they call the gateway internally (localhost:18789) and return clean JSON.
+  // Routing /api/* directly to the gateway bypasses the BFF and breaks things
+  // (e.g. /api/agents returns raw SSE instead of JSON).
+  //
+  // Specific bridge-handled routes (above this point):
+  //   - /api/sessions/respond → local WebSocket broadcast
+  //   - /api/sessions/stream  → local WebSocket broadcast
+  //   - /api/sessions/send    → smart SSE bridge to gateway (sidepane chat)
+  //
+  // Everything else (/api/agents, /api/auth/*, /api/chat/*, etc.) falls through
+  // to the fallback proxy below, which sends it to port 4000 (web UI).
+
   // ── Root → redirect to /ui/ (Next.js basePath) or show bridge status ──
   if (req.method === "GET" && path === "") {
     // Quick probe to check if OC UI is running

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-navigator",
-  "version": "5.4.2",
+  "version": "5.5.1",
   "description": "One-command bridge + tunnel for the Navigator browser — works on any machine, any OS",
   "keywords": [
     "browser",