@saptools/cf-inspector 0.7.0 → 0.7.1

package/dist/cli.js

@@ -152,16 +152,16 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process12 from "process";
+import process13 from "process";
 
 // src/cli/program.ts
 import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 
 // src/cli/commands/attach.ts
-import process3 from "process";
+import process4 from "process";
 
 // src/inspector/discovery.ts
 init_types();
@@ -386,13 +386,13 @@ function startInspectorKeepalive(host, port, options = {}) {
 }
 
 // src/cli/output.ts
-import process from "process";
+import process2 from "process";
 function writeProgress(message) {
-  process.stderr.write(`[cf-inspector] ${message}
+  process2.stderr.write(`[cf-inspector] ${message}
 `);
 }
 function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
+  process2.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
 }
 function writeHumanSnapshot(snapshot) {
@@ -423,7 +423,7 @@ function writeHumanSnapshot(snapshot) {
       appendStackFrameLine(lines, frame);
     }
   }
-  process.stdout.write(`${lines.join("\n")}
+  process2.stdout.write(`${lines.join("\n")}
 `);
 }
 function appendFrameLines(lines, frame) {
@@ -466,36 +466,36 @@ function appendExceptionLines(lines, exception) {
 }
 function writeLogEvent(event, json) {
   if (json) {
-    process.stdout.write(`${JSON.stringify(event)}
+    process2.stdout.write(`${JSON.stringify(event)}
 `);
     return;
   }
   const isolateSuffix = event.isolate === void 0 ? "" : ` (${formatIsolate(event.isolate)})`;
   if (event.error !== void 0) {
-    process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} !err ${renderTruncated(event.error, event)}
+    process2.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} !err ${renderTruncated(event.error, event)}
 `);
     return;
   }
-  process.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} ${renderTruncated(event.value ?? "", event)}
+  process2.stdout.write(`[${event.ts}] ${event.at}${isolateSuffix} ${renderTruncated(event.value ?? "", event)}
 `);
 }
 function writeWatchEvent(event, json) {
   if (json) {
-    process.stdout.write(`${JSON.stringify(event)}
+    process2.stdout.write(`${JSON.stringify(event)}
 `);
     return;
   }
-  process.stdout.write(
+  process2.stdout.write(
     `[${event.ts}] hit#${event.hit.toString()} ${event.at} (${formatIsolate(event.isolate)})
 `
   );
   if (event.exception !== void 0) {
-    process.stdout.write(`  exception: ${renderExceptionDetail(event.exception)}
+    process2.stdout.write(`  exception: ${renderExceptionDetail(event.exception)}
 `);
   }
   for (const capture of event.captures) {
     const detail = capture.error ?? capture.value ?? "undefined";
-    process.stdout.write(`  ${capture.expression} = ${renderTruncated(detail, capture)}
+    process2.stdout.write(`  ${capture.expression} = ${renderTruncated(detail, capture)}
 `);
   }
 }
@@ -1776,9 +1776,247 @@ var DEFAULT_BREAKPOINT_TIMEOUT_SEC = 30;
 var DEFAULT_CF_TIMEOUT_SEC = 180;
 var DEFAULT_EXCEPTION_TIMEOUT_SEC = 30;
 
+// src/cli/sessionLock.ts
+init_types();
+import { execFileSync } from "child_process";
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import { mkdir, open, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var ELECTION_WINDOW_MS = 25;
+var LOCK_FILE_SUFFIX = ".lock";
+async function acquireDebugSessionLock(target, options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const pid = options.pid ?? process.pid;
+  const getProcessStart = options.getProcessStart ?? processStart;
+  const ownerProcessStart = getProcessStart(pid);
+  const token = options.token?.() ?? randomUUID();
+  const targetIdentity = debugTargetIdentity(target);
+  const key = createHash("sha256").update(targetIdentity).digest("hex");
+  const lockRoot = options.stateRoot ?? defaultStateRoot();
+  const lockDirectory = join(lockRoot, "cf-inspector", "locks");
+  const ownPath = join(lockDirectory, `${key}.${pid.toString()}.${token}${LOCK_FILE_SUFFIX}`);
+  const metadata = {
+    pid,
+    ...ownerProcessStart === void 0 ? {} : { processStart: ownerProcessStart },
+    state: "pending",
+    startedAt: now().toISOString(),
+    token,
+    target: targetIdentity
+  };
+  await mkdir(lockDirectory, { recursive: true, mode: 448 });
+  const handle = await open(ownPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+  try {
+    await handle.writeFile(`${JSON.stringify(metadata)}
+`, "utf8");
+  } finally {
+    await handle.close();
+  }
+  try {
+    await new Promise((resolve) => {
+      setTimeout(resolve, ELECTION_WINDOW_MS);
+    });
+    const contenders = await findLiveContenders(
+      lockDirectory,
+      key,
+      ownPath,
+      options.isProcessAlive ?? processIsAlive,
+      getProcessStart
+    );
+    const owner = contenders.find((candidate) => candidate.state === "owned") ?? contenders.filter((candidate) => candidate.state === "pending" && candidate.token < token).sort((left, right) => left.token.localeCompare(right.token))[0];
+    if (owner !== void 0) {
+      throw alreadyDebuggedError(owner);
+    }
+    await writeLockMetadata(ownPath, { ...metadata, state: "owned" });
+  } catch (error) {
+    await unlink(ownPath).catch(() => {
+    });
+    throw error;
+  }
+  let released = false;
+  return {
+    path: ownPath,
+    release: async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      const current = await readLockMetadata(ownPath);
+      if (current?.token !== token || current.pid !== pid) {
+        return;
+      }
+      await unlink(ownPath).catch((error) => {
+        if (!isNodeError(error, "ENOENT")) {
+          throw error;
+        }
+      });
+    }
+  };
+}
+function debugTargetIdentity(target) {
+  const targetIndex = target.targetIndex ?? 0;
+  if (target.kind === "port") {
+    return JSON.stringify({
+      kind: "port",
+      host: normalizeHost(target.host),
+      port: target.port,
+      targetIndex
+    });
+  }
+  return JSON.stringify({
+    kind: "cf",
+    region: target.region,
+    org: target.org,
+    space: target.space,
+    app: target.app,
+    targetIndex
+  });
+}
+function defaultStateRoot() {
+  const configured = process.env["CF_INSPECTOR_STATE_DIR"]?.trim();
+  return configured === void 0 || configured.length === 0 ? join(homedir(), ".saptools") : configured;
+}
+async function findLiveContenders(lockDirectory, key, ownPath, isProcessAlive, getProcessStart) {
+  const prefix = `${key}.`;
+  const names = await readdir(lockDirectory);
+  const contenders = [];
+  for (const name of names) {
+    if (!name.startsWith(prefix) || !name.endsWith(LOCK_FILE_SUFFIX)) {
+      continue;
+    }
+    const path = join(lockDirectory, name);
+    if (path === ownPath) {
+      continue;
+    }
+    const info = await stat(path).catch(() => {
+    });
+    const metadata = await readLockMetadata(path) ?? (info === void 0 ? void 0 : metadataFromFilename(name, key, info.mtimeMs));
+    if (metadata !== void 0) {
+      if (ownerIsAlive(metadata, isProcessAlive, getProcessStart)) {
+        contenders.push(metadata);
+      } else {
+        await unlink(path).catch(() => {
+        });
+      }
+      continue;
+    }
+    if (info !== void 0) {
+      contenders.push({
+        pid: 0,
+        state: "owned",
+        startedAt: new Date(info.mtimeMs).toISOString(),
+        token: "unknown",
+        target: "unknown"
+      });
+    }
+  }
+  return contenders;
+}
+async function readLockMetadata(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (!isRecord2(parsed)) {
+      return void 0;
+    }
+    const pid = parsed["pid"];
+    const processStart2 = parsed["processStart"];
+    const state = parsed["state"];
+    const startedAt = parsed["startedAt"];
+    const token = parsed["token"];
+    const target = parsed["target"];
+    if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0 || processStart2 !== void 0 && typeof processStart2 !== "string" || state !== "pending" && state !== "owned" || typeof startedAt !== "string" || Number.isNaN(Date.parse(startedAt)) || typeof token !== "string" || token.length === 0 || typeof target !== "string" || target.length === 0) {
+      return void 0;
+    }
+    return {
+      pid,
+      ...typeof processStart2 === "string" ? { processStart: processStart2 } : {},
+      state,
+      startedAt,
+      token,
+      target
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeLockMetadata(path, metadata) {
+  await writeFile(path, `${JSON.stringify(metadata)}
+`, { encoding: "utf8", mode: 384 });
+}
+function metadataFromFilename(name, key, mtimeMs) {
+  const match = new RegExp(`^${key}\\.(\\d+)\\.(.+)\\${LOCK_FILE_SUFFIX}$`, "u").exec(name);
+  const rawPid = match?.[1];
+  const token = match?.[2];
+  if (rawPid === void 0 || token === void 0 || token.length === 0) {
+    return void 0;
+  }
+  const pid = Number.parseInt(rawPid, 10);
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return void 0;
+  }
+  return {
+    pid,
+    state: "owned",
+    startedAt: new Date(mtimeMs).toISOString(),
+    token,
+    target: "unknown"
+  };
+}
+function ownerIsAlive(metadata, isProcessAlive, getProcessStart) {
+  if (!isProcessAlive(metadata.pid)) {
+    return false;
+  }
+  const currentStart = getProcessStart(metadata.pid);
+  return metadata.processStart === void 0 || currentStart === void 0 || metadata.processStart === currentStart;
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    const status = processStatus(pid);
+    return !status?.startsWith("Z");
+  } catch (error) {
+    return isNodeError(error, "EPERM");
+  }
+}
+function processStatus(pid) {
+  return runPs(pid, "stat=");
+}
+function processStart(pid) {
+  return runPs(pid, "lstart=");
+}
+function runPs(pid, field) {
+  try {
+    const value = execFileSync("ps", ["-o", field, "-p", pid.toString()], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return value.length === 0 ? void 0 : value;
+  } catch {
+    return void 0;
+  }
+}
+function alreadyDebuggedError(owner) {
+  const ownerLabel = owner.pid > 0 ? `PID ${owner.pid.toString()}` : "an unknown process";
+  return new CfInspectorError(
+    "TARGET_ALREADY_DEBUGGED",
+    `Another cf-inspector session (${ownerLabel}, started ${owner.startedAt}) is already actively debugging this target. Concurrent debugging sessions on the same isolate(s) can corrupt each other and disrupt real application traffic, so this attempt was refused rather than queued. Wait for the other session to finish, or confirm that it is gone before retrying; locks from dead processes are reclaimed automatically.`
+  );
+}
+function normalizeHost(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized === "localhost" || normalized === "::1" ? "127.0.0.1" : normalized;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
 // src/cli/warnings.ts
 init_types();
-import process2 from "process";
+import process3 from "process";
 
 // src/cli/captureParser.ts
 function parseCaptureList(raw) {
@@ -1893,7 +2131,7 @@ function warnOnCaptureMutationRisk(expressions, allowMutation) {
     return;
   }
   const suffix = allowMutation ? "will run without the V8 side-effect guard because --allow-mutation was passed." : "will be checked by the V8 side-effect guard and blocked unless V8 proves them safe; pass --allow-mutation to run them unrestricted.";
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${riskyCount.toString()} capture ${riskyCount === 1 ? "expression looks" : "expressions look"} mutation-capable and ${suffix}
 `
   );
@@ -1908,7 +2146,7 @@ function enforceNativeConditionMutationPolicy(expression, allowMutation, context
       `${context} looks mutation-capable. Native breakpoint conditions cannot be protected by V8's side-effect guard; pass --allow-mutation to arm it explicitly.`
     );
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${context} looks mutation-capable and will run as a native breakpoint condition; native conditions cannot be side-effect-gated.
 `
   );
@@ -1917,7 +2155,7 @@ function warnOnMutationRisk(expression, context) {
   if (!looksLikeMutation(expression)) {
     return;
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${context} looks mutation-capable and will execute against the live inspectee without a side-effect guard.
 `
   );
@@ -1926,7 +2164,7 @@ function warnOnUnboundBreakpoints(handles) {
   for (const handle of handles) {
     if (handle.resolvedLocations.length === 0) {
       const tsHint = handle.file.endsWith(".ts") ? " Hint: Source TS breakpoints may not bind. Try inspecting loaded scripts with list-scripts and target the compiled .js file instead." : "";
-      process2.stderr.write(
+      process3.stderr.write(
         `[cf-inspector] warning: breakpoint ${handle.file}:${handle.line.toString()} did not bind to any loaded script. Check the path or pass --remote-root. Use 'list-scripts' to inspect what V8 currently has loaded.${tsHint}
 `
       );
@@ -1937,14 +2175,14 @@ function warnOnImplicitInspectorSelection(session, targetWasExplicit, workerWasE
   const targetCount = session.targetCount ?? 1;
   const targetIndex = session.targetIndex ?? 0;
   if (!targetWasExplicit && targetCount > 1) {
-    process2.stderr.write(
+    process3.stderr.write(
       `[cf-inspector] notice: attached to inspector target ${targetIndex.toString()} of ${targetCount.toString()}; pass --target <index> to pick another.
 `
     );
   }
   const workerCount = session.workerTargets?.length ?? 0;
   if (!workerWasExplicit && workerCount > 0) {
-    process2.stderr.write(
+    process3.stderr.write(
       `[cf-inspector] notice: attached to the main isolate; ${workerCount.toString()} Node ${workerCount === 1 ? "worker is" : "workers are"} available. This command is single-isolate by nature; use --worker-id <id> to inspect one worker explicitly.
 `
     );
@@ -1957,7 +2195,7 @@ function warnOnBoundBreakpointWithoutHit(handles) {
   if (boundCount === 0) {
     return;
   }
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: ${boundCount.toString()} breakpoint ${boundCount === 1 ? "location bound" : "locations bound"}, but no hit was observed. No selected isolate executed the location before the command stopped. Check conditions, hit counts, request traffic, and use check-breakpoint to verify the exact line.
 `
   );
@@ -1967,7 +2205,7 @@ function roundDurationMs(durationMs) {
 }
 function warnOnUnmatchedPause(pause) {
   const reason = pause.reason.length > 0 ? pause.reason : "unknown";
-  process2.stderr.write(
+  process3.stderr.write(
     `[cf-inspector] warning: target is paused by another debugger event (${reason} at ${formatPauseLocation(pause)}); waiting for it to resume...
 `
   );
@@ -2142,65 +2380,75 @@ function parseWorkerId(value) {
   return trimmed;
 }
 async function withSession(target, fn, reportProgress, signal) {
-  const tunnel = await openTarget(target, reportProgress, signal);
-  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,
-      ...selectionOptions(target.targetIndex, target.workerIndex),
-      ...target.workerId === void 0 ? {} : { workerId: target.workerId }
-    });
-    warnOnImplicitInspectorSelection(
-      session,
-      target.targetIndex !== void 0,
-      target.workerIndex !== void 0 || target.workerId !== void 0
-    );
-    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 withSessions(target, fn, reportProgress, signal) {
-  const tunnel = await openTarget(target, reportProgress, signal);
-  let group;
+  const lock = await acquireDebugSessionLock(target);
   try {
-    reportProgress?.(
-      `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
-    );
-    const autoAttach = target.targetIndex === void 0 && target.workerIndex === void 0 && target.workerId === void 0 && target.mainOnly !== true;
-    if (autoAttach) {
-      group = await connectInspectorGroup({ port: tunnel.port, host: tunnel.host });
-    } else {
-      const session = await connectInspector({
+    const tunnel = await openTarget(target, reportProgress, signal);
+    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,
-        ...selectionOptions(target.targetIndex, target.workerIndex, target.workerId)
+        ...selectionOptions(target.targetIndex, target.workerIndex),
+        ...target.workerId === void 0 ? {} : { workerId: target.workerId }
       });
-      group = singleSessionGroup(session);
+      warnOnImplicitInspectorSelection(
+        session,
+        target.targetIndex !== void 0,
+        target.workerIndex !== void 0 || target.workerId !== void 0
+      );
+      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();
     }
-    reportProgress?.("Inspector session is ready.");
-    return await fn(group, tunnel.port);
   } finally {
+    await lock.release();
+  }
+}
+async function withSessions(target, fn, reportProgress, signal) {
+  const lock = await acquireDebugSessionLock(target);
+  try {
+    const tunnel = await openTarget(target, reportProgress, signal);
+    let group;
     try {
-      if (group !== void 0) {
-        const sessionCount = group.list().length;
-        reportProgress?.(sessionCount === 1 ? "Closing the inspector session..." : `Closing ${sessionCount.toString()} inspector sessions...`);
-        await group.dispose();
-        reportProgress?.(sessionCount === 1 ? "Inspector session closed." : "Inspector sessions closed.");
+      reportProgress?.(
+        `Connecting to the Node.js inspector at ${tunnel.host}:${tunnel.port.toString()}...`
+      );
+      const autoAttach = target.targetIndex === void 0 && target.workerIndex === void 0 && target.workerId === void 0 && target.mainOnly !== true;
+      if (autoAttach) {
+        group = await connectInspectorGroup({ port: tunnel.port, host: tunnel.host });
+      } else {
+        const session = await connectInspector({
+          port: tunnel.port,
+          host: tunnel.host,
+          ...selectionOptions(target.targetIndex, target.workerIndex, target.workerId)
+        });
+        group = singleSessionGroup(session);
       }
+      reportProgress?.("Inspector session is ready.");
+      return await fn(group, tunnel.port);
     } finally {
-      await tunnel.dispose();
+      try {
+        if (group !== void 0) {
+          const sessionCount = group.list().length;
+          reportProgress?.(sessionCount === 1 ? "Closing the inspector session..." : `Closing ${sessionCount.toString()} inspector sessions...`);
+          await group.dispose();
+          reportProgress?.(sessionCount === 1 ? "Inspector session closed." : "Inspector sessions closed.");
+        }
+      } finally {
+        await tunnel.dispose();
+      }
     }
+  } finally {
+    await lock.release();
   }
 }
 function singleSessionGroup(session) {
@@ -2262,7 +2510,7 @@ async function handleAttach(opts) {
       writeJson({ host: tunnel.host, port: tunnel.port, ...version });
       return;
     }
-    process3.stdout.write(
+    process4.stdout.write(
       `Connected to ${tunnel.host}:${tunnel.port.toString()}
   Browser: ${version.browser}
   Protocol: ${version.protocolVersion}
@@ -2274,7 +2522,7 @@ async function handleAttach(opts) {
 }
 
 // src/cli/commands/checkBreakpoint.ts
-import process4 from "process";
+import process5 from "process";
 
 // src/pathMapper.ts
 init_types();
@@ -2561,25 +2809,25 @@ async function checkSession(session, matcher, requestedLine) {
 }
 function writeHumanCheck(result) {
   if (result.status === "script-not-loaded") {
-    process4.stdout.write(
+    process5.stdout.write(
       `${result.file}:${result.line.toString()} does not match any loaded script. Run list-scripts and check --remote-root/path mapping, or trigger lazy module loading first.
 `
     );
     return;
   }
   if (result.status === "unbreakable") {
-    process4.stdout.write(
+    process5.stdout.write(
       `${result.file}:${result.line.toString()} matches a loaded script, but this exact line has no breakable location. Try a neighboring executable line.
 `
     );
     return;
   }
-  process4.stdout.write(`${result.file}:${result.line.toString()} is breakable:
+  process5.stdout.write(`${result.file}:${result.line.toString()} is breakable:
 `);
   for (const script of result.scripts) {
     for (const location of script.locations) {
       const isolate = script.isolate.kind === "main" ? "main" : `worker ${script.isolate.workerId}`;
-      process4.stdout.write(
+      process5.stdout.write(
         `  ${isolate}	${script.url}	line ${(location.lineNumber + 1).toString()}:${((location.columnNumber ?? 0) + 1).toString()}
 `
       );
@@ -2588,7 +2836,7 @@ function writeHumanCheck(result) {
 }
 
 // src/cli/commands/eval.ts
-import process5 from "process";
+import process6 from "process";
 
 // src/inspector/runtime.ts
 init_types();
@@ -2685,7 +2933,7 @@ async function handleEval(opts) {
   if (opts.json) {
     writeJson(result);
     if (result.exceptionDetails !== void 0) {
-      process5.exitCode = 1;
+      process6.exitCode = 1;
     }
     return;
   }
@@ -2694,33 +2942,33 @@ async function handleEval(opts) {
 function writeHumanEvalResult(result) {
   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";
-    process5.stderr.write(`${detail}
+    process6.stderr.write(`${detail}
 `);
-    process5.exitCode = 1;
+    process6.exitCode = 1;
     return;
   }
   const inner = result.result;
   if (inner === void 0) {
-    process5.stdout.write("\n");
+    process6.stdout.write("\n");
     return;
   }
   if (typeof inner.value === "string") {
-    process5.stdout.write(`${inner.value}
+    process6.stdout.write(`${inner.value}
 `);
     return;
   }
   if (typeof inner.description === "string") {
-    process5.stdout.write(`${inner.description}
+    process6.stdout.write(`${inner.description}
 `);
     return;
   }
-  process5.stdout.write(`${JSON.stringify(inner.value)}
+  process6.stdout.write(`${JSON.stringify(inner.value)}
 `);
 }
 
 // src/cli/commands/exception.ts
 import { performance as performance5 } from "perf_hooks";
-import process7 from "process";
+import process8 from "process";
 
 // src/inspector/pause.ts
 init_types();
@@ -3814,19 +4062,19 @@ async function captureExpression(session, callFrameId, expression, maxValueLengt
 init_types();
 
 // src/cli/signals.ts
-import process6 from "process";
+import process7 from "process";
 async function withTerminationSignal(fn) {
   const abort = new AbortController();
   const onSignal = () => {
     abort.abort();
   };
-  process6.once("SIGINT", onSignal);
-  process6.once("SIGTERM", onSignal);
+  process7.once("SIGINT", onSignal);
+  process7.once("SIGTERM", onSignal);
   try {
     return await fn(abort.signal);
   } finally {
-    process6.off("SIGINT", onSignal);
-    process6.off("SIGTERM", onSignal);
+    process7.off("SIGINT", onSignal);
+    process7.off("SIGTERM", onSignal);
   }
 }
 
@@ -3913,7 +4161,7 @@ async function resumeAfterException(session, snapshot, pausedStartedAt) {
     await resume(session);
     return withPausedDuration(snapshot, roundDurationMs(performance5.now() - pausedStartedAt));
   } catch {
-    process7.stderr.write(
+    process8.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after exception capture; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -3927,7 +4175,7 @@ async function disablePauseOnExceptionsBestEffort(session) {
 }
 
 // src/cli/commands/listScripts.ts
-import process8 from "process";
+import process9 from "process";
 async function handleListScripts(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts);
   const filter = compileScriptUrlFilter(opts.filter);
@@ -3937,7 +4185,7 @@ async function handleListScripts(opts) {
     return;
   }
   for (const script of scripts) {
-    process8.stdout.write(`${script.scriptId}	${script.url}
+    process9.stdout.write(`${script.scriptId}	${script.url}
 `);
   }
 }
@@ -3968,7 +4216,7 @@ async function buildListedTargets(targets) {
       return buildListedTarget(target, index, workerResult.supported, workerResult.workers);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      process8.stderr.write(
+      process9.stderr.write(
         `[cf-inspector] warning: worker discovery failed for raw target ${index.toString()}: ${message}
 `
       );
@@ -3995,7 +4243,7 @@ function looksLikeWorkerTarget(target) {
   return `${target.type} ${target.title} ${target.url}`.toLowerCase().includes("worker");
 }
 function writeTargetCountSummary(targetCount, workerCount) {
-  process8.stderr.write(
+  process9.stderr.write(
     `[cf-inspector] ${targetCount.toString()} raw inspector ${targetCount === 1 ? "target" : "targets"}; ${workerCount.toString()} ${workerCount === 1 ? "worker" : "workers"}.
 `
   );
@@ -4006,7 +4254,7 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
   }
   const supported = targets[0]?.workerDiscoverySupported === true;
   const supportHint = supported ? "NodeWorker discovery is available, but no live worker attached." : "This runtime did not expose NodeWorker discovery.";
-  process8.stderr.write(
+  process9.stderr.write(
     `[cf-inspector] warning: only the main inspector target is reachable. ${supportHint} If worker code is expected, ensure the worker is alive and rerun list-targets. A worker on a separate inspector port is not carried by a single Cloud Foundry tunnel.
 `
   );
@@ -4014,12 +4262,12 @@ function warnOnMissingWorkers(targetCount, workerCount, targets) {
 function writeHumanTargets(targets) {
   for (const target of targets) {
     const workerLabel = target.likelyWorker ? "	likely-worker" : "";
-    process8.stdout.write(
+    process9.stdout.write(
       `${target.index.toString()}	target	${target.type}	${target.title}	${target.url}${workerLabel}
 `
     );
     for (const worker of target.workers) {
-      process8.stdout.write(
+      process9.stdout.write(
         `  ${worker.index.toString()}	worker	${worker.type}	${worker.title}	${worker.url}
 `
       );
@@ -4096,7 +4344,7 @@ function matchesFilterTokens(value, tokens) {
 }
 
 // src/cli/commands/log.ts
-import process9 from "process";
+import process10 from "process";
 
 // src/logpoint/stream.ts
 init_types();
@@ -4503,11 +4751,11 @@ function isZeroHitStop(reason) {
 }
 function writeLogSummary(stoppedReason, emitted, json) {
   if (json) {
-    process9.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
+    process10.stderr.write(`${JSON.stringify({ stopped: stoppedReason, emitted })}
 `);
     return;
   }
-  process9.stderr.write(
+  process10.stderr.write(
     `Stopped (${stoppedReason}); emitted ${emitted.toString()} log ${emitted === 1 ? "entry" : "entries"}.
 `
   );
@@ -4515,7 +4763,7 @@ function writeLogSummary(stoppedReason, emitted, json) {
 
 // src/cli/commands/snapshot.ts
 import { performance as performance6 } from "perf_hooks";
-import process10 from "process";
+import process11 from "process";
 init_types();
 async function handleSnapshot(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -4694,7 +4942,7 @@ async function resumeAfterSnapshot(session, snapshot, pausedStartedAt, reportPro
     reportProgress?.("Target resumed.");
     return withPausedDuration(snapshot, roundDurationMs(performance6.now() - pausedStartedAt));
   } catch {
-    process10.stderr.write(
+    process11.stderr.write(
       "[cf-inspector] warning: Debugger.resume failed after snapshot; pausedDurationMs is unknown.\n"
     );
     return withPausedDuration(snapshot, null);
@@ -4707,7 +4955,7 @@ function parseSetupEvals(raw) {
 
 // src/cli/commands/watch.ts
 import { performance as performance7 } from "perf_hooks";
-import process11 from "process";
+import process12 from "process";
 init_types();
 async function handleWatch(opts) {
   const target = await resolveTargetWithCurrentCfTarget(opts, { useTimeoutForTunnel: false });
@@ -4806,7 +5054,7 @@ async function runWatchGroup(group, command, opts, signal) {
         await resume(hit.session);
         hit.session.debuggerState.paused = false;
       } catch {
-        process11.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
+        process12.stderr.write("[cf-inspector] warning: Debugger.resume failed during watch.\n");
         stoppedReason = "transport-closed";
         break;
       }
@@ -4820,7 +5068,7 @@ async function runWatchGroup(group, command, opts, signal) {
     }
   } finally {
     const cleanup = await fanout.cleanup();
-    process11.stderr.write(
+    process12.stderr.write(
       `[cf-inspector] breakpoint cleanup: cleared ${cleanup.cleared.toString()} of ${cleanup.attempted.toString()}; resumed ${cleanup.resumed.toString()} paused isolates.
 `
     );
@@ -4918,11 +5166,11 @@ function formatLocation(command, topFrame) {
 }
 function writeWatchSummary(reason, emitted, json) {
   if (json) {
-    process11.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
+    process12.stderr.write(`${JSON.stringify({ stopped: reason, emitted })}
 `);
     return;
   }
-  process11.stderr.write(
+  process12.stderr.write(
     `Stopped (${reason}); emitted ${emitted.toString()} watch ${emitted === 1 ? "event" : "events"}.
 `
   );
@@ -4952,7 +5200,7 @@ var collectStrings = (value, prev = []) => [
 function readPackageVersion() {
   let current = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 4; depth += 1) {
-    const candidate = join(current, "package.json");
+    const candidate = join2(current, "package.json");
     try {
       const parsed = JSON.parse(readFileSync(candidate, "utf8"));
       if (typeof parsed === "object" && parsed !== null) {
@@ -5060,20 +5308,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process12.argv);
+  await main(process13.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process12.stderr.write(`Error [${err.code}]: ${err.message}
+    process13.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process12.stderr.write(`  detail: ${err.detail}
+      process13.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process12.exit(1);
+    process13.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process12.stderr.write(`Error: ${message}
+  process13.stderr.write(`Error: ${message}
 `);
-  process12.exit(1);
+  process13.exit(1);
 }
 //# sourceMappingURL=cli.js.map