@sureliving/n8n-nodes-claudecode 0.1.0

package/dist/nodes/ClaudeCode/ClaudeCode.node.js

@@ -0,0 +1,690 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+function buildSanitizedEnv(overrides) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value !== 'string')
+            continue;
+        env[key] = value;
+    }
+    const authKeysToStrip = [
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_TOKEN',
+        'CLAUDE_API_KEY',
+        'CLAUDE_CODE_OAUTH_TOKEN',
+        'CLAUDE_CODE_SESSION_TOKEN',
+    ];
+    for (const k of authKeysToStrip)
+        delete env[k];
+    for (const [k, v] of Object.entries(overrides)) {
+        if (typeof v === 'string' && v.length > 0)
+            env[k] = v;
+    }
+    return env;
+}
+function redactString(input, secrets) {
+    let out = input;
+    for (const secret of secrets) {
+        if (!secret)
+            continue;
+        out = out.split(secret).join('***REDACTED***');
+    }
+    return out;
+}
+function redactSecretsDeep(value, secrets) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string')
+        return redactString(value, secrets);
+    if (typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => redactSecretsDeep(v, secrets));
+    const obj = value;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        out[k] = redactSecretsDeep(v, secrets);
+    }
+    return out;
+}
+class ClaudeCode {
+    constructor() {
+        this.description = {
+            displayName: 'Claude Code',
+            name: 'claudeCode',
+            icon: 'file:claudecode.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["prompt"]}}',
+            description: 'Use Claude Code SDK to execute AI-powered coding tasks with customizable tool support',
+            defaults: {
+                name: 'Claude Code',
+            },
+            credentials: [
+                {
+                    name: 'anthropicApi',
+                    required: true,
+                },
+            ],
+            inputs: [{ type: "main" }],
+            outputs: [{ type: "main" }],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Query',
+                            value: 'query',
+                            description: 'Start a new conversation with Claude Code',
+                            action: 'Start a new conversation with claude code',
+                        },
+                        {
+                            name: 'Continue',
+                            value: 'continue',
+                            description: 'Continue a previous conversation (requires prior query)',
+                            action: 'Continue a previous conversation requires prior query',
+                        },
+                    ],
+                    default: 'query',
+                },
+                {
+                    displayName: 'Prompt',
+                    name: 'prompt',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    description: 'The prompt or instruction to send to Claude Code',
+                    required: true,
+                    placeholder: 'e.g., "Create a Python function to parse CSV files"',
+                    hint: 'Use expressions like {{$json.prompt}} to use data from previous nodes',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Sonnet',
+                            value: 'sonnet',
+                            description: 'Fast and efficient model for most tasks',
+                        },
+                        {
+                            name: 'Opus',
+                            value: 'opus',
+                            description: 'Most capable model for complex tasks',
+                        },
+                    ],
+                    default: 'sonnet',
+                    description: 'Claude model to use',
+                },
+                {
+                    displayName: 'Max Turns',
+                    name: 'maxTurns',
+                    type: 'number',
+                    default: 25,
+                    description: 'Maximum number of conversation turns (back-and-forth exchanges) allowed. Complex tasks may require more turns.',
+                },
+                {
+                    displayName: 'Timeout',
+                    name: 'timeout',
+                    type: 'number',
+                    default: 300,
+                    description: 'Maximum time to wait for completion (in seconds) before aborting',
+                },
+                {
+                    displayName: 'Project Path',
+                    name: 'projectPath',
+                    type: 'string',
+                    default: '',
+                    description: 'The directory path where Claude Code should run (e.g., /path/to/project). If empty, uses the current working directory.',
+                    placeholder: '/home/user/projects/my-app',
+                    hint: 'This sets the working directory for Claude Code, allowing it to access files and run commands in the specified project location',
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormat',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Structured',
+                            value: 'structured',
+                            description: 'Returns a structured object with messages, summary, result, and metrics',
+                        },
+                        {
+                            name: 'Messages',
+                            value: 'messages',
+                            description: 'Returns the raw array of all messages exchanged',
+                        },
+                        {
+                            name: 'Text',
+                            value: 'text',
+                            description: 'Returns only the final result text',
+                        },
+                    ],
+                    default: 'structured',
+                    description: 'Choose how to format the output data',
+                },
+                {
+                    displayName: 'Allowed Tools',
+                    name: 'allowedTools',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Bash', value: 'Bash', description: 'Execute bash commands' },
+                        { name: 'Edit', value: 'Edit', description: 'Edit files' },
+                        { name: 'Exit Plan Mode', value: 'exit_plan_mode', description: 'Exit planning mode' },
+                        { name: 'Glob', value: 'Glob', description: 'Find files by pattern' },
+                        { name: 'Grep', value: 'Grep', description: 'Search file contents' },
+                        { name: 'LS', value: 'LS', description: 'List directory contents' },
+                        { name: 'MultiEdit', value: 'MultiEdit', description: 'Make multiple edits' },
+                        { name: 'Notebook Edit', value: 'NotebookEdit', description: 'Edit Jupyter notebooks' },
+                        { name: 'Notebook Read', value: 'NotebookRead', description: 'Read Jupyter notebooks' },
+                        { name: 'Read', value: 'Read', description: 'Read file contents' },
+                        { name: 'Task', value: 'Task', description: 'Launch agents for complex searches' },
+                        { name: 'Todo Write', value: 'TodoWrite', description: 'Manage todo lists' },
+                        { name: 'Web Fetch', value: 'WebFetch', description: 'Fetch web content' },
+                        { name: 'Web Search', value: 'WebSearch', description: 'Search the web' },
+                        { name: 'Write', value: 'Write', description: 'Write files' },
+                    ],
+                    default: ['WebFetch', 'TodoWrite', 'WebSearch', 'exit_plan_mode', 'Task'],
+                    description: 'Select which built-in tools Claude Code is allowed to use during execution',
+                },
+                {
+                    displayName: 'Disallowed Tools',
+                    name: 'disallowedTools',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Bash', value: 'Bash', description: 'Execute bash commands' },
+                        { name: 'Edit', value: 'Edit', description: 'Edit files' },
+                        { name: 'Exit Plan Mode', value: 'exit_plan_mode', description: 'Exit planning mode' },
+                        { name: 'Glob', value: 'Glob', description: 'Find files by pattern' },
+                        { name: 'Grep', value: 'Grep', description: 'Search file contents' },
+                        { name: 'LS', value: 'LS', description: 'List directory contents' },
+                        { name: 'MultiEdit', value: 'MultiEdit', description: 'Make multiple edits' },
+                        { name: 'Notebook Edit', value: 'NotebookEdit', description: 'Edit Jupyter notebooks' },
+                        { name: 'Notebook Read', value: 'NotebookRead', description: 'Read Jupyter notebooks' },
+                        { name: 'Read', value: 'Read', description: 'Read file contents' },
+                        { name: 'Task', value: 'Task', description: 'Launch agents for complex searches' },
+                        { name: 'Todo Write', value: 'TodoWrite', description: 'Manage todo lists' },
+                        { name: 'Web Fetch', value: 'WebFetch', description: 'Fetch web content' },
+                        { name: 'Web Search', value: 'WebSearch', description: 'Search the web' },
+                        { name: 'Write', value: 'Write', description: 'Write files' },
+                    ],
+                    default: [],
+                    description: 'Select which built-in tools Claude Code is explicitly blocked from using. Takes precedence over Allowed Tools.',
+                },
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Debug Mode',
+                            name: 'debug',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to enable debug logging',
+                        },
+                        {
+                            displayName: 'Fallback Model',
+                            name: 'fallbackModel',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'None',
+                                    value: '',
+                                    description: 'No fallback model',
+                                },
+                                {
+                                    name: 'Sonnet',
+                                    value: 'sonnet',
+                                    description: 'Fallback to Sonnet when primary model is overloaded',
+                                },
+                                {
+                                    name: 'Opus',
+                                    value: 'opus',
+                                    description: 'Fallback to Opus when primary model is overloaded',
+                                },
+                            ],
+                            default: '',
+                            description: 'Automatically switch to fallback model when primary model is overloaded',
+                        },
+                        {
+                            displayName: 'Max Thinking Tokens',
+                            name: 'maxThinkingTokens',
+                            type: 'number',
+                            default: 0,
+                            description: 'Maximum number of thinking tokens (0 for unlimited)',
+                            hint: 'Controls how many tokens Claude can use for internal reasoning',
+                        },
+                        {
+                            displayName: 'Permission Mode',
+                            name: 'permissionMode',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Default',
+                                    value: 'default',
+                                    description: 'Standard permission prompts',
+                                },
+                                {
+                                    name: 'Accept Edits',
+                                    value: 'acceptEdits',
+                                    description: 'Automatically accept file edits',
+                                },
+                                {
+                                    name: 'Bypass Permissions',
+                                    value: 'bypassPermissions',
+                                    description: 'Skip all permission checks',
+                                },
+                                {
+                                    name: 'Plan',
+                                    value: 'plan',
+                                    description: 'Planning mode - Claude will plan before executing',
+                                },
+                            ],
+                            default: 'bypassPermissions',
+                            description: 'How to handle permission requests for tool usage',
+                        },
+                        {
+                            displayName: 'System Prompt',
+                            name: 'systemPrompt',
+                            type: 'string',
+                            typeOptions: {
+                                rows: 4,
+                            },
+                            default: '',
+                            description: 'Additional context or instructions for Claude Code',
+                            placeholder: 'You are helping with a Python project. Focus on clean, readable code with proper error handling.',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            let timeout = 300;
+            try {
+                const operation = this.getNodeParameter('operation', itemIndex);
+                const prompt = this.getNodeParameter('prompt', itemIndex);
+                const model = this.getNodeParameter('model', itemIndex);
+                const maxTurns = this.getNodeParameter('maxTurns', itemIndex);
+                timeout = this.getNodeParameter('timeout', itemIndex);
+                const projectPath = this.getNodeParameter('projectPath', itemIndex);
+                const outputFormat = this.getNodeParameter('outputFormat', itemIndex);
+                const allowedTools = this.getNodeParameter('allowedTools', itemIndex, []);
+                const disallowedTools = this.getNodeParameter('disallowedTools', itemIndex, []);
+                const additionalOptions = this.getNodeParameter('additionalOptions', itemIndex);
+                const abortController = new AbortController();
+                const timeoutMs = timeout * 1000;
+                const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+                if (!prompt || prompt.trim() === '') {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Prompt is required and cannot be empty', {
+                        itemIndex,
+                    });
+                }
+                if (additionalOptions.debug) {
+                    this.logger.debug('Starting Claude Code execution', {
+                        itemIndex,
+                        prompt: prompt.substring(0, 100) + '...',
+                        model,
+                        maxTurns,
+                        timeout: `${timeout}s`,
+                        allowedTools,
+                        disallowedTools,
+                        fallbackModel: additionalOptions.fallbackModel || 'none',
+                    });
+                }
+                const queryOptions = {
+                    prompt,
+                    abortController,
+                    options: {
+                        maxTurns,
+                        permissionMode: (additionalOptions.permissionMode || 'bypassPermissions'),
+                        model,
+                        systemPrompt: additionalOptions.systemPrompt
+                            ? { type: 'preset', preset: 'claude_code', append: additionalOptions.systemPrompt }
+                            : { type: 'preset', preset: 'claude_code' },
+                        settingSources: ['user', 'project', 'local'],
+                    },
+                };
+                const credentials = (await this.getCredentials('anthropicApi'));
+                const apiKey = (_a = credentials.apiKey) === null || _a === void 0 ? void 0 : _a.trim();
+                if (!apiKey) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Anthropic API Key credential is required', {
+                        itemIndex,
+                    });
+                }
+                const secretsToRedact = [apiKey];
+                queryOptions.options.env = buildSanitizedEnv({
+                    ANTHROPIC_API_KEY: apiKey,
+                });
+                if (projectPath && projectPath.trim() !== '') {
+                    queryOptions.options.cwd = projectPath.trim();
+                    if (additionalOptions.debug) {
+                        this.logger.debug('Working directory set', { cwd: queryOptions.options.cwd });
+                    }
+                }
+                if (allowedTools.length > 0) {
+                    queryOptions.options.allowedTools = allowedTools;
+                    if (additionalOptions.debug) {
+                        this.logger.debug('Allowed tools configured', { allowedTools });
+                    }
+                }
+                if (disallowedTools.length > 0) {
+                    queryOptions.options.disallowedTools = disallowedTools;
+                    if (additionalOptions.debug) {
+                        this.logger.debug('Disallowed tools configured', { disallowedTools });
+                    }
+                }
+                if (additionalOptions.fallbackModel) {
+                    queryOptions.options.fallbackModel = additionalOptions.fallbackModel;
+                }
+                if (additionalOptions.maxThinkingTokens && additionalOptions.maxThinkingTokens > 0) {
+                    queryOptions.options.maxThinkingTokens = additionalOptions.maxThinkingTokens;
+                }
+                if (operation === 'continue') {
+                    queryOptions.options.continue = true;
+                }
+                const messages = [];
+                const startTime = Date.now();
+                try {
+                    for await (const message of (0, claude_agent_sdk_1.query)(queryOptions)) {
+                        messages.push(message);
+                        if (additionalOptions.debug) {
+                            if (message.type === 'system' && message.subtype === 'init') {
+                                this.logger.debug('System init message', {
+                                    type: message.type,
+                                    subtype: message.subtype,
+                                    model: message.model,
+                                    toolCount: ((_b = message.tools) === null || _b === void 0 ? void 0 : _b.length) || 0,
+                                });
+                            }
+                            else if (message.type === 'assistant') {
+                                const content = (_c = message.message) === null || _c === void 0 ? void 0 : _c.content;
+                                this.logger.debug('Assistant message', {
+                                    type: message.type,
+                                    contentTypes: (content === null || content === void 0 ? void 0 : content.map((c) => c.type)) || [],
+                                    textLength: ((_e = (_d = content === null || content === void 0 ? void 0 : content.find((c) => c.type === 'text')) === null || _d === void 0 ? void 0 : _d.text) === null || _e === void 0 ? void 0 : _e.length) || 0,
+                                    hasToolUse: (content === null || content === void 0 ? void 0 : content.some((c) => c.type === 'tool_use')) || false,
+                                });
+                            }
+                            else if (message.type === 'user') {
+                                this.logger.debug('User message', {
+                                    type: message.type,
+                                    hasToolResult: !!((_g = (_f = message.message) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.some((c) => c.type === 'tool_result')),
+                                });
+                            }
+                            else if (message.type === 'result') {
+                                const resultMsg = message;
+                                this.logger.debug('Result message', {
+                                    type: message.type,
+                                    subtype: resultMsg.subtype,
+                                    hasResult: !!resultMsg.result,
+                                    hasError: !!resultMsg.error,
+                                    resultLength: resultMsg.result ? String(resultMsg.result).length : 0,
+                                    error: resultMsg.error || 'none',
+                                    duration_ms: resultMsg.duration_ms,
+                                    total_cost: resultMsg.total_cost_usd,
+                                });
+                                if (resultMsg.subtype === 'error_during_execution') {
+                                    this.logger.error('Claude Code execution error', {
+                                        subtype: resultMsg.subtype,
+                                        error: resultMsg.error,
+                                        details: JSON.stringify(resultMsg).substring(0, 500),
+                                    });
+                                }
+                            }
+                            else {
+                                this.logger.debug('Other message', {
+                                    type: message.type,
+                                    message: JSON.stringify(message).substring(0, 200),
+                                });
+                            }
+                        }
+                        if (message.type === 'assistant' && ((_h = message.message) === null || _h === void 0 ? void 0 : _h.content)) {
+                            const content = message.message.content[0];
+                            if (additionalOptions.debug) {
+                                if (content.type === 'text') {
+                                    this.logger.debug('Assistant response', {
+                                        text: content.text.substring(0, 100) + '...',
+                                    });
+                                }
+                                else if (content.type === 'tool_use') {
+                                    this.logger.debug('Tool use', { toolName: content.name });
+                                }
+                            }
+                        }
+                    }
+                    clearTimeout(timeoutId);
+                    const duration = Date.now() - startTime;
+                    if (additionalOptions.debug) {
+                        this.logger.debug('Execution completed', {
+                            durationMs: duration,
+                            messageCount: messages.length,
+                        });
+                        const messageTypes = messages.map((m) => ({
+                            type: m.type,
+                            subtype: m.subtype,
+                        }));
+                        this.logger.debug('All messages in order', { messageTypes });
+                    }
+                    if (outputFormat === 'text') {
+                        const resultMessage = messages.find((m) => m.type === 'result');
+                        if (additionalOptions.debug) {
+                            this.logger.debug('Processing text output format', {
+                                foundResultMessage: !!resultMessage,
+                                messageCount: messages.length,
+                            });
+                        }
+                        let finalText = '';
+                        let errorText = '';
+                        if (resultMessage) {
+                            if (resultMessage.result) {
+                                finalText = resultMessage.result;
+                            }
+                            else if (resultMessage.error) {
+                                errorText = resultMessage.error;
+                                finalText = `Error: ${resultMessage.error}`;
+                            }
+                            else if (resultMessage.subtype === 'error_max_turns') {
+                                errorText = 'Maximum turns reached';
+                                const assistantMessages = messages.filter((m) => { var _a; return m.type === 'assistant' && ((_a = m.message) === null || _a === void 0 ? void 0 : _a.content); });
+                                if (assistantMessages.length > 0) {
+                                    const lastMessage = assistantMessages[assistantMessages.length - 1];
+                                    const textContent = (_k = (_j = lastMessage.message) === null || _j === void 0 ? void 0 : _j.content) === null || _k === void 0 ? void 0 : _k.find((c) => c.type === 'text');
+                                    if (textContent === null || textContent === void 0 ? void 0 : textContent.text) {
+                                        finalText = `[PARTIAL - Max turns reached]\n\n${textContent.text}\n\n[Note: Task incomplete. Increase maxTurns parameter to complete.]`;
+                                    }
+                                    else {
+                                        finalText =
+                                            'Error: Maximum conversation turns reached. Consider increasing maxTurns parameter.';
+                                    }
+                                }
+                                else {
+                                    finalText =
+                                        'Error: Maximum conversation turns reached. Consider increasing maxTurns parameter.';
+                                }
+                            }
+                            else if (resultMessage.subtype === 'error_during_execution') {
+                                errorText = 'Error during execution';
+                                const assistantMessages = messages.filter((m) => { var _a; return m.type === 'assistant' && ((_a = m.message) === null || _a === void 0 ? void 0 : _a.content); });
+                                if (assistantMessages.length > 0) {
+                                    const lastMessage = assistantMessages[assistantMessages.length - 1];
+                                    const textContent = (_m = (_l = lastMessage.message) === null || _l === void 0 ? void 0 : _l.content) === null || _m === void 0 ? void 0 : _m.find((c) => c.type === 'text');
+                                    if (textContent === null || textContent === void 0 ? void 0 : textContent.text) {
+                                        finalText = `[ERROR - Execution failed]\n\n${textContent.text}\n\n[Note: An error occurred during execution. Check logs for details.]`;
+                                    }
+                                    else {
+                                        finalText = 'Error: Execution failed. Check debug logs for details.';
+                                    }
+                                }
+                                else {
+                                    finalText = 'Error: Execution failed. No output available.';
+                                }
+                            }
+                            if (additionalOptions.debug) {
+                                this.logger.debug('Result message details', {
+                                    type: resultMessage.type,
+                                    subtype: resultMessage.subtype,
+                                    hasResult: !!resultMessage.result,
+                                    hasError: !!resultMessage.error,
+                                    resultLength: resultMessage.result ? String(resultMessage.result).length : 0,
+                                    errorMessage: resultMessage.error || 'none',
+                                });
+                            }
+                        }
+                        else {
+                            const assistantMessages = messages.filter((m) => { var _a; return m.type === 'assistant' && ((_a = m.message) === null || _a === void 0 ? void 0 : _a.content); });
+                            if (assistantMessages.length > 0) {
+                                const lastMessage = assistantMessages[assistantMessages.length - 1];
+                                const textContent = (_p = (_o = lastMessage.message) === null || _o === void 0 ? void 0 : _o.content) === null || _p === void 0 ? void 0 : _p.find((c) => c.type === 'text');
+                                finalText = (textContent === null || textContent === void 0 ? void 0 : textContent.text) || '';
+                            }
+                            if (!finalText) {
+                                finalText = 'No response generated - check debug logs for details';
+                            }
+                        }
+                        const outputData = {
+                            result: redactString(String(finalText || 'No response generated'), secretsToRedact),
+                            success: (resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.subtype) === 'success' ? true : false,
+                            duration_ms: Number((resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.duration_ms) || 0),
+                            total_cost_usd: Number((resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.total_cost_usd) || 0),
+                        };
+                        if (additionalOptions.debug) {
+                            this.logger.debug('Text output format data', {
+                                outputData,
+                                resultPreview: outputData.result.substring(0, 200) +
+                                    (outputData.result.length > 200 ? '...' : ''),
+                                outputDataTypes: {
+                                    result: typeof outputData.result,
+                                    success: typeof outputData.success,
+                                    duration_ms: typeof outputData.duration_ms,
+                                    total_cost_usd: typeof outputData.total_cost_usd,
+                                },
+                            });
+                            const messageSummary = messages.reduce((acc, msg) => {
+                                acc[msg.type] = (acc[msg.type] || 0) + 1;
+                                return acc;
+                            }, {});
+                            this.logger.debug('Message summary', {
+                                messageSummary,
+                                totalMessages: messages.length,
+                                hasResultMessage: !!resultMessage,
+                                resultError: errorText || 'none',
+                            });
+                            try {
+                                JSON.stringify(outputData);
+                            }
+                            catch (e) {
+                                this.logger.error('Output data is not JSON-compatible', { error: e });
+                            }
+                        }
+                        returnData.push({
+                            json: outputData,
+                            pairedItem: { item: itemIndex },
+                        });
+                    }
+                    else if (outputFormat === 'messages') {
+                        returnData.push({
+                            json: {
+                                messages: redactSecretsDeep(messages, secretsToRedact),
+                                messageCount: messages.length,
+                            },
+                            pairedItem: { item: itemIndex },
+                        });
+                    }
+                    else if (outputFormat === 'structured') {
+                        const userMessages = messages.filter((m) => m.type === 'user');
+                        const assistantMessages = messages.filter((m) => m.type === 'assistant');
+                        const toolUses = messages.filter((m) => { var _a, _b, _c; return m.type === 'assistant' && ((_c = (_b = (_a = m.message) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.type) === 'tool_use'; });
+                        const systemInit = messages.find((m) => m.type === 'system' && m.subtype === 'init');
+                        const resultMessage = messages.find((m) => m.type === 'result');
+                        returnData.push({
+                            json: {
+                                messages: redactSecretsDeep(messages, secretsToRedact),
+                                summary: {
+                                    userMessageCount: userMessages.length,
+                                    assistantMessageCount: assistantMessages.length,
+                                    toolUseCount: toolUses.length,
+                                    hasResult: !!resultMessage,
+                                    toolsAvailable: (systemInit === null || systemInit === void 0 ? void 0 : systemInit.tools) || [],
+                                },
+                                result: redactSecretsDeep((resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.result) || (resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.error) || null, secretsToRedact),
+                                metrics: resultMessage
+                                    ? {
+                                        duration_ms: resultMessage.duration_ms,
+                                        num_turns: resultMessage.num_turns,
+                                        total_cost_usd: resultMessage.total_cost_usd,
+                                        usage: resultMessage.usage,
+                                    }
+                                    : null,
+                                success: (resultMessage === null || resultMessage === void 0 ? void 0 : resultMessage.subtype) === 'success',
+                            },
+                            pairedItem: { item: itemIndex },
+                        });
+                    }
+                }
+                catch (queryError) {
+                    clearTimeout(timeoutId);
+                    if (outputFormat === 'text') {
+                        const errorMessage = queryError instanceof Error ? queryError.message : String(queryError);
+                        returnData.push({
+                            json: {
+                                result: `Error during execution: ${errorMessage}`,
+                                success: false,
+                                duration_ms: Date.now() - startTime,
+                                total_cost_usd: 0,
+                            },
+                            pairedItem: { item: itemIndex },
+                        });
+                    }
+                    else {
+                        throw queryError;
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
+                const isTimeout = error instanceof Error && error.name === 'AbortError';
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            errorType: isTimeout ? 'timeout' : 'execution_error',
+                            errorDetails: error instanceof Error ? error.stack : undefined,
+                            itemIndex,
+                        },
+                        pairedItem: itemIndex,
+                    });
+                    continue;
+                }
+                const userFriendlyMessage = isTimeout
+                    ? `Operation timed out after ${timeout} seconds. Consider increasing the timeout in Additional Options.`
+                    : `Claude Code execution failed: ${errorMessage}`;
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), userFriendlyMessage, {
+                    itemIndex,
+                    description: errorMessage,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ClaudeCode = ClaudeCode;
+//# sourceMappingURL=ClaudeCode.node.js.map