@vltpkg/cli-js 1.5.0 → 1.6.0

package/chunk-JV5XR5JQ.js

@@ -0,0 +1,349 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  rimraf
+} from "./chunk-PDWPFR5T.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../src/rollback-remove/src/index.ts
+import { spawn } from "node:child_process";
+import { rename } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+
+// ../../src/rollback-remove/src/remove.ts
+import { resolve } from "node:path";
+var __CODE_SPLIT_SCRIPT_NAME = resolve(import.meta.dirname, "rollback-remove-src-remove.js");
+
+// ../../src/rollback-remove/src/index.ts
+var isDeno = globalThis.Deno != void 0;
+var RollbackRemove = class {
+  #key = String(Math.random()).substring(2);
+  #paths = /* @__PURE__ */ new Map();
+  async rm(path) {
+    if (this.#paths.has(path)) return;
+    const target = `${dirname(path)}/.VLT.DELETE.${this.#key}.${basename(path)}`;
+    try {
+      await rename(path, target);
+    } catch (e) {
+      if (e instanceof Error && "code" in e && /* c8 ignore start - very spurious weirdness on Windows */
+      (e.code === "ENOENT" || e.code === "EPERM")) {
+        return;
+      }
+      throw e;
+    }
+    this.#paths.set(path, target);
+  }
+  confirm() {
+    if (!this.#paths.size) return;
+    const env = { ...process.env };
+    const args = [];
+    const detached = !(isDeno && process.platform === "win32");
+    if (isDeno) {
+      args.push(
+        "--unstable-node-globals",
+        "--unstable-bare-node-builtins"
+      );
+    }
+    args.push(__CODE_SPLIT_SCRIPT_NAME);
+    const child = spawn(process.execPath, args, {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached,
+      env
+    });
+    for (const path of this.#paths.values()) {
+      child.stdin.write(`${path}\0`);
+    }
+    child.stdin.end();
+    if (detached) {
+      child.unref();
+    }
+    this.#paths.clear();
+  }
+  async rollback() {
+    const promises = [];
+    for (const [original, moved] of this.#paths) {
+      promises.push(
+        rimraf(original).catch(() => {
+        }).then(() => rename(moved, original))
+      );
+    }
+    await Promise.all(promises);
+    this.#paths.clear();
+  }
+};
+
+// ../../src/cmd-shim/src/read.ts
+import { lstat, readFile, readlink } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+
+// ../../src/cmd-shim/src/paths.ts
+var paths = process.platform === "win32" ? (path) => [
+  path + ".cmd",
+  path + ".ps1",
+  path,
+  path + ".pwsh"
+] : (path) => [path];
+
+// ../../src/cmd-shim/src/read.ts
+var extractPath = (path, cmdshimContents) => {
+  if (/\.cmd$/i.test(path)) {
+    return extractPathFromCmd(cmdshimContents);
+  } else if (/\.(ps1|pwsh)$/i.test(path)) {
+    return extractPathFromPowershell(cmdshimContents);
+  } else {
+    return extractPathFromCygwin(cmdshimContents);
+  }
+};
+var extractPathFromPowershell = (cmdshimContents) => {
+  const matches = /"(?:[$]basedir\/|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+[$]args/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var extractPathFromCmd = (cmdshimContents) => {
+  const matches = /"(?:%(?:~dp0|dp0%)\\|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+%[*]/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var extractPathFromCygwin = (cmdshimContents) => {
+  const matches = /"(?:[$]basedir\/|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+"[$]@"/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var findCmdShimIfExists = async (path) => {
+  path = path.replace(/\.(cmd|pwsh|ps1)$/i, "");
+  for (const p of paths(path)) {
+    const result = await readCmdShimIfExists(p);
+    if (result) return [p, result];
+  }
+};
+var readCmdShimIfExists = async (path) => {
+  try {
+    const st = await lstat(path);
+    if (st.isSymbolicLink()) {
+      return resolve2(dirname2(path), await readlink(path));
+    }
+    const contents = await readFile(path);
+    const destination = extractPath(path, contents.toString());
+    if (destination) return resolve2(dirname2(path), destination);
+  } catch {
+  }
+};
+
+// ../../src/cmd-shim/src/index.ts
+import {
+  chmod,
+  mkdir,
+  readFile as readFile2,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname3, isAbsolute, relative } from "node:path";
+
+// ../../src/cmd-shim/src/to-batch-syntax.ts
+var convertToSetCommand = (key, value) => convertToSetCommand_(key.trim(), value.trim());
+var convertToSetCommand_ = (key, value) => key && value ? `@SET ${key}=${replaceDollarWithPercentPair(value)}\r
+` : "";
+var extractVariableValuePairs = (declarations) => declarations.reduce(
+  (pairs, declaration) => {
+    const [key = "", val = ""] = declaration.split("=");
+    pairs[key] = val;
+    return pairs;
+  },
+  {}
+);
+var convertToSetCommands = (variableString) => Object.entries(extractVariableValuePairs(variableString.split(" "))).map(([key, val]) => convertToSetCommand(key, val)).join("");
+var replaceDollarWithPercentPair = (value) => {
+  const dollarExpressions = /\$\{?([^$@#?\- \t{}:]+)\}?/g;
+  let result = "";
+  let startIndex = 0;
+  do {
+    const match = dollarExpressions.exec(value);
+    if (match) {
+      const betweenMatches = value.substring(startIndex, match.index) || "";
+      result += betweenMatches + "%" + String(match[1]) + "%";
+      startIndex = dollarExpressions.lastIndex;
+    }
+  } while (dollarExpressions.lastIndex > 0);
+  result += value.slice(startIndex);
+  return result;
+};
+
+// ../../src/cmd-shim/src/index.ts
+var shebangExpr = /^#!\s*(?:\/usr\/bin\/env\s+(?:-S\s+)?((?:[^ \t=]+=[^ \t=]+\s+)*))?([^ \t]+)(.*)$/;
+var cmdShimIfExists = async (from, to, remover) => {
+  try {
+    await stat(from);
+  } catch {
+    return;
+  }
+  await writeShim(from, to, remover);
+};
+var cmdShim = async (from, to, remover) => {
+  try {
+    await stat(from);
+    await writeShim(from, to, remover);
+  } catch (er) {
+    throw error("Could not shim to executable file", {
+      path: from,
+      target: to,
+      cause: er
+    });
+  }
+};
+var writeShim = async (from, to, remover) => {
+  await Promise.all([
+    remover.rm(to),
+    remover.rm(to + ".cmd"),
+    remover.rm(to + ".ps1"),
+    remover.rm(to + ".pwsh")
+  ]);
+  await mkdir(dirname3(to), { recursive: true });
+  const data = await readFile2(from, "utf8").catch(() => "");
+  if (!data) {
+    return await writeShim_(from, to);
+  }
+  const firstLine = data.trim().split(/\r*\n/)[0];
+  const shebang = firstLine?.match(shebangExpr) ?? void 0;
+  return writeShim_(
+    from,
+    to,
+    shebang?.[2],
+    shebang?.[3],
+    shebang?.[1]
+  );
+};
+var writeShim_ = async (from, to, prog, args, variables) => {
+  let shTarget = relative(dirname3(to), from);
+  const [dp0, basedir] = isAbsolute(shTarget) ? ["", ""] : ["%dp0%\\", "$basedir/"];
+  let target = shTarget.split("/").join("\\");
+  let longProg;
+  let shProg = prog?.split("\\").join("/");
+  let shLongProg;
+  let pwshProg = shProg && `"${shProg}$exe"`;
+  let pwshLongProg;
+  shTarget = shTarget.split("\\").join("/");
+  args = args || "";
+  variables = variables || "";
+  if (!prog) {
+    prog = `"${dp0}${target}"`;
+    shProg = `"${basedir}${shTarget}"`;
+    pwshProg = shProg;
+    args = "";
+    target = "";
+    shTarget = "";
+  } else {
+    longProg = `"%dp0%\\${prog}.exe"`;
+    shLongProg = `"$basedir/${prog}"`;
+    pwshLongProg = `"$basedir/${prog}$exe"`;
+    target = `"${dp0}${target}"`;
+    shTarget = `"${basedir}${shTarget}"`;
+  }
+  const head = "@ECHO off\r\nGOTO start\r\n:find_dp0\r\nSET dp0=%~dp0\r\nEXIT /b\r\n:start\r\nSETLOCAL\r\nCALL :find_dp0\r\n";
+  let cmd;
+  if (longProg) {
+    shLongProg = (shLongProg ?? "").trim();
+    args = args.trim();
+    const variablesBatch = convertToSetCommands(variables);
+    cmd = `${head}${variablesBatch}\r
+IF EXIST ${longProg} (\r
+  SET "_prog=${longProg.replace(/(^")|("$)/g, "")}"\r
+) ELSE (\r
+  SET "_prog=${prog.replace(/(^")|("$)/g, "")}"\r
+  SET PATHEXT=%PATHEXT:;.JS;=;%\r
+)\r
+\r
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" ${args} ${target} %*\r
+`;
+  } else {
+    cmd = `${head}${prog} ${args} ${target} %*\r
+`;
+  }
+  let sh = `#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')")
+
+case \`uname\` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=\`cygpath -w "$basedir"\`
+        fi
+    ;;
+esac
+
+`;
+  if (shLongProg) {
+    sh += `if [ -x ${shLongProg} ]; then
+  exec ${variables}${shLongProg} ${args} ${shTarget} "$@"
+else 
+  exec ${variables}${shProg} ${args} ${shTarget} "$@"
+fi
+`;
+  } else {
+    sh += `exec ${shProg} ${args} ${shTarget} "$@"
+`;
+  }
+  let pwsh = '#!/usr/bin/env pwsh\n$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent\n\n$exe=""\nif ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {\n  # Fix case when both the Windows and Linux builds of Node\n  # are installed in the same directory\n  $exe=".exe"\n}\n';
+  if (shLongProg) {
+    pwsh += `$ret=0
+if (Test-Path ${pwshLongProg}) {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshLongProg} ${args} ${shTarget} $args
+  } else {
+    & ${pwshLongProg} ${args} ${shTarget} $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshProg} ${args} ${shTarget} $args
+  } else {
+    & ${pwshProg} ${args} ${shTarget} $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
+`;
+  } else {
+    pwsh += `# Support pipeline input
+if ($MyInvocation.ExpectingInput) {
+  $input | & ${pwshProg} ${args} ${shTarget} $args
+} else {
+  & ${pwshProg} ${args} ${shTarget} $args
+}
+exit $LASTEXITCODE
+`;
+  }
+  await Promise.all([
+    writeFile(to + ".cmd", cmd, "utf8"),
+    writeFile(to + ".ps1", pwsh, "utf8"),
+    writeFile(to, sh, "utf8")
+  ]);
+  await chmodShim(to);
+};
+var chmodShim = async (to) => await Promise.all([
+  chmod(to, 493),
+  chmod(to + ".cmd", 493),
+  chmod(to + ".ps1", 493)
+]);
+
+export {
+  findCmdShimIfExists,
+  readCmdShimIfExists,
+  cmdShimIfExists,
+  cmdShim,
+  RollbackRemove
+};

package/{chunk-IJUVVD7E.js → chunk-KD5ZK72K.js}

@@ -11,7 +11,7 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   getId
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 
 // ../../src/cli-sdk/src/stub-node.ts
 var createStubNode = (spec, name, version, options) => ({

package/{chunk-WHWPAYZY.js → chunk-KVWGMSPW.js}

@@ -12,28 +12,34 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   generateDefaultHelp,
   generateFullHelp
-} from "./chunk-X6JKMIOU.js";
+} from "./chunk-LGQVZTYR.js";
 import {
   parseError
-} from "./chunk-4TSHLSRK.js";
+} from "./chunk-EYGOEAJM.js";
 import {
   isLazyView,
   isViewClass,
   loadLazyView
 } from "./chunk-4KCU2KZL.js";
+import {
+  sweepPendingRemove
+} from "./chunk-GCTREKA4.js";
+import {
+  globalCommands
+} from "./chunk-MCDLJZXT.js";
 import {
   hasConfiguredRegistry,
   hasNpmRegistry,
   missingNpmRegistryError,
   missingRegistryError
-} from "./chunk-UZ6ICZE3.js";
+} from "./chunk-7M2VTFLP.js";
 import {
   defaultView
-} from "./chunk-CMLDLZZ3.js";
+} from "./chunk-EFHOWRKU.js";
 import {
   isGraphRunError,
   splitDepID
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   emitter
 } from "./chunk-B6RIGNEO.js";
@@ -43,7 +49,10 @@ import {
 import {
   isErrorWithCause,
   isObject
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
 
 // ../../src/cli-sdk/src/print-err.ts
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -665,6 +674,16 @@ var outputCommand = async (cliCommand, conf, { start, vltVersion } = {
   const telemetryEnabled = conf.values.telemetry;
   const commandName = conf.command;
   try {
+    if (conf.explicit.global && !conf.globalRoot) {
+      throw error(
+        `\`vlt ${conf.command}\` does not support --global`,
+        {
+          code: "EUSAGE",
+          found: conf.command,
+          validOptions: [...globalCommands]
+        }
+      );
+    }
     if (needsRegistry && !hasConfiguredRegistry(conf)) {
       throw missingRegistryError();
     }
@@ -673,6 +692,7 @@ var outputCommand = async (cliCommand, conf, { start, vltVersion } = {
         conf.options["default-registry-alias"]
       );
     }
+    if (conf.globalRoot) await sweepPendingRemove(conf.globalRoot);
     const output = await onDone(await command(conf));
     stopRequestLog();
     const duration_ms = Date.now() - start;

package/{chunk-VR7NRWAD.js → chunk-LCLRP64K.js}

@@ -17,19 +17,19 @@ import {
   pickManifest,
   resolve,
   revs
-} from "./chunk-IFEZ6BFV.js";
+} from "./chunk-EMTGRCSE.js";
 import {
   Monorepo,
   PackageJson
-} from "./chunk-C6ZVVEFV.js";
+} from "./chunk-TQQO2F56.js";
 import {
   Spec
-} from "./chunk-LUVDMEW4.js";
+} from "./chunk-6D3QAFNZ.js";
 import {
   registryErrorMessage,
   storeRoot,
   tokenRefusalAdvice
-} from "./chunk-5KW6AOTT.js";
+} from "./chunk-4GMNWW4C.js";
 import {
   logRequest
 } from "./chunk-B6RIGNEO.js";
@@ -41,7 +41,7 @@ import {
   brotliTarballUrl,
   integrityHex,
   tarballFormat
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -338,7 +338,7 @@ var PackageInfoClient = class {
   }
   async getRegistryClient() {
     if (this.#registryClient) return this.#registryClient;
-    this.#registryClientPromise ??= import("./src-H6DFCAPH.js").then(({ RegistryClient }) => {
+    this.#registryClientPromise ??= import("./src-QO5G2S4O.js").then(({ RegistryClient }) => {
       this.#registryClient = new RegistryClient(this.options);
       return this.#registryClient;
     });
@@ -377,7 +377,7 @@ var PackageInfoClient = class {
   }
   async getTarPool() {
     if (this.#tarPool) return this.#tarPool;
-    this.#tarPoolPromise ??= import("./src-LHDC4NJO.js").then(
+    this.#tarPoolPromise ??= import("./src-W2VQULRG.js").then(
       ({ Pool }) => {
         this.#tarPool = new Pool();
         return this.#tarPool;
@@ -593,7 +593,7 @@ var PackageInfoClient = class {
       }
       case "remote": {
         const rc = await this.getRegistryClient();
-        const { CacheEntry: Entry, cacheKey } = await import("./src-H6DFCAPH.js");
+        const { CacheEntry: Entry, cacheKey } = await import("./src-QO5G2S4O.js");
         const key = cacheKey("GET", new URL(r.resolved));
         const unzipped = (entry) => {
           try {

package/{chunk-X6JKMIOU.js → chunk-LGQVZTYR.js}

@@ -12,43 +12,12 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   source_default
 } from "./chunk-WGDTG44V.js";
+import {
+  loadPackageJson
+} from "./chunk-E74WGW5C.js";
 import {
   commandAliases
-} from "./chunk-CMLDLZZ3.js";
-
-// ../../node_modules/.vlt/~npm~package-json-from-dist@1.0.1/node_modules/package-json-from-dist/dist/esm/index.js
-import { readFileSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-var NM = `${sep}node_modules${sep}`;
-var STORE = `.store${sep}`;
-var PKG = `${sep}package${sep}`;
-var DIST = `${sep}dist${sep}`;
-var findPackageJson = (from, pathFromSrc = "../package.json") => {
-  const f = typeof from === "object" || from.startsWith("file://") ? fileURLToPath(from) : from;
-  const __dirname = dirname(f);
-  const nms = __dirname.lastIndexOf(NM);
-  if (nms !== -1) {
-    const nm = __dirname.substring(0, nms + NM.length);
-    const pkgDir = __dirname.substring(nms + NM.length);
-    if (pkgDir.startsWith(STORE)) {
-      const pkg = pkgDir.indexOf(PKG, STORE.length);
-      if (pkg) {
-        return resolve(nm, pkgDir.substring(0, pkg + PKG.length), "package.json");
-      }
-    }
-    const pkgName = pkgDir.startsWith("@") ? pkgDir.split(sep, 2).join(sep) : String(pkgDir.split(sep)[0]);
-    return resolve(nm, pkgName, "package.json");
-  } else {
-    const d = __dirname.lastIndexOf(DIST);
-    if (d !== -1) {
-      return resolve(__dirname.substring(0, d), "package.json");
-    } else {
-      return resolve(__dirname, pathFromSrc);
-    }
-  }
-};
-var loadPackageJson = (from, pathFromSrc = "../package.json") => JSON.parse(readFileSync(findPackageJson(from, pathFromSrc), "utf8"));
+} from "./chunk-EFHOWRKU.js";
 
 // ../../src/cli-sdk/src/custom-help.ts
 var { version } = loadPackageJson(
@@ -407,7 +376,6 @@ ${s("dim", `Run \`vlt help <command>\` for detailed information about a specific
 };
 
 export {
-  loadPackageJson,
   generateDefaultHelp,
   generateFullHelp
 };