@buoy-gg/network 7.0.25 → 7.0.27

package/lib/commonjs/network/components/NetworkOverrideHeaderButton.js

@@ -79,24 +79,27 @@ function NetworkOverrideHeaderButton({
   });
 }
 const styles = _reactNative.StyleSheet.create({
+  // Night: the header's dark-glass chip, with the accent label the night
+  // language gives labelled actions (plate + accent ink). Active keeps the
+  // warning tint — same "you are not seeing the truth" signal as the flask.
   button: {
     paddingHorizontal: 10,
     paddingVertical: 6,
-    borderRadius: 6,
+    borderRadius: 8,
     borderWidth: 1,
-    borderColor: _sharedUi.macOSColors.border.input,
-    backgroundColor: _sharedUi.macOSColors.background.input
+    borderColor: _sharedUi.night.color.border,
+    backgroundColor: _sharedUi.night.color.buttonSurface
   },
   buttonActive: {
-    borderColor: _sharedUi.macOSColors.semantic.warning + "77",
-    backgroundColor: _sharedUi.macOSColors.semantic.warningBackground
+    borderColor: _sharedUi.night.color.warning + "77",
+    backgroundColor: _sharedUi.night.color.warningSoft
   },
   label: {
     fontSize: 11,
     fontWeight: "700",
-    color: _sharedUi.macOSColors.text.primary
+    color: _sharedUi.night.color.accent
   },
   labelActive: {
-    color: _sharedUi.macOSColors.semantic.warning
+    color: _sharedUi.night.color.warning
   }
 });

package/lib/commonjs/network/components/NetworkOverridesButton.js

@@ -35,7 +35,7 @@ function NetworkOverridesButton({
     accessibilityLabel: active ? `Response overrides — ${activeCount} active` : "Response overrides",
     children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_sharedUi.FlaskConical, {
       size: 14,
-      color: active ? _sharedUi.macOSColors.semantic.warning : _sharedUi.macOSColors.text.secondary
+      color: active ? _sharedUi.night.color.warning : _sharedUi.night.color.textSecondary
     }), active ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
       style: styles.badge,
       children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
@@ -56,15 +56,15 @@ const styles = _reactNative.StyleSheet.create({
     borderRadius: 8,
     alignItems: "center",
     justifyContent: "center",
-    backgroundColor: _sharedUi.macOSColors.background.hover,
+    backgroundColor: _sharedUi.night.color.buttonSurface,
     borderWidth: 1,
-    borderColor: _sharedUi.macOSColors.border.default
+    borderColor: _sharedUi.night.color.border
   },
   // Active fills the whole box, the way the power toggle goes green — the
   // warning now reads at a glance instead of as a tinted glyph.
   buttonActive: {
-    backgroundColor: _sharedUi.macOSColors.semantic.warningBackground,
-    borderColor: _sharedUi.macOSColors.semantic.warning + "77"
+    backgroundColor: _sharedUi.night.color.warningSoft,
+    borderColor: _sharedUi.night.color.warning + "77"
   },
   badge: {
     position: "absolute",
@@ -78,11 +78,11 @@ const styles = _reactNative.StyleSheet.create({
     paddingHorizontal: 3,
     alignItems: "center",
     justifyContent: "center",
-    backgroundColor: _sharedUi.macOSColors.semantic.warning
+    backgroundColor: _sharedUi.night.color.warning
   },
   badgeText: {
     fontSize: 8,
     fontWeight: "800",
-    color: _sharedUi.macOSColors.background.base
+    color: "#000000"
   }
 });

package/lib/commonjs/network/sync/networkSyncAdapter.js

@@ -364,22 +364,30 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
   // flags, and a total snapshot budget so the list degrades instead of the
   // whole panel being dropped at the emit layer.
   version: 5,
-  getSnapshot: () => ({
-    events: fitEventsToBudget(_networkEventStore.networkEventStore.getEvents()),
-    /**
-     * Response-override rules live on the DEVICE — that's the only place they
-     * can run, since a rule is applied inside the app's own XMLHttpRequest.
-     * Remote surfaces mirror this and forward their edits back as actions.
-     */
-    overrides: stripLargeRuleBodies(_overrideRulesStore.overrideRulesStore.getState()),
-    // Saved snapshots go through the same body strip. They are few (capped in
-    // the store) but they ride on EVERY snapshot, so a fat one would land in
-    // the same 200ms loop that the body-stripping exists to protect.
-    saved: _networkSavedStore.networkSavedStore.getRecords().map(record => ({
-      ...record,
-      event: toWireEvent(record.event).event
-    }))
-  }),
+  getSnapshot: () => {
+    // Piggyback the interception health check on the watch loop: while a
+    // dashboard/MCP watch is open this runs continuously, so a clobbered
+    // fetch/XHR patch (see networkListener.startListening) heals within one
+    // snapshot tick instead of staying dead for the session. Two property
+    // reads when healthy.
+    _networkEventStore.networkEventStore.ensureInterception();
+    return {
+      events: fitEventsToBudget(_networkEventStore.networkEventStore.getEvents()),
+      /**
+       * Response-override rules live on the DEVICE — that's the only place they
+       * can run, since a rule is applied inside the app's own XMLHttpRequest.
+       * Remote surfaces mirror this and forward their edits back as actions.
+       */
+      overrides: stripLargeRuleBodies(_overrideRulesStore.overrideRulesStore.getState()),
+      // Saved snapshots go through the same body strip. They are few (capped in
+      // the store) but they ride on EVERY snapshot, so a fat one would land in
+      // the same 200ms loop that the body-stripping exists to protect.
+      saved: _networkSavedStore.networkSavedStore.getRecords().map(record => ({
+        ...record,
+        event: toWireEvent(record.event).event
+      }))
+    };
+  },
   subscribe: onChange => {
     // Pinning with no traffic in flight still has to reach the dashboard, so
     // both stores drive the snapshot.
@@ -590,10 +598,22 @@ const networkSyncAdapter = exports.networkSyncAdapter = {
       } catch {
         /* no interceptable runtime here */
       }
+      // `interceptorInstalled` is the listener's own flag; `interceptorLive`
+      // is whether the interceptors are actually reachable through the global
+      // chain. installed:true + live:false = something re-assigned fetch/XHR
+      // over the interceptor (it self-heals on the next subscribe/snapshot —
+      // see ensureInterception).
+      let interceptorLive = null;
+      try {
+        interceptorLive = (0, _networkListener.isNetworkInterceptionLive)();
+      } catch {
+        /* no interceptable runtime here */
+      }
       return {
         capturing: subscribers > 0,
         subscribers,
         interceptorInstalled,
+        interceptorLive,
         listenerCount,
         eventCount: _networkEventStore.networkEventStore.getEvents().length
       };

package/lib/commonjs/network/utils/networkEventStore.js

@@ -175,6 +175,32 @@ class NetworkEventStore extends _sharedUi.BaseEventStore {
     return this.rawListenerUnsubscribe !== null;
   }
 
+  /**
+   * Re-assert the interceptor if something re-assigned fetch/XHR since capture
+   * started (Expo's runtime, RN DevTools, a second dev server's tooling — see
+   * networkListener.startListening). A no-op costing two property reads when
+   * everything is healthy, and a no-op entirely unless this store is actively
+   * capturing — a mirror-mode dashboard must never install an interceptor in
+   * its own process.
+   */
+  ensureInterception() {
+    if (!this.isCapturing()) return;
+    (0, _networkListener.networkListener)().startListening();
+  }
+
+  /**
+   * Every new consumer — the Network modal opening, a badge mounting, a
+   * dashboard watch attaching — is a chance to notice and repair a clobbered
+   * interceptor, which matters because a long-lived watch can hold the
+   * subscriber count above zero for the whole session (so the 0→1
+   * startCapturing path would never run again).
+   */
+  subscribeToEvents(listener) {
+    const unsubscribe = super.subscribeToEvents(listener);
+    this.ensureInterception();
+    return unsubscribe;
+  }
+
   /**
    * Process a network listener event
    */

package/lib/commonjs/network/utils/networkListener.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.stopNetworkListener = exports.startNetworkListener = exports.removeAllNetworkListeners = exports.networkListener = exports.isNetworkListening = exports.getNetworkListenerCount = exports.addNetworkListener = void 0;
+exports.stopNetworkListener = exports.startNetworkListener = exports.removeAllNetworkListeners = exports.networkListener = exports.isNetworkListening = exports.isNetworkInterceptionLive = exports.getNetworkListenerCount = exports.addNetworkListener = exports.BUOY_XHR_INTERCEPTOR_FLAG = exports.BUOY_FETCH_INTERCEPTOR_FLAG = void 0;
 var _engine = require("../overrides/engine");
 var _applyToXhr = require("../overrides/applyToXhr");
 var _applyToFetch = require("../overrides/applyToFetch");
@@ -31,6 +31,18 @@ let insideOverriddenFetch = false;
 
 // Event types for network operations
 
+/**
+ * Markers stamped on the installed interceptor functions so their presence in
+ * the live chain stays detectable even after another tool wraps them.
+ * Cooperating patchers (@buoy-gg/impersonate) copy every `__buoy*` marker from
+ * the function they wrap onto their own wrapper; a global fetch/XHR WITHOUT
+ * the marker therefore means our interceptor was clobbered — some runtime
+ * re-assigned `globalThis.fetch` over it (Expo's winter runtime, React Native
+ * DevTools' network panel, a second dev server's tooling, hot-reload churn all
+ * do this in the wild) — and capture must re-install. See startListening.
+ */
+const BUOY_FETCH_INTERCEPTOR_FLAG = exports.BUOY_FETCH_INTERCEPTOR_FLAG = "__buoyNetworkFetchIntercepted";
+const BUOY_XHR_INTERCEPTOR_FLAG = exports.BUOY_XHR_INTERCEPTOR_FLAG = "__buoyNetworkXhrIntercepted";
 /**
  * Network traffic interceptor for React Native applications
  *
@@ -71,6 +83,25 @@ class NetworkListener {
 
   // Store original methods
 
+  /**
+   * The wrappers currently installed by THIS instance, for identity checks:
+   * `stopListening` restores a global only when it is still literally ours —
+   * assigning our saved original over someone who patched after us would wipe
+   * their interceptor exactly the way this class gets wiped (see below).
+   */
+  patchedFetch = null;
+  patchedXHROpen = null;
+  patchedXHRSend = null;
+  patchedXHRSetRequestHeader = null;
+
+  /**
+   * Bumped on every (re)install and on stop. Each wrapper closes over the
+   * generation it was born with and goes silent (pure pass-through — no emit,
+   * no counter bump) once a newer generation exists, so a wrapper stranded
+   * inside another tool's chain can never double-report a request.
+   */
+  fetchGeneration = 0;
+  xhrGeneration = 0;
   constructor() {
     // Store original methods
     this.originalFetch = globalThis.fetch.bind(globalThis);
@@ -408,30 +439,82 @@ class NetworkListener {
     }
   }
 
+  /** Is our fetch interceptor still reachable through the global chain? */
+  isFetchInterceptionLive() {
+    return globalThis.fetch[BUOY_FETCH_INTERCEPTOR_FLAG] === true;
+  }
+
+  /** Is our XHR interceptor still reachable through the prototype chain? */
+  isXhrInterceptionLive() {
+    return XMLHttpRequest.prototype.send[BUOY_XHR_INTERCEPTOR_FLAG] === true;
+  }
+
   /**
-   * Start intercepting network operations by swizzling fetch and XMLHttpRequest
-   *
-   * This method replaces the global fetch function and XMLHttpRequest methods
-   * with instrumented versions that emit events while preserving original functionality.
+   * Both halves of the interceptor are reachable — requests actually flow
+   * through capture. `isListening` alone cannot promise that (see
+   * startListening); diagnostics should report THIS.
+   */
+  isInterceptionLive() {
+    return this.isFetchInterceptionLive() && this.isXhrInterceptionLive();
+  }
+
+  /**
+   * Start (or repair) interception by swizzling fetch and XMLHttpRequest.
    *
-   * @throws Will log warnings if already listening
+   * NOT guarded by a plain `isListening` flag: `globalThis.fetch` gets
+   * re-assigned in the wild — Expo's winter runtime, React Native DevTools'
+   * network panel, a second dev server's tooling, hot-reload churn. When that
+   * happens the flag still says "listening" while every request bypasses
+   * capture, and a flag-only guard makes the outage PERMANENT (observed as
+   * "No network events" forever with `interceptorInstalled: true`). So this
+   * verifies each interceptor is actually reachable (marker check) and
+   * re-installs whichever half was clobbered, wrapping the CURRENT global so
+   * whatever replaced us keeps working underneath. When both halves are live
+   * this costs two property reads.
    *
    * @performance Uses method swizzling for minimal runtime overhead
    * @performance Includes request deduplication through ignored URL patterns
    */
   startListening() {
-    if (this.isListening) {
+    const fetchLive = this.isListening && this.isFetchInterceptionLive();
+    const xhrLive = this.isListening && this.isXhrInterceptionLive();
+    if (fetchLive && xhrLive) {
       return;
     }
-    const self = this;
+    if (!fetchLive) {
+      this.installFetchInterceptor();
+    }
+    if (!xhrLive) {
+      this.installXhrInterceptor();
+    }
+    this.isListening = true;
+    if (__DEV__) {
+      // Network listener has started monitoring fetch and XMLHttpRequest operations
+    }
+  }
 
-    // Swizzle fetch
-    globalThis.fetch = async (input, init) => {
+  /** Swizzle `globalThis.fetch`, wrapping whatever is installed right now. */
+  installFetchInterceptor() {
+    const self = this;
+    // The pass-through is the CURRENT global (not the construction-time one):
+    // re-installing after a clobber must call through the replacement, and a
+    // stale generation must replay the chain exactly as it stood beneath it.
+    const passthroughFetch = globalThis.fetch.bind(globalThis);
+    this.originalFetch = passthroughFetch;
+    const generation = ++this.fetchGeneration;
+    const wrappedFetch = async (input, init) => {
       const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
 
+      // A newer install supersedes this wrapper. If it is still stranded in
+      // another tool's chain it must pass through silently, or one request
+      // would be reported once per stranded generation.
+      if (generation !== self.fetchGeneration) {
+        return passthroughFetch(input, init);
+      }
+
       // Skip ignored URLs
       if (self.shouldIgnoreUrl(url)) {
-        return self.originalFetch(input, init);
+        return passthroughFetch(input, init);
       }
       const startTime = Date.now();
       const requestId = `fetch_${++self.requestCounter}`;
@@ -514,7 +597,7 @@ class NetworkListener {
           insideOverriddenFetch = outcome != null;
           let pending;
           try {
-            pending = self.originalFetch(input, init);
+            pending = passthroughFetch(input, init);
           } finally {
             insideOverriddenFetch = false;
           }
@@ -617,30 +700,51 @@ class NetworkListener {
         throw error;
       }
     };
+    wrappedFetch[BUOY_FETCH_INTERCEPTOR_FLAG] = true;
+    this.patchedFetch = wrappedFetch;
+    globalThis.fetch = this.patchedFetch;
+  }
 
-    // Swizzle XMLHttpRequest
-    XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
-      // Store request info on the xhr instance
-      const xhr = this;
-      xhr._requestId = `xhr_${++self.requestCounter}`;
-      xhr._method = method;
-      xhr._url = url;
-      xhr._startTime = Date.now();
-      xhr._requestHeaders = {};
-      return self.originalXHROpen.call(this, method, url, async, user, password);
+  /** Swizzle the XHR prototype methods, wrapping whatever is installed now. */
+  installXhrInterceptor() {
+    const self = this;
+    // Same contract as the fetch half: pass through to the CURRENT methods.
+    const passthroughOpen = XMLHttpRequest.prototype.open;
+    const passthroughSend = XMLHttpRequest.prototype.send;
+    const passthroughSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+    this.originalXHROpen = passthroughOpen;
+    this.originalXHRSend = passthroughSend;
+    this.originalXHRSetRequestHeader = passthroughSetRequestHeader;
+    const generation = ++this.xhrGeneration;
+    const patchedOpen = function (method, url, async, user, password) {
+      // Superseded generations must not re-stamp (a double stamp burns two
+      // request ids per request) — just pass through.
+      if (generation === self.xhrGeneration) {
+        const xhr = this;
+        xhr._requestId = `xhr_${++self.requestCounter}`;
+        xhr._method = method;
+        xhr._url = url;
+        xhr._startTime = Date.now();
+        xhr._requestHeaders = {};
+      }
+      return passthroughOpen.call(this, method, url, async ?? true, user, password);
     };
 
     // Track request headers
-    XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+    const patchedSetRequestHeader = function (header, value) {
       const xhr = this;
-      if (xhr._requestHeaders) {
+      if (generation === self.xhrGeneration && xhr._requestHeaders) {
         xhr._requestHeaders[header] = value;
       }
-      return self.originalXHRSetRequestHeader.call(this, header, value);
+      return passthroughSetRequestHeader.call(this, header, value);
     };
-    XMLHttpRequest.prototype.send = function (
+    const patchedSend = function (
     // @ts-ignore - this does exist on native
     data) {
+      // Superseded generation: silent pass-through (see the fetch wrapper).
+      if (generation !== self.xhrGeneration) {
+        return passthroughSend.call(this, data);
+      }
       const xhr = this;
       const requestId = xhr._requestId;
       const method = xhr._method || "GET";
@@ -650,7 +754,7 @@ class NetworkListener {
 
       // Skip ignored URLs
       if (self.shouldIgnoreUrl(url)) {
-        return self.originalXHRSend.call(this, data);
+        return passthroughSend.call(this, data);
       }
       const {
         url: cleanUrl,
@@ -767,18 +871,21 @@ class NetworkListener {
         // Listeners are attached above FIRST: `runOverride` drives the same
         // readyState transitions a real response would, and the interceptor has
         // to see them (readyState 2 is where TTFB is stamped).
-        const handled = (0, _applyToXhr.runOverride)(this, url, outcome, () => self.originalXHRSend.call(this, data));
+        const handled = (0, _applyToXhr.runOverride)(this, url, outcome, () => passthroughSend.call(this, data));
         // `handled` is false only where this isn't React Native's own
         // XMLHttpRequest and can't be driven by hand. Fall through and send for
         // real rather than dropping the request on the floor.
         if (handled) return;
       }
-      return self.originalXHRSend.call(this, data);
+      return passthroughSend.call(this, data);
     };
-    this.isListening = true;
-    if (__DEV__) {
-      // Network listener has started monitoring fetch and XMLHttpRequest operations
-    }
+    patchedSend[BUOY_XHR_INTERCEPTOR_FLAG] = true;
+    this.patchedXHROpen = patchedOpen;
+    this.patchedXHRSend = patchedSend;
+    this.patchedXHRSetRequestHeader = patchedSetRequestHeader;
+    XMLHttpRequest.prototype.open = this.patchedXHROpen;
+    XMLHttpRequest.prototype.send = this.patchedXHRSend;
+    XMLHttpRequest.prototype.setRequestHeader = this.patchedXHRSetRequestHeader;
   }
 
   /**
@@ -792,11 +899,30 @@ class NetworkListener {
       return;
     }
 
-    // Restore original methods
-    globalThis.fetch = this.originalFetch;
-    XMLHttpRequest.prototype.open = this.originalXHROpen;
-    XMLHttpRequest.prototype.send = this.originalXHRSend;
-    XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    // Silence any of our wrappers stranded inside another tool's chain — they
+    // check the generation on every call and now pass through without emitting.
+    this.fetchGeneration++;
+    this.xhrGeneration++;
+
+    // Restore ONLY what is still literally ours. If another tool patched after
+    // us (impersonate, a debugger), assigning our saved originals would wipe
+    // ITS interceptor — the exact injury startListening defends against.
+    if (this.patchedFetch && globalThis.fetch === this.patchedFetch) {
+      globalThis.fetch = this.originalFetch;
+    }
+    if (this.patchedXHROpen && XMLHttpRequest.prototype.open === this.patchedXHROpen) {
+      XMLHttpRequest.prototype.open = this.originalXHROpen;
+    }
+    if (this.patchedXHRSend && XMLHttpRequest.prototype.send === this.patchedXHRSend) {
+      XMLHttpRequest.prototype.send = this.originalXHRSend;
+    }
+    if (this.patchedXHRSetRequestHeader && XMLHttpRequest.prototype.setRequestHeader === this.patchedXHRSetRequestHeader) {
+      XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    }
+    this.patchedFetch = null;
+    this.patchedXHROpen = null;
+    this.patchedXHRSend = null;
+    this.patchedXHRSetRequestHeader = null;
     this.isListening = false;
     if (__DEV__) {
       // Network listener has stopped monitoring and restored original methods
@@ -921,4 +1047,12 @@ const isNetworkListening = () => getNetworkListener().isActive;
  */
 exports.isNetworkListening = isNetworkListening;
 const getNetworkListenerCount = () => getNetworkListener().listenerCount;
-exports.getNetworkListenerCount = getNetworkListenerCount;
+
+/**
+ * Whether both interceptors are actually reachable through the live global
+ * chain — the honest version of `isNetworkListening` (whose flag stays true
+ * even after another tool re-assigns `globalThis.fetch` over the wrapper).
+ */
+exports.getNetworkListenerCount = getNetworkListenerCount;
+const isNetworkInterceptionLive = () => getNetworkListener().isInterceptionLive();
+exports.isNetworkInterceptionLive = isNetworkInterceptionLive;

package/lib/module/network/components/NetworkDetailStepper.js

@@ -98,6 +98,7 @@ export const NetworkDetailStepper = /*#__PURE__*/memo(function NetworkDetailStep
     itemLabel: "Request",
     applySafeAreaInset: applySafeAreaInset,
     onPrevious: stepPrevious,
-    onNext: stepNext
+    onNext: stepNext,
+    variant: "night"
   });
 });