openclaw-navigator 5.6.0 → 5.6.1

package/cli.mjs

@@ -1136,42 +1136,189 @@ function handleRequest(req, res) {
     return;
   }
 
-  // ── Chat send: store user message + broadcast via WebSocket ────────────
-  // The bridge IS the chat backend — messages are stored here in-memory.
-  // The OC agent reads them via navigator_get_chat_messages MCP tool,
-  // processes them, and pushes responses via navigator_chat_respond.
+  // ── 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
   if (path === "/api/sessions/send" && req.method === "POST") {
     readBody(req)
-      .then((body) => {
+      .then((bodyStr) => {
+        let data;
         try {
-          const data = JSON.parse(body);
-          const message = data.message || data.content || data.text || "";
-          const sessionKey = data.sessionKey || "main";
-          if (!message) {
-            sendJSON(res, 400, { ok: false, error: "Missing 'message'" });
-            return;
-          }
-          // Store user message in local session
-          const session = getChatSession(sessionKey);
-          session.messages.push({
-            role: "user",
-            content: message,
-            timestamp: Date.now(),
-          });
-          // Broadcast via WebSocket so any listening UI gets it
-          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}`);
-          sendJSON(res, 200, { ok: true, stored: true, messageCount: session.messages.length });
+          data = JSON.parse(bodyStr);
         } catch {
           sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+          return;
+        }
+
+        const message = data.message || data.content || data.text || "";
+        const sessionKey = data.sessionKey || "main";
+        if (!message) {
+          sendJSON(res, 400, { ok: false, error: "Missing 'message'" });
+          return;
         }
+
+        // 1. Store user message locally
+        const session = getChatSession(sessionKey);
+        session.messages.push({
+          role: "user",
+          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
+        const proxyOpts = {
+          hostname: "127.0.0.1",
+          port: ocGatewayPort,
+          path: `/api/sessions/send`,
+          method: "POST",
+          headers: {
+            "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;
+              const lines = buffer.split("\n");
+              buffer = lines.pop() || "";
+              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);
+                    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,
+                        timestamp: Date.now(),
+                      });
+                    }
+                  } catch {
+                    if (raw && raw !== "[DONE]") fullText += raw;
+                  }
+                }
+              }
+            });
+
+            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;
+                  }
+                }
+              }
+              if (fullText) {
+                // Store assistant response
+                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(`  ${DIM}Gateway SSE→WS: ${fullText.substring(0, 80)}...${RESET}`);
+              }
+              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" });
+            });
+          } 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");
+              let jsonBody;
+              try {
+                jsonBody = JSON.parse(body);
+              } 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}`);
+              }
+              sendJSON(res, 200, {
+                ok: true,
+                stored: true,
+                response: inlineResponse || null,
+                source: "gateway-json",
+              });
+            });
+          }
+        });
+
+        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" });
+        });
+
+        proxyReq.write(bodyStr);
+        proxyReq.end();
       })
       .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
     return;

package/package.json

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