@rozenite/network-activity-plugin 1.8.1 → 1.10.0

package/dist/react-native/index.d.ts

@@ -63,7 +63,7 @@ declare type HttpEventMap = {
     };
     'response-body': {
         requestId: RequestId;
-        body: string | null;
+        body: ResponseBody;
     };
     'set-overrides': {
         overrides: [string, RequestOverride][];
@@ -76,9 +76,37 @@ declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
 
 declare type Initiator = {
     type: string;
+    symbolicationStatus?: 'pending' | 'complete' | 'failed' | 'unavailable';
+    symbolicationError?: string;
+    functionName?: string;
     url?: string;
     lineNumber?: number;
     columnNumber?: number;
+    generatedUrl?: string;
+    generatedLineNumber?: number;
+    generatedColumnNumber?: number;
+    codeFrame?: InitiatorCodeFrame | null;
+    stack?: InitiatorStackFrame[];
+};
+
+declare type InitiatorCodeFrame = {
+    content: string;
+    fileName: string;
+    location?: {
+        row: number;
+        column: number;
+    } | null;
+};
+
+declare type InitiatorStackFrame = {
+    functionName?: string;
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    generatedUrl?: string;
+    generatedLineNumber?: number;
+    generatedColumnNumber?: number;
+    isCollapsed?: boolean;
 };
 
 declare type InspectorsConfig = {
@@ -171,6 +199,14 @@ declare type Response_2 = {
     responseTime: Timestamp;
 };
 
+declare type ResponseBody = string | {
+    kind: 'binary';
+    base64: string;
+} | {
+    kind: 'binary-too-large';
+    size: number;
+} | null;
+
 declare type SSECloseEvent = {
     type: 'sse-close';
     requestId: SSERequestId;
@@ -216,7 +252,7 @@ declare type SSERequestId = string;
 
 declare type Timestamp = number;
 
-export declare let useNetworkActivityDevTools: useNetworkActivityDevTools_2;
+export declare let useNetworkActivityDevTools: typeof useNetworkActivityDevTools_2;
 
 declare const useNetworkActivityDevTools_2: (config?: NetworkActivityDevToolsConfig) => RozeniteDevToolsClient<NetworkActivityEventMap> | null;
 
@@ -298,7 +334,7 @@ declare type WebSocketOpenEvent = {
     source?: NetworkEventSource;
 };
 
-export declare let withOnBootNetworkActivityRecording: withOnBootNetworkActivityRecording_2;
+export declare let withOnBootNetworkActivityRecording: typeof withOnBootNetworkActivityRecording_2;
 
 /**
  * Enable network activity recording during app boot, before DevTools connects.

package/dist/rozenite.json

@@ -1 +1 @@
-{"name":"@rozenite/network-activity-plugin","version":"1.8.1","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/devtools/App.html"}]}
+{"name":"@rozenite/network-activity-plugin","version":"1.10.0","description":"Network Activity for Rozenite.","panels":[{"name":"Network Activity","source":"/devtools/App.html"}]}

package/dist/sdk/index.d.ts

@@ -402,7 +402,7 @@ declare type HttpEventMap = {
     };
     'response-body': {
         requestId: RequestId;
-        body: string | null;
+        body: ResponseBody;
     };
     'set-overrides': {
         overrides: [string, RequestOverride][];
@@ -415,9 +415,37 @@ export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | '
 
 export declare type Initiator = {
     type: string;
+    symbolicationStatus?: 'pending' | 'complete' | 'failed' | 'unavailable';
+    symbolicationError?: string;
+    functionName?: string;
     url?: string;
     lineNumber?: number;
     columnNumber?: number;
+    generatedUrl?: string;
+    generatedLineNumber?: number;
+    generatedColumnNumber?: number;
+    codeFrame?: InitiatorCodeFrame | null;
+    stack?: InitiatorStackFrame[];
+};
+
+declare type InitiatorCodeFrame = {
+    content: string;
+    fileName: string;
+    location?: {
+        row: number;
+        column: number;
+    } | null;
+};
+
+declare type InitiatorStackFrame = {
+    functionName?: string;
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    generatedUrl?: string;
+    generatedLineNumber?: number;
+    generatedColumnNumber?: number;
+    isCollapsed?: boolean;
 };
 
 export declare const NETWORK_ACTIVITY_AGENT_PLUGIN_ID = "@rozenite/network-activity-plugin";
@@ -1070,6 +1098,14 @@ declare type Response_2 = {
 };
 export { Response_2 as Response }
 
+declare type ResponseBody = string | {
+    kind: 'binary';
+    base64: string;
+} | {
+    kind: 'binary-too-large';
+    size: number;
+} | null;
+
 declare type SSEAgentMessage = {
     id: string;
     type: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rozenite/network-activity-plugin",
-  "version": "1.8.1",
+  "version": "1.10.0",
   "description": "Network Activity for Rozenite.",
   "type": "module",
   "main": "./dist/react-native/index.cjs",
@@ -16,9 +16,9 @@
   },
   "dependencies": {
     "nanoevents": "^9.1.0",
-    "@rozenite/agent-shared": "1.8.1",
-    "@rozenite/agent-bridge": "1.8.1",
-    "@rozenite/plugin-bridge": "1.8.1"
+    "@rozenite/agent-shared": "1.10.0",
+    "@rozenite/agent-bridge": "1.10.0",
+    "@rozenite/plugin-bridge": "1.10.0"
   },
   "devDependencies": {
     "@floating-ui/react": "^0.26.0",
@@ -29,6 +29,9 @@
     "@radix-ui/react-tabs": "^1.1.12",
     "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.0.0",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
     "@types/react": "~19.2.2",
     "@types/react-dom": "~19.1.7",
     "autoprefixer": "^10.4.21",
@@ -43,14 +46,15 @@
     "react-native": "0.83.1",
     "react-native-sse": "^1.2.1",
     "react-native-web": "^0.21.2",
+    "react-virtuoso": "^4.6.0",
     "tailwind-merge": "^3.3.1",
     "tailwindcss": "^3.4.17",
     "tailwindcss-animate": "^1.0.7",
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
     "zustand": "^5.0.6",
-    "@rozenite/vite-plugin": "1.8.1",
-    "rozenite": "1.8.1"
+    "@rozenite/vite-plugin": "1.10.0",
+    "rozenite": "1.10.0"
   },
   "peerDependencies": {
     "react-native-nitro-fetch": "*",
@@ -86,6 +90,7 @@
     "build": "rozenite build",
     "dev": "rozenite dev",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "test": "vitest --run --passWithNoTests"
   }
 }

package/src/react-native/agent/use-network-activity-agent-tools.ts

@@ -2,9 +2,7 @@ import { useEffect } from 'react';
 import { useRozenitePluginAgentTool } from '@rozenite/agent-bridge';
 import type { NetworkActivityDevToolsClient } from '../../shared/client';
 import type { NetworkInspector } from '../network-inspector';
-import {
-  getNetworkActivityAgentState,
-} from './state';
+import { getNetworkActivityAgentState } from './state';
 import {
   NETWORK_ACTIVITY_AGENT_PLUGIN_ID,
   type NetworkActivityGetResponseBodyResult,
@@ -195,7 +193,9 @@ export const useNetworkActivityAgentTools = ({
   useRozenitePluginAgentTool({
     pluginId: NETWORK_ACTIVITY_AGENT_PLUGIN_ID,
     tool: getResponseBodyTool,
-    handler: async ({ requestId }): Promise<NetworkActivityGetResponseBodyResult> => {
+    handler: async ({
+      requestId,
+    }): Promise<NetworkActivityGetResponseBodyResult> => {
       const record = state.getHttpRecord(requestId);
       if (!record) {
         throw new Error(`Unknown request "${requestId}"`);
@@ -228,6 +228,24 @@ export const useNetworkActivityAgentTools = ({
         };
       }
 
+      if (typeof body !== 'string') {
+        if (body.kind === 'binary-too-large') {
+          return {
+            requestId,
+            available: false,
+            reason: `Response body exceeded the in-capture size cap (${body.size} bytes).`,
+          };
+        }
+        return {
+          requestId,
+          available: true,
+          body: body.base64,
+          base64Encoded: true,
+          decoded: false,
+          mimeType: record.response?.contentType,
+        };
+      }
+
       return {
         requestId,
         available: true,

package/src/react-native/http/__tests__/http-utils.test.ts

@@ -0,0 +1,228 @@
+// @vitest-environment jsdom
+import { describe, expect, it } from 'vitest';
+import { BINARY_CAPTURE_SIZE_CAP, getResponseBody } from '../http-utils';
+
+type XHRStubOptions = {
+  responseType?: XMLHttpRequestResponseType;
+  responseText?: string;
+  response?: unknown;
+  contentType?: string;
+};
+
+const makeXHRStub = ({
+  responseType = '',
+  responseText = '',
+  response = null,
+  contentType = '',
+}: XHRStubOptions): XMLHttpRequest =>
+  ({
+    responseType,
+    responseText,
+    response,
+    getResponseHeader: (name: string) =>
+      name.toLowerCase() === 'content-type' ? contentType : null,
+  }) as unknown as XMLHttpRequest;
+
+describe('getResponseBody', () => {
+  it('returns plain text when responseType is empty', async () => {
+    const xhr = makeXHRStub({
+      responseType: '',
+      responseText: 'hello world',
+    });
+    expect(await getResponseBody(xhr)).toBe('hello world');
+  });
+
+  it('returns plain text when responseType is "text"', async () => {
+    const xhr = makeXHRStub({
+      responseType: 'text',
+      responseText: 'hello world',
+    });
+    expect(await getResponseBody(xhr)).toBe('hello world');
+  });
+
+  it('stringifies the JSON response when responseType is "json"', async () => {
+    const xhr = makeXHRStub({
+      responseType: 'json',
+      response: { ok: true, n: 1 },
+    });
+    expect(await getResponseBody(xhr)).toBe('{"ok":true,"n":1}');
+  });
+
+  it('reads a text blob as text', async () => {
+    const blob = new Blob(['<p>hello</p>'], { type: 'text/html' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'text/html; charset=utf-8',
+    });
+    expect(await getResponseBody(xhr)).toBe('<p>hello</p>');
+  });
+
+  it('reads a JSON blob as text', async () => {
+    const blob = new Blob(['{"ok":true}'], { type: 'application/json' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'application/json',
+    });
+    expect(await getResponseBody(xhr)).toBe('{"ok":true}');
+  });
+
+  it('routes image/svg+xml through the text path so the source is preserved', async () => {
+    const svg = '<svg xmlns="http://www.w3.org/2000/svg"><circle r="5"/></svg>';
+    const blob = new Blob([svg], { type: 'image/svg+xml' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'image/svg+xml',
+    });
+    expect(await getResponseBody(xhr)).toBe(svg);
+  });
+
+  it('reads application/xml as text', async () => {
+    const xml = '<feed><title>Demo</title></feed>';
+    const blob = new Blob([xml], { type: 'application/xml' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'application/xml',
+    });
+    expect(await getResponseBody(xhr)).toBe(xml);
+  });
+
+  it('reads text/xml as text', async () => {
+    const xml = '<root/>';
+    const blob = new Blob([xml], { type: 'text/xml' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'text/xml; charset=utf-8',
+    });
+    expect(await getResponseBody(xhr)).toBe(xml);
+  });
+
+  it('reads RFC 7303 +xml composite types (Atom, RSS, SOAP) as text', async () => {
+    const atom =
+      '<feed xmlns="http://www.w3.org/2005/Atom"><entry><title>x</title></entry></feed>';
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: new Blob([atom], { type: 'application/atom+xml' }),
+      contentType: 'application/atom+xml; charset=utf-8',
+    });
+    expect(await getResponseBody(xhr)).toBe(atom);
+  });
+
+  it('returns a binary union variant with base64 for an image blob under the cap', async () => {
+    // Three bytes (0x01 0x02 0x03) base64-encodes to "AQID".
+    const blob = new Blob([new Uint8Array([1, 2, 3])], { type: 'image/png' });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'image/png',
+    });
+    const result = await getResponseBody(xhr);
+    expect(result).toEqual({ kind: 'binary', base64: 'AQID' });
+  });
+
+  it('returns a binary-too-large variant without shipping bytes when the blob exceeds the cap', async () => {
+    // Stub a blob whose .size lies — we only care about the size-check
+    // path here, no FileReader.readAsDataURL should be invoked.
+    const oversizedBlob = {
+      size: BINARY_CAPTURE_SIZE_CAP + 1,
+      type: 'image/jpeg',
+    } as unknown as Blob;
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: oversizedBlob,
+      contentType: 'image/jpeg',
+    });
+    expect(await getResponseBody(xhr)).toEqual({
+      kind: 'binary-too-large',
+      size: BINARY_CAPTURE_SIZE_CAP + 1,
+    });
+  });
+
+  it('returns a binary union variant for non-image, non-text blob content-types', async () => {
+    const blob = new Blob([new Uint8Array([1, 2, 3])], {
+      type: 'application/pdf',
+    });
+    const xhr = makeXHRStub({
+      responseType: 'blob',
+      response: blob,
+      contentType: 'application/pdf',
+    });
+    expect(await getResponseBody(xhr)).toEqual({
+      kind: 'binary',
+      base64: 'AQID',
+    });
+  });
+
+  it('captures arraybuffer responses as binary', async () => {
+    const buffer = new Uint8Array([1, 2, 3]).buffer;
+    const xhr = makeXHRStub({
+      responseType: 'arraybuffer',
+      response: buffer,
+    });
+    expect(await getResponseBody(xhr)).toEqual({
+      kind: 'binary',
+      base64: 'AQID',
+    });
+  });
+
+  it('chunks large arraybuffer responses without exhausting fromCharCode', async () => {
+    // 100 KB of bytes — past the 32 KB chunk boundary used by the
+    // base64 encoder, well under the 5 MB cap. Confirms the chunked
+    // path produces correct base64 output.
+    const size = 100 * 1024;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+      bytes[i] = i & 0xff;
+    }
+    const xhr = makeXHRStub({
+      responseType: 'arraybuffer',
+      response: bytes.buffer,
+    });
+    const result = await getResponseBody(xhr);
+    expect(typeof result === 'object' && result?.kind === 'binary').toBe(true);
+    if (typeof result === 'object' && result?.kind === 'binary') {
+      // Round-trip: decode the base64 back and compare with the input.
+      const binary = atob(result.base64);
+      const decoded = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        decoded[i] = binary.charCodeAt(i);
+      }
+      expect(decoded.length).toBe(size);
+      expect(decoded[0]).toBe(0);
+      expect(decoded[size - 1]).toBe((size - 1) & 0xff);
+    }
+  });
+
+  it('short-circuits arraybuffer responses above the size cap', async () => {
+    // Stub a buffer whose byteLength lies — the cap check should fire
+    // before any encoding work happens.
+    const oversized = {
+      byteLength: BINARY_CAPTURE_SIZE_CAP + 1,
+    } as unknown as ArrayBuffer;
+    const xhr = makeXHRStub({
+      responseType: 'arraybuffer',
+      response: oversized,
+    });
+    expect(await getResponseBody(xhr)).toEqual({
+      kind: 'binary-too-large',
+      size: BINARY_CAPTURE_SIZE_CAP + 1,
+    });
+  });
+
+  it('returns null for an arraybuffer responseType with no payload', async () => {
+    const xhr = makeXHRStub({ responseType: 'arraybuffer' });
+    expect(await getResponseBody(xhr)).toBeNull();
+  });
+
+  it('returns null for an arraybuffer responseType with an empty buffer', async () => {
+    const xhr = makeXHRStub({
+      responseType: 'arraybuffer',
+      response: new ArrayBuffer(0),
+    });
+    expect(await getResponseBody(xhr)).toBeNull();
+  });
+});