@nestbox-ai/cli 1.0.13 → 1.0.16

package/src/types/agentYaml.ts

@@ -0,0 +1,107 @@
+/**
+ * Type definition for Agent YAML configuration file
+ */
+
+/**
+ * Represents a parameter for an agent in the YAML configuration
+ */
+export interface AgentParameter {
+  /**
+   * Name of the parameter
+   */
+  name: string;
+  
+  /**
+   * Description of the parameter
+   */
+  description: string;
+  
+  /**
+   * Default value for the parameter
+   */
+  default?: any;
+  
+  /**
+   * Default value as a string (used internally)
+   */
+  default_value?: string;
+  
+  /**
+   * Whether this parameter is configurable by users
+   * @default true
+   */
+  isUserParam?: boolean;
+}
+
+/**
+ * Represents a single agent definition in the YAML configuration
+ */
+export interface AgentDefinition {
+  /**
+   * Name of the agent (required)
+   */
+  name: string;
+  
+  /**
+   * Description of the agent's purpose
+   * @default `AI agent for ${name}`
+   */
+  goal?: string;
+  
+  /**
+   * Agent type ("CHAT" or "AGENT")
+   * CHAT creates a chatbot, AGENT creates a regular agent
+   * @default "CHAT"
+   */
+  type?: string;
+  
+  /**
+   * Machine manifest ID for the agent
+   * @default "llamaindex-agent"
+   */
+  machineManifestId?: string;
+  
+  /**
+   * Instance IP address
+   * @default "http://34.121.124.21"
+   */
+  instanceIP?: string;
+  
+  /**
+   * Name of the machine
+   * @default "agent-instance"
+   */
+  machineName?: string;
+  
+  /**
+   * Machine instance ID
+   * @default 17
+   */
+  machineInstanceId?: number;
+  
+  /**
+   * Name of the instance
+   */
+  instanceName?: string;
+  
+  /**
+   * Model base ID
+   * @default ""
+   */
+  modelBaseId?: string;
+  
+  /**
+   * Agent parameters
+   */
+  parameters?: AgentParameter[];
+}
+
+/**
+ * Overall structure of the YAML configuration file
+ */
+export interface AgentYamlConfig {
+  /**
+   * Array of agent definitions
+   */
+  agents: AgentDefinition[];
+}

package/src/types/auth.ts

@@ -1,12 +1,12 @@
-/**
- * User credentials stored in the config file
- */
+// types/auth.ts
+
 export interface UserCredentials {
-  domain: string;
-  email: string;
-  token: string;
-  apiServerUrl: string;
-  name: string;
-  picture: string;
-  timestamp?: number;
+    domain: string;
+    email: string;
+    token: string;
+    accessToken: string;  // Google OAuth token
+    apiServerUrl: string;
+    name?: string;
+    picture?: string;
+    timestamp: string;
 }

package/src/utils/agent.ts

@@ -6,6 +6,7 @@ import { promisify } from "util";
 import { exec } from "child_process";
 import AdmZip from "adm-zip";
 import * as os from 'os';
+import axios from "axios";
 
 
 const execAsync = promisify(exec);
@@ -167,4 +168,85 @@ export function createZipFromDirectory(dirPath: any, excludePatterns = ['node_mo
   
   // Return the temp path for upload
   return tempZipFilePath;
+}
+
+export interface TemplateInfo {
+  name: string;
+  description: string;
+  fileId: string;
+  lang: string;
+  type: string;
+}
+
+export const TEMPLATES: Record<string, TemplateInfo> = {
+  'template-base-js.zip': {
+    name: 'Base JavaScript Agent',
+    description: 'Basic JavaScript agent template',
+    fileId: '1EYaa4eZWDc3HiaSnauXgW7oLJYzqOhPZ', // Replace with actual file ID
+    lang: 'js',
+    type: 'agent'
+  },
+  'template-base-ts.zip': {
+    name: 'Base TypeScript Agent',
+    description: 'Basic TypeScript agent template',
+    fileId: '1kk2JWlgeRuNOGpz8wsZUTD115qfNzWk5', // Replace with actual file ID
+    lang: 'ts',
+    type: 'agent'
+  },
+  'template-chatbot-js.zip': {
+    name: 'JavaScript Chatbot',
+    description: 'JavaScript chatbot template',
+    fileId: '1b4c4NQa_Qm85-GwObn52D-bEKz48zh9O', // Replace with actual file ID
+    lang: 'js',
+    type: 'chatbot'
+  },
+  'template-chatbot-ts.zip': {
+    name: 'TypeScript Chatbot',
+    description: 'TypeScript chatbot template',
+    fileId: '1vbA5Jlet3XIRMQ4NSsMsLMeHt-mUhRTe', // Replace with actual file ID
+    lang: 'ts',
+    type: 'chatbot'
+  }
+};
+
+export async function downloadFromGoogleDrive(fileId: string, outputPath: string): Promise<void> {
+  const url = `https://drive.google.com/uc?export=download&id=${fileId}`;
+  
+  const response = await axios({
+    method: 'GET',
+    url: url,
+    responseType: 'stream',
+  });
+
+  const writer = fs.createWriteStream(outputPath);
+  response.data.pipe(writer);
+
+  return new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+}
+
+// Helper function to extract zip file
+export function extractZip(zipPath: string, extractPath: string): void {
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(extractPath, true);
+}
+
+export function createNestboxConfig(projectPath: string, isTypeScript: boolean): void {
+  if (!isTypeScript) return;
+
+  const configPath = path.join(projectPath, 'nestbox.config.json');
+  const config = {
+    agents: {
+      predeploy: [
+        'rm -rf dist',
+        'npm run lint',
+        'npm run build'
+      ]
+    }
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(chalk.green(`Created nestbox.config.json at ${configPath}`));
 }

package/src/utils/auth.ts

@@ -62,6 +62,7 @@ export function getAuthToken(domain?: string): {token: string, serverUrl: string
     return {
       token: configData.token,
       serverUrl: configData.apiServerUrl,
+      accessToken: configData.accessToken,
     }
   } catch (error) {
     console.error('Error getting auth token:', error);
@@ -69,6 +70,31 @@ export function getAuthToken(domain?: string): {token: string, serverUrl: string
   }
 }
 
+/**
+ * Update the authentication token for a specific user
+ */
+export function updateAuthToken(email: string, domain: string, newToken: string): boolean {
+  try {
+    const fileName = `${email.replace('@', '_at_')}_${domain}.json`;
+    const filePath = path.join(CONFIG_DIR, fileName);
+    
+    if (!fs.existsSync(filePath)) {
+      console.error(`Credential file not found for ${email} at ${domain}`);
+      return false;
+    }
+    
+    const configData = JSON.parse(fs.readFileSync(filePath).toString());
+    configData.token = newToken;
+    configData.timestamp = new Date().toISOString();
+    
+    fs.writeFileSync(filePath, JSON.stringify(configData, null, 2));
+    return true;
+  } catch (error) {
+    console.error('Error updating auth token:', error);
+    return false;
+  }
+}
+
 /**
  * Get user credentials for a specific domain and email
  */
@@ -79,7 +105,8 @@ export function getUserCredentials(domain: string, email?: string): UserCredenti
     
     if (email) {
       // Get specific email for domain
-      targetFiles = files.filter(file => file === `${email}_${domain}.json`);
+      const emailFile = email.replace('@', '_at_');
+      targetFiles = files.filter(file => file === `${emailFile}_${domain}.json`);
     } else {
       // Get all for domain, sort by last used
       targetFiles = files.filter(file => file.endsWith(`_${domain}.json`));
@@ -89,10 +116,12 @@ export function getUserCredentials(domain: string, email?: string): UserCredenti
           const data = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, file)).toString()) as UserCredentials;
           return {
             file,
+            timestamp: data.timestamp || '1970-01-01T00:00:00.000Z'
           };
         });
         
-        // Sort by last used, most recent first
+        // Sort by timestamp, most recent first
+        allConfigs.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
         targetFiles = [allConfigs[0].file];
       }
     }
@@ -155,7 +184,8 @@ export function removeCredentials(domain: string, email?: string): boolean {
     
     if (email) {
       // Remove specific email for domain
-      domainFiles = files.filter(file => file === `${email}_${domain}.json`);
+      const emailFile = email.replace('@', '_at_');
+      domainFiles = files.filter(file => file === `${emailFile}_${domain}.json`);
     } else {
       // Remove all for domain
       domainFiles = files.filter(file => file.endsWith(`_${domain}.json`));

package/src/utils/error.ts

@@ -0,0 +1,168 @@
+// utils/error.ts
+import { AuthApi, Configuration, OAuthLoginRequestDTOTypeEnum } from '@nestbox-ai/admin';
+import { getAuthToken } from './auth';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+interface TokenRefreshResult {
+  success: boolean;
+  newToken?: string;
+  error?: string;
+}
+
+/**
+ * Attempts to refresh the authentication token using stored credentials
+ */
+async function refreshAuthToken(serverUrl: string, accessToken: string): Promise<TokenRefreshResult> {
+  try {
+    // Get the stored credentials to extract user info
+    const configDir = path.join(os.homedir(), '.config', '.nestbox');
+    const files = fs.readdirSync(configDir);
+    
+    // Find the credential file that matches this server URL
+    let userCredentials: any = null;
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(configDir, file), 'utf8'));
+        if (data.apiServerUrl === serverUrl && data.accessToken === accessToken) {
+          userCredentials = data;
+          break;
+        }
+      } catch (e) {
+        // Skip invalid files
+      }
+    }
+
+    if (!userCredentials) {
+      return { success: false, error: 'Could not find stored credentials' };
+    }
+
+    // Create new configuration with the access token
+    const configuration = new Configuration({
+      basePath: serverUrl,
+      accessToken: accessToken,
+    });
+
+    const authApi = new AuthApi(configuration);
+
+    // Try to re-authenticate using the stored Google OAuth token
+    const response = await authApi.authControllerOAuthLogin({
+      providerId: accessToken,
+      type: OAuthLoginRequestDTOTypeEnum.Google,
+      email: userCredentials.email,
+      profilePictureUrl: userCredentials.picture || '',
+    });
+
+    const newToken = response.data.token;
+
+    // Update the stored credentials with the new token
+    const fileName = `${userCredentials.email.replace('@', '_at_')}_${userCredentials.domain}.json`;
+    const filePath = path.join(configDir, fileName);
+    
+    userCredentials.token = newToken;
+    userCredentials.timestamp = new Date().toISOString();
+    
+    fs.writeFileSync(filePath, JSON.stringify(userCredentials, null, 2));
+
+    return { success: true, newToken };
+  } catch (error: any) {
+    console.error(chalk.yellow('Token refresh failed:'), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Enhanced 401 error handler with automatic token refresh
+ */
+export async function handle401Error(error: any, retryCallback?: () => Promise<any>): Promise<any> {
+  if (error.response && error.response.status === 401) {
+    // Get current auth token info
+    const authInfo = getAuthToken();
+    
+    if (!authInfo || !authInfo.accessToken) {
+      throw new Error('Authentication token has expired. Please login again using "nestbox login <domain>".');
+    }
+
+    console.log(chalk.yellow('Authentication token expired. Attempting to refresh...'));
+
+    // Try to refresh the token
+    const refreshResult = await refreshAuthToken(authInfo.serverUrl, authInfo.accessToken);
+
+    if (refreshResult.success && retryCallback) {
+      console.log(chalk.green('Token refreshed successfully. Retrying request...'));
+      
+      try {
+        // Retry the original request with the new token
+        const result = await retryCallback();
+        return { success: true, data: result };
+      } catch (retryError: any) {
+        // If retry also fails with 401, the refresh didn't work properly
+        if (retryError.response && retryError.response.status === 401) {
+          throw new Error('Authentication failed after token refresh. Please login again using "nestbox login <domain>".');
+        }
+        // Re-throw other errors
+        throw retryError;
+      }
+    } else {
+      // Refresh failed
+      throw new Error('Authentication token has expired and automatic refresh failed. Please login again using "nestbox login <domain>".');
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Wrapper function to make API calls with automatic retry on 401
+ */
+export async function withTokenRefresh<T>(
+  apiCall: () => Promise<T>,
+  onRetry?: () => void
+): Promise<T> {
+  try {
+    return await apiCall();
+  } catch (error: any) {
+    if (error.response && error.response.status === 401) {
+      // Get current auth token info
+      const authInfo = getAuthToken();
+      
+      if (!authInfo || !authInfo.accessToken) {
+        throw new Error('Authentication token has expired. Please login again using "nestbox login <domain>".');
+      }
+
+      console.log(chalk.yellow('Authentication token expired. Attempting to refresh...'));
+
+      // Try to refresh the token
+      const refreshResult = await refreshAuthToken(authInfo.serverUrl, authInfo.accessToken);
+
+      if (refreshResult.success) {
+        console.log(chalk.green('Token refreshed successfully. Retrying request...'));
+        
+        // If onRetry callback is provided, call it to reinitialize API clients
+        if (onRetry) {
+          onRetry();
+        }
+        
+        try {
+          // Retry the original API call
+          return await apiCall();
+        } catch (retryError: any) {
+          // If retry also fails with 401, the refresh didn't work properly
+          if (retryError.response && retryError.response.status === 401) {
+            throw new Error('Authentication failed after token refresh. Please login again using "nestbox login <domain>".');
+          }
+          // Re-throw other errors
+          throw retryError;
+        }
+      } else {
+        // Refresh failed
+        throw new Error('Authentication token has expired and automatic refresh failed. Please login again using "nestbox login <domain>".');
+      }
+    }
+    
+    // If not a 401 error, re-throw
+    throw error;
+  }
+}

package/src/utils/project.ts

@@ -2,11 +2,10 @@ 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;
@@ -17,15 +16,24 @@ interface CommandOptions {
     [key: string]: any;
 }
 
-export async function resolveProject(projectsApi: ProjectsApi, options: CommandOptions): Promise<ProjectInfo> {
-  const spinner = ora('Resolving project...').start();
+interface ResolveProjectOptions extends CommandOptions {
+    showSpinner?: boolean;  // New option to control spinner visibility
+}
+
+export async function resolveProject(
+    projectsApi: ProjectsApi, 
+    options: ResolveProjectOptions
+): Promise<ProjectInfo> {
+  // Default to showing spinner if not specified
+  const showSpinner = options.showSpinner !== false;
+  const spinner = showSpinner ? ora('Resolving project...').start() : null;
   
   try {
     const projectsResponse = await projectsApi.projectControllerGetAllProjects();
     const allProjects = projectsResponse.data?.data?.projects;
 
     if (!allProjects || allProjects.length === 0) {
-      spinner.fail('No projects found.');
+      if (spinner) spinner.fail('No projects found.');
       throw new Error('No projects found');
     }
 
@@ -43,39 +51,38 @@ export async function resolveProject(projectsApi: ProjectsApi, options: CommandO
         projectName = byName.name;
         projectId = byName.id;
       } else {
-        spinner.fail(`Project not found with ID or name: ${projectId}`);
+        if (spinner) 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})`);
+      if (spinner) 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.');
+        if (spinner) 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.`);
+        if (spinner) 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})`);
+      if (spinner) spinner.succeed(`Using default project: ${projectName} (ID: ${projectId})`);
     }
 
     return { id: projectId, name: projectName };
   } catch (error) {
-    if (!spinner.isSpinning) {
+    if (spinner && 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');
     }
-    spinner.fail('Failed to resolve project');
     throw error;
   }
 }