@lhi/n8m 0.2.0 → 0.2.2

package/dist/utils/n8nClient.js

@@ -110,7 +110,7 @@ export class N8nClient {
         try {
             const url = new URL(`${this.apiUrl}/executions`);
             url.searchParams.set('workflowId', workflowId);
-            url.searchParams.set('limit', '5');
+            url.searchParams.set('limit', '25');
             const response = await fetch(url.toString(), {
                 headers: this.headers,
                 method: 'GET',
@@ -178,8 +178,6 @@ export class N8nClient {
                 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,
@@ -190,7 +188,11 @@ export class N8nClient {
             return { id: result.id };
         }
         catch (error) {
-            throw new Error(`Failed to create workflow: ${error.message}`);
+            const msg = error.message;
+            if (msg === 'fetch failed' || msg.includes('ECONNREFUSED') || msg.includes('ENOTFOUND')) {
+                throw new Error(`Cannot connect to n8n at ${this.apiUrl}. Ensure n8n is running and the URL is correct.`);
+            }
+            throw new Error(`Failed to create workflow: ${msg}`);
         }
     }
     /**
@@ -210,7 +212,6 @@ export class N8nClient {
                     method: 'GET',
                 });
                 if (!response.ok) {
-                    console.warn(`[N8nClient] node-types request failed (${response.status}) — validation/shimming disabled`);
                     return [];
                 }
                 const result = await response.json();
@@ -365,6 +366,60 @@ export class N8nClient {
             connections
         };
     }
+    /**
+     * 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.
+     */
+    async setPinData(workflowId, workflowData, pinData) {
+        const settings = { ...(workflowData.settings || {}) };
+        delete settings.timezone; // n8n rejects many timezone values
+        const payload = {
+            name: workflowData.name,
+            nodes: workflowData.nodes,
+            connections: workflowData.connections,
+            settings,
+            pinData,
+        };
+        // Preserve versionId and staticData so the internal API doesn't reset them
+        if (workflowData.versionId)
+            payload.versionId = workflowData.versionId;
+        if (workflowData.staticData)
+            payload.staticData = workflowData.staticData;
+        // Attempt 1: public /api/v1/ endpoint
+        const pubResponse = await fetch(`${this.apiUrl}/workflows/${workflowId}`, {
+            body: JSON.stringify(payload),
+            headers: this.headers,
+            method: 'PUT',
+        });
+        if (pubResponse.ok)
+            return;
+        const pubErr = await pubResponse.text();
+        // Attempt 2: internal /rest/ endpoint (used by n8n UI; accepts pinData)
+        if (pubResponse.status === 400 && pubErr.includes('additional properties')) {
+            const restUrl = this.apiUrl.replace('/api/v1', '/rest');
+            const restResponse = await fetch(`${restUrl}/workflows/${workflowId}`, {
+                body: JSON.stringify(payload),
+                headers: this.headers,
+                method: 'PUT',
+            });
+            if (restResponse.ok)
+                return;
+            const restErr = await restResponse.text();
+            throw new Error(`set pin data failed: ${restResponse.status} - ${restErr}`);
+        }
+        if (pubResponse.status === 403) {
+            throw new Error(`set pin data failed (403 Forbidden). Ensure your API key has permission to update this workflow. n8n says: ${pubErr}`);
+        }
+        if (pubResponse.status === 401) {
+            throw new Error(`set pin data failed (401 Unauthorized). Run: n8m config --n8n-key <your-key>`);
+        }
+        throw new Error(`set pin data failed: ${pubResponse.status} - ${pubErr}`);
+    }
     /**
      * Get n8n instance deep link for a workflow
      */
@@ -372,4 +427,113 @@ export class N8nClient {
         const baseUrl = this.apiUrl.replace('/api/v1', '');
         return `${baseUrl}/workflow/${workflowId}`;
     }
+    /**
+     * 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.
+     */
+    static PASS_THROUGH_TYPES = new Set([
+        'n8n-nodes-base.webhook',
+        'n8n-nodes-base.manualTrigger',
+        'n8n-nodes-base.scheduleTrigger',
+        'n8n-nodes-base.intervalTrigger',
+        'n8n-nodes-base.code',
+        'n8n-nodes-base.function',
+        'n8n-nodes-base.functionItem',
+        'n8n-nodes-base.if',
+        'n8n-nodes-base.switch',
+        'n8n-nodes-base.set',
+        'n8n-nodes-base.editFields',
+        'n8n-nodes-base.merge',
+        'n8n-nodes-base.noOp',
+        'n8n-nodes-base.executeWorkflow',
+        'n8n-nodes-base.executeWorkflowTrigger',
+        'n8n-nodes-base.respondToWebhook',
+        'n8n-nodes-base.wait',
+        'n8n-nodes-base.splitInBatches',
+        'n8n-nodes-base.aggregate',
+        'n8n-nodes-base.splitOut',
+        'n8n-nodes-base.itemLists',
+        'n8n-nodes-base.filter',
+        'n8n-nodes-base.sort',
+        'n8n-nodes-base.limit',
+        'n8n-nodes-base.removeDuplicates',
+        'n8n-nodes-base.dateTime',
+        'n8n-nodes-base.html',
+        'n8n-nodes-base.htmlExtract',
+        'n8n-nodes-base.xml',
+        'n8n-nodes-base.markdown',
+        'n8n-nodes-base.compression',
+        'n8n-nodes-base.convertToFile',
+        'n8n-nodes-base.extractFromFile',
+        'n8n-nodes-base.crypto',
+        'n8n-nodes-base.executeCommand',
+        'n8n-nodes-base.stickyNote',
+        'n8n-nodes-base.start',
+    ]);
+    /**
+     * 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) {
+        return nodes.map((node) => {
+            if (!node)
+                return node;
+            if (N8nClient.PASS_THROUGH_TYPES.has(node.type))
+                return node;
+            // LangChain sub-nodes (@n8n/ namespace) communicate via supplyData(), not main outputs.
+            // Replacing them with Code nodes breaks the supplyData protocol — skip shimming.
+            if (node.type?.startsWith('@n8n/'))
+                return node;
+            const hasCredentials = node.credentials && Object.keys(node.credentials).length > 0;
+            const isHttpRequest = node.type === 'n8n-nodes-base.httpRequest';
+            if (!hasCredentials && !isHttpRequest)
+                return node;
+            return {
+                id: node.id,
+                name: node.name,
+                type: 'n8n-nodes-base.code',
+                typeVersion: 2,
+                position: node.position,
+                parameters: {
+                    mode: 'runOnceForAllItems',
+                    jsCode: N8nClient.buildNetworkShimCode(node.type),
+                },
+            };
+        });
+    }
+    /** Generate the JS body for a Code shim that stands in for an external-calling node. */
+    static buildNetworkShimCode(nodeType) {
+        const t = nodeType.toLowerCase();
+        if (t.includes('httprequest')) {
+            return `// [n8m:shim] HTTP Request — no external call made during testing\nreturn [{ json: { status: 200, statusText: 'OK', body: '{"ok":true,"shimmed":true}', headers: { 'content-type': 'application/json' } } }];`;
+        }
+        if (t.includes('openai') || t.includes('anthropic') || t.includes('gemini') || t.includes('lmchat') || t.includes('languagemodel')) {
+            return `// [n8m:shim] AI node — no external call made during testing\nreturn [{ json: { message: { role: 'assistant', content: '[test shim: AI response]' }, finish_reason: 'stop', usage: { total_tokens: 0 } } }];`;
+        }
+        if (t.includes('slack')) {
+            return `// [n8m:shim] Slack — no external call made during testing\nreturn [{ json: { ok: true, ts: '1000000000.000001', channel: 'C00000000', message: { text: '[test shim]' } } }];`;
+        }
+        if (t.includes('gmail') || t.includes('emailsend') || t.includes('sendemail') || t.includes('imap')) {
+            return `// [n8m:shim] Email — no external call made during testing\nreturn [{ json: { id: 'shim-msg-id', threadId: 'shim-thread-id', labelIds: ['SENT'] } }];`;
+        }
+        if (t.includes('googledrive') || t.includes('googlesheets') || t.includes('googledocs')) {
+            return `// [n8m:shim] Google service — no external call made during testing\nreturn [{ json: { kind: 'drive#file', id: 'shim-id', name: 'shim', mimeType: 'application/json' } }];`;
+        }
+        if (t.includes('github') || t.includes('gitlab')) {
+            return `// [n8m:shim] Git service — no external call made during testing\nreturn [{ json: { id: 1, number: 1, title: '[test shim]', state: 'open', html_url: 'https://example.com' } }];`;
+        }
+        if (t.includes('telegram') || t.includes('discord') || t.includes('teams') || t.includes('mattermost')) {
+            return `// [n8m:shim] Messaging service — no external call made during testing\nreturn [{ json: { ok: true, result: { message_id: 1, text: '[test shim]' } } }];`;
+        }
+        if (t.includes('airtable') || t.includes('notion') || t.includes('jira') || t.includes('asana') || t.includes('trello')) {
+            return `// [n8m:shim] Project management service — no external call made during testing\nreturn [{ json: { id: 'shim-id', name: '[test shim]', status: 'ok' } }];`;
+        }
+        // Default: generic success response for any other credentialed service node
+        return `// [n8m:shim] External service — no external call made during testing\nreturn [{ json: { ok: true, shimmed: true, id: 'shim-id', result: '[test shim]' } }];`;
+    }
 }

package/dist/utils/spinner.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ref-counted terminal spinner.
+ *
+ * Multiple concurrent callers (e.g. two parallel Engineer nodes) share a
+ * single animated line.  The animation stops only when every caller has
+ * called stop().
+ */
+export declare class Spinner {
+    private static refCount;
+    private static intervalId;
+    private static frameIdx;
+    private static text;
+    static start(text: string): void;
+    static stop(): void;
+    /** Convenience: run fn() while the spinner is active. */
+    static wrap<T>(text: string, fn: () => Promise<T>): Promise<T>;
+}

package/dist/utils/spinner.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import spinners from 'cli-spinners';
+const frames = spinners.dots.frames;
+/**
+ * Ref-counted terminal spinner.
+ *
+ * Multiple concurrent callers (e.g. two parallel Engineer nodes) share a
+ * single animated line.  The animation stops only when every caller has
+ * called stop().
+ */
+export class Spinner {
+    static refCount = 0;
+    static intervalId = null;
+    static frameIdx = 0;
+    static text = '';
+    static start(text) {
+        if (!process.stdout.isTTY)
+            return;
+        // Update the label to the latest caller's message.
+        Spinner.text = text;
+        Spinner.refCount++;
+        if (Spinner.intervalId)
+            return; // already animating
+        Spinner.frameIdx = 0;
+        Spinner.intervalId = setInterval(() => {
+            const frame = chalk.hex('#A855F7')(frames[Spinner.frameIdx++ % frames.length]);
+            process.stdout.write(`\r${frame} ${chalk.dim(Spinner.text)}`);
+        }, 80);
+    }
+    static stop() {
+        if (!process.stdout.isTTY)
+            return;
+        Spinner.refCount = Math.max(0, Spinner.refCount - 1);
+        if (Spinner.refCount > 0)
+            return; // other callers still in flight
+        if (Spinner.intervalId) {
+            clearInterval(Spinner.intervalId);
+            Spinner.intervalId = null;
+        }
+        process.stdout.write('\r\x1b[K'); // erase the spinner line
+    }
+    /** Convenience: run fn() while the spinner is active. */
+    static async wrap(text, fn) {
+        Spinner.start(text);
+        try {
+            return await fn();
+        }
+        finally {
+            Spinner.stop();
+        }
+    }
+}

package/oclif.manifest.json

@@ -199,6 +199,46 @@
         "doc.js"
       ]
     },
+    "fixture": {
+      "aliases": [],
+      "args": {
+        "action": {
+          "description": "Action to perform (init, capture)",
+          "name": "action",
+          "options": [
+            "init",
+            "capture"
+          ],
+          "required": true
+        },
+        "workflowId": {
+          "description": "n8n workflow ID (optional — omit to browse and select)",
+          "name": "workflowId",
+          "required": false
+        }
+      },
+      "description": "Manage n8m workflow fixtures for offline testing",
+      "examples": [
+        "<%= config.bin %> fixture init abc123       # scaffold an empty fixture template",
+        "<%= config.bin %> fixture capture           # browse local files + n8n instance to pick a workflow",
+        "<%= config.bin %> fixture capture abc123    # pull latest real execution for a specific workflow ID"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "fixture",
+      "pluginAlias": "@lhi/n8m",
+      "pluginName": "@lhi/n8m",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "fixture.js"
+      ]
+    },
     "mcp": {
       "aliases": [],
       "args": {},
@@ -373,6 +413,14 @@
           "name": "ai-scenarios",
           "allowNo": false,
           "type": "boolean"
+        },
+        "fixture": {
+          "char": "f",
+          "description": "Path to a fixture JSON file to use for offline testing",
+          "name": "fixture",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
         }
       },
       "hasDynamicHelp": false,
@@ -391,5 +439,5 @@
       ]
     }
   },
-  "version": "0.2.0"
+  "version": "0.2.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lhi/n8m",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Agentic n8n CLI wrapper - A Skill Bridge for n8n workflow automation",
   "author": "Lem Canady",
   "license": "MIT",
@@ -85,7 +85,7 @@
     }
   },
   "scripts": {
-    "build": "shx rm -rf dist && tsc -b && shx mkdir -p dist/resources && shx cp src/resources/*.json dist/resources/",
+    "build": "shx rm -rf dist && tsc -b && shx mkdir -p dist/resources && shx cp src/resources/*.json dist/resources/ && shx cp src/fixture-schema.json dist/fixture-schema.json",
     "lint": "eslint .",
     "postpack": "shx rm -f oclif.manifest.json",
     "posttest": "npm run lint",