@intuned/runtime-dev 0.1.0-test.4 → 0.1.0-test.41

package/InterfaceTemplate/index.playwright.ts

@@ -0,0 +1,5 @@
+import { runAutomationCLI } from "@intuned/runtime/dist/commands/interface/run";
+
+import { importModule } from "./utils";
+
+runAutomationCLI(importModule);

package/InterfaceTemplate/utils.ts

@@ -0,0 +1,257 @@
+import * as playwright from "@intuned/playwright-core";
+import { Handler, Response } from "@tinyhttp/app";
+import * as path from "path";
+import { getExecutionContext } from "@intuned/runtime";
+import { setTimeout } from "timers/promises";
+
+export class FunctionNotFoundError extends Error {
+  functionName: string;
+  path: string;
+  constructor(functionName: string, path: string) {
+    const message = `function ${functionName} not found in ${path}`;
+    super(message);
+    this.functionName = functionName;
+    this.path = path;
+    this.name = "FunctionNotFound";
+    Object.setPrototypeOf(this, FunctionNotFoundError.prototype);
+  }
+}
+
+export function getIsRetryableError(error: any) {
+  if (error?.message) {
+    return error.message.includes("ERR_NETWORK_CHANGED");
+  }
+  return false;
+}
+
+export function getErrorResponse(error: any): {
+  status: number;
+  body: any;
+} {
+  if (error instanceof FunctionNotFoundError) {
+    return {
+      status: 404,
+      body: {
+        message: error.message,
+        error: error.name,
+      },
+    };
+  }
+  if (error instanceof playwright.errors.TimeoutError) {
+    return {
+      status: 500,
+      body: { message: error.message, error: error.name },
+    };
+  }
+  /**
+   * here we use error.constructor.name instead of error instanceof RunError
+   * this is because the error is thrown by importing the runner from the api code on intuned app
+   * the definition of class RunError which is imported from here is different than the class RunError
+   * imported from the user.
+   */
+  if (error.constructor.name === "RunError") {
+    return {
+      status: 200,
+      body: {
+        status: error.options.status_code ?? 500,
+        message: error.message,
+        error: error.options.error_code ?? error.name,
+        intunedOptions: error.options,
+      },
+    };
+  }
+  return {
+    status: 500,
+    body: { error: error?.name ?? error, message: error?.message },
+  };
+}
+
+export function handlePlaywrightExecutionError(error: any, res: Response) {
+  const { status, body } = getErrorResponse(error);
+  return res.status(status).json(body);
+}
+
+type EventTraceEvent = {
+  type: "event";
+  time: number;
+  class: string;
+  method: string;
+  params: any;
+  pageId?: string;
+};
+
+type AppHandlerParams = Parameters<Handler>;
+
+export function errorRetryMiddleware(handler: Handler) {
+  return async (...args: AppHandlerParams) => {
+    let attempts = 1;
+    const [req, res, next] = args;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        await handler(req, res, next);
+        break;
+      } catch (error) {
+        console.log(error?.name, error?.message);
+        if (!getIsRetryableError(error) || attempts >= 3) {
+          return handlePlaywrightExecutionError(error, res);
+        }
+        attempts++;
+      }
+    }
+  };
+}
+
+export function getTraceFilePath(runId: string, attemptNumber?: string) {
+  const fileName = `${runId}${attemptNumber ? `_${attemptNumber}` : ""}`;
+  return path.join(process.env.TRACES_DIRECTORY ?? "", `${fileName}.zip`);
+}
+
+export interface ProxyConfig {
+  username: string;
+  server: string;
+  password: string;
+}
+
+export function proxyToUrl(proxy: ProxyConfig) {
+  const url = new URL(proxy.server);
+  url.username = proxy.username;
+  url.password = proxy.password;
+  return url.toString();
+}
+
+export function isJobRunMachine() {
+  return process.env.JOB_ID && process.env.JOB_RUN_ID;
+}
+
+export function isHeadless() {
+  return process.env.INTUNED_PLAYWRIGHT_HEADLESS !== "0";
+}
+
+export abstract class AsyncRunEndpointController {
+  private static activeRequests: Set<string> = new Set();
+
+  static isRunning(taskToken: string) {
+    return this.activeRequests.has(taskToken);
+  }
+
+  static addRequest(taskToken: string) {
+    this.activeRequests.add(taskToken);
+  }
+
+  static removeRequest(taskToken: string) {
+    this.activeRequests.delete(taskToken);
+  }
+
+  static get activeRequestsCount() {
+    return this.activeRequests.size;
+  }
+}
+
+export async function waitWithExtendableTimeout<T>({
+  initialTimeout,
+  promise,
+  abortController,
+}: {
+  initialTimeout: number;
+  promise: Promise<T>;
+  abortController?: AbortController;
+}): Promise<
+  | {
+      timedOut: true;
+    }
+  | {
+      timedOut: false;
+      result: T;
+    }
+> {
+  const context = getExecutionContext()!;
+  if (context.timeoutInfo) {
+    context.timeoutInfo.timeoutTimestamp = Date.now() + initialTimeout;
+  }
+  const timerSymbol = Symbol("timer");
+  if (!context) {
+    const result = await Promise.race([
+      promise,
+      setTimeout(initialTimeout, timerSymbol),
+    ]);
+    if (result === timerSymbol) {
+      abortController?.abort("Timed out");
+      return { timedOut: true };
+    }
+    return { timedOut: false, result };
+  }
+
+  let taskTimeout = initialTimeout;
+  while (true as boolean) {
+    const result = await Promise.race([
+      promise,
+      setTimeout(taskTimeout, timerSymbol),
+    ]);
+
+    if (result !== timerSymbol) {
+      break;
+    }
+
+    const remainingTime =
+      (context.timeoutInfo?.timeoutTimestamp ?? 0) - Date.now();
+    if (remainingTime < 0) {
+      abortController?.abort("Timed out");
+      return { timedOut: true };
+    }
+
+    taskTimeout = remainingTime;
+  }
+
+  return {
+    timedOut: false,
+    result: await promise,
+  };
+}
+
+export async function importModule(path: string) {
+  const [folderName, ...functionNameParts] = path.split("/");
+  const functionNameDepth = functionNameParts.length;
+
+  // string literals should be inline
+  // currently we support only 5 levels of depth
+  // rollup dynamic import does not support multiple levels of dynamic imports so we need to specify the possible paths explicitly
+  try {
+    let imported: any = undefined;
+    switch (functionNameDepth) {
+      case 1:
+        imported = await import(`./${folderName}/${functionNameParts[0]}.ts`);
+        break;
+      case 2:
+        imported = await import(
+          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}.ts`
+        );
+        break;
+      case 3:
+        imported = await import(
+          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}.ts`
+        );
+        break;
+      case 4:
+        imported = await import(
+          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}.ts`
+        );
+        break;
+      case 5:
+        imported = await import(
+          `./${folderName}/${functionNameParts[0]}/${functionNameParts[1]}/${functionNameParts[2]}/${functionNameParts[3]}/${functionNameParts[4]}.ts`
+        );
+        break;
+      default:
+        throw new Error(
+          "intuned supports maximum 5 levels of depth in the api folder"
+        );
+    }
+    return imported;
+  } catch (error: any) {
+    if (error.message.includes("Unknown variable dynamic import")) {
+      throw new FunctionNotFoundError("", path);
+    }
+    throw error;
+  }
+}

package/Intuned.json

@@ -1,5 +1,5 @@
 {
   "authSessions": {
-    "enabled": true
+    "enabled": false
   }
 }

package/WebTemplate/api.ts

@@ -33,109 +33,107 @@ import {
 } from "./headers";
 import { FEATURES } from "./features";
 
-export function registerApiEndpoints() {
-  if (!isJobRunMachine()) {
-    app.use((req, _, next) => {
-      const runId = req.headers[RUN_ID_HEADER] as string;
-      const jobId = req.headers[JOB_ID_HEADER] as string;
-      const jobRunId = req.headers[JOB_RUN_ID_HEADER] as string;
-      const queueId = req.headers[QUEUE_ID_HEADER] as string;
-      const proxy = req?.body?.proxy
-        ? (proxyToUrl(req.body.proxy as ProxyConfig) as string)
-        : undefined;
-      const contextData = {
-        runId: runId ?? "",
-        jobId,
-        jobRunId,
-        queueId,
-        proxy,
-        ...(req?.body?.executionContext ?? {}),
-      };
-      runWithContext(contextData, next);
-    });
-
-    app.get(
-      "/api/protected/health",
-      accessKeyValidatorMiddleware,
-      async (req, res) => {
-        res.status(200).json({ status: "ok" });
-      }
-    );
+if (!isJobRunMachine()) {
+  app.use((req, _, next) => {
+    const runId = req.headers[RUN_ID_HEADER] as string;
+    const jobId = req.headers[JOB_ID_HEADER] as string;
+    const jobRunId = req.headers[JOB_RUN_ID_HEADER] as string;
+    const queueId = req.headers[QUEUE_ID_HEADER] as string;
+    const proxy = req?.body?.proxy
+      ? (proxyToUrl(req.body.proxy as ProxyConfig) as string)
+      : undefined;
+    const contextData = {
+      runId: runId ?? "",
+      jobId,
+      jobRunId,
+      queueId,
+      proxy,
+      ...(req?.body?.executionContext ?? {}),
+    };
+    runWithContext(contextData, next);
+  });
 
-    app.post(
-      "/api/auth-session/create",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(createAuthSessionController)
-    );
+  app.get(
+    "/api/protected/health",
+    accessKeyValidatorMiddleware,
+    async (req, res) => {
+      res.status(200).json({ status: "ok" });
+    }
+  );
 
-    app.post(
-      "/api/auth-session-async/create",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(createAuthSessionAsyncController)
-    );
+  app.post(
+    "/api/auth-session/create",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(createAuthSessionController)
+  );
 
-    app.post(
-      "/api/auth-session/check",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(checkAuthSessionController)
-    );
+  app.post(
+    "/api/auth-session-async/create",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(createAuthSessionAsyncController)
+  );
 
-    app.post(
-      "/api/auth-session-async/check",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(checkAuthSessionAsyncController)
-    );
+  app.post(
+    "/api/auth-session/check",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(checkAuthSessionController)
+  );
 
-    app.post(
-      "/api/auth-session/kill",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(killAuthSessionOperationController)
-    );
+  app.post(
+    "/api/auth-session-async/check",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(checkAuthSessionAsyncController)
+  );
 
-    app.post(
-      "/api/auth-session/resume",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(resumeAuthSessionOperationController)
-    );
+  app.post(
+    "/api/auth-session/kill",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(killAuthSessionOperationController)
+  );
 
-    app.post(
-      "/api/auth-session-async/resume",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(resumeAuthSessionOperationAsyncController)
-    );
+  app.post(
+    "/api/auth-session/resume",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(resumeAuthSessionOperationController)
+  );
 
-    app.post(
-      "/api/run/*",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(runApiController)
-    );
+  app.post(
+    "/api/auth-session-async/resume",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(resumeAuthSessionOperationAsyncController)
+  );
 
-    app.post(
-      "/api/run-async/start/*",
-      accessKeyValidatorMiddleware,
-      errorRetryMiddleware(runApiAsyncController) // todo: this probably needs changing
-    );
+  app.post(
+    "/api/run/*",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(runApiController)
+  );
 
-    app.get(
-      "/api/run-async/count",
-      accessKeyValidatorMiddleware,
-      getActiveAsyncEndpointController
-    );
+  app.post(
+    "/api/run-async/start/*",
+    accessKeyValidatorMiddleware,
+    errorRetryMiddleware(runApiAsyncController) // todo: this probably needs changing
+  );
 
-    app.post(
-      "/api/trace/upload/:runId",
-      accessKeyValidatorMiddleware,
-      uploadTraceController
-    );
+  app.get(
+    "/api/run-async/count",
+    accessKeyValidatorMiddleware,
+    getActiveAsyncEndpointController
+  );
 
-    app.post(
-      "/api/trace/delete/:runId",
-      accessKeyValidatorMiddleware,
-      deleteTraceController
-    );
-  }
+  app.post(
+    "/api/trace/upload/:runId",
+    accessKeyValidatorMiddleware,
+    uploadTraceController
+  );
 
-  app.get("/api/features", accessKeyValidatorMiddleware, async (_, res) => {
-    res.status(200).json({ features: FEATURES });
-  });
+  app.post(
+    "/api/trace/delete/:runId",
+    accessKeyValidatorMiddleware,
+    deleteTraceController
+  );
 }
+
+app.get("/api/features", accessKeyValidatorMiddleware, async (_, res) => {
+  res.status(200).json({ features: FEATURES });
+});

package/WebTemplate/controllers/async.ts

@@ -40,59 +40,63 @@ export async function runEndpointAsync<_Parameters extends any[], _Result>(
   } catch (e: any) {
     console.error(`Error running ${requestId} in async mode:`, e);
     ({ status, body } = getErrorResponse(e));
-  } finally {
-    AsyncRunEndpointController.removeRequest(taskToken);
   }
 
-  // report result
-  console.log("Reporting result for", requestId);
   try {
-    // `retry` will keep retrying any errors unless they are thrown through calling `bail`
-    await retry(
-      async (bail: (e: Error) => void) => {
-        const response = await callBackendFunctionWithToken(
-          "run/reportResult",
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              "fly-instance-id": process.env.FLY_ALLOC_ID ?? "",
-            },
-            body: JSON.stringify({
-              status,
-              body,
-              startTime,
-              taskToken,
-            }),
-          }
-        );
-        if (!response.ok) {
-          // Do not retry unauthenticated, forbidden, not found or too large responses
-          if ([401, 403, 404, 413].includes(response.status)) {
-            bail(
-              new Error(
-                `Reporting result failed for ${requestId} (non-retryable), status ${response.status}`
-              )
-            );
+    // report result
+    console.log("Reporting result for", requestId);
+    try {
+      // `retry` will keep retrying any errors unless they are thrown through calling `bail`
+      await retry(
+        async (bail: (e: Error) => void) => {
+          const response = await callBackendFunctionWithToken(
+            "run/reportResult",
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "fly-instance-id": process.env.FLY_ALLOC_ID ?? "",
+              },
+              body: JSON.stringify({
+                status,
+                body,
+                startTime,
+                taskToken,
+              }),
+            }
+          ).catch((e) => {
+            const message = `Reporting result failed for ${requestId}, error: ${e.message}`;
+            console.error(message);
+            throw e;
+          });
+          if (!response.ok) {
+            // Do not retry unauthenticated, forbidden, not found or too large responses
+            if ([401, 403, 404, 413].includes(response.status)) {
+              const message = `Reporting result failed for ${requestId} (non-retryable), status ${response.status}`;
+              console.error(message);
+              bail(new Error(message));
+            }
+            // retry other errors (such as 502)
+            const message = `Reporting result failed for ${requestId}, status ${response.status}`;
+            console.error(message);
+            throw new Error(message);
           }
-          // retry other errors (such as 502)
-          throw new Error(
-            `Reporting result failed for ${requestId}, status ${response.status}`
-          );
-        }
 
-        return response;
-      },
-      {
-        retries: 5,
-        factor: 2,
-        maxTimeout: 1000 * 60, // 1 minute
-        minTimeout: 1000 * 5, // 5 seconds
-      }
-    );
-    console.log("Reported result for", requestId);
-  } catch (e: any) {
-    console.log(e?.message ?? `Reporting result failed for ${requestId}`);
+          return response;
+        },
+        {
+          retries: 5,
+          factor: 2,
+          maxTimeout: 1000 * 60, // 1 minute
+          minTimeout: 1000 * 5, // 5 seconds
+        }
+      );
+      console.log("Reported result for", requestId);
+    } catch (e: any) {
+      // ignore
+    }
+  } finally {
+    AsyncRunEndpointController.removeRequest(taskToken);
   }
 
   await ShutdownController.instance.checkForShutdown();

package/WebTemplate/controllers/authSessions/check.ts

@@ -1,6 +1,7 @@
 import { readJSON } from "fs-extra";
 import { isHeadless } from "../../utils";
 import { runApi } from "@intuned/runtime/dist/common/runApi";
+import { importModule } from "../../utils";
 
 export async function checkAuthSession({
   proxy,
@@ -46,12 +47,10 @@ export async function checkAuthSession({
       },
       runCheck: false,
     },
+    importFunction: importModule,
   });
   if (result.isErr()) {
-    return {
-      status: 500,
-      body: result.error,
-    };
+    return result.error.apiResponse;
   }
   return {
     status: 200,

package/WebTemplate/controllers/authSessions/create.ts

@@ -1,5 +1,5 @@
 import { authSessionsContextsStore } from "./store";
-import { getTraceFilePath, isHeadless } from "../../utils";
+import { getTraceFilePath, isHeadless, importModule } from "../../utils";
 import * as fs from "fs-extra";
 import { runApiGenerator } from "@intuned/runtime/dist/common/runApi";
 import type { RequestMoreInfoDetails } from "@intuned/runtime/dist/runtime";
@@ -54,7 +54,7 @@ export async function createAuthSession({
   >({
     automationFunction: {
       name: "auth-sessions/create",
-      params: parameters ?? {},
+      params: parameters,
     },
     tracing: saveTrace
       ? {
@@ -69,18 +69,16 @@ export async function createAuthSession({
     },
     abortSignal: abortController.signal,
     retrieveSession: true,
+    importFunction: importModule,
   });
 
   const result = await createGenerator.next();
 
-  if (result.done) {
+  if (result.done === true) {
     const r = result.value;
 
     if (r.isErr()) {
-      return {
-        status: 500,
-        body: r.error,
-      };
+      return r.error.apiResponse;
     }
 
     return {

package/WebTemplate/controllers/authSessions/resumeOperation.ts

@@ -33,7 +33,7 @@ export async function resumeAuthSessionOperation({
 
   const result = await operation.generator.next(input);
 
-  if (result.done) {
+  if (result.done === true) {
     authSessionsContextsStore.delete(operationId);
     if (result.value.isErr()) {
       return result.value.error.apiResponse;