@saptools/cf-inspector 0.4.0 → 0.4.2

package/dist/cli.js

@@ -35,10 +35,19 @@ __export(wsTransport_exports, {
   wsTransportFactory: () => wsTransportFactory
 });
 import { WebSocket } from "ws";
-async function wsTransportFactory(url) {
+async function wsTransportFactory(url, options = {}) {
   const socket = new WebSocket(url, { perMessageDeflate: false });
-  await waitForOpen(socket, url);
-  const wrappers = /* @__PURE__ */ new WeakMap();
+  await waitForOpen(socket, url, options.connectTimeoutMs);
+  const wrappers = /* @__PURE__ */ new Map();
+  function wrappersFor(event) {
+    const existing = wrappers.get(event);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const created = /* @__PURE__ */ new WeakMap();
+    wrappers.set(event, created);
+    return created;
+  }
   return {
     send(payload) {
       socket.send(payload);
@@ -50,11 +59,12 @@ async function wsTransportFactory(url) {
       return socket.readyState;
     },
     on(event, listener) {
-      const wrapped = wrapListener(event, listener, wrappers);
+      const wrapped = wrapListener(event, listener);
+      wrappersFor(event).set(listener, wrapped);
       socket.on(event, wrapped);
     },
     off(event, listener) {
-      const wrapped = wrappers.get(listener);
+      const wrapped = wrappersFor(event).get(listener);
       if (!wrapped) {
         return;
       }
@@ -62,14 +72,30 @@ async function wsTransportFactory(url) {
     }
   };
 }
-async function waitForOpen(socket, url) {
+async function waitForOpen(socket, url, timeoutMs) {
   await new Promise((resolve, reject) => {
-    const onOpen = () => {
+    let settled = false;
+    const cleanup = () => {
+      socket.off("open", onOpen);
       socket.off("error", onError);
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    };
+    const onOpen = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
       resolve();
     };
     const onError = (err) => {
-      socket.off("open", onOpen);
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
       reject(
         new CfInspectorError(
           "INSPECTOR_CONNECTION_FAILED",
@@ -77,29 +103,45 @@ async function waitForOpen(socket, url) {
         )
       );
     };
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      socket.on("error", () => {
+      });
+      try {
+        socket.terminate();
+      } catch {
+      }
+      reject(
+        new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          `WebSocket handshake to ${url} timed out after ${timeoutMs.toString()}ms`
+        )
+      );
+    }, timeoutMs);
     socket.once("open", onOpen);
     socket.once("error", onError);
   });
 }
-function wrapListener(event, listener, wrappers) {
+function wrapListener(event, listener) {
   if (event === "message") {
     const wrapped2 = (data) => {
       listener(data.toString("utf8"));
     };
-    wrappers.set(listener, wrapped2);
     return wrapped2;
   }
   if (event === "close") {
     const wrapped2 = () => {
       listener();
     };
-    wrappers.set(listener, wrapped2);
     return wrapped2;
   }
   const wrapped = (err) => {
     listener(err);
   };
-  wrappers.set(listener, wrapped);
   return wrapped;
 }
 var init_wsTransport = __esm({
@@ -110,7 +152,7 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process10 from "process";
+import process11 from "process";
 
 // src/cli/program.ts
 import { Command } from "commander";
@@ -238,6 +280,10 @@ async function fetchInspectorVersion(host, port, timeoutMs) {
 
 // src/cli/output.ts
 import process from "process";
+function writeProgress(message) {
+  process.stderr.write(`[cf-inspector] ${message}
+`);
+}
 function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
@@ -352,7 +398,8 @@ async function openCfTunnel(target) {
     ...target.tunnelReadyTimeoutMs === void 0 ? {} : { tunnelReadyTimeoutMs: target.tunnelReadyTimeoutMs },
     ...target.preferredPort === void 0 ? {} : { preferredPort: target.preferredPort },
     ...target.verbose === void 0 ? {} : { verbose: target.verbose },
-    ...target.signal === void 0 ? {} : { signal: target.signal }
+    ...target.signal === void 0 ? {} : { signal: target.signal },
+    ...target.onStatus === void 0 ? {} : { onStatus: target.onStatus }
   };
   const handle = await startDebugger(opts);
   return {
@@ -404,10 +451,19 @@ var CdpClient = class _CdpClient {
       return;
     }
     if (typeof parsed.method === "string") {
-      this.emitter.emit(parsed.method, parsed.params);
-      this.emitter.emit("event", { method: parsed.method, params: parsed.params });
+      this.safeEmit(parsed.method, parsed.params);
+      this.safeEmit("event", { method: parsed.method, params: parsed.params });
     }
   };
+  safeEmit(event, payload) {
+    const listeners = this.emitter.listeners(event);
+    for (const listener of listeners) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
+  }
   handleClose = () => {
     this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Inspector connection closed"));
   };
@@ -425,7 +481,8 @@ var CdpClient = class _CdpClient {
   }
   static async connect(options) {
     const factory = options.transportFactory ?? await loadDefaultFactory();
-    const transport = await factory(options.url);
+    const factoryOptions = options.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: options.connectTimeoutMs };
+    const transport = await factory(options.url, factoryOptions);
     return new _CdpClient(transport, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
   }
   async send(method, params = {}) {
@@ -475,8 +532,16 @@ var CdpClient = class _CdpClient {
           return;
         }
         const params = raw;
-        if (options.predicate && !options.predicate(params)) {
-          return;
+        if (options.predicate) {
+          let accepted;
+          try {
+            accepted = options.predicate(params);
+          } catch {
+            return;
+          }
+          if (!accepted) {
+            return;
+          }
         }
         finish(params);
       });
@@ -716,7 +781,18 @@ async function connectInspector(options) {
       `No inspector targets available on ${host}:${options.port.toString()}`
     );
   }
-  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl });
+  const client = await CdpClient.connect({
+    url: target.webSocketDebuggerUrl,
+    connectTimeoutMs
+  });
+  try {
+    return await initSession(client, target);
+  } catch (err) {
+    client.dispose();
+    throw err;
+  }
+}
+async function initSession(client, target) {
   const scripts = /* @__PURE__ */ new Map();
   client.on("Debugger.scriptParsed", (raw) => {
     const params = raw;
@@ -772,6 +848,22 @@ var DEFAULT_CF_TIMEOUT_SEC = 60;
 var DEFAULT_EXCEPTION_TIMEOUT_SEC = 30;
 
 // src/cli/target.ts
+var CF_TUNNEL_STATUS_MESSAGES = {
+  starting: "Preparing the Cloud Foundry debugger...",
+  "logging-in": "Logging in to Cloud Foundry...",
+  targeting: "Targeting the Cloud Foundry org and space...",
+  "ssh-enabling": "Enabling SSH for the Cloud Foundry app...",
+  "ssh-restarting": "Restarting the Cloud Foundry app to activate SSH...",
+  signaling: "Starting the remote Node.js inspector...",
+  tunneling: "Opening the SSH inspector tunnel...",
+  ready: "Cloud Foundry inspector tunnel is ready.",
+  stopping: "Closing the Cloud Foundry inspector tunnel...",
+  stopped: "Cloud Foundry inspector tunnel closed.",
+  error: "Cloud Foundry inspector tunnel failed."
+};
+function formatCfTunnelStatus(status) {
+  return CF_TUNNEL_STATUS_MESSAGES[status];
+}
 function parsePositiveInt(raw, label) {
   if (raw === void 0) {
     return void 0;
@@ -806,20 +898,26 @@ function resolveTarget(opts) {
 function hasCfTarget(opts) {
   return opts.region !== void 0 && opts.org !== void 0 && opts.space !== void 0 && opts.app !== void 0;
 }
-async function withSession(target, fn) {
-  const tunnel = await openTarget(target);
+async function withSession(target, fn, reportProgress) {
+  const tunnel = await openTarget(target, reportProgress);
   let session;
   try {
+    reportProgress?.(
+      `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
+    );
     session = await connectInspector({ port: tunnel.port, host: tunnel.host });
+    reportProgress?.("Inspector session is ready.");
     return await fn(session, tunnel.port);
   } finally {
     if (session) {
+      reportProgress?.("Closing the inspector session...");
       await session.dispose();
+      reportProgress?.("Inspector session closed.");
     }
     await tunnel.dispose();
   }
 }
-async function openTarget(target) {
+async function openTarget(target, reportProgress) {
   if (target.kind === "port") {
     return {
       port: target.port,
@@ -827,12 +925,18 @@ async function openTarget(target) {
       dispose: () => Promise.resolve()
     };
   }
+  reportProgress?.(formatCfTunnelStatus("starting"));
   const tunnel = await openCfTunnel({
     region: target.region,
     org: target.org,
     space: target.space,
     app: target.app,
-    tunnelReadyTimeoutMs: target.cfTimeoutMs
+    tunnelReadyTimeoutMs: target.cfTimeoutMs,
+    ...reportProgress === void 0 ? {} : {
+      onStatus: (status) => {
+        reportProgress(formatCfTunnelStatus(status));
+      }
+    }
   });
   return {
     port: tunnel.localPort,
@@ -1066,9 +1170,11 @@ function normalizeRegexRootPattern(pattern) {
   const withoutEndAnchor = withoutStartAnchor.endsWith("$") && !isEscaped(withoutStartAnchor, withoutStartAnchor.length - 1) ? withoutStartAnchor.slice(0, -1) : withoutStartAnchor;
   return stripTrailingSlash(withoutEndAnchor);
 }
-function buildFileUrlRegex(rootPattern, tail) {
-  const separator = rootPattern.endsWith("/") ? "" : "/";
-  return `^file://${rootPattern}${separator}${tail}$`;
+function buildFileUrlRegex(embeddedRoot, tail, separator) {
+  return `^file://${embeddedRoot}${separator}${tail}$`;
+}
+function rootSeparator(rawPattern) {
+  return rawPattern.endsWith("/") ? "" : "/";
 }
 function escapeRegExp(value) {
   return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
@@ -1095,12 +1201,12 @@ function buildBreakpointUrlRegex(input) {
       return `(?:^|/)${tail}$`;
     }
     case "literal": {
-      const escapedRoot = escapeRegExp(input.remoteRoot.value);
-      return buildFileUrlRegex(escapedRoot, tail);
+      const root = input.remoteRoot.value;
+      return buildFileUrlRegex(escapeRegExp(root), tail, rootSeparator(root));
     }
     case "regex": {
-      const rootPattern = normalizeRegexRootPattern(input.remoteRoot.pattern);
-      return buildFileUrlRegex(rootPattern, tail);
+      const root = normalizeRegexRootPattern(input.remoteRoot.pattern);
+      return buildFileUrlRegex(`(?:${root})`, tail, rootSeparator(root));
     }
   }
 }
@@ -1364,19 +1470,32 @@ function scalarFromVariable(variable) {
   }
   return value === "null" ? null : value;
 }
+function isArrayLikeChildren(children) {
+  let hasNumeric = false;
+  for (const child of children) {
+    if (child.name === "length") {
+      continue;
+    }
+    if (parseNumericIndex(child.name) === void 0) {
+      return false;
+    }
+    hasNumeric = true;
+  }
+  return hasNumeric;
+}
 function toStructuredValue(variable) {
   const children = variable.children;
   if (children === void 0 || children.length === 0) {
     return scalarFromVariable(variable);
   }
-  const indexed = children.flatMap((child) => {
-    const index = parseNumericIndex(child.name);
-    if (index === void 0) {
-      return [];
-    }
-    return [[index, toStructuredValue(child)]];
-  });
-  if (indexed.length > 0) {
+  if (isArrayLikeChildren(children)) {
+    const indexed = children.flatMap((child) => {
+      const index = parseNumericIndex(child.name);
+      if (index === void 0) {
+        return [];
+      }
+      return [[index, toStructuredValue(child)]];
+    });
     const maxIndex = Math.max(...indexed.map(([index]) => index));
     const out2 = Array.from({ length: maxIndex + 1 }, () => null);
     for (const [index, entry] of indexed) {
@@ -2041,7 +2160,7 @@ async function handleListScripts(opts) {
 }
 
 // src/cli/commands/log.ts
-import process7 from "process";
+import process8 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -2200,7 +2319,10 @@ async function streamLogpoint(session, options) {
       return;
     }
     emitted += 1;
-    options.onEvent(event);
+    try {
+      options.onEvent(event);
+    } catch {
+    }
     if (maxEvents !== void 0 && emitted >= maxEvents) {
       maxEventsReached = true;
       stopMaxEvents?.();
@@ -2285,6 +2407,25 @@ async function waitForStop(session, options, registerMaxEventsSignal) {
 
 // src/cli/commands/log.ts
 init_types();
+
+// src/cli/signals.ts
+import process7 from "process";
+async function withTerminationSignal(fn) {
+  const abort = new AbortController();
+  const onSignal = () => {
+    abort.abort();
+  };
+  process7.once("SIGINT", onSignal);
+  process7.once("SIGTERM", onSignal);
+  try {
+    return await fn(abort.signal);
+  } finally {
+    process7.off("SIGINT", onSignal);
+    process7.off("SIGTERM", onSignal);
+  }
+}
+
+// src/cli/commands/log.ts
 async function handleLog(opts) {
   const target = resolveTarget(opts);
   const location = parseBreakpointSpec(opts.at);
@@ -2297,13 +2438,7 @@ async function handleLog(opts) {
     throw new CfInspectorError("INVALID_EXPRESSION", "--expr must not be empty");
   }
   const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
-  const abort = new AbortController();
-  const onSig = () => {
-    abort.abort();
-  };
-  process7.once("SIGINT", onSig);
-  process7.once("SIGTERM", onSig);
-  try {
+  await withTerminationSignal(async (signal) => {
     await withSession(target, async (session) => {
       await validateExpression(session, expression);
       if (condition !== void 0) {
@@ -2317,7 +2452,7 @@ async function handleLog(opts) {
         ...maxEvents === void 0 ? {} : { maxEvents },
         ...hitCount === void 0 ? {} : { hitCount },
         ...condition === void 0 ? {} : { condition },
-        signal: abort.signal,
+        signal,
         onEvent: (event) => {
           writeLogEvent(event, opts.json);
         },
@@ -2327,18 +2462,15 @@ async function handleLog(opts) {
       });
       writeLogSummary(result.stoppedReason, result.emitted, opts.json);
     });
-  } finally {
-    process7.off("SIGINT", onSig);
-    process7.off("SIGTERM", onSig);
-  }
+  });
 }
 function writeLogSummary(stoppedReason, emitted, json) {
   if (json) {
-    process7.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+    process8.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process7.stderr.write(
+  process8.stderr.write(
     `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
 `
   );
@@ -2346,16 +2478,18 @@ function writeLogSummary(stoppedReason, emitted, json) {
 
 // src/cli/commands/snapshot.ts
 import { performance as performance4 } from "perf_hooks";
-import process8 from "process";
+import process9 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const prepared = prepareSnapshotCommand(opts);
-  const result = await runSnapshotCommand(prepared, opts);
+  const reportProgress = opts.quiet === true ? void 0 : writeProgress;
+  const result = await runSnapshotCommand(prepared, opts, reportProgress);
   if (opts.json) {
     writeJson(result);
   } else {
     writeHumanSnapshot(result);
   }
+  reportProgress?.("Snapshot complete.");
 }
 function prepareSnapshotCommand(opts) {
   const target = resolveTarget(opts);
@@ -2383,24 +2517,34 @@ function prepareSnapshotCommand(opts) {
     stackCaptures: parseCaptureList(opts.stackCaptures)
   };
 }
-async function runSnapshotCommand(command, opts) {
+async function runSnapshotCommand(command, opts, reportProgress) {
   return await withSession(command.target, async (session) => {
     if (command.condition !== void 0) {
+      reportProgress?.("Validating the breakpoint condition...");
       await validateExpression(session, command.condition);
+      reportProgress?.("Breakpoint condition is valid.");
     }
-    const handles = await Promise.all(
-      command.breakpoints.map(
-        (bp) => setBreakpoint(session, {
-          file: bp.file,
-          line: bp.line,
-          remoteRoot: command.remoteRoot,
-          ...command.condition === void 0 ? {} : { condition: command.condition },
-          ...command.hitCount === void 0 ? {} : { hitCount: command.hitCount }
-        })
-      )
+    const breakpointCount = command.breakpoints.length;
+    reportProgress?.(
+      `Setting ${breakpointCount.toString()} ${breakpointCount === 1 ? "breakpoint" : "breakpoints"}...`
+    );
+    const handles = await setCommandBreakpoints(session, command);
+    const resolvedCount = handles.reduce(
+      (total, handle) => total + handle.resolvedLocations.length,
+      0
+    );
+    reportProgress?.(
+      `Breakpoint setup complete: ${resolvedCount.toString()} resolved ${resolvedCount === 1 ? "location" : "locations"}.`
     );
     warnOnUnboundBreakpoints(handles);
+    reportProgress?.(
+      `Waiting up to ${(command.timeoutMs / 1e3).toString()}s for a breakpoint hit...`
+    );
     const pause = await waitForCommandPause(session, opts, handles, command.timeoutMs);
+    const captureCount = command.captures.length;
+    reportProgress?.(
+      `Breakpoint hit; capturing ${captureCount.toString()} ${captureCount === 1 ? "expression" : "expressions"}...`
+    );
     const pausedStartedAt = pause.receivedAtMs ?? performance4.now();
     const snapshot = await captureSnapshot(session, pause, {
       captures: command.captures,
@@ -2410,10 +2554,25 @@ async function runSnapshotCommand(command, opts) {
       stackCaptures: command.stackCaptures
     });
     if (opts.keepPaused === true) {
+      reportProgress?.("Snapshot captured; leaving the target paused as requested.");
       return withPausedDuration(snapshot, null);
     }
-    return await resumeAfterSnapshot(session, snapshot, pausedStartedAt);
-  });
+    reportProgress?.("Snapshot captured; resuming the target...");
+    return await resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress);
+  }, reportProgress);
+}
+async function setCommandBreakpoints(session, command) {
+  return await Promise.all(
+    command.breakpoints.map(
+      (bp) => setBreakpoint(session, {
+        file: bp.file,
+        line: bp.line,
+        remoteRoot: command.remoteRoot,
+        ...command.condition === void 0 ? {} : { condition: command.condition },
+        ...command.hitCount === void 0 ? {} : { hitCount: command.hitCount }
+      })
+    )
+  );
 }
 async function waitForCommandPause(session, opts, handles, timeoutMs) {
   let warnedUnmatchedPause = false;
@@ -2430,12 +2589,13 @@ async function waitForCommandPause(session, opts, handles, timeoutMs) {
     }
   });
 }
-async function resumeAfterSnapshot(session, snapshot, pausedStartedAt) {
+async function resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportProgress) {
   try {
     await resume(session);
+    reportProgress?.("Target resumed.");
     return withPausedDuration(snapshot, roundDurationMs(performance4.now() - pausedStartedAt));
   } catch {
-    process8.stderr.write(
+    process9.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -2443,28 +2603,20 @@ async function resumeAfterSnapshot(session, snapshot, pausedStartedAt) {
 }
 
 // src/cli/commands/watch.ts
-import process9 from "process";
+import { performance as performance5 } from "perf_hooks";
+import process10 from "process";
 init_types();
 async function handleWatch(opts) {
   const prepared = prepareWatchCommand(opts);
-  const abort = new AbortController();
-  const onSig = () => {
-    abort.abort();
-  };
-  process9.once("SIGINT", onSig);
-  process9.once("SIGTERM", onSig);
   let stoppedReason = "signal";
   let emitted = 0;
-  try {
+  await withTerminationSignal(async (signal) => {
     await withSession(prepared.target, async (session) => {
-      const result = await runWatchLoop(session, prepared, opts, abort.signal);
+      const result = await runWatchLoop(session, prepared, opts, signal);
       stoppedReason = result.stoppedReason;
       emitted = result.emitted;
     });
-  } finally {
-    process9.off("SIGINT", onSig);
-    process9.off("SIGTERM", onSig);
-  }
+  });
   writeWatchSummary(stoppedReason, emitted, opts.json);
 }
 function prepareWatchCommand(opts) {
@@ -2545,7 +2697,7 @@ async function runWatchLoop(session, command, opts, signal) {
         break;
       }
       if (pause === "timeout") {
-        if (deadline !== void 0 && Date.now() >= deadline) {
+        if (deadline !== void 0 && performance5.now() >= deadline) {
           setStop("duration");
           break;
         }
@@ -2557,7 +2709,7 @@ async function runWatchLoop(session, command, opts, signal) {
       try {
         await resume(session);
       } catch {
-        process9.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
+        process10.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
         setStop("transport-closed");
         break;
       }
@@ -2575,13 +2727,13 @@ function computeDeadline(durationMs) {
   if (durationMs === void 0) {
     return void 0;
   }
-  return Date.now() + durationMs;
+  return performance5.now() + durationMs;
 }
 function remainingForLoop(deadline, perHitTimeoutMs) {
   if (deadline === void 0) {
     return perHitTimeoutMs;
   }
-  const remaining = deadline - Date.now();
+  const remaining = deadline - performance5.now();
   if (remaining <= 0) {
     return 0;
   }
@@ -2662,11 +2814,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process9.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process10.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process9.stderr.write(
+  process10.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -2695,7 +2847,7 @@ async function main(argv) {
 function registerSnapshot(program) {
   applyTargetOptions(
     program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture expressions, and resume")
-  ).option("--bp <file:line>", "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--condition <expr>", "Only pause when this JS expression evaluates truthy in the paused frame").option("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
+  ).option("--bp <file:line>", "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42", collectStrings, []).option("--capture <expr,\u2026>", "Top-level comma-separated expressions to evaluate in the paused frame").option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").option("--max-value-length <chars>", "Maximum characters per captured value before truncation (default: 4096)").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--condition <expr>", "Only pause when this JS expression evaluates truthy in the paused frame").option("--hit-count <n>", "Only pause after the breakpoint has been hit N or more times").option("--stack-depth <n>", "Walk this many call frames when capturing (default: 1, only top frame)").option("--stack-captures <expr,\u2026>", "Expressions to evaluate on each call frame in the stack").option("--include-scopes", "Include expanded paused-frame scopes in the snapshot").option("--no-json", "Print a human-readable summary instead of JSON").option("--quiet", "Suppress progress messages on stderr").option("--keep-paused", "Skip Debugger.resume after capture; Node may resume when this CLI disconnects").option("--fail-on-unmatched-pause", "Fail immediately if the target pauses somewhere else").action(async (opts) => {
     await handleSnapshot(opts);
   });
 }
@@ -2745,20 +2897,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process10.argv);
+  await main(process11.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process10.stderr.write(`Error [${err.code}]: ${err.message}
+    process11.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process10.stderr.write(`  detail: ${err.detail}
+      process11.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process10.exit(1);
+    process11.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process10.stderr.write(`Error: ${message}
+  process11.stderr.write(`Error: ${message}
 `);
-  process10.exit(1);
+  process11.exit(1);
 }
 //# sourceMappingURL=cli.js.map