claude-browser-bridge 4.0.2 → 4.0.4

package/bin/cli.js

@@ -10,7 +10,7 @@
 import { fileURLToPath } from "node:url";
 import { dirname, join, resolve } from "node:path";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { randomBytes } from "node:crypto";
+import { randomBytes, createHash } from "node:crypto";
 import { execSync } from "node:child_process";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -46,9 +46,15 @@ Docs: https://github.com/HimanshuKanwar2001/claude-browser-bridge
 
 async function init() {
   const extPath = args[args.indexOf("init") + 1] || null;
-  const token = randomBytes(24).toString("hex");
   const os = await import("node:os");
   const home = os.homedir();
+  const port = process.env.BRIDGE_PORT || "8787";
+
+  // Use deterministic token by default (same every time on this machine)
+  const useRandom = args.includes("--random");
+  const token = useRandom
+    ? randomBytes(24).toString("hex")
+    : createHash("sha256").update(`claude-browser-bridge:${os.userInfo().username}@${os.hostname()}:${port}`).digest("hex");
 
   // Write to canonical path: ~/.claude/browser-bridge-token
   const claudeDir = join(home, ".claude");

package/gen-token.js

@@ -1,16 +1,25 @@
-// Generates the shared secret used to authenticate the extension to the bridge.
-// Writes to THREE locations so the token works regardless of install method:
-//   1. ~/.claude/browser-bridge-token  (canonical — works with global npm install)
-//   2. server/.bridge-token            (legacy — works with cloned repo)
-//   3. extension/config.js             (embedded in the Chrome extension)
+// Generates the auth token for the browser bridge.
+// By default uses a deterministic token derived from the machine identity
+// (username + hostname) so it's always the same — no sync issues.
+// Pass --random for a cryptographically random token instead.
 
-import { randomBytes } from "node:crypto";
-import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { homedir, hostname, userInfo } from "node:os";
 
-const token = randomBytes(24).toString("hex");
+const PORT = Number(process.env.BRIDGE_PORT) || 8787;
+const useRandom = process.argv.includes("--random");
+
+let token;
+if (useRandom) {
+  token = randomBytes(24).toString("hex");
+  console.log("Generated random token (unique, not machine-derived)");
+} else {
+  const identity = `claude-browser-bridge:${userInfo().username}@${hostname()}:${PORT}`;
+  token = createHash("sha256").update(identity).digest("hex");
+  console.log("Generated deterministic token (same every time on this machine)");
+}
 
 // 1. Write to ~/.claude/browser-bridge-token (canonical path)
 const claudeDir = join(homedir(), ".claude");
@@ -19,15 +28,13 @@ const canonicalPath = join(claudeDir, "browser-bridge-token");
 writeFileSync(canonicalPath, token + "\n");
 console.log(`✓ Token written to ${canonicalPath}`);
 
-// 2. Write to server/.bridge-token (legacy, for local repo use)
+// 2. Write to server/.bridge-token (legacy fallback)
 try {
   writeFileSync(new URL("./.bridge-token", import.meta.url), token + "\n");
   console.log("✓ Token written to server/.bridge-token");
-} catch {
-  // May fail if running from global install (read-only node_modules)
-}
+} catch {}
 
-// 3. Write extension/config.js (search multiple locations)
+// 3. Write extension/config.js
 const searchPaths = [
   new URL("../extension/config.js", import.meta.url).pathname,
   join(process.cwd(), "extension", "config.js"),
@@ -48,4 +55,4 @@ if (!extensionWritten) {
   console.log(`  const BRIDGE_TOKEN = "${token}";`);
 }
 
-console.log("\n✓ Token generated. Reload the extension in chrome://extensions to apply.");
+console.log("\n✓ Done. Reload the extension in chrome://extensions to apply.");

package/index.js

@@ -6,9 +6,10 @@
 // "owns" the bridge; later sessions detect EADDRINUSE and relay their tool
 // calls through the owner. If the owner exits, a relay takes over the port.
 
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { homedir, hostname, userInfo } from "node:os";
+import { createHash } from "node:crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -19,33 +20,46 @@ import WebSocket, { WebSocketServer } from "ws";
 
 const PORT = Number(process.env.BRIDGE_PORT) || 8787;
 
-// Token resolution: check multiple locations so it works whether the server
-// runs from a global npm install, npx, or the cloned repo.
-const TOKEN_LOCATIONS = [
-  process.env.BRIDGE_TOKEN_PATH,                              // explicit override
-  join(homedir(), ".claude", "browser-bridge-token"),          // canonical home path
-  new URL("./.bridge-token", import.meta.url).pathname,       // relative to server file (repo install)
-  join(process.cwd(), "server", ".bridge-token"),              // cwd/server/ (cloned repo)
-  join(process.cwd(), ".bridge-token"),                        // cwd root
-].filter(Boolean);
+// Deterministic token: derived from machine identity (username + hostname).
+// Same token every time on the same machine — no file sync issues, no
+// regeneration needed, no stale-token bugs across sessions.
+// Falls back to file-based token if BRIDGE_TOKEN env var or token file exists.
+function deriveToken() {
+  const identity = `claude-browser-bridge:${userInfo().username}@${hostname()}:${PORT}`;
+  return createHash("sha256").update(identity).digest("hex");
+}
 
 function readToken() {
-  // Also check env var directly
+  // 1. Explicit env var override
   if (process.env.BRIDGE_TOKEN) return process.env.BRIDGE_TOKEN;
-  for (const p of TOKEN_LOCATIONS) {
+  // 2. File-based token (legacy — checked for backwards compatibility)
+  const filePaths = [
+    process.env.BRIDGE_TOKEN_PATH,
+    join(homedir(), ".claude", "browser-bridge-token"),
+    new URL("./.bridge-token", import.meta.url).pathname,
+    join(process.cwd(), "server", ".bridge-token"),
+    join(process.cwd(), ".bridge-token"),
+  ].filter(Boolean);
+  for (const p of filePaths) {
     try {
       const t = readFileSync(p, "utf8").trim();
       if (t) return t;
     } catch {}
   }
-  return null;
+  // 3. Deterministic token (always works, no files needed)
+  return deriveToken();
 }
-if (!readToken()) {
-  console.error(
-    "[bridge] WARNING: auth token not found. Run `claude-browser-bridge init` " +
-      "or `node gen-token.js`. Searched:\n" +
-      TOKEN_LOCATIONS.map(p => "  - " + p).join("\n")
-  );
+
+// Write the deterministic token to the canonical location so gen-token.js
+// isn't required anymore (but still works for custom tokens).
+const canonicalDir = join(homedir(), ".claude");
+const canonicalPath = join(canonicalDir, "browser-bridge-token");
+if (!existsSync(canonicalPath)) {
+  try {
+    if (!existsSync(canonicalDir)) mkdirSync(canonicalDir, { recursive: true });
+    writeFileSync(canonicalPath, deriveToken() + "\n");
+    console.error(`[bridge] Auto-generated token at ${canonicalPath}`);
+  } catch {}
 }
 
 // --- WebSocket bridge (owner or relay) -------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-browser-bridge",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "Connect your live Chrome tabs to Claude Code — 65 tools for debugging, performance, accessibility, visual inspection, and browser automation.",
   "type": "module",
   "bin": {