@buoy-gg/network 7.0.36 → 7.0.39

package/lib/module/network/conditions/NetworkFloatingTool.test.js

@@ -0,0 +1,218 @@
+"use strict";
+
+// @vitest-environment jsdom
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { NetworkFloatingTool, createRemoteConditionsSource } from "./NetworkFloatingTool";
+const state = vi.hoisted(() => ({
+  profile: "normal",
+  available: true,
+  listeners: new Set(),
+  set: vi.fn()
+}));
+vi.mock("./store", () => ({
+  getNetworkCondition: () => state.profile,
+  conditionsCanApply: () => state.available,
+  subscribeNetworkConditions: listener => {
+    state.listeners.add(listener);
+    return () => state.listeners.delete(listener);
+  },
+  setNetworkCondition: profile => {
+    state.set(profile);
+    state.profile = profile;
+    state.listeners.forEach(listener => listener());
+  }
+}));
+vi.mock("@buoy-gg/shared-ui", async () => ({
+  night: (await vi.importActual("../../../../shared/src/ui/night/nightTheme")).night,
+  ChevronDown: () => null,
+  Check: () => null,
+  openFloatingTool: vi.fn(),
+  FloatingTool: ({
+    children,
+    accessory
+  }) => /*#__PURE__*/createElement("div", null, children, accessory)
+}));
+vi.mock("react-native", () => ({
+  StyleSheet: {
+    create: value => value
+  },
+  useWindowDimensions: () => ({
+    width: 390,
+    height: 844
+  }),
+  View: ({
+    children,
+    testID
+  }) => /*#__PURE__*/createElement("div", {
+    "data-testid": testID
+  }, children),
+  Text: ({
+    children,
+    testID
+  }) => /*#__PURE__*/createElement("span", {
+    "data-testid": testID
+  }, children),
+  ActivityIndicator: () => null,
+  TouchableOpacity: ({
+    children,
+    onPress,
+    disabled,
+    testID,
+    accessibilityLabel
+  }) => /*#__PURE__*/createElement("button", {
+    onClick: onPress,
+    disabled,
+    "data-testid": testID,
+    "aria-label": accessibilityLabel
+  }, children)
+}));
+let root;
+let container;
+const dismiss = vi.fn();
+beforeEach(() => {
+  globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+  state.profile = "normal";
+  state.available = true;
+  state.set.mockClear();
+  dismiss.mockClear();
+  container = document.createElement("div");
+  root = createRoot(container);
+});
+afterEach(() => act(() => root.unmount()));
+const button = id => container.querySelector(`[data-testid="${id}"]`);
+const tap = async id => act(async () => button(id).click());
+const status = () => container.querySelector('[data-testid="throttling-status"]')?.textContent;
+function render(source) {
+  act(() => root.render(/*#__PURE__*/createElement(NetworkFloatingTool, {
+    id: "network-throttling",
+    revealToken: 1,
+    dismiss,
+    source
+  })));
+}
+async function choose(value) {
+  const order = ["normal", "slow", "verySlow", "offline"];
+  const count = (order.indexOf(value) - order.indexOf(state.profile) + order.length) % order.length;
+  for (let i = 0; i < count; i++) await tap("throttling-cycle");
+}
+it("cycles and applies every profile immediately, including wrapping to normal", async () => {
+  render();
+  for (const [profile, label] of [["slow", "+500 ms"], ["verySlow", "+2000 ms"], ["offline", "Blocked"], ["normal", "0 ms"]]) {
+    await tap("throttling-cycle");
+    expect(state.profile).toBe(profile);
+    expect(container.querySelector(`[data-testid="throttling-signal-${profile}"]`)).not.toBeNull();
+    expect(status()).toBe(label);
+  }
+  expect(state.set).toHaveBeenCalledTimes(4);
+});
+it("keeps the profile label informational when tapped", async () => {
+  render();
+  await tap("throttling-profile");
+  expect(state.set).not.toHaveBeenCalled();
+  expect(state.profile).toBe("normal");
+  expect(button("throttling-profile").closest("button")).toBeNull();
+});
+it("changes active profiles and stops before dismissal", async () => {
+  state.profile = "slow";
+  render();
+  await choose("offline");
+  expect(state.profile).toBe("offline");
+  await tap("throttling-close");
+  expect(state.profile).toBe("normal");
+  expect(dismiss).toHaveBeenCalledOnce();
+});
+it("reflects external changes and disables cycling when account admission is revoked", () => {
+  render();
+  act(() => {
+    state.profile = "offline";
+    state.listeners.forEach(listener => listener());
+  });
+  expect(status()).toBe("Blocked");
+  act(() => {
+    state.profile = "normal";
+    state.available = false;
+    state.listeners.forEach(listener => listener());
+  });
+  expect(status()).toBe("Unavailable");
+  expect(button("throttling-cycle").disabled).toBe(true);
+});
+it("keeps remote failures visible and does not claim a profile was applied", async () => {
+  const source = createRemoteConditionsSource();
+  const onChange = vi.fn().mockRejectedValue(new Error("Connection lost"));
+  source.update({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  render(source);
+  await choose("slow");
+  expect(container.textContent).toContain("Connection lost");
+  expect(status()).toBe("0 ms");
+  expect(state.set).not.toHaveBeenCalled();
+});
+it("prevents duplicate remote operations and follows confirmed snapshots", async () => {
+  const source = createRemoteConditionsSource();
+  let resolve;
+  const onChange = vi.fn(() => new Promise(done => {
+    resolve = done;
+  }));
+  source.update({
+    profile: "normal",
+    available: true,
+    onChange
+  });
+  render(source);
+  await tap("throttling-cycle");
+  await tap("throttling-cycle");
+  expect(onChange).toHaveBeenCalledOnce();
+  expect(status()).toBe("Applying…");
+  await act(async () => resolve());
+  expect(status()).toBe("0 ms");
+  act(() => source.update({
+    profile: "slow",
+    available: true,
+    onChange
+  }));
+  expect(status()).toBe("+500 ms");
+  act(() => source.update(undefined));
+  expect(status()).toBe("Unavailable");
+});
+it("ignores a previous device's completion after switching devices", async () => {
+  const source = createRemoteConditionsSource();
+  let reject;
+  source.update({
+    targetId: "first",
+    profile: "normal",
+    available: true,
+    onChange: () => new Promise((_resolve, fail) => {
+      reject = fail;
+    })
+  });
+  render(source);
+  await choose("slow");
+  act(() => source.update({
+    targetId: "second",
+    profile: "normal",
+    available: true,
+    onChange: vi.fn()
+  }));
+  await act(async () => reject(new Error("Old device failed")));
+  expect(container.textContent).not.toContain("Old device failed");
+  expect(status()).toBe("0 ms");
+  expect(button("throttling-profile").textContent).toBe("No throttling");
+});
+it("keeps the strip open when stopping a remote device fails", async () => {
+  const source = createRemoteConditionsSource();
+  source.update({
+    profile: "offline",
+    available: true,
+    onChange: vi.fn().mockRejectedValue(new Error("Could not stop"))
+  });
+  render(source);
+  await tap("throttling-close");
+  expect(dismiss).not.toHaveBeenCalled();
+  expect(status()).toBe("Blocked");
+  expect(container.textContent).toContain("Could not stop");
+});

package/lib/module/network/conditions/store.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import { hasAccountAccess, subscribeAccountAccess } from "@buoy-gg/shared-ui";
+import { addNetworkListener, startNetworkListener, getNetworkListenerCount, stopNetworkListener } from "../utils/networkListener";
+export const NETWORK_CONDITIONS = {
+  normal: {
+    label: "Normal",
+    delayMs: 0
+  },
+  offline: {
+    label: "Offline (requests)",
+    delayMs: 0
+  },
+  slow: {
+    label: "Slow (+500 ms)",
+    delayMs: 500
+  },
+  verySlow: {
+    label: "Very slow (+2000 ms)",
+    delayMs: 2000
+  }
+};
+export const networkConditionsRuntimeId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+let profile = "normal";
+let keepAlive;
+const listeners = new Set();
+export const conditionsCanApply = () => typeof __DEV__ !== "undefined" && __DEV__ && hasAccountAccess();
+export const getNetworkCondition = () => profile;
+export const subscribeNetworkConditions = listener => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+export function setNetworkCondition(value) {
+  if (typeof value !== "string" || !Object.prototype.hasOwnProperty.call(NETWORK_CONDITIONS, value)) {
+    throw new Error("Choose normal, offline, slow, or verySlow.");
+  }
+  if (value !== "normal" && !conditionsCanApply()) {
+    throw new Error("Network conditions require an admitted account and a development build.");
+  }
+  if (value === profile) return profile;
+  if (value !== "normal" && !keepAlive) {
+    startNetworkListener();
+    keepAlive = addNetworkListener(() => {});
+  } else if (value === "normal") {
+    keepAlive?.();
+    keepAlive = undefined;
+    if (getNetworkListenerCount() === 0) stopNetworkListener();
+  }
+  profile = value;
+  listeners.forEach(listener => listener());
+  return profile;
+}
+export function snapshotNetworkCondition(url) {
+  if (profile === "normal" || !conditionsCanApply() || !/^https?:\/\//i.test(url)) return;
+  return Object.freeze({
+    profile,
+    delayMs: NETWORK_CONDITIONS[profile].delayMs
+  });
+}
+subscribeAccountAccess(() => {
+  if (!hasAccountAccess()) setNetworkCondition("normal");
+  listeners.forEach(listener => listener());
+});

package/lib/module/network/conditions/wait.js

@@ -0,0 +1,38 @@
+"use strict";
+
+export function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason !== undefined) throw signal.reason;
+  const error = new Error("The request was aborted.");
+  error.name = "AbortError";
+  throw error;
+}
+
+/** Wait before dispatch, releasing the timer and listener on cancellation. */
+export function waitBeforeDispatch(ms, signal) {
+  return new Promise((resolve, reject) => {
+    try {
+      throwIfAborted(signal);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const cleanup = () => signal?.removeEventListener("abort", abort);
+    const abort = () => {
+      clearTimeout(timer);
+      cleanup();
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, {
+      once: true
+    });
+  });
+}

package/lib/module/network/conditions/xhr.js

@@ -0,0 +1,106 @@
+"use strict";
+
+import { canSynthesize, completeNativeOverride } from "../overrides/applyToXhr";
+/** Active simulation uses a send-to-completion deadline, including the wait. */
+export function runConditionXhr(target, url, condition, outcome, dispatch) {
+  if (!canSynthesize(target)) throw new Error("Network conditions require React Native XMLHttpRequest.");
+  const xhr = target;
+  if (xhr.readyState !== 1 || xhr._sent) throw new Error("Request is not open or has already been sent.");
+  const started = Date.now();
+  let timeout = xhr.timeout;
+  let settled = false;
+  let dispatching = false;
+  let deadline;
+  let pending;
+  const originalAbort = xhr.abort;
+  const originalOpen = xhr.open;
+  const abortDescriptor = Object.getOwnPropertyDescriptor(xhr, "abort");
+  const openDescriptor = Object.getOwnPropertyDescriptor(xhr, "open");
+  const timeoutDescriptor = Object.getOwnPropertyDescriptor(xhr, "timeout");
+  const restore = (key, descriptor) => {
+    if (descriptor) Object.defineProperty(xhr, key, descriptor);else delete xhr[key];
+  };
+  const cleanup = () => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(pending);
+    clearTimeout(deadline);
+    xhr.removeEventListener("loadend", cleanup);
+    restore("abort", abortDescriptor);
+    restore("open", openDescriptor);
+    restore("timeout", timeoutDescriptor);
+    xhr.timeout = timeout;
+  };
+  const fail = timedOut => {
+    if (settled) return;
+    // DONE suppresses abort events while the native transport is cancelled.
+    Object.assign(xhr, {
+      readyState: 4
+    });
+    originalAbort.call(xhr);
+    xhr._aborted = false;
+    xhr._hasError = true;
+    xhr._timedOut = timedOut;
+    xhr._response = timedOut ? "Request timed out (Buoy conditions)" : "Network request failed (Buoy Offline)";
+    xhr.setReadyState(4);
+    cleanup();
+  };
+  const expired = () => timeout > 0 && Date.now() - started >= timeout;
+  const scheduleDeadline = () => {
+    clearTimeout(deadline);
+    if (timeout > 0) deadline = setTimeout(() => fail(true), Math.max(0, timeout - (Date.now() - started)));
+  };
+  Object.defineProperty(xhr, "timeout", {
+    configurable: true,
+    get: () => dispatching ? 0 : timeout,
+    set: value => {
+      timeout = Math.max(0, Number(value) || 0);
+      scheduleDeadline();
+    }
+  });
+  Object.defineProperty(xhr, "abort", {
+    configurable: true,
+    value: () => {
+      if (!settled) {
+        originalAbort.call(xhr);
+        cleanup();
+      }
+    }
+  });
+  Object.defineProperty(xhr, "open", {
+    configurable: true,
+    value: (...args) => {
+      const result = Reflect.apply(originalOpen, xhr, args);
+      cleanup();
+      return result;
+    }
+  });
+  xhr._sent = true;
+  xhr._requestId = null;
+  xhr.addEventListener("loadend", cleanup);
+  scheduleDeadline();
+  pending = setTimeout(() => {
+    if (settled) return;
+    if (expired()) {
+      fail(true);
+      return;
+    }
+    if (condition.profile === "offline") {
+      fail(false);
+      return;
+    }
+    if (outcome && outcome.kind !== "delay") {
+      completeNativeOverride(xhr, url, outcome);
+      return;
+    }
+    xhr._sent = false;
+    dispatching = true;
+    try {
+      dispatch();
+    } catch {
+      fail(false);
+    } finally {
+      dispatching = false;
+    }
+  }, condition.delayMs + (outcome?.delayMs ?? 0));
+}

package/lib/module/network/hooks/useNetworkEvents.js

@@ -14,7 +14,7 @@ import { searchGraphQLVariables } from "../utils/formatGraphQLVariables";
 
 /**
  * @deprecated Read the live limit with `useLimit("network.requests")` — this
- * only reports the FREE tier's value and is blind to the anonymous tier. Kept
+ * only reports the FREE tier's value and ignores the Weekend Pass. Kept
  * because it is part of the package's public exports.
  */
 export const FREE_TIER_REQUEST_LIMIT = TIER_LIMITS["network.requests"].free;

package/lib/module/network/overrides/applyToXhr.js

@@ -400,16 +400,12 @@ export function runOverride(xhr, url, outcome, passThrough) {
   // had already aborted. Claiming it means abort() dispatches DONE + 'abort'
   // and whatwg-fetch rejects with AbortError, as it should.
   internals._sent = true;
-  if (outcome.kind !== "delay") {
-    // Buoy's own `open()` swizzle overwrites RN's private `_requestId` with a
-    // string id. RN normally clobbers it back with the native numeric id inside
-    // `send()` — which we're skipping — so it would survive here, and
-    // `abort()` would hand that string to `RCTNetworking.abortRequest()`.
-    // Nulling it makes abort a clean no-op on the native side.
-    internals._requestId = null;
-  }
+
+  // There is no native request to cancel until a delayed send is dispatched.
+  internals._requestId = null;
   let timer = null;
   const onAbort = () => {
+    xhr.removeEventListener("abort", onAbort);
     if (timer !== null) {
       clearTimeout(timer);
       timer = null;
@@ -442,4 +438,9 @@ export function runOverride(xhr, url, outcome, passThrough) {
   // 'load' before they exist.
   timer = setTimeout(fire, outcome.delayMs);
   return true;
+}
+
+/** Complete an already scheduled native outcome without adding another timer. */
+export function completeNativeOverride(xhr, url, outcome) {
+  if (outcome.kind === "fail") fail(xhr, outcome);else if (outcome.kind === "respond") respond(xhr, url, outcome);
 }

package/lib/module/network/overrides/engine.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { hasAccountAccess } from "@buoy-gg/shared-ui";
 /**
  * The seam between the interceptor and the rule store.
  *
@@ -34,7 +35,7 @@ export function setOverrideHooks(next) {
 export function overridesCanApply() {
   // `__DEV__` is undefined outside React Native (unit tests, the desktop
   // bundle); only an explicit `false` — a real release build — disables it.
-  return !(typeof __DEV__ !== "undefined" && !__DEV__);
+  return hasAccountAccess() && !(typeof __DEV__ !== "undefined" && !__DEV__);
 }
 
 /** Why overrides are inert, for a caller that has to explain it to a person. */

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

@@ -1,5 +1,6 @@
 "use strict";
 
+import { getNetworkCondition, setNetworkCondition, subscribeNetworkConditions, conditionsCanApply, networkConditionsRuntimeId } from "../conditions/store";
 import { networkEventStore } from "../utils/networkEventStore";
 import { flagsForEventId, networkSavedStore } from "../utils/networkSavedStore";
 import { overrideRulesStore } from "../overrides/overrideRulesStore";
@@ -474,10 +475,13 @@ function baseFromRequest(params) {
  * `NetworkPanel`/`NetworkInline` accept either shape.
  */
 export const networkSyncAdapter = {
+  dispose: () => {
+    overrideRulesStore.setEnabled(false);
+  },
   // v5: honest request/responseSize + explicit request/responseBodyOmitted
   // flags, and a total snapshot budget so the list degrades instead of the
   // whole panel being dropped at the emit layer.
-  version: 5,
+  version: 6,
   getSnapshot: () => {
     // Piggyback the interception health check on the watch loop: while a
     // dashboard/MCP watch is open this runs continuously, so a clobbered
@@ -486,6 +490,12 @@ export const networkSyncAdapter = {
     // reads when healthy.
     networkEventStore.ensureInterception();
     return {
+      conditions: {
+        version: 1,
+        runtimeId: networkConditionsRuntimeId,
+        profile: getNetworkCondition(),
+        available: conditionsCanApply()
+      },
       events: fitEventsToBudget(networkEventStore.getEvents()),
       /**
        * Response-override rules live on the DEVICE — that's the only place they
@@ -506,17 +516,32 @@ export const networkSyncAdapter = {
     // Pinning with no traffic in flight still has to reach the dashboard, so
     // both stores drive the snapshot.
     const unsubscribeEvents = networkEventStore.subscribeToEvents(onChange);
+    const unsubscribeConditions = subscribeNetworkConditions(onChange);
     const unsubscribeSaved = networkSavedStore.subscribe(onChange);
     // Same reasoning for rules: editing one with no traffic in flight must
     // still reach the dashboard. Subscribing also hydrates the rule list.
     const unsubscribeOverrides = overrideRulesStore.subscribe(onChange);
     return () => {
+      unsubscribeConditions();
       unsubscribeEvents();
       unsubscribeSaved();
       unsubscribeOverrides();
     };
   },
   actions: {
+    getNetworkConditions: () => ({
+      runtimeId: networkConditionsRuntimeId,
+      profile: getNetworkCondition(),
+      available: conditionsCanApply()
+    }),
+    setNetworkConditions: params => {
+      const profile = params && typeof params === "object" ? params.profile : undefined;
+      return {
+        runtimeId: networkConditionsRuntimeId,
+        profile: setNetworkCondition(profile),
+        available: conditionsCanApply()
+      };
+    },
     clearEvents: () => {
       networkEventStore.clearEvents();
     },

package/lib/module/network/utils/generateNetworkCopyText.js

@@ -77,6 +77,7 @@ export function generateNetworkCopyText(events, copySettings) {
         obj.statusText = event.statusText;
       }
       if (copySettings.includeDuration) obj.duration = event.duration;
+      if (event.condition) obj.condition = event.condition;
       if (copySettings.includeTimestamp) obj.timestamp = event.timestamp;
       if (copySettings.includeClient) obj.requestClient = event.requestClient;
       if (copySettings.includeSizes) {
@@ -115,6 +116,7 @@ export function generateNetworkCopyText(events, copySettings) {
     if (copySettings.includeClient && event.requestClient) {
       md += `**Client:** ${event.requestClient}\n`;
     }
+    if (event.condition) md += `Conditions: ${event.condition.profile} (+${event.condition.delayMs} ms)\n`;
     if (copySettings.includeDuration && event.duration) {
       md += `**Duration:** ${event.duration}ms\n`;
     }