@lhi/n8m 0.2.0 → 0.2.2

package/dist/services/ai.service.js

@@ -5,6 +5,7 @@ import os from 'os';
 import { fileURLToPath } from 'url';
 import { jsonrepair } from 'jsonrepair';
 import { NodeDefinitionsService } from './node-definitions.service.js';
+import { Spinner } from '../utils/spinner.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export const PROVIDER_PRESETS = {
@@ -120,31 +121,34 @@ export class AIService {
         const model = options.model || (options.provider ? PROVIDER_PRESETS[options.provider]?.defaultModel : this.model);
         const maxRetries = 3;
         let lastError;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                if (process.stdout.isTTY && process.env.NODE_ENV !== 'test') {
-                    process.stdout.write(`   (AI Thinking: ${model})\n`);
-                }
-                if (provider === 'anthropic' && !this.baseURL?.includes('openai') && !this.client) {
-                    return await this.callAnthropicNative(prompt, model, options);
+        Spinner.start('Thinking');
+        try {
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    if (provider === 'anthropic' && !this.baseURL?.includes('openai') && !this.client) {
+                        return await this.callAnthropicNative(prompt, model, options);
+                    }
+                    const client = this.getClient(provider);
+                    const completion = await client.chat.completions.create({
+                        model,
+                        messages: [{ role: 'user', content: prompt }],
+                        temperature: options.temperature ?? 0.7,
+                    });
+                    const result = completion;
+                    return result.choices?.[0]?.message?.content || '';
                 }
-                const client = this.getClient(provider);
-                const completion = await client.chat.completions.create({
-                    model,
-                    messages: [{ role: 'user', content: prompt }],
-                    temperature: options.temperature ?? 0.7,
-                });
-                const result = completion;
-                return result.choices?.[0]?.message?.content || '';
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < maxRetries) {
-                    const waitTime = Math.pow(2, attempt) * 1000;
-                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                catch (error) {
+                    lastError = error;
+                    if (attempt < maxRetries) {
+                        const waitTime = Math.pow(2, attempt) * 1000;
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                    }
                 }
             }
         }
+        finally {
+            Spinner.stop();
+        }
         throw lastError;
     }
     getAlternativeModel() {
@@ -380,6 +384,69 @@ export class AIService {
             return { message: cleanJson };
         }
     }
+    async fixExecuteCommandScript(command, error) {
+        const errorCtx = error ? `\nError from the failing command:\n${error}\n` : '';
+        const prompt = `You are a bash scripting expert.
+The following shell command is used in an n8n Execute Command node.
+It appears that newlines were accidentally stripped from the script, collapsing it to a single line.${errorCtx}
+Current (collapsed) command:
+\`\`\`
+${command}
+\`\`\`
+
+Reconstruct the properly-formatted multiline bash script. Rules:
+- Restore newlines between statements (variable assignments, commands, etc.)
+- Properly format line-continuation backslashes: each \\ must be followed by a real newline
+- Keep all original commands and logic intact — do not change what the script does
+- Use \\n to separate statements, not semicolons (unless they were originally there)
+
+Return ONLY the fixed shell script. No markdown fences, no explanation.`;
+        const response = await this.generateContent(prompt, { temperature: 0.1 });
+        return response.replace(/^```(?:bash|sh|shell)?\n?|\n?```$/g, '').trim();
+    }
+    async fixCodeNodeJavaScript(code, error) {
+        const prompt = `You are an n8n Code node JavaScript expert.
+The following code is used in an n8n Code node but fails with a syntax error.
+Error: ${error}
+
+Current code:
+\`\`\`javascript
+${code}
+\`\`\`
+
+Fix the JavaScript so it runs correctly in an n8n Code node. Rules:
+- All ES6+ syntax is valid (const, let, arrow functions, destructuring, template literals, etc.)
+- Access all input items via: const items = $input.all();
+- Access single input via: const item = $input.first();
+- Return transformed items as: return [{json: {...}}];
+- Do NOT use require() or import — n8n provides built-in variables ($input, $json, $node, etc.)
+
+Return ONLY the fixed JavaScript code. No markdown fences, no explanation.`;
+        const response = await this.generateContent(prompt, { temperature: 0.1 });
+        return response.replace(/^```(?:javascript|js)?\n?|\n?```$/g, '').trim();
+    }
+    async shimCodeNodeWithMockData(code) {
+        const prompt = `You are an n8n Code node JavaScript expert.
+The following n8n Code node makes external HTTP/API calls or references other nodes via $('NodeName') — none of which are available in the isolated test environment.
+Your task: completely rewrite it to return hardcoded mock data that matches the expected output structure.
+
+Original code:
+\`\`\`javascript
+${code}
+\`\`\`
+
+Rules:
+- Analyze what data structure the original code was meant to return
+- Write a COMPLETE REPLACEMENT — do NOT keep any HTTP requests, fetch, axios, this.helpers calls, or $('NodeName') references
+- Replace every $('NodeName').first().json.X reference with a reasonable hardcoded value
+- Do NOT use require() or import
+- Return realistic hardcoded mock values as: return [{json: {...}}];
+- The mock data must match the real API response shape so downstream nodes work correctly
+
+Return ONLY the replacement JavaScript code. No markdown fences, no explanation.`;
+        const response = await this.generateContent(prompt, { temperature: 0.1 });
+        return response.replace(/^```(?:javascript|js)?\n?|\n?```$/g, '').trim();
+    }
     async evaluateCandidates(goal, candidates) {
         if (candidates.length === 0)
             return { selectedIndex: 0, reason: "No candidates" };
@@ -416,6 +483,189 @@ export class AIService {
             return { selectedIndex: 0, reason: "Failed to parse AI response" };
         }
     }
+    /**
+     * AI-powered error evaluation for n8n test executions.
+     * Replaces brittle regex classifiers — the model reads the error + node list and decides.
+     */
+    async evaluateTestError(errorMessage, workflowNodes, failingNodeName, failingNodeCode) {
+        const nodesSummary = (workflowNodes || [])
+            .map((n) => `- "${n.name}" (${n.type})`)
+            .join('\n');
+        const codeContext = failingNodeCode
+            ? `\nFailing node's JavaScript code:\n\`\`\`javascript\n${failingNodeCode}\n\`\`\``
+            : '';
+        const prompt = `You are an n8n workflow testing expert. An execution failed with the error below.
+Classify the error and choose the best remediation action.
+
+Error: ${errorMessage}
+${failingNodeName ? `Failing node: "${failingNodeName}"` : ''}${codeContext}
+
+Workflow nodes:
+${nodesSummary}
+
+ACTIONS (choose exactly one):
+• "fix_node" — the error is a fixable node configuration bug in the workflow itself:
+  - nodeFixType "code_node_js":    JavaScript syntax/runtime error in a Code node
+  - nodeFixType "execute_command": shell script error in an Execute Command node
+  - nodeFixType "binary_field":    wrong binaryPropertyName in a node (HTTP Request always outputs field "data")
+• "regenerate_payload" — the test input payload is missing required fields or has wrong values; the workflow logic itself is correct (e.g. "No property named", "is not defined", "$json.body.X" errors)
+• "structural_pass" — the workflow structure is valid but the test environment lacks:
+  external services (Slack, HTTP APIs, OAuth, databases), credentials, upstream binary data, rate limits, or encoding issues (e.g. "could not be parsed").
+  Also use this for any URL or connection error from an external API node (Slack, HTTP Request, Google, etc.) — "Invalid URL", "Failed to connect", "ECONNREFUSED", "401 Unauthorized", "403 Forbidden", "Network error" all indicate the test environment can't reach the external service, not a workflow bug.
+  IMPORTANT: If the failing code uses $('NodeName') to reference other workflow nodes, and those nodes are AI/LLM nodes, external APIs, or services that cannot run in isolation, this is a structural_pass — the workflow requires the full upstream pipeline to test.
+• "escalate" — fundamental design flaw that requires rebuilding the workflow
+
+Respond with ONLY this JSON (no commentary, no markdown):
+{
+  "action": "fix_node" | "regenerate_payload" | "structural_pass" | "escalate",
+  "nodeFixType": "code_node_js" | "execute_command" | "binary_field" | null,
+  "targetNodeName": "<exact node name or null>",
+  "suggestedBinaryField": "data" | null,
+  "reason": "<one sentence>"
+}`;
+        try {
+            const response = await this.generateContent(prompt, { temperature: 0.1 });
+            const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+            const result = JSON.parse(jsonrepair(cleanJson));
+            if (!['fix_node', 'regenerate_payload', 'structural_pass', 'escalate'].includes(result.action)) {
+                result.action = 'structural_pass';
+            }
+            return result;
+        }
+        catch {
+            return { action: 'structural_pass', reason: 'Could not evaluate error — defaulting to structural pass' };
+        }
+    }
+    /**
+     * Offline-only: evaluates whether a fixed Code node or Execute Command script
+     * would succeed given the REAL input items from the fixture's runData.
+     * Used when no live re-execution is possible.
+     */
+    async evaluateCodeFixOffline(fixedCode, inputItems, originalError, nodeType) {
+        const codeLabel = nodeType === 'code_node_js' ? 'JavaScript' : 'shell script';
+        const ruleNote = nodeType === 'code_node_js'
+            ? 'n8n Code node rules: use $input.all() / $input.first(), return Array<{json:{...}}>, no require/import.'
+            : 'Shell script runs in the n8n Execute Command node environment.';
+        const prompt = `You are an n8n ${codeLabel} execution expert.
+
+A node previously failed with this error:
+${originalError}
+
+It was fixed. The fixed ${codeLabel} is:
+\`\`\`
+${fixedCode}
+\`\`\`
+
+The REAL input items from the fixture are:
+${JSON.stringify(inputItems, null, 2)}
+
+${ruleNote}
+
+Task: Mentally execute the fixed code against these real inputs.
+- Does it have syntax errors?
+- Are all referenced fields present in the input items?
+- Does it address the original error?
+- Would it produce valid output?
+
+Respond with ONLY this JSON (no commentary, no markdown):
+{"wouldPass": true|false, "reason": "<one sentence>"}`;
+        try {
+            const response = await this.generateContent(prompt, { temperature: 0.1 });
+            const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+            const result = JSON.parse(jsonrepair(cleanJson));
+            return { wouldPass: Boolean(result.wouldPass), reason: result.reason ?? '' };
+        }
+        catch {
+            return { wouldPass: true, reason: 'Could not evaluate offline — assuming pass' };
+        }
+    }
+    /**
+     * Traces binary data flow through an entire workflow graph to find the correct
+     * binary field name for a failing upload node.
+     *
+     * Handles passthrough nodes (Merge, Set, IF, Switch) by tracing further upstream
+     * and reads Code node jsCode to extract the actual binary field assignment.
+     * Delegates graph traversal + analysis entirely to the AI.
+     */
+    async inferBinaryFieldNameFromWorkflow(failingNodeName, workflowNodes, workflowConnections) {
+        const nodesSummary = (workflowNodes || [])
+            .map((n) => `- "${n.name}" (${n.type})`)
+            .join('\n');
+        const connsSummary = Object.entries(workflowConnections || {})
+            .map(([src, targets]) => {
+            const dests = (targets.main || []).flat()
+                .map((c) => `"${c?.node}"`)
+                .filter(Boolean)
+                .join(', ');
+            return `"${src}" → [${dests}]`;
+        })
+            .join('\n');
+        // Include full jsCode for any Code/Function nodes so the AI can read binary assignments
+        const codeSnippets = (workflowNodes || [])
+            .filter((n) => (n.type === 'n8n-nodes-base.code' || n.type === 'n8n-nodes-base.function') &&
+            n.parameters?.jsCode)
+            .map((n) => `\n"${n.name}" (${n.type}) jsCode:\n\`\`\`javascript\n${n.parameters.jsCode}\n\`\`\``)
+            .join('\n');
+        const prompt = `You are an n8n binary data expert. Analyze this workflow to find the correct binary field name for the failing upload node.
+
+Failing node: "${failingNodeName}" — error: "has no binary field"
+
+Workflow nodes:
+${nodesSummary}
+
+Connections (source → [targets]):
+${connsSummary}
+${codeSnippets ? `\nCode node implementations:${codeSnippets}` : ''}
+
+Task: Trace binary data flow backwards from "${failingNodeName}" to find the node that actually CREATES or DOWNLOADS the binary data. Then determine what field name it uses for the binary output.
+
+Binary field name rules:
+- n8n-nodes-base.httpRequest → always outputs binary as "data"
+- n8n-nodes-base.readBinaryFile / readBinaryFiles → "data"
+- n8n-nodes-base.code / function → look at jsCode: items[0].binary = { FIELD_NAME: ... } or return [{ binary: { FIELD_NAME: ... } }]
+- n8n-nodes-base.merge / set / if / switch / noOp → pass-through nodes, trace upstream
+- Slack / Google Drive / Dropbox / other API download nodes → "data"
+
+What is the correct binaryPropertyName for "${failingNodeName}"?
+If you cannot determine it with confidence, return null.
+
+Respond ONLY with this JSON (no commentary, no markdown):
+{"binaryFieldName": "the_field_name" | null}`;
+        try {
+            const response = await this.generateContent(prompt, { temperature: 0.1 });
+            const cleanJson = response.replace(/```json\n?|\n?```/g, '').trim();
+            const result = JSON.parse(jsonrepair(cleanJson));
+            return typeof result.binaryFieldName === 'string' ? result.binaryFieldName : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Returns jsCode for an n8n Code node (runOnceForAllItems) that produces
+     * synthetic binary test data in the specified field.
+     *
+     * Hardcoded — no LLM call — because the n8n Code node binary format is
+     * deterministic and LLM-generated variants consistently misuse APIs that
+     * aren't available (this.helpers.prepareBinaryData, $input.all() in wrong mode, etc.).
+     */
+    generateBinaryShimCode(binaryFieldName) {
+        const fieldKey = JSON.stringify(binaryFieldName);
+        return [
+            `const base64 = Buffer.from('n8m-test-binary', 'utf-8').toString('base64');`,
+            `return $input.all().map(item => ({`,
+            `  json: item.json,`,
+            `  binary: {`,
+            `    ${fieldKey}: {`,
+            `      data: base64,`,
+            `      mimeType: 'text/plain',`,
+            `      fileName: 'test-file.txt',`,
+            `      fileExtension: 'txt'`,
+            `    }`,
+            `  }`,
+            `}));`,
+        ].join('\n');
+    }
     /**
      * Generates 3-5 diverse test scenarios (input payloads) for a workflow.
      */

package/dist/services/node-definitions.service.d.ts

@@ -8,6 +8,7 @@ export declare class NodeDefinitionsService {
     private static instance;
     private definitions;
     private client;
+    private defaultClient;
     private constructor();
     static getInstance(): NodeDefinitionsService;
     /**

package/dist/services/node-definitions.service.js

@@ -9,9 +9,11 @@ export class NodeDefinitionsService {
     static instance;
     definitions = [];
     client;
+    defaultClient;
     constructor() {
         // Will be overridden in loadDefinitions() once config is available
         this.client = new N8nClient();
+        this.defaultClient = this.client;
     }
     static getInstance() {
         if (!NodeDefinitionsService.instance) {
@@ -26,27 +28,21 @@ export class NodeDefinitionsService {
     async loadDefinitions() {
         if (this.definitions.length > 0)
             return;
-        console.log('Loading node definitions...');
         try {
             // Re-initialize client if env vars changed (e.g. after config load)
             const config = await ConfigManager.load();
             // Env vars take priority over stored config
             const apiUrl = process.env.N8N_API_URL || config.n8nUrl;
             const apiKey = process.env.N8N_API_KEY || config.n8nKey;
-            if (apiUrl && apiKey) {
+            if (apiUrl && apiKey && this.client === this.defaultClient) {
                 this.client = new N8nClient({ apiUrl, apiKey });
             }
             this.definitions = await this.client.getNodeTypes();
             if (this.definitions.length === 0) {
-                console.warn("No node definitions returned from n8n instance. Attempting fallback...");
                 this.loadFallback();
             }
-            else {
-                console.log(`Loaded ${this.definitions.length} node definitions.`);
-            }
         }
         catch {
-            console.error("Failed to load node definitions from n8n instance (fetch failed).");
             this.loadFallback();
         }
     }
@@ -67,15 +63,12 @@ export class NodeDefinitionsService {
             if (fallbackPath) {
                 const fallbackData = fs.readFileSync(fallbackPath, 'utf8');
                 this.definitions = JSON.parse(fallbackData);
-                console.log(`Loaded ${this.definitions.length} node definitions (from fallback at ${path.basename(path.dirname(fallbackPath))}).`);
             }
             else {
-                console.warn("Fallback node definitions file not found in searched locations.");
                 this.definitions = [];
             }
         }
-        catch (fallbackError) {
-            console.error("Failed to load fallback node definitions:", fallbackError);
+        catch {
             this.definitions = [];
         }
     }

package/dist/utils/config.js

@@ -1,10 +1,12 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import dotenv from 'dotenv';
 export class ConfigManager {
     static configDir = path.join(os.homedir(), '.n8m');
     static configFile = path.join(os.homedir(), '.n8m', 'config.json');
     static async load() {
+        dotenv.config({ quiet: true }); // Load .env from cwd if present (no-op if already loaded or file missing)
         try {
             const data = await fs.readFile(this.configFile, 'utf-8');
             return JSON.parse(data);

package/dist/utils/fixtureManager.d.ts

@@ -0,0 +1,28 @@
+export interface WorkflowFixture {
+    version: '1.0';
+    capturedAt: string;
+    workflowId: string;
+    workflowName: string;
+    workflow: any;
+    execution: {
+        id?: string;
+        status: string;
+        startedAt?: string;
+        data: {
+            resultData: {
+                error?: any;
+                runData: Record<string, any[]>;
+            };
+        };
+    };
+}
+export declare class FixtureManager {
+    private fixturesDir;
+    constructor();
+    private fixturePath;
+    exists(workflowId: string): boolean;
+    load(workflowId: string): WorkflowFixture | null;
+    loadFromPath(filePath: string): WorkflowFixture | null;
+    getCapturedDate(workflowId: string): Date | null;
+    save(fixture: WorkflowFixture): Promise<void>;
+}

package/dist/utils/fixtureManager.js

@@ -0,0 +1,41 @@
+import fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+export class FixtureManager {
+    fixturesDir;
+    constructor() {
+        this.fixturesDir = path.join(process.cwd(), '.n8m', 'fixtures');
+    }
+    fixturePath(workflowId) {
+        return path.join(this.fixturesDir, `${workflowId}.json`);
+    }
+    exists(workflowId) {
+        return existsSync(this.fixturePath(workflowId));
+    }
+    load(workflowId) {
+        try {
+            const raw = readFileSync(this.fixturePath(workflowId), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    loadFromPath(filePath) {
+        try {
+            const raw = readFileSync(path.resolve(filePath), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    getCapturedDate(workflowId) {
+        const fixture = this.load(workflowId);
+        return fixture ? new Date(fixture.capturedAt) : null;
+    }
+    async save(fixture) {
+        await fs.mkdir(this.fixturesDir, { recursive: true });
+        await fs.writeFile(this.fixturePath(fixture.workflowId), JSON.stringify(fixture, null, 2), 'utf-8');
+    }
+}

package/dist/utils/n8nClient.d.ts

@@ -90,8 +90,35 @@ export declare class N8nClient {
      * Uses a Webhook to allow actual activation (Manual triggers don't allow activation).
      */
     injectManualTrigger(workflowData: any): any;
+    /**
+     * Temporarily set pin data on a workflow so test executions receive
+     * synthetic binary data instead of running binary-generating nodes live.
+     * Pass pinData:{} to clear injected pins and restore the original state.
+     *
+     * The public /api/v1/ schema may reject pinData as an "additional property".
+     * In that case we fall back to the internal /rest/ API that n8n's own UI uses,
+     * which accepts pinData without schema restriction.
+     */
+    setPinData(workflowId: string, workflowData: any, pinData: Record<string, any[]>): Promise<void>;
     /**
      * Get n8n instance deep link for a workflow
      */
     getWorkflowLink(workflowId: string): string;
+    /**
+     * Node types that never make external HTTP calls — pure logic, control flow,
+     * data transformation, or local execution.  Everything else is a candidate
+     * for shimming during test runs.
+     */
+    private static readonly PASS_THROUGH_TYPES;
+    /**
+     * Replace every node that makes external network calls with an inert Code shim
+     * returning plausible fake data.  Node NAMES (and IDs) are preserved so
+     * connections stay valid.  Used to ensure tests never hit real external services.
+     *
+     * Shimming criteria: the node has credentials configured OR is an HTTP Request node.
+     * Pure-logic nodes in PASS_THROUGH_TYPES are always left untouched.
+     */
+    static shimNetworkNodes(nodes: any[]): any[];
+    /** Generate the JS body for a Code shim that stands in for an external-calling node. */
+    static buildNetworkShimCode(nodeType: string): string;
 }