@lmnr-ai/claude-code-proxy 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -10,15 +10,80 @@ export interface SpanContext {
     laminarUrl?: string;
 }
 /**
- * Set the current trace context by sending an HTTP request to the running proxy server.
+ * A Claude Code Proxy server instance that can be run on a specific port.
  *
- * @param context - The span context containing trace information
- * @throws Error if the HTTP request fails
+ * Each instance manages its own server state, health monitoring,
+ * and can be started/stopped independently.
+ *
+ * @example
+ * ```typescript
+ * // Create multiple proxy instances on different ports
+ * const proxy1 = new ProxyServer(45667);
+ * const proxy2 = new ProxyServer(45668);
+ *
+ * proxy1.runServer('https://api.anthropic.com');
+ * proxy2.runServer('https://api.anthropic.com');
+ *
+ * await proxy1.setCurrentTrace({ traceId: '...', spanId: '...', projectApiKey: '...' });
+ * await proxy2.setCurrentTrace({ traceId: '...', spanId: '...', projectApiKey: '...' });
+ *
+ * proxy1.stopServer();
+ * proxy2.stopServer();
+ * ```
  */
-export declare function setCurrentTrace(context: SpanContext): Promise<void>;
+export declare class ProxyServer {
+    private port;
+    private targetUrl;
+    private monitorInterval;
+    private isHealthCheckRunning;
+    private _isRunning;
+    /**
+     * Initialize a new proxy server instance.
+     *
+     * @param port - The port to listen on (default: 45667)
+     */
+    constructor(port?: number);
+    /**
+     * Set the current trace context by sending an HTTP request to this proxy server.
+     *
+     * @param context - The span context containing trace information
+     * @throws Error if the HTTP request fails
+     */
+    setCurrentTrace(context: SpanContext): Promise<void>;
+    /**
+     * Background function that monitors server health and restarts if needed.
+     * Polls every HEALTH_CHECK_INTERVAL ms.
+     * Uses a flag to prevent concurrent execution, avoiding race conditions.
+     */
+    private healthCheckMonitor;
+    /**
+     * Run the proxy server in a background thread with health monitoring.
+     *
+     * A background monitor will check the server health every HEALTH_CHECK_INTERVAL ms
+     * and automatically restart it if it dies.
+     *
+     * @param url - The target URL to proxy requests to
+     */
+    runServer(url: string): void;
+    /**
+     * Stop the proxy server and its health monitoring.
+     */
+    stopServer(): void;
+    /**
+     * Check if the server is currently running.
+     */
+    get isRunning(): boolean;
+    /**
+     * Get the port this server is running on.
+     */
+    getPort(): number;
+}
 /**
  * Run the proxy server in a background thread with health monitoring.
  *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
+ *
  * A background monitor will check the server health every HEALTH_CHECK_INTERVAL ms
  * and automatically restart it if it dies.
  *
@@ -28,6 +93,19 @@ export declare function setCurrentTrace(context: SpanContext): Promise<void>;
 export declare function runServer(url: string, port?: number): void;
 /**
  * Stop the proxy server and its health monitoring.
+ *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
  */
 export declare function stopServer(): void;
+/**
+ * Set the current trace context by sending an HTTP request to the running proxy server.
+ *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
+ *
+ * @param context - The span context containing trace information
+ * @throws Error if the HTTP request fails
+ */
+export declare function setCurrentTrace(context: SpanContext): Promise<void>;
 export declare const run: any, stop: any;

package/dist/index.js

@@ -3,10 +3,10 @@
  * Laminar Claude Code Proxy - TypeScript/JavaScript bindings for HTTP proxy server
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stop = exports.run = void 0;
-exports.setCurrentTrace = setCurrentTrace;
+exports.stop = exports.run = exports.ProxyServer = void 0;
 exports.runServer = runServer;
 exports.stopServer = stopServer;
+exports.setCurrentTrace = setCurrentTrace;
 // Platform-specific package loading
 // Uses explicit .node subpath exports for bundler compatibility=
 const { join } = require('path');
@@ -47,101 +47,208 @@ function loadNative() {
 }
 const native = loadNative();
 const HEALTH_CHECK_INTERVAL = 1000;
-// Module-level variables to track the server state
-let serverPort = 45667;
-let targetUrl = '';
-let monitorInterval = null;
-let isHealthCheckRunning = false;
 /**
- * Set the current trace context by sending an HTTP request to the running proxy server.
+ * A Claude Code Proxy server instance that can be run on a specific port.
  *
- * @param context - The span context containing trace information
- * @throws Error if the HTTP request fails
- */
-async function setCurrentTrace(context) {
-    const { traceId, spanId, projectApiKey, spanIdsPath = [], spanPath = [], laminarUrl = 'https://api.lmnr.ai', } = context;
-    // Prepare the JSON payload
-    const payload = {
-        trace_id: traceId,
-        span_id: spanId,
-        project_api_key: projectApiKey,
-        span_ids_path: spanIdsPath,
-        span_path: spanPath,
-        laminar_url: laminarUrl,
-    };
-    // Send POST request to the internal endpoint
-    const url = `http://127.0.0.1:${serverPort}/lmnr-internal/span-context`;
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(payload),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to set trace context: ${error}`);
-    }
-}
-/**
- * Background function that monitors server health and restarts if needed.
- * Polls every HEALTH_CHECK_INTERVAL ms.
- * Uses a flag to prevent concurrent execution, avoiding race conditions.
+ * Each instance manages its own server state, health monitoring,
+ * and can be started/stopped independently.
+ *
+ * @example
+ * ```typescript
+ * // Create multiple proxy instances on different ports
+ * const proxy1 = new ProxyServer(45667);
+ * const proxy2 = new ProxyServer(45668);
+ *
+ * proxy1.runServer('https://api.anthropic.com');
+ * proxy2.runServer('https://api.anthropic.com');
+ *
+ * await proxy1.setCurrentTrace({ traceId: '...', spanId: '...', projectApiKey: '...' });
+ * await proxy2.setCurrentTrace({ traceId: '...', spanId: '...', projectApiKey: '...' });
+ *
+ * proxy1.stopServer();
+ * proxy2.stopServer();
+ * ```
  */
-async function healthCheckMonitor() {
-    // Skip if a health check is already running to prevent concurrent restarts
-    if (isHealthCheckRunning) {
-        return;
+class ProxyServer {
+    /**
+     * Initialize a new proxy server instance.
+     *
+     * @param port - The port to listen on (default: 45667)
+     */
+    constructor(port = 45667) {
+        this.targetUrl = '';
+        this.monitorInterval = null;
+        this.isHealthCheckRunning = false;
+        this._isRunning = false;
+        this.port = port;
     }
-    isHealthCheckRunning = true;
-    try {
-        const url = `http://127.0.0.1:${serverPort}/lmnr-internal/health`;
+    /**
+     * Set the current trace context by sending an HTTP request to this proxy server.
+     *
+     * @param context - The span context containing trace information
+     * @throws Error if the HTTP request fails
+     */
+    async setCurrentTrace(context) {
+        const { traceId, spanId, projectApiKey, spanIdsPath = [], spanPath = [], laminarUrl = 'https://api.lmnr.ai', } = context;
+        // Prepare the JSON payload
+        const payload = {
+            trace_id: traceId,
+            span_id: spanId,
+            project_api_key: projectApiKey,
+            span_ids_path: spanIdsPath,
+            span_path: spanPath,
+            laminar_url: laminarUrl,
+        };
+        // Send POST request to the internal endpoint
+        const url = `http://127.0.0.1:${this.port}/lmnr-internal/span-context`;
         try {
             const response = await fetch(url, {
-                // Force new connection for each health check to avoid interfering with streaming
+                method: 'POST',
                 headers: {
-                    'Connection': 'close'
+                    'Content-Type': 'application/json',
                 },
+                body: JSON.stringify(payload),
             });
-            if (response.status === 200) {
-                // Server is healthy
-                return;
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
             }
         }
         catch (error) {
-            // Server is not responding, try to restart
-            console.warn(`Server health check failed: ${error}. Attempting to restart...`);
+            throw new Error(`Failed to set trace context: ${error}`);
+        }
+    }
+    /**
+     * Background function that monitors server health and restarts if needed.
+     * Polls every HEALTH_CHECK_INTERVAL ms.
+     * Uses a flag to prevent concurrent execution, avoiding race conditions.
+     */
+    async healthCheckMonitor() {
+        // Skip if a health check is already running to prevent concurrent restarts
+        if (this.isHealthCheckRunning) {
+            return;
+        }
+        this.isHealthCheckRunning = true;
+        try {
+            const url = `http://127.0.0.1:${this.port}/lmnr-internal/health`;
             try {
-                // Try to stop the existing server (it might be stuck)
+                const response = await fetch(url, {
+                    // Force new connection for each health check to avoid interfering with streaming
+                    headers: {
+                        'Connection': 'close'
+                    },
+                });
+                if (response.status === 200) {
+                    // Server is healthy
+                    return;
+                }
+            }
+            catch (error) {
+                // Server is not responding, try to restart
+                console.warn(`Server health check failed on port ${this.port}: ${error}. Attempting to restart...`);
                 try {
-                    native.stop();
+                    // Try to stop the existing server (it might be stuck)
+                    try {
+                        native.stop(this.port);
+                    }
+                    catch {
+                        // Server might already be dead
+                    }
+                    // Wait a bit before restarting
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                    // Restart the server
+                    native.run(this.targetUrl, this.port);
+                    console.info(`Server restarted successfully on port ${this.port}`);
                 }
-                catch {
-                    // Server might already be dead
+                catch (restartError) {
+                    console.error(`Failed to restart server on port ${this.port}: ${restartError}`);
                 }
-                // Wait a bit before restarting
-                await new Promise(resolve => setTimeout(resolve, 100));
-                // Restart the server
-                native.run(targetUrl, serverPort);
-                console.info('Server restarted successfully');
-            }
-            catch (restartError) {
-                console.error(`Failed to restart server: ${restartError}`);
             }
         }
+        finally {
+            // Always reset the flag when done, even if an error occurred
+            this.isHealthCheckRunning = false;
+        }
+    }
+    /**
+     * Run the proxy server in a background thread with health monitoring.
+     *
+     * A background monitor will check the server health every HEALTH_CHECK_INTERVAL ms
+     * and automatically restart it if it dies.
+     *
+     * @param url - The target URL to proxy requests to
+     */
+    runServer(url) {
+        // Stop any existing monitoring
+        if (this.monitorInterval !== null) {
+            clearInterval(this.monitorInterval);
+            this.monitorInterval = null;
+        }
+        // Store server configuration
+        this.targetUrl = url;
+        // Start the server
+        try {
+            native.run(url, this.port);
+            this._isRunning = true;
+        }
+        catch (error) {
+            console.error(`Error running the proxy server on port ${this.port}: ${error}`);
+            throw error;
+        }
+        // Start the health check monitor
+        this.monitorInterval = setInterval(() => {
+            this.healthCheckMonitor().catch(() => { });
+        }, HEALTH_CHECK_INTERVAL);
+        console.info(`Started proxy server with health monitoring on port ${this.port}`);
+    }
+    /**
+     * Stop the proxy server and its health monitoring.
+     */
+    stopServer() {
+        // Stop the monitor
+        if (this.monitorInterval !== null) {
+            clearInterval(this.monitorInterval);
+            this.monitorInterval = null;
+        }
+        // Reset the health check flag
+        this.isHealthCheckRunning = false;
+        // Stop the server
+        try {
+            native.stop(this.port);
+            this._isRunning = false;
+        }
+        catch (error) {
+            console.debug(`Error stopping the proxy server on port ${this.port}: ${error}`);
+        }
+        console.debug(`Stopped proxy server and health monitoring on port ${this.port}`);
     }
-    finally {
-        // Always reset the flag when done, even if an error occurred
-        isHealthCheckRunning = false;
+    /**
+     * Check if the server is currently running.
+     */
+    get isRunning() {
+        return this._isRunning;
+    }
+    /**
+     * Get the port this server is running on.
+     */
+    getPort() {
+        return this.port;
     }
 }
+exports.ProxyServer = ProxyServer;
+// Singleton instance for backwards compatibility
+let globalProxy = null;
+function getGlobalProxy(port = 45667) {
+    if (globalProxy === null) {
+        globalProxy = new ProxyServer(port);
+    }
+    return globalProxy;
+}
 /**
  * Run the proxy server in a background thread with health monitoring.
  *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
+ *
  * A background monitor will check the server health every HEALTH_CHECK_INTERVAL ms
  * and automatically restart it if it dies.
  *
@@ -149,43 +256,38 @@ async function healthCheckMonitor() {
  * @param port - The port to listen on (default: 45667)
  */
 function runServer(url, port = 45667) {
-    // Stop any existing monitoring
-    if (monitorInterval !== null) {
-        clearInterval(monitorInterval);
-        monitorInterval = null;
-    }
-    // Store server configuration
-    serverPort = port;
-    targetUrl = url;
-    // Start the server
-    try {
-        native.run(url, port);
-    }
-    catch (error) {
-        console.error(`Error running the proxy server: ${error}`);
-        throw error;
+    // If port is different from current global instance, create a new one
+    const proxy = getGlobalProxy(port);
+    if (proxy.getPort() !== port) {
+        // Stop old instance if running
+        if (proxy.isRunning) {
+            proxy.stopServer();
+        }
+        // Create new instance with the requested port
+        globalProxy = new ProxyServer(port);
     }
-    // Start the health check monitor
-    monitorInterval = setInterval(() => {
-        healthCheckMonitor().catch(() => { });
-    }, HEALTH_CHECK_INTERVAL);
+    getGlobalProxy().runServer(url);
 }
 /**
  * Stop the proxy server and its health monitoring.
+ *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
  */
 function stopServer() {
-    // Stop the monitor
-    if (monitorInterval !== null) {
-        clearInterval(monitorInterval);
-        monitorInterval = null;
-    }
-    // Reset the health check flag
-    isHealthCheckRunning = false;
-    // Stop the server
-    try {
-        native.stop();
-    }
-    catch { }
+    getGlobalProxy().stopServer();
+}
+/**
+ * Set the current trace context by sending an HTTP request to the running proxy server.
+ *
+ * This is a backwards-compatible function that uses a global singleton instance.
+ * For more control, consider creating your own ProxyServer instance.
+ *
+ * @param context - The span context containing trace information
+ * @throws Error if the HTTP request fails
+ */
+async function setCurrentTrace(context) {
+    return getGlobalProxy().setCurrentTrace(context);
 }
 // Re-export native functions for direct access if needed
 exports.run = native.run, exports.stop = native.stop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmnr-ai/claude-code-proxy",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "HTTP proxy for Claude Desktop API requests with Laminar observability",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,13 +23,13 @@
     "dist"
   ],
   "optionalDependencies": {
-    "@lmnr-ai/claude-code-proxy-darwin-arm64": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-darwin-x64": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-win32-x64-msvc": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-linux-x64-gnu": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-linux-arm64-gnu": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-linux-x64-musl": "0.1.8",
-    "@lmnr-ai/claude-code-proxy-linux-arm64-musl": "0.1.8"
+    "@lmnr-ai/claude-code-proxy-darwin-arm64": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-darwin-x64": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-win32-x64-msvc": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-linux-x64-gnu": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-linux-arm64-gnu": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-linux-x64-musl": "0.1.10",
+    "@lmnr-ai/claude-code-proxy-linux-arm64-musl": "0.1.10"
   },
   "keywords": [
     "claude",