@saptools/cf-inspector 0.4.0 → 0.4.1

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";
@@ -404,10 +446,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 +476,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 +527,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 +776,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;
@@ -1066,9 +1137,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 +1168,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 +1437,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 +2127,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 +2286,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 +2374,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 +2405,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 +2419,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 +2429,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,7 +2445,7 @@ 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);
@@ -2435,7 +2534,7 @@ async function resumeAfterSnapshot(session, snapshot, pausedStartedAt) {
     await resume(session);
     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 +2542,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 +2636,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 +2648,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 +2666,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 +2753,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"}.
 `
   );
@@ -2745,20 +2836,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