agent-toggle 0.1.0

package/dist/index.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { spawn } from "node:child_process";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { logo } from "./core/logo.js";
+import { BACKUP_DIR, HOME, state } from "./core/jsonio.js";
+import { initGroupsFile } from "./core/groups.js";
+import { getLang, isLang, LANGS, resolveLang, saveLang, setLang, t } from "./core/i18n.js";
+import { scopeLabel as defaultScopeLabel, sectionKindTitle, SECTION_KINDS } from "./core/types.js";
+import { AGENTS, findAgent, isInstalled } from "./agents/index.js";
+import { claudeAiConnectorsDisabled, setClaudeAiConnectors } from "./agents/claude/index.js";
+const CONNECTORS_URL = "https://claude.ai/settings/connectors";
+function parseArgs(argv) {
+    const a = { rest: [], project: process.cwd(), dryRun: false, all: false };
+    for (let i = 0; i < argv.length; i++) {
+        const v = argv[i];
+        if (v === "-p" || v === "--project")
+            a.project = path.resolve(argv[++i]);
+        else if (v === "-s" || v === "--scope")
+            a.scopes = parseScopes(argv[++i]);
+        else if (v === "-n" || v === "--dry-run")
+            a.dryRun = true;
+        else if (v === "-l" || v === "--lang")
+            a.lang = argv[++i];
+        else if (v === "-a" || v === "--all")
+            a.all = true;
+        else if (v === "-h" || v === "--help")
+            a.cmd = "help";
+        else if (!a.cmd)
+            a.cmd = v;
+        else
+            a.rest.push(v);
+    }
+    return a;
+}
+function parseScopes(v) {
+    const map = { user: ["user"], project: ["project"], local: ["local"], both: ["user", "project"], all: ["user", "project", "local"] };
+    const s = map[v];
+    if (!s)
+        throw new Error(t("err.badScope", { scope: v }));
+    return s;
+}
+const help = () => t("help", {
+    agents: AGENTS.map((a) => a.id).join(", "),
+    kinds: SECTION_KINDS.join(" | "),
+    langs: Object.keys(LANGS).join("|"),
+});
+// ---------------------------------------------------------------- core
+const sectionTitle = (s) => (s.title ? t(s.title) : sectionKindTitle(s.kind));
+const scopeLabel = (s, sc) => (s.scopeLabel?.[sc] ? t(s.scopeLabel[sc]) : defaultScopeLabel(sc));
+/** Fits the requested scopes to those of the section (project ↔ local when only one exists). */
+function fitScopes(sec, scopes) {
+    const out = scopes.map((s) => sec.scopes.includes(s) ? s
+        : s === "project" && sec.scopes.includes("local") ? "local"
+            : s === "local" && sec.scopes.includes("project") ? "project" : s);
+    return [...new Set(out)].filter((s) => sec.scopes.includes(s));
+}
+const matchesKind = (s, kind) => s.kind === kind || `${s.kind}s` === kind || s.kind === `${kind}s`;
+function sectionsOf(agent, kind) {
+    const secs = agent.sections.filter((s) => matchesKind(s, kind));
+    if (!secs.length)
+        throw new Error(t("err.nothingForKind", { agent: agent.name, kind, kinds: agent.sections.map((s) => s.kind).join(", ") || t("label.noKind") }));
+    return secs;
+}
+function applyDesired(sec, ctx, scopes, desired) {
+    for (const scope of scopes)
+        for (const item of sec.list(ctx, scope)) {
+            const want = desired.get(item.id);
+            if (want !== undefined && want !== item.enabled)
+                sec.set(ctx, scope, item, want);
+        }
+}
+const dryTag = () => (state.dryRun ? `[${t("label.dryRun")}] ` : "");
+function printChanges(start = 0) {
+    const ch = state.changes.slice(start);
+    if (!ch.length)
+        return console.log(pc.dim(t("msg.noChange")));
+    for (const c of ch)
+        console.log(`${state.dryRun ? pc.yellow(`[${t("label.dryRun")}]`) : pc.green("✔")} ${c}`);
+}
+function openUrl(url) {
+    const [cmd, args] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+    spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+}
+// ---------------------------------------------------------------- non-interactive
+function printList(agent, secs, ctx, scopes) {
+    for (const sec of secs)
+        for (const scope of fitScopes(sec, scopes ?? sec.scopes)) {
+            console.log(pc.bold(`\n${agent.name} — ${sectionTitle(sec)} — ${scopeLabel(sec, scope)}`));
+            let items = [];
+            try {
+                items = sec.list(ctx, scope);
+            }
+            catch (e) {
+                console.log(pc.red(`    ${t("label.error")}: ${e.message}`));
+                continue;
+            }
+            if (!items.length)
+                console.log(pc.dim(`    (${t("label.none")})`));
+            let group = "";
+            for (const it of items) {
+                if (it.group !== group)
+                    console.log(pc.cyan(`  ${(group = it.group)}`));
+                console.log(`    ${it.enabled ? pc.green("●") : pc.red("○")} ${it.label}${it.hint ? pc.dim("  " + it.hint) : ""}`);
+            }
+        }
+}
+function printLang() {
+    console.log(t("msg.currentLang", { lang: `${getLang()} (${LANGS[getLang()]})` }));
+    for (const [code, name] of Object.entries(LANGS))
+        console.log(`  ${code === getLang() ? pc.green("●") : pc.dim("○")} ${code}  ${name}`);
+}
+function runCli(a) {
+    const ctx = { root: a.project };
+    switch (a.cmd) {
+        case "help":
+            if (process.stdout.isTTY)
+                console.log(`${logo()}\n`);
+            return console.log(help());
+        case "groups":
+            return console.log(t("msg.groupsFile", { file: initGroupsFile() }));
+        case "lang": {
+            const code = a.rest[0];
+            if (!code)
+                return printLang();
+            if (!isLang(code))
+                throw new Error(t("err.badLang", { lang: code, langs: Object.keys(LANGS).join(", ") }));
+            saveLang(code);
+            setLang(code);
+            return console.log(t("msg.langSaved", { lang: `${code} (${LANGS[code]})` }));
+        }
+        case "agents":
+            // Only detected agents, unless --all asks for every supported one.
+            for (const ag of a.all ? AGENTS : AGENTS.filter(isInstalled)) {
+                const ok = isInstalled(ag);
+                console.log(`${ok ? pc.green("●") : pc.dim("○")} ${ag.id.padEnd(12)} ${ag.name.padEnd(26)} ${pc.dim(ag.sections.map((s) => sectionTitle(s)).join(", ") || t("label.nothingManageable"))}`);
+            }
+            return;
+        case "list": {
+            const [who, kind] = a.rest;
+            if (!who || !kind)
+                throw new Error(t("usage.list"));
+            const agents = who === "all" ? AGENTS.filter(isInstalled) : [findAgent(who)];
+            for (const ag of agents) {
+                const secs = ag.sections.filter((s) => matchesKind(s, kind));
+                if (secs.length)
+                    printList(ag, secs, ctx, a.scopes);
+                else if (who !== "all")
+                    sectionsOf(ag, kind);
+            }
+            return;
+        }
+        case "enable":
+        case "disable": {
+            const [who, kind, ...ids] = a.rest;
+            if (!who || !kind || !ids.length)
+                throw new Error(t("usage.toggle", { cmd: a.cmd }));
+            const agent = findAgent(who);
+            const secs = sectionsOf(agent, kind);
+            const todo = new Set(ids);
+            for (const sec of secs) {
+                const scopes = fitScopes(sec, a.scopes ?? [sec.scopes[0]]);
+                const items = scopes.flatMap((s) => sec.list(ctx, s));
+                const hits = ids.map((id) => items.find((it) => it.id === id) ?? items.find((it) => it.label === id)).filter(Boolean);
+                for (const h of hits)
+                    todo.delete(ids.find((id) => id === h.id || id === h.label));
+                applyDesired(sec, ctx, scopes, new Map(hits.map((h) => [h.id, a.cmd === "enable"])));
+            }
+            if (todo.size)
+                throw new Error(t("err.notFound", { ids: [...todo].join(", "), agent: agent.id, kind }));
+            return printChanges();
+        }
+        case "claudeai": {
+            if (!["on", "off"].includes(a.rest[0]))
+                throw new Error(t("usage.claudeai"));
+            for (const s of a.scopes ?? ["user"])
+                setClaudeAiConnectors(ctx, s, a.rest[0] === "off");
+            return printChanges();
+        }
+        default:
+            throw new Error(`${t("err.unknownCommand", { cmd: a.cmd ?? "" })}\n\n${help()}`);
+    }
+}
+// ---------------------------------------------------------------- interactive
+/*
+ * Navigation: Esc goes back to the previous menu
+ * (list → scope → category → agent → main menu, which quits).
+ */
+function logNew(start) {
+    for (const c of state.changes.slice(start))
+        p.log.success(`${dryTag()}${c}`);
+}
+/**
+ * Grouped checkbox list, summary, then apply.
+ * Returns false when the user went back without applying anything.
+ */
+async function pickAndApply(title, items, apply) {
+    const groups = {};
+    for (const it of items)
+        (groups[it.group] ??= []).push({ value: it.id, label: it.label, hint: it.hint });
+    let initial = items.filter((i) => i.enabled).map((i) => i.id);
+    for (;;) {
+        const selected = await p.groupMultiselect({
+            message: `${title} ${pc.dim(t("prompt.listKeys"))}`,
+            options: groups,
+            initialValues: initial,
+            required: false,
+            selectableGroups: true,
+            maxItems: Math.max(10, (process.stdout.rows ?? 30) - 8),
+        });
+        if (p.isCancel(selected))
+            return false;
+        const chosen = new Set(selected);
+        const changed = items.filter((i) => chosen.has(i.id) !== i.enabled);
+        if (!changed.length) {
+            p.log.info(t("msg.nothingToChange"));
+            return false;
+        }
+        p.note(changed.map((i) => `${chosen.has(i.id) ? pc.green(`+ ${t("label.enable")}`) : pc.red(`- ${t("label.disable")}`)} ${i.label}${i.hint ? pc.dim("  " + i.hint) : ""}`).join("\n"), t("msg.changesCount", { n: changed.length }));
+        const ok = await p.confirm({ message: t(state.dryRun ? "prompt.simulate" : "prompt.apply") });
+        if (p.isCancel(ok) || !ok) {
+            // Back to the list, keeping the checked boxes.
+            initial = selected;
+            continue;
+        }
+        const start = state.changes.length;
+        try {
+            apply(new Map(changed.map((i) => [i.id, chosen.has(i.id)])));
+        }
+        catch (e) {
+            p.log.error(e.message);
+        }
+        logNew(start);
+        return true;
+    }
+}
+const back = () => pc.dim(t("prompt.escBack"));
+async function chooseScopes(sec) {
+    if (sec.scopes.length === 1)
+        return sec.scopes;
+    const opts = sec.scopes.map((s) => ({ value: [s], label: scopeLabel(sec, s) }));
+    const proj = sec.scopes.find((s) => s !== "user");
+    if (proj && sec.scopes.includes("user") && sec.kind !== "hooks" && sec.kind !== "commands" && sec.kind !== "agents")
+        opts.push({ value: ["user", proj], label: t("scope.userProject") });
+    const v = await p.select({ message: `${sectionTitle(sec)} — ${t("prompt.scope")} ${back()}`, options: opts });
+    return p.isCancel(v) ? undefined : v;
+}
+async function editSection(agent, sec, ctx) {
+    for (;;) {
+        const scopes = await chooseScopes(sec);
+        if (!scopes)
+            return;
+        for (const s of scopes) {
+            const n = sec.note?.(s, ctx);
+            if (n)
+                p.note(n, `${agent.name} — ${scopeLabel(sec, s)}`);
+        }
+        // An item is checked when it is enabled in every chosen scope.
+        const merged = new Map();
+        try {
+            for (const s of scopes)
+                for (const it of sec.list(ctx, s)) {
+                    const prev = merged.get(it.id);
+                    merged.set(it.id, prev ? { ...prev, enabled: prev.enabled && it.enabled } : it);
+                }
+        }
+        catch (e) {
+            p.log.error(e.message);
+            if (sec.scopes.length === 1)
+                return;
+            continue;
+        }
+        if (!merged.size) {
+            p.log.info(t("msg.noItems", { title: sectionTitle(sec) }));
+            if (sec.scopes.length === 1)
+                return;
+            continue;
+        }
+        const done = await pickAndApply(`${agent.name} — ${sectionTitle(sec)}`, [...merged.values()], (d) => applyDesired(sec, ctx, scopes, d));
+        if (done || sec.scopes.length === 1)
+            return;
+    }
+}
+async function editClaudeAi(ctx) {
+    const u = claudeAiConnectorsDisabled(ctx, "user") === true;
+    const l = claudeAiConnectorsDisabled(ctx, "local") === true;
+    p.note(t("claudeai.status", {
+        user: u ? pc.red(t("claudeai.off")) : pc.green(t("claudeai.on")),
+        local: l ? pc.red(t("claudeai.off")) : pc.green(t("claudeai.inherited")),
+        url: CONNECTORS_URL,
+    }), t("label.claudeaiConnectors"));
+    const action = await p.select({
+        message: `${t("prompt.action")} ${back()}`,
+        options: [
+            { value: "user-off", label: t("claudeai.userOff"), hint: "disableClaudeAiConnectors" },
+            { value: "user-on", label: t("claudeai.userOn") },
+            { value: "local-off", label: t("claudeai.localOff"), hint: ".claude/settings.local.json" },
+            { value: "local-on", label: t("claudeai.localOn") },
+            { value: "open", label: t("claudeai.open"), hint: t("claudeai.openHint") },
+        ],
+    });
+    if (p.isCancel(action))
+        return;
+    if (action === "open")
+        return openUrl(CONNECTORS_URL);
+    const [scope, onOff] = action.split("-");
+    const start = state.changes.length;
+    setClaudeAiConnectors(ctx, scope, onOff === "off");
+    logNew(start);
+}
+async function editAgent(agent, ctx) {
+    if (agent.notes?.length)
+        p.note(agent.notes.map((k) => t(k)).join("\n"), agent.name);
+    for (;;) {
+        const choice = await p.select({
+            message: `${agent.name} — ${t("prompt.category")} ${back()}`,
+            options: [
+                ...agent.sections.map((s, i) => ({ value: String(i), label: sectionTitle(s) })),
+                ...(agent.id === "claude" ? [{ value: "claudeai", label: t("label.claudeaiConnectors"), hint: t("claudeai.globalHint") }] : []),
+            ],
+        });
+        if (p.isCancel(choice))
+            return;
+        if (choice === "claudeai")
+            await editClaudeAi(ctx);
+        else
+            await editSection(agent, agent.sections[Number(choice)], ctx);
+    }
+}
+/** Cross view: the MCP servers of every agent, grouped by function. */
+async function crossMcp(ctx) {
+    for (;;) {
+        const scope = await p.select({
+            message: `${t("menu.crossMcp")} — ${t("prompt.scope")} ${back()}`,
+            options: [{ value: "user", label: t("scope.user") }, { value: "project", label: t("scope.projectShort") }],
+        });
+        if (p.isCancel(scope))
+            return;
+        const targets = [];
+        const items = [];
+        for (const agent of AGENTS.filter(isInstalled))
+            for (const sec of agent.sections.filter((s) => s.kind === "mcp")) {
+                const sc = fitScopes(sec, [scope])[0];
+                if (!sc)
+                    continue;
+                try {
+                    for (const it of sec.list(ctx, sc))
+                        items.push({ ...it, id: `${agent.id}::${it.id}`, hint: `${agent.name}${it.hint ? " · " + it.hint : ""}` });
+                    targets.push({ agent, sec, scope: sc });
+                }
+                catch (e) {
+                    p.log.warn(`${agent.name}: ${e.message}`);
+                }
+            }
+        if (!items.length) {
+            p.log.info(t("msg.noMcp"));
+            continue;
+        }
+        const done = await pickAndApply(t("menu.crossMcp"), items, (desired) => {
+            for (const tg of targets) {
+                const prefix = `${tg.agent.id}::`;
+                const mine = new Map([...desired].filter(([id]) => id.startsWith(prefix)).map(([id, v]) => [id.slice(prefix.length), v]));
+                if (mine.size)
+                    applyDesired(tg.sec, ctx, [tg.scope], mine);
+            }
+        });
+        if (done)
+            return;
+    }
+}
+async function chooseLang() {
+    const v = await p.select({
+        message: `${t("menu.language")} ${back()}`,
+        options: Object.entries(LANGS).map(([value, label]) => ({ value, label, hint: value === getLang() ? "●" : undefined })),
+        initialValue: getLang(),
+    });
+    if (p.isCancel(v))
+        return;
+    setLang(v);
+    saveLang(v);
+    p.log.success(t("msg.langSaved", { lang: `${v} (${LANGS[v]})` }));
+}
+/**
+ * Keeps the terminal in raw mode for the whole session. Between prompts, clack
+ * switches back to line mode; on Windows the console then starts a line read
+ * that swallows the next key until Enter is pressed (hence an Esc that seemed
+ * "stuck" after going back). In raw mode Ctrl+C no longer raises SIGINT, so it
+ * is handled here to quit.
+ */
+function holdRawMode() {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return () => { };
+    const original = stdin.setRawMode.bind(stdin);
+    original(true);
+    stdin.setRawMode = (mode) => (mode ? original(true) : stdin);
+    const onKey = (_, key) => {
+        if (key?.ctrl && key.name === "c") {
+            release();
+            p.cancel(t("msg.interrupted"));
+            process.exit(130);
+        }
+    };
+    stdin.on("keypress", onKey);
+    const release = () => {
+        stdin.off("keypress", onKey);
+        stdin.setRawMode = original;
+        original(false);
+    };
+    return release;
+}
+async function interactive(a) {
+    const ctx = { root: a.project };
+    const release = holdRawMode();
+    console.log(`\n${logo()}\n`);
+    p.intro(pc.inverse(" agent-toggle ") + (state.dryRun ? pc.yellow(`  ${t("label.dryRun")}`) : ""));
+    const installed = AGENTS.filter(isInstalled);
+    for (;;) {
+        const choice = await p.select({
+            message: `${t("menu.project")}: ${pc.cyan(ctx.root)}${ctx.root === HOME ? pc.dim(` (${t("menu.homeDir")})`) : ""}`,
+            options: [
+                { value: "::mcp", label: t("menu.crossMcp"), hint: t("menu.crossMcpHint") },
+                ...installed.map((ag) => ({ value: ag.id, label: ag.name, hint: ag.sections.length ? ag.sections.map((s) => sectionTitle(s)).join(" · ") : t("label.nothingManageable") })),
+                { value: "::project", label: t("menu.changeProject") },
+                { value: "::lang", label: t("menu.language"), hint: LANGS[getLang()] },
+                { value: "::quit", label: t("menu.quit") },
+            ],
+            maxItems: Math.max(8, (process.stdout.rows ?? 30) - 6),
+        });
+        // Esc in the main menu: quit cleanly.
+        if (p.isCancel(choice) || choice === "::quit")
+            break;
+        if (choice === "::project") {
+            const dir = await p.text({ message: t("prompt.projectDir"), initialValue: ctx.root });
+            if (!p.isCancel(dir))
+                ctx.root = path.resolve(dir);
+        }
+        else if (choice === "::lang")
+            await chooseLang();
+        else if (choice === "::mcp")
+            await crossMcp(ctx);
+        else {
+            const agent = findAgent(choice);
+            if (!agent.sections.length)
+                p.note(agent.notes?.map((k) => t(k)).join("\n") ?? t("label.nothingManageable"), agent.name);
+            else
+                await editAgent(agent, ctx);
+        }
+    }
+    release();
+    p.outro(state.changes.length && !state.dryRun ? t("msg.outroChanged", { dir: BACKUP_DIR }) : t("msg.bye"));
+}
+// ---------------------------------------------------------------- entry point
+const args = parseArgs(process.argv.slice(2));
+try {
+    setLang(resolveLang(args.lang));
+    state.dryRun = args.dryRun;
+    if (!args.cmd)
+        await interactive(args);
+    else
+        runCli(args);
+}
+catch (e) {
+    console.error(pc.red(`${t("label.error")}: ${e.message}`));
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "agent-toggle",
+  "version": "0.1.0",
+  "description": "CLI to enable/disable the MCP servers, plugins, skills, hooks, commands and agents of every installed AI agent CLI (Claude Code, Codex, Grok, Cursor, Copilot, Gemini…)",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepack": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc"
+  },
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "jsonc-parser": "^3.3.1",
+    "picocolors": "^1.1.1",
+    "smol-toml": "^1.9.0",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
+  },
+  "bin": {
+    "agent-toggle": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "author": "DevOhMyCode",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devohmycode/agent-toggle.git"
+  },
+  "homepage": "https://github.com/devohmycode/agent-toggle#readme",
+  "bugs": {
+    "url": "https://github.com/devohmycode/agent-toggle/issues"
+  },
+  "keywords": [
+    "cli",
+    "mcp",
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "ai-agents",
+    "skills",
+    "hooks",
+    "plugins"
+  ]
+}