@h1d3rone/claude-proxy 0.1.0

package/src/proxy/server.js

@@ -0,0 +1,271 @@
+const express = require("express");
+const fs = require("fs/promises");
+const { DEFAULT_CLIENT_API_KEY } = require("../config");
+const { ensureDir, writeText } = require("../utils");
+const {
+  convertClaudeToOpenAI,
+  convertOpenAIToClaudeResponse,
+  mapClaudeModelToOpenAI,
+  streamOpenAiToClaude
+} = require("./converters");
+
+function resolveChatCompletionsUrl(baseUrl) {
+  const upstreamUrl = new URL(String(baseUrl));
+  const normalizedPath = upstreamUrl.pathname.replace(/\/+$/, "");
+
+  upstreamUrl.pathname =
+    !normalizedPath || normalizedPath === "/"
+      ? "/v1/chat/completions"
+      : `${normalizedPath}/chat/completions`;
+
+  return upstreamUrl.toString();
+}
+
+function extractClientApiKey(request) {
+  const xApiKey = request.headers["x-api-key"];
+  if (xApiKey) {
+    return String(xApiKey);
+  }
+
+  const auth = request.headers.authorization;
+  if (auth && auth.startsWith("Bearer ")) {
+    return auth.slice("Bearer ".length);
+  }
+
+  return null;
+}
+
+function validateClientApiKey(request, config) {
+  if (!config.client_api_key) {
+    return true;
+  }
+  return extractClientApiKey(request) === config.client_api_key;
+}
+
+async function parseUpstreamError(response) {
+  const text = await response.text();
+  try {
+    const json = JSON.parse(text);
+    return json.error?.message || json.message || text;
+  } catch {
+    return text || `Upstream request failed with status ${response.status}`;
+  }
+}
+
+function createUpstreamHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${config.api_key}`
+  };
+}
+
+function estimateInputTokens(messageRequest) {
+  let totalChars = 0;
+  if (typeof messageRequest.system === "string") {
+    totalChars += messageRequest.system.length;
+  } else if (Array.isArray(messageRequest.system)) {
+    totalChars += messageRequest.system
+      .filter((block) => block && typeof block.text === "string")
+      .reduce((sum, block) => sum + block.text.length, 0);
+  }
+
+  for (const message of messageRequest.messages || []) {
+    if (typeof message.content === "string") {
+      totalChars += message.content.length;
+      continue;
+    }
+
+    if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block && typeof block.text === "string") {
+          totalChars += block.text.length;
+        }
+      }
+    }
+  }
+
+  return Math.max(1, Math.floor(totalChars / 4));
+}
+
+async function startServer(config, host) {
+  const app = express();
+  app.use(express.json({ limit: "100mb" }));
+  const baseUrl = host.base_url || config.base_url;
+  const apiKey = host.api_key || config.api_key;
+  const clientApiKey = host.client_api_key || DEFAULT_CLIENT_API_KEY;
+  const smallModel = host.small_model || config.small_model;
+
+  app.get("/", async (request, response) => {
+    response.json({
+      message: "Claude-to-OpenAI API Proxy (Node rewrite)",
+      status: "running",
+      upstream_base_url: baseUrl,
+      listen: `${config.server_host}:${config.server_port}`,
+      host: host.name
+    });
+  });
+
+  app.get("/health", async (request, response) => {
+    response.json({
+      status: "healthy",
+      upstream_base_url: baseUrl,
+      api_key_configured: Boolean(apiKey),
+      client_api_key_configured: Boolean(clientApiKey),
+      host: host.name
+    });
+  });
+
+  app.get("/test-connection", async (request, response) => {
+    try {
+      const upstreamResponse = await fetch(resolveChatCompletionsUrl(baseUrl), {
+        method: "POST",
+        headers: createUpstreamHeaders({ api_key: apiKey }),
+        body: JSON.stringify({
+          model: smallModel,
+          messages: [{ role: "user", content: "Hello" }],
+          max_tokens: 5
+        })
+      });
+
+      if (!upstreamResponse.ok) {
+        throw new Error(await parseUpstreamError(upstreamResponse));
+      }
+
+      const payload = await upstreamResponse.json();
+      response.json({
+        status: "success",
+        model_used: smallModel,
+        response_id: payload.id || null
+      });
+    } catch (error) {
+      response.status(503).json({
+        status: "failed",
+        message: error.message
+      });
+    }
+  });
+
+  app.post("/v1/messages/count_tokens", async (request, response) => {
+    response.json({
+      input_tokens: estimateInputTokens(request.body || {})
+    });
+  });
+
+  app.post("/v1/messages", async (request, response) => {
+    if (!validateClientApiKey(request, { client_api_key: clientApiKey })) {
+      response.status(401).json({
+        type: "error",
+        error: {
+          type: "authentication_error",
+          message: "Invalid Claude client API key."
+        }
+      });
+      return;
+    }
+
+    let openaiRequest;
+    try {
+      openaiRequest = convertClaudeToOpenAI(request.body, {
+        big_model: host.big_model || config.big_model,
+        middle_model: host.middle_model || config.middle_model,
+        small_model: smallModel
+      });
+    } catch (error) {
+      response.status(400).json({
+        type: "error",
+        error: {
+          type: "invalid_request_error",
+          message: error.message
+        }
+      });
+      return;
+    }
+
+    const abortController = new AbortController();
+    request.on("aborted", () => abortController.abort());
+    response.on("close", () => {
+      if (!response.writableEnded) {
+        abortController.abort();
+      }
+    });
+
+    try {
+      const upstreamResponse = await fetch(resolveChatCompletionsUrl(baseUrl), {
+        method: "POST",
+        headers: createUpstreamHeaders({ api_key: apiKey }),
+        body: JSON.stringify(openaiRequest),
+        signal: abortController.signal
+      });
+
+      if (!upstreamResponse.ok) {
+        response.status(upstreamResponse.status).json({
+          type: "error",
+          error: {
+            type: "api_error",
+            message: await parseUpstreamError(upstreamResponse)
+          }
+        });
+        return;
+      }
+
+      if (openaiRequest.stream) {
+        response.status(200);
+        response.setHeader("Content-Type", "text/event-stream");
+        response.setHeader("Cache-Control", "no-cache");
+        response.setHeader("Connection", "keep-alive");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Access-Control-Allow-Headers", "*");
+        response.flushHeaders();
+        await streamOpenAiToClaude(upstreamResponse, response, request.body, abortController);
+        response.end();
+        return;
+      }
+
+      const upstreamJson = await upstreamResponse.json();
+      const claudeResponse = convertOpenAIToClaudeResponse(upstreamJson, request.body);
+      response.json(claudeResponse);
+    } catch (error) {
+      const status = error.name === "AbortError" ? 499 : 500;
+      response.status(status).json({
+        type: "error",
+        error: {
+          type: "api_error",
+          message: error.message
+        }
+      });
+    }
+  });
+
+  await ensureDir(host.state_dir);
+  await ensureDir(host.logs_dir);
+
+  return new Promise((resolve, reject) => {
+    const server = app.listen(config.server_port, config.server_host, async () => {
+      await writeText(host.pid_file, `${process.pid}\n`);
+      resolve(server);
+    });
+
+    server.on("error", async (error) => {
+      try {
+        await fs.rm(host.pid_file, { force: true });
+      } catch {}
+      reject(error);
+    });
+
+    const cleanup = async () => {
+      try {
+        await fs.rm(host.pid_file, { force: true });
+      } catch {}
+      process.exit(0);
+    };
+
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+}
+
+module.exports = {
+  mapClaudeModelToOpenAI,
+  resolveChatCompletionsUrl,
+  startServer
+};

package/src/services/client-config-manager.js

@@ -0,0 +1,302 @@
+const fs = require("fs/promises");
+const path = require("path");
+const toml = require("@iarna/toml");
+const {
+  backupFile,
+  copyFile,
+  ensureDir,
+  pathExists,
+  readJson,
+  writeJson
+} = require("../utils");
+const { cleanClaudeSettings, patchClaudeSettings } = require("./host-manager");
+
+function getEmptyManagedState() {
+  return {
+    version: 1,
+    files: {}
+  };
+}
+
+function reportProgress(options, event) {
+  if (typeof options?.onProgress === "function") {
+    options.onProgress(event);
+  }
+}
+
+async function runManagedStep(options, label, action) {
+  reportProgress(options, { label, status: "started" });
+  try {
+    const result = await action();
+    reportProgress(options, { label, status: "completed" });
+    return result;
+  } catch (error) {
+    reportProgress(options, { label, status: "failed", error });
+    throw error;
+  }
+}
+
+async function readToml(targetPath, fallback = {}) {
+  try {
+    const raw = await fs.readFile(targetPath, "utf8");
+    return toml.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+
+async function writeToml(targetPath, value) {
+  await ensureDir(path.dirname(targetPath));
+  await fs.writeFile(targetPath, toml.stringify(value), "utf8");
+}
+
+async function loadManagedState(host) {
+  const state = await readJson(host.managed_state_file, getEmptyManagedState());
+  return {
+    version: 1,
+    files: {},
+    ...state
+  };
+}
+
+async function ensureManagedBackup(host, state, key, targetPath) {
+  if (state.files[key]) {
+    return state;
+  }
+
+  const existed = await pathExists(targetPath);
+  const backupPath = existed ? await backupFile(targetPath, host.backups_dir) : null;
+  state.files[key] = {
+    existed,
+    target_path: targetPath,
+    backup_path: backupPath
+  };
+  return state;
+}
+
+function getCodexProviderName(document, preferredProvider) {
+  const providers =
+    document.model_providers && typeof document.model_providers === "object"
+      ? document.model_providers
+      : null;
+
+  if (providers && preferredProvider && providers[preferredProvider]) {
+    return preferredProvider;
+  }
+
+  if (providers && document.model_provider && providers[document.model_provider]) {
+    return document.model_provider;
+  }
+
+  if (!providers) {
+    return null;
+  }
+
+  return Object.keys(providers)[0] || null;
+}
+
+function patchCodexConfigDocument(document, host, config = {}) {
+  const patched = { ...document };
+  const providerName = getCodexProviderName(
+    patched,
+    host.codex_provider || config.codex_provider || null
+  );
+  const baseUrl = host.base_url || config.base_url;
+
+  if (providerName) {
+    patched.model_providers = patched.model_providers || {};
+    patched.model_providers[providerName] = {
+      ...(patched.model_providers[providerName] || {}),
+      base_url: baseUrl
+    };
+    return patched;
+  }
+
+  patched.base_url = baseUrl;
+  return patched;
+}
+
+async function patchCodexConfig(config, host, state) {
+  await ensureManagedBackup(host, state, "codex_config", host.codex_config_path);
+  const document = await readToml(host.codex_config_path, {});
+  await writeToml(host.codex_config_path, patchCodexConfigDocument(document, host, config));
+}
+
+async function patchCodexAuth(config, host, state) {
+  await ensureManagedBackup(host, state, "codex_auth", host.codex_auth_path);
+  const auth = await readJson(host.codex_auth_path, {});
+  auth.OPENAI_API_KEY = host.api_key || config.api_key;
+  await writeJson(host.codex_auth_path, auth);
+}
+
+function getManagedApplyEntries(host, config, state) {
+  return {
+    codex_config: {
+      label: `Update Codex config (${host.codex_config_path})`,
+      action: () => patchCodexConfig(config, host, state)
+    },
+    codex_auth: {
+      label: `Update Codex auth (${host.codex_auth_path})`,
+      action: () => patchCodexAuth(config, host, state)
+    },
+    claude_settings: {
+      label: `Update Claude settings (${host.settings_path})`,
+      action: async () => {
+        await ensureManagedBackup(host, state, "claude_settings", host.settings_path);
+        await patchClaudeSettings(config, host, { configPath: config.__configPath });
+      }
+    }
+  };
+}
+
+async function applyManagedEntries(config, host, selectedKeys, options = {}) {
+  await ensureDir(host.backups_dir);
+  await ensureDir(host.state_dir);
+
+  const state = await loadManagedState(host);
+  const entries = getManagedApplyEntries(host, config, state);
+
+  for (const key of selectedKeys) {
+    const entry = entries[key];
+    if (!entry) {
+      continue;
+    }
+
+    await runManagedStep(options, entry.label, entry.action);
+  }
+
+  await runManagedStep(options, `Write managed state (${host.managed_state_file})`, async () => {
+    await writeJson(host.managed_state_file, state);
+  });
+}
+
+async function applyClaudeManagedHostConfig(config, host, options = {}) {
+  return applyManagedEntries(config, host, ["claude_settings"], options);
+}
+
+async function applyOpenAIManagedHostConfig(config, host, options = {}) {
+  return applyManagedEntries(config, host, ["codex_config", "codex_auth"], options);
+}
+
+async function applyManagedHostConfig(config, host, options = {}) {
+  return applyManagedEntries(config, host, ["codex_config", "codex_auth", "claude_settings"], options);
+}
+
+async function restoreManagedFile(host, entry) {
+  await backupFile(entry.target_path, host.backups_dir);
+
+  if (entry.existed && entry.backup_path && (await pathExists(entry.backup_path))) {
+    await copyFile(entry.backup_path, entry.target_path);
+    return;
+  }
+
+  await fs.rm(entry.target_path, { force: true });
+}
+
+function getManagedEntries(host) {
+  return {
+    claude_settings: {
+      key: "claude_settings",
+      label: "Restore Claude settings",
+      targetPath: host.settings_path,
+      fallbackLabel: "Clean Claude settings",
+      fallback: (config) => cleanClaudeSettings(config, host)
+    },
+    codex_config: {
+      key: "codex_config",
+      label: "Restore Codex config",
+      targetPath: host.codex_config_path
+    },
+    codex_auth: {
+      key: "codex_auth",
+      label: "Restore Codex auth",
+      targetPath: host.codex_auth_path
+    }
+  };
+}
+
+async function finalizeManagedState(host, state, options = {}) {
+  if (Object.keys(state.files || {}).length === 0) {
+    await runManagedStep(options, `Remove managed state (${host.managed_state_file})`, async () => {
+      await fs.rm(host.managed_state_file, { force: true });
+    });
+    return;
+  }
+
+  await runManagedStep(options, `Write managed state (${host.managed_state_file})`, async () => {
+    await writeJson(host.managed_state_file, state);
+  });
+}
+
+async function cleanManagedEntries(config, host, selectedKeys, options = {}) {
+  const state = await loadManagedState(host);
+  const fileEntries = state.files || {};
+  const managedEntries = getManagedEntries(host);
+  let changed = false;
+
+  for (const key of selectedKeys) {
+    const descriptor = managedEntries[key];
+    if (!descriptor) {
+      continue;
+    }
+
+    const entry = fileEntries[key];
+    if (entry) {
+      await runManagedStep(options, `${descriptor.label} (${descriptor.targetPath})`, async () => {
+        await restoreManagedFile(host, entry);
+      });
+      delete state.files[key];
+      changed = true;
+      continue;
+    }
+
+    if (descriptor.fallback) {
+      await runManagedStep(
+        options,
+        `${descriptor.fallbackLabel} (${descriptor.targetPath})`,
+        async () => {
+          await descriptor.fallback(config);
+        }
+      );
+      changed = true;
+      continue;
+    }
+
+    reportProgress(options, {
+      label: `${descriptor.label} (${descriptor.targetPath})`,
+      status: "skipped"
+    });
+  }
+
+  if (!changed) {
+    return false;
+  }
+
+  await finalizeManagedState(host, state, options);
+  return true;
+}
+
+async function cleanClaudeManagedHostConfig(config, host, options = {}) {
+  return cleanManagedEntries(config, host, ["claude_settings"], options);
+}
+
+async function cleanOpenAIManagedHostConfig(config, host, options = {}) {
+  return cleanManagedEntries(config, host, ["codex_config", "codex_auth"], options);
+}
+
+async function cleanManagedHostConfig(config, host, options = {}) {
+  return cleanManagedEntries(config, host, ["claude_settings", "codex_config", "codex_auth"], options);
+}
+
+module.exports = {
+  applyClaudeManagedHostConfig,
+  applyManagedHostConfig,
+  applyOpenAIManagedHostConfig,
+  cleanClaudeManagedHostConfig,
+  cleanManagedHostConfig,
+  cleanOpenAIManagedHostConfig,
+  patchCodexConfigDocument
+};