@intuned/runtime 1.3.17 → 1.3.18-interface.6

package/dist/chunk-B3T6RXPC.mjs

@@ -0,0 +1,794 @@
+import {
+  getExecutionContext
+} from "./chunk-W4UX6G4X.mjs";
+import {
+  backendFunctionsTokenManager,
+  callBackendFunctionWithToken
+} from "./chunk-7YL2JUTE.mjs";
+import {
+  API_KEY_ENV_VAR_KEY,
+  PROJECT_ID_ENV_VAR_KEY,
+  WORKSPACE_ID_ENV_VAR_KEY
+} from "./chunk-FGV5T6SI.mjs";
+import {
+  captchaSolverSettingsSchema,
+  settingsSchema
+} from "./chunk-XOAZ2MGA.mjs";
+
+// src/runtime/extendTimeout.ts
+function extendTimeout() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("extendTimeout failed due to an internal error.");
+  }
+  const { timeoutInfo } = context;
+  if (!timeoutInfo) {
+    return;
+  }
+  if (timeoutInfo.extendTimeoutCallback !== void 0) {
+    void timeoutInfo.extendTimeoutCallback().catch(() => void 0);
+  }
+}
+
+// src/runtime/extendPayload.ts
+function extendPayload(payload) {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("extendPayload failed due to an internal error.");
+  }
+  const items = Array.isArray(payload) ? payload : [payload];
+  if (!context.extendedPayloads) {
+    context.extendedPayloads = [...items];
+    return;
+  }
+  context?.extendedPayloads.push(...items);
+  extendTimeout();
+}
+
+// src/runtime/attemptStore.ts
+var attemptStore = Object.freeze({
+  get: (key) => {
+    const context = getExecutionContext();
+    return context?.store ? context.store[key] : void 0;
+  },
+  set: (key, value) => {
+    const context = getExecutionContext();
+    if (!context) {
+      throw new Error("store.set failed due to an internal error.");
+    }
+    if (!context.store) {
+      context.store = {};
+    }
+    context.store[key] = value;
+  }
+});
+
+// src/runtime/persistentStore.ts
+import { z } from "zod";
+var forbiddenCharacters = /[:#]/g;
+var keySchema = z.string().min(1, "Key must be at least 1 character long").refine(
+  (key) => (key.match(forbiddenCharacters)?.length ?? 0) === 0,
+  'Key cannot contain the following characters: ":" or "#"'
+);
+var persistentStore = Object.freeze({
+  get: async (key) => {
+    const parsedKey = keySchema.parse(key);
+    const response = await callBackendFunctionWithToken(
+      `kv-store/${parsedKey}`,
+      {
+        method: "GET"
+      }
+    );
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+    return json.value;
+  },
+  set: async (key, value) => {
+    const keyResult = keySchema.parse(key);
+    const response = await callBackendFunctionWithToken(
+      `kv-store/${keyResult}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(value),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+  }
+});
+
+// src/runtime/getAuthSessionParameters.ts
+async function getAuthSessionParameters() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error(
+      "getAuthSessionParameters failed due to an internal error (context was not found)."
+    );
+  }
+  const { getAuthSessionParameters: getAuthSessionParameters2 } = context;
+  if (!getAuthSessionParameters2) {
+    throw new Error(
+      "getAuthSessionParameters failed due to an internal error (helper was not found on context)."
+    );
+  }
+  return await getAuthSessionParameters2();
+}
+
+// src/runtime/runInfo.ts
+function runInfo() {
+  const context = getExecutionContext();
+  if (!context) {
+    return {
+      runEnvironment: "IDE" /* IDE */
+      // runType: RunType.SYNC,
+    };
+  }
+  const { extendedPayloads: _extendedPayloads, ...rest } = context;
+  return rest;
+}
+
+// src/runtime/RunError.ts
+var RunError = class _RunError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.message = message;
+    this.name = "USER_GENERATED_ERROR";
+    this.options = options ?? {
+      retryable: false
+    };
+    Object.setPrototypeOf(this, _RunError.prototype);
+  }
+};
+new RunError("", {});
+
+// src/common/extension/intunedExtensionServer.ts
+import fastify from "fastify";
+
+// src/common/extension/types.ts
+import { z as z2 } from "zod";
+var captchaTypeSchema = z2.enum([
+  "aws",
+  "cloudflare",
+  "customcaptcha",
+  "funcaptcha",
+  "geetest",
+  "hcaptcha",
+  "lemincaptcha",
+  "recaptcha",
+  "textcaptcha"
+]);
+var captchaStatusSchema = z2.enum([
+  "attached",
+  "solving",
+  "solved",
+  "error",
+  "detached"
+]);
+var captchaErrorCodeSchema = z2.enum([
+  "HIT_LIMIT",
+  "MAX_RETRIES",
+  "UNEXPECTED_SERVER_RESPONSE",
+  "UNEXPECTED_ERROR"
+]);
+var captchaErrorSchema = z2.object({
+  code: captchaErrorCodeSchema,
+  error: z2.unknown().optional()
+});
+var captchaBaseSchema = z2.object({
+  id: z2.string().min(1),
+  tabId: z2.number().int().positive(),
+  type: captchaTypeSchema,
+  retryCount: z2.number().int().nonnegative().optional()
+});
+var captchaNonErrorSchema = captchaBaseSchema.extend({
+  status: captchaStatusSchema.exclude(["error"])
+});
+var captchaErrorStatusSchema = captchaBaseSchema.extend({
+  status: z2.literal("error"),
+  error: captchaErrorSchema
+});
+var captchaSchema = z2.discriminatedUnion("status", [
+  captchaBaseSchema.extend({
+    status: z2.literal("attached")
+  }),
+  captchaBaseSchema.extend({
+    status: z2.literal("solving")
+  }),
+  captchaBaseSchema.extend({
+    status: z2.literal("solved")
+  }),
+  captchaBaseSchema.extend({
+    status: z2.literal("detached")
+  }),
+  captchaErrorStatusSchema
+]);
+var CaptchaSolveError = class extends Error {
+  constructor(message, error) {
+    super(message);
+    this.error = error;
+    this.name = "CaptchaSolveError";
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/commands/common/utils/fileUtils.ts
+import * as path from "path";
+import * as fs from "fs-extra";
+import dotenv from "dotenv";
+dotenv.config();
+function getFullPathInProject(...paths) {
+  return path.resolve(process.cwd(), process.env.ROOT || "./", ...paths);
+}
+
+// src/commands/common/utils/settings.ts
+import { readFile } from "fs/promises";
+async function getSettings() {
+  const settingsFilePath = getFullPathInProject("Intuned.json");
+  const settings = await readFile(settingsFilePath, { encoding: "utf-8" });
+  if (settings) {
+    const parsed = settingsSchema.safeParse(JSON.parse(settings));
+    if (parsed.success) {
+      return parsed.data;
+    } else {
+      throw new Error(parsed.error.message);
+    }
+  }
+  return {
+    authSessions: { enabled: false },
+    stealthMode: { enabled: false }
+  };
+}
+
+// src/common/extension/extensionsHelpers.ts
+import path2 from "path";
+import { writeFile } from "fs/promises";
+import { getPort } from "portfinder";
+var INTUNED_WORKER = "intunedWorker.js";
+var INTUNED_EXTENSION_SETTINGS_FILE_NAME = "intunedSettings.json";
+var captchaSolverSettings = null;
+async function getIntunedCaptchaExtensionPort() {
+  if (process.env.INTUNED_CAPTCHA_EXTENSION_PORT) {
+    return parseInt(process.env.INTUNED_CAPTCHA_EXTENSION_PORT, 10);
+  }
+  return await getPort({});
+}
+async function resolveCaptchaSolverSettings(input) {
+  const parsed = captchaSolverSettingsSchema.parse(input || {});
+  if (!parsed.port) {
+    parsed.port = await getIntunedCaptchaExtensionPort();
+  }
+  return parsed;
+}
+function isIntunedExtensionLoaded() {
+  return !!getIntunedExtensionPath();
+}
+function buildExtensionsList() {
+  const extensionsList = [];
+  if (isIntunedExtensionLoaded()) {
+    const intunedExtensionPath = getIntunedExtensionPath();
+    extensionsList.push(intunedExtensionPath);
+  }
+  return extensionsList;
+}
+function getIntunedExtensionPath() {
+  return process.env.INTUNED_EXTENSION_PATH;
+}
+async function isIntunedExtensionEnabled() {
+  const path3 = getIntunedExtensionPath();
+  if (!path3) {
+    return false;
+  }
+  const captchaSolverSettings2 = await getIntunedCaptchaSolverSettings();
+  return captchaSolverSettings2.enabled;
+}
+async function getIntunedExtensionWorker(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    return null;
+  }
+  let attemptCount = 0;
+  while (attemptCount < 4) {
+    const intunedServiceWorker = context.serviceWorkers().find((serviceWorker) => serviceWorker.url().includes(INTUNED_WORKER));
+    if (intunedServiceWorker) {
+      return intunedServiceWorker;
+    }
+    try {
+      await context.waitForEvent("serviceworker", { timeout: 3e3 });
+    } catch (err) {
+      console.log(`Error accessing service workers (attempt ${attemptCount})`);
+    }
+    attemptCount++;
+  }
+  console.error("Failed to get intuned worker after 5 attmepts");
+  return null;
+}
+async function getIntunedExtensionSettings(captchaSolverSettings2) {
+  const [domain, workspaceId, projectId] = [
+    process.env.FUNCTIONS_DOMAIN,
+    process.env[WORKSPACE_ID_ENV_VAR_KEY],
+    process.env.INTUNED_INTEGRATION_ID ?? process.env[PROJECT_ID_ENV_VAR_KEY]
+  ];
+  if (!domain || !workspaceId || !projectId) {
+    const missingEnvVars = [
+      domain && "FUNCTIONS_DOMAIN",
+      workspaceId && WORKSPACE_ID_ENV_VAR_KEY,
+      projectId && `INTUNED_INTEGRATION_ID OR ${PROJECT_ID_ENV_VAR_KEY}`
+    ];
+    throw new Error(
+      `Missing required environment variables: ${missingEnvVars}`
+    );
+  }
+  const authentication = (() => {
+    if (process.env.INTUNED_API_KEY) {
+      return { type: "apiKey", apiKey: process.env.INTUNED_API_KEY };
+    }
+    if (process.env.INTUNED_BASIC_AUTH_USERNAME && process.env.INTUNED_BASIC_AUTH_PASSWORD) {
+      const credentials = `${process.env.INTUNED_BASIC_AUTH_USERNAME}:${process.env.INTUNED_BASIC_AUTH_PASSWORD}`;
+      const token = Buffer.from(credentials, "utf-8").toString("base64");
+      return { type: "basic", token };
+    }
+    return {
+      type: "bearer",
+      token: backendFunctionsTokenManager.token
+    };
+  })();
+  const baseUrl = process.env.INTUNED_API_BASE_URL ?? domain;
+  return {
+    ...captchaSolverSettings2,
+    workspaceId,
+    projectId,
+    baseUrl,
+    authentication
+  };
+}
+async function getIntunedCaptchaSolverSettings() {
+  if (captchaSolverSettings) {
+    return captchaSolverSettings;
+  }
+  const settings = await getSettings();
+  captchaSolverSettings = await resolveCaptchaSolverSettings(
+    settings.captchaSolver
+  );
+  return captchaSolverSettings;
+}
+async function setupIntunedExtension() {
+  if (!await isIntunedExtensionEnabled()) {
+    return;
+  }
+  const intunedExtensionPath = getIntunedExtensionPath();
+  const intunedExtensionSettingsPath = path2.join(
+    intunedExtensionPath,
+    INTUNED_EXTENSION_SETTINGS_FILE_NAME
+  );
+  const captchaSolverSettings2 = await getIntunedCaptchaSolverSettings();
+  await setupIntunedExtensionServer(captchaSolverSettings2);
+  const captchaSolverSettingsWithRunContext = await getIntunedExtensionSettings(
+    captchaSolverSettings2
+  );
+  await writeFile(
+    intunedExtensionSettingsPath,
+    JSON.stringify(captchaSolverSettingsWithRunContext)
+  );
+}
+
+// src/common/extension/intunedExtensionServer.ts
+var TabCaptchaState = class {
+  constructor(tabId) {
+    this.tabId = tabId;
+    this.captchasById = /* @__PURE__ */ new Map();
+    this.subscribers = new Array();
+  }
+  subscribe(handler) {
+    this.subscribers.push(handler);
+  }
+  unsubscribe(handler, status) {
+    const index = this.subscribers.findIndex(
+      (subscriber) => subscriber.handler === handler && (subscriber.status === status || !status)
+    );
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+    }
+  }
+  getCaptchas() {
+    return [...this.captchasById.values()];
+  }
+  async upsertCaptcha(captcha) {
+    this.captchasById.set(captcha.id, captcha);
+    for (const subscriber of this.subscribers) {
+      if (!subscriber.status || subscriber.status === captcha.status) {
+        await subscriber.handler(captcha);
+      }
+    }
+  }
+};
+var ExtensionServer = class {
+  constructor() {
+    this.app = null;
+    this.tabs = /* @__PURE__ */ new Map();
+  }
+  getOrCreateTab(tabId) {
+    const existing = this.tabs.get(tabId);
+    if (existing) return existing;
+    const created = new TabCaptchaState(tabId);
+    this.tabs.set(tabId, created);
+    return created;
+  }
+  async handleUpsertCaptcha(captcha) {
+    const tab = this.getOrCreateTab(captcha.tabId);
+    await tab.upsertCaptcha(captcha);
+  }
+  async start({
+    port,
+    host = "0.0.0.0"
+  }) {
+    if (this.app) {
+      return;
+    }
+    this.app = fastify({
+      logger: false,
+      bodyLimit: 1e6
+    });
+    this.app.post("/state", async (request, reply) => {
+      try {
+        const result = captchaSchema.safeParse(request.body);
+        if (!result.success) {
+          return reply.code(400).send({
+            error: "Invalid captcha payload",
+            details: result.error.flatten().fieldErrors
+          });
+        }
+        await this.handleUpsertCaptcha(result.data);
+        return reply.code(200).send({});
+      } catch (error) {
+        console.error("Error processing captcha state update:", error);
+        return reply.code(500).send({
+          error: "Internal server error",
+          message: error?.message ?? String(error)
+        });
+      }
+    });
+    this.app.setNotFoundHandler((_request, reply) => {
+      return reply.code(404).send({ error: "Not found" });
+    });
+    await this.app.listen({
+      port,
+      host
+    });
+  }
+  async stop() {
+    if (!this.app) return;
+    const toClose = this.app;
+    this.app = null;
+    await toClose.close();
+  }
+  async getCaptchas(page, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return [];
+    const captchas = tab.getCaptchas();
+    if (!status) return captchas;
+    return captchas.filter((c) => c.status === status && c.tabId === tabId);
+  }
+  async subscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.getOrCreateTab(tabId);
+    tab.subscribe({ handler, status });
+  }
+  async unsubscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.unsubscribe(handler, status);
+  }
+  removeTab(tabId) {
+    this.tabs.delete(tabId);
+  }
+  async getTabId(page) {
+    return await getTabId(page);
+  }
+};
+var extensionServerSingleton = null;
+function getIntunedExtensionServer() {
+  if (!extensionServerSingleton) {
+    throw new Error("Intuned Extension Server is not initialized.");
+  }
+  return extensionServerSingleton;
+}
+async function setupIntunedExtensionServer(captchaSolverSettings2) {
+  if (!captchaSolverSettings2) {
+    captchaSolverSettings2 = await resolveCaptchaSolverSettings();
+  }
+  if (!extensionServerSingleton) {
+    extensionServerSingleton = new ExtensionServer();
+  }
+  await extensionServerSingleton.start({
+    port: captchaSolverSettings2.port ?? 9e3
+  });
+}
+async function cleanIntunedExtensionServer() {
+  if (extensionServerSingleton) {
+    await extensionServerSingleton.stop();
+    extensionServerSingleton = null;
+  }
+}
+var TAB_ID_CACHE_KEY = "__INTUNED_CACHED_TAB_ID__";
+async function getTabId(page) {
+  const cached = page[TAB_ID_CACHE_KEY];
+  if (cached !== void 0 && typeof cached === "number") {
+    return cached;
+  }
+  let tabId;
+  try {
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__", { timeout: 100 });
+  } catch {
+    await page.waitForFunction("window.__INTUNED_TAB_ID__ !== undefined", {
+      timeout: 15e3
+    });
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__");
+  }
+  const numericTabId = Number(tabId);
+  page[TAB_ID_CACHE_KEY] = numericTabId;
+  return numericTabId;
+}
+
+// src/runtime/captcha.ts
+async function withWaitForCaptchaSolve(callback, options) {
+  const {
+    page,
+    timeoutInMs = 1e4,
+    settleDurationMs = 5e3,
+    waitForNetworkSettled = true
+  } = options;
+  console.error(
+    `Starting captcha solve wait (timeout=${timeoutInMs}ms, settleDuration=${settleDurationMs}ms, waitForNetworkSettled=${waitForNetworkSettled})`
+  );
+  const extensionServer = getIntunedExtensionServer();
+  let settledResolve = null;
+  let settledPromise = new Promise((resolve2) => {
+    settledResolve = resolve2;
+  });
+  let isTimeout = false;
+  let captchasAppeared = false;
+  let error = void 0;
+  let actionDone = false;
+  const getPendingCaptchas = async () => await extensionServer.getCaptchas(page, "solving");
+  const hasNoPendingCaptchas = async () => !captchasAppeared || (await getPendingCaptchas()).length === 0;
+  const maybeSettle = async () => {
+    if (await hasNoPendingCaptchas()) {
+      settledResolve?.();
+    }
+  };
+  const onCaptchaUpdate = async (_captcha) => {
+    const solvingCaptchas = await extensionServer.getCaptchas(page, "solving");
+    const errorCaptchas = await extensionServer.getCaptchas(page, "error");
+    console.error(
+      `Captcha update received: solving=${solvingCaptchas.length}, errors=${errorCaptchas.length}`
+    );
+    if (solvingCaptchas.length > 0) {
+      captchasAppeared = true;
+      console.error(
+        `Captchas detected: ${solvingCaptchas.map((c) => c.id).join(", ")}`
+      );
+    }
+    if (errorCaptchas.length > 0) {
+      error = errorCaptchas[0].error;
+      console.error(`Captcha error detected: ${error?.code}`);
+      await maybeSettle();
+      return;
+    }
+    if (solvingCaptchas.length === 0) {
+      console.error("No pending captchas, settling");
+      await maybeSettle();
+    }
+  };
+  const result = await callback(page);
+  actionDone = true;
+  if (waitForNetworkSettled) {
+    try {
+      await page.waitForLoadState("networkidle");
+    } catch (err) {
+      console.error(`Failed to wait for networkidle. Error: ${err}`);
+    }
+  }
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => {
+      isTimeout = true;
+      console.error("Captcha solve timeout reached");
+      settledResolve?.();
+      resolve2();
+    }, timeoutInMs);
+  });
+  await extensionServer.subscribe(page, onCaptchaUpdate);
+  try {
+    const initialPending = await getPendingCaptchas();
+    console.error(`Found ${initialPending.length} ongoing captchas`);
+    if (initialPending.length > 0) {
+      captchasAppeared = true;
+    }
+    await maybeSettle();
+    let shouldContinue = true;
+    while (shouldContinue) {
+      await Promise.race([settledPromise, timeoutPromise]);
+      console.error(
+        `Settled event received, waiting ${settleDurationMs}ms before checking`
+      );
+      await new Promise((r) => setTimeout(r, settleDurationMs));
+      if (error) {
+        console.error(`Raising captcha error: ${error.code}`);
+        throw new CaptchaSolveError(
+          `CAPTCHA Solve Error: ${error.code}`,
+          error
+        );
+      }
+      const noPendingCaptchas = await hasNoPendingCaptchas();
+      const pending = await getPendingCaptchas();
+      console.error(
+        `Check point: actionDone=${actionDone}, noPendingCaptchas=${noPendingCaptchas}, isTimeout=${isTimeout}, pendingCount=${pending.length}`
+      );
+      if (actionDone && noPendingCaptchas || isTimeout) {
+        if (isTimeout && !noPendingCaptchas) {
+          console.error(`Timeout with ${pending.length} pending captchas`);
+          throw new TimeoutError(
+            "CAPTCHA Solve timed out with pending captchas."
+          );
+        }
+        console.error("Captcha solve completed successfully");
+        shouldContinue = false;
+      } else {
+        console.error(
+          `Still have ${pending.length} pending captchas, waiting for more updates`
+        );
+        settledPromise = new Promise((resolve2) => {
+          settledResolve = resolve2;
+        });
+      }
+    }
+    return result;
+  } finally {
+    await extensionServer.unsubscribe(page, onCaptchaUpdate);
+  }
+}
+async function waitForCaptchaSolve(page, {
+  timeoutInMs = 1e4,
+  settleDurationMs = 5e3
+} = {}) {
+  await withWaitForCaptchaSolve(async () => void 0, {
+    page,
+    timeoutInMs,
+    settleDurationMs,
+    waitForNetworkSettled: false
+  });
+}
+async function removeCaptchaEventListener(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  await extensionServer.unsubscribe(page, f, status);
+}
+async function onCaptchaEvent(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  await extensionServer.subscribe(page, f, status);
+}
+async function onceCaptchaEvent(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  const oneTimeHandler = async (captcha) => {
+    await extensionServer.unsubscribe(page, oneTimeHandler, status);
+    await f(captcha);
+  };
+  await extensionServer.subscribe(page, oneTimeHandler, status);
+}
+async function setAutoSolve(context, enabled) {
+  const worker = await getIntunedExtensionWorker(context);
+  if (!worker) {
+    if (!enabled) {
+      return;
+    }
+    throw new Error("Intuned service worker not found");
+  }
+  await worker.evaluate(
+    `
+    (enabled) => new Promise((resolve, reject) => {
+      const updateSettings = () => {
+        if (chrome?.storage?.local) {
+          chrome.storage.local.get('settings', (result) => {
+            if (chrome.runtime.lastError) {
+              reject(new Error(chrome.runtime.lastError.message));
+              return;
+            }
+            const settings = result.settings || {};
+            if (!settings.settings) {
+              settings.settings = {};
+            }
+            settings.settings.autoSolve = enabled;
+            chrome.storage.local.set({ settings }, () => {
+              if (chrome.runtime.lastError) {
+                reject(new Error(chrome.runtime.lastError.message));
+              } else {
+                resolve(true);
+              }
+            });
+          });
+        } else {
+          setTimeout(updateSettings, 50);
+        }
+      };
+      updateSettings();
+    })
+  `,
+    enabled
+  );
+}
+async function pauseCaptchaSolver(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    throw new Error(
+      "Intuned extension is not enabled. Cannot pause captcha solver."
+    );
+  }
+  await setAutoSolve(context, false);
+}
+async function resumeCaptchaSolver(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    throw new Error(
+      "Intuned extension is not enabled. Cannot resume captcha solver."
+    );
+  }
+  await setAutoSolve(context, true);
+}
+
+// src/runtime/getAiGatewayConfig.ts
+function getAiGatewayConfig() {
+  const baseUrl = `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/intuned-ai-gateway`;
+  const apiKey = backendFunctionsTokenManager.token ?? process.env[API_KEY_ENV_VAR_KEY] ?? "";
+  return { baseUrl, apiKey };
+}
+
+// src/runtime/downloadDirectory.ts
+import { ensureDirSync } from "fs-extra";
+function getDownloadDirectoryPath() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("ExecutionContext not found");
+  }
+  const path3 = `/tmp/downloads/${context.runId}`;
+  ensureDirSync(path3, {
+    mode: 1533
+  });
+  return path3;
+}
+
+export {
+  extendTimeout,
+  extendPayload,
+  attemptStore,
+  persistentStore,
+  getAuthSessionParameters,
+  runInfo,
+  RunError,
+  getFullPathInProject,
+  isIntunedExtensionLoaded,
+  buildExtensionsList,
+  isIntunedExtensionEnabled,
+  getIntunedExtensionWorker,
+  setupIntunedExtension,
+  setupIntunedExtensionServer,
+  cleanIntunedExtensionServer,
+  withWaitForCaptchaSolve,
+  waitForCaptchaSolve,
+  removeCaptchaEventListener,
+  onCaptchaEvent,
+  onceCaptchaEvent,
+  pauseCaptchaSolver,
+  resumeCaptchaSolver,
+  getAiGatewayConfig,
+  getDownloadDirectoryPath
+};
+//# sourceMappingURL=chunk-B3T6RXPC.mjs.map