auto-model-router 0.19.0 → 0.20.0

package/test/connect-harnesses.test.ts

@@ -0,0 +1,299 @@
+import { describe, expect, test } from "bun:test";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { connectRemote, type ConnectOptions, type ConnectReport } from "../src/cli/connect.ts";
+import { mergeClineProviders, mergeContinueConfig, mergeOpenCodeConfig } from "../src/cli/harnesses.ts";
+
+/**
+ * The harnesses `connect` reaches beyond omp, Hermes, Codex, Aider and Claude
+ * Code. Each automated one starts from a fixture in the shape its harness
+ * actually writes (`test/fixtures/connect/`), so the assertions are about
+ * merging into a REAL file rather than into an empty one: the user's other keys,
+ * providers and comments must survive, a second run must change nothing,
+ * `--harness <id>` must select exactly one, and a machine without the harness
+ * must be told it was skipped rather than have a file invented for it.
+ *
+ * The two manual harnesses are held to the other half of that promise — they
+ * print and write nothing at all.
+ */
+
+const FIXTURES = join(import.meta.dir, "fixtures", "connect");
+
+/** A temp HOME with nothing in it: every harness is absent until a test plants one. */
+function bare(extra: Partial<ConnectOptions> = {}): { home: string; o: ConnectOptions } {
+	const home = mkdtempSync(join(tmpdir(), "amr-harness-"));
+	const o: ConnectOptions = {
+		url: "https://team.example",
+		key: "amrt_key",
+		userId: "u_ada",
+		name: "Ada",
+		profile: false,
+		dryRun: false,
+		only: [],
+		// Point every harness this suite does not exercise at a path that does not exist.
+		env: { HOME: home, PI_CODING_AGENT_DIR: join(home, "no-omp"), HERMES_HOME: join(home, "no-hermes"), AUTO_MODEL_ROUTER_HOME: join(home, ".auto-model-router"), XDG_CONFIG_HOME: join(home, ".config") },
+		home,
+		packageDir: process.cwd(),
+		platform: "linux",
+		pathHas: () => false,
+		...extra,
+	};
+	return { home, o };
+}
+
+/** Plants a captured config file for a harness under the temp HOME. */
+function plant(home: string, fixture: string, ...rel: string[]): string {
+	const target = join(home, ...rel);
+	mkdirSync(join(target, ".."), { recursive: true });
+	cpSync(join(FIXTURES, fixture), target);
+	return target;
+}
+
+const configuredFor = (r: ConnectReport, prefix: string): string | undefined => r.configured.find((c) => c.startsWith(prefix));
+const backupsIn = (dir: string): string[] => readdirSync(dir).filter((f) => f.endsWith(".bak"));
+
+describe("OpenCode", () => {
+	test("the provider block is merged into opencode.json, the plugin is copied, and a second run changes nothing", () => {
+		const { home, o } = bare();
+		const dir = join(home, ".config", "opencode");
+		const cfg = plant(home, "opencode.json", ".config", "opencode", "opencode.json");
+		try {
+			const r = connectRemote(o);
+			expect(configuredFor(r, "OpenCode (")).toContain("opencode.json");
+			// The exact file: our provider added, `model` pointed at it, and every
+			// other key — the schema, the MCP server, the user's own Ollama provider — kept.
+			expect(JSON.parse(readFileSync(cfg, "utf8"))).toEqual({
+				$schema: "https://opencode.ai/config.json",
+				model: "auto-model-router/auto",
+				mcp: { unityMCP: { type: "remote", url: "http://127.0.0.1:8080/mcp", enabled: true } },
+				provider: {
+					ollama: {
+						npm: "@ai-sdk/openai-compatible",
+						name: "Ollama",
+						options: { baseURL: "http://localhost:11434/v1" },
+						models: { "qwen2.5:7b": { name: "Qwen2.5 7B (local)" } },
+					},
+					"auto-model-router": {
+						npm: "@ai-sdk/openai-compatible",
+						name: "auto-model-router",
+						options: { baseURL: "https://team.example/v1", apiKey: "amrt_key", headers: { "X-Omp-Harness": "opencode" } },
+						models: { auto: { name: "auto" }, "auto-cheap": { name: "auto-cheap" }, "auto-max": { name: "auto-max" } },
+					},
+				},
+			});
+			// The plugin is what gives OpenCode session identity, the toast and the digest.
+			expect(readFileSync(join(dir, "plugin", "auto-model-router.ts"), "utf8")).toContain("chat.headers");
+			expect(backupsIn(dir)).toHaveLength(1); // the previous file was kept
+			const after = readFileSync(cfg, "utf8");
+			connectRemote(o);
+			expect(readFileSync(cfg, "utf8")).toBe(after);
+			expect(backupsIn(dir)).toHaveLength(1); // and a no-op run backs nothing up
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("--harness opencode selects it alone, and an absent OpenCode is reported as skipped", () => {
+		const { home, o } = bare({ only: ["opencode"] });
+		plant(home, "opencode.json", ".config", "opencode", "opencode.json");
+		try {
+			expect(connectRemote(o).configured.map((c) => c.split(" (")[0])).toEqual(["OpenCode"]);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+		const { home: h2, o: o2 } = bare();
+		try {
+			expect(connectRemote(o2).skipped).toContain("OpenCode (not on PATH and no ~/.config/opencode)");
+			expect(existsSync(join(h2, ".config", "opencode"))).toBe(false);
+		} finally {
+			rmSync(h2, { recursive: true, force: true });
+		}
+	});
+
+	test("a pinned scope rides in the provider's headers; a file we cannot parse is left alone", () => {
+		expect(JSON.parse(mergeOpenCodeConfig("", "https://t", "k", "omp-router")!).provider["auto-model-router"].options.headers).toEqual({ "X-Omp-Harness": "opencode", "X-Agentdox-Scope": "omp-router" });
+		expect(mergeOpenCodeConfig("[]", "https://t", "k")).toBeNull();
+		expect(mergeOpenCodeConfig("{ not json", "https://t", "k")).toBeNull();
+		expect(mergeOpenCodeConfig(mergeOpenCodeConfig("", "https://t", "k")!, "https://t", "k")).toBeNull();
+	});
+});
+
+describe("Cline", () => {
+	const REL = [".cline", "data", "settings"];
+
+	test("the openai-compatible provider is merged into providers.json beside the user's own, and a second run changes nothing", () => {
+		const { home, o } = bare();
+		const dir = join(home, ...REL);
+		const cfg = plant(home, "cline-providers.json", ...REL, "providers.json");
+		try {
+			const r = connectRemote(o);
+			expect(configuredFor(r, "Cline (")).toContain("providers.json");
+			const written = JSON.parse(readFileSync(cfg, "utf8")) as Record<string, unknown>;
+			// The harness id can only travel in `settings.headers`: cline's own auth
+			// command has no flag for it, which is why connect writes the file itself.
+			expect((written.providers as Record<string, { settings: unknown }>)["openai-compatible"]!.settings).toEqual({
+				provider: "openai-compatible",
+				apiKey: "amrt_key",
+				model: "auto",
+				baseUrl: "https://team.example/v1",
+				headers: { "X-Omp-Harness": "cline" },
+			});
+			expect(written.lastUsedProvider).toBe("openai-compatible");
+			expect(written.version).toBe(1);
+			// The user's other provider is untouched, key and stamp included.
+			expect((written.providers as Record<string, unknown>).anthropic).toEqual({
+				settings: { provider: "anthropic", apiKey: "sk-ant-existing", model: "claude-sonnet-4-5" },
+				updatedAt: "2026-09-10T05:27:55.818Z",
+				tokenSource: "manual",
+			});
+			expect(backupsIn(dir)).toHaveLength(1);
+			const after = readFileSync(cfg, "utf8");
+			connectRemote(o);
+			expect(readFileSync(cfg, "utf8")).toBe(after);
+			expect(backupsIn(dir)).toHaveLength(1);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("--harness cline selects it alone, and an absent Cline is reported as skipped", () => {
+		const { home, o } = bare({ only: ["cline"] });
+		plant(home, "cline-providers.json", ...REL, "providers.json");
+		try {
+			expect(connectRemote(o).configured.map((c) => c.split(" (")[0])).toEqual(["Cline"]);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+		const { home: h2, o: o2 } = bare();
+		try {
+			expect(connectRemote(o2).skipped).toContain("Cline (not on PATH and no ~/.cline)");
+			expect(existsSync(join(h2, ".cline"))).toBe(false);
+		} finally {
+			rmSync(h2, { recursive: true, force: true });
+		}
+	});
+
+	test("the stamp only moves when the settings do, a pinned scope rides along, and an unreadable file is left alone", () => {
+		const first = mergeClineProviders("", "https://t", "k", "2026-01-01T00:00:00.000Z", "omp-router")!;
+		expect(JSON.parse(first).providers["openai-compatible"].settings.headers).toEqual({ "X-Omp-Harness": "cline", "X-Agentdox-Scope": "omp-router" });
+		expect(mergeClineProviders(first, "https://t", "k", "2027-01-01T00:00:00.000Z", "omp-router")).toBeNull();
+		// A new key is a real change, so the stamp does move.
+		const rekeyed = mergeClineProviders(first, "https://t", "k2", "2027-01-01T00:00:00.000Z", "omp-router")!;
+		expect(JSON.parse(rekeyed).providers["openai-compatible"].updatedAt).toBe("2027-01-01T00:00:00.000Z");
+		expect(mergeClineProviders("nope", "https://t", "k", "2026-01-01T00:00:00.000Z")).toBeNull();
+	});
+});
+
+describe("Continue", () => {
+	test("the three profiles become model entries in config.yaml, keeping the file's comments, and a second run changes nothing", () => {
+		const { home, o } = bare();
+		const dir = join(home, ".continue");
+		const cfg = plant(home, "continue-config.yaml", ".continue", "config.yaml");
+		try {
+			const r = connectRemote(o);
+			expect(configuredFor(r, "Continue (")).toContain("config.yaml");
+			const text = readFileSync(cfg, "utf8");
+			// The document is edited, not re-serialised: comments, the user's own model
+			// and the context blocks are all still there, in their original order.
+			expect(text).toContain("# My Continue assistant — hand-edited, comments and all.");
+			expect(text).toContain("name: Local Assistant");
+			expect(text).toContain("  - name: Ollama Qwen");
+			expect(text.indexOf("context:")).toBeGreaterThan(text.indexOf("auto-model-router-max"));
+			for (const [name, model] of [
+				["auto-model-router", "auto"],
+				["auto-model-router-cheap", "auto-cheap"],
+				["auto-model-router-max", "auto-max"],
+			]) {
+				expect(text).toContain(`  - name: ${name}\n    provider: openai\n    model: ${model}\n    apiBase: https://team.example/v1\n    apiKey: amrt_key\n`);
+			}
+			expect(text).toContain("        X-Omp-Harness: continue");
+			expect(backupsIn(dir)).toHaveLength(1);
+			connectRemote(o);
+			expect(readFileSync(cfg, "utf8")).toBe(text);
+			expect(backupsIn(dir)).toHaveLength(1);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("--harness continue selects it alone, and an absent Continue is reported as skipped", () => {
+		const { home, o } = bare({ only: ["continue"] });
+		plant(home, "continue-config.yaml", ".continue", "config.yaml");
+		try {
+			expect(connectRemote(o).configured.map((c) => c.split(" (")[0])).toEqual(["Continue"]);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+		const { home: h2, o: o2 } = bare();
+		try {
+			expect(connectRemote(o2).skipped).toContain("Continue (no ~/.continue)");
+			expect(existsSync(join(h2, ".continue"))).toBe(false);
+		} finally {
+			rmSync(h2, { recursive: true, force: true });
+		}
+	});
+
+	test("a fresh file gets the schema's required fields first, a re-key replaces entries in place, and broken YAML is left alone", () => {
+		const fresh = mergeContinueConfig("", "https://t", "k")!;
+		expect(fresh.startsWith("name: auto-model-router\nversion: 0.0.1\nschema: v1\nmodels:\n  - name:")).toBe(true);
+		expect(mergeContinueConfig(fresh, "https://t", "k")).toBeNull();
+		const rekeyed = mergeContinueConfig(fresh, "https://t", "k2")!;
+		expect(rekeyed.match(/- name: auto-model-router\n/g)).toHaveLength(1); // replaced, not appended
+		expect(rekeyed).toContain("apiKey: k2");
+		expect(rekeyed).not.toContain("apiKey: k\n");
+		expect(mergeContinueConfig("models:\n  - [unclosed\n", "https://t", "k")).toBeNull();
+		expect(mergeContinueConfig("- a\n- b\n", "https://t", "k")).toBeNull(); // a sequence is not an assistant file
+	});
+});
+
+describe("Cursor and Windsurf keep their provider settings where no file can reach them", () => {
+	test("connect prints what to set and writes nothing under either home", () => {
+		const { home, o } = bare({ only: ["cursor", "windsurf"] });
+		mkdirSync(join(home, ".cursor"), { recursive: true });
+		mkdirSync(join(home, ".codeium", "windsurf"), { recursive: true });
+		try {
+			const r = connectRemote(o);
+			expect(r.configured).toEqual([]);
+			expect(r.manual.map((m) => m.harness)).toEqual(["Cursor", "Windsurf"]);
+			const cursor = r.manual[0]!.lines.join("\n");
+			expect(cursor).toContain("base URL: https://team.example/v1");
+			expect(cursor).toContain("API key:  amrt_key");
+			// Windsurf has no base-URL field of its own, so the useful answer is the extension.
+			expect(r.manual[1]!.lines.join("\n")).toContain("Cline extension");
+			// Nothing was written into either harness's directory.
+			expect(readdirSync(join(home, ".cursor"))).toEqual([]);
+			expect(readdirSync(join(home, ".codeium", "windsurf"))).toEqual([]);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("a loopback router is called out for Cursor, which proxies chat through its own servers", () => {
+		const { home, o } = bare({ only: ["cursor"], url: "http://127.0.0.1:8788" });
+		mkdirSync(join(home, ".cursor"), { recursive: true });
+		try {
+			expect(connectRemote(o).manual[0]!.lines.join("\n")).toContain("reachable from the internet");
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+		// A public remote gets no such warning, and an uninstalled Cursor gets no recipe.
+		const { home: h2, o: o2 } = bare({ only: ["cursor"] });
+		mkdirSync(join(h2, ".cursor"), { recursive: true });
+		try {
+			expect(connectRemote(o2).manual[0]!.lines.join("\n")).not.toContain("reachable from the internet");
+		} finally {
+			rmSync(h2, { recursive: true, force: true });
+		}
+		const { home: h3, o: o3 } = bare();
+		try {
+			const r = connectRemote(o3);
+			expect(r.manual).toEqual([]);
+			expect(r.skipped).toContain("Cursor (no ~/.cursor)");
+			expect(r.skipped).toContain("Windsurf (no ~/.codeium)");
+		} finally {
+			rmSync(h3, { recursive: true, force: true });
+		}
+	});
+});

package/test/fixtures/connect/cline-providers.json

@@ -0,0 +1,16 @@
+{
+  "version": 1,
+  "lastUsedProvider": "anthropic",
+  "modes": {},
+  "providers": {
+    "anthropic": {
+      "settings": {
+        "provider": "anthropic",
+        "apiKey": "sk-ant-existing",
+        "model": "claude-sonnet-4-5"
+      },
+      "updatedAt": "2026-09-10T05:27:55.818Z",
+      "tokenSource": "manual"
+    }
+  }
+}

package/test/fixtures/connect/continue-config.yaml

@@ -0,0 +1,14 @@
+# My Continue assistant — hand-edited, comments and all.
+name: Local Assistant
+version: 0.0.1
+schema: v1
+models:
+  - name: Ollama Qwen
+    provider: ollama
+    model: qwen2.5-coder:7b
+    roles:
+      - chat
+      - edit
+context:
+  - provider: code
+  - provider: diff

package/test/fixtures/connect/opencode.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "anthropic/claude-sonnet-4-5",
+  "provider": {
+    "ollama": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Ollama",
+      "options": { "baseURL": "http://localhost:11434/v1" },
+      "models": { "qwen2.5:7b": { "name": "Qwen2.5 7B (local)" } }
+    }
+  },
+  "mcp": {
+    "unityMCP": { "type": "remote", "url": "http://127.0.0.1:8080/mcp", "enabled": true }
+  }
+}