gdx 0.4.6 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdx",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "Git, but with better DX. The raw power of Git, aligned with human workflows.",
   "homepage": "https://github.com/Type-Delta/gdx#readme",
   "bugs": {
@@ -25,12 +25,13 @@
   "files": [
     "dist/*.js",
     "dist/workers/*.js",
+    "dist/diagnostics/*.js",
     "scripts/postinstall.cjs",
     "scripts/launcher.cjs",
     "README.md",
     "LICENSE"
   ],
-  "packageManager": "bun@1.3.10",
+  "packageManager": "bun@1.3.14",
   "scripts": {
     "prepare-dev": "bun i && bun run transpile-esm",
     "start": "bun run src/index.ts",
@@ -38,11 +39,17 @@
     "start:node": "tsx src/index.ts",
     "transpile-esm": "bunx tsc -p lib/tsconfig.json && bun run scripts/transform-tools.mjs",
     "check": "bun run ts-check && bun run lint && bun run build",
-    "lint": "bun run ts-check && eslint src --ext .ts -c eslint.config.ts --fix",
-    "test": "bun test",
-    "build": "bun run transpile-esm && bun build ./src/index.ts --outfile=./bin/gdx --compile --bytecode --production --keep-names",
+    "lint": "bun run ts-check && eslint src --ext .ts -c eslint.config.ts",
+    "lint:fix": "bun run ts-check && eslint src --ext .ts -c eslint.config.ts --fix",
+    "test:serial": "bun test",
+    "test": "bun test --parallel --timeout 20000",
+    "build": "bun run transpile-esm && bun run build:diagnostics:bin && GDX_BUILD=$(git describe --tags --always --dirty) bun build ./src/index.ts --env='GDX_BUILD*' --outfile=./bin/gdx --compile --bytecode --production --keep-names",
+    "build:release:win32-x64": "bun run transpile-esm && bun run build:diagnostics:bin && GDX_BUILD=$(git describe --tags --always --dirty) bun build ./src/index.ts --env='GDX_BUILD*' --outfile=./bin/gdx-win32-x64.exe --compile --bytecode --production --keep-names",
+    "build:diagnostics:bin": "bun build ./test/postinstall.validator.ts --outfile=./bin/diagnostics/postinstall.validator.js --target=bun --format=esm --production --minify --keep-names",
+    "build:diagnostics:node": "bun build ./test/postinstall.validator.ts --outfile=./dist/diagnostics/postinstall.validator.js --target=node --format=esm --production --minify --keep-names",
     "ts-check": "bunx tsc --noEmit",
-    "package:node": "bun run transpile-esm && bun build ./src/index.ts --outdir=./dist --target=node --external=keytar --external=cspell-lib --external=@shikijs/cli --external=shiki --external=yaml --external=openai --external=fflate --external=diff --format=esm --production --keep-names && bun build ./src/workers/generic.worker.ts --outfile=./dist/workers/generic.worker.min.js --target=node --external=@shikijs/cli --format=esm --production --minify --keep-names",
+    "package:node": "bun run transpile-esm && GDX_BUILD=$(git describe --tags --always --dirty) bun build ./src/index.ts --env='GDX_BUILD*' --outdir=./dist --target=node --external=keytar --external=cspell-lib --external=@shikijs/cli --external=shiki --external=yaml --external=openai --external=fflate --external=diff --external=@leeoniya/ufuzzy --format=esm --production --keep-names && bun build ./src/workers/generic.worker.ts --outfile=./dist/workers/generic.worker.min.js --target=node --external=@shikijs/cli --format=esm --production --minify --keep-names && bun run build:diagnostics:node",
+    "publish:npm": "npm login && npm publish --access public",
     "prepack": "bun run package:node",
     "postinstall": "node scripts/postinstall.cjs",
     "prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"./*.md\"",
@@ -56,14 +63,14 @@
     "@babel/core": "^7.29.0",
     "@babel/preset-env": "^7.29.5",
     "@babel/preset-typescript": "^7.28.5",
-    "@eslint/js": "^9.39.4",
+    "@eslint/js": "^10.0.1",
     "@sinclair/typebox": "^0.34.49",
     "@types/chai": "^5.2.3",
     "@types/ini": "^4.1.1",
     "@types/which": "^3.0.4",
     "@typescript-eslint/eslint-plugin": "^8.59.4",
     "@typescript-eslint/parser": "^8.59.4",
-    "bun-types": "latest",
+    "bun-types": "1.3.14",
     "chai": "^6.2.2",
     "dedent": "^1.7.2",
     "eslint": "^10.4.0",
@@ -81,6 +88,7 @@
     "which": "2.0.2"
   },
   "dependencies": {
+    "@leeoniya/ufuzzy": "^1.0.19",
     "@shikijs/cli": "^4.1.0",
     "cspell-lib": "10.0.0",
     "diff": "^9.0.0",

package/scripts/launcher.cjs

@@ -6,36 +6,55 @@ const fs = require('fs');
 const path = require('path');
 const { spawn } = require('child_process');
 
-const DIST_DIR = path.join(__dirname, '../dist');
-const NATIVE_DIR = path.join(DIST_DIR, 'native');
+const DIST_DIR = path.join(__dirname, '../dist');
+const NATIVE_DIR = path.join(__dirname, '../bin/native');
 const isWin = process.platform === 'win32';
 const binaryName = isWin ? 'gdx.exe' : 'gdx';
-const binaryPath = path.join(NATIVE_DIR, binaryName);
 
-if (process.env.GDX_NODE_SHIM === '1' && process.argv[2] === '--') {
+if (
+   (process.env.GDX_RUNTIME_SHIM === '1' || process.env.GDX_NODE_SHIM === '1') &&
+   process.argv[2] === '--'
+) {
    process.argv.splice(2, 1);
 }
 
-// Check if native binary exists
-if (fs.existsSync(binaryPath)) {
-   const child = spawn(binaryPath, process.argv.slice(2), {
-      stdio: 'inherit'
-   });
-
-   child.on('close', (code) => {
-      process.exit(code);
-   });
-
-   child.on('error', (err) => {
-      console.error('Failed to start native binary:', err);
-      process.exit(1);
-   });
-} else {
-   // Fallback to Node.js runtime (dist/index.js)
-   // Since dist/index.js is ESM, we use dynamic import
-   const jsEntry = path.join(DIST_DIR, 'index.js');
-   import(require('url').pathToFileURL(jsEntry)).catch(err => {
-      console.error('Failed to load JS fallback:', err);
-      process.exit(1);
-   });
-}
+function getNativeBinaryPath() {
+   return path.join(NATIVE_DIR, binaryName);
+}
+
+function runLauncher() {
+   const binaryPath = getNativeBinaryPath();
+
+   // Check if native binary exists
+   if (fs.existsSync(binaryPath)) {
+      const child = spawn(binaryPath, process.argv.slice(2), {
+         stdio: 'inherit'
+      });
+
+      child.on('close', (code) => {
+         process.exit(code);
+      });
+
+      child.on('error', (err) => {
+         console.error('Failed to start native binary:', err);
+         process.exit(1);
+      });
+   } else {
+      // Fallback to Node.js runtime (dist/index.js)
+      // Since dist/index.js is ESM, we use dynamic import
+      const jsEntry = path.join(DIST_DIR, 'index.js');
+      import(require('url').pathToFileURL(jsEntry)).catch(err => {
+         console.error('Failed to load JS fallback:', err);
+         process.exit(1);
+      });
+   }
+}
+
+if (require.main === module) {
+   runLauncher();
+}
+
+module.exports = {
+   getNativeBinaryPath,
+   runLauncher,
+};

package/scripts/postinstall.cjs

@@ -2,6 +2,7 @@
 /* eslint-disable @typescript-eslint/no-require-imports */
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { spawnSync, execFileSync } = require('child_process');
 
 // Configuration
@@ -38,6 +39,35 @@ function writeInstallInfo(info) {
    fs.writeFileSync(INSTALL_INFO_PATH, JSON.stringify(info, null, 2));
 }
 
+function getNativeBinaryName(platform = process.platform) {
+   return platform === 'win32' ? 'gdx.exe' : 'gdx';
+}
+
+function getNativeBuildArgs(finalPath) {
+   return [
+      'build',
+      PKG_SRC_PATH,
+      `--outfile=${finalPath}`,
+      '--compile',
+      '--bytecode',
+      '--production',
+      '--keep-names',
+   ];
+}
+
+function createInstallInfo(mode, finalPath, useNativeShim) {
+   return {
+      mode,
+      platform: process.platform,
+      arch: process.arch,
+      version: getPackageVersion(),
+      userAgent: process.env.npm_config_user_agent || null,
+      useNativeShim,
+      ts: (new Date).toLocaleString(),
+      binaryPath: finalPath
+   };
+}
+
 function isTruthy(v) {
    return v === '1' || v === 'true' || v === 'yes';
 }
@@ -51,11 +81,10 @@ function getPrefixFromEnvOrNpm() {
    const npmExecPath = process.env.npm_execpath;
    if (!npmExecPath) return null;
 
-   const prefix = execFileSync(
-      `"${npmExecPath}"`,
-      ['config', 'get', 'prefix'],
-      { encoding: 'utf8', shell: true }
-   ).trim();
+   const prefix = execFileSync(npmExecPath, ['config', 'get', 'prefix'], {
+      encoding: 'utf8',
+      shell: false,
+   }).trim();
 
    return prefix || null;
 }
@@ -66,7 +95,10 @@ async function checkUrlExists(url) {
       const res = await fetch(url, { method: 'HEAD', redirect: 'follow' });
       return res.ok;
    } catch (err) {
-      throw new Error(`Network error while checking prebuilt availability: ${err.message} (${url})`);
+      throw new Error(
+         `Network error while checking prebuilt availability: ${err.message} (${url})`,
+         { cause: err }
+      );
    }
 }
 
@@ -76,13 +108,38 @@ async function downloadFile(url, tmpPath, destPath) {
       throw new Error(`Failed to download: ${res.statusText} (${url})`);
    }
 
-   const fileStream = fs.createWriteStream(destPath);
+   const fileStream = fs.createWriteStream(tmpPath);
    const stream = require('stream');
    const { promisify } = require('util');
    const pipeline = promisify(stream.pipeline);
 
    await pipeline(res.body, fileStream);
-   fs.renameSync(tmpPath, destPath);
+   if (tmpPath !== destPath) {
+      fs.renameSync(tmpPath, destPath);
+   }
+}
+
+function readSha256FromText(text, assetName) {
+   const trimmed = text.trim();
+   const match = trimmed.match(/\b([a-fA-F0-9]{64})\b/);
+   if (!match) {
+      throw new Error(`Invalid SHA256 checksum for ${assetName}.`);
+   }
+   return match[1].toLowerCase();
+}
+
+function sha256File(filePath) {
+   return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function verifySha256(filePath, checksumText, assetName) {
+   const expected = readSha256FromText(checksumText, assetName);
+   const actual = sha256File(filePath);
+   if (actual !== expected) {
+      throw new Error(
+         `Checksum mismatch for ${assetName}. Expected ${expected}, got ${actual}.`
+      );
+   }
 }
 
 function setExecutable(filePath) {
@@ -102,25 +159,25 @@ function writeFileExecutable(filePath, content) {
    setExecutable(filePath);
 }
 
-function buildNodeShimContents(nodeAbsPath, launcherAbsPath) {
+function buildRuntimeShimContents(runtimeAbsPath, launcherAbsPath) {
    return {
       cmd: [
          '@echo off',
-         'set "GDX_NODE_SHIM=1"',
-         `"${nodeAbsPath}" "${launcherAbsPath}" -- %*`,
+         'set "GDX_RUNTIME_SHIM=1"',
+         `"${runtimeAbsPath}" "${launcherAbsPath}" -- %*`,
          'exit /b %ERRORLEVEL%',
          ''
       ].join('\r\n'),
       ps1: [
-         '$env:GDX_NODE_SHIM = "1"',
-         `& "${nodeAbsPath}" "${launcherAbsPath}" -- @args`,
+         '$env:GDX_RUNTIME_SHIM = "1"',
+         `& "${runtimeAbsPath}" "${launcherAbsPath}" -- @args`,
          'exit $LASTEXITCODE',
          ''
       ].join('\r\n'),
       sh: [
          '#!/usr/bin/env sh',
-         'export GDX_NODE_SHIM=1',
-         `exec "${nodeAbsPath}" "${launcherAbsPath}" -- "$@"`,
+         'export GDX_RUNTIME_SHIM=1',
+         `exec "${runtimeAbsPath}" "${launcherAbsPath}" -- "$@"`,
          ''
       ].join('\n'),
    };
@@ -130,11 +187,10 @@ function getLocalNodeModulesBinDir() {
    return path.resolve(PACKAGE_DIR, '..', '.bin');
 }
 
-function overwriteNodeShim(binDir, launcherAbsPath) {
+function overwriteRuntimeShim(binDir, launcherAbsPath, runtime) {
    if (!binDir || !fs.existsSync(binDir)) return false;
 
-   const nodeAbsPath = process.execPath;
-   const shims = buildNodeShimContents(nodeAbsPath, launcherAbsPath);
+   const shims = buildRuntimeShimContents(runtime.executable, launcherAbsPath);
 
    if (process.platform === 'win32') {
       writeFileExecutable(path.join(binDir, 'gdx.cmd'), shims.cmd);
@@ -168,7 +224,7 @@ function overwriteGlobalShim(nativeAbsPath) {
 
    if (!(process.env.npm_config_user_agent || '').includes('npm/')) {
       log('Non-npm global install detected; skipping global shim overwrite.');
-      log('This may result in overhead introduced by the Node.js launch script.');
+      log('This may result in overhead introduced by the JavaScript launch script.');
       return false;
    }
 
@@ -208,14 +264,46 @@ function overwriteGlobalShim(nativeAbsPath) {
    return true;
 }
 
-function installNodeFallbackShims() {
+function findRuntimeExecutable(name, platform = process.platform) {
+   const locator = platform === 'win32' ? 'where.exe' : 'which';
+   const located = spawnSync(locator, [name], {
+      encoding: 'utf8',
+      windowsHide: true,
+   });
+   if (located.error || located.status !== 0) return null;
+
+   for (const executable of String(located.stdout || '').split(/\r?\n/).filter(Boolean)) {
+      const needsShell = platform === 'win32' && /\.(?:cmd|bat)$/i.test(executable);
+      const probe = spawnSync(
+         executable,
+         ['-e', "require('path');process.stdout.write('gdx-runtime')"],
+         {
+            encoding: 'utf8',
+            shell: needsShell,
+            windowsHide: true,
+         }
+      );
+      if (!probe.error && probe.status === 0 && probe.stdout === 'gdx-runtime') return executable;
+   }
+   return null;
+}
+
+function selectFallbackRuntime(findExecutable = findRuntimeExecutable) {
+   for (const name of ['bun']) { // FIXME: waiting to runtimes with latency lower than Bun's
+      const executable = findExecutable(name);
+      if (executable) return { name, executable };
+   }
+   return { name: 'node', executable: process.execPath };
+}
+
+function installRuntimeFallbackShims(runtime) {
    const launcherAbsPath = path.join(__dirname, 'launcher.cjs');
    const localBin = getLocalNodeModulesBinDir();
    const globalBin = getNpmGlobalBinDir();
 
    return {
-      local: overwriteNodeShim(localBin, launcherAbsPath),
-      global: overwriteNodeShim(globalBin, launcherAbsPath),
+      local: overwriteRuntimeShim(localBin, launcherAbsPath, runtime),
+      global: overwriteRuntimeShim(globalBin, launcherAbsPath, runtime),
    };
 }
 
@@ -232,6 +320,7 @@ async function tryDownloadPrebuilt() {
    const ext = platform === 'win32' ? '.exe' : '';
    const assetName = `gdx-${platform}-${arch}${ext}`;
    const url = `${PREBUILT_BASE_URL}/v${version}/${assetName}`;
+   const checksumUrl = `${url}.sha256`;
 
    log(`Checking availability of prebuilt binary: ${url}`);
    const exists = await checkUrlExists(url);
@@ -241,11 +330,21 @@ async function tryDownloadPrebuilt() {
 
    log(`Downloading prebuilt binary...`);
    const tmpPath = path.join(NATIVE_DIR, `${assetName}.tmp`);
+   const checksumTmpPath = path.join(NATIVE_DIR, `${assetName}.sha256.tmp`);
+   const checksumPath = path.join(NATIVE_DIR, `${assetName}.sha256`);
    const finalPath = path.join(NATIVE_DIR, 'gdx' + ext);
 
    ensureBinDir();
-   await downloadFile(url, tmpPath, finalPath);
-   setExecutable(finalPath);
+   try {
+      await downloadFile(url, tmpPath, tmpPath);
+      await downloadFile(checksumUrl, checksumTmpPath, checksumPath);
+      verifySha256(tmpPath, fs.readFileSync(checksumPath, 'utf8'), assetName);
+      fs.renameSync(tmpPath, finalPath);
+      setExecutable(finalPath);
+   } finally {
+      fs.rmSync(tmpPath, { force: true });
+      fs.rmSync(checksumTmpPath, { force: true });
+   }
 
    log(`Prebuilt binary installed to ${finalPath}`);
 
@@ -271,21 +370,11 @@ function tryBuildNative() {
    }
 
    const platform = process.platform;
-   const arch = process.arch;
-   const isWin = platform === 'win32';
-   const binaryName = isWin ? 'gdx.exe' : 'gdx';
+   const binaryName = getNativeBinaryName(platform);
    const finalPath = path.join(NATIVE_DIR, binaryName);
 
    // Build command
-   const args = [
-      'build',
-      PKG_SRC_PATH,
-      `--outfile=${finalPath}`,
-      '--compile',
-      '--bytecode',
-      '--production',
-      '--keep-names',
-   ];
+   const args = getNativeBuildArgs(finalPath);
 
    ensureBinDir();
    log(`Running: bun ${args.join(' ')}`);
@@ -297,16 +386,7 @@ function tryBuildNative() {
 
    log(`Native binary built at ${finalPath}`);
 
-   writeInstallInfo({
-      mode: 'built',
-      platform,
-      arch,
-      version: getPackageVersion(),
-      userAgent: process.env.npm_config_user_agent || null,
-      useNativeShim: overwriteGlobalShim(finalPath),
-      ts: (new Date).toLocaleString(),
-      binaryPath: finalPath
-   });
+   writeInstallInfo(createInstallInfo('built', finalPath, overwriteGlobalShim(finalPath)));
 }
 
 async function main() {
@@ -323,10 +403,13 @@ async function main() {
       } else if (isTruthy(process.env.GDX_BUILD_NATIVE)) {
          tryBuildNative();
       } else {
-         log('No native install requested (default). Using Node.js fallback.');
-         const shimInstall = installNodeFallbackShims();
+         const runtime = selectFallbackRuntime();
+         log(`No native install requested (default). Using ${runtime.name} fallback.`);
+         const shimInstall = installRuntimeFallbackShims(runtime);
          writeInstallInfo({
-            mode: 'node',
+            mode: 'runtime',
+            runtime: runtime.name,
+            runtimePath: runtime.executable,
             platform: process.platform,
             arch: process.arch,
             version: getPackageVersion(),
@@ -348,8 +431,16 @@ if (require.main === module) {
 }
 
 module.exports = {
-   buildNodeShimContents,
+   buildRuntimeShimContents,
+   createInstallInfo,
+   downloadFile,
+   getNativeBinaryName,
+   getNativeBuildArgs,
    getLocalNodeModulesBinDir,
-   installNodeFallbackShims,
-   overwriteNodeShim,
+   findRuntimeExecutable,
+   installRuntimeFallbackShims,
+   overwriteRuntimeShim,
+   readSha256FromText,
+   selectFallbackRuntime,
+   verifySha256,
 };