@allocator-one/harness-cli 1.16.0 → 1.17.1

package/dist/chunk-67NX7MJ2.js

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+import {
+  resolveCacheHome
+} from "./chunk-BHBEIT5I.js";
+import {
+  CLI_VERSION,
+  OPERATOR_PACKAGE,
+  mountOperatorUnderInfraone,
+  named,
+  operatorMounted
+} from "./chunk-5THYIKLW.js";
+
+// src/core/stdio.ts
+var BROKEN_PIPE_CODES = /* @__PURE__ */ new Set(["EPIPE", "ERR_STREAM_DESTROYED"]);
+function guardBrokenPipes(streams = [process.stdout, process.stderr]) {
+  for (const stream of streams) {
+    stream.on("error", (error) => {
+      if (!BROKEN_PIPE_CODES.has(error.code ?? "")) throw error;
+    });
+  }
+}
+
+// src/core/upgrade.ts
+import { spawn, spawnSync } from "child_process";
+import {
+  accessSync,
+  constants,
+  existsSync,
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join, parse, sep } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@allocator-one/harness-cli";
+var PACKAGE_NAMES = [PACKAGE_NAME, OPERATOR_PACKAGE];
+var UPGRADE_INSTALL_SPEC = `${PACKAGE_NAME}@latest`;
+function upgradeInstallSpec(install) {
+  return `${install.packageName ?? PACKAGE_NAME}@latest`;
+}
+var UPDATE_CHECK_COMMAND = "__update-check";
+var REEXEC_SENTINEL = "HARNESS_UPGRADED";
+function latestUrl(packageName = PACKAGE_NAME) {
+  return `https://registry.npmjs.org/${packageName}/latest`;
+}
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var NPM_ROOT_TIMEOUT_MS = 15e3;
+var INSTALL_TIMEOUT_MS = 12e4;
+var LOCK_STALE_MS = NPM_ROOT_TIMEOUT_MS + INSTALL_TIMEOUT_MS + 6e4;
+function detectInstall(from = fileURLToPath(import.meta.url)) {
+  const unknown = {
+    kind: "unknown",
+    packageRoot: null,
+    nodeModules: null
+  };
+  if (from.split(sep).includes("_npx")) return { ...unknown, kind: "npx" };
+  const found = findPackageRoot(from);
+  if (found === null) return unknown;
+  const { packageRoot, packageName } = found;
+  if (existsSync(join(packageRoot, ".git"))) {
+    return { kind: "checkout", packageRoot, packageName, nodeModules: null };
+  }
+  const nodeModules = enclosingNodeModules(packageRoot);
+  if (nodeModules === null) return { ...unknown, packageRoot, packageName };
+  const kind = existsSync(join(nodeModules, ".bin")) ? "local" : "global";
+  return { kind, packageRoot, packageName, nodeModules };
+}
+function findPackageRoot(from) {
+  let dir = dirname(from);
+  const { root } = parse(dir);
+  for (; ; ) {
+    const name = packageNameAt(join(dir, "package.json"));
+    if (name !== null && PACKAGE_NAMES.includes(name))
+      return { packageRoot: dir, packageName: name };
+    if (dir === root) return null;
+    dir = dirname(dir);
+  }
+}
+function packageNameAt(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const name = parsed["name"];
+    return typeof name === "string" ? name : null;
+  } catch {
+    return null;
+  }
+}
+function versionAt(packageRoot) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(join(packageRoot, "package.json"), "utf8")
+    );
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const version = parsed["version"];
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+function enclosingNodeModules(packageRoot) {
+  let dir = dirname(packageRoot);
+  const { root } = parse(dir);
+  for (; ; ) {
+    if (basename(dir) === "node_modules") return dir;
+    if (dir === root) return null;
+    dir = dirname(dir);
+  }
+}
+var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(value) {
+  const match = SEMVER.exec(value.trim());
+  if (match === null) return null;
+  return {
+    parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ?? null
+  };
+}
+function isNewer(candidate, current) {
+  const a = parseVersion(candidate);
+  const b = parseVersion(current);
+  if (a === null || b === null) return false;
+  for (let index = 0; index < 3; index++) {
+    if (a.parts[index] !== b.parts[index])
+      return a.parts[index] > b.parts[index];
+  }
+  if (a.pre === b.pre) return false;
+  if (a.pre === null) return true;
+  if (b.pre === null) return false;
+  return comparePrerelease(a.pre, b.pre) > 0;
+}
+function comparePrerelease(left, right) {
+  const a = left.split(".");
+  const b = right.split(".");
+  for (let index = 0; index < Math.max(a.length, b.length); index++) {
+    const x = a[index];
+    const y = b[index];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xNumeric = /^\d+$/.test(x);
+    const yNumeric = /^\d+$/.test(y);
+    if (xNumeric && yNumeric) {
+      if (Number(x) !== Number(y)) return Number(x) < Number(y) ? -1 : 1;
+    } else if (xNumeric !== yNumeric) {
+      return xNumeric ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function stampPath(env = process.env, packageName = PACKAGE_NAME) {
+  const file = packageName === PACKAGE_NAME ? "update-check.json" : `update-check-${packageName.replace(/^@[^/]+\//, "")}.json`;
+  return join(resolveCacheHome(env), "harness", file);
+}
+function readStamp(env = process.env, packageName = PACKAGE_NAME) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(stampPath(env, packageName), "utf8")
+    );
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed;
+    const checkedAt = record["checkedAt"];
+    if (typeof checkedAt !== "number" || !Number.isFinite(checkedAt))
+      return null;
+    const latest = record["latest"];
+    return { checkedAt, latest: typeof latest === "string" ? latest : null };
+  } catch {
+    return null;
+  }
+}
+function writeStamp(stamp, env = process.env, packageName = PACKAGE_NAME) {
+  const path = stampPath(env, packageName);
+  const temporary = `${path}.${process.pid}.tmp`;
+  const latest = stamp.latest ?? readStamp(env, packageName)?.latest ?? null;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(temporary, JSON.stringify({ ...stamp, latest }) + "\n");
+    renameSync(temporary, path);
+  } catch {
+    try {
+      rmSync(temporary, { force: true });
+    } catch {
+    }
+  }
+}
+function updateCheck(options = {}) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? Date.now();
+  if (!checksEnabled(env)) return null;
+  const install = options.install ?? detectInstall();
+  if (install.kind !== "global" && install.kind !== "local") return null;
+  const packageName = install.packageName ?? PACKAGE_NAME;
+  const stamp = readStamp(env, packageName);
+  if (stamp === null || now - stamp.checkedAt >= CHECK_INTERVAL_MS) {
+    writeStamp({ checkedAt: now, latest: stamp?.latest ?? null }, env, packageName);
+    (options.refresh ?? spawnRefresh)();
+  }
+  if (stamp !== null && stamp.latest !== null && isNewer(stamp.latest, CLI_VERSION)) {
+    return `harness: ${stamp.latest} is available (you have ${CLI_VERSION}) \u2014 ${upgradeHint(install)}
+`;
+  }
+  return null;
+}
+function upgradeHint(install) {
+  return install.kind === "local" ? `npm i ${upgradeInstallSpec(install)}` : `npm i -g ${upgradeInstallSpec(install)}`;
+}
+function spawnRefresh() {
+  const self = process.argv[1];
+  if (self === void 0 || self === "") return;
+  try {
+    const child = spawn(process.execPath, [self, UPDATE_CHECK_COMMAND], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function performUpdateCheck(env = process.env, now = Date.now(), packageName = detectInstall().packageName ?? PACKAGE_NAME) {
+  if (!checksEnabled(env)) return;
+  writeStamp(
+    { checkedAt: now, latest: await fetchLatestVersion(env, packageName) },
+    env,
+    packageName
+  );
+}
+async function fetchLatestVersion(env, packageName) {
+  const configured = env["HARNESS_REGISTRY_URL"];
+  const url = configured !== void 0 && configured.trim() !== "" ? configured.trim() : latestUrl(packageName);
+  try {
+    const response = await fetch(url, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    const parsed = await response.json();
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const version = parsed["version"];
+    if (typeof version !== "string" || parseVersion(version) === null)
+      return null;
+    return version;
+  } catch {
+    return null;
+  }
+}
+function selfHeal(options = {}) {
+  const env = options.env ?? process.env;
+  const argv = options.argv ?? process.argv;
+  if (truthy(env[REEXEC_SENTINEL])) {
+    return {
+      kind: "skipped",
+      reason: "already upgraded once for this command"
+    };
+  }
+  if (!autoUpgradeEnabled(env))
+    return { kind: "skipped", reason: "automatic upgrades are off" };
+  if (argv[2] === "mcp")
+    return {
+      kind: "skipped",
+      reason: "an MCP session must not be replaced mid-stream"
+    };
+  const install = options.install ?? detectInstall();
+  if (install.kind !== "global" || install.packageRoot === null) {
+    return { kind: "skipped", reason: describeInstall(install.kind) };
+  }
+  const packageRoot = install.packageRoot;
+  const installed = versionAt(packageRoot);
+  if (installed !== null && isNewer(installed, CLI_VERSION)) {
+    return { kind: "upgraded", code: reexec(options, env, argv) };
+  }
+  const lock = takeLock(env);
+  if (lock === null)
+    return {
+      kind: "skipped",
+      reason: "another harness process is already upgrading"
+    };
+  try {
+    const stillHeld = () => readHolder(lock.path)?.pid === lock.pid;
+    const result = (options.runInstall ?? npmInstallGlobal)(install, stillHeld);
+    if (!result.ok) return { kind: "failed", reason: result.detail };
+    const after = versionAt(packageRoot);
+    if (after !== null && after === installed) {
+      return {
+        kind: "failed",
+        reason: `still ${after} after upgrading \u2014 no newer release is published`
+      };
+    }
+    if (after !== null && installed !== null && !isNewer(after, installed)) {
+      return {
+        kind: "failed",
+        reason: `npm left ${after} installed, which is not newer than ${installed}`
+      };
+    }
+  } finally {
+    releaseLock(lock);
+  }
+  return { kind: "upgraded", code: reexec(options, env, argv) };
+}
+function reexec(options, env, argv) {
+  return (options.reexec ?? reexecSelf)(
+    { ...env, [REEXEC_SENTINEL]: "1" },
+    argv
+  );
+}
+function describeInstall(kind) {
+  switch (kind) {
+    case "checkout":
+      return "this is a git checkout, not an npm install";
+    case "local":
+      return "this copy is a project dependency, not a global install";
+    case "npx":
+      return "npx runs a throwaway copy";
+    default:
+      return "cannot tell how this CLI was installed";
+  }
+}
+function npmInstallGlobal(install, stillHeld) {
+  const globalRoot = npmGlobalRoot();
+  if (globalRoot === null)
+    return { ok: false, detail: "npm did not say where its global root is" };
+  if (globalRoot.includes("***")) {
+    return {
+      ok: false,
+      detail: "npm redacted its own global root, so this copy's location cannot be confirmed"
+    };
+  }
+  if (install.nodeModules === null || !samePath(globalRoot, install.nodeModules)) {
+    return {
+      ok: false,
+      detail: `this copy lives in ${install.nodeModules ?? "an unrecognized place"}, not npm's global root (${globalRoot})`
+    };
+  }
+  try {
+    accessSync(globalRoot, constants.W_OK);
+  } catch {
+    return {
+      ok: false,
+      detail: `${globalRoot} is not writable \u2014 upgrade it yourself`
+    };
+  }
+  if (!stillHeld()) {
+    return {
+      ok: false,
+      detail: "lost the upgrade lock while preparing \u2014 another process took over"
+    };
+  }
+  process.stderr.write(
+    named(`harness: upgrading ${install.packageName ?? PACKAGE_NAME} \u2026
+`)
+  );
+  const args = [
+    "install",
+    "--global",
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--no-update-notifier",
+    "--loglevel=error",
+    upgradeInstallSpec(install)
+  ];
+  const result = spawnSync(npmCommand(), args, {
+    // npm's diagnostics belong on stderr with ours; stdout stays the
+    // command's own, so its summary is dropped rather than piped into jq.
+    stdio: ["ignore", "ignore", "inherit"],
+    timeout: INSTALL_TIMEOUT_MS,
+    ...npmSpawnOptions()
+  });
+  if (result.error !== void 0)
+    return { ok: false, detail: result.error.message };
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      detail: `npm install exited ${result.status ?? `on ${String(result.signal)}`}`
+    };
+  }
+  return { ok: true, detail: "" };
+}
+function npmGlobalRoot() {
+  try {
+    const result = spawnSync(npmCommand(), ["root", "--global"], {
+      encoding: "utf8",
+      timeout: NPM_ROOT_TIMEOUT_MS,
+      ...npmSpawnOptions()
+    });
+    if (result.status !== 0 || typeof result.stdout !== "string") return null;
+    const path = result.stdout.trim();
+    return path === "" ? null : path;
+  } catch {
+    return null;
+  }
+}
+function npmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function npmSpawnOptions() {
+  return process.platform === "win32" ? { shell: true } : {};
+}
+function samePath(left, right) {
+  const resolve = (path) => {
+    try {
+      return realpathSync(path);
+    } catch {
+      return path;
+    }
+  };
+  return resolve(left) === resolve(right);
+}
+function reexecSelf(env, argv) {
+  const self = argv[1];
+  if (self === void 0) return 1;
+  const result = spawnSync(process.execPath, [self, ...argv.slice(2)], {
+    stdio: "inherit",
+    env
+  });
+  if (result.error !== void 0) {
+    process.stderr.write(
+      named(`harness: upgraded, but re-running failed: ${result.error.message}
+`)
+    );
+    return 1;
+  }
+  return result.status ?? 1;
+}
+function takeLock(env) {
+  const path = join(resolveCacheHome(env), "harness", "upgrade.lock");
+  const temporary = `${path}.${process.pid}.tmp`;
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(temporary, `${process.pid}
+`);
+  } catch {
+    return null;
+  }
+  try {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        linkSync(temporary, path);
+        return { path, pid: process.pid };
+      } catch {
+        const holder = readHolder(path);
+        if (holder === null) continue;
+        const aged = Date.now() - holder.mtimeMs > LOCK_STALE_MS;
+        const abandoned = holder.pid === null ? aged : !running(holder.pid) || aged;
+        if (!abandoned) return null;
+        try {
+          rmSync(path, { force: true });
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  } finally {
+    try {
+      rmSync(temporary, { force: true });
+    } catch {
+    }
+  }
+}
+function releaseLock(lock) {
+  try {
+    if (readHolder(lock.path)?.pid !== lock.pid) return;
+    rmSync(lock.path, { force: true });
+  } catch {
+  }
+}
+function readHolder(path) {
+  try {
+    const mtimeMs = statSync(path).mtimeMs;
+    const pid = Number.parseInt(readFileSync(path, "utf8").trim(), 10);
+    return { pid: Number.isInteger(pid) && pid > 0 ? pid : null, mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function running(pid) {
+  if (pid === null) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function truthy(value) {
+  if (value === void 0) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+function checksEnabled(env) {
+  return !truthy(env["CI"]) && !truthy(env["HARNESS_NO_UPDATE_CHECK"]);
+}
+function autoUpgradeEnabled(env) {
+  if (!checksEnabled(env)) return false;
+  const explicit = env["HARNESS_AUTO_UPGRADE"];
+  if (explicit !== void 0 && explicit.trim() !== "") return truthy(explicit);
+  return true;
+}
+
+// src/commands/operator-mount.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function runOperatorMount(args) {
+  mountOperatorUnderInfraone();
+  process.argv = [process.execPath, fileURLToPath2(new URL("./cli.js", import.meta.url)), ...args];
+  await import("./cli.js");
+  return process.exit(0);
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function deprecationStampPath(env = process.env) {
+  return join2(resolveCacheHome(env), "harness", "operator-deprecation.json");
+}
+function operatorDeprecationNotice(options = {}) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? Date.now();
+  if (operatorMounted() || !checksEnabled(env)) return null;
+  const path = deprecationStampPath(env);
+  const shownAt = readShownAt(path);
+  if (shownAt !== null && now - shownAt < DAY_MS && now >= shownAt) return null;
+  writeShownAt(path, now);
+  return "operator: the operator command is now `infraone operator`, with the same commands and login (npm i -g @allocator-one/infraone); operator keeps working for now\n";
+}
+function readShownAt(path) {
+  try {
+    const shownAt = JSON.parse(readFileSync2(path, "utf8"))["shownAt"];
+    return typeof shownAt === "number" && Number.isFinite(shownAt) ? shownAt : null;
+  } catch {
+    return null;
+  }
+}
+function writeShownAt(path, now) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  try {
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(temporary, JSON.stringify({ shownAt: now }) + "\n");
+    renameSync2(temporary, path);
+  } catch {
+    try {
+      rmSync2(temporary, { force: true });
+    } catch {
+    }
+  }
+}
+
+export {
+  guardBrokenPipes,
+  UPDATE_CHECK_COMMAND,
+  updateCheck,
+  performUpdateCheck,
+  selfHeal,
+  runOperatorMount,
+  operatorDeprecationNotice
+};