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

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

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { R as RunInfo, P as Payload } from '../../export.d-BAUMB-lG.js';
+
+declare const asyncLocalStorage: AsyncLocalStorage<InternalRunInfo>;
+declare function runWithContext<R, TArgs extends any[]>(contextData: InternalRunInfo, callback: (...args: TArgs) => R, ...args: TArgs): R;
+interface TimeoutInfo {
+    extendTimeoutCallback?: () => Promise<void>;
+}
+interface InternalRunInfo extends RunInfo {
+    extendedPayloads: Payload[];
+    timeoutInfo?: TimeoutInfo;
+    store?: Record<string, any>;
+    getAuthSessionParameters?: () => Promise<any>;
+}
+declare function getExecutionContext(): InternalRunInfo | undefined;
+
+export { type InternalRunInfo, asyncLocalStorage, getExecutionContext, runWithContext };

package/dist/common/asyncLocalStorage/index.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/common/asyncLocalStorage/index.ts
+var asyncLocalStorage_exports = {};
+__export(asyncLocalStorage_exports, {
+  asyncLocalStorage: () => asyncLocalStorage,
+  getExecutionContext: () => getExecutionContext,
+  runWithContext: () => runWithContext
+});
+module.exports = __toCommonJS(asyncLocalStorage_exports);
+var import_node_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(contextData, callback, ...args) {
+  return asyncLocalStorage.run(contextData, callback, ...args);
+}
+function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+  return contextData;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asyncLocalStorage,
+  getExecutionContext,
+  runWithContext
+});

package/dist/common/binStartupScript.d.ts

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

package/dist/common/binStartupScript.js

@@ -0,0 +1,152 @@
+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/common/binStartupScript.ts
+var import_dotenv = __toESM(require("dotenv"));
+var path2 = __toESM(require("path"));
+
+// src/common/intunedJson.ts
+var import_path = __toESM(require("path"));
+var fs = __toESM(require("fs-extra"));
+var import_zod = require("zod");
+var JSONC = __toESM(require("jsonc-parser"));
+var YAML = __toESM(require("yaml"));
+var TOML = __toESM(require("smol-toml"));
+var import_neverthrow = require("neverthrow");
+var intunedJsonSchema = import_zod.z.object({
+  projectName: import_zod.z.string().optional(),
+  workspaceId: import_zod.z.string().optional(),
+  metadata: import_zod.z.object({
+    defaultJobInput: import_zod.z.record(import_zod.z.any()).optional().catch(void 0),
+    defaultRunPlaygroundInput: import_zod.z.record(import_zod.z.any()).optional().catch(void 0),
+    testAuthSessionInput: import_zod.z.record(import_zod.z.any()).optional().catch(void 0)
+  }).optional().catch(void 0),
+  stealthMode: import_zod.z.object({
+    enabled: import_zod.z.boolean()
+  }).optional().catch(void 0)
+}).passthrough().and(
+  import_zod.z.union([
+    import_zod.z.object({
+      authSessions: import_zod.z.object({ enabled: import_zod.z.literal(false) }),
+      apiAccess: import_zod.z.object({
+        enabled: import_zod.z.literal(false)
+      })
+    }),
+    import_zod.z.object({
+      authSessions: import_zod.z.union([
+        import_zod.z.object({ enabled: import_zod.z.literal(false) }),
+        import_zod.z.object({
+          enabled: import_zod.z.literal(true),
+          type: import_zod.z.enum(["MANUAL", "API"]),
+          startUrl: import_zod.z.string().optional(),
+          finishUrl: import_zod.z.string().optional()
+        })
+      ]),
+      apiAccess: import_zod.z.object({
+        enabled: import_zod.z.literal(true)
+      })
+    })
+  ])
+);
+var intunedSettingsFileNames = [
+  "Intuned.json",
+  "Intuned.jsonc",
+  "Intuned.yaml",
+  "Intuned.yml",
+  "Intuned.toml"
+];
+var intunedSettingsParsers = {
+  "Intuned.json": JSON.parse,
+  "Intuned.jsonc": JSONC.parse,
+  "Intuned.yaml": YAML.parse,
+  "Intuned.yml": YAML.parse,
+  "Intuned.toml": TOML.parse
+};
+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, import_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, import_neverthrow.err)(
+      `${settingsFile.name} is not valid:
+${formattedError}
+Please fix the errors and try again.`
+    );
+  }
+  return (0, import_neverthrow.ok)(parseResult.data);
+}
+function getIntunedSettingsFileSync() {
+  for (const fileName of intunedSettingsFileNames) {
+    const filePath = import_path.default.join(process.cwd(), fileName);
+    if (fs.existsSync(filePath)) {
+      return (0, import_neverthrow.ok)({
+        name: fileName,
+        path: filePath,
+        parse: intunedSettingsParsers[fileName]
+      });
+    }
+  }
+  return (0, import_neverthrow.err)("No Intuned settings file found.");
+}
+
+// src/common/binStartupScript.ts
+import_dotenv.default.config({
+  path: `.env`
+});
+function isStealthModeEnabled() {
+  try {
+    const settingsResult = loadIntunedJsonSync();
+    if (settingsResult.isErr()) {
+      console.error(`Warning: Failed to load Intuned settings: ${settingsResult.error}
+Stealth mode will not be enabled.`);
+      return false;
+    }
+    return settingsResult.value.stealthMode?.enabled === true;
+  } catch (error) {
+    console.error("Error reading Intuned.json:", error.message);
+    return false;
+  }
+}
+try {
+  if (isStealthModeEnabled()) {
+    const currentNodeModules = path2.resolve(process.cwd(), "node_modules");
+    process.env.NODE_PATH = process.env.NODE_PATH ? `${process.env.NODE_PATH}:${currentNodeModules}` : currentNodeModules;
+    require("module").Module._initPaths();
+    if (process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH) {
+      require(process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH);
+    }
+  }
+} catch (e) {
+  console.error("Failed to apply stealth mode");
+}

package/dist/common/cleanEnvironmentVariables.d.ts

@@ -0,0 +1,3 @@
+declare function cleanEnvironmentVariables(): void;
+
+export { cleanEnvironmentVariables };

package/dist/common/cleanEnvironmentVariables.js

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/common/cleanEnvironmentVariables.ts
+var cleanEnvironmentVariables_exports = {};
+__export(cleanEnvironmentVariables_exports, {
+  cleanEnvironmentVariables: () => cleanEnvironmentVariables
+});
+module.exports = __toCommonJS(cleanEnvironmentVariables_exports);
+function cleanEnvironmentVariables() {
+  Object.keys(process.env).filter((i) => {
+    if (i.toLocaleLowerCase().startsWith("npm")) {
+      return true;
+    }
+    if (i.toLocaleLowerCase().startsWith("fly") && i !== "FLY_ALLOC_ID") {
+      return true;
+    }
+  }).forEach((i) => delete process.env[i]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanEnvironmentVariables
+});

package/dist/common/constants.d.ts

@@ -0,0 +1,13 @@
+declare const API_FOLDER_NAME = "api";
+declare const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
+declare const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+declare const WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+declare const EXTENSION_PATH_ENV_VAR_KEY = "INTUNED_EXTENSION_PATH";
+declare const PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+declare const API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+declare const AUTH_TOKEN_ENV_VAR_KEY = "INTUNED_AUTH_TOKEN";
+declare const API_KEY_HEADER_NAME = "x-api-key";
+declare const API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+declare const CLI_ENV_VAR_KEY = "INTUNED_CLI";
+
+export { API_BASE_URL_ENV_VAR_KEY, API_FOLDER_NAME, API_KEY_ENV_VAR_KEY, API_KEY_HEADER_NAME, AUTH_SESSIONS_FOLDER_NAME, AUTH_SESSIONS_INSTANCES_FOLDER_NAME, AUTH_TOKEN_ENV_VAR_KEY, CLI_ENV_VAR_KEY, EXTENSION_PATH_ENV_VAR_KEY, PROJECT_ID_ENV_VAR_KEY, WORKSPACE_ID_ENV_VAR_KEY };

package/dist/common/constants.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/common/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  API_BASE_URL_ENV_VAR_KEY: () => API_BASE_URL_ENV_VAR_KEY,
+  API_FOLDER_NAME: () => API_FOLDER_NAME,
+  API_KEY_ENV_VAR_KEY: () => API_KEY_ENV_VAR_KEY,
+  API_KEY_HEADER_NAME: () => API_KEY_HEADER_NAME,
+  AUTH_SESSIONS_FOLDER_NAME: () => AUTH_SESSIONS_FOLDER_NAME,
+  AUTH_SESSIONS_INSTANCES_FOLDER_NAME: () => AUTH_SESSIONS_INSTANCES_FOLDER_NAME,
+  AUTH_TOKEN_ENV_VAR_KEY: () => AUTH_TOKEN_ENV_VAR_KEY,
+  CLI_ENV_VAR_KEY: () => CLI_ENV_VAR_KEY,
+  EXTENSION_PATH_ENV_VAR_KEY: () => EXTENSION_PATH_ENV_VAR_KEY,
+  PROJECT_ID_ENV_VAR_KEY: () => PROJECT_ID_ENV_VAR_KEY,
+  WORKSPACE_ID_ENV_VAR_KEY: () => WORKSPACE_ID_ENV_VAR_KEY
+});
+module.exports = __toCommonJS(constants_exports);
+var API_FOLDER_NAME = "api";
+var AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
+var AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+var WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+var EXTENSION_PATH_ENV_VAR_KEY = "INTUNED_EXTENSION_PATH";
+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 API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+var CLI_ENV_VAR_KEY = "INTUNED_CLI";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_BASE_URL_ENV_VAR_KEY,
+  API_FOLDER_NAME,
+  API_KEY_ENV_VAR_KEY,
+  API_KEY_HEADER_NAME,
+  AUTH_SESSIONS_FOLDER_NAME,
+  AUTH_SESSIONS_INSTANCES_FOLDER_NAME,
+  AUTH_TOKEN_ENV_VAR_KEY,
+  CLI_ENV_VAR_KEY,
+  EXTENSION_PATH_ENV_VAR_KEY,
+  PROJECT_ID_ENV_VAR_KEY,
+  WORKSPACE_ID_ENV_VAR_KEY
+});

package/dist/common/contextStorageStateHelpers.d.ts

@@ -0,0 +1,24 @@
+import * as playwright from 'playwright';
+import { RunApiStorageState } from '@intuned/runtime-interface';
+
+interface StorageEntry {
+    name: string;
+    value: string;
+}
+interface LocalStorageState {
+    origin: string;
+    localStorage: StorageEntry[];
+}
+interface SessionStorageState {
+    origin: string;
+    sessionStorage: StorageEntry[];
+}
+interface StorageState {
+    cookies?: playwright.Cookie[] | null;
+    origins?: LocalStorageState[] | null;
+    sessionStorage?: SessionStorageState[] | null;
+}
+declare function setStorageState(context: playwright.BrowserContext, state: RunApiStorageState): Promise<void>;
+declare function getStorageState(context: playwright.BrowserContext): Promise<RunApiStorageState>;
+
+export { type StorageState, getStorageState, setStorageState };

package/dist/common/contextStorageStateHelpers.js

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/common/contextStorageStateHelpers.ts
+var contextStorageStateHelpers_exports = {};
+__export(contextStorageStateHelpers_exports, {
+  getStorageState: () => getStorageState,
+  setStorageState: () => setStorageState
+});
+module.exports = __toCommonJS(contextStorageStateHelpers_exports);
+async function setStorageState(context, state) {
+  if ("cookies" in state && state.cookies) {
+    await context.addCookies(state.cookies);
+  }
+  const page = await context.newPage();
+  if ("origins" in state && state.origins) {
+    for (const originData of state.origins || []) {
+      const origin = originData.origin;
+      await page.route(
+        `${origin}/*`,
+        (route) => route.fulfill({
+          body: "<html><head><title>Set Storage</title></head><body><h1>Set Storage</h1></body></html>",
+          contentType: "text/html",
+          status: 200
+        })
+      );
+      try {
+        await page.goto(origin);
+        for (const item of originData.localStorage) {
+          await page.evaluate(
+            ([key, value]) => {
+              window.localStorage.setItem(key, value);
+            },
+            [item.name, item.value]
+          );
+        }
+      } finally {
+        await page.unroute(`${origin}/*`);
+      }
+    }
+  }
+  if ("sessionStorage" in state && state.sessionStorage) {
+    await context.addInitScript((storage) => {
+      for (const { origin, sessionStorage } of storage) {
+        if (window.location.origin === origin) {
+          for (const item of sessionStorage) {
+            const value = window.sessionStorage.getItem(item.name);
+            if (!value) {
+              window.sessionStorage.setItem(item.name, item.value);
+            }
+          }
+        }
+      }
+    }, state.sessionStorage);
+  }
+  await page.close();
+}
+async function getStorageState(context) {
+  const result = {
+    cookies: [],
+    origins: []
+  };
+  const storageState = await context.storageState();
+  result.cookies = storageState.cookies;
+  result.origins = storageState.origins;
+  const sessionDataList = [];
+  const pages = await context.pages();
+  for (const page of pages) {
+    if (page.isClosed()) continue;
+    try {
+      const sessionData = await page.evaluate(() => {
+        const items = { ...window.sessionStorage };
+        return {
+          origin: window.location.origin,
+          sessionStorage: Object.entries(items).map(([name, value]) => ({
+            name,
+            value
+          }))
+        };
+      });
+      sessionDataList.push(sessionData);
+    } catch (error) {
+      console.error("Error getting sessionStorage:", error);
+    }
+  }
+  result["sessionStorage"] = sessionDataList;
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStorageState,
+  setStorageState
+});

package/dist/common/jwtTokenManager.d.ts

@@ -0,0 +1,19 @@
+import fetch from 'cross-fetch';
+
+declare class JwtTokenManager {
+    private _token;
+    private tokenRefreshTimeout;
+    private refreshTokenPath;
+    constructor(refreshTokenPath: string);
+    get token(): string | undefined;
+    set token(newToken: string | undefined);
+    private get timeToRefresh();
+    private scheduleTokenRefresh;
+    private refreshToken;
+    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 };

package/dist/common/jwtTokenManager.js

@@ -0,0 +1,180 @@
+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);
+
+// src/common/jwtTokenManager.ts
+var jwtTokenManager_exports = {};
+__export(jwtTokenManager_exports, {
+  backendFunctionsTokenManager: () => backendFunctionsTokenManager,
+  callBackendFunctionWithToken: () => callBackendFunctionWithToken
+});
+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 {
+  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;
+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
+});

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

@@ -0,0 +1,11 @@
+import { Result } from 'neverthrow';
+import { Page, BrowserContext } from 'playwright';
+import { ExtendedRunApiParameters, RunApiResult, RunApiResultWithSessionOk, RunAutomationError } from '@intuned/runtime-interface';
+
+declare function runApi<ResultType = any>(input: ExtendedRunApiParameters & {
+    retrieveSession: true;
+}): Promise<RunApiResult<ResultType, RunApiResultWithSessionOk<ResultType>>>;
+declare function runApi<ResultType = any>(input: ExtendedRunApiParameters): Promise<RunApiResult<ResultType>>;
+declare function checkAuthSessionWithRetries(page: Page, context: BrowserContext, checkFn: (..._: any) => Promise<boolean>, retries?: number): Promise<Result<boolean, RunAutomationError>>;
+
+export { checkAuthSessionWithRetries, runApi };