@tokenade/cli 0.8.11 → 0.8.13

package/README.md

@@ -108,7 +108,7 @@ When reporting, please include your OS, `tokenade --version`, your coding agent,
 | Command | What it does |
 |---|---|
 | `install` | Register Tokenade with your detected agent (hooks). Flags: `--only <agent>`, `--with-hook`, `--with-claude-md`, `--with-lsp-enforcement-hook`, `--with-brevity-skill`, `--dry-run`. |
-| `uninstall [aliases]` | Remove the integration. `uninstall aliases` removes only the shell proxy. `--dry-run` to preview. |
+| `uninstall` | Remove the integration (restores wrapped MCP servers). `--dry-run` to preview. |
 | `login` | Activate via browser device-flow — no key to type. |
 | `activate <key>` | Link this machine to a tokenade.net license (free or paid) with a key. |
 | `upgrade` | Self-update in place (aliases: `self-update`). `--on`/`--off` toggles the 24h background updater. |
@@ -266,7 +266,7 @@ $ tokenade incompatibilities
 [redundant] rtk
   Output-filtering CLI proxy (filters/compresses bash output)
   → binary at ~/.cargo/bin/rtk
-  fix: Tokenade subsumes rtk: `tokenade proxy <cmd>` does the same AND
+  fix: Tokenade subsumes rtk: `tokenade wrap '<cmd>'` does the same AND
        auto-detects 48 formats — usually with better savings.
 
 Run `tokenade install` to interactively migrate & fix the [redundant] /

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,21 +1,32 @@
 {
   "name": "@tokenade/cli",
-  "version": "0.8.11",
-  "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": {
     "tokenade": "bin/tokenade.js"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node install.js",
+    "preuninstall": "node uninstall.js"
   },
   "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"
   ],
   "engines": {

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,
+};

package/uninstall.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * preuninstall — run tokenade's own cleanup BEFORE npm deletes the package
+ * files, so that `npm uninstall -g @tokenade/cli` actually restores the
+ * machine (unwraps MCPs, strips hooks/CLAUDE.md/shell-proxy, and wipes
+ * ~/.tokenade + ~/.cache/tokenade) instead of orphaning integration that then
+ * spawns a missing binary on every tool call.
+ *
+ * We locate the SAME vendored binary that install.js (postinstall) dropped in
+ * ./vendor and invoke it as `tokenade uninstall --headless`:
+ *   --headless → no banner, no next-step guidance, and it does NOT touch the
+ *                binary itself (npm removes ./vendor right after this script).
+ *
+ * FAIL-OPEN by construction: every failure path (missing binary, spawn error,
+ * timeout, non-zero exit) is swallowed and we ALWAYS `process.exit(0)`. A
+ * cleanup that can't run must never block `npm uninstall` or leave the user
+ * unable to remove the package.
+ *
+ * npm lifecycle note: `preuninstall` runs on `npm uninstall` / `npm rm` /
+ * `npm remove` (local AND `-g`), and fires while the package files still
+ * exist. Caveats we accept: it is skipped when the user passes
+ * `--ignore-scripts` (or sets that config), and yarn/pnpm do not guarantee it.
+ * In those cases the binary is simply gone and its self-heal / a future
+ * `tokenade uninstall` covers the leftover integration.
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+// Bound the child so a wedged cleanup can never hang `npm uninstall`.
+const CLEANUP_TIMEOUT_MS =
+	Number(process.env.TOKENADE_UNINSTALL_TIMEOUT_MS) || 20000;
+
+function binaryPath() {
+	const name = process.platform === "win32" ? "tokenade.exe" : "tokenade";
+	return path.join(__dirname, "vendor", name);
+}
+
+function main() {
+	const bin = binaryPath();
+	// Missing binary (never installed, --ignore-scripts, half-install) → nothing
+	// to run; npm still removes the package. Not an error.
+	if (!fs.existsSync(bin)) {
+		return;
+	}
+	try {
+		const res = spawnSync(bin, ["uninstall", "--headless"], {
+			stdio: "inherit",
+			timeout: CLEANUP_TIMEOUT_MS,
+			// A cleanup crash must not surface as a throw here.
+			windowsHide: true,
+		});
+		if (res.error) {
+			console.error(
+				`  tokenade cleanup skipped (${res.error.message}); ` +
+					"run `tokenade uninstall` manually if any integration lingers.",
+			);
+		}
+	} catch (e) {
+		console.error(`  tokenade cleanup skipped (${e && e.message});`);
+	}
+}
+
+try {
+	main();
+} catch (e) {
+	// Absolute backstop — nothing above should throw, but never let it matter.
+	try {
+		console.error(`  tokenade cleanup skipped (${e && e.message});`);
+	} catch {}
+}
+// ALWAYS succeed: npm must be free to remove the package.
+process.exit(0);