@intuned/browser-dev 0.1.4-dev.0

package/dist/helpers/waitForDomSettled.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.waitForDomSettled = void 0;
+var _locatorHelpers = require("../common/locatorHelpers");
+var _Logger = require("../common/Logger");
+const waitForDomSettled = async options => {
+  const {
+    source,
+    settleDurationMs = 500,
+    timeoutInMs = 30000
+  } = options;
+  const settleDurationMsFloored = Math.floor(settleDurationMs);
+  const timeoutMs = Math.floor(timeoutInMs);
+  let pageObj;
+  let elementHandle;
+  if (!(0, _locatorHelpers.isPage)(source)) {
+    pageObj = source.page();
+    const handle = await source.elementHandle();
+    if (!handle) {
+      _Logger.logger.warn("Could not get element handle from locator");
+      return false;
+    }
+    elementHandle = handle;
+  } else if ((0, _locatorHelpers.isPage)(source)) {
+    pageObj = source;
+    elementHandle = await pageObj.evaluateHandle("document.documentElement");
+  } else {
+    throw new Error("Invalid state");
+  }
+  try {
+    const result = await pageObj.evaluate(({
+      target,
+      settleDurationMsFloored,
+      timeoutMs
+    }) => {
+      return new Promise((resolve, reject) => {
+        if (!target) {
+          reject(new Error("Target element not found"));
+          return;
+        }
+        let mutationTimer;
+        let settled = false;
+        const observer = new MutationObserver(() => {
+          if (settled) return;
+          clearTimeout(mutationTimer);
+          mutationTimer = window.setTimeout(() => {
+            settled = true;
+            observer.disconnect();
+            clearTimeout(timeoutTimer);
+            resolve(true);
+          }, settleDurationMsFloored);
+        });
+        const timeoutTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(mutationTimer);
+          reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
+        }, timeoutMs);
+        observer.observe(target, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+          characterData: true
+        });
+        mutationTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(timeoutTimer);
+          resolve(true);
+        }, settleDurationMsFloored);
+      });
+    }, {
+      target: elementHandle,
+      settleDurationMsFloored,
+      timeoutMs
+    });
+    return result;
+  } catch (error) {
+    _Logger.logger.warn(`DOM settlement detection failed: ${error}`);
+    return false;
+  } finally {
+    if ((0, _locatorHelpers.isPage)(source) && elementHandle) {
+      await elementHandle.dispose();
+    }
+  }
+};
+exports.waitForDomSettled = waitForDomSettled;

package/dist/helpers/withNetworkSettledWait.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withNetworkSettledWait = void 0;
+var _Logger = require("../common/Logger");
+const withNetworkSettledWait = async (callback, options) => {
+  const {
+    page,
+    timeoutInMs = 30000,
+    maxInflightRequests = 0
+  } = options || {};
+  _Logger.logger.debug(`Page object: ${page}`);
+  let networkSettledResolve = null;
+  let networkSettledPromise = new Promise(resolve => {
+    networkSettledResolve = resolve;
+  });
+  let isTimeout = false;
+  let requestCounter = 0;
+  let actionDone = false;
+  const pendingRequests = new Set();
+  const maybeSettle = async () => {
+    if (actionDone && requestCounter <= maxInflightRequests) {
+      var _networkSettledResolv;
+      (_networkSettledResolv = networkSettledResolve) === null || _networkSettledResolv === void 0 || _networkSettledResolv();
+    }
+  };
+  const onRequest = request => {
+    requestCounter++;
+    pendingRequests.add(request);
+  };
+  const onRequestDone = async request => {
+    await new Promise(resolve => setTimeout(resolve, 0));
+    if (pendingRequests.has(request)) {
+      requestCounter--;
+      pendingRequests.delete(request);
+      await maybeSettle();
+    }
+  };
+  const handleRequestFinished = async req => {
+    await onRequestDone(req);
+  };
+  const handleRequestFailed = async req => {
+    await onRequestDone(req);
+  };
+  page === null || page === void 0 || page.on("request", onRequest);
+  page === null || page === void 0 || page.on("requestfinished", handleRequestFinished);
+  page === null || page === void 0 || page.on("requestfailed", handleRequestFailed);
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      var _networkSettledResolv2;
+      _Logger.logger.info("waiting for network to settle timed out");
+      isTimeout = true;
+      (_networkSettledResolv2 = networkSettledResolve) === null || _networkSettledResolv2 === void 0 || _networkSettledResolv2();
+      resolve();
+    }, timeoutInMs);
+  });
+  try {
+    const result = await callback(page);
+    actionDone = true;
+    await new Promise(resolve => setTimeout(resolve, 500));
+    await maybeSettle();
+    _Logger.logger.info("-- Start waiting for network to settle... --");
+    let shouldContinue = true;
+    while (shouldContinue) {
+      _Logger.logger.info(`waiting for network to settle, ${requestCounter} requests pending`);
+      await Promise.race([networkSettledPromise, timeoutPromise]);
+      await new Promise(resolve => setTimeout(resolve, 500));
+      if (actionDone && requestCounter <= maxInflightRequests || isTimeout) {
+        if (isTimeout) {
+          _Logger.logger.info("Exiting due to timeout, network did not settle");
+        } else {
+          _Logger.logger.info("network settled, no pending requests");
+        }
+        shouldContinue = false;
+      } else {
+        networkSettledPromise = new Promise(resolve => {
+          networkSettledResolve = resolve;
+        });
+      }
+    }
+    _Logger.logger.info("-- Finished waiting for network to settle --");
+    return result;
+  } finally {
+    page === null || page === void 0 || page.off("request", onRequest);
+    page === null || page === void 0 || page.off("requestfinished", handleRequestFinished);
+    page === null || page === void 0 || page.off("requestfailed", handleRequestFailed);
+  }
+};
+exports.withNetworkSettledWait = withNetworkSettledWait;

package/dist/index.d.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _export = require("./helpers/export");
+Object.keys(_export).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _export[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _export[key];
+    }
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./helpers/export";
+
+export type {
+  Attachment,
+  Trigger,
+  S3Configs,
+  FileType,
+  AttachmentType,
+  SanitizeHtmlOptions,
+} from "./helpers/export";

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _helpers = require("./helpers");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});

package/dist/intunedServices/ApiGateway/aiApiGateway.js

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.APIGateway = void 0;
+var _getModelProvider = require("../../common/getModelProvider");
+var _Anthropic = require("./providers/Anthropic");
+var _OpenAI = require("./providers/OpenAI");
+var _Gemini = require("./providers/Gemini");
+var _dotenv = require("dotenv");
+var _loadRuntime = require("../../common/loadRuntime");
+(0, _dotenv.config)();
+class APIGateway {
+  useGateway = false;
+  isInitialized = false;
+  constructor(options) {
+    this.model = options.model;
+    this.apiKey = options.apiKey;
+  }
+  async ensureInitialized() {
+    if (this.isInitialized) {
+      return;
+    }
+    const provider = this.detectProvider(this.model);
+    if (this.apiKey) {
+      this.useGateway = false;
+      this.isInitialized = true;
+      return;
+    }
+    const envApiKey = this.getApiKeyFromEnv(provider);
+    if (envApiKey) {
+      this.apiKey = envApiKey;
+      this.useGateway = false;
+      this.isInitialized = true;
+      return;
+    }
+    await this.validateIntunedContext();
+    this.config = this.getDefaultConfig();
+    this.validateGatewayConfig(this.config);
+    this.useGateway = true;
+    this.isInitialized = true;
+  }
+  getApiKeyFromEnv(provider) {
+    if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("anthropic")) {
+      return process.env.ANTHROPIC_API_KEY;
+    } else if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("openai")) {
+      return process.env.OPENAI_API_KEY;
+    } else if (provider !== null && provider !== void 0 && provider.toLowerCase().includes("google_vertexai")) {
+      return process.env.GOOGLE_API_KEY;
+    }
+    return undefined;
+  }
+  async validateIntunedContext() {
+    try {
+      const getExecutionContext = await (0, _loadRuntime.loadRuntime)();
+      const context = getExecutionContext();
+      if (!context) {
+        throw new Error("No API key provided and not running in Intuned context. " + "Please provide an API key or ensure @intuned/runtime is installed and you're running within an Intuned workflow.");
+      }
+    } catch (error) {
+      throw new Error("No API key provided and not running in Intuned context. " + "Please provide an API key or ensure @intuned/runtime is installed and you're running within an Intuned workflow. " + `Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  validateGatewayConfig(config) {
+    const missingVars = [];
+    if (!config.functionsDomain) {
+      missingVars.push("FUNCTIONS_DOMAIN");
+    }
+    if (!config.workspaceId) {
+      missingVars.push("INTUNED_WORKSPACE_ID");
+    }
+    if (!config.integrationId) {
+      missingVars.push("INTUNED_PROJECT_ID");
+    }
+    if (missingVars.length > 0) {
+      throw new Error(`Gateway configuration is incomplete. Missing environment variables: ${missingVars.join(", ")}. ` + "These are required when running in Intuned context without an API key.");
+    }
+  }
+  getDefaultConfig() {
+    return {
+      functionsDomain: process.env.FUNCTIONS_DOMAIN,
+      workspaceId: process.env.INTUNED_WORKSPACE_ID,
+      integrationId: process.env.INTUNED_PROJECT_ID || process.env.INTUNED_INTEGRATION_ID || undefined
+    };
+  }
+  detectProvider(model) {
+    const modelLower = model.toLowerCase();
+    return (0, _getModelProvider.getModelProvider)(modelLower);
+  }
+  buildGatewayUrl(provider) {
+    var _this$config$function;
+    if (!this.config) {
+      throw new Error("Gateway configuration not initialized");
+    }
+    const baseDomain = (_this$config$function = this.config.functionsDomain) === null || _this$config$function === void 0 ? void 0 : _this$config$function.replace(/\/$/, "");
+    return `${baseDomain}/api/${this.config.workspaceId}/functions/${this.config.integrationId}/${provider === "anthropic" ? "anthropic/v1" : provider === "google_vertexai" ? "google_vertexai/v1beta" : provider}`;
+  }
+  getModelConfig(extraHeaders) {
+    const provider = this.detectProvider(this.model);
+    if (!this.useGateway && this.apiKey) {
+      return {
+        model: this.model,
+        apiKey: this.apiKey,
+        extraHeaders,
+        baseUrl: undefined
+      };
+    }
+    const baseUrl = this.buildGatewayUrl(provider);
+    return {
+      model: this.model,
+      apiKey: "--THIS_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      extraHeaders,
+      baseUrl
+    };
+  }
+  async createProviderInstance(extraHeaders) {
+    await this.ensureInitialized();
+    const config = this.getModelConfig(extraHeaders);
+    const provider = this.detectProvider(this.model);
+    const input = {
+      apiKey: config.apiKey,
+      headers: config.extraHeaders,
+      model: config.model,
+      baseUrl: config.baseUrl
+    };
+    const providerFactories = {
+      anthropic: () => (0, _Anthropic.createAnthropicInstance)(input),
+      openai: () => (0, _OpenAI.createOpenAIInstance)(input),
+      google_vertexai: () => (0, _Gemini.createGoogleInstance)(input)
+    };
+    const factory = providerFactories[provider];
+    if (!factory) {
+      throw new Error(`Unsupported provider: ${provider}`);
+    }
+    return factory();
+  }
+  async getModel(extraHeaders) {
+    const providerInstance = await this.createProviderInstance(extraHeaders);
+    return providerInstance.chat(this.model);
+  }
+}
+exports.APIGateway = APIGateway;

package/dist/intunedServices/ApiGateway/factory.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GatewayFactory = void 0;
+var _aiApiGateway = require("./aiApiGateway");
+class GatewayFactory {
+  static createAIGateway(options) {
+    return new _aiApiGateway.APIGateway({
+      apiKey: options.apiKey,
+      model: options.model
+    });
+  }
+}
+exports.GatewayFactory = GatewayFactory;

package/dist/intunedServices/ApiGateway/providers/Anthropic.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAnthropicInstance = void 0;
+var _anthropic = require("@ai-sdk/anthropic");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createAnthropicInstance = input => {
+  const {
+    apiKey,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _anthropic.createAnthropic)({
+      apiKey
+    });
+  } else {
+    return (0, _anthropic.createAnthropic)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createAnthropicInstance = createAnthropicInstance;

package/dist/intunedServices/ApiGateway/providers/Gemini.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGoogleInstance = void 0;
+var _google = require("@ai-sdk/google");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createGoogleInstance = input => {
+  const {
+    apiKey,
+    headers,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _google.createGoogleGenerativeAI)({
+      apiKey,
+      headers
+    });
+  } else {
+    return (0, _google.createGoogleGenerativeAI)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      headers,
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createGoogleInstance = createGoogleInstance;

package/dist/intunedServices/ApiGateway/providers/OpenAI.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOpenAIInstance = void 0;
+var _openai = require("@ai-sdk/openai");
+var _jwtTokenManager = require("../../../common/jwtTokenManager");
+const createOpenAIInstance = input => {
+  const {
+    apiKey,
+    headers,
+    baseUrl
+  } = input;
+  if (apiKey && baseUrl === undefined) {
+    return (0, _openai.createOpenAI)({
+      apiKey,
+      headers
+    });
+  } else {
+    return (0, _openai.createOpenAI)({
+      apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+      headers,
+      baseURL: baseUrl,
+      fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+    });
+  }
+};
+exports.createOpenAIInstance = createOpenAIInstance;