@intuned/runtime-dev 0.1.0-test.10 → 0.1.0-test.12

package/dist/common/runApi/index.ts

@@ -0,0 +1,253 @@
+import { getDownloadDirectoryPath } from "../../runtime/downloadDirectory";
+import { getExecutionContext } from "../asyncLocalStorage";
+import * as fs from "fs-extra";
+import { backendFunctionsTokenManager } from "../jwtTokenManager";
+import { getContextStorageState, setContextStorageState } from "../contextStorageStateHelpers";
+import { remove } from "fs-extra";
+import { ok, err } from "neverthrow";
+import { AbortedError, ApiNotFoundError, AutomationError, InvalidApiError, InvalidCheckError, MaxLevelsExceededError } from "./errors.js";
+import { AUTH_SESSIONS_FOLDER_NAME } from "../constants";
+import { getPlaywrightConstructsForMode, getProductionPlaywrightConstructs } from "../getPlaywrightConstructs";
+import { runApiParametersSchema } from "./types.js";
+export * from "./types.js";
+export * from "./errors.js";
+export async function* runApiGenerator({
+  retrieveSession = false,
+  abortSignal,
+  ...input
+}) {
+  let traceStarted = false;
+  const {
+    automationFunction,
+    runOptions,
+    tracing,
+    auth,
+    functionsToken
+  } = runApiParametersSchema.parse(input);
+  backendFunctionsTokenManager.token = functionsToken;
+  const downloadsPath = getDownloadDirectoryPath();
+  let page;
+  let context;
+  if (runOptions.environment === "deployed") {
+    const {
+      headless,
+      proxy
+    } = runOptions;
+    ({
+      page,
+      context
+    } = await getProductionPlaywrightConstructs({
+      headless,
+      proxy,
+      downloadsPath,
+      storageState: auth === null || auth === void 0 ? void 0 : auth.session
+    }));
+  } else {
+    const {
+      mode,
+      cdpAddress
+    } = runOptions;
+    ({
+      page,
+      context
+    } = await getPlaywrightConstructsForMode(mode, cdpAddress, auth === null || auth === void 0 ? void 0 : auth.session));
+  }
+  const executionContext = getExecutionContext();
+  if (!executionContext) {
+    throw "";
+  }
+  async function saveTraceIfNeeded({
+    errorMessage
+  }) {
+    if (!tracing.enabled || !traceStarted) {
+      return;
+    }
+    try {
+      await context.tracing.stop({
+        path: tracing.filePath
+      });
+    } catch (error) {
+      console.log(errorMessage, error === null || error === void 0 ? void 0 : error.message);
+      await remove(tracing.filePath);
+    }
+  }
+  if (tracing.enabled) {
+    await context.tracing.start({
+      screenshots: true,
+      snapshots: true,
+      sources: true
+    });
+    traceStarted = true;
+  }
+  const abortSymbol = Symbol("abort");
+  const abortPromise = new Promise(resolve => {
+    if (!abortSignal) return;
+    abortSignal.addEventListener("abort", () => {
+      resolve(abortSymbol);
+    });
+  });
+  if (auth && auth.session.type === "state") {
+    await setContextStorageState(context, auth.session.state);
+  }
+  async function* runAutomation() {
+    var _getExecutionContext;
+    if (auth !== null && auth !== void 0 && auth.runCheck) {
+      if (!auth.session) {
+        return err({
+          code: "AuthRequiredError"
+        });
+      }
+      console.log("Running auth check");
+      const authCheckResult = await checkAuthSessionWithRetries(page, context, 2);
+      if (authCheckResult.isErr()) {
+        const error = authCheckResult.error;
+        if (["APINotFoundError", "InvalidAPIError"].includes(error.code)) {
+          return err(new InvalidCheckError(`Auth session check function failed`, error));
+        }
+        return authCheckResult;
+      }
+      if (!authCheckResult.value) {
+        return err({
+          code: "AuthCheckFailedError"
+        });
+      }
+    }
+    console.log("Running function", automationFunction.name);
+    const args = [...(automationFunction.params ? [automationFunction.params] : []), page, context];
+    const importResult = await importFunction(automationFunction.name);
+    if (importResult.isErr()) {
+      return importResult;
+    }
+    let result;
+    if (importResult.value.type === "async-generator") {
+      const generator = importResult.value.generator(...args);
+      let next = undefined;
+      while (true) {
+        const generatorResult = await generator.next(...(next ? [next] : []));
+        if (!generatorResult.done) {
+          next = yield generatorResult.value;
+          continue;
+        }
+        result = generatorResult.value;
+        break;
+      }
+    } else {
+      result = await importResult.value.func(...args);
+    }
+    return ok({
+      result,
+      extendedPayloads: (_getExecutionContext = getExecutionContext()) === null || _getExecutionContext === void 0 ? void 0 : _getExecutionContext.extendedPayloads,
+      session: retrieveSession ? await getContextStorageState(context) : undefined
+    });
+  }
+  try {
+    const generator = runAutomation();
+    let next = undefined;
+    while (true) {
+      const result = await Promise.race([generator.next(await next), abortPromise]);
+      if (result === abortSymbol) {
+        return err(new AbortedError());
+      }
+      if (!result.done) {
+        next = yield result.value;
+        continue;
+      }
+      return result.value;
+    }
+  } catch (error) {
+    console.log("run errored", error);
+    return err(new AutomationError(error));
+  } finally {
+    await saveTraceIfNeeded({
+      errorMessage: "failed to save trace"
+    });
+    await context.close();
+    await fs.remove(downloadsPath);
+  }
+}
+export async function runApi(params) {
+  const generator = runApiGenerator(params);
+  const {
+    value,
+    done
+  } = await generator.next();
+  if (done) {
+    return value;
+  }
+  return err(new InvalidApiError("Expected API to be async function, got async generator"));
+}
+export async function checkAuthSessionWithRetries(page, context, retries = 3) {
+  if (retries === 0) {
+    return ok(false);
+  }
+  let tryNumber = 0;
+  console.log("Checking auth session with retries", `${AUTH_SESSIONS_FOLDER_NAME}/check`);
+  const importResult = await importFunction(`${AUTH_SESSIONS_FOLDER_NAME}/check`);
+  if (importResult.isErr()) {
+    return err(importResult.error);
+  }
+  if (importResult.value.type !== "async") {
+    return err(new InvalidCheckError("Check function is not an async function"));
+  }
+  const check = importResult.value.func;
+  while (retries > tryNumber) {
+    const result = await check(page, context);
+    if (result) return ok(true);
+    tryNumber++;
+  }
+  return ok(false);
+}
+async function importFunction(path) {
+  const functionNameParts = path.split("/");
+  const functionNameDepth = functionNameParts.length;
+  try {
+    let imported = undefined;
+    switch (functionNameDepth) {
+      case 1:
+        imported = await import(`../../../${functionNameParts[0]}.ts`);
+        break;
+      case 2:
+        imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}.ts`);
+        break;
+      case 3:
+        imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}.ts`);
+        break;
+      case 4:
+        imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}.ts`);
+        break;
+      case 5:
+        imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}.ts`);
+        break;
+      case 6:
+        imported = await import(`../../../${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}/${functionNameParts[5]}.ts`);
+        break;
+      default:
+        return err(new MaxLevelsExceededError(5));
+    }
+    if (!imported || !imported.default || !imported.default.constructor) {
+      return err(new InvalidApiError("API file path does not have a default export"));
+    }
+    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
+      return ok({
+        type: "async-generator",
+        generator: imported.default
+      });
+    }
+    if (imported.default.constructor.name === "AsyncFunction") {
+      return ok({
+        type: "async",
+        func: imported.default
+      });
+    }
+    return err(new InvalidApiError("API file path does not have a default async function/generator export"));
+  } catch (error) {
+    if (error.message.includes("Unknown variable dynamic import")) {
+      return err(new ApiNotFoundError(path));
+    }
+    if ((error === null || error === void 0 ? void 0 : error.code) === "ERR_MODULE_NOT_FOUND") {
+      console.log("API not found", error);
+      return err(new ApiNotFoundError(path));
+    }
+    throw error;
+  }
+}

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

@@ -1,7 +1,7 @@
 import type { IntunedStorageState } from "../contextStorageStateHelpers";
 import type { Payload } from "../../runtime/export";
 import type { Result } from "neverthrow";
-import type { RunAutomationError } from "./errors";
+import type { RunAutomationError } from "./errors.js";
 import z from "zod";
 export interface PayloadToAppend {
     apiName: string;

package/dist/common/runApi/types.js

@@ -1,50 +1,57 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+import z from "zod";
+export const runApiSessionSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("file"),
+        path: z.string(),
+    }),
+    z.object({
+        type: z.literal("state"),
+        state: z.custom((v) => v),
+    }),
+]);
+export const runApiParametersSchema = z.object({
+    functionsToken: z.string().optional(),
+    automationFunction: z.object({
+        name: z.string(),
+        params: z.any().optional(),
+    }),
+    tracing: z
+        .discriminatedUnion("enabled", [
+        z.object({ enabled: z.literal(false) }),
+        z.object({ enabled: z.literal(true), filePath: z.string() }),
+    ])
+        .optional()
+        .default({ enabled: false }),
+    auth: z
+        .object({
+        session: runApiSessionSchema,
+        runCheck: z.boolean().default(false),
+    })
+        .optional(),
+    runOptions: z
+        .discriminatedUnion("environment", [
+        z.object({
+            environment: z.literal("deployed"),
+            headless: z.boolean().default(true),
+            proxy: z
+                .object({
+                server: z.string(),
+                username: z.string(),
+                password: z.string(),
+            })
+                .optional(),
+        }),
+        z.object({
+            environment: z.literal("ide"),
+            cdpAddress: z.string(),
+            mode: z.union([
+                z.literal("vanilla"),
+                z.literal("playwright"),
+                z.literal("playwright-standalone"),
+                z.literal("playwright-headless"),
+            ]),
+        }),
+    ])
+        .default({ environment: "deployed" }),
+    retrieveSession: z.boolean().default(false),
 });
-exports.runApiSessionSchema = exports.runApiParametersSchema = void 0;
-var _zod = _interopRequireDefault(require("zod"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const runApiSessionSchema = exports.runApiSessionSchema = _zod.default.discriminatedUnion("type", [_zod.default.object({
-  type: _zod.default.literal("file"),
-  path: _zod.default.string()
-}), _zod.default.object({
-  type: _zod.default.literal("state"),
-  state: _zod.default.custom(v => v)
-})]);
-const runApiParametersSchema = exports.runApiParametersSchema = _zod.default.object({
-  functionsToken: _zod.default.string().optional(),
-  automationFunction: _zod.default.object({
-    name: _zod.default.string(),
-    params: _zod.default.any().optional()
-  }),
-  tracing: _zod.default.discriminatedUnion("enabled", [_zod.default.object({
-    enabled: _zod.default.literal(false)
-  }), _zod.default.object({
-    enabled: _zod.default.literal(true),
-    filePath: _zod.default.string()
-  })]).optional().default({
-    enabled: false
-  }),
-  auth: _zod.default.object({
-    session: runApiSessionSchema,
-    runCheck: _zod.default.boolean().default(false)
-  }).optional(),
-  runOptions: _zod.default.discriminatedUnion("environment", [_zod.default.object({
-    environment: _zod.default.literal("deployed"),
-    headless: _zod.default.boolean().default(true),
-    proxy: _zod.default.object({
-      server: _zod.default.string(),
-      username: _zod.default.string(),
-      password: _zod.default.string()
-    }).optional()
-  }), _zod.default.object({
-    environment: _zod.default.literal("ide"),
-    cdpAddress: _zod.default.string(),
-    mode: _zod.default.union([_zod.default.literal("vanilla"), _zod.default.literal("playwright"), _zod.default.literal("playwright-standalone"), _zod.default.literal("playwright-headless")])
-  })]).default({
-    environment: "deployed"
-  }),
-  retrieveSession: _zod.default.boolean().default(false)
-});

package/dist/common/runApi/types.ts

@@ -0,0 +1,43 @@
+import z from "zod";
+export const runApiSessionSchema = z.discriminatedUnion("type", [z.object({
+  type: z.literal("file"),
+  path: z.string()
+}), z.object({
+  type: z.literal("state"),
+  state: z.custom(v => v)
+})]);
+export const runApiParametersSchema = z.object({
+  functionsToken: z.string().optional(),
+  automationFunction: z.object({
+    name: z.string(),
+    params: z.any().optional()
+  }),
+  tracing: z.discriminatedUnion("enabled", [z.object({
+    enabled: z.literal(false)
+  }), z.object({
+    enabled: z.literal(true),
+    filePath: z.string()
+  })]).optional().default({
+    enabled: false
+  }),
+  auth: z.object({
+    session: runApiSessionSchema,
+    runCheck: z.boolean().default(false)
+  }).optional(),
+  runOptions: z.discriminatedUnion("environment", [z.object({
+    environment: z.literal("deployed"),
+    headless: z.boolean().default(true),
+    proxy: z.object({
+      server: z.string(),
+      username: z.string(),
+      password: z.string()
+    }).optional()
+  }), z.object({
+    environment: z.literal("ide"),
+    cdpAddress: z.string(),
+    mode: z.union([z.literal("vanilla"), z.literal("playwright"), z.literal("playwright-standalone"), z.literal("playwright-headless")])
+  })]).default({
+    environment: "deployed"
+  }),
+  retrieveSession: z.boolean().default(false)
+});

package/dist/common/settingsSchema.js

@@ -1,17 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+import * as z from "zod";
+const authSessionsSchema = z
+    .object({
+    enabled: z.boolean(),
+})
+    .optional()
+    .default({
+    enabled: false,
 });
-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
+export const settingsSchema = z.object({
+    authSessions: authSessionsSchema,
 });
-const settingsSchema = exports.settingsSchema = z.object({
-  authSessions: authSessionsSchema
-});

package/dist/common/settingsSchema.ts

@@ -0,0 +1,9 @@
+import * as z from "zod";
+const authSessionsSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+export const settingsSchema = z.object({
+  authSessions: authSessionsSchema
+});

package/dist/common/telemetry.js

@@ -1,32 +1,34 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getTelemetryClient = getTelemetryClient;
-exports.initializeAppInsights = initializeAppInsights;
-var appInsights = _interopRequireWildcard(require("applicationinsights"));
-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; }
+import * as appInsights from "applicationinsights";
 function gracefulShutdown() {
-  console.log("Shutting down, so flushing app insights.");
-  appInsights.defaultClient.flush();
-  process.exit();
+    console.log("Shutting down, so flushing app insights.");
+    appInsights.defaultClient.flush();
+    process.exit();
 }
-function initializeAppInsights() {
-  const appInsightsConnectionString = process.env.APPINSIGHTS_CONNECTION_STRING;
-  if (appInsightsConnectionString) {
-    console.log("Initializing app insights.");
-    appInsights.setup(appInsightsConnectionString).setAutoCollectConsole(true, true).setAutoCollectDependencies(true).setAutoCollectExceptions(true).setAutoCollectHeartbeat(true).setAutoCollectPerformance(true, true).setAutoCollectRequests(true).setAutoDependencyCorrelation(true).setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C).setSendLiveMetrics(true).setUseDiskRetryCaching(true);
-    appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRole] = "@intuned/sdk";
-    if (process.env.FLY_APP_NAME) {
-      appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRoleInstance] = process.env.FLY_APP_NAME;
+export function initializeAppInsights() {
+    const appInsightsConnectionString = process.env.APPINSIGHTS_CONNECTION_STRING;
+    if (appInsightsConnectionString) {
+        console.log("Initializing app insights.");
+        appInsights
+            .setup(appInsightsConnectionString)
+            .setAutoCollectConsole(true, true)
+            .setAutoCollectDependencies(true)
+            .setAutoCollectExceptions(true)
+            .setAutoCollectHeartbeat(true)
+            .setAutoCollectPerformance(true, true)
+            .setAutoCollectRequests(true)
+            .setAutoDependencyCorrelation(true)
+            .setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C)
+            .setSendLiveMetrics(true)
+            .setUseDiskRetryCaching(true);
+        appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRole] = "@intuned/sdk";
+        if (process.env.FLY_APP_NAME) {
+            appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRoleInstance] = process.env.FLY_APP_NAME;
+        }
+        process.on("SIGTERM", gracefulShutdown);
+        process.on("SIGINT", gracefulShutdown);
+        appInsights.start();
     }
-    process.on("SIGTERM", gracefulShutdown);
-    process.on("SIGINT", gracefulShutdown);
-    appInsights.start();
-  }
 }
-function getTelemetryClient() {
-  return appInsights.defaultClient;
-}
+export function getTelemetryClient() {
+    return appInsights.defaultClient;
+}

package/dist/common/telemetry.ts

@@ -0,0 +1,23 @@
+import * as appInsights from "applicationinsights";
+function gracefulShutdown() {
+  console.log("Shutting down, so flushing app insights.");
+  appInsights.defaultClient.flush();
+  process.exit();
+}
+export function initializeAppInsights() {
+  const appInsightsConnectionString = process.env.APPINSIGHTS_CONNECTION_STRING;
+  if (appInsightsConnectionString) {
+    console.log("Initializing app insights.");
+    appInsights.setup(appInsightsConnectionString).setAutoCollectConsole(true, true).setAutoCollectDependencies(true).setAutoCollectExceptions(true).setAutoCollectHeartbeat(true).setAutoCollectPerformance(true, true).setAutoCollectRequests(true).setAutoDependencyCorrelation(true).setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C).setSendLiveMetrics(true).setUseDiskRetryCaching(true);
+    appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRole] = "@intuned/sdk";
+    if (process.env.FLY_APP_NAME) {
+      appInsights.defaultClient.context.tags[appInsights.defaultClient.context.keys.cloudRoleInstance] = process.env.FLY_APP_NAME;
+    }
+    process.on("SIGTERM", gracefulShutdown);
+    process.on("SIGINT", gracefulShutdown);
+    appInsights.start();
+  }
+}
+export function getTelemetryClient() {
+  return appInsights.defaultClient;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { extendPayload, extendTimeout, runInfo, RunError, requestMultipleChoice, requestOTP, } from "./runtime";
-export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage";
-export { getDownloadDirectoryPath } from "./runtime/downloadDirectory";
-export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs";
+export { extendPayload, extendTimeout, runInfo, RunError, requestMultipleChoice, requestOTP, } from "./runtime/index.js";
+export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage/index.js";
+export { getDownloadDirectoryPath } from "./runtime/downloadDirectory.js";
+export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs.js";

package/dist/index.js

@@ -1,69 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "RunError", {
-  enumerable: true,
-  get: function () {
-    return _runtime.RunError;
-  }
-});
-Object.defineProperty(exports, "extendPayload", {
-  enumerable: true,
-  get: function () {
-    return _runtime.extendPayload;
-  }
-});
-Object.defineProperty(exports, "extendTimeout", {
-  enumerable: true,
-  get: function () {
-    return _runtime.extendTimeout;
-  }
-});
-Object.defineProperty(exports, "getDownloadDirectoryPath", {
-  enumerable: true,
-  get: function () {
-    return _downloadDirectory.getDownloadDirectoryPath;
-  }
-});
-Object.defineProperty(exports, "getExecutionContext", {
-  enumerable: true,
-  get: function () {
-    return _asyncLocalStorage.getExecutionContext;
-  }
-});
-Object.defineProperty(exports, "getProductionPlaywrightConstructs", {
-  enumerable: true,
-  get: function () {
-    return _getPlaywrightConstructs.getProductionPlaywrightConstructs;
-  }
-});
-Object.defineProperty(exports, "requestMultipleChoice", {
-  enumerable: true,
-  get: function () {
-    return _runtime.requestMultipleChoice;
-  }
-});
-Object.defineProperty(exports, "requestOTP", {
-  enumerable: true,
-  get: function () {
-    return _runtime.requestOTP;
-  }
-});
-Object.defineProperty(exports, "runInfo", {
-  enumerable: true,
-  get: function () {
-    return _runtime.runInfo;
-  }
-});
-Object.defineProperty(exports, "runWithContext", {
-  enumerable: true,
-  get: function () {
-    return _asyncLocalStorage.runWithContext;
-  }
-});
-var _runtime = require("./runtime");
-var _asyncLocalStorage = require("./common/asyncLocalStorage");
-var _downloadDirectory = require("./runtime/downloadDirectory");
-var _getPlaywrightConstructs = require("./common/getPlaywrightConstructs");
+export { extendPayload, extendTimeout, runInfo, RunError, requestMultipleChoice, requestOTP, } from "./runtime/index.js";
+export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage/index.js";
+export { getDownloadDirectoryPath } from "./runtime/downloadDirectory.js";
+export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs.js";

package/dist/index.ts

@@ -0,0 +1,4 @@
+export { extendPayload, extendTimeout, runInfo, RunError, requestMultipleChoice, requestOTP } from "./runtime/index.js";
+export { runWithContext, getExecutionContext } from "./common/asyncLocalStorage/index.js";
+export { getDownloadDirectoryPath } from "./runtime/downloadDirectory.js";
+export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs.js";

package/dist/runtime/RunError.d.ts

@@ -1,4 +1,4 @@
-import { RunErrorOptions } from "./export";
+import { RunErrorOptions } from "./export.js";
 export declare class RunError extends Error {
     options: RunErrorOptions;
     constructor(message: string, options?: RunErrorOptions);

package/dist/runtime/RunError.js

@@ -1,19 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.RunError = void 0;
-class RunError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.message = message;
-    this.name = "USER_GENERATED_ERROR";
-    this.options = options ?? {
-      retryable: false
-    };
-    Object.setPrototypeOf(this, RunError.prototype);
-  }
+export class RunError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.message = message;
+        this.name = "USER_GENERATED_ERROR";
+        this.options = options ?? {
+            retryable: false,
+        };
+        Object.setPrototypeOf(this, RunError.prototype);
+    }
 }
-exports.RunError = RunError;
-new RunError("", {});
+new RunError("", {});