@saptools/cf-inspector 0.8.1 → 0.9.0

package/dist/cli.js

@@ -152,12 +152,1153 @@ var init_wsTransport = __esm({
 });
 
 // src/cli.ts
-import process13 from "process";
+import process14 from "process";
 
 // src/cli/program.ts
+import process13 from "process";
+
+// ../core/src/package-metadata.ts
 import { readFileSync } from "fs";
-import { dirname, join as join2 } from "path";
+import { dirname, join } from "path";
 import { fileURLToPath } from "url";
+
+// ../core/src/records.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function readString(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// ../core/src/package-metadata.ts
+var MAX_WALK_UP = 6;
+function readPackageManifest(directory) {
+  let raw;
+  try {
+    raw = readFileSync(join(directory, "package.json"), "utf8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed)) {
+    return;
+  }
+  const name = readString(parsed, "name");
+  const version = readString(parsed, "version");
+  if (name === void 0 || version === void 0) {
+    return;
+  }
+  return { name, version, directory };
+}
+function findPackageMetadata(startDirectory, expectedName) {
+  let current = startDirectory;
+  for (let depth = 0; depth < MAX_WALK_UP; depth += 1) {
+    const manifest = readPackageManifest(current);
+    if (manifest?.name === expectedName) {
+      return manifest;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return;
+    }
+    current = parent;
+  }
+  return;
+}
+function readPackageMetadata(importMetaUrl, expectedName) {
+  const startDirectory = dirname(fileURLToPath(importMetaUrl));
+  const found = findPackageMetadata(startDirectory, expectedName);
+  if (found === void 0) {
+    throw new Error(`Cannot find the package.json of ${expectedName} above ${startDirectory}`);
+  }
+  return found;
+}
+
+// ../core/src/saptools-paths.ts
+import { chmodSync, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var SAPTOOLS_DIR_NAME = ".saptools";
+var SAPTOOLS_ROOT_ENV = "SAPTOOLS_ROOT";
+function resolveSaptoolsRoot(explicit, env = process.env) {
+  if (explicit !== void 0 && explicit.length > 0) {
+    return explicit;
+  }
+  const fromEnv = env[SAPTOOLS_ROOT_ENV];
+  if (fromEnv !== void 0 && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return join2(homedir(), SAPTOOLS_DIR_NAME);
+}
+function ensurePrivateDirectorySync(directory) {
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  try {
+    chmodSync(directory, 448);
+  } catch {
+  }
+}
+function writeFileAtomicSync(path, data, mode = 384) {
+  const temp = `${path}.${String(process.pid)}.${Math.random().toString(36).slice(2, 8)}.tmp`;
+  try {
+    writeFileSync(temp, data, { encoding: "utf8", mode });
+    try {
+      chmodSync(temp, mode);
+    } catch {
+    }
+    renameSync(temp, path);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+}
+function readJsonFileSync(path) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+
+// ../core/src/self-update/reexec.ts
+import { spawn } from "child_process";
+import { constants } from "os";
+var REEXEC_MARKER_ENV = "SAPTOOLS_SELF_UPDATE_REEXEC";
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function nativeExecve() {
+  return process.execve?.bind(process);
+}
+function defaultRuntime() {
+  return {
+    platform: process.platform,
+    execve: nativeExecve(),
+    spawnImpl: spawn,
+    onSignal: (signal, handler) => {
+      process.on(signal, handler);
+    },
+    offSignal: (signal, handler) => {
+      process.off(signal, handler);
+    },
+    kill: (pid, signal) => {
+      process.kill(pid, signal);
+    },
+    exit: (code) => {
+      process.exit(code);
+    }
+  };
+}
+function buildReexecArgv(request2) {
+  return [...request2.execArgv, request2.binPath, ...request2.args];
+}
+function reexecEnvironment(env) {
+  return { ...env, [REEXEC_MARKER_ENV]: "1" };
+}
+function signalExitCode(signal) {
+  const number = constants.signals[signal];
+  return 128 + number;
+}
+async function reexecProcess(request2, runtimeOverrides = {}) {
+  const runtime = { ...defaultRuntime(), ...runtimeOverrides };
+  const argv = buildReexecArgv(request2);
+  const env = reexecEnvironment(request2.env);
+  if (runtime.platform !== "win32" && runtime.execve !== void 0) {
+    try {
+      runtime.execve(request2.execPath, [request2.execPath, ...argv], env);
+    } catch {
+    }
+  }
+  await new Promise((resolve, reject) => {
+    const child = runtime.spawnImpl(request2.execPath, argv, { stdio: "inherit", env });
+    const forward = (signal) => {
+      child.kill(signal);
+    };
+    for (const signal of FORWARDED_SIGNALS) {
+      runtime.onSignal(signal, forward);
+    }
+    const detach = () => {
+      for (const signal of FORWARDED_SIGNALS) {
+        runtime.offSignal(signal, forward);
+      }
+    };
+    child.once("error", (error) => {
+      detach();
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      detach();
+      if (signal === null) {
+        runtime.exit(code ?? 1);
+      } else {
+        runtime.kill(process.pid, signal);
+        runtime.exit(signalExitCode(signal));
+      }
+      resolve();
+    });
+  });
+}
+
+// ../core/src/self-update/policy.ts
+var POLICY_ENV = "SAPTOOLS_AUTO_UPDATE";
+var INTERVAL_ENV = "SAPTOOLS_UPDATE_INTERVAL_MINUTES";
+var DEBUG_ENV = "SAPTOOLS_UPDATE_DEBUG";
+var DEFAULT_CHECK_INTERVAL_MINUTES = 60;
+var SELF_UPDATE_COMMAND = "self-update";
+function parsePolicy(raw) {
+  if (raw === void 0) {
+    return;
+  }
+  const value = raw.trim().toLowerCase();
+  if (["on", "1", "true", "yes", "auto", "always"].includes(value)) {
+    return "on";
+  }
+  if (["notify", "check"].includes(value)) {
+    return "notify";
+  }
+  if (["off", "0", "false", "no", "never", "disabled"].includes(value)) {
+    return "off";
+  }
+  return;
+}
+function isTruthyFlag(raw) {
+  return raw !== void 0 && !["", "0", "false", "no", "off"].includes(raw.trim().toLowerCase());
+}
+function readExplicitPolicy(env, envPrefix) {
+  const perPackage = envPrefix === void 0 ? void 0 : parsePolicy(env[`${envPrefix}_AUTO_UPDATE`]);
+  return perPackage ?? parsePolicy(env[POLICY_ENV]);
+}
+function off(reason, explicit) {
+  return { policy: "off", reason, explicit };
+}
+function notify(reason, explicit) {
+  return { policy: "notify", reason, explicit };
+}
+function locationDecision(location, explicit) {
+  switch (location.kind) {
+    case "local":
+      return off("running from a source checkout or linked package, not a package-manager install", explicit);
+    case "npx":
+      return off("running through npx or dlx, which resolves the version on its own", explicit);
+    case "unknown":
+      return notify(`install location not recognized (${location.detail})`, explicit);
+    case "npm-global":
+    case "pnpm-global":
+    case "yarn-global":
+    case "bun-global":
+    case "volta":
+      return;
+  }
+}
+function resolveUpdatePolicy(input) {
+  const { env, location } = input;
+  const manual = input.manual === true;
+  const explicit = readExplicitPolicy(env, input.envPrefix);
+  if (!manual && isTruthyFlag(env[REEXEC_MARKER_ENV])) {
+    return off("already re-executed after an update", false);
+  }
+  const commandPath = input.commandPath ?? "";
+  if (!manual && (commandPath === SELF_UPDATE_COMMAND || (input.skipCommands ?? []).includes(commandPath))) {
+    return off(`the "${commandPath}" command is excluded from automatic updates`, false);
+  }
+  if (!manual && explicit === "off") {
+    return off(`${POLICY_ENV} is off`, true);
+  }
+  if (!manual && explicit === void 0) {
+    if (isTruthyFlag(env["NO_UPDATE_NOTIFIER"])) {
+      return off("NO_UPDATE_NOTIFIER is set", false);
+    }
+    if (isTruthyFlag(env["CI"])) {
+      return off("running in CI", false);
+    }
+    if (env["NODE_ENV"] === "test") {
+      return off("NODE_ENV is test", false);
+    }
+  }
+  const byLocation = locationDecision(location, explicit !== void 0);
+  if (byLocation !== void 0) {
+    return byLocation;
+  }
+  if (!location.writable) {
+    return notify("the install directory is not writable by this user", explicit !== void 0);
+  }
+  if (manual) {
+    return { policy: "on", reason: "requested explicitly", explicit: true };
+  }
+  return explicit === void 0 ? { policy: "on", reason: "default", explicit: false } : { policy: explicit, reason: `${POLICY_ENV} is ${explicit}`, explicit: true };
+}
+function resolveCheckIntervalMs(env) {
+  const raw = env[INTERVAL_ENV];
+  if (raw === void 0) {
+    return DEFAULT_CHECK_INTERVAL_MINUTES * 6e4;
+  }
+  const minutes = Number(raw.trim());
+  if (!Number.isFinite(minutes) || minutes < 0) {
+    return DEFAULT_CHECK_INTERVAL_MINUTES * 6e4;
+  }
+  return Math.round(minutes * 6e4);
+}
+
+// ../core/src/self-update/run.ts
+import { spawn as spawn2 } from "child_process";
+import { homedir as homedir2 } from "os";
+
+// ../core/src/self-update/install-location.ts
+import { accessSync, constants as constants2, realpathSync } from "fs";
+import { basename, dirname as dirname2, join as join3, sep } from "path";
+var UPGRADABLE_KINDS = /* @__PURE__ */ new Set(["npm-global", "pnpm-global", "yarn-global", "bun-global", "volta"]);
+function isUpgradableKind(kind) {
+  return UPGRADABLE_KINDS.has(kind);
+}
+function defaultIsWritable(path) {
+  try {
+    accessSync(path, constants2.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+function isPnpmGlobal(posixDirectory, env) {
+  if (posixDirectory.includes("/pnpm/global/")) {
+    return true;
+  }
+  const home = env["PNPM_HOME"];
+  return home !== void 0 && home.length > 0 && posixDirectory.startsWith(`${toPosix(home).replace(/\/+$/, "")}/global/`);
+}
+function nodeModulesRootOf(packageDirectory) {
+  const parent = dirname2(packageDirectory);
+  if (basename(parent) === "node_modules") {
+    return parent;
+  }
+  const grandparent = dirname2(parent);
+  return basename(grandparent) === "node_modules" ? grandparent : void 0;
+}
+function npmPrefixFor(packageDirectory, platform) {
+  const nodeModules = nodeModulesRootOf(packageDirectory);
+  if (nodeModules === void 0) {
+    return;
+  }
+  const parent = dirname2(nodeModules);
+  if (platform === "win32") {
+    return basename(parent).toLowerCase() === "npm" ? parent : void 0;
+  }
+  return basename(parent) === "lib" ? dirname2(parent) : void 0;
+}
+function classifyKind(packageDirectory, platform, env) {
+  const posix = toPosix(packageDirectory);
+  if (posix.includes("/_npx/") || /\/dlx-[^/]+\//.test(posix) || posix.includes("/pnpm/dlx/") || posix.includes("/.cache/pnpm/dlx")) {
+    return "npx";
+  }
+  if (posix.includes("/.volta/tools/image/packages/")) {
+    return "volta";
+  }
+  if (posix.includes("/.bun/install/global/")) {
+    return "bun-global";
+  }
+  if (posix.includes("/.config/yarn/global/") || posix.includes("/yarn/global/node_modules/")) {
+    return "yarn-global";
+  }
+  if (isPnpmGlobal(posix, env)) {
+    return "pnpm-global";
+  }
+  if (!posix.includes("/node_modules/")) {
+    return "local";
+  }
+  return npmPrefixFor(packageDirectory, platform) === void 0 ? "local" : "npm-global";
+}
+function writableForUpgrade(packageDirectory, prefix, platform, isWritable) {
+  const targets = [packageDirectory, dirname2(packageDirectory)];
+  const nodeModules = nodeModulesRootOf(packageDirectory);
+  if (nodeModules !== void 0) {
+    targets.push(nodeModules);
+  }
+  if (prefix !== void 0) {
+    targets.push(platform === "win32" ? prefix : join3(prefix, "bin"));
+  }
+  return targets.every((target) => isWritable(target));
+}
+function describe(kind, packageDirectory, prefix) {
+  if (kind === "npm-global" && prefix !== void 0) {
+    return `npm global install under ${prefix}`;
+  }
+  return `${kind} install at ${packageDirectory}`;
+}
+function unknownLocation(detail) {
+  return { kind: "unknown", packageDirectory: void 0, prefix: void 0, writable: false, detail };
+}
+function detectInstallLocation(options) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const realpath = options.realpath ?? ((path) => realpathSync(path));
+  const isWritable = options.isWritable ?? defaultIsWritable;
+  let resolvedBin;
+  try {
+    resolvedBin = realpath(options.binPath);
+  } catch (error) {
+    return unknownLocation(`cannot resolve ${options.binPath}: ${errorMessage(error)}`);
+  }
+  const manifest = findPackageMetadata(dirname2(resolvedBin), options.packageName);
+  if (manifest === void 0) {
+    return unknownLocation(`no package.json for ${options.packageName} above ${resolvedBin}`);
+  }
+  const packageDirectory = manifest.directory;
+  const kind = classifyKind(packageDirectory, platform, env);
+  const prefix = kind === "npm-global" ? npmPrefixFor(packageDirectory, platform) : void 0;
+  const writable = isUpgradableKind(kind) && writableForUpgrade(packageDirectory, prefix, platform, isWritable);
+  return { kind, packageDirectory, prefix, writable, detail: describe(kind, packageDirectory, prefix) };
+}
+
+// ../core/src/self-update/installer.ts
+import { existsSync, realpathSync as realpathSync2 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+var DEFAULT_INSTALL_TIMEOUT_MS = 18e4;
+function manualInstallCommand(kind, spec) {
+  switch (kind) {
+    case "pnpm-global":
+      return `pnpm add -g ${spec}`;
+    case "yarn-global":
+      return `yarn global add ${spec}`;
+    case "bun-global":
+      return `bun add -g ${spec}`;
+    case "volta":
+      return `volta install ${spec}`;
+    case "npm-global":
+    case "npx":
+    case "local":
+    case "unknown":
+      return `npm install -g ${spec}`;
+  }
+}
+function resolveNpmInvocation(execPath, platform, exists, realpath) {
+  const binDirectory = dirname3(execPath);
+  if (platform === "win32") {
+    const cli = join4(binDirectory, "node_modules", "npm", "bin", "npm-cli.js");
+    return exists(cli) ? { file: execPath, leadingArgs: [cli] } : void 0;
+  }
+  const sibling = join4(binDirectory, "npm");
+  if (exists(sibling)) {
+    try {
+      const target = realpath(sibling);
+      return target.endsWith(".js") ? { file: execPath, leadingArgs: [target] } : { file: target, leadingArgs: [] };
+    } catch {
+    }
+  }
+  return { file: "npm", leadingArgs: [] };
+}
+function buildNpmCommand(options, spec) {
+  if (options.location.prefix === void 0) {
+    return;
+  }
+  const npm = resolveNpmInvocation(
+    options.execPath ?? process.execPath,
+    options.platform ?? process.platform,
+    options.exists ?? existsSync,
+    options.realpath ?? ((path) => realpathSync2(path))
+  );
+  if (npm === void 0) {
+    return;
+  }
+  return {
+    file: npm.file,
+    args: [
+      ...npm.leadingArgs,
+      "install",
+      "--global",
+      "--prefix",
+      options.location.prefix,
+      spec,
+      "--registry",
+      options.registryUrl,
+      "--no-fund",
+      "--no-audit",
+      "--no-update-notifier",
+      "--loglevel=error"
+    ],
+    display: manualInstallCommand("npm-global", spec)
+  };
+}
+function buildInstallCommand(options) {
+  const spec = `${options.packageName}@${options.version}`;
+  switch (options.location.kind) {
+    case "npm-global":
+      return buildNpmCommand(options, spec);
+    case "pnpm-global":
+      return { file: "pnpm", args: ["add", "--global", spec], display: manualInstallCommand("pnpm-global", spec) };
+    case "yarn-global":
+      return { file: "yarn", args: ["global", "add", spec], display: manualInstallCommand("yarn-global", spec) };
+    case "bun-global":
+      return { file: "bun", args: ["add", "--global", spec], display: manualInstallCommand("bun-global", spec) };
+    case "volta":
+      return { file: "volta", args: ["install", spec], display: manualInstallCommand("volta", spec) };
+    case "npx":
+    case "local":
+    case "unknown":
+      return;
+  }
+}
+function lastLine(text) {
+  const lines = text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  return lines.at(-1) ?? "";
+}
+function runInstall(command, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_INSTALL_TIMEOUT_MS;
+  const env = { ...options.env, SAPTOOLS_AUTO_UPDATE: "off" };
+  delete env["SAP_EMAIL"];
+  delete env["SAP_PASSWORD"];
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = options.spawnImpl(command.file, command.args, { cwd: tmpdir(), env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+    } catch (error) {
+      resolve({ ok: false, reason: errorMessage(error) });
+      return;
+    }
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr = `${stderr}${chunk.toString()}`.slice(-4e3);
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      resolve({ ok: false, reason: `${command.file}: ${error.message}` });
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve({ ok: true });
+        return;
+      }
+      const detail = lastLine(stderr);
+      const suffix = detail.length > 0 ? `: ${detail}` : "";
+      resolve({
+        ok: false,
+        reason: signal === null ? `${command.display} exited with code ${String(code ?? -1)}${suffix}` : `${command.display} was killed by ${signal} after ${String(Math.round(timeoutMs / 1e3))}s`
+      });
+    });
+  });
+}
+
+// ../core/src/self-update/registry.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+
+// ../core/src/self-update/semver.ts
+var SEMVER_PATTERN = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseSemver(text) {
+  const match = SEMVER_PATTERN.exec(text.trim());
+  if (match === null) {
+    return;
+  }
+  const [, major, minor, patch, prerelease] = match;
+  if (major === void 0 || minor === void 0 || patch === void 0) {
+    return;
+  }
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+    prerelease: prerelease === void 0 ? [] : prerelease.split(".")
+  };
+}
+function compareIdentifiers(left, right) {
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric) {
+    return Math.sign(Number(left) - Number(right));
+  }
+  if (leftNumeric) {
+    return -1;
+  }
+  if (rightNumeric) {
+    return 1;
+  }
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) {
+    return 0;
+  }
+  if (left.length === 0) {
+    return 1;
+  }
+  if (right.length === 0) {
+    return -1;
+  }
+  for (const [index, identifier] of left.entries()) {
+    const other = right[index];
+    if (other === void 0) {
+      return 1;
+    }
+    const result = compareIdentifiers(identifier, other);
+    if (result !== 0) {
+      return result;
+    }
+  }
+  return left.length < right.length ? -1 : 0;
+}
+function compareSemver(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) {
+      return left[key] < right[key] ? -1 : 1;
+    }
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+function isNewerRelease(candidate, current) {
+  const next = parseSemver(candidate);
+  const installed = parseSemver(current);
+  if (next === void 0 || installed === void 0) {
+    return false;
+  }
+  if (next.prerelease.length > 0) {
+    return false;
+  }
+  return compareSemver(next, installed) > 0;
+}
+
+// ../core/src/self-update/registry.ts
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+var REGISTRY_ENV = "SAPTOOLS_NPM_REGISTRY";
+var DEFAULT_CHECK_TIMEOUT_MS = 2e3;
+function normalizeRegistryUrl(value) {
+  if (value === void 0) {
+    return;
+  }
+  const trimmed = value.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\/\S+$/i.test(trimmed)) {
+    return;
+  }
+  return trimmed;
+}
+function registryFromNpmrc(text, key) {
+  if (text === void 0) {
+    return;
+  }
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith(";")) {
+      continue;
+    }
+    const separator = trimmed.indexOf("=");
+    if (separator === -1 || trimmed.slice(0, separator).trim() !== key) {
+      continue;
+    }
+    return trimmed.slice(separator + 1).trim().replace(/^"(.*)"$/, "$1");
+  }
+  return;
+}
+function readUserNpmrc(homeDirectory) {
+  try {
+    return readFileSync3(join5(homeDirectory, ".npmrc"), "utf8");
+  } catch {
+    return;
+  }
+}
+function resolveRegistryUrl(env, userNpmrc) {
+  const candidates = [
+    env[REGISTRY_ENV],
+    env["npm_config_registry"],
+    registryFromNpmrc(userNpmrc, "@saptools:registry"),
+    registryFromNpmrc(userNpmrc, "registry")
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeRegistryUrl(candidate);
+    if (normalized !== void 0) {
+      return normalized;
+    }
+  }
+  return DEFAULT_NPM_REGISTRY;
+}
+async function fetchJson(fetchImpl, url, headers, timeoutMs) {
+  try {
+    const response = await fetchImpl(url, { headers, signal: AbortSignal.timeout(timeoutMs), redirect: "follow" });
+    if (!response.ok) {
+      return { ok: false, status: response.status, reason: `HTTP ${String(response.status)} from ${url}` };
+    }
+    const body = await response.json();
+    return { ok: true, body };
+  } catch (error) {
+    return { ok: false, status: void 0, reason: `${errorMessage(error)} (${url})` };
+  }
+}
+function readLatestTag(body, nestedUnderDistTags) {
+  if (!isRecord(body)) {
+    return;
+  }
+  const tags = nestedUnderDistTags ? body["dist-tags"] : body;
+  if (!isRecord(tags)) {
+    return;
+  }
+  const latest = readString(tags, "latest");
+  return latest !== void 0 && parseSemver(latest) !== void 0 ? latest : void 0;
+}
+async function fetchLatestVersion(packageName, registryUrl, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
+  const encoded = encodeURIComponent(packageName);
+  const baseHeaders = { "user-agent": options.userAgent ?? "saptools-self-update" };
+  const distTags = await fetchJson(fetchImpl, `${registryUrl}/-/package/${encoded}/dist-tags`, { ...baseHeaders, accept: "application/json" }, timeoutMs);
+  if (distTags.ok) {
+    const latest2 = readLatestTag(distTags.body, false);
+    return latest2 === void 0 ? { ok: false, reason: "dist-tags response carries no valid latest version" } : { ok: true, latest: latest2 };
+  }
+  if (distTags.status === void 0) {
+    return { ok: false, reason: distTags.reason };
+  }
+  const packument = await fetchJson(
+    fetchImpl,
+    `${registryUrl}/${encoded}`,
+    { ...baseHeaders, accept: "application/vnd.npm.install-v1+json" },
+    timeoutMs
+  );
+  if (!packument.ok) {
+    return { ok: false, reason: packument.reason };
+  }
+  const latest = readLatestTag(packument.body, true);
+  return latest === void 0 ? { ok: false, reason: "packument carries no valid latest dist-tag" } : { ok: true, latest };
+}
+
+// ../core/src/self-update/state.ts
+import { closeSync, openSync, rmSync as rmSync2, statSync, utimesSync, writeSync } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+var EMPTY_UPDATE_STATE = { version: 1 };
+var UPDATES_DIRECTORY_NAME = "updates";
+var DEFAULT_LOCK_STALE_MS = 10 * 6e4;
+var STRING_FIELDS = ["checkedAt", "latest", "lastFailureAt", "lastFailureReason", "notifiedVersion", "notifiedAt"];
+function updateStateFileName(packageName) {
+  return `${packageName.replace(/^@/, "").replaceAll("/", "__")}.json`;
+}
+function updateStatePath(saptoolsRoot, packageName) {
+  return join6(saptoolsRoot, UPDATES_DIRECTORY_NAME, updateStateFileName(packageName));
+}
+function updateLockPath(statePath) {
+  return statePath.replace(/\.json$/, ".lock");
+}
+function readInstallAttempt(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const version = readString(value, "version");
+  const at = readString(value, "at");
+  const ok = value["ok"];
+  if (version === void 0 || at === void 0 || typeof ok !== "boolean") {
+    return;
+  }
+  const reason = readString(value, "reason");
+  return reason === void 0 ? { version, at, ok } : { version, at, ok, reason };
+}
+function readUpdateState(path) {
+  const parsed = readJsonFileSync(path);
+  if (!isRecord(parsed) || parsed["version"] !== 1) {
+    return EMPTY_UPDATE_STATE;
+  }
+  const draft = { version: 1 };
+  for (const key of STRING_FIELDS) {
+    const value = readString(parsed, key);
+    if (value !== void 0) {
+      draft[key] = value;
+    }
+  }
+  const lastInstall = readInstallAttempt(parsed["lastInstall"]);
+  if (lastInstall !== void 0) {
+    draft.lastInstall = lastInstall;
+  }
+  return draft;
+}
+function clearFailure(state) {
+  const next = { ...state };
+  delete next.lastFailureAt;
+  delete next.lastFailureReason;
+  return next;
+}
+function writeUpdateState(path, state) {
+  ensurePrivateDirectorySync(dirname4(path));
+  writeFileAtomicSync(path, `${JSON.stringify(state, null, 2)}
+`, 384);
+}
+function tryCreateLock(lockPath, now) {
+  let descriptor;
+  try {
+    descriptor = openSync(lockPath, "wx", 384);
+  } catch {
+    return;
+  }
+  try {
+    writeSync(descriptor, `${JSON.stringify({ pid: process.pid, at: now.toISOString() })}
+`);
+  } finally {
+    closeSync(descriptor);
+  }
+  utimesSync(lockPath, now, now);
+  return {
+    release: () => {
+      rmSync2(lockPath, { force: true });
+    }
+  };
+}
+function isStaleLock(lockPath, now, staleMs) {
+  try {
+    return now.getTime() - statSync(lockPath).mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+function acquireUpdateLock(lockPath, now, staleMs = DEFAULT_LOCK_STALE_MS) {
+  ensurePrivateDirectorySync(dirname4(lockPath));
+  const lock = tryCreateLock(lockPath, now);
+  if (lock !== void 0) {
+    return lock;
+  }
+  if (!isStaleLock(lockPath, now, staleMs)) {
+    return;
+  }
+  rmSync2(lockPath, { force: true });
+  return tryCreateLock(lockPath, now);
+}
+
+// ../core/src/self-update/run.ts
+var FAILURE_BACKOFF_MS = 15 * 6e4;
+var NOTIFY_INTERVAL_MS = 24 * 60 * 6e4;
+var INSTALL_RETRY_BACKOFF_MS = 24 * 60 * 6e4;
+function defaultRuntime2() {
+  return {
+    env: process.env,
+    argv: process.argv,
+    execPath: process.execPath,
+    execArgv: process.execArgv,
+    platform: process.platform,
+    homeDirectory: homedir2(),
+    now: () => /* @__PURE__ */ new Date(),
+    fetchImpl: fetch,
+    spawnImpl: spawn2,
+    reexecImpl: reexecProcess,
+    checkTimeoutMs: DEFAULT_CHECK_TIMEOUT_MS,
+    installTimeoutMs: DEFAULT_INSTALL_TIMEOUT_MS
+  };
+}
+function ageMs(isoTimestamp, nowMs) {
+  const then = Date.parse(isoTimestamp);
+  return Number.isNaN(then) || then > nowMs ? Number.POSITIVE_INFINITY : nowMs - then;
+}
+function detectLocation(options, runtime, binPath) {
+  return detectInstallLocation({
+    binPath,
+    packageName: options.packageName,
+    platform: runtime.platform,
+    env: runtime.env,
+    ...runtime.realpath === void 0 ? {} : { realpath: runtime.realpath },
+    ...runtime.isWritable === void 0 ? {} : { isWritable: runtime.isWritable }
+  });
+}
+function createContext(options, runtime) {
+  const { env } = runtime;
+  const binPath = runtime.argv[1] ?? "";
+  const location = detectLocation(options, runtime, binPath);
+  const decision = resolveUpdatePolicy({
+    env,
+    location,
+    skipCommands: options.skipCommands ?? [],
+    manual: options.manual === true,
+    ...options.envPrefix === void 0 ? {} : { envPrefix: options.envPrefix },
+    ...options.commandPath === void 0 ? {} : { commandPath: options.commandPath }
+  });
+  const statePath = updateStatePath(resolveSaptoolsRoot(options.saptoolsRoot, env), options.packageName);
+  const notice = options.notice ?? ((line) => {
+    process.stderr.write(`${options.binName}: ${line}
+`);
+  });
+  const debug = isTruthyFlag(env[DEBUG_ENV]) ? (line) => {
+    process.stderr.write(`${options.binName}: [self-update] ${line}
+`);
+  } : () => {
+  };
+  return {
+    options,
+    runtime,
+    binPath,
+    location,
+    decision,
+    registryUrl: resolveRegistryUrl(env, readUserNpmrc(runtime.homeDirectory)),
+    statePath,
+    intervalMs: resolveCheckIntervalMs(env),
+    // Loaded lazily in resolveLatest: a disabled run must not touch ~/.saptools at all.
+    state: EMPTY_UPDATE_STATE,
+    notice,
+    debug
+  };
+}
+function saveState(ctx) {
+  try {
+    writeUpdateState(ctx.statePath, ctx.state);
+  } catch (error) {
+    ctx.debug(`cannot write ${ctx.statePath}: ${errorMessage(error)}`);
+  }
+}
+async function resolveLatest(ctx) {
+  ctx.state = readUpdateState(ctx.statePath);
+  const { state } = ctx;
+  const nowMs = ctx.runtime.now().getTime();
+  if (ctx.options.manual !== true) {
+    if (state.latest !== void 0 && state.checkedAt !== void 0 && ageMs(state.checkedAt, nowMs) < ctx.intervalMs) {
+      ctx.debug(`using cached latest ${state.latest} (checked ${state.checkedAt})`);
+      return state.latest;
+    }
+    if (state.lastFailureAt !== void 0 && ageMs(state.lastFailureAt, nowMs) < FAILURE_BACKOFF_MS) {
+      ctx.debug(`skipping the registry check after a recent failure: ${state.lastFailureReason ?? "unknown"}`);
+      return state.latest;
+    }
+  }
+  const result = await fetchLatestVersion(ctx.options.packageName, ctx.registryUrl, {
+    fetchImpl: ctx.runtime.fetchImpl,
+    timeoutMs: ctx.runtime.checkTimeoutMs,
+    userAgent: `${ctx.options.binName}/${ctx.options.currentVersion} saptools-self-update`
+  });
+  const at = ctx.runtime.now().toISOString();
+  if (result.ok) {
+    ctx.state = clearFailure({ ...ctx.state, checkedAt: at, latest: result.latest });
+    saveState(ctx);
+    return result.latest;
+  }
+  ctx.state = { ...ctx.state, lastFailureAt: at, lastFailureReason: result.reason };
+  saveState(ctx);
+  ctx.debug(`registry check failed: ${result.reason}`);
+  return ctx.state.latest;
+}
+function notify2(ctx, latest, reason) {
+  const nowMs = ctx.runtime.now().getTime();
+  const alreadyAnnounced = ctx.state.notifiedVersion === latest && ctx.state.notifiedAt !== void 0 && ageMs(ctx.state.notifiedAt, nowMs) < NOTIFY_INTERVAL_MS;
+  if (!alreadyAnnounced || ctx.options.manual === true) {
+    const command = manualInstallCommand(ctx.location.kind, `${ctx.options.packageName}@${latest}`);
+    ctx.notice(`${latest} is available (installed ${ctx.options.currentVersion}) but was not installed: ${reason}. Run: ${command}`);
+    ctx.state = { ...ctx.state, notifiedVersion: latest, notifiedAt: ctx.runtime.now().toISOString() };
+    saveState(ctx);
+  }
+  return { kind: "notified", latest, reason };
+}
+function recentInstallFailure(ctx, latest) {
+  const attempt = ctx.state.lastInstall;
+  if (ctx.options.manual === true || attempt === void 0 || attempt.ok || attempt.version !== latest) {
+    return;
+  }
+  if (ageMs(attempt.at, ctx.runtime.now().getTime()) >= INSTALL_RETRY_BACKOFF_MS) {
+    return;
+  }
+  return `the previous attempt failed (${attempt.reason ?? "unknown reason"})`;
+}
+function recordInstall(ctx, latest, ok, reason) {
+  const at = ctx.runtime.now().toISOString();
+  ctx.state = { ...ctx.state, lastInstall: reason === void 0 ? { version: latest, at, ok } : { version: latest, at, ok, reason } };
+  saveState(ctx);
+}
+async function installLatest(ctx, latest) {
+  const command = buildInstallCommand({
+    location: ctx.location,
+    packageName: ctx.options.packageName,
+    version: latest,
+    registryUrl: ctx.registryUrl,
+    execPath: ctx.runtime.execPath,
+    platform: ctx.runtime.platform,
+    ...ctx.runtime.exists === void 0 ? {} : { exists: ctx.runtime.exists },
+    ...ctx.runtime.realpath === void 0 ? {} : { realpath: ctx.runtime.realpath }
+  });
+  if (command === void 0) {
+    return notify2(ctx, latest, "no supported package manager was found for this install");
+  }
+  const lock = acquireUpdateLock(updateLockPath(ctx.statePath), ctx.runtime.now());
+  if (lock === void 0) {
+    ctx.debug("another process holds the update lock");
+    return { kind: "skipped", reason: "another process is installing the update" };
+  }
+  try {
+    ctx.notice(`updating ${ctx.options.currentVersion} -> ${latest} ...`);
+    const result = await runInstall(command, { env: ctx.runtime.env, timeoutMs: ctx.runtime.installTimeoutMs, spawnImpl: ctx.runtime.spawnImpl });
+    const installed = ctx.location.packageDirectory === void 0 ? void 0 : readPackageManifest(ctx.location.packageDirectory)?.version;
+    const failure = result.ok ? installed === latest ? void 0 : `the installed version is ${installed ?? "unreadable"}, not ${latest}` : result.reason;
+    if (failure !== void 0) {
+      recordInstall(ctx, latest, false, failure);
+      ctx.notice(`update to ${latest} failed (${failure}); continuing with ${ctx.options.currentVersion}. Run: ${command.display}`);
+      return { kind: "failed", latest, reason: failure };
+    }
+    recordInstall(ctx, latest, true);
+  } finally {
+    lock.release();
+  }
+  return;
+}
+async function upgrade(ctx, latest) {
+  const failed = await installLatest(ctx, latest);
+  if (failed !== void 0) {
+    return failed;
+  }
+  const outcome = { kind: "updated", from: ctx.options.currentVersion, to: latest };
+  if (ctx.options.reexec === false) {
+    ctx.notice(`updated to ${latest}`);
+    return outcome;
+  }
+  ctx.notice(`updated to ${latest}; re-running the command`);
+  try {
+    await ctx.runtime.reexecImpl({
+      execPath: ctx.runtime.execPath,
+      execArgv: ctx.runtime.execArgv,
+      binPath: ctx.binPath,
+      args: ctx.runtime.argv.slice(2),
+      env: ctx.runtime.env
+    });
+  } catch (error) {
+    ctx.notice(`could not re-run on ${latest} (${errorMessage(error)}); continuing with the already loaded ${ctx.options.currentVersion}`);
+  }
+  return outcome;
+}
+async function runSelfUpdateUnsafe(options, runtime) {
+  const ctx = createContext(options, runtime);
+  if (ctx.decision.policy === "off") {
+    ctx.debug(`off: ${ctx.decision.reason}`);
+    return { kind: "skipped", reason: ctx.decision.reason };
+  }
+  const latest = await resolveLatest(ctx);
+  if (latest === void 0) {
+    return { kind: "skipped", reason: "the latest version is unknown" };
+  }
+  if (!isNewerRelease(latest, options.currentVersion)) {
+    return { kind: "current", latest };
+  }
+  if (ctx.decision.policy === "notify") {
+    return notify2(ctx, latest, ctx.decision.reason);
+  }
+  const backoff = recentInstallFailure(ctx, latest);
+  if (backoff !== void 0) {
+    return notify2(ctx, latest, backoff);
+  }
+  return await upgrade(ctx, latest);
+}
+async function runSelfUpdate(options, overrides = {}) {
+  const runtime = { ...defaultRuntime2(), ...overrides };
+  try {
+    return await runSelfUpdateUnsafe(options, runtime);
+  } catch (error) {
+    const reason = errorMessage(error);
+    if (isTruthyFlag(runtime.env[DEBUG_ENV])) {
+      process.stderr.write(`${options.binName}: [self-update] ${reason}
+`);
+    }
+    return { kind: "skipped", reason };
+  }
+}
+async function inspectSelfUpdate(options, overrides = {}) {
+  const runtime = { ...defaultRuntime2(), ...overrides };
+  const ctx = createContext({ ...options, manual: true }, runtime);
+  const result = await fetchLatestVersion(options.packageName, ctx.registryUrl, {
+    fetchImpl: runtime.fetchImpl,
+    timeoutMs: runtime.checkTimeoutMs,
+    userAgent: `${options.binName}/${options.currentVersion} saptools-self-update`
+  });
+  return {
+    packageName: options.packageName,
+    installed: options.currentVersion,
+    location: ctx.location,
+    policy: resolveUpdatePolicy({
+      env: runtime.env,
+      location: ctx.location,
+      ...options.envPrefix === void 0 ? {} : { envPrefix: options.envPrefix }
+    }),
+    registryUrl: ctx.registryUrl,
+    statePath: ctx.statePath,
+    latest: result.ok ? result.latest : void 0,
+    checkError: result.ok ? void 0 : result.reason
+  };
+}
+
+// ../core/src/self-update/commander.ts
+function commandPathOf(command) {
+  const names = [];
+  let current = command;
+  while (current.parent !== null) {
+    names.unshift(current.name());
+    current = current.parent;
+  }
+  return names.join(" ");
+}
+function attachSelfUpdate(program, options) {
+  program.hook("preAction", async (_thisCommand, actionCommand) => {
+    await runSelfUpdate({ ...options, commandPath: commandPathOf(actionCommand) });
+  });
+}
+function formatSelfUpdateStatus(status) {
+  const latest = status.latest ?? (status.checkError === void 0 ? "unknown" : `unknown (${status.checkError})`);
+  const install = status.location.packageDirectory === void 0 ? status.location.detail : `${status.location.kind} ${status.location.packageDirectory}`;
+  return [
+    `package=${status.packageName}`,
+    `installed=${status.installed}`,
+    `latest=${latest}`,
+    `policy=${status.policy.policy} (${status.policy.reason})`,
+    `install=${install}`,
+    `writable=${status.location.writable ? "yes" : "no"}`,
+    `registry=${status.registryUrl}`,
+    `state=${status.statePath}`
+  ];
+}
+function describeOutcome(outcome) {
+  switch (outcome.kind) {
+    case "current":
+      return `current (${outcome.latest} is the newest release)`;
+    case "updated":
+      return `updated ${outcome.from} -> ${outcome.to}`;
+    case "notified":
+      return `not installed (${outcome.reason})`;
+    case "failed":
+      return `failed (${outcome.reason})`;
+    case "skipped":
+      return `skipped (${outcome.reason})`;
+  }
+}
+async function runSelfUpdateCommand(options, checkOnly) {
+  const print = options.print ?? ((line) => {
+    process.stdout.write(`${line}
+`);
+  });
+  const status = await inspectSelfUpdate(options);
+  for (const line of formatSelfUpdateStatus(status)) {
+    print(line);
+  }
+  if (checkOnly) {
+    const verdict = status.latest === void 0 ? "unknown" : isNewerRelease(status.latest, status.installed) ? "update-available" : "current";
+    print(`result=${verdict}`);
+    return;
+  }
+  const outcome = await runSelfUpdate({ ...options, manual: true, reexec: false });
+  print(`result=${describeOutcome(outcome)}`);
+  if (outcome.kind === "failed") {
+    process.exitCode = 1;
+  }
+}
+function registerSelfUpdateCommand(program, options) {
+  program.command(SELF_UPDATE_COMMAND).description("check npm for a newer release and install it now; every other command does this automatically (at most once an hour)").option("--check", "report whether a newer release exists without installing it").action(async (flags) => {
+    await runSelfUpdateCommand(options, flags.check === true);
+  });
+}
+
+// src/cli/program.ts
 import { Command } from "commander";
 
 // src/cli/commands/attach.ts
@@ -169,7 +1310,7 @@ import { request } from "http";
 import { performance } from "perf_hooks";
 var InvalidDiscoveryPayloadError = class extends CfInspectorError {
 };
-async function fetchJson(url, timeoutMs) {
+async function fetchJson2(url, timeoutMs) {
   const deadline = performance.now() + timeoutMs;
   let lastError;
   while (performance.now() < deadline) {
@@ -296,7 +1437,7 @@ function toInspectorTarget(value, source) {
 }
 async function discoverInspectorTargets(host, port, timeoutMs) {
   const url = `http://${host}:${port.toString()}/json/list`;
-  const raw = await fetchJson(url, timeoutMs);
+  const raw = await fetchJson2(url, timeoutMs);
   if (!Array.isArray(raw) || raw.length === 0) {
     throw new CfInspectorError(
       "INSPECTOR_DISCOVERY_FAILED",
@@ -316,7 +1457,7 @@ function readVersionField(value, ...keys) {
 }
 async function fetchInspectorVersion(host, port, timeoutMs) {
   const url = `http://${host}:${port.toString()}/json/version`;
-  const raw = await fetchJson(url, timeoutMs);
+  const raw = await fetchJson2(url, timeoutMs);
   if (typeof raw !== "object" || raw === null) {
     throw new CfInspectorError(
       "INSPECTOR_DISCOVERY_FAILED",
@@ -1019,7 +2160,7 @@ function asString(value, fallback = "") {
 function asNumber(value, fallback = 0) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -1036,7 +2177,7 @@ function optionalBoolean(value) {
   return typeof value === "boolean" ? value : void 0;
 }
 function toScriptLocation(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const scriptId = nonEmptyString(value["scriptId"]);
@@ -1057,7 +2198,7 @@ function toResolvedLocations(value) {
   }
   return value.flatMap((entry) => {
     const location = toScriptLocation(entry);
-    if (location === void 0 || !isRecord(entry)) {
+    if (location === void 0 || !isRecord2(entry)) {
       return [];
     }
     const url = typeof entry["url"] === "string" ? entry["url"] : void 0;
@@ -1070,7 +2211,7 @@ function toBreakLocations(value) {
   }
   return value.flatMap((entry) => {
     const location = toScriptLocation(entry);
-    if (location === void 0 || !isRecord(entry)) {
+    if (location === void 0 || !isRecord2(entry)) {
       return [];
     }
     const type = nonEmptyString(entry["type"]);
@@ -1087,7 +2228,7 @@ function optionalOwnField(key, value) {
   return Object.hasOwn(value, key) ? { [key]: value[key] } : {};
 }
 function toRemoteObject(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const type = nonEmptyString(value["type"]);
@@ -1114,7 +2255,7 @@ function optionalTextField(key, value) {
   return typeof value === "string" ? { [key]: value } : {};
 }
 function toScope(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const type = nonEmptyString(value["type"]);
@@ -1162,7 +2303,7 @@ function toCallFrameMetadata(candidate, location, scripts) {
   };
 }
 function toCallFrame(value, scripts) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const callFrameId = nonEmptyString(value["callFrameId"]);
@@ -1186,7 +2327,7 @@ function toCallFrames(value, scripts) {
   }) : [];
 }
 function toStackTraceId(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const id = nonEmptyString(value["id"]);
@@ -1197,7 +2338,7 @@ function toStackTraceId(value) {
   return debuggerId === void 0 ? { id } : { id, debuggerId };
 }
 function toStackTraceFrame(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const scriptId = nonEmptyString(value["scriptId"]);
@@ -1213,7 +2354,7 @@ function toStackTraceFrame(value) {
   };
 }
 function toStackTrace(value) {
-  if (!isRecord(value) || !Array.isArray(value["callFrames"])) {
+  if (!isRecord2(value) || !Array.isArray(value["callFrames"])) {
     return void 0;
   }
   const callFrames = value["callFrames"].flatMap((entry) => {
@@ -1231,7 +2372,7 @@ function toStackTrace(value) {
   };
 }
 function toPauseEvent(value, receivedAtMs, scripts) {
-  const params = isRecord(value) ? value : {};
+  const params = isRecord2(value) ? value : {};
   const asyncStackTrace = toStackTrace(params["asyncStackTrace"]);
   const asyncStackTraceId = toStackTraceId(params["asyncStackTraceId"]);
   const asyncCallStackTraceId = toStackTraceId(params["asyncCallStackTraceId"]);
@@ -1247,7 +2388,7 @@ function toPauseEvent(value, receivedAtMs, scripts) {
   };
 }
 function toScriptInfo(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return void 0;
   }
   const scriptId = nonEmptyString(value["scriptId"]);
@@ -1789,10 +2930,10 @@ var DEFAULT_EXCEPTION_TIMEOUT_SEC = 30;
 init_types();
 import { execFileSync } from "child_process";
 import { createHash, randomUUID } from "crypto";
-import { constants } from "fs";
+import { constants as constants3 } from "fs";
 import { mkdir, open, readFile, readdir, stat, unlink, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
 var ELECTION_WINDOW_MS = 25;
 var LOCK_FILE_SUFFIX = ".lock";
 async function acquireDebugSessionLock(target, options = {}) {
@@ -1804,8 +2945,8 @@ async function acquireDebugSessionLock(target, options = {}) {
   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 lockDirectory = join7(lockRoot, "cf-inspector", "locks");
+  const ownPath = join7(lockDirectory, `${key}.${pid.toString()}.${token}${LOCK_FILE_SUFFIX}`);
   const metadata = {
     pid,
     ...ownerProcessStart === void 0 ? {} : { processStart: ownerProcessStart },
@@ -1815,7 +2956,7 @@ async function acquireDebugSessionLock(target, options = {}) {
     target: targetIdentity
   };
   await mkdir(lockDirectory, { recursive: true, mode: 448 });
-  const handle = await open(ownPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+  const handle = await open(ownPath, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
   try {
     await handle.writeFile(`${JSON.stringify(metadata)}
 `, "utf8");
@@ -1884,7 +3025,7 @@ function debugTargetIdentity(target) {
 }
 function defaultStateRoot() {
   const configured = process.env["CF_INSPECTOR_STATE_DIR"]?.trim();
-  return configured === void 0 || configured.length === 0 ? join(homedir(), ".saptools") : configured;
+  return configured === void 0 || configured.length === 0 ? join7(homedir3(), ".saptools") : configured;
 }
 async function findLiveContenders(lockDirectory, key, ownPath, isProcessAlive, getProcessStart) {
   const prefix = `${key}.`;
@@ -1894,7 +3035,7 @@ async function findLiveContenders(lockDirectory, key, ownPath, isProcessAlive, g
     if (!name.startsWith(prefix) || !name.endsWith(LOCK_FILE_SUFFIX)) {
       continue;
     }
-    const path = join(lockDirectory, name);
+    const path = join7(lockDirectory, name);
     if (path === ownPath) {
       continue;
     }
@@ -1925,7 +3066,7 @@ async function findLiveContenders(lockDirectory, key, ownPath, isProcessAlive, g
 async function readLockMetadata(path) {
   try {
     const parsed = JSON.parse(await readFile(path, "utf8"));
-    if (!isRecord2(parsed)) {
+    if (!isRecord3(parsed)) {
       return void 0;
     }
     const pid = parsed["pid"];
@@ -2016,7 +3157,7 @@ function normalizeHost(host) {
   const normalized = host.trim().toLowerCase();
   return normalized === "localhost" || normalized === "::1" ? "127.0.0.1" : normalized;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function isNodeError(error, code) {
@@ -5404,27 +6545,27 @@ var collectStrings = (value, prev = []) => [
   value
 ];
 var READY_EVENT_DESCRIPTION = "Emit a versioned breakpoint-armed JSON event on stderr after every current isolate is armed";
-function readPackageVersion() {
-  let current = dirname(fileURLToPath(import.meta.url));
-  for (let depth = 0; depth < 4; depth += 1) {
-    const candidate = join2(current, "package.json");
-    try {
-      const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-      if (typeof parsed === "object" && parsed !== null) {
-        const record = parsed;
-        if (record["name"] === "@saptools/cf-inspector" && typeof record["version"] === "string") {
-          return record["version"];
-        }
-      }
-    } catch {
-    }
-    current = dirname(current);
+function writeUpdateNotice(argv, line) {
+  if (argv.includes("--emit-ready-event")) {
+    return;
   }
-  throw new Error("Unable to read @saptools/cf-inspector package version");
+  process13.stderr.write(`cf-inspector: ${line}
+`);
 }
 async function main(argv) {
+  const { version } = readPackageMetadata(import.meta.url, "@saptools/cf-inspector");
+  const selfUpdate = {
+    packageName: "@saptools/cf-inspector",
+    currentVersion: version,
+    binName: "cf-inspector",
+    envPrefix: "CF_INSPECTOR",
+    notice: (line) => {
+      writeUpdateNotice(argv, line);
+    }
+  };
   const program = new Command();
-  program.name("cf-inspector").version(readPackageVersion()).description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
+  program.name("cf-inspector").version(version).description("Drive a Node.js inspector from the command line \u2014 set breakpoints, capture snapshots, evaluate expressions");
+  attachSelfUpdate(program, selfUpdate);
   registerSnapshot(program);
   registerLog(program);
   registerWatch(program);
@@ -5434,6 +6575,7 @@ async function main(argv) {
   registerListScripts(program);
   registerListTargets(program);
   registerAttach(program);
+  registerSelfUpdateCommand(program, selfUpdate);
   await program.parseAsync([...argv]);
 }
 function registerCheckBreakpoint(program) {
@@ -5517,20 +6659,20 @@ function registerAttach(program) {
 // src/cli.ts
 init_types();
 try {
-  await main(process13.argv);
+  await main(process14.argv);
 } catch (err) {
   if (err instanceof CfInspectorError) {
-    process13.stderr.write(`Error [${err.code}]: ${err.message}
+    process14.stderr.write(`Error [${err.code}]: ${err.message}
 `);
     if (err.detail !== void 0) {
-      process13.stderr.write(`  detail: ${err.detail}
+      process14.stderr.write(`  detail: ${err.detail}
 `);
     }
-    process13.exit(1);
+    process14.exit(1);
   }
   const message = err instanceof Error ? err.message : String(err);
-  process13.stderr.write(`Error: ${message}
+  process14.stderr.write(`Error: ${message}
 `);
-  process13.exit(1);
+  process14.exit(1);
 }
 //# sourceMappingURL=cli.js.map