@vltpkg/cli-js 1.0.8 → 1.0.10

package/{setup-MWWDSKQZ.js → setup-BTBU3NAI.js}

@@ -12,39 +12,42 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   configWriteTarget,
   registrySelectionFields
-} from "./chunk-WY4PAM6D.js";
-import "./chunk-YCVPEZRM.js";
+} from "./chunk-NA732FNL.js";
+import "./chunk-P5S2TFCF.js";
 import "./chunk-ZWKI5OSF.js";
 import {
   stdout
-} from "./chunk-JXVDCQZF.js";
-import "./chunk-YAIKXFLN.js";
+} from "./chunk-VL7RJVNN.js";
+import "./chunk-5HBKYSTX.js";
 import "./chunk-G2YT2GWF.js";
 import "./chunk-GDJ7JT2R.js";
 import "./chunk-5JFRXIK2.js";
 import "./chunk-WGDTG44V.js";
-import "./chunk-OWML62W5.js";
+import "./chunk-USTJECVS.js";
 import "./chunk-YOE3VZFX.js";
 import {
   commandUsage
-} from "./chunk-PTR5IGFQ.js";
+} from "./chunk-5HPGL5WS.js";
 import "./chunk-XKVU23NC.js";
-import "./chunk-XISRK3R5.js";
+import "./chunk-MNK55XSE.js";
 import "./chunk-4KCU2KZL.js";
 import "./chunk-HTOTG4TS.js";
 import {
   RegistryClient
-} from "./chunk-AGHW2E24.js";
+} from "./chunk-NWLS3VOQ.js";
 import "./chunk-HAYXR3MW.js";
 import "./chunk-E74WGW5C.js";
 import "./chunk-LPIBYUMT.js";
 import "./chunk-UBLFPJHV.js";
-import "./chunk-XNLSTHDK.js";
-import "./chunk-BJBFEQRR.js";
-import "./chunk-VE6CCH33.js";
 import {
-  defaultRegistries
+  asError,
+  defaultRegistries,
+  isErrorWithCause,
+  isObject
 } from "./chunk-VFBCWAOC.js";
+import "./chunk-XNLSTHDK.js";
+import "./chunk-BHJT53TP.js";
+import "./chunk-VE6CCH33.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -56,6 +59,17 @@ var VLT_SIGNUP_URL = "https://www.vlt.io";
 var VLT_REGISTRY_BASE = "https://registry.vlt.io";
 var accountRegistries = ["npm", "main"];
 var accountRegistryURL = (account, name) => `${VLT_REGISTRY_BASE}/${encodeURIComponent(account)}/${name}/`;
+var accountAuthError = (account, er) => isErrorWithCause(er) && isObject(er.cause) && er.cause.status === 404 ? error(
+  [
+    `No vlt.io account or organization named "${account}".`,
+    "",
+    `Looked for it at ${accountRegistryURL(account, accountRegistries[0])}`,
+    "",
+    "Check the spelling of the slug, or sign up / create the",
+    `organization at ${VLT_SIGNUP_URL}, then run \`vlt setup\` again.`
+  ].join("\n"),
+  { code: "ECONFIG", cause: er }
+) : asError(er);
 var normalizeRegistryURL = (url) => url.endsWith("/") ? url : `${url}/`;
 var views = {
   human: (result) => {
@@ -157,11 +171,15 @@ var command = async (conf) => {
             ", "
           )})...`
         );
-        await rc.login(
-          accountRegistries.map(
-            (name) => accountRegistryURL(account, name)
-          )
-        );
+        try {
+          await rc.login(
+            accountRegistries.map(
+              (name) => accountRegistryURL(account, name)
+            )
+          );
+        } catch (er) {
+          throw accountAuthError(account, er);
+        }
       }
       for (; ; ) {
         const more = await ask("Add another registry alias? (y/N) ");

package/{src-6UF5YTTL.js → src-23VBKASP.js}

@@ -11,11 +11,11 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   loadCommand
-} from "./chunk-AQ3XJJUP.js";
+} from "./chunk-Y3QEV76Q.js";
 import {
   Config
-} from "./chunk-WY4PAM6D.js";
-import "./chunk-YCVPEZRM.js";
+} from "./chunk-NA732FNL.js";
+import "./chunk-P5S2TFCF.js";
 import "./chunk-ZWKI5OSF.js";
 import {
   flushAndExit,
@@ -23,21 +23,21 @@ import {
   outputCommand,
   stderr,
   stdout
-} from "./chunk-JXVDCQZF.js";
-import "./chunk-YAIKXFLN.js";
+} from "./chunk-VL7RJVNN.js";
+import "./chunk-5HBKYSTX.js";
 import "./chunk-G2YT2GWF.js";
 import {
   asRootError
 } from "./chunk-GDJ7JT2R.js";
 import "./chunk-5JFRXIK2.js";
 import "./chunk-WGDTG44V.js";
-import "./chunk-OWML62W5.js";
+import "./chunk-USTJECVS.js";
 import "./chunk-YOE3VZFX.js";
 import "./chunk-XKVU23NC.js";
 import {
   getSortedCliOptions,
   getSortedKeys
-} from "./chunk-XISRK3R5.js";
+} from "./chunk-MNK55XSE.js";
 import "./chunk-4KCU2KZL.js";
 import "./chunk-HTOTG4TS.js";
 import {
@@ -45,9 +45,9 @@ import {
 } from "./chunk-E74WGW5C.js";
 import "./chunk-LPIBYUMT.js";
 import "./chunk-UBLFPJHV.js";
+import "./chunk-VFBCWAOC.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-VE6CCH33.js";
-import "./chunk-VFBCWAOC.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 
@@ -121,7 +121,7 @@ var run = async () => {
     return flushAndExit(process.exitCode || 1);
   }
   if (vlt.command === "registry") {
-    const { dispatchRegistry } = await import("./registry-BMWXMQS4.js");
+    const { dispatchRegistry } = await import("./registry-ONSDWNPV.js");
     await dispatchRegistry(vlt);
   }
   const command = await loadCommand(vlt.command);

package/{src-6PISL6QX.js → src-J4BAYOBO.js}

@@ -28,15 +28,15 @@ import {
   setRuntimeToken,
   setToken,
   userAgent
-} from "./chunk-AGHW2E24.js";
+} from "./chunk-NWLS3VOQ.js";
 import "./chunk-HAYXR3MW.js";
 import "./chunk-E74WGW5C.js";
 import "./chunk-LPIBYUMT.js";
 import "./chunk-UBLFPJHV.js";
+import "./chunk-VFBCWAOC.js";
 import "./chunk-XNLSTHDK.js";
-import "./chunk-BJBFEQRR.js";
+import "./chunk-BHJT53TP.js";
 import "./chunk-VE6CCH33.js";
-import "./chunk-VFBCWAOC.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 export {

package/{src-U4EBFPPT.js → src-MOKZQTH2.js}

@@ -10,12 +10,10 @@ globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
-  rimraf
-} from "./chunk-BJBFEQRR.js";
+  rimraf,
+  rimrafSync
+} from "./chunk-BHJT53TP.js";
 import "./chunk-VE6CCH33.js";
-import {
-  asError
-} from "./chunk-VFBCWAOC.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -23,6 +21,13 @@ import "./chunk-PZLD7RTK.js";
 
 // ../../src/tar/src/unpack.ts
 import { randomBytes } from "node:crypto";
+import {
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync
+} from "node:fs";
 import { lstat, mkdir, rename, writeFile } from "node:fs/promises";
 import {
   basename as basename2,
@@ -525,7 +530,7 @@ var parseKVLine = (set, line) => {
 };
 
 // ../../src/tar/src/unpack.ts
-import { unzip as unzipCB } from "node:zlib";
+import { unzip as unzipCB, unzipSync as unzipSyncCB } from "node:zlib";
 
 // ../../src/tar/src/find-tar-dir.ts
 var findTarDir = (path, tarDir) => {
@@ -550,24 +555,30 @@ var parseMaxUnpackedBytes = (raw) => {
 var maxUnpackedBytes = parseMaxUnpackedBytes(
   process.env.VLT_TAR_MAX_UNPACKED_BYTES
 );
+var unzipMax = (len) => Math.min(maxUnpackedBytes, len * MAX_DECOMPRESSION_RATIO);
+var unzipError = (er, found, max) => er.code === "ERR_BUFFER_TOO_LARGE" ? error("tarball exceeds maximum unpacked size", {
+  found,
+  max,
+  cause: er
+}) : er;
 var unzip = async (input) => {
-  const max = Math.min(
-    maxUnpackedBytes,
-    input.length * MAX_DECOMPRESSION_RATIO
-  );
+  const max = unzipMax(input.length);
   return new Promise(
-    (res, rej) => unzipCB(input, { maxOutputLength: max }, (er, result) => {
-      if (!er) return res(result);
-      return rej(
-        er.code === "ERR_BUFFER_TOO_LARGE" ? error("tarball exceeds maximum unpacked size", {
-          found: input.length,
-          max,
-          cause: er
-        }) : er
-      );
-    })
+    (res, rej) => unzipCB(
+      input,
+      { maxOutputLength: max },
+      (er, result) => er ? rej(unzipError(er, input.length, max)) : res(result)
+    )
   );
 };
+var unzipSync = (input) => {
+  const max = unzipMax(input.length);
+  try {
+    return unzipSyncCB(input, { maxOutputLength: max });
+  } catch (er) {
+    throw unzipError(er, input.length, max);
+  }
+};
 var exists = async (path) => {
   try {
     await lstat(path);
@@ -673,7 +684,13 @@ var unpack = async (tarData, target) => {
     target
   );
 };
-var unpackUnzipped = async (buffer, target) => {
+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 tmpName = (target) => dirname(target) + sep + "." + basename2(target) + "." + tmpSuffix();
+var parseTarball = (buffer, tmp2) => {
   const isGzip = buffer[0] === 31 && buffer[1] === 139;
   if (isGzip) {
     throw error("still gzipped after unzipping", {
@@ -689,7 +706,9 @@ var unpackUnzipped = async (buffer, target) => {
   if (buffer.length < 1024) {
     throw error(
       "Invalid tarball: not terminated by 1024 null bytes",
-      { found: buffer.length }
+      {
+        found: buffer.length
+      }
     );
   }
   for (let i = buffer.length - 1024; i < buffer.length; i++) {
@@ -700,86 +719,90 @@ var unpackUnzipped = async (buffer, target) => {
       );
     }
   }
-  const tmp2 = dirname(target) + sep + "." + basename2(target) + "." + tmpSuffix();
-  const og = tmp2 + ".ORIGINAL";
-  let succeeded = false;
-  try {
-    const entries = /* @__PURE__ */ new Map();
-    let tarDir = void 0;
-    let offset = 0;
-    let h;
-    let ex = void 0;
-    let gex = void 0;
-    while (offset < buffer.length && !(h = new Header(buffer, offset, ex, gex)).nullBlock) {
-      offset += 512;
-      ex = void 0;
-      gex = void 0;
-      const size = h.size ?? 0;
-      const body = buffer.subarray(offset, offset + size);
-      if (!h.cksumValid) continue;
-      offset += 512 * Math.ceil(size / 512);
-      switch (h.type) {
-        case "File":
-          if (!tarDir) tarDir = findTarDir(h.path, tarDir);
-          if (!tarDir) continue;
-          if (!checkFs(h, tarDir, tmp2)) continue;
-          {
-            const dest = resolve(tmp2, h.path.substring(tarDir.length));
-            const key = entryKey(dest);
-            if (entries.get(key)?.dir === true) {
-              throw error("file/directory collision in tarball", {
-                path: dest
-              });
-            }
-            entries.set(key, {
-              path: dest,
-              body,
-              executable: 1 === ((h.mode ?? 1638) & 1),
-              dir: false
+  const entries = /* @__PURE__ */ new Map();
+  let tarDir = void 0;
+  let offset = 0;
+  let h;
+  let ex = void 0;
+  let gex = void 0;
+  while (offset < buffer.length && !(h = new Header(buffer, offset, ex, gex)).nullBlock) {
+    offset += 512;
+    ex = void 0;
+    gex = void 0;
+    const size = h.size ?? 0;
+    const body = buffer.subarray(offset, offset + size);
+    if (!h.cksumValid) continue;
+    offset += 512 * Math.ceil(size / 512);
+    switch (h.type) {
+      case "File":
+        if (!tarDir) tarDir = findTarDir(h.path, tarDir);
+        if (!tarDir) continue;
+        if (!checkFs(h, tarDir, tmp2)) continue;
+        {
+          const dest = resolve(tmp2, h.path.substring(tarDir.length));
+          const key = entryKey(dest);
+          if (entries.get(key)?.dir === true) {
+            throw error("file/directory collision in tarball", {
+              path: dest
             });
           }
-          break;
-        case "Directory":
-          if (!tarDir) tarDir = findTarDir(h.path, tarDir);
-          if (!tarDir) continue;
-          if (!checkFs(h, tarDir, tmp2)) continue;
-          {
-            const dest = resolve(tmp2, h.path.substring(tarDir.length));
-            const key = entryKey(dest);
-            if (entries.get(key)?.dir === false) {
-              throw error("file/directory collision in tarball", {
-                path: dest
-              });
-            }
-            entries.set(key, {
-              path: dest,
-              dir: true
+          entries.set(key, {
+            path: dest,
+            body,
+            executable: 1 === ((h.mode ?? 1638) & 1),
+            dir: false
+          });
+        }
+        break;
+      case "Directory":
+        if (!tarDir) tarDir = findTarDir(h.path, tarDir);
+        if (!tarDir) continue;
+        if (!checkFs(h, tarDir, tmp2)) continue;
+        {
+          const dest = resolve(tmp2, h.path.substring(tarDir.length));
+          const key = entryKey(dest);
+          if (entries.get(key)?.dir === false) {
+            throw error("file/directory collision in tarball", {
+              path: dest
             });
           }
-          break;
-        case "GlobalExtendedHeader":
-          gex = Pax.parse(body.toString(), gex, true);
-          break;
-        case "ExtendedHeader":
-        case "OldExtendedHeader":
-          ex = Pax.parse(body.toString(), ex, false);
-          break;
-        case "NextFileHasLongPath":
-        case "OldGnuLongPath":
-          ex ??= /* @__PURE__ */ Object.create(null);
-          ex.path = body.toString().replace(/\0.*/, "");
-          break;
-      }
-    }
-    const dirs = /* @__PURE__ */ new Set();
-    const files = [];
-    for (const e of entries.values()) {
-      if (e.dir) dirs.add(e.path);
-      else {
-        dirs.add(dirname(e.path));
-        files.push(e);
-      }
-    }
+          entries.set(key, {
+            path: dest,
+            dir: true
+          });
+        }
+        break;
+      case "GlobalExtendedHeader":
+        gex = Pax.parse(body.toString(), gex, true);
+        break;
+      case "ExtendedHeader":
+      case "OldExtendedHeader":
+        ex = Pax.parse(body.toString(), ex, false);
+        break;
+      case "NextFileHasLongPath":
+      case "OldGnuLongPath":
+        ex ??= /* @__PURE__ */ Object.create(null);
+        ex.path = body.toString().replace(/\0.*/, "");
+        break;
+    }
+  }
+  const dirs = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const e of entries.values()) {
+    if (e.dir) dirs.add(e.path);
+    else {
+      dirs.add(dirname(e.path));
+      files.push(e);
+    }
+  }
+  return { dirs, files };
+};
+var unpackUnzipped = async (buffer, target) => {
+  const tmp2 = tmpName(target);
+  const og = tmp2 + ".ORIGINAL";
+  let succeeded = false;
+  try {
+    const { dirs, files } = parseTarball(buffer, tmp2);
     rethrowFirst(
       await Promise.allSettled(
         [...dirs].map(
@@ -809,128 +832,63 @@ var unpackUnzipped = async (buffer, target) => {
     }
   }
 };
-
-// ../../src/tar/src/pool.ts
-import os from "node:os";
-
-// ../../src/tar/src/unpack-request.ts
-var ID = 1;
-var UnpackRequest = class {
-  id = ID++;
-  tarData;
-  target;
-  resolve;
-  reject;
-  promise = new Promise((res, rej) => {
-    this.resolve = res;
-    this.reject = rej;
-  });
-  constructor(tarData, target) {
-    this.tarData = tarData;
-    this.target = target;
-  }
-};
-
-// ../../src/tar/src/worker.ts
-var isObj = (o) => !!o && typeof o === "object";
-var isResponseOK = (o) => isObj(o) && typeof o.id === "number" && o.ok === true;
-var Worker = class {
-  onMessage;
-  constructor(onMessage) {
-    this.onMessage = onMessage;
-  }
-  async process(req) {
-    const { target, tarData, id: id2 } = req;
-    try {
-      await unpack(tarData, target);
-      const m = { id: id2, ok: true };
-      this.onMessage(m);
-    } catch (error2) {
-      const m = { id: id2, error: error2 };
-      this.onMessage(m);
+var unpackUnzippedSync = (buffer, target) => {
+  const tmp2 = tmpName(target);
+  const og = tmp2 + ".ORIGINAL";
+  let succeeded = false;
+  try {
+    const { dirs, files } = parseTarball(buffer, tmp2);
+    for (const d of dirs) {
+      mkdirSync(d, { recursive: true, mode: 511 });
+    }
+    for (const f of files) {
+      writeFileSync(f.path, f.body, {
+        mode: f.executable ? 511 : 438
+      });
+    }
+    const targetExists = !!lstatSync(target, {
+      throwIfNoEntry: false
+    });
+    if (targetExists) renameSync(target, og);
+    renameSync(tmp2, target);
+    if (targetExists) rimrafSync(og);
+    succeeded = true;
+  } finally {
+    if (!succeeded) {
+      if (lstatSync(og, { throwIfNoEntry: false })) {
+        rimrafSync(target);
+        renameSync(og, target);
+      }
+      rimrafSync(tmp2);
     }
   }
 };
 
 // ../../src/tar/src/pool.ts
+import { readFile } from "node:fs/promises";
+var syncUnpack = process.env.VLT_TAR_SYNC !== "0";
 var Pool = class {
   /**
-   * Number of workers to employ. Defaults to 8 times one less than
-   * the number of available CPUs, with a minimum of 8.
-   */
-  /* c8 ignore next */
-  jobs = 8 * (Math.max(os.availableParallelism(), 2) - 1);
-  /**
-   * Set of currently active worker threads
-   */
-  workers = /* @__PURE__ */ new Set();
-  /**
-   * Queue of requests awaiting an available worker
-   */
-  queue = [];
-  /**
-   * All requests that have not yet been confirmed completed, both
-   * those currently assigned to a worker and those still waiting in
-   * the queue. Entries are removed once the request resolves or
-   * rejects, releasing the reference to its tarball buffer.
+   * Provide the tardata to be unpacked, and the location where it's to be
+   * placed. Resolves when the tarball has been extracted.
    */
-  pending = /* @__PURE__ */ new Map();
-  // handle a message from the worker
-  #onMessage(w, m) {
-    const { id: id2 } = m;
-    const ur = this.pending.get(id2);
-    if (!ur) return;
-    this.pending.delete(id2);
-    if (isResponseOK(m)) {
-      ur.resolve();
-    } else {
-      ur.reject(
-        error(
-          asError(m.error, "failed without error message").message,
-          {
-            found: m,
-            cause: m.error
-          }
-        )
-      );
-    }
-    const next = this.queue.shift();
-    if (!next) {
-      this.workers.delete(w);
-    } else {
-      void w.process(next);
-    }
-  }
-  // create a new worker
-  #createWorker(req) {
-    const w = new Worker(
-      (m) => this.#onMessage(w, m)
-    );
-    this.workers.add(w);
-    void w.process(req);
+  async unpack(tarData, target) {
+    if (!syncUnpack) return unpack(tarData, target);
+    unpackSync(tarData, target);
   }
   /**
-   * Provide the tardata to be unpacked, and the location where it's to be
-   * placed. Will create a new worker up to the `jobs` value, and then start
-   * pushing in the queue for workers to pick up as they become available.
-   *
-   * Returned promise resolves when the provided tarball has been extracted.
+   * 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 unpack(tarData, target) {
-    const ur = new UnpackRequest(tarData, target);
-    this.pending.set(ur.id, ur);
-    if (this.workers.size < this.jobs) {
-      this.#createWorker(ur);
-    } else {
-      this.queue.push(ur);
+  async unpackFile(file, target, offset = 0) {
+    if (!syncUnpack) {
+      return unpack((await readFile(file)).subarray(offset), target);
     }
-    return ur.promise;
+    unpackFileSync(file, target, offset);
   }
 };
 export {
   Pool,
-  UnpackRequest,
-  Worker,
-  isResponseOK,
   unpack
 };

package/{token-FFUAFL43.js → token-PUJ7QN6D.js}

@@ -14,9 +14,9 @@ import {
 } from "./chunk-5JFRXIK2.js";
 import {
   commandUsage
-} from "./chunk-PTR5IGFQ.js";
+} from "./chunk-5HPGL5WS.js";
 import "./chunk-XKVU23NC.js";
-import "./chunk-XISRK3R5.js";
+import "./chunk-MNK55XSE.js";
 import {
   RegistryClient,
   deleteToken,
@@ -25,15 +25,15 @@ import {
   normalizeRegistryKey,
   registryBase,
   setToken
-} from "./chunk-AGHW2E24.js";
+} from "./chunk-NWLS3VOQ.js";
 import "./chunk-HAYXR3MW.js";
 import "./chunk-E74WGW5C.js";
 import "./chunk-LPIBYUMT.js";
 import "./chunk-UBLFPJHV.js";
+import "./chunk-VFBCWAOC.js";
 import "./chunk-XNLSTHDK.js";
-import "./chunk-BJBFEQRR.js";
+import "./chunk-BHJT53TP.js";
 import "./chunk-VE6CCH33.js";
-import "./chunk-VFBCWAOC.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";