openclaw-navigator 5.6.2 → 5.6.4

package/cli.mjs

@@ -1189,6 +1189,7 @@ function handleRequest(req, res) {
         const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
           const contentType = (proxyRes.headers["content-type"] || "").toLowerCase();
           const isSSE = contentType.includes("text/event-stream");
+          console.log(`  ${DIM}Gateway relay response: ${proxyRes.statusCode} ${contentType || "no-content-type"}${RESET}`);
 
           if (isSSE) {
             // SSE response: collect stream, broadcast chunks via WebSocket
@@ -1274,7 +1275,8 @@ function handleRequest(req, res) {
                   console.log(`  ${DIM}Gateway returned JSON with no response field — waiting for MCP${RESET}`);
                 }
               } catch {
-                console.log(`  ${DIM}Gateway returned non-JSON — waiting for MCP${RESET}`);
+                console.log(`  ${DIM}Gateway returned non-JSON (${body.length} bytes): ${body.substring(0, 200)}${RESET}`);
+                console.log(`  ${DIM}Waiting for MCP agent to respond...${RESET}`);
               }
             });
           }
@@ -1363,6 +1365,10 @@ function handleRequest(req, res) {
   {
     const targetURL = `${path}${url.search}`;
     const incomingHost = req.headers.host || "localhost";
+    // Log API calls for diagnostics (helps debug web UI chat)
+    if (path.startsWith("/api/")) {
+      console.log(`  ${DIM}→ Proxy ${req.method} ${path} → localhost:${ocUIPort}${RESET}`);
+    }
 
     // Encourage JSON responses from the web UI's API routes
     const proxyHeaders = {
@@ -1373,8 +1379,10 @@ function handleRequest(req, res) {
       "x-forwarded-for": req.socket.remoteAddress || "127.0.0.1",
     };
 
-    // For /api/* requests, prefer JSON over SSE
-    if (path.startsWith("/api/")) {
+    // For /api/* requests, prefer JSON over SSE — BUT not for streaming chat endpoints
+    // which need text/event-stream to get SSE responses from the BFF
+    const isStreamingReq = path.startsWith("/api/chat") || path.startsWith("/api/stream");
+    if (path.startsWith("/api/") && !isStreamingReq) {
       proxyHeaders["accept"] = "application/json, text/plain, */*";
     }
 
@@ -1389,6 +1397,12 @@ function handleRequest(req, res) {
     const proxyReq = httpRequest(proxyOpts, (proxyRes) => {
       const headers = { ...proxyRes.headers };
 
+      // Log response info for API calls (helps debug web UI chat)
+      if (path.startsWith("/api/")) {
+        const ct = (proxyRes.headers["content-type"] || "unknown").split(";")[0];
+        console.log(`  ${DIM}← ${proxyRes.statusCode} ${ct} for ${path}${RESET}`);
+      }
+
       // CORS
       headers["access-control-allow-origin"] = "*";
       headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, OPTIONS";
@@ -1479,26 +1493,41 @@ function handleRequest(req, res) {
         return;
       }
 
-      // ── SSE passthrough for streaming endpoints (/api/chat) ──────────
-      // Let the SSE stream through to the browser AND tap it to broadcast
-      // chunks via our WebSocket (so Navigator's sidepane chat gets them).
+      // ── SSE → NDJSON conversion for streaming endpoints (/api/chat) ──
+      // The OC gateway returns standard SSE (data: {...}\n), but the web UI
+      // frontend expects clean JSON lines (NDJSON). Strip the "data: " prefix
+      // and forward clean JSON. Also tap data to broadcast via WebSocket
+      // so Navigator's sidepane chat gets the response too.
       if (isSSE && isStreamingEndpoint) {
-        console.log(`  ${DIM}SSE passthrough + WS tap: ${path}${RESET}`);
+        console.log(`  ${DIM}SSE→NDJSON + WS tap: ${path}${RESET}`);
+
+        // Change content-type so frontend doesn't try to parse as SSE
+        headers["content-type"] = "text/plain; charset=utf-8";
+        delete headers["content-length"];
+        delete headers["transfer-encoding"];
         res.writeHead(proxyRes.statusCode ?? 200, headers);
 
         let fullText = "";
+        let sseBuffer = "";
+
+        proxyRes.setEncoding("utf-8");
         proxyRes.on("data", (chunk) => {
-          // Forward the chunk to the browser immediately
-          res.write(chunk);
+          sseBuffer += chunk;
+          const lines = sseBuffer.split("\n");
+          sseBuffer = lines.pop() || ""; // keep incomplete last line
 
-          // Also parse and broadcast to WebSocket
-          const text = chunk.toString("utf-8");
-          for (const line of text.split("\n")) {
+          for (const line of lines) {
             if (line.startsWith("data: ")) {
               const raw = line.slice(6).trim();
               if (raw === "[DONE]" || !raw) {
                 continue;
               }
+
+              // Forward clean JSON line to browser (no "data: " prefix)
+              res.write(raw + "\n");
+              console.log(`  ${DIM}  SSE chunk: ${raw.substring(0, 100)}${raw.length > 100 ? "..." : ""}${RESET}`);
+
+              // Also broadcast to WebSocket for Navigator sidepane
               try {
                 const evt = JSON.parse(raw);
                 const delta =
@@ -1518,15 +1547,33 @@ function handleRequest(req, res) {
                   });
                 }
               } catch {
-                /* non-JSON SSE event — skip */
+                // Non-JSON SSE data — forward as text anyway
+                fullText += raw;
               }
             }
           }
         });
 
         proxyRes.on("end", () => {
-          // Stream ended — broadcast final message via WebSocket
+          // Process remaining buffer
+          if (sseBuffer.startsWith("data: ")) {
+            const raw = sseBuffer.slice(6).trim();
+            if (raw && raw !== "[DONE]") {
+              res.write(raw + "\n");
+              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 { fullText += raw; }
+            }
+          }
+
+          // Broadcast final message via WebSocket
           if (fullText) {
+            // Also store as assistant message in bridge chat session
+            const session = getChatSession("main");
+            session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
+
             broadcastToWS({
               type: "chat.final",
               text: fullText,
@@ -1535,11 +1582,15 @@ function handleRequest(req, res) {
               role: "assistant",
               timestamp: Date.now(),
             });
+            console.log(`  ${GREEN}✓${RESET} Chat response (${fullText.length} chars): ${fullText.substring(0, 80)}...`);
+          } else {
+            console.log(`  ${DIM}SSE stream ended with no content${RESET}`);
           }
           res.end();
         });
 
-        proxyRes.on("error", () => {
+        proxyRes.on("error", (err) => {
+          console.log(`  ${DIM}SSE stream error: ${err.message}${RESET}`);
           res.end();
         });
         return;
@@ -1550,8 +1601,11 @@ function handleRequest(req, res) {
       proxyRes.pipe(res, { end: true });
     });
 
-    proxyReq.on("error", () => {
-      sendJSON(res, 404, { ok: false, error: "Not found" });
+    proxyReq.on("error", (err) => {
+      if (path.startsWith("/api/")) {
+        console.log(`  ${DIM}✗ Proxy error for ${path}: ${err.message}${RESET}`);
+      }
+      sendJSON(res, 502, { ok: false, error: `Web UI (port ${ocUIPort}) not reachable: ${err.message}` });
     });
 
     req.pipe(proxyReq, { end: true });

package/package.json

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