@intellectronica/ruler 0.3.23 → 0.3.24

package/dist/agents/AbstractAgent.js

@@ -79,6 +79,13 @@ class AbstractAgent {
     supportsMcpRemote() {
         return false;
     }
+    /**
+     * Returns whether this agent supports MCP server timeout configuration.
+     * Defaults to false if not overridden.
+     */
+    supportsMcpTimeout() {
+        return false;
+    }
     /**
      * Returns whether this agent has native skills support.
      * Defaults to false if not overridden.

package/dist/agents/OpenCodeAgent.js

@@ -95,6 +95,9 @@ class OpenCodeAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsMcpTimeout() {
+        return true;
+    }
     supportsNativeSkills() {
         return true;
     }

package/dist/core/UnifiedConfigLoader.js

@@ -182,6 +182,9 @@ async function loadUnifiedConfig(options) {
                 if (serverDef.headers && typeof serverDef.headers === 'object') {
                     server.headers = Object.fromEntries(Object.entries(serverDef.headers).filter(([, v]) => typeof v === 'string'));
                 }
+                if (typeof serverDef.timeout === 'number') {
+                    server.timeout = serverDef.timeout;
+                }
                 // Validate server configuration
                 const hasCommand = !!server.command;
                 const hasUrl = !!server.url;
@@ -301,6 +304,9 @@ async function loadUnifiedConfig(options) {
                     if (def.headers && typeof def.headers === 'object') {
                         server.headers = Object.fromEntries(Object.entries(def.headers).filter(([, v]) => typeof v === 'string'));
                     }
+                    if (typeof def.timeout === 'number') {
+                        server.timeout = def.timeout;
+                    }
                     // Derive type
                     if (server.url)
                         server.type = 'remote';

package/dist/core/apply-engine.js

@@ -427,17 +427,49 @@ async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, back
         }
     }
 }
+function sanitizeMcpTimeoutsForAgent(agent, mcpJson, dryRun) {
+    if (agent.supportsMcpTimeout?.()) {
+        return mcpJson;
+    }
+    if (!mcpJson.mcpServers || typeof mcpJson.mcpServers !== 'object') {
+        return mcpJson;
+    }
+    const servers = mcpJson.mcpServers;
+    const sanitizedServers = {};
+    const strippedTimeouts = [];
+    for (const [name, serverDef] of Object.entries(servers)) {
+        if (serverDef && typeof serverDef === 'object') {
+            const copy = { ...serverDef };
+            if ('timeout' in copy) {
+                delete copy.timeout;
+                strippedTimeouts.push(name);
+            }
+            sanitizedServers[name] = copy;
+        }
+        else {
+            sanitizedServers[name] = serverDef;
+        }
+    }
+    if (strippedTimeouts.length > 0) {
+        (0, constants_1.logWarn)(`${agent.getName()} does not support MCP server timeout configuration; ignoring timeout for: ${strippedTimeouts.join(', ')}`, dryRun);
+    }
+    return {
+        ...mcpJson,
+        mcpServers: sanitizedServers,
+    };
+}
 async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup = true) {
     // Prevent writing MCP configs outside the project root (e.g., legacy home-directory targets)
     if (!dest.startsWith(projectRoot)) {
         (0, constants_1.logVerbose)(`Skipping MCP config for ${agent.getName()} because target path is outside project: ${dest}`, verbose);
         return;
     }
+    const agentMcpJson = sanitizeMcpTimeoutsForAgent(agent, filteredMcpJson, dryRun);
     if (agent.getIdentifier() === 'openhands') {
-        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenHandsMcpConfiguration(agentMcpJson, dest, dryRun, verbose, backup);
     }
     if (agent.getIdentifier() === 'opencode') {
-        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenCodeMcpConfiguration(agentMcpJson, dest, dryRun, verbose, backup);
     }
     // Agents that handle MCP configuration internally should not have external MCP handling
     if (agent.getIdentifier() === 'zed' ||
@@ -447,7 +479,7 @@ async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig,
         (0, constants_1.logVerbose)(`Skipping external MCP config for ${agent.getName()} - handled internally by agent`, verbose);
         return;
     }
-    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
+    return await applyStandardMcpConfiguration(agent, agentMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
 }
 async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
     if (dryRun) {

package/dist/mcp/propagateOpenCodeMcp.js

@@ -63,6 +63,9 @@ function transformToOpenCodeFormat(rulerMcp) {
             if (serverDef.headers) {
                 openCodeServer.headers = serverDef.headers;
             }
+            if (typeof serverDef.timeout === 'number') {
+                openCodeServer.timeout = serverDef.timeout;
+            }
         }
         else if (isLocalServer(serverDef)) {
             openCodeServer.type = 'local';
@@ -74,6 +77,9 @@ function transformToOpenCodeFormat(rulerMcp) {
             if (serverDef.env) {
                 openCodeServer.environment = serverDef.env;
             }
+            if (typeof serverDef.timeout === 'number') {
+                openCodeServer.timeout = serverDef.timeout;
+            }
         }
         else {
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellectronica/ruler",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "description": "Ruler — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "scripts": {