react-native-debug-toolkit 2.3.0 → 3.1.2

package/node/daemon/src/store.js

@@ -0,0 +1,187 @@
+'use strict';
+
+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;
+  if (!logs || typeof logs !== 'object') {
+    return {};
+  }
+
+  return Object.entries(logs).reduce((acc, [type, entries]) => {
+    if (Array.isArray(entries)) {
+      acc[type] = entries.length;
+    }
+    return acc;
+  }, {});
+}
+
+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 maxDevices = options.maxDevices || DEFAULT_MAX_DEVICES;
+  const onUpdate = options.onUpdate || null;
+  const storagePath = options.storagePath || null;
+  const devices = readPersistedDevices(storagePath, maxDevices);
+
+  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.
+    }
+  }
+
+  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),
+    };
+
+    if (existingIndex >= 0) {
+      devices.splice(existingIndex, 1);
+    }
+
+    devices.push(deviceLog);
+    while (devices.length > maxDevices) {
+      devices.shift();
+    }
+
+    persist();
+    if (onUpdate) onUpdate(deviceLog, 'full');
+    return deviceLog;
+  }
+
+  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 (!deviceLog.report.logs[type]) {
+        deviceLog.report.logs[type] = [];
+      }
+      deviceLog.report.logs[type].push(...entries);
+    });
+
+    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 listDevices() {
+    return devices
+      .slice()
+      .reverse()
+      .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 getLatestDevice() {
+    return devices[devices.length - 1] || null;
+  }
+
+  function getDevice(deviceId) {
+    return devices.find((deviceLog) => deviceLog.deviceId === deviceId) || null;
+  }
+
+  function clear() {
+    devices.splice(0, devices.length);
+    persist();
+  }
+
+  return {
+    appendLogs,
+    clear,
+    getDevice,
+    getLatestDevice,
+    listDevices,
+    saveReport,
+  };
+}
+
+module.exports = {
+  createDeviceId,
+  createLogCount,
+  createMemoryStore,
+};

package/node/mcp/src/cli.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { ensureDaemon } = require('./daemonClient');
+const { startStdioServer } = require('./server');
+
+function startMcpFromCli() {
+  let daemonPromise;
+
+  const ensureDaemonOnce = () => {
+    if (!daemonPromise) {
+      daemonPromise = ensureDaemon();
+      daemonPromise.then((result) => {
+        if (!result.ok) {
+          process.stderr.write(`Debug toolkit daemon unavailable: ${result.error}\n`);
+        }
+      });
+    }
+    return daemonPromise;
+  };
+
+  ensureDaemonOnce();
+  startStdioServer({
+    context: {
+      ensureDaemon: ensureDaemonOnce,
+    },
+  });
+}
+
+module.exports = {
+  startMcpFromCli,
+};

package/node/mcp/src/constants.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const MCP_SERVER_NAME = 'react-native-debug-toolkit-mcp';
+const MCP_SERVER_VERSION = '0.1.0';
+const DEFAULT_DAEMON_ORIGIN = 'http://127.0.0.1:3799';
+const EXPECTED_PROTOCOL_VERSION = 2;
+
+module.exports = {
+  DEFAULT_DAEMON_ORIGIN,
+  EXPECTED_PROTOCOL_VERSION,
+  MCP_SERVER_NAME,
+  MCP_SERVER_VERSION,
+};

package/node/mcp/src/daemonClient.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const {
+  DEFAULT_DAEMON_ORIGIN,
+  EXPECTED_PROTOCOL_VERSION,
+} = require('./constants');
+const { requestJson } = require('./httpClient');
+
+function getDaemonOrigin() {
+  return process.env.DEBUG_TOOLKIT_DAEMON_ORIGIN || DEFAULT_DAEMON_ORIGIN;
+}
+
+async function readHealth(origin = getDaemonOrigin()) {
+  const response = await requestJson(origin, '/health', { timeoutMs: 800 });
+  if (response.status !== 200 || !response.body?.ok) {
+    throw new Error(`Daemon health check failed with status ${response.status}`);
+  }
+  if (response.body.protocolVersion !== EXPECTED_PROTOCOL_VERSION) {
+    throw new Error(
+      `Daemon protocol mismatch: expected ${EXPECTED_PROTOCOL_VERSION}, got ${response.body.protocolVersion}`,
+    );
+  }
+  return response.body;
+}
+
+function findDaemonBin() {
+  if (process.env.DEBUG_TOOLKIT_DAEMON_BIN) {
+    return process.env.DEBUG_TOOLKIT_DAEMON_BIN;
+  }
+
+  try {
+    return require.resolve('react-native-debug-toolkit/bin/debug-toolkit.js');
+  } catch {
+    const localPath = path.resolve(__dirname, '../../../bin/debug-toolkit.js');
+    return fs.existsSync(localPath) ? localPath : null;
+  }
+}
+
+function getDaemonBindHost() {
+  return process.env.DEBUG_TOOLKIT_DAEMON_HOST || '0.0.0.0';
+}
+
+function spawnDaemon(origin = getDaemonOrigin()) {
+  const daemonBin = findDaemonBin();
+  if (!daemonBin) {
+    throw new Error('Cannot find react-native-debug-toolkit debug-toolkit bin');
+  }
+
+  const url = new URL(origin);
+  const child = spawn(process.execPath, [
+    daemonBin,
+    '--daemon-only',
+    '--host',
+    getDaemonBindHost(),
+    '--port',
+    url.port || '3799',
+  ], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function ensureDaemon(options = {}) {
+  const origin = options.origin || getDaemonOrigin();
+  const timeoutMs = options.timeoutMs || 3000;
+  const pollMs = options.pollMs || 150;
+  const startedAt = Date.now();
+
+  try {
+    return { ok: true, health: await readHealth(origin), origin, spawned: false };
+  } catch (initialError) {
+    try {
+      spawnDaemon(origin);
+    } catch (spawnError) {
+      return {
+        ok: false,
+        origin,
+        error: `${initialError.message}; ${spawnError.message}`,
+      };
+    }
+  }
+
+  while (Date.now() - startedAt < timeoutMs) {
+    await sleep(pollMs);
+    try {
+      return { ok: true, health: await readHealth(origin), origin, spawned: true };
+    } catch {
+      // Keep polling until timeout; the detached daemon may still be binding.
+    }
+  }
+
+  return {
+    ok: false,
+    origin,
+    error: `Daemon did not become healthy within ${timeoutMs}ms at ${origin}`,
+  };
+}
+
+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}`);
+  }
+  return response.body;
+}
+
+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}`);
+  }
+  return response.body;
+}
+
+module.exports = {
+  ensureDaemon,
+  findDaemonBin,
+  getDaemonOrigin,
+  readHealth,
+  readDevice,
+  readDevices,
+};

package/node/mcp/src/httpClient.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+function requestJson(origin, path, options = {}) {
+  const url = new URL(path, origin);
+  const transport = url.protocol === 'https:' ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const req = transport.request(url, {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+      timeout: options.timeoutMs || 3000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        let body = null;
+        try {
+          body = raw ? JSON.parse(raw) : null;
+        } catch {
+          reject(new Error(`Daemon returned non-JSON response from ${path}`));
+          return;
+        }
+
+        resolve({
+          status: res.statusCode || 0,
+          body,
+        });
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy(new Error(`Daemon request timed out: ${path}`));
+    });
+    req.on('error', reject);
+
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+    req.end();
+  });
+}
+
+module.exports = {
+  requestJson,
+};

package/node/mcp/src/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { ensureDaemon } = require('./daemonClient');
+const { handleMessage, startStdioServer } = require('./server');
+const { callTool, getAppLogsTool, listAppDevicesTool, tools } = require('./tools');
+
+module.exports = {
+  callTool,
+  ensureDaemon,
+  getAppLogsTool,
+  handleMessage,
+  listAppDevicesTool,
+  startStdioServer,
+  tools,
+};

package/node/mcp/src/logs.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const KNOWN_LOG_TYPES = ['network', 'console', 'navigation', 'track', 'zustand'];
+
+function isFailedLog(entry) {
+  return Boolean(
+    entry &&
+    typeof entry === 'object' &&
+    (
+      entry.error ||
+      entry.level === 'error' ||
+      entry.response?.success === false ||
+      entry.response?.status >= 400
+    ),
+  );
+}
+
+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(report, options = {}) {
+  const logs = report?.logs && typeof report.logs === 'object' ? report.logs : {};
+  const logType = options.logType;
+  const limit = Number.isFinite(options.limit) && options.limit > 0
+    ? Math.min(Math.floor(options.limit), 200)
+    : 50;
+  const includeBodies = options.includeBodies !== false;
+  const failedOnly = options.failedOnly === true;
+
+  let entries;
+  if (logType) {
+    entries = Array.isArray(logs[logType]) ? logs[logType] : [];
+  } else {
+    entries = Object.entries(logs).flatMap(([type, typeEntries]) => (
+      Array.isArray(typeEntries)
+        ? typeEntries.map((entry) => ({ type, entry }))
+        : []
+    ));
+  }
+
+  if (failedOnly) {
+    entries = entries.filter((item) => isFailedLog(item.entry || item));
+  }
+
+  entries = entries.slice(-limit);
+
+  if (logType) {
+    return includeBodies ? entries : entries.map(stripBodies);
+  }
+
+  return entries.map((item) => ({
+    type: item.type,
+    entry: includeBodies ? item.entry : stripBodies(item.entry),
+  }));
+}
+
+function createToolPayload(device, options = {}) {
+  const report = device.report || { version: 2, logs: {} };
+  const logs = selectLogs(report, options);
+
+  return {
+    ok: true,
+    deviceId: device.deviceId,
+    receivedAt: device.receivedAt,
+    lastSeenAt: device.lastSeenAt,
+    logType: options.logType || 'all',
+    failedOnly: options.failedOnly === true,
+    includeBodies: options.includeBodies !== false,
+    count: logs.length,
+    logs,
+  };
+}
+
+module.exports = {
+  KNOWN_LOG_TYPES,
+  createToolPayload,
+  isFailedLog,
+  selectLogs,
+  stripBodies,
+};

package/node/mcp/src/server.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const {
+  MCP_SERVER_NAME,
+  MCP_SERVER_VERSION,
+} = require('./constants');
+const { callTool, tools } = require('./tools');
+
+function writeMessage(output, message) {
+  output.write(`${JSON.stringify(message)}\n`);
+}
+
+function createError(id, code, message) {
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code, message },
+  };
+}
+
+async function handleMessage(message, context) {
+  const id = message.id;
+  const method = message.method;
+
+  if (!method) {
+    return null;
+  }
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: message.params?.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: {
+          name: MCP_SERVER_NAME,
+          version: MCP_SERVER_VERSION,
+        },
+      },
+    };
+  }
+
+  if (method === 'notifications/initialized') {
+    return null;
+  }
+
+  if (method === 'ping') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {},
+    };
+  }
+
+  if (method === 'tools/list') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        tools,
+      },
+    };
+  }
+
+  if (method === 'tools/call') {
+    try {
+      const result = await callTool(
+        message.params?.name,
+        message.params?.arguments || {},
+        context,
+      );
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        },
+      };
+    } catch (error) {
+      return createError(id, -32000, error.message || 'Tool call failed');
+    }
+  }
+
+  if (id === undefined) {
+    return null;
+  }
+
+  return createError(id, -32601, `Method not found: ${method}`);
+}
+
+function startStdioServer(options = {}) {
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const errorOutput = options.errorOutput || process.stderr;
+  const context = options.context || {};
+  let buffer = '';
+
+  input.setEncoding('utf8');
+  input.on('data', (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() || '';
+
+    lines.forEach((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return;
+      }
+
+      let message;
+      try {
+        message = JSON.parse(trimmed);
+      } catch (error) {
+        errorOutput.write(`Invalid MCP JSON message: ${error.message}\n`);
+        return;
+      }
+
+      handleMessage(message, context)
+        .then((response) => {
+          if (response) {
+            writeMessage(output, response);
+          }
+        })
+        .catch((error) => {
+          if (message.id !== undefined) {
+            writeMessage(output, createError(message.id, -32000, error.message || 'MCP error'));
+          } else {
+            errorOutput.write(`MCP notification failed: ${error.message}\n`);
+          }
+        });
+    });
+  });
+}
+
+module.exports = {
+  handleMessage,
+  startStdioServer,
+};