@jnymmt/n8n-nodes-claudecode 0.1.0

package/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright 2022 n8n
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)
+
+# n8n-nodes-starter
+
+This starter repository helps you build custom integrations for [n8n](https://n8n.io). It includes example nodes, credentials, the node linter, and all the tooling you need to get started.
+
+## Quick Start
+
+> [!TIP]
+> **New to building n8n nodes?** The fastest way to get started is with `npm create @n8n/node`. This command scaffolds a complete node package for you using the [@n8n/node-cli](https://www.npmjs.com/package/@n8n/node-cli).
+
+**To create a new node package from scratch:**
+
+```bash
+npm create @n8n/node
+```
+
+**Already using this starter? Start developing with:**
+
+```bash
+npm run dev
+```
+
+This starts n8n with your nodes loaded and hot reload enabled.
+
+## What's Included
+
+This starter repository includes two example nodes to learn from:
+
+- **[Example Node](nodes/Example/)** - A simple starter node that shows the basic structure with a custom `execute` method
+- **[GitHub Issues Node](nodes/GithubIssues/)** - A complete, production-ready example built using the **declarative style**:
+  - **Low-code approach** - Define operations declaratively without writing request logic
+  - Multiple resources (Issues, Comments)
+  - Multiple operations (Get, Get All, Create)
+  - Two authentication methods (OAuth2 and Personal Access Token)
+  - List search functionality for dynamic dropdowns
+  - Proper error handling and typing
+  - Ideal for HTTP API-based integrations
+
+> [!TIP]
+> The declarative/low-code style (used in GitHub Issues) is the recommended approach for building nodes that interact with HTTP APIs. It significantly reduces boilerplate code and handles requests automatically.
+
+Browse these examples to understand both approaches, then modify them or create your own.
+
+## Finding Inspiration
+
+Looking for more examples? Check out these resources:
+
+- **[npm Community Nodes](https://www.npmjs.com/search?q=keywords:n8n-community-node-package)** - Browse thousands of community-built nodes on npm using the `n8n-community-node-package` tag
+- **[n8n Built-in Nodes](https://github.com/n8n-io/n8n/tree/master/packages/nodes-base/nodes)** - Study the source code of n8n's official nodes for production-ready patterns and best practices
+- **[n8n Credentials](https://github.com/n8n-io/n8n/tree/master/packages/nodes-base/credentials)** - See how authentication is implemented for various services
+
+These are excellent resources to understand how to structure your nodes, handle different API patterns, and implement advanced features.
+
+## Prerequisites
+
+Before you begin, install the following on your development machine:
+
+### Required
+
+- **[Node.js](https://nodejs.org/)** (v22 or higher) and npm
+  - Linux/Mac/WSL: Install via [nvm](https://github.com/nvm-sh/nvm)
+  - Windows: Follow [Microsoft's NodeJS guide](https://learn.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows)
+- **[git](https://git-scm.com/downloads)**
+
+### Recommended
+
+- Follow n8n's [development environment setup guide](https://docs.n8n.io/integrations/creating-nodes/build/node-development-environment/)
+
+> [!NOTE]
+> The `@n8n/node-cli` is included as a dev dependency and will be installed automatically when you run `npm install`. The CLI includes n8n for local development, so you don't need to install n8n globally.
+
+## Getting Started with this Starter
+
+Follow these steps to create your own n8n community node package:
+
+### 1. Create Your Repository
+
+[Generate a new repository](https://github.com/n8n-io/n8n-nodes-starter/generate) from this template, then clone it:
+
+```bash
+git clone https://github.com/<your-organization>/<your-repo-name>.git
+cd <your-repo-name>
+```
+
+### 2. Install Dependencies
+
+```bash
+npm install
+```
+
+This installs all required dependencies including the `@n8n/node-cli`.
+
+### 3. Explore the Examples
+
+Browse the example nodes in [nodes/](nodes/) and [credentials/](credentials/) to understand the structure:
+
+- Start with [nodes/Example/](nodes/Example/) for a basic node
+- Study [nodes/GithubIssues/](nodes/GithubIssues/) for a real-world implementation
+
+### 4. Build Your Node
+
+Edit the example nodes to fit your use case, or create new node files by copying the structure from [nodes/Example/](nodes/Example/).
+
+> [!TIP]
+> If you want to scaffold a completely new node package, use `npm create @n8n/node` to start fresh with the CLI's interactive generator.
+
+### 5. Configure Your Package
+
+Update `package.json` with your details:
+
+- `name` - Your package name (must start with `n8n-nodes-`)
+- `author` - Your name and email
+- `repository` - Your repository URL
+- `description` - What your node does
+
+Make sure your node is registered in the `n8n.nodes` array.
+
+### 6. Develop and Test Locally
+
+Start n8n with your node loaded:
+
+```bash
+npm run dev
+```
+
+This command runs `n8n-node dev` which:
+
+- Builds your node with watch mode
+- Starts n8n with your node available
+- Automatically rebuilds when you make changes
+- Opens n8n in your browser (usually http://localhost:5678)
+
+You can now test your node in n8n workflows!
+
+> [!NOTE]
+> Learn more about CLI commands in the [@n8n/node-cli documentation](https://www.npmjs.com/package/@n8n/node-cli).
+
+### 7. Lint Your Code
+
+Check for errors:
+
+```bash
+npm run lint
+```
+
+Auto-fix issues when possible:
+
+```bash
+npm run lint:fix
+```
+
+### 8. Build for Production
+
+When ready to publish:
+
+```bash
+npm run build
+```
+
+This compiles your TypeScript code to the `dist/` folder.
+
+### 9. Prepare for Publishing
+
+Before publishing:
+
+1. **Update documentation**: Replace this README with your node's documentation. Use [README_TEMPLATE.md](README_TEMPLATE.md) as a starting point.
+2. **Update the LICENSE**: Add your details to the [LICENSE](LICENSE.md) file.
+3. **Test thoroughly**: Ensure your node works in different scenarios.
+
+### 10. Publish to npm
+
+Publish your package to make it available to the n8n community:
+
+```bash
+npm publish
+```
+
+Learn more about [publishing to npm](https://docs.npmjs.com/packages-and-modules/contributing-packages-to-the-registry).
+
+### 11. Submit for Verification (Optional)
+
+Get your node verified for n8n Cloud:
+
+1. Ensure your node meets the [requirements](https://docs.n8n.io/integrations/creating-nodes/deploy/submit-community-nodes/):
+   - Uses MIT license ✅ (included in this starter)
+   - No external package dependencies
+   - Follows n8n's design guidelines
+   - Passes quality and security review
+
+2. Submit through the [n8n Creator Portal](https://creators.n8n.io/nodes)
+
+**Benefits of verification:**
+
+- Available directly in n8n Cloud
+- Discoverable in the n8n nodes panel
+- Verified badge for quality assurance
+- Increased visibility in the n8n community
+
+## Available Scripts
+
+This starter includes several npm scripts to streamline development:
+
+| Script                | Description                                                      |
+| --------------------- | ---------------------------------------------------------------- |
+| `npm run dev`         | Start n8n with your node and watch for changes (runs `n8n-node dev`) |
+| `npm run build`       | Compile TypeScript to JavaScript for production (runs `n8n-node build`) |
+| `npm run build:watch` | Build in watch mode (auto-rebuild on changes)                    |
+| `npm run lint`        | Check your code for errors and style issues (runs `n8n-node lint`) |
+| `npm run lint:fix`    | Automatically fix linting issues when possible (runs `n8n-node lint --fix`) |
+| `npm run release`     | Create a new release (runs `n8n-node release`)                   |
+
+> [!TIP]
+> These scripts use the [@n8n/node-cli](https://www.npmjs.com/package/@n8n/node-cli) under the hood. You can also run CLI commands directly, e.g., `npx n8n-node dev`.
+
+## Troubleshooting
+
+### My node doesn't appear in n8n
+
+1. Make sure you ran `npm install` to install dependencies
+2. Check that your node is listed in `package.json` under `n8n.nodes`
+3. Restart the dev server with `npm run dev`
+4. Check the console for any error messages
+
+### Linting errors
+
+Run `npm run lint:fix` to automatically fix most common issues. For remaining errors, check the [n8n node development guidelines](https://docs.n8n.io/integrations/creating-nodes/).
+
+### TypeScript errors
+
+Make sure you're using Node.js v22 or higher and have run `npm install` to get all type definitions.
+
+## Resources
+
+- **[n8n Node Documentation](https://docs.n8n.io/integrations/creating-nodes/)** - Complete guide to building nodes
+- **[n8n Community Forum](https://community.n8n.io/)** - Get help and share your nodes
+- **[@n8n/node-cli Documentation](https://www.npmjs.com/package/@n8n/node-cli)** - CLI tool reference
+- **[n8n Creator Portal](https://creators.n8n.io/nodes)** - Submit your node for verification
+- **[Submit Community Nodes Guide](https://docs.n8n.io/integrations/creating-nodes/deploy/submit-community-nodes/)** - Verification requirements and process
+
+## Contributing
+
+Have suggestions for improving this starter? [Open an issue](https://github.com/n8n-io/n8n-nodes-starter/issues) or submit a pull request!
+
+## License
+
+[MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

package/dist/nodes/ClaudeCode/ClaudeCode.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ClaudeCode implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

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

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCode = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const commandBuilder_1 = require("./utils/commandBuilder");
+const processRunner_1 = require("./utils/processRunner");
+const outputParser_1 = require("./utils/outputParser");
+class ClaudeCode {
+    constructor() {
+        this.description = {
+            displayName: 'Claude Code',
+            name: 'claudeCode',
+            icon: 'file:claude.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["model"] || "default"}}',
+            description: 'Execute Claude Code CLI for AI-powered coding tasks',
+            defaults: {
+                name: 'Claude Code',
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            usableAsTool: true,
+            properties: [
+                {
+                    displayName: 'Prompt',
+                    name: 'prompt',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The prompt to send to Claude Code',
+                    placeholder: 'e.g., Analyze this code and suggest improvements',
+                },
+                {
+                    displayName: 'Working Directory',
+                    name: 'workingDirectory',
+                    type: 'string',
+                    default: '',
+                    description: 'Working directory for Claude Code (leave empty to use n8n working directory)',
+                    placeholder: '/path/to/project',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    options: [
+                        { name: 'Custom', value: 'custom' },
+                        { name: 'Default', value: '' },
+                        { name: 'Haiku', value: 'haiku' },
+                        { name: 'Opus', value: 'opus' },
+                        { name: 'Sonnet', value: 'sonnet' },
+                    ],
+                    default: '',
+                    description: 'Claude model to use',
+                },
+                {
+                    displayName: 'Custom Model',
+                    name: 'customModel',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            model: ['custom'],
+                        },
+                    },
+                    description: 'Custom model name (e.g., claude-sonnet-4-20250514)',
+                    placeholder: 'claude-sonnet-4-20250514',
+                },
+                {
+                    displayName: 'System Prompt Mode',
+                    name: 'systemPromptMode',
+                    type: 'options',
+                    options: [
+                        { name: 'None', value: 'none' },
+                        { name: 'Append', value: 'append' },
+                        { name: 'Replace', value: 'replace' },
+                    ],
+                    default: 'none',
+                    description: 'How to handle system prompt',
+                },
+                {
+                    displayName: 'System Prompt',
+                    name: 'systemPrompt',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            systemPromptMode: ['append', 'replace'],
+                        },
+                    },
+                    description: 'System prompt content',
+                },
+                {
+                    displayName: 'Session Mode',
+                    name: 'sessionMode',
+                    type: 'options',
+                    options: [
+                        { name: 'New Session', value: 'new' },
+                        { name: 'Continue Last', value: 'continue' },
+                        { name: 'Resume Specific', value: 'resume' },
+                    ],
+                    default: 'new',
+                    description: 'Session management mode',
+                },
+                {
+                    displayName: 'Session ID',
+                    name: 'sessionId',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            sessionMode: ['resume'],
+                        },
+                    },
+                    description: 'Session ID to resume',
+                },
+                {
+                    displayName: 'Fork Session',
+                    name: 'forkSession',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            sessionMode: ['resume'],
+                        },
+                    },
+                    description: 'Whether to fork the session instead of resuming it',
+                },
+                {
+                    displayName: 'Tool Control',
+                    name: 'toolControl',
+                    type: 'options',
+                    options: [
+                        { name: 'Allow List', value: 'allow' },
+                        { name: 'Custom', value: 'custom' },
+                        { name: 'Default', value: 'default' },
+                        { name: 'Deny List', value: 'deny' },
+                        { name: 'None', value: 'none' },
+                        { name: 'Preset', value: 'preset' },
+                    ],
+                    default: 'default',
+                    description: 'How to control tool usage',
+                },
+                {
+                    displayName: 'Tool Preset',
+                    name: 'toolPreset',
+                    type: 'options',
+                    options: [
+                        { name: 'All Tools', value: 'default' },
+                        { name: 'Code Edit', value: 'Read,Edit,Write,Glob,Grep' },
+                        { name: 'Code Review', value: 'Read,Glob,Grep,WebSearch,WebFetch' },
+                        { name: 'Full Development', value: 'Read,Edit,Write,Bash,Glob,Grep' },
+                        { name: 'Read Only', value: 'Read,Glob,Grep' },
+                    ],
+                    default: 'Read,Glob,Grep',
+                    displayOptions: {
+                        show: {
+                            toolControl: ['preset'],
+                        },
+                    },
+                    description: 'Predefined tool combinations',
+                },
+                {
+                    displayName: 'Tools',
+                    name: 'tools',
+                    type: 'string',
+                    default: 'Read,Edit,Bash',
+                    displayOptions: {
+                        show: {
+                            toolControl: ['custom'],
+                        },
+                    },
+                    description: 'Comma-separated list of tools to enable',
+                },
+                {
+                    displayName: 'Allowed Tools',
+                    name: 'allowedTools',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            toolControl: ['allow'],
+                        },
+                    },
+                    description: 'Comma-separated patterns for allowed tools',
+                },
+                {
+                    displayName: 'Disallowed Tools',
+                    name: 'disallowedTools',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            toolControl: ['deny'],
+                        },
+                    },
+                    description: 'Comma-separated patterns for disallowed tools',
+                },
+                {
+                    displayName: 'Max Turns',
+                    name: 'maxTurns',
+                    type: 'number',
+                    default: 0,
+                    description: 'Maximum agent turns (0 = unlimited)',
+                },
+                {
+                    displayName: 'Custom Agents',
+                    name: 'customAgents',
+                    type: 'json',
+                    default: '',
+                    description: 'Custom sub-agent definitions (JSON)',
+                },
+                {
+                    displayName: 'MCP Config Path',
+                    name: 'mcpConfigPath',
+                    type: 'string',
+                    default: '',
+                    description: 'Path to MCP configuration file',
+                },
+                {
+                    displayName: 'Permission Mode',
+                    name: 'permissionMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Default', value: '' },
+                        { name: 'Plan', value: 'plan' },
+                    ],
+                    default: '',
+                    description: 'Permission mode for Claude Code',
+                },
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Additional Directories',
+                            name: 'additionalDirs',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma-separated additional working directories',
+                        },
+                        {
+                            displayName: 'Betas',
+                            name: 'betas',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma-separated beta features to enable',
+                        },
+                        {
+                            displayName: 'Debug',
+                            name: 'debug',
+                            type: 'string',
+                            default: '',
+                            description: 'Debug filter (e.g., api,mcp)',
+                        },
+                        {
+                            displayName: 'Extra CLI Flags',
+                            name: 'extraFlags',
+                            type: 'string',
+                            default: '',
+                            description: 'Additional CLI flags (advanced)',
+                        },
+                        {
+                            displayName: 'Fallback Model',
+                            name: 'fallbackModel',
+                            type: 'string',
+                            default: '',
+                            description: 'Fallback model to use if primary fails',
+                        },
+                        {
+                            displayName: 'JSON Schema',
+                            name: 'jsonSchema',
+                            type: 'json',
+                            default: '',
+                            description: 'Output JSON schema for structured responses',
+                        },
+                        {
+                            displayName: 'Skip Permissions',
+                            name: 'skipPermissions',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to skip permission checks (DANGEROUS)',
+                        },
+                        {
+                            displayName: 'Timeout (Seconds)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 300,
+                            description: 'Execution timeout in seconds',
+                        },
+                        {
+                            displayName: 'Verbose',
+                            name: 'verbose',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to enable verbose logging',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const prompt = this.getNodeParameter('prompt', itemIndex, '');
+                const workingDirectory = this.getNodeParameter('workingDirectory', itemIndex, '');
+                const model = this.getNodeParameter('model', itemIndex, '');
+                const customModel = this.getNodeParameter('customModel', itemIndex, '');
+                const systemPromptMode = this.getNodeParameter('systemPromptMode', itemIndex, 'none');
+                const systemPrompt = this.getNodeParameter('systemPrompt', itemIndex, '');
+                const sessionMode = this.getNodeParameter('sessionMode', itemIndex, 'new');
+                const sessionId = this.getNodeParameter('sessionId', itemIndex, '');
+                const forkSession = this.getNodeParameter('forkSession', itemIndex, false);
+                const toolControl = this.getNodeParameter('toolControl', itemIndex, 'default');
+                const toolPreset = this.getNodeParameter('toolPreset', itemIndex, '');
+                const tools = this.getNodeParameter('tools', itemIndex, '');
+                const allowedTools = this.getNodeParameter('allowedTools', itemIndex, '');
+                const disallowedTools = this.getNodeParameter('disallowedTools', itemIndex, '');
+                const maxTurns = this.getNodeParameter('maxTurns', itemIndex, 0);
+                const customAgents = this.getNodeParameter('customAgents', itemIndex, '');
+                const mcpConfigPath = this.getNodeParameter('mcpConfigPath', itemIndex, '');
+                const permissionMode = this.getNodeParameter('permissionMode', itemIndex, '');
+                const additionalOptions = this.getNodeParameter('additionalOptions', itemIndex, {});
+                const commandParams = {
+                    prompt,
+                    model,
+                    customModel,
+                    systemPromptMode,
+                    systemPrompt,
+                    sessionMode,
+                    sessionId,
+                    forkSession,
+                    toolControl,
+                    toolPreset,
+                    tools,
+                    allowedTools,
+                    disallowedTools,
+                    maxTurns,
+                    customAgents,
+                    mcpConfigPath,
+                    permissionMode,
+                    additionalOptions,
+                };
+                const { args, errors } = (0, commandBuilder_1.buildCommand)(commandParams);
+                if (errors.length > 0) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Parameter validation failed: ${errors.join(', ')}`);
+                }
+                const timeoutMs = (additionalOptions.timeout || 300) * 1000;
+                const processResult = await (0, processRunner_1.runProcess)(this.getNode(), args, {
+                    cwd: workingDirectory || undefined,
+                    timeout: timeoutMs,
+                });
+                const parsedOutput = (0, outputParser_1.parseOutput)(processResult.stdout);
+                returnData.push({
+                    json: {
+                        result: parsedOutput.result,
+                        sessionId: parsedOutput.sessionId,
+                        usage: parsedOutput.usage,
+                        exitCode: processResult.exitCode,
+                        raw: parsedOutput.raw,
+                        ...(parsedOutput.parseError && { parseError: parsedOutput.parseError }),
+                    },
+                    pairedItem: itemIndex,
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                        },
+                        pairedItem: itemIndex,
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ClaudeCode = ClaudeCode;
+//# sourceMappingURL=ClaudeCode.node.js.map