react-native-debug-toolkit 3.0.0 → 3.1.3

package/node/mcp/src/index.js

@@ -2,14 +2,14 @@
 
 const { ensureDaemon } = require('./daemonClient');
 const { handleMessage, startStdioServer } = require('./server');
-const { callTool, getAppLogsTool, listAppSessionsTool, tools } = require('./tools');
+const { callTool, getAppLogsTool, listAppDevicesTool, tools } = require('./tools');
 
 module.exports = {
   callTool,
   ensureDaemon,
   getAppLogsTool,
   handleMessage,
-  listAppSessionsTool,
+  listAppDevicesTool,
   startStdioServer,
   tools,
 };

package/node/mcp/src/logs.js

@@ -70,14 +70,15 @@ function selectLogs(report, options = {}) {
   }));
 }
 
-function createToolPayload(session, options = {}) {
-  const report = session.report || { version: 2, logs: {} };
+function createToolPayload(device, options = {}) {
+  const report = device.report || { version: 2, logs: {} };
   const logs = selectLogs(report, options);
 
   return {
     ok: true,
-    sessionId: session.sessionId,
-    receivedAt: session.receivedAt,
+    deviceId: device.deviceId,
+    receivedAt: device.receivedAt,
+    lastSeenAt: device.lastSeenAt,
     logType: options.logType || 'all',
     failedOnly: options.failedOnly === true,
     includeBodies: options.includeBodies !== false,

package/node/mcp/src/tools.js

@@ -1,15 +1,15 @@
 'use strict';
 
-const { getDaemonOrigin, readSession, readSessions } = require('./daemonClient');
+const { getDaemonOrigin, readDevice, readDevices } = require('./daemonClient');
 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/sessions/latest is more efficient.',
+  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.',
   inputSchema: {
     type: 'object',
     properties: {
-      sessionId: { type: 'string' },
+      deviceId: { type: 'string' },
       logType: {
         type: 'string',
         enum: KNOWN_LOG_TYPES,
@@ -21,16 +21,16 @@ const getAppLogsTool = {
   },
 };
 
-const listAppSessionsTool = {
-  name: 'list_app_sessions',
-  description: 'List React Native Debug Toolkit sessions available in the local daemon. Tip: if you have shell access, curl http://127.0.0.1:3799/sessions is more efficient.',
+const listAppDevicesTool = {
+  name: 'list_app_devices',
+  description: 'List React Native Debug Toolkit devices available in the local daemon. Tip: if you have shell access, curl http://127.0.0.1:3799/devices is more efficient.',
   inputSchema: {
     type: 'object',
     properties: {},
   },
 };
 
-const tools = [getAppLogsTool, listAppSessionsTool];
+const tools = [getAppLogsTool, listAppDevicesTool];
 
 async function callTool(name, args = {}, context = {}) {
   const ensureDaemon = context.ensureDaemon || (async () => ({ ok: true, origin: getDaemonOrigin() }));
@@ -44,15 +44,15 @@ async function callTool(name, args = {}, context = {}) {
   }
 
   try {
-    if (name === listAppSessionsTool.name) {
-      const readSessionsImpl = context.readSessions || readSessions;
-      const result = await readSessionsImpl(daemon.origin);
-      const sessions = Array.isArray(result.sessions) ? result.sessions : [];
+    if (name === listAppDevicesTool.name) {
+      const readDevicesImpl = context.readDevices || readDevices;
+      const result = await readDevicesImpl(daemon.origin);
+      const devices = Array.isArray(result.devices) ? result.devices : [];
       return {
         ok: true,
         origin: daemon.origin,
-        sessions,
-        count: sessions.length,
+        devices,
+        count: devices.length,
       };
     }
 
@@ -60,8 +60,8 @@ async function callTool(name, args = {}, context = {}) {
       throw new Error(`Unknown tool: ${name}`);
     }
 
-    const session = await readSession(daemon.origin, args.sessionId);
-    return createToolPayload(session, {
+    const device = await readDevice(daemon.origin, args.deviceId);
+    return createToolPayload(device, {
       logType: args.logType,
       limit: args.limit,
       failedOnly: args.failedOnly,
@@ -79,6 +79,6 @@ async function callTool(name, args = {}, context = {}) {
 module.exports = {
   callTool,
   getAppLogsTool,
-  listAppSessionsTool,
+  listAppDevicesTool,
   tools,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-debug-toolkit",
-  "version": "3.0.0",
-  "description": "A dev-only floating debug panel for React Native with network, console, Zustand, navigation, and event logs",
+  "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",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
   "types": "lib/typescript/src/index.d.ts",

package/src/core/initialize.ts

@@ -11,10 +11,16 @@ 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 type { AnyDebugFeature, BuiltInFeatureName } from '../types';
 
 const isDebugMode = __DEV__;
 
+daemonClient.setEndpointDetector((url) => {
+  _addDaemonEndpointToNetworkBlacklist(url);
+});
+
 /** Feature-specific configuration map */
 export interface FeatureConfigs {
   network?: boolean | NetworkFeatureConfig;
@@ -114,6 +120,8 @@ export function initializeDebugToolkit(
       DebugToolkit.hideLauncher();
     }
 
+    restoreDaemonStreaming().catch(() => {});
+
     return DebugToolkit;
   } catch (error) {
     console.error('[DebugToolkit] Initialization failed:', error);

package/src/index.ts

@@ -28,20 +28,28 @@ export { useNavigationLogger } from './features/navigation/useNavigationLogger';
 export { safeStringify } from './utils/safeStringify';
 export { copyToComputer, logToComputer, fmt } from './utils/copyToComputer';
 export type { CopyResult, CopyOptions, CopyMethod } from './utils/copyToComputer';
-export { createDebugSessionReport } from './utils/sessionReport';
-export type { DebugSessionReport, DebugSessionReportOptions } from './utils/sessionReport';
-export { getDefaultDaemonEndpoint, reportDebugSessionToDaemon } from './utils/reportToDaemon';
-export type { ReportResult, ReportToDaemonOptions } from './utils/reportToDaemon';
-export { checkDaemonConnection } from './utils/daemonConnection';
+export { createDebugDeviceReport } from './utils/deviceReport';
+export type { DebugDeviceReport, DebugDeviceReportOptions } from './utils/deviceReport';
+export { DaemonClient, daemonClient } from './utils/DaemonClient';
 export type {
+  DaemonSettings,
+  DaemonConnectionMode,
   DaemonConnectionFailureReason,
   DaemonConnectionOptions,
   DaemonConnectionResult,
-} from './utils/daemonConnection';
-export { startStreaming, stopStreaming, isStreaming } from './utils/streamToDaemon';
-export type { StreamStatus, StreamToDaemonOptions } from './utils/streamToDaemon';
-export { autoDetectDaemonIp, getMetroHost } from './utils/autoDetectDaemon';
-export type { AutoDetectOptions, AutoDetectResult } from './utils/autoDetectDaemon';
+  StreamStatus,
+  StreamToDaemonOptions,
+  ReportResult,
+  ReportToDaemonOptions,
+} from './utils/DaemonClient';
+export {
+  getDefaultDaemonEndpoint,
+  reportDebugDeviceToDaemon,
+  checkDaemonConnection,
+  startStreaming,
+  stopStreaming,
+  isStreaming,
+} from './utils/DaemonClient';
 
 // Types
 export type {

package/src/ui/panel/StreamingSettingsModal.tsx

@@ -13,17 +13,13 @@ import {
 } from 'react-native';
 import { Colors } from '../theme/colors';
 import {
-  buildDeviceDaemonEndpoint,
+  daemonClient,
   type DaemonConnectionMode,
   type DaemonSettings,
-  loadDaemonSettings,
+  buildDeviceDaemonEndpoint,
   normalizeDaemonSettings,
-  saveDaemonSettings,
-} from '../../utils/daemonSettings';
-import { checkDaemonConnection } from '../../utils/daemonConnection';
-import { getDefaultDaemonEndpoint, reportDebugSessionToDaemon } from '../../utils/reportToDaemon';
-import { autoDetectDaemonIp, getMetroHost } from '../../utils/autoDetectDaemon';
-import { startStreaming, stopStreaming, isStreaming } from '../../utils/streamToDaemon';
+  getDefaultDaemonEndpoint,
+} from '../../utils/DaemonClient';
 
 interface StreamingSettingsModalProps {
   visible: boolean;
@@ -42,11 +38,10 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
   const inputRef = useRef<TextInput>(null);
   const [mode, setMode] = useState<DaemonConnectionMode>('simulator');
   const [deviceHost, setDeviceHost] = useState('');
-  const [streaming, setStreaming] = useState(isStreaming());
-  const [syncState, setSyncState] = useState<SyncUiState>(isStreaming() ? 'running' : 'idle');
+  const [streaming, setStreaming] = useState(daemonClient.isConnected());
+  const [syncState, setSyncState] = useState<SyncUiState>(daemonClient.isConnected() ? 'running' : 'idle');
   const [message, setMessage] = useState<string | null>(null);
   const [sending, setSending] = useState(false);
-  const [detecting, setDetecting] = useState(false);
 
   const handleDeviceHostChange = useCallback((value: string) => {
     setDeviceHost(value);
@@ -57,44 +52,19 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
   }, [syncState]);
 
   const detectDeviceHost = useCallback(async () => {
-    setDetecting(true);
-    setMessage('Detecting desktop...');
-    const result = await autoDetectDaemonIp({
-      timeoutMs: 800,
-      scanSubnets: false,
-    });
-    setDetecting(false);
-
-    if (result.ip) {
-      setDeviceHost((current) => current.trim() ? current : result.ip || current);
-      setMessage(`Detected desktop at ${buildDeviceDaemonEndpoint(result.ip)}.`);
-      return;
-    }
-
     setMessage('Enter your Mac IP, or open /health on the phone browser to verify reachability.');
   }, []);
 
   useEffect(() => {
     if (visible) {
-      loadDaemonSettings().then((settings) => {
-        setMode(settings.mode);
-        const savedHost = settings.deviceHost;
-        if (settings.mode === 'device' && !savedHost) {
-          const metroHost = getMetroHost();
-          if (metroHost) {
-            setDeviceHost(metroHost);
-          } else {
-            detectDeviceHost();
-          }
-        } else {
-          setDeviceHost(savedHost);
-        }
-      });
+      const settings = daemonClient.getSettings();
+      setMode(settings.mode);
+      setDeviceHost(settings.deviceHost);
     }
-  }, [detectDeviceHost, visible]);
+  }, [visible]);
 
   useEffect(() => {
-    const active = isStreaming();
+    const active = daemonClient.isConnected();
     setStreaming(active);
     setSyncState(active ? 'running' : 'idle');
   }, [visible]);
@@ -116,19 +86,12 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
 
   const handleModeChange = useCallback((nextMode: DaemonConnectionMode) => {
     setMode(nextMode);
-    if (nextMode === 'device' && !deviceHost) {
-      const metroHost = getMetroHost();
-      if (metroHost) {
-        setDeviceHost(metroHost);
-      } else {
-        detectDeviceHost();
-      }
-    }
-  }, [detectDeviceHost, deviceHost]);
+  }, []);
 
   const toggleLiveSync = useCallback(async () => {
     if (streaming) {
-      stopStreaming();
+      daemonClient.disconnect();
+      daemonClient.setStreamingEnabled(false);
       setStreaming(false);
       setSyncState('idle');
       setMessage(null);
@@ -143,9 +106,9 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
     const daemonOptions = normalizeDaemonSettings(settings);
     setMessage('Checking desktop connection...');
     setSyncState('connecting');
-    await saveDaemonSettings(settings);
+    daemonClient.configure(settings);
 
-    const connection = await checkDaemonConnection({
+    const connection = await daemonClient.checkConnection({
       ...daemonOptions,
       timeoutMs: CONNECTION_TIMEOUT_MS,
     });
@@ -156,7 +119,8 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
       return;
     }
 
-    startStreaming({
+    daemonClient.setStreamingEnabled(true);
+    daemonClient.connect({
       ...daemonOptions,
       timeoutMs: 3000,
       onStatus: (status) => {
@@ -191,10 +155,10 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
     const daemonOptions = normalizeDaemonSettings(settings);
     setSending(true);
     setMessage('Checking desktop connection...');
-    await saveDaemonSettings(settings);
+    daemonClient.configure(settings);
 
     try {
-      const connection = await checkDaemonConnection({
+      const connection = await daemonClient.checkConnection({
         ...daemonOptions,
         timeoutMs: CONNECTION_TIMEOUT_MS,
       });
@@ -204,7 +168,7 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
       }
 
       setMessage('Sending logs...');
-      const result = await reportDebugSessionToDaemon({
+      const result = await daemonClient.reportOnce({
         ...daemonOptions,
         timeoutMs: 2000,
       });
@@ -225,12 +189,10 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
     : getDefaultDaemonEndpoint();
   const canConnect = mode === 'simulator' || Boolean(deviceHost.trim());
   const connecting = !streaming && syncState === 'connecting';
-  const busy = detecting || sending || connecting;
-  const statusTitle = detecting
+  const busy = sending || connecting;
+  const statusTitle = sending
     ? 'Checking'
-    : sending
-      ? 'Checking'
-      : connecting
+    : connecting
         ? 'Checking'
         : streaming && syncState === 'connected'
       ? 'Live sync connected'
@@ -324,7 +286,7 @@ export function StreamingSettingsModal({ visible, onClose }: StreamingSettingsMo
                       disabled={streaming || busy}
                       activeOpacity={0.7}
                     >
-                      <Text style={styles.detectButtonText}>{detecting ? '...' : 'Detect'}</Text>
+                      <Text style={styles.detectButtonText}>?</Text>
                     </TouchableOpacity>
                   </View>
                 </View>