@nestbox-ai/cli 1.0.6 → 1.0.8

package/src/utils/agent.ts

@@ -0,0 +1,170 @@
+import path from "path";
+import fs from 'fs';
+import chalk from "chalk";
+import ora from "ora";
+import { promisify } from "util";
+import { exec } from "child_process";
+import AdmZip from "adm-zip";
+import * as os from 'os';
+
+
+const execAsync = promisify(exec);
+
+export async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  
+  while (currentDir !== path.parse(currentDir).root) {
+    const nestboxConfigPath = path.join(currentDir, 'nestbox.config.json');
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    
+    if (fs.existsSync(nestboxConfigPath) || fs.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    
+    currentDir = path.dirname(currentDir);
+  }
+  
+  return startDir; // Fallback to current directory if no root markers found
+}
+
+// Function to load and parse nestbox.config.json if it exists
+export function loadNestboxConfig(projectRoot: any) {
+  const configPath = path.join(projectRoot, 'nestbox.config.json');
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      return JSON.parse(configContent);
+    } catch (error: any) {
+      console.warn(chalk.yellow(`Warning: Error parsing nestbox.config.json: ${error.message}`));
+    }
+  }
+  
+  return null;
+}
+
+// Function to detect if a directory contains TypeScript files
+export function isTypeScriptProject(directoryPath: any) {
+  // Check for tsconfig.json
+  if (fs.existsSync(path.join(directoryPath, 'tsconfig.json'))) {
+    return true;
+  }
+  
+  // Check for .ts files
+  try {
+    const files = fs.readdirSync(directoryPath);
+    return files.some(file => file.endsWith('.ts') || file.endsWith('.tsx'));
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function runPredeployScripts(scripts: any, projectRoot: any) {
+  if (!scripts || !Array.isArray(scripts) || scripts.length === 0) {
+    return;
+  }
+  
+  const spinner = ora('Running predeploy scripts...').start();
+
+  try {
+    for (const script of scripts) {
+      spinner.text = `Running: ${script}`;
+      
+      // Make sure we're running in the correct directory
+      await execAsync(script, { 
+        cwd: projectRoot,
+      });
+    }
+    spinner.succeed('Predeploy scripts completed successfully');
+  } catch (error: any) {
+    spinner.fail(`Predeploy script failed: ${error.message}`);
+    throw new Error(`Predeploy failed: ${error.message}`);
+  }
+}
+
+// Function to create zip from directory excluding node_modules
+// export function createZipFromDirectory(dirPath: any, excludePatterns = ['node_modules']) {
+//   const dirName = path.basename(dirPath);
+//   const zipFilePath = path.join(os.tmpdir(), `${dirName}_${Date.now()}.zip`);
+  
+//   const zip = new AdmZip();
+    
+//   // Function to recursively add files to zip
+//   function addFilesToZip(currentPath: any, relativePath = '') {
+//     const items = fs.readdirSync(currentPath);
+    
+//     for (const item of items) {
+//       const itemPath = path.join(currentPath, item);
+//       const itemRelativePath = path.join(relativePath, item);
+      
+//       // Check if item should be excluded
+//       if (excludePatterns.some(pattern => 
+//         typeof pattern === 'string' ? itemRelativePath === pattern || item === pattern : 
+//         pattern.test(itemRelativePath)
+//       )) {
+//         continue;
+//       }
+      
+//       const stats = fs.statSync(itemPath);
+      
+//       if (stats.isDirectory()) {
+//         addFilesToZip(itemPath, itemRelativePath);
+//       } else {
+//         zip.addLocalFile(itemPath, path.dirname(itemRelativePath));
+//       }
+//     }
+//   }
+  
+//   addFilesToZip(dirPath);
+//   zip.writeZip(zipFilePath);
+  
+//   return zipFilePath;
+// }
+
+export function createZipFromDirectory(dirPath: any, excludePatterns = ['node_modules', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']) {
+  const dirName = path.basename(dirPath);
+  const timestamp = Date.now();
+  
+  // Create zip in temp directory
+  const tempZipFilePath = path.join(os.tmpdir(), `${dirName}_${timestamp}.zip`);
+  
+  // Create zip in Downloads folder (Mac)
+  const downloadsPath = path.join(os.homedir(), 'Downloads');
+  const downloadsZipFilePath = path.join(downloadsPath, `${dirName}_${timestamp}.zip`);
+  
+  const zip = new AdmZip();
+    
+  // Function to recursively add files to zip
+  function addFilesToZip(currentPath: any, relativePath = '') {
+    const items = fs.readdirSync(currentPath);
+    
+    for (const item of items) {
+      const itemPath = path.join(currentPath, item);
+      const itemRelativePath = path.join(relativePath, item);
+      
+      // Check if item should be excluded
+      if (excludePatterns.some((pattern: any) => 
+        typeof pattern === 'string' ? itemRelativePath === pattern || item === pattern : 
+        pattern.test(itemRelativePath)
+      )) {
+        continue;
+      }
+      
+      const stats = fs.statSync(itemPath);
+      
+      if (stats.isDirectory()) {
+        addFilesToZip(itemPath, itemRelativePath);
+      } else {
+        zip.addLocalFile(itemPath, path.dirname(itemRelativePath));
+      }
+    }
+  }
+  
+  addFilesToZip(dirPath);
+  
+  // Write zip to temp directory (for upload)
+  zip.writeZip(tempZipFilePath);
+  
+  // Return the temp path for upload
+  return tempZipFilePath;
+}

package/src/utils/project.ts

@@ -0,0 +1,81 @@
+import { ProjectsApi } from "@nestbox-ai/admin";
+import ora from "ora";
+import { readNestboxConfig } from "../commands/projects";
+
+
+interface ProjectInfo {
+    id: string;
+    name: string;
+  }
+
+interface CommandOptions {
+    instance: string;
+    project?: string;
+    collection?: string;
+    name?: string;
+    metadata?: string;
+    [key: string]: any;
+}
+
+export async function resolveProject(projectsApi: ProjectsApi, options: CommandOptions): Promise<ProjectInfo> {
+  const spinner = ora('Resolving project...').start();
+  
+  try {
+    const projectsResponse = await projectsApi.projectControllerGetAllProjects();
+    const allProjects = projectsResponse.data?.data?.projects;
+
+    if (!allProjects || allProjects.length === 0) {
+      spinner.fail('No projects found.');
+      throw new Error('No projects found');
+    }
+
+    let projectId = options.project;
+    let projectName = '';
+
+    if (projectId) {
+      const byId = allProjects.find((p) => p.id === projectId);
+      const byName = allProjects.find((p) => p.name === projectId);
+
+      if (byId) {
+        projectName = byId.name;
+        projectId = byId.id;
+      } else if (byName) {
+        projectName = byName.name;
+        projectId = byName.id;
+      } else {
+        spinner.fail(`Project not found with ID or name: ${projectId}`);
+        throw new Error(`Project not found with ID or name: ${projectId}`);
+      }
+
+      spinner.succeed(`Using project: ${projectName} (ID: ${projectId})`);
+    } else {
+      const config = readNestboxConfig();
+      const defaultProjectName = config.projects?.default;
+
+      if (!defaultProjectName) {
+        spinner.fail('No project specified and no default project set. Please provide a project ID or set a default project.');
+        throw new Error('No project specified and no default project set');
+      }
+
+      const defaultProject = allProjects.find((p) => p.name === defaultProjectName);
+
+      if (!defaultProject) {
+        spinner.fail(`Default project "${defaultProjectName}" not found.`);
+        throw new Error(`Default project "${defaultProjectName}" not found.`);
+      }
+
+      projectId = defaultProject.id;
+      projectName = defaultProject.name;
+      spinner.succeed(`Using default project: ${projectName} (ID: ${projectId})`);
+    }
+
+    return { id: projectId, name: projectName };
+  } catch (error) {
+    if (!spinner.isSpinning) {
+      // If spinner was already stopped with fail, we don't need to fail it again
+      throw error;
+    }
+    spinner.fail('Failed to resolve project');
+    throw error;
+  }
+}

package/src/utils/user.ts

@@ -0,0 +1,28 @@
+import axios from "axios";
+import { getAuthToken } from "./auth";
+
+export async function userData() {
+    try {
+        const authData = getAuthToken();
+
+        if (!authData || !authData.serverUrl || !authData.token) {
+            throw new Error("No authentication data found. Please login first.");
+        }
+        
+        const response = await axios.get(
+            `${authData.serverUrl}/user/me`,
+            {
+                headers: {
+                    Authorization: `${authData.token}`,
+                },
+            }
+        );
+        
+        return response.data;
+    } catch (error: any) {
+        console.error("Error fetching user data:", error.message || "Unknown error");
+        if (error.response) {
+        }
+        throw error; // Rethrow to allow caller to handle the error
+    }
+}