claudeup 6.7.1 → 6.8.1

package/src/__tests__/mate-availability.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Whether the mate slots are drawn, and what "installed" is allowed to mean.
+ *
+ * The question is asked of the plugin registry through `plugin-manager`, never of
+ * `installed_plugins.json` / `enabledPlugins` / `installedPluginVersions` directly — those
+ * are Claude Code's to own, and the last of them is maintained by nothing but claudeup, so it
+ * goes stale silently. What is tested here is the DECISION on top of that data, which is the
+ * part a real registry cannot exercise on demand.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	MATE_FORCE_ENV,
+	MATE_PLUGIN_ID,
+	areMatesAvailable,
+	matesForced,
+} from "../services/mate-availability.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+
+const plugin = (overrides: Partial<PluginInfo> = {}): PluginInfo => ({
+	id: MATE_PLUGIN_ID,
+	name: "multimodel",
+	version: "1.0.0",
+	description: "",
+	marketplace: "magus",
+	marketplaceDisplay: "Magus",
+	enabled: true,
+	...overrides,
+});
+
+const lister = (plugins: PluginInfo[]) => async () => plugins;
+
+describe("areMatesAvailable", () => {
+	test("false when the plugin is nowhere in the list", async () => {
+		expect(await areMatesAvailable(undefined, lister([]))).toBe(false);
+		expect(
+			await areMatesAvailable(
+				undefined,
+				lister([plugin({ id: "dev@magus", name: "dev" })]),
+			),
+		).toBe(false);
+	});
+
+	test("true when it is installed at ANY scope", async () => {
+		// Any scope, because a mate is served by whatever Claude Code has loaded when the
+		// agent spawns — the union of the three. A user-scope install serves a project that
+		// enables nothing of its own.
+		for (const scope of ["userScope", "projectScope", "localScope"] as const) {
+			const one = plugin({ [scope]: { enabled: true, version: "1.0.0" } });
+			expect({
+				scope,
+				available: await areMatesAvailable(undefined, lister([one])),
+			}).toEqual({ scope, available: true });
+		}
+	});
+
+	/**
+	 * The enabled-but-not-installed state is NOT installed.
+	 *
+	 * `enabledPlugins` is a flag only claudeup and the user maintain; the version comes from
+	 * the registry, which is what Claude Code actually loaded. Flag set with no version is the
+	 * broken state the plugin list already renders as "not installed" — and a mate row drawn
+	 * on the strength of it would promise routing through a plugin that never loaded.
+	 */
+	test("false when it is enabled but never actually installed", async () => {
+		const flagged = plugin({ userScope: { enabled: true } });
+		expect(await areMatesAvailable(undefined, lister([flagged]))).toBe(false);
+	});
+
+	test("false when it is installed but disabled", async () => {
+		const off = plugin({
+			userScope: { enabled: false, version: "1.0.0" },
+		});
+		expect(await areMatesAvailable(undefined, lister([off]))).toBe(false);
+	});
+
+	test('a version of "0.0.0" still counts — that is how some plugins record themselves', async () => {
+		const zero = plugin({ userScope: { enabled: true, version: "0.0.0" } });
+		expect(await areMatesAvailable(undefined, lister([zero]))).toBe(true);
+	});
+
+	/**
+	 * FAILS CLOSED, and that is the load-bearing half.
+	 *
+	 * This reaches marketplace resolution, which does network work with its own timeouts. A
+	 * failure means "we do not know", and the honest rendering of not knowing is the screen
+	 * exactly as it was before mates existed — not three rows put on screen by an error.
+	 */
+	test("false when the lookup throws", async () => {
+		const throwing = async () => {
+			throw new Error("marketplace unreachable");
+		};
+		expect(await areMatesAvailable(undefined, throwing)).toBe(false);
+	});
+});
+
+/**
+ * `CLAUDEUP_MATES=1` — draw the slots on a machine that cannot serve them.
+ *
+ * It exists because the three rows ARE the feature: without the plugin installed there is no
+ * way to put them on screen, which leaves `kangaroo`'s eight cells — the widest thing this
+ * layout ever has to fit — as the one part nobody can check by eye.
+ */
+describe("the mate-slot override", () => {
+	test("accepts the affirmative spellings, and nothing else", () => {
+		for (const on of ["1", "true", "on", "yes", "TRUE", " On "]) {
+			expect(matesForced({ [MATE_FORCE_ENV]: on })).toBe(true);
+		}
+		// "0" and "false" are not merely unrecognised, they are the common way to try to turn
+		// a flag OFF. Reading either as true would be the worst possible misparse.
+		for (const off of ["0", "false", "off", "no", "", "maybe"]) {
+			expect(matesForced({ [MATE_FORCE_ENV]: off })).toBe(false);
+		}
+		expect(matesForced({})).toBe(false);
+	});
+
+	/**
+	 * The flag SHORT-CIRCUITS, and a throwing lister is how that is proved.
+	 *
+	 * A lister that throws returns false through every other path in this file, so if the
+	 * answer here is true, the registry was genuinely never consulted — which is the point:
+	 * the network work behind it is the slow part, and its result would be discarded anyway.
+	 */
+	test("returns true without consulting the registry at all", async () => {
+		const throwing = async () => {
+			throw new Error("the registry must not be reached");
+		};
+		const original = process.env[MATE_FORCE_ENV];
+		process.env[MATE_FORCE_ENV] = "1";
+		try {
+			expect(await areMatesAvailable(undefined, throwing)).toBe(true);
+		} finally {
+			if (original === undefined) delete process.env[MATE_FORCE_ENV];
+			else process.env[MATE_FORCE_ENV] = original;
+		}
+	});
+
+	/**
+	 * Negative control for the test above.
+	 *
+	 * Same lister, same call, flag absent — false. Without this pair, a bug that made
+	 * `areMatesAvailable` return true unconditionally would pass the short-circuit test and
+	 * look like proof of the flag.
+	 */
+	test("the same call is false once the flag is gone", async () => {
+		const throwing = async () => {
+			throw new Error("the registry must not be reached");
+		};
+		const original = process.env[MATE_FORCE_ENV];
+		delete process.env[MATE_FORCE_ENV];
+		try {
+			expect(await areMatesAvailable(undefined, throwing)).toBe(false);
+		} finally {
+			if (original !== undefined) process.env[MATE_FORCE_ENV] = original;
+		}
+	});
+});

package/src/__tests__/mate-catalog.test.ts

@@ -0,0 +1,295 @@
+/**
+ * Reading claudish's live model catalogue, and the one rule that matters most about it.
+ *
+ * This module's whole job is to be ADVISORY and to FAIL SILENT. So the tests that earn their
+ * place are the negative ones: what happens when claudish is missing, when it exits non-zero,
+ * when it prints a table this build has never seen. Every one of those has to end in "the
+ * catalogue is unknown" and nothing else — an advisory that fires hardest when it knows least
+ * is worse than no advisory at all.
+ *
+ * The fixture below is REAL output, captured from `claudish --models` (v9.3.0) rather than
+ * written from memory of the format. A parser tested against its author's idea of the format
+ * passes forever and tells you nothing about the format.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type CatalogModel,
+	catalogIds,
+	clearMateCatalogCache,
+	loadMateCatalog,
+	parseModelsTable,
+	stalenessNote,
+	unknownBindings,
+} from "../services/mate-catalog.js";
+
+/** Verbatim `claudish --models`, trimmed in the middle. Header, rule, rows, legend, footer. */
+const REAL_OUTPUT = `
+Top 100 models from Firebase (pool: 384 eligible)
+
+  #    Model                          Provider    Pricing     Context  Caps  Released
+  ──────────────────────────────────────────────────────────────────────────────────────────
+    4  deepseek-v4.1-flash            deepseek   $0.75/1M   1M      TRV   2026-09-10
+    1  gpt-6-astra                    openai     $30.00/1M  1M      TRV   2026-09-03
+    3  gemini-3.8-flash               google     $2.25/1M   1M      TRV   2026-09-02
+   57  grok-4.6                       x-ai       $4.00/1M   500K    TRV   2026-08-12
+   15  kimi-k3                        moonshotai $9.00/1M   1M      TRV   2026-07-16
+    8  glm-5.3-fp8                    z-ai       FREE       1M      TR    2026-08-14
+   55  inkling-small                  thinking-machines $0.85/1M   1M      TRV   2026-07-30
+   68  mimo-v2.5                      xiaomi     FREE       1M      TRV   —
+   99  codex-mini-latest              openai     $3.75/1M   200K    TRV   —
+
+  Caps: T = tools  R = reasoning  V = vision
+
+Local providers
+  ──────────────────────────────────────────────────────────────────────
+  Ollama:    not running
+  LiteLLM:   not configured (set LITELLM_BASE_URL + LITELLM_API_KEY)
+
+Filter by provider: claudish --models --provider <slug>
+All providers:      claudish --providers
+`;
+
+const idsOf = (models: CatalogModel[]) => models.map((m) => m.id);
+
+describe("parseModelsTable", () => {
+	test("reads every model row out of real claudish output", () => {
+		expect(idsOf(parseModelsTable(REAL_OUTPUT))).toEqual([
+			"deepseek-v4.1-flash",
+			"gpt-6-astra",
+			"gemini-3.8-flash",
+			"grok-4.6",
+			"kimi-k3",
+			"glm-5.3-fp8",
+			"inkling-small",
+			"mimo-v2.5",
+			"codex-mini-latest",
+		]);
+	});
+
+	test("keeps the fields a binding and a picker need", () => {
+		const grok = parseModelsTable(REAL_OUTPUT).find((m) => m.id === "grok-4.6");
+		expect(grok).toEqual({
+			id: "grok-4.6",
+			provider: "x-ai",
+			pricing: "$4.00/1M",
+			context: "500K",
+			caps: "TRV",
+			released: "2026-08-12",
+		});
+	});
+
+	test("`FREE` is a pricing string like any other, not a missing field", () => {
+		const free = parseModelsTable(REAL_OUTPUT).find(
+			(m) => m.id === "glm-5.3-fp8",
+		);
+		expect(free?.pricing).toBe("FREE");
+		expect(free?.caps).toBe("TR");
+	});
+
+	test("an em-dash release date becomes empty, not a dash in a date field", () => {
+		// Carrying `—` through would put a glyph in a field every reader treats as a date,
+		// and anything that formats or sorts it would have to special-case the glyph.
+		const undated = parseModelsTable(REAL_OUTPUT).find(
+			(m) => m.id === "mimo-v2.5",
+		);
+		expect(undated?.released).toBe("");
+	});
+
+	test("the legend, the local-provider block and the footer are not models", () => {
+		const ids = idsOf(parseModelsTable(REAL_OUTPUT));
+		for (const notAModel of [
+			"Caps:",
+			"Ollama:",
+			"LiteLLM:",
+			"Local",
+			"Filter",
+			"Top",
+		]) {
+			expect(ids).not.toContain(notAModel);
+		}
+	});
+
+	/**
+	 * The defensive half of the seven-token rule.
+	 *
+	 * If claudish adds a column, every row stops matching and the catalogue comes back empty
+	 * — which means "unknown", which suppresses the advisory and changes nothing on screen.
+	 * The alternative (take the first seven of >= 7) would keep matching while reading the
+	 * wrong field into `id`, and would then report live models as retired. Silence beats
+	 * confident nonsense.
+	 */
+	test("an extra column makes the table unreadable rather than misread", () => {
+		const eightColumns =
+			"    4  deepseek-v4.1-flash  deepseek  $0.75/1M  1M  TRV  2026-09-10  extra";
+		expect(parseModelsTable(eightColumns)).toEqual([]);
+	});
+
+	test("never throws on junk, however shaped", () => {
+		for (const junk of ["", "\n\n\n", "error: command not found", "{}", "—"]) {
+			expect(() => parseModelsTable(junk)).not.toThrow();
+			expect(parseModelsTable(junk)).toEqual([]);
+		}
+	});
+
+	test("strips SGR sequences, so colour cannot ride into an id", () => {
+		// Measured: a piped `claudish --models` emits none today. This is about the day it
+		// starts colouring a pipe — an ESC left in the string would make a live model look
+		// retired, which is the one false positive this module must never produce.
+		const coloured =
+			"    57  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12";
+		expect(idsOf(parseModelsTable(coloured))).toEqual(["grok-4.6"]);
+	});
+
+	test("a repeated id is listed once", () => {
+		const twice = `
+    57  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12
+    58  grok-4.6  x-ai  $4.00/1M  500K  TRV  2026-08-12
+`;
+		expect(idsOf(parseModelsTable(twice))).toEqual(["grok-4.6"]);
+	});
+});
+
+describe("unknownBindings", () => {
+	const catalog = parseModelsTable(REAL_OUTPUT);
+
+	/**
+	 * THE load-bearing test in this file.
+	 *
+	 * An unread catalogue lists nothing, so a naive "not in the set" check would mark every
+	 * binding on the machine as retired the moment claudish was missing. The advisory has to
+	 * go quiet exactly when it knows least.
+	 */
+	test("says nothing at all when the catalogue could not be read", () => {
+		expect(unknownBindings(["grok-4.6", "totally-made-up"], [])).toEqual([]);
+	});
+
+	test("names an id the catalogue does not list", () => {
+		expect(unknownBindings(["grok-4.6", "gpt-4-turbo"], catalog)).toEqual([
+			"gpt-4-turbo",
+		]);
+	});
+
+	test("says nothing when every binding is live", () => {
+		expect(unknownBindings(["grok-4.6", "kimi-k3"], catalog)).toEqual([]);
+	});
+
+	test("exact match only — a neighbouring version is not a stand-in", () => {
+		// `grok-4.5` resolving a retired `grok-4.6` is the exact failure this exists to
+		// catch, wearing a helpful face. Same rule the image-model registry holds to.
+		expect(unknownBindings(["grok-4.5"], catalog)).toEqual(["grok-4.5"]);
+	});
+
+	test("reports a repeated unknown id once", () => {
+		expect(unknownBindings(["nope", "nope"], catalog)).toEqual(["nope"]);
+	});
+});
+
+describe("catalogIds", () => {
+	test("is every id, as a set", () => {
+		const ids = catalogIds(parseModelsTable(REAL_OUTPUT));
+		expect(ids.has("grok-4.6")).toBe(true);
+		expect(ids.has("gpt-4-turbo")).toBe(false);
+		expect(ids.size).toBe(9);
+	});
+});
+
+describe("stalenessNote", () => {
+	test("is null when there is nothing to say", () => {
+		expect(stalenessNote([])).toBeNull();
+	});
+
+	test("hedges, because absence from a TOP-N list is weak evidence", () => {
+		// `--models` prints the top 100 of a 384-model pool, so a missing id may simply sit
+		// below the cut. The note must not claim the model is gone.
+		const note = stalenessNote(["gpt-4-turbo"]);
+		expect(note).toContain("gpt-4-turbo");
+		expect(note).toContain("may");
+		expect(note).not.toContain("deleted");
+		expect(note).not.toContain("retired");
+	});
+
+	test("agrees with itself about number", () => {
+		expect(stalenessNote(["a"])).toContain(" is ");
+		expect(stalenessNote(["a", "b"])).toContain(" are ");
+	});
+});
+
+describe("loadMateCatalog", () => {
+	test("returns [] when claudish is not there to answer", async () => {
+		clearMateCatalogCache();
+		expect(await loadMateCatalog(async () => null)).toEqual([]);
+	});
+
+	test("returns [] when the fetcher throws, rather than propagating", async () => {
+		// Nothing above this module is allowed to see an exception from a catalogue read.
+		clearMateCatalogCache();
+		expect(
+			await loadMateCatalog(async () => {
+				throw new Error("claudish exploded");
+			}),
+		).toEqual([]);
+	});
+
+	test("parses what it is handed", async () => {
+		clearMateCatalogCache();
+		const models = await loadMateCatalog(async () => REAL_OUTPUT);
+		expect(idsOf(models)).toContain("grok-4.6");
+	});
+
+	test("caches, so one screen's lookup answers for the session", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const counting = async () => {
+			calls += 1;
+			return REAL_OUTPUT;
+		};
+		await loadMateCatalog(counting);
+		await loadMateCatalog(counting);
+		expect(calls).toBe(1);
+	});
+
+	/**
+	 * A FAILURE is cached too, and that is deliberate.
+	 *
+	 * The catalogue cannot change while claudeup is open, so a machine with no claudish would
+	 * otherwise pay the spawn — and its full timeout — once per screen that asks.
+	 */
+	test("caches the failure as well, so a missing claudish is paid for once", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const failing = async () => {
+			calls += 1;
+			return null;
+		};
+		await loadMateCatalog(failing);
+		await loadMateCatalog(failing);
+		expect(calls).toBe(1);
+	});
+
+	test("concurrent callers share one lookup", async () => {
+		clearMateCatalogCache();
+		let calls = 0;
+		const slow = async () => {
+			calls += 1;
+			await new Promise((r) => setTimeout(r, 10));
+			return REAL_OUTPUT;
+		};
+		await Promise.all([loadMateCatalog(slow), loadMateCatalog(slow)]);
+		expect(calls).toBe(1);
+	});
+
+	test("clearing the cache means the next call asks again", async () => {
+		// The negative control for all four cache tests above: without it, a `loadMateCatalog`
+		// that never called its fetcher at all would pass every one of them.
+		clearMateCatalogCache();
+		let calls = 0;
+		const counting = async () => {
+			calls += 1;
+			return REAL_OUTPUT;
+		};
+		await loadMateCatalog(counting);
+		clearMateCatalogCache();
+		await loadMateCatalog(counting);
+		expect(calls).toBe(2);
+	});
+});