openclaw-navigator 5.0.1 → 5.1.0

package/cli.mjs

@@ -15,7 +15,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { randomUUID, createHash } from "node:crypto";
 import { existsSync, appendFileSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { createServer, request as httpRequest } from "node:http";
 import { connect as netConnect } from "node:net";
@@ -57,6 +57,24 @@ const recentEvents = [];
 const MAX_EVENTS = 200;
 const validTokens = new Set();
 
+// ── Chat session state ────────────────────────────────────────────────────
+const chatSessions = new Map(); // sessionKey → { messages: [...] }
+const wsClients = new Set(); // connected WebSocket clients
+
+function getChatSession(key = "main") {
+  if (!chatSessions.has(key)) {
+    chatSessions.set(key, { messages: [] });
+  }
+  return chatSessions.get(key);
+}
+
+function broadcastToWS(event) {
+  const data = JSON.stringify(event);
+  for (const ws of wsClients) {
+    try { ws.send(data); } catch {}
+  }
+}
+
 // OC Web UI reverse proxy target (configurable via --ui-port or env)
 let ocUIPort = parseInt(process.env.OPENCLAW_UI_PORT ?? "4000", 10);
 
@@ -445,8 +463,9 @@ function handleRequest(req, res) {
       },
       routing: {
         "/ui/*": `localhost:${ocUIPort}`,
-        "/api/*": `localhost:${ocGatewayPort}`,
-        "/ws": `localhost:${ocGatewayPort}`,
+        "/api/sessions/*": "bridge (in-process chat)",
+        "/api/*": `localhost:${ocGatewayPort} (fallback)`,
+        "/ws": "bridge (in-process WebSocket)",
       },
       tunnel: activeTunnelURL
         ? {
@@ -469,7 +488,9 @@ function handleRequest(req, res) {
     if (!bridgeState.connected) {
       bridgeState.connected = true;
       bridgeState.connectedAt = Date.now();
+      const activeURL = activeTunnelURL ?? `http://localhost:${bridgePort}`;
       console.log(`\n${GREEN}✓${RESET} ${BOLD}Navigator connected!${RESET}`);
+      console.log(`  ${DIM}Tunnel: ${activeURL}${RESET}`);
     }
     bridgeState.lastHeartbeat = Date.now();
 
@@ -903,8 +924,117 @@ function handleRequest(req, res) {
     return;
   }
 
+  // ── POST /api/sessions/send — Chat: receive user message ──
+  if (req.method === "POST" && path === "/api/sessions/send") {
+    readBody(req).then(raw => {
+      const body = JSON.parse(raw);
+      const sessionKey = body.sessionKey || "main";
+      const message = body.message;
+      if (!message) {
+        sendJSON(res, 400, { ok: false, error: "Missing 'message'" });
+        return;
+      }
+
+      const session = getChatSession(sessionKey);
+      const userMsg = {
+        role: "user",
+        content: message,
+        timestamp: Date.now(),
+        id: randomUUID(),
+      };
+      session.messages.push(userMsg);
+
+      // Also push as a bridge event so MCP tools can see it
+      recentEvents.push({
+        type: "chat.user_message",
+        sessionKey,
+        message,
+        messageId: userMsg.id,
+        timestamp: userMsg.timestamp,
+      });
+      if (recentEvents.length > MAX_EVENTS) recentEvents.shift();
+
+      // Broadcast to WebSocket clients
+      broadcastToWS({ type: "chat.user_message", sessionKey, message, messageId: userMsg.id });
+
+      sendJSON(res, 200, { ok: true, messageId: userMsg.id });
+    }).catch(() => {
+      sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+    });
+    return;
+  }
+
+  // ── GET /api/sessions/history — Chat: fetch history ──
+  if (req.method === "GET" && path === "/api/sessions/history") {
+    const sessionKey = url.searchParams.get("sessionKey") || "main";
+    const session = getChatSession(sessionKey);
+    sendJSON(res, 200, { ok: true, messages: session.messages });
+    return;
+  }
+
+  // ── POST /api/sessions/respond — Chat: agent sends response ──
+  // Used by MCP tools to send agent responses to the chat
+  if (req.method === "POST" && path === "/api/sessions/respond") {
+    readBody(req).then(raw => {
+      const body = JSON.parse(raw);
+      const sessionKey = body.sessionKey || "main";
+      const content = body.content || body.message;
+      if (!content) {
+        sendJSON(res, 400, { ok: false, error: "Missing 'content'" });
+        return;
+      }
+
+      const session = getChatSession(sessionKey);
+      const assistantMsg = {
+        role: "assistant",
+        content,
+        timestamp: Date.now(),
+        id: randomUUID(),
+      };
+      session.messages.push(assistantMsg);
+
+      // Broadcast final response via WebSocket
+      broadcastToWS({
+        type: "chat.final",
+        text: content,
+        content,
+        runId: body.runId || null,
+        sessionKey,
+      });
+
+      sendJSON(res, 200, { ok: true, messageId: assistantMsg.id });
+    }).catch(() => {
+      sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+    });
+    return;
+  }
+
+  // ── POST /api/sessions/stream — Chat: agent streams partial text ──
+  if (req.method === "POST" && path === "/api/sessions/stream") {
+    readBody(req).then(raw => {
+      const body = JSON.parse(raw);
+      const text = body.text || body.delta || "";
+      const runId = body.runId || null;
+      const sessionKey = body.sessionKey || "main";
+
+      broadcastToWS({
+        type: "chat.delta",
+        text,
+        delta: text,
+        runId,
+        sessionKey,
+      });
+
+      sendJSON(res, 200, { ok: true });
+    }).catch(() => {
+      sendJSON(res, 400, { ok: false, error: "Invalid JSON" });
+    });
+    return;
+  }
+
   // ── Reverse proxy: /api/* → OC Gateway (localhost:ocGatewayPort) ─────
   // Keeps /api/ prefix intact so /api/sessions/send → localhost:18789/api/sessions/send
+  // This is a fallback — specific chat paths above are handled directly.
   if (path.startsWith("/api/")) {
     const targetURL = `${path}${url.search}`;
 
@@ -1147,11 +1277,12 @@ ${BOLD}Stability (recommended for production):${RESET}
   --tunnel-hostname <host>  Hostname for named tunnel (e.g. nav.yourdomain.com)
 
 ${BOLD}Routing (through Cloudflare tunnel):${RESET}
-  /ui/*          → localhost:<ui-port>      Web UI (login page, dashboard)
-  /api/*         → localhost:<gateway-port> Sessions API, chat endpoints
-  /ws, WebSocket → localhost:<gateway-port> Real-time streaming, chat events
-  /health        → bridge itself            Health check
-  /navigator/*   → bridge itself            Navigator control endpoints
+  /ui/*                → localhost:<ui-port>      Web UI (login page, dashboard)
+  /api/sessions/*      → bridge (in-process)      Chat send/history/respond/stream
+  /ws, WebSocket       → bridge (in-process)      Real-time chat events
+  /api/* (other)       → localhost:<gateway-port> Gateway API fallback
+  /health              → bridge itself            Health check
+  /navigator/*         → bridge itself            Navigator control endpoints
 
 ${BOLD}Environment variables:${RESET}
   OPENCLAW_UI_PORT=4000         Where the web UI runs
@@ -1237,49 +1368,142 @@ module.exports = {
     server.listen(port, bindHost, () => resolve());
   });
 
-  // ── WebSocket upgrade proxy → OC Gateway (localhost:ocGatewayPort) ───
-  // Proxies WebSocket connections so Navigator can stream chat events
+  // ── WebSocket handler — manages chat connections directly ─────────────
   server.on("upgrade", (req, socket, head) => {
     const reqUrl = new URL(req.url ?? "/", "http://localhost");
     const reqPath = reqUrl.pathname;
 
-    // Only proxy WebSocket paths intended for the OC gateway
-    if (reqPath === "/ws" || reqPath.startsWith("/ws/") || reqPath.startsWith("/api/") || reqPath === "/") {
-      const targetPath = `${reqPath}${reqUrl.search}`;
-
-      const proxy = netConnect(ocGatewayPort, "127.0.0.1", () => {
-        // Forward the original HTTP upgrade request over the TCP socket
-        const upgradeReq =
-          `${req.method} ${targetPath} HTTP/${req.httpVersion}\r\n` +
-          Object.entries(req.headers)
-            .map(([k, v]) => `${k}: ${v}`)
-            .join("\r\n") +
-          "\r\n\r\n";
-        proxy.write(upgradeReq);
-        if (head && head.length > 0) {
-          proxy.write(head);
-        }
-        // Pipe bidirectionally
-        socket.pipe(proxy);
-        proxy.pipe(socket);
-      });
+    // Only handle /ws paths
+    if (reqPath !== "/ws" && !reqPath.startsWith("/ws/")) {
+      socket.destroy();
+      return;
+    }
+
+    // Perform WebSocket handshake
+    const key = req.headers["sec-websocket-key"];
+    if (!key) {
+      socket.destroy();
+      return;
+    }
+
+    const accept = createHash("sha1")
+      .update(key + "258EAFA5-E914-47DA-95CA-5AB5DC799C07")
+      .digest("base64");
 
-      proxy.on("error", (err) => {
-        console.log(`  ${DIM}WebSocket proxy error: ${err.message}${RESET}`);
+    socket.write(
+      "HTTP/1.1 101 Switching Protocols\r\n" +
+      "Upgrade: websocket\r\n" +
+      "Connection: Upgrade\r\n" +
+      `Sec-WebSocket-Accept: ${accept}\r\n` +
+      "\r\n"
+    );
+
+    // Create a minimal WebSocket wrapper
+    const ws = {
+      socket,
+      send(data) {
+        const payload = Buffer.from(data);
+        const frame = [];
+        frame.push(0x81); // text frame, FIN bit
+        if (payload.length < 126) {
+          frame.push(payload.length);
+        } else if (payload.length < 65536) {
+          frame.push(126, (payload.length >> 8) & 0xFF, payload.length & 0xFF);
+        } else {
+          frame.push(127);
+          for (let i = 7; i >= 0; i--) {
+            frame.push((payload.length >> (i * 8)) & 0xFF);
+          }
+        }
+        socket.write(Buffer.concat([Buffer.from(frame), payload]));
+      },
+      close() {
+        wsClients.delete(ws);
         socket.destroy();
-      });
+      }
+    };
 
-      socket.on("error", () => {
-        proxy.destroy();
-      });
+    wsClients.add(ws);
+    console.log(`  ${DIM}WebSocket client connected (${wsClients.size} active)${RESET}`);
+
+    // Send connected event
+    ws.send(JSON.stringify({ type: "connected" }));
+
+    // Handle incoming WebSocket frames (simplified parser)
+    let frameBuffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+      frameBuffer = Buffer.concat([frameBuffer, chunk]);
+
+      while (frameBuffer.length >= 2) {
+        const firstByte = frameBuffer[0];
+        const secondByte = frameBuffer[1];
+        const opcode = firstByte & 0x0F;
+        const masked = (secondByte & 0x80) !== 0;
+        let payloadLen = secondByte & 0x7F;
+        let offset = 2;
+
+        if (payloadLen === 126) {
+          if (frameBuffer.length < 4) return;
+          payloadLen = (frameBuffer[2] << 8) | frameBuffer[3];
+          offset = 4;
+        } else if (payloadLen === 127) {
+          if (frameBuffer.length < 10) return;
+          payloadLen = 0;
+          for (let i = 0; i < 8; i++) {
+            payloadLen = payloadLen * 256 + frameBuffer[2 + i];
+          }
+          offset = 10;
+        }
 
-      socket.on("close", () => {
-        proxy.destroy();
-      });
-    } else {
-      // Not a proxied path — reject
-      socket.destroy();
-    }
+        const maskSize = masked ? 4 : 0;
+        const totalFrameLen = offset + maskSize + payloadLen;
+        if (frameBuffer.length < totalFrameLen) return;
+
+        let payload;
+        if (masked) {
+          const mask = frameBuffer.slice(offset, offset + 4);
+          payload = Buffer.alloc(payloadLen);
+          for (let i = 0; i < payloadLen; i++) {
+            payload[i] = frameBuffer[offset + 4 + i] ^ mask[i % 4];
+          }
+        } else {
+          payload = frameBuffer.slice(offset, offset + payloadLen);
+        }
+
+        // Handle by opcode
+        if (opcode === 0x08) {
+          // Close frame
+          ws.close();
+          return;
+        } else if (opcode === 0x09) {
+          // Ping — send pong
+          const pongFrame = Buffer.from([0x8A, payload.length, ...payload]);
+          socket.write(pongFrame);
+        } else if (opcode === 0x01) {
+          // Text frame — handle as message
+          const text = payload.toString("utf8");
+          try {
+            const msg = JSON.parse(text);
+            if (msg.type === "ping") {
+              ws.send(JSON.stringify({ type: "pong" }));
+            }
+          } catch {
+            // Non-JSON message, ignore
+          }
+        }
+
+        frameBuffer = frameBuffer.slice(totalFrameLen);
+      }
+    });
+
+    socket.on("close", () => {
+      wsClients.delete(ws);
+      console.log(`  ${DIM}WebSocket client disconnected (${wsClients.size} active)${RESET}`);
+    });
+
+    socket.on("error", () => {
+      wsClients.delete(ws);
+    });
   });
 
   ok(`Bridge server running on ${bindHost}:${port}`);
@@ -1490,9 +1714,10 @@ module.exports = {
   // ── Show OC Web UI access + routing info ─────────────────────────────
   const uiURL = tunnelURL ? `${tunnelURL}/ui/` : `http://localhost:${port}/ui/`;
   console.log(`  ${BOLD}OC Web UI:${RESET} ${CYAN}${uiURL}${RESET}`);
-  info(`  /ui/*  → localhost:${ocUIPort} (web UI)`);
-  info(`  /api/* → localhost:${ocGatewayPort} (gateway API)`);
-  info(`  /ws    → localhost:${ocGatewayPort} (WebSocket)`);
+  info(`  /ui/*              → localhost:${ocUIPort} (web UI)`);
+  info(`  /api/sessions/*    → bridge (in-process chat)`);
+  info(`  /ws                → bridge (in-process WebSocket)`);
+  info(`  /api/* (other)     → localhost:${ocGatewayPort} (gateway fallback)`);
 
   // ── Startup health checks ──────────────────────────────────────────
   console.log("");
@@ -1625,7 +1850,7 @@ module.exports = {
 
       mkdirSync(mcporterDir, { recursive: true });
       writeFileSync(mcporterConfigPath, JSON.stringify(mcporterConfig, null, 2) + "\n", "utf8");
-      ok("Registered MCP server with mcporter (16 browser tools available)");
+      ok("Registered MCP server with mcporter (34 tools: 16 browser + 10 AI + 5 profiling + 3 chat)");
       info(`  Config: ${mcporterConfigPath}`);
 
       // Step 3: Install the navigator-bridge skill so the OC agent knows about all tools
@@ -1670,7 +1895,9 @@ module.exports = {
         "mcporter call navigator.navigator_status",
         BT,
         "",
-        "## All 16 tools",
+        "## All 34 tools",
+        "",
+        "### Browser Control (16 tools)",
         "",
         "| Tool | What it does |",
         "|------|-------------|",
@@ -1691,6 +1918,39 @@ module.exports = {
         "| `navigator_query_element` | Inspect DOM element |",
         "| `navigator_wait_ready` | Wait for page load |",
         "",
+        "### AI Browser Intelligence (10 tools)",
+        "",
+        "| Tool | What it does |",
+        "|------|-------------|",
+        "| `navigator_analyze_page` | Full page analysis — forms, buttons, inputs, links, tables, modals |",
+        "| `navigator_find_element` | Find element by natural language intent (e.g. 'login button') |",
+        "| `navigator_is_ready` | Smart page readiness — checks spinners, skeletons, pending XHR |",
+        "| `navigator_wait_for_element` | Wait for CSS selector to appear (MutationObserver) |",
+        "| `navigator_extract_data` | Extract structured data — text, table, JSON, list, or HTML |",
+        "| `navigator_smart_fill` | Fill form fields by label/name matching (React-safe) |",
+        "| `navigator_intercept_api` | Capture fetch/XHR calls — see what APIs the page uses |",
+        "| `navigator_set_cookies` | Set cookies on the current domain |",
+        "| `navigator_get_performance` | Core Web Vitals and resource transfer stats |",
+        "| `navigator_get_page_state` | Full page state — URL, title, readyState, analysis, timestamp |",
+        "",
+        "### User Profiling (5 tools)",
+        "",
+        "| Tool | What it does |",
+        "|------|-------------|",
+        "| `navigator_get_page_visits` | Get browsing history (auto-recorded page visits) |",
+        "| `navigator_save_page_summary` | Save AI-generated summary of a page |",
+        "| `navigator_get_page_summaries` | Retrieve saved page summaries |",
+        "| `navigator_get_user_profile` | Get aggregated user interest profile |",
+        "| `navigator_save_user_profile` | Save/update user profile from browsing patterns |",
+        "",
+        "### Chat (3 tools)",
+        "",
+        "| Tool | What it does |",
+        "|------|-------------|",
+        "| `navigator_get_chat_messages` | Get recent messages from the Navigator chat pane |",
+        "| `navigator_chat_respond` | Send a response message to the Navigator chat pane |",
+        "| `navigator_chat_stream` | Stream partial text to the chat pane (typing effect) |",
+        "",
         "## Usage",
         "",
         BT + "bash",

package/mcp.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * openclaw-navigator MCP server v5.0.1
+ * openclaw-navigator MCP server v5.1.0
  *
  * Exposes the Navigator bridge HTTP API as MCP tools so the OpenClaw agent
  * can control the browser natively via its tool schema.
@@ -204,7 +204,7 @@ async function sendCommand(command, payload, poll) {
   };
 }
 
-// ── Tool definitions (31 tools: 16 browser + 10 AI intelligence + 5 profiling) ────────────────
+// ── Tool definitions (34 tools: 16 browser + 10 AI intelligence + 5 profiling + 3 chat) ────────────────
 
 const TOOLS = [
   // ── Direct HTTP ──
@@ -596,6 +596,44 @@ const TOOLS = [
       required: ["profile"],
     },
   },
+
+  // ── Chat Tools ──
+  {
+    name: "navigator_get_chat_messages",
+    description: "Get recent chat messages from the Navigator chat pane. Use this to see what the user is asking.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionKey: { type: "string", description: "Chat session key (default: main)", default: "main" },
+        limit: { type: "number", description: "Max messages to return (default: 20)", default: 20 },
+      },
+    },
+  },
+  {
+    name: "navigator_chat_respond",
+    description: "Send a response message to the Navigator chat pane. The user will see this as an agent message.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "The response message to send" },
+        sessionKey: { type: "string", description: "Chat session key (default: main)", default: "main" },
+      },
+      required: ["message"],
+    },
+  },
+  {
+    name: "navigator_chat_stream",
+    description: "Stream a partial response to the Navigator chat pane (for real-time typing effect).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Partial text to stream" },
+        sessionKey: { type: "string", description: "Chat session key (default: main)", default: "main" },
+        runId: { type: "string", description: "Run ID for grouping streamed chunks" },
+      },
+      required: ["text"],
+    },
+  },
 ];
 
 // ── Tool handler dispatch ─────────────────────────────────────────────────
@@ -823,6 +861,34 @@ async function handleTool(name, args) {
           }),
         );
 
+      // ── Chat Tools ──
+      case "navigator_get_chat_messages": {
+        const sessionKey = args.sessionKey || "main";
+        const limit = args.limit ?? 20;
+        const data = await bridgeGet(`/api/sessions/history?sessionKey=${encodeURIComponent(sessionKey)}`);
+        if (data.ok && Array.isArray(data.messages)) {
+          return jsonResult({ ok: true, messages: data.messages.slice(-limit) });
+        }
+        return jsonResult(data);
+      }
+
+      case "navigator_chat_respond":
+        return jsonResult(
+          await bridgePost("/api/sessions/respond", {
+            content: args.message,
+            sessionKey: args.sessionKey || "main",
+          }),
+        );
+
+      case "navigator_chat_stream":
+        return jsonResult(
+          await bridgePost("/api/sessions/stream", {
+            text: args.text,
+            sessionKey: args.sessionKey || "main",
+            runId: args.runId || null,
+          }),
+        );
+
       default:
         return errorResult(`Unknown tool: ${name}`);
     }
@@ -835,7 +901,7 @@ async function handleTool(name, args) {
 // ── MCP server wiring ─────────────────────────────────────────────────────
 
 const server = new Server(
-  { name: "openclaw-navigator", version: "5.0.0" },
+  { name: "openclaw-navigator", version: "5.1.0" },
   { capabilities: { tools: {} } },
 );
 

package/package.json

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