claude-code-relay 0.0.1 → 0.0.4

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
+});

package/dist/cjs/cli.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_node_util = require("node:util");
+
+// src/server.ts
+var import_node_http = require("node:http");
+
+// src/cli-wrapper.ts
+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(command2) {
+  if (command2.startsWith("/") || command2.startsWith("~")) {
+    return (0, import_node_fs.existsSync)(command2) ? command2 : null;
+  }
+  try {
+    const cmd = (0, import_node_os.platform)() === "win32" ? "where" : "which";
+    const result = (0, import_node_child_process.execSync)(`${cmd} ${command2}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim().split("\n")[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function generateId(prefix = "") {
+  const random = Math.random().toString(36).substring(2, 14);
+  return prefix ? `${prefix}-${random}` : random;
+}
+
+// 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;
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/server.ts
+var _cli = null;
+function sendJson(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body),
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(body);
+}
+function sendError(res, message, status = 500) {
+  sendJson(res, { error: { message, type: "server_error" } }, status);
+}
+function sendSSEChunk(res, data) {
+  res.write(`data: ${data}
+
+`);
+}
+async function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+async function handleRequest(req, res) {
+  const url = req.url ?? "/";
+  const method = req.method ?? "GET";
+  if (method === "OPTIONS") {
+    res.writeHead(204, {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization"
+    });
+    res.end();
+    return;
+  }
+  if (method === "GET" && url === "/health") {
+    sendJson(res, { status: _cli ? "ok" : "degraded", cli_available: _cli !== null });
+    return;
+  }
+  if (method === "GET" && url === "/v1/models") {
+    const now = Math.floor(Date.now() / 1e3);
+    const models = {
+      object: "list",
+      data: [
+        { id: "sonnet", object: "model", created: now, owned_by: "anthropic" },
+        { id: "opus", object: "model", created: now, owned_by: "anthropic" },
+        { id: "haiku", object: "model", created: now, owned_by: "anthropic" }
+      ]
+    };
+    sendJson(res, models);
+    return;
+  }
+  if (method === "POST" && url === "/v1/chat/completions") {
+    if (!_cli) {
+      sendError(res, "Claude CLI not available", 503);
+      return;
+    }
+    let request;
+    try {
+      const body = await readBody(req);
+      request = JSON.parse(body);
+    } catch {
+      sendError(res, "Invalid JSON", 400);
+      return;
+    }
+    const chatId = generateId("chatcmpl");
+    const created = Math.floor(Date.now() / 1e3);
+    if (request.stream) {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+        "X-Accel-Buffering": "no"
+      });
+      const initial = {
+        id: chatId,
+        object: "chat.completion.chunk",
+        created,
+        model: request.model,
+        choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]
+      };
+      sendSSEChunk(res, JSON.stringify(initial));
+      try {
+        for await (const text of _cli.stream(request.messages, request.model)) {
+          const chunk = {
+            id: chatId,
+            object: "chat.completion.chunk",
+            created,
+            model: request.model,
+            choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
+          };
+          sendSSEChunk(res, JSON.stringify(chunk));
+        }
+      } catch (err) {
+        sendSSEChunk(res, JSON.stringify({ error: { message: String(err), type: "server_error" } }));
+      }
+      const final = {
+        id: chatId,
+        object: "chat.completion.chunk",
+        created,
+        model: request.model,
+        choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+      };
+      sendSSEChunk(res, JSON.stringify(final));
+      sendSSEChunk(res, "[DONE]");
+      res.end();
+      return;
+    }
+    try {
+      const content = await _cli.complete(request.messages, request.model);
+      const response = {
+        id: chatId,
+        object: "chat.completion",
+        created,
+        model: request.model,
+        choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+      };
+      sendJson(res, response);
+    } catch (err) {
+      sendError(res, String(err));
+    }
+    return;
+  }
+  sendError(res, "Not found", 404);
+}
+function createApp(config) {
+  try {
+    _cli = new ClaudeCLI(config?.cli);
+  } catch (err) {
+    console.error(`Failed to initialize Claude CLI: ${err}`);
+    _cli = null;
+  }
+  return (0, import_node_http.createServer)((req, res) => {
+    handleRequest(req, res).catch((err) => {
+      console.error("Request error:", err);
+      sendError(res, "Internal server error");
+    });
+  });
+}
+function runServer(host = "127.0.0.1", port = 52014, config) {
+  const server = createApp(config);
+  server.listen(port, host, () => {
+    console.log(`Server running at http://${host}:${port}`);
+  });
+}
+
+// src/cli.ts
+var { values, positionals } = (0, import_node_util.parseArgs)({
+  allowPositionals: true,
+  options: {
+    port: { type: "string", short: "p", default: process.env.CLAUDE_CODE_RELAY_PORT ?? "52014" },
+    host: { type: "string", short: "h", default: process.env.CLAUDE_CODE_RELAY_HOST ?? "127.0.0.1" },
+    "claude-path": { type: "string", default: process.env.CLAUDE_CLI_PATH ?? "claude" },
+    timeout: { type: "string", default: process.env.CLAUDE_CODE_RELAY_TIMEOUT ?? "300" },
+    verbose: { type: "boolean", short: "v", default: false },
+    version: { type: "boolean", short: "V", default: false },
+    help: { type: "boolean", default: false }
+  }
+});
+var command = positionals[0];
+if (values.version) {
+  console.log("claude-code-relay 0.0.1");
+  process.exit(0);
+}
+if (values.help || !command && !values.version) {
+  console.log(`
+claude-code-relay - OpenAI-compatible API server for Claude CLI
+
+Usage:
+  claude-code-relay <command> [options]
+
+Commands:
+  serve    Start the API server
+  check    Check if Claude CLI is available
+
+Options:
+  -p, --port <port>         Port to listen on (default: 52014)
+  -h, --host <host>         Host to bind to (default: 127.0.0.1)
+      --claude-path <path>  Path to Claude CLI binary (default: claude)
+      --timeout <seconds>   Request timeout in seconds (default: 300)
+  -v, --verbose             Enable verbose logging
+  -V, --version             Show version
+      --help                Show this help
+`);
+  process.exit(0);
+}
+if (command === "serve") {
+  const port = parseInt(values.port, 10);
+  const host = values.host;
+  const claudePath = values["claude-path"];
+  const timeout = parseInt(values.timeout, 10);
+  const verbose = values.verbose;
+  process.env.CLAUDE_CLI_PATH = claudePath;
+  process.env.CLAUDE_CODE_RELAY_TIMEOUT = String(timeout);
+  process.env.CLAUDE_CODE_RELAY_VERBOSE = verbose ? "1" : "";
+  console.log("Starting Claude Code Relay server...");
+  console.log(`  Host: ${host}`);
+  console.log(`  Port: ${port}`);
+  console.log(`  Claude CLI: ${claudePath}`);
+  console.log(`  Timeout: ${timeout}s`);
+  console.log();
+  console.log(`API endpoint: http://${host}:${port}/v1/chat/completions`);
+  console.log();
+  runServer(host, port, {
+    cli: { cliPath: claudePath, timeout, verbose }
+  });
+} else if (command === "check") {
+  console.log("Checking Claude CLI...");
+  const cliPath = values["claude-path"] ?? process.env.CLAUDE_CLI_PATH ?? "claude";
+  const resolved = which(cliPath);
+  if (resolved) {
+    console.log(`  CLI path: ${resolved}`);
+    console.log("  Status: OK");
+  } else {
+    console.error(`  Error: Claude CLI not found at '${cliPath}'`);
+    process.exit(1);
+  }
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Run 'claude-code-relay --help' for usage");
+  process.exit(1);
+}