@intuned/runtime-dev 0.0.1 → 0.1.0-test.0

package/dist/commands/ts-check.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+"use strict";
+
+var ts = _interopRequireWildcard(require("typescript"));
+var _commander = require("commander");
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _webTemplate = require("./common/utils/webTemplate");
+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; }
+_commander.program.description("Check TypeScript types in the project").allowUnknownOption().action(async () => {
+  await (0, _webTemplate.moveWebTemplateFiles)();
+  const templateTsConfig = path.resolve(__dirname, "..", "..", "template.tsconfig.json");
+  await fs.copy(templateTsConfig, "./intuned/WebTemplate/tsconfig.json");
+  checkTypes();
+});
+function checkTypes() {
+  const configPath = ts.findConfigFile("./intuned/WebTemplate", ts.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    console.error("Could not find a valid 'tsconfig.json'.");
+    process.exit(1);
+  }
+  const readConfigResult = ts.readConfigFile(configPath, ts.sys.readFile);
+  const config = readConfigResult.config;
+  const parseConfigHost = {
+    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    readDirectory: ts.sys.readDirectory,
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile
+  };
+  const parsed = ts.parseJsonConfigFileContent(config, parseConfigHost, "./intuned");
+  const program = ts.createProgram(parsed.fileNames, parsed.options);
+  const emitResult = program.emit();
+  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  allDiagnostics.forEach(diagnostic => {
+    if (diagnostic.file) {
+      const {
+        line,
+        character
+      } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+    } else {
+      console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+  if (allDiagnostics.length === 0) {
+    console.log("✨ TypeScript type checking passed without errors.");
+  } else {
+    console.error("Errors found during TypeScript type checking.");
+    process.exit(1);
+  }
+}
+_commander.program.parse(process.argv);

package/dist/common/Logger/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/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;
+}
+export 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,14 @@
+import { BrowserContext } from "@intuned/playwright";
+import * as playwright from "@intuned/playwright-core";
+export 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>;

package/dist/common/contextStorageStateHelpers.js

@@ -0,0 +1,50 @@
+"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 = context.pages();
+  const pagesSessions = [];
+  for (const page of pages) {
+    try {
+      const [origin, session] = await page.evaluate(() => [location.origin, sessionStorage]);
+      const transformed = sessionStorageToArray(session);
+      pagesSessions.push({
+        origin,
+        sessionStorage: transformed
+      });
+    } catch (e) {}
+  }
+  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,30 @@
+import * as playwright from "@intuned/playwright-core";
+import type { RunApiSession } from "./runApi";
+interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+}
+interface GetPlaywrightConstructsOptions {
+    proxy?: Proxy;
+    headless?: boolean;
+    storageState?: RunApiSession;
+    downloadsPath: 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, authSession?: RunApiSession): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+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 {};

package/dist/common/getPlaywrightConstructs.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightConstructsForMode = getPlaywrightConstructsForMode;
+exports.getProductionPlaywrightConstructs = getProductionPlaywrightConstructs;
+exports.getRemotePlaywrightContext = getRemotePlaywrightContext;
+exports.loadSessionToContext = loadSessionToContext;
+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 loadSessionToContext({
+      context,
+      session: 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, authSession) {
+  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 (authSession) {
+      await loadSessionToContext({
+        context,
+        session: authSession
+      });
+    }
+    return {
+      page,
+      context
+    };
+  }
+  const downloadsPath = (0, _runtime.getDownloadDirectoryPath)();
+  if (mode === "playwright" || mode === "playwright-headless") {
+    const productionConstructs = await getProductionPlaywrightConstructs({
+      headless: mode === "playwright-headless",
+      downloadsPath
+    });
+    if (authSession) {
+      await loadSessionToContext({
+        context: productionConstructs.context,
+        session: authSession
+      });
+    }
+    return {
+      ...productionConstructs
+    };
+  }
+  throw "invalid mode";
+}
+async function loadSessionToContext({
+  context,
+  session
+}) {
+  let sessionToLoad;
+  if (session.type === "state") {
+    sessionToLoad = session.state;
+  } else {
+    const fullPath = (0, _fileUtils.getFullPathInProject)(session.path);
+    sessionToLoad = await fs.readJson(fullPath);
+  }
+  await (0, _contextStorageStateHelpers.setContextStorageState)(context, sessionToLoad);
+}
+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 {};