deepseek

const https = require('https');
const http = require('http');

const BASE = 'https://deep-seek.ai';
const API = `${BASE}/api/chat`;

const MODELS = {
  'v4-flash': 'deepseek/deepseek-v4-flash',
  'r1': 'deepseek/deepseek-r1',
};

const UA_POOL = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
  'Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:126.0) Gecko/20100101 Firefox/126.0',
];

function randomUA() { return UA_POOL[Math.floor(Math.random() * UA_POOL.length)]; }
function delay(ms) { return new Promise(r => setTimeout(r, ms)); }

function fetchBuffer(url, options = {}) {
  return new Promise((resolve, reject) => {
    const parsed = new URL(url);
    const lib = parsed.protocol === 'https:' ? https : http;
    const req = lib.request(url, {
      method: options.method || 'GET',
      headers: options.headers || {},
      timeout: options.timeout || 15000,
    }, (res) => {
      const chunks = [];
      res.on('data', c => chunks.push(c));
      res.on('end', () => {
        resolve({
          status: res.statusCode,
          headers: res.headers,
          body: Buffer.concat(chunks),
          text: () => Buffer.concat(chunks).toString('utf8'),
          getSetCookie: () => {
            const sc = res.headers['set-cookie'];
            return Array.isArray(sc) ? sc : (sc ? [sc] : []);
          },
        });
      });
      res.on('error', reject);
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
    if (options.body) req.write(options.body);
    req.end();
  });
}

async function getSession() {
  const res = await fetchBuffer(BASE, {
    headers: {
      'User-Agent': randomUA(),
      Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
      'Accept-Language': 'en-US,en;q=0.9',
    },
  });

  const html = res.text();
  const csrfMatch = html.match(/<meta name="csrf-token" content="([^"]+)"/);
  const csrf = csrfMatch ? csrfMatch[1] : '';

  const setCookies = res.getSetCookie();
  const xsrfCookie = setCookies.find(c => c.includes('XSRF-TOKEN='));
  const sessionCookie = setCookies.find(c => c.includes('deep_seek_session='));

  const xsrfRaw = xsrfCookie ? xsrfCookie.split(';')[0].split('=')[1] : '';
  const xsrfDecoded = decodeURIComponent(xsrfRaw);

  const cookieParts = [];
  if (xsrfCookie) cookieParts.push(xsrfCookie.split(';')[0]);
  if (sessionCookie) cookieParts.push(sessionCookie.split(';')[0]);

  return { csrf, xsrfToken: xsrfDecoded, cookie: cookieParts.join('; ') };
}

function parseSSEStream(res, onChunk) {
  return new Promise((resolve, reject) => {
    let content = '', reasoning = '', buffer = '';
    res.on('data', chunk => {
      buffer += chunk.toString();
      const lines = buffer.split('\n');
      buffer = lines.pop();
      for (const line of lines) {
        if (!line.startsWith('data: ')) continue;
        const raw = line.slice(6).trim();
        if (raw === '[DONE]') continue;
        try {
          const json = JSON.parse(raw);
          const delta = json?.choices?.[0]?.delta || {};
          if (delta.reasoning) { reasoning += delta.reasoning; if (onChunk) onChunk({ type: 'reasoning', text: delta.reasoning }); }
          if (delta.content) { content += delta.content; if (onChunk) onChunk({ type: 'content', text: delta.content }); }
        } catch {}
      }
    });
    res.on('end', () => resolve({ reasoning, content }));
    res.on('error', reject);
  });
}

async function chat(prompt, model = 'v4-flash', onChunk, retries = 3) {
  if (!MODELS[model]) return { success: false, error: `Model invalid. Pilih: ${Object.keys(MODELS).join(', ')}` };
  const modelId = MODELS[model];
  let session = await getSession();
  const body = JSON.stringify({ model: modelId, messages: [{ role: 'user', content: prompt }] });
  let lastError = null;

  for (let attempt = 0; attempt < retries; attempt++) {
    if (attempt > 0) { await delay(2000 * attempt); session = await getSession(); }
    const headers = {
      'Content-Type': 'application/json', Accept: 'text/event-stream',
      'X-CSRF-TOKEN': session.csrf, 'X-XSRF-TOKEN': session.xsrfToken,
      Cookie: session.cookie, Origin: BASE, Referer: `${BASE}/`,
      'User-Agent': randomUA(), 'Content-Length': Buffer.byteLength(body),
    };
    try {
      const res = await new Promise((resolve, reject) => {
        const req = https.request(API, { method: 'POST', headers, timeout: 180000 }, resolve);
        req.on('error', reject);
        req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
        req.write(body); req.end();
      });
      if (res.statusCode === 419 || res.statusCode === 401) { lastError = `HTTP ${res.statusCode}`; continue; }
      if (res.statusCode !== 200) {
        const chunks = []; for await (const c of res) chunks.push(c);
        lastError = `HTTP ${res.statusCode}: ${Buffer.concat(chunks).toString().slice(0, 300)}`; continue;
      }
      const result = await parseSSEStream(res, onChunk);
      return { success: true, model: modelId, ...result };
    } catch (e) { lastError = e.message; }
  }
  return { success: false, error: lastError || 'Unknown error' };
}

module.exports = { chat, MODELS };

if (require.main === module) {
  const args = process.argv.slice(2);
  const jsonFlag = args.includes('-j') || args.includes('--json');
  const noStreamFlag = args.includes('--no-stream');
  const modelFlag = args.indexOf('-m');
  const listFlag = args.includes('--list-models');
  if (listFlag) { console.log('Model tersedia:'); for (const [k, v] of Object.entries(MODELS)) console.log(`  ${k}: ${v}`); process.exit(0); }
  let model = 'v4-flash';
  let queryArgs = args;
  if (modelFlag !== -1) { model = args[modelFlag + 1]; queryArgs = args.filter((_, i) => i !== modelFlag && i !== modelFlag + 1); }
  queryArgs = queryArgs.filter(a => !a.startsWith('-'));
  if (!queryArgs.length) { console.log('Usage: node deepseek.js "pertanyaan" [-m r1] [-j] [--no-stream] [--list-models]'); process.exit(0); }
  const prompt = queryArgs.join(' ');
  chat(prompt, model, noStreamFlag ? null : ({ type, text }) => {
    if (type === 'reasoning') process.stdout.write(`\x1b[36m${text}\x1b[0m`);
    else if (type === 'content') process.stdout.write(text);
  }).then(result => {
    if (jsonFlag) { const clean = { ...result }; console.log(JSON.stringify(clean, null, 2)); }
    else if (!result.success) console.error('Error:', result.error);
    else if (noStreamFlag) { if (result.reasoning) console.log('\n[REASONING]\n' + result.reasoning + '\n'); console.log(result.content); }
  }).catch(e => console.error('Fatal:', e.message));
}