@tedbrain/vlink 0.1.62 → 0.1.64

package/README.md

@@ -9,7 +9,14 @@ npx --registry=https://registry.npmmirror.com -y @tedbrain/vlink@latest install
 ```
 
 该命令会识别平台和架构，始终安装与当前 npm 包版本一致的 vlink，配置用户
-PATH，并启动 `vlink setup tedbrain`。安装完成后可直接运行：
+PATH，并启动 `vlink setup tedbrain`。如果 PATH 中已有原生 vlink，会优先更新该位置；
+旧文件或目录不可写时，自动回退到用户安装目录（Unix 为 `~/.local/bin`，Windows 为
+`%LOCALAPPDATA%\TedBrain\bin`），保留原来的共享安装。显式设置 `VLINK_INSTALL_DIR`
+时始终使用该目录，写入失败会报错，不会再改装到其他位置。
+
+安装目录会优先加入当前安装进程的 PATH，补全和 setup 均使用新二进制的绝对路径。
+默认目录还会写入 shell 配置或 Windows 用户 PATH；自定义 Unix 目录需要自行配置
+永久 PATH。完成后请打开新终端，让 PATH 和 shell 命令缓存更新，再运行：
 
 ```bash
 vlink --version
@@ -28,6 +35,31 @@ Windows 会在 `vlink.exe` 旁同时生成 `vlink.cmd`。安装目录加入用
 npx --registry=https://registry.npmmirror.com -y @tedbrain/vlink@latest --version
 ```
 
+安装命令会输出安装目标、权限回退原因及 setup 状态；失败时输出错误并返回非零退出码。
+
+需要排查安装过程时，加上 `--verbose`：
+
+```bash
+npx --registry=https://registry.npmmirror.com -y \
+  @tedbrain/vlink@latest install --verbose
+```
+
+verbose 会从 npm 包的 JavaScript wrapper 开始输出 Node、包版本、平台选择、PATH
+查找、权限检查、二进制缓存或下载、复制、补全和 setup 各阶段。也可以设置
+`VLINK_VERBOSE=1`。日志不会打印完整环境变量、registry 凭据或下载 URL 的查询参数。
+
+如果上面的命令连 `[TedBrain:verbose] wrapper entered` 都没有输出，使用 npm 的显式
+package 形式，绕过 npx 的命令推断：
+
+```bash
+npm exec --registry=https://registry.npmmirror.com \
+  --package=@tedbrain/vlink@latest -- \
+  vlink install --verbose
+```
+
+若显式形式可以输出，问题发生在本机 npx 的参数路由或缓存阶段；若仍无 wrapper
+输出，可再加 npm 自身的 `--loglevel verbose` 检查 npm 在执行包之前的行为。
+
 手动配置 Agent 时可以只安装或更新 vlink，并跳过 TedBrain 配置向导：
 
 ```bash

package/bin/vlink.js

@@ -2,12 +2,45 @@
 'use strict';
 
 const { spawn } = require('child_process');
-const { ensureBinary } = require('../install');
-const { runInstallerFromArgs } = require('../installer');
+
+function verboseEnabled(args, env = process.env) {
+  const value = String(env.VLINK_VERBOSE || '').toLowerCase();
+  return args[0] === 'install' && (
+    args.includes('--verbose') || ['1', 'true', 'yes', 'on'].includes(value)
+  );
+}
+
+function verbose(message) {
+  process.stderr.write(`[TedBrain:verbose] ${message}\n`);
+}
+
+function diagnosticArgs(args) {
+  const safe = new Set(['install', '--verbose', '--no-setup', '--help', '-h']);
+  return args.map((arg) => {
+    if (safe.has(arg)) return arg;
+    if (arg.startsWith('--')) return arg.split('=', 1)[0];
+    return '<argument>';
+  });
+}
 
 async function main() {
   const args = process.argv.slice(2);
+  const diagnostic = verboseEnabled(args);
+  if (diagnostic) {
+    process.env.VLINK_VERBOSE = '1';
+    verbose('wrapper entered');
+    verbose(`node=${process.version} executable=${process.execPath}`);
+    verbose(`wrapper=${__filename}`);
+    verbose(`cwd=${process.cwd()}`);
+    verbose(`argv=${JSON.stringify(diagnosticArgs(args))}`);
+  }
+
+  const { ensureBinary, VERSION } = require('../install');
+  const { runInstallerFromArgs } = require('../installer');
+  if (diagnostic) verbose(`package version=${VERSION}`);
+
   if (args[0] === 'install') {
+    if (diagnostic) verbose('dispatching install command');
     await runInstallerFromArgs(args.slice(1));
     return;
   }

package/binaries.json

@@ -1,12 +1,12 @@
 {
-  "version": "0.1.62",
+  "version": "0.1.64",
   "binaries": {
-    "linux-x86_64": "367f723806e56bf5e5b882093aa3963045f743038e94a03163a1472912e24f63",
-    "linux-x86_64-glibc2.17": "6e72ba9f87e7f28d8ff7316be91b611ab3b9213503626623aaaa67458b6b5804",
-    "linux-aarch64": "a949d6df1361d2387a86cdf9849552020a3a2158e9a010da244cf4344fb86141",
-    "macos-x86_64": "e26767ec171771221b8421a02e1c349dc3633bfc8ae1fc7b921e0f502d4fab0a",
-    "macos-aarch64": "d59088bfd940376fa7fcea054e31ccf632ea2553a043da5d417d463deaf6429c",
-    "windows-x86_64.exe": "01482e74fa89c6536ab75278636d2dfab861c69f4e8e2060dc5a3977a2f9b8b6",
-    "windows-aarch64.exe": "572b403ac1ee1dcfd6dbcf8135c28f23fa7dfeca92fe1e958f7560ebc661cad0"
+    "linux-x86_64": "cd46ed189a1cb56a4d2ff84af7cda6a4870ad202f6172500e02a29654cb82b54",
+    "linux-x86_64-glibc2.17": "d578c70bafe98de520b25e78ea10919a12cb14fff0524ab3339bb0d912a78961",
+    "linux-aarch64": "8acbcce5bd84e14652f778ab987abe2a9f461b3ba4bb0dbe4022f8900a42868e",
+    "macos-x86_64": "5e96d897d75dc02a0e8acca05bfb8a5910751d38b10de0eda9f1c0ae9ac6df13",
+    "macos-aarch64": "8481807cd40cac885908550959e259164eaf9d2a20f10e2972c57a5f3e125815",
+    "windows-x86_64.exe": "90a2a090f993bc6258ccddacf62aa05d99d96b411a39a041cf2e6f19c6f8fd69",
+    "windows-aarch64.exe": "e96d0dcbfde313747a62cb7b5f945cfdf444927f40e758f25ed06da6c0d517b6"
   }
 }

package/install.js

@@ -26,6 +26,31 @@ const GLIBC217_SUFFIX = 'linux-x86_64-glibc2.17';
 
 class VlinkInstallError extends Error {}
 
+function verboseEnabled(options = {}) {
+  if (options.verbose === true) return true;
+  return ['1', 'true', 'yes', 'on'].includes(
+    String(process.env.VLINK_VERBOSE || '').toLowerCase()
+  );
+}
+
+function verboseLog(message, options = {}) {
+  if (!verboseEnabled(options)) return;
+  (options.output || process.stderr).write(`[vlink:verbose] ${message}\n`);
+}
+
+function displayUrl(value) {
+  try {
+    const url = new URL(value);
+    url.username = '';
+    url.password = '';
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+  } catch {
+    return '<invalid-url>';
+  }
+}
+
 function parseGlibcVersion(text) {
   for (const line of String(text || '').split(/\r?\n/)) {
     const glibcMatch = line.match(/\bglibc\s+([0-9]+(?:\.[0-9]+)+)/);
@@ -137,7 +162,7 @@ function httpGetText(url) {
           if (res.statusCode !== 200) {
             res.resume();
             return reject(
-              new VlinkInstallError(`HTTP ${res.statusCode} from ${target}`)
+              new VlinkInstallError(`HTTP ${res.statusCode} from ${displayUrl(target)}`)
             );
           }
 
@@ -308,7 +333,9 @@ function downloadFile(url, destPath) {
           if (res.statusCode !== 200) {
             res.resume();
             return reject(
-              new VlinkInstallError(`download failed: HTTP ${res.statusCode} from ${target}`)
+              new VlinkInstallError(
+                `download failed: HTTP ${res.statusCode} from ${displayUrl(target)}`
+              )
             );
           }
           res.pipe(fileStream);
@@ -339,14 +366,23 @@ function verifyBinary(binaryPath) {
   }
 }
 
-async function ensureBinary({ force = false } = {}) {
+async function ensureBinary(options = {}) {
+  const force = options.force === true;
   const spec = platformSpec();
   const binaryPath = resolveBinaryPath(spec);
+  verboseLog(
+    `binary resolver: version=${VERSION} platform=${spec.platform}/${spec.arch} ` +
+      `suffixes=${spec.suffixes.join(',')}`,
+    options
+  );
+  verboseLog(`binary resolver: selected path=${binaryPath} force=${force}`, options);
   if (!force && isExecutable(binaryPath)) {
+    verboseLog('binary resolver: using existing executable', options);
     return binaryPath;
   }
 
   const dir = path.dirname(binaryPath);
+  verboseLog(`binary resolver: creating download directory ${dir}`, options);
   fs.mkdirSync(dir, { recursive: true });
 
   let lastError = new VlinkInstallError('no download source available');
@@ -354,15 +390,22 @@ async function ensureBinary({ force = false } = {}) {
   for (const suffix of spec.suffixes) {
     const tempPath = path.join(dir, `.${spec.binaryName}.download-${process.pid}`);
     const sources = buildDownloadSources(spec, suffix);
+    verboseLog(
+      `download stage: suffix=${suffix} sources=${sources.map((source) => source.name).join(',')}`,
+      options
+    );
     for (const source of sources) {
       try {
+        verboseLog(`download stage: resolving ${source.name}`, options);
         const url = await source.resolve();
-        console.error(`[vlink] downloading ${url} [${source.name}]`);
+        console.error(`[vlink] downloading ${displayUrl(url)} [${source.name}]`);
         fs.rmSync(tempPath, { force: true });
         await downloadFile(url, tempPath);
+        verboseLog(`download stage: received ${source.name} payload`, options);
 
         const checksum = expectedChecksum(spec, suffix);
         if (checksum) {
+          verboseLog(`verification stage: checking SHA-256 for ${suffix}`, options);
           const actual = await sha256File(tempPath);
           if (actual !== checksum) {
             throw new VlinkInstallError(
@@ -376,7 +419,9 @@ async function ensureBinary({ force = false } = {}) {
         }
         if (fs.existsSync(binaryPath)) fs.rmSync(binaryPath, { force: true });
         fs.renameSync(tempPath, binaryPath);
+        verboseLog(`verification stage: executing ${binaryPath} -V`, options);
         verifyBinary(binaryPath);
+        verboseLog('verification stage: binary is ready', options);
         return binaryPath;
       } catch (err) {
         lastError = err;
@@ -393,6 +438,8 @@ module.exports = {
   VlinkInstallError,
   VERSION,
   GLIBC217_SUFFIX,
+  verboseEnabled,
+  displayUrl,
   parseGlibcVersion,
   glibcVersion,
   versionAtLeast,

package/installer.js

@@ -8,6 +8,8 @@ const { spawnSync } = require('child_process');
 
 const installModule = require('./install');
 
+const PERMISSION_ERRORS = new Set(['EACCES', 'EPERM', 'EROFS']);
+
 const CURRENT_WRAPPER = path.resolve(__dirname, 'bin', 'vlink.js');
 
 class VlinkSetupError extends Error {}
@@ -16,6 +18,20 @@ function log(message, output = process.stderr) {
   output.write(`[TedBrain] ${message}\n`);
 }
 
+function verboseEnabled(options = {}) {
+  if (options.verbose === true) return true;
+  const env = options.env || process.env;
+  return ['1', 'true', 'yes', 'on'].includes(
+    String(env.VLINK_VERBOSE || '').toLowerCase()
+  );
+}
+
+function verboseLog(message, options = {}) {
+  if (!verboseEnabled(options)) return;
+  const output = options.output || process.stderr;
+  output.write(`[TedBrain:verbose] ${message}\n`);
+}
+
 function environmentValue(env, name) {
   const expected = name.toLowerCase();
   for (const key of Object.keys(env)) {
@@ -110,8 +126,8 @@ function prependEnvironmentPath(directory, env, platform) {
   const entries = String(current)
     .split(delimiter)
     .filter(Boolean);
-  const alreadyPresent = entries.some((entry) => entry === directory);
-  const next = alreadyPresent ? entries.join(delimiter) : [directory, ...entries].join(delimiter);
+  const next = [directory, ...entries.filter((entry) => !samePath(entry, directory, platform))]
+    .join(delimiter);
 
   for (const key of Object.keys(env)) {
     if (key.toLowerCase() === 'path') delete env[key];
@@ -137,8 +153,9 @@ function updateWindowsUserPath(directory, options) {
     "$entry = $env:TEDBRAIN_INSTALL_DIR.TrimEnd('\\')",
     "$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')",
     "$entries = @($userPath -split ';' | Where-Object { $_ })",
-    "if (-not ($entries | Where-Object { $_.TrimEnd('\\') -ieq $entry })) {",
-    "  $newPath = (@($env:TEDBRAIN_INSTALL_DIR) + $entries) -join ';'",
+    "$remaining = @($entries | Where-Object { $_.TrimEnd('\\') -ine $entry })",
+    "$newPath = (@($env:TEDBRAIN_INSTALL_DIR) + $remaining) -join ';'",
+    "if ($newPath -cne $userPath) {",
     "  [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')",
     "  Write-Output 'changed'",
     "}"
@@ -167,6 +184,7 @@ function ensureUserPath(installDir, options = {}) {
   const fsImpl = options.fs || fs;
   const output = options.output || process.stderr;
 
+  verboseLog(`PATH stage: prioritizing ${installDir}`, options);
   prependEnvironmentPath(installDir, env, platform);
 
   if (platform === 'win32') {
@@ -288,12 +306,16 @@ function installBinary(sourcePath, targetPath, options = {}) {
   const spawnSyncImpl = options.spawnSync || spawnSync;
   const output = options.output || process.stderr;
 
-  if (samePath(sourcePath, targetPath, platform)) return targetPath;
+  if (samePath(sourcePath, targetPath, platform)) {
+    verboseLog(`copy stage: source already equals target ${targetPath}`, options);
+    return targetPath;
+  }
+  verboseLog(`copy stage: ${sourcePath} -> ${targetPath}`, options);
   fsImpl.mkdirSync(path.dirname(targetPath), { recursive: true });
 
   if (options.stopDaemon) {
     log('stopping the existing vlink daemon before replacement', output);
-    const stop = spawnSyncImpl(sourcePath, ['daemon', 'stop'], { stdio: 'inherit' });
+    const stop = spawnSyncImpl(sourcePath, ['daemon', 'stop'], { stdio: 'inherit', env: options.env });
     const failure = commandFailure(stop, 'vlink daemon stop');
     if (failure) throw new VlinkSetupError(failure);
   }
@@ -311,7 +333,9 @@ function installBinary(sourcePath, targetPath, options = {}) {
     fsImpl.renameSync(temporary, targetPath);
   } catch (error) {
     fsImpl.rmSync(temporary, { force: true });
-    throw new VlinkSetupError(`failed to install vlink at ${targetPath}: ${error.message}`);
+    const failure = new VlinkSetupError(`failed to install vlink at ${targetPath}: ${error.message}`);
+    failure.code = error.code;
+    throw failure;
   }
   fsImpl.rmSync(temporary, { force: true });
   log(`installed vlink at ${targetPath}`, output);
@@ -360,10 +384,12 @@ function installWindowsCommandShim(vlinkPath, options = {}) {
 function installShellCompletion(vlinkPath, options = {}) {
   const spawnSyncImpl = options.spawnSync || spawnSync;
   const output = options.output || process.stderr;
+  verboseLog(`completion stage: executing ${vlinkPath}`, options);
   const result = spawnSyncImpl(
     vlinkPath,
     ['completion', '--install', '--quiet'],
     {
+      env: options.env,
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe']
     }
@@ -394,7 +420,11 @@ async function migrateStaticVlink(vlinkPath, spec, options) {
   if (!binaryIsStaticElf(vlinkPath, options)) return vlinkPath;
 
   log('migrating the installed static vlink to the glibc 2.17 build', options.output);
-  const sourcePath = await options.ensureBinary({ force: true });
+  const sourcePath = await options.ensureBinary({
+    force: true,
+    verbose: verboseEnabled(options),
+    output: options.output
+  });
   return installBinary(sourcePath, vlinkPath, {
     ...options,
     stopDaemon: true
@@ -406,6 +436,7 @@ async function runInstaller(options = {}) {
   const platform = options.platform || env.VLINK_PLATFORM || process.platform;
   const arch = options.arch || env.VLINK_ARCH || process.arch;
   const skipSetup = Boolean(options.skipSetup);
+  const verbose = verboseEnabled(options);
   const home = options.home || os.homedir();
   const fsImpl = options.fs || fs;
   const output = options.output || process.stderr;
@@ -414,6 +445,17 @@ async function runInstaller(options = {}) {
   const ensureBinary =
     options.ensureBinary || ((settings) => installModule.ensureBinary(settings));
 
+  verboseLog(
+    `installer entered: package=${installModule.VERSION} platform=${platform} arch=${arch}`,
+    { ...options, env, output, verbose }
+  );
+  verboseLog(`runtime: node=${process.version} executable=${process.execPath}`, {
+    ...options,
+    env,
+    output,
+    verbose
+  });
+
   const spec = platformSpec({
     platform,
     arch,
@@ -423,7 +465,7 @@ async function runInstaller(options = {}) {
         : env.VLINK_GLIBC_VERSION,
     spawnSync: spawnSyncImpl
   });
-  const installDir = defaultInstallDir(spec, env, home);
+  const installDir = path.resolve(defaultInstallDir(spec, env, home));
   const targetPath = installPathFor(spec, installDir);
   const sharedOptions = {
     env,
@@ -431,14 +473,32 @@ async function runInstaller(options = {}) {
     home,
     fs: fsImpl,
     output,
-    spawnSync: spawnSyncImpl
+    spawnSync: spawnSyncImpl,
+    verbose
   };
 
+  verboseLog(
+    `platform stage: suffixes=${spec.suffixes.join(',')} binary=${spec.binaryName}`,
+    sharedOptions
+  );
+  verboseLog(
+    `target stage: installDir=${installDir} configured=${Boolean(env.VLINK_INSTALL_DIR)}`,
+    sharedOptions
+  );
+  const pathEntries = String(environmentValue(env, 'PATH'))
+    .split(platform === 'win32' ? ';' : path.delimiter)
+    .filter(Boolean).length;
+  verboseLog(`PATH stage: inspecting ${pathEntries} entries`, sharedOptions);
+
   let vlinkPath = findOnPath(spec.binaryName, {
     env,
     platform,
     fs: fsImpl
   });
+  verboseLog(
+    `discovery stage: native PATH binary=${vlinkPath || 'none'}`,
+    sharedOptions
+  );
 
   if (vlinkPath) {
     log(
@@ -447,7 +507,6 @@ async function runInstaller(options = {}) {
     );
   } else if (isExecutableFile(targetPath, platform, fsImpl)) {
     vlinkPath = targetPath;
-    ensureUserPath(installDir, sharedOptions);
     log(
       `found vlink at ${vlinkPath}; installing vlink ${installModule.VERSION}`,
       output
@@ -457,16 +516,39 @@ async function runInstaller(options = {}) {
   }
 
   const replacingExisting = Boolean(vlinkPath);
-  const installTarget = vlinkPath || targetPath;
-  const sourcePath = await ensureBinary({});
-  installBinary(sourcePath, installTarget, {
-    ...sharedOptions,
-    stopDaemon: replacingExisting
-  });
-  if (
-    !replacingExisting ||
-    samePath(path.dirname(installTarget), installDir, platform)
-  ) {
+  let installTarget = env.VLINK_INSTALL_DIR ? targetPath : (vlinkPath || targetPath);
+  // Avoid trying to replace a shared installation, even if its parent is writable.
+  if (vlinkPath && !env.VLINK_INSTALL_DIR && !samePath(vlinkPath, targetPath, platform)) {
+    verboseLog(`permission stage: checking ${vlinkPath} and its parent directory`, sharedOptions);
+    try {
+      fsImpl.accessSync(vlinkPath, fs.constants.W_OK);
+      fsImpl.accessSync(path.dirname(vlinkPath), fs.constants.W_OK);
+      verboseLog('permission stage: existing installation is replaceable', sharedOptions);
+    } catch (error) {
+      if (!PERMISSION_ERRORS.has(error.code)) throw error;
+      log(`cannot replace ${vlinkPath} (${error.code}); falling back to ${targetPath}`, output);
+      installTarget = targetPath;
+    }
+  }
+  installTarget = path.resolve(installTarget);
+  log(`installation target: ${installTarget}`, output);
+  verboseLog('binary stage: resolving packaged or cached binary', sharedOptions);
+  const sourcePath = await ensureBinary({ verbose, output });
+  verboseLog(`binary stage: source=${sourcePath}`, sharedOptions);
+  try {
+    installBinary(sourcePath, installTarget, {
+      ...sharedOptions,
+      stopDaemon: replacingExisting
+    });
+  } catch (error) {
+    // Permissions may change after the access check, or an ACL can deny rename.
+    if (env.VLINK_INSTALL_DIR || samePath(installTarget, targetPath, platform) ||
+        !PERMISSION_ERRORS.has(error.code)) throw error;
+    log(`cannot replace ${installTarget} (${error.code}); falling back to ${targetPath}`, output);
+    installTarget = targetPath;
+    installBinary(sourcePath, installTarget, sharedOptions);
+  }
+  if (samePath(path.dirname(installTarget), installDir, platform)) {
     ensureUserPath(installDir, sharedOptions);
   }
   vlinkPath = installTarget;
@@ -476,30 +558,40 @@ async function runInstaller(options = {}) {
     ensureBinary
   });
   const commandShimPath = installWindowsCommandShim(vlinkPath, sharedOptions);
+  verboseLog(
+    `shim stage: ${commandShimPath || 'not required on this platform'}`,
+    sharedOptions
+  );
   installShellCompletion(vlinkPath, sharedOptions);
 
   if (skipSetup) {
     log('skipping TedBrain Agent setup', output);
   } else {
     log('starting TedBrain Agent setup', output);
+    verboseLog(`setup stage: executing ${vlinkPath} setup tedbrain`, sharedOptions);
     const setup = spawnSyncImpl(vlinkPath, ['setup', 'tedbrain'], {
+      env,
       stdio: 'inherit'
     });
     const failure = commandFailure(setup, 'vlink setup tedbrain');
     if (failure) throw new VlinkSetupError(failure);
+    verboseLog('setup stage: completed successfully', sharedOptions);
   }
 
+  log(`installation complete: ${vlinkPath}`, output);
+  log('open a new terminal to use the updated PATH', output);
   return { installDir, vlinkPath, commandShimPath, setupSkipped: skipSetup };
 }
 
 function printInstallHelp(output = process.stdout) {
   output.write(
     [
-      'Usage: npx --registry=https://registry.npmmirror.com -y @tedbrain/vlink@latest install [--no-setup]',
+      'Usage: npx --registry=https://registry.npmmirror.com -y @tedbrain/vlink@latest install [--no-setup] [--verbose]',
       '',
       'Installs or updates vlink and adds it to the user PATH.',
       '',
-      '  --no-setup  Install without starting the TedBrain setup wizard.'
+      '  --no-setup  Install without starting the TedBrain setup wizard.',
+      '  --verbose   Print diagnostics for every installation stage.'
     ].join('\n') + '\n'
   );
 }
@@ -511,18 +603,23 @@ async function runInstallerFromArgs(args, options = {}) {
   }
 
   let skipSetup = false;
+  let verbose = verboseEnabled(options);
   for (const arg of args) {
     if (arg === '--no-setup') {
       skipSetup = true;
+    } else if (arg === '--verbose') {
+      verbose = true;
     } else {
-      throw new VlinkSetupError(`unknown install option: ${arg}`);
+      const displayArg = arg.startsWith('--') ? arg.split('=', 1)[0] : '<argument>';
+      throw new VlinkSetupError(`unknown install option: ${displayArg}`);
     }
   }
-  return runInstaller({ ...options, skipSetup });
+  return runInstaller({ ...options, skipSetup, verbose });
 }
 
 module.exports = {
   VlinkSetupError,
+  verboseEnabled,
   defaultInstallDir,
   installPathFor,
   isExecutableFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tedbrain/vlink",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "vlink Virtuoso bridge CLI installer. Installs the matching platform binary at npm install time, like Claude Code / Codex.",
   "license": "UNLICENSED",
   "bin": {