@intuned/runtime-dev 0.1.0-test.9 → 1.0.0-udas.0

package/.babelrc

@@ -13,9 +13,7 @@
     "@babel/preset-typescript"
   ],
   "plugins": [
-    ["./preserve-dynamic-imports.js"],
     "babel-plugin-macros",
-    "@babel/plugin-syntax-dynamic-import",
     "@babel/plugin-transform-export-namespace-from"
   ],
   "sourceMaps": false,

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,39 @@
+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
+  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;
+}

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,
@@ -35,7 +36,7 @@ export async function checkAuthSession({
       name: "auth-sessions/check",
     },
     runOptions: {
-      environment: "deployed",
+      environment: "standalone",
       headless: isHeadless(),
       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
       ? {
@@ -63,24 +63,22 @@ export async function createAuthSession({
         }
       : { enabled: false },
     runOptions: {
-      environment: "deployed",
+      environment: "standalone",
       headless,
       proxy,
     },
     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;

package/WebTemplate/controllers/runApi/helpers.ts

@@ -1,4 +1,8 @@
-import { getTraceFilePath, waitWithExtendableTimeout } from "../../utils";
+import {
+  getTraceFilePath,
+  importModule,
+  waitWithExtendableTimeout,
+} from "../../utils";
 import * as fs from "fs-extra";
 import { getExecutionContext } from "@intuned/runtime";
 import { backendFunctionsTokenManager } from "@intuned/runtime/dist/common/jwtTokenManager";
@@ -61,23 +65,24 @@ export async function runApi({
 
   const abortController = new AbortController();
 
+  backendFunctionsTokenManager.token = functionsToken;
   const resultWithTimeout = await waitWithExtendableTimeout({
     promise: runApiInternal({
       automationFunction: {
         name: `api/${functionName}`,
-        params: params ?? {},
+        params,
       },
-      auth: !isAuthSessionEnabled
-        ? undefined
-        : {
+      auth: isAuthSessionEnabled
+        ? {
             session: {
               type: "state",
               state: session,
             },
             runCheck: isAuthSessionEnabled,
-          },
+          }
+        : undefined,
       runOptions: {
-        environment: "deployed",
+        environment: "standalone",
         headless,
         proxy,
       },
@@ -87,8 +92,8 @@ export async function runApi({
             filePath: getTraceFilePath(runId, attemptNumber),
           }
         : { enabled: false },
-      functionsToken,
       abortSignal: abortController.signal,
+      importFunction: importModule,
     }),
     initialTimeout: requestTimeout,
     abortController,

package/WebTemplate/index.playwright.ts

@@ -6,52 +6,42 @@ import { getExecutionContext } from "@intuned/runtime";
 import { app } from "./app";
 import { RUN_ID_HEADER } from "./headers";
 import { ShutdownController } from "./shutdown";
-import { registerApiEndpoints } from "./api";
-import { runJobsLoop } from "./jobs";
-import { isJobRunMachine } from "./utils";
 
-void main();
+const port = process.env.PORT ? parseInt(process.env.PORT) : 4000;
 
-async function main() {
-  const port = process.env.PORT ? parseInt(process.env.PORT) : 4000;
+initializeAppInsights();
 
-  initializeAppInsights();
-
-  app.use((req, res, next) => {
-    // Cleanup after the response is sent
-    res.on("finish", () => {
-      console.log("finished", req.headers[RUN_ID_HEADER]);
-      void ShutdownController.instance.checkForShutdown();
-    });
-
-    next();
-  });
-
-  registerApiEndpoints();
-  if (isJobRunMachine()) {
-    console.log("Running in job v3 mode");
-    void runJobsLoop();
-  }
-
-  const server = app.listen(port, () => {
-    // when deployed on flyio, the server will be turned on and
-    // will shutdown after the specified time in TIME_TO_SHUTDOWN env variable
-    ShutdownController.initialize(server);
+app.use((req, res, next) => {
+  // Cleanup after the response is sent
+  res.on("finish", () => {
+    console.log("finished", req.headers[RUN_ID_HEADER]);
     void ShutdownController.instance.checkForShutdown();
-    console.log(`Server is running on port ${port}`);
   });
 
-  process.on("unhandledRejection", (reason, promise) => {
-    const telemetryClient = getTelemetryClient();
-    console.error("Unhandled Rejection at:", promise, "reason:", reason);
-    const context = getExecutionContext();
-    telemetryClient?.trackEvent({
-      name: "UNHANDLED_REJECTION",
-      properties: {
-        runId: context?.runId,
-        promise,
-        reason,
-      },
-    });
+  next();
+});
+
+export * from "./api";
+export * from "./jobs";
+
+const server = app.listen(port, () => {
+  // when deployed on flyio, the server will be turned on and
+  // will shutdown after the specified time in TIME_TO_SHUTDOWN env variable
+  ShutdownController.initialize(server);
+  void ShutdownController.instance.checkForShutdown();
+  console.log(`Server is running on port ${port}`);
+});
+
+process.on("unhandledRejection", (reason, promise) => {
+  const telemetryClient = getTelemetryClient();
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+  const context = getExecutionContext();
+  telemetryClient?.trackEvent({
+    name: "UNHANDLED_REJECTION",
+    properties: {
+      runId: context?.runId,
+      promise,
+      reason,
+    },
   });
-}
+});

package/WebTemplate/jobs.ts

@@ -6,7 +6,13 @@ import {
   RUN_ID_HEADER,
   SHOULD_SHUTDOWN_HEADER,
 } from "./headers";
-import { getErrorResponse, isHeadless, ProxyConfig, proxyToUrl } from "./utils";
+import {
+  getErrorResponse,
+  isHeadless,
+  isJobRunMachine,
+  ProxyConfig,
+  proxyToUrl,
+} from "./utils";
 import {
   callBackendFunctionWithToken,
   backendFunctionsTokenManager,
@@ -26,6 +32,11 @@ type JobPayload = {
   traceSignedUrl?: string;
 };
 
+if (isJobRunMachine()) {
+  console.log("Running in job v3 mode");
+  void jobsV3();
+}
+
 async function runApiInContext(
   jobPayload: JobPayload
 ): Promise<Awaited<ReturnType<typeof runApi>>> {
@@ -72,7 +83,7 @@ async function runApiInContext(
   }
 }
 
-export async function runJobsLoop() {
+async function jobsV3() {
   await reportReady();
   const initialDelay = 1000;
   let delay = initialDelay;