bwb-browser 3.1.1 → 4.0.0

package/lib/tabs.mjs

@@ -8,6 +8,49 @@
 
 import CDP from "chrome-remote-interface";
 import { ensureBrowser, protocol, actualCdpPort, cfg } from "./browser.mjs";
+import { writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// ─── Tab Journal (working-set survival across LMK kills / mayfly teardown) ───
+// Tiny JSON append on every mutation. Journal is the truth the next fresh
+// browser restores from — cookies live in user-data-dir, tab URLs live here.
+
+function journalPath() {
+  if (!cfg.userDataDir) return null;
+  return join(cfg.userDataDir, "bwb-tabs.json");
+}
+
+function saveJournal() {
+  try {
+    const path = journalPath();
+    if (!path) return;
+    const entries = [];
+    for (const [id, tab] of tabs) {
+      if (tab.url && tab.url !== "about:blank") {
+        entries.push({ url: tab.url, title: tab.title || "", active: id === activeTabId });
+      }
+    }
+    writeFileSync(path, JSON.stringify(entries));
+  } catch {}
+}
+
+function loadJournal() {
+  try {
+    const path = journalPath();
+    if (!path || !existsSync(path)) return [];
+    const entries = JSON.parse(readFileSync(path, "utf8"));
+    return Array.isArray(entries) ? entries.filter((e) => e && e.url) : [];
+  } catch {
+    return [];
+  }
+}
+
+// Live-tab cap: 0/unset = unlimited (desktop). Lean profiles set 3.
+function liveCount() {
+  let n = 0;
+  for (const tab of tabs.values()) if (!tab.hibernated) n++;
+  return n;
+}
 
 // ─── Tab State ───────────────────────────────────────────────────────────────
 
@@ -47,6 +90,7 @@ export async function getActiveProtocol() {
 
   if (activeTabId && tabs.has(activeTabId)) {
     const tab = tabs.get(activeTabId);
+    if (tab.hibernated) return wakeTab(activeTabId);
     if (tab.protocol) return tab.protocol;
   }
 
@@ -54,6 +98,72 @@ export async function getActiveProtocol() {
   return protocol;
 }
 
+/**
+ * Hibernate a tab: URL stays in the journal + visible in listTabs, but the
+ * renderer is closed and memory freed. Woken transparently on switchTab.
+ * Never hibernates the active tab — caller must switch away first.
+ */
+export async function hibernateTab(targetId) {
+  const id = targetId || [...tabs.keys()].find((k) => k !== activeTabId && !tabs.get(k)?.hibernated);
+  if (!id || !tabs.has(id)) return null;
+  const tab = tabs.get(id);
+  if (tab.hibernated) return { id, hibernated: true };
+  const port = actualCdpPort || cfg.port;
+  try { await CDP.Close({ id, port }); } catch {}
+  if (tab.protocol && tab.protocol !== protocol) {
+    try { await tab.protocol.close(); } catch {}
+  }
+  tabs.set(id, { protocol: null, title: tab.title, url: tab.url, hibernated: true });
+  saveJournal();
+  return { id, hibernated: true, url: tab.url };
+}
+
+/** Wake a hibernated tab: fresh target, journaled URL re-navigated. */
+async function wakeTab(targetId) {
+  const tab = tabs.get(targetId);
+  if (!tab || !tab.hibernated) return tab?.protocol || protocol;
+  const port = actualCdpPort || cfg.port;
+  const info = await CDP.New({ port, url: tab.url || "about:blank" });
+  const newProtocol = await CDP({ target: info.id, port });
+  tabs.delete(targetId);
+  tabs.set(info.id, { protocol: newProtocol, title: info.title || tab.title, url: info.url || tab.url });
+  if (activeTabId === targetId) activeTabId = info.id;
+  saveJournal();
+  return newProtocol;
+}
+
+/**
+ * Restore the journaled working set after a fresh spawn. First entry
+ * navigates now; the rest become about:blank placeholders woken on switch.
+ * Capped at cfg.tabMax so restore never re-spikes memory at startup.
+ */
+export async function restoreJournal() {
+  const entries = loadJournal();
+  if (!entries.length) return false;
+  await ensureDefaultTab();
+  const cap = cfg.tabMax && cfg.tabMax > 0 ? cfg.tabMax : entries.length;
+  const wanted = entries.slice(0, Math.max(cap, 1));
+  const port = actualCdpPort || cfg.port;
+  let first = true;
+  for (const entry of wanted) {
+    if (first) {
+      first = false;
+      try {
+        await protocol.Page.navigate({ url: entry.url });
+        syncActiveTab(entry.title, entry.url);
+      } catch {}
+      continue;
+    }
+    try {
+      const info = await CDP.New({ port, url: "about:blank" });
+      const newProtocol = await CDP({ target: info.id, port });
+      tabs.set(info.id, { protocol: newProtocol, title: entry.title || "", url: "", pendingUrl: entry.url });
+    } catch {}
+  }
+  saveJournal();
+  return true;
+}
+
 // ─── Create Tab ──────────────────────────────────────────────────────────────
 
 /**
@@ -63,6 +173,16 @@ export async function getActiveProtocol() {
 export async function createTab(url) {
   await ensureDefaultTab();
 
+  // Live-tab cap: hibernate the oldest non-active tab instead of growing
+  // renderers until Android LMK notices. Journal keeps everything restorable.
+  if (cfg.tabMax && cfg.tabMax > 0) {
+    while (liveCount() >= cfg.tabMax) {
+      const victim = [...tabs.keys()].find((k) => k !== activeTabId && !tabs.get(k)?.hibernated);
+      if (!victim) break;
+      await hibernateTab(victim);
+    }
+  }
+
   const port = actualCdpPort || cfg.port;
   const info = await CDP.New({ port, url: url || "about:blank" });
 
@@ -70,6 +190,7 @@ export async function createTab(url) {
   const newProtocol = await CDP({ target: info.id, port });
   tabs.set(info.id, { protocol: newProtocol, title: info.title || "", url: info.url || url || "" });
   activeTabId = info.id;
+  saveJournal();
 
   return { id: info.id, title: info.title || "", url: info.url || "" };
 }
@@ -103,6 +224,7 @@ export async function closeTab(targetId) {
   if (activeTabId === id) {
     activeTabId = tabs.keys().next().value;
   }
+  saveJournal();
 
   return { closed: id, activeTab: activeTabId };
 }
@@ -110,17 +232,35 @@ export async function closeTab(targetId) {
 // ─── Switch Tab ──────────────────────────────────────────────────────────────
 
 /**
- * Switches to a different tab by targetId.
+ * Switches to a different tab by targetId. Hibernated tabs and restored
+ * placeholders wake transparently (async navigation on first switch).
  */
-export function switchTab(targetId) {
+export async function switchTab(targetId) {
   if (!targetId) throw new Error("No targetId provided");
   if (!tabs.has(targetId)) {
     throw new Error(`Tab not found: ${targetId}`);
   }
 
-  activeTabId = targetId;
   const tab = tabs.get(targetId);
-  return { id: targetId, title: tab.title, url: tab.url };
+  if (tab.hibernated) {
+    await wakeTab(targetId);
+    const woken = tabs.get(activeTabId);
+    return { id: activeTabId, title: woken?.title, url: woken?.url, woken: true };
+  }
+  activeTabId = targetId;
+  if (tab.pendingUrl) {
+    const url = tab.pendingUrl;
+    delete tab.pendingUrl;
+    try {
+      const cdp = tab.protocol || protocol;
+      const { Page } = cdp;
+      await Page.navigate({ url });
+      tab.url = url;
+    } catch {}
+  }
+  saveJournal();
+  const current = tabs.get(activeTabId);
+  return { id: activeTabId, title: current?.title, url: current?.url };
 }
 
 // ─── List Tabs ───────────────────────────────────────────────────────────────
@@ -136,6 +276,8 @@ export function listTabs() {
       title: tab.title,
       url: tab.url,
       active: id === activeTabId,
+      ...(tab.hibernated ? { hibernated: true } : {}),
+      ...(tab.pendingUrl ? { pendingUrl: tab.pendingUrl } : {}),
     });
   }
   return result;
@@ -161,5 +303,6 @@ export function syncActiveTab(title, url) {
     const tab = tabs.get(activeTabId);
     if (title) tab.title = title;
     if (url) tab.url = url;
+    saveJournal();
   }
 }

package/lib/vigil.mjs

@@ -0,0 +1,77 @@
+/**
+ * bwb-browser — Resource vigilance (v4)
+ *
+ * Pure measurement + policy. No imports from tabs/browser (avoid cycles) —
+ * the server.mjs response wrapper executes the actions assess() recommends.
+ * MCP can't push, so every tool response carries a ~100-byte footer and the
+ * watcher stream carries memory samples. That IS the "instant" channel.
+ */
+
+import { execSync } from "child_process";
+
+// 1GB-box budgets (MB) when lean; roomier desktop defaults otherwise.
+// Override any via BWB_WARN_MB / BWB_CRIT_MB. resolveBudgets() is called
+// by server.mjs after config — before that, lean-safe values apply.
+export let WARN_MB = parseInt(process.env.BWB_WARN_MB || "300", 10);
+export let CRIT_MB = parseInt(process.env.BWB_CRIT_MB || "450", 10);
+
+export function resolveBudgets(isLean) {
+  if (process.env.BWB_WARN_MB !== undefined) WARN_MB = parseInt(process.env.BWB_WARN_MB, 10);
+  else WARN_MB = isLean ? 300 : 1024;
+  if (process.env.BWB_CRIT_MB !== undefined) CRIT_MB = parseInt(process.env.BWB_CRIT_MB, 10);
+  else CRIT_MB = isLean ? 450 : 1536;
+}
+
+const MB = 1024 * 1024;
+
+function selfMb() {
+  return Math.round(process.memoryUsage().rss / MB);
+}
+
+// Sum RSS of a pid + its descendants via ps. Null when unmeasurable.
+function treeMb(rootPid) {
+  if (!rootPid) return null;
+  try {
+    const out = execSync("ps -o pid=,ppid=,rss= -e", { encoding: "utf8", timeout: 3000 });
+    const procs = out.trim().split("\n").map((l) => {
+      const [pid, ppid, rss] = l.trim().split(/\s+/).map(Number);
+      return { pid, ppid, rss };
+    });
+    const kids = new Set([Number(rootPid)]);
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const p of procs) {
+        if (kids.has(p.ppid) && !kids.has(p.pid)) { kids.add(p.pid); grew = true; }
+      }
+    }
+    let kb = 0;
+    for (const p of procs) if (kids.has(p.pid) && Number.isFinite(p.rss)) kb += p.rss;
+    return Math.round(kb / 1024);
+  } catch {
+    return null;
+  }
+}
+
+/** Snapshot: {mcpMb, chromiumMb|null, tabCount} */
+export function sampleResources(browserPid, tabCount = 0) {
+  return { mcpMb: selfMb(), chromiumMb: treeMb(browserPid), tabCount };
+}
+
+/**
+ * Policy verdict: 'ok' | 'watch' | 'critical'.
+ * critical = shed load NOW (hibernate tabs → teardown). watch = warn only.
+ */
+export function assess(sample) {
+  const total = (sample.chromiumMb || 0) + sample.mcpMb;
+  if (total >= CRIT_MB) return "critical";
+  if (total >= WARN_MB) return "watch";
+  return "ok";
+}
+
+/** ~100-byte footer appended as an extra text block to every tool response. */
+export function resourceFooter(sample, note = "") {
+  const c = sample.chromiumMb === null ? "browser:off" : `browser:${sample.chromiumMb}MB`;
+  const trend = assess(sample);
+  return `[bwb resources] mcp:${sample.mcpMb}MB ${c} tabs:${sample.tabCount} state:${trend}${note ? " " + note : ""}]`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bwb-browser",
-  "version": "3.1.1",
-  "description": "Browser Without Bloat — 76KB MCP server that gives AI agents browser superpowers. Natural language interaction, live event watching, persistent sessions, multi-tab. Runs on Termux/Android, desktop, and CI. Zero heavy dependencies.",
+  "version": "4.0.0",
+  "description": "Browser Without Bloat — lightweight MCP server that gives AI agents browser superpowers. Static-first fetch ladder (Chromium only when JS demands it), lean profiles for Termux/1GB VPS, resource vigilance, tab journaling. Runs anywhere. Stays lean like air.",
   "bin": {
     "bwb": "bin/bwb"
   },
@@ -62,6 +62,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "chrome-remote-interface": "^0.34.0",
-    "zod": "^3.22.0"
+    "zod": "^3.22.0",
+    "@mozilla/readability": "^0.6.0",
+    "linkedom": "^0.18.13"
   }
 }