react-native-debug-toolkit 3.1.3 → 3.1.5

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/daemon/src/store.js

@@ -28,15 +28,33 @@ function slugPart(value) {
     .slice(0, 80) || 'unknown';
 }
 
+function ipTail(ip) {
+  if (!ip || typeof ip !== 'string') return '0';
+  const parts = ip.split('.');
+  return parts.length >= 2 ? parts[parts.length - 1] : slugPart(ip);
+}
+
+function isSimulatorIp(ip) {
+  return ip === '127.0.0.1' || ip === '::1' || ip === '10.0.2.2' || ip === 'localhost';
+}
+
 function createDeviceId(report, source) {
   const device = report && typeof report === 'object' && report.device && typeof report.device === 'object'
     ? report.device
     : {};
-  return [
-    slugPart(device.platform),
-    slugPart(device.model),
-    slugPart(source && source.ip),
-  ].join('_');
+  const platform = slugPart(device.platform);
+  const ip = source && source.ip ? String(source.ip) : '';
+  const sim = isSimulatorIp(ip);
+  let model = slugPart(device.model);
+  if (model === 'unknown' && platform !== 'unknown') {
+    model = sim ? 'sim' : 'device';
+  }
+  const ver = device.appVersion ? slugPart(device.appVersion) : '';
+  const tail = sim ? 'sim' : ipTail(ip);
+  const parts = [platform, model];
+  if (ver && ver !== 'unknown') parts.push(ver);
+  parts.push(tail);
+  return parts.join('_');
 }
 
 function readPersistedDevices(storagePath, maxDevices) {
@@ -92,6 +110,18 @@ function createMemoryStore(options = {}) {
     const deviceId = createDeviceId(report, source);
     const existingIndex = devices.findIndex((item) => item.deviceId === deviceId);
     const existing = existingIndex >= 0 ? devices[existingIndex] : null;
+    const reportSessionId = report.session ? report.session.id : null;
+    if (reportSessionId && report.logs) {
+      Object.entries(report.logs).forEach(function(pair) {
+        if (!Array.isArray(pair[1])) return;
+        report.logs[pair[0]] = pair[1].map(function(entry) {
+          if (entry && typeof entry === 'object' && !entry.sessionId) {
+            return Object.assign({}, entry, { sessionId: reportSessionId });
+          }
+          return entry;
+        });
+      });
+    }
     const deviceLog = {
       deviceId,
       firstSeenAt: existing ? existing.firstSeenAt : receivedAt,
@@ -99,6 +129,7 @@ function createMemoryStore(options = {}) {
       receivedAt,
       source,
       device: report.device || null,
+      session: report.session || null,
       report,
       logCount: createLogCount(report),
     };
@@ -124,6 +155,7 @@ function createMemoryStore(options = {}) {
     }
 
     const deltaLogs = (delta && delta.logs) || {};
+    const currentSessionId = deviceLog.session ? deviceLog.session.id : null;
     Object.entries(deltaLogs).forEach(([type, entries]) => {
       if (!Array.isArray(entries)) {
         return;
@@ -131,7 +163,13 @@ function createMemoryStore(options = {}) {
       if (!deviceLog.report.logs[type]) {
         deviceLog.report.logs[type] = [];
       }
-      deviceLog.report.logs[type].push(...entries);
+      const tagged = entries.map(function(entry) {
+        if (entry && typeof entry === 'object' && currentSessionId && !entry.sessionId) {
+          return Object.assign({}, entry, { sessionId: currentSessionId });
+        }
+        return entry;
+      });
+      deviceLog.report.logs[type].push(...tagged);
     });
 
     deviceLog.lastSeenAt = new Date(Date.now()).toISOString();
@@ -153,6 +191,7 @@ function createMemoryStore(options = {}) {
         receivedAt: deviceLog.receivedAt,
         device: deviceLog.device || null,
         source: deviceLog.source || null,
+        session: deviceLog.session || null,
         logCount: deviceLog.logCount,
       }));
   }

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,7 +1,7 @@
 {
   "name": "react-native-debug-toolkit",
-  "version": "3.1.3",
-  "description": "A local-first React Native debugging bridge with in-app logs, desktop daemon, Web Console, HTTP API, and MCP support",
+  "version": "3.1.5",
+  "description": "A local-first React Native debug toolkit with Web Console, HTTP API, and MCP support for AI-readable app logs",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
   "types": "lib/typescript/src/index.d.ts",
@@ -30,8 +30,12 @@
   "keywords": [
     "react-native",
     "debug",
+    "log-bridge",
+    "web-console",
+    "ai-debugging",
     "toolkit",
     "http-inspector",
+    "mcp",
     "development-tools",
     "floating-panel"
   ],

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) {