agent-react-devtools 0.0.0 → 0.1.0

package/dist/daemon.js

@@ -0,0 +1,1091 @@
+#!/usr/bin/env node
+
+// src/daemon.ts
+import net from "net";
+import fs from "fs";
+import path from "path";
+
+// src/devtools-bridge.ts
+import { WebSocketServer, WebSocket } from "ws";
+var DevToolsBridge = class {
+  wss = null;
+  connections = /* @__PURE__ */ new Set();
+  port;
+  tree;
+  profiler;
+  pendingInspections = /* @__PURE__ */ new Map();
+  pendingProfilingCollect = null;
+  rendererIds = /* @__PURE__ */ new Set();
+  /** Track which root fiber IDs belong to each WebSocket connection */
+  connectionRoots = /* @__PURE__ */ new Map();
+  constructor(port2, tree, profiler) {
+    this.port = port2;
+    this.tree = tree;
+    this.profiler = profiler;
+  }
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.wss = new WebSocketServer({ port: this.port }, () => {
+        resolve();
+      });
+      this.wss.on("error", (err) => {
+        reject(err);
+      });
+      this.wss.on("connection", (ws) => {
+        this.connections.add(ws);
+        ws.on("message", (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this.handleMessage(ws, msg);
+          } catch {
+          }
+        });
+        ws.on("close", () => {
+          this.cleanupConnection(ws);
+        });
+        ws.on("error", () => {
+          this.cleanupConnection(ws);
+        });
+      });
+    });
+  }
+  stop() {
+    for (const conn of this.connections) {
+      conn.close();
+    }
+    this.connections.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+  }
+  getConnectedAppCount() {
+    return this.connections.size;
+  }
+  /**
+   * Request detailed inspection of a specific element.
+   * Sends a request to the React app and waits for the response.
+   */
+  inspectElement(id) {
+    const node = this.tree.getNode(id);
+    if (!node) return Promise.resolve(null);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingInspections.delete(id);
+        resolve(null);
+      }, 5e3);
+      this.pendingInspections.set(id, { resolve, timer });
+      this.sendToAll({
+        event: "inspectElement",
+        payload: {
+          id,
+          rendererID: node.rendererId,
+          forceFullData: true,
+          requestID: id,
+          path: null
+        }
+      });
+    });
+  }
+  startProfiling() {
+    this.sendToAll({
+      event: "startProfiling",
+      payload: { recordChangeDescriptions: true }
+    });
+  }
+  /**
+   * Stop profiling and request data from each renderer.
+   * Returns a promise that resolves when profilingData arrives (or 5s timeout).
+   */
+  stopProfilingAndCollect() {
+    this.sendToAll({
+      event: "stopProfiling",
+      payload: void 0
+    });
+    if (this.rendererIds.size === 0) {
+      return Promise.resolve();
+    }
+    for (const rendererID of this.rendererIds) {
+      this.sendToAll({
+        event: "getProfilingData",
+        payload: { rendererID }
+      });
+    }
+    const expected = this.rendererIds.size;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingProfilingCollect = null;
+        resolve();
+      }, 5e3);
+      this.pendingProfilingCollect = { resolve, timer, remaining: expected };
+    });
+  }
+  handleMessage(ws, msg) {
+    switch (msg.event) {
+      case "backendInitialized":
+        this.sendTo(ws, { event: "getBridgeProtocol", payload: void 0 });
+        this.sendTo(ws, { event: "getBackendVersion", payload: void 0 });
+        this.sendTo(ws, { event: "getIfHasUnsupportedRendererVersion", payload: void 0 });
+        this.sendTo(ws, { event: "getHookSettings", payload: void 0 });
+        this.sendTo(ws, { event: "getProfilingStatus", payload: void 0 });
+        break;
+      case "bridgeProtocol":
+      case "backendVersion":
+      case "profilingStatus":
+      case "overrideComponentFilters":
+        break;
+      case "operations":
+        this.handleOperations(ws, msg.payload);
+        break;
+      case "inspectedElement":
+        this.handleInspectedElement(msg.payload);
+        break;
+      case "profilingData":
+        this.handleProfilingData(msg.payload);
+        break;
+      case "renderer": {
+        const payload = msg.payload;
+        this.rendererIds.add(payload.id);
+        break;
+      }
+      case "rendererAttached": {
+        const payload = msg.payload;
+        this.rendererIds.add(payload.id);
+        break;
+      }
+      case "shutdown":
+        ws.close();
+        break;
+      // Silently ignore known but unhandled events
+      case "hookSettings":
+      case "isBackendStorageAPISupported":
+      case "isReactNativeEnvironment":
+      case "isReloadAndProfileSupportedByBackend":
+      case "isSynchronousXHRSupported":
+      case "syncSelectionFromNativeElementsPanel":
+      case "unsupportedRendererVersion":
+        break;
+      default:
+        break;
+    }
+  }
+  handleOperations(ws, operations) {
+    if (operations.length >= 2) {
+      this.rendererIds.add(operations[0]);
+      const rootFiberId = operations[1];
+      let roots = this.connectionRoots.get(ws);
+      if (!roots) {
+        roots = /* @__PURE__ */ new Set();
+        this.connectionRoots.set(ws, roots);
+      }
+      roots.add(rootFiberId);
+    }
+    const added = this.tree.applyOperations(operations);
+    if (this.profiler.isActive()) {
+      for (const node of added) {
+        this.profiler.trackComponent(node.id, node.displayName);
+      }
+    }
+  }
+  cleanupConnection(ws) {
+    this.connections.delete(ws);
+    const roots = this.connectionRoots.get(ws);
+    if (roots) {
+      for (const rootId of roots) {
+        this.tree.removeRoot(rootId);
+      }
+      this.connectionRoots.delete(ws);
+    }
+  }
+  handleInspectedElement(payload) {
+    const data = payload;
+    if (data.type !== "full-data" && data.type !== "hydrated-path") {
+      const pending2 = this.pendingInspections.get(data.id);
+      if (pending2) {
+        clearTimeout(pending2.timer);
+        this.pendingInspections.delete(data.id);
+        pending2.resolve(null);
+      }
+      return;
+    }
+    const pending = this.pendingInspections.get(data.id);
+    if (!pending || !data.value) return;
+    clearTimeout(pending.timer);
+    this.pendingInspections.delete(data.id);
+    const node = this.tree.getNode(data.id);
+    const inspected = {
+      id: data.id,
+      displayName: data.value.displayName || node?.displayName || "Unknown",
+      type: node?.type || "other",
+      key: data.value.key,
+      props: cleanDehydrated(data.value.props),
+      state: data.value.state ? cleanDehydrated(data.value.state) : null,
+      hooks: data.value.hooks ? parseHooks(data.value.hooks) : null,
+      renderedAt: null
+    };
+    pending.resolve(inspected);
+  }
+  handleProfilingData(payload) {
+    this.profiler.processProfilingData(payload);
+    if (this.pendingProfilingCollect) {
+      this.pendingProfilingCollect.remaining--;
+      if (this.pendingProfilingCollect.remaining <= 0) {
+        clearTimeout(this.pendingProfilingCollect.timer);
+        const pending = this.pendingProfilingCollect;
+        this.pendingProfilingCollect = null;
+        pending.resolve();
+      }
+    }
+  }
+  sendTo(ws, msg) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  sendToAll(msg) {
+    const raw = JSON.stringify(msg);
+    for (const conn of this.connections) {
+      if (conn.readyState === WebSocket.OPEN) {
+        conn.send(raw);
+      }
+    }
+  }
+};
+function cleanDehydrated(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(cleanDehydrated);
+  const record = obj;
+  if ("type" in record && "preview_short" in record) {
+    return record["preview_short"];
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(record)) {
+    cleaned[key] = cleanDehydrated(value);
+  }
+  return cleaned;
+}
+function parseHooks(hooks) {
+  return hooks.map((hook) => {
+    const h = hook;
+    const result = {
+      name: h.name,
+      value: cleanDehydrated(h.value)
+    };
+    if (h.subHooks && h.subHooks.length > 0) {
+      result.subHooks = parseHooks(h.subHooks);
+    }
+    return result;
+  });
+}
+
+// src/component-tree.ts
+var TREE_OPERATION_ADD = 1;
+var TREE_OPERATION_REMOVE = 2;
+var TREE_OPERATION_REORDER_CHILDREN = 3;
+var TREE_OPERATION_UPDATE_TREE_BASE_DURATION = 4;
+var TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS = 5;
+var TREE_OPERATION_REMOVE_ROOT = 6;
+var TREE_OPERATION_SET_SUBTREE_MODE = 7;
+var SUSPENSE_TREE_OPERATION_ADD = 8;
+var SUSPENSE_TREE_OPERATION_REMOVE = 9;
+var SUSPENSE_TREE_OPERATION_REORDER_CHILDREN = 10;
+var SUSPENSE_TREE_OPERATION_RESIZE = 11;
+var SUSPENSE_TREE_OPERATION_SUSPENDERS = 12;
+var TREE_OPERATION_APPLIED_ACTIVITY_SLICE_CHANGE = 13;
+var ELEMENT_TYPE_CLASS = 1;
+var ELEMENT_TYPE_FUNCTION = 5;
+var ELEMENT_TYPE_FORWARD_REF = 6;
+var ELEMENT_TYPE_HOST = 7;
+var ELEMENT_TYPE_MEMO = 8;
+var ELEMENT_TYPE_PROFILER = 10;
+var ELEMENT_TYPE_ROOT = 11;
+var ELEMENT_TYPE_SUSPENSE = 12;
+function toComponentType(elementType) {
+  switch (elementType) {
+    case ELEMENT_TYPE_CLASS:
+      return "class";
+    case ELEMENT_TYPE_FUNCTION:
+      return "function";
+    case ELEMENT_TYPE_FORWARD_REF:
+      return "forwardRef";
+    case ELEMENT_TYPE_HOST:
+      return "host";
+    case ELEMENT_TYPE_MEMO:
+      return "memo";
+    case ELEMENT_TYPE_PROFILER:
+      return "profiler";
+    case ELEMENT_TYPE_SUSPENSE:
+      return "suspense";
+    case ELEMENT_TYPE_ROOT:
+      return "other";
+    // roots are internal, map to 'other'
+    default:
+      return "other";
+  }
+}
+function skipRects(operations, i) {
+  const count = operations[i++];
+  if (count === -1) return i;
+  return i + count * 4;
+}
+var ComponentTree = class {
+  nodes = /* @__PURE__ */ new Map();
+  roots = [];
+  /** Index: lowercase display name → set of node ids */
+  nameIndex = /* @__PURE__ */ new Map();
+  /** Label → real node ID (e.g., "@c1" → 10) */
+  labelToId = /* @__PURE__ */ new Map();
+  /** Real node ID → label */
+  idToLabel = /* @__PURE__ */ new Map();
+  /**
+   * Whether the backend uses the extended ADD format (8 fields with namePropStringID).
+   * Auto-detected from the presence of SUSPENSE_TREE_OPERATION opcodes.
+   */
+  extendedAddFormat = false;
+  applyOperations(operations) {
+    if (operations.length < 2) return [];
+    const added = [];
+    const rendererId = operations[0];
+    let i = 2;
+    const stringTable = [null];
+    const stringTableSize = operations[i++];
+    const stringTableEnd = i + stringTableSize;
+    while (i < stringTableEnd) {
+      const strLen = operations[i++];
+      let str = "";
+      for (let j = 0; j < strLen; j++) {
+        str += String.fromCodePoint(operations[i++]);
+      }
+      stringTable.push(str);
+    }
+    while (i < operations.length) {
+      const op = operations[i];
+      switch (op) {
+        case TREE_OPERATION_ADD: {
+          const id = operations[i + 1];
+          const elementType = operations[i + 2];
+          i += 3;
+          if (elementType === ELEMENT_TYPE_ROOT) {
+            i += 4;
+            const node = {
+              id,
+              displayName: "Root",
+              type: "other",
+              key: null,
+              parentId: null,
+              children: [],
+              rendererId
+            };
+            this.nodes.set(id, node);
+            added.push({ id, displayName: node.displayName });
+            if (!this.roots.includes(id)) {
+              this.roots.push(id);
+            }
+          } else {
+            const parentId = operations[i++];
+            i++;
+            const displayNameStringId = operations[i++];
+            const keyStringId = operations[i++];
+            if (this.extendedAddFormat) {
+              i++;
+            }
+            const displayName = (displayNameStringId > 0 ? stringTable[displayNameStringId] : null) || (elementType === ELEMENT_TYPE_HOST ? "HostComponent" : "Anonymous");
+            const key = keyStringId > 0 ? stringTable[keyStringId] || null : null;
+            const node = {
+              id,
+              displayName,
+              type: toComponentType(elementType),
+              key,
+              parentId: parentId === 0 ? null : parentId,
+              children: [],
+              rendererId
+            };
+            this.nodes.set(id, node);
+            added.push({ id, displayName });
+            if (parentId === 0) {
+              if (!this.roots.includes(id)) {
+                this.roots.push(id);
+              }
+            } else {
+              const parent = this.nodes.get(parentId);
+              if (parent) {
+                parent.children.push(id);
+              }
+            }
+            if (displayName) {
+              const lower = displayName.toLowerCase();
+              let set = this.nameIndex.get(lower);
+              if (!set) {
+                set = /* @__PURE__ */ new Set();
+                this.nameIndex.set(lower, set);
+              }
+              set.add(id);
+            }
+          }
+          break;
+        }
+        case TREE_OPERATION_REMOVE: {
+          const numRemoved = operations[i + 1];
+          for (let j = 0; j < numRemoved; j++) {
+            const id = operations[i + 2 + j];
+            this.removeNode(id);
+          }
+          i += 2 + numRemoved;
+          break;
+        }
+        case TREE_OPERATION_REORDER_CHILDREN: {
+          const id = operations[i + 1];
+          const numChildren = operations[i + 2];
+          const newChildren = [];
+          for (let j = 0; j < numChildren; j++) {
+            newChildren.push(operations[i + 3 + j]);
+          }
+          const node = this.nodes.get(id);
+          if (node) {
+            node.children = newChildren;
+          }
+          i += 3 + numChildren;
+          break;
+        }
+        case TREE_OPERATION_UPDATE_TREE_BASE_DURATION: {
+          i += 3;
+          break;
+        }
+        case TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS: {
+          i += 4;
+          break;
+        }
+        case TREE_OPERATION_REMOVE_ROOT: {
+          const rootId = operations[i + 1];
+          this.removeNode(rootId);
+          i += 2;
+          break;
+        }
+        case TREE_OPERATION_SET_SUBTREE_MODE: {
+          i += 3;
+          break;
+        }
+        // ── Suspense tree operations (newer backends) ──
+        case SUSPENSE_TREE_OPERATION_ADD: {
+          this.extendedAddFormat = true;
+          i += 5;
+          i = skipRects(operations, i);
+          break;
+        }
+        case SUSPENSE_TREE_OPERATION_REMOVE: {
+          this.extendedAddFormat = true;
+          const numIds = operations[i + 1];
+          i += 2 + numIds;
+          break;
+        }
+        case SUSPENSE_TREE_OPERATION_REORDER_CHILDREN: {
+          this.extendedAddFormat = true;
+          const numSuspenseChildren = operations[i + 2];
+          i += 3 + numSuspenseChildren;
+          break;
+        }
+        case SUSPENSE_TREE_OPERATION_RESIZE: {
+          this.extendedAddFormat = true;
+          i += 2;
+          i = skipRects(operations, i);
+          break;
+        }
+        case SUSPENSE_TREE_OPERATION_SUSPENDERS: {
+          this.extendedAddFormat = true;
+          const numChanges = operations[i + 1];
+          i += 2 + numChanges * 4;
+          break;
+        }
+        case TREE_OPERATION_APPLIED_ACTIVITY_SLICE_CHANGE: {
+          this.extendedAddFormat = true;
+          i += 2;
+          break;
+        }
+        default:
+          i++;
+          break;
+      }
+    }
+    return added;
+  }
+  removeNode(id) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    if (node.parentId !== null) {
+      const parent = this.nodes.get(node.parentId);
+      if (parent) {
+        parent.children = parent.children.filter((c) => c !== id);
+      }
+    }
+    this.roots = this.roots.filter((r) => r !== id);
+    if (node.displayName) {
+      const lower = node.displayName.toLowerCase();
+      const set = this.nameIndex.get(lower);
+      if (set) {
+        set.delete(id);
+        if (set.size === 0) this.nameIndex.delete(lower);
+      }
+    }
+    for (const childId of node.children) {
+      this.removeNode(childId);
+    }
+    this.nodes.delete(id);
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getTree(maxDepth) {
+    const result = [];
+    this.labelToId.clear();
+    this.idToLabel.clear();
+    let labelCounter = 1;
+    const walk = (id, depth) => {
+      const node = this.nodes.get(id);
+      if (!node) return;
+      if (maxDepth !== void 0 && depth > maxDepth) return;
+      const label = `@c${labelCounter++}`;
+      this.labelToId.set(label, node.id);
+      this.idToLabel.set(node.id, label);
+      result.push({
+        id: node.id,
+        label,
+        displayName: node.displayName,
+        type: node.type,
+        key: node.key,
+        parentId: node.parentId,
+        children: node.children,
+        depth
+      });
+      for (const childId of node.children) {
+        walk(childId, depth + 1);
+      }
+    };
+    for (const rootId of this.roots) {
+      walk(rootId, 0);
+    }
+    return result;
+  }
+  findByName(name, exact) {
+    const results = [];
+    if (exact) {
+      const lower = name.toLowerCase();
+      const ids = this.nameIndex.get(lower);
+      if (ids) {
+        for (const id of ids) {
+          const node = this.nodes.get(id);
+          if (node && node.displayName.toLowerCase() === lower) {
+            results.push(this.toTreeNode(node));
+          }
+        }
+      }
+    } else {
+      const lower = name.toLowerCase();
+      for (const [indexName, ids] of this.nameIndex) {
+        if (indexName.includes(lower)) {
+          for (const id of ids) {
+            const node = this.nodes.get(id);
+            if (node) {
+              results.push(this.toTreeNode(node));
+            }
+          }
+        }
+      }
+    }
+    return results;
+  }
+  getComponentCount() {
+    return this.nodes.size;
+  }
+  getCountByType() {
+    const counts = {};
+    for (const node of this.nodes.values()) {
+      counts[node.type] = (counts[node.type] || 0) + 1;
+    }
+    return counts;
+  }
+  getAllNodeIds() {
+    return Array.from(this.nodes.keys());
+  }
+  getRootIds() {
+    return [...this.roots];
+  }
+  removeRoot(rootId) {
+    this.removeNode(rootId);
+  }
+  /**
+   * Resolve a label like "@c3" to a real node ID.
+   * Returns undefined if label not found.
+   */
+  resolveLabel(label) {
+    return this.labelToId.get(label);
+  }
+  /**
+   * Resolve either a label string ("@c3") or a numeric ID to a real node ID.
+   */
+  resolveId(id) {
+    if (typeof id === "number") return id;
+    if (id.startsWith("@c")) return this.labelToId.get(id);
+    const num = parseInt(id, 10);
+    return isNaN(num) ? void 0 : num;
+  }
+  toTreeNode(node) {
+    let depth = 0;
+    let current = node;
+    while (current.parentId !== null) {
+      depth++;
+      const parent = this.nodes.get(current.parentId);
+      if (!parent) break;
+      current = parent;
+    }
+    return {
+      id: node.id,
+      label: this.idToLabel.get(node.id) || `@c?`,
+      displayName: node.displayName,
+      type: node.type,
+      key: node.key,
+      parentId: node.parentId,
+      children: node.children,
+      depth
+    };
+  }
+};
+
+// src/profiler.ts
+var Profiler = class {
+  session = null;
+  /** Display names captured during profiling (survives unmounts) */
+  displayNames = /* @__PURE__ */ new Map();
+  isActive() {
+    return this.session !== null && this.session.stoppedAt === null;
+  }
+  start(name) {
+    this.displayNames.clear();
+    this.session = {
+      name: name || `session-${Date.now()}`,
+      startedAt: Date.now(),
+      stoppedAt: null,
+      commits: []
+    };
+  }
+  /** Cache a component's display name (call during profiling to survive unmounts) */
+  trackComponent(id, displayName) {
+    this.displayNames.set(id, displayName);
+  }
+  stop(tree) {
+    if (!this.session) return null;
+    this.session.stoppedAt = Date.now();
+    const duration = this.session.stoppedAt - this.session.startedAt;
+    const renderCounts = /* @__PURE__ */ new Map();
+    for (const commit of this.session.commits) {
+      for (const [id] of commit.fiberActualDurations) {
+        renderCounts.set(id, (renderCounts.get(id) || 0) + 1);
+      }
+    }
+    const componentRenderCounts = Array.from(renderCounts.entries()).map(([id, count]) => ({
+      id,
+      displayName: tree?.getNode(id)?.displayName || this.displayNames.get(id) || "",
+      count
+    })).sort((a, b) => b.count - a.count);
+    return {
+      name: this.session.name,
+      duration,
+      commitCount: this.session.commits.length,
+      componentRenderCounts
+    };
+  }
+  /**
+   * Process profiling data sent from React DevTools.
+   *
+   * The data format varies between React versions. We handle the common
+   * format where each commit contains:
+   * - commitTime
+   * - duration
+   * - fiberActualDurations: [id, duration, ...]
+   * - fiberSelfDurations: [id, duration, ...]
+   * - changeDescriptions: Map<id, description>
+   */
+  processProfilingData(payload) {
+    if (!this.session || this.session.stoppedAt !== null) return;
+    const data = payload;
+    const roots = data?.dataForRoots;
+    if (roots) {
+      for (const root of roots) {
+        if (root.commitData) {
+          for (const commitData of root.commitData) {
+            this.processCommitData(commitData);
+          }
+        }
+      }
+      return;
+    }
+    if (data?.commitData) {
+      for (const commitData of data.commitData) {
+        this.processCommitData(commitData);
+      }
+    }
+  }
+  processCommitData(commitData) {
+    const commit = {
+      timestamp: commitData.timestamp || Date.now(),
+      duration: commitData.duration || 0,
+      fiberActualDurations: /* @__PURE__ */ new Map(),
+      fiberSelfDurations: /* @__PURE__ */ new Map(),
+      changeDescriptions: /* @__PURE__ */ new Map()
+    };
+    if (commitData.fiberActualDurations) {
+      parseDurations(commitData.fiberActualDurations, commit.fiberActualDurations);
+    }
+    if (commitData.fiberSelfDurations) {
+      parseDurations(commitData.fiberSelfDurations, commit.fiberSelfDurations);
+    }
+    if (commitData.changeDescriptions) {
+      const entries = commitData.changeDescriptions instanceof Map ? commitData.changeDescriptions.entries() : commitData.changeDescriptions[Symbol.iterator]();
+      for (const [id, desc] of entries) {
+        const d = desc;
+        commit.changeDescriptions.set(id, {
+          didHooksChange: d.didHooksChange || false,
+          isFirstMount: d.isFirstMount || false,
+          props: d.props || null,
+          state: d.state || null,
+          hooks: d.hooks || null
+        });
+      }
+    }
+    this.session.commits.push(commit);
+  }
+  getReport(componentId, tree) {
+    if (!this.session) return null;
+    const node = tree.getNode(componentId);
+    let renderCount = 0;
+    let totalDuration = 0;
+    let maxDuration = 0;
+    const causeSet = /* @__PURE__ */ new Set();
+    for (const commit of this.session.commits) {
+      const duration = commit.fiberActualDurations.get(componentId);
+      if (duration !== void 0) {
+        renderCount++;
+        totalDuration += duration;
+        if (duration > maxDuration) maxDuration = duration;
+        const desc = commit.changeDescriptions.get(componentId);
+        if (desc) {
+          for (const cause of describeCauses(desc)) {
+            causeSet.add(cause);
+          }
+        }
+      }
+    }
+    if (renderCount === 0) return null;
+    return {
+      id: componentId,
+      displayName: node?.displayName || this.displayNames.get(componentId) || `Component#${componentId}`,
+      renderCount,
+      totalDuration,
+      avgDuration: totalDuration / renderCount,
+      maxDuration,
+      causes: Array.from(causeSet)
+    };
+  }
+  getSlowest(tree, limit = 10) {
+    return this.getAllReports(tree).sort((a, b) => b.avgDuration - a.avgDuration).slice(0, limit);
+  }
+  getMostRerenders(tree, limit = 10) {
+    return this.getAllReports(tree).sort((a, b) => b.renderCount - a.renderCount).slice(0, limit);
+  }
+  getCommitDetails(index, tree, limit = 10) {
+    if (!this.session) return null;
+    if (index < 0 || index >= this.session.commits.length) return null;
+    const commit = this.session.commits[index];
+    const components = [];
+    for (const [id, actualDuration] of commit.fiberActualDurations) {
+      const selfDuration = commit.fiberSelfDurations.get(id) || 0;
+      const desc = commit.changeDescriptions.get(id);
+      components.push({
+        id,
+        displayName: tree.getNode(id)?.displayName || this.displayNames.get(id) || `Component#${id}`,
+        actualDuration,
+        selfDuration,
+        causes: desc ? describeCauses(desc) : []
+      });
+    }
+    components.sort((a, b) => b.selfDuration - a.selfDuration);
+    const totalCount = components.length;
+    return {
+      index,
+      timestamp: commit.timestamp,
+      duration: commit.duration,
+      components: limit > 0 ? components.slice(0, limit) : components,
+      totalComponents: totalCount
+    };
+  }
+  getTimeline(limit) {
+    if (!this.session) return [];
+    const entries = this.session.commits.map((commit, index) => ({
+      index,
+      timestamp: commit.timestamp,
+      duration: commit.duration,
+      componentCount: commit.fiberActualDurations.size
+    }));
+    if (limit) return entries.slice(0, limit);
+    return entries;
+  }
+  getAllReports(tree) {
+    if (!this.session) return [];
+    const componentIds = /* @__PURE__ */ new Set();
+    for (const commit of this.session.commits) {
+      for (const id of commit.fiberActualDurations.keys()) {
+        componentIds.add(id);
+      }
+    }
+    const reports = [];
+    for (const id of componentIds) {
+      const report = this.getReport(id, tree);
+      if (report) reports.push(report);
+    }
+    return reports;
+  }
+};
+function parseDurations(raw, target) {
+  if (raw.length === 0) return;
+  if (Array.isArray(raw[0])) {
+    for (const [id, duration] of raw) {
+      target.set(id, duration);
+    }
+  } else {
+    const flat = raw;
+    for (let i = 0; i < flat.length; i += 2) {
+      target.set(flat[i], flat[i + 1]);
+    }
+  }
+}
+function describeCauses(desc) {
+  const causes = [];
+  if (desc.isFirstMount) {
+    causes.push("first-mount");
+    return causes;
+  }
+  if (desc.props && desc.props.length > 0) causes.push("props-changed");
+  if (desc.state && desc.state.length > 0) causes.push("state-changed");
+  if (desc.didHooksChange) causes.push("hooks-changed");
+  if (causes.length === 0) causes.push("parent-rendered");
+  return causes;
+}
+
+// src/daemon.ts
+var DEFAULT_STATE_DIR = path.join(
+  process.env.HOME || process.env.USERPROFILE || "/tmp",
+  ".agent-react-devtools"
+);
+var STATE_DIR = DEFAULT_STATE_DIR;
+function getSocketPath() {
+  return path.join(STATE_DIR, "daemon.sock");
+}
+function getDaemonInfoPath() {
+  return path.join(STATE_DIR, "daemon.json");
+}
+var Daemon = class {
+  ipcServer = null;
+  bridge;
+  tree;
+  profiler;
+  port;
+  startedAt = Date.now();
+  constructor(port2) {
+    this.port = port2;
+    this.tree = new ComponentTree();
+    this.profiler = new Profiler();
+    this.bridge = new DevToolsBridge(port2, this.tree, this.profiler);
+  }
+  async start() {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const socketPath = getSocketPath();
+    if (fs.existsSync(socketPath)) {
+      try {
+        fs.unlinkSync(socketPath);
+      } catch {
+      }
+    }
+    await this.bridge.start();
+    await this.startIpc(socketPath);
+    const info = {
+      pid: process.pid,
+      port: this.port,
+      socketPath,
+      startedAt: this.startedAt
+    };
+    fs.writeFileSync(getDaemonInfoPath(), JSON.stringify(info, null, 2));
+    console.log(`Daemon started (pid=${process.pid}, port=${this.port})`);
+    const shutdown = () => {
+      this.stop();
+      process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+  }
+  startIpc(socketPath) {
+    return new Promise((resolve, reject) => {
+      this.ipcServer = net.createServer((conn) => {
+        let buffer = "";
+        conn.on("data", (chunk) => {
+          buffer += chunk.toString();
+          let newlineIdx;
+          while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, newlineIdx);
+            buffer = buffer.slice(newlineIdx + 1);
+            try {
+              const cmd = JSON.parse(line);
+              this.handleCommand(cmd).then((response) => {
+                conn.write(JSON.stringify(response) + "\n");
+              });
+            } catch {
+              const response = {
+                ok: false,
+                error: "Invalid JSON"
+              };
+              conn.write(JSON.stringify(response) + "\n");
+            }
+          }
+        });
+      });
+      this.ipcServer.on("error", reject);
+      this.ipcServer.listen(socketPath, () => {
+        resolve();
+      });
+    });
+  }
+  async handleCommand(cmd) {
+    try {
+      switch (cmd.type) {
+        case "ping":
+          return { ok: true, data: "pong" };
+        case "status":
+          return {
+            ok: true,
+            data: {
+              daemonRunning: true,
+              port: this.port,
+              connectedApps: this.bridge.getConnectedAppCount(),
+              componentCount: this.tree.getComponentCount(),
+              profilingActive: this.profiler.isActive(),
+              uptime: Date.now() - this.startedAt
+            }
+          };
+        case "get-tree":
+          return {
+            ok: true,
+            data: this.tree.getTree(cmd.depth)
+          };
+        case "get-component": {
+          const resolvedId = this.tree.resolveId(cmd.id);
+          if (resolvedId === void 0) {
+            return { ok: false, error: `Component ${cmd.id} not found` };
+          }
+          const element = await this.bridge.inspectElement(resolvedId);
+          if (!element) {
+            return { ok: false, error: `Component ${cmd.id} not found` };
+          }
+          const label = typeof cmd.id === "string" ? cmd.id : void 0;
+          return { ok: true, data: element, label };
+        }
+        case "find":
+          return {
+            ok: true,
+            data: this.tree.findByName(cmd.name, cmd.exact)
+          };
+        case "count":
+          return {
+            ok: true,
+            data: this.tree.getCountByType()
+          };
+        case "profile-start":
+          this.profiler.start(cmd.name);
+          for (const id of this.tree.getAllNodeIds()) {
+            const node = this.tree.getNode(id);
+            if (node) this.profiler.trackComponent(id, node.displayName);
+          }
+          this.bridge.startProfiling();
+          return { ok: true, data: "Profiling started" };
+        case "profile-stop": {
+          await this.bridge.stopProfilingAndCollect();
+          const session = this.profiler.stop(this.tree);
+          if (!session) {
+            return { ok: false, error: "No active profiling session" };
+          }
+          return { ok: true, data: session };
+        }
+        case "profile-report": {
+          const resolvedCompId = this.tree.resolveId(cmd.componentId);
+          if (resolvedCompId === void 0) {
+            return { ok: false, error: `Component ${cmd.componentId} not found` };
+          }
+          const report = this.profiler.getReport(resolvedCompId, this.tree);
+          if (!report) {
+            return {
+              ok: false,
+              error: `No profiling data for component ${cmd.componentId}`
+            };
+          }
+          const compLabel = typeof cmd.componentId === "string" ? cmd.componentId : void 0;
+          return { ok: true, data: report, label: compLabel };
+        }
+        case "profile-slow":
+          return {
+            ok: true,
+            data: this.profiler.getSlowest(this.tree, cmd.limit)
+          };
+        case "profile-rerenders":
+          return {
+            ok: true,
+            data: this.profiler.getMostRerenders(this.tree, cmd.limit)
+          };
+        case "profile-timeline":
+          return {
+            ok: true,
+            data: this.profiler.getTimeline(cmd.limit)
+          };
+        case "profile-commit": {
+          const detail = this.profiler.getCommitDetails(cmd.index, this.tree, cmd.limit);
+          if (!detail) {
+            return { ok: false, error: `Commit #${cmd.index} not found` };
+          }
+          return { ok: true, data: detail };
+        }
+        default:
+          return { ok: false, error: `Unknown command: ${cmd.type}` };
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  stop() {
+    this.bridge.stop();
+    if (this.ipcServer) {
+      this.ipcServer.close();
+      this.ipcServer = null;
+    }
+    try {
+      fs.unlinkSync(getSocketPath());
+    } catch {
+    }
+    try {
+      fs.unlinkSync(getDaemonInfoPath());
+    } catch {
+    }
+    console.log("Daemon stopped");
+  }
+};
+var portArg = process.argv.find((a) => a.startsWith("--port="));
+var port = portArg ? parseInt(portArg.split("=")[1], 10) : 8097;
+var stateDirArg = process.argv.find((a) => a.startsWith("--state-dir="));
+if (stateDirArg) {
+  STATE_DIR = stateDirArg.split("=")[1];
+}
+var daemon = new Daemon(port);
+daemon.start().catch((err) => {
+  console.error("Failed to start daemon:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map