@intuned/runtime 1.3.0 → 1.3.2

package/dist/commands/intuned-cli/controller/save.js

@@ -0,0 +1,364 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = void 0;
+exports.runSaveProject = runSaveProject;
+exports.validateProjectName = exports.validateIntunedProject = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _minimatch = require("minimatch");
+var _zod = require("zod");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../constants");
+var _helpers = require("../helpers");
+var _lodash = require("lodash");
+var _uuid = require("uuid");
+var _terminal = require("../helpers/terminal");
+var _build = require("./build");
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _constants2 = require("../../../common/constants");
+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); }
+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; }
+const saveProjectApiResponseSchema = _zod.z.string().transform((val, ctx) => {
+  try {
+    return JSON.parse(val);
+  } catch (e) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Response is not valid JSON"
+    });
+    return _zod.z.NEVER;
+  }
+}).pipe(_zod.z.object({
+  id: _zod.z.string().uuid()
+}));
+async function runSaveProject(projectName, auth) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}`;
+  const headers = {
+    [_constants2.API_KEY_HEADER_NAME]: apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const saveProjectPayload = {
+    codeTree,
+    platformType: "CLI",
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "PUT",
+    body: JSON.stringify(saveProjectPayload)
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new _helpers.CLIError(`Invalid API key. Please check your API key and try again.`);
+    }
+    throw new _helpers.CLIError(`^r^+Invalid response from server\n^:^R${response.status} ${await response.text()}^:\n^r^+Project save failed^:\n`, {
+      autoColor: false
+    });
+  }
+  (0, _terminal.terminal)("^g^+Project saved successfully!^:\n");
+  const body = await response.text();
+  const parseResult = saveProjectApiResponseSchema.safeParse(body);
+  if (!parseResult.success) {
+    (0, _terminal.terminal)(`^yWarning: Could not parse save project response:^:\n`);
+    (0, _terminal.terminal)(body + "\n");
+    return;
+  }
+  const {
+    id: projectId
+  } = parseResult.data;
+  const dotEnvPath = path.join(projectPath, ".env");
+  if (!(await fs.exists(dotEnvPath))) {
+    await fs.writeFile(dotEnvPath, `${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}
+${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}
+${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`);
+    (0, _terminal.terminal)(`^g^+Created .env file with project credentials.^:\n`);
+  }
+  const envContent = await fs.readFile(dotEnvPath, "utf-8");
+  const dotenvContent = dotenv.parse(envContent);
+  let contentToAppend = "";
+  if (!dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] || dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] !== projectId) {
+    contentToAppend += `\n${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}`;
+  }
+  if (!dotenvContent[_constants2.WORKSPACE_ID_ENV_VAR_KEY]) {
+    contentToAppend += `\n${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}`;
+  }
+  if (!dotenvContent[_constants2.API_KEY_ENV_VAR_KEY]) {
+    contentToAppend += `\n${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`;
+  }
+  if (contentToAppend) {
+    await fs.appendFile(dotEnvPath, contentToAppend + "\n");
+    (0, _terminal.terminal)(`^g^+Updated .env file with project credentials.^:\n`);
+  }
+}
+const projectNameSchema = exports.projectNameSchema = _zod.z.string().min(1, "Project Name is required").max(50, "Name must be 50 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Name can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
+  message: "Name cannot be a UUID"
+});
+const validateProjectName = projectName => {
+  const validation = projectNameSchema.safeParse(projectName);
+  if (!validation.success) {
+    return {
+      isValid: false,
+      errorMessage: validation.error.errors[0].message
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateProjectName = validateProjectName;
+const validateIntunedProject = async () => {
+  const currentDirectoryToSave = process.cwd();
+  const validationSteps = [{
+    name: "build",
+    check: async () => {
+      try {
+        const buildResult = await (0, _build.runBuild)();
+        if (!buildResult) {
+          return {
+            isValid: false,
+            errorMessage: "Build failed"
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Build failed"
+        };
+      }
+    }
+  }, {
+    name: "package.json",
+    check: async () => {
+      try {
+        const packageJsonPath = path.join(currentDirectoryToSave, "package.json");
+        await fs.exists(packageJsonPath);
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
+          encoding: "utf-8"
+        }));
+        const userCodePlaywrightVersion = packageJson.dependencies?.playwright;
+        if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
+          return {
+            isValid: false,
+            errorMessage: `Playwright version mismatch: expected ${_constants.CURRENT_PLAYWRIGHT_VERSION}, found ${userCodePlaywrightVersion || "none"}`
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Package.json file not found or cannot be read"
+        };
+      }
+    }
+  }, {
+    name: "Intuned.json",
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToSave, "Intuned.json");
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Intuned.json file not found"
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToSave, "api");
+        await fs.access(apiFolderPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "API folder not found"
+        };
+      }
+    }
+  }];
+  for (const step of validationSteps) {
+    const result = await step.check();
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateIntunedProject = validateIntunedProject;
+function ignoreFilesByPattern(filePath, patterns, projectPath) {
+  const relativePath = path.relative(projectPath, filePath);
+  if (relativePath.startsWith("node_modules")) {
+    return true;
+  }
+  for (const pattern of patterns) {
+    if (!pattern || pattern.startsWith("#")) continue;
+    if (pattern.startsWith("!")) {
+      if ((0, _minimatch.minimatch)(relativePath, pattern.substring(1))) {
+        return false;
+      }
+    } else if ((0, _minimatch.minimatch)(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function listFilesNotIgnored(projectPath, ignorePatterns) {
+  const results = [];
+  function traverseDirectory(dirPath) {
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(fullPath);
+          if (stats.isDirectory()) {
+            traverseDirectory(fullPath);
+          } else if (stats.isFile()) {
+            results.push(path.relative(projectPath, fullPath));
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${fullPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+  }
+  traverseDirectory(projectPath);
+  return results;
+}
+async function convertProjectToCodeTree(projectPath) {
+  const filesToSave = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  const filesToSaveText = "  " + filesToSave.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be saved:^:\n");
+  (0, _terminal.terminal)(filesToSaveText + "\n");
+  function readDirectory(dirPath) {
+    const tree = {};
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(entryPath, _projectExclusions.default, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(entryPath);
+          if (stats.isFile()) {
+            try {
+              const content = fs.readFileSync(entryPath, "utf-8");
+              tree[entry] = {
+                file: {
+                  contents: content
+                }
+              };
+            } catch (error) {
+              (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
+            }
+          } else if (stats.isDirectory()) {
+            const subTree = readDirectory(entryPath);
+            if (Object.keys(subTree).length > 0) {
+              tree[entry] = {
+                directory: subTree
+              };
+            }
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${entryPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+    return tree;
+  }
+  const tree = readDirectory(projectPath);
+  mapToIDEParams(tree);
+  return tree;
+}
+function mapToIDEParams(tree) {
+  if (!tree) {
+    return;
+  }
+  if (!tree["parameters"] || "file" in tree["parameters"]) {
+    return;
+  }
+  const apiParametersMap = {};
+  const cliParameters = Object.keys(tree["parameters"].directory);
+  const ____testParameters = {
+    directory: {}
+  };
+  for (const parameterKey of cliParameters) {
+    const parameter = tree["parameters"].directory[parameterKey];
+    if ("directory" in parameter) {
+      continue;
+    }
+    if ((0, _lodash.isEmpty)(parameter.file.contents)) {
+      continue;
+    }
+    const parameterPayload = JSON.parse(parameter.file.contents);
+    if (!parameterPayload["__api-name"]) {
+      continue;
+    }
+    const api = parameterPayload["__api-name"];
+    const {
+      "__api-name": _,
+      ...parameterValue
+    } = parameterPayload;
+    const testParameter = {
+      name: parameterKey.replace(".json", ""),
+      lastUsed: false,
+      id: (0, _uuid.v4)(),
+      value: JSON.stringify(parameterValue)
+    };
+    if (!apiParametersMap[api]) {
+      apiParametersMap[api] = [];
+    }
+    apiParametersMap[api].push(testParameter);
+  }
+  for (const api in apiParametersMap) {
+    if (apiParametersMap[api].length > 0) {
+      apiParametersMap[api][apiParametersMap[api].length - 1].lastUsed = true;
+    }
+    ____testParameters.directory[`${api}.json`] = {
+      file: {
+        contents: JSON.stringify(apiParametersMap[api], null, 2)
+      }
+    };
+  }
+  delete tree["parameters"];
+  tree["____testParameters"] = ____testParameters;
+  return;
+}

package/dist/commands/intuned-cli/helpers/backend.js

@@ -5,16 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getAuthCredentials = getAuthCredentials;
 exports.getBaseUrl = getBaseUrl;
+var _constants = require("../../../common/constants");
 var _errors = require("./errors");
 var _intunedJson = require("./intunedJson");
 async function getAuthCredentials(options) {
   const workspaceId = options.workspaceId || (await (0, _intunedJson.getSettingIntunedJSON)("workspaceId"));
-  const apiKey = options.apiKey || process.env.INTUNED_API_KEY;
+  const apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
   if (!workspaceId) {
     throw new _errors.CLIError("Workspace ID is required. Please provide it via command line options or Intuned.json");
   }
   if (!apiKey) {
-    throw new _errors.CLIError("API key is required. Please provide it via command line options or INTUNED_API_KEY environment variable.");
+    throw new _errors.CLIError(`API key is required. Please provide it via command line options or ${_constants.API_KEY_ENV_VAR_KEY} environment variable.`);
   }
   return {
     workspaceId,
@@ -22,5 +23,5 @@ async function getAuthCredentials(options) {
   };
 }
 function getBaseUrl() {
-  return process.env.INTUNED_API_BASE_URL || process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`;
+  return process.env[_constants.API_BASE_URL_ENV_VAR_KEY] || process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`;
 }

package/dist/commands/intuned-cli/helpers/errors.d.ts

@@ -1,4 +1,4 @@
-import { AutomationError } from "../../../common/runApi";
+import { RunAutomationError } from "../../../common/runApi";
 export declare class CLIError extends Error {
     autoColor: boolean;
     constructor(message: string, options?: {
@@ -10,5 +10,5 @@ export declare class CLIAssertionError extends CLIError {
         autoColor?: boolean;
     });
 }
-export declare function logAutomationError(error: AutomationError): void;
+export declare function logAutomationError(error: RunAutomationError): void;
 export declare function withErrorLogging<T extends any[]>(fn: (...args: T) => Promise<unknown>): (...args: T) => Promise<never>;

package/dist/commands/intuned-cli/helpers/errors.js

@@ -25,11 +25,15 @@ class CLIAssertionError extends CLIError {
 exports.CLIAssertionError = CLIAssertionError;
 function logAutomationError(error) {
   (0, _terminal.terminal)(`^r^+An error occurred while running the API:^:\n`);
-  if (error.error.stack) {
-    const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
-    (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+  if (error instanceof _runApi.AutomationError) {
+    if (error.error.stack) {
+      const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
+      (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+    } else {
+      (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    }
   } else {
-    (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    (0, _terminal.terminal)(`^r${error.message}^:\n`);
   }
 }
 function withErrorLogging(fn) {

package/dist/commands/intuned-cli/main.js

@@ -1,12 +1,19 @@
 "use strict";
 
 var _dotenv = _interopRequireDefault(require("dotenv"));
+var _constants = require("../../common/constants");
+var _backend = require("./helpers/backend");
 var _commands = require("./commands");
 var _helpers = require("./helpers");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 _dotenv.default.config({
   path: `.env`
 });
+process.env[_constants.CLI_ENV_VAR_KEY] = "true";
+process.env.RUN_ENVIRONMENT = "AUTHORING";
+if (!process.env.FUNCTIONS_DOMAIN) {
+  process.env.FUNCTIONS_DOMAIN = (0, _backend.getBaseUrl)().replace(/\/$/, "");
+}
 _commands.program.configureHelp({
   sortSubcommands: true
 });

package/dist/common/asyncLocalStorage/index.d.ts

@@ -9,6 +9,7 @@ interface TimeoutInfo {
 export interface InternalRunInfo extends RunInfo {
     extendedPayloads: Payload[];
     timeoutInfo?: TimeoutInfo;
+    store?: Record<string, any>;
     getAuthSessionParameters?: () => Promise<any>;
 }
 export declare function getExecutionContext(): InternalRunInfo | undefined;

package/dist/common/constants.d.ts

@@ -1,3 +1,9 @@
 export declare const API_FOLDER_NAME = "api";
 export declare const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
 export declare const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+export declare const WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+export declare const PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+export declare const API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+export declare const API_KEY_HEADER_NAME = "x-api-key";
+export declare const API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+export declare const CLI_ENV_VAR_KEY = "INTUNED_CLI";

package/dist/common/constants.js

@@ -3,7 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = exports.API_FOLDER_NAME = void 0;
+exports.WORKSPACE_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = exports.CLI_ENV_VAR_KEY = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = exports.API_KEY_HEADER_NAME = exports.API_KEY_ENV_VAR_KEY = exports.API_FOLDER_NAME = exports.API_BASE_URL_ENV_VAR_KEY = void 0;
 const API_FOLDER_NAME = exports.API_FOLDER_NAME = "api";
 const AUTH_SESSIONS_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
-const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+const WORKSPACE_ID_ENV_VAR_KEY = exports.WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+const PROJECT_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+const API_KEY_ENV_VAR_KEY = exports.API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+const API_KEY_HEADER_NAME = exports.API_KEY_HEADER_NAME = "x-api-key";
+const API_BASE_URL_ENV_VAR_KEY = exports.API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+const CLI_ENV_VAR_KEY = exports.CLI_ENV_VAR_KEY = "INTUNED_CLI";

package/dist/common/jwtTokenManager.d.ts

@@ -10,6 +10,7 @@ declare class JwtTokenManager {
     private scheduleTokenRefresh;
     private refreshToken;
     fetchWithToken(...[input, init]: Parameters<typeof fetch>): Promise<Response>;
+    get backendFunctionsBaseUrl(): string | undefined;
 }
 export declare const backendFunctionsTokenManager: JwtTokenManager;
 export declare function callBackendFunctionWithToken(path: string, init?: Parameters<typeof fetch>[1]): Promise<Response>;

package/dist/common/jwtTokenManager.js

@@ -8,6 +8,7 @@ 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 }; }
@@ -51,7 +52,7 @@ class JwtTokenManager {
   }
   async refreshToken() {
     if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
-    const res = await this.fetchWithToken(this.refreshTokenPath, {
+    const res = await this.fetchWithToken(`${this.backendFunctionsBaseUrl}/${this.refreshTokenPath}`, {
       method: "GET"
     });
     if (res.status === 401) {
@@ -62,18 +63,47 @@ class JwtTokenManager {
     const newToken = jsonResult.value.token;
     if (newToken) this._token = newToken;
   }
-  fetchWithToken(...[input, init]) {
+  async fetchWithToken(...[input, init]) {
     const headers = new Headers(init?.headers);
-    headers.set("Authorization", `Bearer ${this.token}`);
-    return (0, _crossFetch.default)(input, {
+    if (process.env[_constants.API_KEY_ENV_VAR_KEY]) {
+      headers.set(_constants.API_KEY_HEADER_NAME, process.env[_constants.API_KEY_ENV_VAR_KEY]);
+    }
+    if (this.token !== undefined) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    const result = await (0, _crossFetch.default)(input, {
       ...init,
       headers
     });
+    if (result.status === 401 && process.env[_constants.CLI_ENV_VAR_KEY] === "true") {
+      console.warn("Unauthorized backend function call - make sure to save your project to Intuned to set up the correct API credentials");
+    }
+    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[_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[_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[_constants.PROJECT_ID_ENV_VAR_KEY];
+      return `${domain}/api/${workspaceId}/functions/${projectId}`;
+    } catch (e) {
+      if (process.env[_constants.CLI_ENV_VAR_KEY] === "true") {
+        throw new Error(`API credentials not set - make sure to save your project to Intuned to set up the correct API credentials.\nOriginal error: ${e.message}`);
+      }
+    }
   }
 }
-const backendFunctionsPath = `${process.env.FUNCTIONS_DOMAIN}/api/${process.env.INTUNED_WORKSPACE_ID}/functions/${process.env.INTUNED_INTEGRATION_ID}`;
-const backendFunctionsTokenManager = exports.backendFunctionsTokenManager = new JwtTokenManager(`${backendFunctionsPath}/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(`${backendFunctionsPath}/${path}`, init);
+  return backendFunctionsTokenManager.fetchWithToken(`${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path}`, init);
 }

package/dist/common/playwrightContext.d.ts

@@ -0,0 +1,54 @@
+import * as playwright from "playwright";
+import { RunAutomationError } from "./runApi/errors";
+import type { RunApiSession } from "./runApi/types";
+import { Err, Ok } from "neverthrow";
+import { type ImportFunction } from "./runApi/importUsingImportFunction";
+export interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+}
+export declare function launchChromium(options: {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath?: string;
+    cdpPort?: number;
+}): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare function launchChromium(options: {
+    cdpAddress: string;
+}): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare const browserScriptsFile: string;
+type WithPlaywrightContextParameters = {
+    importFunction: ImportFunction;
+    apiName: string;
+    apiParameters: any;
+} | {
+    importFunction?: undefined;
+    apiName?: undefined;
+    apiParameters?: undefined;
+};
+type WithPlaywrightContextWrappedFunctionReturn<R> = Ok<R, any> | Err<any, RunAutomationError>;
+export type WithPlaywrightContextWrappedFunction<R> = (context: playwright.BrowserContext, page: playwright.Page) => Promise<WithPlaywrightContextWrappedFunctionReturn<R>>;
+export declare function withPlaywrightContext<R>(options: {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function withPlaywrightContext<R>(options: {
+    cdpAddress: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function loadSessionToContext({ context, session, }: {
+    context: playwright.BrowserContext;
+    session: RunApiSession;
+}): Promise<void>;
+export declare function getRemotePlaywrightContext(cdpAddress: string): Promise<{
+    browser: playwright.Browser;
+    context: playwright.BrowserContext;
+}>;
+export {};