opencodekit 0.16.10 → 0.16.13

package/dist/template/.opencode/plugin/skill-mcp.ts

@@ -6,28 +6,31 @@ import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin/tool";
 
 interface McpServerConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-  includeTools?: string[]; // Ampcode-style tool filtering with glob patterns
+	command: string;
+	args?: string[];
+	env?: Record<string, string>;
+	includeTools?: string[]; // Ampcode-style tool filtering with glob patterns
 }
 
 interface McpClient {
-  process: ChildProcess;
-  config: McpServerConfig;
-  requestId: number;
-  pendingRequests: Map<number, { resolve: (v: any) => void; reject: (e: any) => void }>;
-  capabilities?: {
-    tools?: any[];
-    resources?: any[];
-    prompts?: any[];
-  };
-  filteredTools?: any[]; // Tools after includeTools filtering
+	process: ChildProcess;
+	config: McpServerConfig;
+	requestId: number;
+	pendingRequests: Map<
+		number,
+		{ resolve: (v: any) => void; reject: (e: any) => void }
+	>;
+	capabilities?: {
+		tools?: any[];
+		resources?: any[];
+		prompts?: any[];
+	};
+	filteredTools?: any[]; // Tools after includeTools filtering
 }
 
 interface SkillMcpState {
-  clients: Map<string, McpClient>; // key: skillName:serverName
-  loadedSkills: Map<string, Record<string, McpServerConfig>>; // skillName -> mcp configs
+	clients: Map<string, McpClient>; // key: skillName:serverName
+	loadedSkills: Map<string, Record<string, McpServerConfig>>; // skillName -> mcp configs
 }
 
 /**
@@ -35,109 +38,109 @@ interface SkillMcpState {
  * Supports: exact match, * (any chars), ? (single char)
  */
 function matchGlobPattern(pattern: string, toolName: string): boolean {
-  // Exact match
-  if (pattern === toolName) return true;
+	// Exact match
+	if (pattern === toolName) return true;
 
-  // Convert glob to regex
-  const regexPattern = pattern
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
-    .replace(/\*/g, ".*") // * -> .*
-    .replace(/\?/g, "."); // ? -> .
+	// Convert glob to regex
+	const regexPattern = pattern
+		.replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars
+		.replace(/\*/g, ".*") // * -> .*
+		.replace(/\?/g, "."); // ? -> .
 
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(toolName);
+	const regex = new RegExp(`^${regexPattern}$`);
+	return regex.test(toolName);
 }
 
 /**
  * Filter tools based on includeTools patterns
  */
 function filterTools(allTools: any[], includePatterns?: string[]): any[] {
-  if (!includePatterns || includePatterns.length === 0) {
-    return allTools; // No filtering, return all
-  }
+	if (!includePatterns || includePatterns.length === 0) {
+		return allTools; // No filtering, return all
+	}
 
-  return allTools.filter((tool) =>
-    includePatterns.some((pattern) => matchGlobPattern(pattern, tool.name)),
-  );
+	return allTools.filter((tool) =>
+		includePatterns.some((pattern) => matchGlobPattern(pattern, tool.name)),
+	);
 }
 
 function parseYamlFrontmatter(content: string): {
-  frontmatter: any;
-  body: string;
+	frontmatter: any;
+	body: string;
 } {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return { frontmatter: {}, body: content };
-
-  const yamlStr = match[1];
-  const body = match[2];
-
-  // Simple YAML parser for our use case
-  const frontmatter: any = {};
-  let mcpConfig: any = null;
-  let serverName = "";
-  let serverConfig: any = {};
-  let currentArrayKey = "";
-
-  for (const line of yamlStr.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    const indent = line.search(/\S/);
-    const keyMatch = trimmed.match(/^([\w-]+):\s*(.*)$/);
-
-    if (keyMatch) {
-      const [, key, value] = keyMatch;
-
-      if (indent === 0) {
-        // Top-level key
-        if (key === "mcp") {
-          mcpConfig = {};
-          frontmatter.mcp = mcpConfig;
-        } else {
-          frontmatter[key] = value || undefined;
-        }
-        currentArrayKey = "";
-      } else if (mcpConfig !== null && indent === 2) {
-        // Server name under mcp
-        serverName = key;
-        serverConfig = {};
-        mcpConfig[serverName] = serverConfig;
-        currentArrayKey = "";
-      } else if (serverConfig && indent === 4) {
-        // Server config property
-        if (key === "command") {
-          serverConfig.command = value;
-          currentArrayKey = "";
-        } else if (key === "args" || key === "includeTools") {
-          // Parse inline array or set up for multi-line
-          if (value.startsWith("[")) {
-            try {
-              serverConfig[key] = JSON.parse(value);
-            } catch {
-              serverConfig[key] = [];
-            }
-            currentArrayKey = "";
-          } else {
-            serverConfig[key] = [];
-            currentArrayKey = key;
-          }
-        } else {
-          currentArrayKey = "";
-        }
-      }
-    } else if (
-      trimmed.startsWith("- ") &&
-      serverConfig &&
-      currentArrayKey &&
-      serverConfig[currentArrayKey]
-    ) {
-      // Array item for args or includeTools
-      const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
-      serverConfig[currentArrayKey].push(item);
-    }
-  }
-
-  return { frontmatter, body };
+	const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return { frontmatter: {}, body: content };
+
+	const yamlStr = match[1];
+	const body = match[2];
+
+	// Simple YAML parser for our use case
+	const frontmatter: any = {};
+	let mcpConfig: any = null;
+	let serverName = "";
+	let serverConfig: any = {};
+	let currentArrayKey = "";
+
+	for (const line of yamlStr.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+
+		const indent = line.search(/\S/);
+		const keyMatch = trimmed.match(/^([\w-]+):\s*(.*)$/);
+
+		if (keyMatch) {
+			const [, key, value] = keyMatch;
+
+			if (indent === 0) {
+				// Top-level key
+				if (key === "mcp") {
+					mcpConfig = {};
+					frontmatter.mcp = mcpConfig;
+				} else {
+					frontmatter[key] = value || undefined;
+				}
+				currentArrayKey = "";
+			} else if (mcpConfig !== null && indent === 2) {
+				// Server name under mcp
+				serverName = key;
+				serverConfig = {};
+				mcpConfig[serverName] = serverConfig;
+				currentArrayKey = "";
+			} else if (serverConfig && indent === 4) {
+				// Server config property
+				if (key === "command") {
+					serverConfig.command = value;
+					currentArrayKey = "";
+				} else if (key === "args" || key === "includeTools") {
+					// Parse inline array or set up for multi-line
+					if (value.startsWith("[")) {
+						try {
+							serverConfig[key] = JSON.parse(value);
+						} catch {
+							serverConfig[key] = [];
+						}
+						currentArrayKey = "";
+					} else {
+						serverConfig[key] = [];
+						currentArrayKey = key;
+					}
+				} else {
+					currentArrayKey = "";
+				}
+			}
+		} else if (
+			trimmed.startsWith("- ") &&
+			serverConfig &&
+			currentArrayKey &&
+			serverConfig[currentArrayKey]
+		) {
+			// Array item for args or includeTools
+			const item = trimmed.slice(2).replace(/^["']|["']$/g, "");
+			serverConfig[currentArrayKey].push(item);
+		}
+	}
+
+	return { frontmatter, body };
 }
 
 /**
@@ -145,196 +148,200 @@ function parseYamlFrontmatter(content: string): {
  * Priority: mcp.json > YAML frontmatter (Ampcode pattern)
  */
 function loadMcpConfig(
-  skillDir: string,
-  skillPath: string,
+	skillDir: string,
+	skillPath: string,
 ): Record<string, McpServerConfig> | null {
-  // Try mcp.json first (Ampcode pattern)
-  const mcpJsonPath = join(skillDir, "mcp.json");
-  if (existsSync(mcpJsonPath)) {
-    try {
-      const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
-      return mcpJson;
-    } catch {
-      // Fall through to YAML
-    }
-  }
-
-  // Fall back to YAML frontmatter
-  const content = readFileSync(skillPath, "utf-8");
-  const { frontmatter } = parseYamlFrontmatter(content);
-
-  if (frontmatter.mcp && Object.keys(frontmatter.mcp).length > 0) {
-    return frontmatter.mcp;
-  }
-
-  return null;
+	// Try mcp.json first (Ampcode pattern)
+	const mcpJsonPath = join(skillDir, "mcp.json");
+	if (existsSync(mcpJsonPath)) {
+		try {
+			const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
+			return mcpJson;
+		} catch {
+			// Fall through to YAML
+		}
+	}
+
+	// Fall back to YAML frontmatter
+	const content = readFileSync(skillPath, "utf-8");
+	const { frontmatter } = parseYamlFrontmatter(content);
+
+	if (frontmatter.mcp && Object.keys(frontmatter.mcp).length > 0) {
+		return frontmatter.mcp;
+	}
+
+	return null;
 }
 
 function findSkillPath(skillName: string, projectDir: string): string | null {
-  const locations = [
-    join(projectDir, ".opencode", "skill", skillName, "SKILL.md"),
-    join(homedir(), ".config", "opencode", "skill", skillName, "SKILL.md"),
-  ];
-
-  for (const loc of locations) {
-    if (existsSync(loc)) return loc;
-  }
-  return null;
+	const locations = [
+		join(projectDir, ".opencode", "skill", skillName, "SKILL.md"),
+		join(homedir(), ".config", "opencode", "skill", skillName, "SKILL.md"),
+	];
+
+	for (const loc of locations) {
+		if (existsSync(loc)) return loc;
+	}
+	return null;
 }
 
 export const SkillMcpPlugin: Plugin = async ({ directory }) => {
-  const state: SkillMcpState = {
-    clients: new Map(),
-    loadedSkills: new Map(),
-  };
-
-  function getClientKey(skillName: string, serverName: string): string {
-    return `${skillName}:${serverName}`;
-  }
-
-  async function sendRequest(client: McpClient, method: string, params?: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      const id = ++client.requestId;
-      const request = {
-        jsonrpc: "2.0",
-        id,
-        method,
-        params: params || {},
-      };
-
-      client.pendingRequests.set(id, { resolve, reject });
-
-      const timeout = setTimeout(() => {
-        client.pendingRequests.delete(id);
-        reject(new Error(`Request timeout: ${method}`));
-      }, 30000);
-
-      client.pendingRequests.set(id, {
-        resolve: (v) => {
-          clearTimeout(timeout);
-          resolve(v);
-        },
-        reject: (e) => {
-          clearTimeout(timeout);
-          reject(e);
-        },
-      });
-
-      client.process.stdin?.write(`${JSON.stringify(request)}\n`);
-    });
-  }
-
-  async function connectServer(
-    skillName: string,
-    serverName: string,
-    config: McpServerConfig,
-  ): Promise<McpClient> {
-    const key = getClientKey(skillName, serverName);
-
-    // Return existing client if connected
-    const existing = state.clients.get(key);
-    if (existing && !existing.process.killed) {
-      return existing;
-    }
-
-    // Spawn MCP server process
-    const proc = spawn(config.command, config.args || [], {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, ...config.env },
-      shell: true,
-    });
-
-    const client: McpClient = {
-      process: proc,
-      config,
-      requestId: 0,
-      pendingRequests: new Map(),
-    };
-
-    // Handle stdout (JSON-RPC responses)
-    let buffer = "";
-    proc.stdout?.on("data", (data) => {
-      buffer += data.toString();
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const response = JSON.parse(line);
-          if (response.id !== undefined) {
-            const pending = client.pendingRequests.get(response.id);
-            if (pending) {
-              client.pendingRequests.delete(response.id);
-              if (response.error) {
-                pending.reject(new Error(response.error.message));
-              } else {
-                pending.resolve(response.result);
-              }
-            }
-          }
-        } catch {}
-      }
-    });
-
-    proc.on("error", (err) => {
-      console.error(`MCP server error [${key}]:`, err.message);
-    });
-
-    proc.on("exit", () => {
-      state.clients.delete(key);
-    });
-
-    state.clients.set(key, client);
-
-    // Initialize connection
-    try {
-      await sendRequest(client, "initialize", {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        clientInfo: { name: "opencode-skill-mcp", version: "1.1.0" },
-      });
-
-      // Send initialized notification
-      proc.stdin?.write(
-        `${JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/initialized",
-        })}\n`,
-      );
-
-      // Discover capabilities
-      try {
-        const toolsResult = await sendRequest(client, "tools/list", {});
-        const allTools = toolsResult.tools || [];
-        client.capabilities = { tools: allTools };
-
-        // Apply includeTools filtering (Ampcode pattern)
-        client.filteredTools = filterTools(allTools, config.includeTools);
-      } catch {
-        client.capabilities = { tools: [] };
-        client.filteredTools = [];
-      }
-    } catch (e: any) {
-      proc.kill();
-      state.clients.delete(key);
-      throw new Error(`Failed to initialize MCP server: ${e.message}`);
-    }
-
-    return client;
-  }
-
-  function disconnectAll() {
-    for (const [, client] of state.clients) {
-      client.process.kill();
-    }
-    state.clients.clear();
-  }
-
-  return {
-    tool: {
-      skill_mcp: tool({
-        description: `Invoke MCP tools from skill-embedded MCP servers.
+	const state: SkillMcpState = {
+		clients: new Map(),
+		loadedSkills: new Map(),
+	};
+
+	function getClientKey(skillName: string, serverName: string): string {
+		return `${skillName}:${serverName}`;
+	}
+
+	async function sendRequest(
+		client: McpClient,
+		method: string,
+		params?: any,
+	): Promise<any> {
+		return new Promise((resolve, reject) => {
+			const id = ++client.requestId;
+			const request = {
+				jsonrpc: "2.0",
+				id,
+				method,
+				params: params || {},
+			};
+
+			client.pendingRequests.set(id, { resolve, reject });
+
+			const timeout = setTimeout(() => {
+				client.pendingRequests.delete(id);
+				reject(new Error(`Request timeout: ${method}`));
+			}, 30000);
+
+			client.pendingRequests.set(id, {
+				resolve: (v) => {
+					clearTimeout(timeout);
+					resolve(v);
+				},
+				reject: (e) => {
+					clearTimeout(timeout);
+					reject(e);
+				},
+			});
+
+			client.process.stdin?.write(`${JSON.stringify(request)}\n`);
+		});
+	}
+
+	async function connectServer(
+		skillName: string,
+		serverName: string,
+		config: McpServerConfig,
+	): Promise<McpClient> {
+		const key = getClientKey(skillName, serverName);
+
+		// Return existing client if connected
+		const existing = state.clients.get(key);
+		if (existing && !existing.process.killed) {
+			return existing;
+		}
+
+		// Spawn MCP server process
+		const proc = spawn(config.command, config.args || [], {
+			stdio: ["pipe", "pipe", "pipe"],
+			env: { ...process.env, ...config.env },
+			shell: true,
+		});
+
+		const client: McpClient = {
+			process: proc,
+			config,
+			requestId: 0,
+			pendingRequests: new Map(),
+		};
+
+		// Handle stdout (JSON-RPC responses)
+		let buffer = "";
+		proc.stdout?.on("data", (data) => {
+			buffer += data.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const response = JSON.parse(line);
+					if (response.id !== undefined) {
+						const pending = client.pendingRequests.get(response.id);
+						if (pending) {
+							client.pendingRequests.delete(response.id);
+							if (response.error) {
+								pending.reject(new Error(response.error.message));
+							} else {
+								pending.resolve(response.result);
+							}
+						}
+					}
+				} catch {}
+			}
+		});
+
+		proc.on("error", (err) => {
+			console.error(`MCP server error [${key}]:`, err.message);
+		});
+
+		proc.on("exit", () => {
+			state.clients.delete(key);
+		});
+
+		state.clients.set(key, client);
+
+		// Initialize connection
+		try {
+			await sendRequest(client, "initialize", {
+				protocolVersion: "2024-11-05",
+				capabilities: {},
+				clientInfo: { name: "opencode-skill-mcp", version: "1.1.0" },
+			});
+
+			// Send initialized notification
+			proc.stdin?.write(
+				`${JSON.stringify({
+					jsonrpc: "2.0",
+					method: "notifications/initialized",
+				})}\n`,
+			);
+
+			// Discover capabilities
+			try {
+				const toolsResult = await sendRequest(client, "tools/list", {});
+				const allTools = toolsResult.tools || [];
+				client.capabilities = { tools: allTools };
+
+				// Apply includeTools filtering (Ampcode pattern)
+				client.filteredTools = filterTools(allTools, config.includeTools);
+			} catch {
+				client.capabilities = { tools: [] };
+				client.filteredTools = [];
+			}
+		} catch (e: any) {
+			proc.kill();
+			state.clients.delete(key);
+			throw new Error(`Failed to initialize MCP server: ${e.message}`);
+		}
+
+		return client;
+	}
+
+	function disconnectAll() {
+		for (const [, client] of state.clients) {
+			client.process.kill();
+		}
+		state.clients.clear();
+	}
+
+	return {
+		tool: {
+			skill_mcp: tool({
+				description: `Invoke MCP tools from skill-embedded MCP servers.
 
 When a skill declares MCP servers (via mcp.json or YAML frontmatter), use this tool to:
 - List available tools: skill_mcp(skill_name="playwright", list_tools=true)
@@ -342,201 +349,222 @@ When a skill declares MCP servers (via mcp.json or YAML frontmatter), use this t
 
 Skills can use "includeTools" to filter which MCP tools are exposed (reduces token usage).
 The skill must be loaded first via the skill() tool to register its MCP config.`,
-        args: {
-          skill_name: tool.schema.string().describe("Name of the loaded skill with MCP config"),
-          mcp_name: tool.schema
-            .string()
-            .optional()
-            .describe("Specific MCP server name (if skill has multiple)"),
-          list_tools: tool.schema
-            .boolean()
-            .optional()
-            .describe("List available tools from this MCP"),
-          tool_name: tool.schema.string().optional().describe("MCP tool to invoke"),
-          arguments: tool.schema.string().optional().describe("JSON string of tool arguments"),
-        },
-        async execute(args) {
-          const { skill_name, mcp_name, list_tools, tool_name, arguments: argsJson } = args;
-
-          if (!skill_name) {
-            return JSON.stringify({ error: "skill_name required" });
-          }
-
-          // Find skill path
-          const skillPath = findSkillPath(skill_name, directory);
-          if (!skillPath) {
-            return JSON.stringify({ error: `Skill '${skill_name}' not found` });
-          }
-
-          // Load MCP config from mcp.json or YAML frontmatter
-          const skillDir = dirname(skillPath);
-          const mcpConfig = loadMcpConfig(skillDir, skillPath);
-
-          if (!mcpConfig) {
-            return JSON.stringify({
-              error: `Skill '${skill_name}' has no MCP config (check mcp.json or YAML frontmatter)`,
-            });
-          }
-
-          // Determine which MCP server to use
-          const serverNames = Object.keys(mcpConfig);
-          const targetServer = mcp_name || serverNames[0];
-
-          if (!mcpConfig[targetServer]) {
-            return JSON.stringify({
-              error: `MCP server '${targetServer}' not found in skill`,
-              available: serverNames,
-            });
-          }
-
-          const serverConfig = mcpConfig[targetServer];
-
-          // Connect to MCP server
-          let client: McpClient;
-          try {
-            client = await connectServer(skill_name, targetServer, serverConfig);
-          } catch (e: any) {
-            return JSON.stringify({ error: `Failed to connect: ${e.message}` });
-          }
-
-          // List tools (filtered by includeTools if configured)
-          if (list_tools) {
-            const totalTools = client.capabilities?.tools?.length || 0;
-            const filteredTools = client.filteredTools || [];
-            const isFiltered = serverConfig.includeTools && serverConfig.includeTools.length > 0;
-
-            return JSON.stringify(
-              {
-                mcp: targetServer,
-                tools: filteredTools.map((t: any) => ({
-                  name: t.name,
-                  description: t.description,
-                  schema: t.inputSchema,
-                })),
-                ...(isFiltered && {
-                  filtering: {
-                    patterns: serverConfig.includeTools,
-                    showing: filteredTools.length,
-                    total: totalTools,
-                    tokenSavings: `~${Math.round((1 - filteredTools.length / totalTools) * 100)}%`,
-                  },
-                }),
-              },
-              null,
-              2,
-            );
-          }
-
-          // Call tool
-          if (tool_name) {
-            // Validate tool is in filtered list (if filtering is enabled)
-            if (serverConfig.includeTools && serverConfig.includeTools.length > 0) {
-              const isAllowed = client.filteredTools?.some((t: any) => t.name === tool_name);
-              if (!isAllowed) {
-                return JSON.stringify({
-                  error: `Tool '${tool_name}' is not in includeTools filter`,
-                  allowed: client.filteredTools?.map((t: any) => t.name) || [],
-                  hint: "Add this tool to includeTools in mcp.json or YAML frontmatter",
-                });
-              }
-            }
-
-            let toolArgs = {};
-            if (argsJson) {
-              try {
-                toolArgs = JSON.parse(argsJson);
-              } catch {
-                return JSON.stringify({ error: "Invalid JSON in arguments" });
-              }
-            }
-
-            try {
-              const result = await sendRequest(client, "tools/call", {
-                name: tool_name,
-                arguments: toolArgs,
-              });
-              return JSON.stringify({ result }, null, 2);
-            } catch (e: any) {
-              return JSON.stringify({
-                error: `Tool call failed: ${e.message}`,
-              });
-            }
-          }
-
-          return JSON.stringify({
-            error: "Specify either list_tools=true or tool_name to call",
-            mcp: targetServer,
-            available_tools: client.filteredTools?.map((t: any) => t.name) || [],
-          });
-        },
-      }),
-
-      skill_mcp_status: tool({
-        description: "Show status of connected MCP servers from skills.",
-        args: {},
-        async execute() {
-          const servers: any[] = [];
-          for (const [key, client] of state.clients) {
-            const [skillName, serverName] = key.split(":");
-            const totalTools = client.capabilities?.tools?.length || 0;
-            const filteredTools = client.filteredTools?.length || 0;
-            const isFiltered = client.config.includeTools && client.config.includeTools.length > 0;
-
-            servers.push({
-              skill: skillName,
-              server: serverName,
-              connected: !client.process.killed,
-              tools: filteredTools,
-              ...(isFiltered && {
-                filtering: {
-                  total: totalTools,
-                  filtered: filteredTools,
-                },
-              }),
-            });
-          }
-          return JSON.stringify({
-            connected_servers: servers,
-            count: servers.length,
-          });
-        },
-      }),
-
-      skill_mcp_disconnect: tool({
-        description: "Disconnect MCP servers. Use when done with browser automation etc.",
-        args: {
-          skill_name: tool.schema
-            .string()
-            .optional()
-            .describe("Specific skill to disconnect (all if omitted)"),
-        },
-        async execute(args) {
-          if (args.skill_name) {
-            const toDisconnect: string[] = [];
-            for (const key of state.clients.keys()) {
-              if (key.startsWith(`${args.skill_name}:`)) {
-                toDisconnect.push(key);
-              }
-            }
-            for (const key of toDisconnect) {
-              const client = state.clients.get(key);
-              client?.process.kill();
-              state.clients.delete(key);
-            }
-            return JSON.stringify({ disconnected: toDisconnect });
-          }
-          const count = state.clients.size;
-          disconnectAll();
-          return JSON.stringify({ disconnected: "all", count });
-        },
-      }),
-    },
-
-    event: async ({ event }) => {
-      // Cleanup on session idle (closest available event)
-      if (event.type === "session.idle") {
-        // Optional: could disconnect idle servers here
-      }
-    },
-  };
+				args: {
+					skill_name: tool.schema
+						.string()
+						.describe("Name of the loaded skill with MCP config"),
+					mcp_name: tool.schema
+						.string()
+						.optional()
+						.describe("Specific MCP server name (if skill has multiple)"),
+					list_tools: tool.schema
+						.boolean()
+						.optional()
+						.describe("List available tools from this MCP"),
+					tool_name: tool.schema
+						.string()
+						.optional()
+						.describe("MCP tool to invoke"),
+					arguments: tool.schema
+						.string()
+						.optional()
+						.describe("JSON string of tool arguments"),
+				},
+				async execute(args) {
+					const {
+						skill_name,
+						mcp_name,
+						list_tools,
+						tool_name,
+						arguments: argsJson,
+					} = args;
+
+					if (!skill_name) {
+						return JSON.stringify({ error: "skill_name required" });
+					}
+
+					// Find skill path
+					const skillPath = findSkillPath(skill_name, directory);
+					if (!skillPath) {
+						return JSON.stringify({ error: `Skill '${skill_name}' not found` });
+					}
+
+					// Load MCP config from mcp.json or YAML frontmatter
+					const skillDir = dirname(skillPath);
+					const mcpConfig = loadMcpConfig(skillDir, skillPath);
+
+					if (!mcpConfig) {
+						return JSON.stringify({
+							error: `Skill '${skill_name}' has no MCP config (check mcp.json or YAML frontmatter)`,
+						});
+					}
+
+					// Determine which MCP server to use
+					const serverNames = Object.keys(mcpConfig);
+					const targetServer = mcp_name || serverNames[0];
+
+					if (!mcpConfig[targetServer]) {
+						return JSON.stringify({
+							error: `MCP server '${targetServer}' not found in skill`,
+							available: serverNames,
+						});
+					}
+
+					const serverConfig = mcpConfig[targetServer];
+
+					// Connect to MCP server
+					let client: McpClient;
+					try {
+						client = await connectServer(
+							skill_name,
+							targetServer,
+							serverConfig,
+						);
+					} catch (e: any) {
+						return JSON.stringify({ error: `Failed to connect: ${e.message}` });
+					}
+
+					// List tools (filtered by includeTools if configured)
+					if (list_tools) {
+						const totalTools = client.capabilities?.tools?.length || 0;
+						const filteredTools = client.filteredTools || [];
+						const isFiltered =
+							serverConfig.includeTools && serverConfig.includeTools.length > 0;
+
+						return JSON.stringify(
+							{
+								mcp: targetServer,
+								tools: filteredTools.map((t: any) => ({
+									name: t.name,
+									description: t.description,
+									schema: t.inputSchema,
+								})),
+								...(isFiltered && {
+									filtering: {
+										patterns: serverConfig.includeTools,
+										showing: filteredTools.length,
+										total: totalTools,
+										tokenSavings: `~${Math.round((1 - filteredTools.length / totalTools) * 100)}%`,
+									},
+								}),
+							},
+							null,
+							2,
+						);
+					}
+
+					// Call tool
+					if (tool_name) {
+						// Validate tool is in filtered list (if filtering is enabled)
+						if (
+							serverConfig.includeTools &&
+							serverConfig.includeTools.length > 0
+						) {
+							const isAllowed = client.filteredTools?.some(
+								(t: any) => t.name === tool_name,
+							);
+							if (!isAllowed) {
+								return JSON.stringify({
+									error: `Tool '${tool_name}' is not in includeTools filter`,
+									allowed: client.filteredTools?.map((t: any) => t.name) || [],
+									hint: "Add this tool to includeTools in mcp.json or YAML frontmatter",
+								});
+							}
+						}
+
+						let toolArgs = {};
+						if (argsJson) {
+							try {
+								toolArgs = JSON.parse(argsJson);
+							} catch {
+								return JSON.stringify({ error: "Invalid JSON in arguments" });
+							}
+						}
+
+						try {
+							const result = await sendRequest(client, "tools/call", {
+								name: tool_name,
+								arguments: toolArgs,
+							});
+							return JSON.stringify({ result }, null, 2);
+						} catch (e: any) {
+							return JSON.stringify({
+								error: `Tool call failed: ${e.message}`,
+							});
+						}
+					}
+
+					return JSON.stringify({
+						error: "Specify either list_tools=true or tool_name to call",
+						mcp: targetServer,
+						available_tools:
+							client.filteredTools?.map((t: any) => t.name) || [],
+					});
+				},
+			}),
+
+			skill_mcp_status: tool({
+				description: "Show status of connected MCP servers from skills.",
+				args: {},
+				async execute() {
+					const servers: any[] = [];
+					for (const [key, client] of state.clients) {
+						const [skillName, serverName] = key.split(":");
+						const totalTools = client.capabilities?.tools?.length || 0;
+						const filteredTools = client.filteredTools?.length || 0;
+						const isFiltered =
+							client.config.includeTools &&
+							client.config.includeTools.length > 0;
+
+						servers.push({
+							skill: skillName,
+							server: serverName,
+							connected: !client.process.killed,
+							tools: filteredTools,
+							...(isFiltered && {
+								filtering: {
+									total: totalTools,
+									filtered: filteredTools,
+								},
+							}),
+						});
+					}
+					return JSON.stringify({
+						connected_servers: servers,
+						count: servers.length,
+					});
+				},
+			}),
+
+			skill_mcp_disconnect: tool({
+				description:
+					"Disconnect MCP servers. Use when done with browser automation etc.",
+				args: {
+					skill_name: tool.schema
+						.string()
+						.optional()
+						.describe("Specific skill to disconnect (all if omitted)"),
+				},
+				async execute(args) {
+					if (args.skill_name) {
+						const toDisconnect: string[] = [];
+						for (const key of state.clients.keys()) {
+							if (key.startsWith(`${args.skill_name}:`)) {
+								toDisconnect.push(key);
+							}
+						}
+						for (const key of toDisconnect) {
+							const client = state.clients.get(key);
+							client?.process.kill();
+							state.clients.delete(key);
+						}
+						return JSON.stringify({ disconnected: toDisconnect });
+					}
+					const count = state.clients.size;
+					disconnectAll();
+					return JSON.stringify({ disconnected: "all", count });
+				},
+			}),
+		},
+	};
 };