claude-code-relay 0.0.1 → 0.0.7

package/README.md

@@ -0,0 +1,199 @@
+# claude-code-relay
+
+Local proxy that exposes Claude CLI as an OpenAI-compatible API server.
+
+Use your existing Claude CLI installation with any OpenAI-compatible client.
+
+## Why?
+
+- You already have Claude CLI working with your subscription
+- You want to use tools that expect OpenAI API format
+- No separate API key needed - uses your local Claude CLI
+
+## Installation
+
+### Node.js / Bun
+
+```bash
+npx claude-code-relay serve
+# or
+bunx claude-code-relay serve
+# or install globally
+npm install -g claude-code-relay
+```
+
+### Python
+
+```bash
+pip install claude-code-relay
+```
+
+## Usage
+
+### Start the server
+
+```bash
+# Node
+npx claude-code-relay serve --port 52014
+
+# Python
+claude-code-relay serve --port 52014
+```
+
+### Use with OpenAI SDK
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:52014/v1",
+    api_key="not-needed"
+)
+
+response = client.chat.completions.create(
+    model="sonnet",  # or "opus", "haiku"
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```
+
+```typescript
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL: "http://localhost:52014/v1",
+  apiKey: "not-needed",
+});
+
+const response = await client.chat.completions.create({
+  model: "sonnet",
+  messages: [{ role: "user", content: "Hello!" }],
+});
+```
+
+### Use with LiteLLM
+
+```python
+from litellm import completion
+
+response = completion(
+    model="openai/sonnet",
+    api_base="http://localhost:52014/v1",
+    api_key="not-needed",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+### Use with Vercel AI SDK
+
+```typescript
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText } from "ai";
+
+const claude = createOpenAICompatible({
+  name: "claude-code-relay",
+  baseURL: "http://localhost:52014/v1",
+  apiKey: "not-needed",
+});
+
+const { text } = await generateText({
+  model: claude.chatModel("sonnet"),
+  prompt: "Hello!",
+});
+```
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/v1/chat/completions` | POST | Chat completions (streaming supported) |
+| `/v1/models` | GET | List available models |
+| `/health` | GET | Health check |
+
+## OpenAI API Compatibility
+
+### Supported Features
+
+| Feature | Status | Notes |
+|---------|--------|-------|
+| `model` | Supported | `sonnet`, `opus`, `haiku` (+ aliases below) |
+| `messages` | Supported | `system`, `user`, `assistant` roles |
+| `stream` | Supported | SSE streaming |
+| System prompts | Supported | Via `system` role in messages |
+
+### Model Aliases
+
+These model names are normalized to Claude CLI format:
+
+| Input | Maps to |
+|-------|---------|
+| `sonnet` | `sonnet` |
+| `opus` | `opus` |
+| `haiku` | `haiku` |
+| `claude-3-sonnet` | `sonnet` |
+| `claude-3-opus` | `opus` |
+| `claude-3-haiku` | `haiku` |
+| `claude-sonnet-4` | `sonnet` |
+| `claude-opus-4` | `opus` |
+
+### Not Supported
+
+These parameters are accepted but **ignored** (not passed to Claude CLI):
+
+| Parameter | Status |
+|-----------|--------|
+| `temperature` | Ignored |
+| `max_tokens` | Ignored |
+| `top_p` | Ignored |
+| `stop` | Ignored |
+| `n` | Not supported |
+| `presence_penalty` | Not supported |
+| `frequency_penalty` | Not supported |
+| `logit_bias` | Not supported |
+| `response_format` | Not supported |
+| `tools` / `functions` | Not supported |
+| `tool_choice` | Not supported |
+| `seed` | Not supported |
+| `logprobs` | Not supported |
+| `user` | Not supported |
+
+### Response Limitations
+
+- `usage` tokens are always `0` (not tracked by Claude CLI)
+- `finish_reason` is always `"stop"` (no length/tool_calls detection)
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CLAUDE_CODE_RELAY_PORT` | `52014` | Server port (Python only) |
+| `CLAUDE_CODE_RELAY_HOST` | `127.0.0.1` | Host to bind (Python only) |
+| `CLAUDE_CLI_PATH` | `claude` | Path to Claude CLI binary |
+| `CLAUDE_CODE_RELAY_TIMEOUT` | `300` | Request timeout in seconds |
+| `CLAUDE_CODE_RELAY_VERBOSE` | `false` | Enable verbose logging (`1` or `true`) |
+
+### CLI Options
+
+```
+claude-code-relay serve [options]
+
+Options:
+  --port, -p <port>      Server port (default: 52014)
+  --host <host>          Host to bind (default: 127.0.0.1)
+  --claude-path <path>   Path to Claude CLI
+  --timeout <seconds>    Request timeout (default: 300)
+  --verbose, -v          Enable verbose logging
+```
+
+## Requirements
+
+- Claude CLI installed and authenticated
+- Python 3.10+ or Node.js 18+
+
+## License
+
+MIT - see [LICENSE](LICENSE)
+
+**Disclaimer**: Unofficial community project. Users are responsible for compliance with Anthropic's Terms of Service.

package/dist/cjs/cli-wrapper.js

@@ -0,0 +1,186 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli-wrapper.ts
+var cli_wrapper_exports = {};
+__export(cli_wrapper_exports, {
+  ClaudeCLI: () => ClaudeCLI
+});
+module.exports = __toCommonJS(cli_wrapper_exports);
+var import_node_child_process2 = require("node:child_process");
+
+// src/utils.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+function which(command) {
+  if (command.startsWith("/") || command.startsWith("~")) {
+    return (0, import_node_fs.existsSync)(command) ? command : null;
+  }
+  try {
+    const cmd = (0, import_node_os.platform)() === "win32" ? "where" : "which";
+    const result = (0, import_node_child_process.execSync)(`${cmd} ${command}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().split("\n")[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli-wrapper.ts
+var MODEL_MAP = {
+  sonnet: "sonnet",
+  opus: "opus",
+  haiku: "haiku",
+  "claude-3-sonnet": "sonnet",
+  "claude-3-opus": "opus",
+  "claude-3-haiku": "haiku",
+  "claude-sonnet-4": "sonnet",
+  "claude-opus-4": "opus"
+};
+var ClaudeCLI = class {
+  config;
+  constructor(config) {
+    this.config = {
+      cliPath: config?.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude",
+      timeout: config?.timeout ?? parseInt(process.env.CLAUDE_CODE_RELAY_TIMEOUT ?? "300", 10),
+      verbose: config?.verbose ?? process.env.CLAUDE_CODE_RELAY_VERBOSE === "1"
+    };
+    this.validateCLI();
+  }
+  validateCLI() {
+    const cliPath = which(this.config.cliPath);
+    if (!cliPath) {
+      throw new Error(
+        `Claude CLI not found at '${this.config.cliPath}'. Please install it or set CLAUDE_CLI_PATH.`
+      );
+    }
+    if (this.config.verbose) {
+      console.log(`Using Claude CLI at: ${cliPath}`);
+    }
+  }
+  normalizeModel(model) {
+    return MODEL_MAP[model.toLowerCase()] ?? "sonnet";
+  }
+  buildPrompt(messages, systemPrompt) {
+    const parts = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+        break;
+      }
+    }
+    if (systemPrompt) {
+      parts.push(`System: ${systemPrompt}
+`);
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") continue;
+      if (msg.role === "user") {
+        parts.push(`Human: ${msg.content}
+`);
+      } else if (msg.role === "assistant") {
+        parts.push(`Assistant: ${msg.content}
+`);
+      }
+    }
+    parts.push("Assistant:");
+    return parts.join("\n");
+  }
+  async complete(messages, model = "sonnet", systemPrompt) {
+    const prompt = this.buildPrompt(messages, systemPrompt);
+    const normalizedModel = this.normalizeModel(model);
+    return new Promise((resolve, reject) => {
+      const args = ["-p", "--model", normalizedModel, "--output-format", "text"];
+      if (this.config.verbose) {
+        console.log(`Running: ${this.config.cliPath} ${args.join(" ")}`);
+      }
+      const proc = (0, import_node_child_process2.spawn)(this.config.cliPath, args, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Claude CLI failed: ${stderr}`));
+        } else {
+          resolve(stdout.trim());
+        }
+      });
+      proc.on("error", (err) => {
+        reject(err);
+      });
+      proc.stdin.write(prompt);
+      proc.stdin.end();
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Claude CLI timeout after ${this.config.timeout}s`));
+      }, this.config.timeout * 1e3);
+    });
+  }
+  async *stream(messages, model = "sonnet", systemPrompt) {
+    const prompt = this.buildPrompt(messages, systemPrompt);
+    const normalizedModel = this.normalizeModel(model);
+    const args = ["-p", "--model", normalizedModel, "--output-format", "stream-json"];
+    if (this.config.verbose) {
+      console.log(`Running: ${this.config.cliPath} ${args.join(" ")}`);
+    }
+    const proc = (0, import_node_child_process2.spawn)(this.config.cliPath, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+    let buffer = "";
+    for await (const chunk of proc.stdout) {
+      buffer += chunk.toString();
+      while (buffer.includes("\n")) {
+        const [line, rest] = buffer.split("\n", 2);
+        buffer = rest ?? "";
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const data = JSON.parse(trimmed);
+          if (data.content) {
+            yield data.content;
+          } else if (data.text) {
+            yield data.text;
+          } else if (data.delta?.text) {
+            yield data.delta.text;
+          }
+        } catch {
+          if (!trimmed.startsWith("{")) {
+            yield trimmed;
+          }
+        }
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClaudeCLI
+});