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

package/InterfaceTemplate/index.js

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

package/WebTemplate/accessKeyHelpers.js

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,69 @@
+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

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,42 @@
+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/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/authSessions/store.js

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

package/WebTemplate/controllers/controllers.js

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,90 @@
+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,
+            })),
+        },
+    };
+}

package/WebTemplate/controllers/runApi/index.js

@@ -0,0 +1,45 @@
+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 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;
+        const runId = req.headers[RUN_ID_HEADER];
+        const attemptNumber = req.headers[ATTEMPT_NUMBER_HEADER];
+        const shouldSaveTrace = req.query.saveTrace === "true";
+        const headless = isHeadless();
+        const result = [
+            {
+                session,
+                params,
+                proxy,
+                executionContext,
+                functionsToken,
+                runId,
+                attemptNumber,
+                functionName,
+                shouldSaveTrace,
+                headless,
+            },
+        ];
+        return result;
+    },
+    handler: async (parameters) => {
+        const { status, body } = await runApi(parameters);
+        return { status, body };
+    },
+});
+export const getActiveAsyncEndpointController = async (req, res) => {
+    res
+        .status(200)
+        .json({ count: AsyncRunEndpointController.activeRequestsCount });
+};

package/WebTemplate/controllers/runApi/types.js

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

package/WebTemplate/controllers/traces.js

@@ -0,0 +1,108 @@
+import { getTraceFilePath } from "../utils";
+import { pathExists, remove, createReadStream, stat } from "fs-extra";
+import fetch from "node-fetch";
+import { ok, err } from "neverthrow";
+export async function uploadTrace({ runId, attemptNumber, signedUrl, }) {
+    const traceFilePath = getTraceFilePath(runId, attemptNumber);
+    if (!(await pathExists(traceFilePath))) {
+        return err({
+            message: "Trace file not found",
+            error: "Not found",
+            errorCode: "trace_file_not_found",
+        });
+    }
+    const fileSize = (await stat(traceFilePath)).size;
+    const file = createReadStream(traceFilePath);
+    const response = await fetch(signedUrl, {
+        method: "PUT",
+        headers: {
+            "Content-Length": fileSize.toString(),
+        },
+        body: file,
+    });
+    if (!response.ok) {
+        return err({
+            message: `Upload trace failed with status code ${response.status}`,
+            error: "Upload trace failed",
+            errorCode: "upload_trace_failed",
+        });
+    }
+    return ok({
+        traceName: `${runId}.zip`,
+    });
+}
+export async function deleteTrace({ runId, attemptNumber, }) {
+    const traceFilePath = getTraceFilePath(runId, attemptNumber);
+    if (!(await pathExists(traceFilePath))) {
+        return err({
+            message: "Trace file not found",
+            error: "Not found",
+            errorCode: "trace_file_not_found",
+        });
+    }
+    try {
+        await remove(traceFilePath);
+        return ok(undefined);
+    }
+    catch (error) {
+        return err({
+            message: `Delete trace file failed ${runId}`,
+            error: "Delete trace failed",
+            errorCode: "delete_trace_failed",
+        });
+    }
+}
+export const uploadTraceController = async (req, res) => {
+    const { runId } = req.params;
+    const { attemptNumber } = req.query;
+    const signedUrl = req.body.signedUrl;
+    if (!runId) {
+        return res.status(400).json({
+            error: "runId not provided",
+            message: "Please add provide run id",
+        });
+    }
+    if (!signedUrl) {
+        return res.status(400).json({
+            error: "signedUrl not provided",
+            message: "Please add provide signedUrl",
+        });
+    }
+    const uploadTraceResult = await uploadTrace({
+        runId,
+        attemptNumber: attemptNumber,
+        signedUrl,
+    });
+    if (uploadTraceResult.isOk()) {
+        return res.status(200).json({
+            result: uploadTraceResult.value,
+        });
+    }
+    const error = uploadTraceResult.error;
+    if (error.errorCode === "trace_file_not_found") {
+        return res.status(404).json(error);
+    }
+    return res.status(500).json(error);
+};
+export const deleteTraceController = async (req, res) => {
+    const { runId } = req.params;
+    const { attemptNumber } = req.query;
+    if (!runId) {
+        return res.status(400).json({
+            error: "runId not provided",
+            message: "Please add provide run id",
+        });
+    }
+    const deleteTraceResult = await deleteTrace({
+        runId,
+        attemptNumber: attemptNumber,
+    });
+    if (deleteTraceResult.isOk()) {
+        return res.status(204).send("");
+    }
+    const error = deleteTraceResult.error;
+    if (error.errorCode === "trace_file_not_found") {
+        return res.status(404).json(error);
+    }
+    return res.status(500).json(error);
+};

package/WebTemplate/features.js

@@ -0,0 +1,6 @@
+// sync with apps/web/lib/Services/IntegrationService/constants.ts
+export const FEATURES = [
+    "JOBS-V3",
+    "RUN-ASYNC-MODE",
+    "AUTH-SESSION-ASYNC-MODE",
+];