@vltpkg/cli-js 1.4.0 → 1.6.0

package/chunk-O6MQ7NN6.js

@@ -0,0 +1,1155 @@
+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 {
+  detectShell,
+  fishPath,
+  posixPath,
+  prettyPath,
+  shellPathCommand,
+  shellRcFile
+} from "./chunk-BH5CVXNY.js";
+import {
+  RollbackRemove,
+  cmdShimIfExists,
+  findCmdShimIfExists
+} from "./chunk-JV5XR5JQ.js";
+import {
+  readGlobalState,
+  updateGlobalState,
+  writeFileAtomic,
+  writeJsonAtomic
+} from "./chunk-GCTREKA4.js";
+import {
+  globalBinDir,
+  globalWorkspaceName,
+  globalWorkspacePath,
+  globalWorkspacesDir,
+  isInside,
+  samePath
+} from "./chunk-MCDLJZXT.js";
+import {
+  parseSpecArg
+} from "./chunk-7M2VTFLP.js";
+import {
+  joinDepIDTuple
+} from "./chunk-CAV7FKWQ.js";
+import {
+  Spec
+} from "./chunk-6D3QAFNZ.js";
+import {
+  promiseSpawn,
+  which
+} from "./chunk-SUU2WETN.js";
+import {
+  XDG
+} from "./chunk-XNLSTHDK.js";
+import {
+  asError,
+  isObject
+} from "./chunk-BF5DRGRZ.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../src/cli-sdk/src/shell-setup/windows.ts
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, win32 } from "node:path";
+var userEnvKey = "HKCU\\Environment";
+var userEnvLabel = "your Windows user environment";
+var editPathHint = 'Start > "Edit environment variables for your account" > Path';
+var refreshVar = "VLT_PATH_REFRESH";
+var system32 = (env) => win32.join(
+  [env.SystemRoot, env.windir].find(
+    (d) => d && win32.isAbsolute(d)
+  ) ?? "C:\\Windows",
+  "System32"
+);
+var run = (env, exe, args) => promiseSpawn(win32.join(system32(env), exe), args, {
+  stdio: ["ignore", "pipe", "pipe"],
+  windowsHide: true
+});
+var detail = (er) => {
+  const e = asError(er);
+  const c = e.cause;
+  return typeof c?.stderr === "string" && c.stderr ? c.stderr : c?.cause ? asError(c.cause).message : e.message;
+};
+var fail = (what, key, why, hint, cause) => error(
+  `Could not ${what} your user Path (${key}): ${why}
+  ${hint}`,
+  {
+    code: "ECONFIG",
+    cause
+  }
+);
+var addIt = (dir) => `Add ${dir} yourself: ${editPathHint}`;
+var norm = (p, env) => win32.normalize(expandEnv(p.trim().replace(/^"(.*)"$/, "$1"), env)).replace(/[\\/]+$/, "").toLowerCase();
+var unesc = (s) => s.replace(/\\([\s\S])/g, "$1");
+var parseRegExport = (text, name) => {
+  const lines = text.replace(/,\\\r?\n */g, ",").split(/\r?\n/);
+  let inKey = false;
+  for (const line of lines) {
+    if (line.startsWith("[")) {
+      if (inKey) return void 0;
+      inKey = true;
+      continue;
+    }
+    const [, n = "", v = ""] = /^"((?:[^"\\]|\\[\s\S])*)"=([\s\S]*)$/.exec(line) ?? [];
+    if (!inKey || unesc(n).toLowerCase() !== name.toLowerCase()) {
+      continue;
+    }
+    const [, sz] = /^"((?:[^"\\]|\\[\s\S])*)"$/.exec(v) ?? [];
+    if (sz !== void 0) return { type: "REG_SZ", data: unesc(sz) };
+    const [, hex] = /^hex\(2\):([\da-f,]*)$/i.exec(v) ?? [];
+    if (hex !== void 0) {
+      const bytes2 = hex.split(",").filter(Boolean).map((h) => parseInt(h, 16));
+      return {
+        type: "REG_EXPAND_SZ",
+        data: Buffer.from(bytes2).toString("utf16le").replace(/\0+$/, "")
+      };
+    }
+    return { type: v.replace(/:[\s\S]*$/, ""), data: "" };
+  }
+  return void 0;
+};
+var expandEnv = (s, env = process.env) => s.replace(
+  /%([^%]+)%/g,
+  (m, n) => Object.entries(env).find(
+    ([k]) => k.toLowerCase() === n.toLowerCase()
+  )?.[1] ?? m
+);
+var addPathEntry = (value, dir, env = process.env) => {
+  if (!value) return { action: "create", data: dir };
+  const previous = value.data;
+  const d = norm(dir, env);
+  if (previous.split(";").some((e) => e.trim() && norm(e, env) === d)) {
+    return { action: "unchanged", previous, data: previous };
+  }
+  return {
+    action: "prepend",
+    previous,
+    data: previous ? `${dir};${previous}` : dir
+  };
+};
+var readUserPath = async ({
+  env = process.env,
+  key = userEnvKey
+} = {}) => {
+  const d = await mkdtemp(join(tmpdir(), "vlt-"));
+  const file = join(d, "env.reg");
+  try {
+    await run(env, "reg.exe", ["export", key, file, "/y"]);
+    const v = parseRegExport(
+      (await readFile(file)).toString("utf16le"),
+      "Path"
+    );
+    if (v && /[\p{Cs}\0]/u.test(v.data)) {
+      throw new Error("it has characters vlt could not read");
+    }
+    return v;
+  } finally {
+    await rm(d, {
+      recursive: true,
+      force: true,
+      maxRetries: 3
+    }).catch(() => {
+    });
+  }
+};
+var planWindowsPath = async (dir, { env = process.env, key = userEnvKey } = {}) => {
+  if (/[;%]/.test(dir)) {
+    throw fail(
+      "update",
+      key,
+      `the folder name has ";" or "%"`,
+      "Set --global-bin-dir to a folder without them"
+    );
+  }
+  const value = await readUserPath({ env, key }).catch(
+    (er) => {
+      throw fail("read", key, detail(er), addIt(dir), er);
+    }
+  );
+  if (value && !/^REG_(EXPAND_)?SZ$/.test(value.type)) {
+    throw fail(
+      "update",
+      key,
+      `unexpected value type ${value.type}`,
+      addIt(dir)
+    );
+  }
+  return { key, dir, ...addPathEntry(value, dir, env) };
+};
+var applyWindowsPath = async (c, { env = process.env } = {}) => {
+  await run(env, "reg.exe", [
+    "add",
+    c.key,
+    "/v",
+    "Path",
+    "/t",
+    "REG_EXPAND_SZ",
+    "/d",
+    c.data,
+    "/f"
+  ]).catch((er) => {
+    throw fail("update", c.key, detail(er), addIt(c.dir), er);
+  });
+  if (c.key !== userEnvKey) return;
+  await run(env, "setx.exe", [refreshVar, "1"]).then(
+    () => run(env, "reg.exe", ["delete", c.key, "/v", refreshVar, "/f"])
+  ).catch(() => {
+  });
+};
+
+// ../../src/cli-sdk/src/shell-setup/index.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { chown, mkdir, realpath as realpath2, writeFile } from "node:fs/promises";
+import { basename, dirname as dirname2, resolve as resolve3 } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+// ../../src/cli-sdk/src/shell-setup/env.ts
+import { resolve } from "node:path";
+var envFile = (globalDir) => resolve(globalDir, "env");
+var envFishFile = (globalDir) => resolve(globalDir, "env.fish");
+var renderEnv = (dir, o = {}) => [
+  "# vlt global bin dir; sourced from the shell rc file. Edit with `vlt setup --path`.",
+  'case ":$PATH:" in',
+  `  *:${posixPath(dir, o)}:*) ;;`,
+  `  *) ${shellPathCommand("sh", dir, o)} ;;`,
+  "esac",
+  ""
+].join("\n");
+var renderEnvFish = (dir, o = {}) => {
+  const d = fishPath(dir, o);
+  return [
+    "# vlt global bin dir; sourced from fish config. Edit with `vlt setup --path`.",
+    // session only, and fish_add_path needs fish 3.2
+    `contains -- ${d} $PATH; or set -gx PATH ${d} $PATH`,
+    ""
+  ].join("\n");
+};
+
+// ../../src/cli-sdk/src/shell-setup/posix.ts
+import { existsSync } from "node:fs";
+import { lstat, readFile as readFile2, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve as resolve2 } from "node:path";
+var blockStart = "# vlt";
+var blockEnd = "# vlt end";
+var abs = (v) => v && isAbsolute(v) ? v : void 0;
+var isENOENT = (er) => er.code === "ENOENT";
+var ownerOf = (st) => ({ uid: st.uid, gid: st.gid });
+var dirOwner = async (dir) => {
+  let st = await stat(dir).catch(() => void 0);
+  while (!st && dirname(dir) !== dir) {
+    dir = dirname(dir);
+    st = await stat(dir).catch(() => void 0);
+  }
+  return st && ownerOf(st);
+};
+var latin1 = (s) => Buffer.from(s).toString("latin1");
+var bytes = (s) => Buffer.from(s, "latin1");
+var rcFiles = (shell, {
+  env = process.env,
+  platform = process.platform,
+  home = homedir()
+} = {}) => {
+  const h = (f) => resolve2(home, f);
+  switch (shell) {
+    case "zsh":
+      return [resolve2(abs(env.ZDOTDIR) ?? home, ".zshrc")];
+    case "fish":
+      return [
+        resolve2(
+          abs(env.XDG_CONFIG_HOME) ?? h(".config"),
+          "fish/conf.d/vlt.fish"
+        )
+      ];
+    case "sh":
+      return [resolve2(abs(env.ENV) ?? h(".profile"))];
+    case "bash": {
+      const login = [".bash_profile", ".bash_login"].map(h);
+      const list = [...login, h(".bashrc")].filter((f) => existsSync(f));
+      if (!list.length || platform === "darwin" && !login.some((f) => list.includes(f))) {
+        list.push(h(".profile"));
+      }
+      return list;
+    }
+  }
+};
+var renderBlock = (shell, globalDir, o = {}) => {
+  let line;
+  if (shell === "fish") {
+    const f = fishPath(envFishFile(globalDir), o);
+    line = `test -f ${f}; and source ${f}`;
+  } else {
+    const f = posixPath(envFile(globalDir), o);
+    line = `if [ -f ${f} ]; then . ${f}; fi`;
+  }
+  return `${blockStart}
+${line}
+${blockEnd}`;
+};
+var trimEnd = (line) => line.replace(/[\r \t]+$/, "");
+var findBlock = (content) => {
+  let start;
+  let found;
+  let offset = 0;
+  for (const raw of content.split("\n")) {
+    const line = trimEnd(raw);
+    if (line === blockStart) start = offset;
+    else if (line === blockEnd && start !== void 0) {
+      found = { start, end: offset + line.length };
+      start = void 0;
+    }
+    offset += raw.length + 1;
+  }
+  if (!found) return;
+  const text = content.slice(found.start, found.end).split("\n").map(trimEnd).join("\n");
+  return { ...found, text };
+};
+var planEnvFile = async (file, text) => {
+  const content = Buffer.from(text);
+  const previous = await readFile2(file).catch((er) => {
+    if (isENOENT(er)) return void 0;
+    throw er;
+  });
+  return {
+    file,
+    kind: "env",
+    content,
+    action: previous === void 0 ? "create" : previous.equals(content) ? "unchanged" : "replace"
+  };
+};
+var planRcFile = async (file, block) => {
+  const lst = await lstat(file).catch((er) => {
+    if (isENOENT(er)) return void 0;
+    throw er;
+  });
+  if (!lst) {
+    return {
+      file,
+      kind: "rc",
+      action: "create",
+      content: Buffer.from(block + "\n"),
+      owner: await dirOwner(dirname(file))
+    };
+  }
+  if (lst.isSymbolicLink()) {
+    file = await realpath(file);
+  }
+  const st = await stat(file);
+  const previous = await readFile2(file);
+  const text = previous.toString("latin1");
+  const blk = latin1(block);
+  const base = {
+    file,
+    kind: "rc",
+    mode: st.mode & 4095,
+    owner: ownerOf(st)
+  };
+  const b = findBlock(text);
+  if (!b) {
+    const sep2 = text === "" ? "" : text.endsWith("\n") ? "\n" : "\n\n";
+    return {
+      ...base,
+      action: "append",
+      content: bytes(text + sep2 + blk + "\n"),
+      previous
+    };
+  }
+  if (b.text === blk) {
+    return { ...base, action: "unchanged", content: previous };
+  }
+  return {
+    ...base,
+    action: "replace",
+    content: bytes(text.slice(0, b.start) + blk + text.slice(b.end)),
+    previous
+  };
+};
+
+// ../../src/cli-sdk/src/shell-setup/index.ts
+var posixShells = /* @__PURE__ */ new Set([
+  "bash",
+  "zsh",
+  "fish",
+  "sh"
+]);
+var canSetupPath = (shell, platform = process.platform) => (
+  // win32: the user Path reaches every shell
+  platform === "win32" || posixShells.has(shell)
+);
+var planPathSetup = async (o) => {
+  const { globalDir, dir, shell } = o;
+  if ((o.platform ?? process.platform) === "win32") {
+    const { env } = o;
+    const registry = await planWindowsPath(dir, { env });
+    return { globalDir, dir, shell, changes: [], registry, env };
+  }
+  const command = shellPathCommand(shell, dir, o);
+  if (!canSetupPath(shell, o.platform)) {
+    const what = shell === "unknown" ? "your shell" : shell;
+    throw error(
+      `vlt setup --path doesn't support ${what} yet. Add it to your PATH yourself:
+  ${command}`,
+      { code: "ECONFIG", found: shell }
+    );
+  }
+  const changes = [
+    await planEnvFile(envFile(globalDir), renderEnv(dir, o)),
+    await planEnvFile(envFishFile(globalDir), renderEnvFish(dir, o))
+  ];
+  const posix = shell;
+  const block = renderBlock(posix, globalDir, o);
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of rcFiles(posix, o)) {
+    const c = await planRcFile(f, block);
+    const real2 = await realpath2(c.file).catch(() => c.file);
+    if (seen.has(real2)) continue;
+    seen.add(real2);
+    changes.push(c);
+  }
+  return { globalDir, dir, shell, changes };
+};
+var pathSetupChanged = (plan) => plan.changes.some((c) => c.action !== "unchanged") || !!plan.registry && plan.registry.action !== "unchanged";
+var pathSetupFiles = (plan) => {
+  const files = plan.changes.map(
+    ({ file, kind, action }) => ({ file, kind, action })
+  );
+  const reg = plan.registry;
+  if (reg) {
+    files.push({
+      file: reg.key,
+      kind: "registry",
+      action: reg.action
+    });
+  }
+  return files;
+};
+var rcList = (files, home) => files.filter((f) => f.kind !== "env").map(
+  (f) => f.kind === "registry" ? userEnvLabel : prettyPath(f.file, home)
+).join(", ");
+var applyPathSetup = async (plan) => {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = resolve3(plan.globalDir, "backups");
+  const backups = [];
+  const backup = async (name, data, mode) => {
+    await mkdir(backupDir, { recursive: true });
+    const b = resolve3(backupDir, `${name}.${stamp}.bak`);
+    await writeFile(b, data, { mode });
+    backups.push(b);
+  };
+  for (const c of plan.changes) {
+    if (c.action === "unchanged") continue;
+    if (c.previous !== void 0) {
+      await backup(
+        basename(c.file).replace(/^\./, ""),
+        c.previous,
+        c.mode
+      );
+    }
+    const owner = process.getuid?.() === 0 ? c.owner : void 0;
+    const own = [c.file];
+    let d = dirname2(c.file);
+    while (owner && !existsSync2(d)) {
+      own.push(d);
+      d = dirname2(d);
+    }
+    await mkdir(dirname2(c.file), { recursive: true });
+    await writeFileAtomic(c.file, c.content, c.mode);
+    if (owner) {
+      for (const f of own) await chown(f, owner.uid, owner.gid);
+    }
+  }
+  const reg = plan.registry;
+  if (reg && reg.action !== "unchanged") {
+    if (reg.previous !== void 0) await backup("Path", reg.previous);
+    await applyWindowsPath(reg, { env: plan.env });
+  }
+  return {
+    dir: plan.dir,
+    shell: plan.shell,
+    files: pathSetupFiles(plan),
+    backups
+  };
+};
+var sourceCommand = (shell, globalDir, dir, o = {}) => (
+  // no env file on win32
+  (o.platform ?? process.platform) === "win32" ? shellPathCommand(shell, dir, o) : shell === "fish" ? `source ${fishPath(envFishFile(globalDir), o)}` : shell === "sh" ? `. ${posixPath(envFile(globalDir), o)}` : `source ${posixPath(envFile(globalDir), o)}`
+);
+var pathSetupLines = (r, source, home) => {
+  const lines = [
+    `\u2705 Added ${prettyPath(r.dir, home)} to your PATH in ${rcList(r.files, home)}`,
+    `   Open a new terminal${r.files.some((f) => f.kind === "registry") ? " (restart editors like VS Code)" : ""}, or run: ${source}`
+  ];
+  const [b] = r.backups;
+  if (b) lines.push(`   Backups in ${prettyPath(dirname2(b), home)}`);
+  return lines;
+};
+var ask = async (question, {
+  input = process.stdin,
+  output = process.stdout
+} = {}) => {
+  const rl = createInterface({ input, output });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+    input.pause();
+  }
+};
+var offerPathSetup = async (g, o) => {
+  const {
+    globalDir,
+    input = process.stdin,
+    output = process.stdout,
+    env = process.env,
+    platform,
+    home
+  } = o;
+  if (o.noModifyPath || g.inPath) return;
+  if (!g.bins.length && !g.conflicts.length) return;
+  if (!input.isTTY || !output.isTTY || env.CI) return;
+  if ((await readGlobalState(globalDir)).pathSetup === "declined")
+    return;
+  const sh = { env, platform, home };
+  const shell = detectShell(env, platform);
+  const po = { ...sh, globalDir, dir: g.binDir, shell };
+  let plan;
+  try {
+    plan = await planPathSetup(po);
+  } catch {
+    return;
+  }
+  const rcs = rcList(pathSetupFiles(plan), home);
+  const source = sourceCommand(shell, globalDir, g.binDir, sh);
+  const write = (line) => output.write(line + "\n");
+  o.beforeOutput?.();
+  write("");
+  if (!pathSetupChanged(plan)) {
+    write(
+      `\u2139\uFE0F  It's already added in ${rcs}: open a new terminal, or run: ${source}`
+    );
+    return;
+  }
+  if (!o.yes) {
+    let answer;
+    try {
+      answer = await ask(`Add it to ${rcs} now? (Y/n) `, {
+        input,
+        output
+      });
+    } catch {
+      return;
+    }
+    if (/^n/i.test(answer)) {
+      await updateGlobalState(globalDir, (s) => ({
+        ...s,
+        pathSetup: "declined"
+      })).catch(() => {
+      });
+      return;
+    }
+  }
+  try {
+    if (!o.yes) plan = await planPathSetup(po);
+    const r = await applyPathSetup(plan);
+    for (const line of pathSetupLines(r, source, home)) write(line);
+  } catch (er) {
+    write(`\u26A0\uFE0F  Could not add it to your PATH: ${asError(er).message}`);
+  }
+};
+
+// ../../src/cli-sdk/src/global.ts
+import { existsSync as existsSync3, readdirSync, realpathSync } from "node:fs";
+import {
+  lstat as lstat2,
+  mkdir as mkdir2,
+  readdir,
+  realpath as realpath3,
+  rm as rm2,
+  stat as stat2,
+  symlink,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import {
+  basename as basename2,
+  delimiter,
+  isAbsolute as isAbsolute2,
+  relative,
+  resolve as resolve4,
+  sep
+} from "node:path";
+var unsupported = [
+  "workspace",
+  "workspace-group",
+  "lockfile-only"
+];
+var assertGlobalOptions = (conf) => {
+  for (const name of unsupported) {
+    const found = conf.values[name];
+    if (found !== void 0 && found !== false) {
+      throw error(`--${name} is not supported with --global`, {
+        code: "EUSAGE",
+        name,
+        found
+      });
+    }
+  }
+};
+var workspaceId = (path) => joinDepIDTuple(["workspace", path]);
+var specs = /* @__PURE__ */ new WeakMap();
+var globalSpec = (item, conf) => {
+  const known = specs.get(conf) ?? /* @__PURE__ */ new Map();
+  specs.set(conf, known);
+  const spec = known.get(item) ?? namedSpec(item, conf);
+  known.set(item, spec);
+  return spec;
+};
+var namedSpec = async (item, conf) => {
+  const options = conf.options;
+  let spec = parseSpecArg(item, options);
+  if (spec.type === "file" && spec.file && !isAbsolute2(spec.file)) {
+    const file = resolve4(process.cwd(), spec.file).split(sep).join("/");
+    spec = Spec.parse(spec.name, `file:${file}`, options);
+  }
+  if (spec.type === "registry" && !spec.bareSpec) {
+    return Spec.parse(spec.name, options.tag, options);
+  }
+  if (spec.name !== "(unknown)") return spec;
+  const { name } = await options.packageInfo.manifest(spec, {
+    from: process.cwd()
+  });
+  if (!name) {
+    throw error("Could not determine package name", {
+      code: "EUSAGE",
+      spec
+    });
+  }
+  return Spec.parse(name, spec.bareSpec, options);
+};
+var wsPackageName = (dir) => dir.replace(/-ws$/, "").replace("+", "/");
+var findWorkspace = (projectRoot, name) => {
+  const path = globalWorkspacePath(name);
+  const dir = resolve4(projectRoot, path);
+  const base = basename2(path);
+  const entries = readdirSync(
+    resolve4(projectRoot, globalWorkspacesDir)
+  );
+  const variant = entries.find(
+    (e) => e !== base && e.toLowerCase() === base.toLowerCase()
+  );
+  return {
+    path,
+    dir,
+    exists: entries.includes(base) && existsSync3(resolve4(dir, "package.json")),
+    variant: variant && wsPackageName(variant)
+  };
+};
+var parseGlobalAddArgs = async (conf) => {
+  const { positionals, projectRoot } = conf;
+  const add = Object.assign(
+    /* @__PURE__ */ new Map(),
+    { modifiedDependencies: positionals.length > 0 }
+  );
+  const created = [];
+  const importers = /* @__PURE__ */ new Set();
+  try {
+    for (const item of positionals) {
+      const spec = await globalSpec(item, conf);
+      const { path, dir, exists: exists2, variant } = findWorkspace(
+        projectRoot,
+        spec.name
+      );
+      if (!exists2) {
+        if (variant) {
+          throw error(
+            `${spec.name} differs only in case from global package ${variant}`,
+            { code: "EUSAGE", found: spec.name }
+          );
+        }
+        await mkdir2(dir, { recursive: true });
+        created.push(dir);
+        const ws = {
+          name: globalWorkspaceName(spec.name),
+          private: true
+        };
+        await writeFile2(
+          resolve4(dir, "package.json"),
+          JSON.stringify(ws, null, 2) + "\n"
+        );
+      }
+      const id = workspaceId(path);
+      importers.add(id);
+      const dep = { spec, type: "implicit" };
+      add.set(id, /* @__PURE__ */ new Map([[spec.name, dep]]));
+    }
+  } catch (er) {
+    await removeGlobalWorkspaces(created);
+    throw er;
+  }
+  if (created.length) conf.resetOptions(projectRoot);
+  return {
+    add,
+    created,
+    importers: positionals.length ? importers : void 0
+  };
+};
+var parseGlobalRemoveArgs = (conf) => {
+  const { positionals, projectRoot } = conf;
+  if (!positionals.length) {
+    throw error("Missing package name(s) to uninstall", {
+      code: "EUSAGE"
+    });
+  }
+  const remove = Object.assign(
+    /* @__PURE__ */ new Map(),
+    { modifiedDependencies: true }
+  );
+  const dirs = [];
+  for (const name of positionals) {
+    const { path, dir, exists: exists2, variant } = findWorkspace(
+      projectRoot,
+      name
+    );
+    const id = workspaceId(path);
+    if (remove.has(id)) continue;
+    if (!exists2) {
+      throw error(`${name} is not installed globally`, {
+        code: "EUSAGE",
+        found: name,
+        ...variant ? { validOptions: [variant] } : null
+      });
+    }
+    remove.set(id, /* @__PURE__ */ new Set([name]));
+    dirs.push(dir);
+  }
+  return { remove, dirs };
+};
+var removeGlobalWorkspaces = async (dirs) => {
+  await Promise.all(
+    dirs.map((dir) => rm2(dir, { recursive: true, force: true }))
+  );
+};
+var shimExts = ["", ".cmd", ".ps1", ".pwsh"];
+var linkFiles = (link) => process.platform === "win32" ? shimExts.map((ext) => link + ext) : [link];
+var realOr = (p) => realpath3(p).catch(() => p);
+var unlinkGlobalBins = async (binDir, dirs, remover) => {
+  const entries = await readdir(binDir, {
+    withFileTypes: true
+  }).catch(() => []);
+  const names = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    const name = e.name.replace(/\.(cmd|ps1|pwsh)$/i, "");
+    if (name !== e.name || e.isSymbolicLink()) names.add(name);
+  }
+  const roots = [...dirs, ...await Promise.all(dirs.map(realOr))];
+  const removed = [];
+  for (const name of names) {
+    const link = resolve4(binDir, name);
+    const found = await findCmdShimIfExists(link);
+    if (!found || !roots.some((dir) => isInside(dir, found[1])))
+      continue;
+    await Promise.all(
+      linkFiles(link).map(
+        (f) => remover ? remover.rm(f) : rm2(f, { force: true })
+      )
+    );
+    removed.push(name);
+  }
+  return removed.sort((a, b) => a.localeCompare(b, "en"));
+};
+var exists = async (link) => (await Promise.all(
+  linkFiles(link).map(
+    (f) => lstat2(f).then(
+      () => true,
+      () => false
+    )
+  )
+)).some(Boolean);
+var safeBin = (bin) => !!bin && bin === basename2(bin) && !bin.includes("\\") && bin !== "." && bin !== "..";
+var sorted = (s) => [...s].sort((a, b) => a.localeCompare(b, "en"));
+var dedupe = (dirs) => dirs.filter((d, i) => dirs.findIndex((x) => samePath(x, d)) === i);
+var otherBinDirs = async (root, current, state) => {
+  const g = await realpath3(globalBinDir(root)).catch(() => void 0);
+  return dedupe([...state.binDirs ?? [], ...g ? [g] : []]).filter(
+    (d) => !samePath(d, current)
+  );
+};
+var isDir = (d) => stat2(d).then(
+  (s) => s.isDirectory(),
+  () => false
+);
+var isPermError = (er) => er instanceof Error && /^(EACCES|EPERM)$/.test(String(er.code));
+var replaceable = async (link, keep) => {
+  if (process.platform !== "win32" && !(await lstat2(link)).isSymbolicLink()) {
+    return false;
+  }
+  const found = await findCmdShimIfExists(link);
+  if (!found) return false;
+  const to = await realOr(found[1]);
+  return !keep.some((k) => samePath(k, to));
+};
+var linkBins = async (graph, opts, importers) => {
+  const { projectRoot, scurry, force } = opts;
+  const { dir: binDir, source } = opts.binDir;
+  const state = await readGlobalState(projectRoot);
+  const targets = [...graph.importers].filter(
+    (i) => i !== graph.mainImporter && (!importers || importers.has(i.id))
+  ).sort((a, b) => a.location.localeCompare(b.location, "en"));
+  const owned = importers ? targets.map((i) => i.resolvedLocation(scurry)) : [resolve4(projectRoot, globalWorkspacesDir)];
+  const keep = force && source !== "global-dir" ? await Promise.all(
+    [process.execPath, ...process.argv.slice(1, 2)].map(realOr)
+  ) : void 0;
+  const remover = new RollbackRemove();
+  const bins = /* @__PURE__ */ new Set();
+  const conflicts = /* @__PURE__ */ new Set();
+  const otherDirs = [];
+  const created = [];
+  try {
+    await unlinkGlobalBins(binDir, owned, remover);
+    for (const d of await otherBinDirs(projectRoot, binDir, state)) {
+      const removed = await unlinkGlobalBins(d, owned, remover).catch(
+        () => []
+      );
+      if (removed.length) otherDirs.push(d);
+    }
+    await mkdir2(binDir, { recursive: true });
+    for (const importer of targets) {
+      const nm = await realOr(importer.nodeModules(scurry));
+      for (const edge of importer.edgesOut.values()) {
+        for (const [bin, path] of Object.entries(
+          edge.to?.bins ?? {}
+        )) {
+          if (!safeBin(bin)) continue;
+          const target = resolve4(nm, edge.spec.name, path);
+          const win322 = process.platform === "win32";
+          if (win322 && !await stat2(target).catch(() => false)) {
+            continue;
+          }
+          const link = resolve4(binDir, bin);
+          if (await exists(link) && (!force || keep && !await replaceable(link, keep))) {
+            conflicts.add(bin);
+            continue;
+          }
+          if (win322) {
+            created.push(link);
+            await cmdShimIfExists(target, link, remover);
+          } else {
+            await remover.rm(link);
+            await rm2(link, { force: true });
+            created.push(link);
+            await symlink(relative(binDir, target), link);
+          }
+          bins.add(bin);
+        }
+      }
+    }
+  } catch (er) {
+    await Promise.all(
+      created.flatMap(linkFiles).map((f) => rm2(f, { force: true }))
+    );
+    await remover.rollback();
+    throw er;
+  }
+  remover.confirm();
+  return {
+    binDir: opts.binDir,
+    state,
+    bins: sorted(bins),
+    conflicts: sorted(conflicts),
+    otherDirs
+  };
+};
+var recordBinDir = async (projectRoot, { binDir, state, bins, conflicts, otherDirs }) => {
+  const { dir, source, inPath, notWritable } = binDir;
+  const shown = (bins.length > 0 || conflicts.length > 0) && (source === "global-dir" || !state.localBinNoticed);
+  const why = shown ? notWritable : void 0;
+  const notice = !!why && source === "local-bin";
+  const recorded = [];
+  for (const d of state.binDirs ?? []) {
+    if (await isDir(d)) recorded.push(d);
+  }
+  await updateGlobalState(projectRoot, (s) => ({
+    ...s,
+    binDirs: dedupe([...recorded, dir]),
+    ...notice ? { localBinNoticed: true } : {}
+  }));
+  return {
+    binDir: dir,
+    source,
+    bins,
+    conflicts,
+    inPath,
+    otherDirs,
+    ...why ? { notWritable: why } : {}
+  };
+};
+var linkGlobalBins = async (graph, opts, importers) => {
+  let linked;
+  try {
+    linked = await linkBins(graph, opts, importers);
+  } catch (er) {
+    const { binDir, fallback } = opts;
+    if (binDir.source !== "self" || !fallback || !isPermError(er)) {
+      throw er;
+    }
+    linked = await linkBins(
+      graph,
+      { ...opts, binDir: await fallback() },
+      importers
+    );
+  }
+  return recordBinDir(opts.projectRoot, linked);
+};
+var removeGlobalPackages = async (projectRoot, dirs, binDir) => {
+  const current = binDir ?? globalBinDir(projectRoot);
+  await unlinkGlobalBins(current, dirs);
+  const state = await readGlobalState(projectRoot);
+  for (const d of await otherBinDirs(projectRoot, current, state)) {
+    await unlinkGlobalBins(d, dirs).catch(() => []);
+  }
+  await removeGlobalWorkspaces(dirs);
+};
+var isInPath = (dir, PATH = process.env.PATH ?? "") => PATH.split(delimiter).some((p) => !!p && samePath(p, dir));
+var homeOf = (dir, home, win322) => {
+  if (prettyPath(dir, home, win322) !== dir) return home;
+  try {
+    return realpathSync.native(home);
+  } catch {
+    return home;
+  }
+};
+var globalBinsLines = (g, opts = {}) => {
+  const {
+    shell = detectShell(opts.env, opts.platform),
+    platform = process.platform
+  } = opts;
+  const win322 = platform === "win32";
+  const home = homeOf(g.binDir, opts.home ?? homedir2(), win322);
+  const pretty = (p) => prettyPath(p, home, win322);
+  const dir = pretty(g.binDir);
+  const lines = [];
+  if (g.notWritable) {
+    lines.push(
+      `\u2139\uFE0F  Using ${dir} because ${pretty(g.notWritable)} is not writable.`
+    );
+  }
+  if (g.bins.length) {
+    lines.push(`\u{1F517} Linked ${g.bins.join(", ")} in ${dir}`);
+  }
+  if (g.conflicts.length) {
+    lines.push(
+      `\u26A0\uFE0F  Skipped ${g.conflicts.join(", ")}: already in ${dir} (use --force to overwrite)`
+    );
+  }
+  if (!g.inPath && (g.bins.length || g.conflicts.length)) {
+    const rc = shellRcFile(shell, opts);
+    const what = g.bins.length ? g.bins.join(", ") : "global bins";
+    const fix = canSetupPath(shell, platform) ? "Run `vlt setup --path` to add it" : "Set --global-bin-dir to a folder on your PATH";
+    lines.push(
+      // a paragraph of its own: the install offer follows it
+      "",
+      `\u26A0\uFE0F  ${dir} is not on your PATH, so ${what} can't be run yet.`,
+      `   ${fix}, or ${rc ? `add this line to ${rc}` : "run"}:`,
+      `     ${shellPathCommand(shell, g.binDir, { ...opts, home })}`
+    );
+  }
+  return lines;
+};
+
+// ../../src/cli-sdk/src/global-bin-dir.ts
+import { constants } from "node:fs";
+import { access, mkdir as mkdir3, realpath as realpath5, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import {
+  basename as basename3,
+  delimiter as delimiter2,
+  dirname as dirname4,
+  isAbsolute as isAbsolute4,
+  resolve as resolve6
+} from "node:path";
+
+// ../../src/cli-sdk/src/install-receipt.ts
+import { readFile as readFile3, realpath as realpath4 } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute3, resolve as resolve5 } from "node:path";
+var xdg = new XDG("vlt");
+var receiptName = "install-receipt.json";
+var isStr = (v) => typeof v === "string";
+var optStr = (v) => v === void 0 || isStr(v);
+var optStrs = (v) => v === void 0 || Array.isArray(v) && v.every(isStr);
+var isReceipt = (d) => isObject(d) && d.receiptVersion === 1 && isStr(d.method) && !!d.method && isStr(d.binDir) && isAbsolute3(d.binDir) && (d.installer === void 0 || isObject(d.installer) && optStr(d.installer.name) && optStr(d.installer.version)) && optStr(d.version) && optStr(d.channel) && optStr(d.target) && optStrs(d.binaries) && optStrs(d.modifiedPath) && optStr(d.installedAt);
+var readInstallReceipt = async (found, configDir = xdg.config()) => {
+  const dir = dirname3(found);
+  const real2 = await realpath4(dir).catch(() => void 0);
+  if (!real2) return;
+  for (const file of [
+    resolve5(configDir, receiptName),
+    resolve5(dir, receiptName),
+    resolve5(dir, "..", receiptName)
+  ]) {
+    try {
+      const data = JSON.parse(await readFile3(file, "utf8"));
+      if (isReceipt(data) && samePath(await realpath4(data.binDir), real2))
+        return { file, data };
+    } catch {
+    }
+  }
+};
+var writeInstallReceipt = async (file, update) => {
+  let raw;
+  try {
+    raw = JSON.parse(await readFile3(file, "utf8"));
+  } catch (cause) {
+    throw error("Invalid install receipt", { path: file, cause });
+  }
+  if (!isReceipt(raw)) {
+    throw error("Invalid install receipt", { path: file });
+  }
+  await writeJsonAtomic(file, {
+    ...raw,
+    version: update.version,
+    installedAt: update.installedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+
+// ../../src/cli-sdk/src/global-bin-dir.ts
+var real = (p) => realpath5(p).catch(() => void 0);
+var writable = (dir) => access(dir, constants.W_OK).then(
+  () => true,
+  () => false
+);
+var isInPathRealpath = async (dir, PATH = process.env.PATH ?? "") => {
+  if (isInPath(dir, PATH)) return true;
+  const r = await real(dir);
+  if (!r) return false;
+  for (const p of PATH.split(delimiter2)) {
+    const rp = p && await real(p);
+    if (rp && samePath(rp, r)) return true;
+  }
+  return false;
+};
+var isDotBin = (d) => {
+  const name = (p) => process.platform === "win32" ? basename3(p).toLowerCase() : basename3(p);
+  return name(d) === ".bin" && name(dirname4(d)) === "node_modules";
+};
+var findSelf = async () => {
+  const found = await which("vlt", { nothrow: true }).catch(
+    () => null
+  );
+  if (!found || !isAbsolute4(found)) return;
+  const foundDir = dirname4(found);
+  if (!isInPath(foundDir) || isDotBin(foundDir)) return;
+  const dir = await real(foundDir);
+  if (!dir || isDotBin(dir)) return;
+  const shim = /\.(cmd|ps1)$/i.test(found) ? (await findCmdShimIfExists(found))?.[1] : found;
+  const target = shim && await real(shim);
+  if (!target) return;
+  const exec = await real(process.execPath);
+  const standalone = !!exec && samePath(target, exec);
+  if (!standalone) {
+    const script = process.argv[1] && await real(process.argv[1]);
+    if (!script || !samePath(target, script)) return;
+  }
+  const receipt = await readInstallReceipt(found);
+  return {
+    found,
+    dir,
+    target,
+    standalone,
+    ...receipt ? { receipt } : {}
+  };
+};
+var resolveDir = async (conf, selfUnwritable) => {
+  const configured = conf.globalBinDir;
+  if (configured) {
+    try {
+      await mkdir3(configured, { recursive: true });
+    } catch (cause) {
+      throw error("Could not create global-bin-dir", {
+        code: "ECONFIG",
+        found: configured,
+        cause
+      });
+    }
+    try {
+      await access(configured, constants.W_OK);
+    } catch (cause) {
+      throw error("global-bin-dir is not writable", {
+        code: "ECONFIG",
+        found: configured,
+        cause
+      });
+    }
+    const dir2 = await realpath5(configured);
+    return {
+      dir: dir2,
+      source: "config",
+      inPath: await isInPathRealpath(dir2)
+    };
+  }
+  const self = await findSelf();
+  if (self && !selfUnwritable && await writable(self.dir)) {
+    return { dir: self.dir, source: "self", inPath: true };
+  }
+  const notWritable = self?.dir;
+  if (notWritable && process.platform !== "win32") {
+    const local = resolve6(homedir3(), ".local/bin");
+    const st = await stat3(local).catch(() => void 0);
+    if (st?.isDirectory() && await isInPathRealpath(local) && await writable(local)) {
+      const dir2 = await realpath5(local);
+      if (!samePath(dir2, notWritable)) {
+        return { dir: dir2, source: "local-bin", inPath: true, notWritable };
+      }
+    }
+  }
+  const g = globalBinDir(conf.projectRoot);
+  await mkdir3(g, { recursive: true });
+  const dir = await realpath5(g);
+  return {
+    dir,
+    source: "global-dir",
+    inPath: await isInPathRealpath(dir),
+    ...notWritable ? { notWritable } : {}
+  };
+};
+var resolveGlobalBinDir = async (conf, { selfUnwritable = false } = {}) => {
+  const r = await resolveDir(conf, selfUnwritable);
+  process.env.VLT_GLOBAL_BIN_DIR = r.dir;
+  return r;
+};
+
+export {
+  editPathHint,
+  planPathSetup,
+  pathSetupChanged,
+  pathSetupFiles,
+  rcList,
+  applyPathSetup,
+  sourceCommand,
+  pathSetupLines,
+  ask,
+  offerPathSetup,
+  assertGlobalOptions,
+  globalSpec,
+  parseGlobalAddArgs,
+  parseGlobalRemoveArgs,
+  removeGlobalWorkspaces,
+  linkGlobalBins,
+  removeGlobalPackages,
+  globalBinsLines,
+  writeInstallReceipt,
+  findSelf,
+  resolveGlobalBinDir
+};