kingkont 0.2.0

package/server.js

@@ -0,0 +1,427 @@
+// Локальный Node.js сервер: статика + прокси к KIE / ElevenLabs.
+// Запуск: node server.js (требуется Node 18+)
+const { createServer } = require('node:http');
+const { readFile, stat } = require('node:fs/promises');
+const { readFileSync, existsSync } = require('node:fs');
+const { extname, join, normalize, resolve } = require('node:path');
+
+// ---------- .env loader (без зависимостей) ----------
+function loadEnv() {
+  const path = resolve(__dirname, '.env');
+  if (!existsSync(path)) return;
+  for (const raw of readFileSync(path, 'utf-8').split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let val = line.slice(eq + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
+    if (!(key in process.env)) process.env[key] = val;
+  }
+}
+loadEnv();
+
+const PORT = parseInt(process.env.PORT || '8000', 10);
+const KIE_BASE = 'https://api.kie.ai';
+const ELEVEN_BASE = 'https://api.elevenlabs.io';
+const ROOT = __dirname;
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.css':  'text/css; charset=utf-8',
+  '.js':   'application/javascript; charset=utf-8',
+  '.mjs':  'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.svg':  'image/svg+xml',
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif':  'image/gif',
+  '.webp': 'image/webp',
+  '.ico':  'image/x-icon',
+  '.wasm': 'application/wasm',
+};
+
+// ---------- helpers ----------
+function send(res, status, body, headers = {}) {
+  const isStr = typeof body === 'string';
+  res.writeHead(status, {
+    'Content-Type': isStr ? 'text/plain; charset=utf-8' : 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+    ...headers,
+  });
+  res.end(isStr ? body : JSON.stringify(body));
+}
+
+async function readBody(req) {
+  const chunks = [];
+  for await (const c of req) chunks.push(c);
+  return Buffer.concat(chunks);
+}
+async function readJson(req) {
+  const buf = await readBody(req);
+  return buf.length ? JSON.parse(buf.toString('utf-8')) : {};
+}
+
+async function kieFetch(path, options = {}) {
+  const key = process.env.KIE_API_KEY;
+  if (!key) throw new Error('KIE_API_KEY не задан в .env');
+  const r = await fetch(KIE_BASE + path, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${key}`,
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+  });
+  const text = await r.text();
+  let data;
+  try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!r.ok) throw new Error(`KIE ${r.status}: ${(data.msg || text).slice(0, 300)}`);
+  if (data.code && data.code !== 200) throw new Error(`KIE: ${data.msg || 'unknown error'}`);
+  return data;
+}
+
+// Модели KIE: ключ → реальный model id
+const IMAGE_MODELS = {
+  'nano-banana-2':   'nano-banana-2',
+  'grok':            'grok-imagine/text-to-image',
+  'seedream':        'seedream/4.5-text-to-image',
+  'seedream-5-lite': 'seedream/5-lite-text-to-image',
+  // Быстрые модели — для черновых правок и быстрых превью.
+  'flux-schnell':    'flux/schnell',
+  'sdxl-lightning':  'sdxl/lightning',
+};
+const VIDEO_MODELS = {
+  'seedance-2':    'bytedance/seedance-2',
+};
+
+// ---------- /api/generate ----------
+async function handleGenerate(req, res) {
+  const { kind, prompt, imageInputs, videoInputs, aspectRatio, resolution, model: modelKey } = await readJson(req);
+  if (!prompt || !prompt.trim()) return send(res, 400, { error: 'prompt обязателен' });
+
+  const input = { prompt };
+  let model;
+
+  if (kind === 'image') {
+    const key = modelKey || 'nano-banana-2';
+    model = IMAGE_MODELS[key];
+    if (!model) return send(res, 400, { error: `unknown image model: ${key}` });
+    if (key === 'nano-banana-2') {
+      if (imageInputs?.length) input.image_input = imageInputs;
+      if (aspectRatio) input.aspect_ratio = aspectRatio;
+      input.resolution = resolution || '1K';
+      input.output_format = 'jpg';
+    } else if (key === 'grok') {
+      // Grok-Imagine не принимает image_input — игнорируем референсы
+      if (aspectRatio) input.aspect_ratio = aspectRatio;
+      input.nsfw_checker = false;
+      input.enable_pro = false;
+    } else if (key === 'seedream' || key === 'seedream-5-lite') {
+      // Seedream 4.5 / 5 Lite: только text-to-image, image_input не поддерживается
+      input.aspect_ratio = aspectRatio || '16:9';
+      input.quality = 'high';
+      input.nsfw_checker = false;
+    } else if (key === 'flux-schnell' || key === 'sdxl-lightning') {
+      // Быстрые text-to-image: минимум параметров, низкие шаги, рендер ~3-5с.
+      if (aspectRatio) input.aspect_ratio = aspectRatio;
+      input.output_format = 'jpg';
+    }
+  } else if (kind === 'video') {
+    const key = modelKey || 'seedance-2';
+    model = VIDEO_MODELS[key];
+    if (!model) return send(res, 400, { error: `unknown video model: ${key}` });
+    if (imageInputs?.length) input.reference_image_urls = imageInputs;
+    if (videoInputs?.length) input.reference_video_urls = videoInputs;
+    if (aspectRatio) input.aspect_ratio = aspectRatio;
+    if (resolution) input.resolution = resolution;
+  } else {
+    return send(res, 400, { error: `unknown kind: ${kind}` });
+  }
+
+  const data = await kieFetch('/api/v1/jobs/createTask', {
+    method: 'POST',
+    body: JSON.stringify({ model, input }),
+  });
+  send(res, 200, { taskId: data.data?.taskId });
+}
+
+// ---------- /api/poll ----------
+async function handlePoll(res, url) {
+  const taskId = url.searchParams.get('taskId');
+  if (!taskId) return send(res, 400, { error: 'нужен taskId' });
+  const data = await kieFetch(`/api/v1/jobs/recordInfo?taskId=${encodeURIComponent(taskId)}`);
+  const d = data.data || {};
+  const st = d.state;
+
+  if (st === 'success') {
+    let urls = [];
+    try {
+      const parsed = JSON.parse(d.resultJson || '{}');
+      urls = parsed.resultUrls || [];
+    } catch {}
+    if (!urls.length) return send(res, 200, { status: 'error', error: 'KIE вернул успех, но без URL' });
+    send(res, 200, { status: 'done', url: urls[0] });
+  } else if (st === 'fail') {
+    send(res, 200, { status: 'error', error: d.failMsg || d.failCode || 'generation failed' });
+  } else {
+    send(res, 200, { status: 'pending', state: st });
+  }
+}
+
+// ---------- /api/upload (загружает файл в KIE, возвращает публичный URL) ----------
+async function handleUpload(req, res) {
+  const filename = decodeURIComponent(req.headers['x-file-name'] || 'upload.bin');
+  const mimeType = (req.headers['content-type'] || 'application/octet-stream').split(';')[0].trim();
+  const buf = await readBody(req);
+  if (!buf.length) return send(res, 400, { error: 'пустой файл' });
+  // KIE base64 endpoint рекомендован для файлов < 10MB
+  if (buf.length > 10 * 1024 * 1024) {
+    return send(res, 413, { error: `файл слишком большой (${(buf.length/1024/1024).toFixed(1)} MB), лимит 10MB` });
+  }
+  const dataUrl = `data:${mimeType};base64,${buf.toString('base64')}`;
+  const key = process.env.KIE_API_KEY;
+  if (!key) return send(res, 500, { error: 'KIE_API_KEY не задан' });
+  const r = await fetch('https://kieai.redpandaai.co/api/file-base64-upload', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${key}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      base64Data: dataUrl,
+      uploadPath: 'images',
+      fileName: filename,
+    }),
+  });
+  const text = await r.text();
+  let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!r.ok || !data.success) {
+    return send(res, r.status || 500, { error: data.msg || `upload failed: ${text.slice(0, 200)}` });
+  }
+  send(res, 200, { url: data.data.downloadUrl, fileName: data.data.fileName, size: data.data.fileSize });
+}
+
+// ---------- /api/proxy?url=...  (стрим бинарных данных через бэк, минуя CORS) ----------
+async function handleProxy(res, url) {
+  const target = url.searchParams.get('url');
+  if (!target) return send(res, 400, { error: 'нужен url' });
+  let u;
+  try { u = new URL(target); } catch { return send(res, 400, { error: 'битый url' }); }
+  if (!/^https?:$/.test(u.protocol)) return send(res, 400, { error: 'разрешены только http/https' });
+
+  const r = await fetch(target);
+  if (!r.ok) return send(res, r.status, { error: `upstream ${r.status}` });
+  const headers = { 'Content-Type': r.headers.get('content-type') || 'application/octet-stream' };
+  const len = r.headers.get('content-length');
+  if (len) headers['Content-Length'] = len;
+  res.writeHead(200, headers);
+  const reader = r.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(Buffer.from(value));
+  }
+  res.end();
+}
+
+// ---------- /api/voices (список голосов ElevenLabs) ----------
+async function handleVoices(req, res) {
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  const r = await fetch(`${ELEVEN_BASE}/v1/voices`, { headers: { 'xi-api-key': key } });
+  const text = await r.text();
+  let data; try { data = JSON.parse(text); } catch { data = {}; }
+  if (!r.ok) return send(res, r.status, { error: data?.detail?.message || `HTTP ${r.status}` });
+  const voices = (data.voices || []).map(v => ({
+    id: v.voice_id,
+    name: v.name,
+    category: v.category,
+    labels: v.labels || {},
+    preview: v.preview_url,
+  }));
+  send(res, 200, { voices });
+}
+
+// ---------- /api/text (OpenRouter chat completion) ----------
+// Тело: {prompt, model?, system?, images?: [{url}]}
+// images.url — data:image/...;base64,... либо http(s) URL. Если массив не
+// пустой, отправляем content[] с image_url-блоками (vision).
+async function handleText(req, res) {
+  const key = process.env.OPENROUTER_API_KEY;
+  if (!key) return send(res, 500, { error: 'OPENROUTER_API_KEY не задан' });
+  const { prompt, model = 'anthropic/claude-sonnet-4', system, images } = await readJson(req);
+  if (!prompt) return send(res, 400, { error: 'нужен prompt' });
+  const messages = [];
+  if (system) messages.push({ role: 'system', content: system });
+  if (Array.isArray(images) && images.length) {
+    const content = [{ type: 'text', text: prompt }];
+    for (const img of images) {
+      if (!img?.url) continue;
+      content.push({ type: 'image_url', image_url: { url: img.url } });
+    }
+    messages.push({ role: 'user', content });
+  } else {
+    messages.push({ role: 'user', content: prompt });
+  }
+  const r = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${key}`,
+      'Content-Type': 'application/json',
+      'HTTP-Referer': 'http://localhost',
+      'X-Title': 'KingKont',
+    },
+    body: JSON.stringify({ model, messages }),
+  });
+  const text = await r.text();
+  let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!r.ok) {
+    return send(res, r.status, { error: data?.error?.message || data?.raw || `HTTP ${r.status}` });
+  }
+  const content = data?.choices?.[0]?.message?.content || '';
+  send(res, 200, { text: content, model: data?.model || model });
+}
+
+// ---------- /api/sfx (ElevenLabs Sound Effects) ----------
+async function handleSfx(req, res) {
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  const { text, durationSeconds, promptInfluence = 0.3 } = await readJson(req);
+  if (!text) return send(res, 400, { error: 'нужен text' });
+  const body = { text, prompt_influence: promptInfluence };
+  if (durationSeconds) body.duration_seconds = +durationSeconds;
+  const r = await fetch(`${ELEVEN_BASE}/v1/sound-generation`, {
+    method: 'POST',
+    headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) {
+    const t = await r.text();
+    return send(res, r.status, { error: t.slice(0, 400) });
+  }
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
+  const reader = r.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(Buffer.from(value));
+  }
+  res.end();
+}
+
+// ---------- /api/music (ElevenLabs Music) ----------
+async function handleMusic(req, res) {
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  const { prompt, durationMs } = await readJson(req);
+  if (!prompt) return send(res, 400, { error: 'нужен prompt' });
+  const body = { prompt };
+  if (durationMs) body.music_length_ms = +durationMs;
+  const r = await fetch(`${ELEVEN_BASE}/v1/music`, {
+    method: 'POST',
+    headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) {
+    const t = await r.text();
+    return send(res, r.status, { error: t.slice(0, 400) });
+  }
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
+  const reader = r.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(Buffer.from(value));
+  }
+  res.end();
+}
+
+// ---------- /api/tts (ElevenLabs v3) ----------
+async function handleTts(req, res) {
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  const { text, voiceId = 'JBFqnCBsd6RMkjVDRZzb', modelId = 'eleven_v3' } = await readJson(req);
+  if (!text) return send(res, 400, { error: 'нужен text' });
+  const r = await fetch(`${ELEVEN_BASE}/v1/text-to-speech/${voiceId}`, {
+    method: 'POST',
+    headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
+    body: JSON.stringify({ text, model_id: modelId }),
+  });
+  if (!r.ok) {
+    const t = await r.text();
+    return send(res, r.status, { error: t.slice(0, 300) });
+  }
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
+  const reader = r.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(Buffer.from(value));
+  }
+  res.end();
+}
+
+// ---------- статика ----------
+async function serveStatic(res, url) {
+  let pathname = url.pathname === '/' ? '/index.html' : decodeURIComponent(url.pathname);
+  const filePath = normalize(join(ROOT, pathname));
+  if (!filePath.startsWith(ROOT)) return send(res, 403, { error: 'forbidden' });
+  try {
+    const s = await stat(filePath);
+    if (!s.isFile()) return send(res, 404, 'not found');
+    const data = await readFile(filePath);
+    const mime = MIME[extname(filePath).toLowerCase()] || 'application/octet-stream';
+    res.writeHead(200, { 'Content-Type': mime, 'Cache-Control': 'no-cache' });
+    res.end(data);
+  } catch {
+    send(res, 404, 'not found');
+  }
+}
+
+// ---------- роутер ----------
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  try {
+    if (req.method === 'POST' && url.pathname === '/api/generate') return handleGenerate(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/upload')   return handleUpload(req, res);
+    if (req.method === 'GET'  && url.pathname === '/api/poll')     return handlePoll(res, url);
+    if (req.method === 'GET'  && url.pathname === '/api/proxy')    return handleProxy(res, url);
+    if (req.method === 'GET'  && url.pathname === '/api/voices')   return handleVoices(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/tts')      return handleTts(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/sfx')      return handleSfx(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/music')    return handleMusic(req, res);
+    if (req.method === 'POST' && url.pathname === '/api/text')     return handleText(req, res);
+    if (req.method === 'GET') return serveStatic(res, url);
+    send(res, 404, 'not found');
+  } catch (e) {
+    console.error('[error]', e);
+    send(res, 500, { error: e.message || 'server error' });
+  }
+});
+
+// Не падать на необработанных ошибках — логируем и живём дальше
+process.on('unhandledRejection', (err) => console.error('[unhandledRejection]', err));
+process.on('uncaughtException',  (err) => console.error('[uncaughtException]', err));
+
+function start(port = PORT) {
+  return new Promise((resolveOk, reject) => {
+    server.once('error', reject);
+    server.listen(port, () => {
+      const addr = server.address();
+      console.log(`▶  http://localhost:${addr.port}`);
+      console.log(`   KIE_API_KEY:        ${process.env.KIE_API_KEY ? '✓' : '✗ missing'}`);
+      console.log(`   ELEVENLABS_API_KEY: ${process.env.ELEVENLABS_API_KEY ? '✓' : '✗ missing'}`);
+      resolveOk(addr.port);
+    });
+  });
+}
+
+if (require.main === module) {
+  start();
+}
+
+module.exports = { start };