@lmnr-ai/claude-code-proxy 0.1.1-alpha.1

package/README.md

@@ -0,0 +1,5 @@
+# Laminar Claude Code proxy
+
+This library contains a tiny Rust proxy for Claude Code that can accept
+requests from claude-agent-sdk with trace id and span id in order
+to associate spans from the proxy with the parent context.

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Laminar Claude Code Proxy - TypeScript/JavaScript bindings for HTTP proxy server
+ */
+export interface SpanContext {
+    traceId: string;
+    spanId: string;
+    projectApiKey: string;
+    spanIdsPath?: string[];
+    spanPath?: string[];
+    laminarUrl?: string;
+}
+/**
+ * Set the current trace context by sending an HTTP request to the running proxy server.
+ *
+ * @param context - The span context containing trace information
+ * @throws Error if the HTTP request fails
+ */
+export declare function setCurrentTrace(context: SpanContext): Promise<void>;
+/**
+ * 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
+ * @param port - The port to listen on (default: 45667)
+ */
+export declare function runServer(url: string, port?: number): void;
+/**
+ * Stop the proxy server and its health monitoring.
+ */
+export declare function stopServer(): void;
+export declare const run: any, stop: any;

package/dist/index.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * 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.runServer = runServer;
+exports.stopServer = stopServer;
+// Import native functions from the NAPI module
+// When built, this will be in dist/index.js and the native module will be in dist/
+// NAPI-RS generates the binding files in the same directory
+const native = require('./lmnr-claude-code-proxy');
+const HEALTH_CHECK_INTERVAL = 1000;
+// Module-level variables to track the server state
+let serverPort = 45667;
+let targetUrl = '';
+let monitorInterval = null;
+/**
+ * Set the current trace context by sending an HTTP request to the running proxy server.
+ *
+ * @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.
+ */
+async function healthCheckMonitor() {
+    const url = `http://127.0.0.1:${serverPort}/lmnr-internal/health`;
+    try {
+        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: ${error}. Attempting to restart...`);
+        try {
+            // Try to stop the existing server (it might be stuck)
+            try {
+                native.stop();
+            }
+            catch {
+                // Server might already be dead
+            }
+            // 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}`);
+        }
+    }
+}
+/**
+ * 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
+ * @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;
+    }
+    // Start the health check monitor
+    monitorInterval = setInterval(() => {
+        healthCheckMonitor().catch(() => { });
+    }, HEALTH_CHECK_INTERVAL);
+}
+/**
+ * Stop the proxy server and its health monitoring.
+ */
+function stopServer() {
+    // Stop the monitor
+    if (monitorInterval !== null) {
+        clearInterval(monitorInterval);
+        monitorInterval = null;
+    }
+    // Stop the server
+    try {
+        native.stop();
+    }
+    catch { }
+}
+// Re-export native functions for direct access if needed
+exports.run = native.run, exports.stop = native.stop;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lmnr-ai/claude-code-proxy",
+  "version": "0.1.1-alpha.1",
+  "description": "HTTP proxy for Claude Desktop API requests with Laminar observability",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "napi": {
+    "binaryName": "lmnr-claude-code-proxy",
+    "package": {
+      "name": "@lmnr-ai/claude-code-proxy"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "claude",
+    "proxy",
+    "anthropic",
+    "laminar",
+    "observability",
+    "napi"
+  ],
+  "author": "Laminar AI",
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.0.0",
+    "@types/node": "^22.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.6.0"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build:cargo": "cd ../bin && cargo build --release --features typescript",
+    "build:napi": "cd ../bin && napi build --platform --release -o ../ts/dist",
+    "build:ts": "tsc",
+    "build": "node scripts/build.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}