krasavacode 0.3.6 → 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.6';
+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.6",
+  "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,30 +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;
-    const warn = Math.floor(quota.perDay / 5); // 20%
-    if (left > warn) {
-      console.log(line(`    Сегодня осталось: ${left} из ${quota.perDay} запросов`));
-    } else if (left > 0) {
-      console.log(line(`  ⚠️  Осталось ${left} из ${quota.perDay} — обнулится в ~11:00 МСК`));
-    } else {
-      console.log(line(`  ❌ Лимит на сегодня исчерпан (${quota.used} из ${quota.perDay})`));
-      console.log(line(`     Обнулится в ~11:00 МСК. krasavacode setup-gemini`));
-    }
-    console.log(line('    1 твой вопрос ≈ 3–10 запросов (Claude использует tools)'));
+  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,40 +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');
 
-// Google free tier (2026): https://ai.google.dev/gemini-api/docs/rate-limits
-//   Gemini 2.5 Flash free: 10 RPM, 250k TPM, 250 RPD (request-per-day).
-const FREE_QUOTA = {
-  gemini: { perDay: 250, rpm: 10, 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;
@@ -46,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() {
@@ -68,125 +57,178 @@ function getFreePort() {
   });
 }
 
-function formatGeminiQuotaReason(upstreamBody) {
-  // Google's 429 body looks like:
-  //   { "error": { "code": 429, "message": "...",
-  //     "details": [{"@type": ".../QuotaFailure",
-  //                  "violations": [{"quotaMetric":"...generate_content_free_tier_requests",
-  //                                  "quotaId":"...PerDay..."}]}] }}
+/** 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 === 0) return null;
-
-    const v = violations[0];
-    const id = v.quotaId || v.quotaMetric || '';
-    const isPerMinute = /PerMinute/i.test(id);
-    const isPerDay = /PerDay/i.test(id);
-    const isTokens = /Token|input_token|output_token/i.test(id);
-
-    if (isPerMinute) return 'Слишком много запросов в минуту (лимит — 10 запросов/мин). Подожди 30–60 секунд и продолжай.';
-    if (isPerDay && isTokens) return 'Закончился дневной лимит входных токенов Gemini (≈250k/день).';
-    if (isPerDay) return 'Закончилась дневная квота запросов к Gemini (≈250 запросов/день для 2.5-flash).';
-    return `Google Gemini ограничил запрос: ${id}`;
-  } catch { return null; }
+    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 = (provider, used, upstreamBody) => {
-  if (provider === 'gemini') {
-    const reason = formatGeminiQuotaReason(upstreamBody) ||
-      `Google ограничил запрос (использовано ${used} запросов сегодня через нас).`;
-    return {
-      type: 'error',
-      error: {
-        type: 'rate_limit_error',
-        message:
-          `${reason}\n\n` +
-          `Квоты обнуляются в полночь по тихоокеанскому времени (≈11:00 МСК).\n` +
-          `На один твой вопрос Claude Code делает 3–10 запросов (читает файлы, использует инструменты),\n` +
-          `поэтому реальный счёт у Google быстрее, чем в нашем счётчике.\n\n` +
-          `Что делать:\n` +
-          `  • Подожди минуту (если упёрлись в RPM) или до завтра (если в дневной)\n` +
-          `  • Подключи второй Google-аккаунт: krasavacode setup-gemini\n` +
-          `  • Временно вернись на Pollinations (без квот): удали ~/.krasavacode/gemini.env`,
-      },
-    };
+const FRIENDLY_429 = () => ({
+  type: 'error',
+  error: {
+    type: 'rate_limit_error',
+    message:
+      `Все настроенные AI-провайдеры исчерпаны или временно перегружены.\n\n` +
+      `Что делать:\n` +
+      `  • Подожди 1–2 минуты (если упёрлись в RPM) и попробуй опять\n` +
+      `  • Подключи ещё провайдер: krasavacode setup\n` +
+      `  • Дневные лимиты обновляются в ~11:00 МСК`,
+  },
+});
+
+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;
   }
-  return {
-    type: 'error',
-    error: {
-      type: 'rate_limit_error',
-      message:
-        `Pollinations на минуту перегружен. Подожди ~30 секунд и попробуй ещё раз.\n` +
-        `Или подключи Gemini: krasavacode setup-gemini`,
-    },
-  };
-};
-
-/**
- * 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 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: replace body with a friendly Russian message that includes
-      // a parsed reason from Google's QuotaFailure details.
-      if (upRes.statusCode === 429 && !/text\/event-stream/.test(upRes.headers['content-type'] || '')) {
-        const used = await getTodayUsage();
-        const provider = (await isGeminiConfigured()) ? 'gemini' : 'pollinations';
-        const chunks = [];
-        upRes.on('data', d => chunks.push(d));
-        upRes.on('end', () => {
-          const upstreamBody = Buffer.concat(chunks).toString('utf8');
-          if (debug) console.error('[metrics] 429 upstream body:', upstreamBody.slice(0, 500));
-          const friendly = JSON.stringify(FRIENDLY_429(provider, used, upstreamBody));
-          const headers = { ...upRes.headers, 'content-type': 'application/json' };
-          delete headers['content-length'];
-          delete headers['content-encoding'];
-          res.writeHead(429, headers);
-          res.end(friendly);
-        });
+    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(),
+  };
 }