@ha-bits/cortex 1.0.4 → 1.0.6

package/README.md

@@ -47,7 +47,7 @@ Cortex uses `createRequire` from Node.js's `module` API instead of the standard
 
 1. **Bundler Compatibility**: When the code is bundled with esbuild/webpack then ncc, the bundler transforms `require()` calls and creates a static context that can't resolve paths determined at runtime.
 
-2. **Dynamic Path Resolution**: Activepieces modules are downloaded to `/tmp/habits-nodes/` or wherever the env points to at runtime and their paths aren't known at build time. Using `createRequire(__filename)` creates a fresh require function that bypasses the bundler's static analysis.
+2. **Dynamic Path Resolution**: Activepieces modules are downloaded to `/tmp/habits-nodes/` or wherever the env points to at runtime (HABITS_NODES_PATH) and their paths aren't known at build time. Using `createRequire(__filename)` creates a fresh require function that bypasses the bundler's static analysis.
 
 3. **Production Environment**: In production (`/app/dist/pack/index.cjs`), the bundled code would throw "Cannot find module" errors with regular `require()` because webpack's `webpackEmptyContext` can't resolve dynamic paths.
 

package/pack/index.cjs

@@ -254452,17 +254452,59 @@ var import_uuid = __nccwpck_require__(12048);
 
 // packages/cortex/server/src/utils/moduleLoader.ts
 var path3 = __toESM(__nccwpck_require__(16928));
-var import_child_process2 = __nccwpck_require__(35317);
-var import_util2 = __nccwpck_require__(39023);
 
 // packages/cortex/server/src/utils/moduleCloner.ts
 var fs = __toESM(__nccwpck_require__(79896));
 var path2 = __toESM(__nccwpck_require__(16928));
-var import_child_process = __nccwpck_require__(35317);
-var import_util = __nccwpck_require__(39023);
+var import_child_process2 = __nccwpck_require__(35317);
+var import_util2 = __nccwpck_require__(39023);
 
 // packages/cortex/server/src/utils/utils.ts
 var path = __toESM(__nccwpck_require__(16928));
+var import_child_process = __nccwpck_require__(35317);
+var import_util = __nccwpck_require__(39023);
+var logger = console;
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+function buildNpmInstallCommand(packageSpec, options = {}) {
+  const parts = ["npm", "install"];
+  const prefix = getNodesBasePath();
+  if (packageSpec) {
+    parts.push(packageSpec);
+  }
+  if (options.global) {
+    parts.push("-g");
+  }
+  if (options.legacyPeerDeps) {
+    parts.push("--legacy-peer-deps");
+  }
+  if (options.includePeer) {
+    parts.push("--include=peer");
+  }
+  if (options.production) {
+    parts.push("--production");
+  }
+  if (options.noSave) {
+    parts.push("--no-save");
+  }
+  parts.push(`--prefix ${prefix}`);
+  parts.push(`--save`);
+  if (options.saveOptional) {
+    parts.push("--save-optional");
+  }
+  return parts.join(" ");
+}
+async function npmInstall(packageSpec, options = {}) {
+  const command = buildNpmInstallCommand(packageSpec, options);
+  const execOptions = {};
+  if (options.cwd) {
+    execOptions.cwd = options.cwd;
+  }
+  if (options.timeout) {
+    execOptions.timeout = options.timeout;
+  }
+  logger.log(`Executing command: ${command}`);
+  return execAsync(command, execOptions);
+}
 var NODES_BASE_PATH_ENV = "HABITS_NODES_PATH";
 var DEFAULT_NODES_BASE_PATH = "/tmp/habits-nodes";
 var cachedNodesBasePath = null;
@@ -254478,14 +254520,14 @@ function getNodesBasePath() {
   return cachedNodesBasePath;
 }
 function getNodesPath(framework) {
-  return path.join(getNodesBasePath(), "nodes", framework);
+  return path.join(getNodesBasePath(), "node_modules");
 }
 function getModuleFullPath(framework, moduleName) {
-  return path.join(getNodesBasePath(), "nodes", framework, moduleName);
+  return path.join(getNodesBasePath(), "node_modules", moduleName);
 }
 
 // packages/cortex/server/src/utils/moduleCloner.ts
-var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
 function getShimsPath() {
   const distShimsPath = path2.join(__dirname, "..", "shims");
   if (fs.existsSync(distShimsPath) && fs.existsSync(path2.join(distShimsPath, "n8n-workflow", "index.js"))) {
@@ -254503,7 +254545,7 @@ function getShimsPath() {
 }
 async function areShimsLinkedGlobally() {
   try {
-    const { stdout } = await execAsync('npm ls -g --depth=0 --json 2>/dev/null || echo "{}"');
+    const { stdout } = await execAsync2('npm ls -g --depth=0 --json 2>/dev/null || echo "{}"');
     const globalPackages = JSON.parse(stdout);
     return globalPackages.dependencies?.["n8n-workflow"]?.version === "999.0.0";
   } catch {
@@ -254526,13 +254568,85 @@ async function registerShimsGlobally() {
     }
     console.log(`\u{1F517} Registering ${shimName} shim globally...`);
     try {
-      await execAsync("npm link", { cwd: shimPath, timeout: 3e4 });
+      await execAsync2("npm link", { cwd: shimPath, timeout: 3e4 });
       console.log(`\u2713 Registered ${shimName} shim globally`);
     } catch (error) {
       console.warn(`\u26A0\uFE0F  Failed to register ${shimName} shim globally: ${error.message}`);
     }
   }
 }
+var ACTIVEPIECES_PEER_DEPS = [
+  "@activepieces/pieces-common",
+  "@activepieces/pieces-framework",
+  "@activepieces/shared"
+];
+function getActivepiecesPackagesPath() {
+  const possiblePaths = [
+    // Development: relative to the source file
+    path2.join(__dirname, "..", "..", "..", "..", "..", "node_modules"),
+    // Packed: relative to dist folder
+    path2.join(__dirname, "..", "..", "..", "..", "node_modules"),
+    // From process.cwd()
+    path2.join(process.cwd(), "node_modules"),
+    // Parent directories from cwd
+    path2.join(process.cwd(), "..", "node_modules"),
+    path2.join(process.cwd(), "..", "..", "node_modules"),
+    // NEW: In case of the newer setup where nodes are in getNodesBasePath()
+    path2.join(getNodesBasePath(), "node_modules")
+  ];
+  for (const basePath of possiblePaths) {
+    const testPath = path2.join(basePath, "@activepieces", "pieces-framework");
+    if (fs.existsSync(testPath)) {
+      return basePath;
+    }
+  }
+  return null;
+}
+async function linkActivepiecesDeps(modulePath, moduleName) {
+  const cortexNodeModules = getActivepiecesPackagesPath();
+  if (!cortexNodeModules) {
+    console.warn(`\u26A0\uFE0F  Could not find cortex node_modules with ActivePieces packages`);
+    return;
+  }
+  console.log(`\u{1F517} Linking ActivePieces peer dependencies for ${moduleName}...`);
+  const moduleNodeModules = path2.join(modulePath, "node_modules");
+  const activepiecesDir = path2.join(moduleNodeModules, "@activepieces");
+  if (!fs.existsSync(activepiecesDir)) {
+    fs.mkdirSync(activepiecesDir, { recursive: true });
+  }
+  for (const dep of ACTIVEPIECES_PEER_DEPS) {
+    const [scope, pkgName] = dep.split("/");
+    const sourcePackagePath = path2.join(cortexNodeModules, scope, pkgName);
+    const targetPackagePath = path2.join(moduleNodeModules, scope, pkgName);
+    if (!fs.existsSync(sourcePackagePath)) {
+      console.warn(`\u26A0\uFE0F  Source package not found: ${sourcePackagePath}`);
+      continue;
+    }
+    if (fs.existsSync(targetPackagePath)) {
+      try {
+        const stats = fs.lstatSync(targetPackagePath);
+        if (stats.isSymbolicLink()) {
+          const linkTarget = fs.readlinkSync(targetPackagePath);
+          if (linkTarget === sourcePackagePath || linkTarget.endsWith(path2.join(scope, pkgName))) {
+            console.log(`\u2713 ${dep} already linked for ${moduleName}`);
+            continue;
+          }
+        }
+        fs.rmSync(targetPackagePath, { recursive: true, force: true });
+      } catch (e) {
+      }
+    }
+    try {
+      fs.symlinkSync(sourcePackagePath, targetPackagePath, "dir");
+      console.log(`\u2713 Linked ${dep} for ${moduleName}`);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Failed to link ${dep}: ${error.message}`);
+    }
+  }
+}
+async function ensureActivepiecesDepsLinked(modulePath, moduleName) {
+  await linkActivepiecesDeps(modulePath, moduleName);
+}
 async function linkN8nShims(modulePath, moduleName) {
   const shimsPath = getShimsPath();
   if (!await areShimsLinkedGlobally()) {
@@ -254547,7 +254661,7 @@ async function linkN8nShims(modulePath, moduleName) {
     }
     console.log(`\u{1F517} Linking ${shimName} shim for ${moduleName}...`);
     try {
-      await execAsync(`npm link ${shimName}`, { cwd: modulePath, timeout: 3e4 });
+      await execAsync2(`npm link ${shimName}`, { cwd: modulePath, timeout: 3e4 });
       console.log(`\u2713 Linked ${shimName} shim for ${moduleName}`);
     } catch (error) {
       console.log(`\u2139\uFE0F  npm link failed, using manual link for ${shimName}...`);
@@ -254619,7 +254733,7 @@ async function cloneModule(moduleDefinition, targetDir) {
     if (!fs.existsSync(targetDir)) {
       fs.mkdirSync(targetDir, { recursive: true });
     }
-    const { stdout, stderr } = await execAsync(
+    const { stdout, stderr } = await execAsync2(
       `git clone ${repository} ${modulePath}`,
       { cwd: targetDir }
     );
@@ -254631,13 +254745,12 @@ async function cloneModule(moduleDefinition, targetDir) {
       console.log(`\u{1F4E6} Installing dependencies for ${name}...`);
       try {
         await linkN8nShims(modulePath, name);
-        const { stdout: stdout2, stderr: stderr2 } = await execAsync("npm install --legacy-peer-deps", {
-          cwd: modulePath,
-          timeout: 18e4
-          // 3 minutes timeout for larger repos
-        });
+        await npmInstall(void 0, { cwd: modulePath, legacyPeerDeps: true, includePeer: true, timeout: 18e4 });
         console.log(`\u2713 Dependencies installed for ${name}`);
         await removeN8nPackagesIfReinstalled(modulePath, name);
+        if (moduleDefinition.framework === "activepieces") {
+          await ensureActivepiecesDepsLinked(modulePath, name);
+        }
       } catch (error) {
         console.warn(`\u26A0\uFE0F  Warning: Failed to install dependencies for ${name}: ${error.message}`);
       }
@@ -254654,12 +254767,11 @@ async function buildModule(moduleDefinition, modulePath) {
   console.log(`\u{1F4E6} Installing production dependencies for ${name}...`);
   try {
     await linkN8nShims(modulePath, name);
-    const { stdout, stderr } = await execAsync("npm install --production --legacy-peer-deps", {
-      cwd: modulePath,
-      timeout: 12e4
-      // 2 minutes timeout
-    });
+    await npmInstall(void 0, { cwd: modulePath, legacyPeerDeps: true, includePeer: true, production: true, timeout: 12e4 });
     await removeN8nPackagesIfReinstalled(modulePath, name);
+    if (moduleDefinition.framework === "activepieces") {
+      await ensureActivepiecesDepsLinked(modulePath, name);
+    }
   } catch (error) {
     console.warn(`\u26A0\uFE0F  Warning: Failed to install production dependencies for ${name}: ${error.message}`);
   }
@@ -254674,7 +254786,7 @@ async function buildModule(moduleDefinition, modulePath) {
   }
   console.log(`\u{1F528} Building ${name} with command: ${buildCommand}`);
   try {
-    const { stdout, stderr } = await execAsync(buildCommand, {
+    const { stdout, stderr } = await execAsync2(buildCommand, {
       cwd: modulePath,
       maxBuffer: 1024 * 1024 * 10
       // 10MB buffer
@@ -254830,17 +254942,15 @@ async function installNpmModule(moduleDefinition, targetDir) {
     console.log(`\u2713 Module ${name} already installed at ${modulePath}`);
     return modulePath;
   }
-  console.log(`\u{1F4E6} Installing ${name} from npm registry (${packageName})...`);
+  const prefix = getNodesBasePath();
+  console.log(`\u{1F4E6} Installing ${name} from npm registry (${packageName}) to ${prefix}...`);
   try {
     if (!fs.existsSync(targetDir)) {
       fs.mkdirSync(targetDir, { recursive: true });
     }
     const tempDir = path2.join(targetDir, `.temp-${name}`);
     fs.mkdirSync(tempDir, { recursive: true });
-    const { stdout, stderr } = await execAsync(
-      `npm install ${packageName} --no-save --prefix .`,
-      { cwd: tempDir }
-    );
+    const { stdout, stderr } = await npmInstall(packageName, { cwd: tempDir, noSave: true, prefix, includePeer: true });
     if (stderr && !stderr.includes("npm warn")) {
       console.warn(`Install warnings: ${stderr}`);
     }
@@ -254894,13 +255004,12 @@ async function installNpmModule(moduleDefinition, targetDir) {
       console.log(`\u{1F4E6} Installing dependencies for ${name}...`);
       try {
         await linkN8nShims(modulePath, name);
-        const { stdout: stdout2, stderr: stderr2 } = await execAsync("npm install --legacy-peer-deps", {
-          cwd: modulePath,
-          timeout: 12e4
-          // 2 minutes timeout
-        });
+        await npmInstall(void 0, { cwd: modulePath, legacyPeerDeps: true, includePeer: true, timeout: 12e4 });
         console.log(`\u2713 Dependencies installed for ${name}`);
         await removeN8nPackagesIfReinstalled(modulePath, name);
+        if (moduleDefinition.framework === "activepieces") {
+          await ensureActivepiecesDepsLinked(modulePath, name);
+        }
       } catch (error) {
         console.warn(`\u26A0\uFE0F  Warning: Failed to install dependencies for ${name}: ${error.message}`);
       }
@@ -254921,6 +255030,39 @@ function getModulePath(moduleDefinition) {
 }
 function getModuleMainFile(moduleDefinition) {
   const modulePath = getModulePath(moduleDefinition);
+  const packageJsonPath = path2.join(modulePath, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      let mainEntry = packageJson.main || packageJson.module;
+      if (!mainEntry && packageJson.exports) {
+        if (typeof packageJson.exports === "string") {
+          mainEntry = packageJson.exports;
+        } else if (packageJson.exports["."]) {
+          const dotExport = packageJson.exports["."];
+          if (typeof dotExport === "string") {
+            mainEntry = dotExport;
+          } else if (dotExport.require) {
+            mainEntry = dotExport.require;
+          } else if (dotExport.import) {
+            mainEntry = dotExport.import;
+          } else if (dotExport.default) {
+            mainEntry = dotExport.default;
+          }
+        }
+      }
+      if (mainEntry) {
+        mainEntry = mainEntry.replace(/^\.\//, "");
+        const mainPath = path2.join(modulePath, mainEntry);
+        if (fs.existsSync(mainPath)) {
+          console.log(`\u2713 Found main file from package.json for module: ${moduleDefinition.repository} at path: ${mainPath}`);
+          return mainPath;
+        }
+      }
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Failed to parse package.json for ${moduleDefinition.repository}`);
+    }
+  }
   const commonPaths = [
     "dist/index.js",
     "dist/main.js",
@@ -254945,7 +255087,6 @@ function getModuleMainFile(moduleDefinition) {
 }
 
 // packages/cortex/server/src/utils/moduleLoader.ts
-var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
 function getModuleName(moduleDefinition) {
   if (moduleDefinition.source === "github") {
     const url = moduleDefinition.repository;
@@ -254988,7 +255129,7 @@ var fs2 = __toESM(__nccwpck_require__(79896));
 var import_axios = __toESM(__nccwpck_require__(87269));
 var import_form_data = __toESM(__nccwpck_require__(96454));
 var import_module = __nccwpck_require__(73339);
-var logger = console;
+var logger2 = console;
 var credentialTypeCache = /* @__PURE__ */ new Map();
 function loadCredentialType(moduleDefinition, credentialTypeName) {
   if (credentialTypeCache.has(credentialTypeName)) {
@@ -255017,7 +255158,7 @@ function loadCredentialType(moduleDefinition, credentialTypeName) {
                 const instance = new exported();
                 if (instance && instance.name === credentialTypeName) {
                   credentialTypeCache.set(credentialTypeName, instance);
-                  logger.log(`\u{1F4CB} Loaded credential type: ${credentialTypeName}`);
+                  logger2.log(`\u{1F4CB} Loaded credential type: ${credentialTypeName}`);
                   return instance;
                 }
               } catch (e) {
@@ -255029,7 +255170,7 @@ function loadCredentialType(moduleDefinition, credentialTypeName) {
       }
     }
   } catch (error) {
-    logger.warn(`Failed to load credential type ${credentialTypeName}: ${error}`);
+    logger2.warn(`Failed to load credential type ${credentialTypeName}: ${error}`);
   }
   return null;
 }
@@ -255045,7 +255186,7 @@ function resolveCredentialExpression(expression, credentials) {
 function applyCredentialAuthentication(requestOptions, credentialType, credentials) {
   const auth = credentialType.authenticate;
   if (!auth) {
-    logger.warn(`Credential type ${credentialType.name} has no authenticate property`);
+    logger2.warn(`Credential type ${credentialType.name} has no authenticate property`);
     return;
   }
   if (typeof auth === "object" && auth.type === "generic") {
@@ -255092,9 +255233,9 @@ function applyCredentialAuthentication(requestOptions, credentialType, credentia
       );
       requestOptions.auth = { username, password };
     }
-    logger.log(`\u2705 Applied generic authentication from credential type: ${credentialType.name}`);
+    logger2.log(`\u2705 Applied generic authentication from credential type: ${credentialType.name}`);
   } else if (typeof auth === "function") {
-    logger.warn(`Function-based authentication not yet supported for ${credentialType.name}`);
+    logger2.warn(`Function-based authentication not yet supported for ${credentialType.name}`);
   }
 }
 function applyFallbackAuthentication(headers, credentials) {
@@ -255196,7 +255337,7 @@ async function httpRequest(requestOptions) {
   if (axiosConfig.data === void 0 || axiosConfig.method?.toUpperCase() === "GET") {
     delete axiosConfig.data;
   }
-  logger.log(`\u{1F310} Making HTTP request: ${axiosConfig.method} ${axiosConfig.url}`);
+  logger2.log(`\u{1F310} Making HTTP request: ${axiosConfig.method} ${axiosConfig.url}`);
   try {
     const response = await (0, import_axios.default)(axiosConfig);
     if (requestOptions.returnFullResponse) {
@@ -255210,7 +255351,7 @@ async function httpRequest(requestOptions) {
     return response.data;
   } catch (error) {
     if (error.response) {
-      logger.error(`HTTP Error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
+      logger2.error(`HTTP Error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
       throw new Error(`HTTP Error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
     }
     throw error;
@@ -255446,22 +255587,22 @@ function createExecutionContext(node, params, options) {
     getInstanceId: () => "instance-1",
     // Logging
     logger: {
-      info: (...args) => logger.log("[n8n]", ...args),
-      warn: (...args) => logger.warn("[n8n]", ...args),
-      error: (...args) => logger.error("[n8n]", ...args),
-      debug: (...args) => logger.log("[n8n:debug]", ...args)
+      info: (...args) => logger2.log("[n8n]", ...args),
+      warn: (...args) => logger2.warn("[n8n]", ...args),
+      error: (...args) => logger2.error("[n8n]", ...args),
+      debug: (...args) => logger2.log("[n8n:debug]", ...args)
     },
     // Send message to UI (no-op in headless execution)
     sendMessageToUI: (message) => {
-      logger.log("[n8n:ui]", message);
+      logger2.log("[n8n:ui]", message);
     },
     // Put execution to wait (for wait nodes)
     putExecutionToWait: async (waitTill) => {
-      logger.log(`[n8n] Waiting until: ${waitTill.toISOString()}`);
+      logger2.log(`[n8n] Waiting until: ${waitTill.toISOString()}`);
     },
     // Send response (for webhook response nodes)
     sendResponse: (response) => {
-      logger.log("[n8n] Sending response:", response);
+      logger2.log("[n8n] Sending response:", response);
     },
     // Prepare output data - transforms INodeExecutionData[] to INodeExecutionData[][]
     prepareOutputData: async (outputData, outputIndex = 0) => {
@@ -255476,22 +255617,22 @@ function createExecutionContext(node, params, options) {
 }
 function getN8nNodeFile(moduleDefinition) {
   const modulePath = getModulePath(moduleDefinition);
-  logger.log(`
+  logger2.log(`
 \u{1F50D} getN8nNodeFile looking for module at: ${modulePath}`);
-  logger.log(`   Source: ${moduleDefinition.source}`);
+  logger2.log(`   Source: ${moduleDefinition.source}`);
   const packageJsonPath = path4.join(modulePath, "package.json");
   if (!fs2.existsSync(packageJsonPath)) {
-    logger.error(`package.json not found at: ${packageJsonPath}`);
+    logger2.error(`package.json not found at: ${packageJsonPath}`);
     return null;
   }
-  logger.log(`   Found package.json at: ${packageJsonPath}`);
+  logger2.log(`   Found package.json at: ${packageJsonPath}`);
   try {
     const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
     if (packageJson.n8n?.nodes && packageJson.n8n.nodes.length > 0) {
       const nodeFile = packageJson.n8n.nodes[0];
       const fullPath = path4.join(modulePath, nodeFile);
       if (fs2.existsSync(fullPath)) {
-        logger.log(`\u{1F50D} Found n8n node at: ${fullPath}`);
+        logger2.log(`\u{1F50D} Found n8n node at: ${fullPath}`);
         return fullPath;
       }
     }
@@ -255505,14 +255646,14 @@ function getN8nNodeFile(moduleDefinition) {
       if (fs2.existsSync(dir) && fs2.statSync(dir).isDirectory()) {
         const nodeFile = findNodeFileInDirectory(dir);
         if (nodeFile) {
-          logger.log(`\u{1F50D} Found n8n node via search at: ${nodeFile}`);
+          logger2.log(`\u{1F50D} Found n8n node via search at: ${nodeFile}`);
           return nodeFile;
         }
       }
     }
     return null;
   } catch (error) {
-    logger.error(`Error reading package.json: ${error.message}`);
+    logger2.error(`Error reading package.json: ${error.message}`);
     return null;
   }
 }
@@ -255536,7 +255677,7 @@ async function executeN8nModule(paramsOrModuleName, maybeParams) {
   let moduleDefinition;
   let executionParams;
   if (typeof paramsOrModuleName === "string") {
-    logger.log(`
+    logger2.log(`
 \u{1F4CB} executeN8nModule called with string: ${paramsOrModuleName}`);
     moduleDefinition = {
       framework: "n8n",
@@ -255545,11 +255686,11 @@ async function executeN8nModule(paramsOrModuleName, maybeParams) {
     };
     executionParams = maybeParams || {};
   } else {
-    logger.log(`
+    logger2.log(`
 \u{1F4CB} executeN8nModule called with params object:`);
-    logger.log(`   Framework: ${paramsOrModuleName.framework}`);
-    logger.log(`   Source: ${paramsOrModuleName.source}`);
-    logger.log(`   ModuleName: ${paramsOrModuleName.moduleName}`);
+    logger2.log(`   Framework: ${paramsOrModuleName.framework}`);
+    logger2.log(`   Source: ${paramsOrModuleName.source}`);
+    logger2.log(`   ModuleName: ${paramsOrModuleName.moduleName}`);
     moduleDefinition = {
       framework: paramsOrModuleName.framework,
       source: paramsOrModuleName.source,
@@ -255558,7 +255699,7 @@ async function executeN8nModule(paramsOrModuleName, maybeParams) {
     executionParams = paramsOrModuleName.params;
   }
   const inferredModuleName = getModuleName(moduleDefinition);
-  logger.log(`
+  logger2.log(`
 \u{1F50D} Ensuring n8n module is ready: ${inferredModuleName}`);
   await ensureModuleInstalled(moduleDefinition);
   let mainFilePath = getN8nNodeFile(moduleDefinition);
@@ -255568,7 +255709,7 @@ async function executeN8nModule(paramsOrModuleName, maybeParams) {
   if (!mainFilePath) {
     throw new Error(`Could not locate node file for n8n module: ${inferredModuleName}`);
   }
-  logger.log(`\u{1F4E6} n8n node file at: ${mainFilePath}`);
+  logger2.log(`\u{1F4E6} n8n node file at: ${mainFilePath}`);
   try {
     return await executeGenericN8nNode(executionParams, moduleDefinition, mainFilePath);
   } catch (error) {
@@ -255592,7 +255733,7 @@ async function loadNodeFromModule(moduleDefinition, mainFilePath) {
           const instance = new exported();
           if (instance && typeof instance === "object" && "description" in instance) {
             nodeInstance = instance;
-            logger.debug(`Found n8n node class: ${key}`);
+            logger2.debug(`Found n8n node class: ${key}`);
             break;
           }
         } catch (e) {
@@ -255606,17 +255747,17 @@ async function loadNodeFromModule(moduleDefinition, mainFilePath) {
     return nodeInstance;
   } catch (error) {
     process.chdir(originalCwd);
-    logger.error(error.stack);
+    logger2.error(error.stack);
     throw error;
   }
 }
 async function executeGenericN8nNode(params, moduleDefinition, mainFilePath) {
   try {
     const node = await loadNodeFromModule(moduleDefinition, mainFilePath);
-    logger.log(`\u{1F680} Executing n8n node: ${node.description.displayName}`);
+    logger2.log(`\u{1F680} Executing n8n node: ${node.description.displayName}`);
     const operation = params.operation;
     const resource = params.resource;
-    logger.log(`Resource: ${resource || "default"}, Operation: ${operation || "default"}`);
+    logger2.log(`Resource: ${resource || "default"}, Operation: ${operation || "default"}`);
     const paramsWithModule = {
       ...params,
       __moduleDefinition: moduleDefinition
@@ -255626,12 +255767,12 @@ async function executeGenericN8nNode(params, moduleDefinition, mainFilePath) {
     if (node.execute) {
       result = await node.execute.call(context);
     } else if (node.description.requestDefaults || hasRoutingInDescription(node.description)) {
-      logger.log(`\u{1F4E1} Using routing-based execution for declarative node`);
+      logger2.log(`\u{1F4E1} Using routing-based execution for declarative node`);
       result = await executeRoutingBasedNode(node, paramsWithModule, context);
     } else {
       throw new Error(`Node does not have an execute method and is not a routing-based node`);
     }
-    logger.log(`\u2705 Successfully executed n8n node: ${node.description.displayName}`);
+    logger2.log(`\u2705 Successfully executed n8n node: ${node.description.displayName}`);
     const output = result?.[0]?.map((item) => item.json) || result;
     return {
       success: true,
@@ -255647,8 +255788,8 @@ async function executeGenericN8nNode(params, moduleDefinition, mainFilePath) {
       }
     };
   } catch (error) {
-    logger.error(`Failed to execute n8n node: ${error.message}`);
-    logger.error(error.stack);
+    logger2.error(`Failed to execute n8n node: ${error.message}`);
+    logger2.error(error.stack);
     throw error;
   }
 }
@@ -255686,7 +255827,7 @@ async function executeRoutingBasedNode(node, params, context) {
   if (!routingConfig) {
     throw new Error(`No routing configuration found for operation: ${operation}`);
   }
-  logger.log(`\u{1F4E1} Found routing config for operation: ${operation}`);
+  logger2.log(`\u{1F4E1} Found routing config for operation: ${operation}`);
   const requestDefaults = description.requestDefaults || {};
   const requestConfig = routingConfig.request || {};
   let url = requestConfig.url || "";
@@ -255750,8 +255891,8 @@ async function executeRoutingBasedNode(node, params, context) {
       applyFallbackAuthentication(headers, creds);
     }
   }
-  logger.log(`\u{1F310} Making routing-based request: ${method} ${url}`);
-  logger.log(`\u{1F4E4} Request body:`, JSON.stringify(body));
+  logger2.log(`\u{1F310} Making routing-based request: ${method} ${url}`);
+  logger2.log(`\u{1F4E4} Request body:`, JSON.stringify(body));
   const axiosConfig = {
     method,
     url,
@@ -255764,7 +255905,7 @@ async function executeRoutingBasedNode(node, params, context) {
   }
   try {
     const response = await (0, import_axios.default)(axiosConfig);
-    logger.log(`\u2705 Routing-based request successful: ${response.status}`);
+    logger2.log(`\u2705 Routing-based request successful: ${response.status}`);
     if (requestConfig.encoding === "arraybuffer" || response.headers["content-type"]?.includes("audio")) {
       const binaryData = Buffer.from(response.data);
       const base64Data = binaryData.toString("base64");
@@ -255790,7 +255931,7 @@ async function executeRoutingBasedNode(node, params, context) {
     if (error.response) {
       const errorData = error.response.data;
       const errorMessage = Buffer.isBuffer(errorData) ? errorData.toString("utf-8") : JSON.stringify(errorData);
-      logger.error(`HTTP Error (${error.response.status}): ${errorMessage}`);
+      logger2.error(`HTTP Error (${error.response.status}): ${errorMessage}`);
       throw new Error(`HTTP Error (${error.response.status}): ${errorMessage}`);
     }
     throw error;
@@ -255847,7 +255988,7 @@ function resolveParamValue(value) {
 var path5 = __toESM(__nccwpck_require__(16928));
 var import_module2 = __nccwpck_require__(73339);
 var import_shared = __nccwpck_require__(92279);
-var logger2 = console;
+var logger3 = console;
 async function executeActivepiecesModule(params) {
   const moduleDefinition = {
     framework: params.framework,
@@ -255890,18 +256031,18 @@ async function pieceFromModule(moduleDefinition) {
     return piece;
   } catch (error) {
     process.chdir(originalCwd);
-    logger2.error(error.stack);
+    logger3.error(error.stack);
     throw error;
   }
 }
 async function executeGenericActivepiecesPiece(params, moduleDefinition) {
   try {
     const piece = await pieceFromModule(moduleDefinition);
-    logger2.log(`\u{1F680} Executing Activepieces piece: ${piece.displayName}`);
+    logger3.log(`\u{1F680} Executing Activepieces piece: ${piece.displayName}`);
     const actionName = params.params.operation;
     const pieceActions = piece.actions();
-    logger2.log(`Available actions: ${Object.keys(pieceActions).join(", ")}`);
-    logger2.log(`Requested action: ${actionName}`);
+    logger3.log(`Available actions: ${Object.keys(pieceActions).join(", ")}`);
+    logger3.log(`Requested action: ${actionName}`);
     const action = piece.actions()[actionName];
     if (!action) {
       throw new Error(`Action '${actionName}' not found in piece '${piece.displayName}'. Available actions: ${Object.keys(pieceActions).join(", ")}`);
@@ -255912,7 +256053,7 @@ async function executeGenericActivepiecesPiece(params, moduleDefinition) {
       const credentialKeys = Object.keys(credentials);
       if (credentialKeys.length > 0) {
         auth = credentials[credentialKeys[0]];
-        logger2.log(`\u{1F510} Using credentials for: ${credentialKeys[0]}`);
+        logger3.log(`\u{1F510} Using credentials for: ${credentialKeys[0]}`);
       }
     }
     const result = await action.run({
@@ -255921,7 +256062,7 @@ async function executeGenericActivepiecesPiece(params, moduleDefinition) {
         ...actionProps
       }
     });
-    logger2.log(`\u2705 Successfully executed Activepieces piece action: ${actionName}`, result);
+    logger3.log(`\u2705 Successfully executed Activepieces piece action: ${actionName}`, result);
     return {
       success: true,
       module: moduleDefinition.repository,
@@ -255936,7 +256077,7 @@ async function executeGenericActivepiecesPiece(params, moduleDefinition) {
       }
     };
   } catch (error) {
-    logger2.error(error.stack);
+    logger3.error(error.stack);
     throw error;
   }
 }
@@ -255947,7 +256088,7 @@ var import_shared2 = __nccwpck_require__(92279);
 var import_module3 = __nccwpck_require__(73339);
 var import_shared3 = __nccwpck_require__(92279);
 var path6 = __toESM(__nccwpck_require__(16928));
-var logger3 = console;
+var logger4 = console;
 function createSimpleStore(prefix = "") {
   const storage = /* @__PURE__ */ new Map();
   return {
@@ -255975,7 +256116,7 @@ var triggerHelper = {
     if (!mainFilePath) {
       throw new Error(`Could not locate main file for module: ${moduleName}`);
     }
-    logger3.log(`\u{1F4E6} Loading piece from: ${mainFilePath}`);
+    logger4.log(`\u{1F4E6} Loading piece from: ${mainFilePath}`);
     const originalCwd = process.cwd();
     const moduleDir = path6.dirname(mainFilePath);
     try {
@@ -255999,7 +256140,7 @@ var triggerHelper = {
       return piece;
     } catch (error) {
       process.chdir(originalCwd);
-      logger3.error(error.stack);
+      logger4.error(error.stack);
       throw error;
     }
   },
@@ -256027,7 +256168,7 @@ var triggerHelper = {
       throw new Error("Trigger name is not set");
     }
     const { piece, trigger } = await this.getTrigger(moduleDefinition, triggerName);
-    logger3.log(`\u{1F514} Executing trigger: ${triggerName} (${hookType})`);
+    logger4.log(`\u{1F514} Executing trigger: ${triggerName} (${hookType})`);
     const appListeners = [];
     let scheduleOptions;
     const storePrefix = isTest ? "test" : "";
@@ -256114,7 +256255,7 @@ var triggerHelper = {
           };
       }
     } catch (error) {
-      logger3.error(`Error executing trigger ${triggerName}:`, error);
+      logger4.error(`Error executing trigger ${triggerName}:`, error);
       return {
         success: false,
         message: `Error executing trigger: ${(0, import_node_util.inspect)(error)}`,
@@ -256144,28 +256285,28 @@ var triggerHelper = {
     const piece = await this.loadPieceFromModule(moduleDefinition);
     const triggers = piece.triggers();
     for (const [triggerName, trigger] of Object.entries(triggers)) {
-      logger3.log(`\u{1F514} Hooking trigger: ${triggerName} (type: ${trigger.type})`);
+      logger4.log(`\u{1F514} Hooking trigger: ${triggerName} (type: ${trigger.type})`);
       switch (trigger.type) {
         case import_shared2.TriggerStrategy.POLLING:
-          logger3.log(`  \u2192 Setting up polling trigger`);
+          logger4.log(`  \u2192 Setting up polling trigger`);
           if (options?.onPollingTrigger) {
             options.onPollingTrigger(triggerName, trigger);
           }
           break;
         case import_shared2.TriggerStrategy.WEBHOOK:
-          logger3.log(`  \u2192 Setting up webhook trigger`);
+          logger4.log(`  \u2192 Setting up webhook trigger`);
           if (options?.onWebhookTrigger) {
             options.onWebhookTrigger(triggerName, trigger);
           }
           break;
         case import_shared2.TriggerStrategy.APP_WEBHOOK:
-          logger3.log(`  \u2192 Setting up app webhook trigger`);
+          logger4.log(`  \u2192 Setting up app webhook trigger`);
           if (options?.onAppWebhookTrigger) {
             options.onAppWebhookTrigger(triggerName, trigger);
           }
           break;
         default:
-          logger3.warn(`  \u26A0\uFE0F Unknown trigger type: ${trigger.type}`);
+          logger4.warn(`  \u26A0\uFE0F Unknown trigger type: ${trigger.type}`);
       }
     }
   },
@@ -256197,7 +256338,7 @@ var triggerHelper = {
    * Execute a webhook trigger with received payload
    */
   async executeWebhookTrigger(nodeId, payload, headers, query) {
-    logger3.log(`\u{1F514} Executing webhook trigger for node: ${nodeId}`);
+    logger4.log(`\u{1F514} Executing webhook trigger for node: ${nodeId}`);
     return {
       success: true,
       output: [{
@@ -256219,7 +256360,7 @@ var vm = __toESM(__nccwpck_require__(69154));
 var import_child_process3 = __nccwpck_require__(35317);
 var os = __toESM(__nccwpck_require__(70857));
 var ts = __toESM(__nccwpck_require__(35672));
-var logger4 = console;
+var logger5 = console;
 function convertDenoImports(code) {
   const npmPackages = [];
   const imports = [];
@@ -256393,7 +256534,7 @@ async function executeJavaScript(code, params, context) {
     });
     return result;
   } catch (error) {
-    logger4.error(`JavaScript execution error: ${error.message}`);
+    logger5.error(`JavaScript execution error: ${error.message}`);
     throw error;
   }
 }
@@ -256648,9 +256789,9 @@ async function executeWindmillModule(paramsOrModuleName, maybeParams) {
     executionParams = paramsOrModuleName.params;
     inlineScript = paramsOrModuleName.script;
   }
-  logger4.log(`
+  logger5.log(`
 \u{1F300} Executing Windmill module: ${moduleName}`);
-  logger4.log(`   Source: ${source}`);
+  logger5.log(`   Source: ${source}`);
   let script = null;
   if (source === "inline" && inlineScript) {
     script = inlineScript;
@@ -256662,7 +256803,7 @@ async function executeWindmillModule(paramsOrModuleName, maybeParams) {
   if (!script || !script.content) {
     throw new Error(`Could not load Windmill script: ${moduleName}`);
   }
-  logger4.log(`   Language: ${script.language}`);
+  logger5.log(`   Language: ${script.language}`);
   const context = {
     flow_input: executionParams,
     previous_result: executionParams.previous_result || null,
@@ -256688,7 +256829,7 @@ async function executeWindmillModule(paramsOrModuleName, maybeParams) {
       default:
         throw new Error(`Unsupported language: ${script.language}`);
     }
-    logger4.log(`\u2705 Windmill script executed successfully`);
+    logger5.log(`\u2705 Windmill script executed successfully`);
     return {
       success: true,
       module: moduleName,
@@ -256702,7 +256843,7 @@ async function executeWindmillModule(paramsOrModuleName, maybeParams) {
       }
     };
   } catch (error) {
-    logger4.error(`\u274C Windmill script failed: ${error.message}`);
+    logger5.error(`\u274C Windmill script failed: ${error.message}`);
     return {
       success: false,
       module: moduleName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ha-bits/cortex",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Cortex - Habits Workflow Executor CLI",
   "main": "./pack/index.cjs",
   "bin": {
@@ -10,7 +10,7 @@
   "files": [
     "pack",
     "ui",
-    "package.json", 
+    "package.json",
     "README.md"
   ],
   "scripts": {
@@ -55,5 +55,4 @@
     "esbuild": "^0.20.0",
     "typescript": "^5.3.3"
   }
-  
 }