n8n-nodes-mautic-advanced 1.3.7 → 1.3.9

package/dist/nodes/MauticAdvanced/ai-tools/runtime.js

@@ -3,6 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runtimeZod = exports.RuntimeDynamicStructuredTool = void 0;
 // nodes/MauticAdvanced/ai-tools/runtime.ts
 const module_1 = require("module");
+/**
+ * Anchor candidates — packages in n8n's dependency tree that can serve as a
+ * createRequire() anchor to resolve @langchain/core/tools and zod from n8n's
+ * own module tree (not this package's bundled devDependency copies).
+ *
+ * IMPORTANT: resolution must NEVER run at module-import time. n8n's
+ * node-directory-loader requires every node file in this package (including
+ * this one) purely to register node metadata, long before any workflow
+ * executes — and it aborts loading the ENTIRE package if any one file throws
+ * while being required. That used to be exactly what happened here: under
+ * pnpm-strict-isolated n8n installs (v2.29.x+) this package is installed
+ * outside n8n's own node_modules tree (e.g. ~/.n8n/nodes/), so neither
+ * anchor below resolves at all — @langchain/classic/@langchain/core are only
+ * reachable from inside @n8n/n8n-nodes-langchain's own isolated pnpm
+ * subtree, which no filesystem-based require.resolve() from here can walk
+ * into. The resulting throw took down the plain, non-AI `mauticAdvanced`
+ * node and its trigger too, not just this AI-tools node.
+ *
+ * Resolution is therefore deferred to first actual use, inside the Proxy
+ * traps below (which only fire when a connected AI tool is invoked at
+ * workflow-execution time via supplyData()). By then, n8n's own Agent/MCP
+ * Trigger machinery has already loaded @langchain/core/tools itself (to run
+ * its own tool-calling logic), so if the anchors still don't resolve, a
+ * require.cache scan finds the exact module instance n8n itself loaded —
+ * which works regardless of install layout.
+ */
 const ANCHOR_CANDIDATES = [
     // primary: @langchain/classic is a direct dep of @n8n/nodes-langchain, stable since n8n 2.4.x.
     // Its @langchain/core peerDep resolves to n8n's hoisted @langchain/core.
@@ -10,25 +36,224 @@ const ANCHOR_CANDIDATES = [
     // secondary: langchain package is in the n8n catalog and also has @langchain/core as peerDep.
     'langchain/agents',
 ];
-// require.resolve() works because n8n loads community nodes within its own module resolution
-// context. If future n8n isolates community node resolution, use
-// require.resolve(candidate, {paths: [n8nPackagePath]}) option.
-let runtimeRequire = null;
-const errors = [];
-for (const candidate of ANCHOR_CANDIDATES) {
+// Memoized ONLY on success — a failed attempt must not permanently disable
+// retries (e.g. the require.cache scan fallback below may only succeed on a
+// later call, once n8n has finished loading its own langchain-dependent
+// nodes).
+let _runtimeReq;
+let _anchorDiagnostic = null;
+function getRuntimeRequire() {
+    if (_runtimeReq)
+        return _runtimeReq;
+    const tried = [];
+    for (const candidate of ANCHOR_CANDIDATES) {
+        try {
+            const resolved = require.resolve(candidate);
+            _runtimeReq = (0, module_1.createRequire)(resolved);
+            _anchorDiagnostic = `resolved via anchor: ${candidate}`;
+            return _runtimeReq;
+        }
+        catch (e) {
+            tried.push(`${candidate}: ${e.message}`);
+        }
+    }
+    _anchorDiagnostic = `Could not resolve LangChain anchor. Tried:\n${tried.join('\n')}`;
+    return undefined;
+}
+/**
+ * Scans Node's process-global module cache (shared across every node_modules
+ * tree in this process, regardless of who loaded what) for an already-loaded
+ * module whose resolved path matches `pathPattern`, returning the first
+ * match whose exports satisfy `validate`. Must be called lazily (not at
+ * module load) — n8n requires node files for registration before any
+ * workflow runs, i.e. before langchain/zod are necessarily loaded into cache.
+ */
+function findCachedExports(pathPattern, validate, excludeKey) {
     try {
-        const resolved = require.resolve(candidate);
-        runtimeRequire = (0, module_1.createRequire)(resolved);
-        break;
+        // require.cache is the public, documented CommonJS alias that points at the exact
+        // same underlying object as the internal Module._cache. It is available directly in
+        // CJS module scope (this file compiles to CJS via tsc), so no require('module') needed.
+        const cache = require.cache;
+        if (!cache)
+            return undefined;
+        for (const key of Object.keys(cache)) {
+            if (!pathPattern.test(key))
+                continue;
+            if (excludeKey && excludeKey(key))
+                continue;
+            const entry = cache[key];
+            if (!entry)
+                continue;
+            const result = validate(entry.exports);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    catch (_e) {
+        // best-effort — require.cache introspection is not guaranteed across Node versions
+    }
+    return undefined;
+}
+let _RuntimeDynamicStructuredTool;
+let _runtimeZod;
+let _langchainLoadError = null;
+let _zodLoadError = null;
+let _zodDiagnostic = null;
+function resolveDynamicStructuredTool() {
+    if (_RuntimeDynamicStructuredTool)
+        return _RuntimeDynamicStructuredTool;
+    const runtimeReq = getRuntimeRequire();
+    if (runtimeReq) {
+        try {
+            const coreTools = runtimeReq('@langchain/core/tools');
+            if (typeof coreTools?.['DynamicStructuredTool'] === 'function') {
+                _RuntimeDynamicStructuredTool = coreTools['DynamicStructuredTool'];
+                return _RuntimeDynamicStructuredTool;
+            }
+        }
+        catch (e) {
+            _langchainLoadError = e.message;
+        }
     }
-    catch (e) {
-        errors.push(`${candidate}: ${e.message}`);
+    // Fallback for pnpm-isolated installs where no filesystem anchor reaches
+    // @langchain/core at all: it is loaded by n8n's own Agent/MCP Trigger
+    // machinery before our supplyData() ever runs, so grab it straight out of
+    // require.cache once it is resident.
+    const cached = findCachedExports(/[\\/]@langchain[\\/]core[\\/]/, (exports) => typeof exports['DynamicStructuredTool'] === 'function'
+        ? exports['DynamicStructuredTool']
+        : undefined);
+    if (cached) {
+        _RuntimeDynamicStructuredTool = cached;
+        _langchainLoadError = null;
     }
+    return _RuntimeDynamicStructuredTool;
 }
-if (!runtimeRequire) {
-    throw new Error(`[runtime.ts] Could not resolve LangChain anchor. Tried:\n${errors.join('\n')}\n` +
-        `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.`);
+function resolveZod() {
+    if (_runtimeZod)
+        return _runtimeZod;
+    // Three-step resolution, in priority order: require.main → anchor → require.cache scan.
+    //
+    // Primary path: resolve zod starting from n8n's own main entry point's module tree
+    // (require.main). For a correctly-installed (non-isolated) setup this lands on n8n's
+    // top-level zod — the exact copy n8n's own normalizeToolSchema does `instanceof ZodType`
+    // against. Even under pnpm-strict isolation this is a DIFFERENT resolution path than this
+    // package's own local require('zod'), so it is far more likely to reach n8n's real copy
+    // (or fail cleanly) than to silently return this package's OWN bundled zod. Resolved
+    // lazily here (NOT at module top level) so node registration never triggers it — that
+    // laziness is the entire point of this fix (#2).
+    //
+    // Only anchor at require.main when it is actually defined. When it is undefined (ESM-
+    // launched n8n, worker_threads / queue-mode workers — exactly the deployment mode #2 was
+    // filed against), there is NO useful main to anchor at: falling back to `__filename` would
+    // anchor at THIS file (mautic's own runtime.js), whose `require.resolve('zod')` lands on
+    // this package's OWN bundled zod — the copy that fails n8n's `instanceof ZodType` check.
+    // So resolve-then-check the path and skip it if it points into this package's own tree,
+    // reusing the same exclusion substring as the cache-scan path below.
+    if (require.main?.filename) {
+        try {
+            const mainReq = (0, module_1.createRequire)(require.main.filename);
+            const resolvedPath = mainReq.resolve('zod');
+            if (!resolvedPath.includes('n8n-nodes-mautic-advanced')) {
+                _runtimeZod = mainReq('zod');
+                if (_runtimeZod) {
+                    _zodDiagnostic = 'resolved zod via require.main';
+                    _zodLoadError = null;
+                    return _runtimeZod;
+                }
+            }
+        }
+        catch (e) {
+            _zodLoadError = e.message;
+        }
+    }
+    // Secondary path: the existing @langchain/classic / langchain anchor. Same resolve-then-
+    // check exclusion for defense-in-depth consistency — very unlikely to ever resolve into
+    // this package's own tree, but structurally guarded identically to the other two paths.
+    const runtimeReq = getRuntimeRequire();
+    if (runtimeReq) {
+        try {
+            const resolvedPath = runtimeReq.resolve('zod');
+            if (!resolvedPath.includes('n8n-nodes-mautic-advanced')) {
+                _runtimeZod = runtimeReq('zod');
+                if (_runtimeZod) {
+                    _zodDiagnostic = 'resolved zod via anchor';
+                    _zodLoadError = null;
+                    return _runtimeZod;
+                }
+            }
+        }
+        catch (e) {
+            _zodLoadError = e.message;
+        }
+    }
+    // Tertiary path: scan require.cache for an already-resident zod once neither
+    // filesystem resolution reaches it (pnpm-strict-isolated installs). The path regex is
+    // narrowed to zod's own entry-point directories (lib/dist/index/v3/v4) so it never
+    // matches zod-adjacent package names (e.g. zod-to-json-schema). Validate the exports
+    // look like zod via `ZodType` (the class n8n's normalizeToolSchema does `instanceof`
+    // against — the meaningful correctness signal) plus the `object` factory our
+    // schema-generator calls.
+    //
+    // Exclusion guard: this package declares zod as a REAL dependency and imports it at
+    // node-registration time (schema-generator.ts), so this package's OWN bundled zod is
+    // ALWAYS resident in require.cache — potentially earlier in iteration order than n8n's.
+    // We specifically want a DIFFERENT copy (n8n's), because a self-bundled copy would fail
+    // n8n's `instanceof ZodType` class-identity check. So skip any cache key belonging to
+    // this package's own bundled zod. (The pathPattern has already matched the zod segment,
+    // so a package-name match on the key is sufficient and robust to both nested
+    // `.../n8n-nodes-mautic-advanced/node_modules/zod/...` and flatter install layouts.)
+    const cached = findCachedExports(/[\\/]zod[\\/](lib|dist|index|v3|v4)/, (exports) => typeof exports['ZodType'] === 'function' && typeof exports['object'] === 'function'
+        ? exports
+        : undefined, (key) => key.includes('n8n-nodes-mautic-advanced'));
+    if (cached) {
+        _runtimeZod = cached;
+        _zodLoadError = null;
+        _zodDiagnostic = 'resolved zod via require.cache scan (pnpm-isolated install)';
+    }
+    return _runtimeZod;
 }
-const coreTools = runtimeRequire('@langchain/core/tools');
-exports.RuntimeDynamicStructuredTool = coreTools['DynamicStructuredTool'];
-exports.runtimeZod = runtimeRequire('zod');
+// IMPORTANT: Proxy target MUST be `function () {}`, not `{}`.
+// ECMAScript spec §10.5.13: a Proxy only has [[Construct]] if its target does.
+// Plain objects lack [[Construct]], so `new Proxy({}, ...)` throws
+// "is not a constructor" before the construct trap ever fires.
+exports.RuntimeDynamicStructuredTool = new Proxy(function () { }, {
+    construct(_target, args) {
+        const ctor = resolveDynamicStructuredTool();
+        if (!ctor) {
+            throw new Error(`[MauticAdvancedAiTools] Could not resolve LangChain's DynamicStructuredTool. ` +
+                `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.` +
+                (_anchorDiagnostic ? ` Diagnostic: ${_anchorDiagnostic}` : '') +
+                (_langchainLoadError ? ` Load error: ${_langchainLoadError}` : ''));
+        }
+        return new ctor(...args);
+    },
+    get(_target, prop) {
+        const ctor = resolveDynamicStructuredTool();
+        if (ctor) {
+            return ctor[prop];
+        }
+        return undefined;
+    },
+});
+exports.runtimeZod = new Proxy({}, {
+    get(_target, prop) {
+        // Guard: frameworks probe Symbol.toPrimitive, Symbol.toStringTag, .then
+        // (Promise thenable), and .constructor. Throwing on these causes
+        // misleading errors during structural inspection.
+        if (typeof prop === 'symbol' || prop === 'then' || prop === 'constructor')
+            return undefined;
+        const z = resolveZod();
+        if (!z) {
+            throw new Error(`[MauticAdvancedAiTools] Could not resolve zod (accessing .${String(prop)}) ` +
+                `via require.main, LangChain anchor, or require.cache scan. ` +
+                `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.` +
+                (_zodDiagnostic
+                    ? ` Diagnostic: ${_zodDiagnostic}`
+                    : _anchorDiagnostic
+                        ? ` Diagnostic: ${_anchorDiagnostic}`
+                        : '') +
+                (_zodLoadError ? ` Load error: ${_zodLoadError}` : ''));
+        }
+        return z[prop];
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-mautic-advanced",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "Enhanced n8n node for Mautic with comprehensive API coverage including tags, campaigns, categories, and advanced contact management",
   "keywords": [
     "n8n",
@@ -72,5 +72,13 @@
     "@types/change-case": "^0.0.30",
     "change-case": "^5.4.4",
     "zod": "^3.22.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": "*"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": {
+      "optional": true
+    }
   }
 }