berget 0.0.4 → 0.1.0

package/dist/src/client.js

@@ -48,8 +48,8 @@ exports.apiClient = (0, openapi_fetch_1.default)({
     baseUrl: API_BASE_URL,
     headers: {
         'Content-Type': 'application/json',
-        'Accept': 'application/json'
-    }
+        Accept: 'application/json',
+    },
 });
 // Authentication functions
 const getAuthToken = () => {
@@ -72,7 +72,7 @@ const isTokenExpired = (token) => {
         const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
         const jsonPayload = decodeURIComponent(atob(base64)
             .split('')
-            .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
             .join(''));
         const payload = JSON.parse(jsonPayload);
         // Check if token has expired
@@ -127,20 +127,22 @@ const createAuthenticatedClient = () => {
             baseUrl: API_BASE_URL,
             headers: {
                 'Content-Type': 'application/json',
-                'Accept': 'application/json'
-            }
+                Accept: 'application/json',
+            },
         });
     }
     return (0, openapi_fetch_1.default)({
         baseUrl: API_BASE_URL,
-        headers: token ? {
-            'Authorization': `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        } : {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        },
+        headers: token
+            ? {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            }
+            : {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
     });
 };
 exports.createAuthenticatedClient = createAuthenticatedClient;

package/dist/src/services/auth-service.js

@@ -36,7 +36,9 @@ class AuthService {
                 // Step 1: Initiate device authorization
                 const { data: deviceData, error: deviceError } = yield client_1.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_1.default.cyan('\nTo complete login:'));
@@ -46,7 +48,7 @@ class AuthService {
                 try {
                     if (deviceData.verification_url) {
                         yield (0, open_1.default)(deviceData.verification_url);
-                        console.log(chalk_1.default.dim('Browser opened automatically. If it didn\'t open, please use the URL above.'));
+                        console.log(chalk_1.default.dim("Browser opened automatically. If it didn't open, please use the URL above."));
                     }
                 }
                 catch (error) {
@@ -56,13 +58,13 @@ class AuthService {
                 // 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 expiresAt = startTime + expiresIn * 1000;
                 let pollInterval = (deviceData.interval || 5) * 1000;
                 const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
                 let spinnerIdx = 0;
                 while (Date.now() < expiresAt) {
                     // Wait for the polling interval
-                    yield new Promise(resolve => setTimeout(resolve, pollInterval));
+                    yield new Promise((resolve) => setTimeout(resolve, pollInterval));
                     // Update spinner
                     process.stdout.write(`\r${chalk_1.default.blue(spinner[spinnerIdx])} Waiting for authentication...`);
                     spinnerIdx = (spinnerIdx + 1) % spinner.length;
@@ -70,14 +72,12 @@ class AuthService {
                     const deviceCode = deviceData.device_code || '';
                     const { data: tokenData, error: tokenError } = yield client_1.apiClient.POST('/v1/auth/device/token', {
                         body: {
-                            device_code: deviceCode
-                        }
+                            device_code: deviceCode,
+                        },
                     });
                     if (tokenError) {
                         // Parse the error to get status and other details
-                        const errorObj = typeof tokenError === 'string'
-                            ? JSON.parse(tokenError)
-                            : tokenError;
+                        const errorObj = typeof tokenError === 'string' ? JSON.parse(tokenError) : tokenError;
                         const status = errorObj.status || 0;
                         const errorCode = errorObj.code || '';
                         if (status === 401 || errorCode === 'AUTHORIZATION_PENDING') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "berget",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "bin": {
     "berget": "dist/index.js"

package/src/client.ts

@@ -1,22 +1,23 @@
-import createClient from 'openapi-fetch';
-import type { paths } from './types/api';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import chalk from 'chalk';
+import createClient from 'openapi-fetch'
+import type { paths } from './types/api'
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import chalk from 'chalk'
 
 // Configuration directory
-const CONFIG_DIR = path.join(os.homedir(), '.berget');
-const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+const CONFIG_DIR = path.join(os.homedir(), '.berget')
+const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json')
 
 // API Base URL
 // Use --local flag to test against local API
-const isLocalMode = process.argv.includes('--local');
-const API_BASE_URL = process.env.BERGET_API_URL || 
-                    (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai');
+const isLocalMode = process.argv.includes('--local')
+const API_BASE_URL =
+  process.env.BERGET_API_URL ||
+  (isLocalMode ? 'http://localhost:3000' : 'https://api.berget.ai')
 
 if (isLocalMode && !process.env.BERGET_API_URL) {
-  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'));
+  console.log(chalk.yellow('Using local API endpoint: http://localhost:3000'))
 }
 
 // Create a typed client for the Berget API
@@ -24,100 +25,109 @@ export const apiClient = createClient<paths>({
   baseUrl: API_BASE_URL,
   headers: {
     'Content-Type': 'application/json',
-    'Accept': 'application/json'
-  }
-});
+    Accept: 'application/json',
+  },
+})
 
 // Authentication functions
 export const getAuthToken = (): string | null => {
   try {
     if (fs.existsSync(TOKEN_FILE)) {
-      const tokenData = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
-      return tokenData.accessToken;
+      const tokenData = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'))
+      return tokenData.accessToken
     }
   } catch (error) {
-    console.error('Error reading auth token:', error);
+    console.error('Error reading auth token:', error)
   }
-  return null;
-};
+  return null
+}
 
 // Check if token is expired (JWT tokens have an exp claim)
 export const isTokenExpired = (token: string): boolean => {
   try {
-    const base64Url = token.split('.')[1];
-    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const base64Url = token.split('.')[1]
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
     const jsonPayload = decodeURIComponent(
       atob(base64)
         .split('')
-        .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+        .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
         .join('')
-    );
-    const payload = JSON.parse(jsonPayload);
-    
+    )
+    const payload = JSON.parse(jsonPayload)
+
     // Check if token has expired
     if (payload.exp) {
-      return payload.exp * 1000 < Date.now();
+      return payload.exp * 1000 < Date.now()
     }
   } catch (error) {
     // If we can't decode the token, assume it's expired
-    return true;
+    return true
   }
-  
+
   // If there's no exp claim, assume it's valid
-  return false;
-};
+  return false
+}
 
 export const saveAuthToken = (token: string): void => {
   try {
     if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.mkdirSync(CONFIG_DIR, { recursive: true })
     }
-    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ accessToken: token }), 'utf8');
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify({ accessToken: token }), 'utf8')
     // Set file permissions to be readable only by the owner
-    fs.chmodSync(TOKEN_FILE, 0o600);
+    fs.chmodSync(TOKEN_FILE, 0o600)
   } catch (error) {
-    console.error('Error saving auth token:', error);
+    console.error('Error saving auth token:', error)
   }
-};
+}
 
 export const clearAuthToken = (): void => {
   try {
     if (fs.existsSync(TOKEN_FILE)) {
-      fs.unlinkSync(TOKEN_FILE);
+      fs.unlinkSync(TOKEN_FILE)
     }
   } catch (error) {
-    console.error('Error clearing auth token:', error);
+    console.error('Error clearing auth token:', error)
   }
-};
+}
 
 // Create an authenticated client
 export const createAuthenticatedClient = () => {
-  const token = getAuthToken();
-  
+  const token = getAuthToken()
   if (!token) {
-    console.warn(chalk.yellow('No authentication token found. Please run `berget login` first.'));
+    console.warn(
+      chalk.yellow(
+        'No authentication token found. Please run `berget login` first.'
+      )
+    )
   } else if (isTokenExpired(token)) {
-    console.warn(chalk.yellow('Your authentication token has expired. Please run `berget login` to get a new token.'));
+    console.warn(
+      chalk.yellow(
+        'Your authentication token has expired. Please run `berget login` to get a new token.'
+      )
+    )
     // Optionally clear the expired token
-    clearAuthToken();
+    clearAuthToken()
     return createClient<paths>({
       baseUrl: API_BASE_URL,
       headers: {
         'Content-Type': 'application/json',
-        'Accept': 'application/json'
-      }
-    });
+        Accept: 'application/json',
+      },
+    })
   }
-  
+
   return createClient<paths>({
     baseUrl: API_BASE_URL,
-    headers: token ? { 
-      'Authorization': `Bearer ${token}`,
-      'Content-Type': 'application/json',
-      'Accept': 'application/json'
-    } : {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json'
-    },
-  });
-};
+    headers: token
+      ? {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        }
+      : {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+  })
+}

package/src/services/auth-service.ts

@@ -1,4 +1,9 @@
-import { createAuthenticatedClient, saveAuthToken, clearAuthToken, apiClient } from '../client'
+import {
+  createAuthenticatedClient,
+  saveAuthToken,
+  clearAuthToken,
+  apiClient,
+} from '../client'
 import open from 'open'
 import chalk from 'chalk'
 import { handleError } from '../utils/error-handler'
@@ -20,67 +25,97 @@ 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.'))
+          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 +126,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 +143,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,7 +192,7 @@ export class AuthService {
       return false
     }
   }
-  
+
   public async getUserProfile() {
     try {
       const { data, error } = await this.client.GET('/v1/users/me')