n8n-nodes-claude-code-cli 1.5.0 → 1.7.0

package/dist/index.js

@@ -174003,6 +174003,284 @@ var modelDescription = [
   }
 ];
 
+// nodes/ClaudeCode/descriptions/agentsDescription.ts
+var agentsDescription = [
+  {
+    displayName: "Subagents",
+    name: "agents",
+    type: "fixedCollection",
+    typeOptions: {
+      multipleValues: true,
+      multipleValueButtonText: "Add Subagent"
+    },
+    default: { agentsList: [] },
+    displayOptions: {
+      show: {
+        operation: ["executePrompt", "executeWithContext"]
+      }
+    },
+    options: [
+      {
+        name: "agentsList",
+        displayName: "Agents",
+        values: [
+          {
+            displayName: "Agent Name",
+            name: "name",
+            type: "string",
+            default: "",
+            required: true,
+            placeholder: "code-reviewer",
+            description: "Unique identifier for this agent. Lowercase letters, numbers, and hyphens only (3-50 chars)."
+          },
+          {
+            displayName: "Description",
+            name: "description",
+            type: "string",
+            typeOptions: { rows: 2 },
+            default: "",
+            required: true,
+            placeholder: "Expert code reviewer. Use proactively when code changes are made.",
+            description: "When Claude should delegate to this agent."
+          },
+          {
+            displayName: "System Prompt",
+            name: "prompt",
+            type: "string",
+            typeOptions: { rows: 5 },
+            default: "",
+            required: true,
+            placeholder: "You are a senior code reviewer. Focus on...",
+            description: "System prompt governing this agent's behavior."
+          },
+          {
+            displayName: "Model",
+            name: "model",
+            type: "options",
+            options: [
+              {
+                name: "Inherit (Parent Model)",
+                value: "inherit"
+              },
+              { name: "Sonnet", value: "sonnet" },
+              { name: "Opus", value: "opus" },
+              { name: "Haiku", value: "haiku" }
+            ],
+            default: "inherit",
+            description: "Model to use for this agent."
+          },
+          {
+            displayName: "Allowed Tools",
+            name: "tools",
+            type: "string",
+            default: "",
+            placeholder: "Read, Grep, Glob, Bash(git:*)",
+            description: "Tools this agent can use (comma-separated). Leave empty to inherit all tools."
+          },
+          {
+            displayName: "Disallowed Tools",
+            name: "disallowedTools",
+            type: "string",
+            default: "",
+            placeholder: "Write, Edit, Bash(rm:*)",
+            description: "Tools this agent cannot use (comma-separated). Takes precedence over allowed tools."
+          },
+          {
+            displayName: "Permission Mode",
+            name: "permissionMode",
+            type: "options",
+            options: [
+              { name: "Default", value: "" },
+              { name: "Accept Edits", value: "acceptEdits" },
+              { name: "Plan (Read-Only)", value: "plan" },
+              { name: "Don't Ask", value: "dontAsk" },
+              {
+                name: "Bypass Permissions",
+                value: "bypassPermissions"
+              },
+              { name: "Delegate", value: "delegate" }
+            ],
+            default: "",
+            description: "Permission mode for this agent. Leave empty to use default."
+          },
+          {
+            displayName: "Max Turns",
+            name: "maxTurns",
+            type: "number",
+            default: 0,
+            description: "Maximum agentic turns before stopping. 0 = unlimited."
+          },
+          {
+            displayName: "Memory",
+            name: "memory",
+            type: "options",
+            options: [
+              { name: "None", value: "" },
+              {
+                name: "User (Cross-Project)",
+                value: "user"
+              },
+              {
+                name: "Project (Shareable)",
+                value: "project"
+              },
+              {
+                name: "Local (Not Committed)",
+                value: "local"
+              }
+            ],
+            default: "",
+            description: "Memory persistence mode for this agent."
+          }
+        ]
+      }
+    ],
+    description: "Define custom subagents that Claude can delegate to during execution. Useful for specialized workflows (reviewer, debugger, architect...)."
+  }
+];
+
+// 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 = [
   {
@@ -174057,6 +174335,74 @@ var optionsDescription = [
         placeholder: "You are a helpful code reviewer...",
         description: "Additional system prompt to append to Claude Code default system prompt"
       },
+      {
+        displayName: "System Prompt File",
+        name: "systemPromptFile",
+        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."
+      },
+      {
+        displayName: "Verbose",
+        name: "verbose",
+        type: "boolean",
+        default: false,
+        description: "Enable verbose logging. Automatically enabled when Output Format is Stream JSON. Useful for debugging in JSON or Text output modes."
+      },
+      {
+        displayName: "Max Budget (USD)",
+        name: "maxBudgetUsd",
+        type: "number",
+        default: 0,
+        description: "Maximum dollar amount to spend before stopping execution. 0 means unlimited. Critical for controlling costs in automated workflows."
+      },
+      {
+        displayName: "JSON Schema",
+        name: "jsonSchema",
+        type: "string",
+        typeOptions: {
+          rows: 4
+        },
+        default: "",
+        placeholder: '{"type":"object","properties":{"summary":{"type":"string"}}}',
+        description: "JSON schema for validated structured output. Claude will return JSON matching this schema. Must be a valid JSON schema string."
+      },
+      {
+        displayName: "Fallback Model",
+        name: "fallbackModel",
+        type: "string",
+        default: "",
+        placeholder: "claude-sonnet-4-20250514",
+        description: "Fallback model to use when the primary model is overloaded or unavailable. Improves resilience in production workflows."
+      },
+      {
+        displayName: "Extended Context (1M Tokens)",
+        name: "extendedContext",
+        type: "boolean",
+        default: true,
+        description: "Enable 1M token context window for analyzing very large codebases in a single pass. Only supported by Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, and Sonnet 4. Has no effect on other models."
+      },
+      {
+        displayName: "Worktree Isolation",
+        name: "worktreeEnabled",
+        type: "boolean",
+        default: false,
+        description: "Run Claude Code in an isolated git worktree. Each execution works on a separate copy of the repository, preventing conflicts with the main workspace. The worktree is automatically cleaned up if no changes are made."
+      },
+      {
+        displayName: "Worktree Name",
+        name: "worktreeName",
+        type: "string",
+        default: "",
+        placeholder: "feature-auth",
+        description: "Optional name for the worktree. If empty, Claude Code auto-generates a unique name. The worktree is created at <repo>/.claude/worktrees/<name>/.",
+        displayOptions: {
+          show: {
+            worktreeEnabled: [true]
+          }
+        }
+      },
       {
         displayName: "Additional Arguments",
         name: "additionalArgs",
@@ -174110,6 +174456,28 @@ function buildCommand(options, credentials) {
   if (options.systemPrompt) {
     args.push("--append-system-prompt", options.systemPrompt);
   }
+  if (options.systemPromptFile) {
+    args.push("--append-system-prompt-file", options.systemPromptFile);
+  }
+  if (options.verbose && options.outputFormat !== "stream-json") {
+    args.push("--verbose");
+  }
+  if (options.maxBudgetUsd && options.maxBudgetUsd > 0) {
+    args.push("--max-budget-usd", String(options.maxBudgetUsd));
+  }
+  if (options.jsonSchema) {
+    args.push("--json-schema", options.jsonSchema);
+  }
+  if (options.fallbackModel) {
+    args.push("--fallback-model", options.fallbackModel);
+  }
+  if (options.worktree !== void 0) {
+    if (options.worktree) {
+      args.push("--worktree", options.worktree);
+    } else {
+      args.push("--worktree");
+    }
+  }
   if (options.contextFiles && options.contextFiles.length > 0) {
     const uniqueDirs = /* @__PURE__ */ new Set();
     options.contextFiles.forEach((file) => {
@@ -174122,9 +174490,31 @@ function buildCommand(options, credentials) {
       args.push("--add-dir", dir);
     });
   }
+  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 ("envVars" in credentials && credentials.envVars) {
     const envVarsString = credentials.envVars;
     if (envVarsString && envVarsString !== "{}") {
@@ -174325,6 +174715,95 @@ function buildExecutionOptions(context, itemIndex, operation) {
     "default"
   );
   const permissionMode = permissionModeRaw && permissionModeRaw !== "default" ? permissionModeRaw : void 0;
+  const agentsData = context.getNodeParameter("agents", itemIndex, {
+    agentsList: []
+  });
+  let agents;
+  if (agentsData.agentsList && agentsData.agentsList.length > 0) {
+    agents = {};
+    for (const agent of agentsData.agentsList) {
+      const def = {
+        description: agent.description,
+        prompt: agent.prompt
+      };
+      if (agent.tools) {
+        def.tools = agent.tools.split(",").map((t) => t.trim()).filter(Boolean);
+      }
+      if (agent.disallowedTools) {
+        def.disallowedTools = agent.disallowedTools.split(",").map((t) => t.trim()).filter(Boolean);
+      }
+      if (agent.model && agent.model !== "inherit") {
+        def.model = agent.model;
+      }
+      if (agent.permissionMode) {
+        def.permissionMode = agent.permissionMode;
+      }
+      if (agent.maxTurns && agent.maxTurns > 0) {
+        def.maxTurns = agent.maxTurns;
+      }
+      if (agent.memory) {
+        def.memory = agent.memory;
+      }
+      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,
@@ -174337,7 +174816,16 @@ function buildExecutionOptions(context, itemIndex, operation) {
     contextFiles,
     additionalArgs: additionalArgs.length > 0 ? additionalArgs : void 0,
     timeout: options.timeout || 300,
-    systemPrompt: options.systemPrompt || void 0
+    systemPrompt: options.systemPrompt || void 0,
+    systemPromptFile: options.systemPromptFile || 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
   };
 }
 
@@ -174949,6 +175437,12 @@ function buildEphemeralPodSpec(credentials, options, podName) {
   const claudeArgs = buildClaudeArgs(options);
   const envVars = buildEnvVars(credentials);
   const limits = buildResourceLimits(credentials);
+  if (options.extendedContext === false) {
+    envVars.push({
+      name: "CLAUDE_CODE_DISABLE_1M_CONTEXT",
+      value: "1"
+    });
+  }
   const credentialPrefix = buildCredentialInjectionPrefix(credentials);
   const container = credentialPrefix ? {
     name: "claude-code",
@@ -175081,6 +175575,25 @@ function buildClaudeArgs(options) {
       args.push("--add-dir", dir);
     });
   }
+  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);
   }
@@ -175377,10 +175890,11 @@ var K8sPersistentExecutor = class {
         const claudePath = this.credentials.claudePath || "claude";
         const claudeArgs = buildClaudeArgs(options);
         const workDir = options.workingDirectory || this.credentials.defaultWorkingDir || "/workspace";
+        const envPrefix = options.extendedContext === false ? "export CLAUDE_CODE_DISABLE_1M_CONTEXT=1 && " : "";
         const command = [
           "sh",
           "-c",
-          `cd ${workDir} && ${claudePath} ${claudeArgs.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ")}`
+          `${envPrefix}cd ${workDir} && ${claudePath} ${claudeArgs.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ")}`
         ];
         return this.execInPod(clients, namespace, command).then(
           ({ stdout, stderr, exitCode }) => {
@@ -175525,6 +176039,10 @@ var ClaudeCode = class {
       ...toolPermissionsDescription,
       // Model selection
       ...modelDescription,
+      // Custom subagents
+      ...agentsDescription,
+      // MCP servers
+      ...mcpServersDescription,
       // Additional options
       ...optionsDescription
     ]