@vltpkg/cli-js 1.1.0 → 1.2.0

package/{src-MOKZQTH2.js → chunk-QA6RE2GS.js}

@@ -13,19 +13,78 @@ import {
   rimraf,
   rimrafSync
 } from "./chunk-BHJT53TP.js";
-import "./chunk-VE6CCH33.js";
+import {
+  isManifest,
+  normalizeBinPaths
+} from "./chunk-G5BSQ6DP.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
-import "./chunk-PZLD7RTK.js";
+
+// ../../src/tar/src/store-index.ts
+import { readFileSync } from "node:fs";
+import { debuglog } from "node:util";
+var debug = debuglog("vlt");
+var storeIndexPath = (storeEntry) => storeEntry + ".json";
+var isRecord = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+var isOptString = (x) => x === void 0 || typeof x === "string";
+var unsafePath = /(?:^|\/)\.{0,2}(?:\/|$)|\\/;
+var isRelPath = (p) => typeof p === "string" && !unsafePath.test(p);
+var isIndexFile = (f) => Array.isArray(f) && f.length === 3 && isRelPath(f[0]) && typeof f[1] === "number" && (f[2] === 0 || f[2] === 1);
+var isStoreIndex = (x) => isRecord(x) && x.v === 1 && typeof x.scripts === "boolean" && isOptString(x.name) && isOptString(x.version) && (x.bins === void 0 || isRecord(x.bins) && Object.values(x.bins).every((b) => typeof b === "string")) && Array.isArray(x.dirs) && x.dirs.every(isRelPath) && Array.isArray(x.files) && x.files.every(isIndexFile) && isOptString(x.manifest);
+var readStoreIndex = (storeEntry) => {
+  let index;
+  try {
+    index = JSON.parse(
+      readFileSync(storeIndexPath(storeEntry), "utf8")
+    );
+  } catch (er) {
+    if (er.code !== "ENOENT") {
+      debug("global store: invalid index", storeEntry);
+    }
+    return void 0;
+  }
+  if (isStoreIndex(index)) return index;
+  debug("global store: invalid index", storeEntry);
+  return void 0;
+};
+var storeIndexManifest = (packageJson, bindingGyp) => {
+  let pkg;
+  try {
+    pkg = JSON.parse(
+      packageJson.toString("utf8").replace(/^\uFEFF/, "")
+    );
+  } catch (cause) {
+    throw error("invalid package.json in tarball", { cause });
+  }
+  if (!isRecord(pkg)) {
+    throw error("invalid package.json in tarball", { found: pkg });
+  }
+  const { name: name2, version, scripts, bin } = pkg;
+  const s = isRecord(scripts) ? scripts : {};
+  const result = {
+    scripts: !!(s.install || s.preinstall || s.postinstall) || bindingGyp
+  };
+  const bins = normalizeBinPaths({
+    name: typeof name2 === "string" ? name2 : void 0,
+    bin
+  });
+  if (bins && Object.keys(bins).length) result.bins = bins;
+  if (typeof name2 === "string") result.name = name2;
+  if (typeof version === "string") result.version = version;
+  if (isManifest(pkg)) result.manifest = JSON.stringify(pkg);
+  return result;
+};
 
 // ../../src/tar/src/unpack.ts
 import { randomBytes } from "node:crypto";
 import {
+  chmodSync,
   lstatSync,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   renameSync,
+  statSync,
   writeFileSync
 } from "node:fs";
 import { lstat, mkdir, rename, writeFile } from "node:fs/promises";
@@ -33,6 +92,7 @@ import {
   basename as basename2,
   dirname,
   isAbsolute,
+  join,
   relative,
   resolve,
   sep
@@ -688,7 +748,7 @@ var unpackSync = (tarData, target) => {
   const isGzip = tarData[0] === 31 && tarData[1] === 139;
   unpackUnzippedSync(isGzip ? unzipSync(tarData) : tarData, target);
 };
-var unpackFileSync = (file, target, offset = 0) => unpackSync(readFileSync(file).subarray(offset), target);
+var unpackFileSync = (file, target, offset = 0) => unpackSync(readFileSync2(file).subarray(offset), target);
 var tmpName = (target) => dirname(target) + sep + "." + basename2(target) + "." + tmpSuffix();
 var parseTarball = (buffer, tmp2) => {
   const isGzip = buffer[0] === 31 && buffer[1] === 139;
@@ -863,32 +923,193 @@ var unpackUnzippedSync = (buffer, target) => {
     }
   }
 };
+var storeLayout = (tarData, dir) => {
+  const isGzip = tarData[0] === 31 && tarData[1] === 139;
+  const { dirs, files } = parseTarball(
+    isGzip ? unzipSync(tarData) : tarData,
+    dir
+  );
+  const rel = (p) => relative(dir, p).replace(/\\/g, "/");
+  const list = files.map((f) => [rel(f.path), f]);
+  const pj = list.find(([p]) => p === "package.json")?.[1];
+  if (!pj) throw error("no package.json in tarball", { path: dir });
+  const manifest = storeIndexManifest(
+    pj.body,
+    list.some(([p]) => p === "binding.gyp")
+  );
+  const bins = new Set(
+    Object.values(manifest.bins ?? {}).map(entryKey)
+  );
+  const indexFiles = [];
+  const binFiles = [];
+  for (const [p, f] of list) {
+    if (bins.has(entryKey(p))) {
+      f.executable = true;
+      binFiles.push(f.path);
+    }
+    indexFiles.push([p, f.body.length, f.executable ? 1 : 0]);
+  }
+  const allDirs = /* @__PURE__ */ new Set();
+  for (const d of dirs) {
+    for (let p = rel(d); p && !allDirs.has(p); ) {
+      allDirs.add(p);
+      p = p.slice(0, Math.max(0, p.lastIndexOf("/")));
+    }
+  }
+  const indexDirs = [...allDirs].sort().sort((a, b) => a.length - b.length);
+  return {
+    index: {
+      v: 1,
+      files: indexFiles.sort((a, b) => a[0] < b[0] ? -1 : 1),
+      dirs: indexDirs,
+      ...manifest
+    },
+    files,
+    binFiles
+  };
+};
+var unpackToStoreSync = (tarData, dir) => {
+  const { index, files, binFiles } = storeLayout(tarData, dir);
+  mkdirSync(dirname(dir), { recursive: true });
+  mkdirSync(dir, { mode: 511 });
+  let succeeded = false;
+  try {
+    for (const d of index.dirs) {
+      mkdirSync(join(dir, d), { recursive: true, mode: 511 });
+    }
+    for (const f of files) {
+      writeFileSync(f.path, f.body, {
+        mode: f.executable ? 511 : 438
+      });
+    }
+    let binMode = 0;
+    for (const p of binFiles) {
+      binMode ||= statSync(p).mode & 511 | 73;
+      chmodSync(p, binMode);
+    }
+    succeeded = true;
+  } finally {
+    if (!succeeded) rimrafSync(dir);
+  }
+  return { index };
+};
 
-// ../../src/tar/src/pool.ts
-import { readFile } from "node:fs/promises";
-var syncUnpack = process.env.VLT_TAR_SYNC !== "0";
-var Pool = class {
-  /**
-   * Provide the tardata to be unpacked, and the location where it's to be
-   * placed. Resolves when the tarball has been extracted.
-   */
-  async unpack(tarData, target) {
-    if (!syncUnpack) return unpack(tarData, target);
-    unpackSync(tarData, target);
-  }
-  /**
-   * Same, reading the tarball from a file and skipping `offset` leading
-   * bytes, so a cache entry is unpacked without loading it into the
-   * registry client's in-memory cache.
-   */
-  async unpackFile(file, target, offset = 0) {
-    if (!syncUnpack) {
-      return unpack((await readFile(file)).subarray(offset), target);
-    }
-    unpackFileSync(file, target, offset);
+// ../../src/tar/src/store-entry.ts
+import {
+  closeSync,
+  lstatSync as lstatSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync3,
+  statSync as statSync2
+} from "node:fs";
+import { join as join2, relative as relative2 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+var noThrow = { throwIfNoEntry: false };
+var entryName = /^([0-9a-f]{128})(?:\.json|\.copied)?$/;
+var relPath = (from, to) => relative2(from, to).replace(/\\/g, "/");
+var storeEntryNames = (root) => {
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return [];
+  }
+  const hexes = /* @__PURE__ */ new Set();
+  for (const name2 of names) {
+    const hex = entryName.exec(name2)?.[1];
+    if (hex) hexes.add(hex);
+  }
+  return [...hexes].sort();
+};
+var storeCopiedPath = (storeEntry) => storeEntry + ".copied";
+var markStoreEntryCopied = (storeEntry) => {
+  try {
+    closeSync(openSync(storeCopiedPath(storeEntry), "wx"));
+  } catch {
   }
 };
+var removeStoreEntry = (storeEntry) => {
+  rimrafSync(storeEntry);
+  rimrafSync(storeIndexPath(storeEntry));
+  rimrafSync(storeCopiedPath(storeEntry));
+};
+var storeEntryTime = (storeEntry) => (statSync2(storeIndexPath(storeEntry), noThrow) ?? statSync2(storeEntry, noThrow))?.mtimeMs ?? 0;
+var storeEntryCopied = (storeEntry, index = readStoreIndex(storeEntry)) => !!index && (index.scripts || !!lstatSync2(storeCopiedPath(storeEntry), noThrow)) && !!lstatSync2(storeEntry, noThrow)?.isDirectory();
+var storeEntryLinked = (storeEntry, index = readStoreIndex(storeEntry)) => !!index?.files.some(
+  ([p]) => (lstatSync2(join2(storeEntry, p), noThrow)?.nlink ?? 1) > 1
+);
+var indexKeys = [
+  "v",
+  "files",
+  "dirs",
+  "scripts",
+  "bins",
+  "name",
+  "version"
+];
+var verifyStoreEntry = (storeEntry, tarData) => {
+  let layout;
+  try {
+    layout = storeLayout(tarData, storeEntry);
+  } catch {
+    return "bad tarball";
+  }
+  const index = readStoreIndex(storeEntry);
+  if (!index) return "no index";
+  if (indexKeys.some(
+    (k) => !isDeepStrictEqual(index[k], layout.index[k])
+  ) || index.manifest !== void 0 && index.manifest !== layout.index.manifest) {
+    return "index differs";
+  }
+  const found = /* @__PURE__ */ new Set();
+  try {
+    for (const d of readdirSync(storeEntry, {
+      recursive: true,
+      withFileTypes: true
+    })) {
+      if (!d.isDirectory()) {
+        found.add(relPath(storeEntry, join2(d.parentPath, d.name)));
+      }
+    }
+  } catch {
+    return "missing";
+  }
+  const modes = process.platform !== "win32";
+  for (const f of layout.files) {
+    const p = relPath(storeEntry, f.path);
+    if (!found.delete(p)) return `missing ${p}`;
+    let body;
+    let mode;
+    try {
+      mode = statSync2(f.path).mode;
+      body = readFileSync3(f.path);
+    } catch {
+      return `unreadable ${p}`;
+    }
+    if (!body.equals(f.body)) return `modified ${p}`;
+    if (modes && (mode & 73) !== 0 !== f.executable) {
+      return `mode ${p}`;
+    }
+  }
+  const [extra] = found;
+  return extra === void 0 ? void 0 : `extra ${extra}`;
+};
+
 export {
-  Pool,
-  unpack
+  storeIndexPath,
+  readStoreIndex,
+  unpack,
+  unpackSync,
+  unpackFileSync,
+  tmpName,
+  unpackToStoreSync,
+  storeEntryNames,
+  storeCopiedPath,
+  markStoreEntryCopied,
+  removeStoreEntry,
+  storeEntryTime,
+  storeEntryCopied,
+  storeEntryLinked,
+  verifyStoreEntry
 };

package/chunk-SPRVRSEL.js

@@ -0,0 +1,75 @@
+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";
+import {
+  __glob
+} from "./chunk-PZLD7RTK.js";
+
+// import("./commands/**/*.ts") in ../../src/cli-sdk/src/load-command.ts
+var globImport_commands_ts = __glob({
+  "./commands/access.ts": () => import("./access-FTHPFPUJ.js"),
+  "./commands/bugs.ts": () => import("./bugs-QS6HQUO2.js"),
+  "./commands/build.ts": () => import("./build-H27SXMAS.js"),
+  "./commands/cache.ts": () => import("./cache-IB4HMFDT.js"),
+  "./commands/ci.ts": () => import("./ci-XJBYXFFJ.js"),
+  "./commands/config.ts": () => import("./config-H2Q4ABSS.js"),
+  "./commands/create.ts": () => import("./create-LUYL2QI4.js"),
+  "./commands/deprecate.ts": () => import("./deprecate-5ANCI2L6.js"),
+  "./commands/dist-tag.ts": () => import("./dist-tag-SD2CRWIL.js"),
+  "./commands/docs.ts": () => import("./docs-B6LVNWTP.js"),
+  "./commands/exec-cache.ts": () => import("./exec-cache-EE7DAOW2.js"),
+  "./commands/exec-local.ts": () => import("./exec-local-HT3VBN6S.js"),
+  "./commands/exec.ts": () => import("./exec-CJ5KQA72.js"),
+  "./commands/help.ts": () => import("./help-GZ44WYDS.js"),
+  "./commands/init.ts": () => import("./init-HVXRXFVY.js"),
+  "./commands/install.ts": () => import("./install-E2C7EE6P.js"),
+  "./commands/install/reporter.ts": () => import("./reporter-5BVUNWQ6.js"),
+  "./commands/list.ts": () => import("./list-V4V6SHJP.js"),
+  "./commands/login.ts": () => import("./login-VRFV7MCE.js"),
+  "./commands/logout.ts": () => import("./logout-SU75R7BN.js"),
+  "./commands/pack.ts": () => import("./pack-IVGKUXTL.js"),
+  "./commands/ping.ts": () => import("./ping-WB222SDT.js"),
+  "./commands/pkg.ts": () => import("./pkg-LAAFNONA.js"),
+  "./commands/profile.ts": () => import("./profile-P3AVHRDI.js"),
+  "./commands/publish.ts": () => import("./publish-IUNB3KH5.js"),
+  "./commands/query.ts": () => import("./query-XCN55INS.js"),
+  "./commands/registry.ts": () => import("./registry-QQLWJHJI.js"),
+  "./commands/repo.ts": () => import("./repo-BQDWUCX5.js"),
+  "./commands/run-exec.ts": () => import("./run-exec-XYUI7GLN.js"),
+  "./commands/run.ts": () => import("./run-QT7DX243.js"),
+  "./commands/setup.ts": () => import("./setup-CXDJXRAG.js"),
+  "./commands/token.ts": () => import("./token-CBOK6DMT.js"),
+  "./commands/uninstall.ts": () => import("./uninstall-27VP46KJ.js"),
+  "./commands/unpublish.ts": () => import("./unpublish-F4637OQX.js"),
+  "./commands/update.ts": () => import("./update-NGWLJJ22.js"),
+  "./commands/version.ts": () => import("./version-WPD2KNVC.js"),
+  "./commands/view.ts": () => import("./view-YKFTRRPD.js"),
+  "./commands/whoami.ts": () => import("./whoami-I5Q6RTAP.js")
+});
+
+// ../../src/cli-sdk/src/load-command.ts
+var loadCommand = async (command) => {
+  try {
+    return await globImport_commands_ts(`./commands/${command}.ts`);
+  } catch (e) {
+    throw error("Could not load command", {
+      found: command,
+      cause: e
+    });
+  }
+};
+
+export {
+  loadCommand
+};

package/{chunk-YOE3VZFX.js → chunk-SYGF27W7.js}

@@ -11,12 +11,12 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   Spec as Spec2
-} from "./chunk-XKVU23NC.js";
+} from "./chunk-G5NJ7CYI.js";
 import {
   Spec,
   currentDefaultRegistryName,
   defaultRegistryName
-} from "./chunk-VFBCWAOC.js";
+} from "./chunk-G5BSQ6DP.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";

package/{chunk-TNEMFBP5.js → chunk-UNWQVOLY.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   generateDefaultHelp,
   generateFullHelp
-} from "./chunk-HYCYL4RX.js";
+} from "./chunk-GUATFMMU.js";
 import {
   flush,
   trackCommand,
@@ -20,13 +20,13 @@ import {
 } from "./chunk-G2YT2GWF.js";
 import {
   parseError
-} from "./chunk-GDJ7JT2R.js";
+} from "./chunk-YTT3UHUB.js";
 import {
   hasConfiguredRegistry,
   hasNpmRegistry,
   missingNpmRegistryError,
   missingRegistryError
-} from "./chunk-2PWSMJD7.js";
+} from "./chunk-O44Z6MAV.js";
 import {
   isLazyView,
   isViewClass,
@@ -35,20 +35,20 @@ import {
 import {
   isGraphRunError,
   splitDepID
-} from "./chunk-YOE3VZFX.js";
+} from "./chunk-SYGF27W7.js";
 import {
   defaultView
-} from "./chunk-CEHPRPGQ.js";
+} from "./chunk-6A3XS52F.js";
 import {
   emitter
 } from "./chunk-U7TEQCBN.js";
-import {
-  isErrorWithCause,
-  isObject
-} from "./chunk-VFBCWAOC.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";
+import {
+  isErrorWithCause,
+  isObject
+} from "./chunk-G5BSQ6DP.js";
 
 // ../../src/cli-sdk/src/print-err.ts
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -64,7 +64,7 @@ var formatURL = (v, format) => v instanceof URL ? v.toString() : (
   /* c8 ignore next */
   format(v)
 );
-var hasCustomToString = (v) => isObject(v) && v.toString !== Object.prototype.toString;
+var hasCustomToString = (v) => typeof v === "object" && v !== null && v.toString !== Object.prototype.toString;
 var formatToString = (v, format) => hasCustomToString(v) ? v.toString() : format(v);
 var formatArray = (v, format, joiner = ", ") => Array.isArray(v) ? v.join(joiner) : (
   /* c8 ignore next */
@@ -209,8 +209,9 @@ var printCode = (err, usage, stderr2, format) => {
       if (from) {
         stderr2(indent(`From: ${format(from)}`));
       }
-      if (response) {
-        stderr2(indent(`Response: ${format(response)}`));
+      const status = response?.statusCode;
+      if (status) {
+        stderr2(indent(`Status: ${format(status)}`));
       }
       return { file: true };
     }
@@ -441,6 +442,7 @@ var tagStyle = (state, statusCode) => {
   switch (state) {
     case "cache":
     case "stale":
+    case "store":
     case "304":
       return "green";
     case "start":

package/{chunk-SNOBGFNM.js → chunk-UQUIO7LW.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   asError,
   isObject
-} from "./chunk-VFBCWAOC.js";
+} from "./chunk-G5BSQ6DP.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -23,15 +23,18 @@ var MAX_DETAIL_LENGTH = 512;
 var truncate = (s) => s.length <= MAX_DETAIL_LENGTH ? s : `${s.slice(0, MAX_DETAIL_LENGTH - 1)}\u2026`;
 var isHTML = (s) => /^\s*(<!doctype\s+html|<html\b)/i.test(s);
 var stripTags = (s) => s.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
-var detailFromJSON = (text) => {
+var parseBody = (text) => {
   let body;
   try {
     body = JSON.parse(text);
   } catch {
     return void 0;
   }
-  if (!body || typeof body !== "object") return void 0;
-  const rec = body;
+  return !body || typeof body !== "object" ? void 0 : body;
+};
+var detailFromJSON = (text) => {
+  const rec = parseBody(text);
+  if (!rec) return void 0;
   const nested = rec.error;
   for (const v of [rec.error, rec.message, nested?.message]) {
     if (typeof v === "string" && v.trim()) return v.trim();
@@ -51,10 +54,41 @@ var registryErrorMessage = (response) => {
   const detail = detailFromJSON(text) ?? (isHTML(text) ? stripTags(text) : text);
   return detail ? `${status} \u2014 ${truncate(detail)}` : status;
 };
+var refusals = {
+  TokenExpiredError: "expired",
+  TokenRevokedError: "revoked"
+};
+var accountSlug = /^(?=.{3,63}$)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var tokenRefusal = (response) => {
+  const res = response;
+  if (typeof res !== "object" || res?.statusCode !== 401)
+    return void 0;
+  let text = "";
+  try {
+    if (typeof res.text === "function") text = res.text();
+  } catch {
+    return void 0;
+  }
+  const code = parseBody(text)?.code;
+  return typeof code === "string" ? refusals[code] : void 0;
+};
+var tokenRefusalAdvice = (response, url) => {
+  const gone = tokenRefusal(response);
+  if (!gone || url === void 0) return void 0;
+  let account;
+  try {
+    account = new URL(String(url)).pathname.split("/")[1];
+  } catch {
+    return void 0;
+  }
+  if (!account || !accountSlug.test(account)) return void 0;
+  return `Your token for the "${account}" account ${gone === "expired" ? "has expired" : "was revoked"}. Run \`vlt setup ${account}\` to log in again.`;
+};
 var registryError = (response, { message, url, method = "GET", advice }, from, cause) => {
   const { statusCode } = response;
   const denied = statusCode === 401 || statusCode === 403;
-  const extra = advice?.(statusCode);
+  const refused = tokenRefusalAdvice(response, url);
+  const extra = refused ?? advice?.(statusCode);
   const tips = (Array.isArray(extra) ? extra : [extra]).filter(
     (t) => !!t
   );
@@ -122,8 +156,15 @@ var requestError = (err, { message, url, method = "GET", advice }) => {
   );
 };
 
+// ../../src/registry-client/src/store-root.ts
+import { resolve } from "node:path";
+var storeRoot = (cache) => resolve(cache, "store", "v1");
+
 export {
   registryErrorMessage,
+  tokenRefusal,
+  tokenRefusalAdvice,
   assertOk,
-  requestError
+  requestError,
+  storeRoot
 };

package/{chunk-TUXWDPCQ.js → chunk-VHHLO5L6.js}

@@ -19,7 +19,7 @@ var run = async (command) => {
   if (command) {
     process.argv.splice(2, 0, command);
   }
-  const vlt = await import("./src-BNCFK4FH.js");
+  const vlt = await import("./src-UBAERP25.js");
   await vlt.default();
 };
 

package/{chunk-6LEMBT22.js → chunk-YFNQ6HZ3.js}

@@ -13,10 +13,10 @@ import {
   actual,
   callLimit,
   createVirtualRoot
-} from "./chunk-47M7IZ5P.js";
+} from "./chunk-B2FK2HHL.js";
 import {
   SecurityArchive
-} from "./chunk-ZDQJWRCU.js";
+} from "./chunk-FOJCK57G.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -140,7 +140,7 @@ var reloadConfig = async (folder) => {
     unload("project");
   } catch {
   }
-  const { Config } = await import("./config-ZPH7V77F.js");
+  const { Config } = await import("./config-4Y46SH5K.js");
   return Config.load(folder, process.argv, true);
 };
 

package/{chunk-GDJ7JT2R.js → chunk-YTT3UHUB.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   isError,
   isObject
-} from "./chunk-VFBCWAOC.js";
+} from "./chunk-G5BSQ6DP.js";
 
 // ../../src/output/src/error.ts
 var parseError = (err) => {

package/{ci-O2RSLTBX.js → ci-XJBYXFFJ.js}

@@ -11,25 +11,25 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   install
-} from "./chunk-47M7IZ5P.js";
-import "./chunk-ZDQJWRCU.js";
+} from "./chunk-B2FK2HHL.js";
+import "./chunk-FOJCK57G.js";
 import {
   commandUsage
-} from "./chunk-CBASIDQH.js";
-import "./chunk-X2AWQGYG.js";
+} from "./chunk-55DYW2MP.js";
+import "./chunk-6G7MTZGS.js";
 import {
   lazyView
 } from "./chunk-4KCU2KZL.js";
-import "./chunk-YOE3VZFX.js";
-import "./chunk-XKVU23NC.js";
-import "./chunk-CEHPRPGQ.js";
+import "./chunk-SYGF27W7.js";
+import "./chunk-G5NJ7CYI.js";
+import "./chunk-6A3XS52F.js";
 import "./chunk-HTOTG4TS.js";
-import "./chunk-E74WGW5C.js";
+import "./chunk-JTUZP2OD.js";
 import "./chunk-U7TEQCBN.js";
-import "./chunk-VFBCWAOC.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-BHJT53TP.js";
 import "./chunk-VE6CCH33.js";
+import "./chunk-G5BSQ6DP.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 
@@ -59,7 +59,7 @@ var usage = () => commandUsage({
 var views = {
   json: (i) => i.graph.toJSON(),
   human: lazyView(
-    async () => (await import("./reporter-ZW7OMRZT.js")).InstallReporter
+    async () => (await import("./reporter-5BVUNWQ6.js")).InstallReporter
   )
 };
 var command = async (conf) => {

package/cli-package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/cli-sdk",
   "description": "The source for the vlt CLI",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -28,6 +28,7 @@
     "@vltpkg/run": "workspace:*",
     "@vltpkg/security-archive": "workspace:*",
     "@vltpkg/spec": "workspace:*",
+    "@vltpkg/tar": "workspace:*",
     "@vltpkg/types": "workspace:*",
     "@vltpkg/url-open": "workspace:*",
     "@vltpkg/vlt-json": "workspace:*",