kritya 0.8.2-beta

package/dist/commands/mcpCommand.js

@@ -0,0 +1,433 @@
+import { assertSafeUrl, connectServer, disconnectServer, forgetStatus, mcpStatus, replaceStatus, isToolOf, } from "../mcp/client.js";
+import { beginLogin, logout, pendingLogin } from "../mcp/login.js";
+import { loadAuth } from "../mcp/tokens.js";
+import { expandServerConfig, loadProjectMcpServers } from "../mcp/servers.js";
+import { loadConfig, saveConfig } from "../config/config.js";
+import { pluginsDir, scanPlugins, userPluginsDir } from "../plugins/discover.js";
+import { loadPluginMcpServers } from "../plugins/mcp.js";
+import { isServerTrusted, loadMcpAllowlist, revokeFingerprint, revokeServer, serverFingerprint, trustServer, } from "../trust/mcpTrust.js";
+/** Find a server by name across both config sources, with where it came from. */
+export function resolveServer(name, workspace) {
+    const global = loadConfig().mcpServers?.[name];
+    if (global)
+        return { name, cfg: expandServerConfig(global), provenance: "global" };
+    const project = loadProjectMcpServers(workspace)?.[name];
+    if (project)
+        return { name, cfg: expandServerConfig(project), provenance: "project" };
+    return undefined;
+}
+const USAGE = `Usage:
+  /mcp                          status of every configured server
+  /mcp add <name> <url>         add a remote (HTTP) server to your config
+  /mcp add <name> -- <cmd...>   add a local (stdio) server to your config
+  /mcp remove <name>            remove a server from your config
+  /mcp login <name>             sign in to a server via your browser
+  /mcp logout <name>            revoke and delete a server's saved token
+  /mcp code <name> <code>       finish a login by pasting the code (SSH/headless)
+  /mcp trust                    list the servers you've approved
+  /mcp trust revoke <name>      withdraw approval, so it's asked about again`;
+export async function runMcpCommand(ctx) {
+    const parts = ctx.arg.trim().split(/\s+/).filter(Boolean);
+    const sub = parts[0]?.toLowerCase();
+    switch (sub) {
+        case undefined:
+            return showStatus(ctx);
+        case "add":
+            return addServer(ctx, parts.slice(1));
+        case "remove":
+        case "rm":
+            return removeServer(ctx, parts[1]);
+        case "login":
+            return loginServer(ctx, parts[1], parts.slice(2));
+        case "logout":
+            return logoutServer(ctx, parts[1]);
+        case "code":
+            return submitCode(ctx, parts[1], parts.slice(2).join(" "));
+        case "trust":
+            return trustCommand(ctx, parts.slice(1));
+        default:
+            ctx.addItem({ kind: "info", text: `Unknown /mcp subcommand "${sub}".\n\n${USAGE}` });
+    }
+}
+function showStatus(ctx) {
+    const statuses = mcpStatus();
+    const plugins = scanPlugins([pluginsDir(ctx.workspace), userPluginsDir()]);
+    const { provenance } = loadPluginMcpServers(plugins, () => { });
+    if (statuses.length === 0) {
+        ctx.addItem({
+            kind: "info",
+            text: "No MCP servers configured.\n\n" +
+                "Add one with /mcp add <name> <url>, or by hand under mcpServers in\n" +
+                "~/.kritya/config.json or a .mcp.json at the workspace root:\n" +
+                `  { "mcpServers": { "linear": { "url": "https://mcp.linear.app/mcp" },\n` +
+                `                    "files":  { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] } } }`,
+        });
+        return;
+    }
+    const lines = statuses.map((s) => {
+        const mark = s.ok ? "✔" : s.needsAuth ? "○" : "✘";
+        const plugin = provenance[s.name] ? ` (plugin: ${provenance[s.name]})` : "";
+        const head = `${mark} ${s.name} (${s.transport})${plugin} — ${s.target}`;
+        if (s.ok) {
+            const auth = s.transport === "http" && loadAuth(s.target) ? " · signed in" : "";
+            const hidden = s.hiddenTools ? ` · ${s.hiddenTools} hidden by config` : "";
+            const extras = [
+                s.prompts.length ? `    ${s.prompts.length} prompt(s): ${s.prompts.join(", ")}` : "",
+                s.resources.length
+                    ? `    ${s.resources.length} resource(s): ${s.resources.join(", ")}`
+                    : "",
+            ].filter(Boolean);
+            return [
+                `${head}${auth}${hidden}`,
+                `    ${s.tools.length} tool(s): ${s.tools.join(", ") || "(none)"}`,
+                ...extras,
+            ].join("\n");
+        }
+        return `${head}\n    ${s.needsAuth ? s.error : `failed: ${s.error}`}`;
+    });
+    const anyAuth = statuses.some((s) => s.needsAuth);
+    const hint = anyAuth ? "\n\n○ = signed out. Run /mcp login <name> to connect it." : "";
+    ctx.addItem({ kind: "info", text: `MCP servers:\n${lines.join("\n")}${hint}\n\n${USAGE}` });
+}
+function addServer(ctx, args) {
+    const name = args[0];
+    const rest = args.slice(1);
+    if (!name || rest.length === 0) {
+        ctx.addItem({
+            kind: "info",
+            text: `Usage: /mcp add <name> <url>  ·  /mcp add <name> -- <command> [args...]`,
+        });
+        return;
+    }
+    if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+        ctx.addItem({
+            kind: "info",
+            text: `Invalid server name "${name}". Use letters, digits, "-" and "_" only — the name becomes part of each tool's name.`,
+        });
+        return;
+    }
+    let cfg;
+    if (rest[0] === "--") {
+        const [command, ...cmdArgs] = rest.slice(1);
+        if (!command) {
+            ctx.addItem({ kind: "info", text: "Usage: /mcp add <name> -- <command> [args...]" });
+            return;
+        }
+        cfg = { command, args: cmdArgs.length ? cmdArgs : undefined };
+    }
+    else {
+        const url = rest[0];
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            ctx.addItem({
+                kind: "info",
+                text: `"${url}" is not a valid URL. For a local server use: /mcp add ${name} -- <command> [args...]`,
+            });
+            return;
+        }
+        if (parsed.protocol !== "https:" &&
+            parsed.hostname !== "localhost" &&
+            parsed.hostname !== "127.0.0.1") {
+            ctx.addItem({
+                kind: "info",
+                text: `Refusing to add "${url}" over plain HTTP — an MCP session carries your credentials. Use https:// (localhost is exempt).`,
+            });
+            return;
+        }
+        cfg = { url };
+    }
+    const config = loadConfig();
+    const servers = { ...config.mcpServers, [name]: cfg };
+    saveConfig({ mcpServers: servers });
+    // Added by hand from this session, so it's the user's own decision — record
+    // the trust now rather than prompting about it on the next startup.
+    trustServer(name, serverFingerprint(cfg));
+    ctx.addItem({
+        kind: "info",
+        text: `Added "${name}" to ~/.kritya/config.json. Connecting…`,
+    });
+    void connectAndAttach(ctx, name, expandServerConfig(cfg));
+}
+async function removeServer(ctx, name) {
+    if (!name) {
+        ctx.addItem({ kind: "info", text: "Usage: /mcp remove <name>" });
+        return;
+    }
+    const config = loadConfig();
+    const cfg = config.mcpServers?.[name];
+    if (!cfg) {
+        const inProject = loadProjectMcpServers(ctx.workspace)?.[name];
+        ctx.addItem({
+            kind: "info",
+            text: inProject
+                ? `"${name}" comes from this workspace's .mcp.json, not your config — remove it from that file (it is checked into the repo).\n` +
+                    `To stop it loading without touching the repo: /mcp trust revoke ${name}`
+                : `No server named "${name}" in ~/.kritya/config.json.`,
+        });
+        return;
+    }
+    const servers = { ...config.mcpServers };
+    delete servers[name];
+    saveConfig({ mcpServers: servers });
+    // A stored token for a server you just removed is a credential with no
+    // remaining purpose; revoke and delete it rather than leaving it behind.
+    let tokenNote = "";
+    if (cfg.url) {
+        const url = expandServerConfig(cfg).url;
+        const result = await logout(url);
+        if (result.hadToken) {
+            tokenNote = result.revoked
+                ? "\nIts saved token was revoked and deleted."
+                : "\nIts saved token was deleted locally (the server offers no revocation endpoint).";
+        }
+    }
+    // Leaving the approval behind would re-approve this exact config silently
+    // the next time any workspace declares it — the server is gone, so the
+    // standing permission should go with it.
+    const untrusted = revokeFingerprint(serverFingerprint(cfg));
+    disconnectServer(name);
+    // Withdraw before forgetting: forgetStatus releases the server's tool names,
+    // after which isToolOf can no longer identify them.
+    const removed = ctx.agent.removeTools(isToolOf(name));
+    forgetStatus(name);
+    ctx.addItem({
+        kind: "info",
+        text: `Removed "${name}" — ${removed} tool(s) withdrawn.${tokenNote}` +
+            (untrusted ? "\nIts approval was withdrawn too." : ""),
+    });
+}
+async function loginServer(ctx, name, flags) {
+    if (!name) {
+        ctx.addItem({ kind: "info", text: "Usage: /mcp login <name>" });
+        return;
+    }
+    const server = resolveServer(name, ctx.workspace);
+    if (!server) {
+        ctx.addItem({
+            kind: "info",
+            text: `No server named "${name}". See /mcp for the list, or add one with /mcp add <name> <url>.`,
+        });
+        return;
+    }
+    if (!server.cfg.url) {
+        ctx.addItem({
+            kind: "info",
+            text: `"${name}" is a local (stdio) server — it runs as your own user and has nothing to log in to.`,
+        });
+        return;
+    }
+    // A login never reaches connectServer, so the transport's own scheme check
+    // can't cover it — and this path is worse than a plain request, since it
+    // mints a durable token against the user's real account.
+    try {
+        assertSafeUrl(name, server.cfg.url);
+    }
+    catch (err) {
+        ctx.addItem({ kind: "info", text: err instanceof Error ? err.message : String(err) });
+        return;
+    }
+    const confirmed = flags.some((f) => f === "--yes" || f === "-y" || f === "confirm");
+    if (server.provenance === "project" && !confirmed) {
+        ctx.addItem({
+            kind: "info",
+            text: `"${name}" is declared by this workspace's .mcp.json, not by you.\n\n` +
+                `  ${server.cfg.url}\n\n` +
+                `Logging in opens your browser and grants this server a token for your\n` +
+                `real account there — it will keep working after this session ends.\n\n` +
+                `If you trust the repo, confirm with:  /mcp login ${name} --yes`,
+        });
+        return;
+    }
+    // A project server that was never through the per-server trust gate (added by
+    // a pull after startup, say) must not reach a consent screen on --yes alone.
+    if (server.provenance === "project" && !isServerTrusted(serverFingerprint(server.cfg))) {
+        trustServer(name, serverFingerprint(server.cfg));
+    }
+    const status = mcpStatus().find((s) => s.name === name);
+    ctx.setActivity(`Signing in to ${name}…`);
+    try {
+        const login = await beginLogin({
+            serverName: name,
+            serverUrl: server.cfg.url,
+            resourceMetadataUrl: status?.authMetadataUrl,
+        });
+        ctx.addItem({
+            kind: "info",
+            text: login.browserOpened
+                ? `Opened your browser to sign in to "${name}".\n` +
+                    `Approve the request there, then this session picks it up automatically.\n\n` +
+                    `If the browser didn't open: ${login.authorizeUrl}`
+                : `No browser available here. Open this URL on any machine:\n\n` +
+                    `${login.authorizeUrl}\n\n` +
+                    `If the redirect can reach ${login.redirectUri} it completes by itself.\n` +
+                    `Otherwise copy the "code" from the address bar and run:\n` +
+                    `  /mcp code ${name} <code>`,
+        });
+        const auth = await login.completed;
+        ctx.addItem({
+            kind: "info",
+            text: `Signed in to "${name}"${auth.scope ? ` (scope: ${auth.scope})` : ""}. Connecting…`,
+        });
+        await connectAndAttach(ctx, name, server.cfg);
+    }
+    catch (err) {
+        ctx.addItem({
+            kind: "info",
+            text: `Login for "${name}" failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+    finally {
+        ctx.setActivity(null);
+    }
+}
+/**
+ * `/mcp trust` — inspect and withdraw per-server approvals.
+ *
+ * Trust is matched by fingerprint across every workspace, so an entry left
+ * behind for a server you've stopped using will silently approve it again the
+ * next time any repo declares the same config. Listing makes that visible;
+ * revoking is the only way to undo an approval short of editing the store.
+ */
+function trustCommand(ctx, args) {
+    const sub = args[0]?.toLowerCase();
+    if (sub === undefined)
+        return listTrusted(ctx);
+    if (sub !== "revoke") {
+        ctx.addItem({ kind: "info", text: `Usage: /mcp trust  ·  /mcp trust revoke <name>` });
+        return;
+    }
+    const name = args[1];
+    if (!name) {
+        ctx.addItem({ kind: "info", text: "Usage: /mcp trust revoke <name>" });
+        return;
+    }
+    const removed = revokeServer(name);
+    if (!removed.length) {
+        ctx.addItem({
+            kind: "info",
+            text: `"${name}" isn't in the trust list — nothing to revoke. See /mcp trust.`,
+        });
+        return;
+    }
+    // Revoking doesn't stop a server already running this session: it governs
+    // whether the next load asks again. Say so rather than implying it's dead.
+    const running = mcpStatus().find((s) => s.name === name && s.ok);
+    const note = running
+        ? `\n\nIt stays connected for this session — /mcp remove ${name} withdraws it now.`
+        : "";
+    ctx.addItem({
+        kind: "info",
+        text: `Revoked trust for "${name}" (${removed.length} entr${removed.length > 1 ? "ies" : "y"}).\n` +
+            `Any workspace declaring it will ask before loading it again.${note}`,
+    });
+}
+function listTrusted(ctx) {
+    const entries = loadMcpAllowlist();
+    if (!entries.length) {
+        ctx.addItem({
+            kind: "info",
+            text: "No MCP servers have been approved yet.\n\nServers you approve at startup are listed here.",
+        });
+        return;
+    }
+    const lines = entries
+        .slice()
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((e) => {
+        const when = e.trustedAt.slice(0, 10);
+        return `  ${e.name}  — approved ${when}  (${e.fingerprint.slice(0, 12)})`;
+    });
+    ctx.addItem({
+        kind: "info",
+        text: `Approved MCP servers:\n${lines.join("\n")}\n\n` +
+            `Approval is matched by config fingerprint and applies in every workspace.\n` +
+            `Withdraw one with /mcp trust revoke <name>.`,
+    });
+}
+function submitCode(ctx, name, code) {
+    if (!name || !code) {
+        ctx.addItem({ kind: "info", text: "Usage: /mcp code <name> <code-or-redirect-url>" });
+        return;
+    }
+    const login = pendingLogin(name);
+    if (!login) {
+        ctx.addItem({
+            kind: "info",
+            text: `No login in progress for "${name}". Start one with /mcp login ${name}.`,
+        });
+        return;
+    }
+    login.submitCode(code);
+    ctx.addItem({ kind: "info", text: `Code accepted for "${name}" — exchanging it for a token…` });
+}
+async function logoutServer(ctx, name) {
+    if (!name) {
+        ctx.addItem({ kind: "info", text: "Usage: /mcp logout <name>" });
+        return;
+    }
+    const server = resolveServer(name, ctx.workspace);
+    if (!server?.cfg.url) {
+        ctx.addItem({
+            kind: "info",
+            text: `No remote server named "${name}" to log out of.`,
+        });
+        return;
+    }
+    const result = await logout(server.cfg.url);
+    if (!result.hadToken) {
+        ctx.addItem({ kind: "info", text: `No saved token for "${name}" — nothing to log out of.` });
+        return;
+    }
+    disconnectServer(name);
+    const removed = ctx.agent.removeTools(isToolOf(name));
+    replaceStatus({
+        name,
+        transport: "http",
+        target: server.cfg.url,
+        ok: false,
+        needsAuth: true,
+        error: `needs login — run /mcp login ${name}`,
+        tools: [],
+        prompts: [],
+        resources: [],
+    });
+    // Deleting a token locally is not the same as killing it, and only one of
+    // those is something the user can rely on. Say which happened.
+    ctx.addItem({
+        kind: "info",
+        text: result.revoked
+            ? `Logged out of "${name}" — token revoked with the server and deleted locally. ${removed} tool(s) withdrawn.`
+            : `Logged out of "${name}" — token deleted locally. ${removed} tool(s) withdrawn.\n` +
+                `⚠ This server offers no revocation endpoint, so the token stays valid on\n` +
+                `  their side until it expires. Remove kritya in that service's settings\n` +
+                `  if you need it dead now.`,
+    });
+}
+/** Connect (or reconnect) a server and hand its tools to the running agent. */
+async function connectAndAttach(ctx, name, cfg) {
+    disconnectServer(name);
+    ctx.agent.removeTools(isToolOf(name));
+    const { tools, status } = await connectServer(name, cfg, {
+        tracer: ctx.agent.tracer,
+        audit: ctx.agent.audit,
+        workspace: ctx.workspace,
+    });
+    replaceStatus(status);
+    if (!status.ok) {
+        ctx.addItem({
+            kind: "info",
+            text: status.needsAuth
+                ? `"${name}" still needs a login — run /mcp login ${name}.`
+                : `"${name}" failed to connect: ${status.error}`,
+        });
+        return;
+    }
+    ctx.agent.addTools(tools);
+    ctx.addItem({
+        kind: "info",
+        text: `"${name}" connected — ${tools.length} tool(s) available now: ${status.tools.join(", ") || "(none)"}`,
+    });
+}

package/dist/commands/pluginsCommand.js

@@ -0,0 +1,204 @@
+import { scanAllPlugins, loadPluginMcpServers } from "../agent/plugins.js";
+import { connectServer, mcpStatus, replaceStatus, disconnectServer, forgetStatus, isToolOf } from "../mcp/client.js";
+/**
+ * The `/plugins` command family: list, show details, and manage plugins.
+ *
+ * Plugins are Agent Plugins packages that bundle skills and MCP servers
+ * into a portable format following the agent-plugins specification.
+ *
+ * @see https://agent-plugins.org/
+ */
+const USAGE = `Usage:
+  /plugins                    list all discovered plugins
+  /plugins <name>             show details for a specific plugin
+  /plugins <name> connect     connect plugins MCP servers to kritya
+  /plugins <name> disconnect  disconnect plugins MCP servers from kritya`;
+export async function runPluginsCommand(ctx) {
+    const parts = ctx.arg.trim().split(/\s+/).filter(Boolean);
+    const sub = parts[0]?.toLowerCase();
+    switch (sub) {
+        case undefined:
+            return listPlugins(ctx);
+        case "connect":
+            return connectPlugin(ctx, parts[1]);
+        case "disconnect":
+            return disconnectPlugin(ctx, parts[1]);
+        default:
+            // If it's not a subcommand, treat it as a plugin name to show details
+            return showPlugin(ctx, sub);
+    }
+}
+function listPlugins(ctx) {
+    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
+    if (!plugins.length) {
+        ctx.addItem({
+            kind: "info",
+            text: "No plugins found.\n\n" +
+                "Plugins are loaded from ~/.kritya/plugins (user-global) and .kritya/plugins (project).\n" +
+                "Create a plugin with a plugin.json manifest, skills/ directory, and optional mcp.json.",
+        });
+        return;
+    }
+    const lines = plugins.map((p) => {
+        const versionInfo = p.version ? ` v${p.version}` : "";
+        const desc = p.description ? ` - ${p.description}` : "";
+        return `  ${p.name}${versionInfo}${desc} (${p.id})`;
+    });
+    ctx.addItem({
+        kind: "info",
+        text: `Plugins:\n${lines.join("\n")}\n\n${USAGE}`,
+    });
+}
+async function showPlugin(ctx, pluginName) {
+    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
+    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
+    if (!plugin) {
+        ctx.addItem({
+            kind: "info",
+            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
+        });
+        return;
+    }
+    // Report skills - note that they are loaded from plugin.skillsDir
+    const skillsText = plugin.skillsDir
+        ? `Skills: Available from ${plugin.skillsDir}\n(Use /skills to list discovered skills including plugin skills)`
+        : "No skills directory";
+    // Load MCP servers from this plugin
+    const mcpServers = loadPluginMcpServers(plugin);
+    const mcpText = mcpServers
+        ? `MCP Servers (${Object.keys(mcpServers).length}):\n${Object.entries(mcpServers).map(([name, cfg]) => {
+            const target = typeof cfg.command === "string" ? `command: ${cfg.command}` : `url: ${cfg.url}`;
+            return `  - ${name}: ${target}`;
+        }).join("\n")}`
+        : "No MCP servers";
+    // Check if MCP servers are currently connected
+    const status = mcpStatus();
+    const connectedServers = status
+        .filter((s) => s.ok && Object.keys(mcpServers || {}).includes(s.name))
+        .map((s) => s.name);
+    const connectionState = connectedServers.length
+        ? `Connected servers: ${connectedServers.join(", ")}`
+        : "MCP servers not connected";
+    ctx.addItem({
+        kind: "info",
+        text: `Plugin: ${plugin.name} ${plugin.version ? `v${plugin.version}` : ""} (${plugin.id})
+${plugin.description ? `Description: ${plugin.description}` : ""}
+
+${skillsText}
+
+${mcpText}
+
+${connectionState}
+
+${USAGE}`,
+    });
+}
+async function connectPlugin(ctx, pluginName) {
+    if (!pluginName) {
+        ctx.addItem({ kind: "info", text: `Usage: /plugins <name> connect` });
+        return;
+    }
+    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
+    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
+    if (!plugin) {
+        ctx.addItem({
+            kind: "info",
+            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
+        });
+        return;
+    }
+    // Load MCP servers from this plugin
+    const mcpServers = loadPluginMcpServers(plugin);
+    if (!mcpServers || !Object.keys(mcpServers).length) {
+        ctx.addItem({
+            kind: "info",
+            text: `Plugin "${pluginName}" has no MCP servers to connect.`,
+        });
+        return;
+    }
+    // Connect each server with plugin-specific naming
+    const connected = [];
+    const failed = [];
+    for (const [name, cfg] of Object.entries(mcpServers)) {
+        // Namespace server name with plugin ID to avoid conflicts
+        const pluginNamespace = plugin.id.replace(/[^a-z0-9_-]/g, "_");
+        const serverName = `${pluginNamespace}:${name}`;
+        try {
+            const { tools, status } = await connectServer(serverName, cfg, {
+                tracer: ctx.agent.tracer,
+                audit: ctx.agent.audit,
+                workspace: ctx.workspace,
+            });
+            replaceStatus(status);
+            if (status.ok) {
+                ctx.agent.addTools(tools);
+                connected.push(serverName);
+            }
+            else {
+                failed.push({ name: serverName, error: status.error || "unknown error" });
+            }
+        }
+        catch (err) {
+            failed.push({ name: serverName, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    let response = `Plugin "${pluginName}":\n`;
+    if (connected.length) {
+        response += `Connected ${connected.length} server(s): ${connected.join(", ")}\n`;
+    }
+    if (failed.length) {
+        response += `Failed to connect ${failed.length} server(s):\n`;
+        response += failed.map((f) => `  - ${f.name}: ${f.error}`).join("\n");
+    }
+    ctx.addItem({ kind: "info", text: response });
+}
+async function disconnectPlugin(ctx, pluginName) {
+    if (!pluginName) {
+        ctx.addItem({ kind: "info", text: `Usage: /plugins <name> disconnect` });
+        return;
+    }
+    const { loaded: plugins } = scanAllPlugins(ctx.workspace);
+    const plugin = plugins.find((p) => p.name === pluginName || p.id === pluginName);
+    if (!plugin) {
+        ctx.addItem({
+            kind: "info",
+            text: `No plugin named "${pluginName}". Run /plugins to see available plugins.`,
+        });
+        return;
+    }
+    // Load MCP servers from this plugin
+    const mcpServers = loadPluginMcpServers(plugin);
+    if (!mcpServers || !Object.keys(mcpServers).length) {
+        ctx.addItem({
+            kind: "info",
+            text: `Plugin "${pluginName}" has no MCP servers to disconnect.`,
+        });
+        return;
+    }
+    // Disconnect each server
+    const disconnected = [];
+    let removedTools = 0;
+    for (const [name] of Object.entries(mcpServers)) {
+        // Use the same namespace as connect
+        const pluginNamespace = plugin.id.replace(/[^a-z0-9_-]/g, "_");
+        const serverName = `${pluginNamespace}:${name}`;
+        disconnected.push(serverName);
+        // Get tools to remove
+        const status = mcpStatus().find((s) => s.name === serverName && s.ok);
+        if (status) {
+            removedTools += status.tools.length;
+        }
+        // Actually disconnect the server
+        disconnectServer(serverName);
+        // Remove tools from agent
+        ctx.agent.removeTools(isToolOf(serverName));
+        // Forget status so it doesn't remain visible
+        forgetStatus(serverName);
+    }
+    ctx.addItem({
+        kind: "info",
+        text: `Plugin "${pluginName}":\n` +
+            `Disconnected ${disconnected.length} server(s): ${disconnected.join(", ")}\n` +
+            `Removed ${removedTools} tool(s).`,
+    });
+}