berget 0.0.4 → 1.0.0

package/src/services/auth-service.ts

@@ -1,11 +1,27 @@
-import { createAuthenticatedClient, saveAuthToken, clearAuthToken, apiClient } from '../client'
-import open from 'open'
+import {
+  createAuthenticatedClient,
+  saveAuthToken,
+  clearAuthToken,
+  apiClient,
+} from '../client'
+// We'll use dynamic import for 'open' to support ESM modules in CommonJS
 import chalk from 'chalk'
 import { handleError } from '../utils/error-handler'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
+/**
+ * Service for authentication operations
+ * Command group: auth
+ */
 export class AuthService {
   private static instance: AuthService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.AUTH
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.AUTH
 
   private constructor() {}
 
@@ -20,67 +36,99 @@ export class AuthService {
     try {
       // Clear any existing token to ensure a fresh login
       clearAuthToken()
-      
+
       console.log(chalk.blue('Initiating login process...'))
 
       // Step 1: Initiate device authorization
-      const { data: deviceData, error: deviceError } = await apiClient.POST('/v1/auth/device', {})
-      
+      const { data: deviceData, error: deviceError } = await apiClient.POST(
+        '/v1/auth/device',
+        {}
+      )
+
       if (deviceError || !deviceData) {
-        throw new Error(deviceError ? JSON.stringify(deviceError) : 'Failed to get device authorization data')
+        throw new Error(
+          deviceError
+            ? JSON.stringify(deviceError)
+            : 'Failed to get device authorization data'
+        )
       }
-      
+
       // Display information to user
       console.log(chalk.cyan('\nTo complete login:'))
-      console.log(chalk.cyan(`1. Open this URL: ${chalk.bold(deviceData.verification_url || 'https://auth.berget.ai/device')}`))
-      console.log(chalk.cyan(`2. Enter this code: ${chalk.bold(deviceData.user_code || '')}\n`))
-      
+      console.log(
+        chalk.cyan(
+          `1. Open this URL: ${chalk.bold(
+            deviceData.verification_url || 'https://auth.berget.ai/device'
+          )}`
+        )
+      )
+      console.log(
+        chalk.cyan(
+          `2. Enter this code: ${chalk.bold(deviceData.user_code || '')}\n`
+        )
+      )
+
       // Try to open browser automatically
       try {
         if (deviceData.verification_url) {
-          await open(deviceData.verification_url)
-          console.log(chalk.dim('Browser opened automatically. If it didn\'t open, please use the URL above.'))
+          // Use dynamic import for the 'open' package
+          const open = await import('open').then(m => m.default);
+          await open(deviceData.verification_url);
+          console.log(
+            chalk.dim(
+              "Browser opened automatically. If it didn't open, please use the URL above."
+            )
+          )
         }
       } catch (error) {
-        console.log(chalk.yellow('Could not open browser automatically. Please open the URL manually.'))
+        console.log(
+          chalk.yellow(
+            'Could not open browser automatically. Please open the URL manually.'
+          )
+        )
       }
-      
+
       console.log(chalk.dim('\nWaiting for authentication to complete...'))
-      
+
       // Step 2: Poll for completion
       const startTime = Date.now()
-      const expiresIn = deviceData.expires_in !== undefined ? deviceData.expires_in : 900
-      const expiresAt = startTime + (expiresIn * 1000)
+      const expiresIn =
+        deviceData.expires_in !== undefined ? deviceData.expires_in : 900
+      const expiresAt = startTime + expiresIn * 1000
       let pollInterval = (deviceData.interval || 5) * 1000
-      
+
       const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
       let spinnerIdx = 0
-      
+
       while (Date.now() < expiresAt) {
         // Wait for the polling interval
-        await new Promise(resolve => setTimeout(resolve, pollInterval))
-        
+        await new Promise((resolve) => setTimeout(resolve, pollInterval))
+
         // Update spinner
-        process.stdout.write(`\r${chalk.blue(spinner[spinnerIdx])} Waiting for authentication...`)
+        process.stdout.write(
+          `\r${chalk.blue(spinner[spinnerIdx])} Waiting for authentication...`
+        )
         spinnerIdx = (spinnerIdx + 1) % spinner.length
-        
+
         // Check if authentication is complete
         const deviceCode = deviceData.device_code || ''
-        const { data: tokenData, error: tokenError } = await apiClient.POST('/v1/auth/device/token', {
-          body: {
-            device_code: deviceCode
+        const { data: tokenData, error: tokenError } = await apiClient.POST(
+          '/v1/auth/device/token',
+          {
+            body: {
+              device_code: deviceCode,
+            },
           }
-        })
-        
+        )
+
         if (tokenError) {
           // Parse the error to get status and other details
-          const errorObj = typeof tokenError === 'string' 
-            ? JSON.parse(tokenError) 
-            : tokenError;
-          
-          const status = errorObj.status || 0;
-          const errorCode = errorObj.code || '';
-          
+          const errorObj =
+            typeof tokenError === 'string' ? JSON.parse(tokenError) : tokenError
+
+          const status = errorObj.status || 0
+          const errorCode = errorObj.code || ''
+
           if (status === 401 || errorCode === 'AUTHORIZATION_PENDING') {
             // Still waiting for user to complete authorization
             continue
@@ -91,10 +139,12 @@ export class AuthService {
           } else if (status === 400) {
             // Error or expired
             if (errorCode === 'EXPIRED_TOKEN') {
-              console.log(chalk.red('\n\nAuthentication timed out. Please try again.'))
+              console.log(
+                chalk.red('\n\nAuthentication timed out. Please try again.')
+              )
             } else if (errorCode !== 'AUTHORIZATION_PENDING') {
               // Only show error if it's not the expected "still waiting" error
-              const errorMessage = errorObj.message || JSON.stringify(errorObj);
+              const errorMessage = errorObj.message || JSON.stringify(errorObj)
               console.log(chalk.red(`\n\nError: ${errorMessage}`))
               return false
             } else {
@@ -106,28 +156,38 @@ export class AuthService {
             // For any other error, log it but continue polling
             // This makes the flow more resilient to temporary issues
             if (process.env.DEBUG) {
-              console.log(chalk.yellow(`\n\nReceived error: ${JSON.stringify(errorObj)}`))
-              console.log(chalk.yellow('Continuing to wait for authentication...'))
-              process.stdout.write(`\r${chalk.blue(spinner[spinnerIdx])} Waiting for authentication...`)
+              console.log(
+                chalk.yellow(`\n\nReceived error: ${JSON.stringify(errorObj)}`)
+              )
+              console.log(
+                chalk.yellow('Continuing to wait for authentication...')
+              )
+              process.stdout.write(
+                `\r${chalk.blue(
+                  spinner[spinnerIdx]
+                )} Waiting for authentication...`
+              )
             }
             continue
           }
         } else if (tokenData && tokenData.token) {
           // Success!
           saveAuthToken(tokenData.token)
-          
+
           process.stdout.write('\r' + ' '.repeat(50) + '\r') // Clear the spinner line
           console.log(chalk.green('✓ Successfully logged in to Berget'))
-          
+
           if (tokenData.user) {
             const user = tokenData.user as any
-            console.log(chalk.green(`Logged in as ${user.name || user.email || 'User'}`))
+            console.log(
+              chalk.green(`Logged in as ${user.name || user.email || 'User'}`)
+            )
           }
-          
+
           return true
         }
       }
-      
+
       console.log(chalk.red('\n\nAuthentication timed out. Please try again.'))
       return false
     } catch (error) {
@@ -145,8 +205,12 @@ export class AuthService {
       return false
     }
   }
-  
-  public async getUserProfile() {
+
+  /**
+   * Get current user profile
+   * Command: berget auth whoami
+   */
+  public async whoami() {
     try {
       const { data, error } = await this.client.GET('/v1/users/me')
       if (error) throw new Error(JSON.stringify(error))

package/src/services/cluster-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface Cluster {
   id: string
@@ -8,9 +9,19 @@ export interface Cluster {
   created: string
 }
 
+/**
+ * Service for managing Kubernetes clusters
+ * Command group: clusters
+ */
 export class ClusterService {
   private static instance: ClusterService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.CLUSTERS
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.CLUSTERS
 
   private constructor() {}
 
@@ -21,7 +32,11 @@ export class ClusterService {
     return ClusterService.instance
   }
 
-  public async getClusterUsage(clusterId: string): Promise<any> {
+  /**
+   * Get resource usage for a cluster
+   * Command: berget clusters get-usage
+   */
+  public async getUsage(clusterId: string): Promise<any> {
     try {
       const { data, error } = await this.client.GET(
         '/v1/clusters/{clusterId}/usage',
@@ -37,7 +52,11 @@ export class ClusterService {
     }
   }
 
-  public async listClusters(): Promise<Cluster[]> {
+  /**
+   * List all clusters
+   * Command: berget clusters list
+   */
+  public async list(): Promise<Cluster[]> {
     try {
       const { data, error } = await this.client.GET('/v1/clusters')
       if (error) throw new Error(JSON.stringify(error))
@@ -47,4 +66,20 @@ export class ClusterService {
       throw error
     }
   }
+  
+  /**
+   * Get detailed information about a cluster
+   * Command: berget clusters describe
+   */
+  public async describe(clusterId: string): Promise<Cluster | null> {
+    try {
+      // This is a placeholder since the API doesn't have a specific endpoint
+      // In a real implementation, this would call a specific endpoint
+      const clusters = await this.list()
+      return clusters.find(cluster => cluster.id === clusterId) || null
+    } catch (error) {
+      console.error('Failed to describe cluster:', error)
+      throw error
+    }
+  }
 }

package/src/services/collaborator-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface Collaborator {
   username: string
@@ -6,9 +7,19 @@ export interface Collaborator {
   status: string
 }
 
+/**
+ * Service for managing collaborators
+ * Command group: users
+ */
 export class CollaboratorService {
   private static instance: CollaboratorService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.USERS
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.USERS
 
   private constructor() {}
 
@@ -19,16 +30,24 @@ export class CollaboratorService {
     return CollaboratorService.instance
   }
 
-  // This endpoint is not available in the API
-  public async addCollaborator(
+  /**
+   * Invite a new collaborator
+   * Command: berget users invite
+   * This endpoint is not available in the API
+   */
+  public async invite(
     clusterId: string,
     githubUsername: string
   ): Promise<Collaborator[]> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async listCollaborators(clusterId: string): Promise<Collaborator[]> {
+  /**
+   * List all collaborators
+   * Command: berget users list
+   * This endpoint is not available in the API
+   */
+  public async list(clusterId: string): Promise<Collaborator[]> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/flux-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface FluxInstallOptions {
   cluster: string
@@ -12,9 +13,19 @@ export interface FluxBootstrapOptions {
   personal?: boolean
 }
 
+/**
+ * Service for managing Flux CD
+ * Command group: flux
+ */
 export class FluxService {
   private static instance: FluxService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.FLUX
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.FLUX
 
   private constructor() {}
 
@@ -25,13 +36,21 @@ export class FluxService {
     return FluxService.instance
   }
 
-  // This endpoint is not available in the API
-  public async installFlux(options: FluxInstallOptions): Promise<boolean> {
+  /**
+   * Install Flux CD
+   * Command: berget flux install
+   * This endpoint is not available in the API
+   */
+  public async install(options: FluxInstallOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async bootstrapFlux(options: FluxBootstrapOptions): Promise<boolean> {
+  /**
+   * Bootstrap Flux CD
+   * Command: berget flux bootstrap
+   * This endpoint is not available in the API
+   */
+  public async bootstrap(options: FluxBootstrapOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/helm-service.ts

@@ -1,4 +1,5 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
 export interface HelmRepoAddOptions {
   name: string
@@ -12,9 +13,19 @@ export interface HelmInstallOptions {
   values?: Record<string, string>
 }
 
+/**
+ * Service for managing Helm charts
+ * Command group: helm
+ */
 export class HelmService {
   private static instance: HelmService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.HELM
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.HELM
 
   private constructor() {}
 
@@ -25,13 +36,21 @@ export class HelmService {
     return HelmService.instance
   }
 
-  // This endpoint is not available in the API
+  /**
+   * Add a Helm repository
+   * Command: berget helm add-repo
+   * This endpoint is not available in the API
+   */
   public async addRepo(options: HelmRepoAddOptions): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async installChart(options: HelmInstallOptions): Promise<any> {
+  /**
+   * Install a Helm chart
+   * Command: berget helm install
+   * This endpoint is not available in the API
+   */
+  public async install(options: HelmInstallOptions): Promise<any> {
     throw new Error('This functionality is not available in the API')
   }
 }

package/src/services/kubectl-service.ts

@@ -1,8 +1,19 @@
 import { createAuthenticatedClient } from '../client'
+import { COMMAND_GROUPS, SUBCOMMANDS } from '../constants/command-structure'
 
+/**
+ * Service for managing Kubernetes resources
+ * Command group: kubectl
+ */
 export class KubectlService {
   private static instance: KubectlService
   private client = createAuthenticatedClient()
+  
+  // Command group name for this service
+  public static readonly COMMAND_GROUP = COMMAND_GROUPS.KUBECTL
+  
+  // Subcommands for this service
+  public static readonly COMMANDS = SUBCOMMANDS.KUBECTL
 
   private constructor() {}
 
@@ -13,18 +24,30 @@ export class KubectlService {
     return KubectlService.instance
   }
 
-  // This endpoint is not available in the API
+  /**
+   * Create a Kubernetes namespace
+   * Command: berget kubectl create-namespace
+   * This endpoint is not available in the API
+   */
   public async createNamespace(name: string): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async applyConfiguration(filename: string): Promise<boolean> {
+  /**
+   * Apply a Kubernetes configuration
+   * Command: berget kubectl apply
+   * This endpoint is not available in the API
+   */
+  public async apply(filename: string): Promise<boolean> {
     throw new Error('This functionality is not available in the API')
   }
 
-  // This endpoint is not available in the API
-  public async getResources(
+  /**
+   * Get Kubernetes resources
+   * Command: berget kubectl get
+   * This endpoint is not available in the API
+   */
+  public async get(
     resource: string,
     namespace?: string
   ): Promise<any[]> {