@saptools/cf-inspector 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -140,11 +140,15 @@ interface CdpTransport {
     on<E extends keyof CdpTransportEventMap>(event: E, listener: CdpTransportEventMap[E]): void;
     off<E extends keyof CdpTransportEventMap>(event: E, listener: CdpTransportEventMap[E]): void;
 }
-type CdpTransportFactory = (url: string) => Promise<CdpTransport>;
+interface CdpTransportFactoryOptions {
+    readonly connectTimeoutMs?: number;
+}
+type CdpTransportFactory = (url: string, options?: CdpTransportFactoryOptions) => Promise<CdpTransport>;
 interface CdpClientOptions {
     readonly url: string;
     readonly transportFactory?: CdpTransportFactory;
     readonly requestTimeoutMs?: number;
+    readonly connectTimeoutMs?: number;
 }
 declare class CdpClient {
     private readonly transport;
@@ -155,6 +159,7 @@ declare class CdpClient {
     private closed;
     private closeReason;
     private readonly handleMessage;
+    private safeEmit;
     private readonly handleClose;
     private readonly handleError;
     private constructor();

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -35,10 +34,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 +58,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 +71,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 +102,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({
@@ -212,9 +253,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`\$&`);
@@ -241,12 +284,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));
     }
   }
 }
@@ -757,10 +800,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"));
   };
@@ -778,7 +830,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 = {}) {
@@ -828,8 +881,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);
       });
@@ -959,7 +1020,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;
@@ -1080,19 +1152,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) {
@@ -1694,7 +1779,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?.();