react-native-debug-toolkit 3.0.0 → 3.1.2

package/node/daemon/src/constants.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const os = require('os');
+const path = require('path');
 
 const DEFAULT_HOST = '0.0.0.0';
 const DEFAULT_PORT = 3799;
@@ -22,11 +23,16 @@ function getLanIPs() {
   return ips;
 }
 
+function getDefaultDeviceStorePath() {
+  return path.join(os.homedir(), '.react-native-debug-toolkit', 'daemon-devices.json');
+}
+
 module.exports = {
   DAEMON_NAME,
   DAEMON_VERSION,
   DEFAULT_HOST,
   DEFAULT_PORT,
   REPORT_PROTOCOL_VERSION,
+  getDefaultDeviceStorePath,
   getLanIPs,
 };

package/node/daemon/src/server.js

@@ -94,21 +94,54 @@ function authorizeRequest(req, res, url, token) {
   return false;
 }
 
-function toSessionPayload(session) {
-  if (!session) {
+function normalizeIpAddress(value) {
+  if (!value || typeof value !== 'string') {
     return null;
   }
 
+  if (value.startsWith('::ffff:')) {
+    return value.slice(7);
+  }
+
+  return value;
+}
+
+function getRequestSource(req) {
+  const forwarded = req.headers['x-forwarded-for'];
+  const forwardedIp = Array.isArray(forwarded)
+    ? forwarded[0]
+    : typeof forwarded === 'string'
+      ? forwarded.split(',')[0]
+      : null;
+  const ip = normalizeIpAddress((forwardedIp || '').trim()) ||
+    normalizeIpAddress(req.socket && req.socket.remoteAddress);
+  const userAgent = req.headers['user-agent'];
+
   return {
-    sessionId: session.sessionId,
-    receivedAt: session.receivedAt,
-    logCount: session.logCount,
-    report: session.report,
+    ip: ip || 'unknown',
+    userAgent: typeof userAgent === 'string' ? userAgent : '',
   };
 }
 
-function selectLogs(session, searchParams) {
-  if (!session) {
+function toDevicePayload(deviceLog) {
+  if (!deviceLog) {
+    return null;
+  }
+
+  return {
+    deviceId: deviceLog.deviceId,
+    firstSeenAt: deviceLog.firstSeenAt,
+    lastSeenAt: deviceLog.lastSeenAt,
+    receivedAt: deviceLog.receivedAt,
+    device: deviceLog.device || null,
+    source: deviceLog.source || null,
+    logCount: deviceLog.logCount,
+    report: deviceLog.report,
+  };
+}
+
+function selectLogs(deviceLog, searchParams) {
+  if (!deviceLog) {
     return [];
   }
 
@@ -118,7 +151,7 @@ function selectLogs(session, searchParams) {
     ? Math.min(Math.floor(limitParam), 500)
     : 50;
   const failedOnly = searchParams.get('failedOnly') === 'true';
-  const logs = session.report.logs || {};
+  const logs = deviceLog.report.logs || {};
 
   let entries = [];
   if (type) {
@@ -143,12 +176,18 @@ function selectLogs(session, searchParams) {
   return entries.slice(-limit);
 }
 
-function broadcastSSE(clients, eventType, session, delta) {
+function broadcastSSE(clients, eventType, deviceLog, delta) {
   if (clients.size === 0) return;
 
   const payload = delta
-    ? { type: 'delta', sessionId: session.sessionId, delta, logCount: session.logCount }
-    : { type: 'full', sessionId: session.sessionId, logCount: session.logCount, device: session.report.device || null };
+    ? { type: 'delta', deviceId: deviceLog.deviceId, delta, logCount: deviceLog.logCount }
+    : {
+      type: 'full',
+      deviceId: deviceLog.deviceId,
+      logCount: deviceLog.logCount,
+      device: deviceLog.device || null,
+      source: deviceLog.source || null,
+    };
   const data = JSON.stringify(payload);
 
   clients.forEach((client) => {
@@ -160,14 +199,136 @@ function broadcastSSE(clients, eventType, session, delta) {
   });
 }
 
+// --- Route Handlers ---
+
+function handleHealth(req, res, ctx) {
+  sendJson(res, 200, {
+    ok: true,
+    name: DAEMON_NAME,
+    version: DAEMON_VERSION,
+    protocolVersion: REPORT_PROTOCOL_VERSION,
+    ips: getLanIPs(),
+    deviceStore: ctx.options.deviceStorePath || null,
+  });
+}
+
+async function handleReport(req, res, ctx) {
+  if (!authorizeRequest(req, res, req.url, ctx.token)) return;
+
+  try {
+    const report = await readJsonBody(req);
+    if (!isValidReport(report)) {
+      sendJson(res, 400, {
+        ok: false,
+        error: `Report must include version ${REPORT_PROTOCOL_VERSION} and logs object`,
+      });
+      return;
+    }
+
+    const deviceLog = ctx.store.saveReport(report, { source: getRequestSource(req) });
+    sendJson(res, 200, {
+      ok: true,
+      deviceId: deviceLog.deviceId,
+      receivedAt: deviceLog.receivedAt,
+      logCount: deviceLog.logCount,
+    });
+  } catch (error) {
+    sendJson(res, error.statusCode || 500, {
+      ok: false,
+      error: error.message || 'Failed to read report',
+    });
+  }
+}
+
+async function handleIngest(req, res, ctx) {
+  if (!authorizeRequest(req, res, req.url, ctx.token)) return;
+
+  try {
+    const body = await readJsonBody(req);
+    if (!body || typeof body.deviceId !== 'string' || !body.delta) {
+      sendJson(res, 400, { ok: false, error: 'Must include deviceId and delta' });
+      return;
+    }
+
+    const deviceLog = ctx.store.appendLogs(body.deviceId, body.delta);
+    if (!deviceLog) {
+      sendJson(res, 404, { ok: false, error: 'Device not found' });
+      return;
+    }
+
+    sendJson(res, 200, { ok: true, deviceId: deviceLog.deviceId, logCount: deviceLog.logCount });
+  } catch (error) {
+    sendJson(res, error.statusCode || 500, {
+      ok: false,
+      error: error.message || 'Failed to ingest',
+    });
+  }
+}
+
+function handleLatestDevice(req, res, ctx) {
+  if (!authorizeRequest(req, res, req.url, ctx.token)) return;
+
+  const deviceLog = ctx.store.getLatestDevice();
+  if (!deviceLog) {
+    sendJson(res, 404, { ok: false, error: 'No device logs have been received' });
+    return;
+  }
+
+  sendJson(res, 200, {
+    ok: true,
+    ...toDevicePayload(deviceLog),
+  });
+}
+
+function handleDevicesList(req, res, ctx) {
+  if (!authorizeRequest(req, res, req.url, ctx.token)) return;
+
+  sendJson(res, 200, { ok: true, devices: ctx.store.listDevices() });
+}
+
+function handleDevicesClear(req, res, ctx) {
+  if (!authorizeRequest(req, res, req.url, ctx.token)) return;
+
+  ctx.store.clear();
+  sendJson(res, 200, { ok: true });
+}
+
+function handleDeviceMatch(req, res, ctx, url, deviceMatch) {
+  if (!authorizeRequest(req, res, url, ctx.token)) return;
+
+  const deviceLog = ctx.store.getDevice(decodeURIComponent(deviceMatch[1]));
+  if (!deviceLog) {
+    sendJson(res, 404, { ok: false, error: 'Device not found' });
+    return;
+  }
+
+  if (url.pathname.endsWith('/logs')) {
+    sendJson(res, 200, {
+      ok: true,
+      deviceId: deviceLog.deviceId,
+      receivedAt: deviceLog.receivedAt,
+      logs: selectLogs(deviceLog, url.searchParams),
+    });
+    return;
+  }
+
+  sendJson(res, 200, {
+    ok: true,
+    ...toDevicePayload(deviceLog),
+  });
+}
+
+// --- Server Factory ---
+
 function createDaemonServer(options = {}) {
   const sseClients = new Set();
   const maxSseClients = options.maxSseClients || MAX_SSE_CLIENTS;
   let keepaliveTimer = null;
 
   const store = options.store || createMemoryStore({
-    onUpdate(session, type, delta) {
-      broadcastSSE(sseClients, 'logs', session, type === 'delta' ? delta : null);
+    storagePath: options.deviceStorePath || null,
+    onUpdate(deviceLog, type, delta) {
+      broadcastSSE(sseClients, 'logs', deviceLog, type === 'delta' ? delta : null);
     },
   });
   const token = options.token || null;
@@ -175,9 +336,12 @@ function createDaemonServer(options = {}) {
     authorize: (req, res, url) => authorizeRequest(req, res, url, token),
   });
 
+  const ctx = { store, token, options };
+
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url || '/', 'http://127.0.0.1');
     const method = req.method || 'GET';
+    req.url = url;
 
     if (handleConsole(req, res, url, method)) return;
 
@@ -197,9 +361,15 @@ function createDaemonServer(options = {}) {
       sseClients.add(res);
       req.on('close', () => { sseClients.delete(res); });
 
-      const latest = store.getLatestSession();
+      const latest = store.getLatestDevice();
       if (latest) {
-        const data = JSON.stringify({ type: 'full', sessionId: latest.sessionId, logCount: latest.logCount, device: latest.report.device || null });
+        const data = JSON.stringify({
+          type: 'full',
+          deviceId: latest.deviceId,
+          logCount: latest.logCount,
+          device: latest.device || null,
+          source: latest.source || null,
+        });
         res.write(`event: logs\ndata: ${data}\n\n`);
       }
 
@@ -219,127 +389,32 @@ function createDaemonServer(options = {}) {
     }
 
     if (method === 'GET' && url.pathname === '/health') {
-      sendJson(res, 200, {
-        ok: true,
-        name: DAEMON_NAME,
-        version: DAEMON_VERSION,
-        protocolVersion: REPORT_PROTOCOL_VERSION,
-        ips: getLanIPs(),
-      });
-      return;
+      return handleHealth(req, res, ctx);
     }
 
     if (method === 'POST' && url.pathname === '/report') {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      try {
-        const report = await readJsonBody(req);
-        if (!isValidReport(report)) {
-          sendJson(res, 400, {
-            ok: false,
-            error: `Report must include version ${REPORT_PROTOCOL_VERSION} and logs object`,
-          });
-          return;
-        }
-
-        const session = store.saveReport(report);
-        sendJson(res, 200, {
-          ok: true,
-          sessionId: session.sessionId,
-          receivedAt: session.receivedAt,
-          logCount: session.logCount,
-        });
-      } catch (error) {
-        sendJson(res, error.statusCode || 500, {
-          ok: false,
-          error: error.message || 'Failed to read report',
-        });
-      }
-      return;
+      return await handleReport(req, res, ctx);
     }
 
     if (method === 'POST' && url.pathname === '/ingest') {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      try {
-        const body = await readJsonBody(req);
-        if (!body || typeof body.sessionId !== 'string' || !body.delta) {
-          sendJson(res, 400, { ok: false, error: 'Must include sessionId and delta' });
-          return;
-        }
-
-        const session = store.appendLogs(body.sessionId, body.delta);
-        if (!session) {
-          sendJson(res, 404, { ok: false, error: 'Session not found' });
-          return;
-        }
-
-        sendJson(res, 200, { ok: true, sessionId: session.sessionId, logCount: session.logCount });
-      } catch (error) {
-        sendJson(res, error.statusCode || 500, {
-          ok: false,
-          error: error.message || 'Failed to ingest',
-        });
-      }
-      return;
+      return await handleIngest(req, res, ctx);
     }
 
-    if (method === 'GET' && (url.pathname === '/latest' || url.pathname === '/sessions/latest')) {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      const session = store.getLatestSession();
-      if (!session) {
-        sendJson(res, 404, { ok: false, error: 'No debug session report has been received' });
-        return;
-      }
-
-      sendJson(res, 200, {
-        ok: true,
-        ...toSessionPayload(session),
-      });
-      return;
+    if (method === 'GET' && url.pathname === '/devices/latest') {
+      return handleLatestDevice(req, res, ctx);
     }
 
-    if (method === 'GET' && url.pathname === '/sessions') {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      sendJson(res, 200, { ok: true, sessions: store.listSessions() });
-      return;
+    if (method === 'GET' && url.pathname === '/devices') {
+      return handleDevicesList(req, res, ctx);
     }
 
-    if (method === 'DELETE' && url.pathname === '/sessions') {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      store.clear();
-      sendJson(res, 200, { ok: true });
-      return;
+    if (method === 'DELETE' && url.pathname === '/devices') {
+      return handleDevicesClear(req, res, ctx);
     }
 
-    const sessionMatch = url.pathname.match(/^\/sessions\/([^/]+)(?:\/logs)?$/);
-    if (method === 'GET' && sessionMatch) {
-      if (!authorizeRequest(req, res, url, token)) return;
-
-      const session = store.getSession(decodeURIComponent(sessionMatch[1]));
-      if (!session) {
-        sendJson(res, 404, { ok: false, error: 'Session not found' });
-        return;
-      }
-
-      if (url.pathname.endsWith('/logs')) {
-        sendJson(res, 200, {
-          ok: true,
-          sessionId: session.sessionId,
-          receivedAt: session.receivedAt,
-          logs: selectLogs(session, url.searchParams),
-        });
-        return;
-      }
-
-      sendJson(res, 200, {
-        ok: true,
-        ...toSessionPayload(session),
-      });
-      return;
+    const deviceMatch = url.pathname.match(/^\/devices\/([^/]+)(?:\/logs)?$/);
+    if (method === 'GET' && deviceMatch) {
+      return handleDeviceMatch(req, res, ctx, url, deviceMatch);
     }
 
     sendJson(res, 404, { ok: false, error: 'Not found' });
@@ -361,5 +436,12 @@ function createDaemonServer(options = {}) {
 
 module.exports = {
   createDaemonServer,
+  handleHealth,
+  handleReport,
+  handleIngest,
+  handleLatestDevice,
+  handleDevicesList,
+  handleDevicesClear,
+  handleDeviceMatch,
   isValidReport,
 };

package/node/daemon/src/store.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const DEFAULT_MAX_SESSIONS = 20;
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MAX_DEVICES = 20;
 
 function createLogCount(report) {
   const logs = report && typeof report === 'object' ? report.logs : undefined;
@@ -16,95 +19,169 @@ function createLogCount(report) {
   }, {});
 }
 
-function createSessionId(now, sequence) {
-  return `session_${now}_${sequence}`;
+function slugPart(value) {
+  return String(value || 'unknown')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80) || 'unknown';
+}
+
+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('_');
+}
+
+function readPersistedDevices(storagePath, maxDevices) {
+  if (!storagePath) {
+    return [];
+  }
+
+  try {
+    const raw = fs.readFileSync(storagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed
+      .filter((deviceLog) => (
+        deviceLog &&
+        typeof deviceLog === 'object' &&
+        typeof deviceLog.deviceId === 'string' &&
+        deviceLog.report &&
+        typeof deviceLog.report === 'object'
+      ))
+      .slice(-maxDevices);
+  } catch {
+    return [];
+  }
 }
 
 function createMemoryStore(options = {}) {
-  const maxSessions = options.maxSessions || DEFAULT_MAX_SESSIONS;
+  const maxDevices = options.maxDevices || DEFAULT_MAX_DEVICES;
   const onUpdate = options.onUpdate || null;
-  const sessions = [];
-  let sequence = 0;
+  const storagePath = options.storagePath || null;
+  const devices = readPersistedDevices(storagePath, maxDevices);
 
-  function saveReport(report) {
-    const now = Date.now();
-    sequence += 1;
+  function persist() {
+    if (!storagePath) {
+      return;
+    }
+
+    try {
+      fs.mkdirSync(path.dirname(storagePath), { recursive: true });
+      const tmpPath = `${storagePath}.tmp`;
+      fs.writeFileSync(tmpPath, JSON.stringify(devices, null, 2));
+      fs.renameSync(tmpPath, storagePath);
+    } catch {
+      // Persistence is best-effort; daemon HTTP API should keep working.
+    }
+  }
 
-    const session = {
-      sessionId: typeof report.sessionId === 'string' && report.sessionId
-        ? report.sessionId
-        : createSessionId(now, sequence),
-      receivedAt: new Date(now).toISOString(),
+  function saveReport(report, metadata = {}) {
+    const now = Date.now();
+    const receivedAt = new Date(now).toISOString();
+    const source = metadata.source || null;
+    const deviceId = createDeviceId(report, source);
+    const existingIndex = devices.findIndex((item) => item.deviceId === deviceId);
+    const existing = existingIndex >= 0 ? devices[existingIndex] : null;
+    const deviceLog = {
+      deviceId,
+      firstSeenAt: existing ? existing.firstSeenAt : receivedAt,
+      lastSeenAt: receivedAt,
+      receivedAt,
+      source,
+      device: report.device || null,
       report,
       logCount: createLogCount(report),
     };
 
-    const existingIndex = sessions.findIndex((item) => item.sessionId === session.sessionId);
     if (existingIndex >= 0) {
-      sessions.splice(existingIndex, 1);
+      devices.splice(existingIndex, 1);
     }
 
-    sessions.push(session);
-    while (sessions.length > maxSessions) {
-      sessions.shift();
+    devices.push(deviceLog);
+    while (devices.length > maxDevices) {
+      devices.shift();
     }
 
-    if (onUpdate) onUpdate(session, 'full');
-    return session;
+    persist();
+    if (onUpdate) onUpdate(deviceLog, 'full');
+    return deviceLog;
   }
 
-  function appendLogs(sessionId, delta) {
-    const session = sessions.find((s) => s.sessionId === sessionId);
-    if (!session) return null;
+  function appendLogs(deviceId, delta) {
+    const deviceLog = devices.find((item) => item.deviceId === deviceId);
+    if (!deviceLog) {
+      return null;
+    }
 
     const deltaLogs = (delta && delta.logs) || {};
     Object.entries(deltaLogs).forEach(([type, entries]) => {
-      if (!Array.isArray(entries)) return;
-      if (!session.report.logs[type]) {
-        session.report.logs[type] = [];
+      if (!Array.isArray(entries)) {
+        return;
+      }
+      if (!deviceLog.report.logs[type]) {
+        deviceLog.report.logs[type] = [];
       }
-      session.report.logs[type].push(...entries);
+      deviceLog.report.logs[type].push(...entries);
     });
 
-    session.logCount = createLogCount(session.report);
-    if (onUpdate) onUpdate(session, 'delta', delta);
-    return session;
+    deviceLog.lastSeenAt = new Date(Date.now()).toISOString();
+    deviceLog.receivedAt = deviceLog.lastSeenAt;
+    deviceLog.logCount = createLogCount(deviceLog.report);
+    persist();
+    if (onUpdate) onUpdate(deviceLog, 'delta', delta);
+    return deviceLog;
   }
 
-  function listSessions() {
-    return sessions
+  function listDevices() {
+    return devices
       .slice()
       .reverse()
-      .map((session) => ({
-        sessionId: session.sessionId,
-        receivedAt: session.receivedAt,
-        logCount: session.logCount,
+      .map((deviceLog) => ({
+        deviceId: deviceLog.deviceId,
+        firstSeenAt: deviceLog.firstSeenAt,
+        lastSeenAt: deviceLog.lastSeenAt,
+        receivedAt: deviceLog.receivedAt,
+        device: deviceLog.device || null,
+        source: deviceLog.source || null,
+        logCount: deviceLog.logCount,
       }));
   }
 
-  function getLatestSession() {
-    return sessions[sessions.length - 1] || null;
+  function getLatestDevice() {
+    return devices[devices.length - 1] || null;
   }
 
-  function getSession(sessionId) {
-    return sessions.find((session) => session.sessionId === sessionId) || null;
+  function getDevice(deviceId) {
+    return devices.find((deviceLog) => deviceLog.deviceId === deviceId) || null;
   }
 
   function clear() {
-    sessions.splice(0, sessions.length);
+    devices.splice(0, devices.length);
+    persist();
   }
 
   return {
     appendLogs,
     clear,
-    getLatestSession,
-    getSession,
-    listSessions,
+    getDevice,
+    getLatestDevice,
+    listDevices,
     saveReport,
   };
 }
 
 module.exports = {
+  createDeviceId,
   createLogCount,
   createMemoryStore,
 };

package/node/mcp/src/daemonClient.js

@@ -105,8 +105,8 @@ async function ensureDaemon(options = {}) {
   };
 }
 
-async function readSession(origin, sessionId) {
-  const requestPath = sessionId ? `/sessions/${encodeURIComponent(sessionId)}` : '/latest';
+async function readDevice(origin, deviceId) {
+  const requestPath = deviceId ? `/devices/${encodeURIComponent(deviceId)}` : '/devices/latest';
   const response = await requestJson(origin, requestPath, { timeoutMs: 3000 });
   if (response.status !== 200 || !response.body?.ok) {
     throw new Error(response.body?.error || `Daemon request failed with status ${response.status}`);
@@ -114,8 +114,8 @@ async function readSession(origin, sessionId) {
   return response.body;
 }
 
-async function readSessions(origin) {
-  const response = await requestJson(origin, '/sessions', { timeoutMs: 3000 });
+async function readDevices(origin) {
+  const response = await requestJson(origin, '/devices', { timeoutMs: 3000 });
   if (response.status !== 200 || !response.body?.ok) {
     throw new Error(response.body?.error || `Daemon request failed with status ${response.status}`);
   }
@@ -127,6 +127,6 @@ module.exports = {
   findDaemonBin,
   getDaemonOrigin,
   readHealth,
-  readSession,
-  readSessions,
+  readDevice,
+  readDevices,
 };