onepatch 0.3.0 → 0.5.0

package/README.md

@@ -2,13 +2,16 @@
 
 The [OnePatch](https://onepatch.dev) CLI. Query your telemetry, read and reply to agent chats, and inspect incidents from a terminal or from a coding agent. It speaks to the same MCP endpoint the product serves at `/mcp`, so it has exact functional parity with connecting an MCP client.
 
-Requires [Bun](https://bun.sh).
-
 ```sh
-bun install -g onepatch   # or: npm install -g onepatch
+npm install -g onepatch      # needs Node
+# or, without Node:
+curl -fsSL https://releases.onepatch.dev/install.sh | sh
+
 onepatch login
 ```
 
+The CLI is a single self-contained binary (compiled with Bun, so Bun is not needed). `npm install -g onepatch` installs a small Node launcher that fetches the binary for your platform from `https://releases.onepatch.dev/v<version>/` and verifies its SHA-256 against the checksum shipped inside the package; the installer script does the same without Node. Releases carry binaries for macOS (arm64, x64), Linux (x64, arm64), and Windows (x64).
+
 `login` uses a device flow: it prints a URL, you approve in the browser, and credentials land in `~/.config/onepatch/credentials.json` (0600). Tokens refresh automatically.
 
 ## Commands
@@ -27,13 +30,19 @@ onepatch incidents read <num> [--raw]
 
 onepatch tools     # list the server's MCP tools
 onepatch whoami
+
+onepatch install   # wire this machine's coding agents (Claude Code, Codex, Cursor)
 ```
 
 Pass `-` to read SQL or message text from stdin. `--json` prints raw MCP content blocks. `--api <url>` (or `ONEPATCH_API_URL`) targets a different deployment.
 
+## Coding agents
+
+`onepatch install` detects Claude Code, Codex, and Cursor and wires each one to OnePatch: the OnePatch plugin (a skill that teaches the agent the tools above) plus the remote MCP server, discovered from the deployment's `/.well-known/onepatch-cli`. It is idempotent — re-run it any time to repair or upgrade. Target one agent with `onepatch install <claude|codex|cursor>`, or install by hand from [claude-code-plugin](https://github.com/1patch/claude-code-plugin), [codex-plugin](https://github.com/1patch/codex-plugin), or [cursor-plugin](https://github.com/1patch/cursor-plugin).
+
 ## Updates
 
-The CLI keeps itself current. Once a day, in a detached background process, it asks the npm registry for the latest version; when one exists it reinstalls itself through whichever package manager owns the copy (bun or npm) and prints a one-line notice to stderr. The command you typed is never delayed and never fails because of update machinery. Set `ONEPATCH_NO_UPDATE=1` to disable it, or run `onepatch update` to update on demand. Running from a source checkout never auto-updates.
+The CLI keeps itself current. Once a day, in a detached background process, it asks the npm registry for the latest version; when one exists it either reinstalls itself through the package manager that owns the copy (npm or bun) or, for a standalone binary, downloads the new release, verifies it, and swaps it in place. It prints a one-line notice to stderr. The command you typed is never delayed and never fails because of update machinery. Set `ONEPATCH_NO_UPDATE=1` to disable it, or run `onepatch update` to update on demand. Running from a source checkout never auto-updates. Self-update of a standalone binary isn't available on Windows yet; re-run the installer there.
 
 ## Programmatic use
 
@@ -47,4 +56,4 @@ const digest = await op.chats.start("investigate the p95 spike on /checkout");
 await op.close();
 ```
 
-All methods return the same plain-text digests the MCP tools produce. `op.call(name, args)` reaches any tool directly.
+All methods return the same plain-text digests the MCP tools produce. `op.call(name, args)` reaches any tool directly. The programmatic API runs under Bun (it imports the TypeScript sources shipped in the package) and needs `@modelcontextprotocol/sdk` installed alongside; the CLI itself has no dependencies.

package/bin/onepatch.cjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+// The npm package's entry point. It is a launcher, not the CLI: it finds (or
+// fetches) the prebuilt onepatch binary for this machine and hands over to
+// it. Plain Node, no dependencies, so `npm install -g onepatch` needs nothing
+// but Node. The binary is downloaded from the release host
+// (https://releases.onepatch.dev/v<version>/) that matches this package's
+// version and verified against the SHA-256 recorded in checksums.json at
+// publish time, so npm's integrity check on this package extends to the
+// binary it fetches.
+"use strict";
+
+const { spawnSync, spawn } = require("node:child_process");
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const root = path.join(__dirname, "..");
+const pkg = require(path.join(root, "package.json"));
+const RELEASE_BASE = process.env.ONEPATCH_RELEASE_BASE || "https://releases.onepatch.dev";
+
+function releaseTarget(platform = process.platform, arch = process.arch) {
+	const osName =
+		platform === "darwin"
+			? "darwin"
+			: platform === "linux"
+				? "linux"
+				: platform === "win32"
+					? "windows"
+					: null;
+	if (osName === null || (arch !== "x64" && arch !== "arm64")) return null;
+	if (osName === "windows" && arch !== "x64") return null;
+	return `${osName}-${arch}`;
+}
+
+function assetName(target) {
+	return `onepatch-${target}.tar.gz`;
+}
+
+function assetUrl(version, target, base = RELEASE_BASE) {
+	return `${base}/v${version}/${assetName(target)}`;
+}
+
+function binaryName(target) {
+	return target.startsWith("windows") ? "onepatch.exe" : "onepatch";
+}
+
+function sha256(buffer) {
+	return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+function readChecksums() {
+	try {
+		return JSON.parse(fs.readFileSync(path.join(root, "checksums.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+// Where the binary lives once fetched. The package's own vendor/ directory is
+// preferred (postinstall fills it, uninstall removes it); a per-user cache is
+// the fallback when the package directory isn't writable at run time.
+function vendorDir() {
+	return path.join(root, "vendor");
+}
+function cacheDir() {
+	const base = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+	return path.join(base, "onepatch", "bin", pkg.version);
+}
+
+function findBinary(target) {
+	if (process.env.ONEPATCH_BIN) return process.env.ONEPATCH_BIN;
+	for (const dir of [vendorDir(), cacheDir()]) {
+		const candidate = path.join(dir, binaryName(target));
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+
+async function download(url) {
+	const res = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(120_000) });
+	if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+	return Buffer.from(await res.arrayBuffer());
+}
+
+// Fetch, verify, and unpack the binary into `dir`. Staged in a sibling
+// directory and renamed in, so a concurrent launcher never sees a half-written
+// file.
+async function fetchBinary(target, dir, { quiet } = {}) {
+	const checksums = readChecksums();
+	const expected = checksums?.[target];
+	if (!expected) {
+		throw new Error(
+			`this onepatch package carries no checksum for ${target}; refusing to download`,
+		);
+	}
+	if (!quiet) process.stderr.write(`Downloading onepatch ${pkg.version} for ${target}…\n`);
+	const tarball = await download(assetUrl(pkg.version, target));
+	const actual = sha256(tarball);
+	if (actual !== expected) {
+		throw new Error(
+			`checksum mismatch for ${assetName(target)}: expected ${expected}, got ${actual}`,
+		);
+	}
+	fs.mkdirSync(dir, { recursive: true });
+	const stage = fs.mkdtempSync(path.join(dir, ".stage-"));
+	try {
+		const archive = path.join(stage, assetName(target));
+		fs.writeFileSync(archive, tarball);
+		const tar = spawnSync("tar", ["-xzf", archive, "-C", stage], { stdio: "ignore" });
+		if (tar.status !== 0) throw new Error("tar failed to extract the onepatch archive");
+		const bin = path.join(stage, binaryName(target));
+		fs.chmodSync(bin, 0o755);
+		fs.renameSync(bin, path.join(dir, binaryName(target)));
+	} finally {
+		fs.rmSync(stage, { recursive: true, force: true });
+	}
+	return path.join(dir, binaryName(target));
+}
+
+async function ensureBinary(target, opts) {
+	const found = findBinary(target);
+	if (found) return found;
+	try {
+		return await fetchBinary(target, vendorDir(), opts);
+	} catch (err) {
+		if (err && err.code !== "EACCES" && err.code !== "EPERM" && err.code !== "EROFS") throw err;
+		return await fetchBinary(target, cacheDir(), opts);
+	}
+}
+
+function isSourceCheckout() {
+	return (
+		fs.existsSync(path.join(root, "src", "cli.ts")) &&
+		!fs.existsSync(path.join(root, "checksums.json"))
+	);
+}
+
+async function main(argv) {
+	const args = argv.slice(2);
+
+	// npm's postinstall: prefetch so the first real invocation is instant.
+	// Never fail the install over it — the launcher fetches on demand anyway.
+	if (args[0] === "--postinstall") {
+		if (isSourceCheckout()) return 0;
+		const target = releaseTarget();
+		if (target === null) return 0;
+		try {
+			await ensureBinary(target, { quiet: true });
+		} catch (err) {
+			process.stderr.write(
+				`onepatch: could not prefetch the binary (${err.message}); it will download on first use.\n`,
+			);
+		}
+		return 0;
+	}
+
+	// A developer's checkout: run the sources under Bun, like before.
+	if (isSourceCheckout()) {
+		const run = spawnSync("bun", [path.join(root, "src", "cli.ts"), ...args], { stdio: "inherit" });
+		return run.status === null ? 1 : run.status;
+	}
+
+	const target = releaseTarget();
+	if (target === null) {
+		process.stderr.write(`onepatch: no prebuilt binary for ${process.platform}/${process.arch}.\n`);
+		return 1;
+	}
+
+	let bin = findBinary(target);
+	if (bin === null) {
+		// Hooks run on every agent prompt and must never wait on a download:
+		// fetch in the background and inject nothing this time.
+		if (args[0] === "hook") {
+			spawn(process.execPath, [__filename, "--postinstall"], {
+				detached: true,
+				stdio: "ignore",
+			}).unref();
+			return 0;
+		}
+		bin = await ensureBinary(target);
+	}
+
+	const run = spawnSync(bin, args, { stdio: "inherit" });
+	if (run.error) throw run.error;
+	if (run.signal) {
+		process.kill(process.pid, run.signal);
+		return 1;
+	}
+	return run.status === null ? 1 : run.status;
+}
+
+module.exports = { releaseTarget, assetName, assetUrl, binaryName, sha256 };
+
+if (require.main === module) {
+	main(process.argv).then(
+		(code) => process.exit(code),
+		(err) => {
+			process.stderr.write(`onepatch: ${err?.message ?? err}\n`);
+			process.exit(1);
+		},
+	);
+}

package/checksums.json

@@ -0,0 +1,7 @@
+{
+  "darwin-arm64": "3fa7a51e2e5972cc804251700d380c990fb3b5f3dab340a7aa6ba716279ece64",
+  "darwin-x64": "6de2f3ba8420633b5d0f08164e3d1c4d370ea85c7d228f95ead4592420458397",
+  "linux-arm64": "fc535ba8717d073a12e7668516fad6a584289bf9968d65aaa47cfeb4474cad9e",
+  "linux-x64": "7600a66ca84211a81dafcf054fd4ed5ea29e751bf394735eb170779b6d2672dc",
+  "windows-x64": "e60500b926849a64fb38315fed258aa860e673b92b69f7e5ce7dc8bbe006c326"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onepatch",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "OnePatch CLI: query your telemetry, chats, and incidents from a terminal or a coding agent",
   "license": "MIT",
   "homepage": "https://onepatch.dev",
@@ -11,34 +11,58 @@
   "bugs": {
     "url": "https://github.com/1patch/cli/issues"
   },
-  "keywords": ["onepatch", "observability", "sre", "cli", "mcp", "opentelemetry"],
+  "keywords": [
+    "onepatch",
+    "observability",
+    "sre",
+    "cli",
+    "mcp",
+    "opentelemetry"
+  ],
   "type": "module",
   "bin": {
-    "onepatch": "./src/cli.ts"
+    "onepatch": "./bin/onepatch.cjs"
   },
   "exports": {
     ".": "./src/index.ts"
   },
-  "files": ["src", "README.md", "LICENSE"],
+  "files": [
+    "bin",
+    "src",
+    "!src/*.test.ts",
+    "checksums.json",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
-    "bun": ">=1.1.0"
+    "node": ">=18"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "postinstall": "node bin/onepatch.cjs --postinstall",
+    "build": "scripts/build-binaries.sh",
+    "mirror": "scripts/mirror-plugins.sh",
     "typecheck": "tsgo --noEmit -p tsconfig.json",
     "test": "bun test",
     "fmt": "biome check --write .",
-    "check": "biome ci . && bun run typecheck && bun test"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "check": "biome ci . && bun run typecheck && bun test",
+    "mirror": "scripts/mirror-plugins.sh"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.8",
     "@types/bun": "^1.3.14",
     "@typescript/native-preview": "^7.0.0-dev.20260506.1",
-    "typescript": "^5.5.0"
+    "typescript": "^5.5.0",
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    }
   }
 }

package/src/cli.ts

@@ -6,6 +6,8 @@ import { decodeJwtClaims, getValidAccessToken } from "./auth";
 import { OnepatchClient } from "./client";
 import { fetchBootstrap, resolveApiUrl } from "./config";
 import { deleteCredentials, loadCredentials, saveCredentials } from "./credentials";
+import { runHook } from "./hook";
+import { runInstall } from "./install";
 import { currentVersion, maybeAutoUpdate, runUpdate } from "./update";
 import { pollForDeviceToken, startDeviceAuthorization } from "./workos";
 
@@ -30,6 +32,11 @@ Usage:
   onepatch incidents read <num> [--raw]   Read one incident by number
 
   onepatch tools                      List the server's MCP tools
+  onepatch hook user-prompt-submit    Agent-hook injector (wired by the plugins; reads
+                                      the event on stdin, prints context to inject)
+  onepatch install [claude|codex|cursor]
+                                      Wire this machine's coding agents to OnePatch
+                                      (plugins + MCP server; no argument = all detected)
   onepatch update                     Update the CLI to the latest version now
 
 Global flags:
@@ -136,6 +143,10 @@ async function main(): Promise<void> {
 			// Internal: `onepatch update --check` only refreshes the cached
 			// latest-version state; the background updater spawns it.
 			check: { type: "boolean", default: false },
+			// Internal: `onepatch hook --refresh` repopulates the hook cache; the
+			// foreground hook invocation spawns it detached.
+			refresh: { type: "boolean", default: false },
+			agent: { type: "string" },
 		},
 	});
 
@@ -150,6 +161,10 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	// Hooks fire on every prompt, so they skip even the auto-update file read
+	// and must never write anything but their injection to stdout.
+	if (noun === "hook") return await runHook(resolveApiUrl(flags.api), verb, flags.refresh);
+
 	if (noun === "update") return await runUpdate({ checkOnly: flags.check });
 	// Every other command triggers the zero-cost background update pass.
 	maybeAutoUpdate();
@@ -157,6 +172,7 @@ async function main(): Promise<void> {
 	const api = resolveApiUrl(flags.api);
 
 	if (noun === "login") return await login(api);
+	if (noun === "install") return await runInstall(api, verb);
 	if (noun === "logout") {
 		console.log(deleteCredentials(api) ? `Logged out of ${api}.` : `No credentials for ${api}.`);
 		return;

package/src/hook.ts

@@ -0,0 +1,108 @@
+// `onepatch hook user-prompt-submit` — the example agent-hook injector the
+// plugins wire up (UserPromptSubmit in Claude Code and Codex). Whatever this
+// prints to stdout is injected into the agent's context for the turn, so the
+// contract is strict: never block the user's prompt (no foreground network —
+// serve from a cache, refresh detached, like update.ts) and never break it
+// (any failure means print nothing and exit 0).
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { OnepatchClient } from "./client";
+import { configDir, ensureConfigDir, loadCredentials } from "./credentials";
+import { selfCommand } from "./runtime";
+
+export const HOOK_CACHE_TTL_MS = 5 * 60 * 1000;
+// A refresh normally lands in seconds; this only bounds how long a failed one
+// suppresses retries.
+const REFRESH_RETRY_MS = 2 * 60 * 1000;
+
+export type HookCache = {
+	fetchedAt?: number;
+	refreshStartedAt?: number;
+	// The context line to inject; "" means "healthy, nothing worth injecting".
+	line?: string;
+};
+
+export function hookCachePath(): string {
+	return join(configDir(), "hook-status.json");
+}
+
+export function readHookCache(): HookCache {
+	try {
+		return JSON.parse(readFileSync(hookCachePath(), "utf8")) as HookCache;
+	} catch {
+		return {};
+	}
+}
+
+export function writeHookCache(cache: HookCache): void {
+	ensureConfigDir();
+	writeFileSync(hookCachePath(), `${JSON.stringify(cache)}\n`);
+}
+
+export type HookAction = { emit: string; refresh: boolean };
+
+// Pure decision: what to print and whether to kick a background refresh.
+// A stale line still gets emitted — slightly old incident context beats none,
+// and the refresh makes the next prompt current.
+export function decideHookAction(cache: HookCache, now: number): HookAction {
+	const fresh = cache.fetchedAt !== undefined && now - cache.fetchedAt < HOOK_CACHE_TTL_MS;
+	const refreshInFlight =
+		cache.refreshStartedAt !== undefined && now - cache.refreshStartedAt < REFRESH_RETRY_MS;
+	return { emit: cache.line ?? "", refresh: !fresh && !refreshInFlight };
+}
+
+// Compress the list_incidents digest into one context line. The digest leads
+// with "<N> open incidents · …" and lists one incident per line
+// ("INC-193 · P2 · waiting on human · <title> · updated <ts>"); we keep the
+// count and the two newest rows, minus the updated-at tail.
+export function buildContextLine(incidentsText: string): string {
+	const lines = incidentsText.split("\n").map((l) => l.trim());
+	const rows = lines
+		.filter((l) => /^INC-\d+ · /.test(l))
+		.map((l) => l.replace(/ · updated \S+$/, ""));
+	const count = Number(lines[0]?.match(/^(\d+) open incident/)?.[1] ?? rows.length);
+	if (count === 0 || rows.length === 0) return "";
+	const shown = rows.slice(0, 2).join("; ");
+	return (
+		`[onepatch] ${count} open incident${count === 1 ? "" : "s"} — newest: ${shown}. ` +
+		"Details: the onepatch MCP tools or `onepatch incidents read <num>`."
+	);
+}
+
+async function refreshHookCache(api: string): Promise<void> {
+	const client = new OnepatchClient({ api });
+	try {
+		const text = await client.incidents.list({ scope: "open", limit: 10 });
+		writeHookCache({ fetchedAt: Date.now(), line: buildContextLine(text) });
+	} finally {
+		await client.close();
+	}
+}
+
+export async function runHook(api: string, event: string | undefined, refresh: boolean) {
+	if (refresh) {
+		// Internal mode spawned below; errors just leave the stale cache in place.
+		try {
+			await refreshHookCache(api);
+		} catch {}
+		return;
+	}
+	if (event !== "user-prompt-submit") return; // unknown events inject nothing
+	// Hooks pipe the event payload on stdin; drain it so the agent never sees
+	// a broken pipe, but nothing in it changes what we inject.
+	try {
+		await Bun.stdin.text();
+	} catch {}
+	if (!loadCredentials(api)) return; // not logged in — stay silent
+	const action = decideHookAction(readHookCache(), Date.now());
+	if (action.refresh) {
+		writeHookCache({ ...readHookCache(), refreshStartedAt: Date.now() });
+		Bun.spawn({
+			cmd: selfCommand(["hook", "--refresh", "--api", api]),
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+		}).unref();
+	}
+	if (action.emit !== "") console.log(action.emit);
+}

package/src/install.ts

@@ -0,0 +1,150 @@
+// `onepatch install [claude|codex|cursor]` — wire this machine's coding
+// agents to OnePatch. The plugins themselves are thin (skills + MCP pointers,
+// published from plugins/ in this repo); this command only does the local
+// wiring each agent needs, and every step is idempotent so re-running is
+// always repair, never damage.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fetchBootstrap } from "./config";
+
+export const AGENTS = ["claude", "codex", "cursor"] as const;
+export type AgentName = (typeof AGENTS)[number];
+
+const CLAUDE_MARKETPLACE_REPO = "1patch/claude-code-plugin";
+const CODEX_MARKETPLACE_REPO = "1patch/codex-plugin";
+const CURSOR_PLUGIN_URL = "https://github.com/1patch/cursor-plugin";
+
+// --- pure decision helpers (unit-tested) ---
+
+// Append an `[mcp_servers.onepatch]` block to Codex's config.toml unless one
+// already exists. A string scan, not a TOML parser: the only claim we make is
+// "a block with this exact header is present", and rewriting a user's config
+// through a parser risks clobbering formatting and comments.
+export function ensureCodexMcpServer(
+	toml: string,
+	mcpUrl: string,
+): { changed: boolean; text: string } {
+	if (/^\s*\[mcp_servers\.onepatch\]/m.test(toml)) return { changed: false, text: toml };
+	const block = `[mcp_servers.onepatch]\nurl = "${mcpUrl}"\n`;
+	const sep = toml === "" || toml.endsWith("\n\n") ? "" : toml.endsWith("\n") ? "\n" : "\n\n";
+	return { changed: true, text: `${toml}${sep}${block}` };
+}
+
+// Merge the onepatch server into Cursor's mcp.json, preserving everything
+// else. `null` means the file doesn't exist yet.
+export function ensureCursorMcpServer(
+	json: string | null,
+	mcpUrl: string,
+): { changed: boolean; text: string } {
+	let doc: { mcpServers?: Record<string, unknown> };
+	try {
+		doc = json === null ? {} : (JSON.parse(json) as typeof doc);
+	} catch {
+		throw new Error("~/.cursor/mcp.json exists but is not valid JSON; fix it and re-run.");
+	}
+	const servers = doc.mcpServers ?? {};
+	if (servers.onepatch !== undefined) return { changed: false, text: json ?? "" };
+	doc.mcpServers = { ...servers, onepatch: { url: mcpUrl } };
+	return { changed: true, text: `${JSON.stringify(doc, null, 2)}\n` };
+}
+
+export function detectAgents(home: string = homedir()): AgentName[] {
+	const found: AgentName[] = [];
+	if (Bun.which("claude")) found.push("claude");
+	if (Bun.which("codex") || existsSync(join(home, ".codex"))) found.push("codex");
+	if (Bun.which("cursor-agent") || existsSync(join(home, ".cursor"))) found.push("cursor");
+	return found;
+}
+
+// --- IO ---
+
+async function run(cmd: string[]): Promise<boolean> {
+	console.log(`  $ ${cmd.join(" ")}`);
+	const proc = Bun.spawn({ cmd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+	return (await proc.exited) === 0;
+}
+
+function upsertFile(path: string, next: string): void {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, next);
+}
+
+async function installClaude(): Promise<void> {
+	if (!Bun.which("claude")) {
+		console.log("claude: CLI not on PATH — install Claude Code first, then re-run.");
+		return;
+	}
+	console.log("claude: installing the OnePatch plugin (marketplace + plugin)…");
+	// The marketplace add fails harmlessly if it's already known; the install
+	// refreshes the marketplace itself, so together these double as upgrade.
+	await run(["claude", "plugin", "marketplace", "add", CLAUDE_MARKETPLACE_REPO]);
+	if (await run(["claude", "plugin", "install", "onepatch@onepatch"])) {
+		console.log("claude: done. Authenticate the onepatch MCP server via /mcp on first use.");
+	} else {
+		console.log(
+			`claude: plugin install failed — run \`claude plugin marketplace add ${CLAUDE_MARKETPLACE_REPO}\` and \`claude plugin install onepatch@onepatch\` by hand to see why.`,
+		);
+	}
+}
+
+async function installCodex(mcpUrl: string, home: string): Promise<void> {
+	const configPath = join(home, ".codex", "config.toml");
+	const current = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+	const result = ensureCodexMcpServer(current, mcpUrl);
+	if (result.changed) {
+		upsertFile(configPath, result.text);
+		console.log(`codex: added [mcp_servers.onepatch] to ${configPath}.`);
+	} else {
+		console.log("codex: MCP server already configured.");
+	}
+	if (Bun.which("codex")) {
+		console.log("codex: installing the OnePatch plugin (skills)…");
+		await run(["codex", "plugin", "marketplace", "add", CODEX_MARKETPLACE_REPO]);
+		await run(["codex", "plugin", "install", "onepatch/onepatch"]);
+	}
+	console.log("codex: sign in with `codex mcp login onepatch` on first use.");
+}
+
+async function installCursor(mcpUrl: string, home: string): Promise<void> {
+	const mcpPath = join(home, ".cursor", "mcp.json");
+	const current = existsSync(mcpPath) ? readFileSync(mcpPath, "utf8") : null;
+	const result = ensureCursorMcpServer(current, mcpUrl);
+	if (result.changed) {
+		upsertFile(mcpPath, result.text);
+		console.log(`cursor: added the onepatch MCP server to ${mcpPath}.`);
+	} else {
+		console.log("cursor: MCP server already configured.");
+	}
+	console.log(
+		`cursor: for the skill + rules, run \`/add-plugin ${CURSOR_PLUGIN_URL}\` in Cursor's agent chat, and log in to onepatch under Settings → MCP.`,
+	);
+}
+
+export async function runInstall(api: string, target?: string): Promise<void> {
+	if (target !== undefined && !AGENTS.includes(target as AgentName)) {
+		throw new Error(`unknown agent "${target}" — expected one of: ${AGENTS.join(", ")}`);
+	}
+	// The MCP URL is discovered, not baked in, so self-hosted deployments get
+	// wired to their own endpoint by passing --api (or ONEPATCH_API_URL).
+	let mcpUrl: string;
+	try {
+		mcpUrl = (await fetchBootstrap(api)).mcpUrl;
+	} catch {
+		mcpUrl = `${api}/mcp`;
+	}
+	const targets = target !== undefined ? [target as AgentName] : detectAgents();
+	if (targets.length === 0) {
+		console.log(
+			"No coding agents found (looked for Claude Code, Codex, Cursor). " +
+				"Pass one explicitly: onepatch install <claude|codex|cursor>.",
+		);
+		return;
+	}
+	const home = homedir();
+	for (const agent of targets) {
+		if (agent === "claude") await installClaude();
+		if (agent === "codex") await installCodex(mcpUrl, home);
+		if (agent === "cursor") await installCursor(mcpUrl, home);
+	}
+}

package/src/runtime.ts

@@ -0,0 +1,35 @@
+// Where this process's code lives and how to re-invoke it. The CLI ships two
+// ways: as a compiled Bun executable (the binary users actually run) and as
+// TypeScript sources under Bun (development, and the programmatic API). Every
+// place that needs "this program again" or "this program's version" asks here
+// instead of assuming a file layout.
+import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import pkg from "../package.json" with { type: "json" };
+
+export const VERSION: string = pkg.version;
+
+// Bun compiled executables mount their bundled sources on a virtual filesystem
+// (`/$bunfs/` on POSIX, `B:\~BUN\` on Windows); nothing else ever lives there.
+export function isCompiled(dir: string = import.meta.dir): boolean {
+	return dir.startsWith("/$bunfs/") || dir.includes("~BUN");
+}
+
+// The argv that re-runs this program with `args`, detached or not.
+export function selfCommand(args: string[], compiled: boolean = isCompiled()): string[] {
+	return compiled
+		? [process.execPath, ...args]
+		: [process.execPath, join(import.meta.dir, "cli.ts"), ...args];
+}
+
+// The path that decides who owns this install: the binary itself when
+// compiled, otherwise the package directory the sources live in. Symlinks
+// (bin shims, ~/.local/bin links) are resolved so the answer is physical.
+export function installRoot(): string {
+	const raw = isCompiled() ? process.execPath : join(import.meta.dir, "..");
+	try {
+		return realpathSync(raw);
+	} catch {
+		return raw;
+	}
+}

package/src/update.ts

@@ -2,35 +2,34 @@
 // actually typed never waits on update machinery. Each invocation reads one
 // small cached JSON file; a stale cache spawns a detached background process
 // to refresh it from the npm registry, and a cache that already names a newer
-// version spawns a detached reinstall via whichever package manager owns this
-// copy. Either way the foreground command proceeds immediately, and the next
-// invocation runs the new code.
-import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+// version spawns a detached update. Either way the foreground command proceeds
+// immediately, and the next invocation runs the new code.
+//
+// How the update lands depends on who owns this copy: a package manager (bun
+// or npm) reinstalls the package, which fetches the matching binary; a
+// standalone binary (curl installer, or a copied file) replaces itself in
+// place from the release host, after checking the tarball's SHA-256.
+//
+// The release host (https://releases.onepatch.dev) is the one source of
+// truth for "what is released": `latest` is written last by the publish job,
+// after both the binaries and the npm package exist, so a version it names
+// is always fully installable by every kind.
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, sep } from "node:path";
+import { dirname, join, sep } from "node:path";
 import { configDir, ensureConfigDir } from "./credentials";
+import { installRoot, isCompiled, selfCommand, VERSION } from "./runtime";
 
 export const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 // A spawned install normally lands in seconds; this only bounds how long a
 // *failed* install suppresses retries (and dogpiles from parallel invocations).
 export const INSTALL_RETRY_MS = 15 * 60 * 1000;
 
-const packageRoot = (() => {
-	// The bin shim is a symlink into the installed package; resolve it so the
-	// path we inspect is where the package physically lives.
-	const raw = join(import.meta.dir, "..");
-	try {
-		return realpathSync(raw);
-	} catch {
-		return raw;
-	}
-})();
+// Overridable so a release can be rehearsed end-to-end against a local server.
+export const RELEASE_BASE = process.env.ONEPATCH_RELEASE_BASE ?? "https://releases.onepatch.dev";
 
 export function currentVersion(): string {
-	const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")) as {
-		version?: unknown;
-	};
-	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+	return VERSION;
 }
 
 // Plain x.y.z compare; a prerelease suffix sorts below its release.
@@ -53,24 +52,65 @@ export function compareVersions(a: string, b: string): number {
 	return pa.pre < pb.pre ? -1 : 1;
 }
 
-export type InstallKind = "bun" | "npm";
+export type InstallKind = "bun" | "npm" | "binary";
 
-// Which package manager owns this copy — decided from where the package
-// physically lives, because that's also the only place the answer is honest.
-// null means a source checkout (dev), where auto-update must stay away.
-export function detectInstallKind(root: string = packageRoot): InstallKind | null {
+// Who owns this copy — decided from where it physically lives, because that's
+// also the only place the answer is honest. A package-manager path wins even
+// for a compiled binary (the launcher's vendored copy), so the manager stays
+// in charge of it. null means a source checkout (dev), where auto-update must
+// stay away.
+export function detectInstallKind(
+	root: string = installRoot(),
+	compiled: boolean = isCompiled(),
+): InstallKind | null {
 	const bunInstall = process.env.BUN_INSTALL ?? join(homedir(), ".bun");
 	if (root.startsWith(bunInstall + sep) || root.split(sep).includes(".bun")) return "bun";
 	if (root.split(sep).includes("node_modules")) return "npm";
-	return null;
+	return compiled ? "binary" : null;
 }
 
-export function installCommand(kind: InstallKind, version: string): string[] {
+export function installCommand(kind: "bun" | "npm", version: string): string[] {
 	return kind === "bun"
 		? ["bun", "add", "-g", `onepatch@${version}`]
 		: ["npm", "install", "-g", `onepatch@${version}`];
 }
 
+// The `<os>-<arch>` suffix of the release asset built for this machine; null
+// when no prebuilt binary exists for it.
+export function releaseTarget(
+	platform: string = process.platform,
+	arch: string = process.arch,
+): string | null {
+	const os =
+		platform === "darwin"
+			? "darwin"
+			: platform === "linux"
+				? "linux"
+				: platform === "win32"
+					? "windows"
+					: null;
+	if (os === null || (arch !== "x64" && arch !== "arm64")) return null;
+	if (os === "windows" && arch !== "x64") return null;
+	return `${os}-${arch}`;
+}
+
+export function assetName(target: string): string {
+	return `onepatch-${target}.tar.gz`;
+}
+
+export function assetUrl(version: string, target: string, base: string = RELEASE_BASE): string {
+	return `${base}/v${version}/${assetName(target)}`;
+}
+
+// The hex digest recorded for `filename` in a `sha256sum`-style listing.
+export function parseSha256Sums(listing: string, filename: string): string | null {
+	for (const line of listing.split("\n")) {
+		const m = /^([0-9a-f]{64})\s+\*?(.+)$/.exec(line.trim());
+		if (m && m[2] === filename) return m[1] ?? null;
+	}
+	return null;
+}
+
 export type UpdateState = {
 	checkedAt?: number;
 	latest?: string;
@@ -113,18 +153,62 @@ export function decideUpdateAction(state: UpdateState, current: string, now: num
 }
 
 export async function fetchLatestVersion(fetchImpl: typeof fetch = fetch): Promise<string> {
-	const res = await fetchImpl("https://registry.npmjs.org/onepatch/latest", {
+	const res = await fetchImpl(`${RELEASE_BASE}/latest`, {
 		headers: { accept: "application/json" },
 		signal: AbortSignal.timeout(10_000),
 	});
-	if (!res.ok) throw new Error(`npm registry answered ${res.status} for onepatch@latest`);
+	if (!res.ok) throw new Error(`release host answered ${res.status} for latest`);
 	const doc = (await res.json()) as { version?: unknown };
 	if (typeof doc.version !== "string") {
-		throw new Error("npm registry returned a manifest without a version");
+		throw new Error("release host returned a latest document without a version");
 	}
 	return doc.version;
 }
 
+async function fetchOk(url: string): Promise<Response> {
+	const res = await fetch(url, { signal: AbortSignal.timeout(120_000) });
+	if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+	return res;
+}
+
+// Replace the running standalone binary with the released `version`. The
+// tarball is checked against the release's SHA256SUMS before anything on disk
+// changes, staged next to the binary (same filesystem, so the final rename is
+// atomic), and swapped in with one rename. A process already running keeps
+// its old inode; the next invocation gets the new file.
+export async function replaceBinary(version: string): Promise<void> {
+	const target = releaseTarget();
+	if (target === null) {
+		throw new Error(`no prebuilt onepatch binary for ${process.platform}/${process.arch}`);
+	}
+	if (target.startsWith("windows")) {
+		throw new Error("self-update isn't available on Windows yet; re-run the installer instead");
+	}
+	const sums = await (await fetchOk(`${RELEASE_BASE}/v${version}/SHA256SUMS`)).text();
+	const expected = parseSha256Sums(sums, assetName(target));
+	if (expected === null) throw new Error(`release v${version} has no checksum for ${target}`);
+	const tarball = new Uint8Array(await (await fetchOk(assetUrl(version, target))).arrayBuffer());
+	const actual = new Bun.CryptoHasher("sha256").update(tarball).digest("hex");
+	if (actual !== expected) {
+		throw new Error(
+			`checksum mismatch for ${assetName(target)}: expected ${expected}, got ${actual}`,
+		);
+	}
+	const real = installRoot();
+	const stage = join(dirname(real), `.onepatch-update-${process.pid}`);
+	mkdirSync(stage, { recursive: true });
+	try {
+		const archive = join(stage, assetName(target));
+		writeFileSync(archive, tarball);
+		const tar = Bun.spawn({ cmd: ["tar", "-xzf", archive, "-C", stage], stdout: "ignore" });
+		if ((await tar.exited) !== 0) throw new Error("tar failed to extract the release archive");
+		chmodSync(join(stage, "onepatch"), 0o755);
+		renameSync(join(stage, "onepatch"), real);
+	} finally {
+		rmSync(stage, { recursive: true, force: true });
+	}
+}
+
 function spawnDetached(cmd: string[]): void {
 	Bun.spawn({ cmd, stdin: "ignore", stdout: "ignore", stderr: "ignore" }).unref();
 }
@@ -141,7 +225,9 @@ export function maybeAutoUpdate(): void {
 		if (action.kind === "install") {
 			// Stamp before spawning so parallel invocations don't dogpile.
 			writeUpdateState({ ...state, installStartedAt: Date.now() });
-			spawnDetached(installCommand(kind, action.latest));
+			spawnDetached(
+				kind === "binary" ? selfCommand(["update"]) : installCommand(kind, action.latest),
+			);
 			console.error(
 				`onepatch ${currentVersion()} → ${action.latest} is installing in the background ` +
 					"(ONEPATCH_NO_UPDATE=1 disables this).",
@@ -149,7 +235,7 @@ export function maybeAutoUpdate(): void {
 		} else if (action.kind === "check") {
 			// Refresh the cache off-process: `onepatch update --check` fetches the
 			// registry and writes the state file, costing this invocation nothing.
-			spawnDetached([process.execPath, join(packageRoot, "src", "cli.ts"), "update", "--check"]);
+			spawnDetached(selfCommand(["update", "--check"]));
 		}
 	} catch {
 		// Auto-update is strictly best-effort; the user's command always wins.
@@ -177,11 +263,16 @@ export async function runUpdate(opts: { checkOnly: boolean }): Promise<void> {
 		);
 		return;
 	}
-	const cmd = installCommand(kind, latest);
-	console.log(`Updating onepatch ${current} → ${latest} (${cmd.join(" ")})…`);
-	const proc = Bun.spawn({ cmd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
-	const code = await proc.exited;
-	if (code !== 0) throw new Error(`${cmd[0]} exited with code ${code}`);
+	if (kind === "binary") {
+		console.log(`Updating onepatch ${current} → ${latest} (${installRoot()})…`);
+		await replaceBinary(latest);
+	} else {
+		const cmd = installCommand(kind, latest);
+		console.log(`Updating onepatch ${current} → ${latest} (${cmd.join(" ")})…`);
+		const proc = Bun.spawn({ cmd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+		const code = await proc.exited;
+		if (code !== 0) throw new Error(`${cmd[0]} exited with code ${code}`);
+	}
 	writeUpdateState({ checkedAt: Date.now(), latest });
 	console.log(`onepatch ${latest} installed.`);
 }

package/src/credentials.test.ts

@@ -1,49 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	credentialsPath,
-	deleteCredentials,
-	loadCredentials,
-	saveCredentials,
-} from "./credentials";
-
-const CREDS = {
-	clientId: "client_01TEST",
-	accessToken: "at",
-	refreshToken: "rt",
-	email: "dev@example.com",
-};
-
-let dir: string;
-
-beforeEach(() => {
-	dir = mkdtempSync(join(tmpdir(), "onepatch-cli-test-"));
-	process.env.ONEPATCH_CONFIG_DIR = dir;
-});
-
-afterEach(() => {
-	delete process.env.ONEPATCH_CONFIG_DIR;
-	rmSync(dir, { recursive: true, force: true });
-});
-
-describe("credential store", () => {
-	test("round-trips per API base and deletes cleanly", () => {
-		expect(loadCredentials("https://a.example")).toBeNull();
-		saveCredentials("https://a.example", CREDS);
-		saveCredentials("https://b.example", { ...CREDS, email: "other@example.com" });
-		expect(loadCredentials("https://a.example")?.email).toBe("dev@example.com");
-		expect(loadCredentials("https://b.example")?.email).toBe("other@example.com");
-		expect(deleteCredentials("https://a.example")).toBe(true);
-		expect(loadCredentials("https://a.example")).toBeNull();
-		expect(loadCredentials("https://b.example")?.email).toBe("other@example.com");
-		expect(deleteCredentials("https://a.example")).toBe(false);
-	});
-
-	test("credential file is written 0600", () => {
-		saveCredentials("https://a.example", CREDS);
-		const mode = statSync(credentialsPath()).mode & 0o777;
-		expect(mode).toBe(0o600);
-	});
-});

package/src/update.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import {
-	CHECK_INTERVAL_MS,
-	compareVersions,
-	decideUpdateAction,
-	detectInstallKind,
-	fetchLatestVersion,
-	INSTALL_RETRY_MS,
-	installCommand,
-} from "./update";
-
-describe("compareVersions", () => {
-	test("orders plain versions", () => {
-		expect(compareVersions("0.2.0", "0.3.0")).toBeLessThan(0);
-		expect(compareVersions("0.3.0", "0.2.9")).toBeGreaterThan(0);
-		expect(compareVersions("1.0.0", "0.99.99")).toBeGreaterThan(0);
-		expect(compareVersions("0.2.0", "0.2.0")).toBe(0);
-	});
-
-	test("compares numerically, not lexically", () => {
-		expect(compareVersions("0.10.0", "0.9.0")).toBeGreaterThan(0);
-	});
-
-	test("prerelease sorts below its release", () => {
-		expect(compareVersions("1.0.0-beta.1", "1.0.0")).toBeLessThan(0);
-		expect(compareVersions("1.0.0", "1.0.0-rc.2")).toBeGreaterThan(0);
-	});
-
-	test("tolerates short versions", () => {
-		expect(compareVersions("1.0", "1.0.0")).toBe(0);
-		expect(compareVersions("1", "1.0.1")).toBeLessThan(0);
-	});
-});
-
-describe("decideUpdateAction", () => {
-	const now = 1_700_000_000_000;
-
-	test("empty state asks for a background check", () => {
-		expect(decideUpdateAction({}, "0.2.0", now)).toEqual({ kind: "check" });
-	});
-
-	test("fresh state with no newer version does nothing", () => {
-		expect(decideUpdateAction({ checkedAt: now - 1000, latest: "0.2.0" }, "0.2.0", now)).toEqual({
-			kind: "none",
-		});
-	});
-
-	test("stale state asks for a background check", () => {
-		expect(
-			decideUpdateAction({ checkedAt: now - CHECK_INTERVAL_MS - 1, latest: "0.2.0" }, "0.2.0", now),
-		).toEqual({ kind: "check" });
-	});
-
-	test("known newer version installs", () => {
-		expect(decideUpdateAction({ checkedAt: now, latest: "0.3.0" }, "0.2.0", now)).toEqual({
-			kind: "install",
-			latest: "0.3.0",
-		});
-	});
-
-	test("an in-flight install suppresses re-spawning", () => {
-		expect(
-			decideUpdateAction(
-				{ checkedAt: now, latest: "0.3.0", installStartedAt: now - 1000 },
-				"0.2.0",
-				now,
-			),
-		).toEqual({ kind: "none" });
-	});
-
-	test("a failed install retries after the guard window", () => {
-		expect(
-			decideUpdateAction(
-				{ checkedAt: now, latest: "0.3.0", installStartedAt: now - INSTALL_RETRY_MS - 1 },
-				"0.2.0",
-				now,
-			),
-		).toEqual({ kind: "install", latest: "0.3.0" });
-	});
-
-	test("a cached latest older than current never installs", () => {
-		expect(decideUpdateAction({ checkedAt: now, latest: "0.1.0" }, "0.2.0", now)).toEqual({
-			kind: "none",
-		});
-	});
-});
-
-describe("detectInstallKind", () => {
-	test("bun global install", () => {
-		expect(
-			detectInstallKind(join(homedir(), ".bun", "install", "global", "node_modules", "onepatch")),
-		).toBe("bun");
-	});
-
-	test("npm global install", () => {
-		expect(detectInstallKind("/usr/local/lib/node_modules/onepatch")).toBe("npm");
-	});
-
-	test("source checkout is not updatable", () => {
-		expect(detectInstallKind("/Users/someone/dev/onepatch-cli")).toBeNull();
-	});
-});
-
-describe("installCommand", () => {
-	test("pins the discovered version, not the latest tag", () => {
-		expect(installCommand("bun", "0.3.0")).toEqual(["bun", "add", "-g", "onepatch@0.3.0"]);
-		expect(installCommand("npm", "0.3.0")).toEqual(["npm", "install", "-g", "onepatch@0.3.0"]);
-	});
-});
-
-describe("fetchLatestVersion", () => {
-	test("reads the version from the registry manifest", async () => {
-		const fake = (async () => Response.json({ version: "0.4.2" })) as unknown as typeof fetch;
-		expect(await fetchLatestVersion(fake)).toBe("0.4.2");
-	});
-
-	test("rejects a manifest without a version", async () => {
-		const fake = (async () => Response.json({})) as unknown as typeof fetch;
-		await expect(fetchLatestVersion(fake)).rejects.toThrow("without a version");
-	});
-
-	test("rejects a non-2xx answer", async () => {
-		const fake = (async () => new Response("nope", { status: 503 })) as unknown as typeof fetch;
-		await expect(fetchLatestVersion(fake)).rejects.toThrow("503");
-	});
-});

package/src/workos.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { type DeviceAuthorization, pollForDeviceToken, refreshTokens } from "./workos";
-
-const DEVICE: DeviceAuthorization = {
-	device_code: "dev_123",
-	user_code: "ABCD-1234",
-	verification_uri: "https://auth.example/device",
-	verification_uri_complete: "https://auth.example/device?code=ABCD-1234",
-	expires_in: 300,
-	interval: 5,
-};
-
-// A fetch stub that answers the authenticate endpoint from a scripted queue.
-function scriptedFetch(responses: Array<{ status: number; body: unknown }>): {
-	fetchImpl: typeof fetch;
-	requests: URLSearchParams[];
-} {
-	const requests: URLSearchParams[] = [];
-	const fetchImpl = (async (_url: string | URL | Request, init?: RequestInit) => {
-		requests.push(new URLSearchParams(String(init?.body ?? "")));
-		const next = responses.shift();
-		if (!next) throw new Error("scripted fetch exhausted");
-		return Response.json(next.body, { status: next.status });
-	}) as typeof fetch;
-	return { fetchImpl, requests };
-}
-
-const TOKENS = {
-	access_token: "at_new",
-	refresh_token: "rt_new",
-	user: { id: "user_1", email: "dev@example.com" },
-	organization_id: "org_1",
-};
-
-describe("pollForDeviceToken", () => {
-	test("keeps polling through authorization_pending, widens on slow_down, then succeeds", async () => {
-		const sleeps: number[] = [];
-		const { fetchImpl, requests } = scriptedFetch([
-			{ status: 400, body: { error: "authorization_pending" } },
-			{ status: 400, body: { error: "slow_down" } },
-			{ status: 200, body: TOKENS },
-		]);
-		const result = await pollForDeviceToken("client_01TEST", DEVICE, {
-			fetchImpl,
-			sleep: async (ms) => {
-				sleeps.push(ms);
-			},
-		});
-		expect(result.accessToken).toBe("at_new");
-		expect(result.refreshToken).toBe("rt_new");
-		expect(result.user?.email).toBe("dev@example.com");
-		expect(result.organizationId).toBe("org_1");
-		// 5s while pending, then 5+5=10s after slow_down.
-		expect(sleeps).toEqual([5000, 10000]);
-		expect(requests[0]?.get("grant_type")).toBe("urn:ietf:params:oauth:grant-type:device_code");
-		expect(requests[0]?.get("device_code")).toBe("dev_123");
-	});
-
-	test("access_denied stops with a clear error", async () => {
-		const { fetchImpl } = scriptedFetch([{ status: 400, body: { error: "access_denied" } }]);
-		await expect(
-			pollForDeviceToken("client_01TEST", DEVICE, { fetchImpl, sleep: async () => {} }),
-		).rejects.toThrow(/denied/);
-	});
-
-	test("expired_token tells the user to log in again", async () => {
-		const { fetchImpl } = scriptedFetch([{ status: 400, body: { error: "expired_token" } }]);
-		await expect(
-			pollForDeviceToken("client_01TEST", DEVICE, { fetchImpl, sleep: async () => {} }),
-		).rejects.toThrow(/login/);
-	});
-});
-
-describe("refreshTokens", () => {
-	test("sends the refresh grant and parses rotated tokens", async () => {
-		const { fetchImpl, requests } = scriptedFetch([{ status: 200, body: TOKENS }]);
-		const result = await refreshTokens("client_01TEST", "rt_old", fetchImpl);
-		expect(result.refreshToken).toBe("rt_new");
-		expect(requests[0]?.get("grant_type")).toBe("refresh_token");
-		expect(requests[0]?.get("refresh_token")).toBe("rt_old");
-	});
-
-	test("a rejected refresh surfaces as a re-login prompt", async () => {
-		const { fetchImpl } = scriptedFetch([{ status: 400, body: { error: "invalid_grant" } }]);
-		await expect(refreshTokens("client_01TEST", "rt_old", fetchImpl)).rejects.toThrow(/login/);
-	});
-});