@askjo/camofox-browser 1.9.0 → 1.9.1

package/Dockerfile

@@ -58,6 +58,7 @@ RUN --mount=type=bind,source=dist,target=/dist \
 WORKDIR /app
 
 COPY package.json ./
+COPY scripts/ ./scripts/
 RUN npm install --production
 
 COPY server.js ./

package/lib/reporter.js

@@ -593,6 +593,20 @@ function formatIssueBody(type, detail) {
   }
 
   // Context (misc extra data)
+  if (detail.nativeMemory) {
+    const nm = detail.nativeMemory;
+    sections.push('', '## Native Memory Details');
+    sections.push(`- **baseline:** ${nm.baselineMb} MB`);
+    sections.push(`- **current:** ${nm.currentMb} MB`);
+    sections.push(`- **high-water:** ${nm.highWaterMb} MB`);
+    sections.push(`- **growth:** ${nm.growthMb} MB`);
+    sections.push(`- **node RSS:** ${nm.rssMb} MB`);
+    sections.push(`- **heap used:** ${nm.heapUsedMb} MB`);
+    sections.push(`- **external:** ${nm.externalMb} MB`);
+    if (nm.lastSeenBrowserRssMb != null) sections.push(`- **browser RSS (last seen):** ${nm.lastSeenBrowserRssMb} MB`);
+    else sections.push(`- **browser RSS (last seen):** not captured (browser already dead)`);
+  }
+
   if (detail.context && Object.keys(detail.context).length > 0) {
     sections.push('', '<details><summary>Context</summary>', '', '```json', anonymize(JSON.stringify(detail.context, null, 2)), '```', '', '</details>');
   }
@@ -806,22 +820,26 @@ export function createReporter(config) {
 
     // --- Native memory leak tracking ---
     // Track RSS minus JS heap over time to detect native/external memory leaks.
-    // Sample every 30s, alert if native memory stays >200MB above baseline for
+    // Sample every 30s, alert if native memory stays >400MB above baseline for
     // 3 consecutive checks (~90s). This avoids false positives from:
     //   - Browser initialization spikes (first 2 min)
     //   - One-time allocations that stabilize
     //   - Post-session RSS that hasn't been reclaimed by the OS yet
+    //   - Self-healing restart (kills browser at 200MB growth when sessions=0)
+    // The memory pressure restart in server.js fires at 200MB when idle.
+    // We only report at 400MB to catch cases where self-healing FAILED.
     let nativeMemBaseline = null; // RSS - heapUsed at first measurement
     let nativeMemHighWater = 0;
     let lastNativeMemCheck = 0;
     const NATIVE_MEM_CHECK_INTERVAL_MS = 30_000;
-    const NATIVE_MEM_LEAK_THRESHOLD_MB = 200; // alert if native mem exceeds baseline by this much
+    const NATIVE_MEM_LEAK_THRESHOLD_MB = 400; // alert only when growth exceeds self-healing threshold
     const NATIVE_MEM_MIN_UPTIME_S = 120;      // don't measure until process has been up 2 min
     const NATIVE_MEM_CONSECUTIVE_REQUIRED = 3; // require 3 consecutive checks above threshold
     const NATIVE_MEM_GRACE_CHECKS = 2;         // skip 2 checks after baseline reset (let memory settle)
     let nativeMemAlertFired = false;
     let nativeMemConsecutiveAbove = 0;          // consecutive checks above threshold
     let nativeMemGraceRemaining = 0;            // checks to skip after baseline reset
+    let lastSeenBrowserRssMb = null;            // captured during growth checks while browser is alive
 
     // SIGCONT detection -- macOS sends SIGCONT on wake from sleep/suspend
     let lastSigcont = 0;
@@ -896,6 +914,20 @@ export function createReporter(config) {
                 // Require sustained growth -- one-time spikes aren't leaks.
                 // Must exceed threshold on 3 consecutive checks (~90s).
                 nativeMemConsecutiveAbove++;
+
+                // Capture browser RSS NOW while it may still be alive.
+                // By report time the browser is often killed by memory pressure restart,
+                // making browserRssMb null. This preserves the last-seen value.
+                try {
+                  if (getContext) {
+                    const ctx = getContext();
+                    if (ctx.resourceOpts?.browserPid) {
+                      const snap = collectResourceSnapshot(ctx.resourceOpts);
+                      if (snap.browserRssMb != null) lastSeenBrowserRssMb = snap.browserRssMb;
+                    }
+                  }
+                } catch { /* swallow */ }
+
                 if (nativeMemConsecutiveAbove >= NATIVE_MEM_CONSECUTIVE_REQUIRED) {
                   nativeMemAlertFired = true;
                   let extra = {};
@@ -903,6 +935,18 @@ export function createReporter(config) {
                   const resources = collectResourceSnapshot(extra.resourceOpts || {});
                   delete extra.resourceOpts;
 
+                  // Skip report if sessions=0 — memory pressure restart handles idle leaks.
+                  // Only report when sessions are active (restart CAN'T fire) or restart failed.
+                  const sessionCount = resources.browserContexts ?? 0;
+                  if (sessionCount === 0 && resources.browserRssMb == null) {
+                    // Browser already dead, restart mechanism handled it. Don't spam.
+                    // But if growth is extreme (>600MB), report anyway — restart may have failed.
+                    if (growth < 600) {
+                      // Self-healing. Skip report.
+                      return;
+                    }
+                  }
+
                   fileReport('leak:native-memory', ['auto-report', 'memory-leak'], {
                     message: `Native memory grew by ${growth}MB (baseline: ${nativeMemBaseline}MB, current: ${nativeMemMb}MB, high-water: ${nativeMemHighWater}MB)`,
                     uptimeMinutes: Math.round(process.uptime() / 60),
@@ -915,6 +959,7 @@ export function createReporter(config) {
                       rssMb: Math.round(mem.rss / 1048576),
                       heapUsedMb: Math.round(mem.heapUsed / 1048576),
                       externalMb: Math.round(mem.external / 1048576),
+                      lastSeenBrowserRssMb,
                     },
                     context: extra,
                   });

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
-  "id": "camofox-browser",
+  "id": "@skyfallsin/camofox-browser",
   "name": "Camofox Browser",
   "description": "Anti-detection browser automation for AI agents using Camoufox (Firefox-based)",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "envVars": {
     "CAMOFOX_API_KEY": {
       "description": "Secret key for the cookie-import endpoint. Cookie import is disabled when unset. Only set this if you need to import browser cookies and the server is local or access-controlled.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askjo/camofox-browser",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "Headless browser automation server and OpenClaw plugin for AI agents - anti-detection, element refs, and session isolation",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -4494,11 +4494,13 @@ setInterval(() => {
   if (reaped > 0) log('warn', 'orphan page reaper closed leaked pages', { reaped });
 }, 60_000);
 
-// Native memory pressure restart -- when all sessions are gone and Firefox's
-// native memory has grown beyond threshold, kill the browser immediately instead
-// of waiting for the idle timer. Firefox/Camoufox doesn't fully reclaim native
-// memory after context.close() due to jemalloc fragmentation, JIT caches, and
-// NSS/TLS session caches. See #1032.
+// Native memory pressure restart -- when all sessions are gone and the Node
+// process's native memory (RSS minus V8 heap) has grown beyond threshold, kill
+// the browser process immediately instead of waiting for the idle timer.
+// Note: This measures Node/Playwright internal state (CDP buffers, glibc arenas),
+// NOT Firefox's own memory (which is a separate child process). Firefox jemalloc
+// fragmentation is tracked separately via browser RSS in /proc/<pid>/status.
+// The restart reclaims Playwright state; Firefox's process dies with it.
 setInterval(() => {
   if (sessions.size > 0 || !browser) return;
   const mem = process.memoryUsage();