@intuned/runtime-dev 0.0.1-split.0 → 0.0.1-split.2

package/dist/common/Logger/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    const {
+      level,
+      timestamp,
+      message,
+      meta
+    } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+    if (meta === undefined) {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`);
+    } else {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message} ${format(meta)}\n`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/{src/common/Logger/Logger/types.ts → dist/common/Logger/Logger/types.d.ts}

@@ -1,9 +1,8 @@
 export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
 export type LogMetadata = Record<string | symbol, any>;
-
 export interface LogEntry {
-  level: LogLevel;
-  message: string;
-  timestamp: number;
-  meta?: LogMetadata;
+    level: LogLevel;
+    message: string;
+    timestamp: number;
+    meta?: LogMetadata;
 }

package/dist/common/Logger/Logger/types.js

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

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

@@ -0,0 +1,12 @@
+import { LogEntry, LogMetadata } from "./types";
+declare class Logger {
+    logFunction(entry: LogEntry): void;
+    private log;
+    trace(message: string, meta?: LogMetadata): void;
+    debug(message: string, meta?: LogMetadata): void;
+    info(message: string, meta?: LogMetadata): void;
+    warn(message: string, meta?: LogMetadata): void;
+    error(message: string, meta?: LogMetadata): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/common/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    const {
+      level,
+      timestamp,
+      message,
+      meta
+    } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+    if (meta === undefined) {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`);
+    } else {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message} ${format(meta)}\n`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/{src/common/Logger/types.ts → dist/common/Logger/types.d.ts}

@@ -1,9 +1,8 @@
 export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
 export type LogMetadata = Record<string | symbol, any>;
-
 export interface LogEntry {
-  level: LogLevel;
-  message: string;
-  timestamp: number;
-  meta?: LogMetadata;
+    level: LogLevel;
+    message: string;
+    timestamp: number;
+    meta?: LogMetadata;
 }

package/dist/common/Logger/types.js

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

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+import { Payload, RunInfo } from "../../runtime/export";
+export declare const asyncLocalStorage: AsyncLocalStorage<InternalRunInfo>;
+export declare function runWithContext<R, TArgs extends any[]>(contextData: InternalRunInfo, callback: (...args: TArgs) => R, ...args: TArgs): R;
+interface TimeoutInfo {
+    extendTimeoutCallback?: () => Promise<void>;
+    timeoutDuration?: number;
+    timeoutTimestamp?: number;
+}
+interface InternalRunInfo extends RunInfo {
+    extendedPayloads: Payload[];
+    timeoutInfo?: TimeoutInfo;
+}
+export declare function getExecutionContext(): InternalRunInfo | undefined;
+export {};

package/dist/common/asyncLocalStorage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncLocalStorage = void 0;
+exports.getExecutionContext = getExecutionContext;
+exports.runWithContext = runWithContext;
+var _async_hooks = require("async_hooks");
+const asyncLocalStorage = exports.asyncLocalStorage = new _async_hooks.AsyncLocalStorage();
+function runWithContext(contextData, callback, ...args) {
+  return asyncLocalStorage.run(contextData, callback, ...args);
+}
+function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+  return contextData;
+}

package/dist/common/cleanEnvironmentVariables.d.ts

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

package/dist/common/cleanEnvironmentVariables.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanEnvironmentVariables = cleanEnvironmentVariables;
+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]);
+}

package/dist/common/constants.d.ts

@@ -0,0 +1 @@
+export declare const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";

package/dist/common/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AUTH_SESSIONS_FOLDER_NAME = void 0;
+const AUTH_SESSIONS_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";

package/dist/common/contextStorageStateHelpers.d.ts

@@ -0,0 +1,15 @@
+import { BrowserContext } from "@intuned/playwright";
+import * as playwright from "@intuned/playwright-core";
+interface OriginSessionStorage {
+    origin: string;
+    sessionStorage: Array<{
+        name: string;
+        value: string;
+    }>;
+}
+export type IntunedStorageState = Exclude<playwright.BrowserContextOptions["storageState"], string> & {
+    sessionStorage?: OriginSessionStorage[];
+};
+export declare function getContextStorageState(context: BrowserContext): Promise<IntunedStorageState>;
+export declare function setContextStorageState(context: BrowserContext, storage: IntunedStorageState): Promise<void>;
+export {};

package/dist/common/contextStorageStateHelpers.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getContextStorageState = getContextStorageState;
+exports.setContextStorageState = setContextStorageState;
+function sessionStorageToArray(storage) {
+  const result = [];
+  for (const key in storage) {
+    result.push({
+      name: key,
+      value: storage[key]
+    });
+  }
+  return result;
+}
+async function getContextStorageState(context) {
+  const cookiesAndLocalStorage = await context.storageState();
+  const pages = await context.pages();
+  const pagesSessions = [];
+  for (const page of pages) {
+    const [origin, session] = await page.evaluate(() => [location.origin, sessionStorage]);
+    const transformed = sessionStorageToArray(session);
+    pagesSessions.push({
+      origin,
+      sessionStorage: transformed
+    });
+  }
+  return {
+    ...cookiesAndLocalStorage,
+    sessionStorage: pagesSessions
+  };
+}
+async function setContextStorageState(context, storage) {
+  await context.intunedSetStorageState(storage);
+  const sessionStorage = storage.sessionStorage;
+  await context.addInitScript(storage => {
+    for (const {
+      origin,
+      sessionStorage
+    } of storage) {
+      if (window.location.origin === origin) {
+        for (const item of sessionStorage) window.sessionStorage.setItem(item.name, item.value);
+      }
+    }
+  }, sessionStorage);
+}

package/dist/common/getPlaywrightConstructs.d.ts

@@ -0,0 +1,28 @@
+import * as playwright from "@intuned/playwright-core";
+import { IntunedStorageState } from "./contextStorageStateHelpers";
+interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+}
+interface GetPlaywrightConstructsOptions {
+    proxy?: Proxy;
+    headless?: boolean;
+    storageState?: IntunedStorageState;
+    downloadsPath: string;
+    userDataDir?: string;
+}
+export declare function getProductionPlaywrightConstructs({ proxy, headless, storageState, downloadsPath, }: GetPlaywrightConstructsOptions): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare function getPlaywrightConstructsForMode(mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless", cdpAddress: string | undefined, authSessionPath?: string): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare function loadAuthSessionToContext(context: playwright.BrowserContext, authSessionPath: string): Promise<void>;
+export declare function getRemotePlaywrightContext(cdpAddress: string): Promise<{
+    browser: playwright.Browser;
+    context: playwright.BrowserContext;
+}>;
+export {};

package/dist/common/getPlaywrightConstructs.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightConstructsForMode = getPlaywrightConstructsForMode;
+exports.getProductionPlaywrightConstructs = getProductionPlaywrightConstructs;
+exports.getRemotePlaywrightContext = getRemotePlaywrightContext;
+exports.loadAuthSessionToContext = loadAuthSessionToContext;
+var playwright = _interopRequireWildcard(require("@intuned/playwright-core"));
+var _fsExtra = _interopRequireWildcard(require("fs-extra"));
+var fs = _fsExtra;
+var _contextStorageStateHelpers = require("./contextStorageStateHelpers");
+var _path = _interopRequireWildcard(require("path"));
+var _fileUtils = require("../commands/common/utils/fileUtils");
+var _waitOn = _interopRequireDefault(require("wait-on"));
+var _runtime = require("../runtime");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 && Object.prototype.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; }
+async function createUserDirWithPreferences() {
+  const playwrightTempDir = await (0, _fsExtra.mkdtemp)("/tmp/pw-");
+  const userDir = (0, _path.join)(playwrightTempDir, "userdir");
+  const defaultDir = (0, _path.join)(userDir, "Default");
+  await (0, _fsExtra.mkdir)(defaultDir, {
+    recursive: true
+  });
+  const preferences = {
+    plugins: {
+      always_open_pdf_externally: true
+    }
+  };
+  await (0, _fsExtra.writeFile)((0, _path.join)(defaultDir, "Preferences"), JSON.stringify(preferences));
+  return userDir;
+}
+async function getProductionPlaywrightConstructs({
+  proxy,
+  headless = true,
+  storageState,
+  downloadsPath
+}) {
+  const extraArgs = ["--no-first-run", "--disable-sync", "--disable-translate", "--disable-features=TranslateUI", "--disable-features=NetworkService", "--lang=en"];
+  if (headless) {
+    extraArgs.push("--headless=new");
+  }
+  const executablePath = playwright.chromium.executablePath();
+  const chromium127Path = executablePath.replace("chromium-1117", "chromium-1124");
+  const isChrome127There = (0, _fsExtra.existsSync)(chromium127Path);
+  const userAgent = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${isChrome127There ? 127 : 125}.0.0.0 Safari/537.36`;
+  const userDataDir = await createUserDirWithPreferences();
+  const context = await playwright.chromium.launchPersistentContext(userDataDir, {
+    headless,
+    ignoreDefaultArgs: [...getChromiumLaunchArgsToIgnore(), "--headless"],
+    proxy,
+    executablePath: isChrome127There ? chromium127Path : executablePath,
+    args: extraArgs,
+    downloadsPath,
+    userAgent
+  });
+  context.once("close", async () => {
+    try {
+      await (0, _fsExtra.rm)(userDataDir, {
+        recursive: true,
+        force: true,
+        retryDelay: 1000,
+        maxRetries: 5
+      });
+    } catch (error) {
+      console.error("Failed to remove user data dir", error);
+    }
+  });
+  if (storageState) {
+    await (0, _contextStorageStateHelpers.setContextStorageState)(context, storageState);
+  }
+  const assetsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
+  await context.addInitScript({
+    path: assetsFile
+  });
+  let page = context.pages().at(0);
+  if (page) {
+    const scriptString = await (0, _fsExtra.readFile)(assetsFile, "utf8");
+    await page.evaluate(scriptString);
+  } else {
+    page = await context.newPage();
+  }
+  return {
+    page,
+    context
+  };
+}
+const getChromiumLaunchArgsToIgnore = () => ["--disable-field-trial-config", "--disable-background-networking", "--enable-features=NetworkService,NetworkServiceInProcess", "--disable-background-timer-throttling", "--disable-backgrounding-occluded-windows", "--disable-back-forward-cache", "--disable-breakpad", "--disable-client-side-phishing-detection", "--disable-component-extensions-with-background-pages", "--disable-component-update", "--no-default-browser-check", "--disable-default-apps", "--disable-dev-shm-usage", "--disable-extensions", "--disable-features=ImprovedCookieControls,LazyFrameLoading,GlobalMediaControls,DestroyProfileOnBrowserClose,MediaRouter,DialMediaRouteProvider,AcceptCHFrame,AutoExpandDetailsElement,CertificateTransparencyComponentUpdater,AvoidUnnecessaryBeforeUnloadCheckSync,Translate,TranslateUI", "--allow-pre-commit-input", "--disable-hang-monitor", "--disable-ipc-flooding-protection", "--disable-prompt-on-repost", "--disable-renderer-backgrounding", "--force-color-profile=srgb", "--metrics-recording-only", "--no-first-run", "--enable-automation", "--password-store=basic", "--use-mock-keychain", "--no-service-autorun", "--export-tagged-pdf", "--enable-use-zoom-for-dsf=false"];
+async function getPlaywrightConstructsForMode(mode, cdpAddress, authSessionPath) {
+  if (mode == "playwright-standalone") {
+    if (!cdpAddress) {
+      throw new Error("cdpAddress is required");
+    }
+    const {
+      context
+    } = await getRemotePlaywrightContext(cdpAddress);
+    if (!context) {
+      throw new Error("no context found");
+    }
+    const assetsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
+    await context.addInitScript({
+      path: assetsFile
+    });
+    const pages = await context.pages();
+    let page = null;
+    if (pages.length > 0) {
+      page = pages[0];
+      const scriptString = await fs.readFile(assetsFile, "utf8");
+      await page.evaluate(scriptString);
+    } else {
+      page = await context.newPage();
+    }
+    if (authSessionPath) {
+      await loadAuthSessionToContext(context, authSessionPath);
+    }
+    return {
+      page,
+      context
+    };
+  }
+  const downloadsPath = (0, _runtime.getDownloadDirectoryPath)();
+  if (mode === "playwright" || mode === "playwright-headless") {
+    const productionConstructs = await getProductionPlaywrightConstructs({
+      headless: mode === "playwright-headless",
+      downloadsPath
+    });
+    if (authSessionPath) {
+      await loadAuthSessionToContext(productionConstructs.context, authSessionPath);
+    }
+    return {
+      ...productionConstructs
+    };
+  }
+  throw "invalid mode";
+}
+async function loadAuthSessionToContext(context, authSessionPath) {
+  const fullPath = (0, _fileUtils.getFullPathInProject)(authSessionPath);
+  const data = await fs.readJson(fullPath);
+  await (0, _contextStorageStateHelpers.setContextStorageState)(context, data);
+}
+async function getRemotePlaywrightContext(cdpAddress) {
+  const playwright = await Promise.resolve().then(() => _interopRequireWildcard(require("@intuned/playwright-core")));
+  let browser = null;
+  if (!cdpAddress) {
+    throw new Error("cdpAddress is required");
+  }
+  const cdpAddressWithoutProtocol = cdpAddress.replace("http://", "").replace("https://", "").replace("localhost", "127.0.0.1");
+  try {
+    await (0, _waitOn.default)({
+      resources: [`http-get://${cdpAddressWithoutProtocol}/json/version`],
+      delay: 100,
+      interval: 100,
+      timeout: 5000,
+      tcpTimeout: 1000,
+      window: 1000
+    });
+  } catch (error) {
+    console.error("Failed to connect to the browser");
+    process.exit(128 + 9);
+  }
+  try {
+    browser = await playwright.chromium.connectOverCDP(cdpAddress);
+  } catch (e) {
+    console.log(e);
+    throw new Error("failed to connect to the browser");
+  }
+  const context = browser.contexts()[0];
+  return {
+    browser,
+    context
+  };
+}

package/dist/common/jwtTokenManager.d.ts

@@ -0,0 +1,16 @@
+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>;
+}
+export declare const backendFunctionsTokenManager: JwtTokenManager;
+export declare function callBackendFunctionWithToken(path: string, init?: Parameters<typeof fetch>[1]): Promise<Response>;
+export {};

package/dist/common/jwtTokenManager.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.backendFunctionsTokenManager = void 0;
+exports.callBackendFunctionWithToken = callBackendFunctionWithToken;
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var jwt = _interopRequireWildcard(require("jsonwebtoken"));
+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 && Object.prototype.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(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class JwtTokenManager {
+  constructor(refreshTokenPath) {
+    this.refreshTokenPath = refreshTokenPath;
+    this._token = undefined;
+  }
+  get token() {
+    return this._token;
+  }
+  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 * 1000;
+    const timeToRefresh = expiry - Date.now() - timeWindow;
+    return Math.max(timeToRefresh, timeWindow);
+  }
+  async scheduleTokenRefresh() {
+    var _process$env$RUN_ENVI;
+    if (((_process$env$RUN_ENVI = process.env.RUN_ENVIRONMENT) === null || _process$env$RUN_ENVI === void 0 ? void 0 : _process$env$RUN_ENVI.toLowerCase()) !== "authoring") return;
+    const timeToRefresh = this.timeToRefresh;
+    if (timeToRefresh === undefined) 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() {
+    var _process$env$RUN_ENVI2;
+    if (((_process$env$RUN_ENVI2 = process.env.RUN_ENVIRONMENT) === null || _process$env$RUN_ENVI2 === void 0 ? void 0 : _process$env$RUN_ENVI2.toLowerCase()) !== "authoring") return;
+    const res = await this.fetchWithToken(this.refreshTokenPath, {
+      method: "GET"
+    });
+    if (res.status === 401) {
+      return (0, _neverthrow.err)("Unauthorized");
+    }
+    const jsonResult = await _neverthrow.ResultAsync.fromPromise(res.json(), () => "not json");
+    if (jsonResult.isErr()) return;
+    const newToken = jsonResult.value.token;
+    if (newToken) this._token = newToken;
+  }
+  fetchWithToken(...[input, init]) {
+    const headers = new Headers(init === null || init === void 0 ? void 0 : init.headers);
+    headers.set("Authorization", `Bearer ${this.token}`);
+    return (0, _crossFetch.default)(input, {
+      ...init,
+      headers
+    });
+  }
+}
+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`);
+backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
+function callBackendFunctionWithToken(path, init) {
+  return backendFunctionsTokenManager.fetchWithToken(`${backendFunctionsPath}/${path}`, init);
+}

package/dist/common/settingsSchema.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod";
+export declare const settingsSchema: z.ZodObject<{
+    authSessions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    authSessions: {
+        enabled: boolean;
+    };
+}, {
+    authSessions?: {
+        enabled: boolean;
+    } | undefined;
+}>;
+export type IntunedSettings = z.infer<typeof settingsSchema>;

package/dist/common/settingsSchema.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.settingsSchema = void 0;
+var z = _interopRequireWildcard(require("zod"));
+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 && Object.prototype.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 authSessionsSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+const settingsSchema = exports.settingsSchema = z.object({
+  authSessions: authSessionsSchema
+});

package/dist/common/telemetry.d.ts

@@ -0,0 +1,3 @@
+import * as appInsights from "applicationinsights";
+export declare function initializeAppInsights(): void;
+export declare function getTelemetryClient(): appInsights.TelemetryClient | undefined;