openclaw-navigator 5.5.3 → 5.6.0

package/cli.mjs

@@ -362,6 +362,19 @@ function validateBridgeAuth(req) {
   return validTokens.has(token);
 }
 
+// ── Chat session storage (in-memory) ────────────────────────────────────
+// Stores messages per session key. Navigator sends user messages here,
+// the OC agent reads them via navigator_get_chat_messages MCP tool,
+// and pushes responses via navigator_chat_respond MCP tool.
+const chatSessions = new Map();
+
+function getChatSession(sessionKey = "main") {
+  if (!chatSessions.has(sessionKey)) {
+    chatSessions.set(sessionKey, { messages: [], createdAt: Date.now() });
+  }
+  return chatSessions.get(sessionKey);
+}
+
 // ── 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
@@ -1069,6 +1082,13 @@ function handleRequest(req, res) {
             sendJSON(res, 400, { ok: false, error: "Missing 'content' or 'message'" });
             return;
           }
+          // Store assistant message in local session
+          const session = getChatSession(sessionKey);
+          session.messages.push({
+            role: "assistant",
+            content: message,
+            timestamp: Date.now(),
+          });
           // Broadcast as a final chat message via WebSocket
           broadcastToWS({
             type: "chat.final",
@@ -1116,179 +1136,63 @@ function handleRequest(req, res) {
     return;
   }
 
-  // ── Smart proxy: /api/sessions/send → OC Gateway + SSE bridge ───────────
-  // This is the main chat send endpoint. The gateway may return:
-  //   (a) JSON: { ok, response, message, ... } — pass through + broadcast
-  //   (b) SSE: text/event-stream with data lines — collect + broadcast + return JSON
-  // Either way, the response is also broadcast via WebSocket so Navigator's
-  // chat pane (OCChatService) gets it via both HTTP and WS.
+  // ── 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.
   if (path === "/api/sessions/send" && req.method === "POST") {
     readBody(req)
-      .then((bodyStr) => {
-        const proxyOpts = {
-          hostname: "127.0.0.1",
-          port: ocGatewayPort,
-          path: `${path}${url.search}`,
-          method: "POST",
-          headers: {
-            ...req.headers,
-            host: `127.0.0.1:${ocGatewayPort}`,
-            "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;
-              // Parse SSE lines
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || ""; // keep incomplete line
-              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);
-                    // Extract text from common SSE shapes
-                    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: "main",
-                        timestamp: Date.now(),
-                      });
-                    }
-                  } catch {
-                    // Non-JSON SSE line — treat as plain text
-                    if (raw && raw !== "[DONE]") {
-                      fullText += raw;
-                    }
-                  }
-                }
-              }
-            });
-
-            proxyRes.on("end", () => {
-              // Process any remaining buffer
-              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) {
-                // Broadcast final via WebSocket
-                broadcastToWS({
-                  type: "chat.final",
-                  text: fullText,
-                  content: fullText,
-                  sessionKey: "main",
-                  role: "assistant",
-                  timestamp: Date.now(),
-                });
-                console.log(`  ${DIM}SSE→WS bridge: ${fullText.substring(0, 80)}...${RESET}`);
-              }
-
-              // Return clean JSON to the caller (OCChatService)
-              sendJSON(res, 200, {
-                ok: true,
-                response: fullText || null,
-                format: "sse-bridged",
-                delivered: wsClients.size,
-              });
-            });
-
-            proxyRes.on("error", () => {
-              sendJSON(res, 502, { ok: false, error: "SSE stream error from gateway" });
-            });
-          } else {
-            // ── JSON response: collect body, broadcast if it has a response, pass through ──
-            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 {
-                // Not JSON — pass through raw
-                const headers = { ...proxyRes.headers };
-                headers["access-control-allow-origin"] = "*";
-                res.writeHead(proxyRes.statusCode ?? 200, headers);
-                res.end(body);
-                return;
-              }
-
-              // If the gateway returned an inline response, broadcast it via WebSocket
-              const inlineResponse =
-                jsonBody.response || jsonBody.message || jsonBody.answer || jsonBody.text || "";
-              if (inlineResponse) {
-                broadcastToWS({
-                  type: "chat.final",
-                  text: inlineResponse,
-                  content: inlineResponse,
-                  sessionKey: "main",
-                  role: "assistant",
-                  timestamp: Date.now(),
-                });
-                console.log(
-                  `  ${DIM}Inline response→WS: ${inlineResponse.substring(0, 80)}...${RESET}`,
-                );
-              }
-
-              sendJSON(res, proxyRes.statusCode ?? 200, jsonBody);
-            });
+      .then((body) => {
+        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;
           }
-        });
-
-        proxyReq.on("error", (err) => {
-          sendJSON(res, 502, {
-            ok: false,
-            error: `OC Gateway not reachable on port ${ocGatewayPort}`,
-            detail: err.message,
+          // Store user message in local session
+          const session = getChatSession(sessionKey);
+          session.messages.push({
+            role: "user",
+            content: message,
+            timestamp: Date.now(),
           });
-        });
-
-        proxyReq.write(bodyStr);
-        proxyReq.end();
+          // 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 });
+        } catch {
+          sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+        }
       })
       .catch(() => sendJSON(res, 400, { ok: false, error: "Bad request body" }));
     return;
   }
 
+  // ── Chat history: return stored messages for a session ────────────────
+  // Called by the OC agent (via navigator_get_chat_messages MCP tool)
+  // and by Navigator's OCChatService to load history on tab switch.
+  if (path === "/api/sessions/history" && req.method === "GET") {
+    const sessionKey = url.searchParams?.get("sessionKey") || "main";
+    const session = getChatSession(sessionKey);
+    sendJSON(res, 200, { ok: true, messages: session.messages });
+    return;
+  }
+
   // ── /api/* routing strategy ──────────────────────────────────────────────
-  // NO direct gateway proxy for /api/* here. The web UI (Next.js on port 4000)
-  // has its own /api/* routes that act as a BFF (Backend for Frontend) —
-  // they call the gateway internally (localhost:18789) and return clean JSON.
-  // Routing /api/* directly to the gateway bypasses the BFF and breaks things
-  // (e.g. /api/agents returns raw SSE instead of JSON).
-  //
-  // Specific bridge-handled routes (above this point):
-  //   - /api/sessions/respond → local WebSocket broadcast
-  //   - /api/sessions/stream  → local WebSocket broadcast
-  //   - /api/sessions/send    → smart SSE bridge to gateway (sidepane chat)
+  // The bridge handles chat endpoints locally:
+  //   - /api/sessions/send     → store user message + WS broadcast
+  //   - /api/sessions/history  → return stored messages
+  //   - /api/sessions/respond  → store assistant message + WS broadcast
+  //   - /api/sessions/stream   → WS broadcast (streaming delta)
   //
   // Everything else (/api/agents, /api/auth/*, /api/chat/*, etc.) falls through
   // to the fallback proxy below, which sends it to port 4000 (web UI).

package/package.json

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