opencoding-agent 1.0.2 → 1.0.4

package/README.md

@@ -5,8 +5,31 @@ opencoding-agent is an OpenCode plugin that provides specialized agents and a su
 ## Features
 
 - **Custom Agents**: Replaces default agents with specialized `plan` and `build` modes.
+- **Dynamic MCP Injection**: Injects powerful Model Context Protocol (MCP) servers into your environment.
 - **Subagent Catalog**: Browse and install subagents from the [awesome-opencode-subagents](https://github.com/j5hjun/awesome-opencode-subagents) repository.
 
+## Built-in MCPs
+
+The following MCP servers are automatically injected and granted full access for `opencoding-plan` and `opencoding-build` agents:
+
+- **websearch**: Real-time web search powered by Exa AI.
+- **context7**: Official documentation lookup for libraries.
+- **grep_app**: Ultra-fast code search across GitHub repositories.
+
+## Configuration
+
+You can customize the plugin by creating a configuration file at `~/.config/opencode/opencoding-agent.json` or `.opencoding-agent.json` in your project root.
+
+### Disable specific MCPs
+
+If you want to disable specific MCP servers, add them to the `disabled_mcps` list:
+
+```json
+{
+  "disabled_mcps": ["grep_app"]
+}
+```
+
 ## Installation
 
 Add this plugin to your `opencode.json`:

package/dist/src/agents/index.d.ts

@@ -1 +1 @@
-export declare const injectAgents: (config: any) => Promise<void>;
+export declare const injectAgents: (opencodeConfig: any) => Promise<void>;

package/dist/src/agents/index.js

@@ -1,20 +1,22 @@
 import { planAgent } from "./plan";
 import { buildAgent } from "./build";
-export const injectAgents = async (config) => {
-    config.agent = {
-        ...config.agent,
+import { deepMerge } from "../config";
+export const injectAgents = async (opencodeConfig) => {
+    const existingAgents = (opencodeConfig.agent ?? {});
+    opencodeConfig.agent = {
+        ...existingAgents,
         // Disable default agents
         "build": { disable: true },
         "plan": { disable: true },
         // Inject our opencoding- prefixed agents
-        "opencoding-plan": {
-            ...planAgent,
+        "opencoding-plan": deepMerge(planAgent, {
+            ...(existingAgents["opencoding-plan"] ?? {}),
             disable: false
-        },
-        "opencoding-build": {
-            ...buildAgent,
+        }),
+        "opencoding-build": deepMerge(buildAgent, {
+            ...(existingAgents["opencoding-build"] ?? {}),
             disable: false
-        }
+        })
     };
-    config.default_agent = "opencoding-plan";
+    opencodeConfig.default_agent = "opencoding-plan";
 };

package/dist/src/config/mcp-parser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parse a list with wildcard and exclusion syntax.
+ * Validates against allAvailable and removes duplicates.
+ */
+export declare function parseList(items: string[], allAvailable: string[]): string[];

package/dist/src/config/mcp-parser.js

@@ -0,0 +1,22 @@
+/**
+ * Parse a list with wildcard and exclusion syntax.
+ * Validates against allAvailable and removes duplicates.
+ */
+export function parseList(items, allAvailable) {
+    if (!items || items.length === 0) {
+        return [];
+    }
+    const allow = items.filter((i) => !i.startsWith("!"));
+    const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
+    if (deny.includes("*")) {
+        return [];
+    }
+    let result;
+    if (allow.includes("*")) {
+        result = allAvailable.filter((item) => !deny.includes(item));
+    }
+    else {
+        result = allow.filter((item) => !deny.includes(item) && allAvailable.includes(item));
+    }
+    return [...new Set(result)];
+}

package/dist/src/config/mcp-parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config/mcp-parser.test.js

@@ -0,0 +1,23 @@
+import { expect, test, describe } from "bun:test";
+import { parseList } from "./mcp-parser";
+describe("parseList", () => {
+    const allAvailable = ["a", "b", "c"];
+    test("returns empty list for empty items", () => {
+        expect(parseList([], allAvailable)).toEqual([]);
+    });
+    test("returns specific items", () => {
+        expect(parseList(["a", "b"], allAvailable)).toEqual(["a", "b"]);
+    });
+    test("returns all items with *", () => {
+        expect(parseList(["*"], allAvailable)).toEqual(["a", "b", "c"]);
+    });
+    test("excludes specific items", () => {
+        expect(parseList(["*", "!b"], allAvailable)).toEqual(["a", "c"]);
+    });
+    test("excludes all with !*", () => {
+        expect(parseList(["a", "!*"], allAvailable)).toEqual([]);
+    });
+    test("handles only exclusions", () => {
+        expect(parseList(["!b"], allAvailable)).toEqual([]);
+    });
+});

package/dist/src/config.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export type AgentInfo = {
     name: string;
     description: string;
@@ -6,4 +7,20 @@ export type AgentInfo = {
     permission: Record<string, string>;
     prompt?: string;
 };
+/**
+ * opencoding-agent Configuration Schema
+ */
+export declare const PluginConfigSchema: z.ZodObject<{
+    disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export declare const PLUGIN_NAME = "opencoding-agent";
+/**
+ * Loads the plugin configuration from the home directory or project directory.
+ * Path: ~/.config/opencode/opencoding-agent.json or <project_dir>/.opencoding-agent.json
+ */
+export declare function loadPluginConfig(projectDir?: string): PluginConfig;
+/**
+ * Basic deep merge for configuration objects.
+ */
+export declare function deepMerge(target: any, source: any): any;

package/dist/src/config.js

@@ -1 +1,54 @@
+import { z } from "zod";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+/**
+ * opencoding-agent Configuration Schema
+ */
+export const PluginConfigSchema = z.object({
+    disabled_mcps: z.array(z.string()).optional(),
+    // Add other config items as needed
+});
 export const PLUGIN_NAME = "opencoding-agent";
+/**
+ * Loads the plugin configuration from the home directory or project directory.
+ * Path: ~/.config/opencode/opencoding-agent.json or <project_dir>/.opencoding-agent.json
+ */
+export function loadPluginConfig(projectDir) {
+    const globalConfigPath = path.join(os.homedir(), ".config", "opencode", `${PLUGIN_NAME}.json`);
+    const projectConfigPath = projectDir ? path.join(projectDir, `.${PLUGIN_NAME}.json`) : null;
+    const configPaths = [projectConfigPath, globalConfigPath].filter(Boolean);
+    for (const configPath of configPaths) {
+        if (fs.existsSync(configPath)) {
+            try {
+                const rawContent = fs.readFileSync(configPath, "utf-8");
+                const json = JSON.parse(rawContent);
+                return PluginConfigSchema.parse(json);
+            }
+            catch (error) {
+                console.error(`[${PLUGIN_NAME}] Failed to load config from ${configPath}:`, error);
+            }
+        }
+    }
+    return {};
+}
+/**
+ * Basic deep merge for configuration objects.
+ */
+export function deepMerge(target, source) {
+    if (typeof target !== "object" || target === null || typeof source !== "object" || source === null) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+                result[key] = deepMerge(target[key] || {}, source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+    }
+    return result;
+}

package/dist/src/hooks/auto-update/cache.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalidates the current package by removing its directory from OpenCode's cache.
+ * This forces a clean state so OpenCode re-downloads the plugin on next run.
+ * @param packageName The name of the package to invalidate.
+ */
+export declare function invalidatePackage(packageName?: string): boolean;

package/dist/src/hooks/auto-update/cache.js

@@ -0,0 +1,24 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CACHE_DIR, PACKAGE_NAME } from './constants';
+/**
+ * Invalidates the current package by removing its directory from OpenCode's cache.
+ * This forces a clean state so OpenCode re-downloads the plugin on next run.
+ * @param packageName The name of the package to invalidate.
+ */
+export function invalidatePackage(packageName = PACKAGE_NAME) {
+    try {
+        const pkgDir = path.join(CACHE_DIR, 'node_modules', packageName);
+        if (fs.existsSync(pkgDir)) {
+            fs.rmSync(pkgDir, { recursive: true, force: true });
+            console.log(`[auto-update] Package cache removed: ${pkgDir}`);
+            return true;
+        }
+        console.log(`[auto-update] Package not found in cache: ${packageName}`);
+        return false;
+    }
+    catch (err) {
+        console.error('[auto-update] Failed to invalidate package:', err);
+        return false;
+    }
+}

package/dist/src/hooks/auto-update/checker.d.ts

@@ -0,0 +1,18 @@
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export declare function getCachedVersion(): string | null;
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export declare function getLatestVersion(channel?: string): Promise<string | null>;
+/**
+ * Checks if the plugin is running in local development mode (e.g. from a file path).
+ */
+export declare function isLocalDevMode(directory: string): boolean;

package/dist/src/hooks/auto-update/checker.js

@@ -0,0 +1,128 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { INSTALLED_PACKAGE_JSON, NPM_FETCH_TIMEOUT, NPM_REGISTRY_URL, PACKAGE_NAME, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC } from './constants';
+/**
+ * Strips single and multi-line comments from a JSON string.
+ */
+function stripJsonComments(text) {
+    return text.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "");
+}
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+let cachedPackageVersion = null;
+export function getCachedVersion() {
+    if (cachedPackageVersion)
+        return cachedPackageVersion;
+    try {
+        if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
+            const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (pkg.version) {
+                cachedPackageVersion = pkg.version;
+                return pkg.version;
+            }
+        }
+    }
+    catch {
+        /* empty */
+    }
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = findPackageJsonUp(currentDir);
+        if (pkgPath) {
+            const content = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (pkg.version) {
+                cachedPackageVersion = pkg.version;
+                return pkg.version;
+            }
+        }
+    }
+    catch (err) {
+        console.warn('[auto-update] Failed to resolve version from current directory:', err);
+    }
+    return null;
+}
+/**
+ * Recursively searches upwards for a package.json belonging to this plugin.
+ */
+function findPackageJsonUp(startPath) {
+    try {
+        const stat = fs.statSync(startPath);
+        let dir = stat.isDirectory() ? startPath : path.dirname(startPath);
+        for (let i = 0; i < 10; i++) {
+            const pkgPath = path.join(dir, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const content = fs.readFileSync(pkgPath, 'utf-8');
+                    const pkg = JSON.parse(content);
+                    if (pkg.name === PACKAGE_NAME)
+                        return pkgPath;
+                }
+                catch {
+                    /* empty */
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return null;
+}
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export async function getLatestVersion(channel = 'latest') {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+    try {
+        const response = await fetch(NPM_REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data[channel] ?? data.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Checks if the plugin is running in local development mode (e.g. from a file path).
+ */
+export function isLocalDevMode(directory) {
+    const configPaths = [
+        path.join(directory, '.opencode', 'opencode.json'),
+        path.join(directory, '.opencode', 'opencode.jsonc'),
+        USER_OPENCODE_CONFIG,
+        USER_OPENCODE_CONFIG_JSONC,
+    ];
+    for (const configPath of configPaths) {
+        try {
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf-8');
+                const json = JSON.parse(stripJsonComments(content));
+                const plugins = json.plugin ?? [];
+                if (plugins.some((p) => p.startsWith('/') || p.startsWith('file://'))) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return false;
+}

package/dist/src/hooks/auto-update/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const PACKAGE_NAME = "opencoding-agent";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencoding-agent/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 3000;
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export declare const CACHE_DIR: string;
+/** Path to this plugin's package.json within the OpenCode cache. */
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/src/hooks/auto-update/constants.js

@@ -0,0 +1,23 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const PACKAGE_NAME = 'opencoding-agent';
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+export const NPM_FETCH_TIMEOUT = 3000;
+function getCacheDir() {
+    if (process.platform === 'win32') {
+        return path.join(process.env.LOCALAPPDATA ?? os.homedir(), 'opencode');
+    }
+    return path.join(os.homedir(), '.cache', 'opencode');
+}
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export const CACHE_DIR = getCacheDir();
+/** Path to this plugin's package.json within the OpenCode cache. */
+export const INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR, 'node_modules', PACKAGE_NAME, 'package.json');
+function getConfigDir() {
+    const userConfigDir = process.env.XDG_CONFIG_HOME
+        ? process.env.XDG_CONFIG_HOME
+        : path.join(os.homedir(), '.config');
+    return path.join(userConfigDir, 'opencode');
+}
+export const USER_OPENCODE_CONFIG = path.join(getConfigDir(), 'opencode.json');
+export const USER_OPENCODE_CONFIG_JSONC = path.join(getConfigDir(), 'opencode.jsonc');

package/dist/src/hooks/auto-update/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+/**
+ * Creates an OpenCode hook that checks for plugin updates and invalidates cache if available.
+ *
+ * @param ctx The plugin input context.
+ * @returns A hook object for the session.created event.
+ */
+export declare function createAutoUpdateHook(ctx: PluginInput): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};

package/dist/src/hooks/auto-update/index.js

@@ -0,0 +1,52 @@
+import { getCachedVersion, getLatestVersion, isLocalDevMode } from './checker';
+import { invalidatePackage } from './cache';
+/**
+ * Creates an OpenCode hook that checks for plugin updates and invalidates cache if available.
+ *
+ * @param ctx The plugin input context.
+ * @returns A hook object for the session.created event.
+ */
+export function createAutoUpdateHook(ctx) {
+    let hasChecked = false;
+    return {
+        event: ({ event }) => {
+            // Only run once per process when a session is created
+            if (event.type !== 'session.created')
+                return;
+            if (hasChecked)
+                return;
+            hasChecked = true;
+            // Run check in the background
+            setTimeout(async () => {
+                // Skip check if in local development mode
+                if (isLocalDevMode(ctx.directory)) {
+                    console.log('[auto-update] Local development mode detected. Skipping check.');
+                    return;
+                }
+                const currentVersion = getCachedVersion();
+                const latestVersion = await getLatestVersion();
+                if (!currentVersion || !latestVersion) {
+                    console.log('[auto-update] Could not determine versions. Skipping.');
+                    return;
+                }
+                if (currentVersion !== latestVersion) {
+                    console.log(`[auto-update] Update available: ${currentVersion} → ${latestVersion}`);
+                    // Show toast notification
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: 'opencoding-agent Update!',
+                            message: `v${latestVersion} is available. Restart OpenCode to apply.`,
+                            variant: 'info',
+                            duration: 8000,
+                        },
+                    }).catch(() => { });
+                    // Invalidate cache
+                    invalidatePackage();
+                }
+                else {
+                    console.log(`[auto-update] Already on latest version: ${currentVersion}`);
+                }
+            }, 0);
+        },
+    };
+}

package/dist/src/index.d.ts

@@ -3,6 +3,7 @@ import type { Plugin } from "@opencode-ai/plugin";
  * opencoding-agent Plugin
  *
  * Replaces default OpenCode agents with core-identical 'plan' and 'build' modes.
+ * Now with dynamic MCP injection!
  */
 declare const OpencodingAgentPlugin: Plugin;
 export default OpencodingAgentPlugin;

package/dist/src/index.js

@@ -1,20 +1,70 @@
 import { injectAgents } from "./agents";
 import { catalogTools } from "./tools/catalog";
+import { createBuiltinMcps } from "./mcp";
+import { loadPluginConfig } from "./config";
+import { createAutoUpdateHook } from "./hooks/auto-update";
 /**
  * opencoding-agent Plugin
  *
  * Replaces default OpenCode agents with core-identical 'plan' and 'build' modes.
+ * Now with dynamic MCP injection!
  */
 const OpencodingAgentPlugin = async (ctx) => {
+    const pluginConfig = loadPluginConfig(ctx.directory);
+    const mcps = createBuiltinMcps(pluginConfig.disabled_mcps);
+    const mcpNames = Object.keys(mcps);
+    // Initialize auto-update hook
+    const autoUpdateHook = createAutoUpdateHook(ctx);
     return {
+        name: "opencoding-agent",
         // Config hook: Injected once during initialization
-        config: async (config) => {
-            await injectAgents(config);
+        // Note: 'any' is used because the Config type is not exported by the plugin SDK
+        config: async (opencodeConfig) => {
+            // 1. Inject specialized agents (opencoding-plan, opencoding-build)
+            await injectAgents(opencodeConfig);
+            // 2. Merge MCP configs (careful not to overwrite user settings)
+            if (!opencodeConfig.mcp) {
+                opencodeConfig.mcp = { ...mcps };
+            }
+            else {
+                const existingMcp = opencodeConfig.mcp;
+                for (const [name, config] of Object.entries(mcps)) {
+                    if (!(name in existingMcp)) {
+                        existingMcp[name] = config;
+                    }
+                }
+            }
+            // 3. Grant full permissions to opencoding- agents for these MCPs
+            const agentsToGrant = ["opencoding-plan", "opencoding-build"];
+            const agentConfig = opencodeConfig.agent;
+            agentsToGrant.forEach((agentName) => {
+                const agent = agentConfig[agentName];
+                if (!agent)
+                    return;
+                if (!agent.permission) {
+                    agent.permission = {};
+                }
+                for (const mcpName of mcpNames) {
+                    // MCP tools are prefixed with sanitized mcp server name
+                    const sanitizedMcpName = mcpName.replace(/[^a-zA-Z0-9_-]/g, "_");
+                    const permissionKey = `${sanitizedMcpName}_*`;
+                    // Force allow unless already defined
+                    if (!(permissionKey in agent.permission)) {
+                        agent.permission[permissionKey] = "allow";
+                    }
+                }
+            });
+        },
+        // Session events
+        event: async (input) => {
+            await autoUpdateHook.event(input);
         },
         // Register custom tools
         tool: {
-            ...catalogTools
-        }
+            ...catalogTools,
+        },
+        // Register MCPs
+        mcp: mcps,
     };
 };
 export default OpencodingAgentPlugin;

package/dist/src/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/index.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, test, mock } from "bun:test";
+import OpencodingAgentPlugin from "./index";
+// Mock config load for test
+mock.module("./config", () => {
+    return {
+        loadPluginConfig: () => ({ disabled_mcps: [] }),
+        PLUGIN_NAME: "opencoding-agent"
+    };
+});
+describe("OpencodingAgentPlugin", () => {
+    const mockCtx = {
+        directory: "/mock/dir"
+    };
+    test("config hook injects agents and mcps and permissions", async () => {
+        const plugin = await OpencodingAgentPlugin(mockCtx);
+        const opencodeConfig = {
+            agent: {},
+            mcp: {}
+        };
+        if (plugin.config) {
+            await plugin.config(opencodeConfig);
+        }
+        // Agents should be injected
+        expect(opencodeConfig.agent["opencoding-plan"]).toBeDefined();
+        expect(opencodeConfig.agent["opencoding-build"]).toBeDefined();
+        // MCPs should be merged
+        expect(opencodeConfig.mcp["websearch"]).toBeDefined();
+        expect(opencodeConfig.mcp["context7"]).toBeDefined();
+        expect(opencodeConfig.mcp["grep_app"]).toBeDefined();
+        // Permissions should be granted to opencoding- agents
+        expect(opencodeConfig.agent["opencoding-plan"].permission["websearch_*"]).toBe("allow");
+        expect(opencodeConfig.agent["opencoding-build"].permission["websearch_*"]).toBe("allow");
+    });
+});

package/dist/src/mcp/context7.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export declare const context7: RemoteMcpConfig;

package/dist/src/mcp/context7.js

@@ -0,0 +1,12 @@
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export const context7 = {
+    type: 'remote',
+    url: 'https://mcp.context7.com/mcp',
+    headers: process.env.CONTEXT7_API_KEY
+        ? { CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY }
+        : undefined,
+    oauth: false,
+};

package/dist/src/mcp/grep-app.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export declare const grep_app: RemoteMcpConfig;

package/dist/src/mcp/grep-app.js

@@ -0,0 +1,9 @@
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export const grep_app = {
+    type: 'remote',
+    url: 'https://mcp.grep.app',
+    oauth: false,
+};

package/dist/src/mcp/index.d.ts

@@ -0,0 +1,7 @@
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones.
+ * Supports wildcard (*) and exclusion (!) syntax via parseList.
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[]): Record<string, McpConfig>;

package/dist/src/mcp/index.js

@@ -0,0 +1,21 @@
+import { context7 } from './context7';
+import { grep_app } from './grep-app';
+import { websearch } from './websearch';
+import { parseList } from '../config/mcp-parser';
+const allBuiltinMcps = {
+    websearch,
+    context7,
+    grep_app,
+};
+/**
+ * Creates MCP configurations, excluding disabled ones.
+ * Supports wildcard (*) and exclusion (!) syntax via parseList.
+ */
+export function createBuiltinMcps(disabledMcps = []) {
+    const allNames = Object.keys(allBuiltinMcps);
+    // By default, all builtin MCPs are allowed.
+    // We prepend '*' to the list and then apply the disabled list as exclusions.
+    const items = ["*", ...disabledMcps.map(name => `!${name}`)];
+    const enabledNames = parseList(items, allNames);
+    return Object.fromEntries(Object.entries(allBuiltinMcps).filter(([name]) => enabledNames.includes(name)));
+}

package/dist/src/mcp/types.d.ts

@@ -0,0 +1,12 @@
+export type RemoteMcpConfig = {
+    type: 'remote';
+    url: string;
+    headers?: Record<string, string>;
+    oauth?: false;
+};
+export type LocalMcpConfig = {
+    type: 'local';
+    command: string[];
+    environment?: Record<string, string>;
+};
+export type McpConfig = RemoteMcpConfig | LocalMcpConfig;

package/dist/src/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/mcp/websearch.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Exa AI web search - real-time web search
+ * @see https://exa.ai
+ */
+export declare const websearch: RemoteMcpConfig;

package/dist/src/mcp/websearch.js

@@ -0,0 +1,12 @@
+/**
+ * Exa AI web search - real-time web search
+ * @see https://exa.ai
+ */
+export const websearch = {
+    type: 'remote',
+    url: 'https://mcp.exa.ai/mcp?tools=web_search_exa',
+    headers: process.env.EXA_API_KEY
+        ? { 'x-api-key': process.env.EXA_API_KEY }
+        : undefined,
+    oauth: false,
+};

package/dist/src/tools/catalog.d.ts

@@ -1,33 +1,2 @@
-import { z } from "zod";
-export declare const catalogTools: {
-    "subagent-catalog:list": {
-        description: string;
-        args: {};
-        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-    };
-    "subagent-catalog:search": {
-        description: string;
-        args: {
-            query: z.ZodString;
-            category: z.ZodOptional<z.ZodString>;
-        };
-        execute(args: {
-            query: string;
-            category?: string | undefined;
-        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-    };
-    "subagent-catalog:fetch": {
-        description: string;
-        args: {
-            name: z.ZodString;
-            scope: z.ZodDefault<z.ZodEnum<{
-                global: "global";
-                local: "local";
-            }>>;
-        };
-        execute(args: {
-            name: string;
-            scope: "global" | "local";
-        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-    };
-};
+import { type ToolDefinition } from "@opencode-ai/plugin";
+export declare const catalogTools: Record<string, ToolDefinition>;

package/dist/src/tools/catalog.js

@@ -40,7 +40,8 @@ export const catalogTools = {
             query: z.string().describe("Search term"),
             category: z.string().optional().describe("Filter by category")
         },
-        execute: async ({ query, category }) => {
+        execute: async (args) => {
+            const { query, category } = args;
             try {
                 const url = `${REPO_URL}/catalog.json?t=${Date.now()}`;
                 const response = await fetch(url);
@@ -75,7 +76,8 @@ export const catalogTools = {
             name: z.string().describe("Name of the agent to fetch"),
             scope: z.enum(["global", "local"]).default("global").describe("Installation scope (global: all projects, local: current project only)")
         },
-        execute: async ({ name, scope }, { directory }) => {
+        execute: async (args, { directory }) => {
+            const { name, scope } = args;
             try {
                 const catalogUrl = `${REPO_URL}/catalog.json?t=${Date.now()}`;
                 const catalogResponse = await fetch(catalogUrl);

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "opencoding-agent",
-  "version": "1.0.2",
-  "description": "OpenCode specialized agents and subagent catalog manager",
-  "type": "module",
+  "version": "1.0.4",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.0",
+    "@types/bun": "^1.2.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.0.0"
+  },
+  "description": "OpenCode specialized agents and subagent catalog manager",
   "files": [
     "dist",
     "README.md",
@@ -16,21 +23,14 @@
     "plugin"
   ],
   "license": "MIT",
-  "peerDependencies": {
-    "@opencode-ai/plugin": "^1.0.0"
-  },
-  "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.0",
-    "@types/bun": "^1.2.0",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "clean": "rm -rf dist",
     "build": "npm run clean && tsc",
     "prepublishOnly": "npm run build"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "type": "module",
+  "types": "dist/index.d.ts"
 }