@canonical/pragma-cli 0.34.0 → 0.36.0

package/dist/src/capabilities/setup/operations/setupLsp.js

@@ -0,0 +1,329 @@
+/**
+ * `setup lsp` — ensure the Terrazzo LSP extension is installed in every
+ * VS Code-family editor present on this machine.
+ *
+ * There is no marketplace listing yet: the install is a VSIX SIDELOAD. The
+ * published npm package bundles the VSIX, so the install is two exec steps —
+ * fetch the package into a pragma-owned staging dir (`bun add`, so the VSIX
+ * lands at a DURABLE path a user can retry by hand, not bunx's ephemeral
+ * `/tmp/bunx-…` cache), then `<editor cli> --install-extension <vsix>` for
+ * each detected editor. The package's own `install.mjs` bin is deliberately
+ * NOT used: it hardcodes the `code` CLI, which is precisely what left
+ * VSCodium/Cursor/Windsurf/Antigravity machines unable to install at all.
+ *
+ * `detectLsp` probes FOR REAL up front, and spawns NOTHING: an editor is
+ * detected when its CLI resolves on PATH (the `editorClis` registry names
+ * them), carries the extension when its extensions dir holds a
+ * `canonical.terrazzo-lsp-extension-<version>/` entry, and is "installed" when
+ * that entry is also new enough to work. Running
+ * `--list-extensions` instead would be the natural probe, but Cursor's Linux
+ * launcher OPENS THE EDITOR on that flag — a detection step must never launch
+ * an app, so the fs is the source of truth. The full extension id is matched
+ * (not the old `terrazzo` substring, which any other terrazzo-named extension
+ * could false-positive).
+ *
+ * No editor CLI found is a NAMED SKIP, not an error: the message says what was
+ * looked for and what to do, and the run exits 0 — there is nothing on this
+ * machine the step could honestly fail at. Real failures (fetch, sideload)
+ * travel the task failure channel (`checkExecOk`) with a recovery that names a
+ * command runnable on THIS machine, so the run-all can isolate the step
+ * (S1-1) and a direct `setup lsp` still renders the original error.
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { exec, flatMap, mkdir, sequence_, } from "@canonical/task";
+import { BIN_NAME } from "../../../constants.js";
+import { checkExecOk, guardMissingBinary } from "../../shared/index.js";
+/** The full extension id, as the editor's extensions dir spells it. */
+const EXTENSION_ID = "canonical.terrazzo-lsp-extension";
+/** The npm package whose tarball bundles the VSIX. */
+const LSP_PACKAGE = "@canonical/terrazzo-lsp-extension";
+/**
+ * Whether an editor CLI resolves on PATH, given the candidate paths the host
+ * would consider for it.
+ *
+ * The candidates come from `@canonical/harnesses`' `executableCandidates` —
+ * the same helper harness detection resolves `process` signals with — rather
+ * than from a local `PATH`-join here. That local version joined the BARE name
+ * onto each PATH directory, which resolves nothing on Windows: `code`,
+ * `codium` and friends install as `.cmd` shims, so every installed editor
+ * went unseen and `setup lsp` took the no-editor path. That path is a named
+ * SKIP, so the run exited 0 reporting a clean answer on a machine that had
+ * the editor — a wrong skip reads as correct, which is worse than a wrong
+ * failure. One implementation of the platform rules means the probe cannot
+ * drift away from detection's.
+ */
+const cliOnPath = (candidates) => candidates.some((candidate) => existsSync(candidate));
+/**
+ * The oldest extension release whose bundled language server actually starts.
+ *
+ * Every VSIX before this one ships the server as ~166 loose modules importing
+ * `colorjs.io`, `@lezer/common` and `@lezer/css` by BARE SPECIFIER, with no
+ * `node_modules` beside them — so the server dies on load under `node` and
+ * under `bun --no-install`. It appeared to work only because the extension
+ * prefers Bun, and Bun silently fetches missing packages from the network at
+ * spawn time; a machine without that behaviour got a language server that
+ * never started, and one with it got a server resolving unpinned dependencies
+ * over the wire. Fixed in 0.8.3, which bundles the server into one file
+ * (canonical/design-tokens#110).
+ */
+const MIN_EXTENSION_VERSION = "0.8.3";
+/** {@link MIN_EXTENSION_VERSION}, parsed once. */
+const MINIMUM = MIN_EXTENSION_VERSION.split(".").map(Number);
+/**
+ * A version this check can actually read: dot-separated digit runs, nothing
+ * else. Deliberately strict — see {@link parseVersion}.
+ */
+const NUMERIC_VERSION = /^\d+(?:\.\d+)*$/;
+/**
+ * Parse a dotted numeric version, or `undefined` when it is not one.
+ *
+ * `Number.parseInt` is the wrong tool here and quietly breaks the fail-closed
+ * rule this module claims: it accepts numeric PREFIXES, so `1.0.0junk` reads
+ * as `[1, 0, 0]`, and `|| 0` turns a `NaN` component into a zero, so
+ * `1.invalid.0` also reads as `[1, 0, 0]`. Both then compare NEWER than the
+ * minimum and report a broken extension as installed — the exact wrong-skip
+ * this version check exists to prevent, reintroduced by the parser.
+ *
+ * So the whole string is validated before any component is trusted.
+ */
+const parseVersion = (value) => NUMERIC_VERSION.test(value)
+    ? value.split(".").map((part) => Number(part))
+    : undefined;
+/** Compare two dotted numeric versions. Returns <0, 0, >0 like a comparator. */
+const compareVersions = (left, right) => {
+    for (let i = 0; i < Math.max(left.length, right.length); i++) {
+        const diff = (left[i] ?? 0) - (right[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+};
+/**
+ * The two facts an editor's extensions dir answers: is a copy THERE, and is it
+ * new enough to WORK.
+ *
+ * `current` is version-aware on purpose. Matching any
+ * `canonical.terrazzo-lsp-extension-*` entry meant a machine carrying a build
+ * whose server cannot start reported `installed`, so `setup lsp` skipped it and
+ * `doctor` called it healthy — a wrong skip that reads as correct, which is
+ * worse than a wrong failure. Everyone who ran `setup lsp` before
+ * {@link MIN_EXTENSION_VERSION} would have kept a dead language server forever,
+ * with nothing telling them why. An unparseable suffix counts as too old: a
+ * directory this function cannot read the version of is one it cannot vouch for.
+ *
+ * `present` is the same probe WITHOUT the version gate, and it exists because
+ * removal asks a different question. A pre-0.8.3 copy is not `current`, but it
+ * is unquestionably there, and it is a copy this command installed — so a
+ * removal keyed on `current` would leave the dead extension on disk while
+ * reporting success. See {@link DetectedEditor}.
+ */
+const extensionState = (editor, platform) => {
+    let entries;
+    try {
+        entries = readdirSync(editor.extensionsDir(platform));
+    }
+    catch {
+        return { present: false, current: false }; // No dir — nothing installed.
+    }
+    const prefix = `${EXTENSION_ID}-`;
+    const matching = entries.filter((entry) => entry.toLowerCase().startsWith(prefix));
+    const current = matching.some((entry) => {
+        const version = parseVersion(entry.toLowerCase().slice(prefix.length));
+        if (version === undefined)
+            return false; // Unreadable: cannot vouch for it.
+        return compareVersions(version, MINIMUM) >= 0;
+    });
+    return { present: matching.length > 0, current };
+};
+/**
+ * Probe every registry editor: CLI presence via PATH lookup, installed-state
+ * via the extensions dir — no spawns (see the module docblock for why).
+ *
+ * @param _cwd - Unused; kept so every `detectX` shares the (cwd) shape.
+ * @returns The detected {@link LspDetection}.
+ * @note Impure — reads PATH dirs and editor extension dirs off the real fs.
+ */
+export async function detectLsp(_cwd) {
+    const { editorClis, executableCandidates, readPlatformEnv, userDataBase } = await import("@canonical/harnesses");
+    const platform = readPlatformEnv();
+    const editors = editorClis
+        .filter((editor) => cliOnPath(executableCandidates(editor.cli, platform)))
+        .map((editor) => {
+        const { present, current } = extensionState(editor, platform);
+        return {
+            editor,
+            present,
+            installed: current,
+            extensionsDir: editor.extensionsDir(platform),
+        };
+    });
+    const state = editors.length === 0
+        ? "unknown"
+        : editors.every((e) => e.installed)
+            ? "installed"
+            : "absent";
+    return {
+        available: true,
+        state,
+        editors,
+        probed: editorClis.map((editor) => editor.cli),
+        stagingDir: join(userDataBase(platform), BIN_NAME, "lsp"),
+    };
+}
+/**
+ * The editors an install would act on: those missing the extension, narrowed to
+ * the user's per-editor selection when the wizard collected one.
+ *
+ * A machine commonly has several VS Code forks installed and the user wants the
+ * extension in one of them. Installing into all of them because they are on
+ * PATH is the same overreach the MCP row already avoids by offering its files.
+ *
+ * @param d - The detection gathered up front.
+ * @param chosen - Selected editor CLI names, or undefined for "all pending".
+ * @returns The editors to install into.
+ */
+export const selectedEditors = (d, chosen) => {
+    const pending = d.editors.filter((e) => !e.installed);
+    return chosen === undefined
+        ? pending
+        : pending.filter((e) => chosen.includes(e.editor.cli));
+};
+/** The editor names in a detection (for messages/results). */
+export const lspEditorNames = (d) => d.editors.map((e) => e.editor.name);
+/**
+ * The named-skip reason for a machine with no VS Code-family CLI on PATH. It
+ * names every CLI that was probed, because a skip the user cannot act on is
+ * only honest if it says what would have counted.
+ *
+ * @param d - The detection gathered up front.
+ * @returns The reason line.
+ */
+export const lspSkipReason = (d) => `no VS Code-family editor CLI on PATH (${d.probed.join(", ")})`;
+/**
+ * The remedy beneath that skip. It states plainly that nothing is possible here
+ * yet rather than offering a command for a binary this machine lacks — the rule
+ * every remedy line in this capability holds to.
+ */
+export const LSP_SKIP_REMEDY = "no action is possible on this machine yet — install VS Code or VSCodium, then run this again";
+/**
+ * Compose the LSP-install effects for a detection.
+ *
+ * Built from re-runnable combinators (NOT a single-use `gen`) because
+ * `execute` interprets the task twice (preview + perform); a dry-run mocks
+ * every exec (exit 0), so the preview shows the fetch + per-editor sideloads
+ * without spawning. Failures travel the task failure channel with
+ * machine-honest recoveries (see module docblock).
+ *
+ * @param d - The detection gathered up front.
+ * @returns A Task installing the extension into each editor missing it.
+ */
+export function composeLsp(d, chosen) {
+    // Nothing to install: no editor CLI on PATH (a named skip the plan row
+    // carries) or every detected editor already has it. Both compose NOTHING —
+    // what the run SAYS about this target is the plan row's business.
+    if (d.state !== "absent")
+        return sequence_([]);
+    const pending = selectedEditors(d, chosen);
+    // Every pending editor was deselected — there is no fetch to do either.
+    if (pending.length === 0)
+        return sequence_([]);
+    const vsixPath = lspVsixPath(d);
+    // Fetch the VSIX-bundling package into the pragma-owned staging dir. `bun`
+    // (not bunx) so the unpacked package — and its VSIX — survives at a stable
+    // path the recovery lines below can honestly point at.
+    const fetchCommand = `bun add ${LSP_PACKAGE}@latest`;
+    const fetchVsix = guardMissingBinary("bun", {
+        message: `Install Bun (https://bun.sh), then run \`${BIN_NAME} setup lsp\` again.`,
+    }, sequence_([
+        mkdir(d.stagingDir, true),
+        flatMap(exec("bun", ["add", `${LSP_PACKAGE}@latest`], d.stagingDir), (result) => checkExecOk(fetchCommand, result, {
+            message: "The extension package cannot be fetched — this machine cannot reach registry.npmjs.org. Check the connection, then run " +
+                `\`${BIN_NAME} setup lsp\` again.`,
+        })),
+    ]));
+    const sideloads = pending.map(({ editor }) => {
+        const command = `${editor.cli} --install-extension ${vsixPath}`;
+        return guardMissingBinary(editor.cli, {
+            message: `The \`${editor.cli}\` CLI disappeared from PATH mid-run — restore it, then run \`${BIN_NAME} setup lsp\` again.`,
+        }, flatMap(exec(editor.cli, ["--install-extension", vsixPath], d.stagingDir), (result) => checkExecOk(command, result, {
+            message: `${editor.name} refused the VSIX (its output is above). The file is kept at ${vsixPath} — retry by hand with ` +
+                `\`${command}\`, or update ${editor.name} first.`,
+        })));
+    });
+    return sequence_([fetchVsix, ...sideloads]);
+}
+/**
+ * The editors this command OWNS an extension copy in right now — every detected
+ * editor whose extensions dir holds a `canonical.terrazzo-lsp-extension-*`
+ * entry, version-gate deliberately NOT applied (see {@link DetectedEditor}).
+ *
+ * Named and shaped like `ownedMcpGroups` and `ownedSkillLinks`, and for the
+ * same reason those exist: a reversal is composed from what detection says this
+ * command owns, never from what a fresh forward plan would create.
+ *
+ * @param d - The detection gathered up front.
+ * @returns The editors carrying a copy.
+ */
+export const ownedLspEditors = (d) => d.editors.filter((e) => e.present);
+/**
+ * Compose the removal: one `<editor cli> --uninstall-extension <id>` per owned
+ * editor, carried as the `undo` of a forward no-op.
+ *
+ * The docblock this replaces claimed "an `exec` carries no reversal". That was
+ * factually wrong about the effect model — `Exec` has an `undo` slot and `exec`
+ * takes `UndoOptions`. What is true is that `exec` has no DEFAULT undo; the
+ * caller supplies one, exactly as `composeMcpRemoval` does for its `mkdir`.
+ *
+ * The carrier is copied from `composeMcpRemoval`, and its trap is the reason
+ * for the shape: `runUndo` collects undos by walking the FORWARD task with
+ * effects MOCKED, so the forward side must be walkable without reading or
+ * mutating anything. A `mkdir` of the editor's own extensions directory — which
+ * `present` proves already exists — reads nothing and is a genuine no-op. Phase
+ * two then runs the uninstall against the real editor.
+ *
+ * @param d - The detection gathered up front.
+ * @returns A Task whose undo uninstalls the extension from each owned editor.
+ */
+export function composeLspRemoval(d) {
+    const owned = ownedLspEditors(d);
+    // Nothing on this machine carries a copy — there is no honest work to model,
+    // and the plan row says so. Same shape as the other rows' empty removals.
+    if (owned.length === 0)
+        return sequence_([]);
+    return sequence_(owned.map(({ editor, extensionsDir }) => {
+        const command = `${editor.cli} --uninstall-extension ${EXTENSION_ID}`;
+        return mkdir(extensionsDir, true, {
+            undo: guardMissingBinary(editor.cli, {
+                message: `The \`${editor.cli}\` CLI disappeared from PATH mid-run — restore it, then run \`${BIN_NAME} setup lsp --undo\` again.`,
+            }, flatMap(exec(editor.cli, ["--uninstall-extension", EXTENSION_ID], extensionsDir), (result) => checkExecOk(command, result, {
+                message: `${editor.name} refused the uninstall (its output is above). ` +
+                    `Remove it by hand with \`${command}\`.`,
+            }))),
+        });
+    }));
+}
+/**
+ * The uninstall instruction for a detection — a command that runs on THIS
+ * machine, or `undefined` when nothing here carries the extension and there is
+ * therefore nothing honest to print.
+ *
+ * It names an OWNING editor. Reading `d.editors.at(0)` named the first editor
+ * on PATH instead, so a machine with Cursor installed and the extension only in
+ * VSCodium printed a command against the wrong editor — one that would report
+ * success having uninstalled nothing.
+ *
+ * @param d - The detection gathered up front.
+ * @returns The uninstall command, or undefined.
+ */
+export function lspUninstallRemedy(d) {
+    const cli = ownedLspEditors(d).at(0)?.editor.cli;
+    return cli === undefined
+        ? undefined
+        : `${cli} --uninstall-extension ${EXTENSION_ID}`;
+}
+/** The VSIX path a failed sideload leaves behind for a manual retry. */
+export function lspVsixPath(d) {
+    return join(d.stagingDir, "node_modules", ...LSP_PACKAGE.split("/"), "terrazzo-lsp.vsix");
+}
+//# sourceMappingURL=setupLsp.js.map

package/dist/src/capabilities/setup/operations/setupLsp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupLsp.js","sourceRoot":"","sources":["../../../../../src/capabilities/setup/operations/setupLsp.ts"],"names":[],"mappings":"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"}

package/dist/src/capabilities/setup/operations/setupMcp.js

@@ -0,0 +1,253 @@
+/**
+ * `setup mcp` — register the pragma MCP server in detected AI harnesses.
+ *
+ * Split into `detectMcp` (harness detection runs FOR REAL up front, via
+ * `runTask` over safe reads, and the resolved config targets are deduplicated
+ * into per-file {@link TargetGroup}s for the chosen `--scope`) and `composeMcp`
+ * (a pure, re-runnable write body driven by the SELECTED groups). Each write is
+ * a distinct `(path, mcpKey)` so two harnesses sharing a file (VS Code + Cline)
+ * each preserve the other. What a run SAYS about each file is the plan row's
+ * per-file children, not a log line composed here.
+ *
+ * Detection ALSO reads each group's existing config (via `readMcpConfigFrom`,
+ * FOR REAL up front) and classifies every group as `absent` (no pragma entry
+ * yet), `registered` (the pragma entry already matches what we'd write), or
+ * `drifted` (a pragma entry exists but differs). The wizard shows that prior
+ * state in each row and DEFAULT-DESELECTS the already-`registered` files; the
+ * write itself stays idempotent (a re-merge of the identical entry is
+ * byte-for-byte), so a re-run is a no-op the recap reports as "unchanged" — the
+ * same state-awareness `setup skills` has always had.
+ */
+import { dirname } from "node:path";
+import { mkdir, sequence_ } from "@canonical/task";
+import { MCP_SERVER_NAME } from "../../../constants.js";
+/**
+ * The argv a registered harness spawns to reach the server.
+ *
+ * The server verb is `mcp serve`: `mcp` is the noun, and the noun on its own is
+ * not the server entry. An entry still carrying the old single-token `mcp`
+ * spawns something that no longer serves, so it must not survive.
+ *
+ * It does not have to: `mcpEntryMatches` treats `args` as a controlled field,
+ * so an entry written before this rename classifies as `drifted` on the very
+ * next detection and the ordinary forward write repairs it. That is the whole
+ * migration — no flag, no prompt, no compatibility branch — and the run after
+ * it converges, because the repaired entry then matches byte for byte.
+ */
+const MCP_SERVE_ARGV = ["mcp", "serve"];
+/**
+ * The pragma MCP server entry we register — the SINGLE source of truth both the
+ * classifier (does the existing entry match this?) and the writer (`composeMcp`)
+ * consume, so "already registered" means byte-for-byte what a write would emit.
+ *
+ * The entry is SCOPE-shaped: a project-scope entry records the project root as
+ * `cwd` (that binding is the point of a per-repo registration), while a
+ * global-scope entry OMITS `cwd` entirely — a per-user server must not be
+ * pinned to whatever directory `setup mcp --global` happened to run from
+ * (observed: a global registration from `~/Downloads` permanently served
+ * `~/Downloads`, and re-running from repo B "repaired" it to repo B,
+ * ping-ponging the machine scope between projects). The per-harness
+ * serializers already omit an undefined `cwd`, and the matcher treats an
+ * omitted controlled field as must-be-absent, so a stale global entry still
+ * carrying a `cwd` classifies as `drifted` and converges on the next write.
+ *
+ * @param cwd - The project root (recorded only on project-scope entries).
+ * @param scope - The config scope the entry is written to.
+ * @returns The pragma {@link McpServerConfig}.
+ */
+export function pragmaMcpEntry(cwd, scope) {
+    return scope === "project"
+        ? { command: MCP_SERVER_NAME, args: [...MCP_SERVE_ARGV], cwd }
+        : { command: MCP_SERVER_NAME, args: [...MCP_SERVE_ARGV] };
+}
+/**
+ * Classify ONE write against its on-disk config: `absent` when the file carries
+ * no pragma entry under this write's `mcpKey`, `registered` when the entry
+ * already matches what this write would emit, `drifted` when one is there and
+ * differs. Reads the file for real via `readMcpConfigFrom` (which reads only
+ * this write's key), and matches the raw entry against what THAT write's
+ * per-harness serializer would emit for the group's SCOPE (`mcpEntryMatches`
+ * compares the serializer's controlled fields — so a global entry still
+ * pinning a `cwd` reads as drifted — and ignores extra keys a harness or user
+ * added, so we never churn a file we did not author).
+ *
+ * The write, not the file, is the unit that can be classified honestly: a
+ * shared `.vscode/mcp.json` holds VS Code's `servers` and Cline's `mcpServers`
+ * as two independent entries, and "the file" has no single state when one is
+ * current and the other is missing.
+ *
+ * @param write - The resolved config target to inspect.
+ * @param want - The canonical pragma entry for the group's scope.
+ * @param harnessesApi - The dynamically imported harnesses module.
+ * @param runTask - The node Task interpreter.
+ * @returns This write's {@link McpTargetState}.
+ * @note Impure — reads the write's config file.
+ */
+async function classifyWrite(write, want, harnessesApi, runTask) {
+    const servers = await runTask(harnessesApi.readMcpConfigFrom(write));
+    const existing = servers[MCP_SERVER_NAME];
+    if (existing === undefined)
+        return "absent";
+    return harnessesApi.mcpEntryMatches(existing, want, write.serializeEntry)
+        ? "registered"
+        : "drifted";
+}
+/**
+ * The state of a whole FILE, aggregated from its writes: `absent` when no write
+ * carries the entry, `registered` when every write already carries a matching
+ * one, `drifted` otherwise. This is the rule the write side needs — a file is
+ * rewritten unless it is `registered` everywhere — and it is deliberately the
+ * only place the per-write states are collapsed, so nothing else re-derives it.
+ *
+ * @param states - Each write's own state, in the group's write order.
+ * @returns The group's {@link McpTargetState}.
+ */
+const aggregateMcpStates = (states) => {
+    if (states.every((state) => state === "absent"))
+        return "absent";
+    if (states.every((state) => state === "registered"))
+        return "registered";
+    return "drifted";
+};
+/**
+ * The key one write's state is recorded under: the file it lands in AND the
+ * `mcpKey` it owns there. `(path, mcpKey)` is exactly the write-dedup key
+ * `groupConfigTargets` builds its `writes` from, so the map has one entry per
+ * write and no two harnesses sharing a file can collide. The separator is NUL
+ * because a config path may legally contain everything else.
+ *
+ * @param write - The resolved config target.
+ * @returns Its lookup key in {@link McpDetection.stateByWrite}.
+ */
+const mcpWriteKey = (write) => `${write.path}\u0000${write.mcpKey}`;
+/**
+ * Detect the AI harnesses present in the project (real reads, up front),
+ * resolve+dedup their config targets for the chosen scope, AND read each
+ * group's existing config to classify it `absent`/`registered`/`drifted` — so
+ * the wizard can show prior state and default-deselect already-`registered`
+ * files.
+ *
+ * @param rt - The per-invocation runtime.
+ * @param scope - The scope being planned (global or project).
+ * @returns The scope's target groups, their prior states, + the config writer.
+ * @note Impure — reads the filesystem via `detectHarnesses` + `readMcpConfigFrom`.
+ */
+export async function detectMcp(rt, scope) {
+    const cwd = rt.cwd;
+    const [{ detectHarnesses, groupTargetsForScope, mcpEntryMatches, readMcpConfigFrom, readPlatformEnv, removeMcpConfigFrom, writeMcpConfigTargets, }, { runTask },] = await Promise.all([
+        import("@canonical/harnesses"),
+        import("@canonical/task/node"),
+    ]);
+    const platform = readPlatformEnv();
+    const detected = await runTask(detectHarnesses(cwd, platform));
+    const groups = groupTargetsForScope(detected, cwd, scope, platform);
+    // Read each group's existing config (for real, up front) so the recap/preview
+    // and the default selection reflect true prior state — the same discipline
+    // `detectSkills` uses for its per-link create/skip/replace decision. The
+    // wanted entry is SCOPE-shaped (a global entry omits `cwd`), so it is built
+    // per group, not once. Each WRITE is classified and kept; the file's state is
+    // their aggregate, so the coarse view is derived from the fine one rather
+    // than measured separately.
+    const stateByPath = new Map();
+    const stateByWrite = new Map();
+    await Promise.all(groups.map(async (group) => {
+        const want = pragmaMcpEntry(cwd, group.scope);
+        const classified = await Promise.all(group.writes.map(async (write) => ({
+            write,
+            state: await classifyWrite(write, want, { readMcpConfigFrom, mcpEntryMatches }, runTask),
+        })));
+        for (const { write, state } of classified) {
+            stateByWrite.set(mcpWriteKey(write), state);
+        }
+        stateByPath.set(group.path, aggregateMcpStates(classified.map((c) => c.state)));
+    }));
+    return {
+        groups,
+        stateByPath,
+        stateByWrite,
+        cwd,
+        platform,
+        writeMcpConfigTargets,
+        removeMcpConfigFrom,
+    };
+}
+/**
+ * The prior state of a group, defaulting to `absent` for an unknown path (so a
+ * caller never has to guard the map lookup).
+ */
+export function mcpGroupState(d, path) {
+    return d.stateByPath.get(path) ?? "absent";
+}
+/**
+ * The prior state of ONE write — the state of the single harness key it owns,
+ * not of the file it shares. Defaults to `absent` for an unknown write, the
+ * same way {@link mcpGroupState} does for an unknown path.
+ *
+ * @param d - The detection gathered up front.
+ * @param write - One of a group's {@link ConfigTarget} writes.
+ * @returns That write's {@link McpTargetState}.
+ */
+export function mcpWriteState(d, write) {
+    return d.stateByWrite.get(mcpWriteKey(write)) ?? "absent";
+}
+/** The target groups the user selected (by path), or all when none recorded. */
+export function selectedGroups(d, selectedPaths) {
+    return d.groups.filter((g) => selectedPaths.includes(g.path));
+}
+/**
+ * Compose the per-target config writes for the SELECTED groups (pure —
+ * re-runnable; builds ABSOLUTE config paths itself). An already-`registered`
+ * group composes NOTHING: the entry on disk is byte-for-byte what a write would
+ * emit, so re-writing it would only move an mtime. Removal no longer depends on
+ * the forward plan having written something ({@link composeMcpRemoval}), which
+ * is what used to force the redundant write.
+ *
+ * The task carries no log effects — the plan row owns what the run says.
+ *
+ * @param d - The detection gathered up front.
+ * @param groups - The target groups the user chose (a subset of `d.groups`).
+ * @returns A Task that writes the pragma MCP config into each chosen file.
+ */
+export function composeMcp(d, groups) {
+    // Re-runnable combinators (NOT a single-use `gen`): `execute` interprets the
+    // task twice (preview + perform). One combined write per file keeps a shared
+    // file (VS Code + Cline) a single read-modify-write — dry-run safe. The
+    // written entry is SCOPE-shaped per group (a global entry omits `cwd`).
+    const pending = groups.filter((group) => mcpGroupState(d, group.path) !== "registered");
+    return sequence_(pending.map((group) => d.writeMcpConfigTargets(group.writes, MCP_SERVER_NAME, pragmaMcpEntry(d.cwd, group.scope))));
+}
+/**
+ * The groups this scope OWNS right now — every file where detection classifies a
+ * pragma entry as present (`registered` or `drifted`). Removal acts on exactly
+ * this set, so a file that never carried the entry is never rewritten and a
+ * foreign server in a file that does is never touched.
+ */
+export const ownedMcpGroups = (d) => d.groups.filter((group) => mcpGroupState(d, group.path) !== "absent");
+/**
+ * Compose the removal of the pragma entry from every owned file.
+ *
+ * The FORWARD side of this task must be walkable without reading anything.
+ * `runUndo` collects undos by walking the forward task with effects MOCKED —
+ * real `Exists`, but `ReadFile` deliberately returns a placeholder, so that the
+ * walk cannot observe the forward run's own edits. Re-asserting the entry here
+ * (the obvious composition, and the one this had) put a read-parse-merge on
+ * that walk: the placeholder is not JSON, the parse failed closed, and the
+ * collection aborted before gathering a single undo. `setup mcp --undo` could
+ * not remove anything, and said so by refusing a config that was perfectly
+ * valid.
+ *
+ * So the forward effect is a `mkdir` of the config's own directory — which
+ * already exists, reads nothing, and is a genuine no-op — carrying the
+ * key-scoped removal as its `undo`. Phase two then runs that removal against
+ * the real file. Only the pragma key is ever deleted; a foreign server in the
+ * same file is never touched.
+ *
+ * @param d - The detection gathered up front.
+ * @returns A Task whose undo removes the pragma entry from each owned file.
+ */
+export function composeMcpRemoval(d) {
+    return sequence_(ownedMcpGroups(d).map((group) => mkdir(dirname(group.path), true, {
+        undo: sequence_(group.writes.map((write) => d.removeMcpConfigFrom(write, MCP_SERVER_NAME))),
+    })));
+}
+//# sourceMappingURL=setupMcp.js.map

package/dist/src/capabilities/setup/operations/setupMcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupMcp.js","sourceRoot":"","sources":["../../../../../src/capabilities/setup/operations/setupMcp.ts"],"names":[],"mappings":"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"}