@nestbox-ai/cli 1.0.23 → 1.0.24

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";

package/src/commands/agent/list.ts

@@ -0,0 +1,104 @@
+import { Command } from "commander";
+import { withTokenRefresh } from "../../utils/error";
+import chalk from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+import { resolveProject } from "../../utils/project";
+import { AgentType } from "../../types/agentType";
+import { createApis } from "./apiUtils";
+
+export function registerListCommand(agentCommand: Command): void {
+  agentCommand
+    .command("list")
+    .description("List all AI agents associated with the authenticated user")
+    .option(
+      "--project <projectName>",
+      "Project name (defaults to the current project)"
+    )
+    .action(async (options) => {
+      try {
+        let apis = createApis();
+
+        // Execute with token refresh support
+        await withTokenRefresh(
+          async () => {
+            // Resolve project
+            const projectData = await resolveProject(apis.projectsApi, options);
+
+            const spinner = ora(
+              `Listing agents in project ${projectData.name}...`
+            ).start();
+
+            try {
+              // Get the agents for the specific project
+              const agentsResponse: any =
+                await apis.agentsApi.machineAgentControllerGetMachineAgentByProjectId(
+                  projectData.id,
+                  0,
+                  10,
+                  AgentType.REGULAR
+                );
+
+              spinner.succeed("Successfully retrieved agents");
+
+              // Display the results
+              const agents = agentsResponse.data?.machineAgents || [];
+
+              if (!agents || agents.length === 0) {
+                console.log(
+                  chalk.yellow(`No agents found in project ${projectData.name}`)
+                );
+                return;
+              }
+
+              console.log(
+                chalk.blue(`\nAgents in project ${projectData.name}:\n`)
+              );
+
+              // Create a formatted table
+              const table = new Table({
+                head: [
+                  chalk.white.bold("ID"),
+                  chalk.white.bold("Name"),
+                  chalk.white.bold("URL"),
+                ],
+                style: {
+                  head: [],
+                  border: [],
+                },
+              });
+
+              // Add agents to the table
+              agents.forEach((agent: any) => {
+                let url = "N/A";
+                if (agent.instanceIP) {
+                  url = `${agent.instanceIP}/v1/agents/${agent.modelBaseId}/query`;
+                }
+
+                table.push([agent.id || "N/A", agent.agentName || "N/A", url]);
+              });
+
+              console.log(table.toString());
+              console.log(`\nTotal agents: ${agents.length}`);
+              
+            } catch (error: any) {
+              spinner.fail("Failed to retrieve agents");
+              throw error;
+            }
+          },
+          () => {
+            // Recreate APIs after token refresh
+            apis = createApis();
+          }
+        );
+      } catch (error: any) {
+        if (error.message && error.message.includes('Authentication')) {
+          console.error(chalk.red(error.message));
+        } else if (error.response?.data?.message) {
+          console.error(chalk.red("API Error:"), error.response.data.message);
+        } else {
+          console.error(chalk.red("Error:"), error.message || "Unknown error");
+        }
+      }
+    });
+}

package/src/commands/agent/remove.ts

@@ -0,0 +1,103 @@
+import { Command } from "commander";
+import { withTokenRefresh } from "../../utils/error";
+import chalk from "chalk";
+import ora from "ora";
+import { resolveProject } from "../../utils/project";
+import { AgentType } from "../../types/agentType";
+import { createApis } from "./apiUtils";
+
+export function registerRemoveCommand(agentCommand: Command): void {
+  agentCommand
+    .command("remove")
+    .description("Remove an AI agent")
+    .requiredOption("--agent <agentId>", "Agent ID to remove")
+    .option(
+      "--project <projectName>",
+      "Project name (defaults to the current project)"
+    )
+    .action(async (options) => {
+      try {
+        let apis = createApis();
+        const { agent } = options;
+
+        await withTokenRefresh(
+          async () => {
+            // Resolve project
+            const projectData = await resolveProject(apis.projectsApi, options);
+
+            const spinner = ora(
+              `Finding agent ${agent} in project ${projectData.name}...`
+            ).start();
+
+            try {
+              // Get the list of agents to find the correct modelbaseId
+              const agentsResponse: any =
+                await apis.agentsApi.machineAgentControllerGetMachineAgentByProjectId(
+                  projectData.id,
+                  0,
+                  100,
+                  AgentType.REGULAR
+                );
+
+              const agents = agentsResponse.data?.machineAgents || [];
+              const targetAgent = agents.find(
+                (a: any) => a.id.toString() === agent.toString()
+              );
+
+              if (!targetAgent) {
+                spinner.fail(
+                  `Agent with ID ${agent} not found in project ${projectData.name}`
+                );
+                return;
+              }
+
+              const modelbaseId = targetAgent.modelBaseId;
+              if (!modelbaseId) {
+                spinner.fail(
+                  `Could not find modelbaseId for agent ${agent}. Please try again.`
+                );
+                return;
+              }
+
+              spinner.text = `Removing agent ${agent} from project ${projectData.name}...`;
+
+              // Remove the agent
+              const payload: any = [
+                {
+                  id: parseInt(agent, 10),
+                  modelbaseId: modelbaseId,
+                },
+              ];
+
+              await apis.agentsApi.machineAgentControllerDeleteMachineAgents(
+                projectData.id,
+                agent,
+                payload
+              );
+
+              spinner.succeed("Successfully removed agent");
+              console.log(
+                chalk.green(
+                  `Agent ${agent} removed successfully from project ${projectData.name}`
+                )
+              );
+            } catch (error: any) {
+              spinner.fail("Failed to remove agent");
+              throw error;
+            }
+          },
+          () => {
+            apis = createApis();
+          }
+        );
+      } catch (error: any) {
+        if (error.message && error.message.includes('Authentication')) {
+          console.error(chalk.red(error.message));
+        } else if (error.response?.data?.message) {
+          console.error(chalk.red("API Error:"), error.response.data.message);
+        } else {
+          console.error(chalk.red("Error:"), error.message || "Unknown error");
+        }
+      }
+    });
+}