magus-cli 0.0.0-placeholder → 7.0.0

package/src/__tests__/alias-store.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "bun:test";
+import { ALIAS_FLAGS } from "../data/alias-flags";
+import {
+	CHANNELS_FLAG_ID,
+	DEFAULT_ALIAS_NAME,
+	DEVLOAD_FLAG_ID,
+	type FlagValue,
+	defaultAliasConfig,
+	defaultValueFor,
+	derivedChannelValues,
+	listValues,
+	validateAliasName,
+	withoutDerivedChannel,
+} from "../services/alias-store";
+
+function textList(values: string[], enabled = true): FlagValue {
+	return { kind: "text-list", enabled, values };
+}
+
+describe("defaultAliasConfig", () => {
+	it("seeds every known flag with a sane default and the default alias name", () => {
+		const c = defaultAliasConfig();
+		expect(c.aliasName).toBe(DEFAULT_ALIAS_NAME);
+		expect(c.aliasName).toBe("c");
+		expect(c.flags["dangerously-skip-permissions"]).toEqual({
+			kind: "boolean",
+			enabled: false,
+		});
+		expect(c.flags.chrome).toEqual({ kind: "tri-state", state: "unset" });
+		expect(c.flags.effort).toEqual({
+			kind: "select",
+			enabled: false,
+			value: "low",
+		});
+		expect(c.flags["dangerously-load-development-channels"]).toEqual({
+			kind: "text-list",
+			enabled: false,
+			values: ["plugin:claudish@magus"],
+		});
+		expect(c.flags.debug).toEqual({
+			kind: "multi-with-custom",
+			enabled: false,
+			picked: [],
+			custom: [],
+		});
+	});
+
+	it("covers every flag in the catalog", () => {
+		const c = defaultAliasConfig();
+		for (const flag of ALIAS_FLAGS) {
+			expect(c.flags[flag.id]).toBeDefined();
+		}
+	});
+});
+
+describe("defaultValueFor", () => {
+	it("returns the right default for each kind", () => {
+		const ide = ALIAS_FLAGS.find((f) => f.id === "ide")!;
+		expect(defaultValueFor(ide)).toEqual({ kind: "boolean", enabled: false });
+
+		const chrome = ALIAS_FLAGS.find((f) => f.id === "chrome")!;
+		expect(defaultValueFor(chrome)).toEqual({
+			kind: "tri-state",
+			state: "unset",
+		});
+
+		const debug = ALIAS_FLAGS.find((f) => f.id === "debug")!;
+		expect(defaultValueFor(debug)).toEqual({
+			kind: "multi-with-custom",
+			enabled: false,
+			picked: [],
+			custom: [],
+		});
+	});
+});
+
+describe("derivedChannelValues (derive-on-display model)", () => {
+	it("returns dev-load values when the dev-load flag is enabled", () => {
+		const flags: Record<string, FlagValue> = {
+			[DEVLOAD_FLAG_ID]: textList(["plugin:claudish@magus"], true),
+			[CHANNELS_FLAG_ID]: textList([], false),
+		};
+		expect(derivedChannelValues(flags)).toEqual(["plugin:claudish@magus"]);
+	});
+
+	it("returns nothing when the dev-load flag is DISABLED", () => {
+		const flags: Record<string, FlagValue> = {
+			[DEVLOAD_FLAG_ID]: textList(["plugin:claudish@magus"], false),
+			[CHANNELS_FLAG_ID]: textList([], false),
+		};
+		expect(derivedChannelValues(flags)).toEqual([]);
+	});
+
+	it("returns nothing when the dev-load flag is absent", () => {
+		expect(derivedChannelValues({})).toEqual([]);
+	});
+
+	it("does NOT read from channels.values (provenance stays separate)", () => {
+		// channels holds OWN values; dev-load is the only derived source.
+		const flags: Record<string, FlagValue> = {
+			[CHANNELS_FLAG_ID]: textList(["plugin:own@m"], true),
+			[DEVLOAD_FLAG_ID]: textList(["plugin:dev@m"], true),
+		};
+		expect(derivedChannelValues(flags)).toEqual(["plugin:dev@m"]);
+		// channels.values is untouched — own only.
+		expect(listValues(flags[CHANNELS_FLAG_ID])).toEqual(["plugin:own@m"]);
+	});
+});
+
+describe("withoutDerivedChannel (delete-through to dev-load)", () => {
+	it("removes the value from dev-load, NOT from channels.values", () => {
+		const flags: Record<string, FlagValue> = {
+			[CHANNELS_FLAG_ID]: textList(["plugin:own@m"], true),
+			[DEVLOAD_FLAG_ID]: textList(["plugin:dev@m", "plugin:keep@m"], true),
+		};
+		const next = withoutDerivedChannel(flags, "plugin:dev@m");
+		expect(listValues(next[DEVLOAD_FLAG_ID])).toEqual(["plugin:keep@m"]);
+		// channels.values untouched — the deletion landed on the source flag.
+		expect(listValues(next[CHANNELS_FLAG_ID])).toEqual(["plugin:own@m"]);
+	});
+
+	it("disables dev-load when its last value is removed", () => {
+		const flags: Record<string, FlagValue> = {
+			[DEVLOAD_FLAG_ID]: textList(["plugin:only@m"], true),
+		};
+		const next = withoutDerivedChannel(flags, "plugin:only@m");
+		expect(next[DEVLOAD_FLAG_ID]).toEqual({
+			kind: "text-list",
+			enabled: false,
+			values: [],
+		});
+	});
+
+	it("is a no-op when the value isn't present", () => {
+		const flags: Record<string, FlagValue> = {
+			[DEVLOAD_FLAG_ID]: textList(["plugin:a@m"], true),
+		};
+		expect(
+			listValues(withoutDerivedChannel(flags, "nope")[DEVLOAD_FLAG_ID]),
+		).toEqual(["plugin:a@m"]);
+	});
+});
+
+describe("validateAliasName", () => {
+	it("accepts safe identifiers", () => {
+		expect(validateAliasName("c")).toBeNull();
+		expect(validateAliasName("claude")).toBeNull();
+		expect(validateAliasName("cc-yolo_2")).toBeNull();
+		expect(validateAliasName("_underscore")).toBeNull();
+	});
+
+	it("rejects empty, leading-digit, and special-char names", () => {
+		expect(validateAliasName("")).toMatch(/empty/);
+		expect(validateAliasName("9live")).toMatch(/letter/);
+		expect(validateAliasName("c laude")).toMatch(/letters/);
+		expect(validateAliasName("c'")).toMatch(/letters/);
+		expect(validateAliasName("c=d")).toMatch(/letters/);
+	});
+
+	it("rejects pathologically long names", () => {
+		expect(validateAliasName("a".repeat(64))).toMatch(/long/);
+	});
+});

package/src/__tests__/binary-signing.test.ts

@@ -0,0 +1,120 @@
+/**
+ * `services/binary-signing.ts` — the build-time code-signing gate.
+ *
+ * Why this exists at all: `bun build --compile` emits an ad-hoc,
+ * linker-signed Mach-O and then appends the JavaScript bundle to it. The
+ * signature therefore does not cover the file it ships in. `codesign -v`
+ * reported "code or signature have been modified" on every published magus
+ * back to 4.22.0. macOS 27 kills such a binary at exec, with no output, which
+ * is what broke 4.40.0 onward.
+ *
+ * The decision logic lives in `src/` rather than in `scripts/build-binaries.ts`
+ * for one blunt reason: `scripts/test-isolated.ts` only walks `src/`, so a test
+ * placed beside the build script would never be collected and would report
+ * nothing at all.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { appendFileSync, copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	type Run,
+	needsSigning,
+	signAndVerify,
+} from "../services/binary-signing.js";
+
+/** Records every command instead of running one. */
+function recorder(status = 0) {
+	const calls: Array<[string, string[]]> = [];
+	const run: Run = (cmd, args) => {
+		calls.push([cmd, args]);
+		return { status, stderr: "" };
+	};
+	return { calls, run };
+}
+
+describe("binary-signing", () => {
+	test("T-sign-1: a darwin target is signed ad-hoc, then verified", () => {
+		const { calls, run } = recorder();
+		signAndVerify({ os: "darwin" }, "/out/bin/magus", run);
+
+		// Ad-hoc (`--sign -`), not Developer ID: npm-installed files are not
+		// quarantined, so the kernel signature check is the only failing gate.
+		// No Apple account, no CI secrets, no notarization wait.
+		expect(calls).toEqual([
+			["codesign", ["--force", "--sign", "-", "/out/bin/magus"]],
+			["codesign", ["--verify", "--strict", "/out/bin/magus"]],
+		]);
+	});
+
+	test("T-sign-2: a failing codesign is a hard gate, not a warning", () => {
+		// A release that ships an unverifiable binary is the whole defect. The
+		// build must stop, not print and continue.
+		const signFails: Run = (_cmd, args) =>
+			args[0] === "--force"
+				? { status: 1, stderr: "sign failed" }
+				: { status: 0, stderr: "" };
+		expect(() =>
+			signAndVerify({ os: "darwin" }, "/out/bin/magus", signFails),
+		).toThrow();
+
+		const verifyFails: Run = (_cmd, args) =>
+			args[0] === "--verify"
+				? { status: 1, stderr: "verify failed" }
+				: { status: 0, stderr: "" };
+		expect(() =>
+			signAndVerify({ os: "darwin" }, "/out/bin/magus", verifyFails),
+		).toThrow();
+	});
+
+	test("T-sign-3: a linux target runs no codesign at all", () => {
+		// `codesign` does not exist off macOS. Running it would fail the linux
+		// leg of the release matrix for no reason.
+		expect(needsSigning({ os: "linux" })).toBe(false);
+		expect(needsSigning({ os: "darwin" })).toBe(true);
+
+		const { calls, run } = recorder();
+		signAndVerify({ os: "linux" }, "/out/bin/magus", run);
+		expect(calls).toEqual([]);
+	});
+
+	// darwin-only: the subject is the macOS signature format itself. skipIf, not
+	// a bare early return — both CI jobs run on ubuntu, where a return would
+	// execute zero assertions and report green. The macOS coverage of this
+	// invariant in CI comes from the release matrix, which runs the real
+	// signAndVerify during `build:binaries` on both darwin legs.
+	test.skipIf(process.platform !== "darwin")(
+		"T-sign-4: real codesign rejects a signed file with bytes appended",
+		() => {
+			const dir = mkdtempSync(path.join(os.tmpdir(), "magus-signing-"));
+			try {
+				const subject = path.join(dir, "subject");
+				copyFileSync("/bin/echo", subject);
+
+				// Positive control. Without it a passing T-sign-4 would prove only
+				// that codesign fails on this machine for some unrelated reason.
+				expect(() => signAndVerify({ os: "darwin" }, subject)).not.toThrow();
+
+				// Exactly what `bun build --compile` does: append the bundle after
+				// the signature has been written.
+				appendFileSync(subject, "appended-bundle-bytes");
+
+				// Skip the re-sign so the REAL verify judges the corrupted file.
+				const verifyForReal: Run = (cmd, args) => {
+					if (args.includes("--sign")) return { status: 0, stderr: "" };
+					const r = spawnSync(cmd, args, { encoding: "utf8" });
+					return { status: r.status, stderr: r.stderr ?? "" };
+				};
+				// Assert on throwing only. codesign's wording moves between macOS
+				// releases; the verdict does not.
+				expect(() =>
+					signAndVerify({ os: "darwin" }, subject, verifyForReal),
+				).toThrow();
+			} finally {
+				rmSync(dir, { recursive: true, force: true });
+			}
+		},
+	);
+});

package/src/__tests__/blackbox-active-closure.test.ts

@@ -0,0 +1,119 @@
+/**
+ * BLACK-BOX: the one profile choice both front ends resolve through (R2
+ * precondition: "for the same project and profile"). §8.4 contracts only;
+ * IO injected through `loadActiveClosure`'s deps.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type ActiveClosureDeps,
+	loadActiveClosure,
+	selectProfileId,
+} from "../services/active-closure.js";
+import type {
+	BinRequirement,
+	ProfileManifest,
+	ResolvedClosure,
+} from "../types/index.js";
+
+describe("selectProfileId: explicit ?? active ?? the only id ?? null", () => {
+	test.each([
+		{ ids: ["a", "b"], explicit: "b", active: "a", want: "b" },
+		{ ids: ["a", "b"], explicit: "zz", active: "a", want: "a" },
+		{ ids: ["a", "b"], explicit: undefined, active: "b", want: "b" },
+		{ ids: ["a", "b"], explicit: undefined, active: "zz", want: null },
+		{ ids: ["only"], explicit: undefined, active: null, want: "only" },
+		{ ids: ["only"], explicit: "zz", active: "yy", want: "only" },
+		{ ids: ["a", "b"], explicit: undefined, active: null, want: null },
+		{ ids: [], explicit: "a", active: "a", want: null },
+	])(
+		"ids=$ids explicit=$explicit active=$active → $want",
+		({ ids, explicit, active, want }) => {
+			expect(selectProfileId(ids, explicit, active)).toBe(want);
+		},
+	);
+});
+
+function manifest(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			default: { name: "Default", plugins: { "dev@magus": "latest" } },
+			other: { name: "Other", plugins: { "setup@magus": "latest" } },
+		},
+	};
+}
+
+function closureFor(id: string): ResolvedClosure {
+	return {
+		marketplaces: {},
+		plugins: { [`${id}-plugin@magus`]: "latest" },
+		mcpServers: {},
+		bins: [],
+		skills: [],
+		settings: {},
+		env: { required: [], optional: [] },
+	};
+}
+
+describe("loadActiveClosure", () => {
+	test("resolves the active profile through the injected deps", async () => {
+		const resolved: string[] = [];
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => "other",
+			resolveProfile: async (_m, id) => {
+				resolved.push(id);
+				return closureFor(id);
+			},
+		};
+
+		const got = await loadActiveClosure("/proj", { deps });
+
+		expect(got?.profileId).toBe("other");
+		// selectProfileId returns `string | null`; widen the matcher's type so the
+		// comparison type-checks. Runtime assertion unchanged.
+		expect<string | null | undefined>(got?.profileId).toBe(
+			selectProfileId(["default", "other"], undefined, "other"),
+		);
+		expect(got?.closure.plugins).toEqual({ "other-plugin@magus": "latest" });
+		expect(resolved).toEqual(["other"]);
+	});
+
+	test("resolveBins: false hands resolveProfile a bin resolver that yields nothing", async () => {
+		let resolver: ((pluginId: string) => Promise<BinRequirement[]>) | undefined;
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => "default",
+			resolveProfile: async (_m, id, opts) => {
+				resolver = opts?.binResolver;
+				return closureFor(id);
+			},
+		};
+
+		await loadActiveClosure("/proj", { resolveBins: false, deps });
+
+		expect(resolver).toBeDefined();
+		expect(await resolver?.("terminal@magus")).toEqual([]);
+	});
+
+	test("an unreadable manifest yields null and never throws", async () => {
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => {
+				throw new Error("ENOENT profiles.json");
+			},
+			activeProfile: async () => "default",
+		};
+
+		expect(await loadActiveClosure("/proj", { deps })).toBeNull();
+	});
+
+	test("no selectable profile (two profiles, none active) yields null", async () => {
+		const deps: Partial<ActiveClosureDeps> = {
+			readManifest: async () => manifest(),
+			activeProfile: async () => null,
+			resolveProfile: async (_m, id) => closureFor(id),
+		};
+
+		expect(await loadActiveClosure("/proj", { deps })).toBeNull();
+	});
+});