@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-CSIE4Y7C.js

@@ -0,0 +1,1093 @@
+import {
+  homeLauncherPath
+} from "./chunk-KZ4JMGZ5.js";
+import {
+  resolveInstallHomeDir
+} from "./chunk-GZAJHLKO.js";
+import {
+  mkBuildTempDir,
+  mkBuildTempDirSync
+} from "./chunk-D6WTZMZB.js";
+import {
+  safeRmDir
+} from "./chunk-ALDTFNZ3.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  resolveCliBinary
+} from "./chunk-GVJGSSKM.js";
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+import {
+  processIsAlive
+} from "./chunk-MT2WAIR3.js";
+
+// src/cli/commands/setup-temp-cleanup.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { execa as execa4 } from "execa";
+
+// src/cli/commands/upgrade-support.ts
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { execa as execa3, execaSync } from "execa";
+
+// src/cli/commands/upgrade-git-source-build.ts
+import fs2 from "fs";
+import { tmpdir } from "os";
+import path2 from "path";
+import { execa as execa2 } from "execa";
+
+// src/cli/commands/upgrade-output.ts
+import fs from "fs";
+import path from "path";
+import { execa } from "execa";
+import * as semver from "semver";
+var FAILURE_TAIL_LINES = 40;
+var UpgradeStepError = class extends Error {
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+    this.name = "UpgradeStepError";
+  }
+  detail;
+};
+function upgradeNpmEnvironment(env = process.env) {
+  return { ...env, PATH: `${path.dirname(process.execPath)}${path.delimiter}${env.PATH ?? ""}` };
+}
+function describeUpgradeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return error instanceof UpgradeStepError && error.detail ? `${message}
+${error.detail}` : message;
+}
+function failureDetail(output) {
+  if (!output.trim()) return "";
+  const lines = output.replace(/\s+$/, "").split("\n");
+  if (lines.length <= FAILURE_TAIL_LINES) return lines.join("\n");
+  let logNote;
+  try {
+    const logPath = path.join(mkBuildTempDirSync("upgrade-log"), "output.log");
+    fs.writeFileSync(logPath, `${lines.join("\n")}
+`);
+    logNote = `Full output: ${logPath}`;
+  } catch {
+    logNote = "Full output could not be saved.";
+  }
+  const omitted = lines.length - FAILURE_TAIL_LINES;
+  return [
+    `... ${omitted} earlier lines omitted`,
+    ...lines.slice(-FAILURE_TAIL_LINES),
+    logNote
+  ].join("\n");
+}
+async function runCaptured(file, args, options = {}) {
+  const command = file === "npm" ? resolveCliBinary("npm", "npm") : file;
+  const result = await execa(command, args, {
+    ...options,
+    ...file === "npm" ? { env: upgradeNpmEnvironment(options.env ?? process.env) } : {},
+    stdout: "pipe",
+    stderr: "pipe",
+    all: true,
+    reject: false
+  });
+  if (!result.failed) {
+    if (file === "npm" && typeof result.stderr === "string" && result.stderr.trim()) {
+      process.stderr.write(`${result.stderr.trimEnd()}
+`);
+    }
+    return;
+  }
+  const output = typeof result.all === "string" ? result.all : "";
+  const message = result.shortMessage ?? result.message ?? `${file} failed`;
+  throw new UpgradeStepError(message, failureDetail(output));
+}
+function formatIdentity(identity) {
+  const version = identity.version ?? "unknown version";
+  return identity.commit ? `${version} (${identity.commit.slice(0, 7)})` : version;
+}
+function renderUpgradeResult(before, after) {
+  const from = formatIdentity(before);
+  const to = formatIdentity(after);
+  if (from === to) return `Already up to date: ${to}`;
+  const older = semver.valid(after.version) && semver.valid(before.version) && semver.lt(after.version, before.version);
+  return `${older ? "Downgraded" : "Upgraded"} ${from} -> ${to}`;
+}
+
+// src/cli/commands/upgrade-git-source-build.ts
+var BUILD_STEP_TIMEOUT_MS = 30 * 60 * 1e3;
+var BUILD_ENV_SCRUB = [
+  "GITHUB_TOKEN",
+  "BUILD_INSTALL_GH_TOKEN",
+  "BUILD_SKIP_PREPACK",
+  "BUILD_HOME",
+  "BUILD_CONFIG_DIR",
+  "BUILD_DATA_DIR"
+];
+var GH_CREDENTIAL_FALLBACK_ARGS = [
+  "-c",
+  "credential.https://github.com.helper=!gh auth git-credential"
+];
+var GIT_ACCESS_DENIED = /repository not found|authentication failed|could not read username|invalid username|permission denied|returned error: 40[134]|terminal prompts disabled/i;
+async function retryPastUrlRewriteOnDenial(repository, run) {
+  const first = await run([]);
+  if (first.exitCode === 0 || !GIT_ACCESS_DENIED.test(first.stderr)) return first;
+  return run(["-c", `url.${repository}.insteadOf=${repository}`]);
+}
+function parseGitInstallTarget(target) {
+  const match = /^git\+(.+)#([0-9a-f]{40})$/.exec(target);
+  return match?.[1] && match[2] ? { repository: match[1], commit: match[2] } : void 0;
+}
+var buildGitSourceTarball = async (repository, commit) => {
+  const buildDir = await mkBuildTempDir("upgrade-git-build");
+  const dispose = async () => {
+    await safeRmDir(buildDir, { protectedPaths: [tmpdir()], managedRoots: [tmpdir()] });
+  };
+  try {
+    const srcDir = path2.join(buildDir, "src");
+    const packDir = path2.join(buildDir, "pack");
+    fs2.mkdirSync(srcDir);
+    fs2.mkdirSync(packDir);
+    process.stderr.write(`Fetching commit ${commit.slice(0, 12)} from ${repository}...
+`);
+    for (const args of [
+      ["init", "--quiet"],
+      ["remote", "add", "origin", repository],
+      [...GH_CREDENTIAL_FALLBACK_ARGS, "fetch", "--depth", "1", "--quiet", "origin", commit],
+      ["-c", "core.autocrlf=false", "checkout", "--quiet", "--detach", "FETCH_HEAD"]
+    ]) {
+      const run2 = (configArgs) => execGit([...configArgs, ...args], { cwd: srcDir, timeoutMs: BUILD_STEP_TIMEOUT_MS });
+      const result = args.includes("fetch") ? await retryPastUrlRewriteOnDenial(repository, run2) : await run2([]);
+      if (result.exitCode !== 0) {
+        const verb = args[0] === "-c" ? args[2] : args[0];
+        throw new Error(`git ${verb} failed for commit ${commit}: ${result.stderr.trim()}`);
+      }
+    }
+    const head = (await execGit(["rev-parse", "HEAD"], { cwd: srcDir })).stdout.trim();
+    if (head !== commit) {
+      throw new Error(`Fetched checkout is ${head || "unknown"}, expected ${commit}.`);
+    }
+    const env = upgradeNpmEnvironment();
+    for (const name of BUILD_ENV_SCRUB) delete env[name];
+    const ignoreScripts = await execa2(
+      resolveCliBinary("npm", "npm"),
+      ["config", "get", "ignore-scripts"],
+      {
+        cwd: srcDir,
+        env,
+        extendEnv: false,
+        reject: false
+      }
+    );
+    if (/^(true|1|yes|on)$/i.test(String(ignoreScripts.stdout).trim())) {
+      throw new Error(
+        "npm is configured with ignore-scripts=true, so the source build cannot produce dist/. Remove the effective setting (npm config delete ignore-scripts; inspect with npm config list) and retry."
+      );
+    }
+    process.stderr.write("Building from source (npm ci, npm pack)...\n");
+    const run = (file, args) => runCaptured(file, args, {
+      cwd: srcDir,
+      env,
+      extendEnv: false,
+      timeout: BUILD_STEP_TIMEOUT_MS,
+      stdin: "ignore"
+    });
+    const npm = (args) => run("npm", args);
+    const ciArgs = ["ci", "--include=dev", "--no-audit", "--no-fund"];
+    const normalizer = path2.join("scripts", "normalize-lockfile-gypfile.mjs");
+    if (fs2.existsSync(path2.join(srcDir, normalizer))) {
+      await npm([...ciArgs, "--ignore-scripts"]);
+      await run(process.execPath, [normalizer, "."]);
+      await npm(["rebuild"]);
+    } else {
+      await npm(ciArgs);
+    }
+    await npm(["pack", "--pack-destination", packDir]);
+    const tarball = fs2.readdirSync(packDir).find((name) => name.endsWith(".tgz"));
+    if (!tarball) throw new Error(`npm pack produced no tarball under ${packDir}.`);
+    return { tarballPath: path2.join(packDir, tarball), dispose };
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+};
+
+// src/cli/commands/upgrade-support.ts
+var DEFAULT_PACKAGE = "@ebrindley/build";
+var INSTALL_LOCK_DIR_NAME = "install.lock.d";
+var INSTALL_LOCK_OWNER_FILE = "owner.json";
+var DEFAULT_LOCK_TIMEOUT_MS = 3e4;
+var DEFAULT_LOCK_STALE_MS = 36 * 6e4;
+var DEFAULT_LOCK_RETRY_MS = 250;
+var LS_REMOTE_TIMEOUT_MS = 6e4;
+var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+var PARTIAL_SHA_RE = /^[0-9a-f]{7,39}$/i;
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPidAlive(pid) {
+  return Number.isInteger(pid) && pid > 0 && processIsAlive(pid);
+}
+function buildHomeDir(homeDir) {
+  return resolveInstallHomeDir(homeDir);
+}
+function installManifestPath(homeDir) {
+  return path3.join(buildHomeDir(homeDir), "install.json");
+}
+function installLockDir(homeDir) {
+  return path3.join(buildHomeDir(homeDir), INSTALL_LOCK_DIR_NAME);
+}
+function readInstallLockOwner(lockDir) {
+  try {
+    const ownerPath = path3.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+    if (!fs3.existsSync(ownerPath)) return void 0;
+    const raw = fs3.readFileSync(ownerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data.pid !== "number" || typeof data.hostname !== "string" || typeof data.startedAt !== "string" || typeof data.token !== "string") {
+      return void 0;
+    }
+    return {
+      pid: data.pid,
+      hostname: data.hostname,
+      startedAt: data.startedAt,
+      command: typeof data.command === "string" ? data.command : "unknown",
+      token: data.token
+    };
+  } catch {
+    return void 0;
+  }
+}
+function formatLockDiagnostics(lockDir, owner, alive, stale) {
+  const lines = [`Install lock is held at ${lockDir}.`];
+  if (!owner) {
+    lines.push("Owner metadata is missing or unreadable.");
+  } else {
+    lines.push(
+      `Owner: pid=${owner.pid} host=${owner.hostname} startedAt=${owner.startedAt} command=${owner.command}`
+    );
+    if (alive === false) lines.push("Owner process is not running (stale lock).");
+    if (alive === true) lines.push("Owner process appears to be running.");
+  }
+  if (stale) lines.push("Lock is considered stale and can be reclaimed.");
+  lines.push("Wait for the other upgrade/install to finish, or remove the stale lock directory.");
+  return lines.join(" ");
+}
+function writeLockOwner(lockDir, owner) {
+  const ownerPath = path3.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+  const tmp = path3.join(lockDir, `.owner.${owner.pid}.${Date.now()}.tmp`);
+  fs3.writeFileSync(tmp, `${JSON.stringify(owner, null, 2)}
+`, "utf8");
+  fs3.renameSync(tmp, ownerPath);
+}
+function releaseLockDir(lockDir, token) {
+  try {
+    const owner = readInstallLockOwner(lockDir);
+    if (owner && owner.token !== token) {
+      return;
+    }
+    const ownerPath = path3.join(lockDir, INSTALL_LOCK_OWNER_FILE);
+    try {
+      fs3.unlinkSync(ownerPath);
+    } catch {
+    }
+    try {
+      for (const entry of fs3.readdirSync(lockDir)) {
+        if (entry.startsWith(".owner.")) {
+          try {
+            fs3.unlinkSync(path3.join(lockDir, entry));
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    fs3.rmdirSync(lockDir);
+  } catch {
+  }
+}
+function isLockStale(lockDir, owner, staleMs, nowMs, pidAlive, localHostname) {
+  if (!owner) {
+    try {
+      const stat = fs3.statSync(lockDir);
+      return { stale: nowMs - stat.mtimeMs > staleMs, alive: void 0 };
+    } catch {
+      return { stale: true, alive: void 0 };
+    }
+  }
+  if (owner.hostname !== localHostname) {
+    const started2 = Date.parse(owner.startedAt);
+    return {
+      stale: Number.isFinite(started2) && nowMs - started2 > staleMs,
+      alive: void 0
+    };
+  }
+  const alive = pidAlive(owner.pid);
+  if (!alive) return { stale: true, alive: false };
+  const started = Date.parse(owner.startedAt);
+  if (Number.isFinite(started) && nowMs - started > staleMs) {
+    return { stale: false, alive: true };
+  }
+  return { stale: false, alive: true };
+}
+async function acquireInstallLock(options = {}) {
+  const homeDir = options.homeDir;
+  const lockDir = installLockDir(homeDir);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_LOCK_STALE_MS;
+  const retryMs = options.retryMs ?? DEFAULT_LOCK_RETRY_MS;
+  const nowFn = options.now ?? Date.now;
+  const sleepFn = options.sleep ?? defaultSleep;
+  const pidAlive = options.isPidAlive ?? isPidAlive;
+  const hostname = options.hostname ?? os.hostname();
+  const pid = options.pid ?? process.pid;
+  const command = options.command ?? "build upgrade";
+  const parent = buildHomeDir(homeDir);
+  fs3.mkdirSync(parent, { recursive: true });
+  const deadline = nowFn() + timeoutMs;
+  let lastDiagnostics = `Install lock is held at ${lockDir}.`;
+  while (true) {
+    const token = `${pid}:${nowFn()}:${Math.random().toString(16).slice(2)}`;
+    const owner = {
+      pid,
+      hostname,
+      startedAt: new Date(nowFn()).toISOString(),
+      command,
+      token
+    };
+    try {
+      fs3.mkdirSync(lockDir);
+      try {
+        writeLockOwner(lockDir, owner);
+      } catch (error) {
+        try {
+          fs3.rmdirSync(lockDir);
+        } catch {
+        }
+        throw error;
+      }
+      return {
+        lockDir,
+        owner,
+        release: () => releaseLockDir(lockDir, token)
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      const existing = readInstallLockOwner(lockDir);
+      const { stale, alive } = isLockStale(lockDir, existing, staleMs, nowFn(), pidAlive, hostname);
+      lastDiagnostics = formatLockDiagnostics(lockDir, existing, alive, stale);
+      if (stale) {
+        try {
+          releaseLockDir(lockDir, existing?.token ?? "");
+        } catch {
+        }
+        if (!fs3.existsSync(lockDir)) continue;
+      }
+      if (nowFn() >= deadline) {
+        throw new Error(
+          `Error: could not acquire install lock within ${timeoutMs}ms. ${lastDiagnostics}`
+        );
+      }
+      await sleepFn(retryMs);
+    }
+  }
+}
+function parseLsRemoteLines(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    const [sha, ref] = line.split(/\s+/, 2);
+    if (sha && ref && FULL_SHA_RE.test(sha)) {
+      out.push({ sha: sha.toLowerCase(), ref });
+    }
+  }
+  return out;
+}
+async function resolveGitCommitSha(repoUrl, ref, runLsRemote) {
+  const trimmed = ref.trim();
+  if (!trimmed) {
+    throw new Error("Error: git ref is empty");
+  }
+  if (FULL_SHA_RE.test(trimmed)) {
+    const result2 = await runLsRemote(repoUrl);
+    if (result2.exitCode !== 0) {
+      throw new Error(
+        `Error: could not query advertised git identities from ${repoUrl}${result2.stderr.trim() ? `: ${result2.stderr.trim()}` : ` (exit ${result2.exitCode})`}`
+      );
+    }
+    const rows2 = parseLsRemoteLines(result2.stdout);
+    const peeledTags = new Set(
+      rows2.filter((row) => row.ref.endsWith("^{}")).map((row) => row.ref.slice(0, -3))
+    );
+    const advertised = rows2.some((row) => {
+      if (row.sha !== trimmed.toLowerCase()) return false;
+      const annotatedTagObject = row.ref.startsWith("refs/tags/") && !row.ref.endsWith("^{}") && peeledTags.has(row.ref);
+      return !annotatedTagObject;
+    });
+    if (advertised) return trimmed.toLowerCase();
+    throw new Error(`Error: full git SHA "${trimmed}" is not an advertised identity on ${repoUrl}`);
+  }
+  if (PARTIAL_SHA_RE.test(trimmed)) {
+    const result2 = await runLsRemote(repoUrl, trimmed);
+    const matches = parseLsRemoteLines(result2.stdout).filter(
+      (row) => row.sha.startsWith(trimmed.toLowerCase())
+    );
+    const unique = [...new Set(matches.map((m) => m.sha))];
+    if (unique.length === 1) {
+      return unique[0];
+    }
+    if (unique.length > 1) {
+      throw new Error(
+        `Error: partial git SHA "${trimmed}" is ambiguous (${unique.length} matches). Use a full 40-character commit SHA.`
+      );
+    }
+    throw new Error(
+      `Error: partial git SHA "${trimmed}" could not be verified against ${repoUrl}. Use a full 40-character commit SHA.`
+    );
+  }
+  const result = await runLsRemote(repoUrl, [
+    `refs/tags/${trimmed}`,
+    `refs/tags/${trimmed}^{}`,
+    `refs/heads/${trimmed}`
+  ]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      result.stderr.trim() || `Error: could not query git refs for "${trimmed}" on ${repoUrl} (exit ${result.exitCode})`
+    );
+  }
+  const rows = parseLsRemoteLines(result.stdout);
+  const peeled = rows.find((row) => row.ref === `refs/tags/${trimmed}^{}`);
+  if (peeled?.sha) {
+    return peeled.sha;
+  }
+  const lightweight = rows.find((row) => row.ref === `refs/tags/${trimmed}`);
+  if (lightweight?.sha) return lightweight.sha;
+  const head = rows.find((row) => row.ref === `refs/heads/${trimmed}`);
+  if (head?.sha) return head.sha;
+  throw new Error(
+    `Error: could not resolve git ref "${trimmed}" on ${repoUrl}. Named refs must resolve before install.`
+  );
+}
+async function resolvePackageVersionString(packageName, ref, runNpmView) {
+  const result = await runNpmView(packageName, ref);
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `Error: npm could not resolve ${packageName}@${ref}`);
+  }
+  const version = result.stdout.trim().split(/\r?\n/).at(-1)?.trim() ?? "";
+  if (!version) {
+    throw new Error(`Error: npm returned no version for ${packageName}@${ref}`);
+  }
+  if (!/^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`Error: npm returned an invalid version for ${packageName}@${ref}`);
+  }
+  return version;
+}
+function packageInstallTarget(packageName, resolvedVersion) {
+  return `${packageName}@${resolvedVersion}`;
+}
+function gitInstallTarget(repository, resolvedFullCommit) {
+  if (!FULL_SHA_RE.test(resolvedFullCommit)) {
+    throw new Error(
+      `Error: git install target requires a full 40-character commit SHA, got "${resolvedFullCommit}"`
+    );
+  }
+  return `git+${repository}#${resolvedFullCommit.toLowerCase()}`;
+}
+function writeInstallManifestAtomic(manifest, options = {}) {
+  const manifestPath = options.manifestPath ?? installManifestPath(options.homeDir);
+  const dir = path3.dirname(manifestPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const payload = `${JSON.stringify(manifest, null, 2)}
+`;
+  const tmp = path3.join(
+    dir,
+    `.install.json.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+  );
+  try {
+    fs3.writeFileSync(tmp, payload, "utf8");
+    fs3.renameSync(tmp, manifestPath);
+  } catch (error) {
+    try {
+      fs3.unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function readInstallManifestFromDisk(options = {}) {
+  try {
+    const manifestPath = options.manifestPath ?? installManifestPath(options.homeDir);
+    if (!fs3.existsSync(manifestPath)) return void 0;
+    const data = JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
+    if (!data || typeof data !== "object") return void 0;
+    if (data.source === "package" || data.source === "git") {
+      return data;
+    }
+    if (typeof data.commit === "string" && data.commit.length > 0) {
+      return { ...data, source: "git", schema: 2 };
+    }
+    if (typeof data.version === "string" || typeof data.package === "string") {
+      return { ...data, source: "package", schema: 2 };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function findPackageJson(startDir) {
+  let current = startDir;
+  while (true) {
+    const candidate = path3.join(current, "package.json");
+    if (fs3.existsSync(candidate)) return candidate;
+    const parent = path3.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function resolveNpmPrefix(installDir) {
+  if (installDir) return installDir;
+  try {
+    const result = execaSync("npm", ["config", "get", "prefix", "--global"]);
+    const prefix = result.stdout.trim();
+    return prefix || "";
+  } catch {
+    return "";
+  }
+}
+function prefixOfInstalledEntry(entryPath) {
+  const match = /^(.+?)\/lib\/node_modules\/(?:@[^/]+\/)?[^/]+\//.exec(
+    entryPath.replace(/\\/g, "/")
+  );
+  return match?.[1];
+}
+function canonicalPath(value) {
+  try {
+    return fs3.realpathSync(value);
+  } catch {
+    return path3.resolve(value);
+  }
+}
+function resolveInstallPrefixTarget(args) {
+  if (args.installDir) return { prefix: args.installDir, source: "install-dir" };
+  const running = prefixOfInstalledEntry(args.entryPath);
+  const manifest = args.manifestPrefix || void 0;
+  if (running) {
+    if (manifest && canonicalPath(manifest) !== canonicalPath(running)) {
+      throw new Error(
+        `Error: this build runs from ${running} but install.json records ${manifest}. Upgrading either would leave the other unchanged. Pass --install-dir <dir> to choose.`
+      );
+    }
+    return { prefix: running, source: "running-entry" };
+  }
+  if (manifest) return { prefix: manifest, source: "manifest" };
+  return { prefix: (args.npmPrefix ?? resolveNpmPrefix)(), source: "npm-global" };
+}
+function detectPackageOnDisk(packageName, installDir) {
+  const prefix = resolveNpmPrefix(installDir);
+  if (!prefix) return false;
+  return fs3.existsSync(path3.join(prefix, "lib", "node_modules", packageName, "package.json"));
+}
+function readInstalledPackageVersion(packageName, installDir) {
+  const prefix = resolveNpmPrefix(installDir);
+  if (!prefix) return void 0;
+  try {
+    const packageJsonPath = path3.join(prefix, "lib", "node_modules", packageName, "package.json");
+    const parsed = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function snapshotInstallState(options) {
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const manifestPath = installManifestPath(options.homeDir);
+  let manifestBytes = null;
+  try {
+    if (fs3.existsSync(manifestPath)) {
+      manifestBytes = fs3.readFileSync(manifestPath, "utf8");
+    }
+  } catch {
+    manifestBytes = null;
+  }
+  return {
+    manifestPath,
+    manifestBytes,
+    packagePresent: detectPackageOnDisk(packageName, options.installDir),
+    packageVersion: readInstalledPackageVersion(packageName, options.installDir),
+    prefix: resolveNpmPrefix(options.installDir),
+    capturedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+  };
+}
+function preserveManifestBackup(snapshot, writeStderr) {
+  if (!snapshot.manifestBytes) return;
+  try {
+    const bakPath = `${snapshot.manifestPath}.bak`;
+    fs3.writeFileSync(bakPath, snapshot.manifestBytes, "utf8");
+    writeStderr?.(`Previous manifest preserved at ${bakPath}.
+`);
+  } catch {
+  }
+}
+function restoreManifestFromSnapshot(snapshot) {
+  if (snapshot.manifestBytes === null) {
+    try {
+      if (fs3.existsSync(snapshot.manifestPath)) {
+        fs3.unlinkSync(snapshot.manifestPath);
+      }
+    } catch {
+    }
+    return;
+  }
+  const dir = path3.dirname(snapshot.manifestPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const tmp = `${snapshot.manifestPath}.restore.${process.pid}.tmp`;
+  fs3.writeFileSync(tmp, snapshot.manifestBytes, "utf8");
+  fs3.renameSync(tmp, snapshot.manifestPath);
+}
+function detectSourceCheckout(options = {}) {
+  let entryPath = options.entryPath;
+  if (!entryPath) {
+    try {
+      entryPath = fileURLToPath(import.meta.url);
+    } catch {
+      entryPath = process.argv[1] ?? "";
+    }
+  }
+  const normalized = entryPath.replace(/\\/g, "/");
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const packageRoot = findPackageJson(path3.dirname(entryPath));
+  const hasTsx = process.argv.some((arg) => arg.includes("tsx")) || process.execArgv.some((arg) => arg.includes("tsx"));
+  let kind = "unknown";
+  if (hasTsx && !normalized.includes("/node_modules/")) {
+    kind = "development";
+  } else if (normalized.includes(`/node_modules/${packageName}/`)) {
+    try {
+      const real = fs3.realpathSync(entryPath).replace(/\\/g, "/");
+      if (real !== normalized && !real.includes("/node_modules/")) {
+        kind = "npm-link";
+      } else if (normalized.includes("/lib/node_modules/") || normalized.includes("/.nvm/") || normalized.includes("/volta/")) {
+        kind = "global";
+      } else {
+        kind = "package";
+      }
+    } catch {
+      kind = "package";
+    }
+  } else if (normalized.includes("/dist/") && !normalized.includes("/node_modules/")) {
+    kind = "repo-dist";
+  } else if (["/lib/node_modules/", "/.npm/", "/nvm/", "/volta/"].some((p) => normalized.includes(p))) {
+    kind = "global";
+  } else if (packageRoot) {
+    const rootDir = path3.dirname(packageRoot);
+    const hasSrc = fs3.existsSync(path3.join(rootDir, "src"));
+    const hasGit = fs3.existsSync(path3.join(rootDir, ".git"));
+    if (hasSrc && (hasGit || fs3.existsSync(path3.join(rootDir, "install.sh")))) {
+      kind = "source-checkout";
+    }
+  }
+  const isSourceLike = kind === "source-checkout" || kind === "npm-link" || kind === "repo-dist" || kind === "development";
+  const guidance = isSourceLike ? [
+    `This Build binary looks like a ${kind} (not a published package install).`,
+    "Refusing to default to the unpublished package channel from a source/link checkout.",
+    "Update from source instead:",
+    "  git pull",
+    "  ./scripts/compile-dist.sh",
+    "Do not run package-channel upgrade against a dirty source checkout.",
+    "If you intentionally want the published package, pass --source package --force after installing from npm."
+  ] : [];
+  return {
+    kind,
+    isSourceLike,
+    entryPath,
+    packageRoot: packageRoot ? path3.dirname(packageRoot) : void 0,
+    guidance
+  };
+}
+function defaultRunGitLsRemote(repoUrl, refspec) {
+  const patterns = refspec === void 0 ? [] : Array.isArray(refspec) ? refspec : [refspec];
+  return retryPastUrlRewriteOnDenial(
+    repoUrl,
+    (configArgs) => execGit([...configArgs, ...GH_CREDENTIAL_FALLBACK_ARGS, "ls-remote", repoUrl, ...patterns], {
+      cwd: os.tmpdir(),
+      timeoutMs: LS_REMOTE_TIMEOUT_MS
+    })
+  );
+}
+function defaultRunNpmViewVersion(packageName, ref) {
+  return execa3("npm", ["view", `${packageName}@${ref}`, "version"], { reject: false }).then(
+    (result) => ({
+      exitCode: result.exitCode ?? 1,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    })
+  );
+}
+
+// src/cli/commands/setup-temp-cleanup.ts
+var LABEL = "com.build.temp-cleanup";
+var WRAPPER_DIR = join(homedir(), ".build", "bin");
+var WRAPPER_PATH = join(WRAPPER_DIR, "build-cleanup");
+var PLIST_DIR = join(homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = join(PLIST_DIR, `${LABEL}.plist`);
+var LOG_DIR = join(homedir(), ".build", "logs");
+var LOG_OUT = join(LOG_DIR, "temp-cleanup.log");
+var LOG_ERR = join(LOG_DIR, "temp-cleanup-error.log");
+async function resolveBuildBinary() {
+  const prefix = readInstallManifestFromDisk()?.prefix;
+  if (prefix) {
+    const selectedBinary = join(prefix, "bin", "build");
+    if (existsSync(selectedBinary)) return selectedBinary;
+  }
+  const launcher = homeLauncherPath();
+  if (existsSync(launcher)) return launcher;
+  return null;
+}
+function shellUnescapeSingleQuoted(value) {
+  return value.replace(/'\\''/g, "'");
+}
+function buildCleanupArgs(config) {
+  const args = ["cleanup", "provider-temp", "--execute", "--silent"];
+  if (config.roots.length > 0) {
+    for (const root of config.roots) {
+      args.push("--root", root);
+    }
+  } else if (config.useDefaultRoots) {
+    args.push("--use-default-roots");
+  }
+  return args;
+}
+async function loadConfiguredRoots() {
+  try {
+    const { loadAllConfigSources } = await import("./config-loader-RGP634PC.js");
+    const { orderConfigSourcesLowestFirst } = await import("./config-merger-TVUJBZTS.js");
+    const sources = orderConfigSourcesLowestFirst(await loadAllConfigSources(process.cwd(), {}));
+    let roots = [];
+    for (const source of sources) {
+      const cleanup = source.data?.cleanup;
+      if (cleanup?.providerTemp?.roots?.length) {
+        roots = cleanup.providerTemp.roots;
+      }
+    }
+    return roots;
+  } catch {
+    return [];
+  }
+}
+async function resolveTargetConfig(options) {
+  if (options?.roots && options.roots.length > 0) {
+    return { roots: options.roots, useDefaultRoots: false };
+  }
+  if (options?.useDefaultRoots) {
+    return { roots: [], useDefaultRoots: true };
+  }
+  const configuredRoots = await loadConfiguredRoots();
+  if (configuredRoots.length > 0) {
+    return { roots: configuredRoots, useDefaultRoots: false };
+  }
+  return {
+    error: "No provider temp roots configured. Set cleanup.providerTemp.roots, or re-run with --use-default-roots or --root <path>."
+  };
+}
+function generateWrapper(buildBinary, targetConfig) {
+  const cleanupArgs = buildCleanupArgs(targetConfig).map((arg) => quotePosixShellArg(arg)).join(" ");
+  const invokeCmd = `exec "$BUILD_BIN" ${cleanupArgs}`;
+  const home = homedir();
+  return `#!/bin/bash
+# Build temp cleanup wrapper \u2014 managed by \`build cleanup temp-agent\`
+# Do not edit manually; re-run \`build cleanup temp-agent --install-launchagent\` to update.
+
+set -euo pipefail
+
+# LaunchAgents run with minimal environment \u2014 set HOME explicitly
+export HOME=${quotePosixShellArg(home)}
+
+# Verify the target binary exists; exit 0 (not 1) to avoid launchd backoff
+BUILD_BIN=${quotePosixShellArg(buildBinary)}
+if [ ! -x "$BUILD_BIN" ]; then
+  echo "$(date -Iseconds) build-cleanup: binary not found at $BUILD_BIN \u2014 skipping" >> ${quotePosixShellArg(LOG_ERR)} 2>/dev/null || true
+  exit 0
+fi
+
+${invokeCmd}
+`;
+}
+function generatePlist(intervalSeconds) {
+  const home = homedir();
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${WRAPPER_PATH}</string>
+  </array>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${home}</string>
+  </dict>
+
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>StandardOutPath</key>
+  <string>${LOG_OUT}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${LOG_ERR}</string>
+
+  <key>Nice</key>
+  <integer>10</integer>
+
+  <key>ProcessType</key>
+  <string>Background</string>
+</dict>
+</plist>
+`;
+}
+async function writeFileAtomic(filePath, content, mode) {
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tempPath, content, "utf8");
+    if (mode !== void 0) await chmod(tempPath, mode);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await unlink(tempPath).catch(() => void 0);
+    throw error;
+  }
+}
+async function restoreFile(filePath, prior, mode) {
+  if (prior === null) {
+    await unlink(filePath).catch(() => void 0);
+    return;
+  }
+  await writeFileAtomic(filePath, prior, mode);
+}
+async function unloadJob() {
+  const uid = process.getuid?.() ?? 501;
+  try {
+    await execa4("launchctl", ["bootout", `gui/${uid}`, PLIST_PATH], {
+      reject: false,
+      timeout: 1e4
+    });
+  } catch {
+  }
+}
+async function loadJob() {
+  const uid = process.getuid?.() ?? 501;
+  await execa4("launchctl", ["bootstrap", `gui/${uid}`, PLIST_PATH], {
+    timeout: 1e4
+  });
+}
+async function installTempCleanup(options) {
+  const effectiveIntervalMinutes = options?.intervalMinutes ?? 1440;
+  const intervalSeconds = effectiveIntervalMinutes * 60;
+  const buildBinary = await resolveBuildBinary();
+  if (!buildBinary) {
+    return {
+      installed: false,
+      updated: false,
+      message: "Could not resolve the Build binary. Reinstall Build, or run `build ci install-hook` to write the launcher under the Build home folder."
+    };
+  }
+  const targetConfig = await resolveTargetConfig(options);
+  if ("error" in targetConfig) {
+    return {
+      installed: false,
+      updated: false,
+      message: targetConfig.error
+    };
+  }
+  await mkdir(WRAPPER_DIR, { recursive: true });
+  await mkdir(PLIST_DIR, { recursive: true });
+  await mkdir(LOG_DIR, { recursive: true });
+  const wrapperContent = generateWrapper(buildBinary, targetConfig);
+  let wrapperChanged = true;
+  if (existsSync(WRAPPER_PATH)) {
+    const existing = await readFile(WRAPPER_PATH, "utf8");
+    wrapperChanged = existing !== wrapperContent;
+  }
+  const priorWrapper = existsSync(WRAPPER_PATH) ? await readFile(WRAPPER_PATH, "utf8") : null;
+  const plistContent = generatePlist(intervalSeconds);
+  let plistChanged = true;
+  if (existsSync(PLIST_PATH)) {
+    const existing = await readFile(PLIST_PATH, "utf8");
+    plistChanged = existing !== plistContent;
+  }
+  const priorPlist = existsSync(PLIST_PATH) ? await readFile(PLIST_PATH, "utf8") : null;
+  try {
+    if (wrapperChanged) await writeFileAtomic(WRAPPER_PATH, wrapperContent, 493);
+    if (plistChanged) await writeFileAtomic(PLIST_PATH, plistContent);
+    await unloadJob();
+    await loadJob();
+  } catch (err) {
+    await restoreFile(WRAPPER_PATH, priorWrapper, 493);
+    await restoreFile(PLIST_PATH, priorPlist);
+    if (priorPlist !== null) await loadJob().catch(() => void 0);
+    return {
+      installed: false,
+      updated: false,
+      message: `Failed to load LaunchAgent: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const updated = existsSync(PLIST_PATH) && (wrapperChanged || plistChanged);
+  return {
+    installed: true,
+    updated,
+    message: updated ? `LaunchAgent updated and loaded (interval: ${effectiveIntervalMinutes}m)` : `LaunchAgent installed and loaded (interval: ${effectiveIntervalMinutes}m)`
+  };
+}
+async function readInstalledTempCleanupOptions() {
+  if (!existsSync(WRAPPER_PATH) || !existsSync(PLIST_PATH)) return null;
+  try {
+    const [wrapper, plist] = await Promise.all([
+      readFile(WRAPPER_PATH, "utf8"),
+      readFile(PLIST_PATH, "utf8")
+    ]);
+    const execLine = wrapper.match(/^exec "\$BUILD_BIN" (.+)$/m)?.[1] ?? "";
+    const args = [...execLine.matchAll(/'((?:'\\''|[^'])*)'/g)].map(
+      (match) => shellUnescapeSingleQuoted(match[1] ?? "")
+    );
+    const roots = [];
+    for (let index = 0; index < args.length; index += 1) {
+      const root = args[index + 1];
+      if (args[index] === "--root" && root) roots.push(root);
+    }
+    const intervalSeconds = Number(
+      plist.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/)?.[1]
+    );
+    if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) return null;
+    return {
+      intervalMinutes: intervalSeconds / 60,
+      roots,
+      useDefaultRoots: args.includes("--use-default-roots")
+    };
+  } catch {
+    return null;
+  }
+}
+async function uninstallTempCleanup() {
+  let removed = false;
+  await unloadJob();
+  if (existsSync(PLIST_PATH)) {
+    await unlink(PLIST_PATH);
+    removed = true;
+  }
+  if (existsSync(WRAPPER_PATH)) {
+    await unlink(WRAPPER_PATH);
+    removed = true;
+  }
+  return {
+    removed,
+    message: removed ? "LaunchAgent and wrapper removed." : "LaunchAgent was not installed."
+  };
+}
+function parseWrapperPaths(content) {
+  const singleQuoted = "'((?:'\\\\''|[^'])*)'";
+  const binMatch = new RegExp(`^BUILD_BIN=${singleQuoted}$`, "m").exec(content) ?? /^BUILD_BIN="(.+)"$/m.exec(content);
+  const execMatch = new RegExp(`^exec ${singleQuoted} "\\$BUILD_BIN"(?:\\s|$)`, "m").exec(content) ?? /^exec "(.+)" "(.+)" /m.exec(content);
+  const binaryPath = binMatch?.[1] ? shellUnescapeSingleQuoted(binMatch[1]) : execMatch?.[2] ?? null;
+  const nodePath = execMatch?.[1] ? shellUnescapeSingleQuoted(execMatch[1]) : null;
+  return {
+    binaryPath,
+    nodePath
+  };
+}
+async function checkTempCleanupStatus() {
+  const wrapperExists = existsSync(WRAPPER_PATH);
+  const plistExists = existsSync(PLIST_PATH);
+  let jobLoaded = false;
+  try {
+    const result = await execa4("launchctl", ["list"], { timeout: 5e3 });
+    jobLoaded = result.stdout.includes(LABEL);
+  } catch {
+  }
+  let embeddedBinaryPath = null;
+  let embeddedBinaryExists = null;
+  let embeddedNodePath = null;
+  let embeddedNodeExists = null;
+  if (wrapperExists) {
+    try {
+      const wrapperContent = await readFile(WRAPPER_PATH, "utf8");
+      const { binaryPath, nodePath } = parseWrapperPaths(wrapperContent);
+      embeddedBinaryPath = binaryPath;
+      embeddedBinaryExists = binaryPath !== null ? existsSync(binaryPath) : null;
+      embeddedNodePath = nodePath;
+      embeddedNodeExists = nodePath !== null ? existsSync(nodePath) : null;
+    } catch {
+    }
+  }
+  const stale = (
+    // Partial install: one artifact is present without the other
+    wrapperExists !== plistExists || // Wrapper installed but unreadable or unparseable — can't validate its launcher
+    wrapperExists && embeddedBinaryPath === null || // Wrapper installed and parseable but one or both embedded paths are gone
+    embeddedBinaryExists === false || // Legacy wrappers pinned Node separately; retain that stale-path check.
+    embeddedNodeExists === false
+  );
+  return {
+    wrapperExists,
+    plistExists,
+    jobLoaded,
+    wrapperPath: WRAPPER_PATH,
+    plistPath: PLIST_PATH,
+    embeddedBinaryPath,
+    embeddedBinaryExists,
+    embeddedNodePath,
+    embeddedNodeExists,
+    stale
+  };
+}
+var __testOnly = {
+  buildCleanupArgs,
+  generateWrapper,
+  parseWrapperPaths,
+  resolveBuildBinary,
+  resolveTargetConfig,
+  generatePlist,
+  writeFileAtomic,
+  WRAPPER_PATH,
+  PLIST_PATH
+};
+
+export {
+  describeUpgradeError,
+  runCaptured,
+  renderUpgradeResult,
+  parseGitInstallTarget,
+  buildGitSourceTarball,
+  DEFAULT_PACKAGE,
+  acquireInstallLock,
+  resolveGitCommitSha,
+  resolvePackageVersionString,
+  packageInstallTarget,
+  gitInstallTarget,
+  writeInstallManifestAtomic,
+  readInstallManifestFromDisk,
+  findPackageJson,
+  resolveNpmPrefix,
+  resolveInstallPrefixTarget,
+  snapshotInstallState,
+  preserveManifestBackup,
+  restoreManifestFromSnapshot,
+  detectSourceCheckout,
+  defaultRunGitLsRemote,
+  defaultRunNpmViewVersion,
+  installTempCleanup,
+  readInstalledTempCleanupOptions,
+  uninstallTempCleanup,
+  checkTempCleanupStatus,
+  __testOnly
+};
+//# sourceMappingURL=chunk-CSIE4Y7C.js.map