@nestbox-ai/cli 1.0.23 → 1.0.25

package/src/commands/agent/createFromYaml.ts

@@ -0,0 +1,192 @@
+import { Command } from "commander";
+import { withTokenRefresh } from "../../utils/error";
+import chalk from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+import fs from "fs";
+import yaml from 'js-yaml';
+import { AgentYamlConfig } from "../../types/agentYaml";
+import { userData } from "../../utils/user";
+import { createAgent } from "./create";
+import { createApis } from "./apiUtils";
+
+export function registerCreateFromYamlCommand(agentCommand: Command): void {
+  agentCommand
+    .command("create [firstArg] [secondArg]")
+    .description("Create multiple agents from a YAML configuration file")
+    .option("--project <projectId>", "Project ID (defaults to the current project)")
+    .action(async (firstArg: string, secondArg: any, options: any) => {
+      try {
+        let apis = createApis();
+
+        // Determine which argument is the YAML file path
+        let yamlFilePath: string;
+        
+        if (firstArg === 'file' && secondArg) {
+          yamlFilePath = secondArg;
+        } else if (firstArg) {
+          yamlFilePath = firstArg;
+          if (typeof secondArg === 'object' && !options) {
+            options = secondArg;
+          }
+        } else {
+          console.error(chalk.red("Missing YAML file path. Usage: nestbox agent create <yamlFile> OR nestbox agent create file <yamlFile>"));
+          return;
+        }
+
+        // Check if file exists
+        if (!fs.existsSync(yamlFilePath)) {
+          console.error(chalk.red(`YAML file not found: ${yamlFilePath}`));
+          return;
+        }
+
+        // Read and parse the YAML file
+        const spinner = ora(`Reading agents configuration from ${yamlFilePath}...`).start();
+        
+        try {
+          const fileContents = fs.readFileSync(yamlFilePath, 'utf8');
+          const config = yaml.load(fileContents) as AgentYamlConfig;
+          
+          if (!config || !config.agents || !Array.isArray(config.agents)) {
+            spinner.fail("Invalid YAML configuration: Missing 'agents' array");
+            console.error(chalk.red("The YAML file should contain an 'agents' array with agent configurations"));
+            return;
+          }
+          
+          spinner.succeed(`Found ${config.agents.length} agents in configuration file`);
+          
+          // Process each agent with token refresh support
+          const results = {
+            success: 0,
+            failed: 0,
+            agents: [] as Array<{name: string; success: boolean; message: string}>
+          };
+          
+          // Get user data once
+          const user = await userData();
+          
+          for (const agent of config.agents) {
+            if (!agent.name) {
+              console.log(chalk.yellow("Skipping agent with no name defined"));
+              results.failed++;
+              results.agents.push({
+                name: "unnamed",
+                success: false,
+                message: "Name is required"
+              });
+              continue;
+            }
+            
+            let agentType = agent.type || "CHAT";
+            const resourceType = agentType === "AGENT" ? "Agent" : "Chatbot";
+            
+            const agentSpinner = ora(`Creating ${resourceType.toLowerCase()} '${agent.name}'...`).start();
+            
+            try {
+              // Create agent with token refresh support
+              await withTokenRefresh(
+                async () => {
+                  // Map YAML config to createAgent options
+                  const createOptions = {
+                    ...options,
+                    goal: agent.goal || "No goal specified",
+                    modelBaseId: agent.modelBaseId || "",
+                    instanceIP: agent.instanceIP || "localhost",
+                    machineInstanceId: agent.machineInstanceId || 1,
+                    machineManifestId: agent.machineManifestId || "default",
+                    machineName: agent.machineName || `agent-${agent.name.toLowerCase()}`,
+                    type: agentType,
+                    userId: user.id,
+                    parameters: agent.parameters ? agent.parameters.map((p: any) => {
+                      return {
+                        name: p.name || "unnamed",
+                        description: p.description || "",
+                        default: p.default || "",
+                        isUserParam: p.isUserParam !== undefined ? p.isUserParam : true
+                      };
+                    }) : []
+                  };
+                  
+                  await createAgent(agent.name, createOptions, apis.agentsApi, apis.projectsApi);
+                },
+                () => {
+                  apis = createApis();
+                }
+              );
+              
+              agentSpinner.stop();
+              
+              results.success++;
+              results.agents.push({
+                name: agent.name,
+                success: true,
+                message: `Created successfully`
+              });
+            } catch (error: any) {
+              agentSpinner.fail(`Failed to create ${resourceType.toLowerCase()} '${agent.name}'`);
+              console.error(chalk.red(`Error: ${error.message}`));
+              results.failed++;
+              results.agents.push({
+                name: agent.name,
+                success: false,
+                message: error.message
+              });
+            }
+          }
+          
+          // Final summary
+          console.log(chalk.blue("\nResource creation summary:"));
+          const table = new Table({
+            head: [
+              chalk.white.bold("Name"),
+              chalk.white.bold("Type"),
+              chalk.white.bold("Status"),
+              chalk.white.bold("Message"),
+            ],
+            style: {
+              head: [],
+              border: [],
+            },
+          });
+          
+          results.agents.forEach((agent, index) => {
+            const agentConfig = config.agents.find(a => a.name === agent.name) || config.agents[index];
+            const agentType = agentConfig?.type || "CHAT";
+            const resourceType = agentType === "AGENT" ? "Agent" : "Chatbot";
+            
+            table.push([
+              agent.name,
+              resourceType,
+              agent.success ? chalk.green("Success") : chalk.red("Failed"),
+              agent.message
+            ]);
+          });
+          
+          console.log(table.toString());
+          console.log(`\nTotal: ${results.success + results.failed}, Successful: ${results.success}, Failed: ${results.failed}`);
+          
+        } catch (error: any) {
+          spinner.fail("Failed to process YAML file");
+          if (error.code === 'ENOENT') {
+            console.error(chalk.red(`File not found: ${yamlFilePath}`));
+          } else if (error.name === 'YAMLException') {
+            console.error(chalk.red(`Invalid YAML format: ${error.message}`));
+          } else {
+            console.error(
+              chalk.red("Error:"),
+              error.message || "Unknown error"
+            );
+          }
+        }
+      } catch (error: any) {
+        if (error.message && error.message.includes('Authentication')) {
+          console.error(chalk.red(error.message));
+        } else {
+          console.error(
+            chalk.red("Error:"),
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+    });
+}

package/src/commands/agent/deploy.ts

@@ -0,0 +1,272 @@
+import { Command } from "commander";
+import { withTokenRefresh } from "../../utils/error";
+import chalk from "chalk";
+import ora from "ora";
+import { resolveProject } from "../../utils/project";
+import fs from "fs";
+import {
+  createZipFromDirectory,
+  findProjectRoot,
+  isTypeScriptProject,
+  loadNestboxConfig,
+  runPredeployScripts,
+} from "../../utils/agent";
+import axios from "axios";
+import { AgentType } from "../../types/agentType";
+import path from "path";
+import { getAuthToken } from "../../utils/auth";
+import { createApis } from "./apiUtils";
+
+export function registerDeployCommand(agentCommand: Command): void {
+  agentCommand
+    .command("deploy")
+    .description("Deploy an AI agent to the Nestbox platform")
+    .option("--agent <agentName>", "Agent name to deploy")
+    .option("--chatbot <chatbotName>", "Chatbot name to deploy")
+    .requiredOption("--instance <instanceName>", "Instance name")
+    .option(
+      "--zip <zipFileOrDirPath>",
+      "Path to the zip file or directory to upload"
+    )
+    .option(
+      "--project <projectName>",
+      "Project name (defaults to the current project)"
+    )
+    .option("--entry <entryFunction>", "Entry function name")
+    .option("--log", "Show detailed logs during deployment")
+    .action(async (options) => {
+      try {
+        const {
+          agent: agentName,
+          chatbot: chatbotName,
+          instance: instanceName,
+          zip: customZipPath,
+          entry,
+          log,
+        } = options;
+        
+        // Ensure either agent or chatbot is provided, but not both
+        if ((!agentName && !chatbotName) || (agentName && chatbotName)) {
+          console.error(
+            chalk.red("Please provide either --agent OR --chatbot option, but not both.")
+          );
+          return;
+        }
+
+        let apis = createApis();
+
+        // Find project root
+        const projectRoot = await findProjectRoot();
+        console.log(chalk.blue(`Project root detected at: ${projectRoot}`));
+
+        // Main deployment logic with token refresh
+        await withTokenRefresh(
+          async () => {
+            // Resolve project
+            const projectData = await resolveProject(apis.projectsApi, options);
+
+            // Determine if we're deploying an agent or chatbot
+            const isAgent = !!agentName;
+            const resourceName = isAgent ? agentName : chatbotName;
+            const resourceType = isAgent ? "Agent" : "Chatbot";
+            const agentType = isAgent ? AgentType.REGULAR : "CHAT";
+            
+            // Get agents data and find agent/chatbot by name
+            const agentsData: any = await apis.agentsApi.machineAgentControllerGetMachineAgentByProjectId(
+              projectData.id, 
+              0, 
+              10, 
+              agentType
+            );
+
+            const targetAgent = agentsData.data.machineAgents.find(
+              (agent: any) => agent.agentName === resourceName
+            );
+
+            if (!targetAgent) {
+              console.error(
+                chalk.red(`${resourceType} with name "${resourceName}" not found in project "${projectData.name}".`)
+              );
+              console.log(chalk.yellow(`Available ${resourceType.toLowerCase()}s:`));
+              agentsData.data.machineAgents.forEach((agent: any) => {
+                console.log(chalk.yellow(`  - ${agent.agentName} (ID: ${agent.id})`));
+              });
+              return;
+            }
+
+            // Get instance data and find instance by name
+            const instanceData: any = await apis.instanceApi.machineInstancesControllerGetMachineInstanceByUserId(
+              projectData.id, 
+              0, 
+              10
+            );
+
+            const targetInstance = instanceData.data.machineInstances.find(
+              (instance: any) => instance.instanceName === instanceName
+            );
+
+            if (!targetInstance) {
+              console.error(
+                chalk.red(`Instance with name "${instanceName}" not found in project "${projectData.name}".`)
+              );
+              console.log(chalk.yellow("Available instances:"));
+              instanceData.data.machineInstances.forEach((instance: any) => {
+                console.log(chalk.yellow(`  - ${instance.instanceName} (ID: ${instance.id})`));
+              });
+              return;
+            }
+
+            // Extract IDs
+            const agentId = targetAgent.id;
+            const resolvedEntry = entry || targetAgent.entryFunctionName || "main";
+            const instanceId = targetInstance.id;
+
+            // Load nestbox.config.json
+            const config = loadNestboxConfig(projectRoot);
+
+            // Start the deployment process
+            const spinner = ora(
+              `Preparing to deploy ${resourceType.toLowerCase()} ${agentId} to instance ${instanceId}...`
+            ).start();
+
+            try {
+              let zipFilePath;
+
+              if (customZipPath) {
+                // Process custom zip path
+                if (!fs.existsSync(customZipPath)) {
+                  spinner.fail(`Path not found: ${customZipPath}`);
+                  return;
+                }
+
+                const stats = fs.statSync(customZipPath);
+
+                if (stats.isFile()) {
+                  if (!customZipPath.toLowerCase().endsWith(".zip")) {
+                    spinner.fail(`File is not a zip archive: ${customZipPath}`);
+                    return;
+                  }
+                  spinner.text = `Using provided zip file: ${customZipPath}`;
+                  zipFilePath = customZipPath;
+                } else if (stats.isDirectory()) {
+                  // Process directory
+                  spinner.text = `Processing directory: ${customZipPath}`;
+                  
+                  const isTypeScript = isTypeScriptProject(customZipPath);
+
+                  if (isTypeScript && (config?.agent?.predeploy || config?.agents?.predeploy)) {
+                    const predeployScripts = config?.agent?.predeploy || config?.agents?.predeploy;
+                    spinner.text = `Running predeploy scripts on target directory...`;
+                    await runPredeployScripts(predeployScripts, customZipPath);
+                  }
+
+                  spinner.text = `Creating zip archive from directory ${customZipPath}...`;
+                  zipFilePath = createZipFromDirectory(customZipPath);
+                  spinner.text = `Directory zipped successfully to ${zipFilePath}`;
+                }
+              } else {
+                // Use project root
+                spinner.text = `Using project root: ${projectRoot}`;
+                
+                const isTypeScript = isTypeScriptProject(projectRoot);
+
+                if (isTypeScript && (config?.agent?.predeploy || config?.agents?.predeploy)) {
+                  const predeployScripts = config?.agent?.predeploy || config?.agents?.predeploy;
+                  spinner.text = `Running predeploy scripts on project root...`;
+                  await runPredeployScripts(predeployScripts, projectRoot);
+                }
+
+                spinner.text = `Creating zip archive from project root ${projectRoot}...`;
+                zipFilePath = createZipFromDirectory(projectRoot);
+                spinner.text = `Directory zipped successfully to ${zipFilePath}`;
+              }
+
+              spinner.text = `Deploying ${resourceType.toLowerCase()} ${agentId} to instance ${instanceId}...`;
+
+              // Prepare deployment
+              const authToken = getAuthToken();
+              const baseUrl = authToken?.serverUrl?.endsWith("/")
+                ? authToken.serverUrl.slice(0, -1)
+                : authToken?.serverUrl;
+
+              const { default: FormData } = await import("form-data");
+              const form = new FormData();
+
+              form.append("file", fs.createReadStream(zipFilePath));
+              form.append("machineAgentId", agentId.toString());
+              form.append("instanceId", instanceId.toString());
+              form.append("entryFunctionName", resolvedEntry);
+              form.append("isSourceCodeUpdate", "true");
+              form.append("projectId", projectData.id);
+
+              if (log) {
+                console.log(chalk.blue("Form Details "));
+                console.log(chalk.blue(`  - File: ${path.basename(zipFilePath)}`));
+                console.log(chalk.blue(`  - Agent ID: ${agentId}`));
+                console.log(chalk.blue(`  - Instance ID: ${instanceId}`));
+                console.log(chalk.blue(`  - Entry Function: ${resolvedEntry}`));
+                console.log(chalk.blue(`  - Project ID: ${projectData.id}`));
+              }
+
+              const axiosInstance = axios.create({
+                baseURL: baseUrl,
+                headers: {
+                  ...form.getHeaders(),
+                  Authorization: authToken?.token,
+                },
+              });
+
+              const endpoint = `/projects/${projectData.id}/agents/${agentId}`;
+
+              spinner.text = `Sending API request to deploy ${resourceType.toLowerCase()}...`;
+              const res = await axiosInstance.patch(endpoint, form);
+              
+              if (!customZipPath && zipFilePath && fs.existsSync(zipFilePath)) {
+                fs.unlinkSync(zipFilePath);
+              }
+
+              if (log) {
+                console.log(chalk.blue("\nDeployment request:"));
+                console.log(chalk.blue(`  URL: ${baseUrl}${endpoint}`));
+                console.log(chalk.blue(`  Method: PATCH`));
+                console.log(chalk.blue(`  File: ${path.basename(zipFilePath)}`));  
+                console.log(chalk.blue(`  Response status: ${res.status} ${res.statusText}`));
+                const lines = res.data.logEntries || [];
+                console.log(chalk.blue(`  Deployment log entries (${lines.length} lines):`));
+                lines.forEach((line:  any) => {
+                  console.log(chalk.blue(`    - [${line.type} ${line.timestamp}] ${line.message} `));
+                });
+              }
+              spinner.succeed("Successfully deployed");
+              console.log(chalk.green(`${resourceType} deployed successfully!`));
+              console.log(chalk.cyan(`📍 Instance: ${instanceName}`));
+              console.log(chalk.cyan(`🤖 Agent: ${agentName} (${agentId})`));
+              console.log(chalk.cyan(`⚙️ Entry: ${resolvedEntry}`));
+              console.log(chalk.cyan(`🔄 Process: ${res.data.processName}`));
+            } catch (error: any) {
+              spinner.fail(`Failed to deploy ${resourceType.toLowerCase()}`);
+              throw error;
+            }
+          },
+          () => {
+            apis = createApis();
+          }
+        );
+      } catch (error: any) {
+        if (error.message && error.message.includes('Authentication')) {
+          console.error(chalk.red(error.message));
+        } else if (error.response) {
+          console.error(
+            chalk.red(
+              `API Error (${error.response.status}): ${error.response.data?.message || "Unknown error"}`
+            )
+          );
+          if (error.response.data) {
+            console.error(chalk.red(`Error Data: ${JSON.stringify(error.response.data, null, 2)}`));
+          }
+        } else {
+          console.error(chalk.red("Error:"), error.message || "Unknown error");
+        }
+      }
+    });
+}

package/src/commands/agent/generate.ts

@@ -0,0 +1,151 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import {
+  createNestboxConfig,
+  extractZip,
+} from "../../utils/agent";
+import inquirer from "inquirer";
+import path from "path";
+
+export function registerGenerateCommand(agentCommand: Command): void {
+  agentCommand
+    .command("generate <folder>")
+    .description("Generate a new project from templates")
+    .option("--lang <language>", "Project language (ts|js)")
+    .option("--template <type>", "Template type (agent|chatbot)")
+    .option("--project <projectId>", "Project ID")
+    .action(async (folder, options) => {
+      try {
+        const spinner = ora("Initializing project generation...").start();
+
+        // Ensure target folder doesn't exist
+        if (fs.existsSync(folder)) {
+          spinner.fail(`Folder ${folder} already exists`);
+          return;
+        }
+
+        let selectedLang = options.lang;
+        let selectedTemplate = options.template;
+
+        // Interactive selection if not provided
+        if (!selectedLang || !selectedTemplate) {
+          spinner.stop();
+          
+          const answers = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'lang',
+              message: 'Select project language:',
+              choices: [
+                { name: 'TypeScript', value: 'ts' },
+                { name: 'JavaScript', value: 'js' }
+              ],
+              when: () => !selectedLang
+            },
+            {
+              type: 'list',
+              name: 'template',
+              message: 'Select template type:',
+              choices: [
+                { name: 'Agent', value: 'agent' },
+                { name: 'Chatbot', value: 'chatbot' }
+              ],
+              when: () => !selectedTemplate
+            }
+          ]);
+
+          selectedLang = selectedLang || answers.lang;
+          selectedTemplate = selectedTemplate || answers.template;
+          
+          spinner.start("Generating project...");
+        }
+
+        // Find matching template in local templates folder
+        const templateMapping: Record<string, string> = {
+          'agent': 'base',
+          'chatbot': 'chatbot'
+        };
+        const mappedTemplateType = templateMapping[selectedTemplate] || selectedTemplate;
+        const templateKey = `template-${mappedTemplateType}-${selectedLang}.zip`;
+        
+        // Try process.cwd() first, then __dirname fallback
+        let templatePath = path.resolve(process.cwd(), 'templates', templateKey);
+        if (!fs.existsSync(templatePath)) {
+          // fallback to __dirname
+          templatePath = path.resolve(__dirname, '../../../templates', templateKey);
+        }
+        
+        if (!fs.existsSync(templatePath)) {
+          spinner.fail(`Template not found: ${templatePath}`);
+          // Show available templates in both locations
+          const cwdTemplates = path.resolve(process.cwd(), 'templates');
+          const dirTemplates = path.resolve(__dirname, '../../../templates');
+          let shown = false;
+          
+          if (fs.existsSync(cwdTemplates)) {
+            console.log(chalk.yellow('Available templates in ./templates:'));
+            fs.readdirSync(cwdTemplates).forEach(file => {
+              console.log(chalk.yellow(`  - ${file}`));
+            });
+            shown = true;
+          }
+          
+          if (fs.existsSync(dirTemplates)) {
+            console.log(chalk.yellow('Available templates in templates:'));
+            fs.readdirSync(dirTemplates).forEach(file => {
+              console.log(chalk.yellow(`  - ${file}`));
+            });
+            shown = true;
+          }
+          
+          if (!shown) {
+            console.log(chalk.red('No templates directory found. Please add your templates.'));
+          }
+          return;
+        }
+
+        spinner.text = `Extracting template to ${folder}...`;
+
+        try {
+          // Extract template to target folder
+          extractZip(templatePath, folder);
+
+          // Create nestbox.config.json for TypeScript projects
+          createNestboxConfig(folder, selectedLang === 'ts');
+
+          // Update package.json with project name if it exists
+          const packageJsonPath = path.join(folder, 'package.json');
+          if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            packageJson.name = path.basename(folder);
+            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+          }
+
+          spinner.succeed(`Successfully generated ${mappedTemplateType} project in ${folder}`);
+          
+          console.log(chalk.green("\nNext steps:"));
+          console.log(chalk.yellow(`  cd ${folder}`));
+          console.log(chalk.yellow("  npm install"));
+          if (selectedLang === 'ts') {
+            console.log(chalk.yellow("  npm run build"));
+          }
+          console.log(chalk.yellow("  nestbox agent deploy --agent <agent-name> --instance <instance-name>"));
+
+        } catch (error) {
+          // Clean up on error
+          if (fs.existsSync(folder)) {
+            fs.rmSync(folder, { recursive: true, force: true });
+          }
+          throw error;
+        }
+
+      } catch (error: any) {
+        console.error(
+          chalk.red("Error:"),
+          error.message || "Failed to generate project"
+        );
+      }
+    });
+}

package/src/commands/agent/index.ts

@@ -0,0 +1,12 @@
+// Main agent command exports
+export { createAgent, type CreateAgentOptions } from "./create";
+
+// Individual command exports for direct usage if needed
+export { registerListCommand } from "./list";
+export { registerRemoveCommand } from "./remove";
+export { registerDeployCommand } from "./deploy";
+export { registerGenerateCommand } from "./generate";
+export { registerCreateFromYamlCommand } from "./createFromYaml";
+
+// API utilities
+export { createApis, type ApiInstances } from "./apiUtils";