auto-model-router 0.10.0 → 0.11.0

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.10.0",
+    "version": "0.11.0",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.10.0",
+      "version": "0.11.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1340,6 +1340,21 @@ sends the name itself, which the router does not accept as a scope (a scope is a
 lowercase slug) and falls back to its default. `--scope <slug>` pins one project for the
 whole machine instead; a refresh keeps a pin, and `connect --scope ""` removes it.
 
+### One file to install
+
+A remote that serves members can hand them this package as a single executable: the CLI
+compiled by `bun build --compile` for their operating system (`buildExecutable` in the
+library, one of `linux-x64`, `linux-arm64`, `darwin-x64`, `darwin-arm64`,
+`windows-x64`), with the package's own source files embedded. Nothing else is installed —
+no bun, no npm. omp still loads the extensions from disk and Hermes still copies its
+plugin, so the first `connect` from the executable writes the embedded files out under
+`<router home>/package/<version>/` and points every harness there; the executable itself
+becomes Claude Code's key helper and, with `--profile`, goes on PATH. `connect
+--setup-token <token>` trades a one-time onboarding token at the remote's
+`/setup/exchange` for the credential, so the install command carries no key at all.
+`remote.json` records the executable, and a refresh from inside omp keeps the helper
+pointed at it.
+
 ## Multiple coding harnesses, one router
 
 **One router process for everything.** omp's embed extension binds a private

package/omp-extension/remote-logic.ts

@@ -36,6 +36,12 @@ export interface RemoteRouter {
 	refreshExpiresAtMs?: number;
 	/** What the remote calls this machine. */
 	device?: string;
+	/**
+	 * The compiled executable that ran `connect`, when one did. A refresh from
+	 * inside omp re-writes every harness config and must point Claude Code's key
+	 * helper at it, not at a `bun run` of the extracted source.
+	 */
+	executable?: string;
 }
 
 export function remoteFilePath(routerHome: string): string {
@@ -59,6 +65,7 @@ export function parseRemoteRouter(text: string): RemoteRouter | null {
 			...(typeof raw.keyExpiresAtMs === "number" ? { keyExpiresAtMs: raw.keyExpiresAtMs } : {}),
 			...(typeof raw.refreshExpiresAtMs === "number" ? { refreshExpiresAtMs: raw.refreshExpiresAtMs } : {}),
 			...(typeof raw.device === "string" && raw.device !== "" ? { device: raw.device } : {}),
+			...(typeof raw.executable === "string" && raw.executable !== "" ? { executable: raw.executable } : {}),
 		};
 	} catch {
 		return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/build-executable.ts

@@ -0,0 +1,142 @@
+/**
+ * Builds the single-file member install: this package compiled by
+ * `bun build --compile` for one operating system, with the package's own source
+ * files embedded so `connect` can write out what omp and Hermes load from disk
+ * (see `embedded.ts`). A team server calls this once per router version and
+ * target and serves the result; nothing here runs on a member's machine.
+ *
+ * Cross-compiling needs bun's runtime for the target, which bun downloads on
+ * first use and caches; a host without network access to bun's releases can
+ * only build its own platform.
+ */
+
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { EMBEDDED_GLOBAL, type EmbeddedPackage } from "./embedded.ts";
+
+export const EXECUTABLE_TARGETS = ["linux-x64", "linux-arm64", "darwin-x64", "darwin-arm64", "windows-x64"] as const;
+export type ExecutableTarget = (typeof EXECUTABLE_TARGETS)[number];
+
+export function isExecutableTarget(value: string): value is ExecutableTarget {
+	return (EXECUTABLE_TARGETS as readonly string[]).includes(value);
+}
+
+/** The target of the machine this process runs on, or null when bun has no build for it. */
+export function hostTarget(platform = process.platform, arch = process.arch): ExecutableTarget | null {
+	const cpu = arch === "x64" ? "x64" : arch === "arm64" ? "arm64" : null;
+	if (cpu === null) return null;
+	if (platform === "linux") return `linux-${cpu}`;
+	if (platform === "darwin") return `darwin-${cpu}`;
+	if (platform === "win32" && cpu === "x64") return "windows-x64";
+	return null;
+}
+
+/** The file name a build for `target` is served under. */
+export function executableFileName(target: ExecutableTarget): string {
+	return `auto-model-router-${target}${target.startsWith("windows") ? ".exe" : ""}`;
+}
+
+/** The package entries the install needs: the CLI, the harness integrations, and the two runtime deps. */
+const PACKAGE_ENTRIES = ["package.json", "README.md", "src", "omp-extension", "hermes-plugin", "opencode-plugin"] as const;
+const RUNTIME_DEPS = ["yaml", "zod"] as const;
+
+function walk(root: string, rel: string, keep: (rel: string) => boolean, out: Record<string, string>): void {
+	const abs = join(root, ...rel.split("/").filter((s) => s !== ""));
+	const st = statSync(abs);
+	if (st.isDirectory()) {
+		for (const name of readdirSync(abs)) walk(root, rel === "" ? name : `${rel}/${name}`, keep, out);
+		return;
+	}
+	if (!keep(rel)) return;
+	// Everything the filters let through is text (ts, py, yaml, js, json, md). No byte-level
+	// sniffing: src/util/hash.ts holds a NUL inside a string literal and was silently dropped
+	// by one, which broke the extension on a member machine and nowhere else.
+	out[rel] = readFileSync(abs, "utf8");
+}
+
+const keepPackageFile = (rel: string): boolean => !rel.includes("__pycache__") && !rel.endsWith(".pyc") && !rel.endsWith(".test.ts");
+const keepDepFile = (rel: string): boolean => !/(^|\/)(tests?|__tests__)\//.test(rel) && !/\.(d\.[cm]?ts|map)$/.test(rel) && !/\.test\.[cm]?[jt]sx?$/.test(rel);
+
+/**
+ * Every file the executable embeds, keyed by path relative to the package
+ * root. The runtime dependencies are resolved from the package's own location,
+ * so a `bun link`ed package finds them too.
+ */
+export function collectPackageFiles(packageDir: string): EmbeddedPackage {
+	const files: Record<string, string> = {};
+	for (const entry of PACKAGE_ENTRIES) {
+		if (existsSync(join(packageDir, entry))) walk(packageDir, entry, keepPackageFile, files);
+	}
+	for (const dep of RUNTIME_DEPS) {
+		let depDir: string;
+		try {
+			depDir = dirname(Bun.resolveSync(`${dep}/package.json`, packageDir));
+		} catch {
+			continue;
+		}
+		const depFiles: Record<string, string> = {};
+		walk(depDir, "", keepDepFile, depFiles);
+		for (const [rel, content] of Object.entries(depFiles)) files[`node_modules/${dep}/${rel}`] = content;
+	}
+	const version = (JSON.parse(files["package.json"] ?? "{}") as { version?: string }).version ?? "0.0.0";
+	return { version, files };
+}
+
+export interface BuildExecutableOptions {
+	packageDir: string;
+	target: ExecutableTarget;
+	/** Where the executable goes; created or replaced. */
+	outFile: string;
+	/** The bun binary to build with; this process's own when it is bun. */
+	bun?: string;
+	/** A directory for the manifest and entry module; a temp dir when absent, removed afterwards. */
+	stageDir?: string;
+}
+
+export type BuildExecutableResult = { ok: true; path: string; bytes: number } | { ok: false; reason: string };
+
+function bunBinary(explicit: string | undefined): string | null {
+	if (explicit !== undefined) return explicit;
+	if (/(^|[\\/])bun(\.exe)?$/i.test(process.execPath)) return process.execPath;
+	return Bun.which("bun");
+}
+
+/**
+ * Compiles the package at `packageDir` into `outFile` for `target`. The entry
+ * module sets the global `embedded.ts` reads and then loads the CLI, so the CLI
+ * itself never knows at build time whether it will be compiled.
+ */
+export async function buildExecutable(opts: BuildExecutableOptions): Promise<BuildExecutableResult> {
+	const bun = bunBinary(opts.bun);
+	if (bun === null) return { ok: false, reason: "bun is not available to build with" };
+	const stage = opts.stageDir ?? mkdtempSync(join(tmpdir(), "amr-exe-"));
+	mkdirSync(stage, { recursive: true });
+	try {
+		const pkg = collectPackageFiles(opts.packageDir);
+		if (pkg.files["src/index.ts"] === undefined) return { ok: false, reason: `${opts.packageDir} does not hold the router package (no src/index.ts)` };
+		writeFileSync(join(stage, "manifest.json"), JSON.stringify(pkg), "utf8");
+		const entry = join(opts.packageDir, "src", "index.ts").replaceAll("\\", "/");
+		writeFileSync(
+			join(stage, "entry.ts"),
+			[
+				`import manifest from "./manifest.json" with { type: "file" };`,
+				`(globalThis as Record<string, unknown>)[${JSON.stringify(EMBEDDED_GLOBAL)}] = { manifestPath: manifest };`,
+				`await import(${JSON.stringify(entry)});`,
+				"",
+			].join("\n"),
+			"utf8",
+		);
+		mkdirSync(dirname(opts.outFile), { recursive: true });
+		const proc = Bun.spawn([bun, "build", "--compile", `--target=bun-${opts.target}`, join(stage, "entry.ts"), "--outfile", opts.outFile], { stdout: "pipe", stderr: "pipe", cwd: opts.packageDir });
+		const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+		if (exitCode !== 0 || !existsSync(opts.outFile)) {
+			const tail = `${stderr}\n${stdout}`.trim().split("\n").slice(-6).join("\n");
+			return { ok: false, reason: `bun build --compile for ${opts.target} failed (exit ${exitCode}): ${tail}` };
+		}
+		return { ok: true, path: opts.outFile, bytes: statSync(opts.outFile).size };
+	} finally {
+		if (opts.stageDir === undefined) rmSync(stage, { recursive: true, force: true });
+	}
+}
+

package/src/cli/connect.ts

@@ -25,11 +25,12 @@
  */
 
 import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { refreshAccountOf, remoteFilePath } from "../../omp-extension/remote-logic.ts";
 import { SCOPE_ENV } from "../context/scope.ts";
+import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
 import { pickStore, saveRefreshToken, type StoreDeps, type StoreKind } from "./credential-store.ts";
 import { flagString, type CliArgs } from "./args.ts";
 
@@ -58,6 +59,12 @@ export interface ConnectOptions {
 	keyExpiresAtMs?: number;
 	refreshExpiresAtMs?: number;
 	device?: string;
+	/**
+	 * The compiled executable running this, when one is (see embedded.ts). It
+	 * becomes Claude Code's key helper and goes on PATH with --profile, and
+	 * remote.json records it so a refresh from omp keeps pointing at it.
+	 */
+	exePath?: string;
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -257,6 +264,7 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 				...(o.keyExpiresAtMs !== undefined ? { keyExpiresAtMs: o.keyExpiresAtMs } : {}),
 				...(o.refreshExpiresAtMs !== undefined ? { refreshExpiresAtMs: o.refreshExpiresAtMs } : {}),
 				...(o.device !== undefined && o.device !== "" ? { device: o.device } : {}),
+				...(o.exePath !== undefined && o.exePath !== "" ? { executable: o.exePath } : {}),
 			},
 			null,
 			2,
@@ -339,8 +347,9 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		const env: Record<string, unknown> = { ...((settings.env as Record<string, unknown> | undefined) ?? {}), ANTHROPIC_BASE_URL: o.url };
 		// Never leave a stale key beside the helper: the helper is the source now.
 		delete env.ANTHROPIC_API_KEY;
-		const entry = resolve(o.packageDir, "src", "index.ts").replaceAll("\\", "/");
-		const next = { ...settings, env, apiKeyHelper: `bun run "${entry}" token` };
+		// The executable is its own helper; under bun the source entry is.
+		const helper = o.exePath !== undefined && o.exePath !== "" ? `"${o.exePath.replaceAll("\\", "/")}" token` : `bun run "${resolve(o.packageDir, "src", "index.ts").replaceAll("\\", "/")}" token`;
+		const next = { ...settings, env, apiKeyHelper: helper };
 		const after = `${JSON.stringify(next, null, 2)}\n`;
 		if (after !== before) {
 			if (before !== "" && !o.dryRun) writeFileSync(`${settingsPath}.${new Date().toISOString().replaceAll(":", "-")}.bak`, before, "utf8");
@@ -358,11 +367,14 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 				const [k, ...v] = line.split("=");
 				Bun.spawnSync(["setx", k!, v.join("=")], { stdout: "ignore", stderr: "ignore" });
 			}
+			// Not setx for PATH: it truncates at 1024 characters and would eat the rest.
+			if (o.exePath !== undefined && o.exePath !== "") addToUserPathWindows(dirname(o.exePath));
 			report.notes.push("user environment variables set with setx; open a new terminal");
 		} else {
 			const shell = o.env.SHELL ?? "";
 			const rc = shell.includes("zsh") ? join(o.home, ".zshrc") : join(o.home, ".bashrc");
-			const block = `\n# auto-model-router remote (added by \`auto-model-router connect\`)\n${report.envLines.map((l) => `export ${l}`).join("\n")}\n`;
+			const pathLine = o.exePath !== undefined && o.exePath !== "" ? [`export PATH="${dirname(o.exePath)}:$PATH"`] : [];
+			const block = `\n# auto-model-router remote (added by \`auto-model-router connect\`)\n${[...report.envLines.map((l) => `export ${l}`), ...pathLine].join("\n")}\n`;
 			const before = existsSync(rc) ? readFileSync(rc, "utf8") : "";
 			if (!before.includes("# auto-model-router remote") && !before.includes("# auto-model-router team")) appendFileSync(rc, block, "utf8");
 			else write(rc, before.replace(/\n# auto-model-router (?:remote|team)[^\n]*\n(?:export [^\n]*\n)*/, block));
@@ -374,16 +386,84 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 	return report;
 }
 
+/** What a team's one-time setup token is traded for. */
+export interface IssuedCredential {
+	key: string;
+	refreshToken: string;
+	keyExpiresAtMs?: number;
+	refreshExpiresAtMs?: number;
+	userId: string;
+	name: string;
+}
+
+/**
+ * Trades a one-time setup token for this machine's credential at the team's
+ * exchange route, so the install needs nothing on the machine but this
+ * program: the token is the only secret in the install command and dies on use.
+ */
+export async function exchangeSetupToken(url: string, token: string, device: string, fetchImpl: typeof fetch = fetch): Promise<IssuedCredential> {
+	const res = await fetchImpl(`${url}/setup/exchange`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ token, device }), signal: AbortSignal.timeout(15_000) });
+	if (res.status === 401) throw new Error("the setup token was refused (expired or already used); get a new one from the team's portal");
+	if (!res.ok) throw new Error(`the team's setup exchange answered ${res.status}`);
+	const body = (await res.json()) as Record<string, unknown>;
+	if (typeof body.key !== "string" || body.key === "") throw new Error("the team's setup exchange returned no key");
+	return {
+		key: body.key,
+		refreshToken: typeof body.refreshToken === "string" ? body.refreshToken : "",
+		...(typeof body.keyExpiresAtMs === "number" ? { keyExpiresAtMs: body.keyExpiresAtMs } : {}),
+		...(typeof body.refreshExpiresAtMs === "number" ? { refreshExpiresAtMs: body.refreshExpiresAtMs } : {}),
+		userId: typeof body.userId === "string" ? body.userId : "",
+		name: typeof body.name === "string" ? body.name : "",
+	};
+}
+
+/** Adds `dir` to the user's PATH on Windows, once, through the registry-backed API rather than setx. */
+function addToUserPathWindows(dir: string): void {
+	const quoted = `'${dir.replaceAll("'", "''")}'`;
+	const script = `$d=${quoted}; $p=[Environment]::GetEnvironmentVariable('Path','User'); if ($null -eq $p) { $p='' }; if (($p -split ';') -notcontains $d) { [Environment]::SetEnvironmentVariable('Path', (($p.TrimEnd(';') + ';' + $d).TrimStart(';')), 'User') }`;
+	Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", script], { stdout: "ignore", stderr: "ignore" });
+}
+
+/**
+ * Where the harness integrations are read from. Under bun that is this
+ * package; in the compiled executable it is the copy written out from the
+ * executable's own embedded files.
+ */
+async function resolvePackageDir(): Promise<string> {
+	const embedded = await readEmbeddedPackage();
+	if (embedded === null) return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+	const raw = process.env.AUTO_MODEL_ROUTER_HOME ?? join(homedir(), ".auto-model-router");
+	return materializePackage(expand(raw, homedir()), embedded);
+}
+
 export async function connectCommand(args: CliArgs): Promise<void> {
 	const url = (flagString(args, "url") ?? process.env.AUTO_MODEL_ROUTER_URL ?? "").replace(/\/+$/, "");
-	const key = flagString(args, "key") ?? process.env.AUTO_MODEL_ROUTER_API_KEY ?? "";
-	if (url === "" || key === "") throw new Error("connect needs --url <remote router> and --key <its key>");
+	let key = flagString(args, "key") ?? process.env.AUTO_MODEL_ROUTER_API_KEY ?? "";
+	const setupToken = flagString(args, "setup-token") ?? "";
+	if (url === "" || (key === "" && setupToken === "")) throw new Error("connect needs --url <remote router> and either --key <its key> or --setup-token <one-time token from the team>");
 	const only = (flagString(args, "harness") ?? "").split(",").map((s) => s.trim().toLowerCase()).filter((s) => s !== "");
 	const pathHas = (bin: string): boolean => Bun.which(bin) !== null;
-	const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
-	// Verify the key against the route every router serves before touching anything.
+	const packageDir = await resolvePackageDir();
+	const exePath = executablePath();
 	let name = flagString(args, "name") ?? "";
 	let userId = flagString(args, "user-id") ?? "";
+	let device = flagString(args, "device") ?? "";
+	// A remote that issues short-lived keys hands these over beside the key.
+	let refreshToken = flagString(args, "refresh-token") ?? "";
+	let keyExpires = Number.parseInt(flagString(args, "key-expires") ?? "", 10);
+	let refreshExpires = Number.parseInt(flagString(args, "refresh-expires") ?? "", 10);
+	if (setupToken !== "") {
+		if (device === "") device = hostname();
+		const issued = await exchangeSetupToken(url, setupToken, device);
+		key = issued.key;
+		refreshToken = issued.refreshToken;
+		keyExpires = issued.keyExpiresAtMs ?? Number.NaN;
+		refreshExpires = issued.refreshExpiresAtMs ?? Number.NaN;
+		if (issued.userId !== "") userId = issued.userId;
+		if (issued.name !== "") name = issued.name;
+		console.log(`credential issued for ${name === "" ? userId : name} (device ${device})`);
+	}
+	// Verify the key against the route every router serves before touching anything.
 	try {
 		const res = await fetch(`${url}/v1/models`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(10_000) });
 		if (res.status === 401) throw new Error("the remote router rejected this key");
@@ -396,11 +476,6 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	// A single-project machine can label every request; a machine with several
 	// repos should leave it off and let the extensions send the workspace's own.
 	const scopeFlag = flagString(args, "scope");
-	// A remote that issues short-lived keys hands these over beside the key.
-	const refreshToken = flagString(args, "refresh-token") ?? "";
-	const keyExpires = Number.parseInt(flagString(args, "key-expires") ?? "", 10);
-	const refreshExpires = Number.parseInt(flagString(args, "refresh-expires") ?? "", 10);
-	const device = flagString(args, "device") ?? "";
 	const report = connectRemote({
 		url,
 		key,
@@ -419,7 +494,9 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 		...(Number.isFinite(keyExpires) ? { keyExpiresAtMs: keyExpires } : {}),
 		...(Number.isFinite(refreshExpires) ? { refreshExpiresAtMs: refreshExpires } : {}),
 		...(device === "" ? {} : { device }),
+		...(exePath === null ? {} : { exePath }),
 	});
+	if (exePath !== null) console.log(`executable ${exePath}; package files under ${packageDir}`);
 	console.log(`${args.flags.has("dry-run") ? "would write" : "wrote"} ${report.remoteFile}${name === "" ? "" : ` for ${name}`}`);
 	for (const c of report.configured) console.log(`  configured ${c}`);
 	for (const s of report.skipped) console.log(`  skipped    ${s}`);

package/src/cli/embedded.ts

@@ -0,0 +1,78 @@
+/**
+ * The router package carried inside a compiled executable.
+ *
+ * `bun build --compile` turns this CLI into one file per operating system, and
+ * that is what a team member downloads: no bun, no npm, nothing else. But the
+ * harness integrations are not the CLI — omp loads `omp-extension/*.ts` with
+ * its own runtime and Hermes copies `hermes-plugin/` — so the executable also
+ * carries the package's source files and writes them out under the router home
+ * the first time `connect` runs. The build side (`build-executable.ts`) puts a
+ * JSON manifest of those files into the executable and sets a global that names
+ * it; this side reads it.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface EmbeddedPackage {
+	/** The router package's version, which also names the extracted directory. */
+	version: string;
+	/** Relative path (forward slashes) → file content. Text only: the package has no binaries. */
+	files: Record<string, string>;
+}
+
+/** What the build's entry module sets before the CLI loads. */
+export interface EmbeddedHandle {
+	/** Path of the manifest inside the executable's embedded filesystem. */
+	manifestPath: string;
+}
+
+export const EMBEDDED_GLOBAL = "AUTO_MODEL_ROUTER_EMBEDDED";
+
+export function embeddedHandle(): EmbeddedHandle | null {
+	const h = (globalThis as Record<string, unknown>)[EMBEDDED_GLOBAL];
+	return typeof h === "object" && h !== null && typeof (h as EmbeddedHandle).manifestPath === "string" ? (h as EmbeddedHandle) : null;
+}
+
+/** True when this process is the compiled executable rather than `bun run src/index.ts`. */
+export function isCompiled(): boolean {
+	return embeddedHandle() !== null;
+}
+
+/** The executable's own path when compiled, for key helpers and PATH; null under bun. */
+export function executablePath(): string | null {
+	return isCompiled() ? process.execPath : null;
+}
+
+export async function readEmbeddedPackage(): Promise<EmbeddedPackage | null> {
+	const h = embeddedHandle();
+	if (h === null) return null;
+	const parsed = JSON.parse(await Bun.file(h.manifestPath).text()) as EmbeddedPackage;
+	return typeof parsed.version === "string" && typeof parsed.files === "object" && parsed.files !== null ? parsed : null;
+}
+
+const MARKER = ".materialized";
+
+/**
+ * Writes the embedded package under `<routerHome>/package/<version>/` and
+ * returns that directory, the `packageDir` every harness config then points
+ * at. Idempotent: a marker records the manifest's hash, so an unchanged
+ * executable writes nothing on later runs and a rebuilt one of the same
+ * version refreshes the files.
+ */
+export function materializePackage(routerHome: string, pkg: EmbeddedPackage): string {
+	const dir = join(routerHome, "package", pkg.version);
+	const digest = Bun.hash(JSON.stringify(pkg.files)).toString(16);
+	try {
+		if (readFileSync(join(dir, MARKER), "utf8").trim() === digest) return dir;
+	} catch {
+		/* not written yet */
+	}
+	for (const [rel, content] of Object.entries(pkg.files)) {
+		const target = join(dir, ...rel.split("/"));
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, content, "utf8");
+	}
+	writeFileSync(join(dir, MARKER), `${digest}\n`, "utf8");
+	return dir;
+}

package/src/cli/refresh.ts

@@ -13,6 +13,7 @@
  * its own expiry, so a session still holding it is never cut.
  */
 
+import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -89,7 +90,12 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 	const rh = opts.routerHome ?? routerHome();
 	const fresh = await refreshCredential(opts.remote, opts.fetchImpl ?? fetch, rh, opts.storeDeps ?? {});
 	const home = opts.home ?? (process.env.HOME !== undefined && process.env.HOME !== "" ? process.env.HOME : homedir());
-	const packageDir = opts.packageDir ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+	// The compiled executable rewrites from its own extracted package and keeps
+	// itself as the key helper; the omp extension, running from that extracted
+	// package, learns the executable from remote.json.
+	const embedded = opts.packageDir === undefined ? await readEmbeddedPackage() : null;
+	const packageDir = opts.packageDir ?? (embedded === null ? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..") : materializePackage(rh, embedded));
+	const exePath = opts.remote.executable ?? executablePath() ?? undefined;
 	connectRemote({
 		url: opts.remote.url,
 		key: fresh.key,
@@ -110,6 +116,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 		// The store that already holds it keeps it; a machine never silently changes store.
 		...(opts.remote.refreshTokenStore !== undefined ? { store: opts.remote.refreshTokenStore } : {}),
 		...(opts.storeDeps !== undefined ? { storeDeps: opts.storeDeps } : {}),
+		...(exePath !== undefined ? { exePath } : {}),
 		// undefined keeps whatever scope the managed models.yml block already carries.
 	});
 	return fresh;

package/src/index.ts

@@ -13,6 +13,7 @@ import { configCommand } from "./cli/config-cmd.ts";
 import { explainCommand } from "./cli/explain.ts";
 import { exportCommand } from "./cli/export.ts";
 import { connectCommand } from "./cli/connect.ts";
+import { isCompiled, readEmbeddedPackage } from "./cli/embedded.ts";
 import { refreshCommand, tokenCommand } from "./cli/refresh.ts";
 import { modelsCommand } from "./cli/models.ts";
 import { reportCommand } from "./cli/report.ts";
@@ -27,7 +28,7 @@ Usage: auto-model-router <command> [options]
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
   export     One row per day, harness and model as CSV (--json for rows)
-  connect    Point this machine at a remote router (--url, --key[, --refresh-token]; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment)
+  connect    Point this machine at a remote router (--url with --key[, --refresh-token] or --setup-token <one-time token from a team>; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment and, from the compiled executable, PATH)
   refresh    Trade the refresh token for a new access key and re-write every harness config (--force: even when not near expiry)
   token      Print an access key that is good right now, refreshing first if needed (for a harness key-helper)
   models     Show what each complexity tier would consider, and why
@@ -56,7 +57,9 @@ async function main(): Promise<number> {
 	const args = parseArgv(process.argv.slice(2));
 
 	if (args.flags.has("version")) {
-		const pkg: unknown = await Bun.file(join(import.meta.dir, "..", "package.json")).json();
+		// The compiled executable has no package.json beside it; its embedded copy answers.
+		const embedded = await readEmbeddedPackage();
+		const pkg: unknown = embedded ?? (await Bun.file(join(import.meta.dir, "..", "package.json")).json());
 		const value =
 			typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string"
 				? pkg.version
@@ -108,7 +111,8 @@ async function main(): Promise<number> {
 	}
 }
 
-if (import.meta.main) {
+// The compiled executable loads this module from its entry, so it is never import.meta.main there.
+if (import.meta.main || isCompiled()) {
 	try {
 		const code = await main();
 		if (code !== 0) process.exit(code);

package/src/lib.ts

@@ -23,5 +23,6 @@ export { openDb } from "./util/sqlite.ts";
 export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView } from "./cost/views.ts";
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
+export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";
 export type { RequestPolicy } from "./wire/types.ts";
 export type { Ledger, LedgerEntry } from "./cost/types.ts";

package/test/executable.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget } from "../src/cli/build-executable.ts";
+import { connectRemote, exchangeSetupToken } from "../src/cli/connect.ts";
+import { EMBEDDED_GLOBAL, embeddedHandle, isCompiled, materializePackage, readEmbeddedPackage } from "../src/cli/embedded.ts";
+import { parseRemoteRouter } from "../omp-extension/remote-logic.ts";
+
+const NL = String.fromCharCode(10);
+
+describe("the single-file member install", () => {
+	test("the embedded package is the install: CLI, harness integrations, runtime deps; no tests, no caches", () => {
+		const pkg = collectPackageFiles(process.cwd());
+		expect(pkg.version).toBe((JSON.parse(readFileSync("package.json", "utf8")) as { version: string }).version);
+		expect(pkg.files["src/index.ts"]).toContain("connect");
+		expect(pkg.files["omp-extension/router-embed.ts"]).toBeDefined();
+		expect(pkg.files["hermes-plugin/native/__init__.py"] ?? pkg.files[Object.keys(pkg.files).find((k) => k.startsWith("hermes-plugin/")) ?? ""]).toBeDefined();
+		expect(pkg.files["node_modules/zod/package.json"]).toBeDefined();
+		expect(pkg.files["node_modules/yaml/package.json"]).toBeDefined();
+		const names = Object.keys(pkg.files);
+		// Every non-test source file, none missing: a dropped one only fails on a member machine, when the extension imports it.
+		const onDisk = readdirSync("src", { recursive: true }).map(String).filter((f) => /\.(ts|py|yaml)$/.test(f) && !f.endsWith(".test.ts")).map((f) => `src/${f.replaceAll("\\", "/")}`);
+		expect(onDisk.length).toBeGreaterThan(50);
+		for (const f of onDisk) expect(names).toContain(f);
+		expect(names.some((n) => n.endsWith(".test.ts"))).toBe(false);
+		expect(names.some((n) => n.includes("__pycache__") || n.endsWith(".pyc"))).toBe(false);
+		expect(names.some((n) => /\.d\.ts$/.test(n) && n.startsWith("node_modules/"))).toBe(false);
+	});
+
+	test("targets and file names", () => {
+		expect(isExecutableTarget("linux-x64")).toBe(true);
+		expect(isExecutableTarget("linux-x86")).toBe(false);
+		expect(executableFileName("windows-x64")).toBe("auto-model-router-windows-x64.exe");
+		expect(executableFileName("darwin-arm64")).toBe("auto-model-router-darwin-arm64");
+		expect(hostTarget("win32", "x64")).toBe("windows-x64");
+		expect(hostTarget("darwin", "arm64")).toBe("darwin-arm64");
+		expect(hostTarget("win32", "arm64")).toBeNull();
+	});
+
+	test("under bun there is no embedded package", async () => {
+		expect(isCompiled()).toBe(false);
+		expect(embeddedHandle()).toBeNull();
+		expect(await readEmbeddedPackage()).toBeNull();
+	});
+
+	test("materializing writes the files once, keyed by content, under the router home", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-mat-"));
+		try {
+			const pkg = { version: "9.9.9", files: { "package.json": `{"version":"9.9.9"}${NL}`, "src/index.ts": `console.log(1)${NL}`, "omp-extension/x.ts": "export {}" } };
+			const dir = materializePackage(home, pkg);
+			expect(dir).toBe(join(home, "package", "9.9.9"));
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe(`console.log(1)${NL}`);
+			// Unchanged: a second call leaves a hand-edited file alone (nothing is rewritten).
+			writeFileSync(join(dir, "src", "index.ts"), "edited", "utf8");
+			expect(materializePackage(home, pkg)).toBe(dir);
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe("edited");
+			// A rebuilt executable of the same version with different content refreshes it.
+			expect(materializePackage(home, { ...pkg, files: { ...pkg.files, "src/index.ts": "v2" } })).toBe(dir);
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe("v2");
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("connect from the executable: it is Claude Code's key helper, goes on PATH, and remote.json names it", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-exe-connect-"));
+		const claude = join(home, ".claude");
+		mkdirSync(claude, { recursive: true });
+		const rh = join(home, ".auto-model-router");
+		const env = { HOME: home, PI_CODING_AGENT_DIR: join(home, "no-omp"), AUTO_MODEL_ROUTER_HOME: rh, HERMES_HOME: join(home, "no-hermes"), SHELL: "/bin/zsh" };
+		const exe = join(rh, "bin", "auto-model-router");
+		try {
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u_ada", name: "Ada", profile: true, dryRun: false, only: ["claude"], env, home, packageDir: join(rh, "package", "1.0.0"), exePath: exe, platform: "linux", pathHas: () => false });
+			expect(r.configured.some((c) => c.startsWith("Claude Code ("))).toBe(true);
+			const s = JSON.parse(readFileSync(join(claude, "settings.json"), "utf8")) as { apiKeyHelper: string };
+			expect(s.apiKeyHelper).toBe(`"${exe.replaceAll("\\", "/")}" token`);
+			expect(parseRemoteRouter(readFileSync(join(rh, "remote.json"), "utf8"))?.executable).toBe(exe);
+			const rc = readFileSync(join(home, ".zshrc"), "utf8");
+			expect(rc).toContain(`export PATH="${join(rh, "bin")}:$PATH"`);
+			expect(rc).toContain("export AUTO_MODEL_ROUTER_URL=https://team.example");
+			// Re-running keeps one block.
+			connectRemote({ url: "https://team.example", key: "amrt_k2", userId: "u_ada", name: "Ada", profile: true, dryRun: false, only: ["claude"], env, home, packageDir: join(rh, "package", "1.0.0"), exePath: exe, platform: "linux", pathHas: () => false });
+			expect(readFileSync(join(home, ".zshrc"), "utf8").split("# auto-model-router remote").length).toBe(2);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("a setup token is traded for the credential; a refused token says so", async () => {
+		const seen: { url: string; body: string }[] = [];
+		const ok = (async (url: string | URL | Request, init?: RequestInit) => {
+			seen.push({ url: String(url), body: String(init?.body) });
+			return Response.json({ key: "amrt_new", refreshToken: "amrr_new", keyExpiresAtMs: 10, refreshExpiresAtMs: 20, userId: "u_ada", name: "Ada", teamUrl: "https://team.example" });
+		}) as unknown as typeof fetch;
+		const issued = await exchangeSetupToken("https://team.example", "amrs_t", "laptop", ok);
+		expect(issued).toEqual({ key: "amrt_new", refreshToken: "amrr_new", keyExpiresAtMs: 10, refreshExpiresAtMs: 20, userId: "u_ada", name: "Ada" });
+		expect(seen[0]?.url).toBe("https://team.example/setup/exchange");
+		expect(JSON.parse(seen[0]?.body ?? "{}")).toEqual({ token: "amrs_t", device: "laptop" });
+		const refused = (async () => Response.json({ error: "invalid_token" }, { status: 401 })) as unknown as typeof fetch;
+		await expect(exchangeSetupToken("https://team.example", "amrs_old", "laptop", refused)).rejects.toThrow("refused");
+	});
+
+	test("the executable builds for this host and knows its version from the embedded package", async () => {
+		const target = hostTarget();
+		if (target === null) return;
+		const dir = mkdtempSync(join(tmpdir(), "amr-build-"));
+		try {
+			const out = join(dir, executableFileName(target));
+			const r = await buildExecutable({ packageDir: process.cwd(), target, outFile: out });
+			if (!r.ok) throw new Error(r.reason);
+			expect(existsSync(out)).toBe(true);
+			expect(r.bytes).toBeGreaterThan(10_000_000);
+			const version = Bun.spawnSync([out, "--version"], { stdout: "pipe", stderr: "pipe" }).stdout.toString().trim();
+			expect(version).toBe((JSON.parse(readFileSync("package.json", "utf8")) as { version: string }).version);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	}, 120_000);
+
+	test("the global handle is what marks a compiled process", () => {
+		const g = globalThis as Record<string, unknown>;
+		g[EMBEDDED_GLOBAL] = { manifestPath: "/$bunfs/root/manifest.json" };
+		try {
+			expect(isCompiled()).toBe(true);
+			expect(embeddedHandle()?.manifestPath).toBe("/$bunfs/root/manifest.json");
+		} finally {
+			delete g[EMBEDDED_GLOBAL];
+		}
+		expect(isCompiled()).toBe(false);
+	});
+});