tui-devtools 0.1.0

package/dist/chunk-UV6LYAWB.js

@@ -0,0 +1,925 @@
+#!/usr/bin/env node
+
+// src/daemon.ts
+import fs from "fs";
+import path from "path";
+import net from "net";
+
+// src/server.ts
+import { WebSocketServer } from "ws";
+
+// src/store.ts
+var MAX_LOGS = 500;
+var DevToolsStore = class {
+  roots = /* @__PURE__ */ new Map();
+  nodes = /* @__PURE__ */ new Map();
+  logs = [];
+  connected = false;
+  appName = null;
+  rendererIds = [];
+  // Pending inspection responses keyed by request ID
+  inspectCallbacks = /* @__PURE__ */ new Map();
+  nextRequestId = 1;
+  addNode(node) {
+    this.nodes.set(node.id, node);
+    if (node.parentId === null || node.parentId === 0) {
+      this.roots.set(node.id, node);
+    }
+  }
+  removeNode(id) {
+    const node = this.nodes.get(id);
+    if (node) {
+      if (node.parentId !== null) {
+        const parent = this.nodes.get(node.parentId);
+        if (parent) {
+          parent.childIds = parent.childIds.filter((cid) => cid !== id);
+        }
+      }
+      for (const childId of node.childIds) {
+        this.removeNode(childId);
+      }
+      this.nodes.delete(id);
+      this.roots.delete(id);
+    }
+  }
+  addLog(entry) {
+    this.logs.push(entry);
+    if (this.logs.length > MAX_LOGS) {
+      this.logs = this.logs.slice(-MAX_LOGS);
+    }
+  }
+  findByName(name) {
+    for (const node of this.nodes.values()) {
+      if (node.displayName === name) return node;
+    }
+    for (const node of this.nodes.values()) {
+      if (node.displayName?.includes(name)) return node;
+    }
+    return null;
+  }
+  findAllByName(name) {
+    const results = [];
+    for (const node of this.nodes.values()) {
+      if (node.displayName?.includes(name)) results.push(node);
+    }
+    return results;
+  }
+  getTree(rootId, maxDepth = 20) {
+    const lines = [];
+    const roots = rootId ? [this.nodes.get(rootId)].filter(Boolean) : [...this.roots.values()];
+    for (const root of roots) {
+      this.printNode(root, 0, maxDepth, lines);
+    }
+    return lines.join("\n");
+  }
+  getTreeJson(rootId, maxDepth = 20) {
+    const roots = rootId ? [this.nodes.get(rootId)].filter(Boolean) : [...this.roots.values()];
+    return roots.map((r) => this.nodeToJson(r, 0, maxDepth));
+  }
+  printNode(node, depth, maxDepth, lines) {
+    if (depth > maxDepth) return;
+    const indent = "  ".repeat(depth);
+    const name = node.displayName || `<${node.type}>`;
+    const keyStr = node.key ? ` key="${node.key}"` : "";
+    lines.push(`${indent}${name}${keyStr} [${node.id}]`);
+    for (const childId of node.childIds) {
+      const child = this.nodes.get(childId);
+      if (child) this.printNode(child, depth + 1, maxDepth, lines);
+    }
+  }
+  nodeToJson(node, depth, maxDepth) {
+    const children = depth < maxDepth ? node.childIds.map((id) => this.nodes.get(id)).filter(Boolean).map((child) => this.nodeToJson(child, depth + 1, maxDepth)) : [];
+    return {
+      id: node.id,
+      name: node.displayName,
+      type: node.type,
+      key: node.key,
+      children
+    };
+  }
+  registerInspectCallback(callback) {
+    const id = this.nextRequestId++;
+    this.inspectCallbacks.set(id, callback);
+    return id;
+  }
+  resolveInspectCallback(requestId, data) {
+    const cb = this.inspectCallbacks.get(requestId);
+    if (cb) {
+      this.inspectCallbacks.delete(requestId);
+      cb(data);
+    }
+  }
+  clear() {
+    this.roots.clear();
+    this.nodes.clear();
+    this.logs = [];
+    this.connected = false;
+    this.appName = null;
+    this.rendererIds = [];
+  }
+};
+
+// src/types.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 ElementTypeClass = 1;
+var ElementTypeFunction = 2;
+var ElementTypeHostComponent = 5;
+var ElementTypeRoot = 9;
+
+// src/bridge.ts
+var DevToolsBridge = class {
+  ws = null;
+  store;
+  onLog;
+  debugLog;
+  constructor(store, onLog, debugLog) {
+    this.store = store;
+    this.onLog = onLog;
+    this.debugLog = debugLog;
+  }
+  attach(ws) {
+    this.ws = ws;
+    this.store.connected = true;
+    ws.on("message", (data) => {
+      try {
+        const raw = typeof data === "string" ? data : data.toString();
+        const msg = JSON.parse(raw);
+        this.debugLog?.(`[MSG] event=${msg.event} payload_type=${typeof msg.payload} payload_keys=${msg.payload && typeof msg.payload === "object" ? Object.keys(msg.payload).join(",") : Array.isArray(msg.payload) ? `array[${msg.payload.length}]` : String(msg.payload)?.slice(0, 80)}`);
+        this.handleMessage(msg);
+      } catch (e) {
+        this.debugLog?.(`[PARSE_ERR] ${e.message} raw=${(typeof data === "string" ? data : data.toString()).slice(0, 200)}`);
+      }
+    });
+    ws.on("close", () => {
+      this.store.connected = false;
+      this.ws = null;
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.event) {
+      case "operations": {
+        let ops;
+        if (Array.isArray(msg.payload)) {
+          ops = msg.payload;
+        } else if (msg.payload && typeof msg.payload === "object") {
+          const obj = msg.payload;
+          const keys = Object.keys(obj).map(Number).sort((a, b) => a - b);
+          ops = keys.map((k) => obj[String(k)]);
+        } else {
+          break;
+        }
+        this.debugLog?.(`[OPS] parsed ${ops.length} entries: [${ops.join(",")}]`);
+        this.handleOperations(ops);
+        break;
+      }
+      case "inspectedElement":
+        this.handleInspectedElement(msg.payload);
+        break;
+      case "shutdown":
+        this.store.connected = false;
+        break;
+      // Console capture — DevTools patches console methods and sends logs
+      case "console-log":
+      case "console-warn":
+      case "console-error":
+      case "console-info":
+      case "console-debug": {
+        const level = msg.event.replace("console-", "");
+        const entry = {
+          level,
+          args: Array.isArray(msg.payload) ? msg.payload : [msg.payload],
+          timestamp: Date.now()
+        };
+        this.store.addLog(entry);
+        this.onLog?.(entry);
+        break;
+      }
+      // DevTools backend sends renderer info
+      case "renderer": {
+        const payload = msg.payload;
+        if (payload?.id != null) {
+          this.store.rendererIds.push(payload.id);
+        }
+        break;
+      }
+      case "renderer-attached": {
+        const payload = msg.payload;
+        if (payload?.id != null && !this.store.rendererIds.includes(payload.id)) {
+          this.store.rendererIds.push(payload.id);
+        }
+        break;
+      }
+    }
+  }
+  handleOperations(ops) {
+    if (!ops || ops.length === 0) return;
+    let i = 0;
+    const rendererId = ops[i++];
+    const rootId = ops[i++];
+    if (!this.store.rendererIds.includes(rendererId)) {
+      this.store.rendererIds.push(rendererId);
+    }
+    const stringTableSize = ops[i++];
+    const stringTable = [""];
+    const stringTableEnd = i + stringTableSize;
+    while (i < stringTableEnd) {
+      const len = ops[i++];
+      const chars = [];
+      for (let j = 0; j < len; j++) {
+        chars.push(String.fromCharCode(ops[i++]));
+      }
+      stringTable.push(chars.join(""));
+    }
+    this.debugLog?.(`[OPS] stringTable=[${stringTable.join(",")}] remaining=${ops.length - i} ops`);
+    while (i < ops.length) {
+      const op = ops[i++];
+      switch (op) {
+        case TREE_OPERATION_ADD: {
+          const id = ops[i++];
+          const elementType = ops[i++];
+          const parentId = ops[i++];
+          const ownerID = ops[i++];
+          void ownerID;
+          const displayNameIndex = ops[i++];
+          const keyIndex = ops[i++];
+          const displayName = stringTable[displayNameIndex] || null;
+          const key = stringTable[keyIndex] || null;
+          let type = "other";
+          if (elementType === ElementTypeFunction) type = "function";
+          else if (elementType === ElementTypeClass) type = "class";
+          else if (elementType === ElementTypeHostComponent) type = "host";
+          else if (elementType === ElementTypeRoot) type = "other";
+          const resolvedParentId = parentId === 0 ? null : parentId;
+          const node = {
+            id,
+            displayName,
+            type,
+            parentId: resolvedParentId,
+            childIds: [],
+            key
+          };
+          this.debugLog?.(`[ADD] id=${id} type=${type} parent=${resolvedParentId} name=${displayName}`);
+          this.store.addNode(node);
+          if (resolvedParentId != null) {
+            const parent = this.store.nodes.get(resolvedParentId);
+            if (parent && !parent.childIds.includes(id)) {
+              parent.childIds.push(id);
+            }
+          }
+          break;
+        }
+        case TREE_OPERATION_REMOVE: {
+          const removeCount = ops[i++];
+          for (let j = 0; j < removeCount; j++) {
+            const id = ops[i++];
+            this.store.removeNode(id);
+          }
+          break;
+        }
+        case TREE_OPERATION_REORDER_CHILDREN: {
+          const id = ops[i++];
+          const childCount = ops[i++];
+          const newChildIds = [];
+          for (let j = 0; j < childCount; j++) {
+            newChildIds.push(ops[i++]);
+          }
+          const node = this.store.nodes.get(id);
+          if (node) node.childIds = newChildIds;
+          break;
+        }
+        case TREE_OPERATION_UPDATE_TREE_BASE_DURATION: {
+          i++;
+          i++;
+          break;
+        }
+        case TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS: {
+          i++;
+          i++;
+          i++;
+          break;
+        }
+        case TREE_OPERATION_REMOVE_ROOT: {
+          break;
+        }
+        case TREE_OPERATION_SET_SUBTREE_MODE: {
+          i++;
+          i++;
+          break;
+        }
+        default:
+          this.debugLog?.(`[OPS] unknown op=${op} at index=${i - 1}`);
+          break;
+      }
+    }
+  }
+  handleInspectedElement(payload) {
+    const p = payload;
+    if (p?.responseID != null) {
+      this.store.resolveInspectCallback(p.responseID, p.value);
+    }
+    if (p?.id != null && p?.value) {
+      const node = this.store.nodes.get(p.id);
+      if (node) {
+        if (p.value.props) node.props = p.value.props;
+        if (p.value.state) node.state = p.value.state;
+      }
+    }
+  }
+  /** Request element inspection from the DevTools backend */
+  inspectElement(id) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws) {
+        reject(new Error("Not connected"));
+        return;
+      }
+      const requestId = this.store.registerInspectCallback(resolve);
+      const rendererId = this.store.rendererIds[0] ?? 1;
+      this.ws.send(JSON.stringify({
+        event: "inspectElement",
+        payload: {
+          id,
+          rendererID: rendererId,
+          requestID: requestId,
+          forceFullData: true,
+          path: null
+        }
+      }));
+      setTimeout(() => {
+        this.store.resolveInspectCallback(requestId, null);
+      }, 5e3);
+    });
+  }
+  detach() {
+    this.ws?.close();
+    this.ws = null;
+    this.store.connected = false;
+  }
+};
+
+// src/server.ts
+var DevToolsServer = class {
+  wss = null;
+  store;
+  bridge;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.store = new DevToolsStore();
+    this.bridge = new DevToolsBridge(this.store, options.onLog, options.debugLog);
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      const host = this.options.host ?? "127.0.0.1";
+      this.wss = new WebSocketServer({ port: this.options.port, host });
+      this.wss.on("listening", () => {
+        resolve();
+      });
+      this.wss.on("error", (err) => {
+        reject(err);
+      });
+      this.wss.on("connection", (ws) => {
+        this.bridge.attach(ws);
+        this.options.onConnect?.();
+        ws.on("close", () => {
+          this.options.onDisconnect?.();
+        });
+      });
+    });
+  }
+  stop() {
+    this.bridge.detach();
+    this.wss?.close();
+    this.wss = null;
+  }
+  getStore() {
+    return this.store;
+  }
+  getBridge() {
+    return this.bridge;
+  }
+  isConnected() {
+    return this.store.connected;
+  }
+};
+
+// src/pty-session.ts
+import * as pty from "node-pty";
+import xtermPkg from "@xterm/headless";
+import unicode11Pkg from "@xterm/addon-unicode11";
+var { Terminal } = xtermPkg;
+var { Unicode11Addon } = unicode11Pkg;
+var PtySession = class {
+  id;
+  command;
+  ptyProcess;
+  terminal;
+  _running = true;
+  exitCode = null;
+  cols;
+  rows;
+  constructor(id, options) {
+    this.id = id;
+    this.command = options.command;
+    this.cols = options.cols ?? 120;
+    this.rows = options.rows ?? 40;
+    this.terminal = new Terminal({
+      cols: this.cols,
+      rows: this.rows,
+      allowProposedApi: true
+    });
+    const unicode11 = new Unicode11Addon();
+    this.terminal.loadAddon(unicode11);
+    this.terminal.unicode.activeVersion = "11";
+    const env = { ...process.env, ...options.env };
+    if (!env.TERM) env.TERM = "xterm-256color";
+    if (!env.FORCE_COLOR) env.FORCE_COLOR = "1";
+    env.COLUMNS = String(this.cols);
+    env.LINES = String(this.rows);
+    const shell = process.env.SHELL || "/bin/bash";
+    const shellArgs = ["-c", options.command];
+    this.ptyProcess = pty.spawn(shell, shellArgs, {
+      name: "xterm-256color",
+      cols: this.cols,
+      rows: this.rows,
+      cwd: options.cwd ?? process.cwd(),
+      env
+    });
+    this.ptyProcess.onData((data) => {
+      this.terminal.write(data);
+    });
+    this.ptyProcess.onExit(({ exitCode }) => {
+      this._running = false;
+      this.exitCode = exitCode;
+    });
+  }
+  /** Simple shell-like string splitting (handles quotes) */
+  shellSplit(cmd) {
+    const parts = [];
+    let current = "";
+    let inSingle = false;
+    let inDouble = false;
+    for (const ch of cmd) {
+      if (ch === "'" && !inDouble) {
+        inSingle = !inSingle;
+        continue;
+      }
+      if (ch === '"' && !inSingle) {
+        inDouble = !inDouble;
+        continue;
+      }
+      if (ch === " " && !inSingle && !inDouble) {
+        if (current) parts.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    if (current) parts.push(current);
+    return parts;
+  }
+  get pid() {
+    return this.ptyProcess.pid;
+  }
+  get running() {
+    return this._running;
+  }
+  get info() {
+    return {
+      id: this.id,
+      command: this.command,
+      pid: this.ptyProcess.pid,
+      cols: this.cols,
+      rows: this.rows,
+      running: this._running
+    };
+  }
+  /** Capture current screen content as text */
+  screenshot(options) {
+    const buffer = this.terminal.buffer.active;
+    const lines = [];
+    for (let i = 0; i < this.rows; i++) {
+      const line = buffer.getLine(i);
+      if (line) {
+        lines.push(line.translateToString(true));
+      }
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.pop();
+    }
+    let text = lines.join("\n");
+    if (options?.stripAnsi) {
+      text = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+    }
+    return text;
+  }
+  /** Send key press to the PTY */
+  press(key) {
+    const seq = this.keyToSequence(key);
+    this.ptyProcess.write(seq);
+  }
+  /** Type text character by character */
+  type(text) {
+    this.ptyProcess.write(text);
+  }
+  /** Scroll the terminal viewport */
+  scroll(direction, amount = 1) {
+    for (let i = 0; i < amount; i++) {
+      if (direction === "up") {
+        this.ptyProcess.write("\x1B[5~");
+      } else {
+        this.ptyProcess.write("\x1B[6~");
+      }
+    }
+  }
+  /** Resize the terminal */
+  resize(cols, rows) {
+    this.ptyProcess.resize(cols, rows);
+    this.terminal.resize(cols, rows);
+  }
+  /** Wait for text to appear on screen */
+  async wait(text, timeoutMs = 3e4) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const screen = this.screenshot();
+      if (screen.includes(text)) return true;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    return false;
+  }
+  /** Kill the PTY process */
+  kill(signal = "SIGTERM") {
+    try {
+      this.ptyProcess.kill(signal);
+    } catch {
+    }
+    this._running = false;
+  }
+  /** Clean up resources */
+  dispose() {
+    this.kill();
+    this.terminal.dispose();
+  }
+  /** Convert key name to terminal escape sequence */
+  keyToSequence(key) {
+    const keyMap = {
+      "Enter": "\r",
+      "Return": "\r",
+      "Tab": "	",
+      "Escape": "\x1B",
+      "Backspace": "\x7F",
+      "Delete": "\x1B[3~",
+      "Space": " ",
+      "ArrowUp": "\x1B[A",
+      "ArrowDown": "\x1B[B",
+      "ArrowRight": "\x1B[C",
+      "ArrowLeft": "\x1B[D",
+      "Home": "\x1B[H",
+      "End": "\x1B[F",
+      "PageUp": "\x1B[5~",
+      "PageDown": "\x1B[6~",
+      "Insert": "\x1B[2~",
+      "F1": "\x1BOP",
+      "F2": "\x1BOQ",
+      "F3": "\x1BOR",
+      "F4": "\x1BOS",
+      "F5": "\x1B[15~",
+      "F6": "\x1B[17~",
+      "F7": "\x1B[18~",
+      "F8": "\x1B[19~",
+      "F9": "\x1B[20~",
+      "F10": "\x1B[21~",
+      "F11": "\x1B[23~",
+      "F12": "\x1B[24~",
+      "Ctrl-c": "",
+      "Ctrl-d": "",
+      "Ctrl-z": "",
+      "Ctrl-l": "\f",
+      "Ctrl-a": "
",
+      "Ctrl-e": "",
+      "Ctrl-k": "\v",
+      "Ctrl-u": ""
+    };
+    return keyMap[key] ?? key;
+  }
+};
+
+// src/session-manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(id, options) {
+    if (this.sessions.has(id)) {
+      this.sessions.get(id).dispose();
+    }
+    const session = new PtySession(id, options);
+    this.sessions.set(id, session);
+    return session.info;
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  list() {
+    return [...this.sessions.values()].map((s) => s.info);
+  }
+  kill(id) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    session.dispose();
+    this.sessions.delete(id);
+    return true;
+  }
+  killAll() {
+    for (const session of this.sessions.values()) {
+      session.dispose();
+    }
+    this.sessions.clear();
+  }
+};
+
+// src/daemon.ts
+var BASE_DIR = path.join(process.env.HOME ?? "/tmp", ".tui-devtools");
+function ensureBaseDir() {
+  fs.mkdirSync(BASE_DIR, { recursive: true });
+}
+function getSocketPath(session) {
+  return path.join(BASE_DIR, `${session}.sock`);
+}
+function getPidPath(session) {
+  return path.join(BASE_DIR, `${session}.pid`);
+}
+function getLogPath(session) {
+  return path.join(BASE_DIR, `${session}.log`);
+}
+function isDaemonRunning(session) {
+  const pidPath = getPidPath(session);
+  try {
+    const pid = parseInt(fs.readFileSync(pidPath, "utf-8").trim(), 10);
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sendIpcRequest(session, request) {
+  return new Promise((resolve, reject) => {
+    const socketPath = getSocketPath(session);
+    const client = net.createConnection(socketPath);
+    let buffer = "";
+    client.on("connect", () => {
+      client.write(JSON.stringify(request) + "\n");
+    });
+    client.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split("\n");
+      if (lines.length > 1) {
+        try {
+          const response = JSON.parse(lines[0]);
+          client.end();
+          resolve(response);
+        } catch (e) {
+          reject(new Error(`Invalid IPC response: ${lines[0]}`));
+        }
+      }
+    });
+    client.on("error", (err) => {
+      reject(new Error(`Cannot connect to daemon (session: ${session}): ${err.message}`));
+    });
+    setTimeout(() => {
+      client.destroy();
+      reject(new Error("IPC timeout"));
+    }, 1e4);
+  });
+}
+async function startDaemon(session, port) {
+  ensureBaseDir();
+  const socketPath = getSocketPath(session);
+  try {
+    fs.unlinkSync(socketPath);
+  } catch {
+  }
+  fs.writeFileSync(getPidPath(session), String(process.pid));
+  const logStream = fs.createWriteStream(getLogPath(session), { flags: "a" });
+  const log = (msg) => {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    logStream.write(`[${ts}] ${msg}
+`);
+  };
+  const sessionMgr = new SessionManager();
+  const devtools = new DevToolsServer({
+    port,
+    onLog: (entry) => {
+      log(`[${entry.level}] ${entry.args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}`);
+    },
+    onConnect: () => log("App connected"),
+    onDisconnect: () => log("App disconnected"),
+    debugLog: (msg) => log(msg)
+  });
+  await devtools.start();
+  log(`DevTools server listening on port ${port}`);
+  const ipcServer = net.createServer((conn) => {
+    let buffer = "";
+    conn.on("data", async (data) => {
+      buffer += data.toString();
+      const lines = buffer.split("\n");
+      if (lines.length <= 1) return;
+      buffer = lines.slice(1).join("\n");
+      try {
+        const req = JSON.parse(lines[0]);
+        const res = await handleIpcRequest(req, devtools, sessionMgr, log);
+        conn.write(JSON.stringify(res) + "\n");
+      } catch (e) {
+        conn.write(JSON.stringify({ ok: false, error: String(e) }) + "\n");
+      }
+    });
+  });
+  ipcServer.listen(socketPath);
+  log(`IPC server listening on ${socketPath}`);
+  const cleanup = () => {
+    log("Shutting down...");
+    sessionMgr.killAll();
+    devtools.stop();
+    ipcServer.close();
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(getPidPath(session));
+    } catch {
+    }
+    logStream.end();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}
+async function handleIpcRequest(req, devtools, sessionMgr, log) {
+  const store = devtools.getStore();
+  const bridge = devtools.getBridge();
+  switch (req.command) {
+    // ─── DevTools commands ───
+    case "status":
+      return {
+        ok: true,
+        data: {
+          connected: store.connected,
+          appName: store.appName,
+          nodeCount: store.nodes.size,
+          rootCount: store.roots.size,
+          logCount: store.logs.length,
+          rendererIds: store.rendererIds,
+          sessions: sessionMgr.list()
+        }
+      };
+    case "tree": {
+      const depth = req.args?.depth ?? 20;
+      const json = req.args?.json;
+      if (json) {
+        return { ok: true, data: store.getTreeJson(void 0, depth) };
+      }
+      return { ok: true, data: store.getTree(void 0, depth) };
+    }
+    case "inspect": {
+      const name = req.args?.name;
+      const id = req.args?.id;
+      let node = id != null ? store.nodes.get(id) : null;
+      if (!node && name) {
+        node = store.findByName(name);
+      }
+      if (!node) {
+        return { ok: false, error: `Component not found: ${name ?? id}` };
+      }
+      const inspectData = await bridge.inspectElement(node.id);
+      return {
+        ok: true,
+        data: {
+          id: node.id,
+          displayName: node.displayName,
+          type: node.type,
+          key: node.key,
+          parentId: node.parentId,
+          childIds: node.childIds,
+          props: node.props,
+          state: node.state,
+          inspectData
+        }
+      };
+    }
+    case "logs": {
+      const level = req.args?.level;
+      const tail = req.args?.tail ?? 50;
+      let logs = store.logs;
+      if (level) {
+        logs = logs.filter((l) => l.level === level);
+      }
+      logs = logs.slice(-tail);
+      return { ok: true, data: logs };
+    }
+    case "find": {
+      const name = req.args?.name;
+      if (!name) return { ok: false, error: "name is required" };
+      const nodes = store.findAllByName(name);
+      return {
+        ok: true,
+        data: nodes.map((n) => ({
+          id: n.id,
+          displayName: n.displayName,
+          type: n.type,
+          key: n.key
+        }))
+      };
+    }
+    // ─── PTY automation commands ───
+    case "run": {
+      const command = req.args?.command;
+      const sessionId = req.args?.sessionId ?? "default";
+      const cwd = req.args?.cwd;
+      const cols = req.args?.cols;
+      const rows = req.args?.rows;
+      const env = req.args?.env;
+      if (!command) return { ok: false, error: "command is required" };
+      log(`[PTY] run session=${sessionId} command=${command}`);
+      const info = sessionMgr.create(sessionId, { command, cwd, cols, rows, env });
+      return { ok: true, data: info };
+    }
+    case "screenshot": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const stripAnsi = req.args?.stripAnsi;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      const text = session.screenshot({ stripAnsi });
+      return { ok: true, data: { screenshot: text, running: session.running } };
+    }
+    case "press": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const keys = req.args?.keys;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      for (const key of keys ?? []) {
+        session.press(key);
+      }
+      return { ok: true };
+    }
+    case "type": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const text = req.args?.text;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      if (!text) return { ok: false, error: "text is required" };
+      session.type(text);
+      return { ok: true };
+    }
+    case "scroll": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const direction = req.args?.direction ?? "down";
+      const amount = req.args?.amount ?? 1;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      session.scroll(direction, amount);
+      return { ok: true };
+    }
+    case "wait": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const text = req.args?.text;
+      const timeout = req.args?.timeout ?? 3e4;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      if (!text) return { ok: false, error: "text is required" };
+      const found = await session.wait(text, timeout);
+      return { ok: true, data: { found, screenshot: session.screenshot() } };
+    }
+    case "resize": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const cols = req.args?.cols ?? 120;
+      const rows = req.args?.rows ?? 40;
+      const session = sessionMgr.get(sessionId);
+      if (!session) return { ok: false, error: `Session not found: ${sessionId}` };
+      session.resize(cols, rows);
+      return { ok: true };
+    }
+    case "kill-session": {
+      const sessionId = req.args?.sessionId ?? "default";
+      const killed = sessionMgr.kill(sessionId);
+      return { ok: killed, error: killed ? void 0 : `Session not found: ${sessionId}` };
+    }
+    case "sessions":
+      return { ok: true, data: sessionMgr.list() };
+    default:
+      return { ok: false, error: `Unknown command: ${req.command}` };
+  }
+}
+
+export {
+  getSocketPath,
+  getPidPath,
+  getLogPath,
+  isDaemonRunning,
+  sendIpcRequest,
+  startDaemon
+};
+//# sourceMappingURL=chunk-UV6LYAWB.js.map