berget 2.2.6 → 2.2.8

package/dist/src/utils/opencode-validator.js

@@ -3,28 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixOpenCodeConfig = exports.validateOpenCodeConfig = void 0;
+exports.validateOpenCodeConfig = exports.fixOpenCodeConfig = void 0;
 const ajv_1 = __importDefault(require("ajv"));
 const ajv_formats_1 = __importDefault(require("ajv-formats"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const path_2 = require("path");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_path_2 = require("node:path");
 // Load the official OpenCode JSON Schema
-const __dirname = (0, path_2.dirname)(__filename);
-const schemaPath = (0, path_1.join)(__dirname, '..', 'schemas', 'opencode-schema.json');
+const __dirname = (0, node_path_2.dirname)(__filename);
+const schemaPath = (0, node_path_1.join)(__dirname, '..', 'schemas', 'opencode-schema.json');
 let ajv;
 let openCodeSchema;
 let validateFunction;
 try {
-    const schemaContent = (0, fs_1.readFileSync)(schemaPath, 'utf-8');
+    const schemaContent = (0, node_fs_1.readFileSync)(schemaPath, 'utf-8');
     openCodeSchema = JSON.parse(schemaContent);
     // Initialize AJV with formats and options
     ajv = new ajv_1.default({
         allErrors: true,
-        verbose: true,
-        strict: false,
         allowUnionTypes: true,
         removeAdditional: false,
+        strict: false,
+        verbose: true,
     });
     // Add JSON Schema formats
     (0, ajv_formats_1.default)(ajv);
@@ -35,39 +35,11 @@ catch (error) {
     console.error('Failed to load OpenCode schema:', error);
     throw new Error('Could not initialize OpenCode validator');
 }
-/**
- * Validate OpenCode configuration against the official JSON Schema
- */
-function validateOpenCodeConfig(config) {
-    var _a;
-    try {
-        if (!validateFunction) {
-            return { valid: false, errors: ['Schema validator not initialized'] };
-        }
-        const isValid = validateFunction(config);
-        if (isValid) {
-            return { valid: true };
-        }
-        else {
-            const errors = ((_a = validateFunction.errors) === null || _a === void 0 ? void 0 : _a.map((err) => {
-                const path = err.instancePath || err.schemaPath || 'root';
-                const message = err.message || 'Unknown error';
-                return `${path}: ${message}`;
-            })) || ['Unknown validation error'];
-            return { valid: false, errors };
-        }
-    }
-    catch (error) {
-        console.error('Validation error:', error);
-        return { valid: false, errors: ['Validation process failed'] };
-    }
-}
-exports.validateOpenCodeConfig = validateOpenCodeConfig;
 /**
  * Fix common OpenCode configuration issues
  */
 function fixOpenCodeConfig(config) {
-    const fixed = Object.assign({}, config);
+    const fixed = { ...config };
     // Fix tools.compact - should be boolean, not object
     if (fixed.tools && typeof fixed.tools.compact === 'object') {
         console.warn('⚠️  Converting tools.compact from object to boolean');
@@ -75,43 +47,39 @@ function fixOpenCodeConfig(config) {
         fixed.tools.compact = true;
     }
     // Remove invalid properties
-    const invalidProps = ['maxTokens', 'contextWindow'];
-    invalidProps.forEach((prop) => {
-        if (fixed[prop] !== undefined) {
-            console.warn(`⚠️  Removing invalid property: ${prop}`);
-            delete fixed[prop];
+    const invalidProperties = ['maxTokens', 'contextWindow'];
+    for (const property of invalidProperties) {
+        if (fixed[property] !== undefined) {
+            console.warn(`⚠️  Removing invalid property: ${property}`);
+            delete fixed[property];
         }
-    });
+    }
     // Fix provider models with invalid properties
     if (fixed.provider) {
         Object.values(fixed.provider).forEach((provider) => {
-            if (provider === null || provider === void 0 ? void 0 : provider.models) {
+            if (provider?.models) {
                 Object.values(provider.models).forEach((model) => {
-                    if (model && typeof model === 'object') {
-                        // Move maxTokens/contextWindow to proper structure if needed
-                        if (model.maxTokens || model.contextWindow) {
-                            if (!model.limit)
-                                model.limit = {};
-                            // Use the larger of maxTokens/contextWindow for context
-                            const contextValues = [
-                                model.maxTokens,
-                                model.contextWindow,
-                            ].filter(Boolean);
-                            if (contextValues.length > 0) {
-                                const newContext = Math.max(...contextValues);
-                                if (!model.limit.context || newContext > model.limit.context) {
-                                    model.limit.context = newContext;
-                                }
-                            }
-                            // Set a reasonable default for output if not present
-                            // (typically 1/4 to 1/8 of context window)
-                            if (!model.limit.output && model.limit.context) {
-                                model.limit.output = Math.floor(model.limit.context / 4);
+                    if (model &&
+                        typeof model === 'object' && // Move maxTokens/contextWindow to proper structure if needed
+                        (model.maxTokens || model.contextWindow)) {
+                        if (!model.limit)
+                            model.limit = {};
+                        // Use the larger of maxTokens/contextWindow for context
+                        const contextValues = [model.maxTokens, model.contextWindow].filter(Boolean);
+                        if (contextValues.length > 0) {
+                            const newContext = Math.max(...contextValues);
+                            if (!model.limit.context || newContext > model.limit.context) {
+                                model.limit.context = newContext;
                             }
-                            delete model.maxTokens;
-                            delete model.contextWindow;
-                            console.warn('⚠️  Moved maxTokens/contextWindow to limit.context/output');
                         }
+                        // Set a reasonable default for output if not present
+                        // (typically 1/4 to 1/8 of context window)
+                        if (!model.limit.output && model.limit.context) {
+                            model.limit.output = Math.floor(model.limit.context / 4);
+                        }
+                        delete model.maxTokens;
+                        delete model.contextWindow;
+                        console.warn('⚠️  Moved maxTokens/contextWindow to limit.context/output');
                     }
                 });
             }
@@ -120,3 +88,30 @@ function fixOpenCodeConfig(config) {
     return fixed;
 }
 exports.fixOpenCodeConfig = fixOpenCodeConfig;
+/**
+ * Validate OpenCode configuration against the official JSON Schema
+ */
+function validateOpenCodeConfig(config) {
+    try {
+        if (!validateFunction) {
+            return { errors: ['Schema validator not initialized'], valid: false };
+        }
+        const isValid = validateFunction(config);
+        if (isValid) {
+            return { valid: true };
+        }
+        else {
+            const errors = validateFunction.errors?.map((error) => {
+                const path = error.instancePath || error.schemaPath || 'root';
+                const message = error.message || 'Unknown error';
+                return `${path}: ${message}`;
+            }) || ['Unknown validation error'];
+            return { errors, valid: false };
+        }
+    }
+    catch (error) {
+        console.error('Validation error:', error);
+        return { errors: ['Validation process failed'], valid: false };
+    }
+}
+exports.validateOpenCodeConfig = validateOpenCodeConfig;

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

@@ -24,16 +24,18 @@ var __importStar = (this && this.__importStar) || function (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 fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 const logger_1 = require("./logger");
 /**
  * Manages authentication tokens including refresh functionality
  */
 class TokenManager {
+    static instance;
+    tokenData = null;
+    tokenFilePath;
     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)) {
@@ -49,40 +51,11 @@ class 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) {
-            logger_1.logger.error('Failed to load authentication token');
-            this.tokenData = null;
-        }
-    }
-    /**
-     * Save token data to file
+     * Clear all token data
      */
-    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) {
-            logger_1.logger.error('Failed to save authentication token');
-        }
+    clearTokens() {
+        this.tokenData = null;
+        this.saveToken();
     }
     /**
      * Get the current access token
@@ -134,34 +107,90 @@ class TokenManager {
      * Set new token data
      * @param accessToken The new access token
      * @param refreshToken The new refresh token
-     * @param expiresIn Expiration time in seconds
+     * @param expiresIn Expiration time in seconds (fallback if JWT parsing fails)
      */
     setTokens(accessToken, refreshToken, expiresIn) {
+        // Extract the actual expiry time from the JWT token
+        const jwtExpiresAt = extractJwtExpiresAt(accessToken);
+        const expiresAt = jwtExpiresAt > 0 ? jwtExpiresAt : Date.now() + expiresIn * 1000;
         this.tokenData = {
             access_token: accessToken,
+            expires_at: expiresAt,
             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
+     * @param expiresIn Expiration time in seconds (fallback if JWT parsing fails)
      */
     updateAccessToken(accessToken, expiresIn) {
         if (!this.tokenData)
             return;
+        // Extract the actual expiry time from the JWT token
+        const jwtExpiresAt = extractJwtExpiresAt(accessToken);
+        const expiresAt = jwtExpiresAt > 0 ? jwtExpiresAt : Date.now() + expiresIn * 1000;
         this.tokenData.access_token = accessToken;
-        this.tokenData.expires_at = Date.now() + expiresIn * 1000;
+        this.tokenData.expires_at = expiresAt;
         this.saveToken();
     }
     /**
-     * Clear all token data
+     * Load token data from file
      */
-    clearTokens() {
-        this.tokenData = null;
-        this.saveToken();
+    loadToken() {
+        try {
+            if (fs.existsSync(this.tokenFilePath)) {
+                const data = fs.readFileSync(this.tokenFilePath, 'utf8');
+                this.tokenData = JSON.parse(data);
+            }
+        }
+        catch {
+            logger_1.logger.error('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 {
+            logger_1.logger.error('Failed to save authentication token');
+        }
     }
 }
 exports.TokenManager = TokenManager;
+/**
+ * Extract the expiration time from a JWT token
+ * @param accessToken The JWT access token
+ * @returns The expiration timestamp in milliseconds, or 0 if invalid
+ */
+function extractJwtExpiresAt(accessToken) {
+    try {
+        const parts = accessToken.split('.');
+        if (parts.length !== 3)
+            return 0;
+        const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const decoded = JSON.parse(payload);
+        if (typeof decoded.exp === 'number') {
+            return decoded.exp * 1000; // JWT exp is in seconds, convert to milliseconds
+        }
+    }
+    catch {
+        // If decoding fails, return 0 (treated as expired)
+    }
+    return 0;
+}

package/dist/tests/commands/chat.test.js

@@ -1,16 +1,7 @@
 "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 });
-const vitest_1 = require("vitest");
 const commander_1 = require("commander");
+const vitest_1 = require("vitest");
 const chat_1 = require("../../src/commands/chat");
 const chat_service_1 = require("../../src/services/chat-service");
 const default_api_key_1 = require("../../src/utils/default-api-key");
@@ -19,8 +10,8 @@ vitest_1.vi.mock('../../src/services/chat-service');
 vitest_1.vi.mock('../../src/utils/default-api-key');
 vitest_1.vi.mock('readline', () => ({
     createInterface: vitest_1.vi.fn(() => ({
-        question: vitest_1.vi.fn(),
         close: vitest_1.vi.fn(),
+        question: vitest_1.vi.fn(),
     })),
 }));
 (0, vitest_1.describe)('Chat Commands', () => {
@@ -49,22 +40,22 @@ vitest_1.vi.mock('readline', () => ({
     (0, vitest_1.describe)('chat run command', () => {
         (0, vitest_1.it)('should use berget/glm-4.7 as default model', () => {
             const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
-            const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find((cmd) => cmd.name() === 'run');
+            const runCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
             // Check the help text which contains the default model
-            const helpText = runCommand === null || runCommand === void 0 ? void 0 : runCommand.helpInformation();
+            const helpText = runCommand?.helpInformation();
             (0, vitest_1.expect)(helpText).toContain('glm-4.7');
         });
         (0, vitest_1.it)('should have streaming enabled by default', () => {
             const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
-            const runCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find((cmd) => cmd.name() === 'run');
+            const runCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'run');
             (0, vitest_1.expect)(runCommand).toBeDefined();
             // Check that the option is --no-stream (meaning streaming is default)
-            const streamOption = runCommand === null || runCommand === void 0 ? void 0 : runCommand.options.find((opt) => opt.long === '--no-stream');
+            const streamOption = runCommand?.options.find((opt) => opt.long === '--no-stream');
             (0, vitest_1.expect)(streamOption).toBeDefined();
-            (0, vitest_1.expect)(streamOption === null || streamOption === void 0 ? void 0 : streamOption.description).toContain('Disable streaming');
+            (0, vitest_1.expect)(streamOption?.description).toContain('Disable streaming');
         });
-        (0, vitest_1.it)('should create completion with correct default options', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should create completion with correct default options', async () => {
             // Mock API key
             process.env.BERGET_API_KEY = 'test-key';
             // Mock successful completion
@@ -81,29 +72,29 @@ vitest_1.vi.mock('readline', () => ({
             (0, vitest_1.expect)(mockChatService.createCompletion).not.toHaveBeenCalled();
             // Clean up
             delete process.env.BERGET_API_KEY;
-        }));
+        });
     });
     (0, vitest_1.describe)('chat list command', () => {
-        (0, vitest_1.it)('should list available models', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, vitest_1.it)('should list available models', async () => {
             const mockModels = {
                 data: [
                     {
-                        id: 'gpt-oss',
-                        owned_by: 'openai',
                         active: true,
                         capabilities: {
-                            vision: false,
                             function_calling: true,
                             json_mode: true,
+                            vision: false,
                         },
+                        id: 'gpt-oss',
+                        owned_by: 'openai',
                     },
                 ],
             };
             mockChatService.listModels.mockResolvedValue(mockModels);
             const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
-            const listCommand = chatCommand === null || chatCommand === void 0 ? void 0 : chatCommand.commands.find((cmd) => cmd.name() === 'list');
+            const listCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'list');
             (0, vitest_1.expect)(listCommand).toBeDefined();
-            (0, vitest_1.expect)(listCommand === null || listCommand === void 0 ? void 0 : listCommand.description()).toBe('List available chat models');
-        }));
+            (0, vitest_1.expect)(listCommand?.description()).toBe('List available chat models');
+        });
     });
 });