@intuned/runtime-dev 0.1.0-test.28 → 0.1.0-test.29

package/WebTemplate/controllers/async.ts

@@ -40,59 +40,61 @@ 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,
-            }),
+    // 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);
           }
-        );
-        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}`
-              )
-            );
-          }
-          // 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/create.ts

@@ -1,11 +1,7 @@
 import { authSessionsContextsStore } from "./store";
 import { getTraceFilePath, isHeadless, importModule } from "../../utils";
 import * as fs from "fs-extra";
-import {
-  runApiGenerator,
-  type RunApiResult,
-  type RunApiResultWithSessionOk,
-} from "@intuned/runtime/dist/common/runApi";
+import { runApiGenerator } from "@intuned/runtime/dist/common/runApi";
 import type { RequestMoreInfoDetails } from "@intuned/runtime/dist/runtime";
 
 export async function createAuthSession({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/runtime-dev",
-  "version": "0.1.0-test.28",
+  "version": "0.1.0-test.29",
   "description": "Intuned runtime",
   "exports": {
     ".": "./dist/index.js",

package/InterfaceTemplate/index.js

@@ -1 +0,0 @@
-export {};

package/WebTemplate/accessKeyHelpers.js

@@ -1,20 +0,0 @@
-import { createHash } from "crypto";
-function hashToken(token) {
-    // This has to match the logic from the workflow that saves adds the token to fly io App.
-    return createHash("sha256").update(token).digest("hex");
-}
-export const accessKeyValidatorMiddleware = (req, res, next) => {
-    const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith("Bearer ")) {
-        return res.status(401).send("Unauthorized");
-    }
-    const token = authHeader.split(" ")[1];
-    // Create a hash of the provided token
-    const hashedToken = hashToken(token);
-    const hashedTokenFromEnv = process.env.HASHED_ACCESS_KEY;
-    if (hashedToken !== hashedTokenFromEnv) {
-        console.log("Token mismatch", hashedToken, hashedTokenFromEnv);
-        return res.status(401).send("Unauthorized");
-    }
-    next();
-};

package/WebTemplate/api.js

@@ -1,48 +0,0 @@
-import { errorRetryMiddleware, proxyToUrl, isJobRunMachine, } from "./utils";
-import { accessKeyValidatorMiddleware } from "./accessKeyHelpers";
-import { runWithContext } from "@intuned/runtime";
-import { createAuthSessionController, createAuthSessionAsyncController, resumeAuthSessionOperationController, resumeAuthSessionOperationAsyncController, killAuthSessionOperationController, checkAuthSessionController, checkAuthSessionAsyncController, } from "./controllers/authSessions";
-import { app } from "./app";
-import { getActiveAsyncEndpointController, runApiAsyncController, runApiController, } from "./controllers/runApi";
-import { uploadTraceController, deleteTraceController, } from "./controllers/traces";
-import { RUN_ID_HEADER, JOB_ID_HEADER, JOB_RUN_ID_HEADER, QUEUE_ID_HEADER, } from "./headers";
-import { FEATURES } from "./features";
-if (!isJobRunMachine()) {
-    app.use((req, _, next) => {
-        const runId = req.headers[RUN_ID_HEADER];
-        const jobId = req.headers[JOB_ID_HEADER];
-        const jobRunId = req.headers[JOB_RUN_ID_HEADER];
-        const queueId = req.headers[QUEUE_ID_HEADER];
-        const proxy = req?.body?.proxy
-            ? proxyToUrl(req.body.proxy)
-            : 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" });
-    });
-    app.post("/api/auth-session/create", accessKeyValidatorMiddleware, errorRetryMiddleware(createAuthSessionController));
-    app.post("/api/auth-session-async/create", accessKeyValidatorMiddleware, errorRetryMiddleware(createAuthSessionAsyncController));
-    app.post("/api/auth-session/check", accessKeyValidatorMiddleware, errorRetryMiddleware(checkAuthSessionController));
-    app.post("/api/auth-session-async/check", accessKeyValidatorMiddleware, errorRetryMiddleware(checkAuthSessionAsyncController));
-    app.post("/api/auth-session/kill", accessKeyValidatorMiddleware, errorRetryMiddleware(killAuthSessionOperationController));
-    app.post("/api/auth-session/resume", accessKeyValidatorMiddleware, errorRetryMiddleware(resumeAuthSessionOperationController));
-    app.post("/api/auth-session-async/resume", accessKeyValidatorMiddleware, errorRetryMiddleware(resumeAuthSessionOperationAsyncController));
-    app.post("/api/run/*", accessKeyValidatorMiddleware, errorRetryMiddleware(runApiController));
-    app.post("/api/run-async/start/*", accessKeyValidatorMiddleware, errorRetryMiddleware(runApiAsyncController) // todo: this probably needs changing
-    );
-    app.get("/api/run-async/count", accessKeyValidatorMiddleware, getActiveAsyncEndpointController);
-    app.post("/api/trace/upload/:runId", accessKeyValidatorMiddleware, uploadTraceController);
-    app.post("/api/trace/delete/:runId", accessKeyValidatorMiddleware, deleteTraceController);
-}
-app.get("/api/features", accessKeyValidatorMiddleware, async (_, res) => {
-    res.status(200).json({ features: FEATURES });
-});

package/WebTemplate/app.js

@@ -1,13 +0,0 @@
-import { App } from "@tinyhttp/app";
-import { json as parser } from "milliparsec";
-export const port = process.env.PORT ? parseInt(process.env.PORT) : 4000;
-export const app = new App();
-app.use("/", parser());
-// add header with flyio instance id where the request is served from
-app.use((_, res, next) => {
-    res.setHeader("fly-instance-id", process.env.FLY_ALLOC_ID ?? "");
-    next();
-});
-app.get("/api/health", async (req, res) => {
-    res.status(200).json({ status: "ok" });
-});

package/WebTemplate/controllers/async.js

@@ -1,78 +0,0 @@
-import { AsyncRunEndpointController, getErrorResponse } from "../utils";
-import { backendFunctionsTokenManager, callBackendFunctionWithToken, } from "@intuned/runtime/dist/common/jwtTokenManager";
-import retry from "async-retry";
-import { ShutdownController } from "../shutdown";
-export async function runEndpointAsync(handler, parameters, endpointParameters) {
-    const { functionsToken, taskToken, startTime, requestId = "endpoint", } = endpointParameters;
-    AsyncRunEndpointController.addRequest(taskToken);
-    backendFunctionsTokenManager.token = functionsToken;
-    let status, body;
-    try {
-        console.log("Running", requestId, "in async mode");
-        ({ status, body } = await handler(...parameters));
-        console.log("Finished running", requestId, "in async mode");
-    }
-    catch (e) {
-        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) => {
-            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}`));
-                }
-                // 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) {
-        console.log(e?.message ?? `Reporting result failed for ${requestId}`);
-    }
-    await ShutdownController.instance.checkForShutdown();
-    return { status, body };
-}
-export function makeAsyncEndpointController({ requestId, handler, parameters, }) {
-    return async (req, res) => {
-        const { taskToken, startTime, functionsToken } = req.body;
-        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({});
-    };
-}

package/WebTemplate/controllers/authSessions/check.js

@@ -1,44 +0,0 @@
-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, session, }) {
-    const isAuthSessionEnabled = (await readJSON("./Intuned.json")).authSessions
-        ?.enabled;
-    if (!isAuthSessionEnabled) {
-        return {
-            status: 400,
-            body: {
-                error: "Invalid Request",
-                message: "auth sessions are not enabled",
-            },
-        };
-    }
-    const result = await runApi({
-        automationFunction: {
-            name: "auth-sessions/check",
-        },
-        runOptions: {
-            environment: "deployed",
-            headless: isHeadless(),
-            proxy,
-        },
-        auth: {
-            session: {
-                type: "state",
-                state: session,
-            },
-            runCheck: false,
-        },
-        importFunction: importModule,
-    });
-    if (result.isErr()) {
-        return result.error.apiResponse;
-    }
-    return {
-        status: 200,
-        body: {
-            result: result.value.result,
-        },
-    };
-}

package/WebTemplate/controllers/authSessions/create.js

@@ -1,69 +0,0 @@
-import { authSessionsContextsStore } from "./store";
-import { getTraceFilePath, isHeadless, importModule } from "../../utils";
-import * as fs from "fs-extra";
-import { runApiGenerator, } from "@intuned/runtime/dist/common/runApi";
-export async function createAuthSession({ parameters, operationId, proxy, saveTrace, }) {
-    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 (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 headless = isHeadless();
-    const abortController = new AbortController();
-    const createGenerator = runApiGenerator({
-        automationFunction: {
-            name: "auth-sessions/create",
-            params: parameters,
-        },
-        tracing: saveTrace
-            ? {
-                enabled: true,
-                filePath: getTraceFilePath(operationId),
-            }
-            : { enabled: false },
-        runOptions: {
-            environment: "deployed",
-            headless,
-            proxy,
-        },
-        abortSignal: abortController.signal,
-        retrieveSession: true,
-        importFunction: importModule,
-    });
-    const result = await createGenerator.next();
-    if (result.done === true) {
-        const r = result.value;
-        if (r.isErr()) {
-            return r.error.apiResponse;
-        }
-        return {
-            status: 200,
-            body: { ...r.value.session, status: 200 },
-        };
-    }
-    authSessionsContextsStore.set(operationId, {
-        done: false,
-        generator: createGenerator,
-        requestInfo: result.value,
-        abortController,
-    });
-    return {
-        status: 200,
-        body: result.value,
-    };
-}

package/WebTemplate/controllers/authSessions/index.js

@@ -1,25 +0,0 @@
-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.js

@@ -1,26 +0,0 @@
-import { authSessionsContextsStore } from "./store";
-export async function killAuthSessionOperation({ operationId, }) {
-    const operation = authSessionsContextsStore.get(operationId);
-    if (!operation) {
-        return {
-            status: 200,
-            body: {
-                done: true,
-            },
-        };
-    }
-    try {
-        operation.abortController.abort();
-        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.js

@@ -1,42 +0,0 @@
-import { authSessionsContextsStore } from "./store";
-export async function resumeAuthSessionOperation({ operationId, input, }) {
-    const operation = authSessionsContextsStore.get(operationId);
-    if (!operation) {
-        return {
-            status: 404,
-            body: {
-                error: "Invalid Request",
-                message: "operation not found",
-            },
-        };
-    }
-    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);
-    if (result.done) {
-        authSessionsContextsStore.delete(operationId);
-        if (result.value.isErr()) {
-            return result.value.error.apiResponse;
-        }
-        return {
-            status: 200,
-            body: result.value.value.session,
-        };
-    }
-    authSessionsContextsStore.set(operationId, {
-        ...operation,
-        requestInfo: result.value,
-    });
-    return {
-        status: 200,
-        body: result.value,
-    };
-}

package/WebTemplate/controllers/authSessions/store.js

@@ -1 +0,0 @@
-export const authSessionsContextsStore = new Map();

package/WebTemplate/controllers/controllers.js

@@ -1,30 +0,0 @@
-import { AsyncRunEndpointController } from "../utils";
-import { runEndpointAsync } from "./async";
-export function makeSyncEndpointController({ handler, parameters, }) {
-    return async (req, res) => {
-        const { status, body } = await handler(...(typeof parameters === "function" ? parameters(req) : parameters));
-        res.status(status).json(body);
-    };
-}
-export function makeAsyncEndpointController({ requestId, handler, parameters, }) {
-    return async (req, res) => {
-        const { taskToken, startTime, functionsToken } = req.body;
-        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({ requestId, handler, parameters, }) {
-    return {
-        sync: makeSyncEndpointController({ handler, parameters }),
-        async: makeAsyncEndpointController({ requestId, handler, parameters }),
-    };
-}

package/WebTemplate/controllers/runApi/helpers.js

@@ -1,90 +0,0 @@
-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";
-import { runApi as runApiInternal } from "@intuned/runtime/dist/common/runApi";
-export async function runApi({ session, params, proxy, functionsToken, runId, attemptNumber, functionName, shouldSaveTrace, headless = true, }) {
-    const isAuthSessionEnabled = (await fs.readJSON("./Intuned.json"))
-        .authSessions?.enabled;
-    if (!runId) {
-        return {
-            status: 400,
-            body: {
-                error: "runId header not provided",
-                message: "Please add provide run id to header",
-            },
-        };
-    }
-    backendFunctionsTokenManager.token = functionsToken;
-    // handle timeout
-    const requestTimeout = +(process.env.REQUEST_TIMEOUT ?? 600) * 1000;
-    getExecutionContext().timeoutInfo = {
-        ...(getExecutionContext()?.timeoutInfo ?? {}),
-        timeoutDuration: requestTimeout,
-    };
-    async function handleTimeout() {
-        console.log("timeout triggered");
-        return {
-            status: 508,
-            body: {
-                error: "TimeoutError",
-                message: "The request timed out",
-            },
-        };
-    }
-    const abortController = new AbortController();
-    const resultWithTimeout = await waitWithExtendableTimeout({
-        promise: runApiInternal({
-            automationFunction: {
-                name: `api/${functionName}`,
-                params,
-            },
-            auth: isAuthSessionEnabled
-                ? {
-                    session: {
-                        type: "state",
-                        state: session,
-                    },
-                    runCheck: isAuthSessionEnabled,
-                }
-                : undefined,
-            runOptions: {
-                environment: "deployed",
-                headless,
-                proxy,
-            },
-            tracing: shouldSaveTrace
-                ? {
-                    enabled: true,
-                    filePath: getTraceFilePath(runId, attemptNumber),
-                }
-                : { enabled: false },
-            functionsToken,
-            abortSignal: abortController.signal,
-            importFunction: importModule,
-        }),
-        initialTimeout: requestTimeout,
-        abortController,
-    });
-    if (resultWithTimeout.timedOut === true) {
-        return await handleTimeout();
-    }
-    const { result } = resultWithTimeout;
-    if (result.isErr()) {
-        if (result.error.code === "AbortedError") {
-            return await handleTimeout();
-        }
-        return result.error.apiResponse;
-    }
-    return {
-        status: 200,
-        body: {
-            status: 200,
-            result: result.value.result,
-            payloadToAppend: result.value.extendedPayloads?.map(({ api, parameters }) => ({
-                apiName: api,
-                parameters,
-            })),
-        },
-    };
-}