smartcontext-proxy 0.1.0 → 0.2.0

package/dist/src/index.js

@@ -6,26 +6,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const auto_detect_js_1 = require("./config/auto-detect.js");
 const server_js_1 = require("./proxy/server.js");
+const connect_proxy_js_1 = require("./proxy/connect-proxy.js");
 const ollama_js_1 = require("./embedding/ollama.js");
 const lancedb_js_1 = require("./storage/lancedb.js");
+const optimizer_js_1 = require("./context/optimizer.js");
+const anthropic_js_1 = require("./providers/anthropic.js");
+const openai_js_1 = require("./providers/openai.js");
+const ollama_js_2 = require("./providers/ollama.js");
+const google_js_1 = require("./providers/google.js");
+const ca_manager_js_1 = require("./tls/ca-manager.js");
 const process_js_1 = require("./daemon/process.js");
-const service_js_1 = require("./daemon/service.js");
+const installer_js_1 = require("./system/installer.js");
 const node_http_1 = __importDefault(require("node:http"));
-const VERSION = '0.1.0';
+const VERSION = '0.2.0';
 function parseArgs(args) {
     const result = {};
     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')
@@ -33,63 +42,60 @@ function parseArgs(args) {
         else if (arg === '--data-dir')
             result.dataDir = args[++i];
         else if (!arg.startsWith('-'))
-            result.command = arg;
+            result.command = result.command ? result.command : arg;
     }
     return result;
 }
 function printHelp() {
     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
+  --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
 
-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
+After install, all LLM API traffic is automatically intercepted.
+Dashboard: http://localhost:4800
 `);
 }
 async function showStatus(port) {
+    const inst = (0, installer_js_1.status)(port);
+    console.log('Installation:');
+    for (const [key, val] of Object.entries(inst)) {
+        console.log(`  ${key}: ${val}`);
+    }
     return new Promise((resolve) => {
         node_http_1.default.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}`);
+                    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('Could not parse status response');
+                    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();
         });
     });
@@ -105,6 +111,7 @@ async function main() {
         return;
     }
     const port = args.port ? parseInt(args.port, 10) : 4800;
+    // Commands
     if (args.command === 'status') {
         await showStatus(port);
         return;
@@ -113,69 +120,83 @@ async function main() {
         (0, process_js_1.stopDaemon)();
         return;
     }
-    if (args.command === 'start') {
-        (0, process_js_1.startDaemon)(process.argv.slice(3));
-        return;
-    }
-    if (args.command === 'restart') {
-        (0, process_js_1.stopDaemon)();
-        await new Promise(r => setTimeout(r, 1000));
-        (0, process_js_1.startDaemon)(process.argv.slice(3));
-        return;
-    }
-    if (args.command === 'install-service') {
-        const path = (0, service_js_1.installService)(port);
-        console.log(`Service installed: ${path}`);
+    if (args.command === 'install') {
+        console.log('Installing SmartContext Proxy...\n');
+        (0, ca_manager_js_1.ensureCA)();
+        const result = (0, installer_js_1.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((0, service_js_1.uninstallService)());
+    if (args.command === 'uninstall') {
+        console.log('Uninstalling SmartContext Proxy...\n');
+        const result = (0, installer_js_1.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 = (0, auto_detect_js_1.buildConfig)({
-        proxy: { port, host: '127.0.0.1' },
-    });
-    // Initialize embedding and storage (unless --no-optimize)
+    // Build config
+    const config = (0, auto_detect_js_1.buildConfig)({ proxy: { port, host: '127.0.0.1' } });
+    // Initialize embedding and storage
     let embedding;
     let storage;
+    let optimizer;
     if (!args.noOptimize) {
         try {
-            const embeddingUrl = args.embeddingUrl || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
-            const embeddingModel = args.embeddingModel || 'nomic-embed-text';
-            const dataDir = args.dataDir;
-            embedding = new ollama_js_1.OllamaEmbeddingAdapter(embeddingUrl, embeddingModel);
+            const embUrl = args.embeddingUrl || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+            const embModel = args.embeddingModel || 'nomic-embed-text';
+            embedding = new ollama_js_1.OllamaEmbeddingAdapter(embUrl, embModel);
             await embedding.initialize();
-            storage = new lancedb_js_1.LanceDBAdapter(dataDir);
+            storage = new lancedb_js_1.LanceDBAdapter(args.dataDir);
             await storage.initialize();
-            console.log(`  Embedding: ${embeddingModel} @ ${embeddingUrl}`);
-            console.log(`  Storage: LanceDB`);
+            optimizer = new optimizer_js_1.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 server_js_1.ProxyServer(config, embedding, storage);
-    const providers = server.getProviderNames();
-    const mode = embedding && storage ? 'optimizing' : 'transparent';
-    await server.start();
+    // Build provider adapters map
+    const adapters = new Map();
+    adapters.set('anthropic', new anthropic_js_1.AnthropicAdapter());
+    adapters.set('openai', new openai_js_1.OpenAIAdapter());
+    adapters.set('ollama', new ollama_js_2.OllamaAdapter());
+    adapters.set('google', new google_js_1.GoogleAdapter());
+    adapters.set('openrouter', new openai_js_1.OpenAIAdapter('https://openrouter.ai/api'));
+    adapters.set('groq', new openai_js_1.OpenAIAdapter('https://api.groq.com'));
+    adapters.set('together', new openai_js_1.OpenAIAdapter('https://api.together.xyz'));
+    adapters.set('deepseek', new openai_js_1.OpenAIAdapter('https://api.deepseek.com'));
+    const mode = optimizer ? 'optimizing' : 'transparent';
+    if (args.legacy) {
+        // Legacy mode: explicit /v1/{provider}/* routing
+        const server = new server_js_1.ProxyServer(config, embedding, storage);
+        await server.start();
+        console.log(`  Mode: legacy (explicit routing)`);
+    }
+    else {
+        // Default: CONNECT proxy with transparent interception
+        (0, ca_manager_js_1.ensureCA)();
+        const proxy = new connect_proxy_js_1.ConnectProxy(config, optimizer, adapters);
+        await proxy.start();
+    }
+    (0, process_js_1.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
-    (0, process_js_1.writePid)();
     const shutdown = async () => {
         console.log('\nShutting down...');
         (0, process_js_1.removePid)();
-        await server.stop();
         if (storage)
             await storage.close();
         process.exit(0);

package/dist/src/proxy/classifier.d.ts

@@ -0,0 +1,14 @@
+/** Known LLM provider hostnames and their API patterns */
+export interface ProviderMatch {
+    provider: string;
+    hostname: string;
+    isLLM: true;
+}
+export declare function addCustomHost(hostname: string, provider: string): void;
+export declare function removeCustomHost(hostname: string): void;
+/** Check if a hostname:port is an LLM provider that should be intercepted */
+export declare function classifyHost(hostname: string, port: number): ProviderMatch | null;
+/** Get all known LLM hostnames (for PAC file generation) */
+export declare function getLLMHostnames(): string[];
+/** Check if a request path looks like an LLM API call */
+export declare function isLLMPath(path: string): boolean;

package/dist/src/proxy/classifier.js

@@ -0,0 +1,63 @@
+"use strict";
+/** Known LLM provider hostnames and their API patterns */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCustomHost = addCustomHost;
+exports.removeCustomHost = removeCustomHost;
+exports.classifyHost = classifyHost;
+exports.getLLMHostnames = getLLMHostnames;
+exports.isLLMPath = isLLMPath;
+const LLM_HOSTS = {
+    'api.anthropic.com': 'anthropic',
+    'api.openai.com': 'openai',
+    'generativelanguage.googleapis.com': 'google',
+    'openrouter.ai': 'openrouter',
+    'api.together.xyz': 'together',
+    'api.fireworks.ai': 'fireworks',
+    'api.mistral.ai': 'mistral',
+    'api.cohere.com': 'cohere',
+    'api.groq.com': 'groq',
+    'api.deepseek.com': 'deepseek',
+};
+/** Ollama ports to intercept (HTTP, no TLS) */
+const OLLAMA_PORTS = new Set([11434]);
+/** Custom hosts added via config */
+let customHosts = {};
+function addCustomHost(hostname, provider) {
+    customHosts[hostname] = provider;
+}
+function removeCustomHost(hostname) {
+    delete customHosts[hostname];
+}
+/** Check if a hostname:port is an LLM provider that should be intercepted */
+function classifyHost(hostname, port) {
+    // Check known LLM hosts
+    const provider = LLM_HOSTS[hostname] || customHosts[hostname];
+    if (provider) {
+        return { provider, hostname, isLLM: true };
+    }
+    // Check Ollama local
+    if ((hostname === 'localhost' || hostname === '127.0.0.1') && OLLAMA_PORTS.has(port)) {
+        return { provider: 'ollama', hostname, isLLM: true };
+    }
+    return null;
+}
+/** Get all known LLM hostnames (for PAC file generation) */
+function getLLMHostnames() {
+    return [
+        ...Object.keys(LLM_HOSTS),
+        ...Object.keys(customHosts),
+    ];
+}
+/** Check if a request path looks like an LLM API call */
+function isLLMPath(path) {
+    const llmPaths = [
+        '/v1/messages', // Anthropic
+        '/v1/chat/completions', // OpenAI
+        '/v1/completions', // OpenAI legacy
+        '/api/chat', // Ollama
+        '/api/generate', // Ollama
+        '/v1beta/models', // Google
+    ];
+    return llmPaths.some((p) => path.startsWith(p));
+}
+//# sourceMappingURL=classifier.js.map

package/dist/src/proxy/connect-proxy.d.ts

@@ -0,0 +1,34 @@
+import type { SmartContextConfig } from '../config/schema.js';
+import type { ProviderAdapter } from '../providers/types.js';
+import { ContextOptimizer } from '../context/optimizer.js';
+import { MetricsCollector } from '../metrics/collector.js';
+/**
+ * HTTP CONNECT proxy that transparently intercepts LLM traffic.
+ *
+ * - Non-LLM HTTPS: blind TCP tunnel (zero overhead)
+ * - LLM HTTPS: TLS intercept → optimize → forward
+ * - HTTP requests: direct handling (dashboard, API, Ollama)
+ */
+export declare class ConnectProxy {
+    private server;
+    private metrics;
+    private optimizer;
+    private adapters;
+    private paused;
+    private requestCounter;
+    private config;
+    constructor(config: SmartContextConfig, optimizer?: ContextOptimizer | null, adapters?: Map<string, ProviderAdapter>);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getMetrics(): MetricsCollector;
+    isPaused(): boolean;
+    setPaused(v: boolean): void;
+    /** Handle HTTP CONNECT requests (HTTPS tunnel establishment) */
+    private handleConnect;
+    /** Handle plain HTTP requests (dashboard, API, Ollama interception) */
+    private handleHTTP;
+    private handleAPI;
+    private generatePAC;
+    private interceptorOptions;
+    private log;
+}

package/dist/src/proxy/connect-proxy.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectProxy = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const classifier_js_1 = require("./classifier.js");
+const tunnel_js_1 = require("./tunnel.js");
+const tls_interceptor_js_1 = require("./tls-interceptor.js");
+const collector_js_1 = require("../metrics/collector.js");
+const dashboard_js_1 = require("../ui/dashboard.js");
+/**
+ * HTTP CONNECT proxy that transparently intercepts LLM traffic.
+ *
+ * - Non-LLM HTTPS: blind TCP tunnel (zero overhead)
+ * - LLM HTTPS: TLS intercept → optimize → forward
+ * - HTTP requests: direct handling (dashboard, API, Ollama)
+ */
+class ConnectProxy {
+    server;
+    metrics = new collector_js_1.MetricsCollector();
+    optimizer = null;
+    adapters = new Map();
+    paused = false;
+    requestCounter = { value: 0 };
+    config;
+    constructor(config, optimizer, adapters) {
+        this.config = config;
+        this.optimizer = optimizer || null;
+        if (adapters)
+            this.adapters = adapters;
+        this.server = node_http_1.default.createServer((req, res) => this.handleHTTP(req, res));
+        this.server.on('connect', (req, clientSocket, head) => this.handleConnect(req, clientSocket, head));
+    }
+    async start() {
+        const { port, host } = this.config.proxy;
+        return new Promise((resolve) => {
+            this.server.listen(port, host, () => resolve());
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.server.close(() => resolve());
+        });
+    }
+    getMetrics() { return this.metrics; }
+    isPaused() { return this.paused; }
+    setPaused(v) { this.paused = v; }
+    /** Handle HTTP CONNECT requests (HTTPS tunnel establishment) */
+    handleConnect(req, clientSocket, head) {
+        const [hostname, portStr] = (req.url || '').split(':');
+        const port = parseInt(portStr || '443', 10);
+        const match = (0, classifier_js_1.classifyHost)(hostname, port);
+        if (match) {
+            // LLM provider → intercept TLS
+            this.log('info', `INTERCEPT ${hostname}:${port} (${match.provider})`);
+            (0, tls_interceptor_js_1.interceptTLS)(clientSocket, hostname, port, match, this.interceptorOptions());
+        }
+        else {
+            // Non-LLM → blind tunnel
+            (0, tunnel_js_1.createTunnel)(clientSocket, hostname, port);
+        }
+    }
+    /** Handle plain HTTP requests (dashboard, API, Ollama interception) */
+    async handleHTTP(req, res) {
+        const path = req.url || '/';
+        const method = req.method || 'GET';
+        // Dashboard
+        if (path === '/' && method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, dashboard_js_1.renderDashboard)(this.metrics, this.paused));
+            return;
+        }
+        // Health
+        if (path === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                ok: true,
+                requests: this.requestCounter.value,
+                paused: this.paused,
+                mode: this.optimizer ? 'optimizing' : 'transparent',
+                type: 'connect-proxy',
+            }));
+            return;
+        }
+        // PAC file
+        if (path === '/proxy.pac') {
+            res.writeHead(200, { 'Content-Type': 'application/x-ns-proxy-autoconfig' });
+            res.end(this.generatePAC());
+            return;
+        }
+        // API endpoints
+        if (path.startsWith('/_sc/')) {
+            this.handleAPI(path, method, req, res);
+            return;
+        }
+        // Everything else: 404
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    }
+    handleAPI(path, method, req, res) {
+        res.setHeader('Content-Type', 'application/json');
+        switch (path) {
+            case '/_sc/status':
+                res.end(JSON.stringify({
+                    state: this.paused ? 'paused' : 'running',
+                    uptime: this.metrics.getUptime(),
+                    requests: this.requestCounter.value,
+                    mode: this.optimizer ? 'optimizing' : 'transparent',
+                }));
+                break;
+            case '/_sc/stats':
+                res.end(JSON.stringify(this.metrics.getStats()));
+                break;
+            case '/_sc/feed':
+                res.end(JSON.stringify(this.metrics.getRecent(50)));
+                break;
+            case '/_sc/pause':
+                this.paused = true;
+                res.end(JSON.stringify({ ok: true, state: 'paused' }));
+                break;
+            case '/_sc/resume':
+                this.paused = false;
+                res.end(JSON.stringify({ ok: true, state: 'running' }));
+                break;
+            default:
+                res.writeHead(404);
+                res.end(JSON.stringify({ error: `Unknown: ${path}` }));
+        }
+    }
+    generatePAC() {
+        const { getLLMHostnames } = require('./classifier.js');
+        const hosts = getLLMHostnames();
+        const { port, host } = this.config.proxy;
+        const conditions = hosts
+            .map((h) => `    if (dnsDomainIs(host, "${h}")) return proxy;`)
+            .join('\n');
+        return `function FindProxyForURL(url, host) {
+    var proxy = "PROXY ${host}:${port}";
+${conditions}
+    // Ollama local
+    if (host === "localhost" && url.indexOf(":11434") !== -1) return proxy;
+    return "DIRECT";
+}`;
+    }
+    interceptorOptions() {
+        return {
+            config: this.config,
+            optimizer: this.optimizer,
+            metrics: this.metrics,
+            adapters: this.adapters,
+            paused: this.paused,
+            requestCounter: this.requestCounter,
+            log: this.log.bind(this),
+        };
+    }
+    log(level, message) {
+        const timestamp = new Date().toISOString().slice(11, 23);
+        const prefix = level === 'error' ? '✗' : '→';
+        if (level === 'error' || this.config.logging.level !== 'error') {
+            console.log(`[${timestamp}] ${prefix} ${message}`);
+        }
+    }
+}
+exports.ConnectProxy = ConnectProxy;
+//# sourceMappingURL=connect-proxy.js.map

package/dist/src/proxy/tls-interceptor.d.ts

@@ -0,0 +1,23 @@
+import type { Socket } from 'node:net';
+import { type ProviderMatch } from './classifier.js';
+import type { ProviderAdapter } from '../providers/types.js';
+import type { SmartContextConfig } from '../config/schema.js';
+import { ContextOptimizer } from '../context/optimizer.js';
+import { MetricsCollector } from '../metrics/collector.js';
+export interface InterceptorOptions {
+    config: SmartContextConfig;
+    optimizer: ContextOptimizer | null;
+    metrics: MetricsCollector;
+    adapters: Map<string, ProviderAdapter>;
+    paused: boolean;
+    requestCounter: {
+        value: number;
+    };
+    log: (level: string, message: string) => void;
+}
+/**
+ * Intercept TLS connection to an LLM provider.
+ * Terminates TLS with a generated cert, parses the HTTP request inside,
+ * optionally optimizes context, then forwards to the real provider.
+ */
+export declare function interceptTLS(clientSocket: Socket, hostname: string, port: number, match: ProviderMatch, options: InterceptorOptions): void;