@vltpkg/cli-js 1.5.0 → 1.6.0

package/{chunk-2U4PVHP4.js → chunk-F5LZMLAQ.js}

@@ -14,12 +14,12 @@ import {
   SecurityArchive,
   pRetry,
   usesNpmRegistry
-} from "./chunk-SMXXFQPI.js";
+} from "./chunk-YTDABXPD.js";
 import {
   Monorepo,
   PackageJson,
   minimatch
-} from "./chunk-C6ZVVEFV.js";
+} from "./chunk-TQQO2F56.js";
 import {
   asDepID,
   baseDepID,
@@ -33,13 +33,13 @@ import {
   joinExtra,
   splitDepID,
   splitExtra
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   Spec as Spec2
-} from "./chunk-LUVDMEW4.js";
+} from "./chunk-6D3QAFNZ.js";
 import {
   userAgentHeaders
-} from "./chunk-G3FZ2ZJK.js";
+} from "./chunk-GEQFMH5M.js";
 import {
   graphStep
 } from "./chunk-B6RIGNEO.js";
@@ -83,7 +83,7 @@ import {
   shortDependencyTypes,
   subset,
   tarballFormat
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error,
   syntaxError,
@@ -5009,21 +5009,21 @@ var Graph = class {
     const rest = [];
     const importers = this.importers.values();
     let seenImporters = 0;
-    let sorted = true;
+    let sorted2 = true;
     let prev;
     for (const node of this.nodes.values()) {
       if (this.importers.has(node)) {
         if (rest.length || importers.next().value !== node) {
-          sorted = false;
+          sorted2 = false;
         }
         seenImporters++;
         continue;
       }
-      if (sorted && prev && cmp(prev, node) > 0) sorted = false;
+      if (sorted2 && prev && cmp(prev, node) > 0) sorted2 = false;
       prev = node;
       rest.push(node);
     }
-    if (sorted && seenImporters === this.importers.size) return;
+    if (sorted2 && seenImporters === this.importers.size) return;
     rest.sort(cmp);
     const nodes = /* @__PURE__ */ new Map();
     for (const node of this.importers) nodes.set(node.id, node);
@@ -5064,6 +5064,7 @@ var Graph = class {
         }
         return edge;
       }
+      edge.to?.edgesIn.delete(edge);
       this.edges.delete(edge);
     }
     this.mutations++;
@@ -9805,7 +9806,7 @@ var Query = class {
 };
 
 // ../../src/graph/src/skills/lazy.ts
-var load3 = () => import("./skills-YD2TB2VD.js");
+var load3 = () => import("./skills-KA2VR5Q5.js");
 var listSkills = async (o) => (await load3()).listSkills(o);
 var linkSkills = async (o) => (await load3()).linkSkills(o);
 var hasSkills = async (node) => isNode(node) && (await load3()).shipsSkills(node);
@@ -9889,15 +9890,79 @@ var assertQuery = async (selector, flag, partSelectors) => {
   }
 };
 
+// ../../src/graph/src/skills/gitignore.ts
+import { lstatSync as lstatSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var GITIGNORE_BEGIN = "# >>> vlt agent skills (links into node_modules)";
+var GITIGNORE_END = "# <<< vlt agent skills";
+var sorted = (names) => [...names].sort((a, b) => a.localeCompare(b, "en")).map((n) => `/${n}`);
+var findBlock = (lines) => {
+  const begin = lines.findIndex((l) => l.trim() === GITIGNORE_BEGIN);
+  const end = lines.findIndex(
+    (l, i) => begin !== -1 && i > begin && l.trim() === GITIGNORE_END
+  );
+  return { begin, end };
+};
+var update = (file, { add, remove }) => {
+  const st = lstatSync2(file, { throwIfNoEntry: false });
+  if (st && !st.isFile()) return "refused";
+  const text = st ? readFileSync3(file, "utf8") : "";
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines = text.split(eol);
+  const { begin, end } = findBlock(lines);
+  let out;
+  if (end === -1) {
+    if (!add.length) return "ok";
+    out = (text && !text.endsWith(eol) ? text + eol : text) + [GITIGNORE_BEGIN, ...sorted(add), GITIGNORE_END].join(eol) + eol;
+  } else {
+    const rm2 = new Set(sorted(remove));
+    const block = lines.slice(begin + 1, end).filter((l) => !rm2.has(l.trim()));
+    const have = new Set(block.map((l) => l.trim()));
+    lines.splice(
+      begin + 1,
+      end - begin - 1,
+      ...block,
+      ...sorted(add).filter((l) => !have.has(l))
+    );
+    out = lines.join(eol);
+  }
+  if (out !== text) writeFileSync2(file, out);
+  return "ok";
+};
+var editGitignore = (dir, edit) => {
+  try {
+    return update(join2(dir, ".gitignore"), edit);
+  } catch {
+    return "refused";
+  }
+};
+var gitignoreNames = (dir) => {
+  try {
+    const file = join2(dir, ".gitignore");
+    if (!lstatSync2(file, { throwIfNoEntry: false })?.isFile()) {
+      return /* @__PURE__ */ new Set();
+    }
+    const lines = readFileSync3(file, "utf8").split(/\r?\n/);
+    const { begin, end } = findBlock(lines);
+    if (end === -1) return /* @__PURE__ */ new Set();
+    return new Set(
+      lines.slice(begin + 1, end).map((l) => l.trim()).filter((l) => l.startsWith("/")).map((l) => l.slice(1))
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+};
+
 // ../../src/graph/src/skills/mounts.ts
 import {
-  lstatSync as lstatSync2,
+  existsSync as existsSync2,
+  lstatSync as lstatSync3,
   readdirSync as readdirSync2,
   readlinkSync,
   realpathSync,
   unlinkSync
 } from "node:fs";
-import { dirname as dirname3, join as join2, relative as relative2, resolve as resolve5, sep } from "node:path";
+import { dirname as dirname3, join as join3, relative as relative2, resolve as resolve5, sep } from "node:path";
 
 // ../../src/graph/src/reify/symlink-sync.ts
 import { mkdirSync as mkdirSync2, symlinkSync } from "node:fs";
@@ -9915,7 +9980,7 @@ var symlinkSyncMkdirp = (target, link2, type2) => {
 // ../../src/graph/src/skills/mounts.ts
 var lstat = (path2) => {
   try {
-    return lstatSync2(path2, { throwIfNoEntry: false });
+    return lstatSync3(path2, { throwIfNoEntry: false });
   } catch {
     return void 0;
   }
@@ -9933,12 +9998,22 @@ var realOr = (p) => {
 };
 var samePath = (a, b) => norm(realOr(a)) === norm(realOr(b));
 var storeSeg = `${sep}node_modules${sep}.vlt${sep}`;
-var mountTarget = (link2) => {
+var linkTarget = (link2) => {
   if (!lstat(link2)?.isSymbolicLink()) return void 0;
   let raw = readlinkSync(link2);
   if (raw.startsWith("\\\\?\\")) raw = raw.slice(4);
-  const target = resolve5(dirname3(link2), raw);
-  return norm(target).includes(storeSeg) ? target : void 0;
+  return resolve5(dirname3(link2), raw);
+};
+var mountTarget = (link2) => {
+  const target = linkTarget(link2);
+  return target && norm(target).includes(storeSeg) ? target : void 0;
+};
+var workspaceOf = (target, workspaces) => {
+  const t = norm(realOr(target));
+  return workspaces.filter(({ path: path2 }) => {
+    const p = norm(path2);
+    return t === p || t.startsWith(p + sep);
+  }).sort((a, b) => b.path.length - a.path.length)[0];
 };
 var ownerOf = (target) => {
   const parts = target.split(sep);
@@ -9962,7 +10037,10 @@ var packageKey = (id2) => {
     at > 0 ? spec2.slice(0, at) : spec2
   ]);
 };
-var readMounts = (scan) => {
+var readMounts = (scan, {
+  workspaces = [],
+  made
+} = {}) => {
   const mounts = [];
   for (const dir of scan) {
     let entries;
@@ -9971,29 +10049,33 @@ var readMounts = (scan) => {
     } catch {
       continue;
     }
+    const listed = gitignoreNames(dir.real);
     for (const name of entries) {
-      const link2 = join2(dir.real, name);
+      const link2 = join3(dir.real, name);
+      const mount = `${dir.dir}/${name}`;
+      const m = { dir, name, mount, link: link2 };
       const target = mountTarget(link2);
       if (target) {
-        mounts.push({
-          dir,
-          name,
-          mount: `${dir.dir}/${name}`,
-          link: link2,
-          target,
-          owner: ownerOf(target)
-        });
+        mounts.push({ ...m, target, owner: ownerOf(target) });
+        continue;
       }
+      const wsTarget = (listed.has(name) || made?.has(mount)) && linkTarget(link2);
+      if (!wsTarget) continue;
+      if (!existsSync2(wsTarget)) {
+        mounts.push({ ...m, target: wsTarget });
+        continue;
+      }
+      const ws = workspaceOf(wsTarget, workspaces);
+      if (ws) mounts.push({ ...m, target: wsTarget, owner: ws.id });
     }
   }
   return mounts.sort((a, b) => a.mount.localeCompare(b.mount, "en"));
 };
-var mountSkill = (skill2, dir) => {
-  const link2 = join2(dir.real, skill2.skill);
+var mountSkill = (skill2, dir, owned = false) => {
+  const link2 = join3(dir.real, skill2.skill);
   if (lstat(link2)) {
-    const target = mountTarget(link2);
-    if (!target) return "conflict";
-    if (samePath(target, skill2.path)) return "unchanged";
+    if (samePath(link2, skill2.path)) return "unchanged";
+    if (!owned && !mountTarget(link2)) return "conflict";
     unlinkSync(link2);
   }
   if (process.platform === "win32") {
@@ -10009,13 +10091,13 @@ var unmountSkill = (m) => {
 
 // ../../src/graph/src/skills/dirs.ts
 import {
-  lstatSync as lstatSync3,
+  lstatSync as lstatSync4,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync3,
   realpathSync as realpathSync2,
   statSync
 } from "node:fs";
-import { isAbsolute, join as join3, relative as relative3, resolve as resolve6, sep as sep2 } from "node:path";
+import { isAbsolute, join as join4, relative as relative3, resolve as resolve6, sep as sep2 } from "node:path";
 var AGENTS_SKILLS = ".agents/skills";
 var CLAUDE_ENV = ["CLAUDECODE", "CLAUDE_CODE"];
 var AGENT_ROOTS = [
@@ -10147,18 +10229,18 @@ var walk2 = (realRoot, dir, create) => {
   let real = realRoot;
   try {
     for (const [i, part] of parts.entries()) {
-      const next = join3(real, part);
-      let st = lstatSync3(next, { throwIfNoEntry: false });
+      const next = join4(real, part);
+      let st = lstatSync4(next, { throwIfNoEntry: false });
       if (!st) {
         if (!create)
-          return { dir, real: join3(real, ...parts.slice(i)) };
+          return { dir, real: join4(real, ...parts.slice(i)) };
         try {
           mkdirSync3(next);
         } catch (er) {
           if (er.code !== "EEXIST")
             throw er;
         }
-        st = lstatSync3(next);
+        st = lstatSync4(next);
       }
       if (st.isSymbolicLink()) {
         let r;
@@ -10199,11 +10281,11 @@ var skillsDirs = ({
   } else {
     const found = /* @__PURE__ */ new Set();
     for (const [marker, d] of AGENT_ROOTS) {
-      if (isDir(join3(realRoot, marker))) found.add(d);
+      if (isDir(join4(realRoot, marker))) found.add(d);
     }
     if (CLAUDE_ENV.some((k) => env2[k])) found.add(".claude/skills");
     for (const d of dots) {
-      if (isDir(join3(realRoot, d))) found.add(d);
+      if (isDir(join4(realRoot, d))) found.add(d);
     }
     list = [
       AGENTS_SKILLS,
@@ -10282,6 +10364,7 @@ export {
   filterNodesByQueryParts,
   assertQuery,
   symlinkSyncMkdirp,
+  editGitignore,
   lstat,
   norm,
   realOr,

package/{chunk-Z5D5KODU.js → chunk-FXD3IV2S.js}

@@ -10,14 +10,16 @@ globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
+  defaultRegistryKey,
   getTokenByURL,
   registryKeys
-} from "./chunk-35EG6T3J.js";
+} from "./chunk-44AWMA4F.js";
 
 // ../../src/cli-sdk/src/query-auth.ts
 var createGetAuthHeader = (conf) => {
   const keys = registryKeys(conf.options);
-  return async (url) => getTokenByURL(url, conf.options.identity, keys);
+  const def = defaultRegistryKey(conf.options);
+  return async (url) => getTokenByURL(url, conf.options.identity, keys, def);
 };
 
 export {

package/chunk-GCTREKA4.js

@@ -0,0 +1,115 @@
+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 {
+  isInside,
+  samePath
+} from "./chunk-MCDLJZXT.js";
+import {
+  isDepID
+} from "./chunk-CAV7FKWQ.js";
+import {
+  isObject
+} from "./chunk-BF5DRGRZ.js";
+
+// ../../src/cli-sdk/src/global-state.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmod,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+var globalStateFile = (root) => resolve(root, "global-state.json");
+var readGlobalState = async (root) => {
+  let data;
+  try {
+    data = JSON.parse(await readFile(globalStateFile(root), "utf8"));
+  } catch {
+    return {};
+  }
+  if (!isObject(data)) return {};
+  const state = { ...data };
+  const { binDirs, localBinNoticed } = state;
+  if (Array.isArray(binDirs)) {
+    state.binDirs = binDirs.filter(
+      (d) => typeof d === "string" && isAbsolute(d)
+    );
+  } else delete state.binDirs;
+  if (Array.isArray(state.pendingRemove)) {
+    state.pendingRemove = state.pendingRemove.filter(
+      (d) => typeof d === "string" && isAbsolute(d)
+    );
+  } else delete state.pendingRemove;
+  if (typeof localBinNoticed !== "boolean")
+    delete state.localBinNoticed;
+  if (state.pathSetup !== "declined") delete state.pathSetup;
+  return state;
+};
+var writeFileAtomic = async (file, data, mode) => {
+  const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, data, {
+      flag: "wx",
+      ...mode === void 0 ? {} : { mode }
+    });
+    if (mode !== void 0) await chmod(tmp, mode);
+    await rename(tmp, file);
+  } catch (er) {
+    await rm(tmp, { force: true });
+    throw er;
+  }
+};
+var writeJsonAtomic = (file, data) => writeFileAtomic(file, JSON.stringify(data, null, 2) + "\n");
+var updateGlobalState = async (root, fn) => {
+  const state = fn(await readGlobalState(root));
+  await writeJsonAtomic(globalStateFile(root), state);
+  return state;
+};
+var sweepPendingRemove = async (root) => {
+  try {
+    const { pendingRemove = [] } = await readGlobalState(root);
+    if (!pendingRemove.length) return;
+    const store = resolve(await realpath(root), "node_modules/.vlt");
+    const script = process.argv[1];
+    const running = script && await realpath(script).catch(() => void 0);
+    const left = [];
+    for (const entry of pendingRemove) {
+      if (!samePath(dirname(entry), store) || !isDepID(basename(entry))) {
+        continue;
+      }
+      if (running && isInside(entry, running)) {
+        left.push(entry);
+        continue;
+      }
+      await rm(entry, { recursive: true, force: true }).catch(
+        () => left.push(entry)
+      );
+    }
+    if (left.length === pendingRemove.length) return;
+    await updateGlobalState(root, (s) => ({
+      ...s,
+      pendingRemove: left
+    }));
+  } catch {
+  }
+};
+
+export {
+  readGlobalState,
+  writeFileAtomic,
+  writeJsonAtomic,
+  updateGlobalState,
+  sweepPendingRemove
+};

package/{chunk-G3FZ2ZJK.js → chunk-GEQFMH5M.js}

@@ -14,7 +14,7 @@ var require = _vlt_createRequire(import.meta.filename);
 var package_default = {
   name: "@vltpkg/user-agent",
   description: "The User-Agent string that vlt sends with every outbound request",
-  version: "1.5.0",
+  version: "1.6.0",
   repository: {
     type: "git",
     url: "git+https://github.com/vltpkg/vltpkg.git",

package/{chunk-CS6AYPY5.js → chunk-GZVI75KX.js}

@@ -12,17 +12,17 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   addKey,
   asDependency
-} from "./chunk-2U4PVHP4.js";
+} from "./chunk-F5LZMLAQ.js";
 import {
-  asUnknownSpecPrefix
-} from "./chunk-UZ6ICZE3.js";
+  parseSpecArg
+} from "./chunk-7M2VTFLP.js";
 import {
   joinDepIDTuple,
   splitDepID
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   Spec
-} from "./chunk-LUVDMEW4.js";
+} from "./chunk-6D3QAFNZ.js";
 
 // ../../src/cli-sdk/src/parse-add-remove-args.ts
 import { isAbsolute, relative, resolve } from "node:path";
@@ -68,13 +68,6 @@ var rebaseFileSpec = (spec, importerPath, scurryCwd, specOptions, monorepo) => {
   if (rebasedPath === spec.file) return spec;
   return Spec.parseArgs(rebasedPath, specOptions);
 };
-var parseArg = (item, options) => {
-  try {
-    return Spec.parseArgs(item, options);
-  } catch (er) {
-    throw asUnknownSpecPrefix(er);
-  }
-};
 var parseAddArgs = (config, scurry, monorepo) => {
   const add = new AddImportersDependenciesMapImpl();
   const items = config.positionals;
@@ -84,7 +77,7 @@ var parseAddArgs = (config, scurry, monorepo) => {
   const parsedItems = [];
   let hasFileSpecs = false;
   for (const item of items) {
-    const spec = parseArg(item, specOptions);
+    const spec = parseSpecArg(item, specOptions);
     parsedItems.push({ spec, type });
     if (spec.type === "file") hasFileSpecs = true;
     add.modifiedDependencies = true;

package/{chunk-CW56EJIL.js → chunk-HT6FS4VB.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   commandAliases,
   jack
-} from "./chunk-CMLDLZZ3.js";
+} from "./chunk-EFHOWRKU.js";
 
 // ../../src/cli-sdk/src/config/usage.ts
 var toArr = (v) => Array.isArray(v) ? v : [v];

package/{chunk-LH7J5BDU.js → chunk-IXAMCWIT.js}

@@ -11,13 +11,13 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   openUrl
-} from "./chunk-7UWRR6EE.js";
+} from "./chunk-22LZBDEC.js";
 import {
   mermaidOutput
-} from "./chunk-4UH3KMTD.js";
+} from "./chunk-36UIE654.js";
 import {
   stderr
-} from "./chunk-WHWPAYZY.js";
+} from "./chunk-KVWGMSPW.js";
 import {
   ViewClass
 } from "./chunk-4KCU2KZL.js";

package/{chunk-ARE7FKDG.js → chunk-JCNI6ZHH.js}

@@ -12,13 +12,13 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   actual,
   createVirtualRoot
-} from "./chunk-4UH3KMTD.js";
+} from "./chunk-36UIE654.js";
 import {
   callLimit
-} from "./chunk-2U4PVHP4.js";
+} from "./chunk-F5LZMLAQ.js";
 import {
   SecurityArchive
-} from "./chunk-SMXXFQPI.js";
+} from "./chunk-YTDABXPD.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -142,8 +142,8 @@ var reloadConfig = async (folder) => {
     unload("project");
   } catch {
   }
-  const { Config } = await import("./config-TMB2X6DW.js");
-  return Config.load(folder, process.argv, true);
+  const { Config } = await import("./config-EKHBW6I5.js");
+  return Config.load(folder, process.argv, true, false);
 };
 
 // ../../src/cli-sdk/src/query-host-contexts.ts