openclaw-navigator 5.6.1 → 5.6.3

package/cli.mjs

@@ -1136,12 +1136,12 @@ function handleRequest(req, res) {
     return;
   }
 
-  // ── Chat send: store locally + relay to OC Gateway for processing ──────
-  // HYBRID approach:
-  //   1. Store user message in bridge (for MCP tools to read via history)
-  //   2. Relay to OC Gateway (port 18789) so the AI agent processes it
-  //   3. Gateway may return response inline (JSON/SSE) → store + broadcast
-  //   4. Or agent responds async via navigator_chat_respond MCP tool
+  // ── 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
   if (path === "/api/sessions/send" && req.method === "POST") {
     readBody(req)
       .then((bodyStr) => {
@@ -1167,25 +1167,22 @@ function handleRequest(req, res) {
           content: message,
           timestamp: Date.now(),
         });
-        broadcastToWS({
-          type: "chat.user",
-          text: message,
-          content: message,
-          sessionKey,
-          role: "user",
-          timestamp: Date.now(),
-        });
         console.log(`  ${DIM}Chat send [${sessionKey}]: ${message.substring(0, 60)}...${RESET}`);
 
-        // 2. Relay to OC Gateway for AI processing
+        // 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 });
         const proxyOpts = {
           hostname: "127.0.0.1",
           port: ocGatewayPort,
           path: `/api/sessions/send`,
           method: "POST",
+          timeout: 60000, // 60s — agent may take a while to respond
           headers: {
             "content-type": "application/json",
-            "content-length": Buffer.byteLength(bodyStr),
+            "content-length": Buffer.byteLength(proxyBody),
           },
         };
 
@@ -1194,10 +1191,9 @@ function handleRequest(req, res) {
           const isSSE = contentType.includes("text/event-stream");
 
           if (isSSE) {
-            // ── SSE response: collect stream, broadcast chunks, return JSON ──
+            // SSE response: collect stream, broadcast chunks via WebSocket
             let fullText = "";
             let buffer = "";
-
             proxyRes.setEncoding("utf-8");
             proxyRes.on("data", (chunk) => {
               buffer += chunk;
@@ -1227,7 +1223,6 @@ function handleRequest(req, res) {
                 }
               }
             });
-
             proxyRes.on("end", () => {
               if (buffer.startsWith("data: ")) {
                 const raw = buffer.slice(6).trim();
@@ -1241,12 +1236,7 @@ function handleRequest(req, res) {
                 }
               }
               if (fullText) {
-                // Store assistant response
-                session.messages.push({
-                  role: "assistant",
-                  content: fullText,
-                  timestamp: Date.now(),
-                });
+                session.messages.push({ role: "assistant", content: fullText, timestamp: Date.now() });
                 broadcastToWS({
                   type: "chat.final",
                   text: fullText,
@@ -1255,69 +1245,51 @@ function handleRequest(req, res) {
                   role: "assistant",
                   timestamp: Date.now(),
                 });
-                console.log(`  ${DIM}Gateway SSE→WS: ${fullText.substring(0, 80)}...${RESET}`);
+                console.log(`  ${GREEN}✓${RESET} Gateway SSE response: ${fullText.substring(0, 80)}...`);
               }
-              sendJSON(res, 200, {
-                ok: true,
-                stored: true,
-                response: fullText || null,
-                source: "gateway-sse",
-              });
-            });
-
-            proxyRes.on("error", () => {
-              sendJSON(res, 200, { ok: true, stored: true, response: null, source: "gateway-sse-error" });
             });
+            proxyRes.on("error", () => {});
           } else {
-            // ── JSON response from gateway ──
+            // JSON response from gateway
             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);
+                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}`);
+                }
               } catch {
-                // Non-JSON — message is stored, agent will respond via MCP
-                sendJSON(res, 200, { ok: true, stored: true, response: null, source: "gateway-raw" });
-                return;
-              }
-              // Check if gateway returned an inline AI response
-              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(`  ${DIM}Gateway inline→WS: ${inlineResponse.substring(0, 80)}...${RESET}`);
+                console.log(`  ${DIM}Gateway returned non-JSON — waiting for MCP${RESET}`);
               }
-              sendJSON(res, 200, {
-                ok: true,
-                stored: true,
-                response: inlineResponse || null,
-                source: "gateway-json",
-              });
             });
           }
         });
 
+        proxyReq.on("timeout", () => {
+          proxyReq.destroy();
+          console.log(`  ${DIM}Gateway relay timed out — agent will respond via MCP${RESET}`);
+        });
+
         proxyReq.on("error", (err) => {
-          // Gateway not reachable — message is still stored, agent can use MCP tools
-          console.log(`  ${DIM}Gateway not reachable (${err.message}) — message stored for MCP polling${RESET}`);
-          sendJSON(res, 200, { ok: true, stored: true, response: null, source: "local-only" });
+          console.log(`  ${DIM}Gateway relay failed (${err.message}) — agent will respond via MCP${RESET}`);
         });
 
-        proxyReq.write(bodyStr);
+        proxyReq.write(proxyBody);
         proxyReq.end();
       })
       .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
@@ -1391,6 +1363,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 = {
@@ -1401,8 +1377,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, */*";
     }
 
@@ -1417,6 +1395,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";
@@ -1578,8 +1562,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.1",
+  "version": "5.6.3",
   "description": "One-command bridge + tunnel for the Navigator browser — works on any machine, any OS",
   "keywords": [
     "browser",