proxium 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,14 @@
-# Temporary Holding Version
+  # proxium
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+  Sign in to [Proxium](https://proxium.tech) once, then run your AI tools through it with your login.
+
+  ```sh
+  npx proxium login
+  proxium launch claude
+  ```
+
+  - `proxium login` signs you in with the browser and sets up Claude Code, OpenCode, Pi and Hermes on this machine.
+  - `proxium launch claude` starts Claude Code with Proxium as its model provider.
+  - `proxium token` prints a fresh token of your login, for a tool or a script.
+
+  The tools keep no key: each one runs `proxium token` when it needs one. The guide: https://proxium.tech/docs/guides/login

package/package.json

@@ -1,6 +1,11 @@
-{
-  "name": "proxium",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  {
+    "name": "proxium",
+    "version": "0.1.0",
+    "description": "Sign in to Proxium once, then run Claude Code, OpenCode, Pi and Hermes through it with your login.",
+    "license": "Elastic-2.0",
+    "homepage": "https://proxium.tech",
+    "type": "module",
+    "bin": { "proxium": "proxium-cli.mjs" },
+    "files": ["proxium-cli.mjs", "README.md"],
+    "engines": { "node": ">=20" }
+  }

package/proxium-cli.mjs

@@ -0,0 +1,1301 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+//#region ../node_modules/@munhq/mcp-kit/dist/cli/device.js
+/**
+* The CLI half of the sign-in: the device login of RFC 8628 against a product whose identity runs
+* better-auth's `deviceAuthorization` plugin (`fleetDevice()` in `@munhq/auth`).
+*
+* The product shows a code, the person approves it in the browser where they are signed in, and the
+* CLI gets a better-auth session token. What the CLI does with that token is the product's own
+* step: desk exchanges it for a desk token, chat-recall for a sync device token, proxium for a
+* project key.
+*/
+var LoginError = class extends Error {};
+const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+/** Opens `url` with the desktop's opener. False on a machine with no display. */
+function openInBrowser(url) {
+	const [bin, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+	try {
+		const child = spawn(bin, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => void 0);
+		child.unref();
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function postJson(f, url, body) {
+	let res;
+	try {
+		res = await f(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	} catch (e) {
+		throw new LoginError(`${new URL(url).origin} did not answer: ${e.message}`);
+	}
+	const text = await res.text();
+	try {
+		return {
+			status: res.status,
+			json: text ? JSON.parse(text) : {}
+		};
+	} catch {
+		return {
+			status: res.status,
+			json: { error: text.slice(0, 200) }
+		};
+	}
+}
+const said = (j) => String(j.error_description ?? j.error ?? "no reason given");
+/** Runs the device login and answers the session token of the person who approved the code. */
+async function deviceLogin(o) {
+	const server = o.server.replace(/\/+$/, "");
+	const f = o.fetch ?? fetch;
+	const say = o.write ?? ((l) => process.stdout.write(`${l}\n`));
+	const sleep = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+	const open = o.openBrowser ?? openInBrowser;
+	const start = await postJson(f, `${server}/api/auth/device/code`, { client_id: o.clientId });
+	if (start.status === 404) throw new LoginError(`${server} has no device login.`);
+	const j = start.json;
+	const deviceCode = j.device_code;
+	const userCode = j.user_code;
+	const uri = j.verification_uri;
+	if (start.status !== 200 || !deviceCode || !userCode || !uri) throw new LoginError(`${server} refused the device login (${start.status}): ${said(j)}`);
+	const page = j.verification_uri_complete ?? uri;
+	say(`Your code: ${userCode}`);
+	say(!o.noBrowser && open(page) ? `The browser opens ${page}. Sign in there and approve the code.` : `Open ${page} in a browser, sign in and approve the code.`);
+	let interval = Math.max(1, Number(j.interval ?? 5)) * 1e3;
+	const end = Date.now() + Math.max(30, Number(j.expires_in ?? 600)) * 1e3;
+	for (;;) {
+		if (Date.now() > end) throw new LoginError("the code expired before it was approved. Run the login again.");
+		await sleep(interval);
+		const r = await postJson(f, `${server}/api/auth/device/token`, {
+			grant_type: DEVICE_GRANT,
+			device_code: deviceCode,
+			client_id: o.clientId
+		});
+		if (r.status === 200 && typeof r.json.access_token === "string") return r.json.access_token;
+		const error = r.json.error;
+		if (error === "authorization_pending") continue;
+		if (error === "slow_down") interval += 5e3;
+		else if (error === "access_denied") throw new LoginError("the code was denied in the browser. Nothing was stored.");
+		else if (error === "expired_token") throw new LoginError("the code expired before it was approved. Run the login again.");
+		else throw new LoginError(`the device login failed (${r.status}): ${said(r.json)}`);
+	}
+}
+//#endregion
+//#region ../node_modules/@munhq/mcp-kit/dist/cli/host.js
+function systemHost(env = process.env) {
+	return {
+		home: env.HOME ?? homedir(),
+		env,
+		run(bin, args, opts = {}) {
+			const r = spawnSync(bin, args, {
+				input: opts.input,
+				cwd: opts.cwd,
+				env: opts.env ?? env,
+				encoding: "utf8"
+			});
+			return {
+				code: r.status ?? 1,
+				stdout: r.stdout ?? "",
+				stderr: r.stderr ?? (r.error ? String(r.error) : "")
+			};
+		},
+		read(path) {
+			try {
+				return readFileSync(path, "utf8");
+			} catch {
+				return;
+			}
+		},
+		write(path, text, opts = {}) {
+			mkdirSync(dirname(path), {
+				recursive: true,
+				...opts.dirMode === void 0 ? {} : { mode: opts.dirMode }
+			});
+			if (opts.mode === void 0) {
+				if (existsSync(path)) copyFileSync(path, `${path}.munhq-bak`);
+				writeFileSync(path, text);
+			} else {
+				writeFileSync(path, text, { mode: opts.mode });
+				chmodSync(path, opts.mode);
+			}
+		}
+	};
+}
+//#endregion
+//#region ../node_modules/@munhq/mcp-kit/dist/cli/store.js
+const SECRET_NAME = /^[a-z][a-z0-9-]*(\/[A-Za-z0-9_.-]+){2,3}$/;
+/** Keeps `value` and answers where it went. */
+function saveSecret(value, o) {
+	const host = o.host ?? systemHost();
+	const run = o.run ?? host.run;
+	if (!o.forceFile && SECRET_NAME.test(o.name)) {
+		if (run("sealkeep", [
+			"set",
+			"--stdin",
+			...o.description ? ["-d", o.description] : [],
+			o.name
+		], { input: value }).code === 0) return {
+			kind: "sealkeep",
+			name: o.name
+		};
+	}
+	host.write(o.file, `${value}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+	return {
+		kind: "file",
+		path: o.file
+	};
+}
+const quote$1 = (w) => /^[A-Za-z0-9_./:=@%+-]+$/.test(w) ? w : `'${w.replace(/'/g, `'\\''`)}'`;
+/** A shell script that starts `command` with the secret in `envVar`; its own arguments follow the command. */
+function launchScript(where, envVar, command, comment = "") {
+	const lines = ["#!/bin/sh", ...comment ? comment.split("\n").map((l) => `# ${l}`) : []];
+	if (where.kind === "sealkeep") lines.push(`exec sealkeep run -e ${envVar}=${where.name} -- ${command.map(quote$1).join(" ")} "$@"`);
+	else lines.push(`${envVar}="$(cat ${quote$1(where.path)})"`, `export ${envVar}`, `exec ${command.map(quote$1).join(" ")} "$@"`);
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+//#region ../node_modules/@munhq/mcp-kit/dist/cli/clients.js
+const done = (client, changed, message) => ({
+	client,
+	ok: true,
+	changed,
+	message
+});
+const failed = (client, message) => ({
+	client,
+	ok: false,
+	changed: false,
+	message
+});
+const last = (text) => text.trim().split("\n").filter(Boolean).slice(-2).join(" / ");
+const xdg = (h) => h.env.XDG_CONFIG_HOME || join(h.home, ".config");
+/** Reads a JSON file, lets `edit` change it, and writes it when `edit` answers true. */
+function editJson(h, path, edit) {
+	const text = h.read(path);
+	let doc = {};
+	if (text !== void 0 && text.trim() !== "") try {
+		doc = JSON.parse(text);
+	} catch {
+		return { error: `${path} is not JSON, so it was not changed` };
+	}
+	if (!edit(doc)) return { changed: false };
+	h.write(path, `${JSON.stringify(doc, null, 2)}\n`);
+	return { changed: true };
+}
+const obj = (d, key) => d[key] ??= {};
+/** Adds `value` under `d[section][name]` unless the entry is there already. */
+function putEntry(h, client, label, path, section, name, value) {
+	const r = editJson(h, path, (d) => {
+		const entries = obj(d, section);
+		if (JSON.stringify(entries[name]) === JSON.stringify(value)) return false;
+		entries[name] = value;
+		return true;
+	});
+	if ("error" in r) return failed(client, r.error);
+	return done(client, r.changed, r.changed ? `${label}: added ${name} to ${path}` : `${label}: ${name} is already in ${path}`);
+}
+/** The major version of OpenCode, or 0 when it does not answer. */
+function openCodeMajor(h) {
+	const r = h.run("opencode", ["--version"]);
+	const m = /(\d+)\.\d+\.\d+/.exec(`${r.stdout} ${r.stderr}`);
+	return m ? Number(m[1]) : 0;
+}
+/**
+* The OpenCode 2 plugin that gives the provider `name` a fresh key on each request: its `model.request` hook runs
+* `command` (which prints `{"access_token", "expires_in"}`) and keeps the token until two minutes before its end.
+* OpenCode takes no key command in its config, and reads `{env:…}` only at start.
+*/
+function openCodeKeyPlugin(name, command) {
+	return `// Written by the login of ${name}: each request of the provider ${name} carries a fresh key.
+import { execFile } from "node:child_process";
+const COMMAND = ${JSON.stringify(command)};
+let kept;
+function mint() {
+  return new Promise((resolve, reject) =>
+    execFile("/bin/sh", ["-c", COMMAND], { timeout: 15000 }, (e, out, err) =>
+      e ? reject(new Error(String(err).trim() || e.message)) : resolve(String(out))),
+  );
+}
+async function key() {
+  const now = Date.now() / 1000;
+  if (kept && kept.exp - now > 120) return kept.token;
+  const j = JSON.parse(await mint());
+  kept = { token: j.access_token, exp: now + Number(j.expires_in) };
+  return kept.token;
+}
+export default {
+  id: ${JSON.stringify(`${name}-key`)},
+  async setup(ctx) {
+    await ctx.session.hook("model.request", async (event) => {
+      event.headers.authorization = "Bearer " + (await key());
+    }, { providerID: ${JSON.stringify(name)} });
+  },
+};
+`;
+}
+/**
+* OpenCode 2 with a key command: the plugin in the product's own folder (`~/.config/<name>/opencode-plugin`), listed
+* in `plugins`, and the provider with no key. OpenCode loads a plugin from any folder that `plugins` lists.
+*/
+function openCodeWithPlugin(h, p, command) {
+	const dir = join(xdg(h), p.name, "opencode-plugin");
+	const config = join(xdg(h), "opencode", "opencode.json");
+	const source = openCodeKeyPlugin(p.name, command);
+	const pluginChanged = h.read(join(dir, "index.js")) !== source;
+	if (pluginChanged) h.write(join(dir, "index.js"), source);
+	const r = editJson(h, config, (d) => {
+		let changed = false;
+		const plugins = Array.isArray(d.plugins) ? d.plugins : d.plugins = [];
+		if (!plugins.includes(dir)) {
+			plugins.push(dir);
+			changed = true;
+		}
+		const providers = obj(d, "provider");
+		const value = {
+			npm: "@ai-sdk/openai-compatible",
+			name: p.label,
+			options: {
+				baseURL: p.baseUrl,
+				...p.headers ? { headers: p.headers } : {}
+			},
+			models: Object.fromEntries(p.models.map((m) => [m.id, { name: m.label ?? m.id }]))
+		};
+		if (JSON.stringify(providers[p.name]) !== JSON.stringify(value)) {
+			providers[p.name] = value;
+			changed = true;
+		}
+		return changed;
+	});
+	if ("error" in r) return failed("opencode", r.error);
+	const changed = r.changed || pluginChanged;
+	return done("opencode", changed, changed ? `OpenCode: added ${p.name} to ${config}, with the plugin ${dir} that sets its key` : `OpenCode: ${p.name} is already in ${config}`);
+}
+/** `check` succeeds when the server is registered already. */
+function byCommand(h, client, label, name, check, add) {
+	if (h.run(check[0], check[1]).code === 0) return done(client, false, `${label}: ${name} is already registered`);
+	const r = h.run(add[0], add[1]);
+	if (r.code !== 0) return failed(client, `${label}: ${add[0]} ${add[1].slice(0, 2).join(" ")} failed: ${last(r.stderr || r.stdout)}`);
+	return done(client, true, `${label}: registered ${name}`);
+}
+const CLIENTS = {
+	claude: {
+		id: "claude",
+		name: "Claude Code",
+		bin: "claude",
+		addMcp: (h, s) => byCommand(h, "claude", "Claude Code", s.name, ["claude", [
+			"mcp",
+			"get",
+			s.name
+		]], ["claude", [
+			"mcp",
+			"add",
+			"--scope",
+			"user",
+			"--transport",
+			"http",
+			s.name,
+			s.url
+		]]),
+		mcpLogin: (_h, s) => ({
+			client: "claude",
+			instruction: `Start a new session, run /mcp, select ${s.name}, and sign in.`
+		})
+	},
+	codex: {
+		id: "codex",
+		untested: true,
+		name: "Codex",
+		bin: "codex",
+		addMcp: (h, s) => byCommand(h, "codex", "Codex", s.name, ["codex", [
+			"mcp",
+			"get",
+			s.name
+		]], ["codex", [
+			"mcp",
+			"add",
+			s.name,
+			"--url",
+			s.url
+		]]),
+		mcpLogin: (_h, s) => ({
+			client: "codex",
+			command: [
+				"codex",
+				"mcp",
+				"login",
+				s.name
+			],
+			instruction: `Run codex mcp login ${s.name}.`
+		})
+	},
+	opencode: {
+		id: "opencode",
+		name: "OpenCode",
+		bin: "opencode",
+		addMcp: (h, s) => putEntry(h, "opencode", "OpenCode", join(xdg(h), "opencode", "opencode.json"), "mcp", s.name, {
+			type: "remote",
+			url: s.url,
+			enabled: true
+		}),
+		mcpLogin: (h, s) => ({
+			client: "opencode",
+			command: [
+				"opencode",
+				"mcp",
+				"auth",
+				s.name
+			],
+			cwd: h.home,
+			instruction: `Run opencode mcp auth ${s.name} in your home folder.`
+		}),
+		takesKeyCommand: (h) => openCodeMajor(h) >= 2,
+		addProvider: (h, p) => p.keyCommandJson && openCodeMajor(h) >= 2 ? openCodeWithPlugin(h, p, p.keyCommandJson) : putEntry(h, "opencode", "OpenCode", join(xdg(h), "opencode", "opencode.json"), "provider", p.name, {
+			npm: "@ai-sdk/openai-compatible",
+			name: p.label,
+			env: [p.keyEnv],
+			options: {
+				baseURL: p.baseUrl,
+				apiKey: `{env:${p.keyEnv}}`,
+				...p.headers ? { headers: p.headers } : {}
+			},
+			models: Object.fromEntries(p.models.map((m) => [m.id, { name: m.label ?? m.id }]))
+		})
+	},
+	pi: {
+		id: "pi",
+		name: "Pi",
+		bin: "pi",
+		addMcp: (h, s) => {
+			if (h.run("pi", [
+				"mcp",
+				"list",
+				"--json"
+			]).stdout.includes(`"${s.name}"`)) return done("pi", false, `Pi: ${s.name} is already registered`);
+			const r = h.run("pi", [
+				"mcp",
+				"add",
+				s.name,
+				"--url",
+				s.url
+			]);
+			return r.code === 0 ? done("pi", true, `Pi: registered ${s.name}`) : failed("pi", `Pi: pi mcp add failed: ${last(r.stderr || r.stdout)}`);
+		},
+		mcpLogin: (_h, s) => ({
+			client: "pi",
+			command: [
+				"pi",
+				"mcp",
+				"login",
+				s.name
+			],
+			instruction: `Run pi mcp login ${s.name}.`
+		}),
+		takesKeyCommand: () => true,
+		addProvider: (h, p) => putEntry(h, "pi", "Pi", join(h.home, ".pi", "agent", "models.json"), "providers", p.name, {
+			baseUrl: p.baseUrl,
+			api: "openai-completions",
+			apiKey: p.keyCommand ? `!${p.keyCommand}` : `$${p.keyEnv}`,
+			...p.headers ? { headers: p.headers } : {},
+			models: p.models.map((m) => ({ id: m.id }))
+		})
+	},
+	hermes: {
+		id: "hermes",
+		name: "Hermes",
+		bin: "hermes",
+		addMcp: (h, s) => hermesSet(h, "mcp_servers", s.name, {
+			url: s.url,
+			auth: "oauth",
+			...s.registerClient ? { oauth: { cimd: false } } : {}
+		}),
+		mcpLogin: (_h, s) => ({
+			client: "hermes",
+			command: [
+				"hermes",
+				"mcp",
+				"login",
+				s.name
+			],
+			instruction: `Run hermes mcp login ${s.name}.`
+		}),
+		takesKeyCommand: () => true,
+		addProvider: (h, p) => hermesSet(h, "providers", p.name, {
+			api: p.baseUrl,
+			...p.keyCommandJson ? { key_cmd: p.keyCommandJson } : { key_env: p.keyEnv },
+			default_model: p.defaultModel,
+			...p.headers ? { extra_headers: p.headers } : {}
+		})
+	},
+	gemini: {
+		id: "gemini",
+		untested: true,
+		name: "Gemini CLI",
+		bin: "gemini",
+		addMcp: (h, s) => putEntry(h, "gemini", "Gemini CLI", join(h.home, ".gemini", "settings.json"), "mcpServers", s.name, { httpUrl: s.url }),
+		mcpLogin: (_h, s) => ({
+			client: "gemini",
+			instruction: `Start gemini, run /mcp auth ${s.name}, and sign in.`
+		})
+	},
+	cursor: {
+		id: "cursor",
+		untested: true,
+		name: "Cursor",
+		bin: "cursor",
+		addMcp: (h, s) => putEntry(h, "cursor", "Cursor", join(h.home, ".cursor", "mcp.json"), "mcpServers", s.name, { url: s.url }),
+		mcpLogin: (_h, s) => ({
+			client: "cursor",
+			instruction: `Open Cursor, and sign in to ${s.name} when it asks.`
+		})
+	}
+};
+/** Hermes keeps its configuration in YAML. Its own CLI reads and writes the entry, so the kit has no YAML parser. */
+function hermesSet(h, section, name, value) {
+	const key = `${section}.${name}`;
+	const have = h.run("hermes", [
+		"config",
+		"get",
+		"--json",
+		key
+	]);
+	if (have.code === 0) try {
+		if (JSON.stringify(JSON.parse(have.stdout)) === JSON.stringify(value)) return done("hermes", false, `Hermes: ${name} is already in ${section}`);
+	} catch {}
+	const r = h.run("hermes", [
+		"config",
+		"set",
+		key,
+		JSON.stringify(value)
+	]);
+	if (r.code !== 0) return failed("hermes", `Hermes: hermes config set ${key} failed: ${last(r.stderr || r.stdout)}`);
+	return done("hermes", true, `Hermes: set ${key}`);
+}
+/** The clients of `only` (all when omitted) whose program is on the PATH. */
+function installedClients(h, only) {
+	return Object.values(CLIENTS).filter((c) => (!only || only.includes(c.id)) && h.run("sh", ["-c", `command -v ${c.bin}`]).code === 0);
+}
+/** Adds a remote MCP server to each client. A failure of one client does not stop the others. */
+function addMcpServer(h, clients, server) {
+	const outcomes = [];
+	const logins = [];
+	for (const c of clients) {
+		const o = c.addMcp(h, server);
+		outcomes.push(o);
+		if (o.ok) logins.push(c.mcpLogin(h, server));
+	}
+	return {
+		outcomes,
+		logins
+	};
+}
+const upper = (name) => name.toUpperCase().replace(/-/g, "_");
+/** The folder of the files of a product's CLI. */
+function configDir(product, host) {
+	return join(host.home, ".config", product.name);
+}
+/** The environment variable that carries the session into a `token` run under sealkeep. */
+function sessionEnv(product) {
+	return `${upper(product.name)}_SESSION`;
+}
+/** Keeps the session of a login, and the server it belongs to. A token of an earlier login is dropped. */
+function keepSession(product, server, session, host) {
+	const dir = configDir(product, host);
+	const record = {
+		server,
+		session: saveSecret(session, {
+			name: `personal/${product.name}/prod/${upper(product.name)}_SESSION`,
+			file: join(dir, "session"),
+			description: `The ${product.name} login session; ${product.name} token trades it for a short-lived token`,
+			host
+		})
+	};
+	host.write(join(dir, "login.json"), `${JSON.stringify(record, null, 2)}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+	host.write(join(dir, "token.json"), "{}\n", {
+		mode: 384,
+		dirMode: 448
+	});
+	return record;
+}
+/** The `exp` of a JWT, in seconds, or 0 when the token has none. The signature is the server's to check. */
+function expiryOf(token) {
+	const payload = token.split(".")[1];
+	if (!payload) return 0;
+	try {
+		const exp = JSON.parse(Buffer.from(payload, "base64url").toString("utf8")).exp;
+		return typeof exp === "number" && Number.isFinite(exp) ? exp : 0;
+	} catch {
+		return 0;
+	}
+}
+function parse(text) {
+	try {
+		return text ? JSON.parse(text) : {};
+	} catch {
+		return {};
+	}
+}
+/** One line of output in `format`. */
+function formatToken(token, format, now) {
+	if (format === "json") return `${JSON.stringify({
+		access_token: token,
+		expires_in: Math.max(0, expiryOf(token) - now)
+	})}\n`;
+	if (format === "header") return `${JSON.stringify({ Authorization: `Bearer ${token}` })}\n`;
+	return `${token}\n`;
+}
+/** Runs `<product> token`. Answers the exit code; the token alone goes to the output. */
+async function runToken(product, deps = {}) {
+	const host = deps.host ?? systemHost();
+	const f = deps.fetch ?? fetch;
+	const now = deps.now ?? (() => Math.floor(Date.now() / 1e3));
+	const out = deps.out ?? ((t) => process.stdout.write(t));
+	const err = deps.err ?? ((l) => process.stderr.write(`${l}\n`));
+	const format = deps.format ?? "token";
+	const dir = configDir(product, host);
+	const login = parse(host.read(join(dir, "login.json")));
+	if (typeof login.server !== "string" || !login.session) {
+		err(`${product.name}: no login on this machine. Run ${product.name} login`);
+		return 1;
+	}
+	const cached = parse(host.read(join(dir, "token.json")));
+	if (cached.server === login.server && typeof cached.token === "string" && (cached.exp ?? 0) - now() > 120) {
+		out(formatToken(cached.token, format, now()));
+		return 0;
+	}
+	const session = readSession(product, login.session, host);
+	if (session.kind === "sealkeep") {
+		const self = deps.self ?? [
+			process.execPath,
+			process.argv[1],
+			"token"
+		];
+		const r = host.run("sealkeep", [
+			"run",
+			"-e",
+			`${sessionEnv(product)}=${session.name}`,
+			"--",
+			...self
+		]);
+		if (r.code !== 0) {
+			err(r.stderr.trim() || `${product.name}: sealkeep did not give the session (exit ${r.code})`);
+			return r.code || 1;
+		}
+		const token = r.stdout.trim();
+		if (!token) {
+			err(`${product.name}: the run under sealkeep printed no token`);
+			return 1;
+		}
+		out(formatToken(token, format, now()));
+		return 0;
+	}
+	if (session.kind === "missing") {
+		err(`${product.name}: the login session is missing. Run ${product.name} login`);
+		return 1;
+	}
+	let r;
+	try {
+		r = await f(`${login.server}${product.tokenPath ?? "/api/auth/token"}`, { headers: {
+			authorization: `Bearer ${session.value}`,
+			"user-agent": `${product.name}-cli`
+		} });
+	} catch (e) {
+		err(`${product.name}: ${login.server} did not answer (${e.message})`);
+		return 1;
+	}
+	if (r.status === 401 || r.status === 403) {
+		err(`${product.name}: the login expired. Run ${product.name} login`);
+		return 1;
+	}
+	const token = r.ok ? (await r.json().catch(() => ({}))).token : void 0;
+	if (typeof token !== "string" || !token) {
+		err(`${product.name}: the server gave no token (${r.status})`);
+		return 1;
+	}
+	const record = {
+		server: login.server,
+		token,
+		exp: expiryOf(token)
+	};
+	host.write(join(dir, "token.json"), `${JSON.stringify(record)}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+	out(formatToken(token, format, now()));
+	return 0;
+}
+/** The session: its value, or the sealkeep name when this run is not the one inside sealkeep. */
+function readSession(product, where, host) {
+	const value = where.kind === "file" ? host.read(where.path)?.trim() : host.env[sessionEnv(product)]?.trim();
+	if (value) return {
+		kind: "value",
+		value
+	};
+	return where.kind === "sealkeep" ? {
+		kind: "sealkeep",
+		name: where.name
+	} : { kind: "missing" };
+}
+//#endregion
+//#region ../node_modules/@munhq/mcp-kit/dist/cli/login.js
+const CLIENT_IDS = [
+	"claude",
+	"codex",
+	"opencode",
+	"pi",
+	"hermes",
+	"gemini",
+	"cursor"
+];
+const HELP$1 = (p) => `${p.name} login [--server URL] [--only claude,pi,…] [--no-browser] [--no-signin]${Object.keys(p.options ?? {}).map((k) => ` [--${k}${p.options?.[k]?.type === "string" ? " VALUE" : ""}]`).join("")}
+
+Signs you in, adds the ${p.name} MCP server to each AI client on this machine, and signs each one in.
+  --server URL     the server (default ${p.server}, or the variable ${p.name.toUpperCase().replace(/-/g, "_")}_URL)
+  --only LIST      only these clients: ${CLIENT_IDS.join(", ")}
+  --no-browser     print the code and the page, and open no browser
+  --no-signin      add the server to the clients, and do not start their sign-in
+${Object.entries(p.options ?? {}).map(([k, o]) => `  --${(k + (o.type === "string" ? " VALUE" : "")).padEnd(14)} ${o.help}`).join("\n")}
+`;
+/** The MCP URL: the discovery document of the server when it has one, else the origin and the path. */
+async function discoverMcp(server, path, f) {
+	const fallback = `${server}${path}`;
+	try {
+		const r = await f(`${server}/.well-known/oauth-protected-resource${path}`);
+		if (!r.ok) return fallback;
+		const j = await r.json();
+		return typeof j.resource === "string" && /^https?:\/\//.test(j.resource) ? j.resource : fallback;
+	} catch {
+		return fallback;
+	}
+}
+function terminalSignIn(step) {
+	const [bin, ...args] = step.command;
+	return spawnSync(bin, args, {
+		stdio: "inherit",
+		cwd: step.cwd
+	}).status ?? 1;
+}
+/** Runs `<product> login`. Answers the exit code. */
+async function runLogin(product, argv, deps = {}) {
+	const say = deps.say ?? ((l) => process.stdout.write(`${l}\n`));
+	const host = deps.host ?? systemHost();
+	const f = deps.fetch ?? fetch;
+	let values;
+	try {
+		({values} = parseArgs({
+			args: argv,
+			options: {
+				...Object.fromEntries(Object.entries(product.options ?? {}).map(([k, o]) => [k, { type: o.type }])),
+				server: { type: "string" },
+				only: { type: "string" },
+				"no-browser": { type: "boolean" },
+				"no-signin": { type: "boolean" },
+				help: { type: "boolean" }
+			}
+		}));
+	} catch (e) {
+		say(`${e.message}\n\n${HELP$1(product)}`);
+		return 2;
+	}
+	if (values.help) {
+		say(HELP$1(product));
+		return 0;
+	}
+	const only = values.only?.split(",").map((s) => s.trim()).filter(Boolean);
+	const unknown = (only ?? []).filter((c) => !CLIENT_IDS.includes(c));
+	if (unknown.length) {
+		say(`unknown client: ${unknown.join(", ")}. The clients are ${CLIENT_IDS.join(", ")}.`);
+		return 2;
+	}
+	const envName = `${product.name.toUpperCase().replace(/-/g, "_")}_URL`;
+	const server = (values.server ?? host.env[envName] ?? product.server).replace(/\/+$/, "");
+	let session;
+	try {
+		session = await (deps.device ?? deviceLogin)({
+			server,
+			clientId: product.clientId,
+			noBrowser: values["no-browser"],
+			fetch: f,
+			write: say
+		});
+	} catch (e) {
+		if (e instanceof LoginError) {
+			say(`Login failed: ${e.message}`);
+			return 1;
+		}
+		throw e;
+	}
+	say("Signed in.");
+	const kept = keepSession(product, server, session, host);
+	say(`The login is kept in ${kept.session.kind === "sealkeep" ? `sealkeep (${kept.session.name})` : `${kept.session.path} (only you can read it)`}. ${product.name} token prints a token from it.`);
+	const clients = installedClients(host, only);
+	const ctx = {
+		server,
+		flags: Object.fromEntries(Object.keys(product.options ?? {}).map((k) => [k, values[k]])),
+		session,
+		clients,
+		host,
+		fetch: f,
+		say
+	};
+	let failed = false;
+	const summary = [];
+	try {
+		summary.push(...await product.afterApproval?.(ctx) ?? []);
+	} catch (e) {
+		failed = true;
+		summary.push(`${product.name}: ${e.message}`);
+	}
+	if (clients.length === 0) summary.push("No AI client was found on this machine, so no MCP server was added.");
+	else {
+		const url = await discoverMcp(server, product.mcpPath ?? "/mcp", f);
+		const { outcomes, logins } = addMcpServer(host, clients, {
+			name: product.name,
+			url,
+			registerClient: product.registerClient
+		});
+		for (const o of outcomes) {
+			summary.push(o.message);
+			if (!o.ok) failed = true;
+		}
+		for (const step of logins) if (step.command && !values["no-signin"]) {
+			say(`Signing in ${step.client}…`);
+			const code = (deps.signIn ?? terminalSignIn)({
+				...step,
+				command: step.command
+			});
+			summary.push(code === 0 ? `${step.client}: signed in` : `${step.client}: the sign-in did not finish (exit ${code}). ${step.instruction}`);
+			if (code !== 0) failed = true;
+		} else summary.push(`${step.client}: ${step.instruction}`);
+	}
+	for (const l of summary) say(l);
+	return failed ? 1 : 0;
+}
+//#endregion
+//#region src/cli/launch.ts
+const PRODUCT = { name: "proxium" };
+function settingsPath(host) {
+	return join(configDir(PRODUCT, host), "settings.json");
+}
+function readSettings(host) {
+	try {
+		return JSON.parse(host.read(settingsPath(host)) ?? "{}");
+	} catch {
+		return {};
+	}
+}
+function writeSettings(host, s) {
+	host.write(settingsPath(host), `${JSON.stringify(s, null, 2)}\n`, {
+		mode: 384,
+		dirMode: 448
+	});
+}
+const quote = (w) => `'${w.replace(/'/g, `'\\''`)}'`;
+/**
+* The command that runs this program, for the tools that run `proxium token` later. `npx proxium` runs the file
+* from the cache of npm (`…/_npx/<hash>/…`), which npm may delete, so that file is copied to `~/.local/bin/proxium`
+* first, as `install.sh` does, and the tools name the copy.
+*/
+function stableSelf(host, execPath, script) {
+	if (!/[\\/]_npx[\\/]/.test(script)) return [execPath, script];
+	const text = host.read(script);
+	if (text === void 0) return [execPath, script];
+	const dest = join(host.home, ".local", "bin", "proxium");
+	if (host.read(dest) !== text) host.write(dest, text, { mode: 493 });
+	return [execPath, dest];
+}
+/** The command line of `proxium token`, for a tool that runs it through a shell. */
+function tokenCommand(self, ...flags) {
+	return [
+		...self,
+		"token",
+		...flags
+	].map(quote).join(" ");
+}
+/** The Claude Code config folder of Proxium. A folder of its own keeps the subscription login of `~/.claude` out of it. */
+const CLAUDE_DIR = ".claude-proxium";
+/**
+* Claude Code as an API client of Proxium. Its key comes from `apiKeyHelper`, so the two key variables are removed:
+* Claude Code prefers them to the helper. `auto` is the model unless the person set one. The Proxium MCP comes with
+* the same login: `headersHelper` runs `proxium token --header` (the MCP of `id/` takes the login token).
+*/
+function claudeLaunch(o) {
+	const env = { ...o.env };
+	delete env.ANTHROPIC_API_KEY;
+	delete env.ANTHROPIC_AUTH_TOKEN;
+	env.ANTHROPIC_BASE_URL = o.server;
+	env.ANTHROPIC_CUSTOM_HEADERS = ["x-proxium-source: claude-code", ...o.project ? [`x-proxium-project: ${o.project}`] : []].join("\n");
+	env.ANTHROPIC_MODEL ??= "auto";
+	env.ANTHROPIC_SMALL_FAST_MODEL ??= "auto";
+	env.ANTHROPIC_DEFAULT_HAIKU_MODEL ??= "auto";
+	env.CLAUDE_CONFIG_DIR = join(o.home, CLAUDE_DIR);
+	env.CLAUDE_CODE_API_KEY_HELPER_TTL_MS ??= "600000";
+	return {
+		command: [
+			"claude",
+			"--settings",
+			JSON.stringify({ apiKeyHelper: tokenCommand(o.self) }),
+			"--mcp-config",
+			JSON.stringify({ mcpServers: { proxium: {
+				type: "http",
+				url: `${o.server}/mcp`,
+				headersHelper: tokenCommand(o.self, "--header")
+			} } }),
+			...o.args
+		],
+		env
+	};
+}
+const TOOLS = ["claude"];
+const HELP = `proxium launch <tool> [--project SLUG] [-- tool arguments]
+
+Starts the tool with Proxium as its model provider and your login as its key. The tools: ${TOOLS.join(", ")}.
+  --project SLUG   the project of the calls (default: PROXIUM_PROJECT, else the project of proxium login)
+Example: proxium launch claude -- -p "Reply with one word: ok"
+`;
+function runInherit(l) {
+	const [bin, ...args] = l.command;
+	const r = spawnSync(bin, args, {
+		stdio: "inherit",
+		env: l.env
+	});
+	if (r.error) throw r.error;
+	return r.status ?? 1;
+}
+/** Runs `proxium launch`. Answers the exit code: the tool's own, or 1 or 2 for a fault before it starts. */
+function runLaunch(argv, deps = {}) {
+	const host = deps.host ?? systemHost();
+	const err = deps.err ?? ((l) => process.stderr.write(`${l}\n`));
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: argv,
+			allowPositionals: true,
+			options: {
+				project: { type: "string" },
+				help: { type: "boolean" }
+			}
+		});
+	} catch (e) {
+		err(`${e.message}\n\n${HELP}`);
+		return 2;
+	}
+	const [tool, ...rest] = parsed.positionals;
+	if (parsed.values.help || !tool) {
+		err(HELP);
+		return parsed.values.help ? 0 : 2;
+	}
+	if (!TOOLS.includes(tool)) {
+		err(`proxium launch: ${tool} is not a tool it can start. The tools: ${TOOLS.join(", ")}.`);
+		return 2;
+	}
+	let login = {};
+	try {
+		login = JSON.parse(host.read(join(configDir(PRODUCT, host), "login.json")) ?? "{}");
+	} catch {
+		login = {};
+	}
+	if (typeof login.server !== "string") {
+		err("proxium: no login on this machine. Run proxium login");
+		return 1;
+	}
+	const project = parsed.values.project ?? host.env.PROXIUM_PROJECT ?? readSettings(host).project;
+	const self = deps.self ?? stableSelf(host, process.execPath, process.argv[1]);
+	const l = claudeLaunch({
+		server: login.server,
+		project,
+		self,
+		home: host.home,
+		env: host.env,
+		args: rest
+	});
+	if (!deps.run) prepareClaudeDir(host.home);
+	return (deps.run ?? runInherit)(l);
+}
+/** The config folder of Proxium's Claude Code, with the person's `CLAUDE.md` linked into it. */
+function prepareClaudeDir(home) {
+	const dir = join(home, CLAUDE_DIR);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const own = join(home, ".claude", "CLAUDE.md");
+	const linked = join(dir, "CLAUDE.md");
+	if (existsSync(own) && !present(linked)) symlinkSync(own, linked);
+}
+/** Whether a path exists, a link that points nowhere included. */
+function present(path) {
+	try {
+		lstatSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/cli/launchers.ts
+/** `opencode run` talks to a shared background service that has no key in its environment, so it starts a server of its own. */
+const OPENCODE = `if [ "$1" = run ]; then shift; set -- run --standalone "$@"; elif [ $# -eq 0 ] || [ "\${1#-}" != "$1" ]; then set -- --standalone "$@"; fi; exec opencode "$@"`;
+/** The launcher of a tool, or undefined for a tool that has none (it still gets the MCP server). */
+function launcherFor(id, server, project, app) {
+	if (!/^https?:\/\/[\w.:-]+$/.test(server)) throw new Error(`${server} is not a server address`);
+	const comment = `${app} through Proxium, project ${project}. Written by proxium login.`;
+	switch (id) {
+		case "opencode": return {
+			file: "opencode-proxium",
+			envVar: "PROXIUM_API_KEY",
+			command: [
+				"sh",
+				"-c",
+				OPENCODE,
+				"opencode-proxium"
+			],
+			comment: `${comment}\nUse the model proxium/auto, or proxium/code for the code tier.`
+		};
+		case "hermes": return {
+			file: "hermes-proxium",
+			envVar: "PROXIUM_API_KEY",
+			command: [
+				"hermes",
+				"--provider",
+				"proxium",
+				"-m",
+				"auto"
+			],
+			comment
+		};
+		case "pi": return {
+			file: "pi-proxium",
+			envVar: "PROXIUM_API_KEY",
+			command: [
+				"pi",
+				"--provider",
+				"proxium",
+				"--model",
+				"auto"
+			],
+			comment
+		};
+		default: return;
+	}
+}
+/** The app name in the log of Proxium for each tool (the header x-proxium-source). */
+const APP_OF = {
+	claude: "claude-code",
+	opencode: "opencode",
+	pi: "pi",
+	hermes: "hermes"
+};
+const shq = (w) => `'${w.replace(/'/g, `'\\''`)}'`;
+/** `claude-proxium`: Claude Code through Proxium with the login of `proxium login` (`proxium launch claude`). */
+function claudeLauncher(self, project) {
+	return [
+		"#!/bin/sh",
+		`# claude-code through Proxium, project ${project}. Written by proxium login.`,
+		"# Claude Code runs proxium token for its key, so this file holds no key.",
+		"# Any Proxium model works: ANTHROPIC_MODEL=openrouter/anthropic/claude-sonnet-5.5 claude-proxium",
+		`exec ${self.map(shq).join(" ")} launch claude -- "$@"`,
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/cli/provision.ts
+var Api = class Api {
+	server;
+	jwt;
+	f;
+	constructor(server, jwt, f) {
+		this.server = server;
+		this.jwt = jwt;
+		this.f = f;
+	}
+	/** Trades the session token of the device login for the token that the gateway checks. */
+	static async open(server, session, f) {
+		const r = await f(`${server}/api/auth/token`, { headers: {
+			authorization: `Bearer ${session}`,
+			"user-agent": "proxium-cli"
+		} });
+		const j = await r.json().catch(() => ({}));
+		if (!r.ok || !j.token) throw new Error(`the server gave no token for this login (${r.status})`);
+		return new Api(server, j.token, f);
+	}
+	async call(method, path, body) {
+		const r = await this.f(`${this.server}${path}`, {
+			method,
+			headers: {
+				authorization: `Bearer ${this.jwt}`,
+				"user-agent": "proxium-cli",
+				...body === void 0 ? {} : { "content-type": "application/json" }
+			},
+			...body === void 0 ? {} : { body: JSON.stringify(body) }
+		});
+		return {
+			status: r.status,
+			json: await r.json().catch(() => ({}))
+		};
+	}
+};
+const slugOf = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "host";
+/** The project to use: the one named, a new one, or the only one the person has. */
+async function chooseProject(api, me, named) {
+	const projects = me.projects ?? [];
+	const want = named?.trim();
+	if (want) {
+		const found = projects.find((p) => p.tenant_slug === want || p.display_name.toLowerCase() === want.toLowerCase());
+		if (found) return {
+			project: found,
+			created: false
+		};
+		return {
+			project: await createProject(api, want),
+			created: true
+		};
+	}
+	if (projects.length === 1 && projects[0]) return {
+		project: projects[0],
+		created: false
+	};
+	if (projects.length === 0) return {
+		project: await createProject(api, "development"),
+		created: true
+	};
+	throw new Error(`you have ${projects.length} projects (${projects.map((p) => p.tenant_slug).join(", ")}). Run proxium login --project NAME`);
+}
+async function createProject(api, name) {
+	const r = await api.call("POST", "/api/teams", { name });
+	if (r.status >= 300 || !r.json.tenant_slug) throw new Error(`the project ${name} was not created (${r.status}): ${r.json.error?.message ?? "no reason given"}`);
+	return {
+		tenant_slug: r.json.tenant_slug,
+		display_name: r.json.display_name ?? name
+	};
+}
+function secretIn(value) {
+	if (typeof value === "string") return void 0;
+	if (Array.isArray(value)) return value.map(secretIn).find(Boolean);
+	if (value && typeof value === "object") for (const [k, v] of Object.entries(value)) {
+		if (typeof v === "string" && [
+			"key",
+			"secret",
+			"api_key",
+			"token"
+		].includes(k) && v.length > 20) return v;
+		const inner = secretIn(v);
+		if (inner) return inner;
+	}
+}
+async function provision(ctx, deps = {}) {
+	const out = [];
+	const { host, say } = ctx;
+	const api = await Api.open(ctx.server, ctx.session, ctx.fetch);
+	const me = (await api.call("GET", "/api/me")).json;
+	const { project, created } = await chooseProject(api, me, ctx.flags.project);
+	const slug = project.tenant_slug;
+	out.push(`proxium: ${created ? "created" : "using"} the project ${project.display_name} (${slug})`);
+	writeSettings(host, { project: slug });
+	const readiness = async () => (await api.call("GET", `/api/teams/${slug}/readiness`)).json.readiness?.can_route === true;
+	if (!await readiness()) {
+		if (me.is_admin && !ctx.flags["no-grant"]) {
+			for (const what of ["platform-pool", "platform-classifier"]) await api.call("PUT", `/provision/teams/${slug}/${what}`, { granted: true });
+			out.push("proxium: you are the operator, so the project may use the platform keys and the platform classifier");
+		}
+		if (!await readiness()) out.push(`proxium: ${slug} cannot route yet. Add a vendor and a key of your own, or ask the operator to allow the platform pool.`);
+	}
+	const existing = new Set((await api.call("GET", `/api/teams/${slug}/api-endpoints`)).json.endpoints?.map((e) => e.name) ?? []);
+	const tag = slugOf((deps.hostname ?? hostname)());
+	const binDir = deps.binDir ?? join(host.home, ".local", "bin");
+	const made = [];
+	const provided = [];
+	const self = deps.self ?? stableSelf(host, process.execPath, process.argv[1]);
+	const providerOf = (app, key) => ({
+		name: "proxium",
+		label: "Proxium",
+		baseUrl: `${ctx.server}/v1`,
+		keyEnv: "PROXIUM_API_KEY",
+		...key ? {
+			keyCommand: key.command,
+			keyCommandJson: key.json
+		} : {},
+		headers: {
+			"x-proxium-source": app,
+			"x-proxium-project": slug
+		},
+		models: [{
+			id: "auto",
+			label: "Proxium auto (the classifier decides)"
+		}, {
+			id: "code",
+			label: "Proxium code tier"
+		}],
+		defaultModel: "auto"
+	});
+	for (const client of ctx.clients) {
+		const app = APP_OF[client.id];
+		if (!app) continue;
+		if (client.id === "claude") {
+			host.write(join(binDir, "claude-proxium"), claudeLauncher(self, slug), { mode: 493 });
+			out.push("claude-code: start it with claude-proxium. It uses your login, and keeps no key");
+			made.push(app);
+			continue;
+		}
+		const launcher = launcherFor(client.id, ctx.server, slug, app);
+		if (!launcher) continue;
+		if (client.takesKeyCommand?.(host)) {
+			if (client.addProvider) {
+				const o = client.addProvider(host, providerOf(app, {
+					command: tokenCommand(self),
+					json: tokenCommand(self, "--json")
+				}));
+				out.push(o.message);
+				if (o.ok) provided.push(client);
+			}
+			host.write(join(binDir, launcher.file), loginLauncher(launcher), { mode: 493 });
+			out.push(`${app}: start it with ${launcher.file}. It uses your login, and keeps no key`);
+			made.push(app);
+			continue;
+		}
+		const secretName = `personal/${slug}/prod/PROXIUM_API_KEY_${app.toUpperCase().replace(/-/g, "_")}`;
+		const file = join(host.home, ".config", "proxium", slug, `${app}.key`);
+		let where = keptBefore(host, secretName, file);
+		let fresh;
+		if (!where) {
+			let name = `${app}-${tag}`;
+			for (let n = 2; existing.has(name); n++) name = `${app}-${tag}-${n}`;
+			const r = await api.call("POST", `/api/teams/${slug}/api-endpoints`, { name });
+			fresh = secretIn(r.json);
+			if (r.status >= 300 || !fresh) {
+				out.push(`${app}: no key was made (${r.status})`);
+				continue;
+			}
+			existing.add(name);
+			where = saveSecret(fresh, {
+				name: secretName,
+				file,
+				description: `Proxium virtual key of the app ${app} in the project ${slug}`,
+				host
+			});
+			out.push(`${app}: made the key ${name}, kept in ${where.kind === "sealkeep" ? `sealkeep (${where.name})` : `${where.path} (only you can read it)`}`);
+		} else out.push(`${app}: the key is kept already (${where.kind === "sealkeep" ? where.name : where.path})`);
+		if (client.addProvider) {
+			const o = client.addProvider(host, providerOf(app));
+			out.push(o.message);
+			if (o.ok) provided.push(client);
+		}
+		const path = join(binDir, launcher.file);
+		host.write(path, launchScript(where, launcher.envVar, launcher.command, launcher.comment), { mode: 493 });
+		out.push(`${app}: start it with ${launcher.file}`);
+		if (fresh) {
+			const r = await ctx.fetch(`${ctx.server}/v1/chat/completions`, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${fresh}`,
+					"content-type": "application/json",
+					"x-proxium-source": app,
+					"user-agent": "proxium-cli"
+				},
+				body: JSON.stringify({
+					model: "auto",
+					messages: [{
+						role: "user",
+						content: "Reply with one word: ok"
+					}],
+					max_tokens: 8
+				})
+			}).catch(() => void 0);
+			out.push(r?.ok ? `${app}: a call through Proxium answered` : `${app}: a test call did not answer (${r?.status ?? "no answer"})`);
+		}
+		made.push(app);
+	}
+	if (made.length) say("");
+	return out;
+}
+/** The launcher of a tool that runs `proxium token` itself: its command, with no key in its environment. */
+function loginLauncher(l) {
+	const q = (w) => /^[A-Za-z0-9_./:=@%+-]+$/.test(w) ? w : `'${w.replace(/'/g, `'\\''`)}'`;
+	return [
+		"#!/bin/sh",
+		...l.comment.split("\n").map((c) => `# ${c}`),
+		"# It runs proxium token for its key, so this file holds no key.",
+		`exec ${l.command.map(q).join(" ")} "$@"`,
+		""
+	].join("\n");
+}
+/** The place where an earlier login kept the key of an app, or undefined. */
+function keptBefore(host, name, file) {
+	if (host.read(file)?.trim()) return {
+		kind: "file",
+		path: file
+	};
+	const r = host.run("sealkeep", ["list", name]);
+	return r.code === 0 && r.stdout.includes(name) ? {
+		kind: "sealkeep",
+		name
+	} : void 0;
+}
+//#endregion
+//#region src/cli/proxium.ts
+/** What `proxium login` is: the shared login of `@munhq/mcp-kit/cli`, with Proxium's own step. */
+const PROXIUM = {
+	name: "proxium",
+	server: "https://proxium.tech",
+	clientId: "proxium-cli",
+	registerClient: true,
+	options: {
+		project: {
+			type: "string",
+			help: "the project to set up: its name or slug, or a new name to create it"
+		},
+		"no-grant": {
+			type: "boolean",
+			help: "do not allow the platform keys and classifier, even for the operator"
+		}
+	},
+	afterApproval: (ctx) => provision(ctx)
+};
+//#endregion
+//#region src/cli/main.ts
+const USAGE = `The commands:
+  proxium login            sign in, and set up the AI tools on this machine
+  proxium token            print a fresh token of your login, for a tool's key
+                           (--json: for Hermes; --header: as {"Authorization": "Bearer ..."})
+  proxium launch <tool>    start a tool through Proxium with your login (proxium launch --help)
+`;
+/** `proxium token`: the bare token, or with `--json` or `--header` the form that a tool reads. */
+function token(args) {
+	const format = args[0] === "--json" ? "json" : args[0] === "--header" ? "header" : "token";
+	return runToken(PROXIUM, { format });
+}
+const [command, ...rest] = process.argv.slice(2);
+if (command === "login" || command === void 0) process.exit(await runLogin(PROXIUM, command === "login" ? rest : []));
+if (command === "token") process.exit(await token(rest));
+if (command === "launch") process.exit(runLaunch(rest));
+if (command === "--help" || command === "help") {
+	process.stdout.write(USAGE);
+	process.exit(0);
+}
+process.stderr.write(`proxium: unknown command ${command}.\n${USAGE}`);
+process.exit(2);
+//#endregion
+export {};