loren-code 0.1.0

package/scripts/uninstall-claude-ollama.ps1

@@ -0,0 +1,73 @@
+$ErrorActionPreference = "Stop"
+
+$repoRoot = Split-Path -Parent $PSScriptRoot
+$userProfile = [Environment]::GetFolderPath("UserProfile")
+$appData = [Environment]::GetFolderPath("ApplicationData")
+$workspaceSettingsPath = Join-Path $appData "Code\\User\\settings.json"
+$claudeSettingsPath = Join-Path $userProfile ".claude\\settings.json"
+$bridgePidPath = Join-Path $repoRoot ".runtime\\bridge.pid"
+$launcherExePath = Join-Path $repoRoot "scripts\\ClaudeWrapperLauncher.exe"
+
+function Read-JsonFile {
+  param([string]$Path)
+
+  if (-not (Test-Path $Path)) {
+    return @{}
+  }
+
+  $raw = Get-Content -LiteralPath $Path -Raw
+  if ([string]::IsNullOrWhiteSpace($raw)) {
+    return @{}
+  }
+
+  $parsed = $raw | ConvertFrom-Json
+  if ($null -eq $parsed) {
+    return @{}
+  }
+
+  $result = @{}
+  foreach ($property in $parsed.PSObject.Properties) {
+    $result[$property.Name] = $property.Value
+  }
+
+  return $result
+}
+
+function Write-JsonFile {
+  param(
+    [string]$Path,
+    [hashtable]$Data
+  )
+
+  $json = $Data | ConvertTo-Json -Depth 20
+  Set-Content -LiteralPath $Path -Value ($json + "`n") -Encoding UTF8
+}
+
+if (Test-Path $workspaceSettingsPath) {
+  $settings = Read-JsonFile -Path $workspaceSettingsPath
+  [void]$settings.Remove("claudeCode.claudeProcessWrapper")
+  [void]$settings.Remove("claudeCode.disableLoginPrompt")
+  Write-JsonFile -Path $workspaceSettingsPath -Data $settings
+}
+
+if (Test-Path $claudeSettingsPath) {
+  $settings = Read-JsonFile -Path $claudeSettingsPath
+  [void]$settings.Remove("model")
+  [void]$settings.Remove("availableModels")
+  Write-JsonFile -Path $claudeSettingsPath -Data $settings
+}
+
+if (Test-Path $bridgePidPath) {
+  try {
+    $pid = [int](Get-Content -LiteralPath $bridgePidPath -Raw).Trim()
+    Stop-Process -Id $pid -Force -ErrorAction SilentlyContinue
+  } catch {
+  }
+  Remove-Item -LiteralPath $bridgePidPath -Force -ErrorAction SilentlyContinue
+}
+
+if (Test-Path $launcherExePath) {
+  Remove-Item -LiteralPath $launcherExePath -Force -ErrorAction SilentlyContinue
+}
+
+Write-Host "Configurazione globale rimossa."

package/src/bootstrap.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function ensureRuntimeDir(projectRoot) {
+  fs.mkdirSync(path.join(projectRoot, ".runtime"), { recursive: true });
+}
+
+export function ensureEnvLocal(projectRoot, options = {}) {
+  const envLocalPath = path.join(projectRoot, ".env.local");
+  const envExamplePath = path.join(projectRoot, ".env.example");
+  const logger = options.logger ?? console;
+
+  if (fs.existsSync(envLocalPath)) {
+    return { created: false, path: envLocalPath };
+  }
+
+  if (!fs.existsSync(envExamplePath)) {
+    fs.writeFileSync(envLocalPath, "OLLAMA_API_KEYS=\nBRIDGE_HOST=127.0.0.1\nBRIDGE_PORT=8788\n", "utf8");
+    logger.warn?.(`Created ${envLocalPath}. Add your Ollama API key(s) before starting the bridge.`);
+    return { created: true, path: envLocalPath };
+  }
+
+  fs.copyFileSync(envExamplePath, envLocalPath);
+  logger.warn?.(`Created ${envLocalPath} from .env.example. Add your real Ollama API key(s) before starting the bridge.`);
+  return { created: true, path: envLocalPath };
+}
+
+export function getBridgeBaseUrl(config) {
+  return `http://${config.host}:${config.port}`;
+}

package/src/cache.js

@@ -0,0 +1,64 @@
+import NodeCache from 'node-cache';
+import logger from './logger.js';
+
+// Cache per i modelli (5 minuti di TTL)
+export const modelCache = new NodeCache({
+  stdTTL: 300, // 5 minuti
+  checkperiod: 60, // Controlla ogni minuto se ci sono entry scadute
+  useClones: false // Performance migliore se non usiamo clones
+});
+
+// Cache per le risposte delle API (30 secondi)
+export const apiCache = new NodeCache({
+  stdTTL: 30,
+  checkperiod: 10,
+  useClones: false
+});
+
+// Funzione helper per il caching con error handling
+export function getFromCache(cache, key) {
+  try {
+    const value = cache.get(key);
+    if (value !== undefined) {
+      logger.debug(`Cache hit for key: ${key}`);
+    }
+    return value;
+  } catch (error) {
+    logger.error(`Error reading from cache: ${error.message}`);
+    return undefined;
+  }
+}
+
+export function setInCache(cache, key, value, ttl) {
+  try {
+    if (ttl) {
+      cache.set(key, value, ttl);
+    } else {
+      cache.set(key, value);
+    }
+    logger.debug(`Cached value for key: ${key}`);
+  } catch (error) {
+    logger.error(`Error writing to cache: ${error.message}`);
+  }
+}
+
+export function deleteFromCache(cache, key) {
+  try {
+    cache.del(key);
+    logger.debug(`Deleted cache for key: ${key}`);
+  } catch (error) {
+    logger.error(`Error deleting from cache: ${error.message}`);
+  }
+}
+
+// Stats per il monitoraggio
+export function getCacheStats(cache, name) {
+  const stats = cache.getStats();
+  return {
+    name,
+    hits: stats.hits,
+    misses: stats.misses,
+    keys: cache.keys().length,
+    hitRate: stats.hits > 0 ? (stats.hits / (stats.hits + stats.misses) * 100).toFixed(2) : 0
+  };
+}

package/src/config-watcher.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import logger from './logger.js';
+
+export class ConfigWatcher {
+  constructor(configFile, onChange) {
+    this.configFile = configFile;
+    this.onChange = onChange;
+    this.watcher = null;
+    this.debounceTimeout = 1000; // 1 secondo
+    this.debounceTimer = null;
+  }
+
+  start() {
+    if (this.watcher) {
+      logger.warn('Config watcher already started');
+      return;
+    }
+
+    try {
+      this.watcher = fs.watch(this.configFile, (eventType, filename) => {
+        if (eventType === 'change') {
+          logger.debug(`Config file changed: ${filename}`);
+          this.handleChange();
+        }
+      });
+
+      logger.info(`Started watching config file: ${this.configFile}`);
+    } catch (error) {
+      logger.error(`Failed to start config watcher: ${error.message}`);
+    }
+  }
+
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+      logger.info('Config watcher stopped');
+    }
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+
+  handleChange() {
+    // Debounce per evitare multipli reload rapidi
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(async () => {
+      try {
+        logger.info('Reloading configuration...');
+        await this.onChange();
+        logger.info('Configuration reloaded successfully');
+      } catch (error) {
+        logger.error(`Failed to reload configuration: ${error.message}`);
+      }
+    }, this.debounceTimeout);
+  }
+}
+
+// Funzione helper per creare un config watcher con reload automatico
+export function createConfigWatcher(configFile, loadConfigFunction) {
+  const watcher = new ConfigWatcher(configFile, async () => {
+    const newConfig = loadConfigFunction();
+    return newConfig;
+  });
+
+  return watcher;
+}

package/src/config.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const DEFAULT_PORT = 8788;
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_UPSTREAM = "https://ollama.com";
+
+export function loadEnvFile(filePath = path.join(process.cwd(), ".env.local")) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  const result = {};
+  const raw = fs.readFileSync(filePath, "utf8");
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const separator = trimmed.indexOf("=");
+    if (separator === -1) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, separator).trim();
+    let value = trimmed.slice(separator + 1).trim();
+    if (
+      (value.startsWith("\"") && value.endsWith("\"")) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+function parseKeyList(value) {
+  if (!value) {
+    return [];
+  }
+
+  return value
+    .split(/[,\r?\n]+/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function parseAliasMap(value) {
+  if (!value) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error("OLLAMA_MODEL_ALIASES must be valid JSON.");
+  }
+}
+
+export function saveEnvFile(filePath, envVars) {
+  const lines = Object.entries(envVars)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+  fs.writeFileSync(filePath, `${lines}\n`, "utf8");
+}
+
+export function loadConfig() {
+  const fileEnv = loadEnvFile();
+  const getValue = (name, fallback = undefined) => {
+    if (Object.prototype.hasOwnProperty.call(fileEnv, name)) {
+      return fileEnv[name];
+    }
+
+    if (Object.prototype.hasOwnProperty.call(process.env, name)) {
+      return process.env[name];
+    }
+
+    return fallback;
+  };
+
+  const apiKeys = parseKeyList(getValue("OLLAMA_API_KEYS") || getValue("OLLAMA_API_KEY"));
+  const aliases = parseAliasMap(getValue("OLLAMA_MODEL_ALIASES"));
+
+  return {
+    host: getValue("BRIDGE_HOST", DEFAULT_HOST),
+    port: Number.parseInt(getValue("BRIDGE_PORT", `${DEFAULT_PORT}`), 10),
+    upstreamBaseUrl: (getValue("OLLAMA_UPSTREAM_BASE_URL", DEFAULT_UPSTREAM)).replace(/\/+$/, ""),
+    apiKeys,
+    aliases,
+    defaultModel:
+      getValue("DEFAULT_MODEL_ALIAS") ||
+      "ollama-free-auto",
+  };
+}

package/src/http-agents.js

@@ -0,0 +1,80 @@
+import http from 'node:http';
+import https from 'node:https';
+import logger from './logger.js';
+
+// Agent per connessioni HTTP (keep-alive abilitato)
+export const httpAgent = new http.Agent({
+  keepAlive: true,
+  maxSockets: 50, // Massimo 50 connessioni contemporanee
+  maxFreeSockets: 10, // Mantieni fino a 10 connessioni aperte in idle
+  timeout: 60000, // Timeout di 60 secondi
+  freeSocketTimeout: 30000, // Chiudi socket idle dopo 30 secondi
+  scheduling: 'lifo' // Last In, First Out per miglior performance
+});
+
+// Agent per connessioni HTTPS
+export const httpsAgent = new https.Agent({
+  keepAlive: true,
+  maxSockets: 50,
+  maxFreeSockets: 10,
+  timeout: 60000,
+  freeSocketTimeout: 30000,
+  scheduling: 'lifo'
+});
+
+// Funzione helper per ottenere l'agent corretto
+export function getAgent(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === 'https:' ? httpsAgent : httpAgent;
+  } catch (error) {
+    logger.error(`Invalid URL for agent selection: ${error.message}`);
+    return httpAgent;
+  }
+}
+
+// Stats per monitoraggio
+export function getAgentStats() {
+  return {
+    http: {
+      totalSocketCount: httpAgent.totalSocketCount,
+      createSocketCount: httpAgent.createSocketCount,
+      timeoutSocketCount: httpAgent.timeoutSocketCount,
+      requestCount: httpAgent.requestCount,
+      freeSockets: Object.keys(httpAgent.freeSockets).length,
+      sockets: Object.keys(httpAgent.sockets).length
+    },
+    https: {
+      totalSocketCount: httpsAgent.totalSocketCount,
+      createSocketCount: httpsAgent.createSocketCount,
+      timeoutSocketCount: httpsAgent.timeoutSocketCount,
+      requestCount: httpsAgent.requestCount,
+      freeSockets: Object.keys(httpsAgent.freeSockets).length,
+      sockets: Object.keys(httpsAgent.sockets).length
+    }
+  };
+}
+
+// Cleanup function per chiudere tutti gli agent
+export function closeAgents() {
+  return new Promise((resolve) => {
+    let pending = 2;
+
+    const done = () => {
+      if (--pending === 0) {
+        logger.info('All HTTP agents closed');
+        resolve();
+      }
+    };
+
+    httpAgent.destroy(() => {
+      logger.debug('HTTP agent destroyed');
+      done();
+    });
+
+    httpsAgent.destroy(() => {
+      logger.debug('HTTPS agent destroyed');
+      done();
+    });
+  });
+}

package/src/key-manager.js

@@ -0,0 +1,69 @@
+import logger from './logger.js';
+
+export class KeyManager {
+  constructor(keys) {
+    this.keys = keys.map(key => ({
+      key,
+      healthy: true,
+      lastUsed: null,
+      failureCount: 0,
+      lastFailure: null
+    }));
+    this.index = 0;
+    this.maxFailures = 3;
+    this.failureWindowMs = 5 * 60 * 1000; // 5 minuti
+  }
+
+  async getHealthyKey() {
+    const startIndex = this.index;
+    const now = Date.now();
+
+    do {
+      const keyInfo = this.keys[this.index];
+
+      // Resetta lo stato se è passato abbastanza tempo dall'ultimo fallimento
+      if (keyInfo.lastFailure && (now - keyInfo.lastFailure) > this.failureWindowMs) {
+        keyInfo.failureCount = 0;
+        keyInfo.healthy = true;
+      }
+
+      if (keyInfo.healthy && keyInfo.failureCount < this.maxFailures) {
+        this.index = (this.index + 1) % this.keys.length;
+        keyInfo.lastUsed = now;
+        logger.debug(`Using API key at index ${this.index}, failures: ${keyInfo.failureCount}`);
+        return keyInfo.key;
+      }
+
+      this.index = (this.index + 1) % this.keys.length;
+    } while (this.index !== startIndex);
+
+    logger.error('No healthy API keys available');
+    throw new Error('No healthy API keys available');
+  }
+
+  markKeyFailed(key, error) {
+    const keyInfo = this.keys.find(k => k.key === key);
+    if (keyInfo) {
+      keyInfo.failureCount++;
+      keyInfo.lastFailure = Date.now();
+      if (keyInfo.failureCount >= this.maxFailures) {
+        keyInfo.healthy = false;
+        logger.warn(`API key marked as unhealthy after ${this.maxFailures} failures`);
+      }
+      logger.error(`API key failed (count: ${keyInfo.failureCount}): ${error.message}`);
+    }
+  }
+
+  getStats() {
+    return {
+      total: this.keys.length,
+      healthy: this.keys.filter(k => k.healthy).length,
+      unhealthy: this.keys.filter(k => !k.healthy).length,
+      keys: this.keys.map(k => ({
+        healthy: k.healthy,
+        failureCount: k.failureCount,
+        lastUsed: k.lastUsed
+      }))
+    };
+  }
+}

package/src/logger.js

@@ -0,0 +1,46 @@
+import winston from 'winston';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const logFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ level, message, timestamp, stack }) => {
+    return `${timestamp} [${level.toUpperCase()}]: ${stack || message}`;
+  })
+);
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: logFormat,
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        logFormat
+      )
+    }),
+    new winston.transports.File({
+      filename: path.join(__dirname, '..', '.runtime', 'error.log'),
+      level: 'error',
+      maxsize: 5242880, // 5MB
+      maxFiles: 5
+    }),
+    new winston.transports.File({
+      filename: path.join(__dirname, '..', '.runtime', 'combined.log'),
+      maxsize: 5242880, // 5MB
+      maxFiles: 5
+    })
+  ],
+  exceptionHandlers: [
+    new winston.transports.File({ filename: path.join(__dirname, '..', '.runtime', 'exceptions.log') })
+  ],
+  rejectionHandlers: [
+    new winston.transports.File({ filename: path.join(__dirname, '..', '.runtime', 'rejections.log') })
+  ]
+});
+
+export default logger;