smartcontext-proxy 0.1.0 → 0.2.1

package/native/macos/SmartContextTray/Sources/main.swift

@@ -0,0 +1,206 @@
+import AppKit
+import Foundation
+
+// MARK: - Status Polling
+
+struct ProxyStatus: Codable {
+    let state: String
+    let uptime: Int
+    let requests: Int
+    let mode: String
+}
+
+struct ProxyStats: Codable {
+    let totalRequests: Int
+    let totalOriginalTokens: Int
+    let totalOptimizedTokens: Int
+    let totalSavingsPercent: Int
+    let avgLatencyOverheadMs: Int
+}
+
+class StatusPoller {
+    var status: ProxyStatus?
+    var stats: ProxyStats?
+    let port: Int
+
+    init(port: Int = 4800) {
+        self.port = port
+    }
+
+    func poll() {
+        fetchJSON("http://127.0.0.1:\(port)/_sc/status") { (result: ProxyStatus?) in
+            self.status = result
+        }
+        fetchJSON("http://127.0.0.1:\(port)/_sc/stats") { (result: ProxyStats?) in
+            self.stats = result
+        }
+    }
+
+    private func fetchJSON<T: Codable>(_ urlString: String, completion: @escaping (T?) -> Void) {
+        guard let url = URL(string: urlString) else { completion(nil); return }
+        let task = URLSession.shared.dataTask(with: url) { data, _, _ in
+            guard let data = data else { completion(nil); return }
+            completion(try? JSONDecoder().decode(T.self, from: data))
+        }
+        task.resume()
+    }
+
+    func apiCall(_ path: String) {
+        guard let url = URL(string: "http://127.0.0.1:\(port)\(path)") else { return }
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        URLSession.shared.dataTask(with: request).resume()
+    }
+}
+
+// MARK: - App Delegate
+
+class TrayAppDelegate: NSObject, NSApplicationDelegate {
+    var statusItem: NSStatusItem!
+    var poller = StatusPoller()
+    var pollTimer: Timer?
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+
+        updateIcon(state: "starting")
+        buildMenu()
+
+        // Poll every 3 seconds
+        poller.poll()
+        pollTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
+            self?.poller.poll()
+            DispatchQueue.main.async { self?.updateMenu() }
+        }
+    }
+
+    func updateIcon(state: String) {
+        guard let button = statusItem.button else { return }
+
+        switch state {
+        case "running":
+            button.title = "◉"
+            button.contentTintColor = .systemGreen
+        case "paused":
+            button.title = "◉"
+            button.contentTintColor = .systemYellow
+        default:
+            button.title = "◎"
+            button.contentTintColor = .systemGray
+        }
+    }
+
+    func buildMenu() {
+        let menu = NSMenu()
+
+        // Header
+        let headerItem = NSMenuItem(title: "SmartContext Proxy", action: nil, keyEquivalent: "")
+        headerItem.isEnabled = false
+        menu.addItem(headerItem)
+
+        menu.addItem(NSMenuItem.separator())
+
+        // Stats (placeholder, updated by polling)
+        let statsItem = NSMenuItem(title: "Loading...", action: nil, keyEquivalent: "")
+        statsItem.tag = 100
+        statsItem.isEnabled = false
+        menu.addItem(statsItem)
+
+        let savingsItem = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+        savingsItem.tag = 101
+        savingsItem.isEnabled = false
+        menu.addItem(savingsItem)
+
+        menu.addItem(NSMenuItem.separator())
+
+        // Dashboard
+        let dashboardItem = NSMenuItem(title: "Open Dashboard", action: #selector(openDashboard), keyEquivalent: "d")
+        dashboardItem.target = self
+        menu.addItem(dashboardItem)
+
+        menu.addItem(NSMenuItem.separator())
+
+        // Pause/Resume
+        let pauseItem = NSMenuItem(title: "Pause Optimization", action: #selector(togglePause), keyEquivalent: "p")
+        pauseItem.tag = 200
+        pauseItem.target = self
+        menu.addItem(pauseItem)
+
+        menu.addItem(NSMenuItem.separator())
+
+        // Quit
+        let quitItem = NSMenuItem(title: "Quit SmartContext", action: #selector(quit), keyEquivalent: "q")
+        quitItem.target = self
+        menu.addItem(quitItem)
+
+        statusItem.menu = menu
+    }
+
+    func updateMenu() {
+        guard let menu = statusItem.menu else { return }
+
+        let state = poller.status?.state ?? "offline"
+        updateIcon(state: state)
+
+        // Update stats
+        if let stats = poller.stats {
+            let savings = estimateCost(stats.totalOriginalTokens - stats.totalOptimizedTokens)
+            if let item = menu.item(withTag: 100) {
+                item.title = "Requests: \(stats.totalRequests) | Savings: \(stats.totalSavingsPercent)%"
+            }
+            if let item = menu.item(withTag: 101) {
+                item.title = "Estimated saved: $\(savings)"
+            }
+        } else {
+            if let item = menu.item(withTag: 100) {
+                item.title = "Proxy offline"
+            }
+        }
+
+        // Update pause/resume text
+        if let item = menu.item(withTag: 200) {
+            if state == "paused" {
+                item.title = "Resume Optimization"
+            } else {
+                item.title = "Pause Optimization"
+            }
+        }
+    }
+
+    func estimateCost(_ tokensSaved: Int) -> String {
+        let cost = Double(tokensSaved) / 1_000_000.0 * 15.0
+        return String(format: "%.2f", cost)
+    }
+
+    @objc func openDashboard() {
+        if let url = URL(string: "http://localhost:\(poller.port)/") {
+            NSWorkspace.shared.open(url)
+        }
+    }
+
+    @objc func togglePause() {
+        let state = poller.status?.state ?? "running"
+        if state == "paused" {
+            poller.apiCall("/_sc/resume")
+        } else {
+            poller.apiCall("/_sc/pause")
+        }
+        // Update after short delay
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+            self?.poller.poll()
+            self?.updateMenu()
+        }
+    }
+
+    @objc func quit() {
+        NSApplication.shared.terminate(self)
+    }
+}
+
+// MARK: - Entry Point
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory) // No dock icon
+let delegate = TrayAppDelegate()
+app.delegate = delegate
+app.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartcontext-proxy",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Intelligent context window optimization proxy for LLM APIs",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -30,9 +30,13 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@types/node-forge": "^1.3.14",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.7.0"
   },
   "dependencies": {
-    "@lancedb/lancedb": "^0.27.1"
+    "@lancedb/lancedb": "^0.27.1",
+    "node-forge": "^1.4.0",
+    "ws": "^8.20.0"
   }
 }

package/src/context/ab-test.ts

@@ -0,0 +1,172 @@
+import type { CanonicalRequest } from './canonical.js';
+import type { ProviderAdapter } from '../providers/types.js';
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+
+export interface ABComparison {
+  requestId: number;
+  timestamp: number;
+  provider: string;
+  model: string;
+  optimizedTokens: number;
+  originalTokens: number;
+  savingsPercent: number;
+  semanticSimilarity: number;
+  qualityMatch: boolean; // >0.95 similarity
+  responseA: string;     // optimized (returned to client)
+  responseB: string;     // original (stored, not returned)
+  latencyA: number;
+  latencyB: number;
+}
+
+let abResults: ABComparison[] = [];
+let abEnabled = false;
+let abSampleRate = 100; // percent
+
+export function enableABTest(sampleRate: number = 100): void {
+  abEnabled = true;
+  abSampleRate = Math.min(100, Math.max(1, sampleRate));
+}
+
+export function disableABTest(): void {
+  abEnabled = false;
+}
+
+export function isABEnabled(): boolean {
+  return abEnabled;
+}
+
+export function shouldABTest(): boolean {
+  if (!abEnabled) return false;
+  return Math.random() * 100 < abSampleRate;
+}
+
+export function getABResults(limit: number = 50): ABComparison[] {
+  return abResults.slice(-limit);
+}
+
+export function getABSummary(): {
+  total: number;
+  qualityMatch: number;
+  minorDiff: number;
+  significantDiff: number;
+  avgSavings: number;
+} {
+  const total = abResults.length;
+  if (total === 0) return { total: 0, qualityMatch: 0, minorDiff: 0, significantDiff: 0, avgSavings: 0 };
+
+  let qualityMatch = 0;
+  let minorDiff = 0;
+  let significantDiff = 0;
+  let totalSavings = 0;
+
+  for (const r of abResults) {
+    if (r.semanticSimilarity >= 0.95) qualityMatch++;
+    else if (r.semanticSimilarity >= 0.85) minorDiff++;
+    else significantDiff++;
+    totalSavings += r.savingsPercent;
+  }
+
+  return {
+    total,
+    qualityMatch,
+    minorDiff,
+    significantDiff,
+    avgSavings: Math.round(totalSavings / total),
+  };
+}
+
+/**
+ * Send the original (unoptimized) request to the provider for comparison.
+ * This is Path B — the result is stored but NOT returned to the client.
+ */
+export async function sendOriginalForComparison(
+  originalBody: Buffer,
+  hostname: string,
+  port: number,
+  path: string,
+  headers: Record<string, string>,
+  requestId: number,
+  provider: string,
+  model: string,
+  optimizedResponse: string,
+  optimizedTokens: number,
+  originalTokens: number,
+  savingsPercent: number,
+): Promise<void> {
+  const startTime = Date.now();
+
+  try {
+    const useHTTPS = port === 443 || hostname.includes('.');
+    const transport = useHTTPS ? https : http;
+    const url = `${useHTTPS ? 'https' : 'http'}://${hostname}:${port}${path}`;
+
+    const forwardHeaders = { ...headers };
+    forwardHeaders['content-length'] = String(originalBody.length);
+
+    const responseB = await new Promise<string>((resolve, reject) => {
+      const req = transport.request(url, { method: 'POST', headers: forwardHeaders }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => resolve(data));
+      });
+      req.on('error', reject);
+      req.write(originalBody);
+      req.end();
+    });
+
+    const latencyB = Date.now() - startTime;
+
+    // Simple text similarity (cosine of character trigrams)
+    const similarity = textSimilarity(optimizedResponse, responseB);
+
+    abResults.push({
+      requestId,
+      timestamp: Date.now(),
+      provider,
+      model,
+      optimizedTokens,
+      originalTokens,
+      savingsPercent,
+      semanticSimilarity: similarity,
+      qualityMatch: similarity >= 0.95,
+      responseA: optimizedResponse.slice(0, 500),
+      responseB: responseB.slice(0, 500),
+      latencyA: 0, // filled externally
+      latencyB,
+    });
+
+    // Keep max 1000 results
+    if (abResults.length > 1000) {
+      abResults = abResults.slice(-500);
+    }
+  } catch {
+    // A/B test failure is non-critical
+  }
+}
+
+/** Simple text similarity using character trigrams */
+function textSimilarity(a: string, b: string): number {
+  if (a === b) return 1.0;
+  if (!a || !b) return 0;
+
+  const trigramsA = getTrigrams(a.toLowerCase());
+  const trigramsB = getTrigrams(b.toLowerCase());
+
+  let intersection = 0;
+  for (const t of trigramsA) {
+    if (trigramsB.has(t)) intersection++;
+  }
+
+  const union = trigramsA.size + trigramsB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function getTrigrams(s: string): Set<string> {
+  const set = new Set<string>();
+  for (let i = 0; i < s.length - 2; i++) {
+    set.add(s.substring(i, i + 3));
+  }
+  return set;
+}

package/src/index.ts

@@ -2,29 +2,38 @@
 
 import { buildConfig } from './config/auto-detect.js';
 import { ProxyServer } from './proxy/server.js';
+import { ConnectProxy } from './proxy/connect-proxy.js';
 import { OllamaEmbeddingAdapter } from './embedding/ollama.js';
 import { LanceDBAdapter } from './storage/lancedb.js';
+import { ContextOptimizer } from './context/optimizer.js';
 import type { EmbeddingAdapter } from './embedding/types.js';
 import type { StorageAdapter } from './storage/types.js';
-import { writePid, removePid, getPid, stopDaemon, startDaemon, isDaemonChild } from './daemon/process.js';
-import { installService, uninstallService } from './daemon/service.js';
+import type { ProviderAdapter } from './providers/types.js';
+import { AnthropicAdapter } from './providers/anthropic.js';
+import { OpenAIAdapter } from './providers/openai.js';
+import { OllamaAdapter } from './providers/ollama.js';
+import { GoogleAdapter } from './providers/google.js';
+import { ensureCA } from './tls/ca-manager.js';
+import { writePid, removePid, getPid, stopDaemon } from './daemon/process.js';
+import { install, uninstall, status as installStatus } from './system/installer.js';
 import http from 'node:http';
 
-const VERSION = '0.1.0';
+const VERSION = '0.2.0';
 
 function parseArgs(args: string[]): Record<string, string | boolean> {
   const result: Record<string, string | boolean> = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === '--port' || arg === '-p') result.port = args[++i];
-    else if (arg === '--config' || arg === '-c') result.config = args[++i];
     else if (arg === '--help' || arg === '-h') result.help = true;
     else if (arg === '--version' || arg === '-v') result.version = true;
     else if (arg === '--no-optimize') result.noOptimize = true;
+    else if (arg === '--legacy') result.legacy = true;
+    else if (arg === '--purge') result.purge = true;
     else if (arg === '--embedding-url') result.embeddingUrl = args[++i];
     else if (arg === '--embedding-model') result.embeddingModel = args[++i];
     else if (arg === '--data-dir') result.dataDir = args[++i];
-    else if (!arg.startsWith('-')) result.command = arg;
+    else if (!arg.startsWith('-')) result.command = result.command ? result.command : arg;
   }
   return result;
 }
@@ -32,56 +41,52 @@ function parseArgs(args: string[]): Record<string, string | boolean> {
 function printHelp(): void {
   console.log(`
 SmartContext Proxy v${VERSION}
-Intelligent context window optimization for LLM APIs
+Transparent LLM context optimization proxy
 
-Usage:
-  smartcontext-proxy [options]
-  smartcontext-proxy status          Show proxy status
+Commands:
+  (default)           Start proxy in foreground
+  install             Install: CA cert + system proxy + auto-start service
+  uninstall           Remove all: CA, proxy config, service (--purge for data)
+  status              Show installation and proxy status
+  start               Start as background daemon
+  stop                Stop daemon
+  restart             Restart daemon
 
 Options:
-  --port, -p <port>           Proxy port (default: 4800)
-  --config, -c <file>         Config file path
-  --no-optimize               Run in transparent proxy mode (no context optimization)
-  --embedding-url <url>       Ollama URL for embeddings (default: http://localhost:11434)
-  --embedding-model <model>   Embedding model (default: nomic-embed-text)
-  --data-dir <path>           Data directory (default: ~/.smartcontext/data)
-  --help, -h                  Show help
-  --version, -v               Show version
-
-Client Integration:
-  ANTHROPIC_API_URL=http://localhost:4800/v1/anthropic
-  OPENAI_BASE_URL=http://localhost:4800/v1/openai
-  OLLAMA_HOST=http://localhost:4800/v1/ollama
-
-API:
-  GET  /health          Health check
-  GET  /_sc/status      Proxy status
-  GET  /_sc/stats       Aggregate metrics
-  GET  /_sc/feed        Recent requests
-  POST /_sc/pause       Pause optimization
-  POST /_sc/resume      Resume optimization
+  --port, -p <port>   Proxy port (default: 4800)
+  --no-optimize       Disable context optimization (transparent proxy only)
+  --legacy            Use legacy explicit-route proxy instead of CONNECT proxy
+  --purge             With uninstall: also delete all data
+  --help, -h          Show help
+  --version, -v       Show version
+
+After install, all LLM API traffic is automatically intercepted.
+Dashboard: http://localhost:4800
 `);
 }
 
 async function showStatus(port: number): Promise<void> {
+  const inst = installStatus(port);
+  console.log('Installation:');
+  for (const [key, val] of Object.entries(inst)) {
+    console.log(`  ${key}: ${val}`);
+  }
+
   return new Promise((resolve) => {
     http.get(`http://127.0.0.1:${port}/_sc/status`, (res) => {
       let data = '';
       res.on('data', (chunk) => (data += chunk));
       res.on('end', () => {
         try {
-          const status = JSON.parse(data);
-          console.log(`SmartContext Proxy: ${status.state}`);
-          console.log(`  Uptime: ${Math.round(status.uptime / 1000)}s`);
-          console.log(`  Requests: ${status.requests}`);
-          console.log(`  Mode: ${status.mode}`);
-        } catch {
-          console.log('Could not parse status response');
-        }
+          const s = JSON.parse(data);
+          console.log(`\nProxy: ${s.state} (${s.mode})`);
+          console.log(`  Uptime: ${Math.round(s.uptime / 1000)}s`);
+          console.log(`  Requests: ${s.requests}`);
+        } catch { console.log('\nProxy: response parse error'); }
         resolve();
       });
     }).on('error', () => {
-      console.log(`SmartContext Proxy: not running on port ${port}`);
+      console.log(`\nProxy: not running on port ${port}`);
       resolve();
     });
   });
@@ -95,73 +100,98 @@ async function main(): Promise<void> {
 
   const port = args.port ? parseInt(args.port as string, 10) : 4800;
 
+  // Commands
   if (args.command === 'status') { await showStatus(port); return; }
   if (args.command === 'stop') { stopDaemon(); return; }
-  if (args.command === 'start') { startDaemon(process.argv.slice(3)); return; }
-  if (args.command === 'restart') { stopDaemon(); await new Promise(r => setTimeout(r, 1000)); startDaemon(process.argv.slice(3)); return; }
-  if (args.command === 'install-service') {
-    const path = installService(port);
-    console.log(`Service installed: ${path}`);
+
+  if (args.command === 'install') {
+    console.log('Installing SmartContext Proxy...\n');
+    ensureCA();
+    const result = install(port);
+    for (const step of result.steps) {
+      console.log(`  ${step.success ? '✓' : '✗'} ${step.step}: ${step.message}`);
+    }
+    console.log(result.success ? '\nInstalled successfully.' : '\nInstallation failed (rolled back).');
     return;
   }
-  if (args.command === 'uninstall-service') {
-    console.log(uninstallService());
+
+  if (args.command === 'uninstall') {
+    console.log('Uninstalling SmartContext Proxy...\n');
+    const result = uninstall(!!args.purge);
+    for (const step of result.steps) {
+      console.log(`  ${step.success ? '✓' : '✗'} ${step.step}: ${step.message}`);
+    }
+    console.log(result.success ? '\nUninstalled.' : '\nSome steps failed.');
     return;
   }
 
-  const config = buildConfig({
-    proxy: { port, host: '127.0.0.1' },
-  });
+  // Build config
+  const config = buildConfig({ proxy: { port, host: '127.0.0.1' } });
 
-  // Initialize embedding and storage (unless --no-optimize)
+  // Initialize embedding and storage
   let embedding: EmbeddingAdapter | undefined;
   let storage: StorageAdapter | undefined;
+  let optimizer: ContextOptimizer | undefined;
 
   if (!args.noOptimize) {
     try {
-      const embeddingUrl = (args.embeddingUrl as string) || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
-      const embeddingModel = (args.embeddingModel as string) || 'nomic-embed-text';
-      const dataDir = args.dataDir as string | undefined;
+      const embUrl = (args.embeddingUrl as string) || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+      const embModel = (args.embeddingModel as string) || 'nomic-embed-text';
 
-      embedding = new OllamaEmbeddingAdapter(embeddingUrl, embeddingModel);
+      embedding = new OllamaEmbeddingAdapter(embUrl, embModel);
       await embedding.initialize();
 
-      storage = new LanceDBAdapter(dataDir);
+      storage = new LanceDBAdapter(args.dataDir as string | undefined);
       await storage.initialize();
 
-      console.log(`  Embedding: ${embeddingModel} @ ${embeddingUrl}`);
-      console.log(`  Storage: LanceDB`);
+      optimizer = new ContextOptimizer(embedding, storage, config.context);
     } catch (err) {
       console.log(`  Optimization unavailable: ${err}`);
       console.log(`  Running in transparent proxy mode`);
-      embedding = undefined;
-      storage = undefined;
     }
   }
 
-  const server = new ProxyServer(config, embedding, storage);
-  const providers = server.getProviderNames();
-  const mode = embedding && storage ? 'optimizing' : 'transparent';
+  // Build provider adapters map
+  const adapters = new Map<string, ProviderAdapter>();
+  adapters.set('anthropic', new AnthropicAdapter());
+  adapters.set('openai', new OpenAIAdapter());
+  adapters.set('ollama', new OllamaAdapter());
+  adapters.set('google', new GoogleAdapter());
+  adapters.set('openrouter', new OpenAIAdapter('https://openrouter.ai/api'));
+  adapters.set('groq', new OpenAIAdapter('https://api.groq.com'));
+  adapters.set('together', new OpenAIAdapter('https://api.together.xyz'));
+  adapters.set('deepseek', new OpenAIAdapter('https://api.deepseek.com'));
+
+  const mode = optimizer ? 'optimizing' : 'transparent';
+
+  if (args.legacy) {
+    // Legacy mode: explicit /v1/{provider}/* routing
+    const server = new ProxyServer(config, embedding, storage);
+    await server.start();
+    console.log(`  Mode: legacy (explicit routing)`);
+  } else {
+    // Default: CONNECT proxy with transparent interception
+    ensureCA();
+    const proxy = new ConnectProxy(config, optimizer, adapters);
+    await proxy.start();
+  }
 
-  await server.start();
+  writePid();
 
   console.log(`
-  ┌─────────────────────────────────────────────┐
-  │  SmartContext Proxy v${VERSION}                  │
-  │  http://${config.proxy.host}:${config.proxy.port}                    │
-  │                                             │
-  │  Providers: ${providers.join(', ').padEnd(31)}│
-  │  Mode: ${mode.padEnd(36)}│
-  └─────────────────────────────────────────────┘
+  ┌──────────────────────────────────────────────────┐
+  │  SmartContext Proxy v${VERSION}                       │
+  │  http://127.0.0.1:${port}                            │
+  │                                                  │
+  │  Mode: ${(args.legacy ? 'legacy (explicit)' : 'transparent (CONNECT)').padEnd(40)}│
+  │  Optimization: ${mode.padEnd(33)}│
+  │  Dashboard: http://localhost:${port}/               │
+  └──────────────────────────────────────────────────┘
 `);
 
-  // Write PID file
-  writePid();
-
   const shutdown = async () => {
     console.log('\nShutting down...');
     removePid();
-    await server.stop();
     if (storage) await storage.close();
     process.exit(0);
   };