agent-toggle 0.1.0

package/dist/agents/claude/settings.js

@@ -0,0 +1,43 @@
+import { P, projectKey, projectPaths } from "./paths.js";
+import { readJson, writeJson } from "../../core/jsonio.js";
+/** settings.json file of a scope. */
+export function settingsFile(ctx, scope) {
+    if (scope === "user")
+        return P.userSettings;
+    const pp = projectPaths(ctx.root);
+    return scope === "project" ? pp.settings : pp.settingsLocal;
+}
+export function readSettings(ctx, scope) {
+    return readJson(settingsFile(ctx, scope));
+}
+/** Reads, modifies, then immediately rewrites a settings.json. */
+export function updateSettings(ctx, scope, what, fn) {
+    const file = settingsFile(ctx, scope);
+    const s = readJson(file);
+    fn(s);
+    writeJson(file, s, what);
+}
+/** Scopes a scope inherits from, strongest first (itself included). */
+export function chain(scope) {
+    return scope === "local" ? ["local", "project", "user"] : scope === "project" ? ["project", "user"] : ["user"];
+}
+/**
+ * ~/.claude.json: Claude Code rewrites it constantly during sessions.
+ * It is re-read right before each write to limit races.
+ */
+export function readClaudeJson() {
+    return readJson(P.claudeJson);
+}
+/** projects[...] keys designating this project (Windows: drive letter case varies). */
+export function projectKeys(cj, root) {
+    // Windows: drive letter case varies between keys; elsewhere paths are case-sensitive.
+    const fold = (s) => (process.platform === "win32" ? s.toLowerCase() : s);
+    const want = fold(projectKey(root));
+    const keys = Object.keys(cj.projects ?? {}).filter((k) => fold(k.replace(/\\/g, "/")) === want);
+    return keys.length ? keys : [projectKey(root)];
+}
+export function updateClaudeJson(what, fn) {
+    const cj = readClaudeJson();
+    fn(cj);
+    writeJson(P.claudeJson, cj, what);
+}

package/dist/agents/claude/skills.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { P, projectPaths } from "./paths.js";
+import { isLink, listDir, toggled } from "../../core/jsonio.js";
+import { chain, readSettings, updateSettings } from "./settings.js";
+import { t } from "../../core/i18n.js";
+function skillsIn(dir) {
+    return listDir(dir)
+        .filter((d) => (d.isDirectory() || d.isSymbolicLink()) && fs.existsSync(path.join(dir, d.name, "SKILL.md")))
+        .map((d) => d.name);
+}
+function override(ctx, scope, name) {
+    for (const sc of chain(scope)) {
+        const v = readSettings(ctx, sc).skillOverrides?.[name];
+        if (typeof v === "string")
+            return { value: v, from: sc };
+    }
+    return {};
+}
+/**
+ * Skills utilisateur et projet, via le setting officiel skillOverrides
+ * ("off" = hidden from the model and from /name). Files do not move, so
+ * skill sync scripts and the other agents are not affected.
+ * Skills shipped by a plugin are not covered: they are disabled with the plugin.
+ */
+export const skillsSection = {
+    kind: "skills",
+    scopes: ["user", "project", "local"],
+    note: () => t("note.claudeSkills"),
+    list(ctx, scope) {
+        const user = skillsIn(P.userSkills);
+        const proj = skillsIn(projectPaths(ctx.root).skills);
+        const items = [];
+        const push = (name, group, hint) => {
+            const o = override(ctx, scope, name);
+            items.push({
+                id: name,
+                label: name,
+                hint: o.value && o.value !== "on" ? `${hint} · ${o.value} (${o.from})` : hint,
+                group,
+                enabled: o.value !== "off",
+            });
+        };
+        for (const n of user)
+            push(n, `${t("group.user")} (~/.claude/skills)`, isLink(path.join(P.userSkills, n)) ? t("hint.link") : t("hint.local"));
+        if (scope !== "user")
+            for (const n of proj)
+                push(n, `${t("group.project")} (.claude/skills)`, t("hint.project"));
+        const known = new Set(items.map((i) => i.id));
+        for (const sc of chain(scope))
+            for (const n of Object.keys(readSettings(ctx, sc).skillOverrides ?? {}))
+                if (!known.has(n)) {
+                    known.add(n);
+                    push(n, t("group.overrides"), t("hint.notFound"));
+                }
+        return items.sort((a, b) => a.group.localeCompare(b.group) || a.label.localeCompare(b.label));
+    },
+    set(ctx, scope, item, enabled) {
+        const parentScope = scope === "local" ? "project" : scope === "project" ? "user" : undefined;
+        const parentOff = parentScope ? override(ctx, parentScope, item.id).value === "off" : false;
+        updateSettings(ctx, scope, toggled(`Skill ${item.id}`, enabled, scope), (s) => {
+            s.skillOverrides ??= {};
+            if (enabled) {
+                if (parentOff)
+                    s.skillOverrides[item.id] = "on";
+                else
+                    delete s.skillOverrides[item.id];
+            }
+            else
+                s.skillOverrides[item.id] = "off";
+            if (!Object.keys(s.skillOverrides).length)
+                delete s.skillOverrides;
+        });
+    },
+};

package/dist/agents/codex.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { dirSection, hooksSection, shortPath } from "../core/generic.js";
+import { home, pathKey, toggled } from "../core/jsonio.js";
+import { addArrayTable, readToml, removeArrayTables } from "../core/toml.js";
+import { t } from "../core/i18n.js";
+import { tomlFlagSection } from "./_toml.js";
+import { skillsIn } from "./_skills.js";
+const CODEX_HOME = process.env.CODEX_HOME ?? home(".codex");
+const config = { user: () => path.join(CODEX_HOME, "config.toml"), project: (c) => path.join(c.root, ".codex", "config.toml") };
+const configFor = (scope, ctx) => (scope === "user" ? config.user() : config.project(ctx));
+const norm = pathKey;
+/** Skills: [[skills.config]] path = ".../SKILL.md", enabled = false (native). */
+const skills = {
+    kind: "skills",
+    scopes: ["user", "project"],
+    note: (s, c) => `${shortPath(configFor(s, c))} · [[skills.config]] enabled = false`,
+    list(ctx, scope) {
+        const found = scope === "user"
+            ? skillsIn([home(".agents", "skills"), path.join(CODEX_HOME, "skills")], t("group.user"))
+            : skillsIn([path.join(ctx.root, ".agents", "skills")], t("group.project"));
+        const off = new Set((readToml(configFor(scope, ctx)).skills?.config ?? [])
+            .filter((e) => e.enabled === false).map((e) => norm(String(e.path))));
+        return found.map((s) => ({ id: s.file, label: s.id, hint: s.hint, group: s.group, enabled: !off.has(norm(s.file)) }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+    },
+    set(ctx, scope, item, enabled) {
+        const file = configFor(scope, ctx);
+        const what = toggled(`Skill ${item.label}`, enabled, shortPath(file));
+        if (enabled)
+            removeArrayTables(file, ["skills", "config"], (d) => norm(String(d.path ?? "")) === norm(item.id) && d.enabled === false, what);
+        else
+            addArrayTable(file, ["skills", "config"], { path: item.id, enabled: false }, what);
+    },
+};
+export const codex = {
+    id: "codex",
+    name: "OpenAI Codex",
+    bins: ["codex"],
+    dirs: [".codex"],
+    sections: [
+        tomlFlagSection({ kind: "mcp", files: config, table: ["mcp_servers"], key: "enabled", off: false }),
+        tomlFlagSection({ kind: "plugins", files: config, table: ["plugins"], key: "enabled", off: false, on: true }),
+        skills,
+        hooksSection({
+            agent: "codex",
+            files: { user: () => path.join(CODEX_HOME, "hooks.json"), project: (c) => path.join(c.root, ".codex", "hooks.json") },
+            key: ["hooks"],
+        }),
+        dirSection({ kind: "commands", title: "title.codexPrompts", dirs: { user: () => path.join(CODEX_HOME, "prompts") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(CODEX_HOME, "agents"), project: (c) => path.join(c.root, ".codex", "agents") }, entry: { ext: [".toml"] } }),
+    ],
+    notes: ["notes.codex.trust", "notes.codex.hookTrust"],
+};

package/dist/agents/copilot.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { boolMapSection, dirSection, hooksSection, listSection } from "../core/generic.js";
+import { home, listDir, readJson } from "../core/jsonio.js";
+import { mcpGroup } from "../core/groups.js";
+import { t } from "../core/i18n.js";
+import { skillsIn } from "./_skills.js";
+const H = process.env.COPILOT_HOME ?? home(".copilot");
+const settings = {
+    user: () => path.join(H, "settings.json"),
+    project: (c) => path.join(c.root, ".github", "copilot", "settings.json"),
+    local: (c) => path.join(c.root, ".github", "copilot", "settings.local.json"),
+};
+function mcpServers(ctx) {
+    const out = [];
+    for (const [file, tag] of [
+        [path.join(H, "mcp-config.json"), t("hint.user")],
+        [path.join(ctx.root, ".mcp.json"), ".mcp.json"],
+        [path.join(ctx.root, ".github", "mcp.json"), ".github/mcp.json"],
+    ])
+        for (const id of Object.keys(readJson(file).mcpServers ?? {}))
+            out.push({ id, hint: tag, group: mcpGroup(id) });
+    return out;
+}
+export const copilot = {
+    id: "copilot",
+    name: "GitHub Copilot CLI",
+    bins: ["copilot"],
+    dirs: [".copilot"],
+    sections: [
+        listSection({
+            kind: "mcp",
+            files: settings,
+            path: ["disabledMcpServers"],
+            discover: (ctx) => mcpServers(ctx),
+            note: "note.copilotMcpUnion",
+        }),
+        boolMapSection({
+            kind: "plugins",
+            files: { user: settings.user, project: settings.project },
+            path: ["enabledPlugins"],
+            discover: () => (readJson(path.join(H, "config.json")).installedPlugins ?? []).map((p) => ({
+                id: p.marketplace ? `${p.name}@${p.marketplace}` : p.name,
+                hint: p.version,
+                enabled: p.enabled !== false,
+            })),
+        }),
+        listSection({
+            kind: "skills",
+            files: { user: settings.user, project: settings.project },
+            path: ["disabledSkills"],
+            discover: (ctx) => [
+                ...skillsIn([path.join(H, "skills"), home(".agents", "skills")], t("group.user")),
+                ...skillsIn([".github/skills", ".agents/skills", ".claude/skills"].map((d) => path.join(ctx.root, d)), t("group.project")),
+            ],
+        }),
+        hooksSection({
+            agent: "copilot",
+            title: "title.hookSettings",
+            files: settings,
+            key: ["hooks"],
+            disableAll: { path: ["disableAllHooks"], off: true },
+        }),
+        dirSection({ kind: "hooks", title: "title.hookFiles", dirs: { user: () => path.join(H, "hooks"), project: (c) => path.join(c.root, ".github", "hooks") }, entry: { ext: [".json"] } }),
+        listSection({
+            kind: "agents",
+            files: { user: settings.user, project: settings.project },
+            path: ["subagents", "disabledSubagents"],
+            discover: (ctx) => [path.join(H, "agents"), path.join(ctx.root, ".github", "agents")].flatMap((d, i) => listDir(d).filter((f) => f.name.endsWith(".md")).map((f) => ({ id: f.name.replace(/(\.agent)?\.md$/, ""), group: t(i ? "group.project" : "group.user") }))),
+            note: "note.copilotBuiltinAgents",
+        }),
+    ],
+};

package/dist/agents/cursor.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { dirSection, hooksSection, mcpSection } from "../core/generic.js";
+import { home } from "../core/jsonio.js";
+const C = home(".cursor");
+export const cursor = {
+    id: "cursor",
+    name: "Cursor Agent",
+    bins: ["cursor-agent"],
+    dirs: [".cursor"],
+    sections: [
+        mcpSection({
+            agent: "cursor",
+            files: { user: () => path.join(C, "mcp.json"), project: (c) => path.join(c.root, ".cursor", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        dirSection({
+            kind: "skills",
+            dirs: { user: () => path.join(C, "skills"), project: (c) => path.join(c.root, ".cursor", "skills") },
+            entry: { dir: "SKILL.md" },
+            note: "note.linkMoved",
+        }),
+        hooksSection({
+            agent: "cursor",
+            files: { user: () => path.join(C, "hooks.json"), project: (c) => path.join(c.root, ".cursor", "hooks.json") },
+            key: ["hooks"],
+        }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(C, "commands"), project: (c) => path.join(c.root, ".cursor", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(C, "agents"), project: (c) => path.join(c.root, ".cursor", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.cursor.plugins"],
+};

package/dist/agents/devin.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { dirSection, hooksSection, mcpSection } from "../core/generic.js";
+import { home } from "../core/jsonio.js";
+// On Windows, Devin keeps its user config in %APPDATA%\devin.
+const D = process.platform === "win32" ? path.join(process.env.APPDATA ?? home("AppData", "Roaming"), "devin") : home(".config", "devin");
+export const devin = {
+    id: "devin",
+    name: "Devin CLI",
+    bins: ["devin"],
+    dirs: [".devin", D],
+    sections: [
+        mcpSection({
+            agent: "devin",
+            files: {
+                user: () => path.join(D, "mcp_config.json"),
+                project: (c) => path.join(c.root, ".devin", "mcp_config.json"),
+                local: (c) => path.join(c.root, ".devin", "mcp_config.local.json"),
+            },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+            note: "note.devinMcp",
+        }),
+        dirSection({
+            kind: "skills",
+            dirs: { user: () => path.join(D, "skills"), project: (c) => path.join(c.root, ".devin", "skills") },
+            entry: { dir: "SKILL.md" },
+            note: "note.dirMoved",
+        }),
+        hooksSection({
+            agent: "devin",
+            files: {
+                user: () => path.join(D, "config.json"),
+                project: (c) => path.join(c.root, ".devin", "config.json"),
+                local: (c) => path.join(c.root, ".devin", "config.local.json"),
+            },
+            key: ["hooks"],
+        }),
+        dirSection({ kind: "agents", dirs: { user: () => home(".config", "devin", "agents"), project: (c) => path.join(c.root, ".devin", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.devin.plugins"],
+};

package/dist/agents/droid.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { boolMapSection, dirSection, hooksSection, listSection, mcpSection } from "../core/generic.js";
+import { exists, home } from "../core/jsonio.js";
+import { t } from "../core/i18n.js";
+import { skillsIn } from "./_skills.js";
+const F = home(".factory");
+const settings = {
+    user: () => path.join(F, "settings.json"),
+    project: (c) => path.join(c.root, ".factory", "settings.json"),
+    local: (c) => path.join(c.root, ".factory", "settings.local.json"),
+};
+/** Hooks: hooks.json when it exists (it takes precedence), otherwise the hooks key of settings.json. */
+const hooksFile = (dir, settingsFile) => (exists(path.join(dir, "hooks.json")) ? path.join(dir, "hooks.json") : settingsFile);
+export const droid = {
+    id: "droid",
+    name: "Factory Droid",
+    bins: ["droid"],
+    dirs: [".factory"],
+    sections: [
+        mcpSection({
+            agent: "droid",
+            files: { user: () => path.join(F, "mcp.json"), project: (c) => path.join(c.root, ".factory", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        boolMapSection({ kind: "plugins", files: settings, path: ["enabledPlugins"], discover: () => [] }),
+        listSection({
+            kind: "skills",
+            files: { user: settings.user, project: settings.project },
+            path: ["disabledSkills"],
+            discover: (ctx) => [
+                ...skillsIn([path.join(F, "skills"), home(".agents", "skills")], t("group.user")),
+                ...skillsIn([path.join(ctx.root, ".factory", "skills"), path.join(ctx.root, ".agents", "skills")], t("group.project")),
+            ],
+        }),
+        hooksSection({
+            agent: "droid",
+            files: {
+                user: () => hooksFile(F, settings.user()),
+                project: (c) => hooksFile(path.join(c.root, ".factory"), settings.project(c)),
+            },
+            key: ["hooks"],
+            disableAll: { path: ["hooks", "hooksDisabled"], off: true },
+        }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(F, "commands"), project: (c) => path.join(c.root, ".factory", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", title: "title.droids", dirs: { user: () => path.join(F, "droids"), project: (c) => path.join(c.root, ".factory", "droids") }, entry: { ext: [".md"] } }),
+    ],
+};

package/dist/agents/gemini.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { dirSection, hooksSection, listSection, scopeGroup, shortPath } from "../core/generic.js";
+import { editJson, getPath, home, readJson, toggled } from "../core/jsonio.js";
+import { mcpGroup } from "../core/groups.js";
+import { t } from "../core/i18n.js";
+import { skillsIn } from "./_skills.js";
+const G = home(".gemini");
+const settings = { user: () => path.join(G, "settings.json"), project: (c) => path.join(c.root, ".gemini", "settings.json") };
+const settingsFor = (scope, ctx) => (scope === "user" ? settings.user() : settings.project(ctx));
+const servers = (ctx) => [settings.user(), settings.project(ctx)].flatMap((f, i) => Object.keys(readJson(f).mcpServers ?? {}).map((id) => ({ id, hint: t(i ? "hint.project" : "hint.user"), group: mcpGroup(id) })));
+/** Names of the .md agent files of a directory. */
+function agentFiles(dir) {
+    const s = dirSection({ kind: "agents", dirs: { user: () => dir }, entry: { ext: [".md"] } });
+    return s.list({ root: "" }, "user").filter((i) => i.enabled).map((i) => i.label);
+}
+/** Subagents: agents.overrides.<name>.enabled = false. */
+const agents = {
+    kind: "agents",
+    scopes: ["user", "project"],
+    note: (s, c) => `${shortPath(settingsFor(s, c))} · agents.overrides.<name>.enabled`,
+    list(ctx, scope) {
+        const over = getPath(readJson(settingsFor(scope, ctx)), ["agents", "overrides"]) ?? {};
+        const dir = scope === "user" ? path.join(G, "agents") : path.join(ctx.root, ".gemini", "agents");
+        const names = new Set([...Object.keys(over), ...agentFiles(dir)]);
+        return [...names].sort().map((id) => ({ id, label: id, group: scopeGroup(scope), enabled: over[id]?.enabled !== false }));
+    },
+    set(ctx, scope, item, enabled) {
+        const file = settingsFor(scope, ctx);
+        editJson(file, toggled(`Agent ${item.id}`, enabled, shortPath(file)), [{ path: ["agents", "overrides", item.id, "enabled"], value: enabled ? undefined : false }]);
+    },
+};
+export const gemini = {
+    id: "gemini",
+    name: "Gemini CLI",
+    bins: ["gemini"],
+    // ~/.gemini is shared with Antigravity: only the binary counts.
+    dirs: [],
+    sections: [
+        listSection({ kind: "mcp", files: settings, path: ["mcp", "excluded"], discover: (ctx) => servers(ctx) }),
+        listSection({
+            kind: "skills",
+            files: settings,
+            path: ["skills", "disabled"],
+            discover: (ctx, scope) => scope === "user" ? skillsIn([path.join(G, "skills")], t("group.user")) : skillsIn([path.join(ctx.root, ".gemini", "skills")], t("group.project")),
+        }),
+        hooksSection({ agent: "gemini", files: settings, key: ["hooks"], disableAll: { path: ["hooksConfig", "enabled"], off: false } }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(G, "commands"), project: (c) => path.join(c.root, ".gemini", "commands") }, entry: { ext: [".toml"] }, sep: ":" }),
+        agents,
+    ],
+    notes: ["notes.gemini.extensions"],
+};

package/dist/agents/grok.js

@@ -0,0 +1,107 @@
+import path from "node:path";
+import { agentCliJson, describeServer, dirSection, runAgentCli, shortPath, sortByGroup } from "../core/generic.js";
+import { home, readJson, toggled, toggleInList } from "../core/jsonio.js";
+import { readToml, setTomlKey } from "../core/toml.js";
+import { mcpGroup } from "../core/groups.js";
+import { t } from "../core/i18n.js";
+import { tomlListSection } from "./_toml.js";
+import { skillsIn } from "./_skills.js";
+const GROK_HOME = process.env.GROK_HOME ?? home(".grok");
+const userConfig = () => path.join(GROK_HOME, "config.toml");
+const projectConfig = (c) => path.join(c.root, ".grok", "config.toml");
+/**
+ * MCP. User: native disabled_mcp_servers list, valid for every source
+ * (config, .mcp.json, Claude/Cursor compat, plugins).
+ * Project: enabled = false on the servers defined in .grok/config.toml.
+ */
+const mcp = {
+    kind: "mcp",
+    scopes: ["user", "project"],
+    note: (s, c) => s === "user"
+        ? `${shortPath(userConfig())} · disabled_mcp_servers (${t("note.allSources")})`
+        : `${shortPath(projectConfig(c))} · [mcp_servers.<name>] enabled = false`,
+    list(ctx, scope) {
+        const items = new Map();
+        const add = (id, hint, enabled) => {
+            if (!items.has(id))
+                items.set(id, { id, label: id, hint, group: mcpGroup(id), enabled });
+        };
+        if (scope === "user") {
+            const cfg = readToml(userConfig());
+            const off = cfg.disabled_mcp_servers ?? [];
+            for (const [n, d] of Object.entries(cfg.mcp_servers ?? {}))
+                add(n, describeServer(d), !off.includes(n) && d.enabled !== false);
+            for (const [n, d] of Object.entries(readToml(projectConfig(ctx)).mcp_servers ?? {}))
+                add(n, `${t("hint.project")} · ${describeServer(d)}`, !off.includes(n));
+            for (const [n, d] of Object.entries(readJson(path.join(ctx.root, ".mcp.json")).mcpServers ?? {}))
+                add(n, `.mcp.json · ${describeServer(d)}`, !off.includes(n));
+            for (const n of off)
+                add(n, t("hint.otherSource"), false);
+        }
+        else {
+            for (const [n, d] of Object.entries(readToml(projectConfig(ctx)).mcp_servers ?? {}))
+                add(n, describeServer(d), d.enabled !== false);
+        }
+        return sortByGroup([...items.values()]);
+    },
+    set(ctx, scope, item, enabled) {
+        const label = `MCP ${item.id}`;
+        if (scope === "user") {
+            const list = toggleInList(readToml(userConfig()).disabled_mcp_servers, item.id, !enabled);
+            setTomlKey(userConfig(), [], "disabled_mcp_servers", list.length ? list : undefined, toggled(label, enabled, shortPath(userConfig())));
+            // An enabled = false set elsewhere would prevent re-enabling.
+            if (enabled && readToml(userConfig()).mcp_servers?.[item.id]?.enabled === false)
+                setTomlKey(userConfig(), ["mcp_servers", item.id], "enabled", undefined, toggled(label, true, "enabled = false"));
+        }
+        else
+            setTomlKey(projectConfig(ctx), ["mcp_servers", item.id], "enabled", enabled ? undefined : false, toggled(label, enabled, shortPath(projectConfig(ctx))));
+    },
+};
+/** Plugins: state read from [plugins], switched through "grok plugin enable|disable". */
+const plugins = {
+    kind: "plugins",
+    scopes: ["user"],
+    note: () => t("note.grokPlugins"),
+    list() {
+        const cfg = readToml(userConfig()).plugins ?? {};
+        const on = cfg.enabled ?? [];
+        const off = cfg.disabled ?? [];
+        const found = agentCliJson("grok", ["plugin", "list", "--json"]) ?? [];
+        return found.map((p) => ({
+            id: p.name,
+            label: p.name,
+            hint: `${p.marketplace ?? ""} ${p.version ?? ""}`.trim(),
+            group: t("group.installed"),
+            enabled: !off.includes(p.name) && (on.length === 0 || on.includes(p.name)),
+        }));
+    },
+    set(_ctx, _scope, item, enabled) {
+        runAgentCli("grok", ["plugin", enabled ? "enable" : "disable", item.id], toggled(`Plugin ${item.id}`, enabled, "grok plugin"));
+    },
+};
+export const grok = {
+    id: "grok",
+    name: "Grok Build",
+    bins: ["grok"],
+    dirs: [".grok"],
+    sections: [
+        mcp,
+        plugins,
+        tomlListSection({
+            kind: "skills",
+            files: { user: userConfig },
+            table: ["skills"],
+            key: "disabled",
+            discover: (ctx) => [
+                ...skillsIn([path.join(GROK_HOME, "skills"), home(".agents", "skills")], t("group.user")),
+                ...skillsIn([path.join(ctx.root, ".grok", "skills"), path.join(ctx.root, ".agents", "skills")], t("group.project")),
+                ...skillsIn([path.join(GROK_HOME, "bundled", "skills")], t("group.builtin")),
+            ],
+            note: "note.grokSkills",
+        }),
+        dirSection({ kind: "hooks", title: "title.hookFiles", dirs: { user: () => path.join(GROK_HOME, "hooks"), project: (c) => path.join(c.root, ".grok", "hooks") }, entry: { ext: [".json"] } }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(GROK_HOME, "commands"), project: (c) => path.join(c.root, ".grok", "commands") }, entry: { ext: [".md"] }, sep: ":" }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(GROK_HOME, "agents"), project: (c) => path.join(c.root, ".grok", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.grok.compat", "notes.grok.trust"],
+};

package/dist/agents/index.js

@@ -0,0 +1,41 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { exists, home } from "../core/jsonio.js";
+import { t } from "../core/i18n.js";
+import { claude } from "./claude/index.js";
+import { codex } from "./codex.js";
+import { grok } from "./grok.js";
+import { droid } from "./droid.js";
+import { cursor } from "./cursor.js";
+import { copilot } from "./copilot.js";
+import { devin } from "./devin.js";
+import { gemini } from "./gemini.js";
+import { antigravity } from "./antigravity.js";
+import { qwen } from "./qwen.js";
+import { amp, crush, kilo, kiro, opencode, warp } from "./others.js";
+import { aider, amazonq, auggie, cline, codebuddy, codebuff, commandcode, continueCli, goose, hermes, iflow, junie, kimi, letta, openhands, pi, plandex, qoder, qodo, rovodev, trae, vibe, windsurf, } from "./more.js";
+/** Every supported agent; only the detected ones are shown by default. */
+export const AGENTS = [
+    claude, codex, gemini, grok, cursor, copilot, devin, antigravity, qwen, droid, opencode, kilo, amp, crush, kiro, amazonq,
+    goose, cline, continueCli, auggie, junie, openhands, kimi, vibe, rovodev, qoder, codebuddy, letta, pi, codebuff, hermes,
+    commandcode, windsurf, trae, iflow, qodo, aider, plandex, warp,
+];
+function onPath(bin) {
+    const r = process.platform === "win32"
+        ? spawnSync("where", [bin], { encoding: "utf8" })
+        : spawnSync("sh", ["-c", `command -v ${bin}`], { encoding: "utf8" });
+    return r.status === 0 && !!r.stdout.trim();
+}
+const cache = new Map();
+/** Installed = a binary on the PATH, or failing that a characteristic directory. */
+export function isInstalled(a) {
+    if (!cache.has(a.id))
+        cache.set(a.id, a.bins.some(onPath) || a.dirs.some((d) => exists(path.isAbsolute(d) ? d : home(d))));
+    return cache.get(a.id);
+}
+export function findAgent(id) {
+    const a = AGENTS.find((x) => x.id === id || x.bins.includes(id));
+    if (!a)
+        throw new Error(t("err.unknownAgent", { id, agents: AGENTS.map((x) => x.id).join(", ") }));
+    return a;
+}