@tokenade/cli 0.8.12 → 0.8.13

package/bin/tokenade.js

@@ -3,16 +3,35 @@
 const { spawnSync } = require("node:child_process");
 const path = require("node:path");
 const fs = require("node:fs");
+const { platformPackageName, binaryName } = require("../platform.js");
 
-const bin = path.join(
-	__dirname,
-	"..",
-	"vendor",
-	process.platform === "win32" ? "tokenade.exe" : "tokenade",
-);
-if (!fs.existsSync(bin)) {
+// Resolve the binary, first hit wins (see platform.js for the two delivery
+// paths): (1) the matching per-platform optionalDependency from the registry,
+// (2) ./vendor, where install.js's download fallback drops it.
+function resolveBinary() {
+	const name = binaryName();
+	// 1. Platform sub-package. A skipped optional dep throws MODULE_NOT_FOUND;
+	//    resolve its package.json so we don't depend on a "main" entry.
+	try {
+		const pkgJson = require.resolve(`${platformPackageName()}/package.json`);
+		const bin = path.join(path.dirname(pkgJson), name);
+		if (fs.existsSync(bin)) return bin;
+	} catch {
+		// optional dep absent — fall through to the vendored copy.
+	}
+	// 2. Downloaded fallback.
+	const vendored = path.join(__dirname, "..", "vendor", name);
+	if (fs.existsSync(vendored)) return vendored;
+	return null;
+}
+
+const bin = resolveBinary();
+if (!bin) {
 	console.error(
-		"tokenade: binary not found. Re-run `npm install -g @tokenade/cli` (the postinstall downloads it).",
+		"tokenade: binary not found. Re-run `npm install -g @tokenade/cli` " +
+			"(the platform binary ships as an optional dependency; a postinstall " +
+			"download is the fallback). If you installed with --no-optional or " +
+			"--ignore-scripts, reinstall without them.",
 	);
 	process.exit(1);
 }

package/install.js

@@ -27,6 +27,11 @@ const http = require("node:http");
 const https = require("node:https");
 const crypto = require("node:crypto");
 const { URL } = require("node:url");
+const {
+	rustTarget,
+	platformPackageName,
+	binaryName,
+} = require("./platform.js");
 
 const DOWNLOADS_BASE =
 	process.env.TOKENADE_DOWNLOADS_BASE || "https://downloads.tokenade.net";
@@ -38,52 +43,6 @@ const VENDOR = path.join(__dirname, "vendor");
 const REQUEST_TIMEOUT_MS = Number(process.env.TOKENADE_HTTP_TIMEOUT_MS) || 30000;
 const MAX_ATTEMPTS = 4;
 
-// Is this Linux userland musl (Alpine, Void-musl, …) rather than glibc?
-// A glibc node reports its runtime glibc version in the process report header;
-// a musl node does not. We fall back to looking for the musl loader on disk.
-// When genuinely unsure we return false (glibc) — that preserves the historical
-// x86_64-gnu mapping for the overwhelming glibc majority, so a detection miss is
-// never worse than the status quo.
-function isMuslLinux() {
-	if (process.platform !== "linux") return false;
-	try {
-		const header = process.report && process.report.getReport().header;
-		if (header && typeof header.glibcVersionRuntime === "string") return false;
-		if (header && "glibcVersionRuntime" in header) {
-			// key present but not a string ⇒ no glibc runtime ⇒ musl
-			return true;
-		}
-	} catch {
-		// fall through to the on-disk probe
-	}
-	try {
-		return fs
-			.readdirSync("/lib")
-			.some((f) => f.startsWith("ld-musl-"));
-	} catch {
-		return false;
-	}
-}
-
-function rustTarget() {
-	const p = process.platform;
-	const a = process.arch;
-	if (p === "darwin")
-		return a === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
-	if (p === "linux") {
-		if (a === "arm64") return "aarch64-unknown-linux-musl";
-		// x86_64: a fully-static musl build runs on glibc too, but musl's DNS
-		// resolver ignores /etc/nsswitch.conf — so we only hand musl to machines
-		// whose libc is already musl (Alpine et al.), and keep the proven glibc
-		// build as the default everywhere else.
-		return isMuslLinux()
-			? "x86_64-unknown-linux-musl"
-			: "x86_64-unknown-linux-gnu";
-	}
-	if (p === "win32") return "x86_64-pc-windows-gnu";
-	throw new Error(`unsupported platform: ${p}/${a}`);
-}
-
 // Resolve the proxy that applies to `targetUrl`, honouring the standard
 // HTTPS_PROXY / HTTP_PROXY / ALL_PROXY and NO_PROXY env vars (both cases).
 // Returns null when no proxy applies — including when NO_PROXY matches.
@@ -260,6 +219,28 @@ async function downloadTo(url, dest) {
 
 async function main() {
 	const target = rustTarget();
+
+	// Fast path: the binary is already here, so the download is pure waste.
+	// It arrives one of two ways — the matching per-platform optionalDependency
+	// npm just installed from the registry, or a ./vendor copy from a previous
+	// run. Either way postinstall is a clean no-op. Crucially this returns
+	// BEFORE any network call, so an unreachable downloads.tokenade.net (blocked
+	// corporate proxy, offline sandbox) can never fail an install whose binary
+	// the registry already delivered.
+	try {
+		require.resolve(`${platformPackageName(target)}/package.json`);
+		console.log(
+			`✓ tokenade provided by ${platformPackageName(target)} (${target}) — no download needed.`,
+		);
+		return;
+	} catch {
+		// optional dep absent (skipped or no registry build) — try ./vendor.
+	}
+	if (fs.existsSync(path.join(VENDOR, binaryName()))) {
+		console.log(`✓ tokenade already vendored (${target}) — no download needed.`);
+		return;
+	}
+
 	const manifest = await fetchJson(MANIFEST_URL);
 	const entry = manifest.targets && manifest.targets[target];
 	if (!entry || !entry.url || !entry.sha256) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tokenade/cli",
-  "version": "0.8.12",
-  "description": "Tokenade \u2014 cut your AI coding agent's token bill. Installs the Tokenade CLI (a local, paid token-reduction tool; activate via your browser).",
+  "version": "0.8.13",
+  "description": "Tokenade — cut your AI coding agent's token bill. Installs the Tokenade CLI (a local, paid token-reduction tool; activate via your browser).",
   "homepage": "https://tokenade.net",
   "license": "UNLICENSED",
   "bin": {
@@ -14,8 +14,17 @@
   "dependencies": {
     "tar": "^7.5.16"
   },
+  "optionalDependencies": {
+    "@tokenade/cli-linux-x64": "0.8.13",
+    "@tokenade/cli-linux-x64-musl": "0.8.13",
+    "@tokenade/cli-linux-arm64-musl": "0.8.13",
+    "@tokenade/cli-darwin-arm64": "0.8.13",
+    "@tokenade/cli-darwin-x64": "0.8.13",
+    "@tokenade/cli-win32-x64": "0.8.13"
+  },
   "files": [
     "bin/",
+    "platform.js",
     "install.js",
     "uninstall.js",
     "README.md"

package/platform.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * platform.js — the ONE place that maps this machine to a Rust target and to
+ * the matching per-platform npm package. Both bin/tokenade.js (runtime resolve)
+ * and install.js (download fallback) require it, so the platform detection —
+ * the musl probe especially — never drifts between the two.
+ *
+ * The per-platform packages (@tokenade/cli-<os>-<cpu>[-musl]) carry the actual
+ * binary and are listed as optionalDependencies of @tokenade/cli. npm installs
+ * ONLY the one whose os/cpu/libc match the host, straight from the registry —
+ * the esbuild/swc/biome pattern. install.js's download is a fallback for when
+ * those optional deps were skipped (--no-optional / --ignore-scripts) or the
+ * registry didn't carry a matching build.
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+
+// Is this Linux userland musl (Alpine, Void-musl, …) rather than glibc?
+// A glibc node reports its runtime glibc version in the process report header;
+// a musl node does not. We fall back to looking for the musl loader on disk.
+// When genuinely unsure we return false (glibc) — that preserves the historical
+// x86_64-gnu mapping for the overwhelming glibc majority, so a detection miss is
+// never worse than the status quo.
+function isMuslLinux() {
+	if (process.platform !== "linux") return false;
+	try {
+		const header = process.report && process.report.getReport().header;
+		if (header && typeof header.glibcVersionRuntime === "string") return false;
+		if (header && "glibcVersionRuntime" in header) {
+			// key present but not a string ⇒ no glibc runtime ⇒ musl
+			return true;
+		}
+	} catch {
+		// fall through to the on-disk probe
+	}
+	try {
+		return fs
+			.readdirSync("/lib")
+			.some((f) => f.startsWith("ld-musl-"));
+	} catch {
+		return false;
+	}
+}
+
+function rustTarget() {
+	const p = process.platform;
+	const a = process.arch;
+	if (p === "darwin")
+		return a === "arm64" ? "aarch64-apple-darwin" : "x86_64-apple-darwin";
+	if (p === "linux") {
+		if (a === "arm64") return "aarch64-unknown-linux-musl";
+		// x86_64: a fully-static musl build runs on glibc too, but musl's DNS
+		// resolver ignores /etc/nsswitch.conf — so we only hand musl to machines
+		// whose libc is already musl (Alpine et al.), and keep the proven glibc
+		// build as the default everywhere else.
+		return isMuslLinux()
+			? "x86_64-unknown-linux-musl"
+			: "x86_64-unknown-linux-gnu";
+	}
+	if (p === "win32") return "x86_64-pc-windows-gnu";
+	throw new Error(`unsupported platform: ${p}/${a}`);
+}
+
+// Rust target dir (in dist/) → the npm sub-package that carries its binary.
+// Kept in lockstep with the six packages the release script publishes and the
+// optionalDependencies in package.json — one source of truth for the mapping.
+const PACKAGE_BY_TARGET = {
+	"x86_64-unknown-linux-gnu": "@tokenade/cli-linux-x64",
+	"x86_64-unknown-linux-musl": "@tokenade/cli-linux-x64-musl",
+	"aarch64-unknown-linux-musl": "@tokenade/cli-linux-arm64-musl",
+	"aarch64-apple-darwin": "@tokenade/cli-darwin-arm64",
+	"x86_64-apple-darwin": "@tokenade/cli-darwin-x64",
+	"x86_64-pc-windows-gnu": "@tokenade/cli-win32-x64",
+};
+
+// The per-platform sub-package name for the current host, or the given target.
+function platformPackageName(target) {
+	const t = target || rustTarget();
+	const pkg = PACKAGE_BY_TARGET[t];
+	if (!pkg) throw new Error(`no npm package mapped for target: ${t}`);
+	return pkg;
+}
+
+// The binary filename inside a sub-package (and in ./vendor).
+function binaryName() {
+	return process.platform === "win32" ? "tokenade.exe" : "tokenade";
+}
+
+module.exports = {
+	isMuslLinux,
+	rustTarget,
+	platformPackageName,
+	binaryName,
+	PACKAGE_BY_TARGET,
+};