@intuned/runtime-dev 1.3.18-interface.10 → 1.3.18-interface.12

package/dist/commands/get-headless-user-agent.js

@@ -0,0 +1,354 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/commands/get-headless-user-agent.ts
+var import_commander = require("commander");
+var import_dotenv2 = __toESM(require("dotenv"));
+
+// src/common/launchBrowser.ts
+var playwright = __toESM(require("playwright"));
+var import_fs_extra = require("fs-extra");
+var fs2 = __toESM(require("fs-extra"));
+var import_wait_on = __toESM(require("wait-on"));
+var import_child_process = require("child_process");
+
+// src/commands/common/utils/fileUtils.ts
+var fs = __toESM(require("fs-extra"));
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+
+// src/common/settingsSchema.ts
+var z = __toESM(require("zod"));
+var baseCaptchaSchema = z.object({
+  enabled: z.boolean()
+});
+var customCaptchaSchema = baseCaptchaSchema.extend({
+  imageLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+var textCaptchaSchema = baseCaptchaSchema.extend({
+  labelLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+var captchaSolverSolveSettingsSchema = z.object({
+  autoSolve: z.boolean().default(true),
+  solveDelay: z.number().min(0).default(2e3),
+  maxRetries: z.number().min(0).default(3),
+  timeout: z.number().min(0).default(3e4)
+});
+var captchaSolverSettingsSchema = z.object({
+  enabled: z.boolean().default(false),
+  port: z.number().int().min(1).max(65535).optional(),
+  cloudflare: baseCaptchaSchema.optional(),
+  googleRecaptchaV2: baseCaptchaSchema.optional(),
+  googleRecaptchaV3: baseCaptchaSchema.optional(),
+  awscaptcha: baseCaptchaSchema.optional(),
+  hcaptcha: baseCaptchaSchema.optional(),
+  funcaptcha: baseCaptchaSchema.optional(),
+  geetest: baseCaptchaSchema.optional(),
+  lemin: baseCaptchaSchema.optional(),
+  customCaptcha: customCaptchaSchema.optional(),
+  text: textCaptchaSchema.optional(),
+  settings: captchaSolverSolveSettingsSchema.default(
+    captchaSolverSolveSettingsSchema.parse({})
+  )
+}).default({});
+var authSessionsSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+var stealthModeSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+var settingsSchema = z.object({
+  authSessions: authSessionsSchema,
+  stealthMode: stealthModeSchema,
+  captchaSolver: captchaSolverSettingsSchema.optional()
+});
+
+// src/common/constants.ts
+var WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+var PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+var API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+var AUTH_TOKEN_ENV_VAR_KEY = "INTUNED_AUTH_TOKEN";
+var API_KEY_HEADER_NAME = "x-api-key";
+var CLI_ENV_VAR_KEY = "INTUNED_CLI";
+
+// src/common/jwtTokenManager.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+var jwt = __toESM(require("jsonwebtoken"));
+var import_neverthrow = require("neverthrow");
+var JwtTokenManager = class {
+  constructor(refreshTokenPath) {
+    this.refreshTokenPath = refreshTokenPath;
+    this._token = void 0;
+  }
+  get token() {
+    return this._token;
+  }
+  // When the token is set, the schedule for renewal is issued automatically
+  // This is currently being set it two places:
+  // 1. Whenever the runner starts, initializes it from the environment variable (set whenever the api is run from the authoring IDE)
+  // 2. Whenever a published api is called to run (/api/run/*), it is set to the token received in the run request.
+  set token(newToken) {
+    if (this._token != newToken) {
+      this._token = newToken;
+      void this.scheduleTokenRefresh();
+    }
+  }
+  get timeToRefresh() {
+    if (!this._token) return;
+    const payload = jwt.decode(this._token);
+    if (!payload || typeof payload == "string") return;
+    const expiry = payload.expiry;
+    if (!expiry || typeof expiry !== "number") return;
+    const timeWindow = 60 * 1e3;
+    const timeToRefresh = expiry - Date.now() - timeWindow;
+    return Math.max(timeToRefresh, timeWindow);
+  }
+  async scheduleTokenRefresh() {
+    if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
+    const timeToRefresh = this.timeToRefresh;
+    if (timeToRefresh === void 0) return;
+    if (this.tokenRefreshTimeout) clearTimeout(this.tokenRefreshTimeout);
+    this.tokenRefreshTimeout = setTimeout(async () => {
+      const result = await this.refreshToken();
+      if (result && result.isErr()) {
+        console.error(`[Internal Error] ${result.error}`);
+        return;
+      }
+      await this.scheduleTokenRefresh();
+    }, timeToRefresh);
+  }
+  async refreshToken() {
+    if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
+    const res = await this.fetchWithToken(
+      `${this.backendFunctionsBaseUrl}/${this.refreshTokenPath}`,
+      {
+        method: "GET"
+      }
+    );
+    if (res.status === 401) {
+      return (0, import_neverthrow.err)("Unauthorized");
+    }
+    const jsonResult = await import_neverthrow.ResultAsync.fromPromise(
+      res.json(),
+      () => "not json"
+    );
+    if (jsonResult.isErr()) return;
+    const newToken = jsonResult.value.token;
+    if (newToken) this._token = newToken;
+  }
+  async fetchWithToken(...[input, init]) {
+    const headers = new Headers(init?.headers);
+    const apiKey = process.env[API_KEY_ENV_VAR_KEY];
+    if (apiKey) {
+      headers.set(API_KEY_HEADER_NAME, apiKey);
+    }
+    const token = process.env[AUTH_TOKEN_ENV_VAR_KEY];
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    if (this.token !== void 0) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    const result = await (0, import_cross_fetch.default)(input, {
+      ...init,
+      headers
+    });
+    if (result.status === 401 && process.env[CLI_ENV_VAR_KEY] === "true") {
+      console.warn(
+        "Unauthorized backend function call - make sure to provision your project to Intuned to set up the correct API credentials.\nRun 'intuned provision' or see https://docs.intunedhq.com/docs/05-references/cli#provision-project for more information."
+      );
+    }
+    return result;
+  }
+  get backendFunctionsBaseUrl() {
+    try {
+      if (!process.env.FUNCTIONS_DOMAIN) {
+        throw new Error(
+          `Cannot call backend function - FUNCTIONS_DOMAIN not set`
+        );
+      }
+      const domain = process.env.FUNCTIONS_DOMAIN;
+      if (!process.env[WORKSPACE_ID_ENV_VAR_KEY]) {
+        throw new Error(
+          `Cannot call backend function - ${WORKSPACE_ID_ENV_VAR_KEY} not set`
+        );
+      }
+      const workspaceId = process.env[WORKSPACE_ID_ENV_VAR_KEY];
+      if (!process.env[PROJECT_ID_ENV_VAR_KEY] && !process.env.INTUNED_INTEGRATION_ID) {
+        throw new Error(
+          `Cannot call backend function - ${PROJECT_ID_ENV_VAR_KEY} or INTUNED_INTEGRATION_ID not set`
+        );
+      }
+      const projectId = process.env.INTUNED_INTEGRATION_ID ?? process.env[PROJECT_ID_ENV_VAR_KEY];
+      return `${domain}/api/${workspaceId}/functions/${projectId}`;
+    } catch (e) {
+      if (process.env[CLI_ENV_VAR_KEY] === "true") {
+        throw new Error(
+          `API credentials not set - make sure to provision your project to Intuned to set up the correct API credentials.
+Run 'intuned provision' or see https://docs.intunedhq.com/docs/05-references/cli#provision-project for more information.
+Original error: ${e.message}`
+        );
+      }
+    }
+  }
+};
+var backendFunctionsTokenManager = new JwtTokenManager(
+  `refreshBackendFunctionsToken`
+);
+backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
+
+// src/common/extension/intunedExtensionServer.ts
+var import_fastify = __toESM(require("fastify"));
+
+// src/common/extension/types.ts
+var import_zod = require("zod");
+var captchaTypeSchema = import_zod.z.enum([
+  "aws",
+  "cloudflare",
+  "customcaptcha",
+  "funcaptcha",
+  "geetest",
+  "hcaptcha",
+  "lemincaptcha",
+  "recaptcha",
+  "textcaptcha"
+]);
+var captchaStatusSchema = import_zod.z.enum([
+  "attached",
+  "solving",
+  "solved",
+  "error",
+  "detached"
+]);
+var captchaErrorCodeSchema = import_zod.z.enum([
+  "HIT_LIMIT",
+  "MAX_RETRIES",
+  "UNEXPECTED_SERVER_RESPONSE",
+  "UNEXPECTED_ERROR"
+]);
+var captchaErrorSchema = import_zod.z.object({
+  code: captchaErrorCodeSchema,
+  error: import_zod.z.unknown().optional()
+});
+var captchaBaseSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1),
+  tabId: import_zod.z.number().int().positive(),
+  type: captchaTypeSchema,
+  retryCount: import_zod.z.number().int().nonnegative().optional()
+});
+var captchaNonErrorSchema = captchaBaseSchema.extend({
+  status: captchaStatusSchema.exclude(["error"])
+});
+var captchaErrorStatusSchema = captchaBaseSchema.extend({
+  status: import_zod.z.literal("error"),
+  error: captchaErrorSchema
+});
+var captchaSchema = import_zod.z.discriminatedUnion("status", [
+  captchaBaseSchema.extend({
+    status: import_zod.z.literal("attached")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod.z.literal("solving")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod.z.literal("solved")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod.z.literal("detached")
+  }),
+  captchaErrorStatusSchema
+]);
+
+// src/common/extension/extensionsHelpers.ts
+var import_portfinder = require("portfinder");
+
+// src/common/launchBrowser.ts
+var import_util = require("util");
+var import_neverthrow2 = require("neverthrow");
+var import_zod2 = require("zod");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+async function getBrowserExecutablePath() {
+  const browserType = getBrowserType();
+  if (browserType === "brave") {
+    return await getBraveExecutablePath();
+  }
+}
+function getBrowserType() {
+  if (process.env.BROWSER_TYPE === "brave") {
+    return "brave";
+  }
+  return "chromium";
+}
+async function getBraveExecutablePath() {
+  const { stdout } = await execAsync("which brave-browser-stable");
+  const bravePath = stdout.trim();
+  if (bravePath.length === 0) {
+    throw new Error("Brave browser not found");
+  }
+  return bravePath;
+}
+async function getHeadlessUserAgent({
+  executablePath,
+  args,
+  ignoreDefaultArgs
+}) {
+  const browser = await playwright.chromium.launch({
+    headless: true,
+    executablePath,
+    args,
+    ignoreDefaultArgs
+  });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  let userAgent = await page.evaluate(() => navigator.userAgent);
+  await browser.close();
+  if (!userAgent || typeof userAgent !== "string") {
+    return void 0;
+  }
+  userAgent = userAgent.replace("HeadlessChrome", "Chrome");
+  return userAgent;
+}
+
+// src/commands/get-headless-user-agent.ts
+import_dotenv2.default.config();
+import_commander.program.description("get headless user agent").action(async () => {
+  try {
+    console.log(
+      await getHeadlessUserAgent({
+        executablePath: await getBrowserExecutablePath()
+      })
+    );
+  } catch (error) {
+    console.error("Error getting headless user agent:", error);
+    process.exit(1);
+  }
+});
+import_commander.program.parse(process.argv);

package/dist/commands/interface/run.js

@@ -398,8 +398,8 @@ var require_interfaceClient = __commonJS({
     exports2.SocketClient = SocketClient;
     SocketClient.LENGTH_HEADER_LENGTH = 4;
     var UnixSocketClient2 = class extends SocketClient {
-      constructor(path4) {
-        super(net.createConnection(path4));
+      constructor(path3) {
+        super(net.createConnection(path3));
       }
     };
     exports2.UnixSocketClient = UnixSocketClient2;
@@ -647,9 +647,9 @@ var backendFunctionsTokenManager = new JwtTokenManager(
   `refreshBackendFunctionsToken`
 );
 backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
-function callBackendFunctionWithToken(path4, init) {
+function callBackendFunctionWithToken(path3, init) {
   return backendFunctionsTokenManager.fetchWithToken(
-    `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path4}`,
+    `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path3}`,
     init
   );
 }
@@ -887,8 +887,8 @@ function getIntunedExtensionPath() {
   return process.env.INTUNED_EXTENSION_PATH;
 }
 async function isIntunedExtensionEnabled() {
-  const path4 = getIntunedExtensionPath();
-  if (!path4) {
+  const path3 = getIntunedExtensionPath();
+  if (!path3) {
     return false;
   }
   const captchaSolverSettings2 = await getIntunedCaptchaSolverSettings();
@@ -1144,11 +1144,11 @@ function getDownloadDirectoryPath() {
   if (!context) {
     throw new Error("ExecutionContext not found");
   }
-  const path4 = `/tmp/downloads/${context.runId}`;
-  (0, import_fs_extra.ensureDirSync)(path4, {
+  const path3 = `/tmp/downloads/${context.runId}`;
+  (0, import_fs_extra.ensureDirSync)(path3, {
     mode: 1533
   });
-  return path4;
+  return path3;
 }
 
 // src/common/runApi/index.ts
@@ -1237,7 +1237,6 @@ async function getStorageState(context) {
 }
 
 // src/common/playwrightContext.ts
-var import_path3 = __toESM(require("path"));
 var fs3 = __toESM(require("fs-extra"));
 var import_neverthrow5 = require("neverthrow");
 
@@ -1248,27 +1247,27 @@ var import_neverthrow3 = require("neverthrow");
 var import_neverthrow2 = require("neverthrow");
 var import_runtime_interface = __toESM(require_dist());
 async function importUsingImportFunction({
-  path: path4,
+  path: path3,
   allowGenerators = true,
   importFunction
 }) {
   try {
-    const importedResult = await importFunction(path4);
+    const importedResult = await importFunction(path3);
     if (importedResult.isErr()) {
       if (importedResult.error.type === "not_found") {
-        return (0, import_neverthrow2.err)(new import_runtime_interface.ApiNotFoundError(path4));
+        return (0, import_neverthrow2.err)(new import_runtime_interface.ApiNotFoundError(path3));
       }
       return (0, import_neverthrow2.err)(new import_runtime_interface.AutomationError(importedResult.error.error));
     }
     const imported = importedResult.value;
     if (!imported || !imported.default || !imported.default.constructor) {
-      return (0, import_neverthrow2.err)(new import_runtime_interface.InvalidApiError(`${path4} does not have a default export`));
+      return (0, import_neverthrow2.err)(new import_runtime_interface.InvalidApiError(`${path3} does not have a default export`));
     }
     if (imported.default.constructor.name === "AsyncGeneratorFunction") {
       if (!allowGenerators) {
         return (0, import_neverthrow2.err)(
           new import_runtime_interface.InvalidApiError(
-            `${path4} default export must be an async function`
+            `${path3} default export must be an async function`
           )
         );
       }
@@ -1287,7 +1286,7 @@ async function importUsingImportFunction({
       return (0, import_neverthrow2.ok)(imported.default);
     }
     return (0, import_neverthrow2.err)(
-      new import_runtime_interface.InvalidApiError(`${path4} default export must be an async function`)
+      new import_runtime_interface.InvalidApiError(`${path3} default export must be an async function`)
     );
   } catch (error) {
     return (0, import_neverthrow2.err)(new import_runtime_interface.AutomationError(error));
@@ -1560,10 +1559,6 @@ async function getHeadlessUserAgent({
 
 // src/common/playwrightContext.ts
 var import_runtime_interface3 = __toESM(require_dist());
-var browserScriptsFile = import_path3.default.join(
-  __dirname,
-  "./assets/browser_scripts.js"
-);
 async function withPlaywrightContext({
   cdpAddress,
   cdpTargetId,
@@ -1674,11 +1669,11 @@ async function loadSessionToContext({
 // src/common/formatZodError.ts
 function formatZodError(zodError) {
   const formattedErrors = zodError.errors.map((error) => {
-    const path4 = error.path.map((segment) => {
+    const path3 = error.path.map((segment) => {
       return typeof segment === "number" ? `[${segment}]` : segment;
     }).join(".");
-    if (path4) {
-      return `${path4} is invalid - ${error.message}`;
+    if (path3) {
+      return `${path3} is invalid - ${error.message}`;
     }
     return error.message;
   });
@@ -1779,13 +1774,6 @@ async function runApi({
           intunedContext.getAuthSessionParameters = async () => auth.parameters;
         }
       }
-      const scriptContent = await fs4.readFile(browserScriptsFile, "utf-8");
-      await context.addInitScript({
-        content: scriptContent
-      });
-      for (const page2 of context.pages()) {
-        await page2.evaluate(scriptContent);
-      }
       if (tracing.enabled) {
         await context.tracing.start({
           screenshots: true,
@@ -2057,9 +2045,9 @@ function getProxyUrlFromRunOptions(runOptions) {
   url.password = proxy.password;
   return url.toString();
 }
-var _defaultImport = async (path4) => {
+var _defaultImport = async (path3) => {
   try {
-    const imported = await Promise.resolve().then(() => require(`${process.cwd()}/${path4}`));
+    const imported = await Promise.resolve().then(() => require(`${process.cwd()}/${path3}`));
     return (0, import_neverthrow7.ok)(imported);
   } catch (e) {
     if ("code" in e && e.code === "MODULE_NOT_FOUND" || e.code === "ERR_MODULE_NOT_FOUND") {

package/dist/commands/intuned-cli/main.d.ts

@@ -0,0 +1,2 @@
+
+export {  }