@buoy-gg/network 7.0.78 → 7.0.80

package/lib/typescript/network/sockets/socketMoments.d.ts

@@ -0,0 +1,24 @@
+import type { SocketFrame } from "./types";
+/**
+ * The socket moments the Events timeline shows: opened, closed, errored, and
+ * messages Buoy faked. Single messages stay in the Sockets screen; a chat app
+ * would bury every other tool's events in typing indicators.
+ *
+ * Shaped like `@buoy-gg/events`' UnifiedEvent without importing it, because
+ * Events loads this package, not the other way round (same deal as three's
+ * onThreeLoad).
+ */
+export interface SocketMoment {
+    id: string;
+    source: "socket";
+    timestamp: number;
+    title: string;
+    subtitle: string;
+    status: "success" | "error" | "pending" | "neutral";
+    originalEvent: SocketFrame;
+    correlationId: string;
+}
+export declare function toSocketMoment(frame: SocketFrame, url: string): SocketMoment | null;
+/** Follow socket moments as they happen. Returns the unsubscribe. */
+export declare function onSocketMoment(listener: (moment: SocketMoment) => void): () => void;
+//# sourceMappingURL=socketMoments.d.ts.map

package/lib/typescript/network/sockets/socketStore.d.ts

@@ -0,0 +1,94 @@
+import { BaseEventStore } from "@buoy-gg/shared-ui";
+import type { SocketAction, SocketActionResult, SocketFrame, SocketsState } from "./types";
+import { type SocketControl, type SocketRecorder } from "./webSocketPatch";
+export declare function isToolingSocket(url: string): boolean;
+/** Desktop: how the mirror reaches the device. */
+export interface SocketsRemote {
+    act(action: SocketAction): Promise<SocketActionResult>;
+    getFrame(id: string): Promise<{
+        frame: SocketFrame;
+        partner: SocketFrame | null;
+    } | null>;
+}
+declare class SocketStore extends BaseEventStore<SocketFrame> implements SocketRecorder {
+    private connections;
+    private controls;
+    /** Open requests by socket, then by correlation id → frame id and send time. */
+    private pending;
+    /** Message types that got a reply, per URL. Kept so cut-off frames don't forget them. */
+    private answered;
+    private socketSeq;
+    private frameSeq;
+    private blocked;
+    private offline;
+    private installed;
+    private mirror;
+    private remote;
+    private capturingSince;
+    private mirrored;
+    private cache;
+    private version;
+    private recheck;
+    private retryOnAccess;
+    constructor();
+    /**
+     * Install the WebSocket wrapper. Called at import in a React Native dev
+     * build (see preset.tsx), and on first subscribe elsewhere. Never in mirror
+     * mode: Desktop must not watch its own sockets.
+     */
+    install(): boolean;
+    protected startCapturing(): void;
+    /** The wrapper stays installed; there is nothing to stop. */
+    protected stopCapturing(): void;
+    isCapturing(): boolean;
+    disableCapture(): void;
+    /** Tell listeners something besides the frame list changed (a connection, a test switch). */
+    private bump;
+    private nextFrameId;
+    private setConnection;
+    private push;
+    register(url: string, protocols: string[] | undefined, control: SocketControl): string | null;
+    private trimConnections;
+    open(socketId: string): void;
+    close(socketId: string, code: number | undefined, reason: string | undefined, byBuoy: boolean): void;
+    error(socketId: string): void;
+    message(socketId: string, direction: "in" | "out", raw: unknown, flags?: {
+        fake?: "inject" | "send";
+        held?: boolean;
+        sentWhileClosed?: boolean;
+    }): string | undefined;
+    /** Learn that a type gets replies, with caps: oldest URL and oldest type go first. */
+    private rememberAnswered;
+    /**
+     * Wake when the next open request's wait is over, so "no reply" shows on
+     * time even if nothing else happens, and again when it is too old to pair,
+     * so it is forgotten: a message with an `id` that never gets an answer (a
+     * one-way event) must not keep memory forever. Stops when none are left.
+     */
+    private scheduleRecheck;
+    cutOff(): string | null;
+    isFrozen(socketId: string): boolean;
+    /** Network's offline mode reaches sockets too: open ones drop, new ones fail. */
+    private syncOffline;
+    getState(): SocketsState;
+    getFrame(id: string): SocketFrame | undefined;
+    /** Subscribe to every change: frames, connections, tests. Returns unsubscribe. */
+    subscribeState(listener: () => void): () => void;
+    /** Desktop: send actions to the device instead of running them here. */
+    setRemote(remote: SocketsRemote | null): void;
+    /** One whole frame and its reply or request. On Desktop it comes from the device. */
+    loadFrame(id: string): Promise<{
+        frame: SocketFrame;
+        partner: SocketFrame | null;
+    } | null>;
+    /** Desktop: show the device's state. */
+    applySnapshot(state: SocketsState | null): void;
+    act(action: SocketAction): Promise<SocketActionResult>;
+    actLocal(action: SocketAction): SocketActionResult;
+    clearEvents(): void;
+    protected notifyArrayListeners(): void;
+}
+/** Singleton: every socket the app opens, and what Buoy is doing to them. */
+export declare const socketStore: SocketStore;
+export {};
+//# sourceMappingURL=socketStore.d.ts.map

package/lib/typescript/network/sockets/socketsSyncAdapter.d.ts

@@ -0,0 +1,66 @@
+import type { SocketFrame, SocketsState } from "./types";
+/**
+ * External-sync adapter for the Sockets screen, under its own `sockets` key.
+ *
+ * Its own key, not part of `network`'s snapshot: a chat app sends messages all
+ * day, and every message would otherwise re-send the HTTP list (and its 1.25 MB
+ * budget) with it. Split, a busy socket only re-sends the socket snapshot.
+ *
+ * The snapshot carries the newest SNAPSHOT_FRAMES frames with short text, for
+ * Desktop's list. Whole messages and the full history come from actions:
+ * `getFrame` for one, `query` for a filtered page (what the MCP uses).
+ */
+export declare const SNAPSHOT_FRAMES = 300;
+/** Text kept per frame in the snapshot. The rest is fetched by `getFrame`. */
+export declare const SNAPSHOT_TEXT = 1000;
+/** With bodies, a list still cuts each one here: 50 big messages would flood an agent. `frameId` gets one whole. */
+export declare const LIST_BODY_TEXT = 4000;
+export interface SocketQuery {
+    socketId?: string;
+    frameId?: string;
+    /** `chat.*` matches by prefix; anything else matches part of the name. */
+    type?: string;
+    direction?: "in" | "out" | "lifecycle";
+    /** Only frames that are part of a problem. */
+    problems?: boolean;
+    /** Only frames at or after this time (ms since epoch). */
+    since?: number;
+    limit?: number;
+    includeBodies?: boolean;
+    includePings?: boolean;
+}
+export declare function matchesType(type: string | undefined, pattern: string): boolean;
+export declare function querySockets(state: SocketsState, q?: SocketQuery): {
+    connections: import("./types").SocketConnection[];
+    problems: import("./types").SocketProblem[];
+    tests: import("./types").SocketTestState;
+    capturingSince: number | null;
+    frames: SocketFrame[];
+    total: number;
+    flagged: string[];
+};
+export declare const socketsSyncAdapter: {
+    version: number;
+    getSnapshot: () => SocketsState;
+    subscribe: (onChange: () => void) => () => void;
+    actions: {
+        /** One whole frame, with its reply or request beside it. */
+        getFrame: (params?: unknown) => {
+            frame: SocketFrame;
+            partner: SocketFrame | null;
+        } | null;
+        /** A filtered page of frames plus every socket and problem. See SocketQuery. */
+        query: (params?: unknown) => {
+            connections: import("./types").SocketConnection[];
+            problems: import("./types").SocketProblem[];
+            tests: import("./types").SocketTestState;
+            capturingSince: number | null;
+            frames: SocketFrame[];
+            total: number;
+            flagged: string[];
+        };
+        /** inject | send | close | freeze | block | reset | clear. Says what really happened. */
+        act: (params?: unknown) => import("./types").SocketActionResult;
+    };
+};
+//# sourceMappingURL=socketsSyncAdapter.d.ts.map

package/lib/typescript/network/sockets/types.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Socket capture types — the Sockets screen of the Network tool.
+ *
+ * One list holds everything that happened on every socket, newest first:
+ * messages both ways AND the open/close/error moments, so a reconnect shows up
+ * between the messages around it instead of on a separate screen.
+ */
+export type SocketState = "connecting" | "open" | "closing" | "closed";
+export interface SocketConnection {
+    /** `s1`, `s2`, ... in the order the app created them. */
+    id: string;
+    /** The URL with secret query values hidden (`?token=[hidden]`). */
+    url: string;
+    protocols?: string[];
+    /** Nth socket this app made to the same URL (its path, query ignored). 1 = first. */
+    attempt: number;
+    state: SocketState;
+    createdAt: number;
+    openedAt?: number;
+    closedAt?: number;
+    closeCode?: number;
+    closeReason?: string;
+    /** Buoy closed it (Drop / Kick out / offline), not the app or the server. */
+    closedByBuoy?: boolean;
+    /** Freeze is on: messages both ways are held back while it still looks open. */
+    frozen?: boolean;
+    sent: number;
+    received: number;
+    bytesSent: number;
+    bytesReceived: number;
+    /** Heartbeat messages, counted here and folded out of the list. */
+    pings: number;
+    lastMessageAt?: number;
+}
+export type SocketFrameKind = "message" | "open" | "close" | "error";
+export interface SocketFrame {
+    /** `f1`, `f2`, ... unique for this app run. */
+    id: string;
+    socketId: string;
+    kind: SocketFrameKind;
+    timestamp: number;
+    /** Messages only: `out` = the app sent it, `in` = the app got it. */
+    direction?: "in" | "out";
+    /** The message as text, secrets hidden, cut at MAX_FRAME_CHARS. Binary shows as a short note. */
+    data?: string;
+    /** Length of the original message in bytes (or characters for text). */
+    size?: number;
+    binary?: boolean;
+    /** `data` was cut at MAX_FRAME_CHARS when captured: the rest is gone. */
+    truncated?: boolean;
+    /** `data` is a short preview for a list. `getFrame` has the whole text. */
+    dataCut?: boolean;
+    /** `data` is JSON. */
+    json?: boolean;
+    /** The message's name, read from `type`, `event`, `op`, `action` or `method`. */
+    type?: string;
+    /** The id that ties a request to its reply: `requestId`, `id`, `ref`, ... */
+    correlationId?: string;
+    /** A heartbeat (`ping`, `pong`, `heartbeat`, engine.io `2`/`3`). */
+    ping?: boolean;
+    /** Buoy made this message: `inject` = pushed into the app, `send` = sent to the server. */
+    fake?: "inject" | "send";
+    /** Held back by Freeze, Block or offline mode: the other side never got it. */
+    held?: boolean;
+    /** The app sent this while the socket was not open. */
+    sentWhileClosed?: boolean;
+    /** For a request: the id of its reply, and how long the reply took. */
+    replyId?: string;
+    replyMs?: number;
+    /** For a reply: the id of the request it answers. */
+    replyTo?: string;
+    /** close / error */
+    code?: number;
+    reason?: string;
+    byBuoy?: boolean;
+    /** close: the socket never opened (refused, bad response, no server). */
+    neverOpened?: boolean;
+}
+export type SocketProblemKind = "no-reply" | "reconnect-storm" | "auth-loop" | "cant-connect" | "two-sockets" | "sent-while-closed";
+export interface SocketProblem {
+    kind: SocketProblemKind;
+    /** Plain words, ready for a row, a chip or an agent. */
+    message: string;
+    socketId?: string;
+    url?: string;
+    /** The frames that prove it. */
+    frameIds: string[];
+    at: number;
+}
+/** What Buoy is doing to sockets right now — every one of these is fake behavior. */
+export interface SocketTestState {
+    /** New sockets fail at once, like a server that is down. */
+    blocked: boolean;
+    /** Network's offline mode is on, so sockets act offline too. */
+    offline: boolean;
+    /** Sockets with Freeze on. */
+    frozen: string[];
+}
+export interface SocketsState {
+    connections: SocketConnection[];
+    frames: SocketFrame[];
+    problems: SocketProblem[];
+    tests: SocketTestState;
+    /** When capture began. Sockets opened before this are not seen. */
+    capturingSince: number | null;
+}
+/** What the Tricks screen, Desktop and the MCP can do. */
+export type SocketAction = {
+    action: "inject";
+    socketId: string;
+    data: string;
+} | {
+    action: "send";
+    socketId: string;
+    data: string;
+} | {
+    action: "close";
+    socketId: string;
+    code?: number;
+    reason?: string;
+} | {
+    action: "freeze";
+    socketId: string;
+    frozen: boolean;
+} | {
+    action: "block";
+    blocked: boolean;
+} | {
+    action: "reset";
+} | {
+    action: "clear";
+};
+export interface SocketActionResult {
+    ok: boolean;
+    /** What really happened, in plain words. */
+    message: string;
+    frameId?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/network/sockets/webSocketPatch.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The WebSocket wrapper behind the Sockets screen.
+ *
+ * `globalThis.WebSocket` is replaced by a subclass, so every socket the app
+ * makes after this runs is seen with no setup. The subclass is still a real
+ * WebSocket (`instanceof` holds, the constants are inherited), and it talks to
+ * the network through the real one.
+ *
+ * WHY THE APP'S HANDLERS ARE KEPT HERE. To push a fake message into the app,
+ * freeze a socket, or fake a 1006 close, Buoy has to decide what reaches the
+ * app's own `onmessage`/`addEventListener` code. So the wrapper keeps the
+ * app's handlers in its own list and registers ONE listener per event with the
+ * real socket. That listener records the event, then hands it to the app's
+ * handlers unless a test is holding it back. React Native's WebSocket and the
+ * browser's both deliver through those listeners, so one path covers both.
+ *
+ * Fake closes: a browser refuses `close(1006)`, and Android ignores `close()`
+ * before the socket opens. So Buoy gives the app the close it asked for right
+ * away, closes the real socket with its own code, and hides the real close
+ * when it comes later.
+ */
+interface MessageFlags {
+    fake?: "inject" | "send";
+    held?: boolean;
+    sentWhileClosed?: boolean;
+}
+/** What the store learns from a socket. Implemented by socketStore. */
+export interface SocketRecorder {
+    /** null = don't track this socket (Buoy's own, Metro's, or capture is off). */
+    register(url: string, protocols: string[] | undefined, control: SocketControl): string | null;
+    open(socketId: string): void;
+    message(socketId: string, direction: "in" | "out", raw: unknown, flags?: MessageFlags): string | undefined;
+    close(socketId: string, code: number | undefined, reason: string | undefined, byBuoy: boolean): void;
+    error(socketId: string): void;
+    /** Why new sockets fail and messages are held (block or offline), or null. */
+    cutOff(): string | null;
+    isFrozen(socketId: string): boolean;
+}
+/** What the store can do to one socket. */
+export interface SocketControl {
+    /** Hand the app a message as if the server sent it. */
+    inject(data: string): string | undefined;
+    /** Send a message to the server. */
+    send(data: string): string | undefined;
+    /** Close as if the network (1006) or the server (1008, ...) did it. */
+    fakeClose(code: number, reason: string): void;
+    isOpen(): boolean;
+}
+/** Whether the wrapper is installed in this runtime. */
+export declare function isWebSocketPatched(): boolean;
+/**
+ * Install the wrapper once. Returns false when there is no WebSocket here or
+ * it is already installed.
+ */
+export declare function installWebSocketPatch(recorder: SocketRecorder): boolean;
+export {};
+//# sourceMappingURL=webSocketPatch.d.ts.map

package/lib/typescript/network/sync/networkSyncAdapter.d.ts

@@ -1,3 +1,4 @@
+import { getNetworkConditions, setNetworkConditions } from "../conditions/store";
 import type { OverrideRulesState } from "../overrides/overrideRulesStore";
 import { type OverrideRuleKind } from "../overrides/types";
 import type { NetworkEvent } from "../types";
@@ -54,10 +55,31 @@ export declare const networkSyncAdapter: {
     version: number;
     getSnapshot: () => {
         conditions: {
-            version: number;
+            version: 2;
             runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
+            revision: number;
+            profile: "offline" | "normal" | "slow" | "verySlow" | "slow3g" | "slow4g" | "fast4g";
+            connection: import("../..").NetworkConnection;
             available: boolean;
+            active: boolean;
+            delayMs: number;
+            downloadBytesPerSecond: number | null;
+            uploadBytesPerSecond: number | null;
+            capabilities: {
+                fetch: string;
+                xhr: string;
+                upload: string;
+                webSocket: string;
+                nativeImages: boolean;
+                nativeModules: boolean;
+                netInfo: import("../conditions/store").ConnectionSupport;
+                expoNetwork: import("../conditions/store").ConnectionSupport;
+            };
+            scope: {
+                download: string;
+                upload: string;
+                transports: string;
+            };
         };
         events: NetworkEvent[];
         /**
@@ -79,16 +101,8 @@ export declare const networkSyncAdapter: {
     };
     subscribe: (onChange: () => void) => () => void;
     actions: {
-        getNetworkConditions: () => {
-            runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
-            available: boolean;
-        };
-        setNetworkConditions: (params?: unknown) => {
-            runtimeId: string;
-            profile: "normal" | "offline" | "slow" | "verySlow";
-            available: boolean;
-        };
+        getNetworkConditions: typeof getNetworkConditions;
+        setNetworkConditions: typeof setNetworkConditions;
         clearEvents: () => void;
         /**
          * Return the full (un-stripped) request/response bodies for one event,
@@ -101,6 +115,7 @@ export declare const networkSyncAdapter: {
             method: string;
             status: number | null;
             override: import("../types").NetworkOverrideMark | null;
+            condition: import("../..").NetworkConditionStamp | null;
             requestData: {} | null;
             responseData: {} | null;
             requestHeaders: Record<string, string>;
@@ -224,11 +239,13 @@ export declare const networkSyncAdapter: {
             ok: boolean;
             count: number;
             enabled: boolean;
+            saved: boolean;
             error?: undefined;
         } | {
             ok: boolean;
             count: number;
             enabled: boolean;
+            saved: boolean;
             error?: undefined;
         }>;
         /**

package/lib/typescript/network/types/index.d.ts

@@ -40,6 +40,12 @@ export interface NetworkEvent {
     responseHeaders: Record<string, string>;
     requestData?: unknown;
     responseData?: unknown;
+    /** `responseData` was parsed from JSON text (so a string was a JSON string). */
+    responseJson?: boolean;
+    /** `responseData` was cut at the size cap (or left out as too large): not the real answer. */
+    responseTruncated?: boolean;
+    /** `responseData` wasn't read (still streaming, or unreadable): a placeholder. */
+    responseUnread?: boolean;
     responseSize?: number;
     requestSize?: number;
     timestamp: number;

package/lib/typescript/network/utils/networkListener.d.ts

@@ -27,6 +27,12 @@ export interface NetworkingEvent {
         headers?: Record<string, string>;
         body?: unknown;
         size?: number;
+        /** The body was parsed from JSON text (so a string body was a JSON string). */
+        json?: boolean;
+        /** The body was cut at the size cap (or left out as too large): not the real answer. */
+        truncated?: boolean;
+        /** The body wasn't read (still streaming, or unreadable): what's there is a placeholder. */
+        unread?: boolean;
     };
     error?: {
         message: string;
@@ -170,6 +176,10 @@ declare class NetworkListener {
      * in flight are emitted when they finish. The recorder stops recording on
      * the first call, so each request is reported once. See
      * core/src/earlyNetwork.ts for the record shapes.
+     *
+     * The recorder sits on a hidden `Symbol.for("buoy.earlyNetwork")` key. An
+     * older core only sets `__BUOY_EARLY_NETWORK__`, so that name is read as a
+     * fallback. Drop the fallback once no supported core writes only that name.
      */
     adoptEarlyRequests(): void;
     private adoptEarlyFetch;