n8n-nodes-claude-code-cli 1.6.0 → 1.8.0

package/dist/index.js

@@ -174139,6 +174139,148 @@ var agentsDescription = [
   }
 ];
 
+// nodes/ClaudeCode/descriptions/mcpServersDescription.ts
+var mcpServersDescription = [
+  {
+    displayName: "MCP Servers",
+    name: "mcpServers",
+    type: "fixedCollection",
+    typeOptions: {
+      multipleValues: true,
+      multipleValueButtonText: "Add MCP Server"
+    },
+    default: { serversList: [] },
+    displayOptions: {
+      show: {
+        operation: ["executePrompt", "executeWithContext"]
+      }
+    },
+    options: [
+      {
+        name: "serversList",
+        displayName: "Servers",
+        values: [
+          {
+            displayName: "Server Name",
+            name: "name",
+            type: "string",
+            default: "",
+            required: true,
+            placeholder: "slack",
+            description: "Unique identifier for this MCP server."
+          },
+          {
+            displayName: "Transport Type",
+            name: "serverType",
+            type: "options",
+            options: [
+              { name: "Stdio", value: "stdio" },
+              { name: "HTTP", value: "http" }
+            ],
+            default: "stdio",
+            description: "Transport protocol for communicating with the MCP server."
+          },
+          {
+            displayName: "Command",
+            name: "command",
+            type: "string",
+            default: "",
+            required: true,
+            placeholder: "npx -y @modelcontextprotocol/server-slack",
+            description: "Full command to launch the MCP server. Arguments after the executable are automatically extracted (e.g. 'npx -y @org/server --key val' becomes command='npx', args=['-y','@org/server','--key','val']).",
+            displayOptions: {
+              show: {
+                serverType: ["stdio"]
+              }
+            }
+          },
+          {
+            displayName: "Arguments",
+            name: "args",
+            type: "string",
+            default: "",
+            placeholder: "--port,3000,--verbose",
+            description: "Comma-separated arguments to pass to the command.",
+            displayOptions: {
+              show: {
+                serverType: ["stdio"]
+              }
+            }
+          },
+          {
+            displayName: "Environment Variables",
+            name: "env",
+            type: "string",
+            typeOptions: { rows: 2 },
+            default: "",
+            placeholder: '{"SLACK_TOKEN": "xoxb-..."}',
+            description: "JSON object of environment variables for the server process.",
+            displayOptions: {
+              show: {
+                serverType: ["stdio"]
+              }
+            }
+          },
+          {
+            displayName: "URL",
+            name: "url",
+            type: "string",
+            default: "",
+            required: true,
+            placeholder: "https://mcp.example.com/sse",
+            description: "HTTP endpoint URL of the MCP server.",
+            displayOptions: {
+              show: {
+                serverType: ["http"]
+              }
+            }
+          },
+          {
+            displayName: "Headers",
+            name: "headers",
+            type: "string",
+            typeOptions: { rows: 2 },
+            default: "",
+            placeholder: '{"Authorization": "Bearer ..."}',
+            description: "JSON object of HTTP headers to send with requests.",
+            displayOptions: {
+              show: {
+                serverType: ["http"]
+              }
+            }
+          }
+        ]
+      }
+    ],
+    description: "Define MCP servers to inject into the Claude Code session. Servers provide external tools (Slack, GitHub, databases, etc.)."
+  },
+  {
+    displayName: "MCP Config File Paths",
+    name: "mcpConfigFilePaths",
+    type: "string",
+    default: "",
+    placeholder: "/path/to/mcp-config.json, /path/to/another.json",
+    description: "Comma-separated file paths to MCP configuration files. Each file is passed as a separate --mcp-config argument.",
+    displayOptions: {
+      show: {
+        operation: ["executePrompt", "executeWithContext"]
+      }
+    }
+  },
+  {
+    displayName: "MCP Strict Mode",
+    name: "mcpStrictMode",
+    type: "boolean",
+    default: false,
+    description: "Whether to enable strict MCP config mode. When enabled, Claude Code will fail if any MCP server cannot be started.",
+    displayOptions: {
+      show: {
+        operation: ["executePrompt", "executeWithContext"]
+      }
+    }
+  }
+];
+
 // nodes/ClaudeCode/descriptions/optionsDescription.ts
 var optionsDescription = [
   {
@@ -174168,6 +174310,18 @@ var optionsDescription = [
         default: "json",
         description: "Output format for Claude Code response. Stream JSON captures all tool interactions as streaming events."
       },
+      {
+        displayName: "Reasoning Effort",
+        name: "effort",
+        type: "options",
+        options: [
+          { name: "Low", value: "low" },
+          { name: "Medium", value: "medium" },
+          { name: "High", value: "high" }
+        ],
+        default: "high",
+        description: "Controls the reasoning effort level. Low = fast and cheap, High = deep thinking. Useful for workflows where some tasks are simple (summary, extraction) vs complex (refactoring)."
+      },
       {
         displayName: "Max Turns",
         name: "maxTurns",
@@ -174182,6 +174336,25 @@ var optionsDescription = [
         default: 300,
         description: "Execution timeout in seconds. Maximum: 3600 (1 hour)."
       },
+      {
+        displayName: "System Prompt Mode",
+        name: "systemPromptMode",
+        type: "options",
+        options: [
+          {
+            name: "Append",
+            value: "append",
+            description: "Append to Claude Code default system prompt"
+          },
+          {
+            name: "Replace",
+            value: "replace",
+            description: "Replace the entire Claude Code default system prompt"
+          }
+        ],
+        default: "append",
+        description: "Whether to append to or replace the default Claude Code system prompt. Replace gives full control over system instructions."
+      },
       {
         displayName: "System Prompt",
         name: "systemPrompt",
@@ -174191,7 +174364,7 @@ var optionsDescription = [
         },
         default: "",
         placeholder: "You are a helpful code reviewer...",
-        description: "Additional system prompt to append to Claude Code default system prompt"
+        description: "System prompt text. Behavior depends on System Prompt Mode: Append adds to the default prompt, Replace overrides it entirely."
       },
       {
         displayName: "System Prompt File",
@@ -174199,7 +174372,7 @@ var optionsDescription = [
         type: "string",
         default: "",
         placeholder: "/path/to/system-prompt.txt",
-        description: "Path to a file containing additional system prompt text to append to Claude Code default system prompt. Use this instead of inline System Prompt for long or reusable prompts."
+        description: "Path to a file containing system prompt text. Behavior depends on System Prompt Mode: Append adds to the default prompt, Replace overrides it entirely."
       },
       {
         displayName: "Verbose",
@@ -174215,6 +174388,13 @@ var optionsDescription = [
         default: 0,
         description: "Maximum dollar amount to spend before stopping execution. 0 means unlimited. Critical for controlling costs in automated workflows."
       },
+      {
+        displayName: "Max Output Tokens",
+        name: "maxOutputTokens",
+        type: "number",
+        default: 0,
+        description: "Maximum number of tokens in the output. 0 means unlimited. Useful for controlling costs and avoiding overly long responses in automated workflows. Sets CLAUDE_CODE_MAX_OUTPUT_TOKENS environment variable."
+      },
       {
         displayName: "JSON Schema",
         name: "jsonSchema",
@@ -174312,14 +174492,25 @@ function buildCommand(options, credentials) {
     );
   }
   if (options.systemPrompt) {
-    args.push("--append-system-prompt", options.systemPrompt);
+    if (options.systemPromptMode === "replace") {
+      args.push("--system-prompt", options.systemPrompt);
+    } else {
+      args.push("--append-system-prompt", options.systemPrompt);
+    }
   }
   if (options.systemPromptFile) {
-    args.push("--append-system-prompt-file", options.systemPromptFile);
+    if (options.systemPromptMode === "replace") {
+      args.push("--system-prompt-file", options.systemPromptFile);
+    } else {
+      args.push("--append-system-prompt-file", options.systemPromptFile);
+    }
   }
   if (options.verbose && options.outputFormat !== "stream-json") {
     args.push("--verbose");
   }
+  if (options.effort && options.effort !== "high") {
+    args.push("--effort", options.effort);
+  }
   if (options.maxBudgetUsd && options.maxBudgetUsd > 0) {
     args.push("--max-budget-usd", String(options.maxBudgetUsd));
   }
@@ -174351,12 +174542,31 @@ function buildCommand(options, credentials) {
   if (options.agents && Object.keys(options.agents).length > 0) {
     args.push("--agents", JSON.stringify(options.agents));
   }
+  if (options.mcpConfig) {
+    if (options.mcpConfig.inlineServers && Object.keys(options.mcpConfig.inlineServers).length > 0) {
+      args.push(
+        "--mcp-config",
+        JSON.stringify({ mcpServers: options.mcpConfig.inlineServers })
+      );
+    }
+    if (options.mcpConfig.configFilePaths && options.mcpConfig.configFilePaths.length > 0) {
+      for (const filePath of options.mcpConfig.configFilePaths) {
+        args.push("--mcp-config", filePath);
+      }
+    }
+    if (options.mcpConfig.strictMode) {
+      args.push("--strict-mcp-config");
+    }
+  }
   if (options.additionalArgs && options.additionalArgs.length > 0) {
     args.push(...options.additionalArgs);
   }
   if (options.extendedContext === false) {
     env.CLAUDE_CODE_DISABLE_1M_CONTEXT = "1";
   }
+  if (options.maxOutputTokens && options.maxOutputTokens > 0) {
+    env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = String(options.maxOutputTokens);
+  }
   if ("envVars" in credentials && credentials.envVars) {
     const envVarsString = credentials.envVars;
     if (envVarsString && envVarsString !== "{}") {
@@ -174589,6 +174799,63 @@ function buildExecutionOptions(context, itemIndex, operation) {
       agents[agent.name] = def;
     }
   }
+  const mcpServersData = context.getNodeParameter("mcpServers", itemIndex, {
+    serversList: []
+  });
+  const mcpConfigFilePathsRaw = context.getNodeParameter(
+    "mcpConfigFilePaths",
+    itemIndex,
+    ""
+  );
+  const mcpStrictMode = context.getNodeParameter(
+    "mcpStrictMode",
+    itemIndex,
+    false
+  );
+  let mcpConfig;
+  const hasInlineServers = mcpServersData.serversList && mcpServersData.serversList.length > 0;
+  const configFilePaths = mcpConfigFilePathsRaw ? mcpConfigFilePathsRaw.split(",").map((p) => p.trim()).filter(Boolean) : [];
+  const hasConfigFiles = configFilePaths.length > 0;
+  if (hasInlineServers || hasConfigFiles || mcpStrictMode) {
+    mcpConfig = {};
+    if (hasInlineServers) {
+      mcpConfig.inlineServers = {};
+      for (const server of mcpServersData.serversList) {
+        let def;
+        if (server.serverType === "http") {
+          def = {
+            type: "http",
+            url: server.url
+          };
+          if (server.headers) {
+            def.headers = JSON.parse(server.headers);
+          }
+        } else {
+          const commandParts = server.command.split(/\s+/).filter(Boolean);
+          const executable = commandParts[0];
+          const commandArgs = commandParts.slice(1);
+          const explicitArgs = server.args ? server.args.split(",").map((a) => a.trim()).filter(Boolean) : [];
+          const allArgs = [...commandArgs, ...explicitArgs];
+          def = {
+            command: executable
+          };
+          if (allArgs.length > 0) {
+            def.args = allArgs;
+          }
+          if (server.env) {
+            def.env = JSON.parse(server.env);
+          }
+        }
+        mcpConfig.inlineServers[server.name] = def;
+      }
+    }
+    if (hasConfigFiles) {
+      mcpConfig.configFilePaths = configFilePaths;
+    }
+    if (mcpStrictMode) {
+      mcpConfig.strictMode = true;
+    }
+  }
   return {
     prompt,
     workingDirectory: options.workingDirectory,
@@ -174603,13 +174870,17 @@ function buildExecutionOptions(context, itemIndex, operation) {
     timeout: options.timeout || 300,
     systemPrompt: options.systemPrompt || void 0,
     systemPromptFile: options.systemPromptFile || void 0,
+    systemPromptMode: options.systemPromptMode || void 0,
     verbose: options.verbose || void 0,
     maxBudgetUsd: options.maxBudgetUsd || void 0,
     jsonSchema: options.jsonSchema || void 0,
     fallbackModel: options.fallbackModel || void 0,
     agents,
+    mcpConfig,
     extendedContext: options.extendedContext !== false,
-    worktree: options.worktreeEnabled ? options.worktreeName || "" : void 0
+    worktree: options.worktreeEnabled ? options.worktreeName || "" : void 0,
+    effort: options.effort && options.effort !== "high" ? options.effort : void 0,
+    maxOutputTokens: options.maxOutputTokens || void 0
   };
 }
 
@@ -174777,9 +175048,15 @@ var LocalExecutor = class {
 };
 
 // nodes/ClaudeCode/transport/SshExecutor.ts
-var import_ssh2 = require("ssh2");
 var import_node_fs = require("node:fs");
 var import_node_os = require("node:os");
+function loadSsh2() {
+  return import("ssh2").catch(() => {
+    throw new Error(
+      'SSH transport requires the "ssh2" package. Install it with: npm install ssh2'
+    );
+  });
+}
 var SshExecutor = class {
   credentials;
   constructor(credentials) {
@@ -174831,169 +175108,190 @@ var SshExecutor = class {
    * Execute a Claude Code command via SSH
    */
   execute(options) {
-    return new Promise((resolve) => {
-      const startTime = Date.now();
-      const remoteCmd = this.buildRemoteCommand(options);
-      let sshConfig;
-      try {
-        sshConfig = this.buildSshConfig();
-      } catch (err) {
-        const duration = Date.now() - startTime;
-        resolve(createErrorResult(err.message, 1, duration));
-        return;
-      }
-      const timeoutMs = options.timeout ? options.timeout * 1e3 : 3e5;
-      let stdout = "";
-      let stderr = "";
-      let connectionClosed = false;
-      const conn = new import_ssh2.Client();
-      const connectionTimeout = setTimeout(() => {
-        if (!connectionClosed) {
-          connectionClosed = true;
-          conn.end();
-          const duration = Date.now() - startTime;
-          resolve(createErrorResult("SSH connection timeout", 1, duration));
-        }
-      }, timeoutMs);
-      conn.on("ready", () => {
-        conn.exec(remoteCmd, { pty: false }, (err, stream2) => {
-          if (err) {
-            clearTimeout(connectionTimeout);
+    const startTime = Date.now();
+    const remoteCmd = this.buildRemoteCommand(options);
+    let sshConfig;
+    try {
+      sshConfig = this.buildSshConfig();
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      return Promise.resolve(
+        createErrorResult(err.message, 1, duration)
+      );
+    }
+    return loadSsh2().then((ssh2) => {
+      return new Promise((resolve) => {
+        const timeoutMs = options.timeout ? options.timeout * 1e3 : 3e5;
+        let stdout = "";
+        let stderr = "";
+        let connectionClosed = false;
+        const conn = new ssh2.Client();
+        const connectionTimeout = setTimeout(() => {
+          if (!connectionClosed) {
             connectionClosed = true;
             conn.end();
             const duration = Date.now() - startTime;
-            resolve(
-              createErrorResult(`SSH exec error: ${err.message}`, 1, duration)
-            );
-            return;
+            resolve(createErrorResult("SSH connection timeout", 1, duration));
           }
-          let exitCode = null;
-          let streamClosed = false;
-          const handleCompletion = () => {
-            if (streamClosed && exitCode !== null && !connectionClosed) {
+        }, timeoutMs);
+        conn.on("ready", () => {
+          conn.exec(remoteCmd, { pty: false }, (err, stream2) => {
+            if (err) {
               clearTimeout(connectionTimeout);
               connectionClosed = true;
               conn.end();
               const duration = Date.now() - startTime;
-              const code = exitCode ?? 0;
-              if (options.outputFormat === "json") {
-                const parsed = parseJsonOutput(stdout);
-                resolve(normalizeOutput(parsed, code, duration, stderr));
-              } else if (options.outputFormat === "stream-json") {
-                const { events, result } = parseStreamJsonOutput(stdout);
-                resolve(
-                  normalizeStreamOutput(events, result, code, duration, stderr)
-                );
-              } else {
-                resolve({
-                  success: code === 0,
-                  sessionId: "",
-                  output: stdout,
-                  exitCode: code,
-                  duration,
-                  error: code !== 0 ? stderr : void 0
-                });
-              }
-            }
-          };
-          stream2.on("exit", (code) => {
-            exitCode = code ?? 0;
-            handleCompletion();
-          });
-          stream2.on("close", () => {
-            streamClosed = true;
-            if (exitCode === null) {
-              exitCode = 0;
+              resolve(
+                createErrorResult(
+                  `SSH exec error: ${err.message}`,
+                  1,
+                  duration
+                )
+              );
+              return;
             }
-            handleCompletion();
-          });
-          stream2.on("data", (data) => {
-            stdout += data.toString();
-          });
-          stream2.stderr.on("data", (data) => {
-            stderr += data.toString();
+            let exitCode = null;
+            let streamClosed = false;
+            const handleCompletion = () => {
+              if (streamClosed && exitCode !== null && !connectionClosed) {
+                clearTimeout(connectionTimeout);
+                connectionClosed = true;
+                conn.end();
+                const duration = Date.now() - startTime;
+                const code = exitCode ?? 0;
+                if (options.outputFormat === "json") {
+                  const parsed = parseJsonOutput(stdout);
+                  resolve(normalizeOutput(parsed, code, duration, stderr));
+                } else if (options.outputFormat === "stream-json") {
+                  const { events, result } = parseStreamJsonOutput(stdout);
+                  resolve(
+                    normalizeStreamOutput(
+                      events,
+                      result,
+                      code,
+                      duration,
+                      stderr
+                    )
+                  );
+                } else {
+                  resolve({
+                    success: code === 0,
+                    sessionId: "",
+                    output: stdout,
+                    exitCode: code,
+                    duration,
+                    error: code !== 0 ? stderr : void 0
+                  });
+                }
+              }
+            };
+            stream2.on("exit", (code) => {
+              exitCode = code ?? 0;
+              handleCompletion();
+            });
+            stream2.on("close", () => {
+              streamClosed = true;
+              if (exitCode === null) {
+                exitCode = 0;
+              }
+              handleCompletion();
+            });
+            stream2.on("data", (data) => {
+              stdout += data.toString();
+            });
+            stream2.stderr.on("data", (data) => {
+              stderr += data.toString();
+            });
+            stream2.end();
           });
-          stream2.end();
         });
+        conn.on("error", (err) => {
+          clearTimeout(connectionTimeout);
+          if (!connectionClosed) {
+            connectionClosed = true;
+            const duration = Date.now() - startTime;
+            resolve(
+              createErrorResult(
+                `SSH connection error: ${err.message}`,
+                1,
+                duration
+              )
+            );
+          }
+        });
+        conn.connect(sshConfig);
       });
-      conn.on("error", (err) => {
-        clearTimeout(connectionTimeout);
-        if (!connectionClosed) {
-          connectionClosed = true;
-          const duration = Date.now() - startTime;
-          resolve(
-            createErrorResult(
-              `SSH connection error: ${err.message}`,
-              1,
-              duration
-            )
-          );
-        }
-      });
-      conn.connect(sshConfig);
+    }).catch((err) => {
+      const duration = Date.now() - startTime;
+      return createErrorResult(err.message, 1, duration);
     });
   }
   /**
    * Test SSH connection and Claude Code availability
    */
   testConnection() {
-    return new Promise((resolve) => {
-      let sshConfig;
-      try {
-        sshConfig = this.buildSshConfig();
-      } catch {
-        resolve(false);
-        return;
-      }
-      const conn = new import_ssh2.Client();
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          conn.end();
-          resolve(false);
-        }
-      }, 1e4);
-      conn.on("ready", () => {
-        const claudePath = this.credentials.claudePath || "claude";
-        conn.exec(`${claudePath} --version`, { pty: false }, (err, stream2) => {
-          if (err) {
-            clearTimeout(timeout);
-            if (!resolved) {
-              resolved = true;
-              conn.end();
-              resolve(false);
+    let sshConfig;
+    try {
+      sshConfig = this.buildSshConfig();
+    } catch {
+      return Promise.resolve(false);
+    }
+    return loadSsh2().then((ssh2) => {
+      return new Promise((resolve) => {
+        const conn = new ssh2.Client();
+        let resolved = false;
+        const timeout = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            conn.end();
+            resolve(false);
+          }
+        }, 1e4);
+        conn.on("ready", () => {
+          const claudePath = this.credentials.claudePath || "claude";
+          conn.exec(
+            `${claudePath} --version`,
+            { pty: false },
+            (err, stream2) => {
+              if (err) {
+                clearTimeout(timeout);
+                if (!resolved) {
+                  resolved = true;
+                  conn.end();
+                  resolve(false);
+                }
+                return;
+              }
+              stream2.on("exit", (code) => {
+                clearTimeout(timeout);
+                if (!resolved) {
+                  resolved = true;
+                  conn.end();
+                  resolve(code === 0);
+                }
+              });
+              stream2.on("close", () => {
+                clearTimeout(timeout);
+                if (!resolved) {
+                  resolved = true;
+                  conn.end();
+                  resolve(true);
+                }
+              });
+              stream2.end();
             }
-            return;
+          );
+        });
+        conn.on("error", () => {
+          clearTimeout(timeout);
+          if (!resolved) {
+            resolved = true;
+            resolve(false);
           }
-          stream2.on("exit", (code) => {
-            clearTimeout(timeout);
-            if (!resolved) {
-              resolved = true;
-              conn.end();
-              resolve(code === 0);
-            }
-          });
-          stream2.on("close", () => {
-            clearTimeout(timeout);
-            if (!resolved) {
-              resolved = true;
-              conn.end();
-              resolve(true);
-            }
-          });
-          stream2.end();
         });
+        conn.connect(sshConfig);
       });
-      conn.on("error", () => {
-        clearTimeout(timeout);
-        if (!resolved) {
-          resolved = true;
-          resolve(false);
-        }
-      });
-      conn.connect(sshConfig);
-    });
+    }).catch(() => false);
   }
 };
 
@@ -175362,6 +175660,22 @@ function buildClaudeArgs(options) {
   if (options.agents && Object.keys(options.agents).length > 0) {
     args.push("--agents", JSON.stringify(options.agents));
   }
+  if (options.mcpConfig) {
+    if (options.mcpConfig.inlineServers && Object.keys(options.mcpConfig.inlineServers).length > 0) {
+      args.push(
+        "--mcp-config",
+        JSON.stringify({ mcpServers: options.mcpConfig.inlineServers })
+      );
+    }
+    if (options.mcpConfig.configFilePaths && options.mcpConfig.configFilePaths.length > 0) {
+      for (const filePath of options.mcpConfig.configFilePaths) {
+        args.push("--mcp-config", filePath);
+      }
+    }
+    if (options.mcpConfig.strictMode) {
+      args.push("--strict-mcp-config");
+    }
+  }
   if (options.additionalArgs && options.additionalArgs.length > 0) {
     args.push(...options.additionalArgs);
   }
@@ -175809,6 +176123,8 @@ var ClaudeCode = class {
       ...modelDescription,
       // Custom subagents
       ...agentsDescription,
+      // MCP servers
+      ...mcpServersDescription,
       // Additional options
       ...optionsDescription
     ]