claudeup 4.17.0 → 4.18.0

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

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "bun:test";
+import {
+  defaultAliasConfig,
+  defaultValueFor,
+  validateAliasName,
+  DEFAULT_ALIAS_NAME,
+} from "../services/alias-store";
+import { ALIAS_FLAGS } from "../data/alias-flags";
+
+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("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__/gitignore-fixer.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -50,6 +50,8 @@ describe("applySafeFixes", () => {
     expect(content).toContain(".env");
     expect(content).toContain(".mnemex/");
     expect(content).toContain("# Added by claudeup");
+    expect(content).toContain("Environment files commonly contain");
+    expect(content).toContain("Local memory/index data");
   });
 
   it("creates .gitignore if absent", async () => {
@@ -151,6 +153,67 @@ describe("applyDestructiveFix", () => {
     expect(ls.stdout).toContain(".mcp.json");
   });
 
+  it("adds unignore exceptions when a parent rule ignores a tracked path", async () => {
+    await mkdir(join(repo, ".claude"), { recursive: true });
+    await writeFile(join(repo, ".claude", "settings.json"), "{}");
+    await writeFile(join(repo, ".gitignore"), "/*\n");
+
+    const r = await applyDestructiveFix(repo, {
+      kind: "ignored-but-should-track",
+      path: ".claude/settings.json",
+      source: "builtin",
+      severity: "destructive",
+    });
+    expect(r.applied).toBe(true);
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("!/.claude/");
+    expect(ignore).toContain("!/.claude/settings.json");
+    expect(ignore).toContain("Team Claude settings should be committed");
+
+    const ls = git(repo, "ls-files");
+    expect(ls.stdout).toContain(".claude/settings.json");
+  });
+
+  it("does not fail when making an absent tracked path trackable", async () => {
+    await writeFile(join(repo, ".gitignore"), "/*\n");
+
+    const r = await applyDestructiveFix(repo, {
+      kind: "ignored-but-should-track",
+      path: "plugin.json",
+      source: "builtin",
+      severity: "destructive",
+    });
+    expect(r.applied).toBe(true);
+    expect(r.message).toContain("does not exist yet");
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("!/plugin.json");
+  });
+
+  it("uses the managed rule pattern when untracking child violations", async () => {
+    await mkdir(join(repo, "logs"), { recursive: true });
+    await writeFile(join(repo, "logs", "app.log"), "x");
+    git(repo, "add", "logs/app.log");
+    git(repo, "commit", "-q", "-m", "add log");
+
+    const r = await applyDestructiveFix(
+      repo,
+      {
+        kind: "tracked-but-should-ignore",
+        path: "logs/app.log",
+        source: "builtin",
+        severity: "destructive",
+      },
+      "logs/",
+    );
+    expect(r.applied).toBe(true);
+
+    const ignore = await readFile(join(repo, ".gitignore"), "utf8");
+    expect(ignore).toContain("logs/");
+    expect(ignore).not.toMatch(/^logs\/app\.log$/m);
+  });
+
   it("stages an untracked file", async () => {
     await writeFile(join(repo, ".mcp.json"), "{}");
     const r = await applyDestructiveFix(repo, {

package/src/__tests__/gitignore-prerun.test.ts

@@ -69,7 +69,7 @@ describe("formatPrerunWarning", () => {
   it("returns a warning string when violations exist", () => {
     const w = formatPrerunWarning({ violationCount: 3, warnings: [] });
     expect(w).not.toBeNull();
-    expect(w).toContain("3 gitignore");
-    expect(w).toContain("Gitignore tab");
+    expect(w).toContain("3 git state");
+    expect(w).toContain("Git State tab");
   });
 });

package/src/__tests__/gitignore-service.test.ts

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process";
 import {
   loadGitignoreState,
   applyTemplate,
+  ensureProjectManifestForEdit,
 } from "../services/gitignore-service";
 
 function git(cwd: string, ...args: string[]): void {
@@ -91,3 +92,44 @@ describe("applyTemplate", () => {
     );
   });
 });
+
+describe("ensureProjectManifestForEdit", () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    projectDir = await mkdtemp(join(tmpdir(), "gitig-edit-"));
+  });
+
+  afterEach(async () => {
+    await rm(projectDir, { recursive: true, force: true });
+  });
+
+  it("creates an editable project manifest from resolved rules", async () => {
+    const path = await ensureProjectManifestForEdit(projectDir, {
+      rules: [
+        { pattern: ".env", action: "ignore", source: "builtin" },
+        { pattern: ".mcp.json", action: "track", source: "builtin" },
+      ],
+      conflicts: [],
+    });
+
+    expect(path).toBe(join(projectDir, ".claude", "gitignore.json"));
+    const written = JSON.parse(await readFile(path, "utf8"));
+    expect(written.ignore).toEqual([".env"]);
+    expect(written.track).toEqual([".mcp.json"]);
+  });
+
+  it("keeps an existing non-empty project manifest", async () => {
+    const path = join(projectDir, ".claude", "gitignore.json");
+    await mkdir(join(projectDir, ".claude"), { recursive: true });
+    await writeFile(path, JSON.stringify({ ignore: ["custom"], track: [] }));
+
+    await ensureProjectManifestForEdit(projectDir, {
+      rules: [{ pattern: ".env", action: "ignore", source: "builtin" }],
+      conflicts: [],
+    });
+
+    const written = JSON.parse(await readFile(path, "utf8"));
+    expect(written.ignore).toEqual(["custom"]);
+  });
+});

package/src/__tests__/marketplaces.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "bun:test";
+import {
+	defaultMarketplaces,
+	deprecatedMarketplaces,
+	getAllMarketplaces,
+} from "../data/marketplaces.js";
+import type { LocalMarketplace } from "../services/local-marketplace.js";
+
+describe("marketplaces", () => {
+	it("uses the canonical Superpowers marketplace by default", () => {
+		const superpowers = defaultMarketplaces.find(
+			(mp) => mp.name === "superpowers-marketplace",
+		);
+
+		expect(superpowers).toBeDefined();
+		expect(superpowers?.displayName).toBe("Superpowers");
+		expect(superpowers?.source.repo).toBe("obra/superpowers-marketplace");
+		expect(superpowers?.featured).toBe(true);
+		expect(deprecatedMarketplaces.superpowers).toBe("superpowers-marketplace");
+	});
+
+	it("hides stale local superpowers entries behind the canonical marketplace", () => {
+		const local = new Map<string, LocalMarketplace>([
+			[
+				"superpowers",
+				{
+					name: "superpowers-dev",
+					description: "Development marketplace",
+					gitRepo: "obra/superpowers",
+					plugins: [],
+				},
+			],
+		]);
+
+		const names = getAllMarketplaces(local).map((mp) => mp.name);
+
+		expect(names).toContain("superpowers-marketplace");
+		expect(names).not.toContain("superpowers");
+	});
+});

package/src/__tests__/plugin-manager-fallback.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+  resolveMarketplacePlugins,
+  clearMarketplaceCache,
+} from "../services/marketplace-fetcher";
+import type {
+  LocalMarketplace,
+  LocalMarketplacePlugin,
+} from "../services/local-marketplace";
+
+/**
+ * Regression coverage for the "deprecated everything" bug.
+ *
+ * When `fetchMarketplacePlugins` returns an empty list (network down,
+ * repo moved, GitHub blocked, etc.), the orphan-detection loop in
+ * `getAvailablePlugins` would flag every installed plugin as
+ * `isOrphaned: true` and the UI rendered them all as "deprecated".
+ *
+ * `resolveMarketplacePlugins` adds the local-marketplace cache as a
+ * fallback so installed plugins keep rendering with their real metadata
+ * even when the machine is offline.
+ */
+
+function buildLocalMarketplace(
+  name: string,
+  plugins: LocalMarketplacePlugin[],
+): LocalMarketplace {
+  return { name, description: "", plugins };
+}
+
+describe("resolveMarketplacePlugins — offline fallback", () => {
+  beforeEach(() => {
+    // Session-level cache could otherwise carry over a previous test's
+    // successful fetch and short-circuit the fallback path.
+    clearMarketplaceCache();
+  });
+
+  it("falls back to the local cache when the remote fetch returns empty", async () => {
+    const local = new Map<string, LocalMarketplace>([
+      [
+        "magus",
+        buildLocalMarketplace("magus", [
+          {
+            name: "code-analysis",
+            version: "5.3.0",
+            description: "Codebase investigation tools",
+            category: "development",
+            author: { name: "Jack Rudenko" },
+          },
+          {
+            name: "dev",
+            version: "2.7.0",
+            description: "Dev workflow",
+          },
+        ]),
+      ],
+    ]);
+
+    // An invalid repo string short-circuits `fetchMarketplacePlugins` to
+    // `[]` without any network call, simulating the offline case.
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+
+    expect(resolved).toHaveLength(2);
+    expect(resolved.map((p) => p.name).sort()).toEqual([
+      "code-analysis",
+      "dev",
+    ]);
+    const codeAnalysis = resolved.find((p) => p.name === "code-analysis");
+    expect(codeAnalysis?.version).toBe("5.3.0");
+    expect(codeAnalysis?.description).toBe("Codebase investigation tools");
+    expect(codeAnalysis?.category).toBe("development");
+    expect(codeAnalysis?.author?.name).toBe("Jack Rudenko");
+  });
+
+  it("returns empty when both remote and cache are empty", async () => {
+    const local = new Map<string, LocalMarketplace>();
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+
+  it("returns empty when remote fails AND cache exists but has no plugins", async () => {
+    const local = new Map<string, LocalMarketplace>([
+      ["magus", buildLocalMarketplace("magus", [])],
+    ]);
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+
+  it("does not consult the cache when the remote returns plugins", async () => {
+    // We can't easily exercise the success branch without a live network,
+    // but we can verify that a cache entry for a DIFFERENT marketplace
+    // doesn't bleed into the requested one.
+    const local = new Map<string, LocalMarketplace>([
+      [
+        "other-marketplace",
+        buildLocalMarketplace("other-marketplace", [
+          { name: "should-not-leak", version: "0.0.1", description: "" },
+        ]),
+      ],
+    ]);
+    const resolved = await resolveMarketplacePlugins(
+      "magus",
+      "not a valid repo string",
+      local,
+    );
+    expect(resolved).toEqual([]);
+  });
+});

package/src/__tests__/useGitignoreModal.test.ts

@@ -31,7 +31,7 @@ describe("buildGitignoreModal", () => {
     expect(dismissed).toBe(true);
   });
 
-  it("shows '(no safe-fixable entries)' label when safeCount is 0", () => {
+  it("shows no missing entries label when safeCount is 0", () => {
     const modal = buildGitignoreModal({
       violationCount: 2,
       safeCount: 0,
@@ -40,7 +40,7 @@ describe("buildGitignoreModal", () => {
       onDismiss: () => {},
     });
     if (modal.type !== "select") throw new Error("type guard");
-    expect(modal.options[0].label).toContain("no safe-fixable");
+    expect(modal.options[0].label).toContain("no missing .gitignore");
   });
 
   it("includes violation count in the message", () => {

package/src/data/alias-flags.js

@@ -0,0 +1,196 @@
+/**
+ * Catalog of `claude` CLI flags that the Alias tab can compose into a managed
+ * shell alias. Verified against `claude --help` output and binary string scan
+ * of the shipped Claude Code 2.1.x binary.
+ *
+ * The catalog drives both the UI editor for each flag and the renderer that
+ * emits the final `alias claude='claude …'` string per shell.
+ */
+/**
+ * Tokens supported in `templated: true` flag values. Description text is
+ * shown to the user; the actual shell-substitution code lives in the writer
+ * because it needs per-shell variants.
+ *
+ * Intentionally excludes `{hash}` for v1 — its only portable form is
+ * `od -An -N4 -tx1 /dev/urandom | tr -d ' \n'`, which looks frightening in a
+ * shell rc file. Users who want randomness can pair this prefix with bare
+ * `--remote-control` (which already auto-generates a unique suffix).
+ */
+export const TEMPLATE_TOKENS = [
+    { token: "{folder}", description: "current directory's basename" },
+    { token: "{day}", description: "day of month, zero-padded (01-31)" },
+    { token: "{month}", description: "month, zero-padded (01-12)" },
+    { token: "{year}", description: "4-digit year" },
+];
+export const FLAG_GROUPS = [
+    { id: "danger", label: "Permissions" },
+    { id: "session", label: "Session" },
+    { id: "context", label: "Context" },
+    { id: "channels", label: "Development channels" },
+    { id: "debug", label: "Debug" },
+    { id: "integration", label: "Integrations" },
+    { id: "worktree", label: "Worktree" },
+];
+export const ALIAS_FLAGS = [
+    {
+        id: "dangerously-skip-permissions",
+        label: "Skip permission checks",
+        flag: "--dangerously-skip-permissions",
+        kind: "boolean",
+        group: "danger",
+        description: "Bypass all permission checks. Recommended only for sandboxes with no internet access.",
+    },
+    {
+        id: "allow-dangerously-skip-permissions",
+        label: "Allow skip-permissions opt-in",
+        flag: "--allow-dangerously-skip-permissions",
+        kind: "boolean",
+        group: "danger",
+        description: "Enable the skip-permissions option without making it the default.",
+    },
+    {
+        id: "remote-control",
+        label: "Remote control",
+        flag: "--remote-control",
+        kind: "boolean",
+        group: "session",
+        description: "Start an interactive session with Remote Control enabled. Claude Code auto-generates a unique session name; use --remote-control-session-name-prefix to customize it.",
+    },
+    {
+        id: "remote-control-session-name-prefix",
+        label: "Remote control name prefix",
+        flag: "--remote-control-session-name-prefix",
+        kind: "text",
+        templated: true,
+        group: "session",
+        description: "Prefix for auto-generated Remote Control session names. Default: hostname. Supports template tokens that expand on each shell invocation: {folder} (basename of $PWD), {day}, {month}, {year}. Example: dev-{folder}-{day} → dev-myproject-15.",
+    },
+    {
+        id: "ide",
+        label: "Auto-connect to IDE",
+        flag: "--ide",
+        kind: "boolean",
+        group: "integration",
+        description: "Automatically connect to IDE on startup if exactly one valid IDE is available.",
+    },
+    {
+        id: "chrome",
+        label: "Chrome integration",
+        flag: "--chrome",
+        triStateOff: "--no-chrome",
+        kind: "tri-state",
+        group: "integration",
+        description: "Enable or disable Claude in Chrome integration. Unset leaves the project default in place.",
+    },
+    {
+        id: "effort",
+        label: "Effort level",
+        flag: "--effort",
+        kind: "select",
+        group: "session",
+        description: "Effort level for the current session.",
+        options: [
+            { label: "low", value: "low" },
+            { label: "medium", value: "medium" },
+            { label: "high", value: "high" },
+            { label: "xhigh", value: "xhigh" },
+            { label: "max", value: "max" },
+        ],
+    },
+    {
+        id: "system-prompt",
+        label: "System prompt",
+        flag: "--system-prompt",
+        kind: "text",
+        group: "context",
+        xorGroup: "system-prompt",
+        description: "System prompt text to use for the session. Mutually exclusive with --system-prompt-file.",
+    },
+    {
+        id: "system-prompt-file",
+        label: "System prompt file",
+        flag: "--system-prompt-file",
+        kind: "text",
+        group: "context",
+        xorGroup: "system-prompt",
+        description: "Path to a file whose contents replace the default system prompt. Mutually exclusive with --system-prompt.",
+    },
+    {
+        id: "append-system-prompt",
+        label: "Append system prompt",
+        flag: "--append-system-prompt",
+        kind: "text",
+        group: "context",
+        description: "Text appended to the default system prompt. Composes with --system-prompt.",
+    },
+    {
+        id: "append-system-prompt-file",
+        label: "Append system prompt file",
+        flag: "--append-system-prompt-file",
+        kind: "text",
+        group: "context",
+        description: "Path to a file whose contents are appended to the default system prompt.",
+    },
+    {
+        id: "dangerously-load-development-channels",
+        label: "Load development channels",
+        flag: "--dangerously-load-development-channels",
+        kind: "text-list",
+        group: "channels",
+        description: "Sideload development channels from magus plugins. Default seed: claudish (the only magus plugin currently shipping channels).",
+        defaultValues: ["plugin:claudish@magus"],
+    },
+    {
+        id: "debug",
+        label: "Debug categories",
+        flag: "--debug",
+        shortFlag: "-d",
+        kind: "multi-with-custom",
+        group: "debug",
+        description: "Enable debug mode with optional category filter. Pick from common categories or add custom tokens (including negations like !file).",
+        picklist: [
+            "api",
+            "hooks",
+            "mcp",
+            "tools",
+            "plugins",
+            "skills",
+            "settings",
+            "permissions",
+            "auth",
+            "cache",
+            "statsig",
+            "file",
+            "1p",
+        ],
+        defaultValues: [],
+    },
+    {
+        id: "worktree",
+        label: "Use worktree",
+        flag: "--worktree",
+        kind: "boolean",
+        group: "worktree",
+        description: "Create a git worktree for the session. Prerequisite for --tmux.",
+    },
+    {
+        id: "tmux",
+        label: "tmux session",
+        flag: "--tmux",
+        kind: "select",
+        group: "worktree",
+        requires: "worktree",
+        description: "Create a tmux session for the worktree. Requires --worktree. iTerm2 native panes when available; classic for traditional tmux.",
+        options: [
+            { label: "auto (iTerm2 native)", value: "" },
+            { label: "classic", value: "classic" },
+        ],
+    },
+];
+/** Look up a flag by id. Throws if missing — keeps callers honest. */
+export function getFlagById(id) {
+    const f = ALIAS_FLAGS.find((flag) => flag.id === id);
+    if (!f)
+        throw new Error(`Unknown alias flag id: ${id}`);
+    return f;
+}