berget 1.0.0 → 1.1.0

package/dist/src/utils/token-manager.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Manages authentication tokens including refresh functionality
+ */
+class TokenManager {
+    constructor() {
+        this.tokenData = null;
+        // Set up token file path in user's home directory
+        const bergetDir = path.join(os.homedir(), '.berget');
+        if (!fs.existsSync(bergetDir)) {
+            fs.mkdirSync(bergetDir, { recursive: true });
+        }
+        this.tokenFilePath = path.join(bergetDir, 'auth.json');
+        this.loadToken();
+    }
+    static getInstance() {
+        if (!TokenManager.instance) {
+            TokenManager.instance = new TokenManager();
+        }
+        return TokenManager.instance;
+    }
+    /**
+     * Load token data from file
+     */
+    loadToken() {
+        try {
+            if (fs.existsSync(this.tokenFilePath)) {
+                const data = fs.readFileSync(this.tokenFilePath, 'utf8');
+                this.tokenData = JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.dim('Failed to load authentication token'));
+            this.tokenData = null;
+        }
+    }
+    /**
+     * Save token data to file
+     */
+    saveToken() {
+        try {
+            if (this.tokenData) {
+                fs.writeFileSync(this.tokenFilePath, JSON.stringify(this.tokenData, null, 2));
+                // Set file permissions to be readable only by the owner
+                fs.chmodSync(this.tokenFilePath, 0o600);
+            }
+            else {
+                // If token data is null, remove the file
+                if (fs.existsSync(this.tokenFilePath)) {
+                    fs.unlinkSync(this.tokenFilePath);
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.dim('Failed to save authentication token'));
+        }
+    }
+    /**
+     * Get the current access token
+     * @returns The access token or null if not available
+     */
+    getAccessToken() {
+        if (!this.tokenData)
+            return null;
+        return this.tokenData.access_token;
+    }
+    /**
+     * Get the refresh token
+     * @returns The refresh token or null if not available
+     */
+    getRefreshToken() {
+        if (!this.tokenData)
+            return null;
+        return this.tokenData.refresh_token;
+    }
+    /**
+     * Check if the access token is expired
+     * @returns true if expired or about to expire (within 5 minutes), false otherwise
+     */
+    isTokenExpired() {
+        if (!this.tokenData || !this.tokenData.expires_at)
+            return true;
+        try {
+            // Consider token expired if it's within 10 minutes of expiration
+            // Using a larger buffer to be more proactive about refreshing
+            const expirationBuffer = 10 * 60 * 1000; // 10 minutes in milliseconds
+            const isExpired = Date.now() + expirationBuffer >= this.tokenData.expires_at;
+            if (isExpired && process.argv.includes('--debug')) {
+                console.log(chalk_1.default.yellow(`DEBUG: Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(this.tokenData.expires_at).toISOString()}`));
+            }
+            return isExpired;
+        }
+        catch (error) {
+            // If there's any error checking expiration, assume token is expired
+            console.error(chalk_1.default.dim(`Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`));
+            return true;
+        }
+    }
+    /**
+     * Set new token data
+     * @param accessToken The new access token
+     * @param refreshToken The new refresh token
+     * @param expiresIn Expiration time in seconds
+     */
+    setTokens(accessToken, refreshToken, expiresIn) {
+        this.tokenData = {
+            access_token: accessToken,
+            refresh_token: refreshToken,
+            expires_at: Date.now() + (expiresIn * 1000)
+        };
+        this.saveToken();
+    }
+    /**
+     * Update just the access token and its expiration
+     * @param accessToken The new access token
+     * @param expiresIn Expiration time in seconds
+     */
+    updateAccessToken(accessToken, expiresIn) {
+        if (!this.tokenData)
+            return;
+        this.tokenData.access_token = accessToken;
+        this.tokenData.expires_at = Date.now() + (expiresIn * 1000);
+        this.saveToken();
+    }
+    /**
+     * Clear all token data
+     */
+    clearTokens() {
+        this.tokenData = null;
+        this.saveToken();
+    }
+}
+exports.TokenManager = TokenManager;