@vltpkg/cli-js 1.5.0 → 1.6.0

package/{chunk-XCQCYB6G.js → chunk-LP3ORD3D.js}

@@ -11,12 +11,17 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   PackageInfoClient
-} from "./chunk-VR7NRWAD.js";
+} from "./chunk-LCLRP64K.js";
 import {
   Monorepo,
   PackageJson,
-  PathScurry
-} from "./chunk-C6ZVVEFV.js";
+  PathScurry,
+  workspaceCache
+} from "./chunk-TQQO2F56.js";
+import {
+  ensureGlobalProject,
+  globalCommands
+} from "./chunk-MCDLJZXT.js";
 import {
   commands,
   defaultValues,
@@ -25,19 +30,20 @@ import {
   isRecordField,
   recordFields,
   storeLinkers
-} from "./chunk-CMLDLZZ3.js";
+} from "./chunk-EFHOWRKU.js";
 import {
   resetCaches
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   find,
   load,
   reload,
-  save
+  save,
+  unload
 } from "./chunk-HTOTG4TS.js";
 import {
   storeRoot
-} from "./chunk-5KW6AOTT.js";
+} from "./chunk-4GMNWW4C.js";
 import {
   cloneAvailable
 } from "./chunk-6IF3RJND.js";
@@ -51,14 +57,15 @@ import {
   getOptions,
   isObject,
   isRecordStringString
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
 
 // ../../src/cli-sdk/src/config/index.ts
 import { readFile, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
 
 // ../../src/cli-sdk/src/config/merge.ts
 var merge = (base, add) => Object.fromEntries(
@@ -252,6 +259,7 @@ var recordsToPairs = (obj) => {
 };
 var kRecord = /* @__PURE__ */ Symbol("parsed key=value record");
 var envKey = (k) => `VLT_${k.replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}`;
+var expandHome = (p) => p.replace(/^~(?=$|[\\/])/, homedir());
 var kParentEnv = "__VLT_INTERNAL_EXPLICIT";
 var parentEnv = () => {
   try {
@@ -292,7 +300,9 @@ var Config = class _Config {
     if (this.#options) return this.#options;
     const scurry = new PathScurry(this.projectRoot);
     const packageJson = new PackageJson();
-    const asRecords = pairsToRecords(this.parse().values);
+    const { path: _, ...asRecords } = pairsToRecords(
+      this.parse().values
+    );
     const extras = {
       projectRoot: this.projectRoot,
       signal: this.#abort.signal,
@@ -350,6 +360,7 @@ var Config = class _Config {
     this.projectRoot = projectRoot;
     this.#options = void 0;
     resetCaches();
+    workspaceCache.clear();
   }
   // memoized options() getter value
   #options;
@@ -376,6 +387,28 @@ var Config = class _Config {
    * `~/projects/xyz`, then the highest dir it will check is `~/projects`
    */
   projectRoot;
+  /**
+   * Global project root, set when `--global` switched to it.
+   */
+  globalRoot;
+  /**
+   * `--global-bin-dir` from cli, env or user config, set with
+   * `globalRoot`.
+   */
+  globalBinDir;
+  // the global project of the `setup` wizard, not switched to
+  #setupGlobal;
+  /**
+   * The global project (`--global-dir`, `--global-bin-dir`: cli > env >
+   * user config, never a project `vlt.json`): the one switched to by
+   * `--global`, or the one `vlt setup` offers PATH setup for.
+   */
+  globalProject() {
+    if (this.globalRoot) {
+      return { root: this.globalRoot, binDir: this.globalBinDir };
+    }
+    return this.#setupGlobal;
+  }
   /**
    * `Record<alias, canonical name>` to dereference command aliases.
    */
@@ -399,6 +432,10 @@ var Config = class _Config {
     const badLinker = process.env.VLT_STORE_LINKER;
     const fixLinker = badLinker !== void 0 && !storeLinkers.includes(badLinker);
     if (fixLinker) process.env.VLT_STORE_LINKER = "unpack";
+    const noModifyPath = process.env.VLT_NO_MODIFY_PATH;
+    if (noModifyPath !== void 0) {
+      process.env.VLT_NO_MODIFY_PATH = noModifyPath === "" || noModifyPath === "0" ? "0" : "1";
+    }
     const envKeys = Object.keys(defaultValues).filter(
       (k) => process.env[envKey(k)] !== void 0
     );
@@ -447,7 +484,20 @@ var Config = class _Config {
     if (cmdOrFallback !== "config") {
       assertSpecAliases(pairsToRecords(p.values));
     }
+    const binDirKey = envKey("global-bin-dir");
+    const keepBinDir = !this.globalRoot && !cliKeys.includes("global-bin-dir");
+    const binDirEnv = process.env[binDirKey];
     this.jack.writeEnv(p);
+    delete process.env[envKey("global")];
+    if (this.globalRoot) {
+      process.env[envKey("global-dir")] = this.globalRoot;
+      if (this.globalBinDir)
+        process.env[binDirKey] = this.globalBinDir;
+      else delete process.env[binDirKey];
+    } else if (keepBinDir) {
+      if (binDirEnv === void 0) delete process.env[binDirKey];
+      else process.env[binDirKey] = binDirEnv;
+    }
     process.env[kParentEnv] = JSON.stringify({
       explicit,
       env: Object.fromEntries(
@@ -724,13 +774,89 @@ var Config = class _Config {
   /**
    * Find the local config file and load both it and the user-level config in
    * the XDG config home.
+   *
+   * When `args` select a `--global` command, the global project is used
+   * instead of the current one.
    */
-  async loadConfigFile() {
+  async loadConfigFile(args) {
     await this.#maybeLoadConfigFile("user");
+    const g = args && this.#globalProject(args);
+    if (g?.switch) {
+      const { root } = g;
+      try {
+        ensureGlobalProject(root);
+      } catch (cause) {
+        throw error("Could not create the global project", {
+          code: "ECONFIG",
+          found: root,
+          cause
+        });
+      }
+      this.globalBinDir = g.binDir;
+      unload("project");
+      this.globalRoot = this.projectRoot = root;
+    } else if (g) {
+      this.#setupGlobal = { root: g.root, binDir: g.binDir };
+    }
     this.projectRoot = dirname(find("project", this.projectRoot));
     await this.#maybeLoadConfigFile("project");
     return this;
   }
+  // global project if `args` run a global command with --global, or
+  // `setup`. cli > env > user config, project config is not loaded yet.
+  // `switch`: use it as the project (not for the setup wizard)
+  #globalProject(args) {
+    const { values, positionals } = this.jack.parseRaw(args);
+    const cmd = getCommand(positionals[0]);
+    if (values.help || !cmd) return;
+    const setup = cmd === "setup";
+    if (!setup && !globalCommands.has(cmd)) return;
+    if (!setup) {
+      const env = process.env[envKey("global")];
+      const global = values.global ?? (env !== void 0 ? env === "1" : this.#defaults().global === true);
+      if (!global) return;
+    }
+    return {
+      root: this.#globalDir(values["global-dir"]),
+      binDir: this.#globalBinDir(args),
+      switch: !setup || values.path === true
+    };
+  }
+  #globalDir(cli) {
+    const dir = cli || process.env[envKey("global-dir")];
+    if (dir) return resolve(expandHome(dir));
+    const user = expandHome(
+      String(
+        this.#defaults()["global-dir"] || defaultValues["global-dir"]
+      )
+    );
+    if (!isAbsolute(user)) {
+      throw error("global-dir in the user config must be absolute", {
+        code: "ECONFIG",
+        found: user
+      });
+    }
+    return resolve(user);
+  }
+  // cli > env > user config, like `#globalProject`
+  #globalBinDir(args) {
+    const { values } = this.jack.parseRaw(args);
+    const dir = values["global-bin-dir"] || process.env[envKey("global-bin-dir")];
+    if (dir) return resolve(expandHome(dir));
+    const user = this.#defaults()["global-bin-dir"];
+    if (typeof user !== "string" || !user) return;
+    const p = expandHome(user);
+    if (!isAbsolute(p)) {
+      throw error(
+        "global-bin-dir in the user config must be absolute",
+        {
+          code: "ECONFIG",
+          found: p
+        }
+      );
+    }
+    return resolve(p);
+  }
   /**
    * Clear cached config values to force re-reading from updated files.
    * @internal
@@ -748,9 +874,9 @@ var Config = class _Config {
     this.values = void 0;
     this.positionals = void 0;
     this.command = void 0;
-    const { unload } = await import("./src-JC3ZUYWO.js");
-    unload("user");
-    unload("project");
+    const { unload: unload2 } = await import("./src-JC3ZUYWO.js");
+    unload2("user");
+    unload2("project");
     await this.#maybeLoadConfigFile("user");
     await this.#maybeLoadConfigFile("project");
     this.parse(this.#originalArgs);
@@ -763,10 +889,10 @@ var Config = class _Config {
    * Load the configuration and return a Promise to a
    * {@link Config} object
    */
-  static async load(projectRoot = process.cwd(), argv = process.argv, reload2 = false) {
+  static async load(projectRoot = process.cwd(), argv = process.argv, reload2 = false, allowGlobal = true) {
     if (this.#loaded && !reload2) return this.#loaded;
     const a = new _Config(definition, projectRoot);
-    const b = await a.loadConfigFile();
+    const b = await a.loadConfigFile(allowGlobal ? argv : void 0);
     this.#loaded = b.parse(argv);
     return this.#loaded;
   }

package/chunk-MCDLJZXT.js

@@ -0,0 +1,82 @@
+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 {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../src/cli-sdk/src/global-project.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+var globalCommands = /* @__PURE__ */ new Set([
+  "install",
+  "uninstall",
+  "list",
+  "query",
+  "build"
+]);
+var globalWorkspacesDir = "packages";
+var globalBinDir = (root) => resolve(root, "bin");
+var samePath = (a, b) => {
+  const norm = (p) => {
+    const r = resolve(p);
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return norm(a) === norm(b);
+};
+var isInside = (dir, path) => {
+  const rel = relative(dir, path);
+  return !!rel && !isAbsolute(rel) && rel.split(sep)[0] !== "..";
+};
+var validName = /^(?:@[a-z0-9][\w.~-]*\/)?[a-z0-9~][\w.~-]*$/i;
+var assertGlobalName = (name) => {
+  if (!validName.test(name)) {
+    throw error("Invalid package name", {
+      code: "EUSAGE",
+      found: name
+    });
+  }
+};
+var globalWorkspaceName = (name) => {
+  assertGlobalName(name);
+  return `${name}-ws`;
+};
+var globalWorkspacePath = (name) => `${globalWorkspacesDir}/${globalWorkspaceName(name).replace("/", "+")}`;
+var writeIfMissing = (file, data) => {
+  try {
+    writeFileSync(file, JSON.stringify(data, null, 2) + "\n", {
+      flag: "wx"
+    });
+  } catch (er) {
+    if (er.code !== "EEXIST") throw er;
+  }
+};
+var ensureGlobalProject = (root) => {
+  mkdirSync(resolve(root, globalWorkspacesDir), { recursive: true });
+  writeIfMissing(resolve(root, "package.json"), {
+    name: "vlt-global",
+    private: true
+  });
+  writeIfMissing(resolve(root, "vlt.json"), {
+    workspaces: `${globalWorkspacesDir}/*`
+  });
+};
+
+export {
+  globalCommands,
+  globalWorkspacesDir,
+  globalBinDir,
+  samePath,
+  isInside,
+  globalWorkspaceName,
+  globalWorkspacePath,
+  ensureGlobalProject
+};

package/{chunk-ISAMD2FE.js → chunk-N6HV7JWC.js}

@@ -16,7 +16,7 @@ import {
 import {
   isManifest,
   normalizeBinPaths
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";