agent-toggle 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DevOhMyCode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# agent-toggle
+
+A TypeScript CLI to enable or disable the **MCP servers** (grouped by function),
+**plugins**, **skills**, **hooks**, **commands** and **subagents** of every AI
+agent CLI installed on the machine, at the **user** level, the **project**
+level, or **both**.
+
+```sh
+npm install -g agent-toggle
+agent-toggle            # interactive menu, run it in the project folder you want
+```
+
+From source: `pnpm install && pnpm run build && npm link`. Requires Node.js 22 or later.
+
+39 agent CLIs are supported. The menu and `agents` only show the ones detected on
+the machine (a binary on the PATH or a characteristic config folder); `agents --all`
+lists them all. The menu lists every detected agent, plus a **cross view**: the MCP servers of
+all agents in a single list, grouped by function. Esc goes back to the previous
+menu, Ctrl+C quits.
+
+## Commands
+
+```sh
+agent-toggle agents                                 # detected agents and what is managed
+agent-toggle agents --all                           # every supported agent, installed or not
+agent-toggle list all mcp                           # MCP servers of every agent
+agent-toggle list codex skills
+agent-toggle disable codex mcp node_repl
+agent-toggle disable grok skills archify -s user
+agent-toggle enable cursor mcp supabase -s project
+agent-toggle claudeai off                           # claude.ai connectors (Claude Code)
+agent-toggle groups                                 # customizable MCP groups
+agent-toggle lang                                   # current language and the available ones
+agent-toggle lang de                                # save the interface language
+```
+
+Options: `-p <dir>` (project), `-s user|project|local|both|all`, `-n` (dry run),
+`-l <en|fr|es|de>` (interface language for this run).
+
+## Language
+
+The interface is in **English** by default. Available: English (`en`),
+French (`fr`), Spanish (`es`), German (`de`). The language is resolved in this
+order:
+
+1. the `--lang` / `-l` option;
+2. the `AGENT_TOGGLE_LANG` environment variable;
+3. the language saved by `agent-toggle lang <code>` or by the **Language** entry
+   of the interactive menu (`~/.agent-toggle/config.json`);
+4. English.
+
+Translations live in `src/core/i18n.ts`. English is the reference catalog, and
+the compiler rejects any other catalog that misses a key.
+
+## Mechanisms per agent
+
+The agent's native mechanism is used whenever one exists. Otherwise the item is
+**set aside**: a JSON entry goes to `~/.agent-toggle/stash.json`, a file or
+directory is moved to `<dir>.disabled/`. In both cases it is restored exactly as
+it was.
+
+| Agent | MCP | Plugins | Skills | Hooks | Commands | Agents |
+|---|---|---|---|---|---|---|
+| **Claude Code** | `disabledMcpServers` (per project, `~/.claude.json`); stash for user servers | `enabledPlugins` | `skillOverrides: off` | stash + `disableAllHooks` | move | move |
+| **Codex** | `[mcp_servers.x] enabled = false` | `[plugins."p@m"] enabled` | `[[skills.config]] enabled = false` | stash (`hooks.json`) | prompts: move | `.toml`: move |
+| **Grok Build** | `disabled_mcp_servers` (every source); project: `enabled = false` | `grok plugin enable/disable` | `[skills] disabled` | `hooks/*.json` files: move | move | move |
+| **Cursor Agent** | `disabled: true` | — (IDE) | link moved | stash (`hooks.json`) | move | move |
+| **Copilot CLI** | `disabledMcpServers` | `enabledPlugins` | `disabledSkills` | stash + `disableAllHooks`; files: move | — | `subagents.disabledSubagents` |
+| **Devin CLI** | `disabled: true` | — | move | stash | — | move |
+| **Antigravity (agy)** | `disabled: true` | `plugins.<p>.enabled` | move | `<hook>.enabled = false` | — | — |
+| **Gemini CLI** | `mcp.excluded` | — | `skills.disabled` | stash + `hooksConfig.enabled` | move | `agents.overrides.<n>.enabled` |
+| **Qwen Code** | `mcp.excluded` | — | `skills.disabled` | stash + `disableAllHooks` | `slashCommands.disabled` | move |
+| **Factory Droid** | `disabled: true` | `enabledPlugins` | `disabledSkills` | stash + `hooksDisabled` | move | droids: move |
+| **OpenCode** | `mcp.<n>.enabled = false` | files: move | `permission.skill.<n> = deny` | — (plugins) | move | `agent.<n>.disable` |
+| **Amp** | stash (no native flag) | files: move | move | — (plugins) | — | — |
+| **Crush** | `disabled: true` | — | `options.disabled_skills` | stash | — | — |
+| **Kiro CLI** | `disabled: true` | — | move | — | prompts: move | `.json`: move |
+| **Kilo Code CLI** | `mcp.<n>.enabled = false` | files: move | move | — (plugins) | move | `agent.<n>.disable` |
+| **Amazon Q CLI** (legacy Kiro) | `disabled: true` | — | — | — | prompts: move | `cli-agents/*.json`: move |
+| **Goose** | `extensions.<n>.enabled: false` (YAML) | `disabledPlugins` | — (plugins) | — (plugins) | — | — |
+| **Cline CLI** | `disabled: true` | — | `SKILL.md` frontmatter `disabled: true` | hook files: move | workflows: move | move |
+| **Continue CLI** | stash (YAML array, no flag) | — | move | stash + `disableAllHooks` | — | — |
+| **Augment Auggie** | stash | `enabledPlugins` | move | stash | move | move |
+| **JetBrains Junie** | stash | — | move | stash | move | move |
+| **OpenHands CLI** | `enabled: false` | — | move | — | — | move |
+| **Kimi CLI** | stash | plugin folders: move | move | — | — | — |
+| **Mistral Vibe** | `[[mcp_servers]] disabled = true` | — | `disabled_skills` | — | — | `disabled_agents` |
+| **Rovo Dev CLI** | `mcp.disabledMcpServers` (YAML) | — | move | — | — | subagents: move |
+| **Qoder CLI** | stash | — | move | — | move | move |
+| **CodeBuddy Code** | stash | `enabledPlugins` | move | stash | move | move |
+| **Letta Code** | — (per agent, use `/mcp`) | mods: move | move | stash + `hooks.disabled` | move | move |
+| **Pi coding agent** | — (no MCP) | extensions: move | move | — | prompt templates: move | — |
+| **Codebuff** | stash (strict schema) | — | — | — | — | — |
+| **Hermes Agent** | `mcp_servers.<n>.enabled: false` (YAML) | — | move | — | — | — |
+| **Command Code** | stash | — | — | stash | — | — |
+| **Windsurf** | stash | — | — | — | — | — |
+| **Trae Agent** | `allow_mcp_servers` allow-list (YAML) | — | — | — | — | — |
+| **iFlow CLI** (discontinued) | `excludeMCPServers` | — | — | stash | move | move |
+| **Qodo Command** (deprecated) | stash (project `mcp.json`) | — | — | — | — | — |
+| **Aider**, **Plandex** | detected, nothing to toggle | | | | | |
+| **Warp / Oz** | state kept inside the app: nothing is managed | | | | | |
+
+### Good to know
+
+- **Shared skills.** Cursor, Kiro, Amp and Antigravity have no per-skill
+  switch, so a skill is disabled by moving its folder (or link). If your skill
+  folders are links to a shared store such as `~/.agents/skills`, only the link
+  moves, and a script that syncs those links would recreate it. Codex, Grok,
+  Copilot, Qwen, Droid, OpenCode and Crush have a native setting that leaves the
+  files in place.
+- **Project config and trust.** Codex and Grok only read a project's config
+  when the folder is "trusted".
+- **Formats are preserved.** JSON/JSONC is edited path by path, comments
+  included (`jsonc-parser`); YAML through the `yaml` document API, comments
+  included. TOML is edited line by line and never rewritten as
+  a whole. A disable/enable round trip gives back an identical file.
+- **Backups.** Each modified file is copied to `~/.agent-toggle/backups/`,
+  which keeps the last 20 copies.
+
+## MCP server groups
+
+Default groups use stable ids: `web`, `docs`, `browser`, `data`, `apps`,
+`design`, `media`, `productivity`, `comms`, `pm`, `other`. Their labels follow
+the interface language. Run `agent-toggle groups`, then edit
+`~/.agent-toggle/groups.json`. A custom group name is displayed as-is, and
+`overrides` can target a default id or a custom name:
+
+```json
+{
+  "groups": { "My tools": ["jina", "/^deep/"] },
+  "overrides": { "claude.ai Splice": "media" }
+}
+```
+
+- **Undocumented switches.** When an agent has no documented native switch, the
+  safe fallback is used (stash, or `<dir>.disabled/`) rather than a guessed key:
+  some agents (Codebuff, Trae) reject unknown keys.
+
+## Adding an agent
+
+Write an adapter in `src/agents/`, an `Agent` object that describes how the
+agent is detected and its sections, then add it to `AGENTS` in
+`src/agents/index.ts`. The generic sections cover most cases: `mcpSection`,
+`listSection`, `boolMapSection`, `hooksSection` and `dirSection` (in
+`src/core/generic.ts`), plus `tomlFlagSection` and `tomlListSection`. User-facing
+text goes through `t()` with a key added to all four catalogs.

package/dist/agents/_skills.js

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { dirNames, shortPath } from "../core/generic.js";
+/** Skills (directories containing SKILL.md) found in several roots, without duplicates. */
+export function skillsIn(dirs, group) {
+    const seen = new Set();
+    const out = [];
+    for (const d of dirs)
+        for (const n of dirNames(d, "SKILL.md")) {
+            if (seen.has(n))
+                continue;
+            seen.add(n);
+            out.push({ id: n, hint: shortPath(d), group, file: path.join(d, n, "SKILL.md") });
+        }
+    return out;
+}

package/dist/agents/_toml.js

@@ -0,0 +1,66 @@
+import { getPath, toggled, toggleInList } from "../core/jsonio.js";
+import { readToml, setTomlKey } from "../core/toml.js";
+import { describeServer, shortPath, sortByGroup } from "../core/generic.js";
+import { mcpGroup } from "../core/groups.js";
+import { t } from "../core/i18n.js";
+const scopesOf = (f) => ["user", "project", "local"].filter((s) => f[s]);
+/**
+ * TOML tables { id: { ... } } with a per-item flag
+ * (e.g. [mcp_servers.x] enabled = false, [plugins."p@m"] enabled = false).
+ */
+export function tomlFlagSection(o) {
+    const isMcp = o.kind === "mcp";
+    return {
+        kind: o.kind,
+        title: o.title,
+        scopes: scopesOf(o.files),
+        note: (scope, ctx) => `${shortPath(o.files[scope](ctx))} · [${o.table.join(".")}.<name>] ${o.key} = ${JSON.stringify(o.off)}`,
+        list(ctx, scope) {
+            const tbl = getPath(readToml(o.files[scope](ctx)), o.table) ?? {};
+            const items = Object.entries(tbl)
+                .filter(([, v]) => v && typeof v === "object" && !Array.isArray(v))
+                .map(([id, def]) => ({
+                id,
+                label: id,
+                hint: isMcp ? describeServer(def) : undefined,
+                group: isMcp ? mcpGroup(id) : t("group.installed"),
+                enabled: def[o.key] !== o.off,
+            }));
+            return isMcp ? sortByGroup(items) : items.sort((a, b) => a.label.localeCompare(b.label));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = o.files[scope](ctx);
+            setTomlKey(file, [...o.table, item.id], o.key, enabled ? o.on : o.off, toggled(item.id, enabled, shortPath(file)));
+        },
+    };
+}
+/** List of disabled names in a TOML file (e.g. [skills] disabled = [...]). */
+export function tomlListSection(o) {
+    const path = [...o.table, o.key];
+    return {
+        kind: o.kind,
+        title: o.title,
+        scopes: scopesOf(o.files),
+        note: (scope, ctx) => `${shortPath(o.files[scope](ctx))} · ${path.join(".")}${o.note ? "\n" + t(o.note) : ""}`,
+        list(ctx, scope) {
+            const list = getPath(readToml(o.files[scope](ctx)), path) ?? [];
+            const seen = new Set();
+            const items = [];
+            for (const d of o.discover(ctx, scope)) {
+                if (seen.has(d.id))
+                    continue;
+                seen.add(d.id);
+                items.push({ id: d.id, label: d.id, hint: d.hint, group: d.group ?? t("group.installed"), enabled: !list.includes(d.id) });
+            }
+            for (const n of list)
+                if (!seen.has(n))
+                    items.push({ id: n, label: n, hint: t("hint.notFound"), group: t("group.others"), enabled: false });
+            return o.kind === "mcp" ? sortByGroup(items) : items.sort((a, b) => a.group.localeCompare(b.group) || a.label.localeCompare(b.label));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = o.files[scope](ctx);
+            const list = toggleInList(getPath(readToml(file), path), item.id, !enabled);
+            setTomlKey(file, o.table, o.key, list.length ? list : undefined, toggled(item.id, enabled, shortPath(file)));
+        },
+    };
+}

package/dist/agents/antigravity.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { dirNames, dirSection, mcpSection, shortPath } from "../core/generic.js";
+import { editJson, exists, home, readJson, toggled } from "../core/jsonio.js";
+import { t } from "../core/i18n.js";
+const CFG = home(".gemini", "config");
+/** Plugins: plugins.<dir>.enabled in ~/.gemini/config/config.json (same as agy plugin enable|disable). */
+const plugins = {
+    kind: "plugins",
+    scopes: ["user"],
+    note: () => `${shortPath(path.join(CFG, "config.json"))} · plugins.<dir>.enabled`,
+    list() {
+        const conf = readJson(path.join(CFG, "config.json")).plugins ?? {};
+        const ids = new Set([...dirNames(path.join(CFG, "plugins")), ...Object.keys(conf)]);
+        return [...ids].sort().map((id) => {
+            const own = readJson(path.join(CFG, "plugins", id, "plugin.json"));
+            const v = conf[id]?.enabled;
+            return { id, label: own.name ?? id, hint: own.version, group: t("group.installed"), enabled: typeof v === "boolean" ? v : own.disabled !== true };
+        });
+    },
+    set(_ctx, _scope, item, enabled) {
+        editJson(path.join(CFG, "config.json"), toggled(`Plugin ${item.id}`, enabled), [{ path: ["plugins", item.id, "enabled"], value: enabled }]);
+    },
+};
+/**
+ * Named hooks { name: { enabled?, <event>: [...] } }: native enabled = false.
+ * On the user side there are two files: ~/.gemini/config/hooks.json and the CLI's own.
+ */
+const hookFiles = (ctx, scope) => scope === "user" ? [path.join(CFG, "hooks.json"), home(".gemini", "antigravity-cli", "hooks.json")] : [path.join(ctx.root, ".agents", "hooks.json")];
+const hooks = {
+    kind: "hooks",
+    scopes: ["user", "project"],
+    note: (s, c) => `${hookFiles(c, s).filter(exists).map(shortPath).join(", ") || t("note.noFile")} · <hook>.enabled = false`,
+    list(ctx, scope) {
+        return hookFiles(ctx, scope).flatMap((f) => Object.entries(readJson(f)).filter(([, v]) => v && typeof v === "object").map(([name, v]) => ({
+            id: `${f}|${name}`,
+            label: name,
+            hint: Object.keys(v).filter((k) => k !== "enabled").join(", "),
+            group: shortPath(f),
+            enabled: v.enabled !== false,
+        })));
+    },
+    set(_ctx, _scope, item, enabled) {
+        const [file, name] = [item.id.slice(0, item.id.lastIndexOf("|")), item.id.slice(item.id.lastIndexOf("|") + 1)];
+        editJson(file, toggled(`Hook ${name}`, enabled, shortPath(file)), [{ path: [name, "enabled"], value: enabled ? undefined : false }]);
+    },
+};
+export const antigravity = {
+    id: "antigravity",
+    name: "Google Antigravity (agy)",
+    bins: ["agy"],
+    dirs: [".gemini/antigravity"],
+    sections: [
+        mcpSection({
+            agent: "antigravity",
+            files: { user: () => path.join(CFG, "mcp_config.json"), project: (c) => path.join(c.root, ".agents", "mcp_config.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        plugins,
+        dirSection({
+            kind: "skills",
+            dirs: { user: () => path.join(CFG, "skills"), project: (c) => path.join(c.root, ".agents", "skills") },
+            entry: { dir: "SKILL.md" },
+            note: "note.sharedSkillsMoved",
+        }),
+        hooks,
+    ],
+};

package/dist/agents/claude/index.js

@@ -0,0 +1,31 @@
+import { dirSection, hooksSection } from "../../core/generic.js";
+import { P, projectPaths } from "./paths.js";
+import { settingsFile } from "./settings.js";
+import { mcpSection } from "./mcp.js";
+import { pluginsSection } from "./plugins.js";
+import { skillsSection } from "./skills.js";
+export { claudeAiConnectorsDisabled, setClaudeAiConnectors } from "./mcp.js";
+export const claude = {
+    id: "claude",
+    name: "Claude Code",
+    bins: ["claude"],
+    dirs: [".claude"],
+    sections: [
+        mcpSection,
+        pluginsSection,
+        skillsSection,
+        hooksSection({
+            agent: "claude",
+            files: {
+                user: (ctx) => settingsFile(ctx, "user"),
+                project: (ctx) => settingsFile(ctx, "project"),
+                local: (ctx) => settingsFile(ctx, "local"),
+            },
+            key: ["hooks"],
+            disableAll: { path: ["disableAllHooks"], off: true },
+        }),
+        dirSection({ kind: "commands", dirs: { user: () => P.userCommands, project: (c) => projectPaths(c.root).commands }, entry: { ext: [".md"] }, sep: ":" }),
+        dirSection({ kind: "agents", dirs: { user: () => P.userAgents, project: (c) => projectPaths(c.root).agents }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.claude.skills", "notes.claude.connectors"],
+};

package/dist/agents/claude/mcp.js

@@ -0,0 +1,164 @@
+import fs from "node:fs";
+import path from "node:path";
+import { P, projectPaths } from "./paths.js";
+import { readJson, toggled, toggleInList } from "../../core/jsonio.js";
+import { t } from "../../core/i18n.js";
+import { projectKeys, readClaudeJson, updateClaudeJson, updateSettings } from "./settings.js";
+import { stashed } from "../../core/stash.js";
+import { restoreKey, stashKey } from "../../core/generic.js";
+import { groupOrder, mcpGroup } from "../../core/groups.js";
+import { installedPlugins, pluginEnabledForUser } from "./plugins.js";
+const userStash = () => new Map(stashed("claude", P.claudeJson).filter((e) => e.kind === "keyed").map((e) => [String(e.path.at(-1)), e.value]));
+const sourceTag = (s) => s === "user" ? t("hint.user") : s === "local" ? t("hint.local") : s === "project" ? ".mcp.json" : s;
+function describe(def) {
+    if (!def || typeof def !== "object")
+        return "";
+    if (def.url)
+        return String(def.url);
+    return [def.command, ...(def.args ?? [])].filter(Boolean).join(" ").slice(0, 70);
+}
+/** MCP servers declared by a plugin (.mcp.json or plugin.json#mcpServers). */
+export function pluginMcpServers(installPath) {
+    const names = new Set();
+    const mcpJson = readJson(path.join(installPath, ".mcp.json"));
+    for (const k of Object.keys(mcpJson.mcpServers ?? mcpJson))
+        names.add(k);
+    const manifest = readJson(path.join(installPath, ".claude-plugin", "plugin.json"));
+    const m = manifest.mcpServers;
+    if (m && typeof m === "object")
+        for (const k of Object.keys(m))
+            names.add(k);
+    else if (typeof m === "string") {
+        const f = readJson(path.join(installPath, m));
+        for (const k of Object.keys(f.mcpServers ?? f))
+            names.add(k);
+    }
+    return [...names];
+}
+export function collectMcp(ctx) {
+    const cj = readClaudeJson();
+    const out = new Map();
+    const add = (s) => { if (!out.has(s.name))
+        out.set(s.name, s); };
+    for (const [n, d] of Object.entries(cj.mcpServers ?? {}))
+        add({ name: n, source: "user", detail: describe(d) });
+    for (const [n, d] of userStash())
+        add({ name: n, source: "user", detail: describe(d) });
+    for (const k of projectKeys(cj, ctx.root))
+        for (const [n, d] of Object.entries(cj.projects?.[k]?.mcpServers ?? {}))
+            add({ name: n, source: "local", detail: describe(d) });
+    const mj = readJson(projectPaths(ctx.root).mcpJson);
+    for (const [n, d] of Object.entries(mj.mcpServers ?? {}))
+        add({ name: n, source: "project", detail: describe(d) });
+    for (const p of installedPlugins(ctx)) {
+        if (!pluginEnabledForUser(ctx, p.id))
+            continue;
+        for (const s of pluginMcpServers(p.installPath))
+            add({ name: `plugin:${p.name}:${s}`, source: "plugin", detail: p.id });
+    }
+    for (const n of cj.claudeAiMcpEverConnected ?? [])
+        add({ name: n, source: "claude.ai", detail: t("hint.claudeaiConnector") });
+    // Names already disabled elsewhere (removed connector, uninstalled plugin…): keep them visible.
+    for (const k of projectKeys(cj, ctx.root))
+        for (const n of cj.projects?.[k]?.disabledMcpServers ?? [])
+            add({ name: n, source: n.startsWith("claude.ai ") ? "claude.ai" : n.startsWith("plugin:") ? "plugin" : "user", detail: t("hint.noLongerDetected") });
+    return [...out.values()];
+}
+function disabledIn(cj, root) {
+    const s = new Set();
+    for (const k of projectKeys(cj, root))
+        for (const n of cj.projects?.[k]?.disabledMcpServers ?? [])
+            s.add(n);
+    return s;
+}
+function setProjectDisabled(root, name, disabled) {
+    updateClaudeJson(toggled(`MCP ${name}`, !disabled, root), (cj) => {
+        cj.projects ??= {};
+        for (const k of projectKeys(cj, root)) {
+            const p = (cj.projects[k] ??= {});
+            p.disabledMcpServers = toggleInList(p.disabledMcpServers, name, disabled);
+        }
+    });
+}
+export const mcpSection = {
+    kind: "mcp",
+    scopes: ["user", "local"],
+    scopeLabel: { local: "scope.projectShort" },
+    note: (scope) => scope === "user"
+        ? t("note.claudeMcpUser")
+        : t("note.claudeMcpProject"),
+    list(ctx, scope) {
+        const cj = readClaudeJson();
+        const stash = userStash();
+        const order = groupOrder();
+        const projects = Object.keys(cj.projects ?? {});
+        const items = collectMcp(ctx).map((s) => {
+            let enabled;
+            let extra = "";
+            if (scope === "user" && s.source === "user") {
+                enabled = !stash.has(s.name) && s.name in (cj.mcpServers ?? {});
+            }
+            else if (scope === "user") {
+                // Disabled at user level = disabled in every known project.
+                const n = projects.filter((k) => (cj.projects[k].disabledMcpServers ?? []).includes(s.name)).length;
+                enabled = !projects.length || n < projects.length;
+                if (n && enabled)
+                    extra = ` · ${t("hint.disabledIn", { n, total: projects.length })}`;
+            }
+            else
+                enabled = !disabledIn(cj, ctx.root).has(s.name);
+            return {
+                id: s.name,
+                label: s.name,
+                hint: `${sourceTag(s.source)}${s.detail ? " · " + s.detail : ""}${extra}`,
+                group: mcpGroup(s.name),
+                enabled,
+            };
+        });
+        return items.sort((a, b) => order.indexOf(a.group) - order.indexOf(b.group) || a.label.localeCompare(b.label));
+    },
+    set(ctx, scope, item, enabled) {
+        const src = collectMcp(ctx).find((s) => s.name === item.id)?.source;
+        if (scope === "user" && src === "user") {
+            if (enabled)
+                restoreKey("claude", P.claudeJson, ["mcpServers", item.id], `MCP ${item.id}`);
+            else
+                stashKey("claude", P.claudeJson, ["mcpServers", item.id], `MCP ${item.id}`);
+            return;
+        }
+        if (scope === "user") {
+            updateClaudeJson(toggled(`MCP ${item.id}`, enabled, t("hint.allProjects")), (cj) => {
+                cj.projects ??= {};
+                for (const p of Object.values(cj.projects))
+                    p.disabledMcpServers = toggleInList(p.disabledMcpServers, item.id, !enabled);
+            });
+            return;
+        }
+        setProjectDisabled(ctx.root, item.id, !enabled);
+        // .mcp.json servers also have to be approved before they start.
+        if (src === "project")
+            updateSettings(ctx, "local", t(enabled ? "change.approved" : "change.rejected", { what: `.mcp.json ${item.id}` }), (s) => {
+                s.enabledMcpjsonServers = toggleInList(s.enabledMcpjsonServers, item.id, enabled);
+                s.disabledMcpjsonServers = toggleInList(s.disabledMcpjsonServers, item.id, !enabled);
+                for (const k of ["enabledMcpjsonServers", "disabledMcpjsonServers"])
+                    if (!s[k].length)
+                        delete s[k];
+            });
+    },
+};
+/** Interrupteur global des connecteurs claude.ai (setting officiel disableClaudeAiConnectors). */
+export function claudeAiConnectorsDisabled(ctx, scope) {
+    const file = scope === "user" ? P.userSettings : scope === "project" ? projectPaths(ctx.root).settings : projectPaths(ctx.root).settingsLocal;
+    if (!fs.existsSync(file))
+        return undefined;
+    return readJson(file).disableClaudeAiConnectors;
+}
+export function setClaudeAiConnectors(ctx, scope, disabled) {
+    updateSettings(ctx, scope, toggled(t("label.claudeaiConnectors"), !disabled, scope), (s) => {
+        // A true value wins whatever its scope: to restore, the key is removed.
+        if (disabled)
+            s.disableClaudeAiConnectors = true;
+        else
+            delete s.disableClaudeAiConnectors;
+    });
+}

package/dist/agents/claude/paths.js

@@ -0,0 +1,32 @@
+import os from "node:os";
+import path from "node:path";
+const HOME = os.homedir();
+export const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, ".claude");
+/** Locations read and written by the tool. */
+export const P = {
+    home: HOME,
+    claudeJson: path.join(HOME, ".claude.json"),
+    userSettings: path.join(CLAUDE_DIR, "settings.json"),
+    userSkills: path.join(CLAUDE_DIR, "skills"),
+    userCommands: path.join(CLAUDE_DIR, "commands"),
+    userAgents: path.join(CLAUDE_DIR, "agents"),
+    installedPlugins: path.join(CLAUDE_DIR, "plugins", "installed_plugins.json"),
+    syncedPlugins: path.join(CLAUDE_DIR, "plugins", "synced"),
+    /** Central skills store shared between agents (symlinks). */
+    centralSkills: path.join(HOME, ".agents", "skills"),
+};
+export function projectPaths(root) {
+    return {
+        root,
+        settings: path.join(root, ".claude", "settings.json"),
+        settingsLocal: path.join(root, ".claude", "settings.local.json"),
+        mcpJson: path.join(root, ".mcp.json"),
+        skills: path.join(root, ".claude", "skills"),
+        commands: path.join(root, ".claude", "commands"),
+        agents: path.join(root, ".claude", "agents"),
+    };
+}
+/** Key in ~/.claude.json projects: absolute path with forward slashes, as Claude Code writes it. */
+export function projectKey(root) {
+    return path.resolve(root).replace(/\\/g, "/");
+}

package/dist/agents/claude/plugins.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { P } from "./paths.js";
+import { listDir, readJson, toggled } from "../../core/jsonio.js";
+import { t } from "../../core/i18n.js";
+import { chain, readSettings, updateSettings } from "./settings.js";
+export function installedPlugins(_ctx) {
+    const out = [];
+    const ip = readJson(P.installedPlugins).plugins ?? {};
+    for (const [id, entries] of Object.entries(ip)) {
+        const at = id.lastIndexOf("@");
+        out.push({
+            id,
+            name: id.slice(0, at),
+            marketplace: id.slice(at + 1),
+            installPath: entries[0]?.installPath ?? "",
+            installed: entries.map((e) => e.scope + (e.projectPath ? `@${e.projectPath}` : "")),
+        });
+    }
+    // Plugins synced from claude.ai: plugins/synced/<org>/<name>.
+    for (const org of listDir(P.syncedPlugins).filter((d) => d.isDirectory()))
+        for (const d of listDir(path.join(P.syncedPlugins, org.name)).filter((d) => d.isDirectory() && !d.name.startsWith(".")))
+            out.push({
+                id: `${d.name}@synced`,
+                name: d.name,
+                marketplace: "synced",
+                installPath: path.join(P.syncedPlugins, org.name, d.name),
+                installed: ["claude.ai"],
+            });
+    return out;
+}
+/** An installed plugin missing from enabledPlugins is active; false disables it. */
+function defaultEnabled(p) {
+    return !!p && p.installed.some((s) => s === "user" || s === "claude.ai");
+}
+function effective(ctx, scope, id, p) {
+    for (const sc of chain(scope)) {
+        const v = readSettings(ctx, sc).enabledPlugins?.[id];
+        if (typeof v === "boolean")
+            return v;
+    }
+    return defaultEnabled(p);
+}
+export function pluginEnabledForUser(ctx, id) {
+    return effective(ctx, "user", id, installedPlugins(ctx).find((p) => p.id === id));
+}
+export const pluginsSection = {
+    kind: "plugins",
+    scopes: ["user", "project", "local"],
+    note: () => t("note.claudePlugins"),
+    list(ctx, scope) {
+        const all = installedPlugins(ctx);
+        const ids = new Set(all.map((p) => p.id));
+        for (const sc of chain(scope))
+            for (const id of Object.keys(readSettings(ctx, sc).enabledPlugins ?? {}))
+                ids.add(id);
+        return [...ids].sort().map((id) => {
+            const p = all.find((x) => x.id === id);
+            const mk = id.slice(id.lastIndexOf("@") + 1);
+            return {
+                id,
+                label: id.slice(0, id.lastIndexOf("@")),
+                hint: p ? p.installed.join(", ") : t("hint.notInstalled"),
+                group: mk === "synced" ? "claude.ai (synced)" : `Marketplace ${mk}`,
+                enabled: effective(ctx, scope, id, p),
+            };
+        }).sort((a, b) => a.group.localeCompare(b.group) || a.label.localeCompare(b.label));
+    },
+    set(ctx, scope, item, enabled) {
+        const parent = scope === "user" ? defaultEnabled(installedPlugins(ctx).find((p) => p.id === item.id))
+            : effective(ctx, scope === "local" ? "project" : "user", item.id, installedPlugins(ctx).find((p) => p.id === item.id));
+        updateSettings(ctx, scope, toggled(`Plugin ${item.id}`, enabled, scope), (s) => {
+            s.enabledPlugins ??= {};
+            // Outside the user scope, a value equal to the inherited one is useless: remove it.
+            if (scope !== "user" && enabled === parent)
+                delete s.enabledPlugins[item.id];
+            else
+                s.enabledPlugins[item.id] = enabled;
+            if (!Object.keys(s.enabledPlugins).length)
+                delete s.enabledPlugins;
+        });
+    },
+};