n8n-nodes-opencode-ai 0.1.0

package/dist/nodes/OpenCode/OpenCode.node.js

@@ -0,0 +1,787 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenCode = void 0;
+const actions_1 = require("./actions");
+class OpenCode {
+    constructor() {
+        this.description = {
+            displayName: 'OpenCode',
+            name: 'openCode',
+            icon: 'file:opencode.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Interact with OpenCode Server API for AI coding assistant sessions',
+            defaults: {
+                name: 'OpenCode',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            usableAsTool: true,
+            credentials: [
+                {
+                    name: 'openCodeApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                // Resource
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Session',
+                            value: 'session',
+                            description: 'Manage OpenCode sessions',
+                        },
+                        {
+                            name: 'Message',
+                            value: 'message',
+                            description: 'Send and receive messages',
+                        },
+                        {
+                            name: 'Config',
+                            value: 'config',
+                            description: 'Get configuration and providers',
+                        },
+                    ],
+                    default: 'session',
+                },
+                // Session Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'Get all sessions',
+                            action: 'List all sessions',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get a specific session',
+                            action: 'Get a session',
+                        },
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new session',
+                            action: 'Create a session',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a session',
+                            action: 'Delete a session',
+                        },
+                        {
+                            name: 'Abort',
+                            value: 'abort',
+                            description: 'Abort a running session',
+                            action: 'Abort a session',
+                        },
+                        {
+                            name: 'Status',
+                            value: 'status',
+                            description: 'Get status of all sessions',
+                            action: 'Get session status',
+                        },
+                    ],
+                    default: 'list',
+                },
+                // Message Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Send',
+                            value: 'send',
+                            description: 'Send a message and wait for response',
+                            action: 'Send a message',
+                        },
+                        {
+                            name: 'Send Async',
+                            value: 'sendAsync',
+                            description: 'Send a message without waiting for response',
+                            action: 'Send a message async',
+                        },
+                        {
+                            name: 'Execute Command',
+                            value: 'command',
+                            description: 'Execute a slash command',
+                            action: 'Execute a command',
+                        },
+                        {
+                            name: 'Run Shell',
+                            value: 'shell',
+                            description: 'Run a shell command',
+                            action: 'Run shell command',
+                        },
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'Get all messages in a session',
+                            action: 'List messages',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get a specific message by ID',
+                            action: 'Get a message',
+                        },
+                    ],
+                    default: 'send',
+                },
+                // Config Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['config'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Get Providers',
+                            value: 'getProviders',
+                            description: 'Get all available providers and models',
+                            action: 'Get providers',
+                        },
+                    ],
+                    default: 'getProviders',
+                },
+                // Session ID (for get, delete, abort)
+                {
+                    displayName: 'Session',
+                    name: 'sessionId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSessions',
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                            operation: ['get', 'delete', 'abort'],
+                        },
+                    },
+                    default: '',
+                    description: 'Select a session',
+                },
+                // Session Mode (for message operations)
+                {
+                    displayName: 'Session Mode',
+                    name: 'sessionMode',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync', 'command', 'shell'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Use Existing Session',
+                            value: 'existing',
+                            description: 'Use an existing session for conversations',
+                        },
+                        {
+                            name: 'Temporary Session',
+                            value: 'temporary',
+                            description: 'Create a new session for this request and delete it after response',
+                        },
+                    ],
+                    default: 'existing',
+                    description: 'Choose how to handle sessions',
+                },
+                // Session ID (for message operations - existing mode)
+                {
+                    displayName: 'Session',
+                    name: 'sessionId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSessions',
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync', 'command', 'shell'],
+                            sessionMode: ['existing'],
+                        },
+                    },
+                    default: '',
+                    description: 'Select a session for messaging',
+                },
+                // Session ID (for message list and get operation)
+                {
+                    displayName: 'Session',
+                    name: 'sessionId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getSessions',
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['list', 'get'],
+                        },
+                    },
+                    default: '',
+                    description: 'Select a session',
+                },
+                // Message ID (for get operation)
+                {
+                    displayName: 'Message ID',
+                    name: 'targetMessageId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['get'],
+                        },
+                    },
+                    default: '',
+                    description: 'The ID of the message to retrieve',
+                },
+                // Limit (for list operation)
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['list'],
+                        },
+                    },
+                    default: 50,
+                    description: 'Maximum number of messages to return',
+                },
+                // Temporary Session Title
+                {
+                    displayName: 'Temporary Session Title',
+                    name: 'tempSessionTitle',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync', 'command', 'shell'],
+                            sessionMode: ['temporary'],
+                        },
+                    },
+                    default: 'Temporary Chat Session',
+                    description: 'Title for temporary sessions (for debugging purposes)',
+                },
+                // Session Title (for create)
+                {
+                    displayName: 'Title',
+                    name: 'title',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: 'New Session',
+                    description: 'Title for the new session',
+                },
+                // Message Text
+                {
+                    displayName: 'Message',
+                    name: 'message',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync'],
+                        },
+                    },
+                    default: '',
+                    description: 'The message to send',
+                },
+                // Model Selection
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                    },
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync', 'command', 'shell'],
+                        },
+                    },
+                    default: '',
+                    description: 'Select a model (optional, uses default if not specified)',
+                },
+                // Simple Response (for send)
+                {
+                    displayName: 'Simple Response',
+                    name: 'simpleResponse',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send'],
+                        },
+                    },
+                    default: false,
+                    description: 'Whether to return only the response text (true) or full metadata (false)',
+                },
+                // Simple Response (for shell)
+                {
+                    displayName: 'Simple Response',
+                    name: 'simpleResponse',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['shell'],
+                        },
+                    },
+                    default: false,
+                    description: 'Whether to return only the shell output (true) or full metadata (false)',
+                },
+                // Command (for command operation)
+                {
+                    displayName: 'Command',
+                    name: 'command',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getCommands',
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['command'],
+                        },
+                    },
+                    default: '',
+                    description: 'Select a slash command to execute',
+                },
+                // Command Arguments (for command operation)
+                {
+                    displayName: 'Command Arguments',
+                    name: 'commandArguments',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 3,
+                    },
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['command'],
+                        },
+                    },
+                    default: '',
+                    placeholder: '{"key": "value"}',
+                    description: 'Arguments for the command in JSON format',
+                },
+                // Shell Command (for shell operation)
+                {
+                    displayName: 'Shell Command',
+                    name: 'shellCommand',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 3,
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['shell'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'ls -la',
+                    description: 'The shell command to run',
+                },
+                // Shell Agent (for shell operation)
+                {
+                    displayName: 'Agent',
+                    name: 'shellAgent',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getAgents',
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['shell'],
+                        },
+                    },
+                    default: '',
+                    description: 'Agent to use for executing the shell command',
+                },
+                // Options for send/sendAsync operations
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['send', 'sendAsync'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Timeout (ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 300000,
+                            description: 'Request timeout in milliseconds (default: 300000 = 5 minutes)',
+                        },
+                        {
+                            displayName: 'Trim Response',
+                            name: 'trimResponse',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to trim whitespace from the response text',
+                        },
+                        {
+                            displayName: 'Response Key',
+                            name: 'responseKey',
+                            type: 'string',
+                            default: 'response',
+                            description: 'The key name for the response text in the output JSON',
+                        },
+                        {
+                            displayName: 'Agent',
+                            name: 'agent',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getAgents',
+                            },
+                            default: '',
+                            description: 'Agent to use for processing the message (optional)',
+                        },
+                        {
+                            displayName: 'Reference Message ID',
+                            name: 'messageID',
+                            type: 'string',
+                            default: '',
+                            description: 'Reference message ID for context (optional)',
+                        },
+                        {
+                            displayName: 'System Prompt',
+                            name: 'system',
+                            type: 'string',
+                            typeOptions: {
+                                rows: 4,
+                            },
+                            default: '',
+                            description: 'System prompt to prepend to the message (optional)',
+                        },
+                        {
+                            displayName: 'No Reply',
+                            name: 'noReply',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to skip waiting for a response (fire and forget)',
+                        },
+                        {
+                            displayName: 'Tools (JSON)',
+                            name: 'tools',
+                            type: 'string',
+                            typeOptions: {
+                                rows: 4,
+                            },
+                            default: '',
+                            placeholder: '[{"name": "tool_name", "description": "..."}]',
+                            description: 'Tool definitions in JSON format (optional)',
+                        },
+                    ],
+                },
+                // Options for command operation
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['command'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Timeout (ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 300000,
+                            description: 'Request timeout in milliseconds (default: 300000 = 5 minutes)',
+                        },
+                        {
+                            displayName: 'Trim Response',
+                            name: 'trimResponse',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to trim whitespace from the response text',
+                        },
+                        {
+                            displayName: 'Response Key',
+                            name: 'responseKey',
+                            type: 'string',
+                            default: 'response',
+                            description: 'The key name for the response text in the output JSON',
+                        },
+                        {
+                            displayName: 'Agent',
+                            name: 'agent',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getAgents',
+                            },
+                            default: '',
+                            description: 'Agent to use for the command (optional)',
+                        },
+                        {
+                            displayName: 'Reference Message ID',
+                            name: 'messageID',
+                            type: 'string',
+                            default: '',
+                            description: 'Reference message ID for context (optional)',
+                        },
+                    ],
+                },
+                // Options for shell operation
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['message'],
+                            operation: ['shell'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Timeout (ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 300000,
+                            description: 'Request timeout in milliseconds (default: 300000 = 5 minutes)',
+                        },
+                        {
+                            displayName: 'Trim Response',
+                            name: 'trimResponse',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to trim whitespace from the response text',
+                        },
+                        {
+                            displayName: 'Response Key',
+                            name: 'responseKey',
+                            type: 'string',
+                            default: 'response',
+                            description: 'The key name for the response text in the output JSON',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getSessions() {
+                    try {
+                        const credentials = await this.getCredentials('openCodeApi');
+                        const baseUrl = credentials.baseUrl;
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${baseUrl}/session`,
+                            auth: {
+                                user: credentials.username,
+                                pass: credentials.password,
+                            },
+                            json: true,
+                        });
+                        const sessions = (Array.isArray(response) ? response : [response]);
+                        return sessions.map((session) => ({
+                            name: session.title || `Session ${session.id.substring(0, 8)}...`,
+                            value: session.id,
+                            description: `ID: ${session.id}`,
+                        }));
+                    }
+                    catch (error) {
+                        console.error('Error loading sessions:', error);
+                        return [{ name: 'Error loading sessions', value: '' }];
+                    }
+                },
+                async getModels() {
+                    try {
+                        const credentials = await this.getCredentials('openCodeApi');
+                        const baseUrl = credentials.baseUrl;
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${baseUrl}/config/providers`,
+                            auth: {
+                                user: credentials.username,
+                                pass: credentials.password,
+                            },
+                            json: true,
+                        });
+                        const options = [
+                            { name: '(Default)', value: '' },
+                        ];
+                        const providers = (response.providers || []);
+                        for (const provider of providers) {
+                            if (provider.models && typeof provider.models === 'object') {
+                                // models is an object, not an array
+                                const modelList = Object.values(provider.models);
+                                for (const model of modelList) {
+                                    // value format: providerID::modelID (use :: as separator)
+                                    options.push({
+                                        name: `${provider.name || provider.id}: ${model.name || model.id}`,
+                                        value: `${provider.id}::${model.id}`,
+                                        description: `Provider: ${provider.id}`,
+                                    });
+                                }
+                            }
+                        }
+                        return options;
+                    }
+                    catch (error) {
+                        console.error('Error loading models:', error);
+                        return [{ name: '(Default)', value: '' }];
+                    }
+                },
+                async getAgents() {
+                    try {
+                        const credentials = await this.getCredentials('openCodeApi');
+                        const baseUrl = credentials.baseUrl;
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${baseUrl}/agent`,
+                            auth: {
+                                user: credentials.username,
+                                pass: credentials.password,
+                            },
+                            json: true,
+                        });
+                        const agents = (Array.isArray(response) ? response : []);
+                        // Find primary agent
+                        const primaryAgent = agents.find((a) => a.mode === 'primary');
+                        const otherAgents = agents.filter((a) => a.mode !== 'primary');
+                        const options = [];
+                        // Add primary agent first (will be default selection)
+                        if (primaryAgent) {
+                            options.push({
+                                name: `${primaryAgent.name} (Primary)`,
+                                value: primaryAgent.name,
+                                description: 'Primary agent',
+                            });
+                        }
+                        // Add other agents
+                        for (const agent of otherAgents) {
+                            options.push({
+                                name: agent.name,
+                                value: agent.name,
+                                description: agent.mode ? `Mode: ${agent.mode}` : undefined,
+                            });
+                        }
+                        return options;
+                    }
+                    catch (error) {
+                        console.error('Error loading agents:', error);
+                        return [{ name: '(Default)', value: '' }];
+                    }
+                },
+                async getCommands() {
+                    try {
+                        const credentials = await this.getCredentials('openCodeApi');
+                        const baseUrl = credentials.baseUrl;
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${baseUrl}/command`,
+                            auth: {
+                                user: credentials.username,
+                                pass: credentials.password,
+                            },
+                            json: true,
+                        });
+                        const commands = (Array.isArray(response) ? response : []);
+                        return commands.map((cmd) => ({
+                            name: cmd.name,
+                            value: cmd.name,
+                            description: cmd.description || `Command: ${cmd.name}`,
+                        }));
+                    }
+                    catch (error) {
+                        console.error('Error loading commands:', error);
+                        return [{ name: 'Error loading commands', value: '' }];
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const results = await actions_1.executeAction.call(this, resource, operation, i);
+                returnData.push(...results);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.OpenCode = OpenCode;
+//# sourceMappingURL=OpenCode.node.js.map