@intuned/runtime-dev 1.3.18-interface.2 → 1.3.18-interface.4

package/dist/common/settingsSchema.d.ts

@@ -0,0 +1,533 @@
+import * as z from "zod";
+export declare const captchaSolverSettingsSchema: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodOptional<z.ZodNumber>;
+    cloudflare: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    googleRecaptchaV2: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    googleRecaptchaV3: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    awscaptcha: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    hcaptcha: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    funcaptcha: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    geetest: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    lemin: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>;
+    customCaptcha: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        imageLocators: z.ZodArray<z.ZodString, "many">;
+        submitLocators: z.ZodArray<z.ZodString, "many">;
+        inputLocators: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        imageLocators: string[];
+        submitLocators: string[];
+        inputLocators: string[];
+    }, {
+        enabled: boolean;
+        imageLocators: string[];
+        submitLocators: string[];
+        inputLocators: string[];
+    }>>;
+    text: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        labelLocators: z.ZodArray<z.ZodString, "many">;
+        submitLocators: z.ZodArray<z.ZodString, "many">;
+        inputLocators: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        submitLocators: string[];
+        inputLocators: string[];
+        labelLocators: string[];
+    }, {
+        enabled: boolean;
+        submitLocators: string[];
+        inputLocators: string[];
+        labelLocators: string[];
+    }>>;
+    settings: z.ZodDefault<z.ZodObject<{
+        autoSolve: z.ZodDefault<z.ZodBoolean>;
+        solveDelay: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        autoSolve: boolean;
+        solveDelay: number;
+        maxRetries: number;
+        timeout: number;
+    }, {
+        autoSolve?: boolean | undefined;
+        solveDelay?: number | undefined;
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    settings: {
+        autoSolve: boolean;
+        solveDelay: number;
+        maxRetries: number;
+        timeout: number;
+    };
+    port?: number | undefined;
+    cloudflare?: {
+        enabled: boolean;
+    } | undefined;
+    googleRecaptchaV2?: {
+        enabled: boolean;
+    } | undefined;
+    googleRecaptchaV3?: {
+        enabled: boolean;
+    } | undefined;
+    awscaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    hcaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    funcaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    geetest?: {
+        enabled: boolean;
+    } | undefined;
+    lemin?: {
+        enabled: boolean;
+    } | undefined;
+    customCaptcha?: {
+        enabled: boolean;
+        imageLocators: string[];
+        submitLocators: string[];
+        inputLocators: string[];
+    } | undefined;
+    text?: {
+        enabled: boolean;
+        submitLocators: string[];
+        inputLocators: string[];
+        labelLocators: string[];
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    port?: number | undefined;
+    cloudflare?: {
+        enabled: boolean;
+    } | undefined;
+    googleRecaptchaV2?: {
+        enabled: boolean;
+    } | undefined;
+    googleRecaptchaV3?: {
+        enabled: boolean;
+    } | undefined;
+    awscaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    hcaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    funcaptcha?: {
+        enabled: boolean;
+    } | undefined;
+    geetest?: {
+        enabled: boolean;
+    } | undefined;
+    lemin?: {
+        enabled: boolean;
+    } | undefined;
+    customCaptcha?: {
+        enabled: boolean;
+        imageLocators: string[];
+        submitLocators: string[];
+        inputLocators: string[];
+    } | undefined;
+    text?: {
+        enabled: boolean;
+        submitLocators: string[];
+        inputLocators: string[];
+        labelLocators: string[];
+    } | undefined;
+    settings?: {
+        autoSolve?: boolean | undefined;
+        solveDelay?: number | undefined;
+        maxRetries?: number | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+}>>;
+export type CaptchaSolverSettings = z.infer<typeof captchaSolverSettingsSchema>;
+export type CaptchaSolverSettingsWithRunContext = CaptchaSolverSettings & {
+    workspaceId: string;
+    projectId: string;
+    baseUrl: string;
+    authentication: {
+        type: "apiKey";
+        apiKey: string;
+    } | {
+        type: "basic" | "bearer";
+        token?: string;
+    };
+};
+export declare const settingsSchema: z.ZodObject<{
+    authSessions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+    stealthMode: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+    captchaSolver: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodOptional<z.ZodNumber>;
+        cloudflare: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        googleRecaptchaV2: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        googleRecaptchaV3: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        awscaptcha: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        hcaptcha: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        funcaptcha: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        geetest: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        lemin: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled: boolean;
+        }>>;
+        customCaptcha: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            imageLocators: z.ZodArray<z.ZodString, "many">;
+            submitLocators: z.ZodArray<z.ZodString, "many">;
+            inputLocators: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        }, {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        }>>;
+        text: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            labelLocators: z.ZodArray<z.ZodString, "many">;
+            submitLocators: z.ZodArray<z.ZodString, "many">;
+            inputLocators: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        }, {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        }>>;
+        settings: z.ZodDefault<z.ZodObject<{
+            autoSolve: z.ZodDefault<z.ZodBoolean>;
+            solveDelay: z.ZodDefault<z.ZodNumber>;
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            autoSolve: boolean;
+            solveDelay: number;
+            maxRetries: number;
+            timeout: number;
+        }, {
+            autoSolve?: boolean | undefined;
+            solveDelay?: number | undefined;
+            maxRetries?: number | undefined;
+            timeout?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        settings: {
+            autoSolve: boolean;
+            solveDelay: number;
+            maxRetries: number;
+            timeout: number;
+        };
+        port?: number | undefined;
+        cloudflare?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV2?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV3?: {
+            enabled: boolean;
+        } | undefined;
+        awscaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        hcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        funcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        geetest?: {
+            enabled: boolean;
+        } | undefined;
+        lemin?: {
+            enabled: boolean;
+        } | undefined;
+        customCaptcha?: {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        } | undefined;
+        text?: {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+        cloudflare?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV2?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV3?: {
+            enabled: boolean;
+        } | undefined;
+        awscaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        hcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        funcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        geetest?: {
+            enabled: boolean;
+        } | undefined;
+        lemin?: {
+            enabled: boolean;
+        } | undefined;
+        customCaptcha?: {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        } | undefined;
+        text?: {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        } | undefined;
+        settings?: {
+            autoSolve?: boolean | undefined;
+            solveDelay?: number | undefined;
+            maxRetries?: number | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    authSessions: {
+        enabled: boolean;
+    };
+    stealthMode: {
+        enabled: boolean;
+    };
+    captchaSolver?: {
+        enabled: boolean;
+        settings: {
+            autoSolve: boolean;
+            solveDelay: number;
+            maxRetries: number;
+            timeout: number;
+        };
+        port?: number | undefined;
+        cloudflare?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV2?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV3?: {
+            enabled: boolean;
+        } | undefined;
+        awscaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        hcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        funcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        geetest?: {
+            enabled: boolean;
+        } | undefined;
+        lemin?: {
+            enabled: boolean;
+        } | undefined;
+        customCaptcha?: {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        } | undefined;
+        text?: {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        } | undefined;
+    } | undefined;
+}, {
+    authSessions?: {
+        enabled: boolean;
+    } | undefined;
+    stealthMode?: {
+        enabled: boolean;
+    } | undefined;
+    captchaSolver?: {
+        enabled?: boolean | undefined;
+        port?: number | undefined;
+        cloudflare?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV2?: {
+            enabled: boolean;
+        } | undefined;
+        googleRecaptchaV3?: {
+            enabled: boolean;
+        } | undefined;
+        awscaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        hcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        funcaptcha?: {
+            enabled: boolean;
+        } | undefined;
+        geetest?: {
+            enabled: boolean;
+        } | undefined;
+        lemin?: {
+            enabled: boolean;
+        } | undefined;
+        customCaptcha?: {
+            enabled: boolean;
+            imageLocators: string[];
+            submitLocators: string[];
+            inputLocators: string[];
+        } | undefined;
+        text?: {
+            enabled: boolean;
+            submitLocators: string[];
+            inputLocators: string[];
+            labelLocators: string[];
+        } | undefined;
+        settings?: {
+            autoSolve?: boolean | undefined;
+            solveDelay?: number | undefined;
+            maxRetries?: number | undefined;
+            timeout?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type IntunedSettings = z.infer<typeof settingsSchema>;

package/dist/common/settingsSchema.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.settingsSchema = exports.captchaSolverSettingsSchema = 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 && {}.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 baseCaptchaSchema = z.object({
+  enabled: z.boolean()
+});
+const customCaptchaSchema = baseCaptchaSchema.extend({
+  imageLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+const textCaptchaSchema = baseCaptchaSchema.extend({
+  labelLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+const captchaSolverSolveSettingsSchema = z.object({
+  autoSolve: z.boolean().default(true),
+  solveDelay: z.number().min(0).default(2000),
+  maxRetries: z.number().min(0).default(3),
+  timeout: z.number().min(0).default(30000)
+});
+const captchaSolverSettingsSchema = exports.captchaSolverSettingsSchema = z.object({
+  enabled: z.boolean().default(false),
+  port: z.number().int().min(1).max(65535).optional(),
+  cloudflare: baseCaptchaSchema.optional(),
+  googleRecaptchaV2: baseCaptchaSchema.optional(),
+  googleRecaptchaV3: baseCaptchaSchema.optional(),
+  awscaptcha: baseCaptchaSchema.optional(),
+  hcaptcha: baseCaptchaSchema.optional(),
+  funcaptcha: baseCaptchaSchema.optional(),
+  geetest: baseCaptchaSchema.optional(),
+  lemin: baseCaptchaSchema.optional(),
+  customCaptcha: customCaptchaSchema.optional(),
+  text: textCaptchaSchema.optional(),
+  settings: captchaSolverSolveSettingsSchema.default(captchaSolverSolveSettingsSchema.parse({}))
+}).default({});
+const authSessionsSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+const stealthModeSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+const settingsSchema = exports.settingsSchema = z.object({
+  authSessions: authSessionsSchema,
+  stealthMode: stealthModeSchema,
+  captchaSolver: captchaSolverSettingsSchema.optional()
+});

package/dist/common/setupContextHook.d.ts

@@ -0,0 +1,16 @@
+import type * as playwright from "playwright";
+import { type Err, type Ok } from "neverthrow";
+import { ImportFunction, type RunAutomationError } from "@intuned/runtime-interface";
+export type InitializeContextHookOptions = {
+    apiName: string;
+    apiParameters: any;
+    cdpUrl: string;
+};
+export type SetupContextHook = (options: InitializeContextHookOptions) => Promise<{
+    page: playwright.Page | null;
+    context: playwright.BrowserContext;
+    cleanup?: () => Promise<void>;
+} | null>;
+export declare function loadSetupContextHook({ importFunction, }: {
+    importFunction: ImportFunction;
+}): Promise<Ok<SetupContextHook | null, any> | Err<any, RunAutomationError>>;

package/dist/common/setupContextHook.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSetupContextHook = loadSetupContextHook;
+var _neverthrow = require("neverthrow");
+var _importUsingImportFunction = require("./runApi/importUsingImportFunction");
+var _runtimeInterface = require("@intuned/runtime-interface");
+const setupContextHookPath = "hooks/setupContext";
+async function loadSetupContextHook({
+  importFunction
+}) {
+  const importedFunctionResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
+    path: setupContextHookPath,
+    importFunction
+  });
+  if (importedFunctionResult.isErr() && importedFunctionResult.error instanceof _runtimeInterface.ApiNotFoundError) {
+    return (0, _neverthrow.ok)(null);
+  }
+  return importedFunctionResult;
+}

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;

package/dist/common/telemetry.js

@@ -0,0 +1,32 @@
+"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 && {}.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 gracefulShutdown() {
+  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;
+    }
+    process.on("SIGTERM", gracefulShutdown);
+    process.on("SIGINT", gracefulShutdown);
+    appInsights.start();
+  }
+}
+function getTelemetryClient() {
+  return appInsights.defaultClient;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { extendPayload, extendTimeout, runInfo, RunError, getAuthSessionParameters, attemptStore, persistentStore, getAiGatewayConfig, } from "./runtime";
+export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage";
+export { getDownloadDirectoryPath } from "./runtime/downloadDirectory";
+export { waitForCaptchaSolve, withWaitForCaptchaSolve, onCaptchaEvent, onceCaptchaEvent, removeCaptchaEventListener, pauseCaptchaSolver, resumeCaptchaSolver, } from "./runtime/captcha";