react-native-ai-devtools-sdk 0.2.0

package/README.md

@@ -0,0 +1,215 @@
+# react-native-ai-devtools-sdk
+
+Lightweight companion SDK for [react-native-ai-devtools](https://www.npmjs.com/package/react-native-ai-devtools) — captures network requests, console logs, and state store references from your React Native app for AI-powered debugging.
+
+## Why use this SDK?
+
+The MCP server (`react-native-ai-devtools`) connects to your app via Chrome DevTools Protocol (CDP). This works great for most features, but CDP has limitations on newer React Native architectures (Expo SDK 52+, Bridgeless):
+
+| | Without SDK | With SDK |
+|---|---|---|
+| Startup network requests (auth, config) | Missed | Captured from first fetch |
+| Request/response headers | Partial | Full |
+| Request/response bodies | Not available | Full (including GraphQL) |
+| Console logs from startup | May miss early logs | Captured from first log |
+| State store access | Manual via `execute_in_app` | Direct references exposed |
+| Works on Bridgeless (Expo SDK 52+) | Partial | Full |
+| Setup | None | One import |
+
+The SDK patches `fetch` and `console` at import time and stores everything in an in-app buffer. The MCP server automatically detects the SDK and reads from it — no extra configuration needed.
+
+## Installation
+
+```bash
+npm install react-native-ai-devtools-sdk
+```
+
+## Setup
+
+Add to your app's entry file (`index.js`, `App.tsx`, or `app/_layout.tsx` for Expo Router) — **must be the first import**:
+
+```js
+import { init } from 'react-native-ai-devtools-sdk';
+if (__DEV__) {
+  init();
+}
+
+// ... rest of your imports
+```
+
+That's it. The MCP tools (`get_network_requests`, `get_logs`, etc.) will automatically use the SDK data when available.
+
+### With state stores
+
+Pass references to your state management stores for direct AI access:
+
+```js
+import { init } from 'react-native-ai-devtools-sdk';
+import { store } from './store'; // Redux store
+import { queryClient } from './queryClient'; // TanStack Query
+
+if (__DEV__) {
+  init({
+    stores: {
+      redux: store,
+      queryClient: queryClient,
+    },
+  });
+}
+```
+
+The AI assistant can then inspect store state directly:
+```
+execute_in_app with expression="globalThis.__RN_AI_DEVTOOLS__.stores.redux.getState()"
+```
+
+### Configuration options
+
+```js
+init({
+  // Max network entries to buffer (default: 500)
+  maxNetworkEntries: 500,
+
+  // Max console entries to buffer (default: 500)
+  maxConsoleEntries: 500,
+
+  // State store references for AI access
+  stores: {
+    redux: reduxStore,
+    queryClient: queryClient,
+    userStore: useUserStore,
+  },
+});
+```
+
+## How it works
+
+### Architecture
+
+```
+React Native App
+  |
+  |  1. import { init } from 'react-native-ai-devtools-sdk'
+  |     → patches globalThis.fetch (captures all network requests)
+  |     → patches console.log/warn/error/info/debug (captures all logs)
+  |     → stores references to state management stores
+  |     → exposes globalThis.__RN_AI_DEVTOOLS__ with query methods
+  |
+  |  2. App runs normally — all fetch() calls and console output
+  |     are intercepted, stored in circular buffers, and passed
+  |     through to their original implementations unchanged
+  |
+  v
+MCP Server (react-native-ai-devtools)
+  |
+  |  3. Connects to app via CDP (Chrome DevTools Protocol)
+  |     Detects SDK: typeof globalThis.__RN_AI_DEVTOOLS__?.getNetworkRequests === "function"
+  |
+  |  4. MCP tools read SDK data via Runtime.evaluate:
+  |     get_network_requests → globalThis.__RN_AI_DEVTOOLS__.getNetworkRequests()
+  |     get_request_details  → globalThis.__RN_AI_DEVTOOLS__.getNetworkRequest(id)
+  |     get_logs (future)    → globalThis.__RN_AI_DEVTOOLS__.getConsoleLogs()
+  |
+  v
+AI Assistant (Claude Code, Cursor, VS Code Copilot, etc.)
+```
+
+### What gets captured
+
+**Network requests** — Every `fetch()` call is intercepted. The SDK captures:
+- Method, URL, status, statusText, duration
+- Full request and response headers
+- Full request and response bodies (via `response.clone().text()` — the original response is untouched)
+- Errors and timing
+
+**Console output** — Every `console.log/warn/error/info/debug` call is captured with:
+- Log level, timestamp, formatted message
+- Original console methods still work — logs appear in Xcode/Metro/DevTools as normal
+
+**State stores** — References passed via `stores` option are exposed globally for the MCP server to query on demand.
+
+### Why it must be the first import
+
+The SDK patches `globalThis.fetch` and `console` when `init()` is called. If other code (your app, libraries like Apollo/Axios) calls `fetch` before the SDK patches it, those requests won't be captured. Placing the import first ensures the SDK intercepts everything from the very beginning, including:
+
+- OAuth token refresh on app launch
+- Initial GraphQL/REST API calls
+- Config/feature flag fetches
+- Early console output during initialization
+
+### Production safety
+
+The SDK is a no-op in production builds:
+
+1. The `if (__DEV__)` guard in your code prevents `init()` from being called
+2. Even if called without the guard, `init()` checks `__DEV__` internally as a safety net
+3. Tree-shaking removes the SDK code from production bundles when wrapped in `if (__DEV__)`
+
+### Circular buffers
+
+Both network and console data are stored in circular buffers (default: 500 entries each). When the buffer is full, the oldest entries are evicted. This bounds memory usage regardless of how many requests or logs the app produces.
+
+## Exposed global API
+
+The SDK exposes `globalThis.__RN_AI_DEVTOOLS__` with these methods. You don't need to call these directly — the MCP tools use them automatically.
+
+```typescript
+globalThis.__RN_AI_DEVTOOLS__ = {
+  version: '0.2.0',
+
+  // Capabilities — tells MCP server what's available
+  capabilities: {
+    network: true,
+    console: true,
+    stores: true,  // true if stores were passed
+    render: false,  // future: render profiling
+  },
+
+  // State store references
+  stores: { redux: store, queryClient: qc, ... },
+
+  // Network
+  getNetworkRequests(options?),  // { count, method, urlPattern, status }
+  getNetworkRequest(id),          // full details including bodies
+  getNetworkStats(),
+  clearNetwork(),
+
+  // Console
+  getConsoleLogs(options?),      // { count, level, text }
+  clearConsole(),
+}
+```
+
+## Compatibility
+
+| React Native | Architecture | Status |
+|---|---|---|
+| Expo SDK 54+ (RN 0.79+) | Bridgeless | Fully supported |
+| Expo SDK 52-53 (RN 0.76-0.78) | Bridgeless | Fully supported |
+| RN 0.73-0.75 | Hermes + Bridge | Fully supported |
+| RN 0.70-0.72 | Hermes + Bridge | Should work (untested) |
+| RN < 0.70 | JSC | Not tested |
+
+The SDK has zero native dependencies — it's pure JavaScript that patches standard globals (`fetch`, `console`). It works on any React Native version that supports these globals.
+
+## Relationship to react-native-ai-devtools
+
+This SDK is an **optional companion** to the [react-native-ai-devtools](https://github.com/nickmcdonnough/react-native-ai-devtools) MCP server. The MCP server works without the SDK — it connects via CDP and provides console logs, component inspection, UI interaction, and basic network tracking out of the box.
+
+The SDK enhances network and console capture for cases where CDP alone isn't sufficient (Bridgeless architecture, startup request capture, response bodies). When the MCP server detects the SDK, it automatically prefers SDK data. When the SDK is absent, it falls back to CDP.
+
+**You do NOT need the SDK for:**
+- Console log viewing (`get_logs`)
+- Component tree inspection (`get_component_tree`, `inspect_component`)
+- UI interaction (`tap`, `swipe`, screenshots)
+- JavaScript execution (`execute_in_app`)
+- App reload, bundle error detection, device management
+
+**The SDK improves:**
+- Network request capture (especially startup requests and response bodies)
+- Console log capture (startup logs that CDP might miss)
+- State store access (direct references vs manual global inspection)
+
+## License
+
+MIT

package/dist/consoleBuffer.d.ts

@@ -0,0 +1,13 @@
+import { ConsoleEntry, ConsoleQueryOptions } from './types';
+export declare class ConsoleBuffer {
+    private entries;
+    private maxSize;
+    constructor(maxSize?: number);
+    add(entry: ConsoleEntry): void;
+    query(options?: ConsoleQueryOptions): ConsoleEntry[];
+    getStats(): {
+        total: number;
+        byLevel: Record<string, number>;
+    };
+    clear(): number;
+}

package/dist/consoleBuffer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleBuffer = void 0;
+class ConsoleBuffer {
+    constructor(maxSize = 500) {
+        this.entries = [];
+        this.maxSize = maxSize;
+    }
+    add(entry) {
+        if (this.entries.length >= this.maxSize) {
+            this.entries.shift();
+        }
+        this.entries.push(entry);
+    }
+    query(options) {
+        let results = [...this.entries].reverse();
+        if (options?.level) {
+            results = results.filter((e) => e.level === options.level);
+        }
+        if (options?.text) {
+            const text = options.text.toLowerCase();
+            results = results.filter((e) => e.message.toLowerCase().includes(text));
+        }
+        if (options?.count != null && options.count > 0) {
+            results = results.slice(0, options.count);
+        }
+        return results;
+    }
+    getStats() {
+        const byLevel = {};
+        for (const entry of this.entries) {
+            byLevel[entry.level] = (byLevel[entry.level] || 0) + 1;
+        }
+        return { total: this.entries.length, byLevel };
+    }
+    clear() {
+        const count = this.entries.length;
+        this.entries = [];
+        return count;
+    }
+}
+exports.ConsoleBuffer = ConsoleBuffer;

package/dist/consoleInterceptor.d.ts

@@ -0,0 +1,3 @@
+import { ConsoleBuffer } from './consoleBuffer';
+export declare function patchConsole(buffer: ConsoleBuffer): void;
+export declare function unpatchConsole(): void;

package/dist/consoleInterceptor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchConsole = patchConsole;
+exports.unpatchConsole = unpatchConsole;
+const LEVELS = ['log', 'warn', 'error', 'info', 'debug'];
+let originals = null;
+let idCounter = 0;
+function generateId() {
+    const random = Math.random().toString(36).substring(2, 6);
+    return `con-${random}-${++idCounter}`;
+}
+function formatArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === 'string')
+            return arg;
+        try {
+            return JSON.stringify(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(' ');
+}
+function patchConsole(buffer) {
+    if (originals) {
+        return;
+    }
+    originals = {};
+    for (const level of LEVELS) {
+        originals[level] = console[level];
+        console[level] = (...args) => {
+            const entry = {
+                id: generateId(),
+                timestamp: Date.now(),
+                level,
+                message: formatArgs(args),
+            };
+            buffer.add(entry);
+            originals[level].apply(console, args);
+        };
+    }
+}
+function unpatchConsole() {
+    if (originals) {
+        for (const level of LEVELS) {
+            console[level] = originals[level];
+        }
+        originals = null;
+    }
+    idCounter = 0;
+}

package/dist/global.d.ts

@@ -0,0 +1,13 @@
+import { NetworkBuffer } from './networkBuffer';
+import { ConsoleBuffer } from './consoleBuffer';
+import { DevToolsGlobal, Capabilities } from './types';
+declare global {
+    var __RN_AI_DEVTOOLS__: DevToolsGlobal | undefined;
+}
+export interface ExposeGlobalOptions {
+    networkBuffer: NetworkBuffer;
+    consoleBuffer: ConsoleBuffer;
+    stores: Record<string, unknown>;
+    capabilities: Capabilities;
+}
+export declare function exposeGlobal(options: ExposeGlobalOptions): void;

package/dist/global.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposeGlobal = exposeGlobal;
+function exposeGlobal(options) {
+    const { networkBuffer, consoleBuffer, stores, capabilities } = options;
+    const devtools = {
+        version: '0.2.0',
+        capabilities,
+        stores,
+        getNetworkRequests: (opts) => networkBuffer.query(opts),
+        getNetworkRequest: (id) => networkBuffer.get(id),
+        getNetworkStats: () => networkBuffer.getStats(),
+        clearNetwork: () => networkBuffer.clear(),
+        getConsoleLogs: (opts) => consoleBuffer.query(opts),
+        clearConsole: () => consoleBuffer.clear(),
+    };
+    globalThis.__RN_AI_DEVTOOLS__ = devtools;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { InitOptions } from './types';
+export type { InitOptions, NetworkEntry, NetworkQueryOptions, NetworkStats, ConsoleEntry, ConsoleQueryOptions, Capabilities, DevToolsGlobal, } from './types';
+export declare function init(options?: InitOptions): void;
+export declare function _resetForTesting(): void;

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports._resetForTesting = _resetForTesting;
+const networkBuffer_1 = require("./networkBuffer");
+const consoleBuffer_1 = require("./consoleBuffer");
+const networkInterceptor_1 = require("./networkInterceptor");
+const consoleInterceptor_1 = require("./consoleInterceptor");
+const global_1 = require("./global");
+let initialized = false;
+function init(options) {
+    if (initialized) {
+        return;
+    }
+    // Safety net: no-op in production
+    if (typeof __DEV__ !== 'undefined' && !__DEV__) {
+        return;
+    }
+    const networkBuffer = new networkBuffer_1.NetworkBuffer(options?.maxNetworkEntries ?? 500);
+    const consoleBuffer = new consoleBuffer_1.ConsoleBuffer(options?.maxConsoleEntries ?? 500);
+    const stores = options?.stores ?? {};
+    (0, networkInterceptor_1.patchFetch)(networkBuffer);
+    (0, consoleInterceptor_1.patchConsole)(consoleBuffer);
+    (0, global_1.exposeGlobal)({
+        networkBuffer,
+        consoleBuffer,
+        stores,
+        capabilities: {
+            network: true,
+            console: true,
+            stores: Object.keys(stores).length > 0,
+            render: false,
+        },
+    });
+    initialized = true;
+}
+// Exported for testing purposes
+function _resetForTesting() {
+    initialized = false;
+    delete globalThis.__RN_AI_DEVTOOLS__;
+}

package/dist/networkBuffer.d.ts

@@ -0,0 +1,13 @@
+import { NetworkEntry, NetworkQueryOptions, NetworkStats } from './types';
+export declare class NetworkBuffer {
+    private entries;
+    private order;
+    private maxSize;
+    constructor(maxSize?: number);
+    add(entry: NetworkEntry): void;
+    update(id: string, updates: Partial<NetworkEntry>): void;
+    get(id: string): NetworkEntry | null;
+    query(options?: NetworkQueryOptions): NetworkEntry[];
+    getStats(): NetworkStats;
+    clear(): number;
+}

package/dist/networkBuffer.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkBuffer = void 0;
+class NetworkBuffer {
+    constructor(maxSize = 500) {
+        this.entries = new Map();
+        this.order = [];
+        this.maxSize = maxSize;
+    }
+    add(entry) {
+        if (this.entries.has(entry.id)) {
+            return;
+        }
+        if (this.order.length >= this.maxSize) {
+            const oldestId = this.order.shift();
+            this.entries.delete(oldestId);
+        }
+        this.entries.set(entry.id, entry);
+        this.order.push(entry.id);
+    }
+    update(id, updates) {
+        const entry = this.entries.get(id);
+        if (entry) {
+            Object.assign(entry, updates);
+        }
+    }
+    get(id) {
+        return this.entries.get(id) ?? null;
+    }
+    query(options) {
+        let results = Array.from(this.order)
+            .map((id) => this.entries.get(id))
+            .reverse();
+        if (options?.method) {
+            const method = options.method.toUpperCase();
+            results = results.filter((e) => e.method === method);
+        }
+        if (options?.urlPattern) {
+            const pattern = options.urlPattern.toLowerCase();
+            results = results.filter((e) => e.url.toLowerCase().includes(pattern));
+        }
+        if (options?.status != null) {
+            results = results.filter((e) => e.status === options.status);
+        }
+        if (options?.count != null && options.count > 0) {
+            results = results.slice(0, options.count);
+        }
+        return results;
+    }
+    getStats() {
+        const all = Array.from(this.entries.values());
+        const completed = all.filter((e) => e.completed && !e.error);
+        const errors = all.filter((e) => !!e.error);
+        const durations = completed
+            .map((e) => e.duration)
+            .filter((d) => d != null);
+        const avgDuration = durations.length > 0
+            ? durations.reduce((sum, d) => sum + d, 0) / durations.length
+            : null;
+        const byMethod = {};
+        for (const entry of all) {
+            byMethod[entry.method] = (byMethod[entry.method] || 0) + 1;
+        }
+        const byStatus = {};
+        for (const entry of all) {
+            if (entry.status != null) {
+                const group = `${Math.floor(entry.status / 100)}xx`;
+                byStatus[group] = (byStatus[group] || 0) + 1;
+            }
+        }
+        const byDomain = {};
+        for (const entry of all) {
+            try {
+                const domain = new URL(entry.url).hostname;
+                byDomain[domain] = (byDomain[domain] || 0) + 1;
+            }
+            catch {
+                // skip malformed URLs
+            }
+        }
+        return {
+            total: all.length,
+            completed: completed.length,
+            errors: errors.length,
+            avgDuration,
+            byMethod,
+            byStatus,
+            byDomain,
+        };
+    }
+    clear() {
+        const count = this.entries.size;
+        this.entries.clear();
+        this.order = [];
+        return count;
+    }
+}
+exports.NetworkBuffer = NetworkBuffer;

package/dist/networkInterceptor.d.ts

@@ -0,0 +1,3 @@
+import { NetworkBuffer } from './networkBuffer';
+export declare function patchFetch(buffer: NetworkBuffer): void;
+export declare function unpatchFetch(): void;

package/dist/networkInterceptor.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFetch = patchFetch;
+exports.unpatchFetch = unpatchFetch;
+let originalFetch = null;
+let idCounter = 0;
+function generateId() {
+    const random = Math.random().toString(36).substring(2, 6);
+    return `sdk-${random}-${++idCounter}`;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractHeaders(headers) {
+    const result = {};
+    if (!headers) {
+        return result;
+    }
+    if (typeof headers.forEach === 'function') {
+        headers.forEach((value, key) => {
+            result[key] = value;
+        });
+    }
+    else if (Array.isArray(headers)) {
+        for (const [key, value] of headers) {
+            result[key] = value;
+        }
+    }
+    else if (typeof headers === 'object') {
+        Object.assign(result, headers);
+    }
+    return result;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractBody(body) {
+    if (body == null) {
+        return undefined;
+    }
+    if (typeof body === 'string') {
+        return body;
+    }
+    return '[non-string body]';
+}
+function responseHeadersToRecord(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+function patchFetch(buffer) {
+    if (originalFetch) {
+        return;
+    }
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = async function patchedFetch(input, init) {
+        const id = generateId();
+        const startTime = Date.now();
+        let url;
+        let method;
+        let requestHeaders;
+        let requestBody;
+        try {
+            if (input instanceof Request) {
+                url = input.url;
+                method = (init?.method || input.method || 'GET').toUpperCase();
+                requestHeaders = extractHeaders(init?.headers ?? input.headers);
+                requestBody = extractBody(init?.body);
+            }
+            else {
+                url = typeof input === 'string' ? input : input.toString();
+                method = (init?.method || 'GET').toUpperCase();
+                requestHeaders = extractHeaders(init?.headers);
+                requestBody = extractBody(init?.body);
+            }
+        }
+        catch {
+            url = String(input);
+            method = 'GET';
+            requestHeaders = {};
+            requestBody = undefined;
+        }
+        const entry = {
+            id,
+            timestamp: startTime,
+            method,
+            url,
+            requestHeaders,
+            requestBody,
+            responseHeaders: {},
+            completed: false,
+        };
+        buffer.add(entry);
+        try {
+            const response = await originalFetch.call(globalThis, input, init);
+            const duration = Date.now() - startTime;
+            const responseHeaders = responseHeadersToRecord(response.headers);
+            const mimeType = response.headers.get('content-type') ?? undefined;
+            buffer.update(id, {
+                status: response.status,
+                statusText: response.statusText,
+                duration,
+                responseHeaders,
+                mimeType,
+                completed: true,
+            });
+            // Capture response body without consuming the original response
+            try {
+                response.clone().text().then((body) => {
+                    buffer.update(id, { responseBody: body });
+                }).catch(() => {
+                    // ignore body read failures
+                });
+            }
+            catch {
+                // ignore clone failures
+            }
+            return response;
+        }
+        catch (err) {
+            const duration = Date.now() - startTime;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            buffer.update(id, {
+                error: errorMessage,
+                duration,
+                completed: true,
+            });
+            throw err;
+        }
+    };
+}
+function unpatchFetch() {
+    if (originalFetch) {
+        globalThis.fetch = originalFetch;
+        originalFetch = null;
+    }
+    idCounter = 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+export interface InitOptions {
+    maxNetworkEntries?: number;
+    maxConsoleEntries?: number;
+    stores?: Record<string, unknown>;
+}
+export interface NetworkEntry {
+    id: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    status?: number;
+    statusText?: string;
+    duration?: number;
+    requestHeaders: Record<string, string>;
+    requestBody?: string;
+    responseHeaders: Record<string, string>;
+    responseBody?: string;
+    mimeType?: string;
+    error?: string;
+    completed: boolean;
+}
+export interface NetworkQueryOptions {
+    count?: number;
+    method?: string;
+    urlPattern?: string;
+    status?: number;
+}
+export interface NetworkStats {
+    total: number;
+    completed: number;
+    errors: number;
+    avgDuration: number | null;
+    byMethod: Record<string, number>;
+    byStatus: Record<string, number>;
+    byDomain: Record<string, number>;
+}
+export interface ConsoleEntry {
+    id: string;
+    timestamp: number;
+    level: 'log' | 'warn' | 'error' | 'info' | 'debug';
+    message: string;
+}
+export interface ConsoleQueryOptions {
+    count?: number;
+    level?: 'log' | 'warn' | 'error' | 'info' | 'debug';
+    text?: string;
+}
+export interface Capabilities {
+    network: boolean;
+    console: boolean;
+    stores: boolean;
+    render: boolean;
+}
+export interface DevToolsGlobal {
+    version: string;
+    capabilities: Capabilities;
+    stores: Record<string, unknown>;
+    getNetworkRequests: (options?: NetworkQueryOptions) => NetworkEntry[];
+    getNetworkRequest: (id: string) => NetworkEntry | null;
+    getNetworkStats: () => NetworkStats;
+    clearNetwork: () => number;
+    getConsoleLogs: (options?: ConsoleQueryOptions) => ConsoleEntry[];
+    clearConsole: () => number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "react-native-ai-devtools-sdk",
+  "version": "0.2.0",
+  "description": "Lightweight SDK for react-native-ai-devtools — captures network requests for AI-powered debugging",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --config jest.config.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["react-native", "debugging", "ai", "network", "mcp"],
+  "author": "Ihor Zheludkov",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "jest": "^30.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": ["dist", "README.md", "LICENSE"]
+}