magus-cli 0.0.0-placeholder → 7.0.0

package/src/__tests__/install-plan.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import {
+	computeEnvStatus,
+	computeVersionDrift,
+	summarizeClosure,
+} from "../services/install-plan.js";
+import type {
+	InstalledPluginsRegistry,
+	ResolvedClosure,
+} from "../types/index.js";
+
+function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
+	return {
+		marketplaces: {},
+		plugins: {},
+		mcpServers: {},
+		bins: [],
+		skills: [],
+		settings: {},
+		env: { required: [], optional: [] },
+		...overrides,
+	};
+}
+
+function registry(plugins: Record<string, string[]>): InstalledPluginsRegistry {
+	const out: InstalledPluginsRegistry = { version: 2, plugins: {} };
+	for (const [id, versions] of Object.entries(plugins)) {
+		out.plugins[id] = versions.map((v) => ({
+			scope: "user",
+			installPath: `/cache/${id}/${v}`,
+			version: v,
+			installedAt: "t",
+			lastUpdated: "t",
+		}));
+	}
+	return out;
+}
+
+describe("computeVersionDrift", () => {
+	test("no drift when installed matches the pin", () => {
+		const c = closure({ plugins: { "dev@magus": "2.9.0" } });
+		expect(
+			computeVersionDrift(c, registry({ "dev@magus": ["2.9.0"] })),
+		).toEqual([]);
+	});
+
+	test("'latest' pins are never drift-checked", () => {
+		const c = closure({ plugins: { "dev@magus": "latest" } });
+		expect(
+			computeVersionDrift(c, registry({ "dev@magus": ["1.0.0"] })),
+		).toEqual([]);
+	});
+
+	test("flags a mismatch, reporting the highest installed version", () => {
+		const c = closure({ plugins: { "dev@magus": "2.9.0" } });
+		const drift = computeVersionDrift(
+			c,
+			registry({ "dev@magus": ["2.8.0", "2.10.0"] }),
+		);
+		expect(drift).toEqual([
+			{ pluginId: "dev@magus", pinned: "2.9.0", installed: "2.10.0" },
+		]);
+	});
+
+	test("flags a pinned plugin that isn't installed at all", () => {
+		const c = closure({ plugins: { "terminal@magus": "4.1.0" } });
+		expect(computeVersionDrift(c, registry({}))).toEqual([
+			{ pluginId: "terminal@magus", pinned: "4.1.0", installed: null },
+		]);
+	});
+});
+
+describe("computeEnvStatus", () => {
+	test("splits present/missing required and optional", () => {
+		const c = closure({
+			env: { required: ["FIGMA_TOKEN", "SET_VAR"], optional: ["OPT"] },
+		});
+		const status = computeEnvStatus(c, { SET_VAR: "x", OPT: "" });
+		expect(status.missingRequired).toEqual(["FIGMA_TOKEN"]);
+		expect(status.required.find((e) => e.name === "SET_VAR")!.present).toBe(
+			true,
+		);
+		// empty string counts as missing
+		expect(status.optional[0]!.present).toBe(false);
+	});
+});
+
+describe("summarizeClosure", () => {
+	test("emits one labeled line per non-empty category", () => {
+		const c = closure({
+			marketplaces: { magus: { source: "github", repo: "MadAppGang/magus" } },
+			plugins: { "dev@magus": "latest", "terminal@magus": "4.1.0" },
+			bins: [
+				{ name: "claudish", via: "bun", version: "1.2.0", sources: ["x"] },
+			],
+			env: { required: ["FIGMA_TOKEN"], optional: [] },
+		});
+		const lines = summarizeClosure(c);
+		expect(lines.some((l) => l.startsWith("marketplaces"))).toBe(true);
+		expect(lines.some((l) => l.includes("terminal@magus@4.1.0"))).toBe(true);
+		expect(lines.some((l) => l.includes("claudish@1.2.0"))).toBe(true);
+		expect(lines.some((l) => l.startsWith("env"))).toBe(true);
+	});
+});

package/src/__tests__/launcher-signal.test.ts

@@ -0,0 +1,308 @@
+/**
+ * `bin/magus.js` — what the launcher does when the prebuilt binary dies.
+ *
+ * The defect these tests pin: a process killed by a signal leaves
+ * `{status: null, signal: "SIGKILL", error: undefined}`. The launcher's guard
+ * read `error` only, so `status ?? 0` turned every signal death into exit 0.
+ * On macOS 27 an invalid code signature kills the binary at exec, so magus
+ * 4.40.0 through 6.8.0 printed nothing and reported success.
+ *
+ * The tests drive the real launcher inside a throwaway tree that mirrors the
+ * npm install layout:
+ *
+ *   <tmp>/package.json                                     ({"type":"module"})
+ *   <tmp>/bin/magus.js                                  (a copy of the real file)
+ *   <tmp>/src/main.tsx                                     (stub source path)
+ *   <tmp>/node_modules/magus-cli-<plat>-<arch>/bin/magus (stub binary)
+ *
+ * `createRequire` inside the copy walks up from <tmp>/bin, so it can never
+ * reach this repo's own installed magus-cli-darwin-arm64. That is why the tree
+ * is built rather than NODE_PATH set: NODE_PATH is consulted only AFTER the
+ * node_modules walk fails, so a dev with the real optionalDependency installed
+ * would silently test the shipped binary instead of the stub.
+ *
+ * Each stub appends one line to $MAGUS_TEST_LEDGER. A ledger file gives
+ * ordering and argv forwarding, which an inherited stdio stream cannot. The
+ * source stub's exit code 7 is a value the masked path can never produce, so
+ * `status === 7` alone separates "fell back" from "pretended to succeed".
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import {
+	chmodSync,
+	cpSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const REAL_LAUNCHER = path.join(import.meta.dir, "..", "..", "bin", "magus.js");
+const PKG_SUFFIX = `${process.platform}-${process.arch}`;
+const PKG_NAME = `magus-cli-${PKG_SUFFIX}`;
+
+/**
+ * Absolute path to node, resolved once. The "Bun is not installed" tests hand
+ * the launcher a PATH with neither node nor bun on it, so the interpreter
+ * cannot be found by name.
+ */
+const NODE_BIN = spawnSync("sh", ["-c", "command -v node"], {
+	encoding: "utf8",
+}).stdout.trim();
+
+const dirs: string[] = [];
+
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function sourceStub(action: string): string {
+	return `import { appendFileSync } from "node:fs";
+appendFileSync(
+	process.env.MAGUS_TEST_LEDGER as string,
+	\`SOURCE \${process.argv.slice(2).join(" ")}\\n\`,
+);
+${action}
+`;
+}
+
+function makeTree(
+	opts: {
+		/** Shell the binary stub runs after logging. Omit = package absent. */
+		binaryAction?: string;
+		binaryMode?: number;
+		/** Statement the source stub runs after logging. */
+		sourceAction?: string;
+	} = {},
+): string {
+	const dir = realpathSync(
+		mkdtempSync(path.join(os.tmpdir(), "magus-launcher-")),
+	);
+	dirs.push(dir);
+
+	// The launcher is ESM. Without a `type: module` package.json above it, node
+	// parses the copy as CJS and dies on the first `import`.
+	writeFileSync(
+		path.join(dir, "package.json"),
+		JSON.stringify({ name: "magus", version: "0.0.0", type: "module" }),
+	);
+
+	mkdirSync(path.join(dir, "bin"));
+	cpSync(REAL_LAUNCHER, path.join(dir, "bin", "magus.js"));
+
+	mkdirSync(path.join(dir, "src"));
+	writeFileSync(
+		path.join(dir, "src", "main.tsx"),
+		sourceStub(opts.sourceAction ?? "process.exit(7);"),
+	);
+
+	if (opts.binaryAction !== undefined) {
+		const pkgDir = path.join(dir, "node_modules", PKG_NAME);
+		mkdirSync(path.join(pkgDir, "bin"), { recursive: true });
+		// No "exports" field: the launcher resolves `<pkg>/package.json`, which
+		// an exports map would refuse.
+		writeFileSync(
+			path.join(pkgDir, "package.json"),
+			JSON.stringify({ name: PKG_NAME, version: "0.0.0" }),
+		);
+		const bin = path.join(pkgDir, "bin", "magus");
+		writeFileSync(
+			bin,
+			`#!/bin/sh\necho "BINARY $*" >> "$MAGUS_TEST_LEDGER"\n${opts.binaryAction}\n`,
+		);
+		chmodSync(bin, opts.binaryMode ?? 0o755);
+	}
+
+	return dir;
+}
+
+function binaryPathIn(dir: string): string {
+	return path.join(dir, "node_modules", PKG_NAME, "bin", "magus");
+}
+
+interface Launch {
+	status: number | null;
+	signal: NodeJS.Signals | null;
+	stderr: string;
+	ledger: string[];
+}
+
+function launch(
+	dir: string,
+	args: string[] = [],
+	env: Record<string, string> = {},
+): Launch {
+	const ledgerPath = path.join(dir, "ledger.txt");
+	const result = spawnSync(
+		NODE_BIN,
+		[path.join(dir, "bin", "magus.js"), ...args],
+		{
+			encoding: "utf8",
+			// Nothing may reach a TUI renderer: hand the child an empty stdin.
+			input: "",
+			env: {
+				...process.env,
+				MAGUS_NO_BINARY: "",
+				MAGUS_TEST_LEDGER: ledgerPath,
+				...env,
+			},
+		},
+	);
+	const ledger = existsSync(ledgerPath)
+		? readFileSync(ledgerPath, "utf8")
+				.split("\n")
+				.map((line) => line.trim())
+				.filter(Boolean)
+		: [];
+	return {
+		status: result.status,
+		signal: result.signal,
+		stderr: result.stderr ?? "",
+		ledger,
+	};
+}
+
+describe("launcher: binary killed by a signal", () => {
+	test("T-sig-1: SIGKILL at exec falls back to source and explains why", () => {
+		const dir = makeTree({ binaryAction: "kill -s KILL $$" });
+		const r = launch(dir, ["--version"]);
+
+		// The shipped bug in one line: this was 0.
+		expect(r.status).not.toBe(0);
+		// 7 is the stub source path's code — nothing else can produce it.
+		expect(r.status).toBe(7);
+		expect(r.ledger).toEqual(["BINARY --version", "SOURCE --version"]);
+
+		// A stranded user needs the signal, the file, and a way out.
+		expect(r.stderr).toContain("SIGKILL");
+		expect(r.stderr).toContain(binaryPathIn(dir));
+		expect(r.stderr).toContain("signature");
+		expect(r.stderr).toContain("codesign --verify");
+		expect(r.stderr).toContain("MAGUS_NO_BINARY=1");
+	});
+
+	test("T-sig-2: SIGINT is the user's own Ctrl-C — exit 130, no fallback", () => {
+		const dir = makeTree({ binaryAction: "kill -s INT $$" });
+		const r = launch(dir);
+
+		expect(r.status).toBe(130);
+		expect(r.ledger.some((line) => line.startsWith("SOURCE"))).toBe(false);
+		expect(r.stderr).toBe("");
+	});
+
+	test("T-sig-3: SIGTERM is exit 143, no fallback", () => {
+		const dir = makeTree({ binaryAction: "kill -s TERM $$" });
+		const r = launch(dir);
+
+		expect(r.status).toBe(143);
+		expect(r.ledger.some((line) => line.startsWith("SOURCE"))).toBe(false);
+	});
+
+	test("T-sig-4: SIGABRT is a crash, not a user signal — it must fall back", () => {
+		// The hole an allowlist of crash signals leaves: a Bun/JSC panic aborts,
+		// which is precisely the "binary is broken, use source" case.
+		const dir = makeTree({ binaryAction: "kill -s ABRT $$" });
+		const r = launch(dir);
+
+		expect(r.status).toBe(7);
+		expect(r.ledger.some((line) => line.startsWith("SOURCE"))).toBe(true);
+	});
+
+	test("T-sig-5: a kill seconds in is deliberate — report it, do not relaunch", () => {
+		// A signature kill lands in single-digit milliseconds at exec. A user
+		// running `kill -9` on a live TUI, or an OOM kill, lands much later.
+		// Without the time gate the fix trades a silent exit 0 for a surprise
+		// relaunch of an app the user deliberately killed.
+		const dir = makeTree({ binaryAction: "sleep 3\nkill -s KILL $$" });
+		const r = launch(dir);
+
+		expect(r.status).toBe(137);
+		expect(r.ledger.some((line) => line.startsWith("SOURCE"))).toBe(false);
+	}, 20000);
+
+	test("T-sig-6: an ordinary non-zero exit passes straight through", () => {
+		const dir = makeTree({ binaryAction: "exit 3" });
+		const r = launch(dir);
+
+		expect(r.status).toBe(3);
+		expect(r.ledger.some((line) => line.startsWith("SOURCE"))).toBe(false);
+	});
+
+	test("T-sig-7: no platform package — straight to source, silently", () => {
+		const dir = makeTree();
+		const r = launch(dir);
+
+		expect(r.status).toBe(7);
+		expect(r.ledger).toEqual(["SOURCE"]);
+		expect(r.stderr).not.toContain("could not start");
+	});
+
+	test("T-sig-8: an unexecutable binary still falls back and says so", () => {
+		const dir = makeTree({ binaryAction: "exit 0", binaryMode: 0o644 });
+		const r = launch(dir);
+
+		expect(r.status).toBe(7);
+		expect(r.stderr).toContain("could not start");
+	});
+
+	test("T-sig-9: MAGUS_NO_BINARY=1 skips the binary entirely", () => {
+		// The escape hatch the SIGKILL diagnostic advertises has to work.
+		const dir = makeTree({ binaryAction: "kill -s KILL $$" });
+		const r = launch(dir, [], { MAGUS_NO_BINARY: "1" });
+
+		expect(r.ledger.some((line) => line.startsWith("BINARY"))).toBe(false);
+		expect(r.status).toBe(7);
+	});
+
+	test("T-sig-10: the source path has the same bug, and nowhere to fall back to", () => {
+		const dir = makeTree({
+			sourceAction: 'process.kill(process.pid, "SIGKILL");',
+		});
+		const r = launch(dir);
+
+		expect(r.status).toBe(137);
+		// No binary was involved, so a codesign hint here would be nonsense.
+		expect(r.stderr).not.toContain("codesign");
+	});
+
+	test("T-sig-11: argv reaches both the binary and the fallback unchanged", () => {
+		const dir = makeTree({ binaryAction: "kill -s KILL $$" });
+		const r = launch(dir, ["--version", "--x"]);
+
+		expect(r.ledger).toContain("BINARY --version --x");
+		expect(r.ledger).toContain("SOURCE --version --x");
+	});
+
+	// An empty PATH removes bun, so the source fallback cannot start either.
+	// This is the terminal state for the population the 6.8.1 fix exists for:
+	// magus installed from npm on macOS 27, no Bun on the machine.
+	const NO_BUN = { PATH: "" };
+
+	test("T-sig-12: binary crashed AND no Bun — the message must not deny the binary", () => {
+		const dir = makeTree({ binaryAction: "kill -s KILL $$" });
+		const r = launch(dir, ["--version"], NO_BUN);
+
+		expect(r.status).toBe(1);
+		// The contradiction: a binary was found, run, and reported killed
+		// moments earlier. Saying none exists sends the user down a dead end.
+		expect(r.stderr).not.toContain(`no prebuilt binary for ${PKG_SUFFIX}`);
+		expect(r.stderr).toContain("unusable on this machine");
+		expect(r.stderr).toContain("npm install -g magus-cli@latest");
+	});
+
+	test("T-sig-13: no binary AND no Bun — that message is still correct, and kept", () => {
+		const dir = makeTree();
+		const r = launch(dir, ["--version"], NO_BUN);
+
+		expect(r.status).toBe(1);
+		expect(r.stderr).toContain(`no prebuilt binary for ${PKG_SUFFIX}`);
+		expect(r.stderr).not.toContain("unusable on this machine");
+	});
+});

package/src/__tests__/local-marketplace-scan.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import {
+	scanMcpServers,
+	scanSkillDirs,
+} from "../services/local-marketplace.js";
+import { walkMarkdown, walkSkillDirs } from "../services/skills-manager.js";
+
+/**
+ * The skill count in the plugin detail panel comes from a scan of the cloned
+ * marketplace. It used to read only the top level of `skills/`, which counts
+ * the *grouping* directories rather than the skills: dev reported 9 against 43
+ * on disk, mattpocock 5 against 37.
+ */
+describe("scanSkillDirs", () => {
+	let root: string;
+
+	beforeEach(async () => {
+		root = await fs.mkdtemp(path.join(os.tmpdir(), "magus-skills-"));
+	});
+
+	afterEach(async () => {
+		await fs.remove(root);
+	});
+
+	async function writeSkill(...segments: string[]): Promise<void> {
+		const dir = path.join(root, ...segments);
+		await fs.ensureDir(dir);
+		await fs.writeFile(path.join(dir, "SKILL.md"), "---\nname: x\n---\n");
+	}
+
+	it("counts skills nested under grouping directories", async () => {
+		await writeSkill("skills", "frontend", "design-system");
+		await writeSkill("skills", "frontend", "forms");
+		await writeSkill("skills", "backend", "db-branching");
+		await writeSkill("skills", "flat-skill");
+
+		const found = await scanSkillDirs(path.join(root, "skills"));
+
+		expect(found.sort()).toEqual([
+			"db-branching",
+			"design-system",
+			"flat-skill",
+			"forms",
+		]);
+	});
+
+	it("never counts a grouping directory as a skill", async () => {
+		await writeSkill("skills", "engineering", "code-review");
+		await writeSkill("skills", "engineering", "tdd");
+
+		const found = await scanSkillDirs(path.join(root, "skills"));
+
+		expect(found.sort()).toEqual(["code-review", "tdd"]);
+		expect(found).not.toContain("engineering");
+	});
+
+	it("returns nothing when the directory is absent", async () => {
+		expect(await scanSkillDirs(path.join(root, "nope"))).toEqual([]);
+	});
+
+	it("stops descending past four levels rather than walking the whole tree", async () => {
+		await writeSkill("skills", "a", "b", "c", "d", "too-deep");
+
+		expect(await scanSkillDirs(path.join(root, "skills"))).toEqual([]);
+	});
+});
+
+/**
+ * mnemex ships one MCP server and nothing else. The scan only looked in an
+ * `mcp-servers/` directory, so it reported zero of every component kind and the
+ * plugin read as shipping nothing at all.
+ */
+describe("scanMcpServers", () => {
+	let root: string;
+
+	beforeEach(async () => {
+		root = await fs.mkdtemp(path.join(os.tmpdir(), "magus-mcp-"));
+	});
+
+	afterEach(async () => {
+		await fs.remove(root);
+	});
+
+	it("reads server names from a root .mcp.json", async () => {
+		await fs.writeJson(path.join(root, ".mcp.json"), {
+			mnemex: { command: "mnemex", args: ["--mcp"] },
+		});
+
+		expect(await scanMcpServers(root)).toEqual(["mnemex"]);
+	});
+
+	it("reads the mcpServers wrapper shape too", async () => {
+		await fs.writeJson(path.join(root, ".mcp.json"), {
+			mcpServers: { alpha: { command: "a" }, beta: { command: "b" } },
+		});
+
+		expect((await scanMcpServers(root)).sort()).toEqual(["alpha", "beta"]);
+	});
+
+	it("still reads an mcp-servers/ directory", async () => {
+		await fs.ensureDir(path.join(root, "mcp-servers"));
+		await fs.writeJson(path.join(root, "mcp-servers", "tmux.json"), {});
+
+		expect(await scanMcpServers(root)).toEqual(["tmux"]);
+	});
+
+	it("reports a server rather than zero when .mcp.json will not parse", async () => {
+		await fs.writeFile(path.join(root, ".mcp.json"), "{ not json");
+
+		expect(await scanMcpServers(root)).toEqual(["mcp"]);
+	});
+
+	it("reports none when the plugin declares no server", async () => {
+		expect(await scanMcpServers(root)).toEqual([]);
+	});
+});
+
+/**
+ * The clone walkers behind the local-first read. A marketplace the user has
+ * added is on disk, so listing its plugins must cost no GitHub request — the
+ * hourly cap of 60 unauthenticated requests is shared across every repo on
+ * screen, and once it ran out every expand answered "Could not read the plugin",
+ * including for marketplaces sitting complete in the cache.
+ */
+describe("clone walkers", () => {
+	let root: string;
+
+	beforeEach(async () => {
+		root = await fs.mkdtemp(path.join(os.tmpdir(), "magus-walk-"));
+	});
+
+	afterEach(async () => {
+		await fs.remove(root);
+	});
+
+	async function write(rel: string, body = "x"): Promise<void> {
+		const full = path.join(root, rel);
+		await fs.ensureDir(path.dirname(full));
+		await fs.writeFile(full, body);
+	}
+
+	it("carries the grouping path so nested skills match the network shape", async () => {
+		await write("skills/frontend/design-system/SKILL.md");
+		await write("skills/backend/db/SKILL.md");
+		await write("skills/flat/SKILL.md");
+
+		const found = await walkSkillDirs(path.join(root, "skills"));
+		const byName = Object.fromEntries(found.map((f) => [f.name, f.group]));
+
+		expect(Object.keys(byName).sort()).toEqual(["db", "design-system", "flat"]);
+		expect(byName["design-system"]).toBe("frontend");
+		expect(byName.db).toBe("backend");
+		expect(byName.flat).toBeUndefined();
+	});
+
+	it("lists markdown commands and skips README", async () => {
+		await write("commands/go.md");
+		await write("commands/README.md");
+		await write("commands/deep/trace.md");
+
+		const found = await walkMarkdown(path.join(root, "commands"));
+
+		expect(found.map((f) => f.name).sort()).toEqual(["go", "trace"]);
+		expect(found.find((f) => f.name === "trace")?.group).toBe("deep");
+	});
+
+	it("returns nothing for a directory that is not there", async () => {
+		expect(await walkSkillDirs(path.join(root, "nope"))).toEqual([]);
+		expect(await walkMarkdown(path.join(root, "nope"))).toEqual([]);
+	});
+});