@buoy-gg/network 7.0.79 → 7.0.81

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

@@ -69,7 +69,7 @@ export declare const networkSyncAdapter: {
                 fetch: string;
                 xhr: string;
                 upload: string;
-                webSocket: boolean;
+                webSocket: string;
                 nativeImages: boolean;
                 nativeModules: boolean;
                 netInfo: import("../conditions/store").ConnectionSupport;
@@ -239,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;