@intuned/runtime-dev 0.0.1-testing.0 → 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/runtime/extendTimeout.js

@@ -14,13 +14,17 @@ function extendTimeout() {
   const {
     timeoutInfo
   } = context;
-  if (!timeoutInfo || timeoutInfo.timeoutTimestamp === undefined || timeoutInfo.timeoutDuration === undefined || timeoutInfo.extendTimeoutCallback === undefined) {
+  if (!timeoutInfo) {
     return;
   }
-  const newTimeoutStamp = Date.now() + timeoutInfo.timeoutDuration;
-  if (newTimeoutStamp - timeoutInfo.timeoutTimestamp < _DEBOUNCE_TIME) {
-    return;
+  if (timeoutInfo.timeoutTimestamp !== undefined && timeoutInfo.timeoutDuration !== undefined) {
+    const newTimeoutStamp = Date.now() + timeoutInfo.timeoutDuration;
+    if (newTimeoutStamp - timeoutInfo.timeoutTimestamp < _DEBOUNCE_TIME) {
+      return;
+    }
+    timeoutInfo.timeoutTimestamp = newTimeoutStamp;
+  }
+  if (timeoutInfo.extendTimeoutCallback !== undefined) {
+    void timeoutInfo.extendTimeoutCallback().catch(() => undefined);
   }
-  timeoutInfo.timeoutTimestamp = newTimeoutStamp;
-  void timeoutInfo.extendTimeoutCallback().catch(() => undefined);
 }

package/dist/runtime/index.d.ts

@@ -3,4 +3,5 @@ export { extendTimeout } from "./extendTimeout";
 export { runInfo } from "./runInfo";
 export { RunError } from "./RunError";
 export { requestMultipleChoice, requestOTP } from "./requestMoreInfo";
+export type { RequestMoreInfoDetails } from "./requestMoreInfo";
 export { getDownloadDirectoryPath } from "./downloadDirectory";

package/dist/runtime/requestMoreInfo.d.ts

@@ -14,4 +14,5 @@ interface RequestOtpReturnType extends RequestMoreInfoReturnTypeBase {
 declare const REQUEST_MORE_INFO_KEY: unique symbol;
 export declare function requestOTP(messageToUser: string): RequestOtpReturnType;
 export declare function requestMultipleChoice(messageToUser: string, choices: string[]): RequestMultipleChoiceReturnType;
+export type RequestMoreInfoDetails = RequestMultipleChoiceReturnType | RequestOtpReturnType;
 export {};