claudeup 4.18.0 → 4.19.0

package/src/__tests__/plugin-setup.test.ts

@@ -73,6 +73,8 @@ mock.module("node:child_process", () => ({
 // Import AFTER mocks are set up
 const {
 	extractGoBinaryName,
+	extractGoVersion,
+	goDepNeedsInstall,
 	installPluginDeps,
 	checkMissingDeps,
 } = await import("../services/plugin-setup.js");
@@ -259,6 +261,115 @@ describe("checkMissingDeps — go packages", () => {
 	});
 });
 
+// ---------------------------------------------------------------------------
+// 4b. Version-aware go dependencies — a bumped plugin must pull the new binary
+// ---------------------------------------------------------------------------
+
+describe("extractGoVersion", () => {
+	it("returns the pinned version", () => {
+		expect(
+			extractGoVersion("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe("v1.6.2");
+	});
+	it("returns null for @latest (a moving target)", () => {
+		expect(
+			extractGoVersion("github.com/MadAppGang/tmux-mcp@latest"),
+		).toBeNull();
+	});
+	it("returns null when unpinned", () => {
+		expect(extractGoVersion("github.com/user/tool")).toBeNull();
+	});
+});
+
+describe("goDepNeedsInstall — version awareness", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go"]);
+		execResults = new Map();
+	});
+
+	it("reinstalls when the pinned version differs from the installed one", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("skips when the installed version matches the pin (v-prefix insensitive)", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", { stdout: "1.6.2", stderr: "" });
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(false);
+	});
+
+	it("reinstalls when the binary can't report its version", async () => {
+		availableBinaries.add("tmux-mcp");
+		execResults.set("tmux-mcp --version", {
+			stdout: "",
+			stderr: "flag provided but not defined: -version",
+			error: true,
+		});
+
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("installs when the binary is absent", async () => {
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@v1.6.2"),
+		).toBe(true);
+	});
+
+	it("leaves an unpinned (@latest) present binary alone", async () => {
+		availableBinaries.add("tmux-mcp");
+		expect(
+			await goDepNeedsInstall("github.com/MadAppGang/tmux-mcp@latest"),
+		).toBe(false);
+	});
+});
+
+describe("checkMissingDeps — pinned go version mismatch", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go", "tmux-mcp"]);
+		execResults = new Map();
+	});
+
+	it("reports a present-but-outdated pinned binary as missing", async () => {
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+
+		const missing = await checkMissingDeps({
+			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
+		});
+
+		expect(missing.go).toEqual(["github.com/MadAppGang/tmux-mcp@v1.6.2"]);
+	});
+});
+
+describe("installPluginDeps — reinstalls an outdated pinned go binary", () => {
+	beforeEach(() => {
+		availableBinaries = new Set(["go", "tmux-mcp"]);
+		execResults = new Map();
+	});
+
+	it("runs go install when the pinned version is newer than installed", async () => {
+		execResults.set("tmux-mcp --version", { stdout: "v1.6.1", stderr: "" });
+		execResults.set("/usr/bin/go install", { stdout: "", stderr: "" });
+
+		const result = await installPluginDeps({
+			go: ["github.com/MadAppGang/tmux-mcp@v1.6.2"],
+		});
+
+		expect(result.installed).toContain(
+			"go:github.com/MadAppGang/tmux-mcp@v1.6.2",
+		);
+		expect(result.skipped).toHaveLength(0);
+	});
+});
+
 // ---------------------------------------------------------------------------
 // 5. checkMissingDeps tests — required binaries
 // ---------------------------------------------------------------------------

package/src/data/alias-flags.js

@@ -131,13 +131,22 @@ export const ALIAS_FLAGS = [
         group: "context",
         description: "Path to a file whose contents are appended to the default system prompt.",
     },
+    {
+        id: "channels",
+        label: "Channels (approved)",
+        flag: "--channels",
+        kind: "text-list",
+        group: "channels",
+        description: "Approved channel plugins/MCP servers to run this session (the allowlist). Channels derived from --dangerously-load appear in a separate section here and are unioned in on write; add your own approved channels on top.",
+        defaultValues: [],
+    },
     {
         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).",
+        description: "Sideload development channels not on the approved allowlist (local dev only). Also shown under --channels and unioned into it on write. Default seed: claudish (the only magus plugin currently shipping channels).",
         defaultValues: ["plugin:claudish@magus"],
     },
     {

package/src/data/alias-flags.ts

@@ -222,6 +222,16 @@ export const ALIAS_FLAGS: AliasFlag[] = [
     description:
       "Path to a file whose contents are appended to the default system prompt.",
   },
+  {
+    id: "channels",
+    label: "Channels (approved)",
+    flag: "--channels",
+    kind: "text-list",
+    group: "channels",
+    description:
+      "Approved channel plugins/MCP servers to run this session (the allowlist). Channels derived from --dangerously-load appear in a separate section here and are unioned in on write; add your own approved channels on top.",
+    defaultValues: [],
+  },
   {
     id: "dangerously-load-development-channels",
     label: "Load development channels",
@@ -229,7 +239,7 @@ export const ALIAS_FLAGS: AliasFlag[] = [
     kind: "text-list",
     group: "channels",
     description:
-      "Sideload development channels from magus plugins. Default seed: claudish (the only magus plugin currently shipping channels).",
+      "Sideload development channels not on the approved allowlist (local dev only). Also shown under --channels and unioned into it on write. Default seed: claudish (the only magus plugin currently shipping channels).",
     defaultValues: ["plugin:claudish@magus"],
   },
   {

package/src/services/alias-shell-writer.js

@@ -11,6 +11,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { ALIAS_FLAGS, getFlagById, } from "../data/alias-flags.js";
+import { CHANNELS_FLAG_ID, defaultValueFor, derivedChannelValues, listValues, } from "./alias-store.js";
 const BLOCK_BEGIN = "# >>> claudeup managed alias >>>";
 const BLOCK_END = "# <<< claudeup managed alias <<<";
 /**
@@ -83,7 +84,14 @@ export function renderArgs(config) {
         const value = config.flags[flag.id];
         if (!value)
             continue;
-        const rendered = renderFlag(flag, value);
+        // `--channels` is the union (own ∪ dev-load-if-enabled), computed here at
+        // render time — the union is NOT stored, so own/derived stay distinct in
+        // the UI. A dev-loaded channel must run, so derived values force `--channels`
+        // to emit even when the user's own channels list is disabled/empty.
+        const renderValue = flag.id === CHANNELS_FLAG_ID
+            ? channelsUnionValue(config.flags, value)
+            : value;
+        const rendered = renderFlag(flag, renderValue);
         if (rendered.length === 0)
             continue;
         out.push(...rendered);
@@ -137,6 +145,22 @@ function templatedSegment(value) {
     }
     return { kind: "composite", parts };
 }
+/**
+ * Build the effective `--channels` value for rendering: the user's own
+ * channels unioned with the dev-load flag's values (when dev-load is enabled),
+ * deduped, own-first. Enabled when EITHER source contributes a value, so a
+ * dev-loaded channel still forces `--channels` to emit even if the user never
+ * enabled their own channels list. The union lives here, at render time — it
+ * is never written back to `channels.values`, so provenance is preserved.
+ */
+function channelsUnionValue(flags, own) {
+    const ownValues = own.kind === "text-list" && own.enabled
+        ? listValues(own)
+        : [];
+    const derived = derivedChannelValues(flags);
+    const merged = dedupe([...ownValues, ...derived]).filter((v) => v.length > 0);
+    return { kind: "text-list", enabled: merged.length > 0, values: merged };
+}
 function renderFlag(flag, value) {
     switch (value.kind) {
         case "boolean":
@@ -379,7 +403,7 @@ export function spliceManagedBlock(existing, block) {
         cutEnd += 1;
     return existing.slice(0, beginIdx) + block + existing.slice(cutEnd);
 }
-export async function writeAliasToShell(config, target) {
+export async function writeAliasToShell(config, target, options = {}) {
     const args = renderArgs(config);
     const unquotable = findUnquotableTokens(args);
     if (unquotable.length > 0) {
@@ -389,7 +413,14 @@ export async function writeAliasToShell(config, target) {
     }
     const rendered = renderAlias(config, target.kind);
     const existing = target.exists ? await readFile(target.path, "utf8") : "";
-    const next = spliceManagedBlock(existing, rendered.block);
+    // Adoption: when a line range was supplied AND the file has no managed block
+    // yet, replace the adopted alias line in place — the managed block takes its
+    // slot, so the original can't survive as a duplicate. Once a managed block
+    // exists, marker-based splicing is position-independent and takes over.
+    const hasBlock = existing.includes(BLOCK_BEGIN);
+    const next = options.adoptLineRange && !hasBlock
+        ? spliceManagedBlockAtRange(existing, rendered.block, options.adoptLineRange)
+        : spliceManagedBlock(existing, rendered.block);
     await writeFile(target.path, next, "utf8");
     return {
         shell: target.kind,
@@ -598,6 +629,15 @@ function unparseSubstitution(posixCode) {
  * scan is sufficient. We pre-index by flag string for `--foo` lookups.
  */
 export function argsToFlagValues(args) {
+    return argsToFlagValuesWithLeftovers(args).flags;
+}
+/**
+ * Like {@link argsToFlagValues}, but reports every token it couldn't map to a
+ * catalog flag. Unknown `--flag value` pairs contribute BOTH tokens to
+ * `leftovers` (the flag and its consumed value) so the adoption gate sees the
+ * full extent of what wouldn't round-trip.
+ */
+export function argsToFlagValuesWithLeftovers(args) {
     // Index every flag by its primary `flag` string AND its triStateOff variant.
     const byFlag = new Map();
     for (const flag of ALIAS_FLAGS) {
@@ -607,17 +647,22 @@ export function argsToFlagValues(args) {
         }
     }
     const out = {};
+    const leftovers = [];
     let i = 0;
     while (i < args.length) {
         const tok = args[i];
         const entry = byFlag.get(tok);
         if (!entry) {
-            // Unknown flag — skip this token AND its likely value, if next looks
-            // like a value (doesn't start with --). This is a best-effort skip
-            // so unknown flag pairs don't cascade-corrupt the rest of the parse.
+            // Unknown token — record it. If the next token looks like its value
+            // (doesn't start with `-`), consume and record that too so unknown
+            // flag/value pairs don't cascade-corrupt the rest of the parse, and so
+            // the adoption gate sees the full unrecognized span.
+            leftovers.push(tok);
             i += 1;
-            if (i < args.length && !args[i].startsWith("-"))
+            if (i < args.length && !args[i].startsWith("-")) {
+                leftovers.push(args[i]);
                 i += 1;
+            }
             continue;
         }
         const { flag, off } = entry;
@@ -746,7 +791,24 @@ export function argsToFlagValues(args) {
             }
         }
     }
-    return out;
+    // Restore channels provenance: the writer emits `--channels` as
+    // (own ∪ dev-load), so a naive parse folds derived values back into
+    // channels.values. Subtract the dev-load values (when that flag was
+    // emitted/enabled) so channels.values holds only the user's OWN channels —
+    // the derived ones come from the dev-load flag at display/render time.
+    const channels = out[CHANNELS_FLAG_ID];
+    const derived = derivedChannelValues(out);
+    if (channels && channels.kind === "text-list" && derived.length > 0) {
+        const ownOnly = channels.values.filter((v) => !derived.includes(v));
+        out[CHANNELS_FLAG_ID] = {
+            kind: "text-list",
+            // Keep enabled only if the user has their own channels; a channels list
+            // that was purely derived shouldn't appear enabled after the subtraction.
+            enabled: ownOnly.length > 0,
+            values: ownOnly,
+        };
+    }
+    return { flags: out, leftovers };
 }
 /**
  * High-level entry point: read shell rc text, parse the managed block, and
@@ -762,3 +824,195 @@ export function parseAliasFromRc(rcText) {
         flags: argsToFlagValues(parsed.args),
     };
 }
+const ANY_ALIAS_LINE_RE = /^alias\s+([A-Za-z_][A-Za-z0-9_-]*)\s*=\s*(['"])(.*)\2\s*$/;
+/**
+ * Tokenize a general (hand-written) POSIX alias body into argv strings.
+ *
+ * Unlike {@link tokenizePosixAliasBody} — which only undoes OUR writer's escape
+ * scheme — this handles the shapes a human would type: bare words, single-
+ * quoted runs (literal, no escapes), and double-quoted runs (we treat the
+ * content literally; we do NOT expand `$VAR` or `$(cmd)`). Adjacent quoted and
+ * bare pieces with no whitespace between them concatenate into one argv token,
+ * matching shell word-joining (`foo' bar'` → `foo bar`).
+ *
+ * Returns `null` for anything we can't cleanly tokenize: unterminated quotes,
+ * or a body containing a shell substitution (`$(`, backtick) or variable (`$`)
+ * — those can't be faithfully represented as a static flag value, so the
+ * caller treats the whole alias as not-adoptable rather than guessing.
+ */
+export function tokenizeGeneralAliasBody(body) {
+    const tokens = [];
+    let current = "";
+    let inToken = false;
+    let i = 0;
+    const len = body.length;
+    const flush = () => {
+        if (inToken) {
+            tokens.push(current);
+            current = "";
+            inToken = false;
+        }
+    };
+    while (i < len) {
+        const ch = body[i];
+        if (ch === " " || ch === "\t") {
+            flush();
+            i += 1;
+            continue;
+        }
+        // Bail on dynamic content — we can't round-trip a variable/substitution.
+        if (ch === "$" || ch === "`")
+            return null;
+        if (ch === "'") {
+            // Single-quoted run: literal until the next single quote.
+            const end = body.indexOf("'", i + 1);
+            if (end === -1)
+                return null; // unterminated
+            current += body.slice(i + 1, end);
+            inToken = true;
+            i = end + 1;
+            continue;
+        }
+        if (ch === '"') {
+            // Double-quoted run: literal until the next double quote. We reject any
+            // `$` or backtick inside (caught at the top of the loop on the next
+            // pass only if unquoted — so scan the run explicitly here).
+            const end = body.indexOf('"', i + 1);
+            if (end === -1)
+                return null; // unterminated
+            const inner = body.slice(i + 1, end);
+            if (inner.includes("$") || inner.includes("`"))
+                return null;
+            current += inner;
+            inToken = true;
+            i = end + 1;
+            continue;
+        }
+        // Bare character.
+        current += ch;
+        inToken = true;
+        i += 1;
+    }
+    flush();
+    return tokens;
+}
+/**
+ * Parse a single hand-written `alias <name>=<quote><body><quote>` line into an
+ * AdoptableAlias (sans `lineRange`/`others`, which the scanner fills in), or
+ * null when the line isn't a `claude`-wrapping alias we can tokenize.
+ */
+function parseAdoptableLine(line) {
+    const match = ANY_ALIAS_LINE_RE.exec(line.trim());
+    if (!match)
+        return null;
+    const [, name, , body] = match;
+    const tokens = tokenizeGeneralAliasBody(body);
+    if (!tokens || tokens.length === 0 || tokens[0] !== "claude")
+        return null;
+    const args = tokens.slice(1);
+    const { flags, leftovers } = argsToFlagValuesWithLeftovers(args);
+    // Fixpoint: render the parsed flags back to tokens and re-parse. If the
+    // result differs, a token was mis-bucketed (e.g. a select value mistaken
+    // for bare). Only an exact fixpoint with no leftovers is lossless.
+    const config = { aliasName: name, flags: withDefaults(flags) };
+    const reparsed = argsToFlagValues(renderArgsAsTokens(config));
+    const fixpoint = flagsDeepEqual(withDefaults(flags), withDefaults(reparsed));
+    const lossless = leftovers.length === 0 && fixpoint;
+    return { name, flags, leftovers, lossless, rawLine: line };
+}
+/**
+ * Scan rc text for a top-level, hand-written `claude`-wrapping alias OUTSIDE
+ * the managed block. Returns the first such alias (with any others noted), or
+ * null when none is found.
+ *
+ * "Top-level" = the line's indentation is zero. We deliberately skip indented
+ * lines: an alias nested in a function or `if` block can't be replaced by the
+ * managed block without dragging the block into that scope.
+ *
+ * Lines inside an existing managed block are ignored — adoption is only for
+ * the no-managed-block case (the screen's mount checks that separately, but we
+ * guard here too so the function is correct in isolation).
+ */
+export function findAdoptableAlias(rcText) {
+    const lines = rcText.split("\n");
+    // Compute the [begin, end] line span of the managed block, if present, so we
+    // can exclude any alias inside it.
+    let blockStart = -1;
+    let blockEnd = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(BLOCK_BEGIN))
+            blockStart = i;
+        else if (lines[i].includes(BLOCK_END)) {
+            blockEnd = i;
+            break;
+        }
+    }
+    const insideBlock = (i) => blockStart !== -1 && blockEnd !== -1 && i >= blockStart && i <= blockEnd;
+    let picked = null;
+    const others = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (insideBlock(i))
+            continue;
+        // Top-level only: no leading whitespace.
+        if (/^\s/.test(line))
+            continue;
+        const parsed = parseAdoptableLine(line);
+        if (!parsed)
+            continue;
+        if (picked === null) {
+            picked = { ...parsed, lineRange: [i, i], others: [] };
+        }
+        else {
+            others.push(line.trim());
+        }
+    }
+    if (picked)
+        picked.others = others;
+    return picked;
+}
+/**
+ * Replace a line range in `existing` (inclusive, zero-based) with `block`.
+ * Used to absorb an adopted hand-written alias: the original line is removed
+ * and the managed block takes its place, guaranteeing no duplicate alias.
+ * Pure function — no I/O. Falls back to {@link spliceManagedBlock} semantics
+ * (append) when the range is out of bounds.
+ */
+export function spliceManagedBlockAtRange(existing, block, range) {
+    const lines = existing.split("\n");
+    const [start, end] = range;
+    if (start < 0 || end >= lines.length || start > end) {
+        return spliceManagedBlock(existing, block);
+    }
+    // `block` ends with a newline; splice it as its own line(s) where the old
+    // alias line was. Rejoin and drop the duplicate trailing newline `block`
+    // would introduce when followed by more lines.
+    const before = lines.slice(0, start);
+    const after = lines.slice(end + 1);
+    const blockLines = block.replace(/\n$/, "").split("\n");
+    return [...before, ...blockLines, ...after].join("\n");
+}
+/** Fill any catalog flags missing from a partial map with their defaults. */
+function withDefaults(partial) {
+    const out = {};
+    for (const flag of ALIAS_FLAGS) {
+        out[flag.id] = partial[flag.id] ?? defaultValueFor(flag);
+    }
+    return out;
+}
+/** Deep-equal two flag maps via per-key JSON compare (small maps). */
+function flagsDeepEqual(a, b) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (let i = 0; i < aKeys.length; i++) {
+        if (aKeys[i] !== bKeys[i])
+            return false;
+    }
+    for (const k of aKeys) {
+        if (JSON.stringify(a[k]) !== JSON.stringify(b[k]))
+            return false;
+    }
+    return true;
+}