npm - mcp-page-bridge - Versions diffs - 0.1.4 → 0.1.6 - Mend

mcp-page-bridge 0.1.4 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/bridge.d.ts +7 -0
package/dist/bridge.js +1 -1
package/dist/{chunk-RRWNJUKA.js → chunk-XUK2DGX4.js} +507 -79
package/dist/cli.d.ts +18 -1
package/dist/cli.js +256 -29
package/package.json +2 -2

package/dist/bridge.d.ts CHANGED Viewed

@@ -40,6 +40,13 @@ interface BridgeOptions {
     host?: string;
     /** If set, browsers must connect with `?token=<token>` or they're rejected. */
     token?: string;
+    /**
+     * If set (> 0), the bridge shuts itself down after this many ms with no
+     * connected browser providers AND no attached `/agent` connections.
+     */
+    idleTimeoutMs?: number;
+    /** Invoked after an idle-triggered shutdown completes (e.g. to exit a daemon). */
+    onIdleShutdown?: () => void;
 }
 declare function createBridge(opts?: BridgeOptions): Promise<Bridge>;

package/dist/bridge.js CHANGED Viewed

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   createBridge
-} from "./chunk-RRWNJUKA.js";
+} from "./chunk-XUK2DGX4.js";
 export {
   createBridge
 };

package/dist/{chunk-RRWNJUKA.js → chunk-XUK2DGX4.js} RENAMED Viewed

@@ -21,7 +21,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 // ../protocol/src/index.ts
-var MCP_PAGE_BRIDGE_VERSION = "0.1.4";
+var MCP_PAGE_BRIDGE_VERSION = "0.1.6";
 var WS_SUBPROTOCOL = "mcp";
 var DEFAULT_PORT = 8787;
 var NAMESPACE_SEP = "__";
@@ -35,6 +35,52 @@ function namespaceName(label, name) {
 }
 var MCP_PAGE_BRIDGE_DASHBOARD_ACTIVATE_TAB = "mcpPageBridge/activateTab";
 var MCP_PAGE_BRIDGE_DASHBOARD_CLOSE_TAB = "mcpPageBridge/closeTab";
+var DASHBOARD_HEADER = "x-mcp-page-bridge-dashboard";
+var DASHBOARD_HEADER_VALUE = "1";
+var TOKEN_HEADER = "x-mcp-page-bridge-token";
+var SERVICE_ID = "mcp-page-bridge";
+var BUILTIN_TOOL_NAMES = [
+  // Page inspection / interaction
+  "eval",
+  "dom_query",
+  "get_page_info",
+  "click",
+  "set_value",
+  "scroll",
+  "wait_for",
+  "get_html",
+  // Element selection
+  "get_selected_element",
+  "get_selected_elements",
+  "get_computed_style",
+  "highlight_element",
+  "show_selected_marker",
+  "hide_selected_marker",
+  "clear_selected_elements",
+  "remove_selected_element",
+  "update_selected_element",
+  // CSS patching
+  "apply_css",
+  "list_css_patches",
+  "remove_css_patch",
+  "clear_css_patches",
+  "export_css_patches",
+  "export_design_changes",
+  // Audits / diagnostics
+  "accessibility_audit",
+  "responsive_summary",
+  "debug_summary",
+  "console_logs",
+  // Design baseline
+  "capture_design_baseline",
+  "compare_design_baseline",
+  "clear_design_baseline",
+  // Service-worker delegated
+  "screenshot",
+  "navigate",
+  "reload"
+];
+var BROWSER_TOOL_NAMES = ["list_tabs", "open_tab", "activate_tab", "navigate_tab", "close_tab"];
 // src/dashboard.ts
 var FAVICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><polygon points="22.39,6.00 22.39,18.00 12.00,24.00 1.61,18.00 1.61,6.00 12.00,0.00" fill="#E63946"/><svg x="3" y="3" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="#ffffff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 22v-5"/><path d="M15 8V2"/><path d="M17 8a1 1 0 0 1 1 1v4a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1z"/><path d="M9 8V2"/></svg></svg>';
@@ -139,7 +185,21 @@ var DASHBOARD_HTML = `<!doctype html>
       .status { display: flex; align-items: center; gap: 9px; color: var(--muted); }
       .dot { width: 8px; height: 8px; background: var(--brand); box-shadow: 0 0 0 4px var(--brand-soft); }
       .dot.on { background: var(--green); box-shadow: 0 0 0 4px var(--green-soft); }
+      .status-actions { display: flex; align-items: center; gap: 10px; }
       .refresh { color: var(--quiet); font-size: 12px; font-family: var(--mono); }
+      .shutdown-btn {
+        appearance: none;
+        border: 1px solid color-mix(in srgb, var(--brand) 42%, var(--line));
+        border-radius: 4px;
+        background: var(--brand-soft);
+        color: var(--brand);
+        padding: 6px 9px;
+        cursor: pointer;
+        font-size: 12px;
+        font-weight: 700;
+      }
+      .shutdown-btn:hover { border-color: var(--brand); }
+      .shutdown-btn:disabled { opacity: 0.58; cursor: wait; }
       .stats {
         display: grid;
         grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -334,7 +394,33 @@ var DASHBOARD_HTML = `<!doctype html>
       .empty.small { min-height: 96px; border: 1px dashed var(--line); border-radius: 5px; background: var(--panel-2); }
       .placeholder { color: var(--muted); }
       code { border: 1px solid var(--line); background: var(--panel-2); padding: 1px 5px; border-radius: 3px; font-family: var(--mono); }
-      footer { margin-top: 20px; color: var(--quiet); font-size: 12px; }
+      .search {
+        width: 100%;
+        margin-bottom: 12px;
+        border: 1px solid var(--line);
+        border-radius: 6px;
+        background: var(--panel-2);
+        color: var(--fg);
+        padding: 9px 11px;
+        font: inherit;
+        font-size: 13px;
+      }
+      .search:focus { outline: none; border-color: var(--line-strong); }
+      .search::placeholder { color: var(--quiet); }
+      .provider-meta { margin-top: 6px; display: flex; flex-wrap: wrap; gap: 10px; color: var(--quiet); font-family: var(--mono); font-size: 11px; }
+      .detail-head-right { display: flex; align-items: center; gap: 10px; }
+      .copy-btn {
+        appearance: none;
+        border: 1px solid var(--line);
+        border-radius: 4px;
+        background: var(--panel-2);
+        color: var(--muted);
+        padding: 4px 8px;
+        cursor: pointer;
+        font-size: 11px;
+      }
+      .copy-btn:hover { color: var(--fg); border-color: var(--line-strong); }
+      mark { background: var(--brand-soft); color: inherit; border-radius: 2px; padding: 0 1px; }
       @media (max-width: 900px) {
         .topbar, .status-row { align-items: flex-start; flex-direction: column; }
         .endpoint { justify-content: flex-start; }
@@ -374,7 +460,10 @@ var DASHBOARD_HTML = `<!doctype html>
           <span class="dot" id="dot"></span>
           <span id="statusText">connecting</span>
         </div>
-        <div class="refresh">auto refresh: 1.5s</div>
+        <div class="status-actions">
+          <div class="refresh">auto refresh: 1.5s</div>
+          <button class="shutdown-btn" id="shutdownBtn" type="button">Shutdown bridge</button>
+        </div>
       </div>
       <section class="stats" aria-label="Connected provider summary">
@@ -385,14 +474,13 @@ var DASHBOARD_HTML = `<!doctype html>
       <main class="layout">
         <section>
           <div class="panel-title"><span>Providers</span><span id="listCount">0 connected</span></div>
+          <input class="search" id="search" type="search" placeholder="Filter tools by name or description\u2026" autocomplete="off" spellcheck="false" />
           <div id="list"></div>
         </section>
         <aside class="detail" id="detail">
           <div class="detail-inner"><div class="empty placeholder">Select an item to inspect its schema and source.</div></div>
         </aside>
       </main>
-      <footer>Dashboard is served by the local bridge on the same port as WebSocket transport.</footer>
     </div>
     <script>
@@ -400,28 +488,52 @@ var DASHBOARD_HTML = `<!doctype html>
       const esc = (s) =>
         String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
+      // The bridge requires the shared token (if configured) on HTTP requests too.
+      // Operators open the dashboard as http://127.0.0.1:<port>/?token=<secret>.
+      const BRIDGE_TOKEN = new URLSearchParams(location.search).get("token") || "";
+      const TOKEN_HEADER = "x-mcp-page-bridge-token";
+      const DASHBOARD_HEADER = "x-mcp-page-bridge-dashboard";
+      function authHeaders(extra) {
+        const headers = Object.assign({}, extra || {});
+        if (BRIDGE_TOKEN) headers[TOKEN_HEADER] = BRIDGE_TOKEN;
+        return headers;
+      }
+      function withToken(path) {
+        return BRIDGE_TOKEN ? path + (path.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(BRIDGE_TOKEN) : path;
+      }
       const EMPTY = "No tools published.";
-      const BUILTIN_TOOLS = new Set([
-        "eval",
-        "dom_query",
-        "get_html",
-        "get_page_info",
-        "click",
-        "set_value",
-        "scroll",
-        "wait_for",
-        "console_logs",
-        "screenshot",
-        "navigate",
-        "reload",
-      ]);
-      const BROWSER_TOOLS = new Set(["list_tabs", "open_tab", "activate_tab", "navigate_tab", "close_tab"]);
+      const BUILTIN_TOOLS = new Set(${JSON.stringify([...BUILTIN_TOOL_NAMES])});
+      const BROWSER_TOOLS = new Set(${JSON.stringify([...BROWSER_TOOL_NAMES])});
       let data = { version: "", port: 8787, providers: [] };
       let selected = null; // { kind, provider, key }
+      let filter = ""; // lowercased tool filter query
+      let bridgeOnline = false;
+      let shutdownRequested = false;
       const openProviders = Object.create(null);
       const openGroups = Object.create(null);
+      function timeAgo(iso) {
+        const t = Date.parse(iso);
+        if (!Number.isFinite(t)) return "";
+        const s = Math.max(0, Math.round((Date.now() - t) / 1000));
+        if (s < 60) return s + "s";
+        const m = Math.floor(s / 60);
+        if (m < 60) return m + "m";
+        const h = Math.floor(m / 60);
+        if (h < 24) return h + "h";
+        return Math.floor(h / 24) + "d";
+      }
+      function highlight(text) {
+        const s = esc(text);
+        if (!filter) return s;
+        const i = s.toLowerCase().indexOf(filter);
+        if (i < 0) return s;
+        return s.slice(0, i) + "<mark>" + s.slice(i, i + filter.length) + "</mark>" + s.slice(i + filter.length);
+      }
       function shortName(provider, key) {
         const raw = String(key || "");
         const prefix = provider.label + "__";
@@ -468,9 +580,16 @@ var DASHBOARD_HTML = `<!doctype html>
         return "Page tools";
       }
+      function matchesFilter(provider, item) {
+        if (!filter) return true;
+        const hay = (shortName(provider, item.name) + " " + item.name + " " + (item.description || "")).toLowerCase();
+        return hay.includes(filter);
+      }
       function groupsFor(provider) {
         const buckets = new Map();
         for (const item of itemList(provider)) {
+          if (!matchesFilter(provider, item)) continue;
           const title = classifyTool(provider, item);
           if (!buckets.has(title)) buckets.set(title, []);
           buckets.get(title).push(item);
@@ -491,12 +610,12 @@ var DASHBOARD_HTML = `<!doctype html>
           esc(key) +
           '">' +
           '<span><span class="nm">' +
-          esc(local) +
+          highlight(local) +
           '</span><span class="full">' +
           esc(key) +
           "</span></span>" +
           '<span class="ds">' +
-          esc(itemDescription(item)) +
+          highlight(itemDescription(item)) +
           "</span></button>"
         );
       }
@@ -507,7 +626,7 @@ var DASHBOARD_HTML = `<!doctype html>
         return groups
           .map((group) => {
             const id = groupId(provider, group.title);
-            const open = openGroups[id] !== false;
+            const open = filter ? true : openGroups[id] !== false;
             return (
               '<details class="group" data-group="' +
               esc(id) +
@@ -527,8 +646,16 @@ var DASHBOARD_HTML = `<!doctype html>
       function renderProvider(provider) {
         const c = counts(provider);
+        if (filter && !groupsFor(provider).length) return "";
         const title = provider.title || provider.name || provider.label;
-        const open = openProviders[provider.label] === true;
+        const open = filter ? true : openProviders[provider.label] === true;
+        const metaParts = [];
+        if (provider.version) metaParts.push("v" + esc(provider.version));
+        const ago = timeAgo(provider.connectedAt);
+        if (ago) metaParts.push("connected " + ago + " ago");
+        const metaHtml = metaParts.length
+          ? '<div class="provider-meta">' + metaParts.map((m) => "<span>" + m + "</span>").join("") + "</div>"
+          : "";
         const actions =
           provider.tabId === undefined
             ? ""
@@ -550,6 +677,7 @@ var DASHBOARD_HTML = `<!doctype html>
           esc(title) +
           "</span></div>" +
           (provider.url ? '<div class="url">' + esc(provider.url) + "</div>" : "") +
+          metaHtml +
           '</div><div class="provider-side"><div class="metrics"><span class="metric">Tools ' +
           c.tool +
           "</span></div>" +
@@ -571,9 +699,9 @@ var DASHBOARD_HTML = `<!doctype html>
       async function callProviderAction(provider, action) {
         if (action === "close" && !confirm("Close tab for provider " + provider + "?")) return;
-        const res = await fetch("/api/providers/" + encodeURIComponent(provider) + "/" + action, {
+        const res = await fetch(withToken("/api/providers/" + encodeURIComponent(provider) + "/" + action), {
           method: "POST",
-          headers: { "x-mcp-page-bridge-dashboard": "1" },
+          headers: authHeaders({ [DASHBOARD_HEADER]: "1" }),
         });
         const body = await res.json().catch(() => ({}));
         if (!res.ok || body.ok === false) throw new Error(body.error || "action failed");
@@ -581,14 +709,47 @@ var DASHBOARD_HTML = `<!doctype html>
         await tick();
       }
+      async function shutdownBridge() {
+        if (!confirm("Shutdown the local mcp-page-bridge daemon? Connected agents and browser tabs will disconnect.")) return;
+        const btn = $("shutdownBtn");
+        btn.disabled = true;
+        $("statusText").textContent = "shutting down bridge";
+        const res = await fetch(withToken("/api/shutdown"), {
+          method: "POST",
+          headers: authHeaders({ [DASHBOARD_HEADER]: "1" }),
+        });
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok || body.ok === false) throw new Error(body.error || "shutdown failed");
+        shutdownRequested = true;
+        bridgeOnline = false;
+        selected = null;
+        data = { version: data.version, port: data.port, providers: [] };
+        $("dot").className = "dot";
+        $("statusText").textContent = "bridge shutdown requested";
+        updateStats();
+        renderList();
+        renderDetail();
+      }
       function renderList() {
         const list = $("list");
+        if (!bridgeOnline) {
+          list.innerHTML = shutdownRequested
+            ? '<div class="card"><div class="empty">Bridge shutdown requested.<br/>Restart mcp-page-bridge to use the dashboard again.</div></div>'
+            : '<div class="card"><div class="empty">Bridge is not reachable.<br/>Start mcp-page-bridge and refresh this page.</div></div>';
+          return;
+        }
         if (!data.providers.length) {
           list.innerHTML =
             '<div class="card"><div class="empty">No browsers connected yet.<br/>Enable the mcp-page-bridge extension on a tab.</div></div>';
           return;
         }
-        list.innerHTML = data.providers.map(renderProvider).join("");
+        const html = data.providers.map(renderProvider).join("");
+        if (!html) {
+          list.innerHTML = '<div class="card"><div class="empty">No tools match "' + esc(filter) + '".</div></div>';
+          return;
+        }
+        list.innerHTML = html;
         for (const card of document.querySelectorAll(".provider-card")) {
           card.addEventListener("toggle", () => {
@@ -654,6 +815,10 @@ var DASHBOARD_HTML = `<!doctype html>
       function renderDetail() {
         const el = $("detail");
+        if (!bridgeOnline) {
+          el.innerHTML = '<div class="detail-inner"><div class="empty placeholder">Bridge is offline.</div></div>';
+          return;
+        }
         if (!selected) {
           el.innerHTML = '<div class="detail-inner"><div class="empty placeholder">Select an item to inspect its schema and source.</div></div>';
           return;
@@ -681,13 +846,28 @@ var DASHBOARD_HTML = `<!doctype html>
         el.innerHTML =
           '<div class="detail-inner"><div class="detail-head"><span class="kind">' +
           kind +
-          '</span><span class="from">' +
+          '</span><div class="detail-head-right"><button class="copy-btn" id="copyName" type="button">Copy name</button><span class="from">' +
           esc(source) +
-          "</span></div><h2>" +
+          "</span></div></div><h2>" +
           esc(key) +
           "</h2>" +
           body +
           "</div>";
+        const copyBtn = $("copyName");
+        if (copyBtn) {
+          copyBtn.addEventListener("click", () => {
+            const done = () => {
+              copyBtn.textContent = "Copied";
+              setTimeout(() => {
+                copyBtn.textContent = "Copy name";
+              }, 1200);
+            };
+            if (navigator.clipboard?.writeText) {
+              navigator.clipboard.writeText(key).then(done).catch(() => {});
+            }
+          });
+        }
       }
       function updateStats() {
@@ -699,8 +879,21 @@ var DASHBOARD_HTML = `<!doctype html>
       async function tick() {
         try {
-          const res = await fetch("/api/providers", { cache: "no-store" });
+          const res = await fetch(withToken("/api/providers"), { cache: "no-store", headers: authHeaders() });
           data = await res.json();
+          if (shutdownRequested) {
+            bridgeOnline = false;
+            selected = null;
+            data = { version: data.version, port: data.port, providers: [] };
+            $("dot").className = "dot";
+            $("statusText").textContent = "bridge shutdown requested";
+            updateStats();
+            renderList();
+            renderDetail();
+            return;
+          }
+          bridgeOnline = true;
+          $("shutdownBtn").disabled = false;
           $("dot").className = "dot on";
           $("version").textContent = "v" + data.version;
           $("endpoint").textContent = "ws://127.0.0.1:" + data.port;
@@ -710,13 +903,31 @@ var DASHBOARD_HTML = `<!doctype html>
           renderList();
           renderDetail();
         } catch {
+          bridgeOnline = false;
+          selected = null;
           data = { version: "", port: 8787, providers: [] };
           $("dot").className = "dot";
-          $("statusText").textContent = "bridge not reachable";
+          $("statusText").textContent = shutdownRequested ? "bridge shut down" : "bridge not reachable";
+          $("shutdownBtn").disabled = true;
           updateStats();
+          renderList();
+          renderDetail();
         }
       }
+      $("search").addEventListener("input", (event) => {
+        filter = event.target.value.trim().toLowerCase();
+        renderList();
+      });
+      $("shutdownBtn").addEventListener("click", () => {
+        shutdownBridge().catch((error) => {
+          shutdownRequested = false;
+          $("shutdownBtn").disabled = false;
+          $("statusText").textContent = error instanceof Error ? error.message : String(error);
+        });
+      });
       tick();
       setInterval(tick, 1500);
     </script>
@@ -743,11 +954,11 @@ var WebSocketServerTransport = class {
         this.onerror?.(error);
         return;
       }
-      if (!this.started || !this.onmessage) {
+      if (!this.started || !this._onmessage) {
         this.buffer.push(message);
         return;
       }
-      this.onmessage(message);
+      this._onmessage(message);
     });
     this.socket.on("close", () => this.onclose?.());
     this.socket.on("error", (error) => this.onerror?.(error));
@@ -755,29 +966,74 @@ var WebSocketServerTransport = class {
   socket;
   onclose;
   onerror;
-  onmessage;
   sessionId;
   started = false;
   buffer = [];
+  _onmessage;
+  /** Flush any buffered messages as soon as both started and a consumer exist. */
+  get onmessage() {
+    return this._onmessage;
+  }
+  set onmessage(handler) {
+    this._onmessage = handler;
+    if (handler && this.started) this.flush();
+  }
   async start() {
     this.started = true;
+    this.flush();
+  }
+  flush() {
+    if (!this._onmessage) return;
     const pending = this.buffer;
     this.buffer = [];
-    for (const message of pending) this.onmessage?.(message);
+    for (const message of pending) this._onmessage(message);
   }
   async send(message) {
-    this.socket.send(JSON.stringify(message));
+    if (this.socket.readyState !== this.socket.OPEN) {
+      throw new Error("cannot send on a non-open WebSocket");
+    }
+    await new Promise((resolve, reject) => {
+      this.socket.send(JSON.stringify(message), (error) => error ? reject(error) : resolve());
+    });
   }
   async close() {
-    this.socket.close();
+    try {
+      this.socket.close();
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        this.socket.terminate();
+      } catch {
+      }
+    }, 1e3).unref?.();
   }
 };
 // src/bridge.ts
 var META_LIST_CLIENTS = "mcp_page_bridge_list_clients";
+var MAX_LABEL_RESERVATIONS = 1e3;
 async function createBridge(opts = {}) {
   const host = opts.host ?? "127.0.0.1";
   const providers = /* @__PURE__ */ new Map();
+  const labelReservations = /* @__PURE__ */ new Map();
+  let agentConnections = 0;
+  let idleTimer;
+  function checkIdle() {
+    const idleMs = opts.idleTimeoutMs ?? 0;
+    if (idleMs <= 0) return;
+    const idle = providers.size === 0 && agentConnections === 0;
+    if (idle) {
+      if (idleTimer) return;
+      idleTimer = setTimeout(() => {
+        void closeBridge().then(() => opts.onIdleShutdown?.());
+      }, idleMs);
+      idleTimer.unref?.();
+    } else if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+  }
   const toolRoutes = /* @__PURE__ */ new Map();
   const promptRoutes = /* @__PURE__ */ new Map();
   const resourceRoutes = /* @__PURE__ */ new Map();
@@ -871,13 +1127,59 @@ async function createBridge(opts = {}) {
       });
     }
   }
-  function uniqueLabel(base) {
-    const used = new Set([...providers.values()].map((p) => p.label));
+  function uniqueLabel(base, used) {
     if (!used.has(base)) return base;
     let i = 2;
     while (used.has(`${base}-${i}`)) i += 1;
     return `${base}-${i}`;
   }
+  function reservationKeys(base, meta) {
+    const exact = [];
+    const fallback = [];
+    if (meta.tabId !== void 0 && meta.providerId) {
+      exact.push(`tab:${meta.tabId}:provider:${meta.providerId}:name:${base}`);
+    } else if (meta.providerId) {
+      exact.push(`provider:${meta.providerId}:name:${base}`);
+    }
+    if (meta.tabId !== void 0) fallback.push(`tab:${meta.tabId}:name:${base}`);
+    if (meta.url) fallback.push(`url:${meta.url}:name:${base}`);
+    return { exact, fallback };
+  }
+  function touchReservation(key, label) {
+    if (labelReservations.has(key)) labelReservations.delete(key);
+    labelReservations.set(key, label);
+  }
+  function pruneReservations() {
+    if (labelReservations.size <= MAX_LABEL_RESERVATIONS) return;
+    const inUse = new Set([...providers.values()].map((p) => p.label));
+    for (const [key, label] of labelReservations) {
+      if (labelReservations.size <= MAX_LABEL_RESERVATIONS) break;
+      if (inUse.has(label)) continue;
+      labelReservations.delete(key);
+    }
+  }
+  function rememberLabel(keys, label) {
+    for (const key of keys.exact) touchReservation(key, label);
+    for (const key of keys.fallback) {
+      touchReservation(key, labelReservations.get(key) ?? label);
+    }
+    pruneReservations();
+  }
+  function assignLabel(rawName, meta) {
+    const base = sanitizeLabel(rawName);
+    const keys = reservationKeys(base, meta);
+    const used = new Set([...providers.values()].map((p) => p.label));
+    for (const key of [...keys.exact, ...keys.fallback]) {
+      const reserved = labelReservations.get(key);
+      if (reserved && !used.has(reserved)) {
+        rememberLabel(keys, reserved);
+        return reserved;
+      }
+    }
+    const label = uniqueLabel(base, used);
+    rememberLabel(keys, label);
+    return label;
+  }
   function createAgentServer() {
     const agentServer = new Server(
       { name: "mcp-page-bridge", version: MCP_PAGE_BRIDGE_VERSION },
@@ -937,6 +1239,7 @@ async function createBridge(opts = {}) {
     return agentServer;
   }
   const server = createAgentServer();
+  let closing;
   function providerSummary() {
     return [...providers.values()].map((p) => ({
       label: p.label,
@@ -977,12 +1280,53 @@ async function createBridge(opts = {}) {
       return {};
     }
   }
-  async function handleProviderAction(req, res, label, action) {
-    if (req.headers["x-mcp-page-bridge-dashboard"] !== "1") {
-      res.writeHead(403, { "content-type": "application/json" });
-      res.end(JSON.stringify({ ok: false, error: "missing dashboard header" }));
-      return;
+  function localAuthorities() {
+    return /* @__PURE__ */ new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+  }
+  function hostAllowed(req) {
+    const allowed = localAuthorities();
+    const hostHeader = req.headers.host;
+    if (!hostHeader || !allowed.has(hostHeader)) return false;
+    const origin = req.headers.origin;
+    if (origin && origin !== "null") {
+      try {
+        if (!allowed.has(new URL(origin).host)) return false;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  function tokenOk(req) {
+    if (!token) return true;
+    if (req.headers[TOKEN_HEADER] === token) return true;
+    try {
+      return new URL(req.url ?? "/", "http://localhost").searchParams.get("token") === token;
+    } catch {
+      return false;
     }
+  }
+  function denyJson(res, status, error) {
+    res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+    res.end(JSON.stringify({ ok: false, error }));
+  }
+  function authorizeStateChange(req, res) {
+    if (!hostAllowed(req)) {
+      denyJson(res, 403, "request is not local (bad Host/Origin)");
+      return false;
+    }
+    if (req.headers[DASHBOARD_HEADER] !== DASHBOARD_HEADER_VALUE) {
+      denyJson(res, 403, "missing dashboard header");
+      return false;
+    }
+    if (!tokenOk(req)) {
+      denyJson(res, 401, "missing or invalid token");
+      return false;
+    }
+    return true;
+  }
+  async function handleProviderAction(req, res, label, action) {
+    if (!authorizeStateChange(req, res)) return;
     const provider = [...providers.values()].find((p) => p.label === label);
     if (!provider) {
       res.writeHead(404, { "content-type": "application/json" });
@@ -996,7 +1340,7 @@ async function createBridge(opts = {}) {
     }
     const method = action === "activate" ? MCP_PAGE_BRIDGE_DASHBOARD_ACTIVATE_TAB : MCP_PAGE_BRIDGE_DASHBOARD_CLOSE_TAB;
     try {
-      await provider.client.request({ method }, EmptyResultSchema);
+      await provider.client.request({ method }, EmptyResultSchema, { timeout: 5e3 });
       res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
       res.end(JSON.stringify({ ok: true }));
     } catch (error) {
@@ -1006,10 +1350,55 @@ async function createBridge(opts = {}) {
       );
     }
   }
+  async function handleShutdown(req, res) {
+    if (!authorizeStateChange(req, res)) return;
+    res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store", connection: "close" });
+    res.end(JSON.stringify({ ok: true }));
+    setImmediate(() => {
+      void closeBridge().catch((error) => {
+        console.error(`[mcp-page-bridge] shutdown failed: ${error.message}`);
+      });
+    });
+  }
+  async function closeBridge() {
+    if (closing) return closing;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+    closing = (async () => {
+      for (const p of providers.values()) {
+        try {
+          await p.client.close();
+        } catch {
+        }
+      }
+      for (const agentServer of [...agentServers]) {
+        agentServers.delete(agentServer);
+        try {
+          await agentServer.close();
+        } catch {
+        }
+      }
+      for (const client of wss.clients) {
+        try {
+          client.terminate();
+        } catch {
+        }
+      }
+      await new Promise((resolve) => wss.close(() => resolve()));
+      await new Promise((resolve) => httpServer.close(() => resolve()));
+    })();
+    return closing;
+  }
   const token = opts.token;
   const httpServer = createHttpServer((req, res) => {
     const path = (req.url ?? "/").split("?")[0] ?? "/";
     const actionMatch = path.match(/^\/api\/providers\/([^/]+)\/(activate|close)$/);
+    if (req.method === "POST" && path === "/api/shutdown") {
+      void handleShutdown(req, res);
+      return;
+    }
     if (req.method === "POST" && actionMatch) {
       void handleProviderAction(
         req,
@@ -1020,7 +1409,11 @@ async function createBridge(opts = {}) {
       return;
     }
     if (req.method === "GET" && (path === "/" || path === "/ui")) {
-      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      if (!hostAllowed(req)) {
+        denyJson(res, 403, "request is not local (bad Host/Origin)");
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
       res.end(DASHBOARD_HTML);
       return;
     }
@@ -1029,18 +1422,55 @@ async function createBridge(opts = {}) {
       res.end(FAVICON_SVG);
       return;
     }
+    if (req.method === "GET" && path === "/api/health") {
+      if (!hostAllowed(req)) {
+        denyJson(res, 403, "request is not local (bad Host/Origin)");
+        return;
+      }
+      res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+      res.end(
+        JSON.stringify({
+          service: SERVICE_ID,
+          version: MCP_PAGE_BRIDGE_VERSION,
+          requiresToken: !!token,
+          port
+        })
+      );
+      return;
+    }
     if (req.method === "GET" && (path === "/api/providers" || path === "/providers.json")) {
-      res.writeHead(200, {
-        "content-type": "application/json",
-        "cache-control": "no-store",
-        "access-control-allow-origin": "*"
-      });
-      res.end(JSON.stringify({ version: MCP_PAGE_BRIDGE_VERSION, port, providers: providerSummary() }));
+      if (!hostAllowed(req)) {
+        denyJson(res, 403, "request is not local (bad Host/Origin)");
+        return;
+      }
+      if (!tokenOk(req)) {
+        denyJson(res, 401, "missing or invalid token");
+        return;
+      }
+      res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+      res.end(
+        JSON.stringify({
+          service: SERVICE_ID,
+          version: MCP_PAGE_BRIDGE_VERSION,
+          port,
+          providers: providerSummary()
+        })
+      );
       return;
     }
     res.writeHead(404, { "content-type": "text/plain" });
     res.end("not found");
   });
+  await new Promise((resolve, reject) => {
+    httpServer.once("listening", resolve);
+    httpServer.once("error", reject);
+    httpServer.listen(opts.port ?? DEFAULT_PORT, host);
+  });
+  httpServer.on("error", (error) => {
+    console.error(`[mcp-page-bridge] http server error: ${error.message}`);
+  });
+  const address = httpServer.address();
+  const port = typeof address === "object" && address ? address.port : opts.port ?? DEFAULT_PORT;
   const wss = new WebSocketServer({
     server: httpServer,
     handleProtocols: (protocols) => protocols.has(WS_SUBPROTOCOL) ? WS_SUBPROTOCOL : false,
@@ -1053,13 +1483,9 @@ async function createBridge(opts = {}) {
       }
     } : void 0
   });
-  await new Promise((resolve, reject) => {
-    httpServer.once("listening", resolve);
-    httpServer.once("error", reject);
-    httpServer.listen(opts.port ?? DEFAULT_PORT, host);
+  wss.on("error", (error) => {
+    console.error(`[mcp-page-bridge] websocket server error: ${error.message}`);
   });
-  const address = httpServer.address();
-  const port = typeof address === "object" && address ? address.port : opts.port ?? DEFAULT_PORT;
   wss.on("connection", async (ws, req) => {
     const path = (() => {
       try {
@@ -1071,7 +1497,15 @@ async function createBridge(opts = {}) {
     if (path === "/agent") {
       const agentServer = createAgentServer();
       const transport2 = new WebSocketServerTransport(ws);
+      agentConnections += 1;
+      checkIdle();
+      let counted = true;
       const cleanupAgent = () => {
+        if (counted) {
+          counted = false;
+          agentConnections -= 1;
+          checkIdle();
+        }
         if (!agentServers.delete(agentServer)) return;
         void agentServer.close().catch(() => {
         });
@@ -1103,20 +1537,21 @@ async function createBridge(opts = {}) {
     const info = client.getServerVersion();
     const caps = client.getServerCapabilities();
     const rawName = info?.name ?? "browser";
+    const meta = {
+      title: info?.title,
+      url: info?.websiteUrl,
+      ...requestMeta(req.url)
+    };
     const provider = {
       id,
-      label: uniqueLabel(sanitizeLabel(rawName)),
+      label: assignLabel(rawName, meta),
       rawName,
       version: info?.version ?? "0.0.0",
       client,
       tools: [],
       prompts: [],
       resources: [],
-      meta: {
-        title: info?.title,
-        url: info?.websiteUrl,
-        ...requestMeta(req.url)
-      },
+      meta,
       connectedAt: Date.now()
     };
     providers.set(id, provider);
@@ -1178,12 +1613,15 @@ async function createBridge(opts = {}) {
         notifyChanged("tools");
         notifyChanged("prompts");
         notifyChanged("resources");
+        checkIdle();
       }
     };
     client.onclose = cleanup;
     ws.on("close", cleanup);
+    checkIdle();
     await Promise.all([refreshTools(), refreshPrompts(), refreshResources()]);
   });
+  checkIdle();
   return {
     server,
     wss,
@@ -1192,21 +1630,7 @@ async function createBridge(opts = {}) {
       return [...providers.values()].map(({ client: _client, ...rest }) => rest);
     },
     async close() {
-      for (const p of providers.values()) {
-        try {
-          await p.client.close();
-        } catch {
-        }
-      }
-      await new Promise((resolve) => wss.close(() => resolve()));
-      await new Promise((resolve) => httpServer.close(() => resolve()));
-      for (const agentServer of [...agentServers]) {
-        agentServers.delete(agentServer);
-        try {
-          await agentServer.close();
-        } catch {
-        }
-      }
+      await closeBridge();
     }
   };
 }
@@ -1214,5 +1638,9 @@ async function createBridge(opts = {}) {
 export {
   MCP_PAGE_BRIDGE_VERSION,
   DEFAULT_PORT,
+  DASHBOARD_HEADER,
+  DASHBOARD_HEADER_VALUE,
+  TOKEN_HEADER,
+  SERVICE_ID,
   createBridge
 };

package/dist/cli.d.ts CHANGED Viewed

@@ -1,2 +1,19 @@
+type BridgeProbe = {
+    status: "none";
+} | {
+    status: "foreign";
+} | {
+    status: "bridge";
+    requiresToken: boolean;
+};
+/** Identify what (if anything) is listening on the bridge HTTP port. */
+declare function probeBridge(port: number): Promise<BridgeProbe>;
+declare function parsePort(argv: string[]): number;
+/**
+ * Verify that a bridge already running on `port` is compatible with this agent's
+ * token before we attach. Throws a clear, actionable error on mismatch.
+ */
+declare function assertCompatibleToken(port: number, token: string | undefined, probe: BridgeProbe): Promise<void>;
+declare function isDirectInvocation(entry?: string | undefined, moduleUrl?: string): boolean;
-export {  }
+export { assertCompatibleToken, isDirectInvocation, parsePort, probeBridge };

package/dist/cli.js CHANGED Viewed

@@ -1,13 +1,102 @@
 #!/usr/bin/env node
 import {
+  DASHBOARD_HEADER,
+  DASHBOARD_HEADER_VALUE,
   DEFAULT_PORT,
   MCP_PAGE_BRIDGE_VERSION,
+  SERVICE_ID,
+  TOKEN_HEADER,
   createBridge
-} from "./chunk-RRWNJUKA.js";
+} from "./chunk-XUK2DGX4.js";
 // src/cli.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
+import { spawn } from "child_process";
+import { realpathSync } from "fs";
+import { readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { setTimeout as delay } from "timers/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+var DAEMON_FLAG = "--daemon";
+var DAEMON_READY_TIMEOUT_MS = 5e3;
+var DAEMON_READY_INTERVAL_MS = 100;
+function pidFilePath(port) {
+  return process.env.MCP_PAGE_BRIDGE_DAEMON_PID_FILE ?? join(tmpdir(), `mcp-page-bridge-${port}.pid`);
+}
+async function writePidFile(path) {
+  try {
+    await writeFile(path, `${process.pid}
+`);
+  } catch (error) {
+    console.error(`[mcp-page-bridge] warning: failed to write pid file: ${error.message}`);
+  }
+}
+async function removePidFile(path) {
+  await rm(path, { force: true }).catch(() => {
+  });
+}
+async function readPidFile(port) {
+  try {
+    const pid = Number((await readFile(pidFilePath(port), "utf8")).trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseIdleTimeoutMs(argv) {
+  const raw = parseFlag(argv, "--idle-timeout") ?? process.env.MCP_PAGE_BRIDGE_IDLE_TIMEOUT;
+  if (raw === void 0) return 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`invalid --idle-timeout "${raw}": expected a non-negative number of seconds`);
+  }
+  return Math.round(n * 1e3);
+}
+async function fetchWithTimeout(url, init = {}, ms = 500) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function probeBridge(port) {
+  try {
+    const res = await fetchWithTimeout(`http://127.0.0.1:${port}/api/health`);
+    if (res.ok) {
+      const body = await res.json().catch(() => ({}));
+      if (body.service === SERVICE_ID) {
+        return { status: "bridge", requiresToken: !!body.requiresToken };
+      }
+      return { status: "foreign" };
+    }
+    if (res.status === 404) {
+      const legacy = await fetchWithTimeout(`http://127.0.0.1:${port}/api/providers`);
+      if (legacy.status === 401) return { status: "bridge", requiresToken: true };
+      if (legacy.ok) {
+        const body = await legacy.json().catch(() => ({}));
+        if (Array.isArray(body.providers)) return { status: "bridge", requiresToken: false };
+      }
+      return { status: "foreign" };
+    }
+    return { status: "foreign" };
+  } catch {
+    return { status: "none" };
+  }
+}
+async function tokenAccepted(port, token) {
+  try {
+    const res = await fetchWithTimeout(`http://127.0.0.1:${port}/api/providers`, {
+      headers: { [TOKEN_HEADER]: token }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
 function parseFlag(argv, flag) {
   const idx = argv.indexOf(flag);
   if (idx >= 0 && argv[idx + 1]) return argv[idx + 1];
@@ -15,11 +104,109 @@ function parseFlag(argv, flag) {
 }
 function parsePort(argv) {
   const fromFlag = parseFlag(argv, "--port") ?? process.env.MCP_PAGE_BRIDGE_PORT;
+  if (fromFlag === void 0) return DEFAULT_PORT;
   const n = Number(fromFlag);
-  return Number.isFinite(n) && n > 0 ? n : DEFAULT_PORT;
+  if (!Number.isInteger(n) || n < 1 || n > 65535) {
+    throw new Error(`invalid --port "${fromFlag}": expected an integer in 1..65535`);
+  }
+  return n;
+}
+function hasFlag(argv, flag) {
+  return argv.includes(flag);
 }
-function isAddrInUse(error) {
-  return !!error && typeof error === "object" && error.code === "EADDRINUSE";
+function daemonExecArgv() {
+  return process.execArgv.filter((arg) => !arg.startsWith("--inspect") && !arg.startsWith("--debug"));
+}
+async function bridgeReady(port) {
+  return (await probeBridge(port)).status === "bridge";
+}
+async function assertCompatibleToken(port, token, probe) {
+  if (probe.status !== "bridge") return;
+  if (probe.requiresToken) {
+    if (!token) {
+      throw new Error(
+        `a bridge is already running on port ${port} and requires a token; pass --token <secret> (or set MCP_PAGE_BRIDGE_TOKEN) to attach`
+      );
+    }
+    if (!await tokenAccepted(port, token)) {
+      throw new Error(
+        `a bridge is already running on port ${port} but rejected the provided token; every agent on this port must use the same --token`
+      );
+    }
+  } else if (token) {
+    console.error(
+      `[mcp-page-bridge] note: a tokenless bridge is already running on port ${port}; the provided token is ignored for this attach`
+    );
+  }
+}
+async function startDaemon(port, token, idleTimeoutMs) {
+  const pidFile = pidFilePath(port);
+  const bridge = await createBridge({
+    port,
+    token,
+    idleTimeoutMs,
+    onIdleShutdown: () => {
+      console.error(`[mcp-page-bridge] idle for ${idleTimeoutMs}ms with no agents/providers; shutting down`);
+      void removePidFile(pidFile).finally(() => process.exit(0));
+    }
+  });
+  await writePidFile(pidFile);
+  console.error(
+    `[mcp-page-bridge] daemon v${MCP_PAGE_BRIDGE_VERSION} \u2014 ws://127.0.0.1:${bridge.port} \xB7 dashboard http://127.0.0.1:${bridge.port}/` + (token ? " (token required)" : "") + (idleTimeoutMs > 0 ? ` \xB7 idle-timeout ${idleTimeoutMs / 1e3}s` : "")
+  );
+  const shutdown = async () => {
+    await bridge.close();
+    await removePidFile(pidFile);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function ensureDaemon(port, token, idleTimeoutMs) {
+  const existing = await probeBridge(port);
+  if (existing.status === "bridge") {
+    await assertCompatibleToken(port, token, existing);
+    return;
+  }
+  if (existing.status === "foreign") {
+    throw new Error(
+      `port ${port} is in use by a non-mcp-page-bridge server; choose another port with --port <n>`
+    );
+  }
+  const script = fileURLToPath(import.meta.url);
+  const args = [...daemonExecArgv(), script, DAEMON_FLAG, "--port", String(port)];
+  if (idleTimeoutMs > 0) args.push("--idle-timeout", String(idleTimeoutMs / 1e3));
+  const env = { ...process.env, MCP_PAGE_BRIDGE_PORT: String(port) };
+  if (token) env.MCP_PAGE_BRIDGE_TOKEN = token;
+  let spawnError;
+  let exit;
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    env,
+    stdio: "ignore"
+  });
+  child.once("error", (error) => {
+    spawnError = error;
+  });
+  child.once("exit", (code, signal) => {
+    exit = { code, signal };
+  });
+  child.unref();
+  const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (spawnError) throw spawnError;
+    if (exit) {
+      throw new Error(
+        `bridge daemon exited before it was ready` + (exit.signal ? ` (signal ${exit.signal})` : ` (code ${exit.code ?? "unknown"})`)
+      );
+    }
+    if (await bridgeReady(port)) {
+      console.error(`[mcp-page-bridge] started background bridge daemon on port ${port}`);
+      return;
+    }
+    await delay(DAEMON_READY_INTERVAL_MS);
+  }
+  throw new Error(`timed out waiting for bridge daemon on port ${port}`);
 }
 async function connectProxy(port, token) {
   const url = new URL(`ws://127.0.0.1:${port}/agent`);
@@ -53,35 +240,75 @@ async function connectProxy(port, token) {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
+async function stopDaemon(port, token) {
+  const probe = await probeBridge(port);
+  if (probe.status === "none") {
+    console.error(`[mcp-page-bridge] no bridge is running on port ${port}`);
+    return;
+  }
+  if (probe.status === "foreign") {
+    throw new Error(`port ${port} is held by a non-mcp-page-bridge server; refusing to stop it`);
+  }
+  if (probe.requiresToken && !token) {
+    throw new Error(`the bridge on port ${port} requires a token; pass --token <secret> to stop it`);
+  }
+  const headers = { [DASHBOARD_HEADER]: DASHBOARD_HEADER_VALUE };
+  if (token) headers[TOKEN_HEADER] = token;
+  try {
+    const res = await fetchWithTimeout(
+      `http://127.0.0.1:${port}/api/shutdown`,
+      { method: "POST", headers },
+      2e3
+    );
+    if (!res.ok) throw new Error(`shutdown endpoint returned ${res.status}`);
+    console.error(`[mcp-page-bridge] shutdown requested on port ${port}`);
+    return;
+  } catch (error) {
+    const pid = await readPidFile(port);
+    if (pid) {
+      try {
+        process.kill(pid, "SIGTERM");
+        console.error(`[mcp-page-bridge] sent SIGTERM to daemon pid ${pid} on port ${port}`);
+        return;
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
 async function main() {
   const argv = process.argv.slice(2);
+  const command = argv[0] && !argv[0].startsWith("-") ? argv[0] : void 0;
   const port = parsePort(argv);
   const token = parseFlag(argv, "--token") ?? process.env.MCP_PAGE_BRIDGE_TOKEN;
-  let bridge;
-  try {
-    bridge = await createBridge({ port, token });
-  } catch (error) {
-    if (!isAddrInUse(error)) throw error;
-    console.error(
-      `[mcp-page-bridge] port ${port} is already in use; attaching this agent to the existing bridge`
-    );
-    await connectProxy(port, token);
+  if (command === "stop") {
+    await stopDaemon(port, token);
     return;
   }
-  console.error(
-    `[mcp-page-bridge] v${MCP_PAGE_BRIDGE_VERSION} \u2014 ws://127.0.0.1:${bridge.port} \xB7 dashboard http://127.0.0.1:${bridge.port}/` + (token ? " (token required)" : "")
-  );
-  const transport = new StdioServerTransport();
-  await bridge.server.connect(transport);
-  console.error("[mcp-page-bridge] MCP stdio server ready (waiting for agent + browser connections)");
-  const shutdown = async () => {
-    await bridge.close();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  if (hasFlag(argv, DAEMON_FLAG)) {
+    await startDaemon(port, token, parseIdleTimeoutMs(argv));
+    return;
+  }
+  await ensureDaemon(port, token, parseIdleTimeoutMs(argv));
+  await connectProxy(port, token);
+}
+function isDirectInvocation(entry = process.argv[1], moduleUrl = import.meta.url) {
+  if (!entry) return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(moduleUrl));
+  } catch {
+    return moduleUrl === pathToFileURL(entry).href;
+  }
+}
+if (isDirectInvocation()) {
+  main().catch((error) => {
+    console.error("[mcp-page-bridge] fatal:", error);
+    process.exit(1);
+  });
 }
-main().catch((error) => {
-  console.error("[mcp-page-bridge] fatal:", error);
-  process.exit(1);
-});
+export {
+  assertCompatibleToken,
+  isDirectInvocation,
+  parsePort,
+  probeBridge
+};

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "mcp-page-bridge",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "MCP bridge that aggregates live browser-page MCP servers and exposes them to a coding agent over stdio",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "typescript": "^5.7.3",
     "vitest": "^2.1.8",
     "zod": "^3.25.0",
-    "mcp-page-bridge-protocol": "0.1.4"
+    "mcp-page-bridge-protocol": "0.1.6"
   },
   "scripts": {
     "start": "tsx src/cli.ts",