@intuned/runtime-dev 1.3.1-api-token.6 → 1.3.3-fix.0

package/dist/commands/api/run.js

@@ -48,8 +48,7 @@ async function executeCLI(apiName, mode, inputData, options) {
       session: {
         type: "file",
         path: authSessionPathToUse
-      },
-      runCheck: false
+      }
     } : undefined,
     runOptions: {
       environment: "cdp",
@@ -78,7 +77,10 @@ async function executeCLI(apiName, mode, inputData, options) {
     _Logger.logger.info(_chalk.default.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
     fs.ensureDirSync(resultsDir);
     const path = `${resultsDir}/${options.outputFileId}.json`;
-    await fs.writeJson(path, result, {
+    await fs.writeJson(path, {
+      input: inputData,
+      output: result
+    }, {
       spaces: 2
     });
   } else {

package/dist/commands/auth-sessions/load.js

@@ -2,7 +2,7 @@
 "use strict";
 
 var _commander = require("commander");
-var _getPlaywrightConstructs = require("../../common/getPlaywrightConstructs");
+var _playwrightContext = require("../../common/playwrightContext");
 var _settings = require("../common/utils/settings");
 var _dotenv = _interopRequireDefault(require("dotenv"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -19,8 +19,8 @@ _commander.program.description("load auth session to browser").option("--cdpAddr
   }
   const {
     context
-  } = await (0, _getPlaywrightConstructs.getRemotePlaywrightContext)(cdpAddress);
-  await (0, _getPlaywrightConstructs.loadSessionToContext)({
+  } = await (0, _playwrightContext.getRemotePlaywrightContext)(cdpAddress);
+  await (0, _playwrightContext.loadSessionToContext)({
     context,
     session: {
       type: "file",

package/dist/commands/auth-sessions/run-check.js

@@ -54,8 +54,7 @@ _commander.program.description("run auth session check").option("--cdpAddress <c
       session: {
         type: "file",
         path: authSessionPath
-      },
-      runCheck: false
+      }
     },
     importFunction: _tsNodeImport.tsNodeImport
   }));

package/dist/commands/auth-sessions/run-create.js

@@ -3,7 +3,6 @@
 
 var _commander = require("commander");
 var fs = _interopRequireWildcard(require("fs-extra"));
-var _promptly = require("promptly");
 var _fileUtils = require("../common/utils/fileUtils");
 var _settings = require("../common/utils/settings");
 var _dotenv = _interopRequireDefault(require("dotenv"));
@@ -42,7 +41,7 @@ _commander.program.description("run auth session create").option("--cdpAddress <
     throw new Error("auth session create file not found");
   }
   async function runCreate() {
-    const generator = (0, _runApi.runApiGenerator)({
+    const result = await (0, _runApi.runApi)({
       automationFunction: {
         name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`,
         params: inputData
@@ -55,40 +54,18 @@ _commander.program.description("run auth session create").option("--cdpAddress <
       retrieveSession: true,
       importFunction: _tsNodeImport.tsNodeImport
     });
-    let nextGeneratorParam = undefined;
-    while (true) {
-      const {
-        value,
-        done
-      } = await generator.next(...(nextGeneratorParam ? [nextGeneratorParam] : []));
-      if (done) {
-        if (value.isErr()) {
-          if (value.error instanceof _runApi.AutomationError) {
-            throw value.error.error;
-          }
-          console.error(value.error);
-          throw new Error("Error while running create");
-        }
-        const fullState = value.value.session;
-        if (pathToSave) {
-          const fullPath = (0, _fileUtils.getFullPathInProject)(pathToSave);
-          fs.ensureFileSync(fullPath);
-          await fs.writeJSON(fullPath, fullState);
-        }
-        break;
-      }
-      if (value.action === "request_more_info" && value.requestType == "multiple_choice") {
-        nextGeneratorParam = await (0, _promptly.prompt)(value.messageToUser + `, choices: ${value.choices}`, {
-          validator: input => {
-            if (!value.choices.includes(input)) {
-              throw new Error("Please type on of the allowed choices");
-            }
-            return input;
-          }
-        });
-      } else if (value.action === "request_more_info" && value.requestType == "otp") {
-        nextGeneratorParam = await (0, _promptly.prompt)(value.messageToUser, {});
+    if (result.isErr()) {
+      if (result.error instanceof _runApi.AutomationError) {
+        throw result.error.error;
       }
+      console.error(result.error);
+      throw new Error("Error while running create");
+    }
+    const fullState = result.value.session;
+    if (pathToSave) {
+      const fullPath = (0, _fileUtils.getFullPathInProject)(pathToSave);
+      fs.ensureFileSync(fullPath);
+      await fs.writeJSON(fullPath, fullState);
     }
   }
   await (0, _asyncLocalStorage.runWithContext)({

package/dist/commands/interface/run.d.ts

@@ -1 +1 @@
-export declare function runAutomationCLI(importFunction?: (path: string) => Promise<any>): void;
+export declare function runAutomationCLI<ResultType = any>(importFunction?: (path: string) => Promise<any>): void;

package/dist/commands/interface/run.js

@@ -64,15 +64,10 @@ function runAutomationCLI(importFunction) {
     const throttleTime = 60 * 1000;
     let timeoutTimestamp = Date.now();
     const client = net.createConnection(socketPath);
-    let generator = null;
     const abortController = new AbortController();
-    client.on("error", err => {
-      void generator?.throw(err).catch(() => undefined);
-    });
     const interruptSignalHandler = async () => {
       abortController.abort();
       await (0, _promises.setTimeout)(60_000);
-      void generator?.throw(new Error("Interrupted")).catch(() => undefined);
       client.end();
       process.exit(1);
     };
@@ -107,11 +102,6 @@ function runAutomationCLI(importFunction) {
         return;
       }
       if (message.type === "start") {
-        generator = (0, _runApi.runApiGenerator)({
-          ...message.parameters,
-          abortSignal: abortController.signal,
-          importFunction: importFunction ?? _defaultImport
-        });
         context = {
           extendedPayloads: [],
           runEnvironment: message.parameters.runOptions.environment === "standalone" ? _enums.RunEnvironment.DEPLOYED : _enums.RunEnvironment.IDE,
@@ -130,38 +120,18 @@ function runAutomationCLI(importFunction) {
         };
         _jwtTokenManager.backendFunctionsTokenManager.token = message.parameters.functionsToken;
         resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
-          return await generator.next();
+          return await (0, _runApi.runApi)({
+            ...message.parameters,
+            abortSignal: abortController.signal,
+            importFunction: importFunction ?? _defaultImport
+          });
         });
         return;
       }
       if (message.type === "next") {
-        if (!generator) {
-          throw new Error("generator not started");
-        }
-        resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
-          return await generator.next(message.parameters.value);
-        });
-        return;
+        throw new Error("next not supported anymore");
       }
     }
-    async function handleResult(generatorResult) {
-      if (!generatorResult.done) {
-        jsonUnixSocket.sendJSON({
-          type: "yield",
-          result: generatorResult.value
-        });
-        return false;
-      }
-      const result = generatorResult.value;
-      const success = result.isOk();
-      const resultToSend = success ? result.value : result.error.json;
-      jsonUnixSocket.sendJSON({
-        type: "done",
-        result: resultToSend,
-        success
-      });
-      return true;
-    }
     let receiveMessagesPromise = receiveMessages();
     while (true) {
       const messageOrResult = await Promise.race([receiveMessagesPromise.then(message => ({
@@ -199,10 +169,14 @@ function runAutomationCLI(importFunction) {
       const {
         result
       } = messageOrResult;
-      const done = await handleResult(result);
-      if (done) {
-        break;
-      }
+      const success = result.isOk();
+      const resultToSend = success ? result.value : result.error.json;
+      jsonUnixSocket.sendJSON({
+        type: "done",
+        result: resultToSend,
+        success
+      });
+      break;
     }
     if (!client.closed) {
       client.end();

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -1,7 +1,8 @@
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
-    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
+    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
+} & {
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, "strip", import("zod").ZodTypeAny, {

package/dist/commands/intuned-cli/commands/types.d.ts

@@ -15,7 +15,7 @@ export declare const baseCommandOptionsSchema: z.ZodObject<{
     proxy?: string | undefined;
 }, {
     proxy?: string | undefined;
-    timeout?: string | undefined;
     headless?: boolean | undefined;
+    timeout?: string | undefined;
 }>;
 export type BaseCommandOptions = z.infer<typeof baseCommandOptionsSchema>;

package/dist/commands/intuned-cli/controller/__test__/api.test.js

@@ -84,8 +84,7 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
           session: {
             type: "state",
             state: "auth"
-          },
-          runCheck: false
+          }
         },
         importFunction: _vitest.expect.anything()
       }));

package/dist/commands/intuned-cli/controller/api.js

@@ -159,8 +159,7 @@ async function attemptApi({
         session: {
           type: "state",
           state: auth
-        },
-        runCheck: false
+        }
       } : undefined,
       importFunction: _tsNodeImport.tsNodeImport,
       abortSignal

package/dist/commands/intuned-cli/controller/authSession.js

@@ -179,8 +179,7 @@ async function runCheck({
         session: {
           type: "state",
           state: auth
-        },
-        runCheck: false
+        }
       },
       importFunction: _tsNodeImport.tsNodeImport,
       abortSignal
@@ -241,7 +240,7 @@ async function runCheckWithRetries({
         return true;
       }
     } catch (error) {
-      if (error instanceof _runApi.AutomationError) {
+      if (error instanceof _runApi.RunAutomationError) {
         (0, _helpers.logAutomationError)(error);
       } else {
         throw error;
@@ -270,7 +269,7 @@ async function runCreateWithRetries({
       (0, _terminal.terminal)(`^+^gAuth session create succeeded^:\n`);
       break;
     } catch (error) {
-      if (error instanceof _runApi.AutomationError) {
+      if (error instanceof _runApi.RunAutomationError) {
         (0, _helpers.logAutomationError)(error);
       } else {
         throw error;

package/dist/commands/intuned-cli/controller/save.js

@@ -53,7 +53,7 @@ async function runSaveProject(projectName, auth) {
       contents: JSON.stringify(_constants.tsConfigCli, null, 2)
     }
   };
-  const deployProjectPayload = {
+  const saveProjectPayload = {
     codeTree,
     platformType: "CLI",
     language: "typescript"
@@ -61,13 +61,13 @@ async function runSaveProject(projectName, auth) {
   const response = await fetch(url, {
     headers,
     method: "PUT",
-    body: JSON.stringify(deployProjectPayload)
+    body: JSON.stringify(saveProjectPayload)
   });
   if (!response.ok) {
     if (response.status === 401) {
       throw new _helpers.CLIError(`Invalid API key. Please check your API key and try again.`);
     }
-    throw new _helpers.CLIError(`^r^+Invalid response from server\n^:^R${response.status} ${await response.text()}^:\n^r^+Project deployment failed^:\n`, {
+    throw new _helpers.CLIError(`^r^+Invalid response from server\n^:^R${response.status} ${await response.text()}^:\n^r^+Project save failed^:\n`, {
       autoColor: false
     });
   }
@@ -83,29 +83,28 @@ async function runSaveProject(projectName, auth) {
     id: projectId
   } = parseResult.data;
   const dotEnvPath = path.join(projectPath, ".env");
-  if (await fs.exists(dotEnvPath)) {
-    const envContent = await fs.readFile(dotEnvPath, "utf-8");
-    const dotenvContent = dotenv.parse(envContent);
-    let contentToAppend = "";
-    if (!dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] || dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] !== projectId) {
-      contentToAppend += `\n${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}`;
-    }
-    if (!dotenvContent[_constants2.WORKSPACE_ID_ENV_VAR_KEY]) {
-      contentToAppend += `\n${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}`;
-    }
-    if (!dotenvContent[_constants2.API_KEY_ENV_VAR_KEY]) {
-      contentToAppend += `\n${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`;
-    }
-    if (contentToAppend) {
-      await fs.appendFile(dotEnvPath, contentToAppend + "\n");
-      (0, _terminal.terminal)(`^g^+Updated .env file with project credentials.^:\n`);
-    }
-  } else {
+  if (!(await fs.exists(dotEnvPath))) {
     await fs.writeFile(dotEnvPath, `${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}
 ${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}
 ${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`);
     (0, _terminal.terminal)(`^g^+Created .env file with project credentials.^:\n`);
   }
+  const envContent = await fs.readFile(dotEnvPath, "utf-8");
+  const dotenvContent = dotenv.parse(envContent);
+  let contentToAppend = "";
+  if (!dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] || dotenvContent[_constants2.PROJECT_ID_ENV_VAR_KEY] !== projectId) {
+    contentToAppend += `\n${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}`;
+  }
+  if (!dotenvContent[_constants2.WORKSPACE_ID_ENV_VAR_KEY]) {
+    contentToAppend += `\n${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}`;
+  }
+  if (!dotenvContent[_constants2.API_KEY_ENV_VAR_KEY]) {
+    contentToAppend += `\n${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`;
+  }
+  if (contentToAppend) {
+    await fs.appendFile(dotEnvPath, contentToAppend + "\n");
+    (0, _terminal.terminal)(`^g^+Updated .env file with project credentials.^:\n`);
+  }
 }
 const projectNameSchema = exports.projectNameSchema = _zod.z.string().min(1, "Project Name is required").max(50, "Name must be 50 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Name can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
   message: "Name cannot be a UUID"
@@ -124,7 +123,7 @@ const validateProjectName = projectName => {
 };
 exports.validateProjectName = validateProjectName;
 const validateIntunedProject = async () => {
-  const currentDirectoryToDeploy = process.cwd();
+  const currentDirectoryToSave = process.cwd();
   const validationSteps = [{
     name: "build",
     check: async () => {
@@ -150,7 +149,7 @@ const validateIntunedProject = async () => {
     name: "package.json",
     check: async () => {
       try {
-        const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
+        const packageJsonPath = path.join(currentDirectoryToSave, "package.json");
         await fs.exists(packageJsonPath);
         const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
           encoding: "utf-8"
@@ -176,7 +175,7 @@ const validateIntunedProject = async () => {
     name: "Intuned.json",
     check: async () => {
       try {
-        const intunedJsonPath = path.join(currentDirectoryToDeploy, "Intuned.json");
+        const intunedJsonPath = path.join(currentDirectoryToSave, "Intuned.json");
         await fs.exists(intunedJsonPath);
         return {
           isValid: true
@@ -192,7 +191,7 @@ const validateIntunedProject = async () => {
     name: "api folder",
     check: async () => {
       try {
-        const apiFolderPath = path.join(currentDirectoryToDeploy, "api");
+        const apiFolderPath = path.join(currentDirectoryToSave, "api");
         await fs.access(apiFolderPath);
         return {
           isValid: true
@@ -262,10 +261,10 @@ function listFilesNotIgnored(projectPath, ignorePatterns) {
   return results;
 }
 async function convertProjectToCodeTree(projectPath) {
-  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
-  const filesToDeployText = "  " + filesToDeploy.join("\n  ");
+  const filesToSave = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  const filesToSaveText = "  " + filesToSave.join("\n  ");
   (0, _terminal.terminal)("^CFiles to be saved:^:\n");
-  (0, _terminal.terminal)(filesToDeployText + "\n");
+  (0, _terminal.terminal)(filesToSaveText + "\n");
   function readDirectory(dirPath) {
     const tree = {};
     try {

package/dist/commands/intuned-cli/helpers/errors.d.ts

@@ -1,4 +1,4 @@
-import { AutomationError } from "../../../common/runApi";
+import { RunAutomationError } from "../../../common/runApi";
 export declare class CLIError extends Error {
     autoColor: boolean;
     constructor(message: string, options?: {
@@ -10,5 +10,5 @@ export declare class CLIAssertionError extends CLIError {
         autoColor?: boolean;
     });
 }
-export declare function logAutomationError(error: AutomationError): void;
+export declare function logAutomationError(error: RunAutomationError): void;
 export declare function withErrorLogging<T extends any[]>(fn: (...args: T) => Promise<unknown>): (...args: T) => Promise<never>;

package/dist/commands/intuned-cli/helpers/errors.js

@@ -25,11 +25,15 @@ class CLIAssertionError extends CLIError {
 exports.CLIAssertionError = CLIAssertionError;
 function logAutomationError(error) {
   (0, _terminal.terminal)(`^r^+An error occurred while running the API:^:\n`);
-  if (error.error.stack) {
-    const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
-    (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+  if (error instanceof _runApi.AutomationError) {
+    if (error.error.stack) {
+      const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
+      (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+    } else {
+      (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    }
   } else {
-    (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    (0, _terminal.terminal)(`^r${error.message}^:\n`);
   }
 }
 function withErrorLogging(fn) {

package/dist/commands/intuned-cli/main.js

@@ -10,9 +10,9 @@ _dotenv.default.config({
   path: `.env`
 });
 process.env[_constants.CLI_ENV_VAR_KEY] = "true";
-process.env.RUN_ENVIRONMENT = "authoring";
+process.env.RUN_ENVIRONMENT = "AUTHORING";
 if (!process.env.FUNCTIONS_DOMAIN) {
-  process.env.FUNCTIONS_DOMAIN = (0, _backend.getBaseUrl)();
+  process.env.FUNCTIONS_DOMAIN = (0, _backend.getBaseUrl)().replace(/\/$/, "");
 }
 _commands.program.configureHelp({
   sortSubcommands: true

package/dist/common/asyncLocalStorage/index.d.ts

@@ -9,6 +9,7 @@ interface TimeoutInfo {
 export interface InternalRunInfo extends RunInfo {
     extendedPayloads: Payload[];
     timeoutInfo?: TimeoutInfo;
+    store?: Record<string, any>;
     getAuthSessionParameters?: () => Promise<any>;
 }
 export declare function getExecutionContext(): InternalRunInfo | undefined;

package/dist/common/playwrightContext.d.ts

@@ -0,0 +1,54 @@
+import * as playwright from "playwright";
+import { RunAutomationError } from "./runApi/errors";
+import type { RunApiSession } from "./runApi/types";
+import { Err, Ok } from "neverthrow";
+import { type ImportFunction } from "./runApi/importUsingImportFunction";
+export interface Proxy {
+    server: string;
+    username: string;
+    password: string;
+}
+export declare function launchChromium(options: {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath?: string;
+    cdpPort?: number;
+}): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare function launchChromium(options: {
+    cdpAddress: string;
+}): Promise<{
+    page: playwright.Page;
+    context: playwright.BrowserContext;
+}>;
+export declare const browserScriptsFile: string;
+type WithPlaywrightContextParameters = {
+    importFunction: ImportFunction;
+    apiName: string;
+    apiParameters: any;
+} | {
+    importFunction?: undefined;
+    apiName?: undefined;
+    apiParameters?: undefined;
+};
+type WithPlaywrightContextWrappedFunctionReturn<R> = Ok<R, any> | Err<any, RunAutomationError>;
+export type WithPlaywrightContextWrappedFunction<R> = (context: playwright.BrowserContext, page: playwright.Page) => Promise<WithPlaywrightContextWrappedFunctionReturn<R>>;
+export declare function withPlaywrightContext<R>(options: {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function withPlaywrightContext<R>(options: {
+    cdpAddress: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function loadSessionToContext({ context, session, }: {
+    context: playwright.BrowserContext;
+    session: RunApiSession;
+}): Promise<void>;
+export declare function getRemotePlaywrightContext(cdpAddress: string): Promise<{
+    browser: playwright.Browser;
+    context: playwright.BrowserContext;
+}>;
+export {};