@intuned/runtime-dev 1.3.13-kv.1 → 1.3.14-ts-runtime-helpers

package/dist/common/extension/intunedExtensionServer.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionServer = void 0;
+exports.cleanIntunedExtensionServer = cleanIntunedExtensionServer;
+exports.getIntunedExtensionServer = getIntunedExtensionServer;
+exports.getTabId = getTabId;
+exports.setupIntunedExtensionServer = setupIntunedExtensionServer;
+var _fastify = _interopRequireDefault(require("fastify"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TabCaptchaState {
+  constructor(tabId) {
+    this.tabId = tabId;
+    this.captchasById = 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 = 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) {
+      await subscriber.handler(captcha);
+    }
+  }
+}
+class ExtensionServer {
+  app = null;
+  isHealthy = false;
+  constructor() {
+    this.tabs = 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 = (0, _fastify.default)({
+      logger: false,
+      bodyLimit: 1_000_000
+    });
+    this.app.post("/state", async (request, reply) => {
+      try {
+        const data = request.body ?? {};
+        const captcha = {
+          id: String(data?.id ?? ""),
+          tabId: Number(data?.tabId ?? 0),
+          type: data?.type,
+          status: data?.status,
+          retryCount: data?.retryCount,
+          error: data?.error ?? null
+        };
+        if (!captcha.id || !captcha.tabId || !captcha.type || !captcha.status) {
+          return reply.code(400).send({
+            error: "Invalid captcha payload"
+          });
+        }
+        await this.handleUpsertCaptcha(captcha);
+        return reply.code(200).send({});
+      } catch (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
+    });
+    this.isHealthy = true;
+  }
+  async stop() {
+    if (!this.app) return;
+    const toClose = this.app;
+    this.app = null;
+    this.isHealthy = false;
+    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);
+  }
+}
+exports.ExtensionServer = ExtensionServer;
+let extensionServerSingleton = null;
+function getIntunedExtensionServer() {
+  if (!extensionServerSingleton) {
+    throw new Error("Intuned Extension Server is not initialized.");
+  }
+  return extensionServerSingleton;
+}
+async function setupIntunedExtensionServer({
+  port,
+  host
+}) {
+  if (!extensionServerSingleton) {
+    extensionServerSingleton = new ExtensionServer();
+  }
+  await extensionServerSingleton.start({
+    port,
+    host
+  });
+}
+async function cleanIntunedExtensionServer() {
+  if (extensionServerSingleton) {
+    await extensionServerSingleton.stop();
+    extensionServerSingleton = null;
+  }
+}
+async function getTabId(page) {
+  await page.waitForFunction("window.__INTUNED_TAB_ID__ !== undefined", {
+    timeout: 15_000
+  });
+  const tabId = await page.evaluate("window.__INTUNED_TAB_ID__");
+  return Number(tabId);
+}

package/dist/common/extension/types.d.ts

@@ -0,0 +1,21 @@
+export type CaptchaType = "aws" | "cloudflare" | "customcaptcha" | "funcaptcha" | "geetest" | "hcaptcha" | "lemincaptcha" | "recaptcha" | "textcaptcha";
+export type CaptchaStatus = "attached" | "solving" | "solved" | "error" | "detached";
+export type CaptchaError = {
+    code: "HIT_LIMIT" | "MAX_RETRIES" | "UNEXPECTED_SERVER_RESPONSE" | "UNEXPECTED_ERROR";
+    error?: unknown;
+};
+export type CaptchaBase = {
+    id: string;
+    tabId: number;
+    type: CaptchaType;
+    retryCount?: number;
+};
+export type CaptchaNonError = CaptchaBase & {
+    status: Exclude<CaptchaStatus, "error">;
+};
+export type CaptchaErrorStatus = CaptchaBase & {
+    status: "error";
+    error: CaptchaError;
+};
+export type Captcha = CaptchaNonError | CaptchaErrorStatus;
+export type CaptchaCallback = (captcha: Captcha) => void | Promise<void>;

package/dist/common/extension/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/common/intunedJson.d.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+import { type Err, type Ok } from "neverthrow";
+export declare const intunedJsonSchema: z.ZodIntersection<z.ZodObject<{
+    projectName: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        defaultJobInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        defaultRunPlaygroundInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        testAuthSessionInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, "strip", z.ZodTypeAny, {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    }, {
+        defaultJobInput?: unknown;
+        defaultRunPlaygroundInput?: unknown;
+        testAuthSessionInput?: unknown;
+    }>>>;
+    stealthMode: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    projectName: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        defaultJobInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        defaultRunPlaygroundInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        testAuthSessionInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, "strip", z.ZodTypeAny, {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    }, {
+        defaultJobInput?: unknown;
+        defaultRunPlaygroundInput?: unknown;
+        testAuthSessionInput?: unknown;
+    }>>>;
+    stealthMode: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    projectName: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        defaultJobInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        defaultRunPlaygroundInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        testAuthSessionInput: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, "strip", z.ZodTypeAny, {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    }, {
+        defaultJobInput?: unknown;
+        defaultRunPlaygroundInput?: unknown;
+        testAuthSessionInput?: unknown;
+    }>>>;
+    stealthMode: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodUnion<[z.ZodObject<{
+    authSessions: z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: false;
+    }, {
+        enabled: false;
+    }>;
+    apiAccess: z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: false;
+    }, {
+        enabled: false;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    authSessions: {
+        enabled: false;
+    };
+    apiAccess: {
+        enabled: false;
+    };
+}, {
+    authSessions: {
+        enabled: false;
+    };
+    apiAccess: {
+        enabled: false;
+    };
+}>, z.ZodObject<{
+    authSessions: z.ZodUnion<[z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: false;
+    }, {
+        enabled: false;
+    }>, z.ZodObject<{
+        enabled: z.ZodLiteral<true>;
+        type: z.ZodEnum<["MANUAL", "API"]>;
+        startUrl: z.ZodOptional<z.ZodString>;
+        finishUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    }, {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    }>]>;
+    apiAccess: z.ZodObject<{
+        enabled: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: true;
+    }, {
+        enabled: true;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    authSessions: {
+        enabled: false;
+    } | {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+}, {
+    authSessions: {
+        enabled: false;
+    } | {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+}>]>>;
+export type IntunedJson = z.infer<typeof intunedJsonSchema>;
+export declare const intunedSettingsFileNames: readonly ["Intuned.json", "Intuned.jsonc", "Intuned.yaml", "Intuned.yml", "Intuned.toml"];
+export declare function loadIntunedJson(): Promise<Err<never, string> | Ok<{
+    projectName?: string | undefined;
+    workspaceId?: string | undefined;
+    metadata?: {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    } | undefined;
+    stealthMode?: {
+        enabled: boolean;
+    } | undefined;
+} & {
+    [k: string]: unknown;
+} & ({
+    authSessions: {
+        enabled: false;
+    };
+    apiAccess: {
+        enabled: false;
+    };
+} | {
+    authSessions: {
+        enabled: false;
+    } | {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+}), never>>;
+export declare function getIntunedSettingsFile(): Promise<Ok<{
+    name: typeof intunedSettingsFileNames[number];
+    path: string;
+    parse: (content: string) => any;
+}, never> | Err<never, string>>;
+export declare function getIntunedSettingsFileName(): Promise<Err<never, string> | Ok<"Intuned.json" | "Intuned.jsonc" | "Intuned.yaml" | "Intuned.yml" | "Intuned.toml", never>>;
+export declare function loadIntunedJsonSync(): Err<never, string> | Ok<{
+    projectName?: string | undefined;
+    workspaceId?: string | undefined;
+    metadata?: {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    } | undefined;
+    stealthMode?: {
+        enabled: boolean;
+    } | undefined;
+} & {
+    [k: string]: unknown;
+} & ({
+    authSessions: {
+        enabled: false;
+    };
+    apiAccess: {
+        enabled: false;
+    };
+} | {
+    authSessions: {
+        enabled: false;
+    } | {
+        enabled: true;
+        type: "API" | "MANUAL";
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+}), never>;

package/dist/common/intunedJson.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIntunedSettingsFile = getIntunedSettingsFile;
+exports.getIntunedSettingsFileName = getIntunedSettingsFileName;
+exports.intunedSettingsFileNames = exports.intunedJsonSchema = void 0;
+exports.loadIntunedJson = loadIntunedJson;
+exports.loadIntunedJsonSync = loadIntunedJsonSync;
+var _path = _interopRequireDefault(require("path"));
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _zod = require("zod");
+var JSONC = _interopRequireWildcard(require("jsonc-parser"));
+var YAML = _interopRequireWildcard(require("yaml"));
+var TOML = _interopRequireWildcard(require("smol-toml"));
+var _neverthrow = require("neverthrow");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const playwright = undefined;
+const intunedJsonSchema = exports.intunedJsonSchema = _zod.z.object({
+  projectName: _zod.z.string().optional(),
+  workspaceId: _zod.z.string().optional(),
+  metadata: _zod.z.object({
+    defaultJobInput: _zod.z.record(_zod.z.any()).optional().catch(undefined),
+    defaultRunPlaygroundInput: _zod.z.record(_zod.z.any()).optional().catch(undefined),
+    testAuthSessionInput: _zod.z.record(_zod.z.any()).optional().catch(undefined)
+  }).optional().catch(undefined),
+  stealthMode: _zod.z.object({
+    enabled: _zod.z.boolean()
+  }).optional().catch(undefined)
+}).passthrough().and(_zod.z.union([_zod.z.object({
+  authSessions: _zod.z.object({
+    enabled: _zod.z.literal(false)
+  }),
+  apiAccess: _zod.z.object({
+    enabled: _zod.z.literal(false)
+  })
+}), _zod.z.object({
+  authSessions: _zod.z.union([_zod.z.object({
+    enabled: _zod.z.literal(false)
+  }), _zod.z.object({
+    enabled: _zod.z.literal(true),
+    type: _zod.z.enum(["MANUAL", "API"]),
+    startUrl: _zod.z.string().optional(),
+    finishUrl: _zod.z.string().optional()
+  })]),
+  apiAccess: _zod.z.object({
+    enabled: _zod.z.literal(true)
+  })
+})]));
+const intunedSettingsFileNames = exports.intunedSettingsFileNames = ["Intuned.json", "Intuned.jsonc", "Intuned.yaml", "Intuned.yml", "Intuned.toml"];
+async function loadIntunedJson() {
+  const settingsFileResult = await getIntunedSettingsFile();
+  if (!settingsFileResult.isOk()) {
+    return settingsFileResult;
+  }
+  const settingsFile = settingsFileResult.value;
+  const intunedJsonContent = await fs.readFile(settingsFile.path, "utf-8");
+  let intunedJson;
+  try {
+    intunedJson = settingsFile.parse(intunedJsonContent);
+  } catch (e) {
+    return (0, _neverthrow.err)(`Failed to parse ${settingsFile.name}: ${e.message}`);
+  }
+  const parseResult = intunedJsonSchema.safeParse(intunedJson);
+  if (!parseResult.success) {
+    const formattedError = parseResult.error.errors.map(e => `- ${e.path.join(".")}: ${e.message}`).join("\n");
+    return (0, _neverthrow.err)(`${settingsFile.name} is not valid:\n${formattedError}\nPlease fix the errors and try again.`);
+  }
+  return (0, _neverthrow.ok)(parseResult.data);
+}
+const intunedSettingsParsers = {
+  "Intuned.json": JSON.parse,
+  "Intuned.jsonc": JSONC.parse,
+  "Intuned.yaml": YAML.parse,
+  "Intuned.yml": YAML.parse,
+  "Intuned.toml": TOML.parse
+};
+async function getIntunedSettingsFile() {
+  for (const fileName of intunedSettingsFileNames) {
+    const filePath = _path.default.join(process.cwd(), fileName);
+    if (await fs.exists(filePath)) {
+      return (0, _neverthrow.ok)({
+        name: fileName,
+        path: filePath,
+        parse: intunedSettingsParsers[fileName]
+      });
+    }
+  }
+  return (0, _neverthrow.err)("No Intuned settings file found.");
+}
+async function getIntunedSettingsFileName() {
+  const settingsFileResult = await getIntunedSettingsFile();
+  if (!settingsFileResult.isOk()) {
+    return settingsFileResult;
+  }
+  return (0, _neverthrow.ok)(settingsFileResult.value.name);
+}
+function loadIntunedJsonSync() {
+  const settingsFileResult = getIntunedSettingsFileSync();
+  if (!settingsFileResult.isOk()) {
+    return settingsFileResult;
+  }
+  const settingsFile = settingsFileResult.value;
+  const intunedJsonContent = fs.readFileSync(settingsFile.path, "utf-8");
+  let intunedJson;
+  try {
+    intunedJson = settingsFile.parse(intunedJsonContent);
+  } catch (e) {
+    return (0, _neverthrow.err)(`Failed to parse ${settingsFile.name}: ${e.message}`);
+  }
+  const parseResult = intunedJsonSchema.safeParse(intunedJson);
+  if (!parseResult.success) {
+    const formattedError = parseResult.error.errors.map(e => `- ${e.path.join(".")}: ${e.message}`).join("\n");
+    return (0, _neverthrow.err)(`${settingsFile.name} is not valid:\n${formattedError}\nPlease fix the errors and try again.`);
+  }
+  return (0, _neverthrow.ok)(parseResult.data);
+}
+function getIntunedSettingsFileSync() {
+  for (const fileName of intunedSettingsFileNames) {
+    const filePath = _path.default.join(process.cwd(), fileName);
+    if (fs.existsSync(filePath)) {
+      return (0, _neverthrow.ok)({
+        name: fileName,
+        path: filePath,
+        parse: intunedSettingsParsers[fileName]
+      });
+    }
+  }
+  return (0, _neverthrow.err)("No Intuned settings file found.");
+}

package/dist/common/launchBrowser.d.ts

@@ -21,5 +21,11 @@ export type LaunchChromiumCdpOptions = {
 };
 export declare function launchChromium(options: LaunchChromiumStandaloneOptions): Promise<LaunchBrowserResult>;
 export declare function launchChromium(options: LaunchChromiumCdpOptions): Promise<LaunchBrowserResult>;
+export declare function getBrowserExecutablePath(): Promise<string | undefined>;
 export declare function launchBrowser(options: Omit<LaunchChromiumStandaloneOptions, "executablePath"> | LaunchChromiumCdpOptions): Promise<LaunchBrowserResult>;
 export declare function getLocalCdpAddress(port: number): string;
+export declare function getHeadlessUserAgent({ executablePath, args, ignoreDefaultArgs, }: {
+    executablePath?: string;
+    args?: string[];
+    ignoreDefaultArgs?: string[];
+}): Promise<string | undefined>;

package/dist/common/launchBrowser.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getBrowserExecutablePath = getBrowserExecutablePath;
+exports.getHeadlessUserAgent = getHeadlessUserAgent;
 exports.getLocalCdpAddress = getLocalCdpAddress;
 exports.launchBrowser = launchBrowser;
 exports.launchChromium = launchChromium;
@@ -12,7 +14,8 @@ var fs = _fsExtra;
 var _path = require("path");
 var _waitOn = _interopRequireDefault(require("wait-on"));
 var _child_process = require("child_process");
-var _extensionsHelpers = require("./extensionsHelpers");
+var _extensionsHelpers = require("./extension/extensionsHelpers");
+var _intunedExtensionServer = require("./extension/intunedExtensionServer");
 var _util = require("util");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
@@ -86,10 +89,15 @@ async function launchChromium(options) {
       executablePath = undefined;
     }
   }
+  const viewport = null;
+  const userAgent = process.env.__PLAYWRIGHT_USER_AGENT_OVERRIDE ?? (await getHeadlessUserAgent({
+    executablePath
+  }));
   const context = await playwright.chromium.launchPersistentContext(userDataDir, {
+    userAgent,
     executablePath,
     headless,
-    viewport: null,
+    viewport,
     proxy,
     downloadsPath,
     args: extraArgs,
@@ -97,6 +105,7 @@ async function launchChromium(options) {
   });
   context.once("close", async () => {
     try {
+      await (0, _intunedExtensionServer.cleanIntunedExtensionServer)();
       await (0, _fsExtra.rm)(userDataDir, {
         recursive: true,
         force: true,
@@ -120,25 +129,20 @@ async function launchChromium(options) {
     context
   };
 }
+async function getBrowserExecutablePath() {
+  const browserType = getBrowserType();
+  if (browserType === "brave") {
+    return await getBraveExecutablePath();
+  }
+}
 async function launchBrowser(options) {
   if ("cdpAddress" in options) {
     return launchChromium(options);
   }
-  const browserType = getBrowserType();
-  switch (browserType) {
-    case "chromium":
-      {
-        return launchChromium(options);
-      }
-    case "brave":
-      {
-        const braveExecutablePath = await getBraveExecutablePath();
-        return launchChromium({
-          ...options,
-          executablePath: braveExecutablePath
-        });
-      }
-  }
+  return launchChromium({
+    ...options,
+    executablePath: await getBrowserExecutablePath()
+  });
 }
 function getBrowserType() {
   if (process.env.BROWSER_TYPE === "brave") {
@@ -169,4 +173,25 @@ async function waitOnCdpAddress(cdpAddress) {
     tcpTimeout: 1000,
     window: 1000
   });
+}
+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 undefined;
+  }
+  userAgent = userAgent.replace("HeadlessChrome", "Chrome");
+  return userAgent;
 }