@saptools/cf-inspector 0.2.0

package/dist/cli.js

@@ -0,0 +1,1496 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var CfInspectorError;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    CfInspectorError = class extends Error {
+      code;
+      detail;
+      constructor(code, message, detail) {
+        super(message);
+        this.name = "CfInspectorError";
+        this.code = code;
+        if (detail !== void 0) {
+          this.detail = detail;
+        }
+      }
+    };
+  }
+});
+
+// src/wsTransport.ts
+var wsTransport_exports = {};
+__export(wsTransport_exports, {
+  wsTransportFactory: () => wsTransportFactory
+});
+import { WebSocket } from "ws";
+async function wsTransportFactory(url) {
+  const socket = new WebSocket(url, { perMessageDeflate: false });
+  await new Promise((resolve, reject) => {
+    const onOpen = () => {
+      socket.off("error", onError);
+      resolve();
+    };
+    const onError = (err) => {
+      socket.off("open", onOpen);
+      reject(
+        new CfInspectorError(
+          "INSPECTOR_CONNECTION_FAILED",
+          `Failed to connect to inspector at ${url}: ${err.message}`
+        )
+      );
+    };
+    socket.once("open", onOpen);
+    socket.once("error", onError);
+  });
+  const wrappers = /* @__PURE__ */ new WeakMap();
+  const wrapMessage = (listener) => {
+    const wrapped = (data) => {
+      listener(data.toString("utf8"));
+    };
+    wrappers.set(listener, wrapped);
+    return wrapped;
+  };
+  const wrapClose = (listener) => {
+    const wrapped = () => {
+      listener();
+    };
+    wrappers.set(listener, wrapped);
+    return wrapped;
+  };
+  const wrapError = (listener) => {
+    const wrapped = (err) => {
+      listener(err);
+    };
+    wrappers.set(listener, wrapped);
+    return wrapped;
+  };
+  return {
+    send(payload) {
+      socket.send(payload);
+    },
+    close() {
+      socket.close();
+    },
+    get readyState() {
+      return socket.readyState;
+    },
+    on(event, listener) {
+      if (event === "message") {
+        socket.on("message", wrapMessage(listener));
+      } else if (event === "close") {
+        socket.on("close", wrapClose(listener));
+      } else {
+        socket.on("error", wrapError(listener));
+      }
+    },
+    off(event, listener) {
+      const wrapped = wrappers.get(listener);
+      if (!wrapped) {
+        return;
+      }
+      if (event === "message") {
+        socket.off("message", wrapped);
+      } else if (event === "close") {
+        socket.off("close", wrapped);
+      } else {
+        socket.off("error", wrapped);
+      }
+    }
+  };
+}
+var init_wsTransport = __esm({
+  "src/wsTransport.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/cli.ts
+import process from "process";
+import { Command } from "commander";
+
+// src/inspector.ts
+import { request } from "http";
+
+// src/cdp.ts
+init_types();
+import { EventEmitter } from "events";
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+function parseMessage(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value !== "object" || value === null) {
+      return void 0;
+    }
+    return value;
+  } catch {
+    return void 0;
+  }
+}
+async function loadDefaultFactory() {
+  const mod = await Promise.resolve().then(() => (init_wsTransport(), wsTransport_exports));
+  return mod.wsTransportFactory;
+}
+var CdpClient = class _CdpClient {
+  transport;
+  requestTimeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  emitter = new EventEmitter();
+  nextId = 1;
+  closed = false;
+  closeReason;
+  handleMessage = (raw) => {
+    const parsed = parseMessage(raw);
+    if (!parsed) {
+      return;
+    }
+    if (typeof parsed.id === "number") {
+      const pending = this.pending.get(parsed.id);
+      if (!pending) {
+        return;
+      }
+      this.pending.delete(parsed.id);
+      clearTimeout(pending.timer);
+      if (parsed.error) {
+        pending.reject(
+          new CfInspectorError(
+            "CDP_REQUEST_FAILED",
+            `CDP request ${parsed.id.toString()} failed: ${parsed.error.message}`,
+            JSON.stringify(parsed.error)
+          )
+        );
+        return;
+      }
+      pending.resolve(parsed.result);
+      return;
+    }
+    if (typeof parsed.method === "string") {
+      this.emitter.emit(parsed.method, parsed.params);
+      this.emitter.emit("event", { method: parsed.method, params: parsed.params });
+    }
+  };
+  handleClose = () => {
+    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Inspector connection closed"));
+  };
+  handleError = (err) => {
+    this.markClosed(
+      err instanceof CfInspectorError ? err : new CfInspectorError("INSPECTOR_CONNECTION_FAILED", err.message)
+    );
+  };
+  constructor(transport, requestTimeoutMs) {
+    this.transport = transport;
+    this.requestTimeoutMs = requestTimeoutMs;
+    transport.on("message", this.handleMessage);
+    transport.on("close", this.handleClose);
+    transport.on("error", this.handleError);
+  }
+  static async connect(options) {
+    const factory = options.transportFactory ?? await loadDefaultFactory();
+    const transport = await factory(options.url);
+    return new _CdpClient(transport, options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
+  }
+  async send(method, params = {}) {
+    if (this.closed) {
+      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+    }
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, method, params });
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new CfInspectorError(
+            "CDP_REQUEST_FAILED",
+            `CDP method ${method} timed out after ${this.requestTimeoutMs.toString()}ms`
+          )
+        );
+      }, this.requestTimeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => {
+          resolve(value);
+        },
+        reject,
+        timer
+      });
+      try {
+        this.transport.send(payload);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        const message = err instanceof Error ? err.message : String(err);
+        reject(new CfInspectorError("CDP_REQUEST_FAILED", `Failed to send ${method}: ${message}`));
+      }
+    });
+  }
+  on(method, listener) {
+    this.emitter.on(method, listener);
+    return () => {
+      this.emitter.off(method, listener);
+    };
+  }
+  async waitFor(method, options = {
+    timeoutMs: this.requestTimeoutMs
+  }) {
+    if (this.closed) {
+      throw this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+    }
+    return await new Promise((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        offEvent();
+        offClose();
+      };
+      const offEvent = this.on(method, (raw) => {
+        if (settled) {
+          return;
+        }
+        const params = raw;
+        if (options.predicate && !options.predicate(params)) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(params);
+      });
+      const offClose = this.onClose((err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(err);
+      });
+      const timer = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(
+          new CfInspectorError(
+            "BREAKPOINT_NOT_HIT",
+            `Timed out waiting for ${method} after ${options.timeoutMs.toString()}ms`
+          )
+        );
+      }, options.timeoutMs);
+    });
+  }
+  onClose(listener) {
+    if (this.closed) {
+      const reason = this.closeReason ?? new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection closed");
+      queueMicrotask(() => {
+        listener(reason);
+      });
+      return () => {
+      };
+    }
+    this.emitter.on("__close__", listener);
+    return () => {
+      this.emitter.off("__close__", listener);
+    };
+  }
+  dispose() {
+    if (this.closed) {
+      return;
+    }
+    this.transport.off("message", this.handleMessage);
+    this.transport.off("close", this.handleClose);
+    this.transport.off("error", this.handleError);
+    try {
+      this.transport.close();
+    } catch {
+    }
+    this.markClosed(new CfInspectorError("INSPECTOR_CONNECTION_FAILED", "Connection disposed"));
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  markClosed(reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.closeReason = reason;
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(reason);
+    }
+    this.pending.clear();
+    this.emitter.emit("__close__", reason);
+    this.emitter.removeAllListeners();
+  }
+};
+
+// src/pathMapper.ts
+init_types();
+var REGEX_PREFIX = "regex:";
+var REGEX_FLAGS_PATTERN = /^[dgimsuvy]*$/;
+var TS_JS_EXT_PATTERN = /\.(?:ts|js|mts|mjs|cts|cjs)$/i;
+function parseBreakpointSpec(input) {
+  const idx = input.lastIndexOf(":");
+  if (idx <= 0 || idx === input.length - 1) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint must be in 'file:line' form, received: "${input}"`
+    );
+  }
+  const file = input.slice(0, idx).trim();
+  const lineRaw = input.slice(idx + 1).trim();
+  const line = Number.parseInt(lineRaw, 10);
+  if (!Number.isInteger(line) || line <= 0 || line.toString() !== lineRaw) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint line must be a positive integer, received: "${lineRaw}"`
+    );
+  }
+  if (file.length === 0) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      `Breakpoint file path is empty in "${input}"`
+    );
+  }
+  return { file, line };
+}
+function parseRemoteRoot(value) {
+  const trimmed = value?.trim();
+  if (trimmed === void 0 || trimmed.length === 0) {
+    return { kind: "none" };
+  }
+  if (trimmed.startsWith(REGEX_PREFIX)) {
+    return toRegex(trimmed.slice(REGEX_PREFIX.length), "");
+  }
+  const slashRegex = parseSlashDelimited(trimmed);
+  if (slashRegex !== void 0) {
+    return toRegex(slashRegex.pattern, slashRegex.flags);
+  }
+  return { kind: "literal", value: stripTrailingSlash(trimmed) };
+}
+function toRegex(pattern, flags) {
+  try {
+    const regex = new RegExp(pattern, flags);
+    return { kind: "regex", pattern, flags, regex };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new CfInspectorError(
+      "INVALID_REMOTE_ROOT",
+      `Failed to compile remote-root regex "${pattern}" with flags "${flags}": ${message}`
+    );
+  }
+}
+function parseSlashDelimited(value) {
+  if (!value.startsWith("/")) {
+    return void 0;
+  }
+  const closing = findLastUnescapedSlash(value);
+  if (closing <= 0) {
+    return void 0;
+  }
+  const flags = value.slice(closing + 1);
+  if (flags.length === 0 || !REGEX_FLAGS_PATTERN.test(flags)) {
+    return void 0;
+  }
+  return { pattern: value.slice(1, closing), flags };
+}
+function findLastUnescapedSlash(value) {
+  for (let i = value.length - 1; i > 0; i--) {
+    if (value[i] === "/" && !isEscaped(value, i)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function isEscaped(value, idx) {
+  let backslashes = 0;
+  for (let i = idx - 1; i >= 0; i--) {
+    if (value[i] === "\\") {
+      backslashes++;
+    } else {
+      break;
+    }
+  }
+  return backslashes % 2 === 1;
+}
+function stripTrailingSlash(value) {
+  if (value.length > 1 && value.endsWith("/")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function normalizeRelative(file) {
+  return file.replaceAll(/^[./\\]+/g, "").replaceAll("\\", "/");
+}
+function dropExtension(file) {
+  const match = TS_JS_EXT_PATTERN.exec(file);
+  if (!match) {
+    return { stem: file, matchedExt: false };
+  }
+  return { stem: file.slice(0, match.index), matchedExt: true };
+}
+var EXT_GROUP = String.raw`\.(?:ts|js|mts|mjs|cts|cjs)`;
+var OPTIONAL_EXT_GROUP = String.raw`(?:\.(?:ts|js|mts|mjs|cts|cjs))?`;
+function buildBreakpointUrlRegex(input) {
+  const normalized = normalizeRelative(input.file);
+  const { stem, matchedExt } = dropExtension(normalized);
+  const escapedStem = escapeRegExp(stem);
+  const tail = matchedExt ? `${escapedStem}${EXT_GROUP}` : `${escapedStem}${OPTIONAL_EXT_GROUP}`;
+  switch (input.remoteRoot.kind) {
+    case "none": {
+      return `(?:^|/)${tail}$`;
+    }
+    case "literal": {
+      const escapedRoot = escapeRegExp(input.remoteRoot.value);
+      return `^file://${escapedRoot}/${tail}$`;
+    }
+    case "regex": {
+      return `^file://${input.remoteRoot.pattern}/${tail}$`;
+    }
+  }
+}
+
+// src/inspector.ts
+init_types();
+var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
+var DEFAULT_HOST = "127.0.0.1";
+async function fetchJson(url, timeoutMs) {
+  return await new Promise((resolve, reject) => {
+    const req = request(url, { method: "GET" }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        try {
+          const text = Buffer.concat(chunks).toString("utf8");
+          resolve(JSON.parse(text));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          reject(
+            new CfInspectorError(
+              "INSPECTOR_DISCOVERY_FAILED",
+              `Failed to parse inspector discovery response from ${url}: ${message}`
+            )
+          );
+        }
+      });
+      res.on("error", (err) => {
+        reject(
+          new CfInspectorError(
+            "INSPECTOR_DISCOVERY_FAILED",
+            `Inspector discovery response error: ${err.message}`
+          )
+        );
+      });
+    });
+    req.setTimeout(timeoutMs, () => {
+      req.destroy(
+        new CfInspectorError(
+          "INSPECTOR_DISCOVERY_FAILED",
+          `Inspector discovery at ${url} timed out after ${timeoutMs.toString()}ms`
+        )
+      );
+    });
+    req.on("error", (err) => {
+      reject(
+        err instanceof CfInspectorError ? err : new CfInspectorError(
+          "INSPECTOR_DISCOVERY_FAILED",
+          `Inspector discovery at ${url} failed: ${err.message}`
+        )
+      );
+    });
+    req.end();
+  });
+}
+function toInspectorTarget(value, source) {
+  if (typeof value !== "object" || value === null) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Inspector target is not an object in ${source}`
+    );
+  }
+  const candidate = value;
+  const webSocketDebuggerUrl = candidate["webSocketDebuggerUrl"];
+  if (typeof webSocketDebuggerUrl !== "string" || webSocketDebuggerUrl.length === 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Inspector target is missing webSocketDebuggerUrl in ${source}`
+    );
+  }
+  return {
+    description: typeof candidate["description"] === "string" ? candidate["description"] : "",
+    id: typeof candidate["id"] === "string" ? candidate["id"] : "",
+    title: typeof candidate["title"] === "string" ? candidate["title"] : "",
+    type: typeof candidate["type"] === "string" ? candidate["type"] : "",
+    url: typeof candidate["url"] === "string" ? candidate["url"] : "",
+    webSocketDebuggerUrl,
+    ...typeof candidate["devtoolsFrontendUrl"] === "string" ? { devtoolsFrontendUrl: candidate["devtoolsFrontendUrl"] } : {},
+    ...typeof candidate["faviconUrl"] === "string" ? { faviconUrl: candidate["faviconUrl"] } : {}
+  };
+}
+async function discoverInspectorTargets(host, port, timeoutMs) {
+  const url = `http://${host}:${port.toString()}/json/list`;
+  const raw = await fetchJson(url, timeoutMs);
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No inspector targets returned from ${url}`
+    );
+  }
+  return raw.map((entry, idx) => toInspectorTarget(entry, `${url}[${idx.toString()}]`));
+}
+function readVersionField(value, ...keys) {
+  for (const key of keys) {
+    const entry = value[key];
+    if (typeof entry === "string" && entry.length > 0) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+async function fetchInspectorVersion(host, port, timeoutMs) {
+  const url = `http://${host}:${port.toString()}/json/version`;
+  const raw = await fetchJson(url, timeoutMs);
+  if (typeof raw !== "object" || raw === null) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Unexpected /json/version response from ${url}`
+    );
+  }
+  const value = raw;
+  const browser = readVersionField(value, "Browser", "browser");
+  const protocolVersion = readVersionField(value, "Protocol-Version", "protocolVersion");
+  if (browser === void 0 || protocolVersion === void 0) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `Unexpected /json/version response from ${url}`
+    );
+  }
+  return { browser, protocolVersion };
+}
+async function connectInspector(options) {
+  const host = options.host ?? DEFAULT_HOST;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const targets = await discoverInspectorTargets(host, options.port, connectTimeoutMs);
+  const target = targets[0];
+  if (!target) {
+    throw new CfInspectorError(
+      "INSPECTOR_DISCOVERY_FAILED",
+      `No inspector targets available on ${host}:${options.port.toString()}`
+    );
+  }
+  const client = await CdpClient.connect({ url: target.webSocketDebuggerUrl });
+  const scripts = /* @__PURE__ */ new Map();
+  client.on("Debugger.scriptParsed", (raw) => {
+    const params = raw;
+    const scriptId = asString(params.scriptId);
+    const url = asString(params.url);
+    if (scriptId.length === 0) {
+      return;
+    }
+    scripts.set(scriptId, { scriptId, url });
+  });
+  const PAUSE_BUFFER_LIMIT = 32;
+  const pauseBuffer = [];
+  client.on("Debugger.paused", (raw) => {
+    const params = raw;
+    const event = {
+      reason: asString(params.reason),
+      hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
+      callFrames: toCallFrames(params.callFrames)
+    };
+    if (pauseBuffer.length >= PAUSE_BUFFER_LIMIT) {
+      pauseBuffer.shift();
+    }
+    pauseBuffer.push(event);
+  });
+  await client.send("Runtime.enable");
+  await client.send("Debugger.enable");
+  return {
+    client,
+    target,
+    scripts,
+    pauseBuffer,
+    dispose: async () => {
+      try {
+        await client.send("Debugger.disable");
+      } catch {
+      }
+      client.dispose();
+    }
+  };
+}
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toResolvedLocations(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
+    }
+    const candidate = entry;
+    const scriptId = asString(candidate.scriptId);
+    if (scriptId.length === 0) {
+      return [];
+    }
+    const url = typeof candidate.url === "string" ? candidate.url : void 0;
+    const lineNumber = asNumber(candidate.lineNumber);
+    const result = url === void 0 ? { scriptId, lineNumber, columnNumber: asNumber(candidate.columnNumber) } : { scriptId, url, lineNumber, columnNumber: asNumber(candidate.columnNumber) };
+    return [result];
+  });
+}
+async function setBreakpoint(session, input) {
+  const remoteRoot = input.remoteRoot ?? { kind: "none" };
+  const urlRegex = buildBreakpointUrlRegex({ file: input.file, remoteRoot });
+  const params = {
+    lineNumber: input.line - 1,
+    urlRegex
+  };
+  if (input.condition !== void 0 && input.condition.length > 0) {
+    params["condition"] = input.condition;
+  }
+  const result = await session.client.send(
+    "Debugger.setBreakpointByUrl",
+    params
+  );
+  const breakpointId = asString(result.breakpointId);
+  if (breakpointId.length === 0) {
+    throw new CfInspectorError(
+      "CDP_REQUEST_FAILED",
+      `setBreakpointByUrl did not return a breakpointId for ${input.file}:${input.line.toString()}`
+    );
+  }
+  return {
+    breakpointId,
+    file: input.file,
+    line: input.line,
+    urlRegex,
+    resolvedLocations: toResolvedLocations(result.locations)
+  };
+}
+async function removeBreakpoint(session, breakpointId) {
+  await session.client.send("Debugger.removeBreakpoint", { breakpointId });
+}
+function toScopeChain(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
+    }
+    const candidate = entry;
+    const type = asString(candidate.type);
+    if (type.length === 0) {
+      return [];
+    }
+    const objectId = typeof candidate.object?.objectId === "string" ? candidate.object.objectId : void 0;
+    const name = typeof candidate.name === "string" ? candidate.name : void 0;
+    const base = name === void 0 ? { type } : { type, name };
+    return [objectId === void 0 ? base : { ...base, objectId }];
+  });
+}
+function toCallFrames(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return [];
+    }
+    const candidate = entry;
+    const callFrameId = asString(candidate.callFrameId);
+    if (callFrameId.length === 0) {
+      return [];
+    }
+    const url = typeof candidate.url === "string" ? candidate.url : void 0;
+    const lineNumber = asNumber(candidate.location?.lineNumber);
+    const columnNumber = asNumber(candidate.location?.columnNumber);
+    const base = {
+      callFrameId,
+      functionName: asString(candidate.functionName),
+      lineNumber,
+      columnNumber,
+      scopeChain: toScopeChain(candidate.scopeChain)
+    };
+    return [url === void 0 ? base : { ...base, url }];
+  });
+}
+function pauseMatches(pause, breakpointIds) {
+  if (breakpointIds === void 0 || breakpointIds.length === 0) {
+    return true;
+  }
+  return pause.hitBreakpoints.some((id) => breakpointIds.includes(id));
+}
+async function waitForPause(session, options) {
+  const buffer = session.pauseBuffer;
+  while (buffer.length > 0) {
+    const head = buffer.shift();
+    if (head !== void 0 && pauseMatches(head, options.breakpointIds)) {
+      return head;
+    }
+  }
+  const params = await session.client.waitFor("Debugger.paused", {
+    timeoutMs: options.timeoutMs,
+    predicate: (raw) => {
+      const event = {
+        reason: asString(raw.reason),
+        hitBreakpoints: Array.isArray(raw.hitBreakpoints) ? raw.hitBreakpoints.filter((id) => typeof id === "string") : [],
+        callFrames: []
+      };
+      return pauseMatches(event, options.breakpointIds);
+    }
+  });
+  return {
+    reason: asString(params.reason),
+    hitBreakpoints: Array.isArray(params.hitBreakpoints) ? params.hitBreakpoints.filter((id) => typeof id === "string") : [],
+    callFrames: toCallFrames(params.callFrames)
+  };
+}
+async function resume(session) {
+  await session.client.send("Debugger.resume");
+}
+async function evaluateOnFrame(session, callFrameId, expression) {
+  return await session.client.send("Debugger.evaluateOnCallFrame", {
+    callFrameId,
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true
+  });
+}
+async function evaluateGlobal(session, expression) {
+  return await session.client.send("Runtime.evaluate", {
+    expression,
+    returnByValue: false,
+    generatePreview: true,
+    silent: true
+  });
+}
+function listScripts(session) {
+  return [...session.scripts.values()];
+}
+async function getProperties(session, objectId) {
+  const result = await session.client.send("Runtime.getProperties", {
+    objectId,
+    ownProperties: true,
+    accessorPropertiesOnly: false,
+    generatePreview: true
+  });
+  if (!Array.isArray(result.result)) {
+    return [];
+  }
+  return result.result;
+}
+
+// src/logpoint.ts
+import { randomBytes } from "crypto";
+var SENTINEL_PREFIX = "__CFI_LOG_";
+var SENTINEL_SUFFIX = "__";
+function buildLogpointCondition(sentinel, expression) {
+  return [
+    "(function(){",
+    `var s=${JSON.stringify(sentinel)};`,
+    "try{",
+    `var v=(${expression});`,
+    "var r=typeof v==='string'?v:JSON.stringify(v);",
+    "console.log(s, r);",
+    "}catch(e){",
+    "console.log(s, '!err:'+(e&&e.message?e.message:String(e)));",
+    "}",
+    "return false;",
+    "})()"
+  ].join("");
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readArg(arg, index) {
+  if (typeof arg !== "object" || arg === null) {
+    return void 0;
+  }
+  const candidate = arg;
+  if (candidate.type === "string" && typeof candidate.value === "string") {
+    return candidate.value;
+  }
+  const isPrimitiveType = candidate.type === "number" || candidate.type === "boolean" || candidate.type === "bigint";
+  const isPrimitiveValue = typeof candidate.value === "number" || typeof candidate.value === "boolean" || typeof candidate.value === "bigint";
+  if (isPrimitiveType && isPrimitiveValue) {
+    return String(candidate.value);
+  }
+  return index === 0 ? void 0 : "";
+}
+function parseLogEvent(rawArgs, sentinel, location, timestamp) {
+  if (!Array.isArray(rawArgs) || rawArgs.length < 2) {
+    return void 0;
+  }
+  const tag = readArg(rawArgs[0], 0);
+  if (tag !== sentinel) {
+    return void 0;
+  }
+  const payload = readArg(rawArgs[1], 1) ?? "";
+  const ts = new Date(typeof timestamp === "number" ? timestamp : Date.now()).toISOString();
+  const at = `${location.file}:${location.line.toString()}`;
+  if (payload.startsWith("!err:")) {
+    return { ts, at, error: payload.slice("!err:".length) };
+  }
+  try {
+    const parsed = JSON.parse(payload);
+    if (typeof parsed === "string") {
+      return { ts, at, value: parsed };
+    }
+    return { ts, at, value: JSON.stringify(parsed) };
+  } catch {
+    return { ts, at, value: payload, raw: payload };
+  }
+}
+function generateSentinel() {
+  return `${SENTINEL_PREFIX}${randomBytes(8).toString("hex")}${SENTINEL_SUFFIX}`;
+}
+async function streamLogpoint(session, options) {
+  const sentinel = generateSentinel();
+  const condition = buildLogpointCondition(sentinel, options.expression);
+  const handle = await setBreakpoint(session, {
+    file: options.location.file,
+    line: options.location.line,
+    ...options.remoteRoot === void 0 ? {} : { remoteRoot: options.remoteRoot },
+    condition
+  });
+  let emitted = 0;
+  const offEvent = session.client.on("Runtime.consoleAPICalled", (raw) => {
+    const params = raw;
+    if (asString2(params.type) !== "log") {
+      return;
+    }
+    const ts = typeof params.timestamp === "number" ? params.timestamp : void 0;
+    const event = parseLogEvent(params.args, sentinel, options.location, ts);
+    if (event === void 0) {
+      return;
+    }
+    emitted += 1;
+    options.onEvent(event);
+  });
+  const cleanup = async () => {
+    offEvent();
+    try {
+      await removeBreakpoint(session, handle.breakpointId);
+    } catch {
+    }
+  };
+  try {
+    const reason = await waitForStop(session, options);
+    return { handle, sentinel, emitted, stoppedReason: reason };
+  } finally {
+    await cleanup();
+  }
+}
+async function waitForStop(session, options) {
+  return await new Promise((resolve) => {
+    let settled = false;
+    const finish = (reason) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(reason);
+    };
+    const timer = options.durationMs === void 0 ? void 0 : setTimeout(() => {
+      finish("duration");
+    }, options.durationMs);
+    const offClose = session.client.onClose(() => {
+      finish("transport-closed");
+    });
+    const onAbort = () => {
+      finish("signal");
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted === true) {
+      finish("signal");
+    }
+    function cleanup() {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+      offClose();
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  });
+}
+
+// src/snapshot.ts
+var MAX_SCOPES = 3;
+var MAX_SCOPE_VARIABLES = 20;
+var MAX_CHILD_VARIABLES = 8;
+var MAX_VARIABLE_DEPTH = 2;
+var MAX_VALUE_LENGTH = 240;
+var SENSITIVE_NAME_REGEX = /(pass(?:word)?|token|secret|api[_-]?key|authorization|cookie|session|private[_-]?key)/i;
+var PRIORITY_BY_TYPE = {
+  local: 0,
+  arguments: 1,
+  block: 2,
+  closure: 3,
+  catch: 4,
+  with: 5,
+  module: 6,
+  script: 7
+};
+function buildDescribed(value, type, objectId) {
+  const base = { value };
+  if (type !== void 0) {
+    base.type = type;
+  }
+  if (objectId !== void 0) {
+    base.objectId = objectId;
+  }
+  return base;
+}
+function describeProperty(prop) {
+  const value = prop.value;
+  if (value === void 0) {
+    return { value: "undefined" };
+  }
+  const type = typeof value.type === "string" ? value.type : void 0;
+  const objectId = typeof value.objectId === "string" ? value.objectId : void 0;
+  if (type === "undefined") {
+    return buildDescribed("undefined", type);
+  }
+  if (type === "string" && typeof value.value === "string") {
+    return buildDescribed(JSON.stringify(value.value), type);
+  }
+  if ((type === "number" || type === "boolean" || type === "bigint" || type === "symbol") && isPrimitive(value.value)) {
+    return buildDescribed(formatPrimitive(value.value), type);
+  }
+  if (typeof value.description === "string") {
+    return buildDescribed(value.description, type, objectId);
+  }
+  if (isPrimitive(value.value)) {
+    return buildDescribed(formatPrimitive(value.value), type);
+  }
+  if (objectId === void 0) {
+    return buildDescribed("undefined", type);
+  }
+  return buildDescribed("[object]", type, objectId);
+}
+function isPrimitive(value) {
+  const t = typeof value;
+  return t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol";
+}
+function formatPrimitive(value) {
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (typeof value === "bigint") {
+    return `${value.toString()}n`;
+  }
+  return String(value);
+}
+function sanitizeValue(name, raw) {
+  if (SENSITIVE_NAME_REGEX.test(name)) {
+    return "[REDACTED]";
+  }
+  if (raw.length <= MAX_VALUE_LENGTH) {
+    return raw;
+  }
+  return `${raw.slice(0, MAX_VALUE_LENGTH)}...`;
+}
+function isExpandable(type) {
+  return type === "object" || type === "function";
+}
+async function captureProperties(session, objectId, limit, depth) {
+  const properties = await getProperties(session, objectId);
+  const limited = properties.slice(0, limit);
+  const variables = await Promise.all(
+    limited.map(async (prop) => {
+      const name = typeof prop.name === "string" ? prop.name : "?";
+      const described = describeProperty(prop);
+      let children;
+      if (depth > 0 && described.objectId !== void 0 && isExpandable(described.type)) {
+        try {
+          const nested = await captureProperties(
+            session,
+            described.objectId,
+            MAX_CHILD_VARIABLES,
+            depth - 1
+          );
+          if (nested.length > 0) {
+            children = nested;
+          }
+        } catch {
+        }
+      }
+      const sanitizedValue = sanitizeValue(name, described.value);
+      const base = { name, value: sanitizedValue };
+      const withType = described.type === void 0 ? base : { ...base, type: described.type };
+      return children === void 0 ? withType : { ...withType, children };
+    })
+  );
+  return variables;
+}
+function selectScopes(scopeChain) {
+  const eligible = scopeChain.filter((scope) => scope.objectId !== void 0 && scope.type !== "global");
+  return [...eligible].sort((a, b) => priorityOf(a.type) - priorityOf(b.type)).slice(0, MAX_SCOPES);
+}
+function priorityOf(type) {
+  return PRIORITY_BY_TYPE[type] ?? Number.MAX_SAFE_INTEGER;
+}
+async function captureScopes(session, frame) {
+  const scopes = selectScopes(frame.scopeChain);
+  return await Promise.all(
+    scopes.map(async (scope) => {
+      const objectId = scope.objectId;
+      if (objectId === void 0) {
+        return { type: scope.type, variables: [] };
+      }
+      const variables = await captureProperties(session, objectId, MAX_SCOPE_VARIABLES, MAX_VARIABLE_DEPTH);
+      return { type: scope.type, variables };
+    })
+  );
+}
+function evalResultToCaptured(expression, result) {
+  if (result.exceptionDetails !== void 0) {
+    const text = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "evaluation failed";
+    return { expression, error: text };
+  }
+  const inner = result.result;
+  if (!inner) {
+    return { expression, error: "no result returned" };
+  }
+  const type = typeof inner.type === "string" ? inner.type : void 0;
+  const buildCaptured = (rendered) => {
+    const sanitized = sanitizeValue(expression, rendered);
+    const base = { expression, value: sanitized };
+    return type === void 0 ? base : { ...base, type };
+  };
+  if (type === "string" && typeof inner.value === "string") {
+    return buildCaptured(JSON.stringify(inner.value));
+  }
+  if ((type === "number" || type === "boolean" || type === "bigint") && isPrimitive(inner.value)) {
+    return buildCaptured(formatPrimitive(inner.value));
+  }
+  if (typeof inner.description === "string") {
+    return buildCaptured(inner.description);
+  }
+  if (isPrimitive(inner.value)) {
+    return buildCaptured(formatPrimitive(inner.value));
+  }
+  return buildCaptured("undefined");
+}
+async function captureSnapshot(session, pause, options = {}) {
+  const top = pause.callFrames[0];
+  let topFrame;
+  let captures = [];
+  if (top) {
+    const scopes = await captureScopes(session, top);
+    topFrame = {
+      functionName: top.functionName,
+      ...top.url === void 0 ? {} : { url: top.url },
+      line: top.lineNumber + 1,
+      column: top.columnNumber + 1,
+      scopes
+    };
+    if (options.captures !== void 0 && options.captures.length > 0) {
+      captures = await Promise.all(
+        options.captures.map(async (expression) => {
+          try {
+            const result = await evaluateOnFrame(session, top.callFrameId, expression);
+            return evalResultToCaptured(expression, result);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { expression, error: message };
+          }
+        })
+      );
+    }
+  }
+  return {
+    reason: pause.reason,
+    hitBreakpoints: pause.hitBreakpoints,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...topFrame === void 0 ? {} : { topFrame },
+    captures
+  };
+}
+
+// src/tunnel.ts
+import { startDebugger } from "@saptools/cf-debugger";
+async function openCfTunnel(target) {
+  const opts = {
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    ...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 }
+  };
+  const handle = await startDebugger(opts);
+  return {
+    localPort: handle.session.localPort,
+    handle,
+    dispose: async () => {
+      await handle.dispose();
+    }
+  };
+}
+
+// src/cli.ts
+init_types();
+var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
+var DEFAULT_CF_TIMEOUT_SEC = 60;
+function parsePositiveInt(raw, label) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value <= 0) {
+    throw new CfInspectorError("MISSING_TARGET", `Invalid ${label}: "${raw}"`);
+  }
+  return value;
+}
+function resolveTarget(opts) {
+  const port = parsePositiveInt(opts.port, "--port");
+  if (port !== void 0) {
+    return { kind: "port", port, host: opts.host ?? "127.0.0.1" };
+  }
+  if (opts.region !== void 0 && opts.org !== void 0 && opts.space !== void 0 && opts.app !== void 0) {
+    const cfTimeoutSec = parsePositiveInt(opts.cfTimeout, "--cf-timeout") ?? DEFAULT_CF_TIMEOUT_SEC;
+    return {
+      kind: "cf",
+      region: opts.region,
+      org: opts.org,
+      space: opts.space,
+      app: opts.app,
+      cfTimeoutMs: cfTimeoutSec * 1e3
+    };
+  }
+  throw new CfInspectorError(
+    "MISSING_TARGET",
+    "Provide either --port (and optionally --host) or all of --region, --org, --space, --app."
+  );
+}
+async function openTarget(target) {
+  if (target.kind === "port") {
+    return {
+      port: target.port,
+      host: target.host,
+      dispose: () => Promise.resolve()
+    };
+  }
+  const tunnel = await openCfTunnel({
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    tunnelReadyTimeoutMs: target.cfTimeoutMs
+  });
+  return {
+    port: tunnel.localPort,
+    host: "127.0.0.1",
+    dispose: async () => {
+      await tunnel.dispose();
+    }
+  };
+}
+function parseCaptureList(raw) {
+  if (raw === void 0 || raw.trim().length === 0) {
+    return [];
+  }
+  return raw.split(",").map((piece) => piece.trim()).filter((piece) => piece.length > 0);
+}
+async function withSession(target, fn) {
+  const tunnel = await openTarget(target);
+  let session;
+  try {
+    session = await connectInspector({ port: tunnel.port, host: tunnel.host });
+    return await fn(session, tunnel.port);
+  } finally {
+    if (session) {
+      await session.dispose();
+    }
+    await tunnel.dispose();
+  }
+}
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function writeHumanSnapshot(snapshot) {
+  const lines = [];
+  lines.push(`Snapshot @ ${snapshot.capturedAt}`, `  reason:  ${snapshot.reason}`);
+  if (snapshot.topFrame) {
+    const frame = snapshot.topFrame;
+    const fnName = frame.functionName.length === 0 ? "(anonymous)" : frame.functionName;
+    const sourceUrl = frame.url !== void 0 && frame.url.length > 0 ? frame.url : "(unknown)";
+    lines.push(
+      `  frame:   ${fnName} ${sourceUrl}:${frame.line.toString()}:${frame.column.toString()}`
+    );
+    for (const scope of frame.scopes) {
+      lines.push(`  scope ${scope.type} (${scope.variables.length.toString()} vars):`);
+      for (const variable of scope.variables) {
+        lines.push(`    ${variable.name} = ${variable.value}`);
+      }
+    }
+  }
+  if (snapshot.captures.length > 0) {
+    lines.push("  captures:");
+    for (const capture of snapshot.captures) {
+      const detail = capture.error ?? capture.value ?? "undefined";
+      lines.push(`    ${capture.expression} = ${detail}`);
+    }
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+async function handleSnapshot(opts) {
+  const target = resolveTarget(opts);
+  if (opts.bp.length === 0) {
+    throw new CfInspectorError(
+      "INVALID_BREAKPOINT",
+      "At least one --bp <file:line> is required."
+    );
+  }
+  const breakpoints = opts.bp.map((spec) => parseBreakpointSpec(spec));
+  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
+  const captures = parseCaptureList(opts.capture);
+  const timeoutSec = parsePositiveInt(opts.timeout, "--timeout") ?? DEFAULT_BREAKPOINT_TIMEOUT_SEC;
+  const timeoutMs = timeoutSec * 1e3;
+  const condition = opts.condition !== void 0 && opts.condition.trim().length > 0 ? opts.condition.trim() : void 0;
+  const result = await withSession(target, async (session) => {
+    const handles = await Promise.all(
+      breakpoints.map(
+        (bp) => setBreakpoint(session, {
+          file: bp.file,
+          line: bp.line,
+          remoteRoot,
+          ...condition === void 0 ? {} : { condition }
+        })
+      )
+    );
+    const breakpointIds = handles.map((h) => h.breakpointId);
+    const pause = await waitForPause(session, { timeoutMs, breakpointIds });
+    const snapshot = await captureSnapshot(session, pause, { captures });
+    if (opts.keepPaused !== true) {
+      try {
+        await resume(session);
+      } catch {
+      }
+    }
+    return snapshot;
+  });
+  if (opts.json) {
+    writeJson(result);
+  } else {
+    writeHumanSnapshot(result);
+  }
+}
+async function handleEval(opts) {
+  const target = resolveTarget(opts);
+  const result = await withSession(target, async (session) => {
+    return await evaluateGlobal(session, opts.expr);
+  });
+  if (opts.json) {
+    writeJson(result);
+    return;
+  }
+  if (result.exceptionDetails !== void 0) {
+    const detail = typeof result.exceptionDetails.exception?.description === "string" ? result.exceptionDetails.exception.description : typeof result.exceptionDetails.text === "string" ? result.exceptionDetails.text : "evaluation failed";
+    process.stderr.write(`${detail}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const inner = result.result;
+  if (inner === void 0) {
+    process.stdout.write("\n");
+    return;
+  }
+  if (typeof inner.value === "string") {
+    process.stdout.write(`${inner.value}
+`);
+    return;
+  }
+  if (typeof inner.description === "string") {
+    process.stdout.write(`${inner.description}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(inner.value)}
+`);
+}
+function writeLogEvent(event, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(event)}
+`);
+    return;
+  }
+  if (event.error !== void 0) {
+    process.stdout.write(`[${event.ts}] ${event.at} !err ${event.error}
+`);
+    return;
+  }
+  process.stdout.write(`[${event.ts}] ${event.at} ${event.value ?? ""}
+`);
+}
+async function handleLog(opts) {
+  const target = resolveTarget(opts);
+  const location = parseBreakpointSpec(opts.at);
+  const remoteRoot = parseRemoteRoot(opts.remoteRoot);
+  const durationSec = parsePositiveInt(opts.duration, "--duration");
+  const expression = opts.expr.trim();
+  if (expression.length === 0) {
+    throw new CfInspectorError("INVALID_BREAKPOINT", "--expr must not be empty");
+  }
+  const abort = new AbortController();
+  const onSig = () => {
+    abort.abort();
+  };
+  process.once("SIGINT", onSig);
+  process.once("SIGTERM", onSig);
+  try {
+    await withSession(target, async (session) => {
+      const result = await streamLogpoint(session, {
+        location,
+        expression,
+        remoteRoot,
+        ...durationSec === void 0 ? {} : { durationMs: durationSec * 1e3 },
+        signal: abort.signal,
+        onEvent: (event) => {
+          writeLogEvent(event, opts.json);
+        }
+      });
+      if (opts.json) {
+        process.stderr.write(
+          `${JSON.stringify({ stopped: result.stoppedReason, emitted: result.emitted })}
+`
+        );
+      } else {
+        process.stderr.write(
+          `Stopped (${result.stoppedReason}); emitted ${result.emitted.toString()} log ${result.emitted === 1 ? "entry" : "entries"}.
+`
+        );
+      }
+    });
+  } finally {
+    process.off("SIGINT", onSig);
+    process.off("SIGTERM", onSig);
+  }
+}
+async function handleListScripts(opts) {
+  const target = resolveTarget(opts);
+  const scripts = await withSession(target, (session) => Promise.resolve(listScripts(session)));
+  if (opts.json) {
+    writeJson(scripts);
+    return;
+  }
+  for (const script of scripts) {
+    process.stdout.write(`${script.scriptId}	${script.url}
+`);
+  }
+}
+async function handleAttach(opts) {
+  const target = resolveTarget(opts);
+  const tunnel = await openTarget(target);
+  try {
+    const version = await fetchInspectorVersion(tunnel.host, tunnel.port, 5e3);
+    if (opts.json) {
+      writeJson({ host: tunnel.host, port: tunnel.port, ...version });
+      return;
+    }
+    process.stdout.write(
+      `Connected to ${tunnel.host}:${tunnel.port.toString()}
+  Browser: ${version.browser}
+  Protocol: ${version.protocolVersion}
+`
+    );
+  } finally {
+    await tunnel.dispose();
+  }
+}
+function applyTargetOptions(cmd) {
+  return cmd.option("--port <number>", "Local port the inspector or tunnel listens on").option("--host <host>", "Hostname (default: 127.0.0.1)", "127.0.0.1").option("--region <key>", "CF region key (e.g. eu10)").option("--org <name>", "CF org name").option("--space <name>", "CF space name").option("--app <name>", "CF app name").option("--cf-timeout <seconds>", "Timeout for CF tunnel readiness in seconds");
+}
+async function main(argv) {
+  const program = new Command();
+  program.name("cf-inspector").description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
+  const collectStrings = (value, prev = []) => [
+    ...prev,
+    value
+  ];
+  applyTargetOptions(
+    program.command("snapshot").description("Set a breakpoint, wait for it to hit, capture the scope, and resume")
+  ).option(
+    "--bp <file:line>",
+    "Breakpoint location (repeatable; first hit wins), e.g. src/handler.ts:42",
+    collectStrings,
+    []
+  ).option("--capture <expr,\u2026>", "Comma-separated expressions to evaluate in the paused frame").option("--timeout <seconds>", "How long to wait for the breakpoint to hit (default: 30)").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("--no-json", "Print a human-readable summary instead of JSON").option("--keep-paused", "Skip the auto-resume after capture").action(async (opts) => {
+    await handleSnapshot(opts);
+  });
+  applyTargetOptions(
+    program.command("log").description("Stream a non-pausing logpoint: log an expression each time a line executes")
+  ).requiredOption("--at <file:line>", "Logpoint location, e.g. src/handler.ts:42").requiredOption("--expr <expression>", "JavaScript expression to log on each hit").option("--remote-root <value>", "Path-mapping anchor: literal path or regex:<pattern> / /pattern/flags").option("--duration <seconds>", "Stop streaming after N seconds (default: run until SIGINT)").option("--no-json", "Print human-readable lines instead of JSON Lines").action(async (opts) => {
+    await handleLog(opts);
+  });
+  applyTargetOptions(
+    program.command("eval").description("Evaluate an expression against the global Runtime")
+  ).requiredOption("--expr <expression>", "JavaScript expression to evaluate").option("--no-json", "Print only the resulting value, not the full CDP envelope").action(async (opts) => {
+    await handleEval(opts);
+  });
+  applyTargetOptions(
+    program.command("list-scripts").description("Print the scripts the V8 instance currently knows about")
+  ).option("--no-json", "Print scriptId<TAB>url instead of JSON").action(async (opts) => {
+    await handleListScripts(opts);
+  });
+  applyTargetOptions(
+    program.command("attach").description("Connect, fetch the inspector version, and disconnect (smoke-test)")
+  ).option("--no-json", "Print a multi-line summary instead of JSON").action(async (opts) => {
+    await handleAttach(opts);
+  });
+  await program.parseAsync([...argv]);
+}
+try {
+  await main(process.argv);
+} catch (err) {
+  if (err instanceof CfInspectorError) {
+    process.stderr.write(`Error [${err.code}]: ${err.message}
+`);
+    if (err.detail !== void 0) {
+      process.stderr.write(`  detail: ${err.detail}
+`);
+    }
+    process.exit(1);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+export {
+  main
+};
+//# sourceMappingURL=cli.js.map