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

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,
-            })),
-        },
-    };
-}

package/WebTemplate/controllers/runApi/index.js

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

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

package/WebTemplate/controllers/traces.js

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

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

package/WebTemplate/headers.js

@@ -1,6 +0,0 @@
-export const RUN_ID_HEADER = "x-run-id";
-export const JOB_ID_HEADER = "x-job-id";
-export const JOB_RUN_ID_HEADER = "x-job-run-id";
-export const QUEUE_ID_HEADER = "x-queue-id";
-export const ATTEMPT_NUMBER_HEADER = "x-attempt-number";
-export const SHOULD_SHUTDOWN_HEADER = "x-should-shutdown";

package/WebTemplate/index.playwright.js

@@ -1,37 +0,0 @@
-import { initializeAppInsights, getTelemetryClient, } from "@intuned/runtime/dist/common/telemetry";
-import { getExecutionContext } from "@intuned/runtime";
-import { app } from "./app";
-import { RUN_ID_HEADER } from "./headers";
-import { ShutdownController } from "./shutdown";
-const port = process.env.PORT ? parseInt(process.env.PORT) : 4000;
-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();
-});
-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/index.vanilla.js

@@ -1,19 +0,0 @@
-import { App } from "@tinyhttp/app";
-import { json as parser } from "milliparsec";
-import { accessKeyValidatorMiddleware } from "./accessKeyHelpers";
-const port = process.env.PORT ? parseInt(process.env.PORT) : 4000;
-const app = new App();
-app.use("/", parser());
-app.post("/api/run/*", async (req, res) => {
-    return res.status(502).json({ message: "Not implemented" });
-});
-app.get("/api/health", async (req, res) => {
-    res.status(200).json({ status: "ok" });
-});
-app.use(accessKeyValidatorMiddleware);
-app.get("/protected/health", async (req, res) => {
-    res.status(200).json({ status: "ok" });
-});
-app.listen(port, () => {
-    console.log(`Server is running on port ${port}`);
-});