@intuned/runtime-dev 1.0.6-cli-auth.0.1.3-test → 1.0.6-cli.1

package/bin/intuned-run

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("/Users/omarhurani/Documents/GitHub/WebApp/apps/typescript-runtime/dist/commands/intuned-run/intuned-run.js");

package/dist/commands/common/utils/unixSocket.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as net from "net";
 export declare class JSONUnixSocket {
     private readonly socket;

package/dist/commands/deploy/deploy.js

@@ -4,41 +4,28 @@
 var _commander = require("commander");
 var _chalk = _interopRequireDefault(require("chalk"));
 var _dotenv = _interopRequireDefault(require("dotenv"));
-var _utils = require("./utils");
-var _utils2 = require("../../common/cli/utils");
+var _utils = require("../init/utils");
+var _utils2 = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 _dotenv.default.config({
   path: `.env`
 });
 _commander.program.description("Deploy an Intuned project to be public").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(async (projectName, options) => {
   try {
-    const {
-      isValid,
-      errorMessage
-    } = await (0, _utils.validateIntunedProject)();
-    if (!isValid) {
-      const userErrorMesage = `Project to be deployed is not a valid Intuned project: ${errorMessage}, modify and check again`;
-      throw new Error(userErrorMesage);
-    }
-    const _projectName = projectName || (await (0, _utils2.getSettingIntunedJSON)("projectName"));
-    if (!_projectName) {
+    if (!projectName) {
       throw new Error("Project name is required");
     }
-    const projectNameValidation = (0, _utils.validateProjectName)(_projectName);
+    const projectNameValidation = (0, _utils2.validateProjectName)(projectName);
     if (!projectNameValidation.isValid) {
       throw new Error(projectNameValidation.errorMessage);
     }
-    const auth = await (0, _utils2.getAuthCredentials)(options);
-    const {
-      deployDone,
-      projectId,
-      deployErrorMessage
-    } = await (0, _utils.deployProject)(_projectName, auth);
-    if (!deployDone) {
-      throw new Error(`Project not deployed: ${deployErrorMessage}`);
+    const auth = (0, _utils.getAuthCredentials)(options);
+    const deployStarted = await (0, _utils2.deployProject)(projectName, auth);
+    if (!deployStarted) {
+      throw new Error("Project not deployed");
     }
-    const url = (0, _utils2.getBaseUrl)();
-    console.log(_chalk.default.green(`\n✅ Project "${_projectName}" deployed successfully!` + `\n\nYou can check your project on the platform: ${_chalk.default.bold(`${url}/projects/${projectId}/details`)}\n`));
+    const url = `https://rauf-2.intuned-team-local.com/projects`;
+    console.log(_chalk.default.green(`\n🚀 Project "${projectName}" started deployment successfully!` + `\n\nYou can check your project on the platform: ${_chalk.default.bold(url)}\n`));
   } catch (error) {
     console.error(_chalk.default.red(`\n${error.message}`));
     process.exit(1);

package/dist/commands/deploy/utils.d.ts

@@ -1,16 +1,7 @@
-import { AuthCredentials, FileSystemTree } from "../../common/cli/types";
+import { AuthCredentials, FileSystemTree } from "../init/types";
 export declare function convertProjectToCodeTree(projectPath: string): Promise<FileSystemTree>;
-export declare function deployProject(projectName: string, auth: AuthCredentials): Promise<{
-    deployDone: boolean;
-    projectId?: string;
-    deployErrorMessage?: string;
-}>;
+export declare function deployProject(projectName: string, auth: AuthCredentials): Promise<boolean>;
 export declare const validateProjectName: (projectName: string) => {
     isValid: boolean;
     errorMessage?: string;
 };
-export declare const validateIntunedProject: () => Promise<{
-    isValid: boolean;
-    errorMessage?: string;
-}>;
-export declare const runBuild: () => Promise<boolean>;

package/dist/commands/deploy/utils.js

@@ -5,25 +5,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.convertProjectToCodeTree = convertProjectToCodeTree;
 exports.deployProject = deployProject;
-exports.validateProjectName = exports.validateIntunedProject = exports.runBuild = void 0;
-var fs = _interopRequireWildcard(require("fs-extra"));
+exports.validateProjectName = void 0;
+var fs = _interopRequireWildcard(require("fs"));
 var path = _interopRequireWildcard(require("path"));
 var _chalk = _interopRequireDefault(require("chalk"));
 var _minimatch = require("minimatch");
 var _zod = require("zod");
-var _child_process = require("child_process");
-var _util = require("util");
-var _projectExclusions = _interopRequireDefault(require("../common/projectExclusions"));
-var _constants = require("../../common/cli/constants");
-var _utils = require("../../common/cli/utils");
-var _utils2 = require("../init/utils");
-var _lodash = require("lodash");
-var _uuid = require("uuid");
 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 execPromise = (0, _util.promisify)(_child_process.exec);
-function ignoreFilesByPattern(filePath, patterns, projectPath) {
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function matchesGitignorePatterns(filePath, patterns, projectPath) {
   const relativePath = path.relative(projectPath, filePath);
   if (relativePath.startsWith("node_modules")) {
     return true;
@@ -47,7 +45,7 @@ function listFilesNotIgnored(projectPath, ignorePatterns) {
       const entries = fs.readdirSync(dirPath);
       for (const entry of entries) {
         const fullPath = path.join(dirPath, entry);
-        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
+        if (matchesGitignorePatterns(fullPath, ignorePatterns, projectPath)) {
           continue;
         }
         try {
@@ -69,17 +67,45 @@ function listFilesNotIgnored(projectPath, ignorePatterns) {
   return results;
 }
 async function convertProjectToCodeTree(projectPath) {
-  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  const defaultExcludes = ["node_modules/**", ".git/**", "dist/**", "build/**", "coverage/**", ".next/**", ".cache/**", "out/**", "tmp/**", ".DS_Store", "npm-debug.log*", "yarn-debug.log*", "yarn-error.log*", ".env", ".env.*", "**/*.map", "**/*.tsbuildinfo"];
+  let ignorePatterns = [...defaultExcludes];
+  let currentDir = path.normalize(projectPath);
+  let gitignoreFound = false;
+  while (currentDir !== path.parse(currentDir).root) {
+    const gitignorePath = path.join(currentDir, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+      const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8").split("\n");
+      ignorePatterns = [...ignorePatterns, ...gitignoreContent];
+      console.log(`Found .gitignore file: ${_chalk.default.cyan.bold(gitignorePath)}`);
+      gitignoreFound = true;
+      break;
+    } else {
+      currentDir = path.dirname(currentDir);
+    }
+  }
+  const filesToDeploy = listFilesNotIgnored(projectPath, ignorePatterns);
+  let totalSize = 0;
+  for (const file of filesToDeploy) {
+    try {
+      const stats = fs.statSync(path.join(projectPath, file));
+      totalSize += stats.size;
+    } catch (error) {}
+  }
   console.log(_chalk.default.cyan("\nFiles to be deployed:"));
-  const filesToDeployText = "\n  " + filesToDeploy.join("\n  ");
-  console.log(filesToDeployText);
+  if (filesToDeploy.length > 100) {
+    console.log(_chalk.default.yellow(`  ${filesToDeploy.length} files (too many to display)`));
+  } else {
+    const filesToDeployText = "\n  " + filesToDeploy.join("\n  ");
+    console.log(filesToDeployText);
+  }
+  console.log(_chalk.default.cyan(`\nSummary: ${filesToDeploy.length} files, ${formatBytes(totalSize)}`));
   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)) {
+        if (matchesGitignorePatterns(entryPath, ignorePatterns, projectPath)) {
           continue;
         }
         try {
@@ -112,9 +138,8 @@ async function convertProjectToCodeTree(projectPath) {
     }
     return tree;
   }
-  console.log(_chalk.default.cyan("\n📦 Building project..."));
+  console.log(_chalk.default.cyan("\nBuilding project..."));
   const tree = readDirectory(projectPath);
-  await mapToIDEParams(tree);
   return tree;
 }
 async function deployProject(projectName, auth) {
@@ -122,7 +147,7 @@ async function deployProject(projectName, auth) {
     workspaceId,
     apiKey
   } = auth;
-  const baseUrl = (0, _utils.getBaseUrl)();
+  const baseUrl = "https://rauf-2.intuned-team-local.com";
   const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create`;
   const headers = {
     "x-api-key": apiKey,
@@ -130,14 +155,9 @@ async function deployProject(projectName, auth) {
   };
   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,
+    codeTree: codeTree,
     isCli: true,
     language: "typescript"
   };
@@ -147,43 +167,16 @@ async function deployProject(projectName, auth) {
     body: JSON.stringify(deployProjectPayload)
   });
   if (!response.ok) {
-    if (response.status === 401) {
-      throw new Error(`Invalid API key. Please check your API key and try again.`);
-    }
     throw new Error(`Error deploying project`);
   }
-  const startTime = Date.now();
-  console.log(_chalk.default.greenBright(`\n🚀 Deploying project...`));
-  return new Promise((resolve, reject) => {
-    const checkInterval = setInterval(async () => {
-      try {
-        const {
-          status,
-          message,
-          projectId
-        } = await checkIntunedProjectDeployStatus(workspaceId, projectName, apiKey);
-        if (status === "completed" || status === "failed" || status === "not_found") {
-          clearInterval(checkInterval);
-          resolve(status === "completed" ? {
-            deployDone: true,
-            projectId
-          } : {
-            deployDone: false,
-            projectId: "",
-            deployErrorMessage: message
-          });
-        }
-        const elapsedTime = Date.now() - startTime;
-        if (elapsedTime > _constants.PROJECT_DEPLOY_TIMEOUT) {
-          clearInterval(checkInterval);
-          reject(new Error(`Deployment timed out after ${Math.floor(_constants.PROJECT_DEPLOY_TIMEOUT / 1000 / 60)} minutes`));
-        }
-      } catch (error) {
-        clearInterval(checkInterval);
-        reject(error);
-      }
-    }, 5000);
-  });
+  const data = await response.json();
+  if (response.status === 202) {
+    return true;
+  }
+  if (!data) {
+    throw new Error("Project not deployed");
+  }
+  return false;
 }
 const validateProjectName = projectName => {
   const nameSchema = _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, {
@@ -200,209 +193,4 @@ const validateProjectName = projectName => {
     isValid: true
   };
 };
-exports.validateProjectName = validateProjectName;
-const validateIntunedProject = async () => {
-  const currentDirectoryToDeploy = process.cwd();
-  const validationSteps = [{
-    name: "build",
-    check: async () => {
-      try {
-        const buildResult = await 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 {
-        var _packageJson$dependen;
-        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$dependen = packageJson.dependencies) === null || _packageJson$dependen === void 0 ? void 0 : _packageJson$dependen.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) => {
-  try {
-    const baseUrl = (0, _utils.getBaseUrl)();
-    const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create/${projectName}/result`;
-    const headers = {
-      "x-api-key": apiKey,
-      "Content-Type": "application/json"
-    };
-    const response = await fetch(url, {
-      headers,
-      method: "GET"
-    });
-    if (response.status === 404) {
-      return {
-        status: "not_found",
-        message: "Project not found"
-      };
-    }
-    if (!response.ok) {
-      throw new Error("Error querying deployment status");
-    }
-    const data = await response.json();
-    if (data.status) {
-      return {
-        status: data.status,
-        message: data.message,
-        projectId: data.projectId
-      };
-    }
-    return {
-      status: "failed",
-      message: `Deployment failed, please try again: ${data.message}`
-    };
-  } catch (e) {
-    throw new Error(`Error during deployment`);
-  }
-};
-const runBuild = async () => {
-  const currentProjectDirectory = process.cwd();
-  console.log(_chalk.default.yellow("Running build..."));
-  const distPath = path.join(currentProjectDirectory, "dist");
-  if (await fs.exists(distPath)) {
-    await fs.remove(distPath);
-  }
-  const buildCommand = "tsc";
-  try {
-    await execPromise(buildCommand, {
-      cwd: currentProjectDirectory
-    });
-    console.log(_chalk.default.green("🏗️ Build completed successfully"));
-    return true;
-  } catch (error) {
-    console.error(_chalk.default.red(`Build failed: ${error.message}`));
-    return false;
-  }
-};
-exports.runBuild = runBuild;
-async function mapToIDEParams(tree) {
-  if (!tree) {
-    return;
-  }
-  if (!tree["parameters"] || (0, _utils2._isFileNode)(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 ((0, _utils2._isDirectoryNode)(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: 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;
-}
+exports.validateProjectName = validateProjectName;

package/dist/commands/init/init.js

@@ -9,11 +9,12 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 _dotenv.default.config({
   path: `.env`
 });
-_commander.program.description("Initialize a new Intuned project from a template").argument("[template-name]", "Name of the template to use").action(async templateName => {
+_commander.program.description("Initialize a new Intuned project from a template").argument("[template-name]", "Name of the template to use").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action(async (templateName, options) => {
   try {
+    const auth = (0, _utils.getAuthCredentials)(options);
     const template = await (0, _utils.selectTemplate)(templateName);
-    const isTargetDirectoryEmpty = await (0, _utils.checkEmptyDirectory)();
-    await (0, _utils.scaffoldProject)(template, isTargetDirectoryEmpty);
+    await (0, _utils.checkEmptyDirectory)();
+    await (0, _utils.scaffoldProject)(template, auth);
   } catch (error) {
     console.error(_chalk.default.red(`\n${error.message}`));
     process.exit(1);

package/dist/{common/cli → commands/init}/types.d.ts

@@ -50,25 +50,3 @@ export interface AuthCredentials {
     workspaceId: string;
     apiKey: string;
 }
-export declare enum ApiAuthSessionBehavior {
-    PERFORM_CHECK_AND_REFRESH = "PERFORM_CHECK_AND_REFRESH",
-    SKIP_CHECK_AND_REFRESH = "SKIP_CHECK_AND_REFRESH"
-}
-export declare const CHECK_FAILED_ERROR_MESSAGE = "Auth session check failed";
-export type AuthSessionType = "API" | "MANUAL";
-export type AuthSessionMetadata = {
-    createdAt: string;
-    updatedAt: string;
-    authSessionId: string;
-    authSessionType: AuthSessionType;
-    authSessionInput?: Record<string, any>;
-    recorderStartUrl?: string;
-    recorderEndUrl?: string;
-};
-export interface SessionStorageState {
-    origin: string;
-    sessionStorage: {
-        name: string;
-        value: string;
-    }[];
-}

package/dist/commands/init/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.templateIds = void 0;
+const templateIds = exports.templateIds = ["default", "empty", "linkedin-recorder", "api-auth-sessions", "nested-scheduling", "ai-extractors", "npm-auth-sessions", "python-empty"];

package/dist/commands/init/utils.d.ts

@@ -1,11 +1,9 @@
-import { DirectoryNode, FileNode, FileSystemTree } from "../../common/cli/types";
-export declare function _isDirectoryNode(node: DirectoryNode | FileNode): node is DirectoryNode;
-export declare function _isFileNode(node: DirectoryNode | FileNode): node is FileNode;
+import { AuthCredentials, FileSystemTree } from "./types";
 export declare function mountFiles(cwd: string, tree: FileSystemTree): Promise<void>;
-export declare function checkEmptyDirectory(): Promise<boolean>;
+export declare function checkEmptyDirectory(): Promise<void>;
 export declare function getAuthCredentials(options: any): {
     workspaceId: any;
     apiKey: any;
 };
 export declare function selectTemplate(templateName: any): Promise<any>;
-export declare function scaffoldProject(templateId: string, isTargetDirectoryEmpty: boolean): Promise<void>;
+export declare function scaffoldProject(templateId: string, authCredentials: AuthCredentials): Promise<void>;