@dbx-tools/core 0.9.12 → 0.9.17

package/README.md

@@ -25,6 +25,8 @@ Key features:
 - Cross-process file locks with one portable, stale-reclaiming lock-directory
   protocol shared by Bun and Node.
 - Keyed mutual exclusion across the main thread and its worker threads.
+- npm dependency resolution from an in-memory `package.json` against the
+  configured registry.
 
 ## Install A Binary
 
@@ -45,12 +47,16 @@ const executable = await bin.ensure("tool", releaseUrl, {
 for a different layout. An existing executable returns immediately, so
 a URL resolver is only called when installation is necessary. Concurrent
 callers use a file lock with a check-lock-check-load sequence, preventing
-duplicate downloads across processes and worker threads. Direct downloads
-are selected by default. Zip, tar, tar.gz, and tgz archives can be unpacked
-automatically; a single-file archive needs no selector, while a selector can
-choose a binary from a larger archive. The selected file is normalized to mode
-`0755` and must report an acceptable version before it is atomically moved into
-place; the final renamed path runs the same validation again before returning.
+duplicate downloads across processes and worker threads. After the lock, a
+function URL receives `{ tempDir }` so a local installer can write under that
+directory. Direct HTTP downloads are selected by default. A `file://` URL is
+copied without fetching or unpacking. Zip, tar, tar.gz, and tgz archives can
+be unpacked automatically; a single-file archive needs no selector, while a
+selector can choose a binary from a larger archive. The selected file is
+normalized to mode `0755` and must report an acceptable version before it is
+atomically moved into place; the final renamed path runs the same validation
+again before returning. `trustVersion` on a `BinSource` skips `--version` when
+the producer already identified the requested version.
 
 Every candidate runs with `--version` before it is accepted. Set
 `versionArgument` for a different argument and `minVersion` to require a partial
@@ -318,14 +324,52 @@ share a command/argument result cache only when that resolved path is the live
 process cwd; another directory executes directly. Empty command results are
 cached too.
 
+## Resolve npm Dependencies
+
+```ts
+import { readFile } from "node:fs/promises";
+
+import { json } from "@dbx-tools/shared-core";
+import { dependencyResolver } from "@dbx-tools/core";
+
+const manifest = json.parseRecord(await readFile("package.json", "utf8"));
+if (!manifest) throw new Error("package.json is not a JSON object");
+const missing = await dependencyResolver.missingDependencies(manifest);
+const leftpad = await dependencyResolver.resolveVersion({ name: "leftpad", range: "^1.0.0" });
+const also = await dependencyResolver.resolveVersion("leftpad@^1.0.0");
+const resolved = await dependencyResolver.resolveDependencies({
+  dependencies: {
+    leftpad: "^1.0.0",
+    typescript: { version: "5.8.3" },
+  },
+});
+```
+
+`missingDependencies()` walks declared registry specifiers and each reachable
+packument `dependencies` map through HTTP GETs. `resolveVersion()` accepts a
+package name, `name@version` / `name@range`, a second specifier string, or
+`{ name, version?, range? }` (`semver` is an alias for `version`). An exact
+version that exists is unchanged, and a range is kept when a published version
+satisfies it. `resolveDependencies()` copies the record and pins unavailable
+registry packages (or their parents) until that graph is complete. No installer
+is invoked. Dependency maps may use raw strings or the same structured objects.
+Each returned map entry is `{ name, version, range? }`. The input object is
+unchanged. Workspace, catalog, file, and git specifiers are left alone. Use
+this when a mirror or delayed proxy 404s versions that public npm already has.
+
 ## Modules
 
 - `exec` - async/sync process spawning, stdio handling, abort wiring, and shlex.
-- `bin` - executable download, optional archive extraction, selection, and
-  atomic installation.
+- `bin` - executable download, local `file://` copy, optional archive
+  extraction, selection, and atomic installation. URL thunks receive `{ tempDir }`
+  after the install lock.
 - `bundle` - asynchronous streaming of CLI-resolved Databricks bundle App resources.
-- `project` - cwd normalization, root discovery, project naming, and git-remote
-  parsing.
+- `project` - cwd normalization, root discovery, project naming, git-remote
+  parsing, and memoized npm registry resolution (env, npmrc, bunfig, pnpm yaml,
+  then public npm).
+- `dependencyResolver` - HTTP packument missing-graph walk, single-package
+  version resolution, and resolvable `{ name, version, range? }` maps from a
+  parsed `package.json`. `registryUrl` defaults to `projectUtils.npmRegistry()`.
 - `file` - best-effort stat and parsed-record caching by caller-defined source key.
 - `brand` - YAML/JSON discovery, parsing, validation, and asset path resolution.
 - `config` - scoped environment, dotenv, and validated Databricks bundle lookup,

package/index.ts

@@ -3,22 +3,24 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export const PACKAGE_VERSION = "0.9.12";
+export const PACKAGE_VERSION = "0.9.17";
 export * as bin from "./src/bin.ts";
 export * as brandFiles from "./src/brand-files.ts";
 export * as bundle from "./src/bundle.ts";
 export * as configUtils from "./src/config-utils.ts";
+export * as dependencyResolver from "./src/dependency-resolver.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
 export * as fileLock from "./src/file-lock.ts";
 export * as processLock from "./src/process-lock.ts";
 export * as projectUtils from "./src/project-utils.ts";
-export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinSource, BinUrl } from "./src/bin.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrlResolveContext, BinSource, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand-files.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand-files.ts";
 export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config-utils.ts";
 export type { ConfigMapValue, ConfigData, ConfigSource, ConfigOptions, ConfigFile } from "./src/config-utils.ts";
+export type { DependencyResolverOptions, DependencyInfo, ResolvedNpmVersion, NpmSpecifierInput, ResolvedNpmDependencies, MissingDependencyInfo } from "./src/dependency-resolver.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";
 export type { ExecStdio, LineHandler, StdioOption, ExecResult, ChildProcessResult, ExecOptions, SyncExecStdio, SyncExecOptions, SpawnArgs } from "./src/exec.ts";
 export type { FileLockBackend, FileLockAcquisition, FileLockOptions } from "./src/file-lock.ts";
-export type { ProjectContext } from "./src/project-utils.ts";
+export type { ProjectContext, NpmRegistryOptions } from "./src/project-utils.ts";

package/lib/index.d.ts

@@ -1,20 +1,22 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export declare const PACKAGE_VERSION = "0.9.12";
+export declare const PACKAGE_VERSION = "0.9.17";
 export * as bin from "./src/bin.ts";
 export * as brandFiles from "./src/brand-files.ts";
 export * as bundle from "./src/bundle.ts";
 export * as configUtils from "./src/config-utils.ts";
+export * as dependencyResolver from "./src/dependency-resolver.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
 export * as fileLock from "./src/file-lock.ts";
 export * as processLock from "./src/process-lock.ts";
 export * as projectUtils from "./src/project-utils.ts";
-export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinSource, BinUrl } from "./src/bin.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrlResolveContext, BinSource, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand-files.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand-files.ts";
 export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config-utils.ts";
 export type { ConfigMapValue, ConfigData, ConfigSource, ConfigOptions, ConfigFile } from "./src/config-utils.ts";
+export type { DependencyResolverOptions, DependencyInfo, ResolvedNpmVersion, NpmSpecifierInput, ResolvedNpmDependencies, MissingDependencyInfo } from "./src/dependency-resolver.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";
 export type { ExecStdio, LineHandler, StdioOption, ExecResult, ChildProcessResult, ExecOptions, SyncExecStdio, SyncExecOptions, SpawnArgs } from "./src/exec.ts";
 export type { FileLockBackend, FileLockAcquisition, FileLockOptions } from "./src/file-lock.ts";
-export type { ProjectContext } from "./src/project-utils.ts";
+export type { ProjectContext, NpmRegistryOptions } from "./src/project-utils.ts";

package/lib/index.js

@@ -2,11 +2,12 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export const PACKAGE_VERSION = "0.9.12";
+export const PACKAGE_VERSION = "0.9.17";
 export * as bin from "./src/bin.js";
 export * as brandFiles from "./src/brand-files.js";
 export * as bundle from "./src/bundle.js";
 export * as configUtils from "./src/config-utils.js";
+export * as dependencyResolver from "./src/dependency-resolver.js";
 export * as exec from "./src/exec.js";
 export * as file from "./src/file.js";
 export * as fileLock from "./src/file-lock.js";
@@ -15,4 +16,4 @@ export * as projectUtils from "./src/project-utils.js";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand-files.js";
 export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config-utils.js";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/bin.d.ts

@@ -35,14 +35,25 @@ export interface BinOptions {
     versionArgument?: string;
     /** Version output parser. Defaults to {@link parseVersion}. */
     versionParser?: BinVersionParser;
+    /** Skip `--version` and treat an executable file as acceptable. */
+    skipVersionCheck?: boolean;
+}
+/** Temporary directory created for one `ensure` attempt after the install lock. */
+export interface BinUrlResolveContext {
+    readonly tempDir: string;
 }
 /** Download source resolved only when the executable is not already installed. */
 export interface BinSource {
     url: string;
     sha256?: string;
+    /**
+     * Skip `--version` on this candidate. Use when the source already identified
+     * the requested version, such as `cargo install --version`.
+     */
+    trustVersion?: boolean;
 }
 /** A download source resolved only when the executable is not already installed. */
-export type BinUrl = string | BinSource | (() => string | BinSource | Promise<string | BinSource>);
+export type BinUrl = string | BinSource | ((context: BinUrlResolveContext) => string | BinSource | Promise<string | BinSource>);
 /**
  * Parse the deepest, highest version from stdout, falling back to stderr only
  * when stdout contains no version. Supports one to three numeric components

package/lib/src/bin.js

@@ -8,6 +8,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, mkdir, mkdtemp, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { errorUtils, log } from "@dbx-tools/shared-core";
 import extractZip from "extract-zip";
@@ -114,6 +115,10 @@ async function isValidBin(path, options) {
         logger.debug("binary access check failed", { path, ...access });
         return false;
     }
+    if (options.skipVersionCheck) {
+        logger.debug("binary version check skipped", { path });
+        return true;
+    }
     let stdout;
     let stderr;
     try {
@@ -186,8 +191,28 @@ async function selectSingleFile(source) {
     }
     return selected;
 }
+function fileUrlPath(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "file:")
+            return undefined;
+        return fileURLToPath(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
 async function selectedBin(destination, source, temp, options) {
     const { url } = source;
+    const localPath = fileUrlPath(url);
+    if (localPath) {
+        const access = await accessContext(localPath);
+        if (!access.file) {
+            throw new Error(`binary file URL does not exist: ${displayUrl(url)}`);
+        }
+        logger.debug("using local binary", { from: displayUrl(url), path: localPath });
+        return localPath;
+    }
     const name = downloadName(url, basename(destination.path));
     const downloadPath = join(temp, name);
     logger.debug("downloading binary", {
@@ -257,22 +282,25 @@ export async function ensure(name, url, options = {}) {
             });
             return destination;
         }
-        const resolved = typeof url === "function" ? await url() : url;
-        const source = typeof resolved === "string" ? { url: resolved } : resolved;
-        const from = displayUrl(source.url);
         logger.debug("installing binary", {
             name,
-            from,
             to: destination.path,
             minVersion: options.minVersion,
         });
         const temp = await mkdtemp(join(tmpdir(), `${name}-`));
         let staged;
         try {
+            const resolved = typeof url === "function" ? await url({ tempDir: temp }) : url;
+            const source = typeof resolved === "string" ? { url: resolved } : resolved;
+            const from = displayUrl(source.url);
+            logger.debug("resolved binary source", { name, from });
             const selected = await selectedBin(destination, source, temp, options);
             await chmod(selected, 0o755);
-            if (!(await isValidBin(selected, options))) {
-                throw new Error(`selected binary has no acceptable version: ${selected}`);
+            const accepted = source.trustVersion ? { ...options, skipVersionCheck: true } : options;
+            if (!(await isValidBin(selected, accepted))) {
+                throw new Error(source.trustVersion
+                    ? `selected binary is not executable: ${selected}`
+                    : `selected binary has no acceptable version: ${selected}`);
             }
             await mkdir(destination.binDir, { recursive: true });
             staged = join(destination.binDir, `.${name}-${randomUUID()}`);
@@ -280,7 +308,7 @@ export async function ensure(name, url, options = {}) {
             await chmod(staged, 0o755);
             await rename(staged, destination.path);
             staged = undefined;
-            if (!(await isValidBin(destination.path, options))) {
+            if (!(await isValidBin(destination.path, accepted))) {
                 throw new Error(`installed binary is invalid after rename: ${destination.path}`);
             }
             logger.info("installed binary", {
@@ -297,4 +325,4 @@ export async function ensure(name, url, options = {}) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install and reuse executable binaries under a per-tool home directory.\n *\n * @module\n */\nimport { execFile } from \"node:child_process\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport {\n  chmod,\n  copyFile,\n  mkdir,\n  mkdtemp,\n  readdir,\n  rename,\n  rm,\n  stat,\n  writeFile,\n} from \"node:fs/promises\";\nimport { homedir, tmpdir } from \"node:os\";\nimport { basename, join } from \"node:path\";\nimport { promisify } from \"node:util\";\n\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport extractZip from \"extract-zip\";\nimport { x as extractTar } from \"tar\";\n\nimport { withFileLock } from \"./file-lock.ts\";\n\nconst execFileAsync = promisify(execFile);\nconst logger = log.logger(\"core:bin\");\n\ninterface ParsedVersion {\n  raw: string;\n  parts: number[];\n}\n\ninterface BinAccessContext {\n  file: boolean;\n  executable: boolean;\n}\n\n/** Stable paths for an installed binary. */\nexport interface BinContext {\n  root: string;\n  binDir: string;\n  path: string;\n}\n\n/** Temporary download and extraction paths supplied to a custom selector. */\nexport interface BinSelectionContext {\n  destination: BinContext;\n  downloadPath: string;\n  source: string;\n}\n\n/**\n * Select the executable from a download or unpacked archive. A selector may\n * also prepare the file, such as applying its executable mode.\n */\nexport type BinSelector = (context: BinSelectionContext) => string | Promise<string>;\n\n/** Captured output passed to a custom binary version parser. */\nexport interface BinVersionOutput {\n  stdout: string;\n  stderr: string;\n}\n\n/** Extract a version string from a successful version-command result. */\nexport type BinVersionParser = (output: BinVersionOutput) => string | undefined;\n\n/** Options for {@link ensure}. */\nexport interface BinOptions {\n  autoUnpackage?: boolean;\n  selector?: BinSelector;\n  homeDir?: string;\n  /** Exact installation paths. Omission keeps `$HOME/.<name>/bin/<name>`. */\n  destination?: BinContext;\n  /** Minimum accepted numeric version, with one to three components. */\n  minVersion?: string;\n  /** Argument passed to the binary for version detection. Defaults to `--version`. */\n  versionArgument?: string;\n  /** Version output parser. Defaults to {@link parseVersion}. */\n  versionParser?: BinVersionParser;\n}\n\n/** Download source resolved only when the executable is not already installed. */\nexport interface BinSource {\n  url: string;\n  sha256?: string;\n}\n\n/** A download source resolved only when the executable is not already installed. */\nexport type BinUrl = string | BinSource | (() => string | BinSource | Promise<string | BinSource>);\n\nfunction context(name: string, homeDir: string, destination?: BinContext): BinContext {\n  if (!name || basename(name) !== name || name === \".\" || name === \"..\") {\n    throw new TypeError(`invalid binary name: ${name}`);\n  }\n  if (destination) return destination;\n  const root = join(homeDir, `.${name}`);\n  const binDir = join(root, \"bin\");\n  return { root, binDir, path: join(binDir, name) };\n}\n\nfunction displayUrl(raw: string): string {\n  try {\n    const url = new URL(raw);\n    if (url.protocol === \"data:\") return \"data:\";\n    url.username = \"\";\n    url.password = \"\";\n    url.search = \"\";\n    url.hash = \"\";\n    return url.toString();\n  } catch {\n    return raw;\n  }\n}\n\nasync function accessContext(path: string): Promise<BinAccessContext> {\n  try {\n    const entry = await stat(path);\n    const file = entry.isFile();\n    return {\n      file,\n      executable: file && (process.platform === \"win32\" || (entry.mode & 0o111) !== 0),\n    };\n  } catch {\n    return { file: false, executable: false };\n  }\n}\n\nfunction detectedVersions(output: string): ParsedVersion[] {\n  const versions: ParsedVersion[] = [];\n  const pattern = /\\bv?(\\d+(?:\\.\\d+){0,2})(?:[-+._]?[a-z][0-9a-z.+_-]*)?/gi;\n  for (const match of output.matchAll(pattern)) {\n    const raw = match[0].replace(/^v/i, \"\");\n    const parts = match[1]?.split(\".\").map(Number);\n    if (parts?.every(Number.isFinite)) versions.push({ raw, parts });\n  }\n  return versions.sort((a, b) => {\n    if (a.parts.length !== b.parts.length) return b.parts.length - a.parts.length;\n    for (let index = 0; index < a.parts.length; index += 1) {\n      const order = (b.parts[index] ?? 0) - (a.parts[index] ?? 0);\n      if (order !== 0) return order;\n    }\n    return 0;\n  });\n}\n\n/**\n * Parse the deepest, highest version from stdout, falling back to stderr only\n * when stdout contains no version. Supports one to three numeric components\n * and common suffixes such as `rc1`, `.post1`, and `-dev.2`.\n */\nexport function parseVersion({ stdout, stderr }: BinVersionOutput): string | undefined {\n  return detectedVersions(stdout).at(0)?.raw ?? detectedVersions(stderr).at(0)?.raw;\n}\n\nfunction numericVersion(version: string, strict: boolean): number[] | undefined {\n  const pattern = strict ? /^\\s*v?(\\d+(?:\\.\\d+){0,2})\\s*$/i : /\\bv?(\\d+(?:\\.\\d+){0,2})/i;\n  const match = pattern.exec(version);\n  return match?.[1]?.split(\".\").map(Number);\n}\n\nfunction meetsMinVersion(version: string, minVersion: string | undefined): boolean {\n  if (!minVersion) return true;\n  const actual = numericVersion(version, false);\n  const minimum = numericVersion(minVersion, true);\n  if (!minimum) {\n    throw new TypeError(`invalid minimum binary version: ${minVersion}`);\n  }\n  if (!actual) return false;\n  for (let index = 0; index < Math.max(actual.length, minimum.length); index += 1) {\n    const difference = (actual[index] ?? 0) - (minimum[index] ?? 0);\n    if (difference !== 0) return difference > 0;\n  }\n  return true;\n}\n\nasync function isValidBin(path: string, options: BinOptions): Promise<boolean> {\n  logger.debug(\"checking binary\", {\n    path,\n    minVersion: options.minVersion,\n    versionArgument: options.versionArgument ?? \"--version\",\n  });\n  const access = await accessContext(path);\n  if (!access.file || !access.executable) {\n    logger.debug(\"binary access check failed\", { path, ...access });\n    return false;\n  }\n  let stdout: string;\n  let stderr: string;\n  try {\n    const result = await execFileAsync(path, [options.versionArgument ?? \"--version\"], {\n      encoding: \"utf8\",\n    });\n    stdout = result.stdout;\n    stderr = result.stderr;\n  } catch (cause) {\n    logger.debug(\"binary version command failed\", {\n      path,\n      error: errorUtils.errorMessage(cause),\n    });\n    return false;\n  }\n  const version = (options.versionParser ?? parseVersion)({\n    stdout,\n    stderr,\n  });\n  const valid = version !== undefined && meetsMinVersion(version, options.minVersion);\n  logger.debug(\"binary version checked\", {\n    path,\n    version,\n    minVersion: options.minVersion,\n    valid,\n  });\n  return valid;\n}\n\nfunction downloadName(url: string, name: string): string {\n  try {\n    const candidate = basename(decodeURIComponent(new URL(url).pathname));\n    return candidate && Buffer.byteLength(candidate) <= 200 ? candidate : name;\n  } catch {\n    return name;\n  }\n}\n\nasync function unpack(archive: string, destination: string): Promise<void> {\n  const filename = archive.toLowerCase();\n  if (filename.endsWith(\".zip\")) {\n    await extractZip(archive, { dir: destination });\n    return;\n  }\n  if (filename.endsWith(\".tar\") || filename.endsWith(\".tar.gz\") || filename.endsWith(\".tgz\")) {\n    await extractTar({ file: archive, cwd: destination });\n    return;\n  }\n  throw new Error(`unsupported binary archive: ${basename(archive)}`);\n}\n\nasync function filesUnder(root: string): Promise<string[]> {\n  const entries = await readdir(root, { withFileTypes: true });\n  const files: string[] = [];\n  for (const entry of entries) {\n    const path = join(root, entry.name);\n    if (entry.isDirectory()) {\n      files.push(...(await filesUnder(path)));\n    } else if (entry.isFile()) {\n      files.push(path);\n    }\n  }\n  return files;\n}\n\nasync function selectSingleFile(source: string): Promise<string> {\n  const files = await filesUnder(source);\n  const selected = files.at(0);\n  if (files.length !== 1 || !selected) {\n    throw new Error(`binary archive must contain one file, found ${files.length}`);\n  }\n  return selected;\n}\n\nasync function selectedBin(\n  destination: BinContext,\n  source: BinSource,\n  temp: string,\n  options: BinOptions,\n): Promise<string> {\n  const { url } = source;\n  const name = downloadName(url, basename(destination.path));\n  const downloadPath = join(temp, name);\n  logger.debug(\"downloading binary\", {\n    from: displayUrl(url),\n    to: downloadPath,\n  });\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`binary download failed (${response.status})`);\n  }\n  const downloaded = Buffer.from(await response.arrayBuffer());\n  if (source.sha256) {\n    if (!/^[0-9a-f]{64}$/i.test(source.sha256)) {\n      throw new TypeError(\"binary download SHA-256 digest must contain 64 hexadecimal characters\");\n    }\n    const actual = createHash(\"sha256\").update(downloaded).digest(\"hex\");\n    if (actual.toLowerCase() !== source.sha256.toLowerCase()) {\n      throw new Error(`binary download digest mismatch: ${displayUrl(url)}`);\n    }\n  }\n  await writeFile(downloadPath, downloaded, { mode: 0o755 });\n\n  let selectedSource = downloadPath;\n  if (options.autoUnpackage) {\n    selectedSource = join(temp, `unpacked-${randomUUID()}`);\n    await mkdir(selectedSource);\n    logger.debug(\"unpacking binary archive\", {\n      archive: downloadPath,\n      to: selectedSource,\n    });\n    await unpack(downloadPath, selectedSource);\n  }\n\n  if (options.selector) {\n    const selected = await options.selector({\n      destination,\n      downloadPath,\n      source: selectedSource,\n    });\n    logger.debug(\"selected binary\", { path: selected });\n    return selected;\n  }\n  const selected = options.autoUnpackage ? await selectSingleFile(selectedSource) : selectedSource;\n  logger.debug(\"selected binary\", { path: selected });\n  return selected;\n}\n\n/**\n * Return an existing executable or install it atomically under\n * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load\n * sequence so concurrent callers resolve and download the binary only once.\n * The downloaded candidate and final renamed executable must both pass the\n * same executable and version checks.\n */\nexport async function ensure(\n  name: string,\n  url: BinUrl,\n  options: BinOptions = {},\n): Promise<BinContext> {\n  if (options.minVersion && !numericVersion(options.minVersion, true)) {\n    throw new TypeError(`invalid minimum binary version: ${options.minVersion}`);\n  }\n  const destination = context(name, options.homeDir ?? homedir(), options.destination);\n  if (await isValidBin(destination.path, options)) {\n    logger.debug(\"using installed binary\", { name, path: destination.path });\n    return destination;\n  }\n\n  logger.debug(\"waiting for binary install lock\", { name, path: destination.path });\n  return withFileLock([\"bin.ensure\", destination.path], async () => {\n    if (await isValidBin(destination.path, options)) {\n      logger.debug(\"using binary installed by another caller\", {\n        name,\n        path: destination.path,\n      });\n      return destination;\n    }\n\n    const resolved = typeof url === \"function\" ? await url() : url;\n    const source = typeof resolved === \"string\" ? { url: resolved } : resolved;\n    const from = displayUrl(source.url);\n    logger.debug(\"installing binary\", {\n      name,\n      from,\n      to: destination.path,\n      minVersion: options.minVersion,\n    });\n    const temp = await mkdtemp(join(tmpdir(), `${name}-`));\n    let staged: string | undefined;\n    try {\n      const selected = await selectedBin(destination, source, temp, options);\n      await chmod(selected, 0o755);\n      if (!(await isValidBin(selected, options))) {\n        throw new Error(`selected binary has no acceptable version: ${selected}`);\n      }\n\n      await mkdir(destination.binDir, { recursive: true });\n      staged = join(destination.binDir, `.${name}-${randomUUID()}`);\n      await copyFile(selected, staged);\n      await chmod(staged, 0o755);\n      await rename(staged, destination.path);\n      staged = undefined;\n      if (!(await isValidBin(destination.path, options))) {\n        throw new Error(`installed binary is invalid after rename: ${destination.path}`);\n      }\n      logger.info(\"installed binary\", {\n        name,\n        from,\n        to: destination.path,\n      });\n      return destination;\n    } finally {\n      if (staged) await rm(staged, { force: true });\n      await rm(temp, { recursive: true, force: true });\n    }\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install and reuse executable binaries under a per-tool home directory.\n *\n * @module\n */\nimport { execFile } from \"node:child_process\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport {\n  chmod,\n  copyFile,\n  mkdir,\n  mkdtemp,\n  readdir,\n  rename,\n  rm,\n  stat,\n  writeFile,\n} from \"node:fs/promises\";\nimport { homedir, tmpdir } from \"node:os\";\nimport { basename, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { promisify } from \"node:util\";\n\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport extractZip from \"extract-zip\";\nimport { x as extractTar } from \"tar\";\n\nimport { withFileLock } from \"./file-lock.ts\";\n\nconst execFileAsync = promisify(execFile);\nconst logger = log.logger(\"core:bin\");\n\ninterface ParsedVersion {\n  raw: string;\n  parts: number[];\n}\n\ninterface BinAccessContext {\n  file: boolean;\n  executable: boolean;\n}\n\n/** Stable paths for an installed binary. */\nexport interface BinContext {\n  root: string;\n  binDir: string;\n  path: string;\n}\n\n/** Temporary download and extraction paths supplied to a custom selector. */\nexport interface BinSelectionContext {\n  destination: BinContext;\n  downloadPath: string;\n  source: string;\n}\n\n/**\n * Select the executable from a download or unpacked archive. A selector may\n * also prepare the file, such as applying its executable mode.\n */\nexport type BinSelector = (context: BinSelectionContext) => string | Promise<string>;\n\n/** Captured output passed to a custom binary version parser. */\nexport interface BinVersionOutput {\n  stdout: string;\n  stderr: string;\n}\n\n/** Extract a version string from a successful version-command result. */\nexport type BinVersionParser = (output: BinVersionOutput) => string | undefined;\n\n/** Options for {@link ensure}. */\nexport interface BinOptions {\n  autoUnpackage?: boolean;\n  selector?: BinSelector;\n  homeDir?: string;\n  /** Exact installation paths. Omission keeps `$HOME/.<name>/bin/<name>`. */\n  destination?: BinContext;\n  /** Minimum accepted numeric version, with one to three components. */\n  minVersion?: string;\n  /** Argument passed to the binary for version detection. Defaults to `--version`. */\n  versionArgument?: string;\n  /** Version output parser. Defaults to {@link parseVersion}. */\n  versionParser?: BinVersionParser;\n  /** Skip `--version` and treat an executable file as acceptable. */\n  skipVersionCheck?: boolean;\n}\n\n/** Temporary directory created for one `ensure` attempt after the install lock. */\nexport interface BinUrlResolveContext {\n  readonly tempDir: string;\n}\n\n/** Download source resolved only when the executable is not already installed. */\nexport interface BinSource {\n  url: string;\n  sha256?: string;\n  /**\n   * Skip `--version` on this candidate. Use when the source already identified\n   * the requested version, such as `cargo install --version`.\n   */\n  trustVersion?: boolean;\n}\n\n/** A download source resolved only when the executable is not already installed. */\nexport type BinUrl =\n  | string\n  | BinSource\n  | ((context: BinUrlResolveContext) => string | BinSource | Promise<string | BinSource>);\n\nfunction context(name: string, homeDir: string, destination?: BinContext): BinContext {\n  if (!name || basename(name) !== name || name === \".\" || name === \"..\") {\n    throw new TypeError(`invalid binary name: ${name}`);\n  }\n  if (destination) return destination;\n  const root = join(homeDir, `.${name}`);\n  const binDir = join(root, \"bin\");\n  return { root, binDir, path: join(binDir, name) };\n}\n\nfunction displayUrl(raw: string): string {\n  try {\n    const url = new URL(raw);\n    if (url.protocol === \"data:\") return \"data:\";\n    url.username = \"\";\n    url.password = \"\";\n    url.search = \"\";\n    url.hash = \"\";\n    return url.toString();\n  } catch {\n    return raw;\n  }\n}\n\nasync function accessContext(path: string): Promise<BinAccessContext> {\n  try {\n    const entry = await stat(path);\n    const file = entry.isFile();\n    return {\n      file,\n      executable: file && (process.platform === \"win32\" || (entry.mode & 0o111) !== 0),\n    };\n  } catch {\n    return { file: false, executable: false };\n  }\n}\n\nfunction detectedVersions(output: string): ParsedVersion[] {\n  const versions: ParsedVersion[] = [];\n  const pattern = /\\bv?(\\d+(?:\\.\\d+){0,2})(?:[-+._]?[a-z][0-9a-z.+_-]*)?/gi;\n  for (const match of output.matchAll(pattern)) {\n    const raw = match[0].replace(/^v/i, \"\");\n    const parts = match[1]?.split(\".\").map(Number);\n    if (parts?.every(Number.isFinite)) versions.push({ raw, parts });\n  }\n  return versions.sort((a, b) => {\n    if (a.parts.length !== b.parts.length) return b.parts.length - a.parts.length;\n    for (let index = 0; index < a.parts.length; index += 1) {\n      const order = (b.parts[index] ?? 0) - (a.parts[index] ?? 0);\n      if (order !== 0) return order;\n    }\n    return 0;\n  });\n}\n\n/**\n * Parse the deepest, highest version from stdout, falling back to stderr only\n * when stdout contains no version. Supports one to three numeric components\n * and common suffixes such as `rc1`, `.post1`, and `-dev.2`.\n */\nexport function parseVersion({ stdout, stderr }: BinVersionOutput): string | undefined {\n  return detectedVersions(stdout).at(0)?.raw ?? detectedVersions(stderr).at(0)?.raw;\n}\n\nfunction numericVersion(version: string, strict: boolean): number[] | undefined {\n  const pattern = strict ? /^\\s*v?(\\d+(?:\\.\\d+){0,2})\\s*$/i : /\\bv?(\\d+(?:\\.\\d+){0,2})/i;\n  const match = pattern.exec(version);\n  return match?.[1]?.split(\".\").map(Number);\n}\n\nfunction meetsMinVersion(version: string, minVersion: string | undefined): boolean {\n  if (!minVersion) return true;\n  const actual = numericVersion(version, false);\n  const minimum = numericVersion(minVersion, true);\n  if (!minimum) {\n    throw new TypeError(`invalid minimum binary version: ${minVersion}`);\n  }\n  if (!actual) return false;\n  for (let index = 0; index < Math.max(actual.length, minimum.length); index += 1) {\n    const difference = (actual[index] ?? 0) - (minimum[index] ?? 0);\n    if (difference !== 0) return difference > 0;\n  }\n  return true;\n}\n\nasync function isValidBin(path: string, options: BinOptions): Promise<boolean> {\n  logger.debug(\"checking binary\", {\n    path,\n    minVersion: options.minVersion,\n    versionArgument: options.versionArgument ?? \"--version\",\n  });\n  const access = await accessContext(path);\n  if (!access.file || !access.executable) {\n    logger.debug(\"binary access check failed\", { path, ...access });\n    return false;\n  }\n  if (options.skipVersionCheck) {\n    logger.debug(\"binary version check skipped\", { path });\n    return true;\n  }\n  let stdout: string;\n  let stderr: string;\n  try {\n    const result = await execFileAsync(path, [options.versionArgument ?? \"--version\"], {\n      encoding: \"utf8\",\n    });\n    stdout = result.stdout;\n    stderr = result.stderr;\n  } catch (cause) {\n    logger.debug(\"binary version command failed\", {\n      path,\n      error: errorUtils.errorMessage(cause),\n    });\n    return false;\n  }\n  const version = (options.versionParser ?? parseVersion)({\n    stdout,\n    stderr,\n  });\n  const valid = version !== undefined && meetsMinVersion(version, options.minVersion);\n  logger.debug(\"binary version checked\", {\n    path,\n    version,\n    minVersion: options.minVersion,\n    valid,\n  });\n  return valid;\n}\n\nfunction downloadName(url: string, name: string): string {\n  try {\n    const candidate = basename(decodeURIComponent(new URL(url).pathname));\n    return candidate && Buffer.byteLength(candidate) <= 200 ? candidate : name;\n  } catch {\n    return name;\n  }\n}\n\nasync function unpack(archive: string, destination: string): Promise<void> {\n  const filename = archive.toLowerCase();\n  if (filename.endsWith(\".zip\")) {\n    await extractZip(archive, { dir: destination });\n    return;\n  }\n  if (filename.endsWith(\".tar\") || filename.endsWith(\".tar.gz\") || filename.endsWith(\".tgz\")) {\n    await extractTar({ file: archive, cwd: destination });\n    return;\n  }\n  throw new Error(`unsupported binary archive: ${basename(archive)}`);\n}\n\nasync function filesUnder(root: string): Promise<string[]> {\n  const entries = await readdir(root, { withFileTypes: true });\n  const files: string[] = [];\n  for (const entry of entries) {\n    const path = join(root, entry.name);\n    if (entry.isDirectory()) {\n      files.push(...(await filesUnder(path)));\n    } else if (entry.isFile()) {\n      files.push(path);\n    }\n  }\n  return files;\n}\n\nasync function selectSingleFile(source: string): Promise<string> {\n  const files = await filesUnder(source);\n  const selected = files.at(0);\n  if (files.length !== 1 || !selected) {\n    throw new Error(`binary archive must contain one file, found ${files.length}`);\n  }\n  return selected;\n}\n\nfunction fileUrlPath(url: string): string | undefined {\n  try {\n    const parsed = new URL(url);\n    if (parsed.protocol !== \"file:\") return undefined;\n    return fileURLToPath(parsed);\n  } catch {\n    return undefined;\n  }\n}\n\nasync function selectedBin(\n  destination: BinContext,\n  source: BinSource,\n  temp: string,\n  options: BinOptions,\n): Promise<string> {\n  const { url } = source;\n  const localPath = fileUrlPath(url);\n  if (localPath) {\n    const access = await accessContext(localPath);\n    if (!access.file) {\n      throw new Error(`binary file URL does not exist: ${displayUrl(url)}`);\n    }\n    logger.debug(\"using local binary\", { from: displayUrl(url), path: localPath });\n    return localPath;\n  }\n  const name = downloadName(url, basename(destination.path));\n  const downloadPath = join(temp, name);\n  logger.debug(\"downloading binary\", {\n    from: displayUrl(url),\n    to: downloadPath,\n  });\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`binary download failed (${response.status})`);\n  }\n  const downloaded = Buffer.from(await response.arrayBuffer());\n  if (source.sha256) {\n    if (!/^[0-9a-f]{64}$/i.test(source.sha256)) {\n      throw new TypeError(\"binary download SHA-256 digest must contain 64 hexadecimal characters\");\n    }\n    const actual = createHash(\"sha256\").update(downloaded).digest(\"hex\");\n    if (actual.toLowerCase() !== source.sha256.toLowerCase()) {\n      throw new Error(`binary download digest mismatch: ${displayUrl(url)}`);\n    }\n  }\n  await writeFile(downloadPath, downloaded, { mode: 0o755 });\n\n  let selectedSource = downloadPath;\n  if (options.autoUnpackage) {\n    selectedSource = join(temp, `unpacked-${randomUUID()}`);\n    await mkdir(selectedSource);\n    logger.debug(\"unpacking binary archive\", {\n      archive: downloadPath,\n      to: selectedSource,\n    });\n    await unpack(downloadPath, selectedSource);\n  }\n\n  if (options.selector) {\n    const selected = await options.selector({\n      destination,\n      downloadPath,\n      source: selectedSource,\n    });\n    logger.debug(\"selected binary\", { path: selected });\n    return selected;\n  }\n  const selected = options.autoUnpackage ? await selectSingleFile(selectedSource) : selectedSource;\n  logger.debug(\"selected binary\", { path: selected });\n  return selected;\n}\n\n/**\n * Return an existing executable or install it atomically under\n * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load\n * sequence so concurrent callers resolve and download the binary only once.\n * The downloaded candidate and final renamed executable must both pass the\n * same executable and version checks.\n */\nexport async function ensure(\n  name: string,\n  url: BinUrl,\n  options: BinOptions = {},\n): Promise<BinContext> {\n  if (options.minVersion && !numericVersion(options.minVersion, true)) {\n    throw new TypeError(`invalid minimum binary version: ${options.minVersion}`);\n  }\n  const destination = context(name, options.homeDir ?? homedir(), options.destination);\n  if (await isValidBin(destination.path, options)) {\n    logger.debug(\"using installed binary\", { name, path: destination.path });\n    return destination;\n  }\n\n  logger.debug(\"waiting for binary install lock\", { name, path: destination.path });\n  return withFileLock([\"bin.ensure\", destination.path], async () => {\n    if (await isValidBin(destination.path, options)) {\n      logger.debug(\"using binary installed by another caller\", {\n        name,\n        path: destination.path,\n      });\n      return destination;\n    }\n\n    logger.debug(\"installing binary\", {\n      name,\n      to: destination.path,\n      minVersion: options.minVersion,\n    });\n    const temp = await mkdtemp(join(tmpdir(), `${name}-`));\n    let staged: string | undefined;\n    try {\n      const resolved = typeof url === \"function\" ? await url({ tempDir: temp }) : url;\n      const source = typeof resolved === \"string\" ? { url: resolved } : resolved;\n      const from = displayUrl(source.url);\n      logger.debug(\"resolved binary source\", { name, from });\n      const selected = await selectedBin(destination, source, temp, options);\n      await chmod(selected, 0o755);\n      const accepted = source.trustVersion ? { ...options, skipVersionCheck: true } : options;\n      if (!(await isValidBin(selected, accepted))) {\n        throw new Error(\n          source.trustVersion\n            ? `selected binary is not executable: ${selected}`\n            : `selected binary has no acceptable version: ${selected}`,\n        );\n      }\n\n      await mkdir(destination.binDir, { recursive: true });\n      staged = join(destination.binDir, `.${name}-${randomUUID()}`);\n      await copyFile(selected, staged);\n      await chmod(staged, 0o755);\n      await rename(staged, destination.path);\n      staged = undefined;\n      if (!(await isValidBin(destination.path, accepted))) {\n        throw new Error(`installed binary is invalid after rename: ${destination.path}`);\n      }\n      logger.info(\"installed binary\", {\n        name,\n        from,\n        to: destination.path,\n      });\n      return destination;\n    } finally {\n      if (staged) await rm(staged, { force: true });\n      await rm(temp, { recursive: true, force: true });\n    }\n  });\n}\n"]}

package/lib/src/dependency-resolver.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Resolve npm dependency specifiers against a registry.
+ *
+ * Callers pass an already-parsed `package.json`. The functions never write that
+ * project and never run an installer: they GET packuments over HTTP and walk
+ * declared plus transitive `dependencies`. Exact versions stay exact when they
+ * exist; ranges stay ranges when a published version satisfies them.
+ *
+ * `registryUrl` defaults to {@link npmRegistry} from `project-utils`.
+ *
+ * @module
+ */
+type PackageInfo = {
+    name: string;
+    versions: string[];
+    latest?: string;
+    dependencies: Record<string, Record<string, string>>;
+};
+/** Registry and traversal policy for dependency resolution. */
+export type DependencyResolverOptions = {
+    /** Graph-walk attempts before giving up. Defaults to 100. */
+    maxIterations?: number;
+    /**
+     * Registry origin used for packument GETs. Defaults to
+     * `projectUtils.npmRegistry()` (env, npmrc, bunfig, pnpm yaml, then public npm).
+     */
+    registryUrl?: string | URL;
+    packageInfo?: (name: string) => Promise<PackageInfo | undefined>;
+    skip?: ReadonlySet<string>;
+};
+/**
+ * Package identity plus optional exact version and/or semver range.
+ *
+ * `semver` is accepted as an input alias for `version`.
+ */
+export type DependencyInfo = {
+    name: string;
+    version?: string;
+    semver?: string;
+    range?: string;
+};
+/** Concrete registry version, plus the original range when one was requested. */
+export type ResolvedNpmVersion = {
+    name: string;
+    version: string;
+    range?: string;
+};
+/** String specifier or structured `{ version, range, name? }` value. */
+export type NpmSpecifierInput = string | Omit<DependencyInfo, "name"> | DependencyInfo;
+/** Registry dependency maps with resolved versions and retained ranges. */
+export type ResolvedNpmDependencies = {
+    dependencies: Record<string, ResolvedNpmVersion>;
+    devDependencies: Record<string, ResolvedNpmVersion>;
+    optionalDependencies: Record<string, ResolvedNpmVersion>;
+    peerDependencies: Record<string, ResolvedNpmVersion>;
+    overrides: Record<string, ResolvedNpmVersion>;
+};
+/** A package whose requested specifier is not in the configured registry. */
+export type MissingDependencyInfo = DependencyInfo;
+/**
+ * Return packages the configured registry cannot satisfy for this manifest.
+ *
+ * Walks declared registry specifiers and each reachable packument
+ * `dependencies` map. The input object is not mutated.
+ */
+export declare function missingDependencies(manifest: Record<string, unknown>, options?: DependencyResolverOptions): Promise<MissingDependencyInfo[]>;
+/**
+ * Return a registry version for one package.
+ *
+ * `request` may be a package name, `name@version` / `name@range`, or a
+ * structured `{ name, version?, range? }` object. A second string argument is
+ * treated as the specifier. An exact version that exists is returned
+ * unchanged. A range is retained when a published version satisfies it.
+ */
+export declare function resolveVersion(request: string | DependencyInfo, specifierOrOptions?: string | DependencyResolverOptions, maybeOptions?: DependencyResolverOptions): Promise<ResolvedNpmVersion | undefined>;
+/**
+ * Return resolvable dependency specifiers for an in-memory `package.json`.
+ *
+ * The input object is not mutated. Unavailable registry packages (or their
+ * parents) are pinned until the packument graph is complete.
+ */
+export declare function resolveDependencies(manifest: Record<string, unknown>, options?: DependencyResolverOptions): Promise<ResolvedNpmDependencies>;
+export {};