fss-link 1.0.49 → 1.0.51

package/dist/config/providerPersistence.test.ts

@@ -1,377 +0,0 @@
-/**
- * @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

@@ -1,105 +0,0 @@
-/**
- * @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

@@ -1,107 +0,0 @@
-/**
- * @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;
-}