@rozenite/network-activity-plugin 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rozenite/network-activity-plugin",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Network Activity for Rozenite.",
   "type": "module",
   "main": "./dist/react-native.cjs",
@@ -8,7 +8,8 @@
   "types": "./dist/react-native.d.ts",
   "dependencies": {
     "nanoevents": "^9.1.0",
-    "@rozenite/plugin-bridge": "1.5.0"
+    "@rozenite/agent-bridge": "1.6.0",
+    "@rozenite/plugin-bridge": "1.6.0"
   },
   "devDependencies": {
     "@floating-ui/react": "^0.26.0",
@@ -39,8 +40,8 @@
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
     "zustand": "^5.0.6",
-    "rozenite": "1.5.0",
-    "@rozenite/vite-plugin": "1.5.0"
+    "@rozenite/vite-plugin": "1.6.0",
+    "rozenite": "1.6.0"
   },
   "peerDependencies": {
     "react-native-sse": "*"

package/src/react-native/agent/__tests__/network-activity-agent-state.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, it } from 'vitest';
+import { createNetworkActivityAgentState } from '../state';
+import { NETWORK_ACTIVITY_AGENT_TOOLS } from '../tools';
+import type { Request } from '../../../shared/client';
+
+const createRequest = (overrides?: Partial<Request>): Request => ({
+  url: 'https://example.com/api',
+  method: 'POST',
+  headers: {
+    'content-type': 'application/json',
+  },
+  postData: {
+    type: 'text',
+    value: '{"hello":"world"}',
+  },
+  ...overrides,
+});
+
+describe('network activity agent state', () => {
+  it('exposes the expected fallback and realtime tool names', () => {
+    expect(NETWORK_ACTIVITY_AGENT_TOOLS.map((tool) => tool.name)).toEqual([
+      'startRecording',
+      'stopRecording',
+      'getRecordingStatus',
+      'listRequests',
+      'getRequestDetails',
+      'getRequestBody',
+      'getResponseBody',
+      'listRealtimeConnections',
+      'getRealtimeConnectionDetails',
+    ]);
+  });
+
+  it('tracks HTTP requests with parity-oriented list/detail/body results', () => {
+    const state = createNetworkActivityAgentState();
+    state.startRecording();
+
+    state.onRequestSent({
+      requestId: 'req-1',
+      timestamp: 100,
+      request: createRequest(),
+      type: 'XHR',
+      initiator: { type: 'script', url: 'App.tsx', lineNumber: 12, columnNumber: 4 },
+    });
+    state.onResponseReceived({
+      requestId: 'req-1',
+      timestamp: 120,
+      type: 'XHR',
+      response: {
+        url: 'https://example.com/api',
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'application/json' },
+        contentType: 'application/json',
+        size: 17,
+        responseTime: 120,
+      },
+    });
+    state.onRequestCompleted({
+      requestId: 'req-1',
+      timestamp: 130,
+      duration: 30,
+      size: 17,
+      ttfb: 20,
+    });
+
+    const list = state.listRequests({});
+    expect(list.items).toEqual([
+      {
+        requestId: 'req-1',
+        method: 'POST',
+        url: 'https://example.com/api',
+        status: 200,
+        type: 'XHR',
+        startTimeMs: 100,
+        endTimeMs: 130,
+        durationMs: 30,
+        transferSize: 17,
+        encodedDataLength: 17,
+        outcome: 'success',
+      },
+    ]);
+
+    const details = state.getRequestDetails('req-1');
+    expect(details.request).toMatchObject({
+      requestId: 'req-1',
+      method: 'POST',
+      url: 'https://example.com/api',
+      type: 'XHR',
+      loadingFinished: true,
+      loadingFailed: false,
+      ttfb: 20,
+      size: 17,
+    });
+
+    expect(state.getRequestBody('req-1')).toEqual({
+      requestId: 'req-1',
+      available: true,
+      body: '{"hello":"world"}',
+      base64Encoded: false,
+    });
+  });
+
+  it('returns unavailable request bodies when none were captured', () => {
+    const state = createNetworkActivityAgentState();
+    state.startRecording();
+    state.onRequestSent({
+      requestId: 'req-2',
+      timestamp: 10,
+      request: createRequest({ postData: undefined, method: 'GET' }),
+      type: 'Fetch',
+      initiator: { type: 'other' },
+    });
+
+    expect(state.getRequestBody('req-2')).toEqual({
+      requestId: 'req-2',
+      available: false,
+      reason: 'No request body is available for this request.',
+    });
+  });
+
+  it('supports realtime listing and details for websocket and sse traffic', () => {
+    const state = createNetworkActivityAgentState();
+    state.startRecording();
+
+    state.onWebSocketConnect({
+      type: 'websocket-connect',
+      url: 'wss://example.com/socket',
+      socketId: 7,
+      timestamp: 100,
+      protocols: ['chat'],
+      options: [],
+    });
+    state.onWebSocketOpen({
+      type: 'websocket-open',
+      url: 'wss://example.com/socket',
+      socketId: 7,
+      timestamp: 110,
+    });
+    state.onWebSocketMessageSent({
+      type: 'websocket-message-sent',
+      url: 'wss://example.com/socket',
+      socketId: 7,
+      timestamp: 120,
+      data: 'ping',
+      messageType: 'text',
+    });
+    state.onWebSocketMessageReceived({
+      type: 'websocket-message-received',
+      url: 'wss://example.com/socket',
+      socketId: 7,
+      timestamp: 121,
+      data: 'pong',
+      messageType: 'text',
+    });
+
+    state.onRequestSent({
+      requestId: 'req-sse',
+      timestamp: 200,
+      request: createRequest({
+        method: 'GET',
+        url: 'https://example.com/stream',
+        postData: undefined,
+      }),
+      type: 'Fetch',
+      initiator: { type: 'script' },
+    });
+    state.onSSEOpen({
+      type: 'sse-open',
+      requestId: 'req-sse',
+      timestamp: 210,
+      response: {
+        url: 'https://example.com/stream',
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'text/event-stream' },
+        contentType: 'text/event-stream',
+        size: 0,
+        responseTime: 210,
+      },
+    });
+    state.onSSEMessage({
+      type: 'sse-message',
+      requestId: 'req-sse',
+      timestamp: 220,
+      payload: {
+        type: 'message',
+        data: 'hello',
+      },
+    });
+
+    const list = state.listRealtimeConnections({});
+    expect(list.items).toHaveLength(2);
+    expect(list.items[0]).toMatchObject({
+      requestId: 'req-sse',
+      kind: 'sse',
+      status: 'open',
+      messageCount: 1,
+    });
+    expect(list.items[1]).toMatchObject({
+      requestId: 'ws-7',
+      kind: 'websocket',
+      status: 'open',
+      messageCount: 2,
+    });
+
+    const websocketDetails = state.getRealtimeConnectionDetails('ws-7');
+    expect(websocketDetails.connection).toMatchObject({
+      requestId: 'ws-7',
+      kind: 'websocket',
+      url: 'wss://example.com/socket',
+      status: 'open',
+    });
+    expect(websocketDetails.connection.messages).toHaveLength(2);
+
+    const sseDetails = state.getRealtimeConnectionDetails('req-sse');
+    expect(sseDetails.connection).toMatchObject({
+      requestId: 'req-sse',
+      kind: 'sse',
+      status: 'open',
+    });
+    expect(sseDetails.connection.messages).toHaveLength(1);
+  });
+
+  it('invalidates old cursors after a new recording starts', () => {
+    const state = createNetworkActivityAgentState();
+    state.startRecording();
+    state.onRequestSent({
+      requestId: 'req-1',
+      timestamp: 100,
+      request: createRequest(),
+      type: 'XHR',
+      initiator: { type: 'other' },
+    });
+    state.onRequestSent({
+      requestId: 'req-2',
+      timestamp: 101,
+      request: createRequest({ url: 'https://example.com/api/2' }),
+      type: 'XHR',
+      initiator: { type: 'other' },
+    });
+
+    const firstPage = state.listRequests({ limit: 1 });
+    state.startRecording();
+
+    expect(() =>
+      state.listRequests({ limit: 1, cursor: firstPage.page.nextCursor })
+    ).toThrow('Cursor does not match the requested listing. Run the command again.');
+  });
+});