@muthuishere/routsi 0.1.1 → 0.1.2

package/README.md

@@ -20,9 +20,12 @@ routsi serve                     # listens on :8080 by default
 npm install -g @muthuishere/routsi
 ```
 
-`postinstall` downloads the prebuilt `routsi` binary for your OS/arch from [GitHub
-Releases](https://github.com/muthuishere/routsi/releases) — no Go toolchain needed.
-See [`docs/adr/006-npm-distribution.md`](docs/adr/006-npm-distribution.md) for how it
+`postinstall` best-effort prefetches the prebuilt `routsi` binary for your OS/arch
+from [GitHub Releases](https://github.com/muthuishere/routsi/releases) — no Go
+toolchain needed. The launcher is self-healing: if postinstall didn't run (blocked
+by `allow-scripts`, offline, whatever), the first `routsi` invocation fetches the
+binary itself, so the command always works either way. See
+[`docs/adr/006-npm-distribution.md`](docs/adr/006-npm-distribution.md) for how it
 works.
 
 Point any OpenAI client at `http://localhost:8080/v1`. Then:

package/npm/launcher.js

@@ -1,33 +1,50 @@
 #!/usr/bin/env node
 'use strict';
 
-// Thin launcher installed as the `routsi` bin entry. Execs the native binary
-// downloaded by scripts/postinstall.js into npm/bin/, passing argv/stdio/exit
-// code straight through. Kept separate from the Go build's own `bin/routsi`
-// output so `task build` (repo checkout) and this npm package never collide.
+// Thin launcher installed as the `routsi` bin entry. Guarantees the native
+// binary is present (self-healing — downloads it on demand via
+// npm/resolve-binary.js if postinstall didn't run or was blocked, e.g. by
+// `allow-scripts`), then execs it, passing argv/stdio/exit code straight
+// through. Kept separate from the Go build's own `bin/routsi` output so
+// `task build` (repo checkout) and this npm package never collide.
 
-const path = require('path');
-const fs = require('fs');
-const { spawnSync } = require('child_process');
+const { spawn } = require('child_process');
+const { ensureBinary } = require('./resolve-binary');
 
-const binName = process.platform === 'win32' ? 'routsi.exe' : 'routsi';
-const binPath = path.join(__dirname, 'bin', binName);
+(async function main() {
+  let binPath;
+  try {
+    binPath = await ensureBinary({ quiet: false });
+  } catch (err) {
+    console.error('routsi: ' + (err && err.message ? err.message : String(err)));
+    process.exit(1);
+    return;
+  }
 
-if (!fs.existsSync(binPath)) {
-  console.error(
-    `routsi: native binary not found at ${binPath}.\n` +
-    'The postinstall step may have failed or been skipped (offline install?).\n' +
-    'Try: npm install -g routsi --force\n' +
-    'Or download a binary manually from https://github.com/muthuishere/routsi/releases'
-  );
-  process.exit(1);
-}
+  const child = spawn(binPath, process.argv.slice(2), { stdio: 'inherit' });
 
-const result = spawnSync(binPath, process.argv.slice(2), { stdio: 'inherit' });
+  const forwardSignal = (signal) => {
+    if (child.killed === false) {
+      try {
+        child.kill(signal);
+      } catch (_) {
+        // ignore — child may have already exited
+      }
+    }
+  };
+  process.on('SIGINT', forwardSignal);
+  process.on('SIGTERM', forwardSignal);
 
-if (result.error) {
-  console.error('routsi: failed to launch native binary: ' + result.error.message);
-  process.exit(1);
-}
+  child.on('error', (err) => {
+    console.error('routsi: failed to launch native binary: ' + err.message);
+    process.exit(1);
+  });
 
-process.exit(result.status === null ? 1 : result.status);
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code === null ? 1 : code);
+  });
+})();

package/npm/resolve-binary.js

@@ -0,0 +1,257 @@
+'use strict';
+
+// Shared, zero-dependency binary resolution/fetch logic for routsi's npm
+// distribution (ADR 006). Used by both scripts/postinstall.js (best-effort
+// prefetch) and npm/launcher.js (guarantees the binary before every run).
+//
+// Asset naming scheme (MUST match .github/workflows/release.yml):
+//   routsi_<os>_<arch>.tar.gz   (darwin/linux)
+//   routsi_windows_<arch>.zip  (windows)
+// where <os> in {darwin, linux, windows}, <arch> in {amd64, arm64}.
+// Release URL: https://github.com/muthuishere/routsi/releases/download/v<version>/<asset>
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+const REPO = 'muthuishere/routsi';
+const PKG_ROOT = path.join(__dirname, '..');
+const BIN_DIR = path.join(PKG_ROOT, 'npm', 'bin');
+
+// platform: node's os.platform() value ('darwin'|'linux'|'win32'|...)
+// arch: node's os.arch() value ('x64'|'arm64'|...)
+function mapPlatform(platform) {
+  if (platform === 'darwin') return 'darwin';
+  if (platform === 'linux') return 'linux';
+  if (platform === 'win32') return 'windows';
+  return null;
+}
+
+function mapArch(arch) {
+  if (arch === 'x64') return 'amd64';
+  if (arch === 'arm64') return 'arm64';
+  return null;
+}
+
+// Pure mapping function — unit-tested by scripts/postinstall.test.js.
+function assetName(platform, arch, version) {
+  const os_ = mapPlatform(platform);
+  const arch_ = mapArch(arch);
+  if (!os_ || !arch_) {
+    throw new Error(`unsupported platform/arch: ${platform}/${arch}`);
+  }
+  const ext = os_ === 'windows' ? 'zip' : 'tar.gz';
+  return `routsi_${os_}_${arch_}.${ext}`;
+}
+
+function binaryName(platform) {
+  return mapPlatform(platform) === 'windows' ? 'routsi.exe' : 'routsi';
+}
+
+function binaryPath() {
+  return path.join(BIN_DIR, binaryName(process.platform));
+}
+
+function releaseUrl(version, asset) {
+  return `https://github.com/${REPO}/releases/download/v${version}/${asset}`;
+}
+
+// version() reads package.json's version, but allows an env override for
+// testing against an already-released version before a new one is cut.
+function version() {
+  if (process.env.ROUTSI_BINARY_VERSION) return process.env.ROUTSI_BINARY_VERSION;
+  const pkg = require(path.join(PKG_ROOT, 'package.json'));
+  return pkg.version;
+}
+
+function isOffline() {
+  if (process.env.npm_config_offline === 'true') return true;
+  if (process.env.npm_config_prefer_offline === 'true' && process.env.ROUTSI_ALLOW_STALE) return true;
+  return false;
+}
+
+// GET with a bounded number of redirect hops. Returns a Buffer via callback.
+function fetchBuffer(url, redirectsLeft, cb) {
+  const req = https.get(url, { headers: { 'User-Agent': 'routsi-npm-launcher' } }, (res) => {
+    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+      if (redirectsLeft <= 0) {
+        cb(new Error('too many redirects fetching ' + url));
+        return;
+      }
+      res.resume();
+      fetchBuffer(res.headers.location, redirectsLeft - 1, cb);
+      return;
+    }
+    if (res.statusCode !== 200) {
+      res.resume();
+      cb(new Error(`GET ${url} -> HTTP ${res.statusCode}`));
+      return;
+    }
+    const chunks = [];
+    res.on('data', (c) => chunks.push(c));
+    res.on('end', () => cb(null, Buffer.concat(chunks)));
+    res.on('error', cb);
+  });
+  req.on('error', cb);
+}
+
+function fetchBufferAsync(url) {
+  return new Promise((resolve, reject) => {
+    fetchBuffer(url, 5, (err, buf) => (err ? reject(err) : resolve(buf)));
+  });
+}
+
+// Best-effort checksum verification. If checksums.txt can't be fetched (e.g.
+// older release, network hiccup), we proceed without failing the install.
+async function verifyChecksum(ver, assetBuf, asset) {
+  let checksumsBuf;
+  try {
+    checksumsBuf = await fetchBufferAsync(releaseUrl(ver, 'checksums.txt'));
+  } catch (err) {
+    console.warn('routsi: could not fetch checksums.txt (' + err.message + '), skipping verification');
+    return;
+  }
+  const text = checksumsBuf.toString('utf8');
+  const line = text.split('\n').find((l) => l.trim().endsWith(asset));
+  if (!line) {
+    console.warn('routsi: no checksum entry for ' + asset + ', skipping verification');
+    return;
+  }
+  const expected = line.trim().split(/\s+/)[0].toLowerCase();
+  const actual = crypto.createHash('sha256').update(assetBuf).digest('hex');
+  if (expected !== actual) {
+    throw new Error(`checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
+  }
+}
+
+function extractTarGz(buf, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const tmpTar = path.join(os.tmpdir(), `routsi-${Date.now()}.tar.gz`);
+  fs.writeFileSync(tmpTar, buf);
+  try {
+    execFileSync('tar', ['-xzf', tmpTar, '-C', destDir], { stdio: 'inherit' });
+  } finally {
+    fs.rmSync(tmpTar, { force: true });
+  }
+}
+
+function extractZip(buf, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const tmpZip = path.join(os.tmpdir(), `routsi-${Date.now()}.zip`);
+  fs.writeFileSync(tmpZip, buf);
+  try {
+    if (process.platform === 'win32') {
+      execFileSync('powershell.exe', [
+        '-NoProfile', '-Command',
+        `Expand-Archive -Force -Path "${tmpZip}" -DestinationPath "${destDir}"`,
+      ], { stdio: 'inherit' });
+    } else {
+      execFileSync('unzip', ['-o', tmpZip, '-d', destDir], { stdio: 'inherit' });
+    }
+  } finally {
+    fs.rmSync(tmpZip, { force: true });
+  }
+}
+
+// Locate the extracted binary — tarball/zip is flat (no top-level dir), but
+// tolerate one either way.
+function findExtractedBinary(destDir, wantName) {
+  const direct = path.join(destDir, wantName);
+  if (fs.existsSync(direct)) return direct;
+  const entries = fs.readdirSync(destDir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      const nested = path.join(destDir, e.name, wantName);
+      if (fs.existsSync(nested)) return nested;
+    }
+  }
+  return null;
+}
+
+// ensureBinary: returns the absolute path to a working npm/bin/routsi[.exe],
+// downloading + extracting the release asset if it isn't already there.
+// Never touches npm install lifecycle semantics — callers decide what to do
+// with a thrown error.
+async function ensureBinary(opts) {
+  opts = opts || {};
+  const quiet = !!opts.quiet;
+  const platform = process.platform;
+  const arch = process.arch;
+  const finalBinPath = binaryPath();
+
+  if (fs.existsSync(finalBinPath) && fs.statSync(finalBinPath).size > 0) {
+    return finalBinPath;
+  }
+
+  const ver = version();
+
+  if (isOffline()) {
+    throw new Error(
+      'offline mode requested (npm_config_offline) and no binary present at ' + finalBinPath
+    );
+  }
+
+  let asset;
+  try {
+    asset = assetName(platform, arch, ver);
+  } catch (err) {
+    throw new Error(
+      `${err.message}. routsi ships prebuilt binaries for darwin/linux/windows on amd64/arm64.\n` +
+      `Build from source instead: https://github.com/${REPO}`
+    );
+  }
+
+  if (!quiet) {
+    console.error(`routsi: fetching native binary v${ver} for ${platform}-${arch}...`);
+  }
+
+  const url = releaseUrl(ver, asset);
+  let assetBuf;
+  try {
+    assetBuf = await fetchBufferAsync(url);
+  } catch (err) {
+    throw new Error(
+      `failed to download ${url}: ${err.message}\n` +
+      `See release assets at https://github.com/${REPO}/releases — you can also\n` +
+      'download the right binary by hand and place it on your PATH.'
+    );
+  }
+
+  await verifyChecksum(ver, assetBuf, asset);
+
+  const extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'routsi-extract-'));
+  try {
+    if (asset.endsWith('.zip')) {
+      extractZip(assetBuf, extractDir);
+    } else {
+      extractTarGz(assetBuf, extractDir);
+    }
+
+    const wantName = binaryName(platform);
+    const extracted = findExtractedBinary(extractDir, wantName);
+    if (!extracted) {
+      throw new Error(`downloaded archive ${asset} did not contain expected binary ${wantName}`);
+    }
+
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+    fs.copyFileSync(extracted, finalBinPath);
+    fs.chmodSync(finalBinPath, 0o755);
+    return finalBinPath;
+  } finally {
+    fs.rmSync(extractDir, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  assetName,
+  mapPlatform,
+  mapArch,
+  binaryName,
+  binaryPath,
+  releaseUrl,
+  version,
+  ensureBinary,
+};

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@muthuishere/routsi",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "OpenAI-compatible dynamic LLM router — a single Go binary, installed via npm as a prebuilt native binary",
   "license": "MIT",
   "bin": {
     "routsi": "npm/launcher.js"
   },
   "files": [
-    "npm",
-    "scripts",
+    "npm/resolve-binary.js",
+    "npm/launcher.js",
+    "scripts/postinstall.js",
     "README.md",
     "LICENSE"
   ],

package/scripts/postinstall.js

@@ -1,251 +1,28 @@
 #!/usr/bin/env node
 'use strict';
 
-// Zero-dependency postinstall: downloads the prebuilt routsi binary for this
-// OS/arch from GitHub Releases and drops it at npm/bin/routsi[.exe].
-//
-// Asset naming scheme (MUST match .github/workflows/release.yml):
-//   routsi_<os>_<arch>.tar.gz   (darwin/linux)
-//   routsi_windows_<arch>.zip  (windows)
-// where <os> in {darwin, linux, windows}, <arch> in {amd64, arm64}.
-// Release URL: https://github.com/muthuishere/routsi/releases/download/v<version>/<asset>
-// Each release also carries a checksums.txt (sha256sum output) covering all assets.
-
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const zlib = require('zlib');
-const crypto = require('crypto');
-const { execFileSync } = require('child_process');
-
-const REPO = 'muthuishere/routsi';
-const PKG_ROOT = path.join(__dirname, '..');
-const BIN_DIR = path.join(PKG_ROOT, 'npm', 'bin');
-
-function pkgVersion() {
-  const pkg = require(path.join(PKG_ROOT, 'package.json'));
-  return pkg.version;
-}
-
-// Pure mapping function — unit-tested by scripts/postinstall.test.js.
-// platform: node's os.platform() value ('darwin'|'linux'|'win32'|...)
-// arch: node's os.arch() value ('x64'|'arm64'|...)
-function mapPlatform(platform) {
-  if (platform === 'darwin') return 'darwin';
-  if (platform === 'linux') return 'linux';
-  if (platform === 'win32') return 'windows';
-  return null;
-}
-
-function mapArch(arch) {
-  if (arch === 'x64') return 'amd64';
-  if (arch === 'arm64') return 'arm64';
-  return null;
-}
-
-function assetName(platform, arch, version) {
-  const os_ = mapPlatform(platform);
-  const arch_ = mapArch(arch);
-  if (!os_ || !arch_) {
-    throw new Error(`unsupported platform/arch: ${platform}/${arch}`);
-  }
-  const ext = os_ === 'windows' ? 'zip' : 'tar.gz';
-  return `routsi_${os_}_${arch_}.${ext}`;
-}
-
-function binaryName(platform) {
-  return mapPlatform(platform) === 'windows' ? 'routsi.exe' : 'routsi';
-}
-
-function releaseUrl(version, asset) {
-  return `https://github.com/${REPO}/releases/download/v${version}/${asset}`;
-}
-
-function isOffline() {
-  if (process.env.npm_config_offline === 'true') return true;
-  if (process.env.npm_config_prefer_offline === 'true' && process.env.ROUTSI_ALLOW_STALE) return true;
-  return false;
-}
-
-function fail(msg) {
-  console.error('\nroutsi postinstall: ' + msg);
-  console.error(
-    `See release assets at https://github.com/${REPO}/releases — you can also\n` +
-    'download the right binary by hand and place it on your PATH.\n'
-  );
-  process.exit(1);
-}
-
-function warnSkip(msg) {
-  console.warn('routsi postinstall: ' + msg + ' — skipping download.');
-  process.exit(0);
-}
-
-// GET with a bounded number of redirect hops. Returns a Buffer via callback.
-function fetchBuffer(url, redirectsLeft, cb) {
-  const req = https.get(url, { headers: { 'User-Agent': 'routsi-npm-postinstall' } }, (res) => {
-    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-      if (redirectsLeft <= 0) {
-        cb(new Error('too many redirects fetching ' + url));
-        return;
-      }
-      res.resume();
-      fetchBuffer(res.headers.location, redirectsLeft - 1, cb);
-      return;
-    }
-    if (res.statusCode !== 200) {
-      res.resume();
-      cb(new Error(`GET ${url} -> HTTP ${res.statusCode}`));
-      return;
-    }
-    const chunks = [];
-    res.on('data', (c) => chunks.push(c));
-    res.on('end', () => cb(null, Buffer.concat(chunks)));
-    res.on('error', cb);
-  });
-  req.on('error', cb);
-}
-
-function fetchBufferAsync(url) {
-  return new Promise((resolve, reject) => {
-    fetchBuffer(url, 5, (err, buf) => (err ? reject(err) : resolve(buf)));
-  });
-}
-
-// Best-effort checksum verification. If checksums.txt can't be fetched (e.g.
-// older release, network hiccup), we proceed without failing the install.
-async function verifyChecksum(version, assetBuf, asset) {
-  let checksumsBuf;
-  try {
-    checksumsBuf = await fetchBufferAsync(releaseUrl(version, 'checksums.txt'));
-  } catch (err) {
-    console.warn('routsi postinstall: could not fetch checksums.txt (' + err.message + '), skipping verification');
-    return;
-  }
-  const text = checksumsBuf.toString('utf8');
-  const line = text.split('\n').find((l) => l.trim().endsWith(asset));
-  if (!line) {
-    console.warn('routsi postinstall: no checksum entry for ' + asset + ', skipping verification');
-    return;
-  }
-  const expected = line.trim().split(/\s+/)[0].toLowerCase();
-  const actual = crypto.createHash('sha256').update(assetBuf).digest('hex');
-  if (expected !== actual) {
-    fail(`checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
-  }
-}
-
-function extractTarGz(buf, destDir) {
-  fs.mkdirSync(destDir, { recursive: true });
-  const tmpTar = path.join(os.tmpdir(), `routsi-${Date.now()}.tar.gz`);
-  fs.writeFileSync(tmpTar, buf);
-  try {
-    execFileSync('tar', ['-xzf', tmpTar, '-C', destDir], { stdio: 'inherit' });
-  } finally {
-    fs.rmSync(tmpTar, { force: true });
-  }
-}
-
-function extractZip(buf, destDir) {
-  fs.mkdirSync(destDir, { recursive: true });
-  const tmpZip = path.join(os.tmpdir(), `routsi-${Date.now()}.zip`);
-  fs.writeFileSync(tmpZip, buf);
-  try {
-    if (process.platform === 'win32') {
-      execFileSync('powershell.exe', [
-        '-NoProfile', '-Command',
-        `Expand-Archive -Force -Path "${tmpZip}" -DestinationPath "${destDir}"`,
-      ], { stdio: 'inherit' });
-    } else {
-      execFileSync('unzip', ['-o', tmpZip, '-d', destDir], { stdio: 'inherit' });
-    }
-  } finally {
-    fs.rmSync(tmpZip, { force: true });
-  }
-}
-
-// Locate the extracted binary — tarball/zip is flat (no top-level dir), but
-// tolerate one either way.
-function findExtractedBinary(destDir, wantName) {
-  const direct = path.join(destDir, wantName);
-  if (fs.existsSync(direct)) return direct;
-  const entries = fs.readdirSync(destDir, { withFileTypes: true });
-  for (const e of entries) {
-    if (e.isDirectory()) {
-      const nested = path.join(destDir, e.name, wantName);
-      if (fs.existsSync(nested)) return nested;
-    }
-  }
-  return null;
-}
-
-async function main() {
-  const platform = process.platform;
-  const arch = process.arch;
-  const version = pkgVersion();
-  const finalBinPath = path.join(BIN_DIR, binaryName(platform));
-
-  if (fs.existsSync(finalBinPath) && fs.statSync(finalBinPath).size > 0) {
-    console.log('routsi postinstall: binary already present at ' + finalBinPath + ', skipping download');
-    return;
-  }
-
-  if (isOffline()) {
-    warnSkip('offline mode requested (npm_config_offline)');
-    return;
-  }
-
-  let asset;
-  try {
-    asset = assetName(platform, arch, version);
-  } catch (err) {
-    fail(
-      `${err.message}. routsi ships prebuilt binaries for darwin/linux/windows on amd64/arm64.\n` +
-      'Build from source instead: https://github.com/' + REPO
+// Best-effort prefetch. This is NOT relied upon to guarantee the binary —
+// npm/launcher.js does that on every `routsi` invocation (see
+// npm/resolve-binary.js). This script only tries to warm the cache at
+// install time so the first `routsi` run doesn't pay the download latency,
+// and it must NEVER fail `npm install` — that would break under
+// `--ignore-scripts`/`allow-scripts` blocking or a flaky network, both of
+// which are fine: the launcher self-heals on first run regardless.
+
+const { ensureBinary } = require('../npm/resolve-binary');
+
+ensureBinary({ quiet: false })
+  .then((binPath) => {
+    console.log('routsi postinstall: binary ready at ' + binPath);
+  })
+  .catch((err) => {
+    console.warn(
+      'routsi postinstall: could not prefetch the native binary (' +
+        (err && err.message ? err.message : String(err)) +
+        ').'
     );
-    return;
-  }
-
-  const url = releaseUrl(version, asset);
-  console.log(`routsi postinstall: downloading ${asset} from ${url}`);
-
-  let assetBuf;
-  try {
-    assetBuf = await fetchBufferAsync(url);
-  } catch (err) {
-    fail(`failed to download ${url}: ${err.message}`);
-    return;
-  }
-
-  await verifyChecksum(version, assetBuf, asset);
-
-  const extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'routsi-extract-'));
-  try {
-    if (asset.endsWith('.zip')) {
-      extractZip(assetBuf, extractDir);
-    } else {
-      extractTarGz(assetBuf, extractDir);
-    }
-
-    const wantName = binaryName(platform);
-    const extracted = findExtractedBinary(extractDir, wantName);
-    if (!extracted) {
-      fail(`downloaded archive ${asset} did not contain expected binary ${wantName}`);
-      return;
-    }
-
-    fs.mkdirSync(BIN_DIR, { recursive: true });
-    fs.copyFileSync(extracted, finalBinPath);
-    fs.chmodSync(finalBinPath, 0o755);
-    console.log('routsi postinstall: installed binary at ' + finalBinPath);
-  } finally {
-    fs.rmSync(extractDir, { recursive: true, force: true });
-  }
-}
-
-if (require.main === module) {
-  main().catch((err) => fail(err && err.message ? err.message : String(err)));
-}
-
-module.exports = { assetName, mapPlatform, mapArch, binaryName, releaseUrl };
+    console.warn('routsi: it will be fetched automatically on first `routsi` run instead.');
+  })
+  .finally(() => {
+    process.exit(0);
+  });

package/scripts/postinstall.test.js

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Tiny assertion check for the pure platform->asset mapping in postinstall.js.
-// Run with: node scripts/postinstall.test.js
-
-const assert = require('assert');
-const { assetName, binaryName, releaseUrl } = require('./postinstall.js');
-
-function eq(actual, expected, label) {
-  assert.strictEqual(actual, expected, `${label}: expected ${expected}, got ${actual}`);
-  console.log(`ok - ${label}`);
-}
-
-eq(assetName('darwin', 'arm64', '0.1.0'), 'routsi_darwin_arm64.tar.gz', 'darwin/arm64 asset name');
-eq(assetName('darwin', 'x64', '0.1.0'), 'routsi_darwin_amd64.tar.gz', 'darwin/amd64 asset name');
-eq(assetName('linux', 'x64', '0.1.0'), 'routsi_linux_amd64.tar.gz', 'linux/amd64 asset name');
-eq(assetName('linux', 'arm64', '0.1.0'), 'routsi_linux_arm64.tar.gz', 'linux/arm64 asset name');
-eq(assetName('win32', 'x64', '0.1.0'), 'routsi_windows_amd64.zip', 'windows/amd64 asset name');
-
-eq(binaryName('darwin'), 'routsi', 'darwin binary name');
-eq(binaryName('win32'), 'routsi.exe', 'windows binary name');
-
-eq(
-  releaseUrl('0.1.0', 'routsi_linux_amd64.tar.gz'),
-  'https://github.com/muthuishere/routsi/releases/download/v0.1.0/routsi_linux_amd64.tar.gz',
-  'release URL construction'
-);
-
-assert.throws(() => assetName('sunos', 'x64', '0.1.0'), /unsupported platform\/arch/, 'unsupported platform throws');
-assert.throws(() => assetName('linux', 'ia32', '0.1.0'), /unsupported platform\/arch/, 'unsupported arch throws');
-
-console.log('\nall postinstall mapping checks passed');