@ha-bits/cortex-core 0.1.0-next.69 → 1.1.16

package/index.js

@@ -7,27 +7,13 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // packages/cortex/core/src/WorkflowExecutor.ts
 import { v4 as uuidv4 } from "uuid";
-import { Cron } from "croner";
 
 // packages/bindings/src/runtime.ts
 function isTauri() {
-  const g = globalThis;
-  return !!(g.__TAURI__ || g.__TAURI_INTERNALS__);
-}
-function getTauri() {
-  if (!isTauri()) return null;
-  return globalThis.__TAURI__;
-}
-function getTauriPlugin(pluginName) {
-  const tauri = getTauri();
-  if (!tauri) {
-    throw new Error(`Tauri is not available. Make sure withGlobalTauri is enabled in tauri.conf.json.`);
-  }
-  const plugin = tauri[pluginName];
-  if (!plugin) {
-    throw new Error(`Tauri plugin '${pluginName}' is not available. Make sure the plugin is installed and enabled.`);
+  if (typeof window === "undefined") {
+    return false;
   }
-  return plugin;
+  return !!(window.__TAURI__ || window.__TAURI_INTERNALS__);
 }
 function isNode() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
@@ -231,12 +217,16 @@ function dirname(p) {
 // packages/bindings/src/shell.ts
 var nodeChildProcess = null;
 var nodeUtil = null;
+var tauriShell = null;
 if (isNode()) {
   nodeChildProcess = __require("child_process");
   nodeUtil = __require("util");
 }
-function getTauriShell() {
-  return getTauriPlugin("shell");
+async function getTauriShell() {
+  if (!tauriShell) {
+    tauriShell = await import("@tauri-apps/plugin-shell");
+  }
+  return tauriShell;
 }
 function filterEnv(env) {
   if (!env) return void 0;
@@ -250,7 +240,7 @@ function filterEnv(env) {
 }
 async function exec(command, options = {}) {
   if (isTauri()) {
-    const shell = getTauriShell();
+    const shell = await getTauriShell();
     const shellProgram = process.platform === "win32" ? "cmd" : "sh";
     const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
     const cmd = shell.Command.create(shellProgram, shellArgs, {
@@ -291,6 +281,11 @@ async function exec(command, options = {}) {
   throw new Error("exec is not supported in this environment");
 }
 
+// packages/core/src/types.ts
+function isFrontendWorkflow(workflow) {
+  return "nodes" in workflow && "edges" in workflow && Array.isArray(workflow.nodes) && Array.isArray(workflow.edges);
+}
+
 // packages/core/src/logger/types.ts
 var LOG_LEVEL_PRIORITY = {
   trace: 0,
@@ -608,9 +603,9 @@ var ConfigResolver = class {
     }
     const formatEnv = env[LOG_ENV_VARS.FORMAT];
     if (formatEnv && ["text", "json"].includes(formatEnv.toLowerCase())) {
-      const format2 = formatEnv.toLowerCase();
+      const format = formatEnv.toLowerCase();
       result.outputs = result.outputs.map(
-        (o) => o.type === "console" || o.type === "file" ? { ...o, format: format2 } : o
+        (o) => o.type === "console" || o.type === "file" ? { ...o, format } : o
       );
     }
     for (const [key, value] of Object.entries(env)) {
@@ -1172,8 +1167,8 @@ var LoggerFactory = class {
   /**
    * Create a formatter based on format type
    */
-  static createFormatter(format2) {
-    return format2 === "json" ? new JsonFormatter() : new TextFormatter();
+  static createFormatter(format) {
+    return format === "json" ? new JsonFormatter() : new TextFormatter();
   }
 };
 
@@ -2201,17 +2196,6 @@ function getModuleMainFile(moduleDefinition) {
 
 // packages/cortex/core/src/utils/moduleLoader.ts
 var logger2 = LoggerFactory.getRoot();
-var bundledModulesRegistry = /* @__PURE__ */ new Map();
-function registerBundledModule(moduleName, moduleExports) {
-  bundledModulesRegistry.set(moduleName, moduleExports);
-  console.log(`\u{1F4E6} Registered bundled module: ${moduleName}`);
-}
-function getBundledModule(moduleName) {
-  return bundledModulesRegistry.get(moduleName);
-}
-function isBundledModule(moduleName) {
-  return bundledModulesRegistry.has(moduleName);
-}
 function getModuleName(moduleDefinition) {
   if (moduleDefinition.source === "github") {
     const url = moduleDefinition.repository;
@@ -2230,20 +2214,6 @@ function getModuleName(moduleDefinition) {
 var MODULES_CONFIG_PATH = join(process.cwd(), "modules.json");
 async function ensureModuleInstalled(moduleDefinition) {
   const moduleName = getModuleName(moduleDefinition);
-  if (isBundledModule(moduleDefinition.repository)) {
-    console.log(`\u2713 Module ${moduleName} is pre-bundled, skipping installation
-`);
-    return moduleDefinition.repository;
-  }
-  if (typeof __require !== "undefined") {
-    try {
-      __require(moduleDefinition.repository);
-      console.log(`\u2713 Module ${moduleName} already available via require
-`);
-      return moduleDefinition.repository;
-    } catch {
-    }
-  }
   console.log(`
 \u{1F50D} ensureModuleInstalled called:`);
   console.log(`   Module name: ${moduleName}`);
@@ -2265,157 +2235,75 @@ async function ensureModuleInstalled(moduleDefinition) {
 // packages/cortex/core/src/n8n/executionContext.ts
 import * as path3 from "path";
 
-// packages/bindings/src/fetch.ts
-function getTauriHttp() {
-  return getTauriPlugin("http");
-}
-function headersToObject(headers) {
-  if (!headers) return void 0;
-  if (headers instanceof Headers) {
-    const obj = {};
-    headers.forEach((value, key) => {
-      obj[key] = value;
-    });
-    return obj;
-  }
-  if (Array.isArray(headers)) {
-    const obj = {};
-    for (const [key, value] of headers) {
-      obj[key] = value;
-    }
-    return obj;
-  }
-  return headers;
-}
-function wrapTauriResponse(response) {
-  return {
-    ok: response.ok,
-    status: response.status,
-    statusText: response.statusText || "",
-    headers: response.headers,
-    url: response.url,
-    redirected: response.redirected || false,
-    text: () => response.text(),
-    json: () => response.json(),
-    arrayBuffer: () => response.arrayBuffer(),
-    blob: () => response.blob()
-  };
-}
-function wrapNativeResponse(response) {
-  return {
-    ok: response.ok,
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-    url: response.url,
-    redirected: response.redirected,
-    text: () => response.text(),
-    json: () => response.json(),
-    arrayBuffer: () => response.arrayBuffer(),
-    blob: () => response.blob()
+// packages/cortex/core/src/n8n/httpRequest.ts
+import axios from "axios";
+import FormData from "form-data";
+var logger3 = LoggerFactory.getRoot();
+function convertN8nRequestToAxios(requestOptions) {
+  const { headers, method, timeout, auth, url, body, qs } = requestOptions;
+  const axiosConfig = {
+    headers: headers ?? {},
+    method: method || "GET",
+    timeout: timeout || 3e5,
+    url,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity
   };
-}
-async function fetch2(url, options = {}) {
-  if (isTauri()) {
-    return fetchTauri(url, options);
-  }
-  return fetchNative(url, options);
-}
-async function fetchNative(url, options = {}) {
-  const { timeout, maxRedirections, body, ...nativeOptions } = options;
-  let processedBody = void 0;
-  if (body !== null && body !== void 0) {
-    if (typeof body === "object" && !(body instanceof ArrayBuffer) && !(body instanceof Blob) && !(body instanceof FormData) && !(body instanceof URLSearchParams) && !(body instanceof ReadableStream) && !ArrayBuffer.isView(body)) {
-      processedBody = JSON.stringify(body);
-    } else {
-      processedBody = body;
-    }
+  if (qs) {
+    axiosConfig.params = qs;
   }
-  let controller;
-  let timeoutId;
-  if (timeout) {
-    controller = new AbortController();
-    timeoutId = setTimeout(() => controller.abort(), timeout);
+  if (auth) {
+    axiosConfig.auth = {
+      username: auth.username || "",
+      password: auth.password || ""
+    };
   }
-  try {
-    const response = await globalThis.fetch(url, {
-      ...nativeOptions,
-      body: processedBody,
-      signal: controller?.signal ?? options.signal
-    });
-    return wrapNativeResponse(response);
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
+  if (requestOptions.baseURL) {
+    axiosConfig.baseURL = requestOptions.baseURL;
   }
-}
-async function fetchTauri(url, options = {}) {
-  const http = getTauriHttp();
-  const { timeout, maxRedirections, body, headers, ...restOptions } = options;
-  let processedBody = void 0;
-  if (body !== null && body !== void 0) {
-    if (typeof body === "object" && !(body instanceof ArrayBuffer) && !(body instanceof Blob) && !(body instanceof FormData) && !(body instanceof URLSearchParams) && !(body instanceof ReadableStream) && !ArrayBuffer.isView(body)) {
-      processedBody = JSON.stringify(body);
-    } else {
-      processedBody = body;
-    }
+  if (requestOptions.disableFollowRedirect) {
+    axiosConfig.maxRedirects = 0;
   }
-  const tauriOptions = {
-    ...restOptions,
-    body: processedBody,
-    headers: headersToObject(headers)
-  };
-  if (timeout !== void 0) {
-    tauriOptions.timeout = timeout;
+  if (requestOptions.encoding) {
+    axiosConfig.responseType = requestOptions.encoding;
   }
-  if (maxRedirections !== void 0) {
-    tauriOptions.maxRedirections = maxRedirections;
+  if (requestOptions.skipSslCertificateValidation) {
   }
-  const response = await http.fetch(url.toString(), tauriOptions);
-  return wrapTauriResponse(response);
-}
-
-// packages/cortex/core/src/n8n/httpRequest.ts
-import FormData2 from "form-data";
-var logger3 = LoggerFactory.getRoot();
-function buildUrl(url, baseURL, qs) {
-  let fullUrl = url;
-  if (baseURL && !url.startsWith("http://") && !url.startsWith("https://")) {
-    fullUrl = baseURL.replace(/\/$/, "") + "/" + url.replace(/^\//, "");
-  }
-  if (qs && Object.keys(qs).length > 0) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(qs)) {
-      if (value !== void 0 && value !== null) {
-        params.append(key, String(value));
-      }
+  if (body) {
+    if (body instanceof FormData) {
+      axiosConfig.data = body;
+      axiosConfig.headers = {
+        ...axiosConfig.headers,
+        ...body.getHeaders()
+      };
+    } else if (body instanceof URLSearchParams) {
+      axiosConfig.headers = {
+        ...axiosConfig.headers,
+        "Content-Type": "application/x-www-form-urlencoded"
+      };
+      axiosConfig.data = body;
+    } else if (typeof body === "object" && Object.keys(body).length > 0) {
+      axiosConfig.data = body;
+    } else if (typeof body === "string") {
+      axiosConfig.data = body;
     }
-    fullUrl += (fullUrl.includes("?") ? "&" : "?") + params.toString();
   }
-  return fullUrl;
-}
-function prepareBody(body, headers) {
-  if (!body) return void 0;
-  if (body instanceof FormData2) {
-    const formHeaders = body.getHeaders();
-    Object.assign(headers, formHeaders);
-    return body;
-  }
-  if (body instanceof URLSearchParams) {
-    headers["Content-Type"] = "application/x-www-form-urlencoded";
-    return body.toString();
+  if (requestOptions.json) {
+    axiosConfig.headers = {
+      ...axiosConfig.headers,
+      Accept: "application/json"
+    };
   }
-  if (typeof body === "object" && Object.keys(body).length > 0) {
-    if (!headers["Content-Type"]) {
-      headers["Content-Type"] = "application/json";
-    }
-    return JSON.stringify(body);
+  if (!axiosConfig.headers?.["User-Agent"]) {
+    axiosConfig.headers = {
+      ...axiosConfig.headers,
+      "User-Agent": "n8n-habits-executor"
+    };
   }
-  if (typeof body === "string") {
-    return body;
+  if (requestOptions.ignoreHttpStatusErrors) {
+    axiosConfig.validateStatus = () => true;
   }
-  return void 0;
+  return axiosConfig;
 }
 async function httpRequest(requestOptions) {
   const noBodyMethods = ["GET", "HEAD", "OPTIONS"];
@@ -2423,69 +2311,27 @@ async function httpRequest(requestOptions) {
   if (noBodyMethods.includes(method) && requestOptions.body && Object.keys(requestOptions.body).length === 0) {
     delete requestOptions.body;
   }
-  const headers = {
-    ...requestOptions.headers ?? {}
-  };
-  if (requestOptions.auth) {
-    const credentials = Buffer.from(
-      `${requestOptions.auth.username || ""}:${requestOptions.auth.password || ""}`
-    ).toString("base64");
-    headers["Authorization"] = `Basic ${credentials}`;
-  }
-  if (requestOptions.json) {
-    headers["Accept"] = "application/json";
-  }
-  if (!headers["User-Agent"]) {
-    headers["User-Agent"] = "n8n-habits-executor";
+  const axiosConfig = convertN8nRequestToAxios(requestOptions);
+  if (axiosConfig.data === void 0 || axiosConfig.method?.toUpperCase() === "GET") {
+    delete axiosConfig.data;
   }
-  const url = buildUrl(requestOptions.url, requestOptions.baseURL, requestOptions.qs);
-  let body;
-  if (!noBodyMethods.includes(method)) {
-    body = prepareBody(requestOptions.body, headers);
-  }
-  logger3.log(`\u{1F310} Making HTTP request: ${method} ${url}`);
+  logger3.log(`\u{1F310} Making HTTP request: ${axiosConfig.method} ${axiosConfig.url}`);
   try {
-    const response = await fetch2(url, {
-      method,
-      headers,
-      body,
-      redirect: requestOptions.disableFollowRedirect ? "manual" : "follow"
-    });
-    let responseData;
-    const contentType = response.headers.get("content-type") || "";
-    if (requestOptions.encoding === "arraybuffer" || contentType.includes("application/octet-stream")) {
-      responseData = await response.arrayBuffer();
-    } else if (contentType.includes("application/json")) {
-      responseData = await response.json();
-    } else {
-      responseData = await response.text();
-      try {
-        responseData = JSON.parse(responseData);
-      } catch {
-      }
-    }
-    if (!response.ok && !requestOptions.ignoreHttpStatusErrors) {
-      logger3.error(`HTTP Error (${response.status}): ${JSON.stringify(responseData)}`);
-      throw new Error(`HTTP Error (${response.status}): ${JSON.stringify(responseData)}`);
-    }
+    const response = await axios(axiosConfig);
     if (requestOptions.returnFullResponse) {
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
       return {
-        body: responseData,
-        headers: responseHeaders,
+        body: response.data,
+        headers: response.headers,
         statusCode: response.status,
         statusMessage: response.statusText
       };
     }
-    return responseData;
+    return response.data;
   } catch (error) {
-    if (error.message?.startsWith("HTTP Error")) {
-      throw error;
+    if (error.response) {
+      logger3.error(`HTTP Error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
+      throw new Error(`HTTP Error (${error.response.status}): ${JSON.stringify(error.response.data)}`);
     }
-    logger3.error(`Request failed: ${error.message}`);
     throw error;
   }
 }
@@ -2701,7 +2547,7 @@ function createExecutionContext(node, params, options) {
     },
     // Helpers object with HTTP request and other utilities
     helpers: {
-      // HTTP request function
+      // HTTP request function (real implementation)
       httpRequest: async (opts) => {
         return await httpRequest(opts);
       },
@@ -2886,6 +2732,7 @@ function createExecutionContext(node, params, options) {
 
 // packages/cortex/core/src/n8n/nodeExecution.ts
 import * as path4 from "path";
+import axios2 from "axios";
 var logger6 = LoggerFactory.getRoot();
 async function loadNodeFromModule(moduleDefinition, mainFilePath) {
   const moduleName = getModuleName(moduleDefinition);
@@ -3093,33 +2940,23 @@ async function executeRoutingBasedNode(node, params, context) {
   }
   logger6.log(`\u{1F310} Making routing-based request: ${method} ${url}`);
   logger6.log(`\u{1F4E4} Request body:`, { body });
-  let fullUrl = url;
-  if (Object.keys(queryParams).length > 0) {
-    const params2 = new URLSearchParams();
-    for (const [key, value] of Object.entries(queryParams)) {
-      if (value !== void 0 && value !== null) {
-        params2.append(key, String(value));
-      }
-    }
-    fullUrl += (fullUrl.includes("?") ? "&" : "?") + params2.toString();
-  }
-  const requestBody = Object.keys(body).length > 0 ? JSON.stringify(body) : void 0;
-  if (requestBody && !headers["Content-Type"]) {
-    headers["Content-Type"] = "application/json";
+  const axiosConfig = {
+    method,
+    url,
+    headers,
+    params: Object.keys(queryParams).length > 0 ? queryParams : void 0,
+    data: Object.keys(body).length > 0 ? body : void 0
+  };
+  if (requestConfig.encoding === "arraybuffer") {
+    axiosConfig.responseType = "arraybuffer";
   }
   try {
-    const response = await fetch2(fullUrl, {
-      method,
-      headers,
-      body: requestBody
-    });
+    const response = await axios2(axiosConfig);
     logger6.log(`\u2705 Routing-based request successful: ${response.status}`);
-    const contentType = response.headers.get("content-type") || "";
-    if (requestConfig.encoding === "arraybuffer" || contentType.includes("audio")) {
-      const arrayBuffer = await response.arrayBuffer();
-      const binaryData = Buffer.from(arrayBuffer);
+    if (requestConfig.encoding === "arraybuffer" || response.headers["content-type"]?.includes("audio")) {
+      const binaryData = Buffer.from(response.data);
       const base64Data = binaryData.toString("base64");
-      const mimeType = contentType || "audio/mpeg";
+      const mimeType = response.headers["content-type"] || "audio/mpeg";
       return [[{
         json: {
           success: true,
@@ -3136,28 +2973,14 @@ async function executeRoutingBasedNode(node, params, context) {
         }
       }]];
     }
-    let responseData;
-    if (contentType.includes("application/json")) {
-      responseData = await response.json();
-    } else {
-      const text = await response.text();
-      try {
-        responseData = JSON.parse(text);
-      } catch {
-        responseData = text;
-      }
-    }
-    if (!response.ok) {
-      const errorMessage = typeof responseData === "object" ? JSON.stringify(responseData) : String(responseData);
-      logger6.error(`HTTP Error (${response.status}): ${errorMessage}`);
-      throw new Error(`HTTP Error (${response.status}): ${errorMessage}`);
-    }
-    return [[{ json: responseData }]];
+    return [[{ json: response.data }]];
   } catch (error) {
-    if (error.message?.startsWith("HTTP Error")) {
-      throw error;
+    if (error.response) {
+      const errorData = error.response.data;
+      const errorMessage = Buffer.isBuffer(errorData) ? errorData.toString("utf-8") : JSON.stringify(errorData);
+      logger6.error(`HTTP Error (${error.response.status}): ${errorMessage}`);
+      throw new Error(`HTTP Error (${error.response.status}): ${errorMessage}`);
     }
-    logger6.error(`Request failed: ${error.message}`);
     throw error;
   }
 }
@@ -3437,13 +3260,13 @@ async function ensureActivepiecesModulesLoaded2() {
   trimVersionFromAlias2 = shared.trimVersionFromAlias;
 }
 var logger9 = LoggerFactory.getRoot();
-var TriggerHookType = /* @__PURE__ */ ((TriggerHookType4) => {
-  TriggerHookType4["ON_ENABLE"] = "ON_ENABLE";
-  TriggerHookType4["ON_DISABLE"] = "ON_DISABLE";
-  TriggerHookType4["RUN"] = "RUN";
-  TriggerHookType4["TEST"] = "TEST";
-  TriggerHookType4["HANDSHAKE"] = "HANDSHAKE";
-  return TriggerHookType4;
+var TriggerHookType = /* @__PURE__ */ ((TriggerHookType3) => {
+  TriggerHookType3["ON_ENABLE"] = "ON_ENABLE";
+  TriggerHookType3["ON_DISABLE"] = "ON_DISABLE";
+  TriggerHookType3["RUN"] = "RUN";
+  TriggerHookType3["TEST"] = "TEST";
+  TriggerHookType3["HANDSHAKE"] = "HANDSHAKE";
+  return TriggerHookType3;
 })(TriggerHookType || {});
 function createSimpleStore(prefix = "") {
   const storage = /* @__PURE__ */ new Map();
@@ -3835,6 +3658,7 @@ var triggerHelper = {
 };
 
 // packages/cortex/core/src/bits/declarativeExecutor.ts
+import axios3 from "axios";
 function resolveExpression(expression, context) {
   if (expression === null || expression === void 0) {
     return expression;
@@ -4172,73 +3996,30 @@ async function executeDeclarativeNode(node, context) {
     throw new Error("No URL specified in request configuration or defaults");
   }
   try {
-    let fullUrl = requestConfig.url || "";
-    if (requestConfig.baseURL && !fullUrl.startsWith("http://") && !fullUrl.startsWith("https://")) {
-      fullUrl = requestConfig.baseURL.replace(/\/$/, "") + "/" + fullUrl.replace(/^\//, "");
-    }
-    if (requestConfig.params && Object.keys(requestConfig.params).length > 0) {
-      const params = new URLSearchParams();
-      for (const [key, value] of Object.entries(requestConfig.params)) {
-        if (value !== void 0 && value !== null) {
-          params.append(key, String(value));
-        }
-      }
-      fullUrl += (fullUrl.includes("?") ? "&" : "?") + params.toString();
-    }
-    const headers = { ...requestConfig.headers };
-    let body;
-    if (requestConfig.data) {
-      if (!headers["Content-Type"]) {
-        headers["Content-Type"] = "application/json";
-      }
-      body = typeof requestConfig.data === "string" ? requestConfig.data : JSON.stringify(requestConfig.data);
-    }
-    const response = await fetch2(fullUrl, {
-      method: requestConfig.method || "GET",
-      headers,
-      body
-    });
-    let responseData;
-    const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      responseData = await response.json();
-    } else {
-      const text = await response.text();
-      try {
-        responseData = JSON.parse(text);
-      } catch {
-        responseData = text;
-      }
-    }
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
+    const response = await axios3(requestConfig);
     const operationRouting = findOperationRouting(description.properties, context.parameters);
-    if (!response.ok) {
-      if (operationRouting?.request?.ignoreHttpStatusErrors) {
-        return {
-          success: true,
-          data: responseData,
-          status: response.status,
-          headers: responseHeaders
-        };
-      }
-      throw new Error(`HTTP Error (${response.status}): ${JSON.stringify(responseData)}`);
-    }
     const expressionContext = {
       $parameter: context.parameters,
       $credentials: context.credentials || {},
-      $response: responseData
+      $response: response.data
     };
-    const processedData = processResponse(responseData, operationRouting, expressionContext);
+    const processedData = processResponse(response.data, operationRouting, expressionContext);
     return {
       success: true,
       data: processedData,
       status: response.status,
-      headers: responseHeaders
+      headers: response.headers
     };
   } catch (error) {
+    const operationRouting = findOperationRouting(description.properties, context.parameters);
+    if (operationRouting?.request?.ignoreHttpStatusErrors && error.response) {
+      return {
+        success: true,
+        data: error.response.data,
+        status: error.response.status,
+        headers: error.response.headers
+      };
+    }
     throw new Error(`Request failed: ${error.message}`);
   }
 }
@@ -4317,374 +4098,12 @@ function extractDeclarativeNode(loadedModule) {
   return null;
 }
 
-// packages/cortex/core/src/store.ts
-var logger10 = LoggerFactory.getRoot();
-var driverModule = null;
-var driverLoadAttempted = false;
-var useInMemoryFallback = false;
-var inMemoryStore = /* @__PURE__ */ new Map();
-var inMemoryDriver = {
-  async store(params) {
-    const key = `${params.collection}:${params.key}`;
-    inMemoryStore.set(key, params.value);
-    return { success: true };
-  },
-  async get(params) {
-    const key = `${params.collection}:${params.key}`;
-    if (inMemoryStore.has(key)) {
-      return { found: true, value: inMemoryStore.get(key) };
-    }
-    return { found: false, value: null };
-  },
-  async del(params) {
-    const key = `${params.collection}:${params.key}`;
-    inMemoryStore.delete(key);
-    return { success: true };
-  },
-  async list(params) {
-    const prefix = `${params.collection}:${params.prefix || ""}`;
-    const keys = [];
-    for (const key of inMemoryStore.keys()) {
-      if (key.startsWith(prefix)) {
-        keys.push(key.replace(`${params.collection}:`, ""));
-      }
-    }
-    return { keys: keys.slice(0, params.limit || 100) };
-  }
-};
-async function getDriver() {
-  if (useInMemoryFallback) {
-    return inMemoryDriver;
-  }
-  if (!driverModule && !driverLoadAttempted) {
-    driverLoadAttempted = true;
-    try {
-      const modulePath = "@ha-bits/bit-database-sql/driver";
-      driverModule = await import(
-        /* webpackIgnore: true */
-        modulePath
-      );
-      logger10.log("\u{1F4BE} Polling store: Loaded database driver");
-    } catch (err) {
-      logger10.warn(`\u{1F4BE} Polling store: Database driver not available, using in-memory fallback: ${err.message}`);
-      useInMemoryFallback = true;
-      return inMemoryDriver;
-    }
-  }
-  return driverModule || inMemoryDriver;
-}
-var PollingStore = class {
-  constructor(options = {}) {
-    this.options = {
-      database: options.database ?? "habits-polling.db",
-      collection: options.collection ?? "polling",
-      dedupStrategy: options.dedupStrategy ?? "id",
-      ttlDays: options.ttlDays ?? 30
-    };
-  }
-  /**
-   * Generate a unique key for a seen item
-   */
-  getItemKey(ctx, itemId) {
-    return `${ctx.workflowId}:${ctx.triggerId}:${itemId}`;
-  }
-  /**
-   * Generate the key for storing last polled date
-   */
-  getLastPolledKey(ctx) {
-    return `${ctx.workflowId}:${ctx.triggerId}:__lastPolled__`;
-  }
-  /**
-   * Check if an item has been seen before
-   */
-  async hasSeenItem(ctx, itemId, itemDate) {
-    const driver = await getDriver();
-    const key = this.getItemKey(ctx, itemId);
-    const result = await driver.get({
-      collection: this.options.collection,
-      key,
-      database: this.options.database
-    });
-    if (!result.found) {
-      return false;
-    }
-    if (this.options.dedupStrategy === "date" && itemDate) {
-      const record = result.value;
-      return new Date(record.sourceDate) >= new Date(itemDate);
-    }
-    return true;
-  }
-  /**
-   * Mark an item as seen
-   */
-  async markItemSeen(ctx, itemId, sourceDate, data) {
-    const driver = await getDriver();
-    const key = this.getItemKey(ctx, itemId);
-    const record = {
-      id: itemId,
-      sourceDate,
-      seenAt: (/* @__PURE__ */ new Date()).toISOString(),
-      data
-    };
-    await driver.store({
-      collection: this.options.collection,
-      key,
-      value: record,
-      database: this.options.database
-    });
-    logger10.log(`\u{1F4BE} Polling store: Marked item as seen: ${itemId}`);
-  }
-  /**
-   * Get multiple items' seen status in batch
-   * Returns a Set of item IDs that have been seen
-   */
-  async getSeenItems(ctx, itemIds) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const itemId of itemIds) {
-      if (await this.hasSeenItem(ctx, itemId)) {
-        seen.add(itemId);
-      }
-    }
-    return seen;
-  }
-  /**
-   * Mark multiple items as seen in batch
-   */
-  async markItemsSeen(ctx, items) {
-    for (const item of items) {
-      await this.markItemSeen(ctx, item.id, item.date, item.data);
-    }
-  }
-  /**
-   * Get the last polled timestamp for a trigger
-   * Returns null if never polled before
-   */
-  async getLastPolledDate(ctx) {
-    const driver = await getDriver();
-    const key = this.getLastPolledKey(ctx);
-    const result = await driver.get({
-      collection: this.options.collection,
-      key,
-      database: this.options.database
-    });
-    if (!result.found) {
-      return null;
-    }
-    return result.value;
-  }
-  /**
-   * Set the last polled timestamp for a trigger
-   */
-  async setLastPolledDate(ctx, date) {
-    const driver = await getDriver();
-    const key = this.getLastPolledKey(ctx);
-    await driver.store({
-      collection: this.options.collection,
-      key,
-      value: date,
-      database: this.options.database
-    });
-    logger10.log(`\u{1F4BE} Polling store: Updated last polled date: ${date}`);
-  }
-  /**
-   * Get the count of seen items for a trigger
-   */
-  async getSeenCount(ctx) {
-    const driver = await getDriver();
-    const prefix = `${ctx.workflowId}:${ctx.triggerId}:`;
-    const result = await driver.list({
-      collection: this.options.collection,
-      prefix,
-      limit: 1e4,
-      // High limit to count all
-      database: this.options.database
-    });
-    const count = result.keys.filter((k) => !k.endsWith("__lastPolled__")).length;
-    return count;
-  }
-  /**
-   * Clear all seen items for a trigger (useful for testing or reset)
-   */
-  async clearTrigger(ctx) {
-    const driver = await getDriver();
-    const prefix = `${ctx.workflowId}:${ctx.triggerId}:`;
-    const result = await driver.list({
-      collection: this.options.collection,
-      prefix,
-      limit: 1e4,
-      database: this.options.database
-    });
-    let deleted = 0;
-    for (const key of result.keys) {
-      await driver.del({
-        collection: this.options.collection,
-        key,
-        database: this.options.database
-      });
-      deleted++;
-    }
-    logger10.log(`\u{1F4BE} Polling store: Cleared ${deleted} items for trigger ${ctx.triggerId}`);
-    return deleted;
-  }
-  /**
-   * TODO: Implement TTL-based cleanup
-   * Clean up old records based on ttlDays configuration
-   */
-  async cleanup() {
-    logger10.log(`\u{1F4BE} Polling store: Cleanup not yet implemented (TTL: ${this.options.ttlDays} days)`);
-    return 0;
-  }
-};
-function createPollingStore(options) {
-  return new PollingStore(options);
-}
-
-// packages/cortex/core/src/bits/oauthTokenStore.ts
-var OAuth2TokenStore = class {
-  constructor() {
-    this.tokens = /* @__PURE__ */ new Map();
-    this.logger = LoggerFactory.create(void 0, void 0, { bitName: "OAuth2TokenStore" });
-  }
-  /**
-   * Store tokens for a bit
-   * @param bitId - Unique identifier for the bit (e.g., "bit-oauth-mock")
-   * @param tokens - Token set from OAuth provider
-   * @param config - OAuth config used (for refresh)
-   */
-  setToken(bitId, tokens, config) {
-    this.tokens.set(bitId, {
-      tokens,
-      config,
-      storedAt: Date.now()
-    });
-    this.logger.info("Token stored", { bitId, expiresAt: tokens.expiresAt });
-  }
-  /**
-   * Get tokens for a bit
-   * @param bitId - Unique identifier for the bit
-   * @returns Token set or null if not found
-   */
-  getToken(bitId) {
-    const entry = this.tokens.get(bitId);
-    if (!entry) {
-      return null;
-    }
-    return entry.tokens;
-  }
-  /**
-   * Get full token entry including config
-   * @param bitId - Unique identifier for the bit
-   */
-  getEntry(bitId) {
-    return this.tokens.get(bitId) || null;
-  }
-  /**
-   * Check if a valid (non-expired) token exists for a bit
-   * @param bitId - Unique identifier for the bit
-   * @returns true if valid token exists
-   */
-  hasValidToken(bitId) {
-    const entry = this.tokens.get(bitId);
-    if (!entry) {
-      return false;
-    }
-    return !this.isExpired(bitId);
-  }
-  /**
-   * Check if token is expired
-   * @param bitId - Unique identifier for the bit
-   * @returns true if token is expired or doesn't exist
-   */
-  isExpired(bitId) {
-    const entry = this.tokens.get(bitId);
-    if (!entry) {
-      return true;
-    }
-    if (!entry.tokens.expiresAt) {
-      return false;
-    }
-    return Date.now() > entry.tokens.expiresAt - 6e4;
-  }
-  /**
-   * Remove token for a bit
-   * @param bitId - Unique identifier for the bit
-   */
-  removeToken(bitId) {
-    this.tokens.delete(bitId);
-    this.logger.info("Token removed", { bitId });
-  }
-  /**
-   * Get all stored bit IDs
-   */
-  getAllBitIds() {
-    return Array.from(this.tokens.keys());
-  }
-  /**
-   * Clear all tokens
-   */
-  clear() {
-    this.tokens.clear();
-    this.logger.info("All tokens cleared");
-  }
-  /**
-   * Refresh an expired token using the refresh token
-   * @param bitId - Unique identifier for the bit
-   * @returns New token set or null if refresh failed
-   */
-  async refreshToken(bitId) {
-    const entry = this.tokens.get(bitId);
-    if (!entry || !entry.tokens.refreshToken) {
-      this.logger.warn("Cannot refresh token: no refresh token available", { bitId });
-      return null;
-    }
-    const { config, tokens } = entry;
-    try {
-      const params = new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: tokens.refreshToken,
-        client_id: config.clientId
-      });
-      if (config.clientSecret) {
-        params.set("client_secret", config.clientSecret);
-      }
-      const response = await fetch(config.tokenUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: params.toString()
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        this.logger.error("Token refresh failed", { bitId, status: response.status, error: errorText });
-        return null;
-      }
-      const data = await response.json();
-      const newTokens = {
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token || tokens.refreshToken,
-        // Keep old refresh token if not returned
-        tokenType: data.token_type || "Bearer",
-        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
-        scope: data.scope
-      };
-      this.setToken(bitId, newTokens, config);
-      this.logger.info("Token refreshed successfully", { bitId });
-      return newTokens;
-    } catch (error) {
-      this.logger.error("Token refresh error", { bitId, error: String(error) });
-      return null;
-    }
-  }
-};
-var oauthTokenStore = new OAuth2TokenStore();
-
 // packages/cortex/core/src/bits/bitsDoer.ts
-var logger11 = LoggerFactory.getRoot();
+var logger10 = LoggerFactory.getRoot();
 function extractBitsPieceFromModule(loadedModule) {
   const declarativeNode = extractDeclarativeNode(loadedModule);
   if (declarativeNode) {
-    logger11.log(`\u{1F4CB} Detected declarative node: ${declarativeNode.description.displayName}`);
+    logger10.log(`\u{1F4CB} Detected declarative node: ${declarativeNode.description.displayName}`);
     return convertDeclarativeNodeToBitsPiece(declarativeNode);
   }
   let piece = null;
@@ -4705,8 +4124,6 @@ function extractBitsPieceFromModule(loadedModule) {
     throw new Error("No valid bits piece found in module. Expected export with actions and triggers.");
   }
   return {
-    id: piece.id,
-    // Webhook routing ID (e.g., 'gohighlevel', 'hubspot')
     displayName: piece.displayName || "Unknown Piece",
     description: piece.description,
     logoUrl: piece.logoUrl,
@@ -4824,20 +4241,11 @@ function createDeclarativeActionRunner(node, operation) {
 }
 async function pieceFromModule2(moduleDefinition) {
   const moduleName = getModuleName(moduleDefinition);
-  if (isBundledModule(moduleDefinition.repository)) {
-    logger11.log(`\u{1F4E6} Using pre-bundled module: ${moduleName}`);
-    const loadedModule = getBundledModule(moduleDefinition.repository);
-    if (loadedModule) {
-      const piece = extractBitsPieceFromModule(loadedModule);
-      return piece;
-    }
-    throw new Error(`Bundled module ${moduleName} not found in registry`);
-  }
   const mainFilePath = getModuleMainFile(moduleDefinition);
   if (!mainFilePath) {
     throw new Error(`Could not locate main file for module: ${moduleName}`);
   }
-  logger11.log(`\u{1F4E6} Bits module ready at: ${mainFilePath}`);
+  logger10.log(`\u{1F4E6} Bits module ready at: ${mainFilePath}`);
   const originalCwd = process.cwd();
   const moduleDir = dirname(mainFilePath);
   let nodeModulesDir = moduleDir;
@@ -4852,18 +4260,18 @@ async function pieceFromModule2(moduleDefinition) {
     return piece;
   } catch (error) {
     process.chdir(originalCwd);
-    logger11.error(error.stack);
+    logger10.error(error.stack);
     throw error;
   }
 }
 async function executeGenericBitsPiece(params, moduleDefinition) {
   try {
     const piece = await pieceFromModule2(moduleDefinition);
-    logger11.log(`\u{1F680} Executing Bits piece: ${piece.displayName}`);
+    logger10.log(`\u{1F680} Executing Bits piece: ${piece.displayName}`);
     const actionName = params.params.operation;
     const pieceActions = piece.actions();
-    logger11.log(`Available actions: ${Object.keys(pieceActions).join(", ")}`);
-    logger11.log(`Requested action: ${actionName}`);
+    logger10.log(`Available actions: ${Object.keys(pieceActions).join(", ")}`);
+    logger10.log(`Requested action: ${actionName}`);
     const action = pieceActions[actionName];
     if (!action) {
       throw new Error(
@@ -4872,80 +4280,11 @@ async function executeGenericBitsPiece(params, moduleDefinition) {
     }
     let auth = void 0;
     const { credentials, ...actionProps } = params.params;
-    if (piece.auth && (piece.auth.type === "OAUTH2" || piece.auth.type === "OAUTH2_PKCE")) {
-      const parts = moduleDefinition.repository.split("/");
-      const bitId = parts[parts.length - 1];
-      const oauthCredKey = Object.keys(credentials || {}).find((key) => {
-        const cred = credentials[key];
-        return cred && (cred.accessToken || cred.access_token);
-      });
-      if (oauthCredKey && credentials[oauthCredKey]) {
-        const directTokens = credentials[oauthCredKey];
-        auth = {
-          accessToken: directTokens.accessToken || directTokens.access_token,
-          refreshToken: directTokens.refreshToken || directTokens.refresh_token,
-          tokenType: directTokens.tokenType || directTokens.token_type || "Bearer",
-          expiresAt: directTokens.expiresAt || directTokens.expires_at
-        };
-        logger11.log(`\u{1F510} Using OAuth2 tokens from credentials for: ${bitId}`);
-        if (auth.refreshToken) {
-          const pieceAuth = piece.auth;
-          oauthTokenStore.setToken(bitId, auth, {
-            displayName: pieceAuth.displayName || bitId,
-            required: pieceAuth.required || false,
-            authorizationUrl: pieceAuth.authorizationUrl || "",
-            tokenUrl: pieceAuth.tokenUrl || "",
-            clientId: pieceAuth.clientId || "",
-            clientSecret: pieceAuth.clientSecret,
-            scopes: pieceAuth.scopes || []
-          });
-        }
-      } else if (params.oauthTokens && params.oauthTokens[bitId]) {
-        const userToken = params.oauthTokens[bitId];
-        auth = {
-          accessToken: userToken.accessToken,
-          refreshToken: userToken.refreshToken,
-          tokenType: userToken.tokenType,
-          expiresAt: userToken.expiresAt
-        };
-        logger11.log(`\u{1F510} Using per-user OAuth2 token from cookies for: ${bitId}`);
-        if (userToken.expiresAt && userToken.expiresAt < Date.now()) {
-          logger11.warn(`\u26A0\uFE0F Per-user OAuth token expired for ${bitId}. User needs to re-authenticate.`);
-        }
-      } else {
-        const oauthToken = oauthTokenStore.getToken(bitId);
-        if (oauthToken) {
-          auth = {
-            accessToken: oauthToken.accessToken,
-            refreshToken: oauthToken.refreshToken,
-            tokenType: oauthToken.tokenType,
-            expiresAt: oauthToken.expiresAt
-          };
-          logger11.log(`\u{1F510} Using OAuth2 PKCE token for: ${bitId}`);
-          if (oauthTokenStore.isExpired(bitId)) {
-            logger11.log(`\u26A0\uFE0F OAuth token expired for ${bitId}, attempting refresh...`);
-            const refreshedToken = await oauthTokenStore.refreshToken(bitId);
-            if (refreshedToken) {
-              auth = {
-                accessToken: refreshedToken.accessToken,
-                refreshToken: refreshedToken.refreshToken,
-                tokenType: refreshedToken.tokenType,
-                expiresAt: refreshedToken.expiresAt
-              };
-              logger11.log(`\u2705 OAuth token refreshed for ${bitId}`);
-            } else {
-              logger11.warn(`\u274C Failed to refresh OAuth token for ${bitId}`);
-            }
-          }
-        } else {
-          logger11.warn(`\u26A0\uFE0F No OAuth token found for ${bitId}. Provide tokens via credentials or complete the OAuth flow.`);
-        }
-      }
-    } else if (credentials) {
+    if (credentials) {
       const credentialKeys = Object.keys(credentials);
       if (credentialKeys.length > 0) {
         auth = credentials[credentialKeys[0]];
-        logger11.log(`\u{1F510} Using credentials for: ${credentialKeys[0]}`);
+        logger10.log(`\u{1F510} Using credentials for: ${credentialKeys[0]}`);
       }
     }
     let bitLogger = void 0;
@@ -4963,10 +4302,9 @@ async function executeGenericBitsPiece(params, moduleDefinition) {
       propsValue: {
         ...actionProps
       },
-      logger: bitLogger,
-      executor: params.executor
+      logger: bitLogger
     });
-    logger11.log(`\u2705 Successfully executed Bits piece action: ${actionName}`, result);
+    logger10.log(`\u2705 Successfully executed Bits piece action: ${actionName}`, result);
     return {
       success: true,
       module: moduleDefinition.repository,
@@ -4981,7 +4319,7 @@ async function executeGenericBitsPiece(params, moduleDefinition) {
       }
     };
   } catch (error) {
-    logger11.error(error.stack);
+    logger10.error(error.stack);
     throw error;
   }
 }
@@ -4995,7 +4333,7 @@ async function executeBitsModule(params) {
     throw new Error(`Bits module '${params.moduleName}' not found in modules.json`);
   }
   const inferredModuleName = getModuleName(moduleDefinition);
-  logger11.log(`
+  logger10.log(`
 \u{1F50D} Ensuring bits module is ready: ${inferredModuleName}`);
   await ensureModuleInstalled(moduleDefinition);
   try {
@@ -5006,7 +4344,7 @@ async function executeBitsModule(params) {
 }
 
 // packages/cortex/core/src/bits/bitsWatcher.ts
-var logger12 = LoggerFactory.getRoot();
+var logger11 = LoggerFactory.getRoot();
 function createSimpleStore2(prefix = "") {
   const storage = /* @__PURE__ */ new Map();
   return {
@@ -5024,39 +4362,6 @@ function createSimpleStore2(prefix = "") {
     }
   };
 }
-function createBoundPollingStore(workflowId, triggerId, dedupStrategy = "id") {
-  const store = createPollingStore({
-    collection: "polling_seen_items",
-    dedupStrategy
-  });
-  const ctx = { workflowId, triggerId };
-  const baseStore = createSimpleStore2(`polling:${workflowId}:${triggerId}`);
-  return {
-    // Base store methods
-    get: baseStore.get,
-    put: baseStore.put,
-    delete: baseStore.delete,
-    // Polling-specific methods
-    async hasSeenItem(itemId, itemDate) {
-      return store.hasSeenItem(ctx, itemId, itemDate);
-    },
-    async markItemSeen(itemId, sourceDate, data) {
-      return store.markItemSeen(ctx, itemId, sourceDate, data);
-    },
-    async getLastPolledDate() {
-      return store.getLastPolledDate(ctx);
-    },
-    async setLastPolledDate(date) {
-      return store.setLastPolledDate(ctx, date);
-    },
-    async getSeenCount() {
-      return store.getSeenCount(ctx);
-    },
-    async clearTrigger() {
-      return store.clearTrigger(ctx);
-    }
-  };
-}
 function isNil2(value) {
   return value === null || value === void 0;
 }
@@ -5101,7 +4406,7 @@ var bitsTriggerHelper = {
    * Execute a trigger based on hook type
    */
   async executeTrigger(params) {
-    const { moduleDefinition, triggerName, input, hookType, trigger, payload, webhookUrl, isTest, store, executor, workflowId, nodeId } = params;
+    const { moduleDefinition, triggerName, input, hookType, trigger, payload, webhookUrl, isTest, store } = params;
     if (isNil2(triggerName)) {
       throw new Error("Trigger name is not set");
     }
@@ -5112,19 +4417,11 @@ var bitsTriggerHelper = {
       const { trigger: loadedTrigger } = await this.getTrigger(moduleDefinition, triggerName);
       bitsTrigger = loadedTrigger;
     }
-    logger12.log(`\u{1F514} Executing bits trigger: ${triggerName} (${hookType})`);
+    logger11.log(`\u{1F514} Executing bits trigger: ${triggerName} (${hookType})`);
     const appListeners = [];
     let scheduleOptions;
     const storePrefix = isTest ? "test" : triggerName;
     const triggerStore = store || createSimpleStore2(storePrefix);
-    const triggerType = mapTriggerType(bitsTrigger.type);
-    let pollingStore;
-    if (triggerType === "POLLING" /* POLLING */ && workflowId) {
-      const dedupStrategy = input.dedupBy || "id";
-      const triggerId = `${moduleDefinition.repository}:${triggerName}`;
-      pollingStore = createBoundPollingStore(workflowId, triggerId, dedupStrategy);
-      logger12.log(`\u{1F4CA} Created polling store for ${triggerId} (dedup: ${dedupStrategy})`);
-    }
     let auth = void 0;
     const { credentials, ...triggerProps } = input;
     if (credentials) {
@@ -5135,7 +4432,7 @@ var bitsTriggerHelper = {
           props: credentialData,
           ...credentialData
         };
-        logger12.log(`\u{1F510} Using credentials for trigger: ${credentialKeys[0]}`);
+        logger11.log(`\u{1F510} Using credentials for trigger: ${credentialKeys[0]}`);
       }
     }
     const context = {
@@ -5154,11 +4451,7 @@ var bitsTriggerHelper = {
           cronExpression: options.cronExpression,
           timezone: options.timezone ?? "UTC"
         };
-      },
-      executor,
-      workflowId,
-      nodeId,
-      pollingStore
+      }
     };
     try {
       switch (hookType) {
@@ -5166,11 +4459,11 @@ var bitsTriggerHelper = {
           if (bitsTrigger.onEnable) {
             await bitsTrigger.onEnable(context);
           }
-          const triggerTypeForResult = mapTriggerType(bitsTrigger.type);
+          const triggerType = mapTriggerType(bitsTrigger.type);
           return {
             success: true,
             listeners: appListeners,
-            scheduleOptions: triggerTypeForResult === "POLLING" /* POLLING */ ? scheduleOptions : void 0
+            scheduleOptions: triggerType === "POLLING" /* POLLING */ ? scheduleOptions : void 0
           };
         }
         case "ON_DISABLE" /* ON_DISABLE */: {
@@ -5227,7 +4520,7 @@ var bitsTriggerHelper = {
           };
       }
     } catch (error) {
-      logger12.error(`Error executing trigger ${triggerName}:`, error);
+      logger11.error(`Error executing trigger ${triggerName}:`, error);
       return {
         success: false,
         message: `Error executing trigger: ${error}`,
@@ -5256,13 +4549,13 @@ var bitsTriggerHelper = {
    * For webhooks: calls run directly
    */
   async executeBitsTrigger(params) {
-    const { moduleDefinition, triggerName, input, payload, webhookUrl, store, executor, workflowId, nodeId } = params;
+    const { moduleDefinition, triggerName, input, payload, webhookUrl, store } = params;
     const { piece, trigger } = await this.getTrigger(moduleDefinition, triggerName);
     const triggerType = mapTriggerType(trigger.type);
     const triggerStore = store || createSimpleStore2(`trigger:${triggerName}`);
     switch (triggerType) {
       case "POLLING" /* POLLING */: {
-        logger12.log(`Polling trigger flow: onEnable \u2192 run`);
+        logger11.log(`Polling trigger flow: onEnable \u2192 run`);
         const onEnableResult = await this.executeTrigger({
           moduleDefinition,
           triggerName,
@@ -5272,22 +4565,19 @@ var bitsTriggerHelper = {
           payload,
           webhookUrl,
           isTest: false,
-          store: triggerStore,
-          executor,
-          workflowId,
-          nodeId
+          store: triggerStore
         });
         if (!onEnableResult.success) {
           return onEnableResult;
         }
-        logger12.log(`  \u2705 onEnable completed`);
+        logger11.log(`  \u2705 onEnable completed`);
         if (onEnableResult.scheduleOptions) {
-          logger12.log(`  \u{1F4C5} Schedule: ${onEnableResult.scheduleOptions.cronExpression} (${onEnableResult.scheduleOptions.timezone})`);
+          logger11.log(`  \u{1F4C5} Schedule: ${onEnableResult.scheduleOptions.cronExpression} (${onEnableResult.scheduleOptions.timezone})`);
         }
         if (onEnableResult.listeners && onEnableResult.listeners.length > 0) {
-          logger12.log(`  \u{1F442} Listeners: ${onEnableResult.listeners.length}`);
+          logger11.log(`  \u{1F442} Listeners: ${onEnableResult.listeners.length}`);
         }
-        logger12.log(`  \u2192 Calling run to fetch items...`);
+        logger11.log(`  \u2192 Calling run to fetch items...`);
         const runResult = await this.executeTrigger({
           moduleDefinition,
           triggerName,
@@ -5297,20 +4587,17 @@ var bitsTriggerHelper = {
           payload,
           webhookUrl,
           isTest: false,
-          store: triggerStore,
-          executor,
-          workflowId,
-          nodeId
+          store: triggerStore
         });
         if (!runResult.success) {
-          logger12.warn(`  \u26A0\uFE0F Run failed: ${runResult.message}`);
+          logger11.warn(`  \u26A0\uFE0F Run failed: ${runResult.message}`);
         } else {
-          logger12.log(`  \u2705 Run completed, items found: ${runResult.output?.length || 0}`);
+          logger11.log(`  \u2705 Run completed, items found: ${runResult.output?.length || 0}`);
         }
         return runResult;
       }
       case "WEBHOOK" /* WEBHOOK */: {
-        logger12.log(`Webhook trigger`);
+        logger11.log(`Webhook trigger`);
         return await this.executeTrigger({
           moduleDefinition,
           triggerName,
@@ -5318,10 +4605,7 @@ var bitsTriggerHelper = {
           hookType: "RUN" /* RUN */,
           payload,
           webhookUrl,
-          isTest: false,
-          executor,
-          workflowId,
-          nodeId
+          isTest: false
         });
       }
       default: {
@@ -5341,14 +4625,14 @@ var bitsTriggerHelper = {
     const triggers = piece.triggers();
     for (const [triggerName, trigger] of Object.entries(triggers)) {
       const triggerType = mapTriggerType(trigger.type);
-      logger12.log(`\u{1F514} Hooking trigger: ${triggerName} (type: ${triggerType})`);
+      logger11.log(`\u{1F514} Hooking trigger: ${triggerName} (type: ${triggerType})`);
       switch (triggerType) {
         case "POLLING" /* POLLING */:
-          logger12.log(`  \u2192 Setting up polling trigger`);
+          logger11.log(`  \u2192 Setting up polling trigger`);
           if (options?.onPollingTrigger) {
             options.onPollingTrigger(triggerName, trigger);
           }
-          logger12.log(`  \u{1F680} Running polling trigger immediately...`);
+          logger11.log(`  \u{1F680} Running polling trigger immediately...`);
           try {
             const result = await this.executeBitsTrigger({
               moduleDefinition,
@@ -5356,32 +4640,32 @@ var bitsTriggerHelper = {
               input: options?.input || {}
             });
             if (result.success) {
-              logger12.log(`  \u2705 Trigger ${triggerName} executed successfully`);
-              logger12.log(`  \u{1F4E6} Output items: ${result.output?.length || 0}`);
+              logger11.log(`  \u2705 Trigger ${triggerName} executed successfully`);
+              logger11.log(`  \u{1F4E6} Output items: ${result.output?.length || 0}`);
             } else {
-              logger12.warn(`  \u26A0\uFE0F Trigger ${triggerName} failed: ${result.message}`);
+              logger11.warn(`  \u26A0\uFE0F Trigger ${triggerName} failed: ${result.message}`);
             }
             if (options?.onTriggerResult) {
               options.onTriggerResult(triggerName, result);
             }
           } catch (error) {
-            logger12.error(`  \u274C Error running trigger ${triggerName}:`, error.message);
+            logger11.error(`  \u274C Error running trigger ${triggerName}:`, error.message);
           }
           break;
         case "WEBHOOK" /* WEBHOOK */:
-          logger12.log(`  \u2192 Setting up webhook trigger`);
+          logger11.log(`  \u2192 Setting up webhook trigger`);
           if (options?.onWebhookTrigger) {
             options.onWebhookTrigger(triggerName, trigger);
           }
           break;
         case "APP_WEBHOOK" /* APP_WEBHOOK */:
-          logger12.log(`  \u2192 Setting up app webhook trigger`);
+          logger11.log(`  \u2192 Setting up app webhook trigger`);
           if (options?.onAppWebhookTrigger) {
             options.onAppWebhookTrigger(triggerName, trigger);
           }
           break;
         default:
-          logger12.warn(`  \u26A0\uFE0F Unknown trigger type: ${triggerType}`);
+          logger11.warn(`  \u26A0\uFE0F Unknown trigger type: ${triggerType}`);
       }
     }
   },
@@ -5419,7 +4703,7 @@ var bitsTriggerHelper = {
    * Execute a webhook trigger with received payload
    */
   async executeWebhookTrigger(nodeId, payload, headers, query) {
-    logger12.log(`\u{1F514} Executing webhook trigger for node: ${nodeId}`);
+    logger11.log(`\u{1F514} Executing webhook trigger for node: ${nodeId}`);
     return {
       success: true,
       output: [
@@ -5440,10 +4724,10 @@ var bitsTriggerHelper = {
 import * as fs3 from "fs";
 import * as path5 from "path";
 import * as vm from "vm";
-import { spawn as spawn2, execSync as execSync2 } from "child_process";
+import { spawn, execSync } from "child_process";
 import * as os from "os";
 import * as ts from "typescript";
-var logger13 = LoggerFactory.getRoot();
+var logger12 = LoggerFactory.getRoot();
 function convertDenoImports(code) {
   const npmPackages = [];
   const imports = [];
@@ -5616,7 +4900,7 @@ async function executeJavaScript(code, params, context) {
     });
     return result;
   } catch (error) {
-    logger13.error(`JavaScript execution error: ${error.message}`);
+    logger12.error(`JavaScript execution error: ${error.message}`);
     throw error;
   }
 }
@@ -5645,7 +4929,7 @@ if __name__ == "__main__":
   fs3.writeFileSync(scriptPath, wrappedCode);
   return new Promise((resolve4, reject) => {
     const pythonCmd = process.platform === "win32" ? "python" : "python3";
-    const proc = spawn2(pythonCmd, [scriptPath], {
+    const proc = spawn(pythonCmd, [scriptPath], {
       env: { ...process.env },
       cwd: tmpDir
     });
@@ -5724,8 +5008,8 @@ func main() {
   fs3.writeFileSync(scriptPath, wrappedCode);
   return new Promise((resolve4, reject) => {
     try {
-      execSync2(`go build -o main`, { cwd: scriptDir, stdio: "pipe" });
-      const proc = spawn2("./main", [], {
+      execSync(`go build -o main`, { cwd: scriptDir, stdio: "pipe" });
+      const proc = spawn("./main", [], {
         cwd: scriptDir,
         env: { ...process.env }
       });
@@ -5797,7 +5081,7 @@ ${code}
 `;
   fs3.writeFileSync(scriptPath, wrappedCode, { mode: 493 });
   return new Promise((resolve4, reject) => {
-    const proc = spawn2("bash", [scriptPath], {
+    const proc = spawn("bash", [scriptPath], {
       env: { ...process.env },
       cwd: tmpDir
     });
@@ -5871,9 +5155,9 @@ async function executeScriptModule(paramsOrModuleName, maybeParams) {
     executionParams = paramsOrModuleName.params;
     inlineScript = paramsOrModuleName.script;
   }
-  logger13.log(`
+  logger12.log(`
 \u{1F300} Executing Script module: ${moduleName}`);
-  logger13.log(`   Source: ${source}`);
+  logger12.log(`   Source: ${source}`);
   let script = null;
   if (source === "inline" && inlineScript) {
     script = inlineScript;
@@ -5885,7 +5169,7 @@ async function executeScriptModule(paramsOrModuleName, maybeParams) {
   if (!script || !script.content) {
     throw new Error(`Could not load script: ${moduleName}`);
   }
-  logger13.log(`   Language: ${script.language}`);
+  logger12.log(`   Language: ${script.language}`);
   const context = {
     flow_input: executionParams,
     previous_result: executionParams.previous_result || null,
@@ -5911,7 +5195,7 @@ async function executeScriptModule(paramsOrModuleName, maybeParams) {
       default:
         throw new Error(`Unsupported language: ${script.language}`);
     }
-    logger13.log(`\u2705 Script executed successfully`);
+    logger12.log(`\u2705 Script executed successfully`);
     return {
       success: true,
       module: moduleName,
@@ -5925,7 +5209,7 @@ async function executeScriptModule(paramsOrModuleName, maybeParams) {
       }
     };
   } catch (error) {
-    logger13.error(`\u274C Script failed: ${error.message}`);
+    logger12.error(`\u274C Script failed: ${error.message}`);
     return {
       success: false,
       module: moduleName,
@@ -5952,7 +5236,7 @@ function getSecurityConfig() {
   const moderationEnabled = process.env.HABITS_MODERATION_ENABLED === "true";
   return { dlpEnabled, dlpIcapUrl, dlpIcapTimeout, piiMode, moderationEnabled };
 }
-async function scanInputForSecurity(data, config, logger15) {
+async function scanInputForSecurity(data, config, logger13) {
   let processedData = data;
   if (!config.dlpEnabled && !config.piiMode && !config.moderationEnabled) {
     return processedData;
@@ -5960,50 +5244,50 @@ async function scanInputForSecurity(data, config, logger15) {
   try {
     const intersect = await import("@codenteam/intersect");
     if (config.dlpEnabled) {
-      logger15.log("\u{1F510} [Security] Running DLP scan on input data...");
+      logger13.log("\u{1F510} [Security] Running DLP scan on input data...");
       try {
         const dlpOptions = {};
         if (config.dlpIcapUrl) {
           dlpOptions.icapUrl = config.dlpIcapUrl;
           dlpOptions.timeout = config.dlpIcapTimeout;
-          logger15.log(`\u{1F510} [DLP] Using ICAP server: ${config.dlpIcapUrl}`);
+          logger13.log(`\u{1F510} [DLP] Using ICAP server: ${config.dlpIcapUrl}`);
         }
         const dlpResult = await intersect.dlp.consume(processedData, dlpOptions);
         processedData = dlpResult.data ?? processedData;
         if (dlpResult.findings && dlpResult.findings.length > 0) {
-          logger15.log(`\u{1F510} [DLP] Found ${dlpResult.findings.length} sensitive data instance(s)`);
+          logger13.log(`\u{1F510} [DLP] Found ${dlpResult.findings.length} sensitive data instance(s)`);
         }
       } catch (dlpError) {
-        logger15.warn(`\u26A0\uFE0F [DLP] Scan failed: ${dlpError.message}`);
+        logger13.warn(`\u26A0\uFE0F [DLP] Scan failed: ${dlpError.message}`);
       }
     }
     if (config.piiMode) {
-      logger15.log(`\u{1F510} [Security] Running PII scan (mode: ${config.piiMode}) on input data...`);
+      logger13.log(`\u{1F510} [Security] Running PII scan (mode: ${config.piiMode}) on input data...`);
       try {
         const piiResult = await intersect.pii.consume(processedData, { mode: config.piiMode });
         processedData = piiResult.data ?? processedData;
         if (piiResult.detections && piiResult.detections.length > 0) {
-          logger15.log(`\u{1F510} [PII] Found ${piiResult.detections.length} PII instance(s) - mode: ${config.piiMode}`);
+          logger13.log(`\u{1F510} [PII] Found ${piiResult.detections.length} PII instance(s) - mode: ${config.piiMode}`);
         }
       } catch (piiError) {
-        logger15.warn(`\u26A0\uFE0F [PII] Scan failed: ${piiError.message}`);
+        logger13.warn(`\u26A0\uFE0F [PII] Scan failed: ${piiError.message}`);
       }
     }
     if (config.moderationEnabled) {
-      logger15.log("\u{1F510} [Security] Running moderation scan on input data...");
+      logger13.log("\u{1F510} [Security] Running moderation scan on input data...");
       try {
         const modResult = await intersect.moderation.consume(processedData);
         if (modResult.flagged) {
-          logger15.warn(`\u26A0\uFE0F [Moderation] Content flagged: ${JSON.stringify(modResult.categories)}`);
+          logger13.warn(`\u26A0\uFE0F [Moderation] Content flagged: ${JSON.stringify(modResult.categories)}`);
         }
         processedData = modResult.data ?? processedData;
       } catch (modError) {
-        logger15.warn(`\u26A0\uFE0F [Moderation] Scan failed: ${modError.message}`);
+        logger13.warn(`\u26A0\uFE0F [Moderation] Scan failed: ${modError.message}`);
       }
     }
   } catch (importError) {
-    logger15.warn(`\u26A0\uFE0F [Security] @codenteam/intersect package not available: ${importError.message}`);
-    logger15.warn("   Security features (DLP, PII, Moderation) are disabled.");
+    logger13.warn(`\u26A0\uFE0F [Security] @codenteam/intersect package not available: ${importError.message}`);
+    logger13.warn("   Security features (DLP, PII, Moderation) are disabled.");
   }
   return processedData;
 }
@@ -6016,8 +5300,6 @@ var WorkflowExecutor = class {
     this.config = null;
     this.logger = LoggerFactory.getRoot();
     this.env = {};
-    /** Active polling cron jobs - keyed by workflowId:nodeId */
-    this.pollingCronJobs = /* @__PURE__ */ new Map();
   }
   /**
    * Initialize from in-memory data (no file system access needed)
@@ -6072,7 +5354,7 @@ var WorkflowExecutor = class {
         this.logger.log(`   \u{1F511} Environment variables:`);
         for (const key of Object.keys(this.env)) {
           if (key.startsWith("HABITS_")) {
-            this.logger.log(`      - ${key}: ${this.env[key] !== void 0 ? "(Set but a secret you know)" : "(not set)"}`);
+            this.logger.log(`      - ${key}: ${this.env[key]}`);
           }
         }
         this.logger.log(`   \u{1F4CB} Resolvable habits params in workflow:`);
@@ -6082,7 +5364,7 @@ var WorkflowExecutor = class {
             if (param.startsWith("habits.env.")) {
               const envVar = param.slice("habits.env.".length);
               const value = this.env[envVar];
-              this.logger.log(`      - {{${param}}} \u2192 ${value !== void 0 ? "(Set but a secret you know)" : "(not set)"}`);
+              this.logger.log(`      - {{${param}}} \u2192 ${value !== void 0 ? value : "(not set)"}`);
             } else {
               this.logger.log(`      - {{${param}}} \u2192 (resolved at runtime)`);
             }
@@ -6152,7 +5434,6 @@ var WorkflowExecutor = class {
 \u{1F4E6} Module preloading complete
 `);
     await this.hookPollingTriggers();
-    await this.registerBitsPollingTriggers();
   }
   /**
    * Hook polling triggers for all loaded workflows
@@ -6215,145 +5496,6 @@ var WorkflowExecutor = class {
       }
     }
   }
-  /**
-   * Register bits polling triggers with cron scheduling.
-   * Scans workflows for polling trigger nodes, calls their onEnable() to get schedule,
-   * then creates cron jobs using croner to periodically call run().
-   */
-  async registerBitsPollingTriggers() {
-    const workflows = this.getAllWorkflows();
-    this.logger.log(`
-\u23F0 Scanning ${workflows.length} workflow(s) for polling triggers...`);
-    let registeredCount = 0;
-    for (const { reference, workflow } of workflows) {
-      if (reference.enabled === false) continue;
-      const workflowId = reference.id || workflow.id;
-      for (const node of workflow.nodes || []) {
-        const nodeData = node.data;
-        const isTrigger = nodeData?.isTrigger === true || node.type === "trigger";
-        const isBits = nodeData?.framework === "bits";
-        const hasModule = !!nodeData?.module;
-        if (!isTrigger || !isBits || !hasModule) continue;
-        const moduleName = nodeData.module;
-        const triggerName = nodeData.operation || "default";
-        try {
-          let bitPiece = null;
-          const moduleDefinition = {
-            source: nodeData.source || "npm",
-            module: moduleName,
-            framework: "bits",
-            repository: moduleName
-          };
-          try {
-            bitPiece = await pieceFromModule2(moduleDefinition);
-          } catch (loadError) {
-            this.logger.warn(`   \u26A0\uFE0F Could not load module ${moduleName}: ${loadError}`);
-            continue;
-          }
-          const triggers = typeof bitPiece.triggers === "function" ? bitPiece.triggers() : bitPiece.triggers;
-          const trigger = triggers?.[triggerName];
-          if (!trigger) {
-            this.logger.warn(`   \u26A0\uFE0F Trigger ${triggerName} not found in module ${moduleName}`);
-            continue;
-          }
-          const triggerType = trigger.type?.toUpperCase?.() || trigger.type;
-          if (triggerType !== "POLLING") {
-            continue;
-          }
-          const rawProps = nodeData.params || {};
-          const triggerProps = this.resolveParameters(rawProps, {});
-          this.logger.log(`   \u23F0 Enabling polling trigger: ${workflowId}/${node.id} (${moduleName}:${triggerName})`);
-          const result = await bitsTriggerHelper.executeTrigger({
-            moduleDefinition,
-            triggerName,
-            input: triggerProps,
-            hookType: "ON_ENABLE" /* ON_ENABLE */,
-            trigger,
-            workflowId,
-            nodeId: node.id
-          });
-          if (!result.success) {
-            this.logger.warn(`   \u26A0\uFE0F Failed to enable ${workflowId}/${node.id}: ${result.message}`);
-            continue;
-          }
-          const scheduleOptions = result.scheduleOptions;
-          if (!scheduleOptions?.cronExpression) {
-            this.logger.warn(`   \u26A0\uFE0F No schedule returned from onEnable for ${workflowId}/${node.id}`);
-            continue;
-          }
-          const cronKey = `${workflowId}:${node.id}`;
-          const { cronExpression, timezone = "UTC" } = scheduleOptions;
-          this.logger.log(`   \u{1F4C5} Creating cron job: ${cronExpression} (${timezone}) for ${cronKey}`);
-          const cronJob = new Cron(cronExpression, { timezone, name: cronKey }, async () => {
-            const triggeredAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.logger.log(`   \u23F0 Cron fired: ${cronKey} at ${triggeredAt}`);
-            try {
-              const runResult = await bitsTriggerHelper.executeTrigger({
-                moduleDefinition,
-                triggerName,
-                input: triggerProps,
-                hookType: "RUN" /* RUN */,
-                trigger,
-                workflowId,
-                nodeId: node.id
-              });
-              if (runResult.success && runResult.output && runResult.output.length > 0) {
-                this.logger.log(`   \u{1F4E6} Trigger returned ${runResult.output.length} item(s), executing workflow for each...`);
-                const loadedWorkflow = this.getWorkflow(workflowId);
-                if (!loadedWorkflow) {
-                  this.logger.error(`   \u274C Workflow ${workflowId} not found`);
-                  return;
-                }
-                for (let i = 0; i < runResult.output.length; i++) {
-                  const item = runResult.output[i];
-                  this.logger.log(`   \u{1F504} Processing item ${i + 1}/${runResult.output.length}`);
-                  try {
-                    const execution = await this.executeWorkflow(loadedWorkflow.workflow, {
-                      initialContext: {
-                        "habits.input": item,
-                        // Single item, not array
-                        __pollingTrigger: true,
-                        __pollingNodeId: node.id,
-                        __triggeredAt: triggeredAt,
-                        __pollingItemIndex: i
-                      },
-                      skipTriggerWait: true,
-                      triggerNodeId: node.id
-                    });
-                    this.logger.log(`   \u2705 Item ${i + 1} processed: ${execution.status}`);
-                  } catch (itemErr) {
-                    this.logger.error(`   \u274C Item ${i + 1} failed: ${itemErr.message}`);
-                  }
-                }
-                this.logger.log(`   \u2705 Workflow ${workflowId} completed processing ${runResult.output.length} item(s)`);
-              } else {
-                this.logger.log(`   \u23F3 No new items from trigger, skipping workflow execution`);
-              }
-            } catch (err) {
-              this.logger.error(`   \u274C Error in polling trigger: ${err.message}`);
-            }
-          });
-          this.pollingCronJobs.set(cronKey, cronJob);
-          registeredCount++;
-          this.logger.log(`   \u2705 Registered: ${workflowId}/${node.id} (${triggerName}) -> ${cronExpression}`);
-        } catch (error) {
-          this.logger.error(`   \u274C Error enabling polling trigger for ${workflowId}/${node.id}: ${error}`);
-        }
-      }
-    }
-    this.logger.log(`\u23F0 Enabled ${registeredCount} polling trigger(s)
-`);
-  }
-  /**
-   * Stop all polling cron jobs
-   */
-  stopPollingTriggers() {
-    for (const [key, cron] of this.pollingCronJobs) {
-      cron.stop();
-      this.logger.log(`   \u23F9\uFE0F Stopped polling trigger: ${key}`);
-    }
-    this.pollingCronJobs.clear();
-  }
   /**
    * Find all template params starting with "habits." in a workflow
    */
@@ -6463,7 +5605,7 @@ var WorkflowExecutor = class {
     });
     try {
       const webhookTriggers = this.findWebhookTriggers(workflow.nodes);
-      if (webhookTriggers.length > 0 && !options?.skipTriggerWait) {
+      if (webhookTriggers.length > 0) {
         if (!options?.webhookHandler) {
           throw new Error(
             `Workflow "${workflow.name}" contains ${webhookTriggers.length} webhook trigger(s) but no webhookHandler was provided. Webhook triggers are only supported in Node.js server environments. Provide a webhookHandler via options or remove webhook triggers from the workflow.`
@@ -6475,9 +5617,6 @@ var WorkflowExecutor = class {
           this.logger.log(`   - Node: ${trigger.nodeId}`);
         }
         this.logger.log("\n\u23F3 Waiting for webhook(s) to be triggered...\n");
-      } else if (webhookTriggers.length > 0 && options?.skipTriggerWait) {
-        this.logger.log(`
-\u{1F4CB} Detected ${webhookTriggers.length} webhook trigger(s) - using pre-provided payload`);
       }
       const dependencies = this.buildDependencyMap(workflow.nodes, workflow?.edges || []);
       execution.nodeStatuses = workflow.nodes.map((node) => ({
@@ -6485,9 +5624,6 @@ var WorkflowExecutor = class {
         status: "pending"
       }));
       let context = options?.initialContext ? { ...options.initialContext } : {};
-      if (options?.oauthTokens) {
-        context._oauthTokens = options.oauthTokens;
-      }
       if (!context.habits) {
         context.habits = {};
       }
@@ -6556,76 +5692,31 @@ var WorkflowExecutor = class {
             status: "running"
           });
           try {
-            const isPollingTriggerNode = context.__pollingTrigger && context.__pollingNodeId === nodeId && (node.type === "trigger" || node.data?.isTrigger);
-            if (isPollingTriggerNode) {
-              this.logger.log(`\u23F0 Using pre-fetched polling data for trigger node: ${nodeId}`);
-              const pollingData = context["habits.input"];
-              const scannedResult = await scanInputForSecurity(pollingData, securityConfig, this.logger);
+            if (this.isWebhookTriggerNode(node)) {
+              const webhookResult = await this.handleWebhookTrigger(node, context, execution, options.webhookHandler, options?.webhookTimeout);
+              const scannedResult = await scanInputForSecurity(webhookResult.result, securityConfig, this.logger);
               context[`${nodeId}`] = scannedResult;
               context[nodeId] = scannedResult;
               context.previous_result = scannedResult;
-              this.updateNodeStatus(execution, nodeId, "completed", {
+              context.webhookPayload = scannedResult;
+              this.updateNodeStatus(execution, nodeId, webhookResult.success ? "completed" : "failed", {
                 result: scannedResult,
-                startTime: /* @__PURE__ */ new Date(),
-                endTime: /* @__PURE__ */ new Date(),
-                duration: 0
+                error: webhookResult.error,
+                startTime: new Date(webhookResult.timestamp.getTime() - webhookResult.duration),
+                endTime: webhookResult.timestamp,
+                duration: webhookResult.duration
               });
               emitStreamEvent({
-                type: "node_completed",
+                type: webhookResult.success ? "node_completed" : "node_failed",
                 nodeId,
                 nodeName: node.data.label,
-                status: "completed",
+                status: webhookResult.success ? "completed" : "failed",
                 result: scannedResult,
-                duration: 0
+                error: webhookResult.error,
+                duration: webhookResult.duration
               });
-            } else if (this.isWebhookTriggerNode(node)) {
-              const skipWait = options?.skipTriggerWait && (options?.triggerNodeId === nodeId || !options?.triggerNodeId);
-              if (skipWait && context.webhookPayload) {
-                this.logger.log(`\u{1F514} Using pre-provided webhook payload for trigger node: ${nodeId}`);
-                const scannedResult = await scanInputForSecurity(context.webhookPayload, securityConfig, this.logger);
-                context[`${nodeId}`] = scannedResult;
-                context[nodeId] = scannedResult;
-                context.previous_result = scannedResult;
-                this.updateNodeStatus(execution, nodeId, "completed", {
-                  result: scannedResult,
-                  startTime: /* @__PURE__ */ new Date(),
-                  endTime: /* @__PURE__ */ new Date(),
-                  duration: 0
-                });
-                emitStreamEvent({
-                  type: "node_completed",
-                  nodeId,
-                  nodeName: node.data.label,
-                  status: "completed",
-                  result: scannedResult,
-                  duration: 0
-                });
-              } else {
-                const webhookResult = await this.handleWebhookTrigger(node, context, execution, options.webhookHandler, options?.webhookTimeout);
-                const scannedResult = await scanInputForSecurity(webhookResult.result, securityConfig, this.logger);
-                context[`${nodeId}`] = scannedResult;
-                context[nodeId] = scannedResult;
-                context.previous_result = scannedResult;
-                context.webhookPayload = scannedResult;
-                this.updateNodeStatus(execution, nodeId, webhookResult.success ? "completed" : "failed", {
-                  result: scannedResult,
-                  error: webhookResult.error,
-                  startTime: new Date(webhookResult.timestamp.getTime() - webhookResult.duration),
-                  endTime: webhookResult.timestamp,
-                  duration: webhookResult.duration
-                });
-                emitStreamEvent({
-                  type: webhookResult.success ? "node_completed" : "node_failed",
-                  nodeId,
-                  nodeName: node.data.label,
-                  status: webhookResult.success ? "completed" : "failed",
-                  result: scannedResult,
-                  error: webhookResult.error,
-                  duration: webhookResult.duration
-                });
-                if (!webhookResult.success) {
-                  this.logger.error(`\u274C Webhook trigger ${nodeId} failed: ${webhookResult.error}`);
-                }
+              if (!webhookResult.success) {
+                this.logger.error(`\u274C Webhook trigger ${nodeId} failed: ${webhookResult.error}`);
               }
             } else {
               const nodeResult = await this.executeNode(node, context, execution);
@@ -6997,10 +6088,7 @@ var WorkflowExecutor = class {
               triggerName: node.data.operation || "unknown",
               input: fullParams,
               payload: context.triggerPayload || context.webhookPayload || {},
-              webhookUrl: context.webhookUrl,
-              executor: this,
-              workflowId: execution.workflowId,
-              nodeId: node.id
+              webhookUrl: context.webhookUrl
             });
             if (!triggerResult.success) {
               throw new Error(triggerResult.message || "Trigger execution failed");
@@ -7015,10 +6103,7 @@ var WorkflowExecutor = class {
               logger: this.logger,
               workflowId: execution.workflowId,
               nodeId: node.id,
-              executionId: execution.id,
-              executor: this,
-              // Pass per-user OAuth tokens from context (for multi-user server mode)
-              oauthTokens: context._oauthTokens
+              executionId: execution.id
             });
             nodeResult = output.result;
           }
@@ -7095,34 +6180,9 @@ var WorkflowExecutor = class {
   }
   /**
    * Evaluate a JavaScript expression in the given context
-   * Supports default values with || operator: {{habits.input.value || 'default'}}
    */
   evaluateExpression(expression, context) {
     try {
-      const defaultMatch = expression.match(/^(.+?)\s*\|\|\s*(['"`])(.*)(\2)$/);
-      if (defaultMatch) {
-        const [, mainExpr, , defaultValue] = defaultMatch;
-        const result = this.evaluateExpression(mainExpr.trim(), context);
-        if (result === void 0 || result === null || result === "" || result === mainExpr.trim()) {
-          return defaultValue;
-        }
-        return result;
-      }
-      const defaultUnquotedMatch = expression.match(/^(.+?)\s*\|\|\s*([^'"`].*)$/);
-      if (defaultUnquotedMatch) {
-        const [, mainExpr, defaultValue] = defaultUnquotedMatch;
-        const result = this.evaluateExpression(mainExpr.trim(), context);
-        if (result === void 0 || result === null || result === "" || result === mainExpr.trim()) {
-          const trimmedDefault = defaultValue.trim();
-          if (trimmedDefault === "true") return true;
-          if (trimmedDefault === "false") return false;
-          if (trimmedDefault === "null") return null;
-          const num = Number(trimmedDefault);
-          if (!isNaN(num)) return num;
-          return trimmedDefault;
-        }
-        return result;
-      }
       if (expression.startsWith("habits.env.")) {
         const envVar = expression.slice("habits.env.".length);
         const value = this.env[envVar] ?? (typeof process !== "undefined" ? process.env?.[envVar] : void 0);
@@ -7457,6 +6517,7 @@ function assertNotNullOrUndefined(value, fieldName) {
 }
 
 // packages/cortex/core/src/bits/framework.ts
+import axios4 from "axios";
 var AuthenticationType = /* @__PURE__ */ ((AuthenticationType2) => {
   AuthenticationType2["BEARER_TOKEN"] = "BEARER_TOKEN";
   AuthenticationType2["BASIC"] = "BASIC";
@@ -7477,42 +6538,42 @@ var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
 })(HttpMethod || {});
 var httpClient = {
   async sendRequest(request) {
-    const headers = { ...request.headers };
+    const config = {
+      url: request.url,
+      method: request.method,
+      headers: { ...request.headers },
+      data: request.body,
+      params: request.queryParams,
+      timeout: request.timeout || 3e4
+    };
     if (request.authentication) {
       switch (request.authentication.type) {
         case "BEARER_TOKEN" /* BEARER_TOKEN */:
-          headers["Authorization"] = `Bearer ${request.authentication.token}`;
+          config.headers = {
+            ...config.headers,
+            Authorization: `Bearer ${request.authentication.token}`
+          };
           break;
         case "BASIC" /* BASIC */:
-          const credentials = Buffer.from(
-            `${request.authentication.username || ""}:${request.authentication.password || ""}`
-          ).toString("base64");
-          headers["Authorization"] = `Basic ${credentials}`;
+          config.auth = {
+            username: request.authentication.username || "",
+            password: request.authentication.password || ""
+          };
           break;
         case "API_KEY" /* API_KEY */:
           const headerName = request.authentication.headerName || "X-API-Key";
-          headers[headerName] = request.authentication.apiKey || "";
+          config.headers = {
+            ...config.headers,
+            [headerName]: request.authentication.apiKey || ""
+          };
           break;
       }
     }
-    let url = request.url;
-    if (request.queryParams && Object.keys(request.queryParams).length > 0) {
-      const params = new URLSearchParams(request.queryParams);
-      url += (url.includes("?") ? "&" : "?") + params.toString();
-    }
-    const response = await fetch2(url, {
-      method: request.method,
-      headers,
-      body: request.body ? JSON.stringify(request.body) : void 0
-    });
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
+    const response = await axios4(config);
     return {
       status: response.status,
-      headers: responseHeaders,
-      body: await response.json()
+      headers: response.headers,
+      body: response.data
     };
   }
 };
@@ -7662,24 +6723,13 @@ var BitAuth = {
   },
   OAuth2(config) {
     return {
-      type: "OAUTH2",
-      displayName: config.displayName,
+      type: "CUSTOM_AUTH",
+      displayName: "OAuth2",
       description: config.description,
       required: config.required,
-      authorizationUrl: config.authorizationUrl,
-      tokenUrl: config.tokenUrl,
-      clientId: config.clientId,
-      clientSecret: config.clientSecret,
-      scopes: config.scopes,
-      pkce: config.pkce ?? true,
-      // PKCE enabled by default
-      extraAuthParams: config.extraAuthParams
+      ...config
     };
   },
-  /** @deprecated Use OAuth2() instead */
-  OAuth2PKCE(config) {
-    return BitAuth.OAuth2({ ...config, pkce: true });
-  },
   BasicAuth(config) {
     return {
       type: "CUSTOM_AUTH",
@@ -7721,7 +6771,6 @@ function createTrigger(config) {
     run: config.run,
     test: config.test,
     onHandshake: config.onHandshake,
-    filter: config.filter,
     sampleData: config.sampleData
   };
 }
@@ -7768,7 +6817,6 @@ function createBit(config) {
     }
   }
   return {
-    id: config.id,
     displayName: config.displayName,
     description: config.description,
     logoUrl: config.logoUrl,
@@ -7844,530 +6892,14 @@ function createCustomApiCallAction(config) {
     }
   });
 }
-
-// packages/cortex/core/src/bits/oauthDiscovery.ts
-var logger14 = LoggerFactory.create(void 0, void 0, { bitName: "OAuthDiscovery" });
-function resolveEnvExpression(value) {
-  if (typeof value !== "string") return value;
-  const envPattern = /\{\{habits\.env\.([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
-  return value.replace(envPattern, (match, envVar) => {
-    return process.env[envVar] || "";
-  });
-}
-function extractAuthCredentials(nodeAuth) {
-  if (!nodeAuth) return {};
-  let clientId = nodeAuth.clientId || nodeAuth.CLIENT_ID || nodeAuth.client_id;
-  let clientSecret = nodeAuth.clientSecret || nodeAuth.CLIENT_SECRET || nodeAuth.client_secret;
-  if (clientId) clientId = resolveEnvExpression(clientId);
-  if (clientSecret) clientSecret = resolveEnvExpression(clientSecret);
-  return { clientId, clientSecret };
-}
-function extractBitId(moduleName) {
-  const parts = moduleName.split("/");
-  return parts[parts.length - 1];
-}
-async function getAuthFromModule(moduleDefinition) {
-  const moduleName = getModuleName(moduleDefinition);
-  try {
-    if (isBundledModule(moduleDefinition.repository)) {
-      const loadedModule = getBundledModule(moduleDefinition.repository);
-      if (loadedModule) {
-        const piece = extractBitsPieceFromModule(loadedModule);
-        return { auth: piece.auth, displayName: piece.displayName };
-      }
-      return null;
-    }
-    const mainFilePath = getModuleMainFile(moduleDefinition);
-    if (!mainFilePath) {
-      return null;
-    }
-    const originalCwd = process.cwd();
-    const moduleDir = dirname(mainFilePath);
-    let nodeModulesDir = moduleDir;
-    while (nodeModulesDir && !nodeModulesDir.endsWith("/node_modules") && nodeModulesDir !== dirname(nodeModulesDir)) {
-      nodeModulesDir = dirname(nodeModulesDir);
-    }
-    try {
-      process.chdir(moduleDir);
-      const loadedModule = simpleRequire(mainFilePath, nodeModulesDir);
-      const piece = extractBitsPieceFromModule(loadedModule);
-      process.chdir(originalCwd);
-      return { auth: piece.auth, displayName: piece.displayName };
-    } catch (error) {
-      process.chdir(originalCwd);
-      throw error;
-    }
-  } catch (error) {
-    logger14.warn("Failed to load auth from module", { moduleName, error: String(error) });
-    return null;
-  }
-}
-function isOAuth2(auth) {
-  return auth && (auth.type === "OAUTH2" || auth.type === "OAUTH2_PKCE");
-}
-async function discoverOAuthRequirements(workflows) {
-  const requirements = [];
-  const processedModules = /* @__PURE__ */ new Set();
-  for (const [workflowId, workflow] of workflows) {
-    for (const node of workflow.nodes) {
-      const nodeData = node.data;
-      if (nodeData?.framework !== "bits") {
-        continue;
-      }
-      const moduleName = nodeData.module;
-      if (!moduleName || processedModules.has(moduleName)) {
-        continue;
-      }
-      processedModules.add(moduleName);
-      const moduleDefinition = {
-        repository: moduleName,
-        source: "npm",
-        framework: "bits"
-      };
-      const moduleAuth = await getAuthFromModule(moduleDefinition);
-      if (!moduleAuth || !isOAuth2(moduleAuth.auth)) {
-        continue;
-      }
-      const bitId = extractBitId(moduleName);
-      const hasValidToken = oauthTokenStore.hasValidToken(bitId);
-      const isExpired = oauthTokenStore.isExpired(bitId);
-      let status;
-      if (hasValidToken && !isExpired) {
-        status = "valid";
-      } else if (hasValidToken && isExpired) {
-        status = "expired";
-      } else {
-        status = "needed";
-      }
-      const nodeAuthCredentials = extractAuthCredentials(nodeData.auth);
-      const clientId = nodeAuthCredentials.clientId || moduleAuth.auth.clientId;
-      const clientSecret = nodeAuthCredentials.clientSecret || moduleAuth.auth.clientSecret;
-      requirements.push({
-        bitId,
-        moduleName,
-        displayName: moduleAuth.displayName,
-        config: {
-          displayName: moduleAuth.auth.displayName,
-          description: moduleAuth.auth.description,
-          required: moduleAuth.auth.required,
-          authorizationUrl: moduleAuth.auth.authorizationUrl,
-          tokenUrl: moduleAuth.auth.tokenUrl,
-          clientId,
-          clientSecret,
-          scopes: moduleAuth.auth.scopes,
-          extraAuthParams: moduleAuth.auth.extraAuthParams
-        },
-        hasValidToken,
-        status
-      });
-    }
-  }
-  return requirements;
-}
-async function printOAuthRequirements(requirements, getAuthUrl) {
-  const neededRequirements = requirements.filter((r) => r.status !== "valid");
-  if (neededRequirements.length === 0) {
-    logger14.info("All OAuth2 tokens are valid");
-    return;
-  }
-  console.log("\n" + "=".repeat(60));
-  console.log("\u{1F510} OAuth2 Authorization Required");
-  console.log("=".repeat(60));
-  for (const req of neededRequirements) {
-    const statusIcon = req.status === "expired" ? "\u26A0\uFE0F  (expired)" : "\u274C (missing)";
-    console.log(`
-\u{1F4E6} ${req.displayName} ${statusIcon}`);
-    console.log(`   Module: ${req.moduleName}`);
-    console.log(`   Scopes: ${req.config.scopes.join(", ")}`);
-    const authUrl = await getAuthUrl(req);
-    console.log(`   \u279C Visit: ${authUrl}`);
-  }
-  console.log("\n" + "=".repeat(60));
-  console.log("Open the URLs above in your browser to authorize access.");
-  console.log("After authorization, the tokens will be stored automatically.");
-  console.log("=".repeat(60) + "\n");
-}
-
-// packages/cortex/core/src/bits/OAuthFlowManager.ts
-var OAuthFlowManager = class {
-  constructor(options) {
-    this.pendingFlows = /* @__PURE__ */ new Map();
-    this.callbackBaseUrl = options.callbackBaseUrl.replace(/\/$/, "");
-    this.logger = options.logger ?? LoggerFactory.create(void 0, void 0, { bitName: "OAuthFlowManager" });
-  }
-  /**
-   * Generate a cryptographically secure random string for PKCE code verifier.
-   * RFC 7636 requires 43-128 characters, URL-safe.
-   * 
-   * Uses Web Crypto API for platform compatibility.
-   */
-  generateCodeVerifier() {
-    const randomBytes = new Uint8Array(32);
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      crypto.getRandomValues(randomBytes);
-    } else {
-      for (let i = 0; i < 32; i++) {
-        randomBytes[i] = Math.floor(Math.random() * 256);
-      }
-    }
-    return this.base64UrlEncode(randomBytes).slice(0, 43);
-  }
-  /**
-   * Generate code challenge from verifier using SHA256.
-   * RFC 7636 S256 method.
-   */
-  async generateCodeChallenge(codeVerifier) {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(codeVerifier);
-    if (typeof crypto !== "undefined" && crypto.subtle) {
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      return this.base64UrlEncode(new Uint8Array(hashBuffer));
-    }
-    try {
-      const nodeCrypto = await import("crypto");
-      const hash = nodeCrypto.createHash("sha256").update(codeVerifier).digest();
-      return this.base64UrlEncode(new Uint8Array(hash));
-    } catch {
-      throw new Error("No crypto implementation available for PKCE code challenge");
-    }
-  }
-  /**
-   * Generate a random state parameter for CSRF protection.
-   */
-  generateState() {
-    const randomBytes = new Uint8Array(16);
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      crypto.getRandomValues(randomBytes);
-    } else {
-      for (let i = 0; i < 16; i++) {
-        randomBytes[i] = Math.floor(Math.random() * 256);
-      }
-    }
-    return Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  /**
-   * Base64URL encode a Uint8Array (RFC 4648).
-   */
-  base64UrlEncode(data) {
-    let binary = "";
-    for (let i = 0; i < data.length; i++) {
-      binary += String.fromCharCode(data[i]);
-    }
-    const base64 = btoa(binary);
-    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  }
-  /**
-   * Initiate an OAuth2 flow for a bit.
-   * 
-   * @param bitId - Unique identifier for the bit (e.g., "bit-google-drive")
-   * @param config - OAuth2 configuration
-   * @returns Authorization URL and flow info
-   */
-  async initiateFlow(bitId, config) {
-    const state = this.generateState();
-    const redirectUri = `${this.callbackBaseUrl}/${bitId}/callback`;
-    const usePkce = config.pkce !== false;
-    const codeVerifier = usePkce ? this.generateCodeVerifier() : void 0;
-    const codeChallenge = usePkce && codeVerifier ? await this.generateCodeChallenge(codeVerifier) : void 0;
-    const oauthState = {
-      codeVerifier,
-      codeChallenge,
-      state,
-      redirectUri,
-      bitId,
-      createdAt: Date.now(),
-      config
-    };
-    this.pendingFlows.set(state, oauthState);
-    this.logger.info("OAuth flow initiated", { bitId, redirectUri, pkce: usePkce });
-    const params = new URLSearchParams({
-      response_type: "code",
-      client_id: config.clientId,
-      redirect_uri: redirectUri,
-      scope: config.scopes.join(" "),
-      state
-    });
-    if (usePkce && codeChallenge) {
-      params.set("code_challenge", codeChallenge);
-      params.set("code_challenge_method", "S256");
-    }
-    if (config.extraAuthParams) {
-      for (const [key, value] of Object.entries(config.extraAuthParams)) {
-        params.set(key, value);
-      }
-    }
-    const authUrl = `${config.authorizationUrl}?${params.toString()}`;
-    return { authUrl, state, redirectUri };
-  }
-  /**
-   * Parse an OAuth callback URL to extract parameters.
-   * Supports both query parameters (?code=...) and hash fragments (#access_token=...).
-   * 
-   * @param callbackUrl - Full callback URL received from OAuth provider
-   * @returns Parsed callback parameters
-   */
-  parseCallbackUrl(callbackUrl) {
-    const result = {};
-    try {
-      const url = new URL(callbackUrl);
-      const queryParams = url.searchParams;
-      if (queryParams.has("code")) {
-        result.code = queryParams.get("code") || void 0;
-      }
-      if (queryParams.has("state")) {
-        result.state = queryParams.get("state") || void 0;
-      }
-      if (queryParams.has("error")) {
-        result.error = queryParams.get("error") || void 0;
-        result.errorDescription = queryParams.get("error_description") || void 0;
-      }
-      if (url.hash) {
-        const hashParams = new URLSearchParams(url.hash.slice(1));
-        if (hashParams.has("access_token")) {
-          result.accessToken = hashParams.get("access_token") || void 0;
-          result.tokenType = hashParams.get("token_type") || "Bearer";
-          const expiresIn = hashParams.get("expires_in");
-          if (expiresIn) {
-            result.expiresIn = parseInt(expiresIn, 10);
-          }
-          result.refreshToken = hashParams.get("refresh_token") || void 0;
-        }
-        if (hashParams.has("state") && !result.state) {
-          result.state = hashParams.get("state") || void 0;
-        }
-        if (hashParams.has("error") && !result.error) {
-          result.error = hashParams.get("error") || void 0;
-          result.errorDescription = hashParams.get("error_description") || void 0;
-        }
-      }
-    } catch (e) {
-      const parts = callbackUrl.split("#");
-      if (parts.length > 1) {
-        const hashParams = new URLSearchParams(parts[1]);
-        result.accessToken = hashParams.get("access_token") || void 0;
-        result.tokenType = hashParams.get("token_type") || void 0;
-        result.state = hashParams.get("state") || void 0;
-        result.error = hashParams.get("error") || void 0;
-        result.errorDescription = hashParams.get("error_description") || void 0;
-        const expiresIn = hashParams.get("expires_in");
-        if (expiresIn) {
-          result.expiresIn = parseInt(expiresIn, 10);
-        }
-      }
-      const queryParts = callbackUrl.split("?");
-      if (queryParts.length > 1) {
-        const queryStr = queryParts[1].split("#")[0];
-        const queryParams = new URLSearchParams(queryStr);
-        if (!result.code) result.code = queryParams.get("code") || void 0;
-        if (!result.state) result.state = queryParams.get("state") || void 0;
-        if (!result.error) result.error = queryParams.get("error") || void 0;
-        if (!result.errorDescription) result.errorDescription = queryParams.get("error_description") || void 0;
-      }
-    }
-    return result;
-  }
-  /**
-   * Handle a callback URL directly (convenience method combining parse + exchange/handleImplicit).
-   * 
-   * @param callbackUrl - Full callback URL received from OAuth provider
-   * @returns Exchange result with bit ID and tokens
-   */
-  async handleCallback(callbackUrl) {
-    const params = this.parseCallbackUrl(callbackUrl);
-    if (params.error) {
-      throw new Error(`OAuth error: ${params.error}${params.errorDescription ? ` - ${params.errorDescription}` : ""}`);
-    }
-    if (params.accessToken && params.state) {
-      return this.handleImplicitCallback(params);
-    }
-    if (!params.code || !params.state) {
-      throw new Error("Missing code or state parameter in OAuth callback");
-    }
-    return this.exchangeCode(params.state, params.code);
-  }
-  /**
-   * Handle implicit flow callback (access token directly in callback URL).
-   */
-  handleImplicitCallback(params) {
-    if (!params.state || !params.accessToken) {
-      throw new Error("Missing state or access_token for implicit flow");
-    }
-    const oauthState = this.pendingFlows.get(params.state);
-    if (!oauthState) {
-      throw new Error("Invalid or expired OAuth state. Please restart the authorization flow.");
-    }
-    this.pendingFlows.delete(params.state);
-    const tokens = {
-      accessToken: params.accessToken,
-      refreshToken: params.refreshToken,
-      tokenType: params.tokenType || "Bearer",
-      expiresAt: params.expiresIn ? Date.now() + params.expiresIn * 1e3 : void 0
-    };
-    oauthTokenStore.setToken(oauthState.bitId, tokens, oauthState.config);
-    this.logger.info("OAuth implicit flow completed successfully", { bitId: oauthState.bitId });
-    return { bitId: oauthState.bitId, tokens };
-  }
-  /**
-   * Exchange authorization code for tokens.
-   * 
-   * @param state - State parameter from callback
-   * @param code - Authorization code from callback
-   * @returns Token set or throws error
-   */
-  async exchangeCode(state, code) {
-    const oauthState = this.pendingFlows.get(state);
-    if (!oauthState) {
-      throw new Error("Invalid or expired OAuth state. Please restart the authorization flow.");
-    }
-    this.pendingFlows.delete(state);
-    const { config, codeVerifier, redirectUri, bitId } = oauthState;
-    const params = new URLSearchParams({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: redirectUri,
-      client_id: config.clientId
-    });
-    if (codeVerifier) {
-      params.set("code_verifier", codeVerifier);
-    }
-    if (config.clientSecret) {
-      params.set("client_secret", config.clientSecret);
-    }
-    this.logger.info("Exchanging authorization code", { bitId });
-    const response = await fetch(config.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "Accept": "application/json"
-      },
-      body: params.toString()
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      this.logger.error("Token exchange failed", { bitId, status: response.status, error: errorText });
-      throw new Error(`Token exchange failed: ${response.status} - ${errorText}`);
-    }
-    const data = await response.json();
-    const tokens = {
-      accessToken: data.access_token,
-      refreshToken: data.refresh_token,
-      tokenType: data.token_type || "Bearer",
-      expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
-      scope: data.scope
-    };
-    oauthTokenStore.setToken(bitId, tokens, config);
-    this.logger.info("OAuth flow completed successfully", { bitId });
-    return { bitId, tokens };
-  }
-  /**
-   * Get the pending OAuth state for a given state parameter.
-   * Useful for validation without consuming the state.
-   */
-  getPendingFlow(state) {
-    return this.pendingFlows.get(state);
-  }
-  /**
-   * Check if a flow is pending for a bit.
-   */
-  hasPendingFlow(bitId) {
-    for (const state of this.pendingFlows.values()) {
-      if (state.bitId === bitId) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get pending authorization URL for a bit (if flow already initiated).
-   */
-  getPendingAuthUrl(bitId) {
-    for (const [state, oauthState] of this.pendingFlows.entries()) {
-      if (oauthState.bitId === bitId) {
-        const { config, codeChallenge, redirectUri } = oauthState;
-        const params = new URLSearchParams({
-          response_type: "code",
-          client_id: config.clientId,
-          redirect_uri: redirectUri,
-          scope: config.scopes.join(" "),
-          state
-        });
-        if (codeChallenge) {
-          params.set("code_challenge", codeChallenge);
-          params.set("code_challenge_method", "S256");
-        }
-        if (config.extraAuthParams) {
-          for (const [key, value] of Object.entries(config.extraAuthParams)) {
-            params.set(key, value);
-          }
-        }
-        return `${config.authorizationUrl}?${params.toString()}`;
-      }
-    }
-    return null;
-  }
-  /**
-   * Cancel a pending OAuth flow.
-   */
-  cancelFlow(state) {
-    return this.pendingFlows.delete(state);
-  }
-  /**
-   * Cancel all pending flows for a bit.
-   */
-  cancelFlowsForBit(bitId) {
-    let cancelled = 0;
-    for (const [state, oauthState] of this.pendingFlows.entries()) {
-      if (oauthState.bitId === bitId) {
-        this.pendingFlows.delete(state);
-        cancelled++;
-      }
-    }
-    return cancelled;
-  }
-  /**
-   * Clean up expired flows (older than 10 minutes).
-   */
-  cleanupExpiredFlows() {
-    const now = Date.now();
-    const expirationTime = 10 * 60 * 1e3;
-    let cleaned = 0;
-    for (const [state, oauthState] of this.pendingFlows.entries()) {
-      if (now - oauthState.createdAt > expirationTime) {
-        this.pendingFlows.delete(state);
-        this.logger.debug("Expired OAuth flow cleaned up", { bitId: oauthState.bitId });
-        cleaned++;
-      }
-    }
-    return cleaned;
-  }
-  /**
-   * Get all pending flow states (for debugging/status).
-   */
-  getPendingFlowStates() {
-    return Array.from(this.pendingFlows.entries()).map(([state, oauthState]) => ({
-      bitId: oauthState.bitId,
-      state,
-      createdAt: oauthState.createdAt,
-      redirectUri: oauthState.redirectUri
-    }));
-  }
-};
-
-// packages/core/src/types.ts
-function isFrontendWorkflow(workflow) {
-  return "nodes" in workflow && "edges" in workflow && Array.isArray(workflow.nodes) && Array.isArray(workflow.edges);
-}
 export {
   AuthenticationType,
   BitAuth,
   BitCategory,
   HabitsExecutor,
   HttpMethod,
-  LoggerFactory,
-  OAuthFlowManager,
   PieceAuth,
   PieceCategory,
-  PollingStore,
   Property,
   StoreScope,
   TriggerHookType,
@@ -8382,29 +6914,20 @@ export {
   createBitTrigger,
   createCustomApiCallAction,
   createPiece,
-  createPollingStore,
   createTrigger,
   customRequire,
-  discoverOAuthRequirements,
   ensureModuleInstalled,
   executeActivepiecesModule,
   executeBitsModule,
   executeN8nModule,
   executeScriptModule,
-  extractBitsPieceFromModule,
-  getBundledModule,
   getLocalModulePath,
   getModuleFullPath,
   getNodesBasePath,
   getNodesPath,
   getSecurityConfig,
   httpClient,
-  isBundledModule,
   isFrontendWorkflow,
-  oauthTokenStore,
-  pieceFromModule2 as pieceFromModule,
-  printOAuthRequirements,
-  registerBundledModule,
   registerCortexModule,
   scanInputForSecurity,
   triggerHelper