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

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

@@ -0,0 +1,486 @@
+import type { IntunedStorageState } from "../contextStorageStateHelpers";
+import type { Payload } from "../../runtime/export";
+import type { Result } from "neverthrow";
+import type { RunAutomationError } from "./errors";
+import z from "zod";
+export interface PayloadToAppend {
+    apiName: string;
+    parameters: Record<string, any>;
+}
+export interface RunAutomationSuccessResult {
+    result: any;
+    status: number;
+    payloadToAppend: PayloadToAppend[] | null;
+    session?: IntunedStorageState;
+}
+export interface RunAutomationErrorResult {
+    error: string;
+    message: string;
+    status?: number;
+    details?: any;
+    [key: string]: any;
+}
+export type RunAutomationResult = RunAutomationSuccessResult | RunAutomationErrorResult;
+export interface RunAutomationResponse {
+    status: number;
+    body: RunAutomationResult;
+}
+export declare const runApiSessionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "file";
+    path: string;
+}, {
+    type: "file";
+    path: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"state">;
+    state: z.ZodType<{
+        cookies: {
+            name: string;
+            value: string;
+            domain: string;
+            path: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                name: string;
+                value: string;
+            }[];
+        }[];
+    } & {
+        sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+    }, z.ZodTypeDef, {
+        cookies: {
+            name: string;
+            value: string;
+            domain: string;
+            path: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                name: string;
+                value: string;
+            }[];
+        }[];
+    } & {
+        sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "state";
+    state: {
+        cookies: {
+            name: string;
+            value: string;
+            domain: string;
+            path: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                name: string;
+                value: string;
+            }[];
+        }[];
+    } & {
+        sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+    };
+}, {
+    type: "state";
+    state: {
+        cookies: {
+            name: string;
+            value: string;
+            domain: string;
+            path: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                name: string;
+                value: string;
+            }[];
+        }[];
+    } & {
+        sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+    };
+}>]>;
+export declare const runApiParametersSchema: z.ZodObject<{
+    functionsToken: z.ZodOptional<z.ZodString>;
+    automationFunction: z.ZodObject<{
+        name: z.ZodString;
+        params: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        params?: any;
+    }, {
+        name: string;
+        params?: any;
+    }>;
+    tracing: z.ZodDefault<z.ZodOptional<z.ZodDiscriminatedUnion<"enabled", [z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: false;
+    }, {
+        enabled: false;
+    }>, z.ZodObject<{
+        enabled: z.ZodLiteral<true>;
+        filePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        enabled: true;
+        filePath: string;
+    }, {
+        enabled: true;
+        filePath: string;
+    }>]>>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        session: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "file";
+            path: string;
+        }, {
+            type: "file";
+            path: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"state">;
+            state: z.ZodType<{
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            }, z.ZodTypeDef, {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        }, {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        }>]>;
+        runCheck: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        session: {
+            type: "file";
+            path: string;
+        } | {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        };
+        runCheck: boolean;
+    }, {
+        session: {
+            type: "file";
+            path: string;
+        } | {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        };
+        runCheck?: boolean | undefined;
+    }>>;
+    runOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"environment", [z.ZodObject<{
+        environment: z.ZodLiteral<"deployed">;
+        headless: z.ZodDefault<z.ZodBoolean>;
+        proxy: z.ZodOptional<z.ZodObject<{
+            server: z.ZodString;
+            username: z.ZodString;
+            password: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            server: string;
+            username: string;
+            password: string;
+        }, {
+            server: string;
+            username: string;
+            password: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        environment: "deployed";
+        headless: boolean;
+        proxy?: {
+            server: string;
+            username: string;
+            password: string;
+        } | undefined;
+    }, {
+        environment: "deployed";
+        headless?: boolean | undefined;
+        proxy?: {
+            server: string;
+            username: string;
+            password: string;
+        } | undefined;
+    }>, z.ZodObject<{
+        environment: z.ZodLiteral<"ide">;
+        cdpAddress: z.ZodString;
+        mode: z.ZodUnion<[z.ZodLiteral<"vanilla">, z.ZodLiteral<"playwright">, z.ZodLiteral<"playwright-standalone">, z.ZodLiteral<"playwright-headless">]>;
+    }, "strip", z.ZodTypeAny, {
+        mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless";
+        environment: "ide";
+        cdpAddress: string;
+    }, {
+        mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless";
+        environment: "ide";
+        cdpAddress: string;
+    }>]>>;
+    retrieveSession: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    automationFunction: {
+        name: string;
+        params?: any;
+    };
+    tracing: {
+        enabled: false;
+    } | {
+        enabled: true;
+        filePath: string;
+    };
+    runOptions: {
+        environment: "deployed";
+        headless: boolean;
+        proxy?: {
+            server: string;
+            username: string;
+            password: string;
+        } | undefined;
+    } | {
+        mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless";
+        environment: "ide";
+        cdpAddress: string;
+    };
+    retrieveSession: boolean;
+    functionsToken?: string | undefined;
+    auth?: {
+        session: {
+            type: "file";
+            path: string;
+        } | {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        };
+        runCheck: boolean;
+    } | undefined;
+}, {
+    automationFunction: {
+        name: string;
+        params?: any;
+    };
+    functionsToken?: string | undefined;
+    tracing?: {
+        enabled: false;
+    } | {
+        enabled: true;
+        filePath: string;
+    } | undefined;
+    auth?: {
+        session: {
+            type: "file";
+            path: string;
+        } | {
+            type: "state";
+            state: {
+                cookies: {
+                    name: string;
+                    value: string;
+                    domain: string;
+                    path: string;
+                    expires: number;
+                    httpOnly: boolean;
+                    secure: boolean;
+                    sameSite: "Strict" | "Lax" | "None";
+                }[];
+                origins: {
+                    origin: string;
+                    localStorage: {
+                        name: string;
+                        value: string;
+                    }[];
+                }[];
+            } & {
+                sessionStorage?: import("../contextStorageStateHelpers").OriginSessionStorage[] | undefined;
+            };
+        };
+        runCheck?: boolean | undefined;
+    } | undefined;
+    runOptions?: {
+        environment: "deployed";
+        headless?: boolean | undefined;
+        proxy?: {
+            server: string;
+            username: string;
+            password: string;
+        } | undefined;
+    } | {
+        mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless";
+        environment: "ide";
+        cdpAddress: string;
+    } | undefined;
+    retrieveSession?: boolean | undefined;
+}>;
+export type RunApiSession = z.infer<typeof runApiSessionSchema>;
+export type RunApiParameters = z.input<typeof runApiParametersSchema>;
+export type ExtendedRunApiParameters = RunApiParameters & {
+    abortSignal?: AbortSignal;
+};
+export type RunApiResultOk<R = any> = {
+    result: R;
+    extendedPayloads?: Payload[];
+};
+export type RunApiResultWithSessionOk<R = any> = RunApiResultOk<R> & {
+    session: IntunedStorageState;
+};
+export type RunApiResult<R = any, FullResult extends RunApiResultOk<R> = RunApiResultOk<R>> = Result<FullResult, RunAutomationError>;

package/dist/common/runApi/types.js

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

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 && 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 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, requestMultipleChoice, requestOTP, } from "./runtime";
+export { runWithContext, getExecutionContext, } from "./common/asyncLocalStorage";
+export { getDownloadDirectoryPath } from "./runtime/downloadDirectory";
+export { getProductionPlaywrightConstructs } from "./common/getPlaywrightConstructs";

package/dist/index.js

@@ -0,0 +1,69 @@
+"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");

package/dist/runtime/RunError.d.ts

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