opencode-mcp-marketplace 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+// Cross-platform paths
+const HOME = os.homedir();
+const CONFIG_DIR = path.join(HOME, ".config", "opencode");
+const MCPS_DIR = path.join(CONFIG_DIR, "mcps");
+const OPENCODE_CONFIG = path.join(CONFIG_DIR, "opencode.json");
+const MARKETPLACE_STATE = path.join(CONFIG_DIR, "marketplace-state.json");
+// GitHub config
+const GITHUB_USER = "schwarztim";
+const GITHUB_API = "https://api.github.com";
+// Safe command execution helper
+function runCommand(command, args, cwd) {
+    try {
+        const output = execFileSync(command, args, {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return { success: true, output };
+    }
+    catch (error) {
+        const err = error;
+        return { success: false, output: err.stderr || err.message || "Unknown error" };
+    }
+}
+// Ensure directories exist
+function ensureDirectories() {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(MCPS_DIR)) {
+        fs.mkdirSync(MCPS_DIR, { recursive: true });
+    }
+}
+// Load marketplace state
+function loadState() {
+    if (fs.existsSync(MARKETPLACE_STATE)) {
+        return JSON.parse(fs.readFileSync(MARKETPLACE_STATE, "utf-8"));
+    }
+    return { installed: {} };
+}
+// Save marketplace state
+function saveState(state) {
+    fs.writeFileSync(MARKETPLACE_STATE, JSON.stringify(state, null, 2));
+}
+// Load opencode config
+function loadOpencodeConfig() {
+    if (fs.existsSync(OPENCODE_CONFIG)) {
+        return JSON.parse(fs.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    }
+    return {};
+}
+// Save opencode config
+function saveOpencodeConfig(config) {
+    fs.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2));
+}
+// Validate MCP name (alphanumeric, hyphens, underscores only)
+function isValidMcpName(name) {
+    return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+// Fetch repos from GitHub
+async function fetchGitHubRepos() {
+    const repos = [];
+    let page = 1;
+    const perPage = 100;
+    while (true) {
+        const response = await fetch(`${GITHUB_API}/users/${GITHUB_USER}/repos?per_page=${perPage}&page=${page}&sort=updated`);
+        if (!response.ok) {
+            throw new Error(`GitHub API error: ${response.status}`);
+        }
+        const data = (await response.json());
+        if (data.length === 0)
+            break;
+        for (const repo of data) {
+            // Filter for MCP repos
+            if (repo.name.toLowerCase().includes("mcp") ||
+                repo.name.toLowerCase().endsWith("-mcp")) {
+                repos.push({
+                    name: repo.name,
+                    description: repo.description || "No description",
+                    url: repo.html_url,
+                    stars: repo.stargazers_count,
+                    updated: repo.updated_at,
+                });
+            }
+        }
+        if (data.length < perPage)
+            break;
+        page++;
+    }
+    return repos;
+}
+// Detect package manager
+function detectPackageManager(mcpPath) {
+    if (fs.existsSync(path.join(mcpPath, "bun.lockb")))
+        return "bun";
+    if (fs.existsSync(path.join(mcpPath, "pnpm-lock.yaml")))
+        return "pnpm";
+    return "npm";
+}
+// Parse .env.example or README for env vars
+function parseEnvVars(mcpPath) {
+    const envVars = [];
+    // Try .env.example first
+    const envExamplePath = path.join(mcpPath, ".env.example");
+    if (fs.existsSync(envExamplePath)) {
+        const content = fs.readFileSync(envExamplePath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith("#")) {
+                const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=/);
+                if (match) {
+                    // Look for comment on previous line
+                    const idx = lines.indexOf(line);
+                    let desc = "";
+                    if (idx > 0 && lines[idx - 1].trim().startsWith("#")) {
+                        desc = lines[idx - 1].trim().replace(/^#\s*/, "");
+                    }
+                    envVars.push({ name: match[1], description: desc || match[1] });
+                }
+            }
+        }
+    }
+    // Fallback to README parsing
+    if (envVars.length === 0) {
+        const readmePath = path.join(mcpPath, "README.md");
+        if (fs.existsSync(readmePath)) {
+            const content = fs.readFileSync(readmePath, "utf-8");
+            // Look for env var patterns
+            const matches = content.matchAll(/`([A-Z_][A-Z0-9_]*)`/g);
+            const seen = new Set();
+            for (const match of matches) {
+                if (!seen.has(match[1])) {
+                    seen.add(match[1]);
+                    envVars.push({ name: match[1], description: `From README: ${match[1]}` });
+                }
+            }
+        }
+    }
+    return envVars;
+}
+// Get entry point from package.json
+function getEntryPoint(mcpPath) {
+    const pkgPath = path.join(mcpPath, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.main)
+            return pkg.main;
+        if (pkg.bin) {
+            if (typeof pkg.bin === "string")
+                return pkg.bin;
+            return Object.values(pkg.bin)[0];
+        }
+    }
+    // Default to common patterns
+    if (fs.existsSync(path.join(mcpPath, "dist", "index.js"))) {
+        return "dist/index.js";
+    }
+    return "index.js";
+}
+// Tools definition
+const tools = [
+    {
+        name: "list_available",
+        description: "List all available MCPs from GitHub that can be installed. Shows name, description, and install status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refresh: {
+                    type: "boolean",
+                    description: "Force refresh from GitHub (default: false, uses cache if recent)",
+                },
+            },
+        },
+    },
+    {
+        name: "list_installed",
+        description: "List all locally installed MCPs with their status and paths.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "install",
+        description: "Install an MCP from GitHub. Clones the repo, builds it, and configures it for Opencode.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the MCP to install (e.g., 'elastic-mcp', 'crowdstrike-mcp')",
+                },
+                env_vars: {
+                    type: "object",
+                    description: "Environment variables to configure (key-value pairs). If not provided, will list required vars.",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "update",
+        description: "Update an installed MCP to the latest version from GitHub.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the MCP to update",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "update_all",
+        description: "Update all installed MCPs to their latest versions.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "uninstall",
+        description: "Uninstall an MCP - removes the files and Opencode configuration.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the MCP to uninstall",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "configure",
+        description: "Reconfigure environment variables for an installed MCP.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the MCP to configure",
+                },
+                env_vars: {
+                    type: "object",
+                    description: "Environment variables to set (key-value pairs)",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            required: ["name", "env_vars"],
+        },
+    },
+    {
+        name: "get_required_env",
+        description: "Get the required environment variables for an MCP (installed or available).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the MCP",
+                },
+            },
+            required: ["name"],
+        },
+    },
+];
+// Tool handlers
+async function handleListAvailable(args) {
+    ensureDirectories();
+    const state = loadState();
+    const repos = await fetchGitHubRepos();
+    const result = repos.map((repo) => ({
+        ...repo,
+        installed: !!state.installed[repo.name],
+        localPath: state.installed[repo.name]?.path,
+    }));
+    const installed = result.filter((r) => r.installed);
+    const available = result.filter((r) => !r.installed);
+    let output = `## Available MCPs (${available.length})\n\n`;
+    for (const mcp of available) {
+        output += `- **${mcp.name}** - ${mcp.description}\n`;
+        output += `  Stars: ${mcp.stars} | Updated: ${new Date(mcp.updated).toLocaleDateString()}\n\n`;
+    }
+    output += `\n## Already Installed (${installed.length})\n\n`;
+    for (const mcp of installed) {
+        output += `- **${mcp.name}** (${mcp.localPath})\n`;
+    }
+    return output;
+}
+async function handleListInstalled() {
+    ensureDirectories();
+    const state = loadState();
+    if (Object.keys(state.installed).length === 0) {
+        return "No MCPs installed yet. Use `install` to add some!";
+    }
+    let output = "## Installed MCPs\n\n";
+    for (const [name, info] of Object.entries(state.installed)) {
+        output += `### ${name}\n`;
+        output += `- Path: ${info.path}\n`;
+        output += `- Installed: ${new Date(info.installedAt).toLocaleDateString()}\n`;
+        if (info.envVars.length > 0) {
+            output += `- Configured env vars: ${info.envVars.join(", ")}\n`;
+        }
+        output += "\n";
+    }
+    return output;
+}
+async function handleInstall(args) {
+    ensureDirectories();
+    const state = loadState();
+    const { name, env_vars } = args;
+    // Validate name
+    if (!isValidMcpName(name)) {
+        return `Invalid MCP name: ${name}. Names can only contain letters, numbers, hyphens, and underscores.`;
+    }
+    // Check if already installed
+    if (state.installed[name]) {
+        return `${name} is already installed at ${state.installed[name].path}. Use \`update\` to get the latest version.`;
+    }
+    const mcpPath = path.join(MCPS_DIR, name);
+    const repoUrl = `https://github.com/${GITHUB_USER}/${name}.git`;
+    // Step 1: Clone
+    if (fs.existsSync(mcpPath)) {
+        fs.rmSync(mcpPath, { recursive: true });
+    }
+    const cloneResult = runCommand("git", ["clone", repoUrl, mcpPath]);
+    if (!cloneResult.success) {
+        return `Failed to clone ${name}. Make sure the repo exists at ${repoUrl}\nError: ${cloneResult.output}`;
+    }
+    // Step 2: Check required env vars
+    const requiredEnvVars = parseEnvVars(mcpPath);
+    if (requiredEnvVars.length > 0 && !env_vars) {
+        let output = `## ${name} requires configuration\n\n`;
+        output += `The following environment variables are needed:\n\n`;
+        for (const v of requiredEnvVars) {
+            output += `- **${v.name}**: ${v.description}\n`;
+        }
+        output += `\nPlease call \`install\` again with the \`env_vars\` parameter containing these values.`;
+        return output;
+    }
+    // Step 3: Write .env file if env_vars provided
+    if (env_vars && Object.keys(env_vars).length > 0) {
+        const envContent = Object.entries(env_vars)
+            .map(([k, v]) => `${k}=${v}`)
+            .join("\n");
+        fs.writeFileSync(path.join(mcpPath, ".env"), envContent);
+    }
+    // Step 4: Install dependencies and build
+    const pm = detectPackageManager(mcpPath);
+    const installResult = runCommand(pm, ["install"], mcpPath);
+    if (!installResult.success) {
+        return `Failed to install dependencies for ${name}. Error: ${installResult.output}`;
+    }
+    // Check if build script exists
+    const pkgPath = path.join(mcpPath, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.scripts?.build) {
+            const buildResult = runCommand(pm, ["run", "build"], mcpPath);
+            if (!buildResult.success) {
+                return `Failed to build ${name}. Error: ${buildResult.output}`;
+            }
+        }
+    }
+    // Step 5: Add to Opencode config
+    const config = loadOpencodeConfig();
+    if (!config.mcp) {
+        config.mcp = {};
+    }
+    const entryPoint = getEntryPoint(mcpPath);
+    const fullEntryPath = path.join(mcpPath, entryPoint);
+    config.mcp[name] = {
+        command: "node",
+        args: [fullEntryPath],
+        env: env_vars || {},
+    };
+    saveOpencodeConfig(config);
+    // Step 6: Update marketplace state
+    state.installed[name] = {
+        name,
+        path: mcpPath,
+        installedAt: new Date().toISOString(),
+        envVars: env_vars ? Object.keys(env_vars) : [],
+    };
+    saveState(state);
+    return `## Successfully installed ${name}!\n\n- Location: ${mcpPath}\n- Added to Opencode config\n\nRestart Opencode to use the new MCP.`;
+}
+async function handleUpdate(args) {
+    ensureDirectories();
+    const state = loadState();
+    const { name } = args;
+    if (!isValidMcpName(name)) {
+        return `Invalid MCP name: ${name}`;
+    }
+    if (!state.installed[name]) {
+        return `${name} is not installed. Use \`list_installed\` to see installed MCPs.`;
+    }
+    const mcpPath = state.installed[name].path;
+    // Pull latest
+    const pullResult = runCommand("git", ["pull"], mcpPath);
+    if (!pullResult.success) {
+        return `Failed to pull updates for ${name}: ${pullResult.output}`;
+    }
+    // Rebuild
+    const pm = detectPackageManager(mcpPath);
+    const installResult = runCommand(pm, ["install"], mcpPath);
+    if (!installResult.success) {
+        return `Failed to install dependencies for ${name}: ${installResult.output}`;
+    }
+    const pkgPath = path.join(mcpPath, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.scripts?.build) {
+            const buildResult = runCommand(pm, ["run", "build"], mcpPath);
+            if (!buildResult.success) {
+                return `Failed to build ${name}: ${buildResult.output}`;
+            }
+        }
+    }
+    return `## Successfully updated ${name}!\n\nRestart Opencode to use the updated MCP.`;
+}
+async function handleUpdateAll() {
+    ensureDirectories();
+    const state = loadState();
+    if (Object.keys(state.installed).length === 0) {
+        return "No MCPs installed to update.";
+    }
+    const results = [];
+    for (const name of Object.keys(state.installed)) {
+        const result = await handleUpdate({ name });
+        results.push(`### ${name}\n${result}`);
+    }
+    return `## Update Results\n\n${results.join("\n\n")}`;
+}
+async function handleUninstall(args) {
+    ensureDirectories();
+    const state = loadState();
+    const { name } = args;
+    if (!isValidMcpName(name)) {
+        return `Invalid MCP name: ${name}`;
+    }
+    if (!state.installed[name]) {
+        return `${name} is not installed.`;
+    }
+    const mcpPath = state.installed[name].path;
+    // Remove from Opencode config
+    const config = loadOpencodeConfig();
+    if (config.mcp && config.mcp[name]) {
+        delete config.mcp[name];
+        saveOpencodeConfig(config);
+    }
+    // Remove files
+    if (fs.existsSync(mcpPath)) {
+        fs.rmSync(mcpPath, { recursive: true });
+    }
+    // Update state
+    delete state.installed[name];
+    saveState(state);
+    return `## Uninstalled ${name}\n\n- Removed from Opencode config\n- Deleted files at ${mcpPath}`;
+}
+async function handleConfigure(args) {
+    ensureDirectories();
+    const state = loadState();
+    const { name, env_vars } = args;
+    if (!isValidMcpName(name)) {
+        return `Invalid MCP name: ${name}`;
+    }
+    if (!state.installed[name]) {
+        return `${name} is not installed. Install it first.`;
+    }
+    const mcpPath = state.installed[name].path;
+    // Update .env file
+    const envContent = Object.entries(env_vars)
+        .map(([k, v]) => `${k}=${v}`)
+        .join("\n");
+    fs.writeFileSync(path.join(mcpPath, ".env"), envContent);
+    // Update Opencode config
+    const config = loadOpencodeConfig();
+    if (config.mcp && config.mcp[name]) {
+        config.mcp[name].env = env_vars;
+        saveOpencodeConfig(config);
+    }
+    // Update state
+    state.installed[name].envVars = Object.keys(env_vars);
+    saveState(state);
+    return `## Updated configuration for ${name}\n\nRestart Opencode to apply changes.`;
+}
+async function handleGetRequiredEnv(args) {
+    ensureDirectories();
+    const state = loadState();
+    const { name } = args;
+    if (!isValidMcpName(name)) {
+        return `Invalid MCP name: ${name}`;
+    }
+    let mcpPath;
+    if (state.installed[name]) {
+        mcpPath = state.installed[name].path;
+    }
+    else {
+        // Need to fetch from GitHub temporarily
+        const tempPath = path.join(os.tmpdir(), `mcp-check-${name}`);
+        const repoUrl = `https://github.com/${GITHUB_USER}/${name}.git`;
+        if (fs.existsSync(tempPath)) {
+            fs.rmSync(tempPath, { recursive: true });
+        }
+        const cloneResult = runCommand("git", ["clone", "--depth", "1", repoUrl, tempPath]);
+        if (!cloneResult.success) {
+            return `Could not find ${name} on GitHub.`;
+        }
+        mcpPath = tempPath;
+    }
+    const envVars = parseEnvVars(mcpPath);
+    if (envVars.length === 0) {
+        return `No environment variables detected for ${name}.`;
+    }
+    let output = `## Required Environment Variables for ${name}\n\n`;
+    for (const v of envVars) {
+        output += `- **${v.name}**: ${v.description}\n`;
+    }
+    return output;
+}
+// Main server setup
+const server = new Server({
+    name: "mcp-marketplace",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case "list_available":
+                result = await handleListAvailable(args);
+                break;
+            case "list_installed":
+                result = await handleListInstalled();
+                break;
+            case "install":
+                result = await handleInstall(args);
+                break;
+            case "update":
+                result = await handleUpdate(args);
+                break;
+            case "update_all":
+                result = await handleUpdateAll();
+                break;
+            case "uninstall":
+                result = await handleUninstall(args);
+                break;
+            case "configure":
+                result = await handleConfigure(args);
+                break;
+            case "get_required_env":
+                result = await handleGetRequiredEnv(args);
+                break;
+            default:
+                result = `Unknown tool: ${name}`;
+        }
+        return {
+            content: [{ type: "text", text: result }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Marketplace server running");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "opencode-mcp-marketplace",
+  "version": "1.0.0",
+  "description": "MCP server for discovering, installing, and managing other MCPs for Opencode",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "opencode-mcp-marketplace": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "opencode",
+    "marketplace",
+    "model-context-protocol"
+  ],
+  "author": "schwarztim",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/schwarztim/mcp-marketplace.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,748 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// Cross-platform paths
+const HOME = os.homedir();
+const CONFIG_DIR = path.join(HOME, ".config", "opencode");
+const MCPS_DIR = path.join(CONFIG_DIR, "mcps");
+const OPENCODE_CONFIG = path.join(CONFIG_DIR, "opencode.json");
+const MARKETPLACE_STATE = path.join(CONFIG_DIR, "marketplace-state.json");
+
+// GitHub config
+const GITHUB_USER = "schwarztim";
+const GITHUB_API = "https://api.github.com";
+
+interface McpInfo {
+  name: string;
+  description: string;
+  url: string;
+  stars: number;
+  updated: string;
+  installed?: boolean;
+  localPath?: string;
+}
+
+interface InstalledMcp {
+  name: string;
+  path: string;
+  installedAt: string;
+  version?: string;
+  envVars: string[];
+}
+
+interface MarketplaceState {
+  installed: Record<string, InstalledMcp>;
+}
+
+// Safe command execution helper
+function runCommand(command: string, args: string[], cwd?: string): { success: boolean; output: string } {
+  try {
+    const output = execFileSync(command, args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { success: true, output };
+  } catch (error: unknown) {
+    const err = error as { stderr?: string; message?: string };
+    return { success: false, output: err.stderr || err.message || "Unknown error" };
+  }
+}
+
+// Ensure directories exist
+function ensureDirectories() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(MCPS_DIR)) {
+    fs.mkdirSync(MCPS_DIR, { recursive: true });
+  }
+}
+
+// Load marketplace state
+function loadState(): MarketplaceState {
+  if (fs.existsSync(MARKETPLACE_STATE)) {
+    return JSON.parse(fs.readFileSync(MARKETPLACE_STATE, "utf-8"));
+  }
+  return { installed: {} };
+}
+
+// Save marketplace state
+function saveState(state: MarketplaceState) {
+  fs.writeFileSync(MARKETPLACE_STATE, JSON.stringify(state, null, 2));
+}
+
+// Load opencode config
+function loadOpencodeConfig(): Record<string, unknown> {
+  if (fs.existsSync(OPENCODE_CONFIG)) {
+    return JSON.parse(fs.readFileSync(OPENCODE_CONFIG, "utf-8"));
+  }
+  return {};
+}
+
+// Save opencode config
+function saveOpencodeConfig(config: Record<string, unknown>) {
+  fs.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2));
+}
+
+// Validate MCP name (alphanumeric, hyphens, underscores only)
+function isValidMcpName(name: string): boolean {
+  return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+
+// Fetch repos from GitHub
+async function fetchGitHubRepos(): Promise<McpInfo[]> {
+  const repos: McpInfo[] = [];
+  let page = 1;
+  const perPage = 100;
+
+  while (true) {
+    const response = await fetch(
+      `${GITHUB_API}/users/${GITHUB_USER}/repos?per_page=${perPage}&page=${page}&sort=updated`
+    );
+
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+
+    const data = (await response.json()) as Array<{
+      name: string;
+      description: string | null;
+      html_url: string;
+      stargazers_count: number;
+      updated_at: string;
+    }>;
+
+    if (data.length === 0) break;
+
+    for (const repo of data) {
+      // Filter for MCP repos
+      if (
+        repo.name.toLowerCase().includes("mcp") ||
+        repo.name.toLowerCase().endsWith("-mcp")
+      ) {
+        repos.push({
+          name: repo.name,
+          description: repo.description || "No description",
+          url: repo.html_url,
+          stars: repo.stargazers_count,
+          updated: repo.updated_at,
+        });
+      }
+    }
+
+    if (data.length < perPage) break;
+    page++;
+  }
+
+  return repos;
+}
+
+// Detect package manager
+function detectPackageManager(mcpPath: string): string {
+  if (fs.existsSync(path.join(mcpPath, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path.join(mcpPath, "pnpm-lock.yaml"))) return "pnpm";
+  return "npm";
+}
+
+// Parse .env.example or README for env vars
+function parseEnvVars(mcpPath: string): { name: string; description: string }[] {
+  const envVars: { name: string; description: string }[] = [];
+
+  // Try .env.example first
+  const envExamplePath = path.join(mcpPath, ".env.example");
+  if (fs.existsSync(envExamplePath)) {
+    const content = fs.readFileSync(envExamplePath, "utf-8");
+    const lines = content.split("\n");
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=/);
+        if (match) {
+          // Look for comment on previous line
+          const idx = lines.indexOf(line);
+          let desc = "";
+          if (idx > 0 && lines[idx - 1].trim().startsWith("#")) {
+            desc = lines[idx - 1].trim().replace(/^#\s*/, "");
+          }
+          envVars.push({ name: match[1], description: desc || match[1] });
+        }
+      }
+    }
+  }
+
+  // Fallback to README parsing
+  if (envVars.length === 0) {
+    const readmePath = path.join(mcpPath, "README.md");
+    if (fs.existsSync(readmePath)) {
+      const content = fs.readFileSync(readmePath, "utf-8");
+      // Look for env var patterns
+      const matches = content.matchAll(/`([A-Z_][A-Z0-9_]*)`/g);
+      const seen = new Set<string>();
+      for (const match of matches) {
+        if (!seen.has(match[1])) {
+          seen.add(match[1]);
+          envVars.push({ name: match[1], description: `From README: ${match[1]}` });
+        }
+      }
+    }
+  }
+
+  return envVars;
+}
+
+// Get entry point from package.json
+function getEntryPoint(mcpPath: string): string {
+  const pkgPath = path.join(mcpPath, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.main) return pkg.main;
+    if (pkg.bin) {
+      if (typeof pkg.bin === "string") return pkg.bin;
+      return Object.values(pkg.bin)[0] as string;
+    }
+  }
+  // Default to common patterns
+  if (fs.existsSync(path.join(mcpPath, "dist", "index.js"))) {
+    return "dist/index.js";
+  }
+  return "index.js";
+}
+
+// Tools definition
+const tools: Tool[] = [
+  {
+    name: "list_available",
+    description:
+      "List all available MCPs from GitHub that can be installed. Shows name, description, and install status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        refresh: {
+          type: "boolean",
+          description: "Force refresh from GitHub (default: false, uses cache if recent)",
+        },
+      },
+    },
+  },
+  {
+    name: "list_installed",
+    description: "List all locally installed MCPs with their status and paths.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "install",
+    description:
+      "Install an MCP from GitHub. Clones the repo, builds it, and configures it for Opencode.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the MCP to install (e.g., 'elastic-mcp', 'crowdstrike-mcp')",
+        },
+        env_vars: {
+          type: "object",
+          description:
+            "Environment variables to configure (key-value pairs). If not provided, will list required vars.",
+          additionalProperties: { type: "string" },
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "update",
+    description: "Update an installed MCP to the latest version from GitHub.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the MCP to update",
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "update_all",
+    description: "Update all installed MCPs to their latest versions.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "uninstall",
+    description: "Uninstall an MCP - removes the files and Opencode configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the MCP to uninstall",
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "configure",
+    description: "Reconfigure environment variables for an installed MCP.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the MCP to configure",
+        },
+        env_vars: {
+          type: "object",
+          description: "Environment variables to set (key-value pairs)",
+          additionalProperties: { type: "string" },
+        },
+      },
+      required: ["name", "env_vars"],
+    },
+  },
+  {
+    name: "get_required_env",
+    description: "Get the required environment variables for an MCP (installed or available).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the MCP",
+        },
+      },
+      required: ["name"],
+    },
+  },
+];
+
+// Tool handlers
+async function handleListAvailable(args: { refresh?: boolean }): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+
+  const repos = await fetchGitHubRepos();
+
+  const result = repos.map((repo) => ({
+    ...repo,
+    installed: !!state.installed[repo.name],
+    localPath: state.installed[repo.name]?.path,
+  }));
+
+  const installed = result.filter((r) => r.installed);
+  const available = result.filter((r) => !r.installed);
+
+  let output = `## Available MCPs (${available.length})\n\n`;
+  for (const mcp of available) {
+    output += `- **${mcp.name}** - ${mcp.description}\n`;
+    output += `  Stars: ${mcp.stars} | Updated: ${new Date(mcp.updated).toLocaleDateString()}\n\n`;
+  }
+
+  output += `\n## Already Installed (${installed.length})\n\n`;
+  for (const mcp of installed) {
+    output += `- **${mcp.name}** (${mcp.localPath})\n`;
+  }
+
+  return output;
+}
+
+async function handleListInstalled(): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+
+  if (Object.keys(state.installed).length === 0) {
+    return "No MCPs installed yet. Use `install` to add some!";
+  }
+
+  let output = "## Installed MCPs\n\n";
+  for (const [name, info] of Object.entries(state.installed)) {
+    output += `### ${name}\n`;
+    output += `- Path: ${info.path}\n`;
+    output += `- Installed: ${new Date(info.installedAt).toLocaleDateString()}\n`;
+    if (info.envVars.length > 0) {
+      output += `- Configured env vars: ${info.envVars.join(", ")}\n`;
+    }
+    output += "\n";
+  }
+
+  return output;
+}
+
+async function handleInstall(args: {
+  name: string;
+  env_vars?: Record<string, string>;
+}): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+  const { name, env_vars } = args;
+
+  // Validate name
+  if (!isValidMcpName(name)) {
+    return `Invalid MCP name: ${name}. Names can only contain letters, numbers, hyphens, and underscores.`;
+  }
+
+  // Check if already installed
+  if (state.installed[name]) {
+    return `${name} is already installed at ${state.installed[name].path}. Use \`update\` to get the latest version.`;
+  }
+
+  const mcpPath = path.join(MCPS_DIR, name);
+  const repoUrl = `https://github.com/${GITHUB_USER}/${name}.git`;
+
+  // Step 1: Clone
+  if (fs.existsSync(mcpPath)) {
+    fs.rmSync(mcpPath, { recursive: true });
+  }
+
+  const cloneResult = runCommand("git", ["clone", repoUrl, mcpPath]);
+  if (!cloneResult.success) {
+    return `Failed to clone ${name}. Make sure the repo exists at ${repoUrl}\nError: ${cloneResult.output}`;
+  }
+
+  // Step 2: Check required env vars
+  const requiredEnvVars = parseEnvVars(mcpPath);
+
+  if (requiredEnvVars.length > 0 && !env_vars) {
+    let output = `## ${name} requires configuration\n\n`;
+    output += `The following environment variables are needed:\n\n`;
+    for (const v of requiredEnvVars) {
+      output += `- **${v.name}**: ${v.description}\n`;
+    }
+    output += `\nPlease call \`install\` again with the \`env_vars\` parameter containing these values.`;
+    return output;
+  }
+
+  // Step 3: Write .env file if env_vars provided
+  if (env_vars && Object.keys(env_vars).length > 0) {
+    const envContent = Object.entries(env_vars)
+      .map(([k, v]) => `${k}=${v}`)
+      .join("\n");
+    fs.writeFileSync(path.join(mcpPath, ".env"), envContent);
+  }
+
+  // Step 4: Install dependencies and build
+  const pm = detectPackageManager(mcpPath);
+
+  const installResult = runCommand(pm, ["install"], mcpPath);
+  if (!installResult.success) {
+    return `Failed to install dependencies for ${name}. Error: ${installResult.output}`;
+  }
+
+  // Check if build script exists
+  const pkgPath = path.join(mcpPath, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.scripts?.build) {
+      const buildResult = runCommand(pm, ["run", "build"], mcpPath);
+      if (!buildResult.success) {
+        return `Failed to build ${name}. Error: ${buildResult.output}`;
+      }
+    }
+  }
+
+  // Step 5: Add to Opencode config
+  const config = loadOpencodeConfig();
+  if (!config.mcp) {
+    config.mcp = {};
+  }
+
+  const entryPoint = getEntryPoint(mcpPath);
+  const fullEntryPath = path.join(mcpPath, entryPoint);
+
+  (config.mcp as Record<string, unknown>)[name] = {
+    command: "node",
+    args: [fullEntryPath],
+    env: env_vars || {},
+  };
+
+  saveOpencodeConfig(config);
+
+  // Step 6: Update marketplace state
+  state.installed[name] = {
+    name,
+    path: mcpPath,
+    installedAt: new Date().toISOString(),
+    envVars: env_vars ? Object.keys(env_vars) : [],
+  };
+  saveState(state);
+
+  return `## Successfully installed ${name}!\n\n- Location: ${mcpPath}\n- Added to Opencode config\n\nRestart Opencode to use the new MCP.`;
+}
+
+async function handleUpdate(args: { name: string }): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+  const { name } = args;
+
+  if (!isValidMcpName(name)) {
+    return `Invalid MCP name: ${name}`;
+  }
+
+  if (!state.installed[name]) {
+    return `${name} is not installed. Use \`list_installed\` to see installed MCPs.`;
+  }
+
+  const mcpPath = state.installed[name].path;
+
+  // Pull latest
+  const pullResult = runCommand("git", ["pull"], mcpPath);
+  if (!pullResult.success) {
+    return `Failed to pull updates for ${name}: ${pullResult.output}`;
+  }
+
+  // Rebuild
+  const pm = detectPackageManager(mcpPath);
+
+  const installResult = runCommand(pm, ["install"], mcpPath);
+  if (!installResult.success) {
+    return `Failed to install dependencies for ${name}: ${installResult.output}`;
+  }
+
+  const pkgPath = path.join(mcpPath, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pkg.scripts?.build) {
+      const buildResult = runCommand(pm, ["run", "build"], mcpPath);
+      if (!buildResult.success) {
+        return `Failed to build ${name}: ${buildResult.output}`;
+      }
+    }
+  }
+
+  return `## Successfully updated ${name}!\n\nRestart Opencode to use the updated MCP.`;
+}
+
+async function handleUpdateAll(): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+
+  if (Object.keys(state.installed).length === 0) {
+    return "No MCPs installed to update.";
+  }
+
+  const results: string[] = [];
+
+  for (const name of Object.keys(state.installed)) {
+    const result = await handleUpdate({ name });
+    results.push(`### ${name}\n${result}`);
+  }
+
+  return `## Update Results\n\n${results.join("\n\n")}`;
+}
+
+async function handleUninstall(args: { name: string }): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+  const { name } = args;
+
+  if (!isValidMcpName(name)) {
+    return `Invalid MCP name: ${name}`;
+  }
+
+  if (!state.installed[name]) {
+    return `${name} is not installed.`;
+  }
+
+  const mcpPath = state.installed[name].path;
+
+  // Remove from Opencode config
+  const config = loadOpencodeConfig();
+  if (config.mcp && (config.mcp as Record<string, unknown>)[name]) {
+    delete (config.mcp as Record<string, unknown>)[name];
+    saveOpencodeConfig(config);
+  }
+
+  // Remove files
+  if (fs.existsSync(mcpPath)) {
+    fs.rmSync(mcpPath, { recursive: true });
+  }
+
+  // Update state
+  delete state.installed[name];
+  saveState(state);
+
+  return `## Uninstalled ${name}\n\n- Removed from Opencode config\n- Deleted files at ${mcpPath}`;
+}
+
+async function handleConfigure(args: {
+  name: string;
+  env_vars: Record<string, string>;
+}): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+  const { name, env_vars } = args;
+
+  if (!isValidMcpName(name)) {
+    return `Invalid MCP name: ${name}`;
+  }
+
+  if (!state.installed[name]) {
+    return `${name} is not installed. Install it first.`;
+  }
+
+  const mcpPath = state.installed[name].path;
+
+  // Update .env file
+  const envContent = Object.entries(env_vars)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n");
+  fs.writeFileSync(path.join(mcpPath, ".env"), envContent);
+
+  // Update Opencode config
+  const config = loadOpencodeConfig();
+  if (config.mcp && (config.mcp as Record<string, unknown>)[name]) {
+    ((config.mcp as Record<string, unknown>)[name] as Record<string, unknown>).env = env_vars;
+    saveOpencodeConfig(config);
+  }
+
+  // Update state
+  state.installed[name].envVars = Object.keys(env_vars);
+  saveState(state);
+
+  return `## Updated configuration for ${name}\n\nRestart Opencode to apply changes.`;
+}
+
+async function handleGetRequiredEnv(args: { name: string }): Promise<string> {
+  ensureDirectories();
+  const state = loadState();
+  const { name } = args;
+
+  if (!isValidMcpName(name)) {
+    return `Invalid MCP name: ${name}`;
+  }
+
+  let mcpPath: string;
+
+  if (state.installed[name]) {
+    mcpPath = state.installed[name].path;
+  } else {
+    // Need to fetch from GitHub temporarily
+    const tempPath = path.join(os.tmpdir(), `mcp-check-${name}`);
+    const repoUrl = `https://github.com/${GITHUB_USER}/${name}.git`;
+
+    if (fs.existsSync(tempPath)) {
+      fs.rmSync(tempPath, { recursive: true });
+    }
+
+    const cloneResult = runCommand("git", ["clone", "--depth", "1", repoUrl, tempPath]);
+    if (!cloneResult.success) {
+      return `Could not find ${name} on GitHub.`;
+    }
+    mcpPath = tempPath;
+  }
+
+  const envVars = parseEnvVars(mcpPath);
+
+  if (envVars.length === 0) {
+    return `No environment variables detected for ${name}.`;
+  }
+
+  let output = `## Required Environment Variables for ${name}\n\n`;
+  for (const v of envVars) {
+    output += `- **${v.name}**: ${v.description}\n`;
+  }
+
+  return output;
+}
+
+// Main server setup
+const server = new Server(
+  {
+    name: "mcp-marketplace",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: string;
+
+    switch (name) {
+      case "list_available":
+        result = await handleListAvailable(args as { refresh?: boolean });
+        break;
+      case "list_installed":
+        result = await handleListInstalled();
+        break;
+      case "install":
+        result = await handleInstall(
+          args as { name: string; env_vars?: Record<string, string> }
+        );
+        break;
+      case "update":
+        result = await handleUpdate(args as { name: string });
+        break;
+      case "update_all":
+        result = await handleUpdateAll();
+        break;
+      case "uninstall":
+        result = await handleUninstall(args as { name: string });
+        break;
+      case "configure":
+        result = await handleConfigure(
+          args as { name: string; env_vars: Record<string, string> }
+        );
+        break;
+      case "get_required_env":
+        result = await handleGetRequiredEnv(args as { name: string });
+        break;
+      default:
+        result = `Unknown tool: ${name}`;
+    }
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("MCP Marketplace server running");
+}
+
+main().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}