@intuned/runtime-dev 1.0.4-stuck.1 → 1.0.6-cli-auth.0.0.1

package/WebTemplate/controllers/runApi/helpers.ts

@@ -1,128 +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 { RunBody } from "./types";
-import { runApi as runApiInternal } from "@intuned/runtime/dist/common/runApi";
-
-export async function runApi({
-  session,
-  params,
-  proxy,
-  functionsToken,
-  runId,
-  attemptNumber,
-  functionName,
-  shouldSaveTrace,
-  headless = true,
-}: RunBody & {
-  runId: string;
-  attemptNumber: string | undefined;
-  functionName: string;
-  shouldSaveTrace: boolean;
-  headless?: boolean;
-}): Promise<{
-  status: number;
-  body: any;
-}> {
-  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();
-
-  backendFunctionsTokenManager.token = functionsToken;
-  const resultWithTimeout = await waitWithExtendableTimeout({
-    promise: runApiInternal({
-      automationFunction: {
-        name: `api/${functionName}`,
-        params,
-      },
-      auth: isAuthSessionEnabled
-        ? {
-            session: {
-              type: "state",
-              state: session,
-            },
-            runCheck: isAuthSessionEnabled,
-          }
-        : undefined,
-      runOptions: {
-        environment: "standalone",
-        headless,
-        proxy,
-      },
-      tracing: shouldSaveTrace
-        ? {
-            enabled: true,
-            filePath: getTraceFilePath(runId, attemptNumber),
-          }
-        : { enabled: false },
-      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.ts

@@ -1,68 +0,0 @@
-import { Handler } from "@tinyhttp/app";
-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 interface Proxy {
-  server: string;
-  username: string;
-  password: string;
-}
-
-export interface RunBody {
-  session: any;
-  params?: object;
-  proxy?: Proxy;
-  executionContext: any;
-  functionsToken: string;
-}
-
-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 as RunBody;
-      const runId = req.headers[RUN_ID_HEADER] as string;
-      const attemptNumber = req.headers[ATTEMPT_NUMBER_HEADER] as
-        | string
-        | undefined;
-      const shouldSaveTrace = req.query.saveTrace === "true";
-      const headless = isHeadless();
-      const result: Parameters<typeof runApi> = [
-        {
-          session,
-          params,
-          proxy,
-          executionContext,
-          functionsToken,
-          runId,
-          attemptNumber,
-          functionName,
-          shouldSaveTrace,
-          headless,
-        },
-      ];
-      return result;
-    },
-    handler: async (parameters: Parameters<typeof runApi>[0]) => {
-      const { status, body } = await runApi(parameters);
-      return { status, body };
-    },
-  });
-
-export const getActiveAsyncEndpointController: Handler = async (req, res) => {
-  res
-    .status(200)
-    .json({ count: AsyncRunEndpointController.activeRequestsCount });
-};

package/WebTemplate/controllers/runApi/types.ts

@@ -1,13 +0,0 @@
-export interface Proxy {
-  server: string;
-  username: string;
-  password: string;
-}
-
-export interface RunBody {
-  session: any;
-  params?: object;
-  proxy?: Proxy;
-  executionContext: any;
-  functionsToken: string;
-}

package/WebTemplate/controllers/traces.ts

@@ -1,151 +0,0 @@
-import { getTraceFilePath } from "../utils";
-import { pathExists, remove, createReadStream, stat } from "fs-extra";
-import fetch from "node-fetch";
-import { Handler } from "@tinyhttp/app";
-import { ok, err } from "neverthrow";
-
-export async function uploadTrace({
-  runId,
-  attemptNumber,
-  signedUrl,
-}: {
-  runId: string;
-  attemptNumber?: string;
-  signedUrl: string;
-}) {
-  const traceFilePath = getTraceFilePath(
-    runId,
-    attemptNumber as string | undefined
-  );
-
-  if (!(await pathExists(traceFilePath))) {
-    return err({
-      message: "Trace file not found",
-      error: "Not found",
-      errorCode: "trace_file_not_found" as const,
-    });
-  }
-
-  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" as const,
-    });
-  }
-
-  return ok({
-    traceName: `${runId}.zip`,
-  });
-}
-
-export async function deleteTrace({
-  runId,
-  attemptNumber,
-}: {
-  runId: string;
-  attemptNumber?: string;
-}) {
-  const traceFilePath = getTraceFilePath(
-    runId,
-    attemptNumber as string | undefined
-  );
-
-  if (!(await pathExists(traceFilePath))) {
-    return err({
-      message: "Trace file not found",
-      error: "Not found",
-      errorCode: "trace_file_not_found" as const,
-    });
-  }
-
-  try {
-    await remove(traceFilePath);
-    return ok(undefined);
-  } catch (error: any) {
-    return err({
-      message: `Delete trace file failed ${runId}`,
-      error: "Delete trace failed",
-      errorCode: "delete_trace_failed" as const,
-    });
-  }
-}
-
-export const uploadTraceController: Handler = async (req, res) => {
-  const { runId } = req.params;
-  const { attemptNumber } = req.query;
-
-  const signedUrl = req.body.signedUrl as string;
-  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 as string | undefined,
-    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: Handler = 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 as string | undefined,
-  });
-
-  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.ts

@@ -1,8 +0,0 @@
-// sync with apps/web/lib/Services/IntegrationService/constants.ts
-export const FEATURES = [
-  "JOBS-V3",
-  "RUN-ASYNC-MODE",
-  "AUTH-SESSION-ASYNC-MODE",
-] as const;
-
-export type Feature = (typeof FEATURES)[number];

package/WebTemplate/headers.ts

@@ -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.ts

@@ -1,47 +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.ts

@@ -1,26 +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}`);
-});