@intuned/runtime-dev 0.0.1-split.0

package/WebTemplate/controllers/authSessions/create.ts

@@ -0,0 +1,128 @@
+import { authSessionsContextsStore } from "./store";
+import { AUTH_SESSIONS_FOLDER_NAME } from "@intuned/runtime/dist/common/constants";
+import { getDownloadDirectoryPath } from "@intuned/runtime";
+import { getProductionPlaywrightConstructs } from "../../../src/common/getPlaywrightConstructs";
+import { callFunction, getTraceFilePath, isHeadless } from "../../utils";
+import * as fs from "fs-extra";
+import { getContextStorageState } from "@intuned/runtime/dist/common/contextStorageStateHelpers";
+
+export async function createAuthSession({
+  parameters,
+  operationId,
+  mode,
+  proxy,
+  saveTrace,
+}: {
+  operationId: string;
+  mode: "async" | "sync";
+  parameters: object | null | undefined;
+  proxy?: {
+    server: string;
+    username: string;
+    password: string;
+  };
+  saveTrace: boolean;
+}) {
+  const isAuthSessionEnabled = (await fs.readJSON("./Intuned.json"))
+    .authSessions?.enabled;
+
+  if (!isAuthSessionEnabled) {
+    return {
+      status: 400,
+      body: {
+        error: "Invalid Request",
+        message: "auth sessions are not enabled",
+      },
+    };
+  }
+
+  if (mode !== "async") {
+    return {
+      status: 400,
+      body: {
+        error: "Invalid Request",
+        message: "only async mode is supported",
+      },
+    };
+  }
+
+  if (authSessionsContextsStore.has(operationId)) {
+    return {
+      status: 400,
+      body: {
+        error: "Invalid Request",
+        message:
+          "operation id already exists, please use a different one, or kill the existing operation, and try again",
+      },
+    };
+  }
+  const downloadsPath = getDownloadDirectoryPath();
+  const headless = isHeadless();
+  const { page, context } = await getProductionPlaywrightConstructs({
+    headless,
+    proxy,
+    downloadsPath,
+  });
+
+  try {
+    if (saveTrace) {
+      try {
+        await context.tracing.start({ screenshots: true, snapshots: true });
+      } catch (error) {
+        console.error("Error starting trace", error);
+      }
+    }
+
+    const operationGenerator = await callFunction(
+      AUTH_SESSIONS_FOLDER_NAME,
+      "create",
+      [parameters ?? {}, page, context]
+    );
+
+    await fs.remove(downloadsPath);
+
+    const result = await operationGenerator.next();
+
+    if (result.done) {
+      if (saveTrace) {
+        try {
+          const traceFilePath = getTraceFilePath(operationId);
+          await context.tracing.stop({ path: traceFilePath });
+        } catch (error) {
+          console.error("Error stopping trace", error);
+        }
+      }
+      const fullSessionState = await getContextStorageState(context);
+      await context.close();
+
+      return {
+        status: 200,
+        body: { ...fullSessionState, status: 200 },
+      };
+    }
+
+    authSessionsContextsStore.set(operationId, {
+      done: false,
+      generator: operationGenerator,
+      context,
+      requestInfo: result.value,
+      saveTrace,
+    });
+
+    return {
+      status: 200,
+      body: result.value,
+    };
+  } catch (e) {
+    if (saveTrace) {
+      try {
+        const traceFilePath = getTraceFilePath(operationId);
+        await context.tracing.stop({ path: traceFilePath });
+      } catch (error) {
+        console.error("Error stopping trace", error);
+      }
+    }
+
+    throw e;
+  }
+}

package/WebTemplate/controllers/authSessions/index.ts

@@ -0,0 +1,41 @@
+import { createAuthSession } from "./create";
+import { makeEndpointControllers } from "../controllers";
+import { checkAuthSession } from "./check";
+import { killAuthSessionOperation } from "./killOperation";
+import { resumeAuthSessionOperation } from "./resumeOperation";
+
+export const {
+  sync: createAuthSessionController,
+  async: createAuthSessionAsyncController,
+} = makeEndpointControllers({
+  requestId: (req) => `createAuthSession ${req.body.operationId}`,
+  handler: createAuthSession,
+  parameters: (req) => [req.body],
+});
+
+export const {
+  sync: checkAuthSessionController,
+  async: checkAuthSessionAsyncController,
+} = makeEndpointControllers({
+  requestId: "checkAuthSession",
+  handler: checkAuthSession,
+  parameters: (req) => [req.body],
+});
+
+export const {
+  sync: killAuthSessionOperationController,
+  async: killAuthSessionOperationAsyncController,
+} = makeEndpointControllers({
+  requestId: (req) => `killAuthSessionOperation ${req.body.operationId}`,
+  handler: killAuthSessionOperation,
+  parameters: (req) => [req.body],
+});
+
+export const {
+  sync: resumeAuthSessionOperationController,
+  async: resumeAuthSessionOperationAsyncController,
+} = makeEndpointControllers({
+  requestId: (req) => `resumeAuthSessionOperation ${req.body.operationId}`,
+  handler: resumeAuthSessionOperation,
+  parameters: (req) => [req.body],
+});

package/WebTemplate/controllers/authSessions/killOperation.ts

@@ -0,0 +1,35 @@
+import { authSessionsContextsStore } from "./store";
+
+export async function killAuthSessionOperation({
+  operationId,
+}: {
+  operationId: string;
+}): Promise<{
+  status: number;
+  body: any;
+}> {
+  const operation = authSessionsContextsStore.get(operationId);
+  if (!operation) {
+    return {
+      status: 200,
+      body: {
+        done: true,
+      },
+    };
+  }
+
+  try {
+    await operation.context.browser()?.close();
+    authSessionsContextsStore.delete(operationId);
+
+    return { status: 200, body: { done: true } };
+  } catch (error) {
+    return {
+      status: 500,
+      body: {
+        error,
+        message: "the server failed to kill the operation",
+      },
+    };
+  }
+}

package/WebTemplate/controllers/authSessions/resumeOperation.ts

@@ -0,0 +1,80 @@
+import { authSessionsContextsStore } from "./store";
+import { getContextStorageState } from "@intuned/runtime/dist/common/contextStorageStateHelpers";
+import { getTraceFilePath } from "../../utils";
+
+export async function resumeAuthSessionOperation({
+  operationId,
+  input,
+}: {
+  operationId: string;
+  input: string;
+}) {
+  const operation = authSessionsContextsStore.get(operationId);
+  if (!operation) {
+    return {
+      status: 404,
+      body: {
+        error: "Invalid Request",
+        message: "operation not found",
+      },
+    };
+  }
+
+  try {
+    if (
+      operation.requestInfo.requestType === "multiple_choice" &&
+      !operation.requestInfo.choices.includes(input)
+    ) {
+      return {
+        status: 400,
+        body: {
+          error: "Invalid Request",
+          message: "input does not match any of the choices",
+        },
+      };
+    }
+
+    const result = await operation.generator.next(input);
+
+    authSessionsContextsStore.set(operationId, {
+      done: result.done,
+      generator: operation.generator,
+      context: operation.context,
+      requestInfo: result.value,
+      saveTrace: operation.saveTrace,
+    });
+
+    if (result.done) {
+      if (operation.saveTrace) {
+        try {
+          const traceFilePath = getTraceFilePath(operationId);
+          await operation.context.tracing.stop({ path: traceFilePath });
+        } catch (error) {
+          console.error("Error stopping trace", error);
+        }
+      }
+      const storageState = await getContextStorageState(operation.context);
+      await operation.context.browser()?.close();
+      authSessionsContextsStore.delete(operationId);
+      return {
+        status: 200,
+        body: storageState,
+      };
+    }
+
+    return {
+      status: 200,
+      body: result.value,
+    };
+  } catch (e) {
+    if (operation.saveTrace) {
+      try {
+        const traceFilePath = getTraceFilePath(operationId);
+        await operation.context.tracing.stop({ path: traceFilePath });
+      } catch (error) {
+        console.error("Error stopping trace", error);
+      }
+    }
+    throw e;
+  }
+}

package/WebTemplate/controllers/authSessions/store.ts

@@ -0,0 +1,14 @@
+//@ts-ignore
+import { RequestMoreInfoDetails } from "@intuned/sdk/dist/common/requestMoreInfo";
+import { BrowserContext } from "@intuned/playwright-core";
+
+export const authSessionsContextsStore = new Map<
+  string,
+  {
+    done: boolean | undefined;
+    generator: AsyncGenerator<any, void, unknown>;
+    context: BrowserContext;
+    requestInfo: RequestMoreInfoDetails;
+    saveTrace: boolean;
+  }
+>();

package/WebTemplate/controllers/controllers.ts

@@ -0,0 +1,73 @@
+import { AsyncRunEndpointController } from "../utils";
+import { Handler } from "@tinyhttp/app";
+import { AsyncEndpointBody, runEndpointAsync } from "./async";
+
+export type RequestHandler<P extends any[], R> = (...parameters: P) => Promise<{
+  status: number;
+  body: R;
+}>;
+
+export function makeSyncEndpointController<_Parameters extends any[], _Result>({
+  handler,
+  parameters,
+}: {
+  handler: RequestHandler<_Parameters, any>;
+  parameters: _Parameters | ((req: any) => _Parameters);
+}): Handler {
+  return async (req, res) => {
+    const { status, body } = await handler(
+      ...(typeof parameters === "function" ? parameters(req) : parameters)
+    );
+    res.status(status).json(body);
+  };
+}
+
+export function makeAsyncEndpointController<_Parameters extends any[]>({
+  requestId,
+  handler,
+  parameters,
+}: {
+  requestId: string | ((req: any) => string);
+  handler: RequestHandler<_Parameters, any>;
+  parameters: _Parameters | ((req: any) => _Parameters);
+}): Handler {
+  return async (req, res) => {
+    const { taskToken, startTime, functionsToken } =
+      req.body as AsyncEndpointBody<_Parameters>;
+    if (AsyncRunEndpointController.isRunning(taskToken)) {
+      res.status(409).json({ error: "Already running" });
+      return;
+    }
+
+    void runEndpointAsync(
+      handler,
+      typeof parameters === "function" ? parameters(req) : parameters,
+      {
+        taskToken,
+        startTime,
+        functionsToken,
+        requestId: typeof requestId === "function" ? requestId(req) : requestId,
+      }
+    );
+
+    res.status(202).json({});
+  };
+}
+
+export function makeEndpointControllers<_Parameters extends any[]>({
+  requestId,
+  handler,
+  parameters,
+}: {
+  requestId: string | ((req: any) => string);
+  handler: RequestHandler<_Parameters, any>;
+  parameters: _Parameters | ((req: any) => _Parameters);
+}): {
+  sync: Handler;
+  async: Handler;
+} {
+  return {
+    sync: makeSyncEndpointController({ handler, parameters }),
+    async: makeAsyncEndpointController({ requestId, handler, parameters }),
+  };
+}

package/WebTemplate/controllers/runApi/helpers.ts

@@ -0,0 +1,220 @@
+import {
+  callFunction,
+  getTraceFilePath,
+  checkAuthSessionWithRetries,
+  waitWithExtendableTimeout,
+} from "../../utils";
+import { IntunedSettings } from "@intuned/runtime/dist/common/settingsSchema";
+import { getDownloadDirectoryPath } from "@intuned/runtime";
+import { getProductionPlaywrightConstructs } from "@intuned/runtime";
+import * as fs from "fs-extra";
+// @ts-ignore
+import { PayloadItem } from "../../../src/common/types";
+import { getTelemetryClient } from "@intuned/runtime/dist/common/telemetry";
+import { getExecutionContext } from "@intuned/runtime";
+import { backendFunctionsTokenManager } from "@intuned/runtime/dist/common/jwtTokenManager";
+import { setContextStorageState } from "@intuned/runtime/dist/common/contextStorageStateHelpers";
+import { remove } from "fs-extra";
+import { RunBody } from "./types";
+
+export async function runApi({
+  session,
+  params,
+  proxy,
+  executionContext,
+  functionsToken,
+  runId,
+  attemptNumber,
+  functionName,
+  shouldSaveTrace,
+  headless = true,
+}: RunBody & {
+  runId: string;
+  attemptNumber: string | undefined;
+  functionName: string;
+  shouldSaveTrace: boolean;
+  headless?: boolean;
+}): Promise<{
+  status: number;
+  body: any;
+}> {
+  const telemetryClient = getTelemetryClient();
+  const integrationId = process.env.INTUNED_INTEGRATION_ID as string;
+  const traceFilePath = getTraceFilePath(runId, attemptNumber);
+
+  if (!runId) {
+    return {
+      status: 400,
+      body: {
+        error: "runId header not provided",
+        message: "Please add provide run id to header",
+      },
+    };
+  }
+
+  let traceStarted = false;
+
+  backendFunctionsTokenManager.token = functionsToken;
+  const downloadsPath = getDownloadDirectoryPath();
+  const { page, context } = await getProductionPlaywrightConstructs({
+    headless,
+    proxy,
+    downloadsPath,
+  });
+
+  // handle timeout
+  const requestTimeout = +(process.env.REQUEST_TIMEOUT ?? 600) * 1000;
+  getExecutionContext()!.timeoutInfo = {
+    ...(getExecutionContext()?.timeoutInfo ?? {}),
+    timeoutDuration: requestTimeout,
+  };
+
+  async function saveTraceIfNeeded(errorMessage: string) {
+    if (!shouldSaveTrace || !traceStarted) {
+      return;
+    }
+    try {
+      await context.tracing.stop({ path: traceFilePath });
+    } catch (error: any) {
+      console.log(errorMessage, error?.message);
+      await remove(traceFilePath);
+    }
+  }
+
+  async function handleTimeout() {
+    console.log("timeout triggered");
+    await saveTraceIfNeeded("failed to save script after timeout");
+
+    await context.close();
+
+    return {
+      status: 508,
+      body: {
+        error: "TimeoutError",
+        message: "The request timed out",
+      },
+    };
+  }
+
+  if (shouldSaveTrace) {
+    await context.tracing.start({
+      screenshots: true,
+      snapshots: true,
+      sources: true,
+    });
+    traceStarted = true;
+  }
+
+  const isAuthSessionsEnabled = (
+    (await fs.readJSON("./Intuned.json", "utf-8")) as IntunedSettings
+  ).authSessions?.enabled;
+
+  const abortController = new AbortController();
+  async function runFunction() {
+    try {
+      if (isAuthSessionsEnabled) {
+        if (!session) {
+          await context.close();
+          return {
+            status: 401,
+            message: "auth sessions is required",
+            error: "auth sessions is required",
+          };
+        }
+
+        await setContextStorageState(context, session);
+        const authSessionCheckResult = await checkAuthSessionWithRetries(
+          page,
+          context,
+          2
+        );
+
+        if (abortController.signal.aborted) {
+          return;
+        }
+
+        if (!authSessionCheckResult) {
+          try {
+            telemetryClient?.trackEvent({
+              name: "AUTH_SESSION_RECOVER_FAILED",
+              properties: {
+                runId,
+                functionName,
+                integrationId,
+                message: "auth session check failed",
+              },
+            });
+            await saveTraceIfNeeded("failed to save trace after check failed");
+          } catch (error: any) {
+            console.log(
+              "failed to save script after check failed",
+              error?.message
+            );
+          }
+
+          await context.close();
+          return {
+            status: 401,
+            message: "auth session check failed",
+            error: "AUTH_SESSION_CHECK_FAILED",
+          };
+        }
+      }
+
+      console.log("Running function", functionName);
+      const result = await callFunction("api", functionName as string, [
+        params ?? {},
+        page,
+        context,
+      ]);
+
+      await saveTraceIfNeeded("failed to save trace after run is done");
+      await context.close();
+
+      const response: {
+        result: any;
+        updatedSession?: object;
+        payloadToAppend: PayloadItem[] | null;
+        // TODO: remove
+        metadata?: {
+          startTime: number;
+          endTime: number;
+        };
+        status?: number;
+      } = {
+        result,
+        updatedSession: undefined,
+        payloadToAppend: getExecutionContext()!.extendedPayloads?.map((i) => ({
+          apiName: i.api,
+          parameters: i.parameters,
+        })),
+        status: 200,
+      };
+      return response;
+    } catch (error) {
+      console.log("run errored", error);
+      await saveTraceIfNeeded("failed to save trace after run errored");
+      await context.close();
+      throw error;
+    } finally {
+      await fs.remove(downloadsPath);
+    }
+  }
+
+  const resultWithTimeout = await waitWithExtendableTimeout({
+    promise: runFunction(),
+    initialTimeout: requestTimeout,
+    abortController,
+  });
+
+  if (resultWithTimeout.timedOut === true) {
+    return await handleTimeout();
+  }
+
+  const { result } = resultWithTimeout;
+
+  return {
+    status: 200,
+    body: result,
+  };
+}

package/WebTemplate/controllers/runApi/index.ts

@@ -0,0 +1,68 @@
+import { Handler } from "@tinyhttp/app";
+import { RUN_ID_HEADER, ATTEMPT_NUMBER_HEADER } from "../../headers";
+import { runApi } from "./helpers";
+import { AsyncRunEndpointController, isHeadless } from "../../utils";
+import { makeEndpointControllers } from "../controllers";
+export { runApi } from "./helpers";
+
+export interface Proxy {
+  server: string;
+  username: string;
+  password: string;
+}
+
+export interface RunBody {
+  session: any;
+  params?: object;
+  proxy?: Proxy;
+  executionContext: any;
+  functionsToken: string;
+}
+
+export const { sync: runApiController, async: runApiAsyncController } =
+  makeEndpointControllers({
+    requestId: (req) =>
+      `runApi ${req.headers[RUN_ID_HEADER]} (${req.headers[ATTEMPT_NUMBER_HEADER]})`,
+    parameters: (req) => {
+      // e.g. /api/run/folder1/api should be folder1/api
+      const functionName = req.params.wild
+        .split("/")
+        // filter(Boolean) should remove empty strings in case of a trailing slash
+        .filter(Boolean)
+        .join("/");
+
+      const { session, params, proxy, executionContext, functionsToken } =
+        req.body as RunBody;
+      const runId = req.headers[RUN_ID_HEADER] as string;
+      const attemptNumber = req.headers[ATTEMPT_NUMBER_HEADER] as
+        | string
+        | undefined;
+      const shouldSaveTrace = req.query.saveTrace === "true";
+      const headless = isHeadless();
+      const result: Parameters<typeof runApi> = [
+        {
+          session,
+          params,
+          proxy,
+          executionContext,
+          functionsToken,
+          runId,
+          attemptNumber,
+          functionName,
+          shouldSaveTrace,
+          headless,
+        },
+      ];
+      return result;
+    },
+    handler: async (parameters: Parameters<typeof runApi>[0]) => {
+      const { status, body } = await runApi(parameters);
+      return { status, body };
+    },
+  });
+
+export const getActiveAsyncEndpointController: Handler = async (req, res) => {
+  res
+    .status(200)
+    .json({ count: AsyncRunEndpointController.activeRequestsCount });
+};

package/WebTemplate/controllers/runApi/types.ts

@@ -0,0 +1,13 @@
+export interface Proxy {
+  server: string;
+  username: string;
+  password: string;
+}
+
+export interface RunBody {
+  session: any;
+  params?: object;
+  proxy?: Proxy;
+  executionContext: any;
+  functionsToken: string;
+}