openclaw-navigator 4.3.6 → 4.3.8

package/cli.mjs

@@ -58,6 +58,9 @@ const validTokens = new Set();
 // OC Web UI reverse proxy target (configurable via --ui-port or env)
 let ocUIPort = parseInt(process.env.OPENCLAW_UI_PORT ?? "4000", 10);
 
+// Tunnel URL — set once the tunnel is active, exposed via /navigator/status
+let activeTunnelURL = null;
+
 // Pairing code state
 let pairingCode = null;
 let pairingData = null;
@@ -217,6 +220,10 @@ function handleRequest(req, res) {
         pendingCommandCount: pendingCommands.length,
         recentEventCount: recentEvents.length,
       },
+      tunnel: activeTunnelURL ? {
+        url: activeTunnelURL,
+        uiURL: `${activeTunnelURL}/ui/`,
+      } : null,
     });
     return;
   }
@@ -670,6 +677,7 @@ ${BOLD}How it works:${RESET}
 
       if (result) {
         tunnelURL = result.url;
+        activeTunnelURL = tunnelURL; // Expose via /navigator/status
         tunnelProcess = result.process;
         gatewayURL = tunnelURL; // Use tunnel URL as the gateway URL
 
@@ -771,49 +779,57 @@ ${BOLD}How it works:${RESET}
 
     ok(`MCP server started (PID ${mcpProcess.pid}) — bridge: http://localhost:${port}`);
 
-    // ── Auto-register MCP server with mcporter (if available) ─────────
+    // ── Auto-register MCP server with mcporter ────────────────────────
     // Writes directly to ~/.mcporter/mcporter.json for reliability.
     //
-    // KEY FIX: We resolve stable paths instead of using process.execPath
-    // which may point to a temp npx cache (/Users/x/.npm/_npx/<hash>/node)
-    // that disappears after npx exits. We find the REAL node binary and
-    // the globally-installed mcp.mjs (or realpath of the current one).
+    // npx runs from a temp cache dir (.npm/_npx/<hash>/) that disappears.
+    // To get stable paths we:
+    //   1. Install openclaw-navigator globally (npm i -g)
+    //   2. Use the global install path for mcporter config
+    //   3. If global install fails, find node's real path via `which node`
     try {
-      const { readFileSync, writeFileSync, mkdirSync, realpathSync } = await import("node:fs");
+      const { readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
+      const { execSync } = await import("node:child_process");
       const { homedir } = await import("node:os");
 
-      // Resolve stable node binary (follow symlinks out of npx temp dir)
+      // Step 1: Install globally to get a stable path
       let stableNode;
-      try {
-        stableNode = realpathSync(process.execPath);
-      } catch {
-        stableNode = process.execPath;
-      }
-
-      // Resolve stable mcp.mjs path
       let stableMcpPath;
+
       try {
-        stableMcpPath = realpathSync(mcpPath);
-      } catch {
-        stableMcpPath = mcpPath;
-      }
+        info("  Installing openclaw-navigator globally for stable paths...");
+        execSync("npm install -g openclaw-navigator@latest", {
+          stdio: ["ignore", "ignore", "ignore"],
+          timeout: 30000,
+        });
+
+        // Find the global node and mcp.mjs
+        const globalPrefix = execSync("npm prefix -g", { encoding: "utf8" }).trim();
+        stableMcpPath = join(globalPrefix, "lib/node_modules/openclaw-navigator/mcp.mjs");
+        // Find node via `which` — always gives the real PATH-resolved binary
+        stableNode = execSync("which node", { encoding: "utf8" }).trim();
+
+        if (!existsSync(stableMcpPath)) {
+          throw new Error(`Global mcp.mjs not found at ${stableMcpPath}`);
+        }
 
-      // If paths are still in npx temp cache, try to find the real install
-      if (stableMcpPath.includes("_npx") || stableMcpPath.includes(".npm/_npx")) {
-        // Check if openclaw-navigator is installed globally
-        const nodeDir = dirname(stableNode);
-        const globalMcp = join(dirname(nodeDir), "lib/node_modules/openclaw-navigator/mcp.mjs");
-        if (existsSync(globalMcp)) {
-          stableMcpPath = globalMcp;
+        ok(`Global install: ${stableMcpPath}`);
+      } catch (installErr) {
+        // Global install failed (permissions?) — fallback to which node + current mcpPath
+        warn(`Global install failed: ${installErr.message}`);
+        try {
+          stableNode = execSync("which node", { encoding: "utf8" }).trim();
+        } catch {
+          stableNode = process.execPath;
         }
-        // If still temp, that's OK — mcporter will use the path we give it
-        // and the bridge running alongside keeps the MCP server alive anyway
+        stableMcpPath = mcpPath;
+        info(`  Falling back to: ${stableNode} ${stableMcpPath}`);
       }
 
       info(`  mcporter: node=${stableNode}`);
       info(`  mcporter: mcp=${stableMcpPath}`);
 
-      // Write directly to ~/.mcporter/mcporter.json
+      // Step 2: Write directly to ~/.mcporter/mcporter.json
       const mcporterDir = join(homedir(), ".mcporter");
       const mcporterConfigPath = join(mcporterDir, "mcporter.json");
 
@@ -848,18 +864,24 @@ ${BOLD}How it works:${RESET}
     // so the bridge + MCP server starts automatically on login.
     if (process.platform === "darwin") {
       try {
-        const { writeFileSync: writePlist, existsSync: plistExists, mkdirSync: mkPlist } = await import("node:fs");
+        const {
+          writeFileSync: writePlist,
+          existsSync: plistExists,
+          mkdirSync: mkPlist,
+        } = await import("node:fs");
         const { homedir: homeDir } = await import("node:os");
         const home = homeDir();
         const launchAgentsDir = join(home, "Library/LaunchAgents");
         const plistPath = join(launchAgentsDir, "com.openclaw.navigator-bridge.plist");
 
-        // Resolve the stable node path (same one we found above for mcporter)
-        const { realpathSync: rp } = await import("node:fs");
+        // Find stable node/npx paths via `which` (not temp npx cache)
+        const { execSync: whichExec } = await import("node:child_process");
         let nodeForPlist;
-        try { nodeForPlist = rp(process.execPath); } catch { nodeForPlist = process.execPath; }
-
-        // Find npx next to the stable node
+        try {
+          nodeForPlist = whichExec("which node", { encoding: "utf8" }).trim();
+        } catch {
+          nodeForPlist = process.execPath;
+        }
         const npxForPlist = join(dirname(nodeForPlist), "npx");
 
         const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
@@ -901,9 +923,15 @@ ${BOLD}How it works:${RESET}
         // Load the service (unload first if already loaded)
         try {
           const { execSync: ex } = await import("node:child_process");
-          try { ex(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" }); } catch { /* not loaded */ }
+          try {
+            ex(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+          } catch {
+            /* not loaded */
+          }
           // Don't load now — we're already running. It'll start on next login.
-        } catch { /* launchctl not available */ }
+        } catch {
+          /* launchctl not available */
+        }
 
         ok("Auto-start installed — bridge will start on login");
         info(`  Plist: ${plistPath}`);

package/mcp.mjs

@@ -156,7 +156,13 @@ const TOOLS = [
   {
     name: "navigator_status",
     description:
-      "Get the Navigator bridge status — connection state, active tabs, current URL, uptime, pending commands.",
+      "Get the Navigator bridge status — connection state, active tabs, current URL, uptime, pending commands. Also returns the tunnel URL and OC Web UI URL.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "navigator_get_ui_url",
+    description:
+      "Get the OC Web UI URL. Returns the Cloudflare tunnel URL with /ui/ path that serves the OpenClaw dashboard. Use this to find the URL before navigating to the UI.",
     inputSchema: { type: "object", properties: {} },
   },
 
@@ -356,6 +362,24 @@ async function handleTool(name, args) {
       case "navigator_status":
         return jsonResult(await bridgeGet("/navigator/status"));
 
+      case "navigator_get_ui_url": {
+        const status = await bridgeGet("/navigator/status");
+        if (status.tunnel?.uiURL) {
+          return jsonResult({
+            ok: true,
+            uiURL: status.tunnel.uiURL,
+            tunnelURL: status.tunnel.url,
+            hint: "Navigate to uiURL to access the OC Web UI dashboard",
+          });
+        }
+        return jsonResult({
+          ok: true,
+          uiURL: `${BRIDGE_URL}/ui/`,
+          tunnelURL: null,
+          hint: "No tunnel active — UI accessible locally only. Start with --mcp to enable tunnel.",
+        });
+      }
+
       // ── Fire-and-forget ──
       case "navigator_navigate":
         return jsonResult(await sendCommand("navigate", { url: args.url }));

package/package.json

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