krasavacode 0.3.5 → 0.4.0

package/bin/krasavacode.js

@@ -5,18 +5,18 @@ import { ensurePreset } from '../src/preset.js';
 import { launchClaude } from '../src/launch.js';
 import { runUpgrade } from '../src/upgrade.js';
 import { runDoctor } from '../src/doctor.js';
-import { runSetupGemini } from '../src/setup-gemini.js';
+import { runSetup } from '../src/setup.js';
 
 // Hardcoded so it works inside Bun --compile (no FS access to package.json)
-const VERSION = '0.3.5';
+const VERSION = '0.4.0';
 
 const cmd = process.argv[2];
 
 async function main() {
   if (cmd === 'doctor') return runDoctor();
   if (cmd === 'upgrade') return runUpgrade();
-  if (cmd === 'setup-gemini' || cmd === 'gemini') {
-    const result = await runSetupGemini();
+  if (cmd === 'setup' || cmd === 'setup-gemini' || cmd === 'gemini') {
+    const result = await runSetup();
     if (!result?.launchAfter) return;
     // fall through to normal launch flow below
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "krasavacode",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "KRASAVACODE — однокнопочный бесплатный вайбкодинг для учеников. Claude Code на бесплатных провайдерах через локальный gateway. Сам ставит Node при необходимости.",
   "type": "module",
   "bin": {

package/src/cooldowns.js

@@ -0,0 +1,54 @@
+/**
+ * Per-provider cooldown tracking.
+ *
+ * When a provider returns 429, metrics-proxy stamps a cooldown until X.
+ * - per-minute rate limit (RPM): 60 sec cooldown
+ * - per-day quota (RPD/TPD):     until 11:00 МСК next day (~daily reset)
+ *
+ * The custom router (~/.krasavacode/router.js) reads this file on every
+ * request and skips providers whose cooldown is still in the future.
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const ROOT = join(homedir(), '.krasavacode');
+const COOLDOWN_FILE = join(ROOT, 'cooldowns.json');
+
+export async function getCooldowns() {
+  try { return JSON.parse(await readFile(COOLDOWN_FILE, 'utf8')); }
+  catch { return {}; }
+}
+
+export async function setCooldown(providerId, until) {
+  await mkdir(ROOT, { recursive: true });
+  const cd = await getCooldowns();
+  cd[providerId] = until.toISOString();
+  cd._lastUpdated = new Date().toISOString();
+  await writeFile(COOLDOWN_FILE, JSON.stringify(cd, null, 2));
+}
+
+export async function clearCooldown(providerId) {
+  const cd = await getCooldowns();
+  delete cd[providerId];
+  await writeFile(COOLDOWN_FILE, JSON.stringify(cd, null, 2));
+}
+
+export async function isOnCooldown(providerId) {
+  const cd = await getCooldowns();
+  if (!cd[providerId]) return false;
+  return new Date(cd[providerId]).getTime() > Date.now();
+}
+
+/** Compute when to lift cooldown based on the 429 reason. */
+export function cooldownUntil(reason) {
+  if (reason === 'per-minute') {
+    return new Date(Date.now() + 60_000);
+  }
+  // per-day or unknown — until 11:00 MSK tomorrow (≈ midnight Pacific reset)
+  const next = new Date();
+  next.setUTCHours(8, 0, 0, 0); // 11:00 MSK == 08:00 UTC
+  if (next.getTime() < Date.now()) next.setUTCDate(next.getUTCDate() + 1);
+  return next;
+}

package/src/doctor.js

@@ -3,6 +3,8 @@ import { homedir, platform, arch, totalmem } from 'node:os';
 import { join } from 'node:path';
 import { access, readFile } from 'node:fs/promises';
 import net from 'node:net';
+import { configuredProviders, PROVIDERS } from './providers.js';
+import { getCooldowns } from './cooldowns.js';
 
 const ROOT = join(homedir(), '.krasavacode');
 
@@ -63,6 +65,23 @@ export async function runDoctor() {
   check('3456 (claude-code-router)', await checkPort(3456), 'свободен или используется ccr');
   check('20128 (omniroute upgrade)', await checkPort(20128));
 
+  console.log('\nПровайдеры:');
+  const cfg = await configuredProviders();
+  const cd = await getCooldowns();
+  if (cfg.length === 0) {
+    console.log('  пусто (используется Pollinations gpt-oss-20b — слабая модель)');
+    console.log('  → krasavacode setup для подключения Cerebras / Groq / Gemini');
+  } else {
+    let i = 1;
+    for (const id of cfg) {
+      const p = PROVIDERS[id];
+      const onCD = cd[id] && new Date(cd[id]).getTime() > Date.now();
+      const status = onCD ? `⏳ cooldown до ${new Date(cd[id]).toLocaleString('ru')}` : '✓ готов';
+      console.log(`  ${i++}. ${p.name} — ${status}`);
+    }
+    console.log(`  ${i}. Pollinations (последний резерв)`);
+  }
+
   console.log('\nState:');
   try {
     const state = JSON.parse(await readFile(join(ROOT, 'state.json'), 'utf8'));

package/src/hub.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { CCR_PORT } from './preset.js';
-import { loadGeminiKey } from './setup-gemini.js';
+import { configuredProviders, loadProviderKey, getProviderEnvVarName } from './providers.js';
 import { startMetricsProxy } from './metrics-proxy.js';
 
 const HOST = '127.0.0.1';
@@ -40,11 +40,13 @@ export async function startHub(paths) {
 
   process.stdout.write(`🚀 Поднимаю локальный gateway на порту ${PORT}… `);
 
-  // Inject GEMINI_API_KEY into ccr env if user has configured Gemini.
-  // ccr's config.json references it as $GEMINI_API_KEY (env-interpolation).
+  // Inject every configured provider's API key as env var so that ccr's
+  // config.json can reference them via interpolation ($CEREBRAS_API_KEY etc).
   const ccrEnv = { ...paths.env };
-  const geminiKey = await loadGeminiKey();
-  if (geminiKey) ccrEnv.GEMINI_API_KEY = geminiKey;
+  for (const id of await configuredProviders()) {
+    const key = await loadProviderKey(id);
+    if (key) ccrEnv[getProviderEnvVarName(id)] = key;
+  }
 
   const child = spawn(paths.ccrBin, ['start'], {
     stdio: process.env.KRASAVACODE_DEBUG ? 'inherit' : 'pipe',

package/src/launch.js

@@ -2,14 +2,15 @@ import { spawn } from 'node:child_process';
 import { mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { isGeminiConfigured } from './setup-gemini.js';
-import { getQuotaInfo } from './metrics-proxy.js';
+import { configuredProviders, PROVIDERS } from './providers.js';
+import { getCooldowns } from './cooldowns.js';
 
 const PLACEHOLDER_TOKEN = 'sk-krasavacode-local';
 const CLAUDE_CONFIG_DIR = join(homedir(), '.krasavacode', 'claude-config');
 
 export async function launchClaude(paths, hub /*, detection */) {
-  const geminiOn = await isGeminiConfigured();
+  const configured = await configuredProviders();
+  const cooldowns = await getCooldowns();
   // Isolate Claude Code's config/credentials from any real Anthropic login
   // the student may have on this machine (~/.claude/). This is the *only*
   // way to suppress the "Welcome back, NAME · publerplatforma@gmail.com's
@@ -47,7 +48,7 @@ export async function launchClaude(paths, hub /*, detection */) {
   // Set KRASAVACODE_BARE=0 to disable for debugging.
   const useBare = process.env.KRASAVACODE_BARE !== '0';
   const passthroughArgs = process.argv.slice(2)
-    .filter(a => !['doctor', 'upgrade', 'setup-gemini', 'gemini'].includes(a));
+    .filter(a => !['doctor', 'upgrade', 'setup', 'setup-gemini', 'gemini'].includes(a));
   if (useBare && !passthroughArgs.includes('--bare')) passthroughArgs.unshift('--bare');
 
   const W = 64;
@@ -55,28 +56,26 @@ export async function launchClaude(paths, hub /*, detection */) {
     const pad = Math.max(0, W - 2 - [...txt].length);
     return '┃ ' + txt + ' '.repeat(pad) + '┃';
   };
-  const quota = await getQuotaInfo();
   console.log('');
   console.log('┏' + '━'.repeat(W - 1) + '┓');
   console.log(line('  K R A S A V A C O D E'));
   console.log(line('  Бесплатный вайбкодинг через локальный hub'));
   console.log('┣' + '━'.repeat(W - 1) + '┫');
-  if (geminiOn) {
-    console.log(line('  ✓ Модель: Google Gemini 2.5 Flash'));
-    const left = quota.perDay - quota.used;
-    if (left > 100) {
-      console.log(line(`    Сегодня осталось: ${left} из ${quota.perDay} запросов`));
-    } else if (left > 0) {
-      console.log(line(`  ⚠️  Осталось ${left} из ${quota.perDay} — обнулится завтра`));
-    } else {
-      console.log(line(`  ❌ Лимит на сегодня исчерпан (${quota.used} из ${quota.perDay})`));
-      console.log(line(`     Обнулится в ~21:00 МСК`));
-    }
+  if (configured.length === 0) {
+    console.log(line('  · Pollinations (gpt-oss-20b, без квот, слабая модель)'));
+    console.log(line('  💡 Лучше модель бесплатно: krasavacode setup'));
   } else {
-    console.log(line('  · Модель: gpt-oss-20b через Pollinations'));
-    console.log(line('    (бесплатно, без логина)'));
-    console.log(line(`    Сегодня сделал ${quota.used} запросов`));
-    console.log(line('  💡 Лучше модель: krasavacode setup-gemini'));
+    console.log(line('  Активная цепочка фолбэков:'));
+    let i = 1;
+    for (const id of configured) {
+      const p = PROVIDERS[id];
+      const cd = cooldowns[id];
+      const onCooldown = cd && new Date(cd).getTime() > Date.now();
+      const tag = onCooldown ? '⏳ на cooldown' : '✓ готов';
+      console.log(line(`    ${i++}. ${p.name} — ${tag}`));
+    }
+    console.log(line(`    ${i}. Pollinations (последний резерв)`));
+    console.log(line('  При 429 — автоматически прыгает на следующий'));
   }
   console.log('┗' + '━'.repeat(W - 1) + '┛');
   console.log('');

package/src/metrics-proxy.js

@@ -1,38 +1,33 @@
 import http from 'node:http';
 import net from 'node:net';
-import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { isGeminiConfigured } from './setup-gemini.js';
+import { configuredProviders, PROVIDERS, PROVIDER_PRIORITY } from './providers.js';
+import { setCooldown, getCooldowns, cooldownUntil } from './cooldowns.js';
 
 const ROOT = join(homedir(), '.krasavacode');
 const USAGE_FILE = join(ROOT, 'usage.json');
 
-const FREE_QUOTA = {
-  gemini: { perDay: 1500, label: 'Google Gemini 2.5 Flash (free tier)' },
-  pollinations: { perDay: null, label: 'Pollinations (free)' },
-};
-
-function todayKey() {
-  return new Date().toISOString().slice(0, 10);
-}
+function todayKey() { return new Date().toISOString().slice(0, 10); }
 
 async function readUsage() {
   try { return JSON.parse(await readFile(USAGE_FILE, 'utf8')); }
   catch { return {}; }
 }
-
 async function writeUsage(u) {
   await mkdir(ROOT, { recursive: true });
   await writeFile(USAGE_FILE, JSON.stringify(u, null, 2));
 }
 
-async function bump() {
+async function bump(providerId) {
   const u = await readUsage();
   const day = todayKey();
-  u[day] = (u[day] || 0) + 1;
+  if (!u[day]) u[day] = {};
+  if (typeof u[day] === 'number') u[day] = { _total: u[day] };
+  u[day][providerId || '_unknown'] = (u[day][providerId || '_unknown'] || 0) + 1;
+  u[day]._total = (u[day]._total || 0) + 1;
   u.lastRequestAt = new Date().toISOString();
-  // keep only last 30 days
   for (const k of Object.keys(u)) {
     if (/^\d{4}-\d{2}-\d{2}$/.test(k)) {
       const age = (Date.now() - new Date(k).getTime()) / 86400000;
@@ -44,14 +39,10 @@ async function bump() {
 
 export async function getTodayUsage() {
   const u = await readUsage();
-  return u[todayKey()] || 0;
-}
-
-export async function getQuotaInfo() {
-  const provider = (await isGeminiConfigured()) ? 'gemini' : 'pollinations';
-  const used = await getTodayUsage();
-  const { perDay, label } = FREE_QUOTA[provider];
-  return { provider, used, perDay, label, remaining: perDay ? Math.max(0, perDay - used) : null };
+  const today = u[todayKey()];
+  if (!today) return 0;
+  if (typeof today === 'number') return today;
+  return today._total || 0;
 }
 
 function getFreePort() {
@@ -66,82 +57,178 @@ function getFreePort() {
   });
 }
 
-const FRIENDLY_429 = (provider, used) => ({
+/** Pick the first available provider not on cooldown, in priority order. */
+async function chooseProvider() {
+  const cd = await getCooldowns();
+  const configured = await configuredProviders();
+  const now = Date.now();
+  const onCooldown = (id) => cd[id] && new Date(cd[id]).getTime() > now;
+
+  for (const id of configured) {
+    if (!onCooldown(id)) return { id, model: PROVIDERS[id].defaultModel };
+  }
+  // All custom providers exhausted — fall back to Pollinations
+  if (!onCooldown('pollinations')) return { id: 'pollinations', model: 'openai' };
+  return null;
+}
+
+function parseQuotaReason(upstreamBody) {
+  try {
+    const parsed = JSON.parse(upstreamBody);
+    const violations = parsed.error?.details?.find(d => d['@type']?.includes('QuotaFailure'))?.violations;
+    if (violations?.length) {
+      const id = violations[0].quotaId || violations[0].quotaMetric || '';
+      if (/PerMinute/i.test(id)) return 'per-minute';
+      return 'per-day';
+    }
+    const msg = String(parsed.error?.message || '').toLowerCase();
+    if (msg.includes('per minute') || msg.includes('per-minute') || msg.includes('rpm')) return 'per-minute';
+    if (msg.includes('per day') || msg.includes('per-day') || msg.includes('rpd') || msg.includes('quota')) return 'per-day';
+  } catch {}
+  return null;
+}
+
+const FRIENDLY_429 = () => ({
   type: 'error',
   error: {
     type: 'rate_limit_error',
     message:
-      provider === 'gemini'
-        ? `Закончились бесплатные запросы Google Gemini на сегодня (использовано ${used} из 1500).\n\n` +
-          `Квота обнулится в ~10:00 PT (~21:00 МСК).\n\n` +
-          `Что делать сейчас:\n` +
-          `  • Подожди до завтра, и продолжи\n` +
-          `  • Или подключи второй Google-аккаунт через krasavacode setup-gemini\n` +
-          `  • Или временно вернись на Pollinations: удали ~/.krasavacode/gemini.env`
-        : `Pollinations на минуту перегружен. Подожди ~30 секунд и нажми Enter ещё раз.\n` +
-          `Или подключи Gemini для стабильности: krasavacode setup-gemini`,
+      `Все настроенные AI-провайдеры исчерпаны или временно перегружены.\n\n` +
+      `Что делать:\n` +
+      `  • Подожди 1–2 минуты (если упёрлись в RPM) и попробуй опять\n` +
+      `  • Подключи ещё провайдер: krasavacode setup\n` +
+      `  • Дневные лимиты обновляются в ~11:00 МСК`,
   },
 });
 
-/**
- * Proxy: Claude Code → metrics-proxy (this) → ccr → upstream.
- *
- * - Counts every successful POST /v1/messages as one request, written to ~/.krasavacode/usage.json
- * - Replaces 429 responses with a friendly Russian message
- * - Streams everything else through unmodified (so SSE works)
- */
+function rewriteBodyWithProvider(originalBody, providerId, modelName) {
+  // claude-code-router treats body.model in form "provider,modelName" as a
+  // direct route, bypassing Router config. We use that to fully control
+  // provider selection from the proxy layer.
+  try {
+    const parsed = JSON.parse(originalBody);
+    parsed.model = `${providerId},${modelName}`;
+    return Buffer.from(JSON.stringify(parsed));
+  } catch {
+    return originalBody;
+  }
+}
+
+function forward(upstream, method, path, headers, bodyBuffer) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      hostname: upstream.hostname,
+      port: upstream.port,
+      path,
+      method,
+      headers: {
+        ...headers,
+        host: `${upstream.hostname}:${upstream.port}`,
+        'content-length': bodyBuffer ? bodyBuffer.length : 0,
+      },
+    }, (res) => resolve(res));
+    req.on('error', reject);
+    if (bodyBuffer && bodyBuffer.length) req.write(bodyBuffer);
+    req.end();
+  });
+}
+
 export async function startMetricsProxy(upstreamBaseUrl) {
   const upstream = new URL(upstreamBaseUrl);
   const port = await getFreePort();
-
   const debug = process.env.KRASAVACODE_DEBUG === '1';
-  const server = http.createServer((req, res) => {
+
+  const server = http.createServer(async (req, res) => {
     const path = (req.url || '').split('?')[0];
     const isMessages = req.method === 'POST' && path === '/v1/messages';
     if (debug) console.error(`[metrics] ${req.method} ${req.url}`);
 
-    const proxyReq = http.request({
-      hostname: upstream.hostname,
-      port: upstream.port,
-      path: req.url,
-      method: req.method,
-      headers: req.headers,
-    }, async (upRes) => {
-      if (debug) console.error(`[metrics] ← ${upRes.statusCode} ${req.url}`);
-      // Treat any 2xx on /v1/messages as one billable request — count immediately.
-      if (isMessages && upRes.statusCode >= 200 && upRes.statusCode < 300) {
-        bump().catch(e => debug && console.error('[metrics] bump fail', e));
-      }
-
-      // 429: try to replace body with a friendly message (non-streaming).
-      // If body is streaming/SSE we still let it through — Claude Code shows it.
-      if (upRes.statusCode === 429 && !/text\/event-stream/.test(upRes.headers['content-type'] || '')) {
-        const used = await getTodayUsage();
-        const provider = (await isGeminiConfigured()) ? 'gemini' : 'pollinations';
-        const body = JSON.stringify(FRIENDLY_429(provider, used));
-        const headers = { ...upRes.headers, 'content-type': 'application/json' };
-        delete headers['content-length'];
-        delete headers['content-encoding'];
-        res.writeHead(429, headers);
-        upRes.resume(); // drain the original
-        res.end(body);
+    const chunks = [];
+    req.on('data', d => chunks.push(d));
+    req.on('end', async () => {
+      const originalBody = Buffer.concat(chunks);
+
+      if (!isMessages) {
+        try {
+          const upRes = await forward(upstream, req.method, req.url, req.headers, originalBody);
+          res.writeHead(upRes.statusCode, upRes.headers);
+          upRes.pipe(res);
+        } catch (e) {
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { type: 'upstream_error', message: e.message } }));
+        }
         return;
       }
 
-      res.writeHead(upRes.statusCode, upRes.headers);
-      upRes.pipe(res);
-    });
+      // /v1/messages: provider selection with retry-on-429
+      for (let attempt = 1; attempt <= 4; attempt++) {
+        const choice = await chooseProvider();
+        if (!choice) {
+          if (debug) console.error('[metrics] all providers on cooldown');
+          res.writeHead(429, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(FRIENDLY_429()));
+          return;
+        }
+
+        const rewrittenBody = rewriteBodyWithProvider(originalBody, choice.id, choice.model);
+        if (debug) console.error(`[metrics] attempt ${attempt}: routing to ${choice.id},${choice.model}`);
+
+        let upRes;
+        try {
+          upRes = await forward(upstream, req.method, req.url, req.headers, rewrittenBody);
+        } catch (e) {
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: { type: 'upstream_error', message: e.message } }));
+          return;
+        }
+
+        if (debug) console.error(`[metrics] attempt ${attempt} → ${upRes.statusCode}`);
+
+        if (upRes.statusCode !== 429) {
+          if (upRes.statusCode >= 200 && upRes.statusCode < 300) {
+            bump(choice.id).catch(() => {});
+          }
+          res.writeHead(upRes.statusCode, upRes.headers);
+          upRes.pipe(res);
+          return;
+        }
+
+        // 429 — buffer body, set cooldown for THIS provider, retry with next
+        const errChunks = [];
+        upRes.on('data', d => errChunks.push(d));
+        await new Promise(r => upRes.on('end', r));
+        const upBody = Buffer.concat(errChunks).toString('utf8');
+        if (debug) console.error(`[metrics] 429 from ${choice.id}: ${upBody.slice(0, 200)}`);
+
+        const reason = parseQuotaReason(upBody);
+        // Pollinations has no daily quota — only short burst-throttling.
+        // Treat its 429 as a 60s cooldown so we don't block it until tomorrow.
+        const effectiveReason = choice.id === 'pollinations' ? 'per-minute' : reason;
+        await setCooldown(choice.id, cooldownUntil(effectiveReason));
+        // loop continues — next iteration picks a different provider
+      }
 
-    proxyReq.on('error', (err) => {
-      res.writeHead(502, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: { type: 'upstream_error', message: err.message } }));
+      // Exhausted attempts
+      res.writeHead(429, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(FRIENDLY_429()));
     });
 
-    req.pipe(proxyReq);
+    req.on('error', () => {});
   });
 
   await new Promise(r => server.listen(port, '127.0.0.1', r));
+  return {
+    server,
+    port,
+    baseUrl: `http://127.0.0.1:${port}`,
+    stop: () => new Promise(r => server.close(r)),
+  };
+}
 
-  const baseUrl = `http://127.0.0.1:${port}`;
-  return { server, port, baseUrl, stop: () => new Promise(r => server.close(r)) };
+export async function getQuotaInfo() {
+  return {
+    used: await getTodayUsage(),
+    configured: await configuredProviders(),
+    cooldowns: await getCooldowns(),
+  };
 }

package/src/preset.js

@@ -1,85 +1,62 @@
 import { mkdir, readFile, writeFile, copyFile, access } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { isGeminiConfigured } from './setup-gemini.js';
+import { PROVIDERS, configuredProviders, pollinationsProvider } from './providers.js';
 
+const ROOT = join(homedir(), '.krasavacode');
 const CCR_DIR = join(homedir(), '.claude-code-router');
 const CCR_CONFIG = join(CCR_DIR, 'config.json');
-const STATE_FILE = join(homedir(), '.krasavacode', 'state.json');
+const STATE_FILE = join(ROOT, 'state.json');
 
 const KRASAVACODE_MARKER = 'krasavacode/managed';
 
-function pollinationsProvider() {
-  return {
-    name: 'pollinations',
-    api_base_url: 'https://text.pollinations.ai/openai/chat/completions',
-    api_key: 'public',
-    models: ['openai', 'openai-fast', 'gpt-oss-20b'],
-  };
-}
-
-function geminiProvider() {
-  // gemini-2.5-pro free tier = 0 requests; only flash is actually free.
-  return {
-    name: 'gemini',
-    api_base_url: 'https://generativelanguage.googleapis.com/v1beta/models/',
-    api_key: '$GEMINI_API_KEY',
-    models: ['gemini-2.5-flash', 'gemini-flash-latest'],
-    transformer: { use: ['gemini'] },
-  };
-}
+async function readState() { try { return JSON.parse(await readFile(STATE_FILE, 'utf8')); } catch { return {}; } }
+async function writeState(s) { await writeFile(STATE_FILE, JSON.stringify(s, null, 2)); }
+async function exists(p) { return access(p).then(() => true).catch(() => false); }
 
-function buildConfig({ withGemini }) {
-  const Providers = withGemini
-    ? [geminiProvider(), pollinationsProvider()]
-    : [pollinationsProvider()];
+async function buildConfig() {
+  const configured = await configuredProviders();
+  const providers = configured.map(id => PROVIDERS[id].ccrProvider());
+  // Pollinations always last — final no-key fallback
+  providers.push(pollinationsProvider());
 
-  const Router = withGemini
-    ? {
-        default: 'gemini,gemini-2.5-flash',
-        background: 'gemini,gemini-2.5-flash',
-        think: 'gemini,gemini-2.5-flash',
-        longContext: 'gemini,gemini-2.5-flash',
-        longContextThreshold: 60000,
-      }
-    : {
-        default: 'pollinations,openai',
-        background: 'pollinations,openai-fast',
-        think: 'pollinations,openai',
-        longContext: 'pollinations,openai',
-        longContextThreshold: 60000,
-      };
+  const firstId = configured[0];
+  const firstModel = firstId ? PROVIDERS[firstId].defaultModel : 'openai';
+  const firstProv = firstId ? firstId : 'pollinations';
 
-  return {
+  const config = {
     HOST: '127.0.0.1',
     PORT: 3456,
     LOG: false,
     API_TIMEOUT_MS: 600000,
-    Providers,
-    Router,
+    Providers: providers,
+    Router: {
+      // Static fallback if custom-router returns null
+      default:     `${firstProv},${firstModel}`,
+      background:  `${firstProv},${firstModel}`,
+      think:       `${firstProv},${firstModel}`,
+      longContext: `${firstProv},${firstModel}`,
+      longContextThreshold: 60000,
+    },
     _krasavacode: KRASAVACODE_MARKER,
   };
-}
 
-async function readState() {
-  try { return JSON.parse(await readFile(STATE_FILE, 'utf8')); }
-  catch { return {}; }
+  // No custom router: provider selection is done at the metrics-proxy layer,
+  // which rewrites body.model = "provider,name" so ccr forwards directly.
+  return config;
 }
-async function writeState(s) { await writeFile(STATE_FILE, JSON.stringify(s, null, 2)); }
-async function exists(p) { return access(p).then(() => true).catch(() => false); }
 
 /**
- * Generates ~/.claude-code-router/config.json:
- *   - If user has run setup-gemini → Gemini first, Pollinations as fallback Provider
- *   - Else → Pollinations only
- *
- * Returns { withGemini: boolean }.
+ * Generates ~/.claude-code-router/config.json AND the custom router file
+ * ~/.krasavacode/router.js. Backs up any pre-existing user config that
+ * isn't ours.
  */
 export async function ensurePreset() {
+  await mkdir(ROOT, { recursive: true });
   await mkdir(CCR_DIR, { recursive: true });
+
   const state = await readState();
-  const withGemini = await isGeminiConfigured();
-  const config = buildConfig({ withGemini });
+  const config = await buildConfig();
 
   if (await exists(CCR_CONFIG)) {
     let existing;
@@ -93,12 +70,12 @@ export async function ensurePreset() {
       await copyFile(CCR_CONFIG, backupPath);
       state.userConfigBackedUp = backupPath;
       await writeState(state);
-      console.log(`💾 Найден свой config.json у claude-code-router — сохранил резервную копию: ${backupPath}`);
+      console.log(`💾 Найден свой config.json у claude-code-router — резервная копия: ${backupPath}`);
     }
   }
 
   await writeFile(CCR_CONFIG, JSON.stringify(config, null, 2));
-  return { withGemini };
+  return { configured: await configuredProviders() };
 }
 
 export const CCR_PORT = 3456;