react-native-debug-toolkit 2.3.0 → 3.0.0

package/src/utils/autoDetectDaemon.ts

@@ -0,0 +1,175 @@
+import { NativeModules } from 'react-native';
+
+export interface AutoDetectOptions {
+  port?: number;
+  timeoutMs?: number;
+  batchSize?: number;
+  scanSubnets?: boolean;
+  signal?: AbortSignal;
+}
+
+export type AutoDetectMethod = 'metro-bundle' | 'network-info' | 'subnet-common' | 'none';
+
+export interface AutoDetectResult {
+  ip: string | null;
+  method: AutoDetectMethod;
+}
+
+const DEFAULT_PORT = 3799;
+const PROBE_TIMEOUT_MS = 1500;
+const DEFAULT_BATCH_SIZE = 20;
+
+const COMMON_SUBNETS = [
+  '192.168.0',
+  '192.168.1',
+  '192.168.2',
+  '192.168.3',
+  '192.168.4',
+  '192.168.31',
+  '192.168.43',
+  '192.168.50',
+  '192.168.68',
+  '192.168.100',
+  '10.0.0',
+  '10.0.1',
+  '10.0.2',
+  '172.16.0',
+];
+
+const SIMULATOR_HOSTS = ['localhost', '127.0.0.1', '10.0.2.2'];
+
+export function getMetroHost(): string | null {
+  try {
+    const scriptURL: unknown = NativeModules?.SourceCode?.scriptURL;
+    if (typeof scriptURL !== 'string') return null;
+    const url = new URL(scriptURL);
+    if (SIMULATOR_HOSTS.includes(url.hostname)) return null;
+    return url.hostname;
+  } catch {
+    return null;
+  }
+}
+
+interface NetworkInfoLike {
+  getIPAddress: () => Promise<string>;
+}
+
+function getNetworkInfo(): NetworkInfoLike | null {
+  try {
+    const mod = require('react-native-network-info');
+    return mod.default || mod;
+  } catch {
+    return null;
+  }
+}
+
+function getSubnetPrefix(ip: string): string | null {
+  const parts = ip.split('.');
+  if (parts.length !== 4) return null;
+  return parts.slice(0, 3).join('.');
+}
+
+function buildCandidates(prefix: string): string[] {
+  const candidates: string[] = [];
+  for (let i = 1; i <= 255; i++) {
+    candidates.push(`${prefix}.${i}`);
+  }
+  return candidates;
+}
+
+async function probeIp(ip: string, port: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean> {
+  if (signal?.aborted) return false;
+
+  type GlobalFetch = typeof globalThis.fetch;
+  const fetchImpl = (globalThis as { fetch?: GlobalFetch }).fetch;
+  if (!fetchImpl) return false;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  const onAbort = () => controller.abort();
+  signal?.addEventListener('abort', onAbort, { once: true });
+
+  try {
+    const response = await fetchImpl(`http://${ip}:${port}/health`, {
+      method: 'GET',
+      signal: controller.signal,
+    });
+    if (!response.ok) return false;
+    try {
+      const body = await response.json();
+      return body != null && typeof body === 'object' && (body as Record<string, unknown>).ok === true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+    signal?.removeEventListener('abort', onAbort);
+  }
+}
+
+async function probeBatch(
+  candidates: string[],
+  port: number,
+  timeoutMs: number,
+  batchSize: number,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  for (let i = 0; i < candidates.length; i += batchSize) {
+    if (signal?.aborted) return null;
+    const batch = candidates.slice(i, i + batchSize);
+    const results = await Promise.all(
+      batch.map((ip) => probeIp(ip, port, timeoutMs, signal)),
+    );
+    const idx = results.findIndex(Boolean);
+    if (idx !== -1) return batch[idx] ?? null;
+  }
+  return null;
+}
+
+export async function autoDetectDaemonIp(
+  options: AutoDetectOptions = {},
+): Promise<AutoDetectResult> {
+  const port = options.port ?? DEFAULT_PORT;
+  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+  const scanSubnets = options.scanSubnets ?? true;
+  const { signal } = options;
+
+  // Strategy 0: extract Mac IP from Metro bundle URL (zero-dep, instant)
+  const metroHost = getMetroHost();
+  if (metroHost) {
+    const alive = await probeIp(metroHost, port, timeoutMs, signal);
+    if (alive) return { ip: metroHost, method: 'metro-bundle' };
+  }
+
+  if (!scanSubnets) {
+    return { ip: null, method: 'none' };
+  }
+
+  // Strategy 1: react-native-network-info → device IP → subnet scan
+  const networkInfo = getNetworkInfo();
+  if (networkInfo?.getIPAddress) {
+    try {
+      const deviceIp = await networkInfo.getIPAddress();
+      const prefix = getSubnetPrefix(deviceIp);
+      if (prefix) {
+        const found = await probeBatch(buildCandidates(prefix), port, timeoutMs, batchSize, signal);
+        if (found) return { ip: found, method: 'network-info' };
+      }
+    } catch {
+      // fall through
+    }
+  }
+
+  // Strategy 2: common subnet probe
+  for (const prefix of COMMON_SUBNETS) {
+    if (signal?.aborted) break;
+    const found = await probeBatch(buildCandidates(prefix), port, timeoutMs, batchSize, signal);
+    if (found) return { ip: found, method: 'subnet-common' };
+  }
+
+  return { ip: null, method: 'none' };
+}

package/src/utils/createPersistedObservableStore.ts

@@ -9,8 +9,9 @@ export interface PersistedStoreOptions<T> {
 }
 
 export interface PersistedObservableStore<T> extends ObservableStore<T> {
-  /** Returns the next auto-incrementing ID and advances the counter. */
   nextId: () => string;
+  ready: Promise<void>;
+  destroy: () => void;
 }
 
 export function createPersistedObservableStore<T extends { id?: string }>(
@@ -20,13 +21,15 @@ export function createPersistedObservableStore<T extends { id?: string }>(
   const store = createObservableStore<T>();
   let writeTimer: ReturnType<typeof setTimeout> | null = null;
   let idCounter = 0;
+  let resolveReady: () => void;
+  const ready = new Promise<void>((resolve) => { resolveReady = resolve; });
 
   // Restore from storage (single notify via pushBatch)
   getPreference(storageKey).then((raw) => {
-    if (!raw) return;
+    if (!raw) { resolveReady(); return; }
     try {
       const entries = JSON.parse(raw) as T[];
-      if (!Array.isArray(entries)) return;
+      if (!Array.isArray(entries)) { resolveReady(); return; }
       const restored = entries.slice(-maxPersist);
       store.pushBatch(restored);
       // Fix ID counter to avoid collision with restored entries
@@ -39,6 +42,7 @@ export function createPersistedObservableStore<T extends { id?: string }>(
     } catch {
       // ignore corrupt data
     }
+    resolveReady();
   });
 
   function scheduleWrite(): void {
@@ -72,5 +76,14 @@ export function createPersistedObservableStore<T extends { id?: string }>(
     },
     subscribe: store.subscribe,
     nextId: () => String(idCounter++),
+    ready,
+    destroy: () => {
+      if (writeTimer !== null) {
+        clearTimeout(writeTimer);
+        writeTimer = null;
+      }
+      store.clear();
+      setPreference(storageKey, '[]');
+    },
   };
 }

package/src/utils/daemonConnection.ts

@@ -0,0 +1,133 @@
+import {
+  buildDaemonUrl,
+  getDefaultDaemonEndpoint,
+  getGlobalFetch,
+} from './reportToDaemon';
+
+const DEFAULT_HEALTH_TIMEOUT_MS = 2000;
+
+type FetchResponseLike = {
+  ok: boolean;
+  status: number;
+  json?: () => Promise<unknown>;
+};
+
+type AbortControllerLike = {
+  signal: unknown;
+  abort: () => void;
+};
+
+export type DaemonConnectionFailureReason =
+  | 'fetch_unavailable'
+  | 'timeout'
+  | 'http'
+  | 'invalid_response'
+  | 'network';
+
+export type DaemonConnectionResult =
+  | {
+    ok: true;
+    endpoint: string;
+    status: number;
+  }
+  | {
+    ok: false;
+    endpoint: string;
+    reason: DaemonConnectionFailureReason;
+    status?: number;
+    error?: string;
+  };
+
+export interface DaemonConnectionOptions {
+  endpoint?: string;
+  timeoutMs?: number;
+}
+
+function createAbortController(): AbortControllerLike | undefined {
+  const AbortControllerCtor = (globalThis as {
+    AbortController?: new () => AbortControllerLike;
+  }).AbortController;
+  return AbortControllerCtor ? new AbortControllerCtor() : undefined;
+}
+
+async function readHealthBody(response: FetchResponseLike): Promise<Record<string, unknown> | null> {
+  try {
+    const body = response.json ? await response.json() : null;
+    return body && typeof body === 'object' && !Array.isArray(body)
+      ? body as Record<string, unknown>
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function checkDaemonConnection(
+  options: DaemonConnectionOptions = {},
+): Promise<DaemonConnectionResult> {
+  const endpoint = options.endpoint ?? getDefaultDaemonEndpoint();
+  const healthUrl = buildDaemonUrl(endpoint, '/health');
+  const fetchImpl = getGlobalFetch();
+
+  if (!fetchImpl) {
+    return {
+      ok: false,
+      endpoint,
+      reason: 'fetch_unavailable',
+      error: 'global fetch is not available',
+    };
+  }
+
+  const timeoutMs = Math.max(0, options.timeoutMs ?? DEFAULT_HEALTH_TIMEOUT_MS);
+  const controller = createAbortController();
+  let timedOut = false;
+  const timeout = controller && timeoutMs > 0
+    ? setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs)
+    : undefined;
+
+  try {
+    const response = await fetchImpl(healthUrl, {
+      method: 'GET',
+      headers: {},
+      signal: controller?.signal,
+    });
+    const body = await readHealthBody(response);
+
+    if (!response.ok) {
+      return {
+        ok: false,
+        endpoint,
+        reason: 'http',
+        status: response.status,
+      };
+    }
+
+    if (body?.ok !== true) {
+      return {
+        ok: false,
+        endpoint,
+        reason: 'invalid_response',
+        status: response.status,
+      };
+    }
+
+    return {
+      ok: true,
+      endpoint,
+      status: response.status,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      endpoint,
+      reason: timedOut ? 'timeout' : 'network',
+      error: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}

package/src/utils/daemonSettings.ts

@@ -0,0 +1,134 @@
+export const DAEMON_ENDPOINT_STORAGE_KEY = 'debugToolkit_streamEndpoint';
+export const DAEMON_TOKEN_STORAGE_KEY = 'debugToolkit_streamToken';
+export const DAEMON_CONNECTION_MODE_STORAGE_KEY = 'debugToolkit_connectionMode';
+export const DAEMON_DEVICE_HOST_STORAGE_KEY = 'debugToolkit_deviceHost';
+
+export type DaemonConnectionMode = 'simulator' | 'device';
+
+export interface DaemonSettings {
+  mode: DaemonConnectionMode;
+  endpoint: string;
+  deviceHost: string;
+  token: string;
+}
+
+interface AsyncStorageLike {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+}
+
+function getAsyncStorage(): AsyncStorageLike | null {
+  try {
+    const asyncStorageModule = require('@react-native-async-storage/async-storage');
+    return asyncStorageModule.default || asyncStorageModule;
+  } catch {
+    return null;
+  }
+}
+
+export async function loadDaemonSettings(): Promise<DaemonSettings> {
+  const AsyncStorage = getAsyncStorage();
+  if (!AsyncStorage) {
+    return { mode: 'simulator', endpoint: '', deviceHost: '', token: '' };
+  }
+
+  try {
+    const [mode, endpoint, deviceHost, token] = await Promise.all([
+      AsyncStorage.getItem(DAEMON_CONNECTION_MODE_STORAGE_KEY),
+      AsyncStorage.getItem(DAEMON_ENDPOINT_STORAGE_KEY),
+      AsyncStorage.getItem(DAEMON_DEVICE_HOST_STORAGE_KEY),
+      AsyncStorage.getItem(DAEMON_TOKEN_STORAGE_KEY),
+    ]);
+
+    const inferredMode = readMode(mode, endpoint || '');
+    const inferredHost = deviceHost || extractDeviceHost(endpoint || '');
+
+    return {
+      mode: inferredMode,
+      endpoint: endpoint || '',
+      deviceHost: inferredMode === 'device' ? inferredHost : '',
+      token: token || '',
+    };
+  } catch {
+    return { mode: 'simulator', endpoint: '', deviceHost: '', token: '' };
+  }
+}
+
+export async function saveDaemonSettings(settings: DaemonSettings): Promise<void> {
+  const AsyncStorage = getAsyncStorage();
+  if (!AsyncStorage) {
+    return;
+  }
+
+  const normalized = normalizeDaemonSettings(settings);
+  try {
+    await Promise.all([
+      AsyncStorage.setItem(DAEMON_CONNECTION_MODE_STORAGE_KEY, settings.mode),
+      AsyncStorage.setItem(DAEMON_DEVICE_HOST_STORAGE_KEY, settings.deviceHost.trim()),
+      AsyncStorage.setItem(DAEMON_ENDPOINT_STORAGE_KEY, normalized.endpoint || ''),
+      AsyncStorage.setItem(DAEMON_TOKEN_STORAGE_KEY, settings.token.trim()),
+    ]);
+  } catch {
+    // AsyncStorage unavailable or rejected: keep runtime behavior unchanged.
+  }
+}
+
+function readMode(value: string | null, endpoint: string): DaemonConnectionMode {
+  if (value === 'device' || value === 'simulator') {
+    return value;
+  }
+  return endpoint && !isSimulatorEndpoint(endpoint) ? 'device' : 'simulator';
+}
+
+function isSimulatorEndpoint(endpoint: string): boolean {
+  try {
+    const url = new URL(endpoint);
+    return ['localhost', '127.0.0.1', '10.0.2.2'].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+function extractDeviceHost(endpoint: string): string {
+  try {
+    const url = new URL(endpoint);
+    return url.port && url.port !== '3799' ? `${url.hostname}:${url.port}` : url.hostname;
+  } catch {
+    return '';
+  }
+}
+
+export function buildDeviceDaemonEndpoint(host: string): string {
+  const trimmed = host.trim().replace(/\/+$/, '');
+  if (!trimmed) {
+    return '';
+  }
+
+  const withProtocol = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(trimmed)
+    ? trimmed
+    : `http://${trimmed}`;
+
+  try {
+    const url = new URL(withProtocol);
+    if (!url.port) {
+      url.port = '3799';
+    }
+    return url.toString().replace(/\/$/, '');
+  } catch {
+    return withProtocol;
+  }
+}
+
+export function normalizeDaemonSettings(settings: DaemonSettings): {
+  endpoint?: string;
+  token?: string;
+} {
+  const endpoint = settings.mode === 'device'
+    ? buildDeviceDaemonEndpoint(settings.deviceHost)
+    : '';
+  const token = settings.token.trim();
+  return {
+    endpoint: endpoint || undefined,
+    token: token || undefined,
+  };
+}

package/src/utils/reportToDaemon.ts

@@ -0,0 +1,172 @@
+import { Platform } from 'react-native';
+
+import { _addDaemonEndpointToNetworkBlacklist } from '../features/network';
+import {
+  createDebugSessionReport,
+  type DebugSessionReport,
+  type DebugSessionReportOptions,
+} from './sessionReport';
+
+const DEFAULT_TIMEOUT_MS = 3000;
+
+type FetchResponseLike = {
+  ok: boolean;
+  status: number;
+  json?: () => Promise<unknown>;
+  text?: () => Promise<string>;
+};
+
+type FetchLike = (
+  url: string,
+  init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    signal?: unknown;
+  },
+) => Promise<FetchResponseLike>;
+
+type AbortControllerLike = {
+  signal: unknown;
+  abort: () => void;
+};
+
+export interface ReportToDaemonOptions extends DebugSessionReportOptions {
+  endpoint?: string;
+  timeoutMs?: number;
+  token?: string;
+}
+
+export interface ReportResult {
+  ok: boolean;
+  endpoint: string;
+  report: DebugSessionReport;
+  status?: number;
+  sessionId?: string;
+  receivedAt?: string;
+  logCount?: Record<string, number>;
+  error?: string;
+}
+
+export function getGlobalFetch(): FetchLike | undefined {
+  return (globalThis as { fetch?: FetchLike }).fetch;
+}
+
+function createAbortController(): AbortControllerLike | undefined {
+  const AbortControllerCtor = (globalThis as {
+    AbortController?: new () => AbortControllerLike;
+  }).AbortController;
+  return AbortControllerCtor ? new AbortControllerCtor() : undefined;
+}
+
+export function getDefaultDaemonEndpoint(): string {
+  if (Platform.OS === 'android') {
+    return 'http://10.0.2.2:3799';
+  }
+  return 'http://localhost:3799';
+}
+
+export function buildDaemonUrl(endpoint: string, path: string): string {
+  const trimmed = endpoint.replace(/\/+$/, '');
+  return trimmed.endsWith(path) ? trimmed : `${trimmed}${path}`;
+}
+
+async function readResponseBody(response: FetchResponseLike): Promise<unknown> {
+  try {
+    if (response.json) {
+      return await response.json();
+    }
+    if (response.text) {
+      const text = await response.text();
+      return text ? JSON.parse(text) : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function readLogCount(value: unknown): Record<string, number> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  return Object.entries(value as Record<string, unknown>).reduce<Record<string, number>>(
+    (acc, [key, count]) => {
+      if (typeof count === 'number') {
+        acc[key] = count;
+      }
+      return acc;
+    },
+    {},
+  );
+}
+
+export async function reportDebugSessionToDaemon(
+  options: ReportToDaemonOptions = {},
+): Promise<ReportResult> {
+  const endpoint = options.endpoint ?? getDefaultDaemonEndpoint();
+  const reportUrl = buildDaemonUrl(endpoint, '/report');
+  const report = createDebugSessionReport(options);
+  const fetchImpl = getGlobalFetch();
+
+  _addDaemonEndpointToNetworkBlacklist(endpoint);
+  _addDaemonEndpointToNetworkBlacklist(reportUrl);
+
+  if (!fetchImpl) {
+    return {
+      ok: false,
+      endpoint,
+      report,
+      error: 'global fetch is not available',
+    };
+  }
+
+  const timeoutMs = Math.max(0, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const controller = createAbortController();
+  const timeout = controller && timeoutMs > 0
+    ? setTimeout(() => controller.abort(), timeoutMs)
+    : undefined;
+
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (options.token) {
+      headers.Authorization = `Bearer ${options.token}`;
+    }
+
+    const response = await fetchImpl(reportUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(report),
+      signal: controller?.signal,
+    });
+    const responseBody = await readResponseBody(response);
+    const bodyObject = responseBody && typeof responseBody === 'object'
+      ? responseBody as Record<string, unknown>
+      : {};
+
+    return {
+      ok: response.ok && bodyObject.ok === true,
+      endpoint,
+      report,
+      status: response.status,
+      sessionId: typeof bodyObject.sessionId === 'string' ? bodyObject.sessionId : undefined,
+      receivedAt: typeof bodyObject.receivedAt === 'string' ? bodyObject.receivedAt : undefined,
+      logCount: readLogCount(bodyObject.logCount),
+      error: response.ok ? undefined : typeof bodyObject.error === 'string' ? bodyObject.error : 'Report failed',
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      endpoint,
+      report,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}