berget 2.2.7 → 2.2.8

package/src/utils/opencode-validator.ts

@@ -1,28 +1,28 @@
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-import { readFileSync } from "fs";
-import { join } from "path";
-import { dirname } from "path";
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { dirname } from 'node:path';
 
 // Load the official OpenCode JSON Schema
 const __dirname = dirname(__filename);
-const schemaPath = join(__dirname, "..", "schemas", "opencode-schema.json");
+const schemaPath = join(__dirname, '..', 'schemas', 'opencode-schema.json');
 
 let ajv: Ajv;
 let openCodeSchema: any;
 let validateFunction: any;
 
 try {
-  const schemaContent = readFileSync(schemaPath, "utf-8");
+  const schemaContent = readFileSync(schemaPath, 'utf-8');
   openCodeSchema = JSON.parse(schemaContent);
 
   // Initialize AJV with formats and options
   ajv = new Ajv({
     allErrors: true,
-    verbose: true,
-    strict: false,
     allowUnionTypes: true,
     removeAdditional: false,
+    strict: false,
+    verbose: true,
   });
 
   // Add JSON Schema formats
@@ -31,43 +31,12 @@ try {
   // Compile the schema
   validateFunction = ajv.compile(openCodeSchema);
 } catch (error) {
-  console.error("Failed to load OpenCode schema:", error);
-  throw new Error("Could not initialize OpenCode validator");
+  console.error('Failed to load OpenCode schema:', error);
+  throw new Error('Could not initialize OpenCode validator');
 }
 
 export type OpenCodeConfig = any;
 
-/**
- * Validate OpenCode configuration against the official JSON Schema
- */
-export function validateOpenCodeConfig(config: any): {
-  valid: boolean;
-  errors?: string[];
-} {
-  try {
-    if (!validateFunction) {
-      return { valid: false, errors: ["Schema validator not initialized"] };
-    }
-
-    const isValid = validateFunction(config);
-
-    if (isValid) {
-      return { valid: true };
-    } else {
-      const errors = validateFunction.errors?.map((err: any) => {
-        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"] };
-  }
-}
-
 /**
  * Fix common OpenCode configuration issues
  */
@@ -75,50 +44,51 @@ export function fixOpenCodeConfig(config: any): OpenCodeConfig {
   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");
+  if (fixed.tools && typeof fixed.tools.compact === 'object') {
+    console.warn('⚠️  Converting tools.compact from object to boolean');
     // If it has properties, assume it should be enabled
     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: any) => {
       if (provider?.models) {
         Object.values(provider.models).forEach((model: any) => {
-          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');
           }
         });
       }
@@ -127,3 +97,34 @@ export function fixOpenCodeConfig(config: any): OpenCodeConfig {
 
   return fixed;
 }
+
+/**
+ * Validate OpenCode configuration against the official JSON Schema
+ */
+export function validateOpenCodeConfig(config: any): {
+  errors?: string[];
+  valid: boolean;
+} {
+  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: any) => {
+        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 };
+  }
+}

package/src/utils/token-manager.ts

@@ -1,32 +1,13 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { logger } from "./logger";
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { logger } from './logger';
 
 interface TokenData {
   access_token: string;
-  refresh_token: string;
   expires_at: number; // timestamp in milliseconds
-}
-
-/**
- * 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: string): number {
-  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;
+  refresh_token: string;
 }
 
 /**
@@ -34,16 +15,16 @@ function extractJwtExpiresAt(accessToken: string): number {
  */
 export class TokenManager {
   private static instance: TokenManager;
+  private tokenData: null | TokenData = null;
   private tokenFilePath: string;
-  private tokenData: TokenData | null = null;
 
   private constructor() {
     // Set up token file path in user's home directory
-    const bergetDir = path.join(os.homedir(), ".berget");
+    const bergetDir = path.join(os.homedir(), '.berget');
     if (!fs.existsSync(bergetDir)) {
       fs.mkdirSync(bergetDir, { recursive: true });
     }
-    this.tokenFilePath = path.join(bergetDir, "auth.json");
+    this.tokenFilePath = path.join(bergetDir, 'auth.json');
     this.loadToken();
   }
 
@@ -55,45 +36,18 @@ export class TokenManager {
   }
 
   /**
-   * Load token data from file
-   */
-  private loadToken(): void {
-    try {
-      if (fs.existsSync(this.tokenFilePath)) {
-        const data = fs.readFileSync(this.tokenFilePath, "utf8");
-        this.tokenData = JSON.parse(data);
-      }
-    } catch {
-      logger.error("Failed to load authentication token");
-      this.tokenData = null;
-    }
-  }
-
-  /**
-   * Save token data to file
+   * Clear all token data
    */
-  private saveToken(): void {
-    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.error("Failed to save authentication token");
-    }
+  public clearTokens(): void {
+    this.tokenData = null;
+    this.saveToken();
   }
 
   /**
    * Get the current access token
    * @returns The access token or null if not available
    */
-  public getAccessToken(): string | null {
+  public getAccessToken(): null | string {
     if (!this.tokenData) return null;
     return this.tokenData.access_token;
   }
@@ -102,7 +56,7 @@ export class TokenManager {
    * Get the refresh token
    * @returns The refresh token or null if not available
    */
-  public getRefreshToken(): string | null {
+  public getRefreshToken(): null | string {
     if (!this.tokenData) return null;
     return this.tokenData.refresh_token;
   }
@@ -129,7 +83,7 @@ export class TokenManager {
 
       if (isExpired) {
         logger.debug(
-          `Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(expiresAt).toISOString()}`
+          `Token expired or expiring soon. Current time: ${new Date().toISOString()}, Expiry: ${new Date(expiresAt).toISOString()}`,
         );
       }
 
@@ -137,7 +91,7 @@ export class TokenManager {
     } catch (error) {
       // If there's any error checking expiration, assume token is expired
       logger.error(
-        `Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`
+        `Error checking token expiration: ${error instanceof Error ? error.message : String(error)}`,
       );
       return true;
     }
@@ -156,8 +110,8 @@ export class TokenManager {
 
     this.tokenData = {
       access_token: accessToken,
-      refresh_token: refreshToken,
       expires_at: expiresAt,
+      refresh_token: refreshToken,
     };
     this.saveToken();
   }
@@ -180,10 +134,57 @@ export class TokenManager {
   }
 
   /**
-   * Clear all token data
+   * Load token data from file
    */
-  public clearTokens(): void {
-    this.tokenData = null;
-    this.saveToken();
+  private loadToken(): void {
+    try {
+      if (fs.existsSync(this.tokenFilePath)) {
+        const data = fs.readFileSync(this.tokenFilePath, 'utf8');
+        this.tokenData = JSON.parse(data);
+      }
+    } catch {
+      logger.error('Failed to load authentication token');
+      this.tokenData = null;
+    }
   }
+
+  /**
+   * Save token data to file
+   */
+  private saveToken(): void {
+    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.error('Failed to save authentication token');
+    }
+  }
+}
+
+/**
+ * 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: string): number {
+  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/tests/commands/chat.test.ts

@@ -1,20 +1,21 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { Command } from "commander";
-import { registerChatCommands } from "../../src/commands/chat";
-import { ChatService } from "../../src/services/chat-service";
-import { DefaultApiKeyManager } from "../../src/utils/default-api-key";
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { registerChatCommands } from '../../src/commands/chat';
+import { ChatService } from '../../src/services/chat-service';
+import { DefaultApiKeyManager } from '../../src/utils/default-api-key';
 
 // Mock dependencies
-vi.mock("../../src/services/chat-service");
-vi.mock("../../src/utils/default-api-key");
-vi.mock("readline", () => ({
+vi.mock('../../src/services/chat-service');
+vi.mock('../../src/utils/default-api-key');
+vi.mock('readline', () => ({
   createInterface: vi.fn(() => ({
-    question: vi.fn(),
     close: vi.fn(),
+    question: vi.fn(),
   })),
 }));
 
-describe("Chat Commands", () => {
+describe('Chat Commands', () => {
   let program: Command;
   let mockChatService: any;
   let mockDefaultApiKeyManager: any;
@@ -43,39 +44,39 @@ describe("Chat Commands", () => {
     vi.clearAllMocks();
   });
 
-  describe("chat run command", () => {
-    it("should use berget/glm-4.7 as default model", () => {
-      const chatCommand = program.commands.find(cmd => cmd.name() === "chat");
-      const runCommand = chatCommand?.commands.find(cmd => cmd.name() === "run");
+  describe('chat run command', () => {
+    it('should use berget/glm-4.7 as default model', () => {
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+      const runCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'run');
 
       expect(runCommand).toBeDefined();
 
       // Check the help text which contains the default model
       const helpText = runCommand?.helpInformation();
-      expect(helpText).toContain("glm-4.7");
+      expect(helpText).toContain('glm-4.7');
     });
 
-    it("should have streaming enabled by default", () => {
-      const chatCommand = program.commands.find(cmd => cmd.name() === "chat");
-      const runCommand = chatCommand?.commands.find(cmd => cmd.name() === "run");
+    it('should have streaming enabled by default', () => {
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+      const runCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'run');
 
       expect(runCommand).toBeDefined();
 
       // Check that the option is --no-stream (meaning streaming is default)
-      const streamOption = runCommand?.options.find(opt => opt.long === "--no-stream");
+      const streamOption = runCommand?.options.find((opt) => opt.long === '--no-stream');
       expect(streamOption).toBeDefined();
-      expect(streamOption?.description).toContain("Disable streaming");
+      expect(streamOption?.description).toContain('Disable streaming');
     });
 
-    it("should create completion with correct default options", async () => {
+    it('should create completion with correct default options', async () => {
       // Mock API key
-      process.env.BERGET_API_KEY = "test-key";
+      process.env.BERGET_API_KEY = 'test-key';
 
       // Mock successful completion
       mockChatService.createCompletion.mockResolvedValue({
         choices: [
           {
-            message: { content: "Test response" },
+            message: { content: 'Test response' },
           },
         ],
       });
@@ -90,30 +91,30 @@ describe("Chat Commands", () => {
     });
   });
 
-  describe("chat list command", () => {
-    it("should list available models", async () => {
+  describe('chat list command', () => {
+    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?.commands.find(cmd => cmd.name() === "list");
+      const chatCommand = program.commands.find((cmd) => cmd.name() === 'chat');
+      const listCommand = chatCommand?.commands.find((cmd) => cmd.name() === 'list');
 
       expect(listCommand).toBeDefined();
-      expect(listCommand?.description()).toBe("List available chat models");
+      expect(listCommand?.description()).toBe('List available chat models');
     });
   });
 });