@skrillex1224/playwright-toolkit 2.1.198 → 2.1.199

package/dist/index.cjs

@@ -599,9 +599,31 @@ var logger2 = createInternalLogger("ProxyMeter");
 var MAX_TOP_DOMAINS = 20;
 var FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_DEBUG_MAX_EVENTS = 400;
+var PROXY_METER_READY_TIMEOUT_MS = 5e3;
+var PROXY_METER_STABLE_WINDOW_MS = 2e3;
+var PROXY_METER_POLL_INTERVAL_MS = 100;
+var PROXY_METER_CONNECT_TIMEOUT_MS = 200;
 var runtime = null;
 var cleanupInstalled = false;
 var observedDomainResourceTypes = /* @__PURE__ */ new Map();
+var sleepSignal = new Int32Array(new SharedArrayBuffer(4));
+var portProbeScript = [
+  'const net = require("net");',
+  "const port = Number(process.argv[1] || 0);",
+  "const timeout = Number(process.argv[2] || 200);",
+  "if (!Number.isFinite(port) || port <= 0) process.exit(2);",
+  'const socket = net.connect({ host: "127.0.0.1", port });',
+  "let done = false;",
+  "const finish = (code) => {",
+  "  if (done) return;",
+  "  done = true;",
+  "  try { socket.destroy(); } catch {}",
+  "  process.exit(code);",
+  "};",
+  'socket.once("connect", () => finish(0));',
+  'socket.once("error", () => finish(1));',
+  "socket.setTimeout(timeout, () => finish(1));"
+].join("");
 var toSafeInt = (value) => {
   const num = Number(value);
   if (!Number.isFinite(num) || num <= 0) return 0;
@@ -700,6 +722,17 @@ var ensureLogPath = () => {
   const label = runId ? `proxy-meter-${runId}-${suffix}.json` : `proxy-meter-${process.pid}-${suffix}.json`;
   return import_path.default.join(baseDir, label);
 };
+var ensureStatePath = () => {
+  const baseDir = resolveLogDir();
+  if (!(0, import_fs.existsSync)(baseDir)) {
+    try {
+      (0, import_fs.mkdirSync)(baseDir, { recursive: true });
+    } catch {
+    }
+  }
+  const suffix = `${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+  return import_path.default.join(baseDir, `proxy-meter-state-${process.pid}-${suffix}.json`);
+};
 var readSnapshot = (logPath) => {
   if (!logPath || !(0, import_fs.existsSync)(logPath)) return null;
   try {
@@ -710,6 +743,86 @@ var readSnapshot = (logPath) => {
     return null;
   }
 };
+var readState = (statePath) => {
+  if (!statePath || !(0, import_fs.existsSync)(statePath)) return null;
+  try {
+    const raw = (0, import_fs.readFileSync)(statePath, "utf8");
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var sleepSync = (durationMs) => {
+  const timeout = Math.max(0, Number(durationMs) || 0);
+  if (timeout <= 0) return;
+  Atomics.wait(sleepSignal, 0, 0, timeout);
+};
+var canConnectToPort = (port, timeoutMs = PROXY_METER_CONNECT_TIMEOUT_MS) => {
+  const result = (0, import_child_process.spawnSync)(process.execPath, ["-e", portProbeScript, String(port), String(timeoutMs)], {
+    stdio: "ignore",
+    timeout: timeoutMs + 100
+  });
+  return result.status === 0;
+};
+var waitForProxyMeterReady = ({ port, statePath }) => {
+  const startedAt = Date.now();
+  const listenDeadline = startedAt + PROXY_METER_READY_TIMEOUT_MS;
+  let firstConnectAt = 0;
+  let stableHealthy = true;
+  while (Date.now() < listenDeadline) {
+    const lifecycle = readState(statePath);
+    if (lifecycle?.status === "exited") {
+      return {
+        ok: false,
+        reason: "child_exit_before_ready",
+        childExitCode: lifecycle.exitCode,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    if (canConnectToPort(port)) {
+      firstConnectAt = Date.now();
+      break;
+    }
+    sleepSync(PROXY_METER_POLL_INTERVAL_MS);
+  }
+  if (!firstConnectAt) {
+    return {
+      ok: false,
+      reason: "listen_timeout",
+      childExitCode: readState(statePath)?.exitCode ?? null,
+      latencyMs: Date.now() - startedAt
+    };
+  }
+  const stableDeadline = firstConnectAt + PROXY_METER_STABLE_WINDOW_MS;
+  while (Date.now() < stableDeadline) {
+    const lifecycle = readState(statePath);
+    if (lifecycle?.status === "exited") {
+      return {
+        ok: false,
+        reason: "stabilize_timeout",
+        childExitCode: lifecycle.exitCode,
+        latencyMs: Date.now() - startedAt
+      };
+    }
+    if (!canConnectToPort(port)) {
+      stableHealthy = false;
+    }
+    sleepSync(PROXY_METER_POLL_INTERVAL_MS);
+  }
+  if (!stableHealthy || !canConnectToPort(port)) {
+    return {
+      ok: false,
+      reason: "stabilize_timeout",
+      childExitCode: readState(statePath)?.exitCode ?? null,
+      latencyMs: Date.now() - startedAt
+    };
+  }
+  return {
+    ok: true,
+    latencyMs: Date.now() - startedAt
+  };
+};
 var normalizeDomainRows = (hosts) => {
   const rows = [];
   let requestCount = 0;
@@ -858,15 +971,23 @@ var startProxyMeter = (options = {}) => {
   const upstreamUrl = String(options.proxyUrl || "").trim();
   if (!upstreamUrl) return null;
   if (runtime && runtime.proc) {
+    const previousStatePath = runtime.statePath;
     try {
       runtime.proc.kill("SIGTERM");
     } catch {
     }
     runtime = null;
+    if (previousStatePath) {
+      try {
+        (0, import_fs.rmSync)(previousStatePath, { force: true });
+      } catch {
+      }
+    }
   }
   observedDomainResourceTypes = /* @__PURE__ */ new Map();
   const port = pickFreePort();
   const logPath = ensureLogPath();
+  const statePath = ensureStatePath();
   const scriptPath = resolveScriptPath();
   const debugMode = Boolean(options.debugMode);
   const debugMaxEvents = Math.max(10, toSafeInt(options.debugMaxEvents) || DEFAULT_DEBUG_MAX_EVENTS);
@@ -877,7 +998,8 @@ var startProxyMeter = (options = {}) => {
     PROXY_METER_UPSTREAM: upstreamUrl,
     PROXY_METER_FLUSH_MS: String(FLUSH_INTERVAL_MS),
     PROXY_METER_DEBUG: debugMode ? "1" : "0",
-    PROXY_METER_DEBUG_MAX_EVENTS: String(debugMaxEvents)
+    PROXY_METER_DEBUG_MAX_EVENTS: String(debugMaxEvents),
+    PROXY_METER_STATE: statePath
   };
   const child = (0, import_child_process.spawn)(process.execPath, [scriptPath], {
     env,
@@ -892,8 +1014,27 @@ var startProxyMeter = (options = {}) => {
     proc: child,
     port,
     logPath,
+    statePath,
     startedAt: Date.now()
   };
+  const readiness = waitForProxyMeterReady({ port, statePath });
+  if (!readiness.ok) {
+    logger2.warn(
+      `[proxy-meter] startup failed reason=${readiness.reason} latency_ms=${readiness.latencyMs} exit_code=${readiness.childExitCode ?? "unknown"}`
+    );
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    runtime = null;
+    try {
+      (0, import_fs.rmSync)(statePath, { force: true });
+    } catch {
+    }
+    throw new Error(`proxy-meter startup failed: ${readiness.reason}`);
+  }
+  runtime.startedAt = Date.now() - readiness.latencyMs;
+  logger2.info(`[proxy-meter] ready latency_ms=${readiness.latencyMs} stable_window_ms=${PROXY_METER_STABLE_WINDOW_MS}`);
   registerCleanup();
   return { server: `http://127.0.0.1:${port}` };
 };
@@ -905,9 +1046,15 @@ var recordProxyMeterResourceType = (requestUrl, resourceType) => {
 };
 var stopProxyMeter = async () => {
   if (!runtime) return null;
-  const { proc, logPath } = runtime;
+  const { proc, logPath, statePath } = runtime;
   if (!proc || proc.killed) {
     runtime = null;
+    if (statePath) {
+      try {
+        (0, import_fs.rmSync)(statePath, { force: true });
+      } catch {
+      }
+    }
     return logPath || null;
   }
   await new Promise((resolve) => {
@@ -929,6 +1076,12 @@ var stopProxyMeter = async () => {
     }
   });
   runtime = null;
+  if (statePath) {
+    try {
+      (0, import_fs.rmSync)(statePath, { force: true });
+    } catch {
+    }
+  }
   return logPath || null;
 };
 var getProxyMeterSnapshot = async (options = {}) => {