react-native-debug-toolkit 3.1.2 → 3.1.4

package/node/daemon/src/server.js

@@ -140,6 +140,25 @@ function toDevicePayload(deviceLog) {
   };
 }
 
+function stripBodies(value, parentKey) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripBodies(item, parentKey));
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  return Object.entries(value).reduce((acc, [key, child]) => {
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey === 'body' || (parentKey === 'response' && normalizedKey === 'data')) {
+      return acc;
+    }
+    acc[key] = stripBodies(child, normalizedKey);
+    return acc;
+  }, {});
+}
+
 function selectLogs(deviceLog, searchParams) {
   if (!deviceLog) {
     return [];
@@ -150,6 +169,8 @@ function selectLogs(deviceLog, searchParams) {
   const limit = Number.isFinite(limitParam) && limitParam > 0
     ? Math.min(Math.floor(limitParam), 500)
     : 50;
+  const entryId = searchParams.get('entryId');
+  const includeBodies = entryId ? true : searchParams.get('includeBodies') === 'true';
   const failedOnly = searchParams.get('failedOnly') === 'true';
   const logs = deviceLog.report.logs || {};
 
@@ -160,7 +181,12 @@ function selectLogs(deviceLog, searchParams) {
     entries = Object.values(logs).flatMap((value) => Array.isArray(value) ? value : []);
   }
 
-  if (failedOnly) {
+  if (entryId) {
+    entries = entries.filter((entry) => (
+      entry && typeof entry === 'object' &&
+      (entry.id === entryId || entry.id === Number(entryId))
+    ));
+  } else if (failedOnly) {
     entries = entries.filter((entry) => (
       entry &&
       typeof entry === 'object' &&
@@ -173,7 +199,11 @@ function selectLogs(deviceLog, searchParams) {
     ));
   }
 
-  return entries.slice(-limit);
+  if (!entryId) {
+    entries = entries.slice(-limit);
+  }
+
+  return includeBodies ? entries : entries.map(stripBodies);
 }
 
 function broadcastSSE(clients, eventType, deviceLog, delta) {

package/node/mcp/src/logs.js

@@ -40,7 +40,8 @@ function selectLogs(report, options = {}) {
   const limit = Number.isFinite(options.limit) && options.limit > 0
     ? Math.min(Math.floor(options.limit), 200)
     : 50;
-  const includeBodies = options.includeBodies !== false;
+  const entryId = options.entryId;
+  const includeBodies = entryId ? true : options.includeBodies === true;
   const failedOnly = options.failedOnly === true;
 
   let entries;
@@ -54,11 +55,18 @@ function selectLogs(report, options = {}) {
     ));
   }
 
-  if (failedOnly) {
+  if (entryId) {
+    entries = entries.filter((item) => {
+      const e = item.entry || item;
+      return e.id === entryId || e.id === Number(entryId);
+    });
+  } else if (failedOnly) {
     entries = entries.filter((item) => isFailedLog(item.entry || item));
   }
 
-  entries = entries.slice(-limit);
+  if (!entryId) {
+    entries = entries.slice(-limit);
+  }
 
   if (logType) {
     return includeBodies ? entries : entries.map(stripBodies);
@@ -72,6 +80,8 @@ function selectLogs(report, options = {}) {
 
 function createToolPayload(device, options = {}) {
   const report = device.report || { version: 2, logs: {} };
+  const entryId = options.entryId;
+  const includeBodies = entryId ? true : options.includeBodies === true;
   const logs = selectLogs(report, options);
 
   return {
@@ -81,7 +91,8 @@ function createToolPayload(device, options = {}) {
     lastSeenAt: device.lastSeenAt,
     logType: options.logType || 'all',
     failedOnly: options.failedOnly === true,
-    includeBodies: options.includeBodies !== false,
+    includeBodies,
+    entryId: entryId || undefined,
     count: logs.length,
     logs,
   };

package/node/mcp/src/tools.js

@@ -5,7 +5,7 @@ const { KNOWN_LOG_TYPES, createToolPayload } = require('./logs');
 
 const getAppLogsTool = {
   name: 'get_app_logs',
-  description: 'Read React Native Debug Toolkit logs from the local daemon. Tip: if you have shell access, curl http://127.0.0.1:3799/devices/latest is more efficient.',
+  description: 'Read React Native Debug Toolkit logs from the local daemon. Bodies are excluded by default to reduce token usage; set includeBodies=true or pass an entryId to fetch details. Tip: if you have shell access, curl http://127.0.0.1:3799/devices/latest/logs?includeBodies=true is more efficient.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -16,7 +16,8 @@ const getAppLogsTool = {
       },
       limit: { type: 'number', default: 50 },
       failedOnly: { type: 'boolean', default: false },
-      includeBodies: { type: 'boolean', default: true },
+      includeBodies: { type: 'boolean', default: false },
+      entryId: { type: 'string', description: 'Fetch a single entry by ID; forces includeBodies=true' },
     },
   },
 };
@@ -66,6 +67,7 @@ async function callTool(name, args = {}, context = {}) {
       limit: args.limit,
       failedOnly: args.failedOnly,
       includeBodies: args.includeBodies,
+      entryId: args.entryId,
     });
   } catch (error) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-debug-toolkit",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "description": "A local-first React Native debugging bridge with in-app logs, desktop daemon, Web Console, HTTP API, and MCP support",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/src/core/DebugToolkit.tsx

@@ -1,176 +1,190 @@
-import type { AnyDebugFeature } from '../types';
+import type { AnyDebugFeature, DebugFeatureListener, FeatureDataProvider } from '../types';
 
-type Listener = () => void;
+class DebugToolkitCore implements FeatureDataProvider {
+  private _features: AnyDebugFeature[] = [];
+  private _launcherVisible = false;
+  private _panelOpen = false;
+  private _enabled = true;
+  private _listeners = new Set<DebugFeatureListener>();
 
-const listeners = new Set<Listener>();
-let _features: AnyDebugFeature[] = [];
-let _launcherVisible = false;
-let _panelOpen = false;
-let _enabled = true;
+  private notify(): void {
+    this._listeners.forEach((l) => l());
+  }
 
-function notify(): void {
-  listeners.forEach((l) => l());
-}
-
-function setupFeature(feature: AnyDebugFeature): void {
-  feature.setup?.();
-}
+  // --- FeatureDataProvider ---
 
-function cleanupFeature(feature: AnyDebugFeature): void {
-  feature.cleanup?.();
-}
+  get features(): AnyDebugFeature[] {
+    return [...this._features];
+  }
 
-export const DebugToolkit = {
-  subscribe(listener: Listener): () => void {
-    listeners.add(listener);
+  subscribe(listener: DebugFeatureListener): () => void {
+    this._listeners.add(listener);
     return () => {
-      listeners.delete(listener);
+      this._listeners.delete(listener);
     };
-  },
+  }
 
-  get features(): AnyDebugFeature[] {
-    return [..._features];
-  },
+  // --- Enabled ---
 
   get enabled(): boolean {
-    return _enabled;
-  },
-
-  get launcherVisible(): boolean {
-    return _launcherVisible;
-  },
+    return this._enabled;
+  }
 
   setEnabled(enabled: boolean): void {
-    if (_enabled === enabled) return;
-    _enabled = enabled;
+    if (this._enabled === enabled) return;
+    this._enabled = enabled;
     if (!enabled) {
-      _launcherVisible = false;
-      _features.forEach(cleanupFeature);
-      _features = [];
+      this._launcherVisible = false;
+      this._features.forEach((f) => f.cleanup?.());
+      this._features = [];
     }
-    notify();
-  },
+    this.notify();
+  }
+
+  // --- Feature Management ---
 
   replaceFeatures(features: AnyDebugFeature[]): void {
-    if (!_enabled) return;
+    if (!this._enabled) return;
     const next = features.filter(
       (f, i, arr) =>
         f && typeof f.name === 'string' && arr.findIndex((item) => item.name === f.name) === i,
     );
-    const prevMap = new Map(_features.map((f) => [f.name, f]));
+    const prevMap = new Map(this._features.map((f) => [f.name, f]));
     const nextMap = new Map(next.map((f) => [f.name, f]));
 
-    _features.forEach((f) => {
-      if (!nextMap.get(f.name) || nextMap.get(f.name) !== f) cleanupFeature(f);
+    this._features.forEach((f) => {
+      if (!nextMap.get(f.name) || nextMap.get(f.name) !== f) f.cleanup?.();
     });
     next.forEach((f) => {
-      if (!prevMap.get(f.name) || prevMap.get(f.name) !== f) setupFeature(f);
+      if (!prevMap.get(f.name) || prevMap.get(f.name) !== f) f.setup?.();
     });
 
-    _features = next;
-    notify();
-  },
+    this._features = next;
+    this.notify();
+  }
 
   addFeature(feature: AnyDebugFeature): void {
-    if (!_enabled || !feature || typeof feature.name !== 'string') {
+    if (!this._enabled || !feature || typeof feature.name !== 'string') {
       return;
     }
 
-    const existingIndex = _features.findIndex((f) => f.name === feature.name);
+    const existingIndex = this._features.findIndex((f) => f.name === feature.name);
     if (existingIndex >= 0) {
-      const existing = _features[existingIndex]!;
+      const existing = this._features[existingIndex]!;
       if (existing === feature) {
         return;
       }
 
-      cleanupFeature(existing);
-      setupFeature(feature);
-      _features = [
-        ..._features.slice(0, existingIndex),
+      existing.cleanup?.();
+      feature.setup?.();
+      this._features = [
+        ...this._features.slice(0, existingIndex),
         feature,
-        ..._features.slice(existingIndex + 1),
+        ...this._features.slice(existingIndex + 1),
       ];
-      notify();
+      this.notify();
       return;
     }
 
-    setupFeature(feature);
-    _features = [..._features, feature];
-    notify();
-  },
+    feature.setup?.();
+    this._features = [...this._features, feature];
+    this.notify();
+  }
 
   removeFeature(name: string): void {
-    if (!_enabled) {
+    if (!this._enabled) {
       return;
     }
 
-    const feature = _features.find((f) => f.name === name);
+    const feature = this._features.find((f) => f.name === name);
     if (!feature) {
       return;
     }
 
-    cleanupFeature(feature);
-    _features = _features.filter((f) => f.name !== name);
-    if (_features.length === 0) {
-      _launcherVisible = false;
+    feature.cleanup?.();
+    this._features = this._features.filter((f) => f.name !== name);
+    if (this._features.length === 0) {
+      this._launcherVisible = false;
     }
-    notify();
-  },
-
-  reset(): void {
-    _launcherVisible = false;
-    _panelOpen = false;
-    _features.forEach(cleanupFeature);
-    _features = [];
-    notify();
-  },
+    this.notify();
+  }
 
   hasFeatures(): boolean {
-    return _features.length > 0;
-  },
+    return this._features.length > 0;
+  }
+
+  // --- Panel ---
 
   get panelOpen(): boolean {
-    return _panelOpen;
-  },
+    return this._panelOpen;
+  }
 
   openPanel(): void {
-    if (!_enabled || _panelOpen) return;
-    _panelOpen = true;
-    notify();
-  },
+    if (!this._enabled || this._panelOpen) return;
+    this._panelOpen = true;
+    this.notify();
+  }
 
   closePanel(): void {
-    if (!_panelOpen) return;
-    _panelOpen = false;
-    notify();
-  },
+    if (!this._panelOpen) return;
+    this._panelOpen = false;
+    this.notify();
+  }
 
   togglePanel(): void {
-    if (_panelOpen) {
-      DebugToolkit.closePanel();
+    if (this._panelOpen) {
+      this.closePanel();
     } else {
-      DebugToolkit.openPanel();
+      this.openPanel();
     }
-  },
+  }
+
+  // --- Launcher ---
+
+  get launcherVisible(): boolean {
+    return this._launcherVisible;
+  }
 
   showLauncher(): void {
-    if (!_enabled) return;
-    _launcherVisible = true;
-    notify();
-  },
+    if (!this._enabled) return;
+    this._launcherVisible = true;
+    this.notify();
+  }
 
   hideLauncher(): void {
-    _launcherVisible = false;
-    notify();
-  },
+    if (!this._launcherVisible) return;
+    this._launcherVisible = false;
+    this.notify();
+  }
+
+  // --- Bulk Operations ---
 
   clearAll(): void {
-    _features.forEach((f) => f.clear?.());
-    notify();
-  },
+    this._features.forEach((f) => f.clear?.());
+    this.notify();
+  }
+
+  reset(): void {
+    this._launcherVisible = false;
+    this._panelOpen = false;
+    this._features.forEach((f) => f.cleanup?.());
+    this._features = [];
+    this.notify();
+  }
 
   destroy(): void {
-    DebugToolkit.reset();
-    listeners.clear();
-  },
-};
+    this.reset();
+    this._listeners.clear();
+  }
+}
+
+/** Module-level default instance for non-React scenarios and backward compatibility. */
+export const debugToolkit = new DebugToolkitCore();
+
+export type DebugToolkit = DebugToolkitCore;
+
+/**
+ * @deprecated Use `debugToolkit` or get instance from `initializeDebugToolkit()`.
+ * This is the default module-level instance exported for backward compatibility.
+ */
+export const DebugToolkit = debugToolkit;

package/src/core/initialize.ts

@@ -1,5 +1,5 @@
 import { DebugToolkit } from './DebugToolkit';
-import { createNetworkFeature } from '../features/network';
+import { createNetworkFeature, addToBlacklist } from '../features/network';
 import type { NetworkFeatureConfig } from '../features/network';
 import { createConsoleLogFeature } from '../features/console';
 import type { ConsoleFeatureConfig } from '../features/console';
@@ -11,16 +11,11 @@ import { createTrackFeature } from '../features/track';
 import type { TrackFeatureConfig } from '../features/track';
 import { createEnvironmentFeature } from '../features/environment';
 import { createClipboardFeature } from '../features/clipboard';
-import { daemonClient, restoreDaemonStreaming } from '../utils/DaemonClient';
-import { _addDaemonEndpointToNetworkBlacklist } from '../features/network';
+import { daemonClient } from '../utils/DaemonClient';
 import type { AnyDebugFeature, BuiltInFeatureName } from '../types';
 
 const isDebugMode = __DEV__;
 
-daemonClient.setEndpointDetector((url) => {
-  _addDaemonEndpointToNetworkBlacklist(url);
-});
-
 /** Feature-specific configuration map */
 export interface FeatureConfigs {
   network?: boolean | NetworkFeatureConfig;
@@ -114,13 +109,17 @@ export function initializeDebugToolkit(
 
     DebugToolkit.replaceFeatures(resolvedFeatures);
 
+    daemonClient.setEndpointDetector((url) => {
+      addToBlacklist(url);
+    });
+
     if (DebugToolkit.hasFeatures()) {
       DebugToolkit.showLauncher();
     } else {
       DebugToolkit.hideLauncher();
     }
 
-    restoreDaemonStreaming().catch(() => {});
+    daemonClient.restore().catch(() => {});
 
     return DebugToolkit;
   } catch (error) {

package/src/features/environment/index.ts

@@ -5,7 +5,7 @@ import type {
   EnvironmentConfig,
   EnvironmentState,
 } from '../../types';
-import { urlRewriter } from '../../utils/urlRewriterRegistry';
+import { setUrlRewriter } from '../../utils/urlRewriter';
 
 // Lazy AsyncStorage loader
 type AsyncStorageModule = {
@@ -32,10 +32,6 @@ function getAsyncStorage(): AsyncStorageModule | null {
 
 const STORAGE_KEY = 'debug_toolkit_env_id';
 
-// Module-level state for synchronous URL rewriting
-let currentHostsMap: Map<string, string> | null = null;
-let activeEnvironmentId: string | null = null;
-
 function buildHostsMap(
   environments: EnvironmentConfig[],
   targetId: string | null,
@@ -53,24 +49,6 @@ function buildHostsMap(
   return map;
 }
 
-function createUrlRewriter(): (url: string) => string {
-  return (url: string): string => {
-    if (!currentHostsMap) return url;
-
-    try {
-      const parsed = new URL(url);
-      const targetHost = currentHostsMap.get(parsed.host);
-      if (targetHost) {
-        return url.replace(parsed.host, targetHost);
-      }
-    } catch {
-      // Not a valid URL or relative URL — return unchanged
-    }
-
-    return url;
-  };
-}
-
 export interface EnvironmentFeatureAPI extends DebugFeature<EnvironmentState> {
   registerEnvironments: (environments: EnvironmentConfig[]) => void;
   switchEnvironment: (environmentId: string | null) => void;
@@ -83,6 +61,26 @@ export const createEnvironmentFeature = (
   const listeners = new Set<DebugFeatureListener>();
   let environments: EnvironmentConfig[] = initialEnvironments ?? [];
   let initialized = false;
+  let currentHostsMap: Map<string, string> | null = null;
+  let activeEnvironmentId: string | null = null;
+
+  const createUrlRewriter = (): ((url: string) => string) => {
+    return (url: string): string => {
+      if (!currentHostsMap) return url;
+
+      try {
+        const parsed = new URL(url);
+        const targetHost = currentHostsMap.get(parsed.host);
+        if (targetHost) {
+          return url.replace(parsed.host, targetHost);
+        }
+      } catch {
+        // Not a valid URL or relative URL — return unchanged
+      }
+
+      return url;
+    };
+  };
 
   const getCurrentState = (): EnvironmentState => ({
     environments,
@@ -102,9 +100,9 @@ export const createEnvironmentFeature = (
     if (initialized) {
       try {
         if (envId && environments.length > 0) {
-          urlRewriter.set(createUrlRewriter());
+          setUrlRewriter(createUrlRewriter());
         } else {
-          urlRewriter.set(null);
+          setUrlRewriter(null);
         }
       } catch (err) {
         if (__DEV__) console.warn('[DebugToolkit] Failed to set URL rewriter:', err);
@@ -149,7 +147,7 @@ export const createEnvironmentFeature = (
 
       // Install rewriter if an environment is already selected
       if (activeEnvironmentId && environments.length > 0) {
-        urlRewriter.set(createUrlRewriter());
+        setUrlRewriter(createUrlRewriter());
       }
 
       // Async persistence load (will override if a preference exists)
@@ -162,7 +160,7 @@ export const createEnvironmentFeature = (
     },
     cleanup: () => {
       if (!initialized) return;
-      urlRewriter.set(null);
+      setUrlRewriter(null);
       activeEnvironmentId = null;
       currentHostsMap = null;
       notify();