@nestbox-ai/cli 1.0.2 → 1.0.3

package/src/commands/projects.ts

@@ -0,0 +1,139 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { getAuthToken } from '../utils/auth';
+import { Configuration, ProjectsApi } from '@nestbox-ai/admin';
+
+// Define a type for the projects configuration
+interface ProjectsConfig {
+    default?: string;
+    [key: string]: string | undefined;
+}
+
+interface NestboxConfig {
+    projects: ProjectsConfig;
+}
+
+// Utility functions for project configuration
+export function getNestboxConfigPath(): string {
+    return path.join(process.cwd(), '.nestboxrc');
+}
+
+export function readNestboxConfig(): NestboxConfig {
+    const configPath = getNestboxConfigPath();
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            return JSON.parse(content);
+        } catch (error) {
+            return { projects: {} };
+        }
+    }
+    return { projects: {} };
+}
+
+export function writeNestboxConfig(config: NestboxConfig): void {
+    const configPath = getNestboxConfigPath();
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function registerProjectCommands(program: Command): void {
+
+    const authToken = getAuthToken();
+    const configuration = new Configuration({
+        basePath: authToken?.serverUrl,
+        baseOptions:{
+            headers: {
+                "Authorization": authToken?.token,
+            }
+        }
+    });
+
+    const projectsApi = new ProjectsApi(configuration);
+
+    // Create the main project command
+    const projectCommand = program
+        .command('project')
+        .description('Manage Nestbox projects');
+
+    // Add the basic 'use' subcommand
+    projectCommand
+        .command('use <project-name>')
+        .description('Set default project for all commands')
+        .action((projectName: string) => {
+            try {
+                if (!authToken) {
+                    console.error(chalk.red('No authentication token found. Please log in first.'));
+                    return;
+                }
+                const config = readNestboxConfig();
+
+                // Set the default project
+                config.projects = config.projects || {};
+                config.projects.default = projectName;
+
+                projectsApi.projectControllerGetAllProjects()
+                .then((response) => {
+                    // Check if the project exists
+                    const projectExists = response.data.data.projects.some((project: any) => project.name === projectName);
+                    if (!projectExists) {
+                        throw new Error(`Project '${projectName}' does not exist.`);
+                    }
+                    // Write the configuration
+                    writeNestboxConfig(config);
+                    console.log(chalk.green(`Default project set to '${projectName}'`));
+                })
+                .catch((error) => {
+                    console.error(error.message);
+                });
+
+            } catch (error) {
+                console.error(chalk.red('Error setting default project:'), error instanceof Error ? error.message : 'Unknown error');
+            }
+        });
+
+    // Add basic 'add' subcommand
+    projectCommand
+        .command('add <project-name> [alias]')
+        .description('Add a project with optional alias')
+        .action((projectName: string, alias?: string) => {
+            try {
+                if (!authToken) {
+                    console.error(chalk.red('No authentication token found. Please log in first.'));
+                    return;
+                }
+                const config = readNestboxConfig();
+                config.projects = config.projects || {};
+
+                // Check if the project already exists
+                if (config.projects[projectName]) {
+                    console.error(chalk.red(`Project '${projectName}' already exists.`));
+                    return;
+                }
+                // Check if the alias already exists
+                if (alias && config.projects[alias]) {
+                    console.error(chalk.red(`Alias '${alias}' already exists.`));
+                    return;
+                }
+
+                if (alias) {
+                  config.projects[alias] = projectName;
+                  console.log(chalk.green(`Added project '${projectName}' with alias '${alias}'`));
+                } else {
+                  config.projects[projectName] = projectName;
+                  console.log(chalk.green(`Added project '${projectName}'`));
+                }
+
+                // If this is the first project, set it as default
+                if (!config.projects.default) {
+                  config.projects.default = projectName;
+                  console.log(chalk.green(`Set '${projectName}' as the default project`));
+                }
+
+                writeNestboxConfig(config);
+            } catch (error) {
+                console.error(chalk.red('Error adding project:'), error instanceof Error ? error.message : 'Unknown error');
+            }
+        });
+}

package/src/index.ts

@@ -1 +1,24 @@
-console.log('Hello World');
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerAuthCommands } from './commands/auth';
+import { registerProjectCommands } from './commands/projects';
+import { registerComputeProgram } from './commands/compute';
+
+// Setup the CLI program
+const program = new Command();
+program
+  .name('nestbox')
+  .description('CLI tool for the Nestbox AI platform')
+  .version('1.0.0');
+
+// Register command groups
+registerAuthCommands(program);
+registerProjectCommands(program);
+registerComputeProgram(program);
+
+// Parse command line arguments
+program.parse(process.argv);
+// Only show help if no arguments were provided
+if (process.argv.length === 2) {
+  program.help();
+}

package/src/types/auth.ts

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

package/src/utils/auth.ts

@@ -0,0 +1,177 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { UserCredentials } from '../types/auth';
+
+// Config path
+const CONFIG_DIR = path.join(os.homedir(), '.config', '.nestbox');
+
+// Ensure config directory exists
+if (!fs.existsSync(CONFIG_DIR)) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+/**
+ * Get authentication token for a specific domain
+ */
+export function getAuthToken(domain?: string): {token: string, serverUrl: string, accessToken?: string} | null {
+  try {
+    const files = fs.readdirSync(CONFIG_DIR);
+
+    if (!domain) {
+      // If no domain is provided, return the first token found
+      const tokenFiles = files.filter(file => file.endsWith('.json'));
+      if (tokenFiles.length === 0) {
+        return null;
+      }
+      
+      const configData = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, tokenFiles[0])).toString());
+      return {
+        token: configData.token,
+        serverUrl: configData.apiServerUrl,
+        accessToken: configData.accessToken,
+      };
+    }
+    const domainFiles = files.filter(file => file.endsWith(`_${domain}.json`));
+
+    if (domainFiles.length === 0) {
+      return null;
+    }
+    
+    // If multiple accounts, sort by last used and take the most recent
+    let configData: UserCredentials;
+    
+    if (domainFiles.length > 1) {
+      const allConfigs = domainFiles.map(file => {
+        const data = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, file)).toString()) as UserCredentials;
+        return {
+          file,
+          data,
+        };
+      });
+
+      // Sort by last used, most recent first
+      configData = allConfigs[0].data;
+    } else {
+      // Just one file
+      const configFile = domainFiles[0];
+      configData = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, configFile)).toString());
+    }
+    
+    return {
+      token: configData.token,
+      serverUrl: configData.apiServerUrl,
+    }
+  } catch (error) {
+    console.error('Error getting auth token:', error);
+    return null;
+  }
+}
+
+/**
+ * Get user credentials for a specific domain and email
+ */
+export function getUserCredentials(domain: string, email?: string): UserCredentials | null {
+  try {
+    const files = fs.readdirSync(CONFIG_DIR);
+    let targetFiles: string[];
+    
+    if (email) {
+      // Get specific email for domain
+      targetFiles = files.filter(file => file === `${email}_${domain}.json`);
+    } else {
+      // Get all for domain, sort by last used
+      targetFiles = files.filter(file => file.endsWith(`_${domain}.json`));
+      
+      if (targetFiles.length > 1) {
+        const allConfigs = targetFiles.map(file => {
+          const data = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, file)).toString()) as UserCredentials;
+          return {
+            file,
+          };
+        });
+        
+        // Sort by last used, most recent first
+        targetFiles = [allConfigs[0].file];
+      }
+    }
+    
+    if (targetFiles.length === 0) {
+      return null;
+    }
+    
+    return JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, targetFiles[0])).toString());
+  } catch (error) {
+    console.error('Error getting user credentials:', error);
+    return null;
+  }
+}
+
+/**
+ * List all saved credentials
+ */
+export function listCredentials(): Array<{
+  domain: string;
+  email: string;
+  name?: string;
+  authMethod?: string;
+  lastUsed?: number;
+}> {
+  try {
+    const files = fs.readdirSync(CONFIG_DIR);
+    return files.map(file => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(CONFIG_DIR, file)).toString()) as UserCredentials;
+        return {
+          domain: data.domain,
+          email: data.email,
+          name: data.name,
+        };
+      } catch (error) {
+        // Skip invalid files
+        return null;
+      }
+    }).filter(Boolean) as Array<{
+      domain: string;
+      email: string;
+      name?: string;
+      authMethod?: string;
+      lastUsed?: number;
+    }>;
+  } catch (error) {
+    console.error('Error listing credentials:', error);
+    return [];
+  }
+}
+
+/**
+ * Remove credentials for a domain/email combination
+ */
+export function removeCredentials(domain: string, email?: string): boolean {
+  try {
+    const files = fs.readdirSync(CONFIG_DIR);
+    let domainFiles: string[];
+    
+    if (email) {
+      // Remove specific email for domain
+      domainFiles = files.filter(file => file === `${email}_${domain}.json`);
+    } else {
+      // Remove all for domain
+      domainFiles = files.filter(file => file.endsWith(`_${domain}.json`));
+    }
+    
+    if (domainFiles.length === 0) {
+      return false;
+    }
+    
+    domainFiles.forEach(file => {
+      fs.unlinkSync(path.join(CONFIG_DIR, file));
+    });
+    
+    return true;
+  } catch (error) {
+    console.error('Error removing credentials:', error);
+    return false;
+  }
+}

package/tsconfig.json

@@ -108,6 +108,9 @@
 
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true     ,                           /* Skip type checking all .d.ts files. */
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
   }
 }