@lhi/n8m 0.1.0

package/dist/utils/config.js

@@ -0,0 +1,25 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+export class ConfigManager {
+    static configDir = path.join(os.homedir(), '.n8m');
+    static configFile = path.join(os.homedir(), '.n8m', 'config.json');
+    static async load() {
+        try {
+            const data = await fs.readFile(this.configFile, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return {};
+        }
+    }
+    static async save(config) {
+        await fs.mkdir(this.configDir, { recursive: true });
+        const existing = await this.load();
+        const merged = { ...existing, ...config };
+        await fs.writeFile(this.configFile, JSON.stringify(merged, null, 2));
+    }
+    static async clear() {
+        await fs.writeFile(this.configFile, JSON.stringify({}, null, 2));
+    }
+}

package/dist/utils/multilinePrompt.d.ts

@@ -0,0 +1 @@
+export declare function promptMultiline(message?: string): Promise<string>;

package/dist/utils/multilinePrompt.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, render, useApp } from 'ink';
+import TextInput from 'ink-text-input';
+import { MultilineInput } from 'ink-multiline-input';
+const SmartPromptElement = ({ onDone, title }) => {
+    const [mode, setMode] = useState('single');
+    const [value, setValue] = useState('');
+    const [multiValue, setMultiValue] = useState('');
+    const { exit } = useApp();
+    const handleSingleSubmit = (text) => {
+        if (text.trim() === '```') {
+            setMode('multi');
+        }
+        else if (text.trim().length > 0) {
+            onDone(text.trim());
+            exit();
+        }
+        // If empty, do nothing (stays open)
+    };
+    const handleMultiSubmit = (text) => {
+        // End with ``` to submit
+        if (text.trim().endsWith('```')) {
+            const finalValue = text.trim();
+            const cleaned = finalValue.slice(0, -3).trim();
+            if (cleaned.length > 0) {
+                onDone(cleaned);
+                exit();
+                return;
+            }
+        }
+        setMultiValue(text + '\n');
+    };
+    if (mode === 'single') {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "? " }), _jsxs(Text, { bold: true, children: [title || 'Describe the workflow (use ``` for multiline): ', " "] }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: handleSingleSubmit })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u2714 " }), _jsxs(Text, { bold: true, children: [title || 'Describe the workflow (use ``` for multiline): ', " "] }), _jsx(Text, { color: "cyan", children: "```" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", children: "Entering multiline mode. Type ``` on a new line to finish." }) }), _jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsx(Text, { color: "gray", children: "\u2503 " }), _jsx(Box, { flexGrow: 1, children: _jsx(MultilineInput, { value: multiValue, onChange: setMultiValue, onSubmit: handleMultiSubmit, rows: 5, maxRows: 15, keyBindings: {
+                                submit: (key) => key.return && !key.shift,
+                                newline: (key) => key.return && key.shift
+                            } }) })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", dimColor: true, children: "Arrows: Navigate | Enter: Submit (if ends with ```) | Shift+Enter: Newline" }) })] }));
+};
+export async function promptMultiline(message) {
+    return new Promise((resolve) => {
+        let result = '';
+        const instance = render(_jsx(SmartPromptElement, { onDone: (val) => {
+                result = val;
+            }, title: message }));
+        instance.waitUntilExit().then(() => {
+            resolve(result);
+        });
+    });
+}

package/dist/utils/n8nClient.d.ts

@@ -0,0 +1,97 @@
+export interface N8nClientConfig {
+    apiUrl?: string;
+    apiKey?: string;
+}
+export interface WorkflowExecutionResult {
+    executionId: string;
+    finished: boolean;
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export interface WorkflowValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * n8n API Client
+ *
+ * Handles authentication and environment variables automatically.
+ * Follows @typescript-expert patterns for robust error handling and type safety.
+ */
+export declare class N8nClient {
+    private apiUrl;
+    private apiKey;
+    private headers;
+    constructor(config?: N8nClientConfig);
+    /**
+     * Activate a workflow
+     */
+    activateWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Deactivate a workflow
+     */
+    deactivateWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Execute a workflow and return the result
+     */
+    executeWorkflow(workflowId: string, _data?: unknown): Promise<WorkflowExecutionResult>;
+    /**
+     * Get workflow execution details and logs
+     */
+    getExecution(executionId: string): Promise<unknown>;
+    /**
+     * Get executions for a workflow
+     */
+    getWorkflowExecutions(workflowId: string): Promise<any[]>;
+    /**
+     * Update a workflow JSON
+     */
+    updateWorkflow(workflowId: string, workflowData: unknown): Promise<void>;
+    /**
+     * Get workflow by ID
+     */
+    getWorkflow(workflowId: string): Promise<unknown>;
+    /**
+     * Create a new workflow
+     */
+    createWorkflow(name: string, workflowData: unknown): Promise<{
+        id: string;
+    }>;
+    /**
+     * Get all installed node types via Probe Workflow (Webhook)
+     *
+     * Strategy:
+     * 1. Create a workflow with Webhook -> HTTP Request (Internal API)
+     * 2. Activate it
+     * 3. Call the webhook -> Returns the node types
+     */
+    /**
+     * Get all installed node types via Probe Workflow (Webhook)
+     * Returns full node type objects including parameters, not just names.
+     */
+    getNodeTypes(): Promise<any[]>;
+    /**
+     * Get all workflows
+     */
+    getWorkflows(): Promise<{
+        id: string;
+        name: string;
+        active: boolean;
+        updatedAt: string;
+    }[]>;
+    /**
+     * Delete a workflow
+     */
+    deleteWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Inject a trigger node to satisfy activation requirements.
+     * Uses a Webhook to allow actual activation (Manual triggers don't allow activation).
+     */
+    injectManualTrigger(workflowData: any): any;
+    /**
+     * Get n8n instance deep link for a workflow
+     */
+    getWorkflowLink(workflowId: string): string;
+}

package/dist/utils/n8nClient.js

@@ -0,0 +1,440 @@
+/**
+ * n8n API Client
+ *
+ * Handles authentication and environment variables automatically.
+ * Follows @typescript-expert patterns for robust error handling and type safety.
+ */
+export class N8nClient {
+    apiUrl;
+    apiKey;
+    headers;
+    constructor(config) {
+        // Priority: Explicit Config > Environment > Defaults
+        this.apiUrl = config?.apiUrl ?? process.env.N8N_API_URL ?? 'http://localhost:5678/api/v1';
+        this.apiKey = config?.apiKey ?? process.env.N8N_API_KEY ?? '';
+        // Constructor validation moved to method call time to allow lazy loading
+        // from config file if not provided here. 
+        this.headers = {
+            'Content-Type': 'application/json',
+            'X-N8N-API-KEY': this.apiKey,
+        };
+    }
+    /**
+     * Activate a workflow
+     */
+    async activateWorkflow(workflowId) {
+        const response = await fetch(`${this.apiUrl}/workflows/${workflowId}/activate`, {
+            headers: this.headers,
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to activate workflow: ${response.status} - ${errorText}`);
+        }
+    }
+    /**
+     * Deactivate a workflow
+     */
+    async deactivateWorkflow(workflowId) {
+        const response = await fetch(`${this.apiUrl}/workflows/${workflowId}/deactivate`, {
+            headers: this.headers,
+            method: 'POST',
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to deactivate workflow: ${response.status} - ${errorText}`);
+        }
+    }
+    /**
+     * Execute a workflow and return the result
+     */
+    async executeWorkflow(workflowId, _data) {
+        try {
+            // NOTE: Public API does not always expose a direct 'execute' endpoint for all workflow types.
+            // For validation purposes, we 'activate' the workflow which runs internal validation.
+            const response = await fetch(`${this.apiUrl}/workflows/${workflowId}/activate`, {
+                headers: this.headers,
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`n8n Validation Error: ${response.status} - ${errorText}`);
+            }
+            // If activation succeeds, we assume basic validation passed.
+            const result = await response.json();
+            return {
+                data: result,
+                error: undefined,
+                executionId: 'val-' + Math.random().toString(36).substring(7),
+                finished: true,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to validate workflow: ${error.message}`);
+        }
+    }
+    /**
+     * Get workflow execution details and logs
+     */
+    async getExecution(executionId) {
+        try {
+            const response = await fetch(`${this.apiUrl}/executions/${executionId}?includeData=true`, {
+                headers: this.headers,
+                method: 'GET',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to get execution: ${response.status}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch execution: ${error.message}`);
+        }
+    }
+    /**
+     * Get executions for a workflow
+     */
+    async getWorkflowExecutions(workflowId) {
+        try {
+            const url = new URL(`${this.apiUrl}/executions`);
+            url.searchParams.set('workflowId', workflowId);
+            url.searchParams.set('limit', '5');
+            const response = await fetch(url.toString(), {
+                headers: this.headers,
+                method: 'GET',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to get executions: ${response.status}`);
+            }
+            const result = await response.json();
+            return result.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workflow executions: ${error.message}`);
+        }
+    }
+    /**
+     * Update a workflow JSON
+     */
+    async updateWorkflow(workflowId, workflowData) {
+        try {
+            const response = await fetch(`${this.apiUrl}/workflows/${workflowId}`, {
+                body: JSON.stringify(workflowData),
+                headers: this.headers,
+                method: 'PUT',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Failed to update workflow: ${response.status} - ${errorText}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to update workflow: ${error.message}`);
+        }
+    }
+    /**
+     * Get workflow by ID
+     */
+    async getWorkflow(workflowId) {
+        try {
+            const response = await fetch(`${this.apiUrl}/workflows/${workflowId}`, {
+                headers: this.headers,
+                method: 'GET',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to get workflow: ${response.status}`);
+            }
+            return response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workflow: ${error.message}`);
+        }
+    }
+    /**
+     * Create a new workflow
+     */
+    async createWorkflow(name, workflowData) {
+        try {
+            const payload = {
+                name,
+                ...workflowData,
+            };
+            // Debug logging for payload validation errors
+            // console.log('DEBUG: createWorkflow payload keys:', Object.keys(payload));
+            const response = await fetch(`${this.apiUrl}/workflows`, {
+                body: JSON.stringify(payload),
+                headers: this.headers,
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Failed to create workflow: ${response.status} - ${errorText}`);
+            }
+            const result = await response.json();
+            return { id: result.id };
+        }
+        catch (error) {
+            throw new Error(`Failed to create workflow: ${error.message}`);
+        }
+    }
+    /**
+     * Get all installed node types via Probe Workflow (Webhook)
+     *
+     * Strategy:
+     * 1. Create a workflow with Webhook -> HTTP Request (Internal API)
+     * 2. Activate it
+     * 3. Call the webhook -> Returns the node types
+     */
+    /**
+     * Get all installed node types via Probe Workflow (Webhook)
+     * Returns full node type objects including parameters, not just names.
+     */
+    async getNodeTypes() {
+        const probeId = `probe-${Math.random().toString(36).substring(7)}`;
+        const probePath = `n8m-probe-${Math.random().toString(36).substring(7)}`;
+        let workflowId = null;
+        try {
+            const internalApiUrl = this.apiUrl + '/node-types';
+            const probeWorkflow = {
+                name: `[n8m:system] Node Probe ${probeId}`,
+                nodes: [
+                    {
+                        parameters: {
+                            httpMethod: "GET",
+                            path: probePath,
+                            responseMode: "lastNode",
+                            options: {}
+                        },
+                        id: "webhook",
+                        name: "ProbeWebhook",
+                        type: "n8n-nodes-base.webhook",
+                        typeVersion: 1,
+                        position: [400, 300],
+                        webhookId: probePath
+                    },
+                    {
+                        parameters: {
+                            url: internalApiUrl,
+                            method: "GET",
+                            authentication: "none",
+                            sendHeaders: true,
+                            headerParameters: {
+                                parameters: [
+                                    {
+                                        name: "X-N8N-API-KEY",
+                                        value: this.apiKey
+                                    }
+                                ]
+                            },
+                            options: {}
+                        },
+                        id: "http-request",
+                        name: "FetchNodes",
+                        type: "n8n-nodes-base.httpRequest",
+                        typeVersion: 4.1,
+                        position: [600, 300]
+                    }
+                ],
+                connections: {
+                    "ProbeWebhook": {
+                        main: [[{ node: "FetchNodes", type: "main", index: 0 }]]
+                    }
+                },
+                settings: {
+                    saveManualExecutions: false,
+                    callerPolicy: 'workflowsFromSameOwner'
+                }
+            };
+            // Header Injection
+            probeWorkflow.nodes[1].parameters.authentication = 'none';
+            probeWorkflow.nodes[1].parameters.headerParameters = {
+                parameters: [
+                    { name: 'X-N8N-API-KEY', value: this.apiKey }
+                ]
+            };
+            // 1. Create
+            const { id } = await this.createWorkflow(probeWorkflow.name, probeWorkflow);
+            workflowId = id;
+            // 2. Activate
+            await this.activateWorkflow(id);
+            // 3. Trigger
+            const baseUrl = this.apiUrl.replace('/api/v1', '');
+            const webhookUrl = `${baseUrl}/webhook/${probePath}`;
+            console.log(`[N8nClient] Triggering probe at ${webhookUrl}...`);
+            const response = await fetch(webhookUrl);
+            if (!response.ok) {
+                const errorText = await response.text();
+                if (process.env.DEBUG) {
+                    console.warn(`[N8nClient] Probe webhook failed (Status ${response.status}): ${errorText}`);
+                }
+                throw new Error(`Probe webhook failed: ${response.status}`);
+            }
+            const result = await response.json();
+            // Return full objects
+            if (Array.isArray(result)) {
+                return result;
+            }
+            if (result.data && Array.isArray(result.data)) {
+                return result.data;
+            }
+            return [];
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn(`[N8nClient] Probe failed: ${error.message}`);
+            }
+            return [];
+        }
+        finally {
+            if (workflowId) {
+                try {
+                    await this.deleteWorkflow(workflowId);
+                }
+                catch { /* intentionally empty */ }
+            }
+        }
+    }
+    /**
+     * Get all workflows
+     */
+    async getWorkflows() {
+        try {
+            let allWorkflows = [];
+            let cursor = undefined;
+            do {
+                const url = new URL(`${this.apiUrl}/workflows`);
+                if (cursor)
+                    url.searchParams.set('cursor', cursor);
+                // increase limit to max to minimize requests
+                url.searchParams.set('limit', '250');
+                const response = await fetch(url.toString(), {
+                    headers: this.headers,
+                    method: 'GET',
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to get workflows: ${response.status}`);
+                }
+                const result = await response.json();
+                allWorkflows = [...allWorkflows, ...result.data];
+                cursor = result.nextCursor;
+            } while (cursor);
+            return allWorkflows;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch workflows: ${error.message}`);
+        }
+    }
+    /**
+     * Delete a workflow
+     */
+    async deleteWorkflow(workflowId) {
+        try {
+            const response = await fetch(`${this.apiUrl}/workflows/${workflowId}`, {
+                headers: this.headers,
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to delete workflow: ${response.status}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to delete workflow: ${error.message}`);
+        }
+    }
+    /**
+     * Inject a trigger node to satisfy activation requirements.
+     * Uses a Webhook to allow actual activation (Manual triggers don't allow activation).
+     */
+    injectManualTrigger(workflowData) {
+        const shimNodeId = "shim-trigger-" + Math.random().toString(36).substring(7);
+        const webhookPath = String("n8m-shim-" + Math.random().toString(36).substring(7));
+        // Shim Node (Trigger)
+        const shimNode = {
+            parameters: {
+                httpMethod: "POST",
+                path: webhookPath,
+                responseMode: "onReceived",
+                options: {}
+            },
+            id: shimNodeId,
+            name: "N8M_Shim_Webhook",
+            type: "n8n-nodes-base.webhook",
+            typeVersion: 1,
+            position: [0, 0],
+            webhookId: String(webhookPath)
+        };
+        // Flattener Node (Code)
+        // Hoists 'body' and 'query' to root so downstream nodes see expected schema
+        const flattenerId = "shim-flattener-" + Math.random().toString(36).substring(7);
+        const flattenerNode = {
+            parameters: {
+                jsCode: `return items.map(item => {
+    const body = item.json.body || {};
+    const query = item.json.query || {};
+    // Prioritize body over query, and existing item props
+    return {
+        json: {
+            ...item.json,
+            ...query,
+            ...body
+        }
+    };
+});`
+            },
+            id: flattenerId,
+            name: "Shim_Flattener",
+            type: "n8n-nodes-base.code",
+            typeVersion: 2,
+            position: [200, 0]
+        };
+        // Ensure no webhookId on flattener or non-webhooks
+        delete flattenerNode.webhookId;
+        const nodes = [...(workflowData.nodes || []), shimNode, flattenerNode];
+        const connections = { ...(workflowData.connections || {}) };
+        // Try to connect to the first non-trigger node to make it a valid flow
+        const targetNode = nodes.find((n) => n.id !== shimNodeId && n.id !== flattenerId && !n.type.includes('Trigger'));
+        if (targetNode) {
+            // Connect Webhook -> Flattener
+            if (!connections[shimNode.name]) {
+                connections[shimNode.name] = {
+                    main: [
+                        [
+                            {
+                                node: flattenerNode.name,
+                                type: 'main',
+                                index: 0
+                            }
+                        ]
+                    ]
+                };
+            }
+            // Connect Flattener -> Target
+            if (!connections[flattenerNode.name]) {
+                connections[flattenerNode.name] = {
+                    main: [
+                        [
+                            {
+                                node: targetNode.name,
+                                type: 'main',
+                                index: 0
+                            }
+                        ]
+                    ]
+                };
+            }
+        }
+        return {
+            ...workflowData,
+            nodes,
+            connections
+        };
+    }
+    /**
+     * Get n8n instance deep link for a workflow
+     */
+    getWorkflowLink(workflowId) {
+        const baseUrl = this.apiUrl.replace('/api/v1', '');
+        return `${baseUrl}/workflow/${workflowId}`;
+    }
+}

package/dist/utils/sandbox.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sandboxed Execution Environment for Dynamic Tools
+ * Allows agents to write and run temporary analysis scripts.
+ */
+export declare class Sandbox {
+    /**
+     * Run a snippet of JavaScript code safely
+     * @param code The code to execute
+     * @param context External variables to expose to the script
+     * @returns The result of the execution
+     */
+    static run(code: string, context?: Record<string, any>): any;
+}

package/dist/utils/sandbox.js

@@ -0,0 +1,34 @@
+import vm from 'vm';
+import { theme } from './theme.js';
+/**
+ * Sandboxed Execution Environment for Dynamic Tools
+ * Allows agents to write and run temporary analysis scripts.
+ */
+export class Sandbox {
+    /**
+     * Run a snippet of JavaScript code safely
+     * @param code The code to execute
+     * @param context External variables to expose to the script
+     * @returns The result of the execution
+     */
+    static run(code, context = {}) {
+        const sandbox = {
+            console: {
+                log: (...args) => console.log(theme.muted('[Sandbox]'), ...args),
+                error: (...args) => console.error(theme.error('[Sandbox Error]'), ...args)
+            },
+            ...context
+        };
+        const script = new vm.Script(code);
+        const vmContext = vm.createContext(sandbox);
+        try {
+            console.log(theme.agent(`Running Dynamic Tool Script (${code.length} bytes)...`));
+            const result = script.runInContext(vmContext, { timeout: 5000 }); // 5s timeout
+            return result;
+        }
+        catch (error) {
+            console.error(theme.error(`Sandbox Execution Failed: ${error.message}`));
+            throw error;
+        }
+    }
+}

package/dist/utils/theme.d.ts

@@ -0,0 +1,23 @@
+export declare const theme: {
+    divider: (len?: number) => string;
+    header: (text: string) => string;
+    subHeader: (text: string) => string;
+    label: (text: string) => string;
+    value: (text: string | number | boolean) => string;
+    info: (text: string) => string;
+    done: (text: string) => string;
+    warn: (text: string) => string;
+    fail: (text: string) => string;
+    agent: (text: string) => string;
+    brand: () => string;
+    tag: (text: string) => string;
+    primary: import("chalk").ChalkInstance;
+    secondary: import("chalk").ChalkInstance;
+    muted: import("chalk").ChalkInstance;
+    foreground: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    warning: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    ai: import("chalk").ChalkInstance;
+    card: import("chalk").ChalkInstance;
+};