@intuned/runtime-dev 1.3.18-interface.13 → 1.3.18-interface.4

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, {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    }, {
+        type: "API" | "MANUAL";
+        enabled: true;
+        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;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+}, {
+    authSessions: {
+        enabled: false;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        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;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        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;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        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");
+var _formatZodError = require("./formatZodError");
+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) {
+    return (0, _neverthrow.err)(`${settingsFile.name} is not valid:\n${(0, _formatZodError.formatZodError)(parseResult.error)}\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/jwtTokenManager.d.ts

@@ -1,5 +1,4 @@
-import fetch from 'cross-fetch';
-
+import fetch from "cross-fetch";
 declare class JwtTokenManager {
     private _token;
     private tokenRefreshTimeout;
@@ -13,7 +12,6 @@ declare class JwtTokenManager {
     fetchWithToken(...[input, init]: Parameters<typeof fetch>): Promise<Response>;
     get backendFunctionsBaseUrl(): string | undefined;
 }
-declare const backendFunctionsTokenManager: JwtTokenManager;
-declare function callBackendFunctionWithToken(path: string, init?: Parameters<typeof fetch>[1]): Promise<Response>;
-
-export { backendFunctionsTokenManager, callBackendFunctionWithToken };
+export declare const backendFunctionsTokenManager: JwtTokenManager;
+export declare function callBackendFunctionWithToken(path: string, init?: Parameters<typeof fetch>[1]): Promise<Response>;
+export {};

package/dist/common/jwtTokenManager.js

@@ -1,63 +1,25 @@
-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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/common/jwtTokenManager.ts
-var jwtTokenManager_exports = {};
-__export(jwtTokenManager_exports, {
-  backendFunctionsTokenManager: () => backendFunctionsTokenManager,
-  callBackendFunctionWithToken: () => callBackendFunctionWithToken
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(jwtTokenManager_exports);
-var import_cross_fetch = __toESM(require("cross-fetch"));
-var jwt = __toESM(require("jsonwebtoken"));
-var import_neverthrow = require("neverthrow");
-
-// 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 JwtTokenManager = class {
+exports.backendFunctionsTokenManager = void 0;
+exports.callBackendFunctionWithToken = callBackendFunctionWithToken;
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var jwt = _interopRequireWildcard(require("jsonwebtoken"));
+var _neverthrow = require("neverthrow");
+var _constants = require("./constants");
+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 }; }
+class JwtTokenManager {
   constructor(refreshTokenPath) {
     this.refreshTokenPath = refreshTokenPath;
-    this._token = void 0;
+    this._token = undefined;
   }
   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;
@@ -70,14 +32,14 @@ var JwtTokenManager = class {
     if (!payload || typeof payload == "string") return;
     const expiry = payload.expiry;
     if (!expiry || typeof expiry !== "number") return;
-    const timeWindow = 60 * 1e3;
+    const timeWindow = 60 * 1000;
     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 (timeToRefresh === undefined) return;
     if (this.tokenRefreshTimeout) clearTimeout(this.tokenRefreshTimeout);
     this.tokenRefreshTimeout = setTimeout(async () => {
       const result = await this.refreshToken();
@@ -90,91 +52,63 @@ var JwtTokenManager = class {
   }
   async refreshToken() {
     if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
-    const res = await this.fetchWithToken(
-      `${this.backendFunctionsBaseUrl}/${this.refreshTokenPath}`,
-      {
-        method: "GET"
-      }
-    );
+    const res = await this.fetchWithToken(`${this.backendFunctionsBaseUrl}/${this.refreshTokenPath}`, {
+      method: "GET"
+    });
     if (res.status === 401) {
-      return (0, import_neverthrow.err)("Unauthorized");
+      return (0, _neverthrow.err)("Unauthorized");
     }
-    const jsonResult = await import_neverthrow.ResultAsync.fromPromise(
-      res.json(),
-      () => "not json"
-    );
+    const jsonResult = await _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];
+    const apiKey = process.env[_constants.API_KEY_ENV_VAR_KEY];
     if (apiKey) {
-      headers.set(API_KEY_HEADER_NAME, apiKey);
+      headers.set(_constants.API_KEY_HEADER_NAME, apiKey);
     }
-    const token = process.env[AUTH_TOKEN_ENV_VAR_KEY];
+    const token = process.env[_constants.AUTH_TOKEN_ENV_VAR_KEY];
     if (token) {
       headers.set("Authorization", `Bearer ${token}`);
     }
-    if (this.token !== void 0) {
+    if (this.token !== undefined) {
       headers.set("Authorization", `Bearer ${this.token}`);
     }
-    const result = await (0, import_cross_fetch.default)(input, {
+    const result = await (0, _crossFetch.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."
-      );
+    if (result.status === 401 && process.env[_constants.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.\n" + "Run '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`
-        );
+        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`
-        );
+      if (!process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY]) {
+        throw new Error(`Cannot call backend function - ${_constants.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 workspaceId = process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY];
+      if (!process.env[_constants.PROJECT_ID_ENV_VAR_KEY] && !process.env.INTUNED_INTEGRATION_ID) {
+        throw new Error(`Cannot call backend function - ${_constants.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];
+      const projectId = process.env.INTUNED_INTEGRATION_ID ?? process.env[_constants.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}`
-        );
+      if (process.env[_constants.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.\n` + `Run 'intuned provision' or see https://docs.intunedhq.com/docs/05-references/cli#provision-project for more information.\n` + `Original error: ${e.message}`);
       }
     }
   }
-};
-var backendFunctionsTokenManager = new JwtTokenManager(
-  `refreshBackendFunctionsToken`
-);
+}
+const backendFunctionsTokenManager = exports.backendFunctionsTokenManager = new JwtTokenManager(`refreshBackendFunctionsToken`);
 backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
 function callBackendFunctionWithToken(path, init) {
-  return backendFunctionsTokenManager.fetchWithToken(
-    `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path}`,
-    init
-  );
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  backendFunctionsTokenManager,
-  callBackendFunctionWithToken
-});
+  return backendFunctionsTokenManager.fetchWithToken(`${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path}`, init);
+}

package/dist/common/launchBrowser.d.ts

@@ -0,0 +1,34 @@
+import * as playwright from "playwright";
+import { Result } from "neverthrow";
+export interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+}
+export type LaunchBrowserResult = {
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+};
+export type LaunchChromiumStandaloneOptions = {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath?: string;
+    cdpPort?: number;
+    appModeInitialUrl?: string;
+    executablePath?: string;
+};
+export type LaunchChromiumCdpOptions = {
+    cdpAddress: string;
+    cdpTargetId?: string;
+};
+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 getCdpWebSocketUrl(cdpAddress: string): Promise<Result<string, string>>;
+export declare function getHeadlessUserAgent({ executablePath, args, ignoreDefaultArgs, }: {
+    executablePath?: string;
+    args?: string[];
+    ignoreDefaultArgs?: string[];
+}): Promise<string | undefined>;