openclaw-navigator 5.5.3 → 5.6.1

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,23 +1136,54 @@ 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 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((bodyStr) => {
+        let data;
+        try {
+          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: `${path}${url.search}`,
+          path: `/api/sessions/send`,
           method: "POST",
           headers: {
-            ...req.headers,
-            host: `127.0.0.1:${ocGatewayPort}`,
             "content-type": "application/json",
             "content-length": Buffer.byteLength(bodyStr),
           },
@@ -1150,18 +1201,14 @@ function handleRequest(req, res) {
             proxyRes.setEncoding("utf-8");
             proxyRes.on("data", (chunk) => {
               buffer += chunk;
-              // Parse SSE lines
               const lines = buffer.split("\n");
-              buffer = lines.pop() || ""; // keep incomplete line
+              buffer = lines.pop() || "";
               for (const line of lines) {
                 if (line.startsWith("data: ")) {
                   const raw = line.slice(6).trim();
-                  if (raw === "[DONE]") {
-                    continue;
-                  }
+                  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) {
@@ -1170,22 +1217,18 @@ function handleRequest(req, res) {
                         type: "chat.delta",
                         text: fullText,
                         delta: text,
-                        sessionKey: "main",
+                        sessionKey,
                         timestamp: Date.now(),
                       });
                     }
                   } catch {
-                    // Non-JSON SSE line — treat as plain text
-                    if (raw && raw !== "[DONE]") {
-                      fullText += raw;
-                    }
+                    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]") {
@@ -1197,34 +1240,36 @@ function handleRequest(req, res) {
                   }
                 }
               }
-
               if (fullText) {
-                // Broadcast final via WebSocket
+                // Store assistant response
+                session.messages.push({
+                  role: "assistant",
+                  content: fullText,
+                  timestamp: Date.now(),
+                });
                 broadcastToWS({
                   type: "chat.final",
                   text: fullText,
                   content: fullText,
-                  sessionKey: "main",
+                  sessionKey,
                   role: "assistant",
                   timestamp: Date.now(),
                 });
-                console.log(`  ${DIM}SSE→WS bridge: ${fullText.substring(0, 80)}...${RESET}`);
+                console.log(`  ${DIM}Gateway SSE→WS: ${fullText.substring(0, 80)}...${RESET}`);
               }
-
-              // Return clean JSON to the caller (OCChatService)
               sendJSON(res, 200, {
                 ok: true,
+                stored: true,
                 response: fullText || null,
-                format: "sse-bridged",
-                delivered: wsClients.size,
+                source: "gateway-sse",
               });
             });
 
             proxyRes.on("error", () => {
-              sendJSON(res, 502, { ok: false, error: "SSE stream error from gateway" });
+              sendJSON(res, 200, { ok: true, stored: true, response: null, source: "gateway-sse-error" });
             });
           } else {
-            // ── JSON response: collect body, broadcast if it has a response, pass through ──
+            // ── JSON response from gateway ──
             const chunks = [];
             proxyRes.on("data", (c) => chunks.push(c));
             proxyRes.on("end", () => {
@@ -1233,42 +1278,43 @@ function handleRequest(req, res) {
               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);
+                // Non-JSON — message is stored, agent will respond via MCP
+                sendJSON(res, 200, { ok: true, stored: true, response: null, source: "gateway-raw" });
                 return;
               }
-
-              // If the gateway returned an inline response, broadcast it via WebSocket
+              // 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: "main",
+                  sessionKey,
                   role: "assistant",
                   timestamp: Date.now(),
                 });
-                console.log(
-                  `  ${DIM}Inline response→WS: ${inlineResponse.substring(0, 80)}...${RESET}`,
-                );
+                console.log(`  ${DIM}Gateway inline→WS: ${inlineResponse.substring(0, 80)}...${RESET}`);
               }
-
-              sendJSON(res, proxyRes.statusCode ?? 200, jsonBody);
+              sendJSON(res, 200, {
+                ok: true,
+                stored: true,
+                response: inlineResponse || null,
+                source: "gateway-json",
+              });
             });
           }
         });
 
         proxyReq.on("error", (err) => {
-          sendJSON(res, 502, {
-            ok: false,
-            error: `OC Gateway not reachable on port ${ocGatewayPort}`,
-            detail: err.message,
-          });
+          // 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);
@@ -1278,17 +1324,22 @@ function handleRequest(req, res) {
     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.1",
   "description": "One-command bridge + tunnel for the Navigator browser — works on any machine, any OS",
   "keywords": [
     "browser",