@dbx-tools/core 0.6.66 → 0.6.67

package/README.md

@@ -23,18 +23,14 @@ Key features:
 ## Install A Binary
 
 ```ts
-import { chmod } from "node:fs/promises";
 import { join } from "node:path";
 
 import { bin } from "@dbx-tools/core";
 
 const executable = await bin.ensure("tool", releaseUrl, {
   autoUnpackage: true,
-  selector: async ({ source }) => {
-    const path = join(source, "tool");
-    await chmod(path, 0o755);
-    return path;
-  },
+  minVersion: "1.2",
+  selector: ({ source }) => join(source, "tool"),
 });
 ```
 
@@ -45,8 +41,23 @@ callers use `processLock` with a check-lock-check-load sequence, preventing
 duplicate downloads across the main thread and wired workers. 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 and prepare a binary from a larger archive. The selected file must be
-executable before it is atomically moved into place.
+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.
+
+Every candidate runs with `--version` before it is accepted. Set
+`versionArgument` for a different argument and `minVersion` to require a partial
+or complete numeric floor such as `1`, `1.2`, or `1.3.5`. The default parser
+searches stdout first, then stderr. It accepts one to three numeric components
+with common npm/Python suffixes such as `1.2.3-rc.1`, `1.2.3rc1`, or
+`1.2.3.patchdev`; candidates with more components rank first, then the highest
+numeric candidate wins. Supply `versionParser({ stdout, stderr })` for another
+output format.
+
+Successful installs log an info event with the source URL and destination path;
+credentials, query parameters, and fragments are removed from the URL. Set
+`LOG_LEVEL=debug` to trace access checks, version decisions, locking, downloads,
+archive extraction, and selection.
 
 ## Load Brand Context
 

package/index.ts

@@ -8,7 +8,7 @@ export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
 export * as processLock from "./src/process-lock.ts";
 export * as project from "./src/project.ts";
-export type { BinContext, BinSelectionContext, BinSelector, BinOptions, BinUrl } from "./src/bin.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";

package/lib/index.d.ts

@@ -4,7 +4,7 @@ export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
 export * as processLock from "./src/process-lock.ts";
 export * as project from "./src/project.ts";
-export type { BinContext, BinSelectionContext, BinSelector, BinOptions, BinUrl } from "./src/bin.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinVersionOutput, BinVersionParser, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";

package/lib/index.js

@@ -9,4 +9,4 @@ export * as processLock from "./src/process-lock.js";
 export * as project from "./src/project.js";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.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

@@ -15,17 +15,38 @@ export interface BinSelectionContext {
  * also prepare the file, such as applying its executable mode.
  */
 export type BinSelector = (context: BinSelectionContext) => string | Promise<string>;
+/** Captured output passed to a custom binary version parser. */
+export interface BinVersionOutput {
+    stdout: string;
+    stderr: string;
+}
+/** Extract a version string from a successful version-command result. */
+export type BinVersionParser = (output: BinVersionOutput) => string | undefined;
 /** Options for {@link ensure}. */
 export interface BinOptions {
     autoUnpackage?: boolean;
     selector?: BinSelector;
     homeDir?: string;
+    /** Minimum accepted numeric version, with one to three components. */
+    minVersion?: string;
+    /** Argument passed to the binary for version detection. Defaults to `--version`. */
+    versionArgument?: string;
+    /** Version output parser. Defaults to {@link parseVersion}. */
+    versionParser?: BinVersionParser;
 }
 /** A URL resolved only when the executable is not already installed. */
 export type BinUrl = string | (() => string | Promise<string>);
+/**
+ * Parse the deepest, highest version from stdout, falling back to stderr only
+ * when stdout contains no version. Supports one to three numeric components
+ * and common suffixes such as `rc1`, `.post1`, and `-dev.2`.
+ */
+export declare function parseVersion({ stdout, stderr }: BinVersionOutput): string | undefined;
 /**
  * Return an existing executable or install it atomically under
  * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load
  * sequence so concurrent callers resolve and download the binary only once.
+ * The downloaded candidate and final renamed executable must both pass the
+ * same executable and version checks.
  */
 export declare function ensure(name: string, url: BinUrl, options?: BinOptions): Promise<BinContext>;

package/lib/src/bin.js

@@ -3,14 +3,18 @@
  *
  * @module
  */
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { access, chmod, copyFile, mkdir, mkdtemp, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
+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 { promisify } from "node:util";
 import extractZip from "extract-zip";
 import { x as extractTar } from "tar";
+import { error, log } from "@dbx-tools/shared-core";
 import { withProcessLock } from "./process-lock.js";
+const execFileAsync = promisify(execFile);
+const logger = log.logger("core:bin");
 function context(name, homeDir) {
     if (!name || basename(name) !== name || name === "." || name === "..") {
         throw new TypeError(`invalid binary name: ${name}`);
@@ -19,16 +23,123 @@ function context(name, homeDir) {
     const binDir = join(root, "bin");
     return { root, binDir, path: join(binDir, name) };
 }
-async function isExecutable(path) {
+function displayUrl(raw) {
     try {
-        if (!(await stat(path)).isFile())
-            return false;
-        await access(path, constants.F_OK | constants.X_OK);
-        return true;
+        const url = new URL(raw);
+        if (url.protocol === "data:")
+            return "data:";
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        return url.toString();
     }
     catch {
+        return raw;
+    }
+}
+async function accessContext(path) {
+    try {
+        const entry = await stat(path);
+        const file = entry.isFile();
+        return {
+            file,
+            executable: file && (process.platform === "win32" || (entry.mode & 0o111) !== 0),
+        };
+    }
+    catch {
+        return { file: false, executable: false };
+    }
+}
+function detectedVersions(output) {
+    const versions = [];
+    const pattern = /\bv?(\d+(?:\.\d+){0,2})(?:[-+._]?[a-z][0-9a-z.+_-]*)?/gi;
+    for (const match of output.matchAll(pattern)) {
+        const raw = match[0].replace(/^v/i, "");
+        const parts = match[1]?.split(".").map(Number);
+        if (parts?.every(Number.isFinite))
+            versions.push({ raw, parts });
+    }
+    return versions.sort((a, b) => {
+        if (a.parts.length !== b.parts.length)
+            return b.parts.length - a.parts.length;
+        for (let index = 0; index < a.parts.length; index += 1) {
+            const order = (b.parts[index] ?? 0) - (a.parts[index] ?? 0);
+            if (order !== 0)
+                return order;
+        }
+        return 0;
+    });
+}
+/**
+ * Parse the deepest, highest version from stdout, falling back to stderr only
+ * when stdout contains no version. Supports one to three numeric components
+ * and common suffixes such as `rc1`, `.post1`, and `-dev.2`.
+ */
+export function parseVersion({ stdout, stderr }) {
+    return detectedVersions(stdout).at(0)?.raw ?? detectedVersions(stderr).at(0)?.raw;
+}
+function numericVersion(version, strict) {
+    const pattern = strict ? /^\s*v?(\d+(?:\.\d+){0,2})\s*$/i : /\bv?(\d+(?:\.\d+){0,2})/i;
+    const match = pattern.exec(version);
+    return match?.[1]?.split(".").map(Number);
+}
+function meetsMinVersion(version, minVersion) {
+    if (!minVersion)
+        return true;
+    const actual = numericVersion(version, false);
+    const minimum = numericVersion(minVersion, true);
+    if (!minimum) {
+        throw new TypeError(`invalid minimum binary version: ${minVersion}`);
+    }
+    if (!actual)
         return false;
+    for (let index = 0; index < Math.max(actual.length, minimum.length); index += 1) {
+        const difference = (actual[index] ?? 0) - (minimum[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0;
     }
+    return true;
+}
+async function isValidBin(path, options) {
+    logger.debug("checking binary", {
+        path,
+        minVersion: options.minVersion,
+        versionArgument: options.versionArgument ?? "--version",
+    });
+    const access = await accessContext(path);
+    if (!access.file || !access.executable) {
+        logger.debug("binary access check failed", { path, ...access });
+        return false;
+    }
+    let stdout;
+    let stderr;
+    try {
+        const result = await execFileAsync(path, [options.versionArgument ?? "--version"], {
+            encoding: "utf8",
+        });
+        stdout = result.stdout;
+        stderr = result.stderr;
+    }
+    catch (cause) {
+        logger.debug("binary version command failed", {
+            path,
+            error: error.errorMessage(cause),
+        });
+        return false;
+    }
+    const version = (options.versionParser ?? parseVersion)({
+        stdout,
+        stderr,
+    });
+    const valid = version !== undefined && meetsMinVersion(version, options.minVersion);
+    logger.debug("binary version checked", {
+        path,
+        version,
+        minVersion: options.minVersion,
+        valid,
+    });
+    return valid;
 }
 function downloadName(url, name) {
     try {
@@ -76,6 +187,10 @@ async function selectSingleFile(source) {
 async function selectedBin(destination, url, temp, options) {
     const name = downloadName(url, basename(destination.path));
     const downloadPath = join(temp, name);
+    logger.debug("downloading binary", {
+        from: displayUrl(url),
+        to: downloadPath,
+    });
     const response = await fetch(url);
     if (!response.ok) {
         throw new Error(`binary download failed (${response.status})`);
@@ -85,39 +200,76 @@ async function selectedBin(destination, url, temp, options) {
     if (options.autoUnpackage) {
         source = join(temp, `unpacked-${randomUUID()}`);
         await mkdir(source);
+        logger.debug("unpacking binary archive", {
+            archive: downloadPath,
+            to: source,
+        });
         await unpack(downloadPath, source);
     }
     if (options.selector) {
-        return options.selector({ destination, downloadPath, source });
+        const selected = await options.selector({ destination, downloadPath, source });
+        logger.debug("selected binary", { path: selected });
+        return selected;
     }
-    return options.autoUnpackage ? selectSingleFile(source) : source;
+    const selected = options.autoUnpackage ? await selectSingleFile(source) : source;
+    logger.debug("selected binary", { path: selected });
+    return selected;
 }
 /**
  * Return an existing executable or install it atomically under
  * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load
  * sequence so concurrent callers resolve and download the binary only once.
+ * The downloaded candidate and final renamed executable must both pass the
+ * same executable and version checks.
  */
 export async function ensure(name, url, options = {}) {
+    if (options.minVersion && !numericVersion(options.minVersion, true)) {
+        throw new TypeError(`invalid minimum binary version: ${options.minVersion}`);
+    }
     const destination = context(name, options.homeDir ?? homedir());
-    if (await isExecutable(destination.path))
+    if (await isValidBin(destination.path, options)) {
+        logger.debug("using installed binary", { name, path: destination.path });
         return destination;
+    }
+    logger.debug("waiting for binary install lock", { name, path: destination.path });
     return withProcessLock(["bin.ensure", destination.path], async () => {
-        if (await isExecutable(destination.path))
+        if (await isValidBin(destination.path, options)) {
+            logger.debug("using binary installed by another caller", {
+                name,
+                path: destination.path,
+            });
             return destination;
+        }
         const resolvedUrl = typeof url === "function" ? await url() : url;
+        const from = displayUrl(resolvedUrl);
+        logger.debug("installing binary", {
+            name,
+            from,
+            to: destination.path,
+            minVersion: options.minVersion,
+        });
         const temp = await mkdtemp(join(tmpdir(), `${name}-`));
         let staged;
         try {
             const selected = await selectedBin(destination, resolvedUrl, temp, options);
-            if (!(await isExecutable(selected))) {
-                throw new Error(`selected binary is not executable: ${selected}`);
+            await chmod(selected, 0o755);
+            if (!(await isValidBin(selected, options))) {
+                throw new Error(`selected binary has no acceptable version: ${selected}`);
             }
             await mkdir(destination.binDir, { recursive: true });
             staged = join(destination.binDir, `.${name}-${randomUUID()}`);
             await copyFile(selected, staged);
-            await chmod(staged, (await stat(selected)).mode);
+            await chmod(staged, 0o755);
             await rename(staged, destination.path);
             staged = undefined;
+            if (!(await isValidBin(destination.path, options))) {
+                throw new Error(`installed binary is invalid after rename: ${destination.path}`);
+            }
+            logger.info("installed binary", {
+                name,
+                from,
+                to: destination.path,
+            });
             return destination;
         }
         finally {
@@ -127,4 +279,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 { randomUUID } from \"node:crypto\";\nimport { constants } from \"node:fs\";\nimport {\n  access,\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\";\n\nimport extractZip from \"extract-zip\";\nimport { x as extractTar } from \"tar\";\n\nimport { withProcessLock } from \"./process-lock.ts\";\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/** Options for {@link ensure}. */\nexport interface BinOptions {\n  autoUnpackage?: boolean;\n  selector?: BinSelector;\n  homeDir?: string;\n}\n\n/** A URL resolved only when the executable is not already installed. */\nexport type BinUrl = string | (() => string | Promise<string>);\n\nfunction context(name: string, homeDir: string): BinContext {\n  if (!name || basename(name) !== name || name === \".\" || name === \"..\") {\n    throw new TypeError(`invalid binary name: ${name}`);\n  }\n  const root = join(homeDir, `.${name}`);\n  const binDir = join(root, \"bin\");\n  return { root, binDir, path: join(binDir, name) };\n}\n\nasync function isExecutable(path: string): Promise<boolean> {\n  try {\n    if (!(await stat(path)).isFile()) return false;\n    await access(path, constants.F_OK | constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\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  url: string,\n  temp: string,\n  options: BinOptions,\n): Promise<string> {\n  const name = downloadName(url, basename(destination.path));\n  const downloadPath = join(temp, name);\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`binary download failed (${response.status})`);\n  }\n  await writeFile(downloadPath, Buffer.from(await response.arrayBuffer()), { mode: 0o755 });\n\n  let source = downloadPath;\n  if (options.autoUnpackage) {\n    source = join(temp, `unpacked-${randomUUID()}`);\n    await mkdir(source);\n    await unpack(downloadPath, source);\n  }\n\n  if (options.selector) {\n    return options.selector({ destination, downloadPath, source });\n  }\n  return options.autoUnpackage ? selectSingleFile(source) : source;\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 */\nexport async function ensure(\n  name: string,\n  url: BinUrl,\n  options: BinOptions = {},\n): Promise<BinContext> {\n  const destination = context(name, options.homeDir ?? homedir());\n  if (await isExecutable(destination.path)) return destination;\n\n  return withProcessLock([\"bin.ensure\", destination.path], async () => {\n    if (await isExecutable(destination.path)) return destination;\n\n    const resolvedUrl = typeof url === \"function\" ? await url() : url;\n    const temp = await mkdtemp(join(tmpdir(), `${name}-`));\n    let staged: string | undefined;\n    try {\n      const selected = await selectedBin(destination, resolvedUrl, temp, options);\n      if (!(await isExecutable(selected))) {\n        throw new Error(`selected binary is not executable: ${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, (await stat(selected)).mode);\n      await rename(staged, destination.path);\n      staged = undefined;\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 { 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 extractZip from \"extract-zip\";\nimport { x as extractTar } from \"tar\";\n\nimport { error, log } from \"@dbx-tools/shared-core\";\nimport { withProcessLock } from \"./process-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  /** 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/** A URL resolved only when the executable is not already installed. */\nexport type BinUrl = string | (() => string | Promise<string>);\n\nfunction context(name: string, homeDir: string): BinContext {\n  if (!name || basename(name) !== name || name === \".\" || name === \"..\") {\n    throw new TypeError(`invalid binary name: ${name}`);\n  }\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: error.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  url: string,\n  temp: string,\n  options: BinOptions,\n): Promise<string> {\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  await writeFile(downloadPath, Buffer.from(await response.arrayBuffer()), { mode: 0o755 });\n\n  let source = downloadPath;\n  if (options.autoUnpackage) {\n    source = join(temp, `unpacked-${randomUUID()}`);\n    await mkdir(source);\n    logger.debug(\"unpacking binary archive\", {\n      archive: downloadPath,\n      to: source,\n    });\n    await unpack(downloadPath, source);\n  }\n\n  if (options.selector) {\n    const selected = await options.selector({ destination, downloadPath, source });\n    logger.debug(\"selected binary\", { path: selected });\n    return selected;\n  }\n  const selected = options.autoUnpackage ? await selectSingleFile(source) : source;\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());\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 withProcessLock([\"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 resolvedUrl = typeof url === \"function\" ? await url() : url;\n    const from = displayUrl(resolvedUrl);\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, resolvedUrl, 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"]}

package/package.json

@@ -23,7 +23,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.66",
+    "@dbx-tools/shared-core": "0.6.67",
     "extract-zip": "^2.0.1",
     "tar": "^7.5.22",
     "yaml": "^2.9.0"
@@ -42,7 +42,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.66",
+  "version": "0.6.67",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/bin.ts

@@ -3,10 +3,9 @@
  *
  * @module
  */
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
 import {
-  access,
   chmod,
   copyFile,
   mkdir,
@@ -19,12 +18,27 @@ import {
 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { promisify } from "node:util";
 
 import extractZip from "extract-zip";
 import { x as extractTar } from "tar";
 
+import { error, log } from "@dbx-tools/shared-core";
 import { withProcessLock } from "./process-lock.ts";
 
+const execFileAsync = promisify(execFile);
+const logger = log.logger("core:bin");
+
+interface ParsedVersion {
+  raw: string;
+  parts: number[];
+}
+
+interface BinAccessContext {
+  file: boolean;
+  executable: boolean;
+}
+
 /** Stable paths for an installed binary. */
 export interface BinContext {
   root: string;
@@ -45,11 +59,26 @@ export interface BinSelectionContext {
  */
 export type BinSelector = (context: BinSelectionContext) => string | Promise<string>;
 
+/** Captured output passed to a custom binary version parser. */
+export interface BinVersionOutput {
+  stdout: string;
+  stderr: string;
+}
+
+/** Extract a version string from a successful version-command result. */
+export type BinVersionParser = (output: BinVersionOutput) => string | undefined;
+
 /** Options for {@link ensure}. */
 export interface BinOptions {
   autoUnpackage?: boolean;
   selector?: BinSelector;
   homeDir?: string;
+  /** Minimum accepted numeric version, with one to three components. */
+  minVersion?: string;
+  /** Argument passed to the binary for version detection. Defaults to `--version`. */
+  versionArgument?: string;
+  /** Version output parser. Defaults to {@link parseVersion}. */
+  versionParser?: BinVersionParser;
 }
 
 /** A URL resolved only when the executable is not already installed. */
@@ -64,14 +93,119 @@ function context(name: string, homeDir: string): BinContext {
   return { root, binDir, path: join(binDir, name) };
 }
 
-async function isExecutable(path: string): Promise<boolean> {
+function displayUrl(raw: string): string {
+  try {
+    const url = new URL(raw);
+    if (url.protocol === "data:") return "data:";
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return raw;
+  }
+}
+
+async function accessContext(path: string): Promise<BinAccessContext> {
   try {
-    if (!(await stat(path)).isFile()) return false;
-    await access(path, constants.F_OK | constants.X_OK);
-    return true;
+    const entry = await stat(path);
+    const file = entry.isFile();
+    return {
+      file,
+      executable: file && (process.platform === "win32" || (entry.mode & 0o111) !== 0),
+    };
   } catch {
+    return { file: false, executable: false };
+  }
+}
+
+function detectedVersions(output: string): ParsedVersion[] {
+  const versions: ParsedVersion[] = [];
+  const pattern = /\bv?(\d+(?:\.\d+){0,2})(?:[-+._]?[a-z][0-9a-z.+_-]*)?/gi;
+  for (const match of output.matchAll(pattern)) {
+    const raw = match[0].replace(/^v/i, "");
+    const parts = match[1]?.split(".").map(Number);
+    if (parts?.every(Number.isFinite)) versions.push({ raw, parts });
+  }
+  return versions.sort((a, b) => {
+    if (a.parts.length !== b.parts.length) return b.parts.length - a.parts.length;
+    for (let index = 0; index < a.parts.length; index += 1) {
+      const order = (b.parts[index] ?? 0) - (a.parts[index] ?? 0);
+      if (order !== 0) return order;
+    }
+    return 0;
+  });
+}
+
+/**
+ * Parse the deepest, highest version from stdout, falling back to stderr only
+ * when stdout contains no version. Supports one to three numeric components
+ * and common suffixes such as `rc1`, `.post1`, and `-dev.2`.
+ */
+export function parseVersion({ stdout, stderr }: BinVersionOutput): string | undefined {
+  return detectedVersions(stdout).at(0)?.raw ?? detectedVersions(stderr).at(0)?.raw;
+}
+
+function numericVersion(version: string, strict: boolean): number[] | undefined {
+  const pattern = strict ? /^\s*v?(\d+(?:\.\d+){0,2})\s*$/i : /\bv?(\d+(?:\.\d+){0,2})/i;
+  const match = pattern.exec(version);
+  return match?.[1]?.split(".").map(Number);
+}
+
+function meetsMinVersion(version: string, minVersion: string | undefined): boolean {
+  if (!minVersion) return true;
+  const actual = numericVersion(version, false);
+  const minimum = numericVersion(minVersion, true);
+  if (!minimum) {
+    throw new TypeError(`invalid minimum binary version: ${minVersion}`);
+  }
+  if (!actual) return false;
+  for (let index = 0; index < Math.max(actual.length, minimum.length); index += 1) {
+    const difference = (actual[index] ?? 0) - (minimum[index] ?? 0);
+    if (difference !== 0) return difference > 0;
+  }
+  return true;
+}
+
+async function isValidBin(path: string, options: BinOptions): Promise<boolean> {
+  logger.debug("checking binary", {
+    path,
+    minVersion: options.minVersion,
+    versionArgument: options.versionArgument ?? "--version",
+  });
+  const access = await accessContext(path);
+  if (!access.file || !access.executable) {
+    logger.debug("binary access check failed", { path, ...access });
+    return false;
+  }
+  let stdout: string;
+  let stderr: string;
+  try {
+    const result = await execFileAsync(path, [options.versionArgument ?? "--version"], {
+      encoding: "utf8",
+    });
+    stdout = result.stdout;
+    stderr = result.stderr;
+  } catch (cause) {
+    logger.debug("binary version command failed", {
+      path,
+      error: error.errorMessage(cause),
+    });
     return false;
   }
+  const version = (options.versionParser ?? parseVersion)({
+    stdout,
+    stderr,
+  });
+  const valid = version !== undefined && meetsMinVersion(version, options.minVersion);
+  logger.debug("binary version checked", {
+    path,
+    version,
+    minVersion: options.minVersion,
+    valid,
+  });
+  return valid;
 }
 
 function downloadName(url: string, name: string): string {
@@ -127,6 +261,10 @@ async function selectedBin(
 ): Promise<string> {
   const name = downloadName(url, basename(destination.path));
   const downloadPath = join(temp, name);
+  logger.debug("downloading binary", {
+    from: displayUrl(url),
+    to: downloadPath,
+  });
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(`binary download failed (${response.status})`);
@@ -137,46 +275,85 @@ async function selectedBin(
   if (options.autoUnpackage) {
     source = join(temp, `unpacked-${randomUUID()}`);
     await mkdir(source);
+    logger.debug("unpacking binary archive", {
+      archive: downloadPath,
+      to: source,
+    });
     await unpack(downloadPath, source);
   }
 
   if (options.selector) {
-    return options.selector({ destination, downloadPath, source });
+    const selected = await options.selector({ destination, downloadPath, source });
+    logger.debug("selected binary", { path: selected });
+    return selected;
   }
-  return options.autoUnpackage ? selectSingleFile(source) : source;
+  const selected = options.autoUnpackage ? await selectSingleFile(source) : source;
+  logger.debug("selected binary", { path: selected });
+  return selected;
 }
 
 /**
  * Return an existing executable or install it atomically under
  * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load
  * sequence so concurrent callers resolve and download the binary only once.
+ * The downloaded candidate and final renamed executable must both pass the
+ * same executable and version checks.
  */
 export async function ensure(
   name: string,
   url: BinUrl,
   options: BinOptions = {},
 ): Promise<BinContext> {
+  if (options.minVersion && !numericVersion(options.minVersion, true)) {
+    throw new TypeError(`invalid minimum binary version: ${options.minVersion}`);
+  }
   const destination = context(name, options.homeDir ?? homedir());
-  if (await isExecutable(destination.path)) return destination;
+  if (await isValidBin(destination.path, options)) {
+    logger.debug("using installed binary", { name, path: destination.path });
+    return destination;
+  }
 
+  logger.debug("waiting for binary install lock", { name, path: destination.path });
   return withProcessLock(["bin.ensure", destination.path], async () => {
-    if (await isExecutable(destination.path)) return destination;
+    if (await isValidBin(destination.path, options)) {
+      logger.debug("using binary installed by another caller", {
+        name,
+        path: destination.path,
+      });
+      return destination;
+    }
 
     const resolvedUrl = typeof url === "function" ? await url() : url;
+    const from = displayUrl(resolvedUrl);
+    logger.debug("installing binary", {
+      name,
+      from,
+      to: destination.path,
+      minVersion: options.minVersion,
+    });
     const temp = await mkdtemp(join(tmpdir(), `${name}-`));
     let staged: string | undefined;
     try {
       const selected = await selectedBin(destination, resolvedUrl, temp, options);
-      if (!(await isExecutable(selected))) {
-        throw new Error(`selected binary is not executable: ${selected}`);
+      await chmod(selected, 0o755);
+      if (!(await isValidBin(selected, options))) {
+        throw new Error(`selected binary has no acceptable version: ${selected}`);
       }
 
       await mkdir(destination.binDir, { recursive: true });
       staged = join(destination.binDir, `.${name}-${randomUUID()}`);
       await copyFile(selected, staged);
-      await chmod(staged, (await stat(selected)).mode);
+      await chmod(staged, 0o755);
       await rename(staged, destination.path);
       staged = undefined;
+      if (!(await isValidBin(destination.path, options))) {
+        throw new Error(`installed binary is invalid after rename: ${destination.path}`);
+      }
+      logger.info("installed binary", {
+        name,
+        from,
+        to: destination.path,
+      });
       return destination;
     } finally {
       if (staged) await rm(staged, { force: true });