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

package/WebTemplate/api.ts

@@ -1,139 +0,0 @@
-import {
-  errorRetryMiddleware,
-  proxyToUrl,
-  ProxyConfig,
-  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] 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" });
-    }
-  );
-
-  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.ts

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

@@ -1,142 +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";
-import { Handler } from "@tinyhttp/app";
-import { RequestHandler } from "./controllers";
-
-export async function runEndpointAsync<_Parameters extends any[], _Result>(
-  handler: RequestHandler<_Parameters, _Result>,
-  parameters: _Parameters,
-  endpointParameters: {
-    functionsToken: string;
-    taskToken: string;
-    startTime: number;
-    // only used for logging
-    requestId?: string;
-  }
-): Promise<{
-  status: number;
-  body: _Result;
-}> {
-  const {
-    functionsToken,
-    taskToken,
-    startTime,
-    requestId = "endpoint",
-  } = endpointParameters;
-  AsyncRunEndpointController.addRequest(taskToken);
-
-  backendFunctionsTokenManager.token = functionsToken;
-
-  let status: number, body: _Result;
-  try {
-    console.log("Running", requestId, "in async mode");
-    ({ status, body } = await handler(...parameters));
-    console.log("Finished running", requestId, "in async mode");
-  } catch (e: any) {
-    console.error(`Error running ${requestId} in async mode:`, e);
-    ({ status, body } = getErrorResponse(e));
-  }
-
-  try {
-    // 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);
-          }
-
-          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();
-  return { status, body };
-}
-
-export type AsyncEndpointBody<T = unknown> = T & {
-  functionsToken: string;
-  taskToken: string;
-  startTime: number;
-};
-
-export function makeAsyncEndpointController<_Parameters extends any[]>({
-  requestId,
-  handler,
-  parameters,
-}: {
-  requestId: string | ((req: any) => string);
-  handler: RequestHandler<_Parameters, any>;
-  parameters: _Parameters | ((req: any) => _Parameters);
-}): Handler {
-  return async (req, res) => {
-    const { taskToken, startTime, functionsToken } =
-      req.body as AsyncEndpointBody<_Parameters>;
-    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.ts

@@ -1,61 +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,
-}: {
-  mode: "async" | "sync";
-  session: any;
-  proxy?: {
-    server: string;
-    username: string;
-    password: string;
-  };
-}): Promise<{
-  status: number;
-  body: any;
-}> {
-  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<boolean>({
-    automationFunction: {
-      name: "auth-sessions/check",
-    },
-    runOptions: {
-      environment: "standalone",
-      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.ts

@@ -1,101 +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";
-import type { RequestMoreInfoDetails } from "@intuned/runtime/dist/runtime";
-
-export async function createAuthSession({
-  parameters,
-  operationId,
-  proxy,
-  saveTrace,
-}: {
-  operationId: string;
-  mode: "async" | "sync";
-  parameters: object | null | undefined;
-  proxy?: {
-    server: string;
-    username: string;
-    password: string;
-  };
-  saveTrace: boolean;
-}) {
-  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<
-    void,
-    RequestMoreInfoDetails,
-    unknown
-  >({
-    automationFunction: {
-      name: "auth-sessions/create",
-      params: parameters,
-    },
-    tracing: saveTrace
-      ? {
-          enabled: true,
-          filePath: getTraceFilePath(operationId),
-        }
-      : { enabled: false },
-    runOptions: {
-      environment: "standalone",
-      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.ts

@@ -1,41 +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): [any] => [req.body],
-});
-
-export const {
-  sync: checkAuthSessionController,
-  async: checkAuthSessionAsyncController,
-} = makeEndpointControllers({
-  requestId: "checkAuthSession",
-  handler: checkAuthSession,
-  parameters: (req): [any] => [req.body],
-});
-
-export const {
-  sync: killAuthSessionOperationController,
-  async: killAuthSessionOperationAsyncController,
-} = makeEndpointControllers({
-  requestId: (req) => `killAuthSessionOperation ${req.body.operationId}`,
-  handler: killAuthSessionOperation,
-  parameters: (req): [any] => [req.body],
-});
-
-export const {
-  sync: resumeAuthSessionOperationController,
-  async: resumeAuthSessionOperationAsyncController,
-} = makeEndpointControllers({
-  requestId: (req) => `resumeAuthSessionOperation ${req.body.operationId}`,
-  handler: resumeAuthSessionOperation,
-  parameters: (req): [any] => [req.body],
-});

package/WebTemplate/controllers/authSessions/killOperation.ts

@@ -1,35 +0,0 @@
-import { authSessionsContextsStore } from "./store";
-
-export async function killAuthSessionOperation({
-  operationId,
-}: {
-  operationId: string;
-}): Promise<{
-  status: number;
-  body: any;
-}> {
-  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.ts

@@ -1,56 +0,0 @@
-import { authSessionsContextsStore } from "./store";
-
-export async function resumeAuthSessionOperation({
-  operationId,
-  input,
-}: {
-  operationId: string;
-  input: string;
-}) {
-  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 === true) {
-    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.ts

@@ -1,19 +0,0 @@
-import type { RequestMoreInfoDetails } from "@intuned/runtime/dist/runtime";
-import type {
-  RunApiResult,
-  RunApiResultWithSessionOk,
-} from "@intuned/runtime/dist/common/runApi";
-
-export const authSessionsContextsStore = new Map<
-  string,
-  {
-    done: boolean | undefined;
-    generator: AsyncGenerator<
-      RequestMoreInfoDetails,
-      RunApiResult<void, RunApiResultWithSessionOk>,
-      string
-    >;
-    requestInfo: RequestMoreInfoDetails;
-    abortController: AbortController;
-  }
->();

package/WebTemplate/controllers/controllers.ts

@@ -1,73 +0,0 @@
-import { AsyncRunEndpointController } from "../utils";
-import { Handler } from "@tinyhttp/app";
-import { AsyncEndpointBody, runEndpointAsync } from "./async";
-
-export type RequestHandler<P extends any[], R> = (...parameters: P) => Promise<{
-  status: number;
-  body: R;
-}>;
-
-export function makeSyncEndpointController<_Parameters extends any[], _Result>({
-  handler,
-  parameters,
-}: {
-  handler: RequestHandler<_Parameters, any>;
-  parameters: _Parameters | ((req: any) => _Parameters);
-}): Handler {
-  return async (req, res) => {
-    const { status, body } = await handler(
-      ...(typeof parameters === "function" ? parameters(req) : parameters)
-    );
-    res.status(status).json(body);
-  };
-}
-
-export function makeAsyncEndpointController<_Parameters extends any[]>({
-  requestId,
-  handler,
-  parameters,
-}: {
-  requestId: string | ((req: any) => string);
-  handler: RequestHandler<_Parameters, any>;
-  parameters: _Parameters | ((req: any) => _Parameters);
-}): Handler {
-  return async (req, res) => {
-    const { taskToken, startTime, functionsToken } =
-      req.body as AsyncEndpointBody<_Parameters>;
-    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<_Parameters extends any[]>({
-  requestId,
-  handler,
-  parameters,
-}: {
-  requestId: string | ((req: any) => string);
-  handler: RequestHandler<_Parameters, any>;
-  parameters: _Parameters | ((req: any) => _Parameters);
-}): {
-  sync: Handler;
-  async: Handler;
-} {
-  return {
-    sync: makeSyncEndpointController({ handler, parameters }),
-    async: makeAsyncEndpointController({ requestId, handler, parameters }),
-  };
-}