berget 0.0.2 → 0.0.4

package/dist/src/services/api-key-service.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyService = void 0;
+const client_1 = require("../client");
+const error_handler_1 = require("../utils/error-handler");
+class ApiKeyService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!ApiKeyService.instance) {
+            ApiKeyService.instance = new ApiKeyService();
+        }
+        return ApiKeyService.instance;
+    }
+    listApiKeys() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.GET('/v1/api-keys');
+                if (error) {
+                    // Check if this is an authentication error
+                    const errorObj = typeof error === 'string' ? JSON.parse(error) : error;
+                    if (errorObj.status === 401) {
+                        throw new Error(JSON.stringify({
+                            error: "Authentication failed. Your session may have expired.",
+                            code: "AUTH_FAILED",
+                            details: "Please run 'berget login' to authenticate again."
+                        }));
+                    }
+                    throw new Error(JSON.stringify(error));
+                }
+                return data || [];
+            }
+            catch (error) {
+                (0, error_handler_1.handleError)('Failed to list API keys', error);
+                throw error;
+            }
+        });
+    }
+    createApiKey(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.POST('/v1/api-keys', {
+                    body: options
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return data;
+            }
+            catch (error) {
+                console.error('Failed to create API key:', error);
+                throw error;
+            }
+        });
+    }
+    deleteApiKey(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { error } = yield this.client.DELETE('/v1/api-keys/{id}', {
+                    params: { path: { id } }
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return true;
+            }
+            catch (error) {
+                console.error('Failed to delete API key:', error);
+                throw error;
+            }
+        });
+    }
+    rotateApiKey(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.PUT('/v1/api-keys/{id}/rotate', {
+                    params: { path: { id } }
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return data;
+            }
+            catch (error) {
+                console.error('Failed to rotate API key:', error);
+                throw error;
+            }
+        });
+    }
+    getApiKeyUsage(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.GET('/v1/api-keys/{id}/usage', {
+                    params: { path: { id } }
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return data;
+            }
+            catch (error) {
+                console.error('Failed to get API key usage:', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.ApiKeyService = ApiKeyService;

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

@@ -0,0 +1,168 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const client_1 = require("../client");
+const open_1 = __importDefault(require("open"));
+const chalk_1 = __importDefault(require("chalk"));
+const error_handler_1 = require("../utils/error-handler");
+class AuthService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!AuthService.instance) {
+            AuthService.instance = new AuthService();
+        }
+        return AuthService.instance;
+    }
+    login() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Clear any existing token to ensure a fresh login
+                (0, client_1.clearAuthToken)();
+                console.log(chalk_1.default.blue('Initiating login process...'));
+                // 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');
+                }
+                // Display information to user
+                console.log(chalk_1.default.cyan('\nTo complete login:'));
+                console.log(chalk_1.default.cyan(`1. Open this URL: ${chalk_1.default.bold(deviceData.verification_url || 'https://auth.berget.ai/device')}`));
+                console.log(chalk_1.default.cyan(`2. Enter this code: ${chalk_1.default.bold(deviceData.user_code || '')}\n`));
+                // Try to open browser automatically
+                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.'));
+                    }
+                }
+                catch (error) {
+                    console.log(chalk_1.default.yellow('Could not open browser automatically. Please open the URL manually.'));
+                }
+                console.log(chalk_1.default.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);
+                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));
+                    // Update spinner
+                    process.stdout.write(`\r${chalk_1.default.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 } = yield client_1.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 || '';
+                        if (status === 401 || errorCode === 'AUTHORIZATION_PENDING') {
+                            // Still waiting for user to complete authorization
+                            continue;
+                        }
+                        else if (status === 429) {
+                            // Slow down
+                            pollInterval *= 2;
+                            continue;
+                        }
+                        else if (status === 400) {
+                            // Error or expired
+                            if (errorCode === 'EXPIRED_TOKEN') {
+                                console.log(chalk_1.default.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);
+                                console.log(chalk_1.default.red(`\n\nError: ${errorMessage}`));
+                                return false;
+                            }
+                            else {
+                                // If it's AUTHORIZATION_PENDING, continue polling
+                                continue;
+                            }
+                            return false;
+                        }
+                        else {
+                            // 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_1.default.yellow(`\n\nReceived error: ${JSON.stringify(errorObj)}`));
+                                console.log(chalk_1.default.yellow('Continuing to wait for authentication...'));
+                                process.stdout.write(`\r${chalk_1.default.blue(spinner[spinnerIdx])} Waiting for authentication...`);
+                            }
+                            continue;
+                        }
+                    }
+                    else if (tokenData && tokenData.token) {
+                        // Success!
+                        (0, client_1.saveAuthToken)(tokenData.token);
+                        process.stdout.write('\r' + ' '.repeat(50) + '\r'); // Clear the spinner line
+                        console.log(chalk_1.default.green('✓ Successfully logged in to Berget'));
+                        if (tokenData.user) {
+                            const user = tokenData.user;
+                            console.log(chalk_1.default.green(`Logged in as ${user.name || user.email || 'User'}`));
+                        }
+                        return true;
+                    }
+                }
+                console.log(chalk_1.default.red('\n\nAuthentication timed out. Please try again.'));
+                return false;
+            }
+            catch (error) {
+                (0, error_handler_1.handleError)('Login failed', error);
+                return false;
+            }
+        });
+    }
+    isAuthenticated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Call an API endpoint that requires authentication
+                const { data, error } = yield this.client.GET('/v1/users/me');
+                return !!data && !error;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    getUserProfile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.GET('/v1/users/me');
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return data;
+            }
+            catch (error) {
+                (0, error_handler_1.handleError)('Failed to get user profile', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.AuthService = AuthService;

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

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterService = void 0;
+const client_1 = require("../client");
+class ClusterService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!ClusterService.instance) {
+            ClusterService.instance = new ClusterService();
+        }
+        return ClusterService.instance;
+    }
+    getClusterUsage(clusterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.GET('/v1/clusters/{clusterId}/usage', {
+                    params: { path: { clusterId } },
+                });
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return data;
+            }
+            catch (error) {
+                console.error('Failed to get cluster usage:', error);
+                throw error;
+            }
+        });
+    }
+    listClusters() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { data, error } = yield this.client.GET('/v1/clusters');
+                if (error)
+                    throw new Error(JSON.stringify(error));
+                return (data === null || data === void 0 ? void 0 : data.data) || [];
+            }
+            catch (error) {
+                console.error('Failed to list clusters:', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.ClusterService = ClusterService;

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

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollaboratorService = void 0;
+const client_1 = require("../client");
+class CollaboratorService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!CollaboratorService.instance) {
+            CollaboratorService.instance = new CollaboratorService();
+        }
+        return CollaboratorService.instance;
+    }
+    // This endpoint is not available in the API
+    addCollaborator(clusterId, githubUsername) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+    // This endpoint is not available in the API
+    listCollaborators(clusterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+}
+exports.CollaboratorService = CollaboratorService;

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

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluxService = void 0;
+const client_1 = require("../client");
+class FluxService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!FluxService.instance) {
+            FluxService.instance = new FluxService();
+        }
+        return FluxService.instance;
+    }
+    // This endpoint is not available in the API
+    installFlux(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+    // This endpoint is not available in the API
+    bootstrapFlux(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+}
+exports.FluxService = FluxService;

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

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelmService = void 0;
+const client_1 = require("../client");
+class HelmService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!HelmService.instance) {
+            HelmService.instance = new HelmService();
+        }
+        return HelmService.instance;
+    }
+    // This endpoint is not available in the API
+    addRepo(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+    // This endpoint is not available in the API
+    installChart(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+}
+exports.HelmService = HelmService;

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

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KubectlService = void 0;
+const client_1 = require("../client");
+class KubectlService {
+    constructor() {
+        this.client = (0, client_1.createAuthenticatedClient)();
+    }
+    static getInstance() {
+        if (!KubectlService.instance) {
+            KubectlService.instance = new KubectlService();
+        }
+        return KubectlService.instance;
+    }
+    // This endpoint is not available in the API
+    createNamespace(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+    // This endpoint is not available in the API
+    applyConfiguration(filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+    // This endpoint is not available in the API
+    getResources(resource, namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This functionality is not available in the API');
+        });
+    }
+}
+exports.KubectlService = KubectlService;

package/dist/src/utils/error-handler.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Formats and prints error messages in a consistent way
+ */
+function handleError(message, error) {
+    console.error(chalk_1.default.red(`Error: ${message}`));
+    // If the error is a string (like JSON.stringify(error))
+    if (typeof error === 'string') {
+        try {
+            // Try to parse it as JSON
+            const parsedError = JSON.parse(error);
+            if (parsedError.error) {
+                console.error(chalk_1.default.dim(`Details: ${parsedError.error}`));
+                if (parsedError.code) {
+                    console.error(chalk_1.default.dim(`Code: ${parsedError.code}`));
+                }
+            }
+            else {
+                console.error(chalk_1.default.dim(`Details: ${error}`));
+            }
+        }
+        catch (_a) {
+            // If it's not valid JSON, just print the string
+            console.error(chalk_1.default.dim(`Details: ${error}`));
+        }
+    }
+    else if (error && error.message) {
+        // If it's an Error object
+        console.error(chalk_1.default.dim(`Details: ${error.message}`));
+    }
+    // Check for authentication errors
+    if ((typeof error === 'string' && error.includes('Unauthorized')) ||
+        (error && error.message && error.message.includes('Unauthorized')) ||
+        (error && error.code && error.code === 401)) {
+        console.error(chalk_1.default.yellow('\nYou need to be logged in to use this command.'));
+        console.error(chalk_1.default.yellow('Run `berget login` to authenticate.'));
+    }
+}
+exports.handleError = handleError;