@intuned/runtime-dev 1.3.0-responseLimits.1 → 1.3.1-api-token.0

package/CHANGELOG.md

@@ -1,6 +1,7 @@
 # UNRELEASED
 
-- 
+# 1.3.0
+- Limit Automation response size to 2MB at MAX.
 
 # 1.2.0
 

package/dist/commands/intuned-cli/commands/deploy.command.js

@@ -6,19 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.deployCommand = void 0;
 var _command = require("./command");
 var _dotenv = _interopRequireDefault(require("dotenv"));
+var _save = require("../controller/save");
 var _deploy = require("../controller/deploy");
 var _helpers = require("../helpers");
-var _zod = require("zod");
+var _save2 = require("./save.command");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 _dotenv.default.config({
   path: `.env`
 });
-const deployCommandSchema = _zod.z.tuple([_zod.z.union([_zod.z.string(), _zod.z.undefined()]), _zod.z.object({
-  workspaceId: _zod.z.string().optional(),
-  apiKey: _zod.z.string().optional()
-})]);
-const deployCommand = exports.deployCommand = _command.program.command("deploy").description("Deploy an Intuned project to the platform").argument("[project-name]", "Name of the project to deploy").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.withErrorLogging)(async (inputProjectName, inputOptions) => {
-  const parseResult = deployCommandSchema.safeParse([inputProjectName, inputOptions]);
+const deployCommand = exports.deployCommand = _command.program.command("deploy").description("Save and deploy an Intuned project to the platform").argument("[project-name]", "Name of the project to deploy").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.withErrorLogging)(async (inputProjectName, inputOptions) => {
+  const parseResult = _save2.saveOrDeployCommandSchema.safeParse([inputProjectName, inputOptions]);
   if (!parseResult.success) {
     return (0, _helpers.logInvalidInput)(parseResult);
   }
@@ -26,7 +23,7 @@ const deployCommand = exports.deployCommand = _command.program.command("deploy")
   const {
     isValid,
     errorMessage
-  } = await (0, _deploy.validateIntunedProject)();
+  } = await (0, _save.validateIntunedProject)();
   if (!isValid) {
     const message = `^r^+Project to be deployed is not a valid Intuned project:^:^R ${errorMessage}:\n`;
     throw new _helpers.CLIError(message, {
@@ -37,7 +34,7 @@ const deployCommand = exports.deployCommand = _command.program.command("deploy")
   if (!_projectName) {
     throw new _helpers.CLIError("Project name is required");
   }
-  const projectNameValidation = (0, _deploy.validateProjectName)(_projectName);
+  const projectNameValidation = (0, _save.validateProjectName)(_projectName);
   if (!projectNameValidation.isValid) {
     throw new _helpers.CLIError(projectNameValidation.errorMessage);
   }

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

@@ -1,6 +1,7 @@
 export * from "./command";
 export * from "./build.command";
 export * from "./deploy.command";
+export * from "./save.command";
 export * from "./init.command";
 export * from "./run.command";
 export * from "./run_api.command";

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

@@ -36,6 +36,17 @@ Object.keys(_deploy).forEach(function (key) {
     }
   });
 });
+var _save = require("./save.command");
+Object.keys(_save).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _save[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _save[key];
+    }
+  });
+});
 var _init = require("./init.command");
 Object.keys(_init).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const saveOrDeployCommandSchema: z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodUndefined]>, z.ZodObject<{
+    workspaceId: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workspaceId?: string | undefined;
+    apiKey?: string | undefined;
+}, {
+    workspaceId?: string | undefined;
+    apiKey?: string | undefined;
+}>], null>;
+export declare const saveCommand: import("commander").Command;

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveOrDeployCommandSchema = exports.saveCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _save = require("../controller/save");
+var _helpers = require("../helpers");
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+const saveOrDeployCommandSchema = exports.saveOrDeployCommandSchema = _zod.z.tuple([_zod.z.union([_zod.z.string(), _zod.z.undefined()]), _zod.z.object({
+  workspaceId: _zod.z.string().optional(),
+  apiKey: _zod.z.string().optional()
+})]);
+const saveCommand = exports.saveCommand = _command.program.command("save").description("Save an Intuned project to the platform without deploying it").argument("[project-name]", "Name of the project to save").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.withErrorLogging)(async (inputProjectName, inputOptions) => {
+  const parseResult = saveOrDeployCommandSchema.safeParse([inputProjectName, inputOptions]);
+  if (!parseResult.success) {
+    return (0, _helpers.logInvalidInput)(parseResult);
+  }
+  const [projectName, options] = parseResult.data;
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _save.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be saved is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.getSettingIntunedJSON)("projectName"));
+  if (!_projectName) {
+    throw new _helpers.CLIError("Project name is required");
+  }
+  const projectNameValidation = (0, _save.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(projectNameValidation.errorMessage);
+  }
+  const auth = await (0, _helpers.getAuthCredentials)(options);
+  await (0, _save.runSaveProject)(_projectName, auth);
+}));

package/dist/commands/intuned-cli/controller/deploy.d.ts

@@ -1,15 +1,4 @@
 import { z } from "zod";
-import type { AuthCredentials, FileSystemTree } from "../types";
-export declare function convertProjectToCodeTree(projectPath: string): Promise<FileSystemTree>;
+import type { AuthCredentials } from "../types";
 export declare function runDeployProject(projectName: string, auth: AuthCredentials): Promise<void>;
 export declare const projectNameSchema: z.ZodEffects<z.ZodString, string, string>;
-export declare const validateProjectName: (projectName: string) => {
-    isValid: true;
-} | {
-    isValid: false;
-    errorMessage: string;
-};
-export declare const validateIntunedProject: () => Promise<{
-    isValid: boolean;
-    errorMessage?: string;
-}>;

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

@@ -3,147 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.convertProjectToCodeTree = convertProjectToCodeTree;
 exports.projectNameSchema = void 0;
 exports.runDeployProject = runDeployProject;
-exports.validateProjectName = exports.validateIntunedProject = void 0;
-var fs = _interopRequireWildcard(require("fs-extra"));
-var path = _interopRequireWildcard(require("path"));
-var _minimatch = require("minimatch");
 var _zod = require("zod");
-var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
 var _constants = require("../constants");
 var _helpers = require("../helpers");
-var _lodash = require("lodash");
-var _uuid = require("uuid");
 var _terminal = require("../helpers/terminal");
 var _promises = require("timers/promises");
 var _ms = _interopRequireDefault(require("ms"));
-var _build = require("./build");
+var _save = require("./save");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function ignoreFilesByPattern(filePath, patterns, projectPath) {
-  const relativePath = path.relative(projectPath, filePath);
-  if (relativePath.startsWith("node_modules")) {
-    return true;
-  }
-  for (const pattern of patterns) {
-    if (!pattern || pattern.startsWith("#")) continue;
-    if (pattern.startsWith("!")) {
-      if ((0, _minimatch.minimatch)(relativePath, pattern.substring(1))) {
-        return false;
-      }
-    } else if ((0, _minimatch.minimatch)(relativePath, pattern)) {
-      return true;
-    }
-  }
-  return false;
-}
-function listFilesNotIgnored(projectPath, ignorePatterns) {
-  const results = [];
-  function traverseDirectory(dirPath) {
-    try {
-      const entries = fs.readdirSync(dirPath);
-      for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry);
-        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
-          continue;
-        }
-        try {
-          const stats = fs.statSync(fullPath);
-          if (stats.isDirectory()) {
-            traverseDirectory(fullPath);
-          } else if (stats.isFile()) {
-            results.push(path.relative(projectPath, fullPath));
-          }
-        } catch (error) {
-          (0, _terminal.terminal)(`^yWarning: Could not access ${fullPath}^:\n`);
-        }
-      }
-    } catch (error) {
-      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
-    }
-  }
-  traverseDirectory(projectPath);
-  return results;
-}
-async function convertProjectToCodeTree(projectPath) {
-  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
-  const filesToDeployText = "  " + filesToDeploy.join("\n  ");
-  (0, _terminal.terminal)("^CFiles to be deployed:^:\n");
-  (0, _terminal.terminal)(filesToDeployText + "\n");
-  function readDirectory(dirPath) {
-    const tree = {};
-    try {
-      const entries = fs.readdirSync(dirPath);
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry);
-        if (ignoreFilesByPattern(entryPath, _projectExclusions.default, projectPath)) {
-          continue;
-        }
-        try {
-          const stats = fs.statSync(entryPath);
-          if (stats.isFile()) {
-            try {
-              const content = fs.readFileSync(entryPath, "utf-8");
-              tree[entry] = {
-                file: {
-                  contents: content
-                }
-              };
-            } catch (error) {
-              (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
-            }
-          } else if (stats.isDirectory()) {
-            const subTree = readDirectory(entryPath);
-            if (Object.keys(subTree).length > 0) {
-              tree[entry] = {
-                directory: subTree
-              };
-            }
-          }
-        } catch (error) {
-          (0, _terminal.terminal)(`^yWarning: Could not access ${entryPath}^:\n`);
-        }
-      }
-    } catch (error) {
-      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
-    }
-    return tree;
-  }
-  const tree = readDirectory(projectPath);
-  await mapToIDEParams(tree);
-  return tree;
-}
 async function runDeployProject(projectName, auth) {
+  await (0, _save.runSaveProject)(projectName, auth);
   const {
     workspaceId,
     apiKey
   } = auth;
   const baseUrl = (0, _helpers.getBaseUrl)();
-  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create`;
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}/deploy`;
   const headers = {
     "x-api-key": apiKey,
     "Content-Type": "application/json"
   };
-  const projectPath = process.cwd();
-  const codeTree = await convertProjectToCodeTree(projectPath);
-  codeTree["tsconfig.json"] = {
-    file: {
-      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
-    }
-  };
-  const deployProjectPayload = {
-    name: projectName,
-    codeTree,
-    isCli: true,
-    language: "typescript"
-  };
   const response = await fetch(url, {
     headers,
-    method: "POST",
-    body: JSON.stringify(deployProjectPayload)
+    method: "POST"
   });
   if (!response.ok) {
     if (response.status === 401) {
@@ -223,115 +107,9 @@ async function runDeployProject(projectName, auth) {
 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"
 });
-const validateProjectName = projectName => {
-  const validation = projectNameSchema.safeParse(projectName);
-  if (!validation.success) {
-    return {
-      isValid: false,
-      errorMessage: validation.error.errors[0].message
-    };
-  }
-  return {
-    isValid: true
-  };
-};
-exports.validateProjectName = validateProjectName;
-const validateIntunedProject = async () => {
-  const currentDirectoryToDeploy = process.cwd();
-  const validationSteps = [{
-    name: "build",
-    check: async () => {
-      try {
-        const buildResult = await (0, _build.runBuild)();
-        if (!buildResult) {
-          return {
-            isValid: false,
-            errorMessage: "Build failed"
-          };
-        }
-        return {
-          isValid: true
-        };
-      } catch (error) {
-        return {
-          isValid: false,
-          errorMessage: "Build failed"
-        };
-      }
-    }
-  }, {
-    name: "package.json",
-    check: async () => {
-      try {
-        const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
-        await fs.exists(packageJsonPath);
-        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
-          encoding: "utf-8"
-        }));
-        const userCodePlaywrightVersion = packageJson.dependencies?.playwright;
-        if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
-          return {
-            isValid: false,
-            errorMessage: `Playwright version mismatch: expected ${_constants.CURRENT_PLAYWRIGHT_VERSION}, found ${userCodePlaywrightVersion || "none"}`
-          };
-        }
-        return {
-          isValid: true
-        };
-      } catch (error) {
-        return {
-          isValid: false,
-          errorMessage: "Package.json file not found or cannot be read"
-        };
-      }
-    }
-  }, {
-    name: "Intuned.json",
-    check: async () => {
-      try {
-        const intunedJsonPath = path.join(currentDirectoryToDeploy, "Intuned.json");
-        await fs.exists(intunedJsonPath);
-        return {
-          isValid: true
-        };
-      } catch (error) {
-        return {
-          isValid: false,
-          errorMessage: "Intuned.json file not found"
-        };
-      }
-    }
-  }, {
-    name: "api folder",
-    check: async () => {
-      try {
-        const apiFolderPath = path.join(currentDirectoryToDeploy, "api");
-        await fs.access(apiFolderPath);
-        return {
-          isValid: true
-        };
-      } catch (error) {
-        return {
-          isValid: false,
-          errorMessage: "API folder not found"
-        };
-      }
-    }
-  }];
-  for (const step of validationSteps) {
-    const result = await step.check();
-    if (!result.isValid) {
-      return result;
-    }
-  }
-  return {
-    isValid: true
-  };
-};
-exports.validateIntunedProject = validateIntunedProject;
 const checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey) => {
   const baseUrl = (0, _helpers.getBaseUrl)();
-  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create/${projectName}/result`;
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}/deploy/result`;
   const headers = {
     "x-api-key": apiKey,
     "Content-Type": "application/json"
@@ -357,58 +135,4 @@ const checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey)
     status: "failed",
     message: `Deployment failed, please try again: ${data.message}`
   };
-};
-async function mapToIDEParams(tree) {
-  if (!tree) {
-    return;
-  }
-  if (!tree["parameters"] || "file" in tree["parameters"]) {
-    return;
-  }
-  const apiParametersMap = {};
-  const cliParameters = Object.keys(tree["parameters"].directory);
-  const ____testParameters = {
-    directory: {}
-  };
-  for (const parameterKey of cliParameters) {
-    const parameter = tree["parameters"].directory[parameterKey];
-    if ("directory" in parameter) {
-      continue;
-    }
-    if ((0, _lodash.isEmpty)(parameter.file.contents)) {
-      continue;
-    }
-    const parameterPayload = JSON.parse(parameter.file.contents);
-    if (!parameterPayload["__api-name"]) {
-      continue;
-    }
-    const api = parameterPayload["__api-name"];
-    const {
-      "__api-name": _,
-      ...parameterValue
-    } = parameterPayload;
-    const testParameter = {
-      name: parameterKey.replace(".json", ""),
-      lastUsed: false,
-      id: (0, _uuid.v4)(),
-      value: JSON.stringify(parameterValue)
-    };
-    if (!apiParametersMap[api]) {
-      apiParametersMap[api] = [];
-    }
-    apiParametersMap[api].push(testParameter);
-  }
-  for (const api in apiParametersMap) {
-    if (apiParametersMap[api].length > 0) {
-      apiParametersMap[api][apiParametersMap[api].length - 1].lastUsed = true;
-    }
-    ____testParameters.directory[`${api}.json`] = {
-      file: {
-        contents: JSON.stringify(apiParametersMap[api], null, 2)
-      }
-    };
-  }
-  delete tree["parameters"];
-  tree["____testParameters"] = ____testParameters;
-  return;
-}
+};

package/dist/commands/intuned-cli/controller/save.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { AuthCredentials } from "../types";
+export declare function runSaveProject(projectName: string, auth: AuthCredentials): Promise<void>;
+export declare const projectNameSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const validateProjectName: (projectName: string) => {
+    isValid: true;
+} | {
+    isValid: false;
+    errorMessage: string;
+};
+export declare const validateIntunedProject: () => Promise<{
+    isValid: boolean;
+    errorMessage?: string;
+}>;

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

@@ -0,0 +1,365 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = void 0;
+exports.runSaveProject = runSaveProject;
+exports.validateProjectName = exports.validateIntunedProject = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _minimatch = require("minimatch");
+var _zod = require("zod");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../constants");
+var _helpers = require("../helpers");
+var _lodash = require("lodash");
+var _uuid = require("uuid");
+var _terminal = require("../helpers/terminal");
+var _build = require("./build");
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _constants2 = require("../../../common/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const saveProjectApiResponseSchema = _zod.z.string().transform((val, ctx) => {
+  try {
+    return JSON.parse(val);
+  } catch (e) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Response is not valid JSON"
+    });
+    return _zod.z.NEVER;
+  }
+}).pipe(_zod.z.object({
+  id: _zod.z.string().uuid()
+}));
+async function runSaveProject(projectName, auth) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}`;
+  const headers = {
+    "x-api-key": apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const deployProjectPayload = {
+    codeTree,
+    platformType: "CLI",
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "PUT",
+    body: JSON.stringify(deployProjectPayload)
+  });
+  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`, {
+      autoColor: false
+    });
+  }
+  (0, _terminal.terminal)("^g^+Project saved successfully!^:\n");
+  const body = await response.text();
+  const parseResult = saveProjectApiResponseSchema.safeParse(body);
+  if (!parseResult.success) {
+    (0, _terminal.terminal)(`^yWarning: Could not parse save project response:^:\n`);
+    (0, _terminal.terminal)(body + "\n");
+    return;
+  }
+  const {
+    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 {
+    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 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"
+});
+const validateProjectName = projectName => {
+  const validation = projectNameSchema.safeParse(projectName);
+  if (!validation.success) {
+    return {
+      isValid: false,
+      errorMessage: validation.error.errors[0].message
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateProjectName = validateProjectName;
+const validateIntunedProject = async () => {
+  const currentDirectoryToDeploy = process.cwd();
+  const validationSteps = [{
+    name: "build",
+    check: async () => {
+      try {
+        const buildResult = await (0, _build.runBuild)();
+        if (!buildResult) {
+          return {
+            isValid: false,
+            errorMessage: "Build failed"
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Build failed"
+        };
+      }
+    }
+  }, {
+    name: "package.json",
+    check: async () => {
+      try {
+        const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
+        await fs.exists(packageJsonPath);
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
+          encoding: "utf-8"
+        }));
+        const userCodePlaywrightVersion = packageJson.dependencies?.playwright;
+        if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
+          return {
+            isValid: false,
+            errorMessage: `Playwright version mismatch: expected ${_constants.CURRENT_PLAYWRIGHT_VERSION}, found ${userCodePlaywrightVersion || "none"}`
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Package.json file not found or cannot be read"
+        };
+      }
+    }
+  }, {
+    name: "Intuned.json",
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToDeploy, "Intuned.json");
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Intuned.json file not found"
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToDeploy, "api");
+        await fs.access(apiFolderPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "API folder not found"
+        };
+      }
+    }
+  }];
+  for (const step of validationSteps) {
+    const result = await step.check();
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateIntunedProject = validateIntunedProject;
+function ignoreFilesByPattern(filePath, patterns, projectPath) {
+  const relativePath = path.relative(projectPath, filePath);
+  if (relativePath.startsWith("node_modules")) {
+    return true;
+  }
+  for (const pattern of patterns) {
+    if (!pattern || pattern.startsWith("#")) continue;
+    if (pattern.startsWith("!")) {
+      if ((0, _minimatch.minimatch)(relativePath, pattern.substring(1))) {
+        return false;
+      }
+    } else if ((0, _minimatch.minimatch)(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function listFilesNotIgnored(projectPath, ignorePatterns) {
+  const results = [];
+  function traverseDirectory(dirPath) {
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(fullPath);
+          if (stats.isDirectory()) {
+            traverseDirectory(fullPath);
+          } else if (stats.isFile()) {
+            results.push(path.relative(projectPath, fullPath));
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${fullPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+  }
+  traverseDirectory(projectPath);
+  return results;
+}
+async function convertProjectToCodeTree(projectPath) {
+  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  const filesToDeployText = "  " + filesToDeploy.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be saved:^:\n");
+  (0, _terminal.terminal)(filesToDeployText + "\n");
+  function readDirectory(dirPath) {
+    const tree = {};
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(entryPath, _projectExclusions.default, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(entryPath);
+          if (stats.isFile()) {
+            try {
+              const content = fs.readFileSync(entryPath, "utf-8");
+              tree[entry] = {
+                file: {
+                  contents: content
+                }
+              };
+            } catch (error) {
+              (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
+            }
+          } else if (stats.isDirectory()) {
+            const subTree = readDirectory(entryPath);
+            if (Object.keys(subTree).length > 0) {
+              tree[entry] = {
+                directory: subTree
+              };
+            }
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${entryPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+    return tree;
+  }
+  const tree = readDirectory(projectPath);
+  mapToIDEParams(tree);
+  return tree;
+}
+function mapToIDEParams(tree) {
+  if (!tree) {
+    return;
+  }
+  if (!tree["parameters"] || "file" in tree["parameters"]) {
+    return;
+  }
+  const apiParametersMap = {};
+  const cliParameters = Object.keys(tree["parameters"].directory);
+  const ____testParameters = {
+    directory: {}
+  };
+  for (const parameterKey of cliParameters) {
+    const parameter = tree["parameters"].directory[parameterKey];
+    if ("directory" in parameter) {
+      continue;
+    }
+    if ((0, _lodash.isEmpty)(parameter.file.contents)) {
+      continue;
+    }
+    const parameterPayload = JSON.parse(parameter.file.contents);
+    if (!parameterPayload["__api-name"]) {
+      continue;
+    }
+    const api = parameterPayload["__api-name"];
+    const {
+      "__api-name": _,
+      ...parameterValue
+    } = parameterPayload;
+    const testParameter = {
+      name: parameterKey.replace(".json", ""),
+      lastUsed: false,
+      id: (0, _uuid.v4)(),
+      value: JSON.stringify(parameterValue)
+    };
+    if (!apiParametersMap[api]) {
+      apiParametersMap[api] = [];
+    }
+    apiParametersMap[api].push(testParameter);
+  }
+  for (const api in apiParametersMap) {
+    if (apiParametersMap[api].length > 0) {
+      apiParametersMap[api][apiParametersMap[api].length - 1].lastUsed = true;
+    }
+    ____testParameters.directory[`${api}.json`] = {
+      file: {
+        contents: JSON.stringify(apiParametersMap[api], null, 2)
+      }
+    };
+  }
+  delete tree["parameters"];
+  tree["____testParameters"] = ____testParameters;
+  return;
+}

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

@@ -5,16 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getAuthCredentials = getAuthCredentials;
 exports.getBaseUrl = getBaseUrl;
+var _constants = require("../../../common/constants");
 var _errors = require("./errors");
 var _intunedJson = require("./intunedJson");
 async function getAuthCredentials(options) {
   const workspaceId = options.workspaceId || (await (0, _intunedJson.getSettingIntunedJSON)("workspaceId"));
-  const apiKey = options.apiKey || process.env.INTUNED_API_KEY;
+  const apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
   if (!workspaceId) {
     throw new _errors.CLIError("Workspace ID is required. Please provide it via command line options or Intuned.json");
   }
   if (!apiKey) {
-    throw new _errors.CLIError("API key is required. Please provide it via command line options or INTUNED_API_KEY environment variable.");
+    throw new _errors.CLIError(`API key is required. Please provide it via command line options or ${_constants.API_KEY_ENV_VAR_KEY} environment variable.`);
   }
   return {
     workspaceId,

package/dist/common/constants.d.ts

@@ -1,3 +1,6 @@
 export declare const API_FOLDER_NAME = "api";
 export declare const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
 export declare const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+export declare const WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+export declare const PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+export declare const API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";

package/dist/common/constants.js

@@ -3,7 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = exports.API_FOLDER_NAME = void 0;
+exports.WORKSPACE_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = exports.API_KEY_ENV_VAR_KEY = exports.API_FOLDER_NAME = void 0;
 const API_FOLDER_NAME = exports.API_FOLDER_NAME = "api";
 const AUTH_SESSIONS_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
-const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+const WORKSPACE_ID_ENV_VAR_KEY = exports.WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+const PROJECT_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+const API_KEY_ENV_VAR_KEY = exports.API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";

package/dist/common/jwtTokenManager.d.ts

@@ -10,6 +10,7 @@ declare class JwtTokenManager {
     private scheduleTokenRefresh;
     private refreshToken;
     fetchWithToken(...[input, init]: Parameters<typeof fetch>): Promise<Response>;
+    get backendFunctionsBaseUrl(): string;
 }
 export declare const backendFunctionsTokenManager: JwtTokenManager;
 export declare function callBackendFunctionWithToken(path: string, init?: Parameters<typeof fetch>[1]): Promise<Response>;

package/dist/common/jwtTokenManager.js

@@ -8,6 +8,7 @@ exports.callBackendFunctionWithToken = callBackendFunctionWithToken;
 var _crossFetch = _interopRequireDefault(require("cross-fetch"));
 var jwt = _interopRequireWildcard(require("jsonwebtoken"));
 var _neverthrow = require("neverthrow");
+var _constants = require("./constants");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -51,7 +52,7 @@ class JwtTokenManager {
   }
   async refreshToken() {
     if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
-    const res = await this.fetchWithToken(this.refreshTokenPath, {
+    const res = await this.fetchWithToken(`${this.backendFunctionsBaseUrl}/refreshBackendFunctionsToken`, {
       method: "GET"
     });
     if (res.status === 401) {
@@ -70,10 +71,18 @@ class JwtTokenManager {
       headers
     });
   }
+  get backendFunctionsBaseUrl() {
+    if (!process.env.FUNCTIONS_DOMAIN || !process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY]) {
+      throw new Error(`Cannot call backend function - FUNCTIONS_DOMAIN or ${_constants.WORKSPACE_ID_ENV_VAR_KEY} not set`);
+    }
+    if (!process.env[_constants.PROJECT_ID_ENV_VAR_KEY] && !process.env.INTUNED_INTEGRATION_ID) {
+      throw new Error(`Cannot call backend function - ${_constants.PROJECT_ID_ENV_VAR_KEY} or INTUNED_INTEGRATION_ID not set`);
+    }
+    return `${process.env.FUNCTIONS_DOMAIN}/api/${process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY]}/functions/${process.env[_constants.PROJECT_ID_ENV_VAR_KEY] ?? process.env.INTUNED_INTEGRATION_ID}`;
+  }
 }
-const backendFunctionsPath = `${process.env.FUNCTIONS_DOMAIN}/api/${process.env.INTUNED_WORKSPACE_ID}/functions/${process.env.INTUNED_INTEGRATION_ID}`;
-const backendFunctionsTokenManager = exports.backendFunctionsTokenManager = new JwtTokenManager(`${backendFunctionsPath}/refreshBackendFunctionsToken`);
+const backendFunctionsTokenManager = exports.backendFunctionsTokenManager = new JwtTokenManager(`refreshBackendFunctionsToken`);
 backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
 function callBackendFunctionWithToken(path, init) {
-  return backendFunctionsTokenManager.fetchWithToken(`${backendFunctionsPath}/${path}`, init);
+  return backendFunctionsTokenManager.fetchWithToken(`${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path}`, init);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/runtime-dev",
-  "version": "1.3.0-responseLimits.1",
+  "version": "1.3.1-api-token.0",
   "description": "Intuned runtime",
   "exports": {
     ".": "./dist/index.js",
@@ -90,9 +90,7 @@
     "typescript": "5.1.6",
     "uuid": "11.1.0",
     "wait-on": "7.2.0",
-    "zod": "^3.21.4",
-    "playwright": "^1.44.0",
-    "playwright-core": "^1.44.0"
+    "zod": "^3.21.4"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.4",