@halilertekin/claude-code-router-config 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 2.0.2
+- UI sadeleştirildi, responsive hale getirildi ve Türkçe/Hollandaca desteği eklendi.
+
+## 2.0.1
+- Include router files in the published npm package.
+
+## 2.0.0
+- Unified router service built into this package (no external router dependency).
+- Native CLI lifecycle commands (start/stop/restart/status/code/ui).
+- Streaming translation between Anthropic and OpenAI-style endpoints.
+- Dashboard now served by the router at `/ui`.
+- Default config uses `smart-intent-router.js` and adds HOST/PORT.

package/README.md

@@ -1,15 +1,16 @@
 # Claude Code Router Config - Advanced Multi-Provider Setup
 
-🚀 **v2.0.0** - Unified router + config package with z.ai (GLM 4.7) support, advanced CLI tools, analytics, smart routing, and configuration templates!
+🚀 **v2.0.2** - Unified router + config package with z.ai (GLM 4.7) support, advanced CLI tools, analytics, smart routing, and configuration templates!
 
 Use Claude Code as a single interface to access multiple AI providers with intelligent routing for optimal performance, cost, and quality.
 
-## ✨ New in v2.0.0
+## ✨ New in v2.0.2
 - **z.ai Support**: Native integration for GLM-4.7 via z.ai (PPInfra).
 - **Lightweight Mode**: New `ccc` function for zero-dependency routing.
 - **Direct GLM Alias**: Type `glm` to launch Claude Code with GLM-4.7 immediately.
 - **Non-interactive install**: CI-friendly installer flags and env controls.
 - **Unified router**: Built-in router service, no external dependency required.
+- **UI refresh**: Daha sade ve responsive tasarım, TR/NL dil desteği.
 
 ## 🚀 Setup on Another Machine (Fastest Way)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halilertekin/claude-code-router-config",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Multi-provider configuration for Claude Code Router with intent-based routing, advanced CLI tools, analytics, and smart routing. Setup OpenAI, Anthropic, Gemini, Qwen, GLM, OpenRouter, and GitHub Copilot with intelligent routing.",
   "main": "install.js",
   "bin": {
@@ -25,6 +25,7 @@
     "bin/",
     "config/",
     "cli/",
+    "router/",
     "logging/",
     "templates/",
     "plugins/",
@@ -35,6 +36,7 @@
     "postinstall.js",
     ".env.example",
     "docs/",
+    "CHANGELOG.md",
     "LICENSE",
     "README.md",
     "NPM_README.md"

package/router/config.js

@@ -0,0 +1,82 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.claude-code-router');
+const DEFAULT_CONFIG_PATH = path.join(DEFAULT_CONFIG_DIR, 'config.json');
+
+function resolveEnv(value) {
+  if (typeof value !== 'string') return value;
+
+  const withHome = value
+    .replace(/\$HOME/g, os.homedir())
+    .replace(/\${HOME}/g, os.homedir());
+
+  if (!withHome.includes('$')) return withHome;
+
+  return withHome.replace(/\$([A-Z0-9_]+)/gi, (_, key) => {
+    return process.env[key] ?? '';
+  });
+}
+
+function resolveConfigValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(resolveConfigValue);
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [key, resolveConfigValue(val)])
+    );
+  }
+  return resolveEnv(value);
+}
+
+function applyDefaults(config) {
+  const defaults = {
+    HOST: '127.0.0.1',
+    PORT: 3456,
+    LOG: true,
+    LOG_LEVEL: 'info',
+    API_TIMEOUT_MS: 300000
+  };
+
+  return {
+    ...defaults,
+    ...config
+  };
+}
+
+function loadConfig() {
+  const configPath = process.env.CCR_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found at ${configPath}`);
+  }
+
+  const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const resolved = resolveConfigValue(raw);
+  return applyDefaults(resolved);
+}
+
+function getConfigPath() {
+  return process.env.CCR_CONFIG_PATH || DEFAULT_CONFIG_PATH;
+}
+
+function getConfigDir() {
+  return process.env.CCR_CONFIG_DIR || DEFAULT_CONFIG_DIR;
+}
+
+function resolveProviderKey(provider) {
+  if (!provider?.api_key) return null;
+  if (typeof provider.api_key === 'string' && provider.api_key.startsWith('$')) {
+    const envKey = provider.api_key.slice(1);
+    return process.env[envKey] || null;
+  }
+  return provider.api_key;
+}
+
+module.exports = {
+  loadConfig,
+  getConfigPath,
+  getConfigDir,
+  resolveProviderKey
+};

package/router/format.js

@@ -0,0 +1,209 @@
+const crypto = require('crypto');
+
+function toText(value) {
+  if (typeof value === 'string') return value;
+  if (value == null) return '';
+  return JSON.stringify(value);
+}
+
+function normalizeAnthropicSystem(system) {
+  if (!system) return '';
+  if (typeof system === 'string') return system;
+  if (Array.isArray(system)) {
+    return system
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (item?.type === 'text') return item.text || '';
+        return toText(item);
+      })
+      .join('\n');
+  }
+  return toText(system);
+}
+
+function anthropicMessagesToOpenAI(messages = []) {
+  return messages.map((message) => {
+    if (typeof message?.content === 'string') {
+      return { role: message.role, content: message.content };
+    }
+    if (Array.isArray(message?.content)) {
+      const text = message.content
+        .map((part) => {
+          if (part?.type === 'text') return part.text || '';
+          return toText(part);
+        })
+        .join('');
+      return { role: message.role, content: text };
+    }
+    return { role: message.role, content: toText(message?.content) };
+  });
+}
+
+function openAIMessagesToAnthropic(messages = []) {
+  return messages
+    .filter((message) => message.role !== 'system')
+    .map((message) => {
+      if (typeof message.content === 'string') {
+        return { role: message.role, content: message.content };
+      }
+      if (Array.isArray(message.content)) {
+        const parts = message.content
+          .map((part) => {
+            if (part?.type === 'text') {
+              return { type: 'text', text: part.text || '' };
+            }
+            return { type: 'text', text: toText(part) };
+          });
+        return { role: message.role, content: parts };
+      }
+      return { role: message.role, content: toText(message.content) };
+    });
+}
+
+function openAIToolsToAnthropic(tools = []) {
+  return tools
+    .map((tool) => {
+      if (tool?.type === 'function' && tool.function) {
+        return {
+          name: tool.function.name,
+          description: tool.function.description || '',
+          input_schema: tool.function.parameters || {}
+        };
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+function anthropicToolsToOpenAI(tools = []) {
+  return tools
+    .map((tool) => {
+      if (!tool?.name) return null;
+      return {
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description || '',
+          parameters: tool.input_schema || {}
+        }
+      };
+    })
+    .filter(Boolean);
+}
+
+function anthropicToOpenAI(body) {
+  const system = normalizeAnthropicSystem(body.system);
+  const messages = anthropicMessagesToOpenAI(body.messages || []);
+  const openAIMessages = system
+    ? [{ role: 'system', content: system }, ...messages]
+    : messages;
+
+  const openai = {
+    model: body.model,
+    messages: openAIMessages,
+    stream: Boolean(body.stream),
+    temperature: body.temperature,
+    max_tokens: body.max_tokens
+  };
+
+  if (body.top_p != null) openai.top_p = body.top_p;
+  if (body.tools) openai.tools = anthropicToolsToOpenAI(body.tools);
+  if (body.tool_choice) openai.tool_choice = body.tool_choice;
+  if (body.metadata) openai.metadata = body.metadata;
+
+  return openai;
+}
+
+function openAIToAnthropic(body) {
+  const systemMessages = (body.messages || []).filter((m) => m.role === 'system');
+  const system = systemMessages.map((m) => toText(m.content)).join('\n');
+  const messages = openAIMessagesToAnthropic(body.messages || []);
+
+  const anthropic = {
+    model: body.model,
+    messages,
+    system: system || undefined,
+    stream: Boolean(body.stream),
+    max_tokens: body.max_tokens,
+    temperature: body.temperature
+  };
+
+  if (body.top_p != null) anthropic.top_p = body.top_p;
+  if (body.tools) anthropic.tools = openAIToolsToAnthropic(body.tools);
+  if (body.tool_choice) anthropic.tool_choice = body.tool_choice;
+  if (body.metadata) anthropic.metadata = body.metadata;
+
+  return anthropic;
+}
+
+function extractOpenAIText(response) {
+  const choice = response?.choices?.[0];
+  if (!choice) return '';
+  if (choice.message?.content) return choice.message.content;
+  if (choice.delta?.content) return choice.delta.content;
+  return '';
+}
+
+function extractAnthropicText(response) {
+  if (!Array.isArray(response?.content)) return toText(response?.content);
+  return response.content
+    .map((part) => (part?.type === 'text' ? part.text || '' : toText(part)))
+    .join('');
+}
+
+function openAIResponseToAnthropic(response, fallbackModel) {
+  const text = extractOpenAIText(response);
+  const id = response?.id || `msg_${crypto.randomUUID()}`;
+  const model = response?.model || fallbackModel;
+  const finish = response?.choices?.[0]?.finish_reason || 'stop';
+
+  return {
+    id,
+    type: 'message',
+    role: 'assistant',
+    model,
+    content: [{ type: 'text', text }],
+    stop_reason: finish,
+    usage: {
+      input_tokens: response?.usage?.prompt_tokens || 0,
+      output_tokens: response?.usage?.completion_tokens || 0
+    }
+  };
+}
+
+function anthropicResponseToOpenAI(response, fallbackModel) {
+  const text = extractAnthropicText(response);
+  const model = response?.model || fallbackModel;
+  const created = Math.floor(Date.now() / 1000);
+  const finish = response?.stop_reason || 'stop';
+  const promptTokens = response?.usage?.input_tokens || 0;
+  const completionTokens = response?.usage?.output_tokens || 0;
+
+  return {
+    id: response?.id || `chatcmpl_${crypto.randomUUID()}`,
+    object: 'chat.completion',
+    created,
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant', content: text },
+        finish_reason: finish
+      }
+    ],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: promptTokens + completionTokens
+    }
+  };
+}
+
+module.exports = {
+  anthropicToOpenAI,
+  openAIToAnthropic,
+  openAIResponseToAnthropic,
+  anthropicResponseToOpenAI,
+  anthropicToolsToOpenAI,
+  openAIToolsToAnthropic
+};

package/router/http.js

@@ -0,0 +1,55 @@
+const { request } = require('undici');
+
+async function readStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function sendJsonRequest({ url, headers, body, timeoutMs }) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await request(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+
+    const rawBody = await readStream(response.body);
+    return {
+      statusCode: response.statusCode,
+      headers: response.headers,
+      rawBody
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function sendStreamRequest({ url, headers, body, timeoutMs }) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  const response = await request(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+    signal: controller.signal
+  });
+
+  response.body.on('end', () => clearTimeout(timeout));
+  response.body.on('error', () => clearTimeout(timeout));
+
+  return response;
+}
+
+module.exports = {
+  sendJsonRequest,
+  sendStreamRequest,
+  readStream
+};

package/router/providers.js

@@ -0,0 +1,53 @@
+const { resolveProviderKey } = require('./config');
+
+function inferProviderFormat(provider) {
+  const name = (provider?.name || '').toLowerCase();
+  const baseUrl = provider?.api_base_url || '';
+  const transformers = provider?.transformer?.use || [];
+
+  if (name === 'anthropic' || name === 'glm') return 'anthropic';
+  if (baseUrl.includes('/v1/messages') || baseUrl.includes('/anthropic')) return 'anthropic';
+  if (transformers.some((t) => t.toLowerCase() === 'anthropic')) return 'anthropic';
+
+  return 'openai';
+}
+
+function resolveAuthHeader(provider, apiKey) {
+  if (!apiKey) return {};
+
+  const name = (provider?.name || '').toLowerCase();
+  const headerName = provider.api_key_header
+    || (name === 'gemini' ? 'x-goog-api-key' : 'authorization');
+  const headerValue = headerName.toLowerCase() === 'authorization'
+    ? `Bearer ${apiKey}`
+    : apiKey;
+
+  return { [headerName]: headerValue };
+}
+
+function buildProviderHeaders(provider) {
+  const apiKey = resolveProviderKey(provider);
+  const headers = {
+    'content-type': 'application/json',
+    ...resolveAuthHeader(provider, apiKey),
+    ...(provider.headers || {})
+  };
+
+  if (inferProviderFormat(provider) === 'anthropic') {
+    headers['anthropic-version'] = headers['anthropic-version'] || '2023-06-01';
+  }
+
+  if ((provider?.name || '').toLowerCase() === 'openrouter') {
+    const referer = provider.referer || process.env.OPENROUTER_REFERRER;
+    const title = provider.app_name || process.env.OPENROUTER_APP_NAME;
+    if (referer) headers['http-referer'] = referer;
+    if (title) headers['x-title'] = title;
+  }
+
+  return { headers, apiKey };
+}
+
+module.exports = {
+  inferProviderFormat,
+  buildProviderHeaders
+};

package/router/route.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+
+function estimateTokens(messages = [], system) {
+  const systemText = Array.isArray(system)
+    ? system.map((s) => (typeof s === 'string' ? s : s?.text || '')).join(' ')
+    : (system || '');
+  const messageText = (messages || [])
+    .map((m) => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')))
+    .join(' ');
+  const text = `${systemText} ${messageText}`;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+
+function parseExplicitRoute(model) {
+  if (!model || !model.includes(',')) return null;
+  const [provider, ...rest] = model.split(',');
+  const modelName = rest.join(',');
+  return provider && modelName ? { provider, model: modelName } : null;
+}
+
+function extractSubagentModel(system) {
+  const systemText = Array.isArray(system)
+    ? system.map((item) => (item?.text ? item.text : '')).join(' ')
+    : (system || '');
+  const match = systemText.match(/<CCR-SUBAGENT-MODEL>(.*?)<\/CCR-SUBAGENT-MODEL>/s);
+  return match ? match[1].trim() : null;
+}
+
+function loadCustomRouter(routerPath) {
+  try {
+    if (!routerPath) return null;
+    if (!fs.existsSync(routerPath)) return null;
+    delete require.cache[require.resolve(routerPath)];
+    return require(routerPath);
+  } catch {
+    return null;
+  }
+}
+
+async function resolveRoute(req, config) {
+  if (!req?.body) return config.Router?.default || null;
+
+  const explicit = parseExplicitRoute(req.body.model);
+  if (explicit) {
+    return `${explicit.provider},${explicit.model}`;
+  }
+
+  const tokenCount = estimateTokens(req.body.messages || [], req.body.system);
+  req.tokenCount = tokenCount;
+
+  const subagentModel = extractSubagentModel(req.body.system);
+  if (subagentModel) {
+    return subagentModel;
+  }
+
+  const customRouter = loadCustomRouter(config.CUSTOM_ROUTER_PATH);
+  if (customRouter) {
+    try {
+      const route = await customRouter(req, config);
+      if (route) return route;
+    } catch {
+      // Fall through to defaults
+    }
+  }
+
+  const routerConfig = config.Router || {};
+  const longContextThreshold = routerConfig.longContextThreshold || 60000;
+  if (tokenCount > longContextThreshold && routerConfig.longContext) {
+    return routerConfig.longContext;
+  }
+
+  if (req.body.thinking && routerConfig.think) {
+    return routerConfig.think;
+  }
+
+  if (Array.isArray(req.body.tools) && req.body.tools.some((tool) => {
+    return typeof tool?.type === 'string' && tool.type.startsWith('web_search');
+  }) && routerConfig.webSearch) {
+    return routerConfig.webSearch;
+  }
+
+  if (req.body.model?.includes('haiku') && routerConfig.background) {
+    return routerConfig.background;
+  }
+
+  return routerConfig.default || null;
+}
+
+module.exports = {
+  resolveRoute,
+  parseExplicitRoute,
+  estimateTokens
+};