skiller 0.4.3

package/dist/mcp/capabilities.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentMcpCapabilities = getAgentMcpCapabilities;
+exports.agentSupportsMcp = agentSupportsMcp;
+exports.filterMcpConfigForAgent = filterMcpConfigForAgent;
+/**
+ * Derives MCP capabilities for an agent
+ */
+function getAgentMcpCapabilities(agent) {
+    return {
+        supportsStdio: agent.supportsMcpStdio?.() ?? false,
+        supportsRemote: agent.supportsMcpRemote?.() ?? false,
+    };
+}
+/**
+ * Checks if an agent supports any MCP functionality
+ */
+function agentSupportsMcp(agent) {
+    const capabilities = getAgentMcpCapabilities(agent);
+    return capabilities.supportsStdio || capabilities.supportsRemote;
+}
+/**
+ * Filters MCP configuration based on agent capabilities
+ */
+function filterMcpConfigForAgent(mcpConfig, agent) {
+    const capabilities = getAgentMcpCapabilities(agent);
+    if (!agentSupportsMcp(agent)) {
+        return null;
+    }
+    const servers = mcpConfig.mcpServers;
+    if (!servers) {
+        return null;
+    }
+    const filteredServers = {};
+    for (const [serverName, serverConfig] of Object.entries(servers)) {
+        const config = serverConfig;
+        // Determine server type
+        const hasCommand = 'command' in config;
+        const hasUrl = 'url' in config;
+        const isStdio = hasCommand && !hasUrl;
+        const isRemote = hasUrl && !hasCommand;
+        // Include server if agent supports its type
+        if (isStdio && capabilities.supportsStdio) {
+            filteredServers[serverName] = serverConfig;
+        }
+        else if (isRemote && capabilities.supportsRemote) {
+            filteredServers[serverName] = serverConfig;
+        }
+        else if (isRemote &&
+            !capabilities.supportsRemote &&
+            capabilities.supportsStdio) {
+            // Transform remote server to stdio server using mcp-remote
+            const transformedConfig = {
+                command: 'npx',
+                args: ['-y', 'mcp-remote@latest', config.url],
+                ...Object.fromEntries(Object.entries(config).filter(([key]) => key !== 'url')),
+            };
+            filteredServers[serverName] = transformedConfig;
+        }
+        // Note: Mixed servers (both command and url) are excluded
+    }
+    return Object.keys(filteredServers).length > 0
+        ? { mcpServers: filteredServers }
+        : null;
+}

package/dist/mcp/merge.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMcp = mergeMcp;
+/**
+ * Merge native and incoming MCP server configurations according to strategy.
+ * @param base Existing native MCP config object.
+ * @param incoming Ruler MCP config object.
+ * @param strategy Merge strategy: 'merge' to union servers, 'overwrite' to replace.
+ * @param serverKey The key to use for servers in the output (e.g., 'servers' for Copilot, 'mcpServers' for others).
+ * @returns Merged MCP config object.
+ */
+function mergeMcp(base, incoming, strategy, serverKey) {
+    if (strategy === 'overwrite') {
+        // Ensure the incoming object uses the correct server key.
+        // Transform from the standard (Crush) MCP config format
+        const incomingServers = incoming[serverKey] ||
+            incoming.mcpServers ||
+            incoming.mcp ||
+            {};
+        return {
+            [serverKey]: incomingServers,
+        };
+    }
+    const baseServers = base[serverKey] ||
+        base.mcpServers ||
+        base.mcp ||
+        {};
+    const incomingServers = incoming[serverKey] ||
+        incoming.mcpServers ||
+        incoming.mcp ||
+        {};
+    const mergedServers = { ...baseServers, ...incomingServers };
+    const newBase = { ...base };
+    delete newBase.mcpServers; // Remove old key if present
+    return {
+        ...newBase,
+        [serverKey]: mergedServers,
+    };
+}

package/dist/mcp/propagateOpenCodeMcp.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateMcpToOpenCode = propagateMcpToOpenCode;
+const fs = __importStar(require("fs/promises"));
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+const path = __importStar(require("path"));
+function isLocalServer(value) {
+    const server = value;
+    return (server &&
+        (typeof server.command === 'string' || Array.isArray(server.command)));
+}
+function isRemoteServer(value) {
+    const server = value;
+    return server && typeof server.url === 'string';
+}
+/**
+ * Transform ruler MCP configuration to OpenCode's specific format
+ */
+function transformToOpenCodeFormat(rulerMcp) {
+    const rulerServers = rulerMcp.mcpServers || {};
+    const openCodeServers = {};
+    for (const [name, serverDef] of Object.entries(rulerServers)) {
+        const openCodeServer = {
+            type: 'local',
+            enabled: true,
+        };
+        if (isRemoteServer(serverDef)) {
+            openCodeServer.type = 'remote';
+            openCodeServer.url = serverDef.url;
+            if (serverDef.headers) {
+                openCodeServer.headers = serverDef.headers;
+            }
+        }
+        else if (isLocalServer(serverDef)) {
+            openCodeServer.type = 'local';
+            const command = Array.isArray(serverDef.command)
+                ? serverDef.command
+                : [serverDef.command];
+            const args = serverDef.args || [];
+            openCodeServer.command = [...command, ...args];
+            if (serverDef.env) {
+                openCodeServer.environment = serverDef.env;
+            }
+        }
+        else {
+            continue;
+        }
+        openCodeServers[name] = openCodeServer;
+    }
+    return {
+        $schema: 'https://opencode.ai/config.json',
+        mcp: openCodeServers,
+    };
+}
+async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath, backup = true) {
+    const rulerMcp = rulerMcpData || {};
+    // Read existing OpenCode config if it exists
+    let existingConfig = {};
+    try {
+        const existingContent = await fs.readFile(openCodeConfigPath, 'utf8');
+        existingConfig = JSON.parse(existingContent);
+    }
+    catch {
+        // File doesn't exist, we'll create it
+    }
+    // Transform ruler MCP to OpenCode format
+    const transformedConfig = transformToOpenCodeFormat(rulerMcp);
+    // Merge with existing config, preserving non-MCP settings
+    const finalConfig = {
+        ...existingConfig,
+        $schema: transformedConfig.$schema,
+        mcp: {
+            ...existingConfig.mcp,
+            ...transformedConfig.mcp,
+        },
+    };
+    await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openCodeConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openCodeConfigPath);
+    }
+    await fs.writeFile(openCodeConfigPath, JSON.stringify(finalConfig, null, 2) + '\n');
+}

package/dist/mcp/propagateOpenHandsMcp.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateMcpToOpenHands = propagateMcpToOpenHands;
+const fs = __importStar(require("fs/promises"));
+const toml_1 = require("@iarna/toml");
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+const path = __importStar(require("path"));
+function isRulerMcpServer(value) {
+    const server = value;
+    return (server &&
+        (typeof server.command === 'string' || typeof server.url === 'string'));
+}
+function classifyRemoteServer(url) {
+    // Heuristic: URLs containing /sse path segments are classified as SSE
+    return /\/sse(\/|$)/i.test(url) ? 'sse' : 'shttp';
+}
+function extractApiKey(headers) {
+    if (!headers)
+        return null;
+    const authHeader = headers.Authorization || headers.authorization;
+    if (!authHeader)
+        return null;
+    // Extract Bearer token if that's the only header, or if only Authorization + standard content headers
+    const headerCount = Object.keys(headers).length;
+    const hasOnlyAuthHeader = headerCount === 1;
+    const hasOnlyStandardHeaders = headerCount <= 2 &&
+        (headers['Content-Type'] ||
+            headers['content-type'] ||
+            headers['Accept'] ||
+            headers['accept']);
+    if ((hasOnlyAuthHeader || hasOnlyStandardHeaders) &&
+        authHeader.startsWith('Bearer ')) {
+        return authHeader.substring('Bearer '.length);
+    }
+    return null;
+}
+function createRemoteServerEntry(url, headers) {
+    const apiKey = extractApiKey(headers);
+    if (apiKey) {
+        return { url, api_key: apiKey };
+    }
+    return url;
+}
+function normalizeRemoteServerArray(entries) {
+    // TOML doesn't support mixed types in arrays, so we need to be consistent
+    // If any entry is an object, convert all simple URLs to objects
+    const hasObjectEntries = entries.some((entry) => typeof entry === 'object');
+    if (hasObjectEntries) {
+        return entries.map((entry) => {
+            if (typeof entry === 'string') {
+                return { url: entry };
+            }
+            return entry;
+        });
+    }
+    // All entries are strings, keep as is
+    return entries;
+}
+async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath, backup = true) {
+    const rulerMcp = rulerMcpData || {};
+    // Always use the legacy Ruler MCP config format as input (top-level "mcpServers" key)
+    const rulerServers = rulerMcp.mcpServers || {};
+    // Return early if no servers to process
+    if (!rulerServers ||
+        typeof rulerServers !== 'object' ||
+        Object.keys(rulerServers).length === 0) {
+        return;
+    }
+    let config = {};
+    try {
+        const tomlContent = await fs.readFile(openHandsConfigPath, 'utf8');
+        config = (0, toml_1.parse)(tomlContent);
+    }
+    catch {
+        // File doesn't exist, we'll create it.
+    }
+    if (!config.mcp) {
+        config.mcp = {};
+    }
+    if (!config.mcp.stdio_servers) {
+        config.mcp.stdio_servers = [];
+    }
+    if (!config.mcp.sse_servers) {
+        config.mcp.sse_servers = [];
+    }
+    if (!config.mcp.shttp_servers) {
+        config.mcp.shttp_servers = [];
+    }
+    // Build maps for merging existing servers
+    const existingStdioServers = new Map(config.mcp.stdio_servers.map((s) => [s.name, s]));
+    const existingSseServers = new Map();
+    config.mcp.sse_servers.forEach((entry) => {
+        const url = typeof entry === 'string' ? entry : entry.url;
+        existingSseServers.set(url, entry);
+    });
+    const existingShttpServers = new Map();
+    config.mcp.shttp_servers.forEach((entry) => {
+        const url = typeof entry === 'string' ? entry : entry.url;
+        existingShttpServers.set(url, entry);
+    });
+    for (const [name, serverDef] of Object.entries(rulerServers)) {
+        if (isRulerMcpServer(serverDef)) {
+            if (serverDef.command) {
+                // Stdio server
+                const { command, args, env } = serverDef;
+                const newServer = { name, command };
+                if (args)
+                    newServer.args = args;
+                if (env)
+                    newServer.env = env;
+                existingStdioServers.set(name, newServer);
+            }
+            else if (serverDef.url) {
+                // Remote server
+                const classification = classifyRemoteServer(serverDef.url);
+                const entry = createRemoteServerEntry(serverDef.url, serverDef.headers);
+                if (classification === 'sse') {
+                    existingSseServers.set(serverDef.url, entry);
+                }
+                else {
+                    existingShttpServers.set(serverDef.url, entry);
+                }
+            }
+        }
+    }
+    // Convert maps back to arrays and normalize for TOML compatibility
+    config.mcp.stdio_servers = Array.from(existingStdioServers.values());
+    config.mcp.sse_servers = normalizeRemoteServerArray(Array.from(existingSseServers.values()));
+    config.mcp.shttp_servers = normalizeRemoteServerArray(Array.from(existingShttpServers.values()));
+    await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openHandsConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openHandsConfigPath);
+    }
+    await fs.writeFile(openHandsConfigPath, (0, toml_1.stringify)(config));
+}

package/dist/mcp/validate.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMcp = validateMcp;
+/**
+ * Validate the structure of the Ruler MCP JSON config.
+ * Minimal validation: ensure 'mcpServers' property exists and is an object.
+ * @param data Parsed JSON object from .ruler/mcp.json.
+ * @throws Error if validation fails.
+ */
+function validateMcp(data) {
+    if (!data ||
+        typeof data !== 'object' ||
+        !('mcpServers' in data) ||
+        typeof data.mcpServers !== 'object') {
+        throw new Error('[ruler] Invalid MCP config: must contain an object property "mcpServers" (Ruler style)');
+    }
+}

package/dist/paths/mcp.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeMcpPath = getNativeMcpPath;
+exports.readNativeMcp = readNativeMcp;
+exports.writeNativeMcp = writeNativeMcp;
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+/** Determine the native MCP config path for a given agent. */
+async function getNativeMcpPath(adapterName, projectRoot) {
+    const candidates = [];
+    switch (adapterName) {
+        case 'GitHub Copilot':
+            candidates.push(path.join(projectRoot, '.vscode', 'mcp.json'));
+            break;
+        case 'Visual Studio':
+            candidates.push(path.join(projectRoot, '.mcp.json'));
+            candidates.push(path.join(projectRoot, '.vs', 'mcp.json'));
+            break;
+        case 'Cursor':
+            candidates.push(path.join(projectRoot, '.cursor', 'mcp.json'));
+            break;
+        case 'Windsurf':
+            candidates.push(path.join(projectRoot, '.windsurf', 'mcp_config.json'));
+            break;
+        case 'Claude Code':
+            candidates.push(path.join(projectRoot, '.mcp.json'));
+            break;
+        case 'OpenAI Codex CLI':
+            candidates.push(path.join(projectRoot, '.codex', 'config.toml'));
+            break;
+        case 'Aider':
+            candidates.push(path.join(projectRoot, '.mcp.json'));
+            break;
+        case 'Open Hands':
+            // For Open Hands, we target the main config file, not a separate mcp.json
+            candidates.push(path.join(projectRoot, 'config.toml'));
+            break;
+        case 'Gemini CLI':
+            candidates.push(path.join(projectRoot, '.gemini', 'settings.json'));
+            break;
+        case 'Qwen Code':
+            candidates.push(path.join(projectRoot, '.qwen', 'settings.json'));
+            break;
+        case 'Kilo Code':
+            candidates.push(path.join(projectRoot, '.kilocode', 'mcp.json'));
+            break;
+        case 'OpenCode':
+            candidates.push(path.join(projectRoot, 'opencode.json'));
+            break;
+        case 'Firebase Studio':
+            candidates.push(path.join(projectRoot, '.idx', 'mcp.json'));
+            break;
+        case 'Zed':
+            // Only consider project-local Zed settings (avoid writing to user home directory)
+            candidates.push(path.join(projectRoot, '.zed', 'settings.json'));
+            break;
+        default:
+            return null;
+    }
+    for (const p of candidates) {
+        try {
+            await fs_1.promises.access(p);
+            return p;
+        }
+        catch {
+            // continue
+        }
+    }
+    // default to first candidate if none exist
+    return candidates.length > 0 ? candidates[0] : null;
+}
+/** Read native MCP config from disk, or return empty object if missing/invalid. */
+async function readNativeMcp(filePath) {
+    try {
+        const text = await fs_1.promises.readFile(filePath, 'utf8');
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+/** Write native MCP config to disk, creating parent directories as needed. */
+async function writeNativeMcp(filePath, data) {
+    await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const text = JSON.stringify(data, null, 2) + '\n';
+    await fs_1.promises.writeFile(filePath, text, 'utf8');
+}