@vltpkg/vlx 1.3.6 → 1.3.8

package/README.md

@@ -41,6 +41,7 @@ const arg0 = await vlx.resolve(positionals, options, promptFn)
 // now one of the following is true:
 // - arg0 refers to a locally installed package bin
 // - arg0 refers to a package bin in the XDG.data directory
+// - arg0 refers to a local directory's bin, shimmed in XDG.cache
 // - arg0 is undefined, and an interactive shell can be executed
 // - an error was thrown, because it couijld not be determined
 if (arg0 === undefined) {

package/dist/index.d.ts

@@ -22,8 +22,9 @@ export type VlxInfo = VlxManifest['vlx'] & {
     /** version of the package being run */
     version?: string;
     /**
-     * path to the synthetic project for non-local installs, or to the
-     * current projectRoot if the resolution is local.
+     * path to the synthetic project for non-local installs, to the
+     * current projectRoot if the resolution is local, or a private shim
+     * dir for local directory specs.
      */
     path: string;
     /**

package/dist/local.d.ts

@@ -0,0 +1,15 @@
+import type { PackageJson } from '@vltpkg/package-json';
+import type { Spec } from '@vltpkg/spec';
+import type { VlxInfo } from './index.ts';
+/**
+ * Absolute path if the spec is a local directory (relative to cwd)
+ */
+export declare const localDir: (spec: Spec) => Promise<string | undefined>;
+/**
+ * Shim a local directory's bins into a private bin dir, so they run
+ * in place. Nothing is installed.
+ *
+ * The dir is keyed by all the shims depend on (dir, bins, shebangs),
+ * and never changed once made, so concurrent runs are safe.
+ */
+export declare const vlxLocal: (dir: string, packageJson: PackageJson) => Promise<VlxInfo>;

package/dist/local.js

@@ -0,0 +1,69 @@
+import { cmdShim } from '@vltpkg/cmd-shim';
+import { error } from '@vltpkg/error-cause';
+import { RollbackRemove } from '@vltpkg/rollback-remove';
+import { XDG } from '@vltpkg/xdg';
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, realpath, rename, rm, } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { dirExists } from "./dir-exists.js";
+import { inferDefaultExecutable } from "./infer-default-executable.js";
+/**
+ * Absolute path if the spec is a local directory (relative to cwd)
+ */
+export const localDir = async (spec) => {
+    const { type, file } = spec.final;
+    if (type !== 'file' || !file)
+        return;
+    const dir = resolve(file);
+    return (await dirExists(dir)) ? dir : undefined;
+};
+/**
+ * Shim a local directory's bins into a private bin dir, so they run
+ * in place. Nothing is installed.
+ *
+ * The dir is keyed by all the shims depend on (dir, bins, shebangs),
+ * and never changed once made, so concurrent runs are safe.
+ */
+export const vlxLocal = async (dir, packageJson) => {
+    const manifest = packageJson.read(dir);
+    const bins = Object.entries(manifest.bin ?? {});
+    const heads = await Promise.all(bins.map(async ([k, v]) => {
+        const target = resolve(dir, v);
+        const data = await readFile(target, 'utf8').catch((cause) => {
+            throw error(`Bin target not found: ${k} -> ${v}`, {
+                path: target,
+                cause,
+            });
+        });
+        return `\0${k}\0${v}\0${data.trim().split(/\r*\n/)[0]}`;
+    }));
+    const key = createHash('sha512')
+        .update(dir + heads.join(''))
+        .digest('hex')
+        .substring(0, 16);
+    const cache = new XDG('vlt/vlx-local').cache();
+    await mkdir(cache, { recursive: true });
+    // real path, so the shims' relative `..` resolve as expected
+    const path = resolve(await realpath(cache), key);
+    if (!(await dirExists(path))) {
+        // build aside, then move into place
+        const tmp = await mkdtemp(`${path}-`);
+        const remover = new RollbackRemove();
+        await Promise.all(bins.map(([k, v]) => cmdShim(resolve(dir, v), resolve(tmp, 'node_modules/.bin', k), remover)));
+        remover.confirm();
+        await rename(tmp, path).catch(async (er) => {
+            // another run made it first
+            if (!(await dirExists(path)))
+                throw er;
+            await rm(tmp, { recursive: true, force: true });
+        });
+    }
+    return {
+        path,
+        name: manifest.name ?? basename(dir),
+        version: manifest.version,
+        resolved: String(pathToFileURL(dir)),
+        arg0: inferDefaultExecutable(manifest)?.[0],
+    };
+};

package/dist/resolve.js

@@ -5,6 +5,7 @@ import { addToPATH } from "./add-to-path.js";
 import { findExecutable } from "./find-executable.js";
 import { findPackage } from "./find-package.js";
 import { vlxInstall } from "./install.js";
+import { localDir, vlxLocal } from "./local.js";
 /**
  * Figure out the `arg0` to use for an exec command.
  *
@@ -22,7 +23,10 @@ export const vlxResolve = async (positionals, options, promptFn) => {
             // caller will run interactive shell
             return undefined;
         }
-        const found = await findExecutable(arg0, projectRoot);
+        // path-like args are never bin names
+        const found = arg0 === '.' || arg0 === '..' || /[\\/]/.test(arg0) ?
+            undefined
+            : await findExecutable(arg0, projectRoot);
         // if found locally, then that's the bin, whatever the package is
         // since no package option was provided anyway.
         if (found)
@@ -33,18 +37,28 @@ export const vlxResolve = async (positionals, options, promptFn) => {
         arg0 = undefined;
     }
     let pkgTarget = undefined;
+    let dir;
     if (pkgOption) {
-        // check for local option, otherwise install in data dir we can
-        // ONLY do the local option if the spec is a simple name. otherwise
-        // it's too complicated to know if it's a match, especially in this
-        // world of multiple registries and such, and it's easy enough to
-        // just install it externally.
-        const pkgSpec = Spec.parseArgs(pkgOption, options);
+        // check for local option, otherwise install in data dir. local is
+        // a simple name found in node_modules, or a local dir run in place.
+        // other specs are too complicated to know if it's a match, especially
+        // in this world of multiple registries and such, and it's easy enough
+        // to just install them externally.
+        const pkgSpec = Spec.parseArgs(
+        // bare . / .. are paths, not names
+        pkgOption === '.' || pkgOption === '..' ?
+            `${pkgOption}/`
+            : pkgOption, options);
         const { name, bareSpec } = pkgSpec.final;
         // if it's just a name, we can use the local version
         if (!bareSpec) {
             pkgTarget = await findPackage(name, projectRoot, packageJson);
         }
+        else {
+            dir = await localDir(pkgSpec);
+            if (dir)
+                pkgTarget = await vlxLocal(dir, packageJson);
+        }
         pkgTarget ??= await vlxInstall(pkgSpec, options, promptFn);
     }
     if (pkgTarget) {
@@ -71,7 +85,8 @@ export const vlxResolve = async (positionals, options, promptFn) => {
         // infer arg0 from the manifst found at pkgTarget[1]
         arg0 = pkgTarget.arg0;
         if (!arg0) {
-            const { name, version, bin } = packageJson.read(resolve(pkgTarget.path, 'node_modules', pkgTarget.name));
+            const { name, version, bin } = packageJson.read(dir ??
+                resolve(pkgTarget.path, 'node_modules', pkgTarget.name));
             throw error('Package executable could not be inferred', {
                 name,
                 version,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/vlx",
   "description": "vlt exec management",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -13,15 +13,15 @@
     "url": "http://vlt.sh"
   },
   "dependencies": {
-    "@vltpkg/cmd-shim": "1.3.6",
-    "@vltpkg/error-cause": "1.3.6",
-    "@vltpkg/graph": "1.3.6",
-    "@vltpkg/package-info": "1.3.6",
-    "@vltpkg/package-json": "1.3.6",
-    "@vltpkg/rollback-remove": "1.3.6",
-    "@vltpkg/spec": "1.3.6",
-    "@vltpkg/types": "1.3.6",
-    "@vltpkg/xdg": "1.3.6",
+    "@vltpkg/cmd-shim": "1.3.8",
+    "@vltpkg/error-cause": "1.3.8",
+    "@vltpkg/graph": "1.3.8",
+    "@vltpkg/package-info": "1.3.8",
+    "@vltpkg/package-json": "1.3.8",
+    "@vltpkg/rollback-remove": "1.3.8",
+    "@vltpkg/spec": "1.3.8",
+    "@vltpkg/types": "1.3.8",
+    "@vltpkg/xdg": "1.3.8",
     "path-scurry": "^2.0.1",
     "walk-up-path": "^4.0.0"
   },