openclaw-navigator 5.6.3 → 5.7.0

package/cli.mjs

@@ -1137,11 +1137,12 @@ function handleRequest(req, res) {
   }
 
   // ── Chat send: store locally + respond immediately ─────────────────────
-  // 1. Store user message in bridge memory (for MCP tools to read)
-  // 2. Respond to Navigator immediately (don't block on gateway)
-  // 3. In background: try relaying to gateway for AI processing
-  //    - If gateway responds → store assistant message + broadcast via WS
-  //    - If gateway hangs/fails → agent will respond via MCP tools later
+  // ── Chat send: Navigator sidepane sends a message ─────────────────────
+  // 1. Store user message in bridge memory
+  // 2. Respond to Navigator immediately
+  // 3. In background: relay to the BFF on port 4000 (/api/chat) for AI processing
+  //    The AI lives behind the BFF, NOT on the gateway (port 18789 returns 405).
+  //    The BFF returns SSE — collect it, store the response, broadcast via WS.
   if (path === "/api/sessions/send" && req.method === "POST") {
     readBody(req)
       .then((bodyStr) => {
@@ -1172,47 +1173,63 @@ function handleRequest(req, res) {
         // 2. Respond immediately — don't block Navigator
         sendJSON(res, 200, { ok: true, stored: true, messageCount: session.messages.length });
 
-        // 3. Background: relay to gateway for AI processing
-        const proxyBody = JSON.stringify({ message, sessionKey });
+        // 3. Background: relay to BFF (port 4000) /api/chat for AI processing
+        //    Format: OpenAI-compatible chat completions with message history
+        const chatHistory = session.messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+        }));
+        const proxyBody = JSON.stringify({
+          messages: chatHistory,
+          stream: true,
+        });
         const proxyOpts = {
           hostname: "127.0.0.1",
-          port: ocGatewayPort,
-          path: `/api/sessions/send`,
+          port: ocUIPort,
+          path: `/api/chat`,
           method: "POST",
-          timeout: 60000, // 60s — agent may take a while to respond
+          timeout: 120000, // 2 min — agent may take a while
           headers: {
             "content-type": "application/json",
             "content-length": Buffer.byteLength(proxyBody),
           },
         };
 
+        console.log(`  ${DIM}→ Relaying to BFF /api/chat (port ${ocUIPort}) with ${chatHistory.length} messages${RESET}`);
+
         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 via WebSocket
-            let fullText = "";
-            let buffer = "";
-            proxyRes.setEncoding("utf-8");
-            proxyRes.on("data", (chunk) => {
-              buffer += chunk;
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || "";
+          console.log(`  ${DIM}← BFF response: ${proxyRes.statusCode} ${contentType || "no-content-type"}${RESET}`);
+
+          // Collect the response (SSE or JSON) and extract the assistant's text
+          let fullText = "";
+          let sseBuffer = "";
+
+          proxyRes.setEncoding("utf-8");
+          proxyRes.on("data", (chunk) => {
+            if (isSSE) {
+              sseBuffer += chunk;
+              const lines = sseBuffer.split("\n");
+              sseBuffer = lines.pop() || "";
               for (const line of lines) {
                 if (line.startsWith("data: ")) {
                   const raw = line.slice(6).trim();
-                  if (raw === "[DONE]") continue;
+                  if (raw === "[DONE]" || !raw) continue;
                   try {
                     const evt = JSON.parse(raw);
-                    const text =
-                      evt.text || evt.content || evt.delta?.text || evt.delta?.content || "";
-                    if (text) {
-                      fullText += text;
+                    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: text,
+                        delta,
                         sessionKey,
                         timestamp: Date.now(),
                       });
@@ -1222,71 +1239,64 @@ function handleRequest(req, res) {
                   }
                 }
               }
-            });
-            proxyRes.on("end", () => {
-              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;
+            } else {
+              sseBuffer += chunk; // Collect JSON body
+            }
+          });
+
+          proxyRes.on("end", () => {
+            // Handle remaining buffer for SSE
+            if (isSSE && sseBuffer) {
+              for (const line of sseBuffer.split("\n")) {
+                if (line.startsWith("data: ")) {
+                  const raw = line.slice(6).trim();
+                  if (raw && raw !== "[DONE]") {
+                    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; }
                   }
                 }
               }
-              if (fullText) {
-                session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
-                broadcastToWS({
-                  type: "chat.final",
-                  text: fullText,
-                  content: fullText,
-                  sessionKey,
-                  role: "assistant",
-                  timestamp: Date.now(),
-                });
-                console.log(`  ${GREEN}✓${RESET} Gateway SSE response: ${fullText.substring(0, 80)}...`);
-              }
-            });
-            proxyRes.on("error", () => {});
-          } else {
-            // JSON response from gateway
-            const chunks = [];
-            proxyRes.on("data", (c) => chunks.push(c));
-            proxyRes.on("end", () => {
-              const body = Buffer.concat(chunks).toString("utf-8");
+            }
+
+            // Handle JSON response
+            if (!isSSE && sseBuffer) {
               try {
-                const jsonBody = JSON.parse(body);
-                const inlineResponse =
-                  jsonBody.response || jsonBody.message || jsonBody.answer || jsonBody.text || "";
-                if (inlineResponse) {
-                  session.messages.push({ role: "assistant", content: inlineResponse, timestamp: Date.now() });
-                  broadcastToWS({
-                    type: "chat.final",
-                    text: inlineResponse,
-                    content: inlineResponse,
-                    sessionKey,
-                    role: "assistant",
-                    timestamp: Date.now(),
-                  });
-                  console.log(`  ${GREEN}✓${RESET} Gateway JSON response: ${inlineResponse.substring(0, 80)}...`);
-                } else {
-                  console.log(`  ${DIM}Gateway returned JSON with no response field — waiting for MCP${RESET}`);
-                }
+                const jsonBody = JSON.parse(sseBuffer);
+                fullText = jsonBody.choices?.[0]?.message?.content || jsonBody.response || jsonBody.message || jsonBody.text || "";
               } catch {
-                console.log(`  ${DIM}Gateway returned non-JSON — waiting for MCP${RESET}`);
+                console.log(`  ${DIM}BFF returned non-JSON (${sseBuffer.length} bytes): ${sseBuffer.substring(0, 200)}${RESET}`);
               }
-            });
-          }
+            }
+
+            if (fullText) {
+              session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
+              broadcastToWS({
+                type: "chat.final",
+                text: fullText,
+                content: fullText,
+                sessionKey,
+                role: "assistant",
+                timestamp: Date.now(),
+              });
+              console.log(`  ${GREEN}✓${RESET} AI response (${fullText.length} chars): ${fullText.substring(0, 80)}...`);
+            } else {
+              console.log(`  ${DIM}BFF returned no content${RESET}`);
+            }
+          });
+
+          proxyRes.on("error", () => {});
         });
 
         proxyReq.on("timeout", () => {
           proxyReq.destroy();
-          console.log(`  ${DIM}Gateway relay timed out — agent will respond via MCP${RESET}`);
+          console.log(`  ${DIM}BFF relay timed out${RESET}`);
         });
 
         proxyReq.on("error", (err) => {
-          console.log(`  ${DIM}Gateway relay failed (${err.message}) — agent will respond via MCP${RESET}`);
+          console.log(`  ${DIM}BFF relay failed: ${err.message}${RESET}`);
         });
 
         proxyReq.write(proxyBody);
@@ -1492,53 +1502,81 @@ function handleRequest(req, res) {
       }
 
       // ── 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).
+      // 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.
       if (isSSE && isStreamingEndpoint) {
-        console.log(`  ${DIM}SSE passthrough + WS tap: ${path}${RESET}`);
+        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);
 
         let fullText = "";
-        proxyRes.on("data", (chunk) => {
-          // Forward the chunk to the browser immediately
-          res.write(chunk);
+        let sseBuffer = "";
 
-          // Also parse and broadcast to WebSocket
-          const text = chunk.toString("utf-8");
-          for (const line of text.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(),
-                  });
+        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 */
                 }
-              } catch {
-                /* non-JSON SSE event — skip */
               }
             }
           }
         });
 
         proxyRes.on("end", () => {
-          // Stream ended — broadcast final message via WebSocket
+          // Flush remaining buffer
+          if (sseBuffer.trim()) {
+            res.write(sseBuffer + "\n\n");
+          }
+
+          // Store and broadcast final response
           if (fullText) {
+            const session = getChatSession("main");
+            session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
+
             broadcastToWS({
               type: "chat.final",
               text: fullText,
@@ -1547,11 +1585,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;

package/package.json

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