openclaw-navigator 5.7.0 → 5.7.2

package/cli.mjs

@@ -375,6 +375,22 @@ function getChatSession(sessionKey = "main") {
   return chatSessions.get(sessionKey);
 }
 
+// ── Cookie jar for BFF auth ────────────────────────────────────────────
+// Captures session cookies from web UI /api/auth responses so the bridge
+// can make authenticated server-side requests to /api/chat (for sidepane relay).
+let bffCookieJar = "";
+
+function captureBFFCookies(setCookieHeaders) {
+  if (!setCookieHeaders) return;
+  const cookies = Array.isArray(setCookieHeaders) ? setCookieHeaders : [setCookieHeaders];
+  // Extract just the cookie name=value (strip attributes like path, domain, etc.)
+  const extracted = cookies.map((c) => c.split(";")[0].trim()).filter(Boolean);
+  if (extracted.length > 0) {
+    bffCookieJar = extracted.join("; ");
+    console.log(`  ${DIM}Captured BFF cookies: ${bffCookieJar.substring(0, 60)}...${RESET}`);
+  }
+}
+
 // ── WebSocket server for chat (minimal, no dependencies) ────────────────
 // Tracks connected WebSocket clients. When the OC agent pushes messages
 // via /api/sessions/respond or /api/sessions/stream, we broadcast to all
@@ -1048,6 +1064,8 @@ function handleRequest(req, res) {
         headers["set-cookie"] = cookies.map((c) =>
           c.replace(/;\s*domain=[^;]*/gi, "").replace(/;\s*secure/gi, ""),
         );
+        // Also capture these for server-side relay auth (sidepane chat)
+        captureBFFCookies(proxyRes.headers["set-cookie"]);
       }
 
       res.writeHead(proxyRes.statusCode ?? 502, headers);
@@ -1183,6 +1201,8 @@ function handleRequest(req, res) {
           messages: chatHistory,
           stream: true,
         });
+        // Build cookie header: prefer captured BFF cookies, fall back to browser's cookies
+        const relayCookie = bffCookieJar || req.headers.cookie || "";
         const proxyOpts = {
           hostname: "127.0.0.1",
           port: ocUIPort,
@@ -1192,12 +1212,68 @@ function handleRequest(req, res) {
           headers: {
             "content-type": "application/json",
             "content-length": Buffer.byteLength(proxyBody),
+            ...(relayCookie ? { cookie: relayCookie } : {}),
           },
         };
 
-        console.log(`  ${DIM}→ Relaying to BFF /api/chat (port ${ocUIPort}) with ${chatHistory.length} messages${RESET}`);
+        console.log(`  ${DIM}→ Relaying to BFF /api/chat (port ${ocUIPort}) with ${chatHistory.length} messages${relayCookie ? " +cookie" : " NO-COOKIE"}${RESET}`);
+
+        // Helper: send the relay request (with optional retry after login)
+        function sendBFFRelay(opts, body, retryCount = 0) {
+        const proxyReq = httpRequest(opts, (proxyRes) => {
+          // Capture any cookies the BFF sends (login session, etc.)
+          if (proxyRes.headers["set-cookie"]) {
+            captureBFFCookies(proxyRes.headers["set-cookie"]);
+          }
+
+          // If redirect (307/302 to /login) — follow it to seed cookies, then retry
+          if ((proxyRes.statusCode === 307 || proxyRes.statusCode === 302) && retryCount < 2) {
+            proxyRes.resume(); // drain
+            const loginPath = proxyRes.headers.location || "/login";
+            console.log(`  ${DIM}← BFF redirect → ${loginPath} — following to seed cookies...${RESET}`);
+
+            // Hit the login page to get session cookies
+            const loginReq = httpRequest(
+              {
+                hostname: "127.0.0.1",
+                port: ocUIPort,
+                path: loginPath,
+                method: "GET",
+                timeout: 5000,
+                headers: bffCookieJar ? { cookie: bffCookieJar } : {},
+              },
+              (loginRes) => {
+                if (loginRes.headers["set-cookie"]) {
+                  captureBFFCookies(loginRes.headers["set-cookie"]);
+                }
+                loginRes.resume(); // drain
+                console.log(`  ${DIM}← Login page: ${loginRes.statusCode} — cookies: ${bffCookieJar ? "yes" : "no"}${RESET}`);
+
+                // Retry the original request with new cookies
+                if (bffCookieJar) {
+                  opts.headers = { ...opts.headers, cookie: bffCookieJar };
+                  console.log(`  ${DIM}→ Retrying /api/chat with cookies...${RESET}`);
+                  sendBFFRelay(opts, body, retryCount + 1);
+                } else {
+                  console.log(`  ${DIM}No cookies from login — BFF may require real auth${RESET}`);
+                  broadcastToWS({
+                    type: "chat.final",
+                    text: "⚠️ Could not authenticate with OC — try opening the web UI first to log in.",
+                    content: "⚠️ Could not authenticate with OC — try opening the web UI first to log in.",
+                    sessionKey,
+                    role: "assistant",
+                    timestamp: Date.now(),
+                  });
+                }
+              },
+            );
+            loginReq.on("error", () => {
+              console.log(`  ${DIM}Login page unreachable${RESET}`);
+            });
+            loginReq.end();
+            return;
+          }
 
-        const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
           const contentType = (proxyRes.headers["content-type"] || "").toLowerCase();
           const isSSE = contentType.includes("text/event-stream");
           console.log(`  ${DIM}← BFF response: ${proxyRes.statusCode} ${contentType || "no-content-type"}${RESET}`);
@@ -1299,8 +1375,11 @@ function handleRequest(req, res) {
           console.log(`  ${DIM}BFF relay failed: ${err.message}${RESET}`);
         });
 
-        proxyReq.write(proxyBody);
+        proxyReq.write(body);
         proxyReq.end();
+        } // end sendBFFRelay
+
+        sendBFFRelay(proxyOpts, proxyBody);
       })
       .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
     return;
@@ -1411,6 +1490,11 @@ function handleRequest(req, res) {
         console.log(`  ${DIM}← ${proxyRes.statusCode} ${ct} for ${path}${RESET}`);
       }
 
+      // Capture session cookies from BFF (for server-side relay auth)
+      if (proxyRes.headers["set-cookie"]) {
+        captureBFFCookies(proxyRes.headers["set-cookie"]);
+      }
+
       // CORS
       headers["access-control-allow-origin"] = "*";
       headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, OPTIONS";
@@ -1501,78 +1585,62 @@ function handleRequest(req, res) {
         return;
       }
 
-      // ── SSE passthrough for streaming endpoints (/api/chat) ──────────
-      // Pipe SSE through transparently. Use setNoDelay to prevent TCP buffering
-      // that would cause the browser to receive multiple SSE events in one chunk.
-      // Also tap the stream to broadcast via WebSocket (for Navigator sidepane)
-      // and store the response in the bridge chat session.
+      // ── SSE→JSON for streaming endpoints (/api/chat) ──────────────────
+      // The BFF returns SSE but the web UI's parser can't handle SSE through
+      // a reverse proxy (it does JSON.parse on raw chunks without stripping
+      // the "data: " prefix). So we collect the full SSE stream, extract the
+      // text, and return a single JSON response. Also store + broadcast via WS.
       if (isSSE && isStreamingEndpoint) {
-        console.log(`  ${DIM}SSE passthrough: ${path}${RESET}`);
-
-        // Disable TCP Nagle for immediate per-event delivery
-        if (res.socket) res.socket.setNoDelay(true);
-
-        // Clean transfer headers — let Node.js manage chunked encoding
-        delete headers["content-length"];
-        delete headers["transfer-encoding"];
-        res.writeHead(proxyRes.statusCode ?? 200, headers);
+        console.log(`  ${DIM}SSE→JSON collect: ${path}${RESET}`);
 
         let fullText = "";
-        let sseBuffer = "";
+        let sseData = "";
 
         proxyRes.setEncoding("utf-8");
         proxyRes.on("data", (chunk) => {
-          sseBuffer += chunk;
-
-          // Split by double-newline (SSE event boundary)
-          const events = sseBuffer.split("\n\n");
-          sseBuffer = events.pop() || ""; // Keep incomplete event in buffer
-
-          for (const event of events) {
-            const trimmed = event.trim();
-            if (!trimmed) continue;
-
-            // Forward the COMPLETE SSE event to browser (preserving data: prefix)
-            res.write(trimmed + "\n\n");
-
-            // Tap for WebSocket broadcast
-            for (const line of trimmed.split("\n")) {
-              if (line.startsWith("data: ")) {
-                const raw = line.slice(6).trim();
-                if (raw === "[DONE]" || !raw) continue;
-                try {
-                  const evt = JSON.parse(raw);
-                  const delta =
-                    evt.choices?.[0]?.delta?.content ||
-                    evt.delta?.text ||
-                    evt.text ||
-                    evt.content ||
-                    "";
-                  if (delta) {
-                    fullText += delta;
-                    broadcastToWS({
-                      type: "chat.delta",
-                      text: fullText,
-                      delta,
-                      sessionKey: "main",
-                      timestamp: Date.now(),
-                    });
-                  }
-                } catch {
-                  /* non-JSON SSE event */
-                }
-              }
-            }
-          }
+          sseData += chunk;
         });
 
         proxyRes.on("end", () => {
-          // Flush remaining buffer
-          if (sseBuffer.trim()) {
-            res.write(sseBuffer + "\n\n");
+          // Extract text from all SSE events
+          for (const line of sseData.split("\n")) {
+            if (line.startsWith("data: ")) {
+              const raw = line.slice(6).trim();
+              if (raw === "[DONE]" || !raw) continue;
+              try {
+                const evt = JSON.parse(raw);
+                const delta =
+                  evt.choices?.[0]?.delta?.content ||
+                  evt.delta?.text ||
+                  evt.text ||
+                  evt.content ||
+                  "";
+                if (delta) fullText += delta;
+              } catch {
+                if (raw) fullText += raw;
+              }
+            }
           }
 
-          // Store and broadcast final response
+          // Return as a single OpenAI-compatible JSON response
+          const result = {
+            id: "chatcmpl_bridge_" + Date.now(),
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            choices: [{
+              index: 0,
+              message: { role: "assistant", content: fullText },
+              finish_reason: "stop",
+            }],
+          };
+
+          headers["content-type"] = "application/json";
+          delete headers["content-length"];
+          delete headers["transfer-encoding"];
+          res.writeHead(200, headers);
+          res.end(JSON.stringify(result));
+
+          // Store in bridge session + broadcast via WebSocket
           if (fullText) {
             const session = getChatSession("main");
             session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
@@ -1589,12 +1657,11 @@ function handleRequest(req, res) {
           } else {
             console.log(`  ${DIM}SSE stream ended with no content${RESET}`);
           }
-          res.end();
         });
 
         proxyRes.on("error", (err) => {
           console.log(`  ${DIM}SSE stream error: ${err.message}${RESET}`);
-          res.end();
+          sendJSON(res, 502, { ok: false, error: "Stream error" });
         });
         return;
       }

package/package.json

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