@rallycry/conveyor-agent 6.0.2 → 6.0.4

package/dist/index.js

@@ -5,14 +5,1273 @@ import {
   ProjectConnection,
   ProjectRunner,
   ensureWorktree,
+  injectTelemetry,
   loadConveyorConfig,
   removeWorktree,
   runSetupCommand,
   runStartCommand
-} from "./chunk-HYWZJYPW.js";
+} from "./chunk-NKZSUGND.js";
+
+// src/debug/cdp-client.ts
+var MAX_VARIABLE_VALUE_BYTES = 2048;
+var MAX_VARIABLES_PER_SCOPE = 50;
+var AUTO_RESUME_TIMEOUT_MS = 3e4;
+var PROBE_BUFFER_MAX_SIZE = 1e3;
+var CdpDebugClient = class {
+  ws = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  breakpoints = /* @__PURE__ */ new Map();
+  probes = /* @__PURE__ */ new Map();
+  probeCounter = 0;
+  probeBufferInjected = false;
+  pausedState = null;
+  autoResumeTimer = null;
+  protocol = "cdp";
+  onPausedCallback = null;
+  onResumedCallback = null;
+  onAutoResumedCallback = null;
+  // ── Connection ─────────────────────────────────────────────────────────
+  // oxlint-disable-next-line require-await
+  async connect(wsUrl, protocol) {
+    if (this.ws) {
+      throw new Error("Already connected to CDP");
+    }
+    this.protocol = protocol ?? "cdp";
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.addEventListener("open", async () => {
+        this.ws = ws;
+        try {
+          await this.send("Debugger.enable", {});
+          await this.send("Runtime.enable", {});
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+      ws.addEventListener("message", (event) => {
+        const data = typeof event.data === "string" ? event.data : String(event.data);
+        this.handleMessage(data);
+      });
+      ws.addEventListener("error", () => {
+        reject(new Error(`CDP WebSocket connection failed: ${wsUrl}`));
+      });
+      ws.addEventListener("close", () => {
+        this.cleanup();
+      });
+    });
+  }
+  disconnect() {
+    if (this.ws) {
+      this.clearAutoResumeTimer();
+      this.ws.close();
+      this.cleanup();
+    }
+  }
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  getProtocol() {
+    return this.protocol;
+  }
+  // ── Breakpoints ────────────────────────────────────────────────────────
+  async setBreakpoint(file, line, condition) {
+    const params = {
+      urlRegex: this.fileToUrlRegex(file),
+      // CDP uses 0-based lines
+      lineNumber: line - 1
+    };
+    if (condition) {
+      params.condition = condition;
+    }
+    const result = await this.send("Debugger.setBreakpointByUrl", params);
+    const breakpointId = result.breakpointId;
+    this.breakpoints.set(breakpointId, { breakpointId, file, line, condition });
+    return breakpointId;
+  }
+  async removeBreakpoint(breakpointId) {
+    await this.send("Debugger.removeBreakpoint", { breakpointId });
+    this.breakpoints.delete(breakpointId);
+  }
+  async removeAllBreakpoints() {
+    const ids = [...this.breakpoints.keys()];
+    for (const id of ids) {
+      try {
+        await this.removeBreakpoint(id);
+      } catch {
+        this.breakpoints.delete(id);
+      }
+    }
+  }
+  listBreakpoints() {
+    return [...this.breakpoints.values()];
+  }
+  // ── Probes (Logpoints) ────────────────────────────────────────────────
+  async setLogpoint(file, line, expressions, label) {
+    await this.ensureProbeBuffer();
+    const probeId = `probe-${++this.probeCounter}`;
+    const probeLabel = label ?? `${file}:${line}`;
+    const dataEntries = expressions.map((expr) => `${JSON.stringify(expr)}: (${expr})`).join(", ");
+    const condition = `(globalThis.__conveyorProbes?.probe(${JSON.stringify(probeLabel)}, {${dataEntries}}), false)`;
+    const breakpointId = await this.setBreakpoint(file, line, condition);
+    const probe = { probeId, breakpointId, file, line, expressions, label: probeLabel };
+    this.probes.set(probeId, probe);
+    return probeId;
+  }
+  async removeProbe(probeId) {
+    const probe = this.probes.get(probeId);
+    if (!probe) {
+      throw new Error(`Probe ${probeId} not found`);
+    }
+    await this.removeBreakpoint(probe.breakpointId);
+    this.probes.delete(probeId);
+  }
+  listProbes() {
+    return [...this.probes.values()];
+  }
+  async getProbeResults(label, limit) {
+    const args = [
+      label === void 0 ? "undefined" : JSON.stringify(label),
+      limit === void 0 ? "undefined" : String(limit)
+    ].join(", ");
+    const result = await this.evaluate(
+      `JSON.stringify(globalThis.__conveyorProbes?.read(${args}) ?? [])`
+    );
+    if (result.type === "error") {
+      return [];
+    }
+    try {
+      const raw = result.value;
+      const parsed = JSON.parse(raw.startsWith('"') ? JSON.parse(raw) : raw);
+      return parsed;
+    } catch {
+      return [];
+    }
+  }
+  async clearProbeResults(label) {
+    const arg = label === void 0 ? "undefined" : JSON.stringify(label);
+    await this.evaluate(`(globalThis.__conveyorProbes?.clear(${arg}), undefined)`);
+  }
+  // ── Paused State ───────────────────────────────────────────────────────
+  isPaused() {
+    return this.pausedState !== null;
+  }
+  getPausedState() {
+    return this.pausedState;
+  }
+  getCallStack() {
+    return this.pausedState?.callFrames ?? [];
+  }
+  async getScopeVariables(callFrameId) {
+    if (!this.pausedState) {
+      throw new Error("Debugger is not paused");
+    }
+    const frame = this.pausedState.callFrames.find((f) => f.callFrameId === callFrameId);
+    if (!frame) {
+      throw new Error(`Call frame ${callFrameId} not found`);
+    }
+    const result = await this.send("Debugger.evaluateOnCallFrame", {
+      callFrameId,
+      expression: "this",
+      returnByValue: false
+    });
+    const variables = [];
+    try {
+      const scopeResult = await this.send("Runtime.getProperties", {
+        objectId: result.result?.objectId,
+        ownProperties: true,
+        generatePreview: false
+      });
+      const descriptors = scopeResult.result ?? [];
+      for (const desc of descriptors.slice(0, MAX_VARIABLES_PER_SCOPE)) {
+        if (desc.value) {
+          variables.push({
+            name: desc.name,
+            type: desc.value.type,
+            value: this.truncateValue(this.formatRemoteObject(desc.value))
+          });
+        }
+      }
+    } catch {
+    }
+    return variables;
+  }
+  // ── Execution Control ──────────────────────────────────────────────────
+  async resume() {
+    this.clearAutoResumeTimer();
+    await this.send("Debugger.resume", {});
+    this.pausedState = null;
+  }
+  async stepOver() {
+    this.clearAutoResumeTimer();
+    await this.send("Debugger.stepOver", {});
+  }
+  async stepInto() {
+    this.clearAutoResumeTimer();
+    await this.send("Debugger.stepInto", {});
+  }
+  // ── Evaluation ─────────────────────────────────────────────────────────
+  async evaluate(expression, callFrameId) {
+    let result;
+    if (callFrameId && this.pausedState) {
+      result = await this.send("Debugger.evaluateOnCallFrame", {
+        callFrameId,
+        expression,
+        returnByValue: false,
+        generatePreview: true
+      });
+    } else {
+      result = await this.send("Runtime.evaluate", {
+        expression,
+        returnByValue: false,
+        generatePreview: true
+      });
+    }
+    const remoteObj = result.result;
+    const errorValue = this.extractEvalError(result, remoteObj);
+    if (errorValue !== null) {
+      return { type: "error", value: errorValue };
+    }
+    return {
+      type: remoteObj?.type ?? "undefined",
+      value: this.truncateValue(this.formatRemoteObject(remoteObj))
+    };
+  }
+  // ── Event Callbacks ────────────────────────────────────────────────────
+  onPaused(callback) {
+    this.onPausedCallback = callback;
+  }
+  onResumed(callback) {
+    this.onResumedCallback = callback;
+  }
+  onAutoResumed(callback) {
+    this.onAutoResumedCallback = callback;
+  }
+  // ── Private: CDP Communication ─────────────────────────────────────────
+  send(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        reject(new Error("CDP WebSocket is not connected"));
+        return;
+      }
+      const id = ++this.requestId;
+      const request = { id, method, params };
+      this.pendingRequests.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify(request));
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`CDP request timed out: ${method}`));
+        }
+      }, 1e4);
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if ("id" in msg && typeof msg.id === "number") {
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        this.pendingRequests.delete(msg.id);
+        const response = msg;
+        if (response.error) {
+          pending.reject(new Error(`CDP error: ${response.error.message}`));
+        } else {
+          pending.resolve(response.result ?? {});
+        }
+      }
+      return;
+    }
+    const event = msg;
+    if (event.method === "Debugger.paused") {
+      this.handlePaused(event.params ?? {});
+    } else if (event.method === "Debugger.resumed") {
+      this.pausedState = null;
+      this.clearAutoResumeTimer();
+      this.onResumedCallback?.();
+    }
+  }
+  handlePaused(params) {
+    const rawFrames = params.callFrames ?? [];
+    const reason = params.reason ?? "unknown";
+    const hitBreakpoints = params.hitBreakpoints;
+    const callFrames = rawFrames.map((frame, index) => ({
+      index,
+      functionName: frame.functionName || "(anonymous)",
+      file: frame.url,
+      // Convert to 1-based
+      line: frame.location.lineNumber + 1,
+      column: frame.location.columnNumber + 1,
+      callFrameId: frame.callFrameId
+    }));
+    this.pausedState = { callFrames, reason, hitBreakpoints };
+    this.clearAutoResumeTimer();
+    this.autoResumeTimer = setTimeout(() => {
+      if (this.pausedState) {
+        this.resume().then(() => {
+          this.onAutoResumedCallback?.();
+        }).catch(() => {
+        });
+      }
+    }, AUTO_RESUME_TIMEOUT_MS);
+    this.onPausedCallback?.(this.pausedState);
+  }
+  // ── Private: Probe Buffer ──────────────────────────────────────────────
+  async ensureProbeBuffer() {
+    if (this.probeBufferInjected) return;
+    await this.send("Runtime.evaluate", {
+      expression: `
+        globalThis.__conveyorProbes = globalThis.__conveyorProbes || {
+          _buffer: [],
+          _maxSize: ${PROBE_BUFFER_MAX_SIZE},
+          probe(label, data) {
+            this._buffer.push({ label, data, timestamp: Date.now() });
+            if (this._buffer.length > this._maxSize) this._buffer.shift();
+          },
+          read(label, limit) {
+            const items = label !== undefined
+              ? this._buffer.filter(function(e) { return e.label === label; })
+              : this._buffer;
+            return limit !== undefined ? items.slice(-limit) : items;
+          },
+          clear(label) {
+            if (label !== undefined) {
+              this._buffer = this._buffer.filter(function(e) { return e.label !== label; });
+            } else {
+              this._buffer = [];
+            }
+          }
+        };
+        "ok"
+      `,
+      returnByValue: true
+    });
+    this.probeBufferInjected = true;
+  }
+  // ── Private: Helpers ───────────────────────────────────────────────────
+  extractEvalError(result, remoteObj) {
+    if (this.protocol === "webkit") {
+      if (result.wasThrown) {
+        return remoteObj?.description ?? remoteObj?.value?.toString() ?? "Unknown error";
+      }
+      return null;
+    }
+    const exceptionDetails = result.exceptionDetails;
+    if (exceptionDetails) {
+      return exceptionDetails.exception?.description ?? exceptionDetails.text ?? "Unknown error";
+    }
+    return null;
+  }
+  fileToUrlRegex(file) {
+    const escaped = file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return `.*${escaped}$`;
+  }
+  formatRemoteObject(obj) {
+    if (!obj) return "undefined";
+    if (obj.type === "undefined") return "undefined";
+    if (obj.type === "boolean" || obj.type === "number") return String(obj.value);
+    if (obj.type === "string") return JSON.stringify(obj.value);
+    if (obj.value === null) return "null";
+    if (obj.description) return obj.description;
+    if (obj.subtype) return `[${obj.type}:${obj.subtype}]`;
+    return `[${obj.type}]`;
+  }
+  truncateValue(value) {
+    if (value.length <= MAX_VARIABLE_VALUE_BYTES) return value;
+    return value.slice(0, MAX_VARIABLE_VALUE_BYTES - 3) + "...";
+  }
+  clearAutoResumeTimer() {
+    if (this.autoResumeTimer) {
+      clearTimeout(this.autoResumeTimer);
+      this.autoResumeTimer = null;
+    }
+  }
+  cleanup() {
+    this.clearAutoResumeTimer();
+    this.ws = null;
+    this.pausedState = null;
+    this.probes.clear();
+    this.probeBufferInjected = false;
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new Error("CDP connection closed"));
+    }
+    this.pendingRequests.clear();
+  }
+};
+
+// src/debug/playwright-types.ts
+var MAX_VARIABLE_VALUE_BYTES2 = 2048;
+function formatRemoteObject(obj) {
+  if (!obj) return "undefined";
+  if (obj.type === "undefined") return "undefined";
+  if (obj.type === "boolean" || obj.type === "number") return String(obj.value);
+  if (obj.type === "string") return JSON.stringify(obj.value);
+  if (obj.value === null) return "null";
+  if (obj.description) return obj.description;
+  if (obj.subtype) return `[${obj.type}:${obj.subtype}]`;
+  return `[${obj.type}]`;
+}
+function truncateValue(value) {
+  if (value.length <= MAX_VARIABLE_VALUE_BYTES2) return value;
+  return value.slice(0, MAX_VARIABLE_VALUE_BYTES2 - 3) + "...";
+}
+
+// src/debug/playwright-client.ts
+var MAX_VARIABLES_PER_SCOPE2 = 50;
+var AUTO_RESUME_TIMEOUT_MS2 = 3e4;
+var PROBE_BUFFER_MAX_SIZE2 = 1e3;
+var BUFFER_MAX = 500;
+var ERROR_BUFFER_MAX = 200;
+var INACTIVITY_TIMEOUT_MS = 6e5;
+var PlaywrightDebugClient = class {
+  browser = null;
+  page = null;
+  cdpSession = null;
+  breakpoints = /* @__PURE__ */ new Map();
+  probes = /* @__PURE__ */ new Map();
+  probeCounter = 0;
+  probeBufferInjected = false;
+  pausedState = null;
+  autoResumeTimer = null;
+  inactivityTimer = null;
+  onPausedCallback = null;
+  onResumedCallback = null;
+  onAutoResumedCallback = null;
+  consoleMessages = [];
+  networkRequests = [];
+  pageErrors = [];
+  sourceMapDetected = null;
+  async launch(previewUrl) {
+    if (this.browser) throw new Error("Playwright browser is already running");
+    const { chromium } = await import("playwright-core");
+    this.browser = await chromium.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu"
+      ]
+    });
+    const context = this.browser.contexts()[0] ?? await this.browser.newContext();
+    this.page = await context.newPage();
+    this.setupPassiveCapture();
+    await this.page.goto(previewUrl, { waitUntil: "domcontentloaded" });
+    this.cdpSession = await context.newCDPSession(this.page);
+    await this.cdpSession.send("Debugger.enable", {});
+    await this.cdpSession.send("Runtime.enable", {});
+    this.setupCdpEvents();
+    await this.checkSourceMaps();
+    this.resetInactivityTimer();
+  }
+  async close() {
+    this.clearAutoResumeTimer();
+    this.clearInactivityTimer();
+    if (this.cdpSession) {
+      try {
+        await this.cdpSession.detach();
+      } catch {
+      }
+      this.cdpSession = null;
+    }
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch {
+      }
+      this.browser = null;
+    }
+    this.page = null;
+    this.pausedState = null;
+    this.breakpoints.clear();
+    this.probes.clear();
+    this.probeBufferInjected = false;
+    this.consoleMessages = [];
+    this.networkRequests = [];
+    this.pageErrors = [];
+  }
+  isConnected() {
+    return this.browser !== null && this.cdpSession !== null;
+  }
+  hasSourceMaps() {
+    return this.sourceMapDetected;
+  }
+  async setBreakpoint(file, line, condition) {
+    const session = this.requireSession();
+    this.resetInactivityTimer();
+    const params = {
+      urlRegex: this.fileToUrlRegex(file),
+      // CDP uses 0-based lines
+      lineNumber: line - 1
+    };
+    if (condition) params.condition = condition;
+    const result = await session.send("Debugger.setBreakpointByUrl", params);
+    const breakpointId = result.breakpointId;
+    this.breakpoints.set(breakpointId, { breakpointId, file, line, condition });
+    return breakpointId;
+  }
+  async removeBreakpoint(breakpointId) {
+    const session = this.requireSession();
+    await session.send("Debugger.removeBreakpoint", { breakpointId });
+    this.breakpoints.delete(breakpointId);
+  }
+  async removeAllBreakpoints() {
+    for (const id of [...this.breakpoints.keys()]) {
+      try {
+        await this.removeBreakpoint(id);
+      } catch {
+        this.breakpoints.delete(id);
+      }
+    }
+  }
+  listBreakpoints() {
+    return [...this.breakpoints.values()];
+  }
+  async setLogpoint(file, line, expressions, label) {
+    await this.ensureProbeBuffer();
+    const probeId = `client-probe-${++this.probeCounter}`;
+    const probeLabel = label ?? `${file}:${line}`;
+    const dataEntries = expressions.map((expr) => `${JSON.stringify(expr)}: (${expr})`).join(", ");
+    const condition = `(globalThis.__conveyorProbes?.probe(${JSON.stringify(probeLabel)}, {${dataEntries}}), false)`;
+    const breakpointId = await this.setBreakpoint(file, line, condition);
+    this.probes.set(probeId, { probeId, breakpointId, file, line, expressions, label: probeLabel });
+    return probeId;
+  }
+  async removeProbe(probeId) {
+    const probe = this.probes.get(probeId);
+    if (!probe) throw new Error(`Probe ${probeId} not found`);
+    await this.removeBreakpoint(probe.breakpointId);
+    this.probes.delete(probeId);
+  }
+  listProbes() {
+    return [...this.probes.values()];
+  }
+  async getProbeResults(label, limit) {
+    const args = [
+      label === void 0 ? "undefined" : JSON.stringify(label),
+      limit === void 0 ? "undefined" : String(limit)
+    ].join(", ");
+    const result = await this.evaluate(
+      `JSON.stringify(globalThis.__conveyorProbes?.read(${args}) ?? [])`
+    );
+    if (result.type === "error") return [];
+    try {
+      const raw = result.value;
+      return JSON.parse(raw.startsWith('"') ? JSON.parse(raw) : raw);
+    } catch {
+      return [];
+    }
+  }
+  async clearProbeResults(label) {
+    const arg = label === void 0 ? "undefined" : JSON.stringify(label);
+    await this.evaluate(`(globalThis.__conveyorProbes?.clear(${arg}), undefined)`);
+  }
+  isPaused() {
+    return this.pausedState !== null;
+  }
+  getPausedState() {
+    return this.pausedState;
+  }
+  getCallStack() {
+    return this.pausedState?.callFrames ?? [];
+  }
+  async getScopeVariables(callFrameId) {
+    if (!this.pausedState) throw new Error("Debugger is not paused");
+    const session = this.requireSession();
+    const frame = this.pausedState.callFrames.find((f) => f.callFrameId === callFrameId);
+    if (!frame) throw new Error(`Call frame ${callFrameId} not found`);
+    const result = await session.send("Debugger.evaluateOnCallFrame", {
+      callFrameId,
+      expression: "this",
+      returnByValue: false
+    });
+    const variables = [];
+    try {
+      const scopeResult = await session.send("Runtime.getProperties", {
+        objectId: result.result?.objectId,
+        ownProperties: true,
+        generatePreview: false
+      });
+      for (const desc of (scopeResult.result ?? []).slice(
+        0,
+        MAX_VARIABLES_PER_SCOPE2
+      )) {
+        if (desc.value) {
+          variables.push({
+            name: desc.name,
+            type: desc.value.type,
+            value: truncateValue(formatRemoteObject(desc.value))
+          });
+        }
+      }
+    } catch {
+    }
+    return variables;
+  }
+  async resume() {
+    this.clearAutoResumeTimer();
+    await this.requireSession().send("Debugger.resume", {});
+    this.pausedState = null;
+  }
+  async stepOver() {
+    this.clearAutoResumeTimer();
+    await this.requireSession().send("Debugger.stepOver", {});
+  }
+  async stepInto() {
+    this.clearAutoResumeTimer();
+    await this.requireSession().send("Debugger.stepInto", {});
+  }
+  async evaluate(expression, callFrameId) {
+    const session = this.requireSession();
+    this.resetInactivityTimer();
+    let result;
+    if (callFrameId && this.pausedState) {
+      result = await session.send("Debugger.evaluateOnCallFrame", {
+        callFrameId,
+        expression,
+        returnByValue: false,
+        generatePreview: true
+      });
+    } else {
+      result = await session.send("Runtime.evaluate", {
+        expression,
+        returnByValue: false,
+        generatePreview: true
+      });
+    }
+    const remoteObj = result.result;
+    const exDetails = result.exceptionDetails;
+    if (exDetails) {
+      return {
+        type: "error",
+        value: exDetails.exception?.description ?? exDetails.text ?? "Unknown error"
+      };
+    }
+    return {
+      type: remoteObj?.type ?? "undefined",
+      value: truncateValue(formatRemoteObject(remoteObj))
+    };
+  }
+  async navigate(url) {
+    this.requirePage();
+    this.resetInactivityTimer();
+    await this.page?.goto(url, { waitUntil: "domcontentloaded" });
+  }
+  async click(selector) {
+    this.requirePage();
+    this.resetInactivityTimer();
+    await this.page?.click(selector, { timeout: 1e4 });
+  }
+  async screenshot() {
+    this.requirePage();
+    this.resetInactivityTimer();
+    const buffer = await this.page?.screenshot({ type: "png", encoding: "base64" });
+    return typeof buffer === "string" ? buffer : Buffer.from(buffer).toString("base64");
+  }
+  getCurrentUrl() {
+    this.requirePage();
+    return this.page?.url() ?? "";
+  }
+  getConsoleMessages(level, limit) {
+    let messages = this.consoleMessages;
+    if (level) messages = messages.filter((m) => m.level === level);
+    if (limit) messages = messages.slice(-limit);
+    return messages;
+  }
+  getNetworkRequests(filter, limit) {
+    let requests = this.networkRequests;
+    if (filter) {
+      const regex = new RegExp(filter, "i");
+      requests = requests.filter((r) => regex.test(r.url));
+    }
+    if (limit) requests = requests.slice(-limit);
+    return requests;
+  }
+  getPageErrors(limit) {
+    return limit ? this.pageErrors.slice(-limit) : [...this.pageErrors];
+  }
+  onPaused(callback) {
+    this.onPausedCallback = callback;
+  }
+  onResumed(callback) {
+    this.onResumedCallback = callback;
+  }
+  onAutoResumed(callback) {
+    this.onAutoResumedCallback = callback;
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  setupCdpEvents() {
+    if (!this.cdpSession) return;
+    this.cdpSession.on("Debugger.paused", (params) => this.handlePaused(params));
+    this.cdpSession.on("Debugger.resumed", () => {
+      this.pausedState = null;
+      this.clearAutoResumeTimer();
+      this.onResumedCallback?.();
+    });
+  }
+  handlePaused(params) {
+    const rawFrames = params.callFrames ?? [];
+    const callFrames = rawFrames.map((frame, index) => ({
+      index,
+      functionName: frame.functionName || "(anonymous)",
+      file: frame.url,
+      line: frame.location.lineNumber + 1,
+      column: frame.location.columnNumber + 1,
+      callFrameId: frame.callFrameId
+    }));
+    this.pausedState = {
+      callFrames,
+      reason: params.reason ?? "unknown",
+      hitBreakpoints: params.hitBreakpoints
+    };
+    this.clearAutoResumeTimer();
+    this.autoResumeTimer = setTimeout(() => {
+      if (this.pausedState) {
+        this.resume().then(() => this.onAutoResumedCallback?.()).catch(() => {
+        });
+      }
+    }, AUTO_RESUME_TIMEOUT_MS2);
+    this.onPausedCallback?.(this.pausedState);
+  }
+  setupPassiveCapture() {
+    if (!this.page) return;
+    this.page.on("console", (msg) => {
+      const m = msg;
+      this.consoleMessages.push({
+        level: m.type(),
+        text: m.text(),
+        timestamp: Date.now(),
+        url: m.location()?.url,
+        line: m.location()?.lineNumber
+      });
+      if (this.consoleMessages.length > BUFFER_MAX) this.consoleMessages.shift();
+    });
+    this.page.on("pageerror", (error) => {
+      const e = error;
+      this.pageErrors.push({ message: e.message, stack: e.stack, timestamp: Date.now() });
+      if (this.pageErrors.length > ERROR_BUFFER_MAX) this.pageErrors.shift();
+    });
+    this.page.on("request", (request) => {
+      const r = request;
+      this.networkRequests.push({
+        url: r.url(),
+        method: r.method(),
+        resourceType: r.resourceType(),
+        timestamp: Date.now()
+      });
+      if (this.networkRequests.length > BUFFER_MAX) this.networkRequests.shift();
+    });
+    this.page.on("response", (response) => {
+      const resp = response;
+      const url = resp.url();
+      for (let i = this.networkRequests.length - 1; i >= 0; i--) {
+        const req = this.networkRequests[i];
+        if (req.url === url && req.status === void 0) {
+          req.status = resp.status();
+          req.duration = Date.now() - req.timestamp;
+          break;
+        }
+      }
+    });
+  }
+  async checkSourceMaps() {
+    const hasMapFiles = this.networkRequests.some(
+      (r) => r.url.endsWith(".map") || r.url.includes("sourceMappingURL")
+    );
+    if (hasMapFiles) {
+      this.sourceMapDetected = true;
+      return;
+    }
+    try {
+      const result = await this.requireSession().send("Runtime.evaluate", {
+        expression: "true",
+        returnByValue: true
+      });
+      this.sourceMapDetected = result.result ? null : false;
+    } catch {
+      this.sourceMapDetected = null;
+    }
+  }
+  async ensureProbeBuffer() {
+    if (this.probeBufferInjected) return;
+    const session = this.requireSession();
+    await session.send("Runtime.evaluate", {
+      expression: `globalThis.__conveyorProbes=globalThis.__conveyorProbes||{_buffer:[],_maxSize:${PROBE_BUFFER_MAX_SIZE2},probe(l,d){this._buffer.push({label:l,data:d,timestamp:Date.now()});if(this._buffer.length>this._maxSize)this._buffer.shift()},read(l,n){var i=l!==void 0?this._buffer.filter(function(e){return e.label===l}):this._buffer;return n!==void 0?i.slice(-n):i},clear(l){if(l!==void 0){this._buffer=this._buffer.filter(function(e){return e.label!==l})}else{this._buffer=[]}}};"ok"`,
+      returnByValue: true
+    });
+    this.probeBufferInjected = true;
+  }
+  requireSession() {
+    if (!this.cdpSession) throw new Error("Playwright CDP session is not connected");
+    return this.cdpSession;
+  }
+  requirePage() {
+    if (!this.page) throw new Error("No page available");
+  }
+  fileToUrlRegex(file) {
+    return `.*${file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
+  }
+  clearAutoResumeTimer() {
+    if (this.autoResumeTimer) {
+      clearTimeout(this.autoResumeTimer);
+      this.autoResumeTimer = null;
+    }
+  }
+  resetInactivityTimer() {
+    this.clearInactivityTimer();
+    this.inactivityTimer = setTimeout(() => {
+      this.close().catch(() => {
+      });
+    }, INACTIVITY_TIMEOUT_MS);
+  }
+  clearInactivityTimer() {
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+      this.inactivityTimer = null;
+    }
+  }
+};
+
+// src/debug/debug-manager.ts
+import { spawn } from "child_process";
+import { execSync } from "child_process";
+var NODE_INSPECTOR_REGEX = /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[^\s]+)/;
+var BUN_INSPECTOR_REGEX = /(ws:\/\/[\w.-]+:\d+\/[\w-]+)/;
+var CONNECTION_TIMEOUT_MS = 1e4;
+var PLAYWRIGHT_INSTALL_TIMEOUT_MS = 12e4;
+var DebugManager = class {
+  cdpClient = null;
+  playwrightClient = null;
+  debugProcess = null;
+  _isDebugMode = false;
+  _isClientDebugMode = false;
+  startCommand;
+  workingDir;
+  eventHandler;
+  breakpointHitQueue = [];
+  clientBreakpointHitQueue = [];
+  constructor(startCommand, workingDir, eventHandler) {
+    this.startCommand = startCommand;
+    this.workingDir = workingDir;
+    this.eventHandler = eventHandler;
+  }
+  // ── Public API ─────────────────────────────────────────────────────────
+  isDebugMode() {
+    return this._isDebugMode;
+  }
+  isClientDebugMode() {
+    return this._isClientDebugMode;
+  }
+  getClient() {
+    return this.cdpClient;
+  }
+  getPlaywrightClient() {
+    return this.playwrightClient;
+  }
+  drainBreakpointHitQueue() {
+    const queued = [...this.breakpointHitQueue];
+    this.breakpointHitQueue = [];
+    return queued;
+  }
+  drainClientBreakpointHitQueue() {
+    const queued = [...this.clientBreakpointHitQueue];
+    this.clientBreakpointHitQueue = [];
+    return queued;
+  }
+  async enterDebugMode(killCurrentProcess, options) {
+    const serverSide = options?.serverSide ?? !options?.clientSide;
+    const clientSide = options?.clientSide ?? false;
+    if (serverSide && this._isDebugMode) {
+      throw new Error("Already in server debug mode");
+    }
+    if (clientSide && this._isClientDebugMode) {
+      throw new Error("Already in client debug mode");
+    }
+    if (serverSide && !this._isDebugMode) {
+      await this.activateServerDebug(killCurrentProcess);
+    }
+    if (clientSide && !this._isClientDebugMode) {
+      await this.activateClientDebug(options?.previewUrl);
+    }
+    this.eventHandler.onDebugModeEntered();
+  }
+  async exitDebugMode(restartNormalServer) {
+    if (!this._isDebugMode && !this._isClientDebugMode) {
+      throw new Error("Not in debug mode");
+    }
+    if (this.cdpClient) {
+      try {
+        await this.cdpClient.removeAllBreakpoints();
+      } catch {
+      }
+      this.cdpClient.disconnect();
+      this.cdpClient = null;
+    }
+    if (this.playwrightClient) {
+      try {
+        await this.playwrightClient.removeAllBreakpoints();
+      } catch {
+      }
+      try {
+        await this.playwrightClient.close();
+      } catch {
+      }
+      this.playwrightClient = null;
+    }
+    if (this.debugProcess && !this.debugProcess.killed) {
+      this.debugProcess.kill("SIGTERM");
+      this.debugProcess = null;
+    }
+    this._isDebugMode = false;
+    this._isClientDebugMode = false;
+    this.breakpointHitQueue = [];
+    this.clientBreakpointHitQueue = [];
+    restartNormalServer?.();
+    this.eventHandler.onDebugModeExited();
+  }
+  // ── Debug Mode Activation ────────────────────────────────────────────
+  async activateServerDebug(killCurrentProcess) {
+    killCurrentProcess?.();
+    const runtime = detectRuntime(this.startCommand);
+    const inspectorUrl = await this.startWithInspector();
+    const protocol = runtime === "bun" ? "webkit" : "cdp";
+    this.cdpClient = new CdpDebugClient();
+    this.cdpClient.onPaused((state) => {
+      this.breakpointHitQueue.push(state);
+      this.eventHandler.onBreakpointHit(state);
+    });
+    this.cdpClient.onAutoResumed(() => {
+      this.eventHandler.onAutoResumed();
+    });
+    await this.cdpClient.connect(inspectorUrl, protocol);
+    this._isDebugMode = true;
+    try {
+      await injectTelemetry(this.cdpClient);
+    } catch {
+    }
+  }
+  async activateClientDebug(previewUrl) {
+    if (!previewUrl) {
+      throw new Error("previewUrl is required for client-side debug mode");
+    }
+    await this.ensurePlaywrightInstalled();
+    this.playwrightClient = new PlaywrightDebugClient();
+    this.playwrightClient.onPaused((state) => {
+      this.clientBreakpointHitQueue.push(state);
+      this.eventHandler.onClientBreakpointHit(state);
+    });
+    this.playwrightClient.onAutoResumed(() => {
+      this.eventHandler.onAutoResumed();
+    });
+    await this.playwrightClient.launch(previewUrl);
+    this._isClientDebugMode = true;
+  }
+  // ── Playwright Installation ───────────────────────────────────────────
+  async ensurePlaywrightInstalled() {
+    try {
+      await import("playwright-core");
+      const pw = await import("playwright-core");
+      const executablePath = pw.chromium.executablePath();
+      if (executablePath) return;
+    } catch {
+    }
+    this.eventHandler.onOutput(
+      "stderr",
+      "Installing Playwright Chromium (first-time setup, ~250MB)...\n"
+    );
+    try {
+      execSync("npx playwright install chromium --with-deps", {
+        cwd: this.workingDir,
+        timeout: PLAYWRIGHT_INSTALL_TIMEOUT_MS,
+        stdio: "pipe"
+      });
+      this.eventHandler.onOutput("stderr", "Playwright Chromium installed successfully.\n");
+    } catch (error) {
+      throw new Error(
+        `Failed to install Playwright Chromium: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { cause: error }
+      );
+    }
+  }
+  // ── Private ────────────────────────────────────────────────────────────
+  // oxlint-disable-next-line require-await
+  async startWithInspector() {
+    const runtime = detectRuntime(this.startCommand);
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      const timeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(getTimeoutMessage(runtime)));
+        }
+      }, CONNECTION_TIMEOUT_MS);
+      let cmd = this.startCommand;
+      let env = { ...process.env };
+      if (runtime === "bun") {
+        cmd = injectBunInspectFlag(this.startCommand);
+      } else {
+        env = { ...env, NODE_OPTIONS: "--inspect=0" };
+      }
+      const inspectorRegex = runtime === "bun" ? BUN_INSPECTOR_REGEX : NODE_INSPECTOR_REGEX;
+      const child = runStartCommandWithEnv(cmd, this.workingDir, env, (stream, data) => {
+        this.eventHandler.onOutput(stream, data);
+        if (!resolved && stream === "stderr") {
+          const match = data.match(inspectorRegex);
+          if (match?.[1]) {
+            resolved = true;
+            clearTimeout(timeout);
+            resolve(match[1]);
+          }
+        }
+      });
+      this.debugProcess = child;
+      child.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+      child.on("exit", (code) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          reject(new Error(`Debug process exited with code ${code} before inspector started`));
+        }
+      });
+    });
+  }
+};
+var BUN_COMMAND_REGEX = /\b(bun|bunx)\b/;
+var NODE_COMMAND_REGEX = /\b(node|npx|tsx|ts-node)\b/;
+function detectRuntime(startCommand) {
+  if (BUN_COMMAND_REGEX.test(startCommand)) return "bun";
+  if (NODE_COMMAND_REGEX.test(startCommand)) return "node";
+  if (process.env.BUN_INSTALL) return "bun";
+  return "node";
+}
+function injectBunInspectFlag(command) {
+  return command.replace(/\b(bunx?)\b/, "$1 --inspect");
+}
+function getTimeoutMessage(runtime) {
+  switch (runtime) {
+    case "bun":
+      return "Timed out waiting for Bun inspector (--inspect flag). Ensure your start command begins with 'bun'";
+    case "node":
+      return "Timed out waiting for Node.js inspector (NODE_OPTIONS='--inspect=0')";
+    default:
+      return "Timed out waiting for debugger inspector. Your runtime may not support CDP.";
+  }
+}
+function runStartCommandWithEnv(cmd, cwd, env, onOutput) {
+  const child = spawn("sh", ["-c", cmd], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...env }
+  });
+  child.stdout?.on("data", (chunk) => {
+    onOutput("stdout", chunk.toString());
+  });
+  child.stderr?.on("data", (chunk) => {
+    onOutput("stderr", chunk.toString());
+  });
+  child.unref();
+  return child;
+}
+
+// src/debug/lifecycle-manager.ts
+var DebugLifecycleManager = class {
+  connection;
+  debugManager = null;
+  hypothesis;
+  sessionStartedAt;
+  breakpointsHitCount = 0;
+  telemetryEvents = [];
+  reproduceRequested = false;
+  keyFindings = [];
+  _isActive = false;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  setDebugManager(manager) {
+    this.debugManager = manager;
+  }
+  /**
+   * Creates a DebugEventHandler that bridges DebugManager events
+   * to the lifecycle manager and broadcasts state to the web UI.
+   */
+  createEventHandler(baseOnOutput) {
+    return {
+      onDebugModeEntered: () => {
+        this._isActive = true;
+        this.sessionStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.breakpointsHitCount = 0;
+        this.telemetryEvents = [];
+        this.keyFindings = [];
+        this.broadcastState();
+      },
+      onDebugModeExited: () => {
+        this.broadcastState();
+      },
+      onBreakpointHit: (state) => {
+        this.breakpointsHitCount++;
+        const file = state.callFrames[0]?.file ?? "unknown";
+        const line = state.callFrames[0]?.line ?? 0;
+        this.keyFindings.push(`Breakpoint hit at ${file}:${line} (${state.reason})`);
+        this.broadcastState();
+      },
+      onClientBreakpointHit: (state) => {
+        this.breakpointsHitCount++;
+        const file = state.callFrames[0]?.file ?? "unknown";
+        const line = state.callFrames[0]?.line ?? 0;
+        this.keyFindings.push(`Client breakpoint hit at ${file}:${line}`);
+        this.broadcastState();
+      },
+      onAutoResumed: () => {
+        this.broadcastState();
+      },
+      onDebugError: (message) => {
+        this.keyFindings.push(`Debug error: ${message}`);
+        this.broadcastState();
+      },
+      onOutput: baseOnOutput
+    };
+  }
+  /** Mark the hypothesis for the current debug session */
+  setHypothesis(hypothesis) {
+    this.hypothesis = hypothesis;
+    this.broadcastState();
+  }
+  /** Signal that the user has been asked to reproduce the bug */
+  requestReproduce(hypothesis) {
+    this.reproduceRequested = true;
+    if (hypothesis) this.hypothesis = hypothesis;
+    this.connection.emitDebugReproduceRequested(hypothesis ?? this.hypothesis);
+    this.broadcastState();
+  }
+  /** Add a telemetry event to the debug session */
+  addTelemetryEvent(event) {
+    this.telemetryEvents.push(event);
+    if (this.telemetryEvents.length > 100) {
+      this.telemetryEvents = this.telemetryEvents.slice(-100);
+    }
+    this.broadcastState();
+  }
+  /** Generate and broadcast a debug session summary, then reset state */
+  completeSession() {
+    if (!this._isActive && !this.sessionStartedAt) return null;
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startedAt = this.sessionStartedAt ?? endedAt;
+    const durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    const breakpoints = this.getBreakpoints();
+    const probes = this.getProbes();
+    const summary = {
+      hypothesis: this.hypothesis,
+      breakpointsSet: breakpoints.length,
+      breakpointsHit: this.breakpointsHitCount,
+      probesSet: probes.length,
+      telemetryEventsCaptured: this.telemetryEvents.length,
+      keyFindings: this.keyFindings.slice(0, 20),
+      durationMs,
+      startedAt,
+      endedAt
+    };
+    this.connection.emitDebugSessionComplete(summary);
+    this._isActive = false;
+    this.hypothesis = void 0;
+    this.sessionStartedAt = void 0;
+    this.breakpointsHitCount = 0;
+    this.telemetryEvents = [];
+    this.reproduceRequested = false;
+    this.keyFindings = [];
+    this.broadcastState();
+    return summary;
+  }
+  /** Auto-exit cleanup — called when agent session ends */
+  autoCleanup() {
+    if (this._isActive || this.sessionStartedAt) {
+      this.completeSession();
+    }
+  }
+  // ── Private ────────────────────────────────────────────────────────
+  getBreakpoints() {
+    if (!this.debugManager) return [];
+    const client = this.debugManager.getClient();
+    if (!client?.isConnected()) return [];
+    try {
+      return client.listBreakpoints().map((bp) => ({
+        id: bp.breakpointId,
+        file: bp.file,
+        line: bp.line,
+        condition: bp.condition,
+        hitCount: 0
+      }));
+    } catch {
+      return [];
+    }
+  }
+  getProbes() {
+    if (!this.debugManager) return [];
+    const client = this.debugManager.getClient();
+    if (!client?.isConnected()) return [];
+    try {
+      return client.listProbes().map((p) => ({
+        id: p.probeId,
+        file: p.file,
+        line: p.line,
+        expressions: p.expressions,
+        label: p.label
+      }));
+    } catch {
+      return [];
+    }
+  }
+  buildState() {
+    const serverDebug = this.debugManager?.isDebugMode() ?? false;
+    const clientDebug = this.debugManager?.isClientDebugMode() ?? false;
+    const active = this._isActive && (serverDebug || clientDebug);
+    let pausedAt;
+    const client = this.debugManager?.getClient();
+    if (client?.isPaused()) {
+      const callStack = client.getCallStack();
+      if (callStack[0]) {
+        pausedAt = {
+          file: callStack[0].file,
+          line: callStack[0].line
+        };
+      }
+    }
+    return {
+      active,
+      hypothesis: this.hypothesis,
+      serverDebug,
+      clientDebug,
+      breakpoints: this.getBreakpoints(),
+      probes: this.getProbes(),
+      telemetryEvents: this.telemetryEvents.slice(-50),
+      pausedAt,
+      reproduceRequested: this.reproduceRequested
+    };
+  }
+  broadcastState() {
+    this.connection.emitDebugStateChanged(this.buildState());
+  }
+};
 export {
   AgentRunner,
+  CdpDebugClient,
   ConveyorConnection,
+  DebugLifecycleManager,
+  DebugManager,
   FileCache,
   ProjectConnection,
   ProjectRunner,