fss-link 1.0.40 → 1.0.45

package/dist/config/providerPersistence.test.ts

@@ -0,0 +1,377 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AuthType, ModelConfig } from 'fss-link-core';
+import { ProviderManager } from './providerManager.js';
+import { getFSSLinkDatabase, closeFSSLinkDatabase } from './database.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('Provider Persistence System', () => {
+  let providerManager: ProviderManager;
+  let testDbPath: string;
+
+  beforeEach(async () => {
+    // Create temporary database for testing
+    testDbPath = path.join(os.tmpdir(), `test-fss-link-${Date.now()}.db`);
+    
+    // Override the database path for testing
+    process.env.FSS_LINK_TEST_DB = testDbPath;
+    
+    providerManager = ProviderManager.getInstance();
+    
+    // Initialize clean database
+    const db = await getFSSLinkDatabase();
+    await db.initialize();
+  });
+
+  afterEach(async () => {
+    // Clean up test database
+    closeFSSLinkDatabase();
+    if (fs.existsSync(testDbPath)) {
+      fs.unlinkSync(testDbPath);
+    }
+    delete process.env.FSS_LINK_TEST_DB;
+  });
+
+  describe('Provider Configuration Management', () => {
+    it('should save and retrieve provider configurations', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-4',
+        endpointUrl: 'https://api.openai.com/v1',
+        apiKey: 'test-key-123',
+        displayName: 'GPT-4 Test',
+        isFavorite: false,
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+      expect(providerId).toBeGreaterThan(0);
+
+      const allProviders = await providerManager.getAllProviders();
+      expect(allProviders).toHaveLength(1);
+      expect(allProviders[0].modelName).toBe('gpt-4');
+      expect(allProviders[0].displayName).toBe('GPT-4 Test');
+    });
+
+    it('should handle provider updates correctly', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OLLAMA,
+        modelName: 'llama2',
+        endpointUrl: 'http://localhost:11434/v1',
+        displayName: 'Llama 2 Local',
+        isFavorite: false,
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      // Update the provider
+      await providerManager.updateProvider(providerId, {
+        modelName: 'llama2-updated',
+        isFavorite: true
+      });
+
+      const allProviders = await providerManager.getAllProviders();
+      const updated = allProviders.find(p => p.id === providerId);
+      
+      expect(updated?.modelName).toBe('llama2-updated');
+      expect(updated?.isFavorite).toBe(true);
+      expect(updated?.displayName).toBe('Llama 2 Local'); // Should remain unchanged
+    });
+
+    it('should track usage statistics correctly', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-3.5-turbo',
+        displayName: 'GPT-3.5 Test',
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      // Record multiple usage sessions
+      await providerManager.recordUsage(providerId, 1000, 30000); // 1000 tokens, 30 seconds
+      await providerManager.recordUsage(providerId, 500, 15000);  // 500 tokens, 15 seconds
+      await providerManager.recordUsage(providerId, 2000, 60000); // 2000 tokens, 60 seconds
+
+      const stats = await providerManager.getUsageStatistics();
+      expect(stats[providerId]).toBeDefined();
+      // Note: Actual validation depends on database implementation
+    });
+  });
+
+  describe('Custom Endpoints Management', () => {
+    it('should save and retrieve custom endpoints', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'custom-model',
+        displayName: 'Custom Provider',
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      // Add custom endpoints
+      const endpoint1Id = await providerManager.saveCustomEndpoint(
+        providerId,
+        'Production API',
+        'https://api.custom.com/v1',
+        'Production endpoint',
+        true
+      );
+
+      const endpoint2Id = await providerManager.saveCustomEndpoint(
+        providerId,
+        'Staging API',
+        'https://staging-api.custom.com/v1',
+        'Staging endpoint',
+        false
+      );
+
+      expect(endpoint1Id).toBeGreaterThan(0);
+      expect(endpoint2Id).toBeGreaterThan(0);
+
+      const endpoints = await providerManager.getCustomEndpoints(providerId);
+      expect(endpoints).toHaveLength(2);
+
+      const defaultEndpoint = endpoints.find(e => e.is_default);
+      expect(defaultEndpoint?.name).toBe('Production API');
+    });
+
+    it('should handle default endpoint switching', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'test-model',
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      // Add first endpoint as default
+      await providerManager.saveCustomEndpoint(
+        providerId,
+        'Endpoint 1',
+        'https://api1.com/v1',
+        undefined,
+        true
+      );
+
+      // Add second endpoint as default (should unset first)
+      await providerManager.saveCustomEndpoint(
+        providerId,
+        'Endpoint 2',
+        'https://api2.com/v1',
+        undefined,
+        true
+      );
+
+      const endpoints = await providerManager.getCustomEndpoints(providerId);
+      const defaultEndpoints = endpoints.filter(e => e.is_default);
+      
+      expect(defaultEndpoints).toHaveLength(1);
+      expect(defaultEndpoints[0].name).toBe('Endpoint 2');
+    });
+  });
+
+  describe('Provider Settings Management', () => {
+    it('should save and retrieve provider-specific settings', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OLLAMA,
+        modelName: 'test-model',
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      // Save various settings
+      await providerManager.saveProviderSetting(providerId, 'num_ctx', 32768);
+      await providerManager.saveProviderSetting(providerId, 'temperature', 0.7);
+      await providerManager.saveProviderSetting(providerId, 'custom_prompt', 'You are a helpful assistant');
+
+      const settings = await providerManager.getProviderSettings(providerId);
+      
+      expect(settings.num_ctx).toBe(32768);
+      expect(settings.temperature).toBe(0.7);
+      expect(settings.custom_prompt).toBe('You are a helpful assistant');
+    });
+
+    it('should handle complex setting values', async () => {
+      const testConfig: ModelConfig = {
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'complex-config',
+        isActive: true
+      };
+
+      const providerId = await providerManager.saveProvider(testConfig);
+
+      const complexSetting = {
+        samplingParams: {
+          temperature: 0.8,
+          max_tokens: 2000,
+          top_p: 0.9
+        },
+        customHeaders: {
+          'X-Custom-Header': 'value'
+        }
+      };
+
+      await providerManager.saveProviderSetting(providerId, 'advanced_config', complexSetting);
+
+      const settings = await providerManager.getProviderSettings(providerId);
+      expect(settings.advanced_config).toEqual(complexSetting);
+    });
+  });
+
+  describe('Smart Default Selection', () => {
+    it('should select favorite provider as default', async () => {
+      // Create multiple providers
+      const _provider1Id = await providerManager.saveProvider({
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-4',
+        displayName: 'GPT-4',
+        isFavorite: false,
+        isActive: true
+      });
+
+      const _provider2Id = await providerManager.saveProvider({
+        authType: AuthType.OLLAMA,
+        modelName: 'llama2',
+        displayName: 'Llama 2',
+        isFavorite: true, // This should be selected as default
+        isActive: true
+      });
+
+      const provider3Id = await providerManager.saveProvider({
+        authType: AuthType.LM_STUDIO,
+        modelName: 'local-model',
+        displayName: 'Local Model',
+        isFavorite: false,
+        isActive: true
+      });
+
+      // Record usage for provider3 to make it most used
+      await providerManager.recordUsage(provider3Id, 5000, 120000);
+      await providerManager.recordUsage(provider3Id, 3000, 90000);
+
+      const defaultProvider = await providerManager.getDefaultProvider();
+      expect(defaultProvider?.displayName).toBe('Llama 2'); // Should prefer favorite over usage
+    });
+
+    it('should select most used provider when no favorite is set', async () => {
+      const provider1Id = await providerManager.saveProvider({
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-4',
+        displayName: 'GPT-4',
+        isActive: true
+      });
+
+      const provider2Id = await providerManager.saveProvider({
+        authType: AuthType.OLLAMA,
+        modelName: 'llama2',
+        displayName: 'Llama 2',
+        isActive: true
+      });
+
+      // Make provider2 most used
+      await providerManager.recordUsage(provider2Id, 10000, 300000);
+      await providerManager.recordUsage(provider2Id, 8000, 200000);
+      await providerManager.recordUsage(provider1Id, 2000, 60000);
+
+      const defaultProvider = await providerManager.getDefaultProvider();
+      expect(defaultProvider?.displayName).toBe('Llama 2');
+    });
+  });
+
+  describe('Provider Filtering and Querying', () => {
+    it('should filter providers by type correctly', async () => {
+      // Create providers of different types
+      await providerManager.saveProvider({
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-4',
+        isActive: true
+      });
+
+      await providerManager.saveProvider({
+        authType: AuthType.OLLAMA,
+        modelName: 'llama2',
+        isActive: true
+      });
+
+      await providerManager.saveProvider({
+        authType: AuthType.OPENAI_API_KEY,
+        modelName: 'gpt-3.5-turbo',
+        isActive: true
+      });
+
+      const openaiProviders = await providerManager.getProvidersByType(AuthType.OPENAI_API_KEY);
+      const ollamaProviders = await providerManager.getProvidersByType(AuthType.OLLAMA);
+
+      expect(openaiProviders).toHaveLength(2);
+      expect(ollamaProviders).toHaveLength(1);
+      expect(ollamaProviders[0].modelName).toBe('llama2');
+    });
+
+    it('should get recommended providers based on usage', async () => {
+      // Create several providers with different usage patterns
+      const providers = [];
+      for (let i = 0; i < 8; i++) {
+        const id = await providerManager.saveProvider({
+          authType: AuthType.OPENAI_API_KEY,
+          modelName: `model-${i}`,
+          displayName: `Model ${i}`,
+          isActive: true,
+          isFavorite: i === 2 // Make one a favorite
+        });
+        providers.push(id);
+
+        // Record different amounts of usage
+        if (i < 5) {
+          await providerManager.recordUsage(id, i * 1000, i * 30000);
+        }
+      }
+
+      const recommended = await providerManager.getRecommendedProviders(3);
+      expect(recommended).toHaveLength(3);
+      
+      // First should be the favorite
+      expect(recommended[0].displayName).toBe('Model 2');
+    });
+  });
+
+  describe('Auto-Configuration', () => {
+    it('should auto-configure provider from successful authentication', async () => {
+      const providerId = await providerManager.autoConfigureFromSuccess(
+        AuthType.USE_GEMINI,
+        'gemini-2.0-flash',
+        undefined,
+        'test-gemini-key',
+        { 
+          temperature: 0.7,
+          max_tokens: 2048
+        }
+      );
+
+      expect(providerId).toBeGreaterThan(0);
+
+      const allProviders = await providerManager.getAllProviders();
+      const newProvider = allProviders.find(p => p.id === providerId);
+
+      expect(newProvider?.authType).toBe(AuthType.USE_GEMINI);
+      expect(newProvider?.modelName).toBe('gemini-2.0-flash');
+      expect(newProvider?.apiKey).toBe('test-gemini-key');
+      expect(newProvider?.displayName).toContain('gemini-2.0-flash');
+
+      // Check additional settings were saved
+      const settings = await providerManager.getProviderSettings(providerId);
+      expect(settings.temperature).toBe(0.7);
+      expect(settings.max_tokens).toBe(2048);
+    });
+  });
+});

package/dist/config/providerPersistence.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AuthType } from 'fss-link-core';
+
+/**
+ * Provider configuration with full persistence support
+ */
+export interface ProviderConfig {
+  id?: number;
+  provider: AuthType;
+  displayName: string;
+  baseUrl?: string;
+  apiKey?: string;
+  model?: string;
+  isDefault: boolean;
+  usageCount: number;
+  lastUsed: Date;
+  customEndpoints?: CustomEndpoint[];
+  additionalSettings?: Record<string, unknown>;
+}
+
+/**
+ * Custom endpoint configuration
+ */
+export interface CustomEndpoint {
+  id?: number;
+  providerId: number;
+  name: string;
+  url: string;
+  description?: string;
+  isDefault: boolean;
+  created: Date;
+}
+
+/**
+ * Provider usage tracking
+ */
+export interface ProviderUsage {
+  providerId: number;
+  sessionCount: number;
+  totalTokens: number;
+  lastSession: Date;
+  averageSessionLength: number;
+}
+
+/**
+ * Enhanced provider persistence manager
+ */
+export class ProviderPersistenceManager {
+  private static instance: ProviderPersistenceManager;
+  
+  static getInstance(): ProviderPersistenceManager {
+    if (!ProviderPersistenceManager.instance) {
+      ProviderPersistenceManager.instance = new ProviderPersistenceManager();
+    }
+    return ProviderPersistenceManager.instance;
+  }
+
+  /**
+   * Save provider configuration with usage tracking
+   */
+  async saveProviderConfig(_config: ProviderConfig): Promise<number> {
+    // Implementation will integrate with existing database
+    throw new Error('Implementation pending');
+  }
+
+  /**
+   * Get all saved providers with usage statistics
+   */
+  async getAllProviders(): Promise<ProviderConfig[]> {
+    throw new Error('Implementation pending');
+  }
+
+  /**
+   * Get smart default provider based on usage and configuration
+   */
+  async getDefaultProvider(): Promise<ProviderConfig | null> {
+    throw new Error('Implementation pending');
+  }
+
+  /**
+   * Track provider usage for intelligent defaults
+   */
+  async recordProviderUsage(_providerId: number, _tokens: number, _sessionDuration: number): Promise<void> {
+    throw new Error('Implementation pending');
+  }
+
+  /**
+   * Get custom endpoints for a provider
+   */
+  async getCustomEndpoints(_providerId: number): Promise<CustomEndpoint[]> {
+    throw new Error('Implementation pending');
+  }
+
+  /**
+   * Save custom endpoint
+   */
+  async saveCustomEndpoint(_endpoint: CustomEndpoint): Promise<number> {
+    throw new Error('Implementation pending');
+  }
+}

package/dist/config/sandboxConfig.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { SandboxConfig } from 'fss-link-core';
+import commandExists from 'command-exists';
+import * as os from 'node:os';
+import { getPackageJson } from '../utils/package.js';
+import { Settings } from './settings.js';
+
+// This is a stripped-down version of the CliArgs interface from config.ts
+// to avoid circular dependencies.
+interface SandboxCliArgs {
+  sandbox?: boolean | string;
+  sandboxImage?: string;
+}
+
+const VALID_SANDBOX_COMMANDS: ReadonlyArray<SandboxConfig['command']> = [
+  'docker',
+  'podman',
+  'sandbox-exec',
+];
+
+function isSandboxCommand(value: string): value is SandboxConfig['command'] {
+  return (VALID_SANDBOX_COMMANDS as readonly string[]).includes(value);
+}
+
+function getSandboxCommand(
+  sandbox?: boolean | string,
+): SandboxConfig['command'] | '' {
+  // If the SANDBOX env var is set, we're already inside the sandbox.
+  if (process.env['SANDBOX']) {
+    return '';
+  }
+
+  // note environment variable takes precedence over argument (from command line or settings)
+  const environmentConfiguredSandbox =
+    process.env['GEMINI_SANDBOX']?.toLowerCase().trim() ?? '';
+  sandbox =
+    environmentConfiguredSandbox?.length > 0
+      ? environmentConfiguredSandbox
+      : sandbox;
+  if (sandbox === '1' || sandbox === 'true') sandbox = true;
+  else if (sandbox === '0' || sandbox === 'false' || !sandbox) sandbox = false;
+
+  if (sandbox === false) {
+    return '';
+  }
+
+  if (typeof sandbox === 'string' && sandbox) {
+    if (!isSandboxCommand(sandbox)) {
+      console.error(
+        `ERROR: invalid sandbox command '${sandbox}'. Must be one of ${VALID_SANDBOX_COMMANDS.join(
+          ', ',
+        )}`,
+      );
+      process.exit(1);
+    }
+    // confirm that specified command exists
+    if (commandExists.sync(sandbox)) {
+      return sandbox;
+    }
+    console.error(
+      `ERROR: missing sandbox command '${sandbox}' (from GEMINI_SANDBOX)`,
+    );
+    process.exit(1);
+  }
+
+  // look for seatbelt, docker, or podman, in that order
+  // for container-based sandboxing, require sandbox to be enabled explicitly
+  if (os.platform() === 'darwin' && commandExists.sync('sandbox-exec')) {
+    return 'sandbox-exec';
+  } else if (commandExists.sync('docker') && sandbox === true) {
+    return 'docker';
+  } else if (commandExists.sync('podman') && sandbox === true) {
+    return 'podman';
+  }
+
+  // throw an error if user requested sandbox but no command was found
+  if (sandbox === true) {
+    console.error(
+      'ERROR: GEMINI_SANDBOX is true but failed to determine command for sandbox; ' +
+        'install docker or podman or specify command in GEMINI_SANDBOX',
+    );
+    process.exit(1);
+  }
+
+  return '';
+}
+
+export async function loadSandboxConfig(
+  settings: Settings,
+  argv: SandboxCliArgs,
+): Promise<SandboxConfig | undefined> {
+  const sandboxOption = argv.sandbox ?? settings.sandbox;
+  const command = getSandboxCommand(sandboxOption);
+
+  const packageJson = await getPackageJson();
+  const image =
+    argv.sandboxImage ??
+    process.env['GEMINI_SANDBOX_IMAGE'] ??
+    packageJson?.config?.sandboxImageUri;
+
+  return command && image ? { command, image } : undefined;
+}