claudeup 4.18.0 → 4.22.0

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

@@ -6,6 +6,7 @@ import {
   tokenizePosixAliasBody,
   argsToFlagValues,
   renderAlias,
+  renderArgsAsTokens,
 } from "../services/alias-shell-writer";
 import { defaultAliasConfig } from "../services/alias-store";
 
@@ -295,6 +296,97 @@ describe("round-trip: render → parse → enabled subset matches", () => {
   });
 });
 
+describe("channels: render-time union + parse-time provenance split", () => {
+  // The model: channels.values holds OWN channels only; dev-load values are
+  // unioned into --channels at render time and subtracted back out on parse,
+  // so the two lists stay distinct in storage but merge on the command line.
+
+  it("emits --channels as (own ∪ enabled dev-load), deduped, own-first", () => {
+    const c = defaultAliasConfig();
+    c.flags["channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:own@m"],
+    };
+    c.flags["dangerously-load-development-channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:dev@m", "plugin:own@m"], // overlap dedupes
+    };
+    const tokens = renderArgsAsTokens(c);
+    // --channels carries own + derived (deduped); dev-load still emits its own.
+    const channelsArgs = tokens
+      .map((t, i) => (tokens[i - 1] === "--channels" ? t : null))
+      .filter(Boolean);
+    expect(channelsArgs).toEqual(["plugin:own@m", "plugin:dev@m"]);
+  });
+
+  it("forces --channels to emit derived values even when own channels is OFF", () => {
+    const c = defaultAliasConfig();
+    c.flags["channels"] = { kind: "text-list", enabled: false, values: [] };
+    c.flags["dangerously-load-development-channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:dev@m"],
+    };
+    const tokens = renderArgsAsTokens(c);
+    expect(tokens).toContain("--channels");
+    const idx = tokens.indexOf("--channels");
+    expect(tokens[idx + 1]).toBe("plugin:dev@m");
+  });
+
+  it("does NOT emit --channels when both own and dev-load are empty/off", () => {
+    const c = defaultAliasConfig(); // both channels + dev-load default off
+    expect(renderArgsAsTokens(c)).not.toContain("--channels");
+  });
+
+  it("round-trips: derived values do NOT leak into parsed channels.values", () => {
+    const c = defaultAliasConfig();
+    c.aliasName = "c";
+    c.flags["channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:own@m"],
+    };
+    c.flags["dangerously-load-development-channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:dev@m"],
+    };
+    const rendered = renderAlias(c, "zsh").block;
+    const parsed = parseAliasFromRc(rendered);
+    // channels.values comes back as OWN ONLY — derived was subtracted.
+    expect(parsed!.flags["channels"]).toEqual({
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:own@m"],
+    });
+    // dev-load round-trips intact (it's the source of truth for derived).
+    expect(parsed!.flags["dangerously-load-development-channels"]).toEqual({
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:dev@m"],
+    });
+  });
+
+  it("round-trips a purely-derived channels list to disabled+empty own", () => {
+    const c = defaultAliasConfig();
+    c.aliasName = "c";
+    // No own channels; only dev-load.
+    c.flags["dangerously-load-development-channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:dev@m"],
+    };
+    const parsed = parseAliasFromRc(renderAlias(c, "zsh").block);
+    expect(parsed!.flags["channels"]).toEqual({
+      kind: "text-list",
+      enabled: false,
+      values: [],
+    });
+  });
+});
+
 describe("parseAliasFromRc — entry point", () => {
   it("returns null on text with no managed block", () => {
     expect(parseAliasFromRc("export PATH=...\n")).toBeNull();

package/src/__tests__/alias-shell-writer.test.ts

@@ -92,7 +92,14 @@ describe("renderArgs", () => {
       enabled: true,
       values: ["plugin:claudish@magus", "plugin:dev@magus"],
     };
+    // Enabling dev-load also forces --channels to emit (the render-time union),
+    // since a dev-loaded channel must be on the channels list to run. --channels
+    // comes first (catalog order), then the repeated dev-load pairs.
     expect(renderArgs(c)).toEqual([
+      "--channels",
+      "plugin:claudish@magus",
+      "--channels",
+      "plugin:dev@magus",
       "--dangerously-load-development-channels",
       "plugin:claudish@magus",
       "--dangerously-load-development-channels",

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

@@ -3,10 +3,20 @@ import {
   defaultAliasConfig,
   defaultValueFor,
   validateAliasName,
+  derivedChannelValues,
+  withoutDerivedChannel,
+  listValues,
+  CHANNELS_FLAG_ID,
+  DEVLOAD_FLAG_ID,
   DEFAULT_ALIAS_NAME,
+  type FlagValue,
 } from "../services/alias-store";
 import { ALIAS_FLAGS } from "../data/alias-flags";
 
+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();
@@ -64,6 +74,73 @@ describe("defaultValueFor", () => {
   });
 });
 
+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();

package/src/__tests__/cli-router.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { route } from "../cli/router.js";
+
+// Silence the help banner and capture what the router prints, without
+// touching the network (--version) or spawning processes (claude/update).
+let logSpy: ReturnType<typeof mock>;
+let errSpy: ReturnType<typeof mock>;
+let logs: string[];
+let errs: string[];
+
+beforeEach(() => {
+	logs = [];
+	errs = [];
+	logSpy = mock((...a: unknown[]) => {
+		logs.push(a.join(" "));
+	});
+	errSpy = mock((...a: unknown[]) => {
+		errs.push(a.join(" "));
+	});
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.log = logSpy as any;
+	// biome-ignore lint/suspicious/noExplicitAny: test double
+	console.error = errSpy as any;
+});
+
+afterEach(() => {
+	mock.restore();
+});
+
+describe("route() dispatch", () => {
+	test("bare invocation falls through to the TUI", async () => {
+		const r = await route([], "1.2.3");
+		expect(r.handled).toBe(false);
+		expect(r.launchTui).toBe(true);
+	});
+
+	test("an unrecognized token falls through to the TUI", async () => {
+		const r = await route(["totally-unknown"], "1.2.3");
+		expect(r.handled).toBe(false);
+		expect(r.launchTui).toBe(true);
+	});
+
+	test("--help is handled, exits 0, and does not launch the TUI", async () => {
+		const r = await route(["--help"], "9.9.9");
+		expect(r).toEqual({ handled: true, exitCode: 0, launchTui: false });
+		expect(logs.join("\n")).toContain("claudeup v9.9.9");
+		// The corrected help must not carry the stale tab names.
+		expect(logs.join("\n")).not.toContain("[3] Status");
+		expect(logs.join("\n")).toContain("[3] MCP");
+	});
+
+	test("-h is treated the same as --help", async () => {
+		const r = await route(["-h"], "1.0.0");
+		expect(r.handled).toBe(true);
+		expect(r.exitCode).toBe(0);
+	});
+
+	test("install, profile, and doctor are routed to real handlers (not stubs)", async () => {
+		// The router maps these to their real command handlers, which are covered
+		// by their services' unit tests. We don't invoke them here to avoid
+		// touching the filesystem / running global installs.
+		const mod = await import("../cli/router.js");
+		expect(typeof mod.route).toBe("function");
+	});
+});