@miruzero/zgpt 0.1.0

package/src/transport/direct/http-client.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const https = require('node:https');
+const fs = require('node:fs');
+const path = require('node:path');
+const paths = require('../../config/paths');
+
+const RETRY_AFTER_CAP_MS = 30000;
+const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 30000;
+const MAX_RATE_LIMIT_COOLDOWN_MS = 15 * 60 * 1000;
+
+const cleanHeaders = (input = {}) => Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null));
+const mergeSetCookies = (cookieString, setCookie) => {
+  const jar = new Map();
+  for (const pair of String(cookieString || '').split(';')) {
+    const index = pair.indexOf('=');
+    if (index > 0) jar.set(pair.slice(0, index).trim(), pair.slice(index + 1).trim());
+  }
+  for (const entry of Array.isArray(setCookie) ? setCookie : [setCookie]) {
+    const first = String(entry || '').split(';')[0];
+    const index = first.indexOf('=');
+    if (index > 0) jar.set(first.slice(0, index).trim(), first.slice(index + 1).trim());
+  }
+  return [...jar].map(([name, value]) => `${name}=${value}`).join('; ');
+};
+
+const rateLimitFileOf = (token, options = {}) => {
+  if (options.rateLimitFile === false) return null;
+  if (typeof options.rateLimitFile === 'string' && options.rateLimitFile.trim()) return path.resolve(options.rateLimitFile);
+  if (options.rateLimitFile === undefined && process.env.NODE_TEST_CONTEXT) return null;
+  return paths.rateLimitFile(options.env || process.env, token);
+};
+const readRateLimitState = (file) => {
+  if (!file || !fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+};
+const writeRateLimitState = (file, state) => {
+  if (!file) return;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temp, file);
+};
+const localRateLimitResponse = (token, options, parseBody) => {
+  const file = rateLimitFileOf(token, options);
+  const state = readRateLimitState(file);
+  const retryAt = Date.parse(state?.retry_not_before || '');
+  if (!Number.isFinite(retryAt) || retryAt <= Date.now()) return null;
+  const retryAfterMs = retryAt - Date.now();
+  return {
+    status: 429,
+    ...(parseBody ? { json: { detail: 'Too many requests' } } : { text: '{"detail":"Too many requests"}' }),
+    contentType: 'application/json',
+    headers: { 'retry-after': String(Math.max(1, Math.ceil(retryAfterMs / 1000))) },
+    localRateLimit: true
+  };
+};
+const recordRateLimitState = (response, token, options = {}) => {
+  const file = rateLimitFileOf(token, options);
+  if (!file || !response) return;
+  if (response.status === 429) {
+    const previous = readRateLimitState(file);
+    const consecutive = previous?.status === 429 ? Number(previous.consecutive_429 || 0) + 1 : 1;
+    const exponentialMs = Math.min(DEFAULT_RATE_LIMIT_COOLDOWN_MS * (2 ** Math.min(consecutive - 1, 8)), MAX_RATE_LIMIT_COOLDOWN_MS);
+    const serverMs = exports.parseRetryAfterMs(response.headers || {}) || 0;
+    const cooldownMs = Math.max(exponentialMs, serverMs);
+    writeRateLimitState(file, {
+      status: 429,
+      consecutive_429: consecutive,
+      observed_at: new Date().toISOString(),
+      retry_after_ms: cooldownMs,
+      retry_not_before: new Date(Date.now() + cooldownMs).toISOString()
+    });
+    return;
+  }
+  if (response.status >= 200 && response.status < 400) {
+    const state = readRateLimitState(file);
+    const retryAt = Date.parse(state?.retry_not_before || '');
+    if (Number.isFinite(retryAt) && retryAt <= Date.now()) {
+      try { fs.rmSync(file, { force: true }); } catch {}
+    }
+  }
+};
+
+exports.persistResponseHeaders = (sessionHeaders = {}, responseHeaders = {}, options = {}) => {
+  const setCookie = responseHeaders['set-cookie'];
+  if (!setCookie) return { changed: false, persisted: false };
+  const currentCookie = sessionHeaders.Cookie || sessionHeaders.cookie || '';
+  const cookie = mergeSetCookies(currentCookie, setCookie);
+  const changed = cookie !== currentCookie;
+  if (!changed) return { changed: false, persisted: false };
+  sessionHeaders.Cookie = cookie;
+  delete sessionHeaders.cookie;
+  const sessionFile = options.sessionFile || paths.sessionFile(options.env || process.env);
+  if (!fs.existsSync(sessionFile)) return { changed: true, persisted: false };
+  const data = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+  if (data.headers && typeof data.headers === 'object') {
+    data.headers.Cookie = cookie;
+    delete data.headers.cookie;
+  } else data.cookie = cookie;
+  data.updatedAt = new Date().toISOString();
+  fs.writeFileSync(sessionFile, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  return { changed: true, persisted: true };
+};
+
+exports.buildHeaders = (token, sessionHeaders = {}, target, targetRoute) => {
+  const targetPath = target.split('?')[0];
+  return cleanHeaders({ ...sessionHeaders, ...(token ? { authorization: `Bearer ${token}` } : {}), 'x-openai-target-path': targetPath, 'x-openai-target-route': targetRoute || targetPath });
+};
+exports.parseRetryAfterMs = (headers = {}) => {
+  const raw = headers['retry-after'];
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.min(Math.max(seconds, 0) * 1000, RETRY_AFTER_CAP_MS);
+  const at = Date.parse(raw);
+  if (Number.isFinite(at)) return Math.min(Math.max(at - Date.now(), 0), RETRY_AFTER_CAP_MS);
+  return null;
+};
+const safeParse = (text) => { try { return JSON.parse(text); } catch { return null; } };
+const rawRequest = (target, token, sessionHeaders, options, parseBody) => new Promise((resolve, reject) => {
+  const payload = options.body === undefined ? null : Buffer.from(JSON.stringify(options.body));
+  let headers = exports.buildHeaders(token, sessionHeaders, target, options.route);
+  if (options.headers) headers = cleanHeaders({ ...headers, ...options.headers });
+  if (payload) { headers['content-type'] = 'application/json'; headers['content-length'] = String(payload.length); }
+  const req = https.request(`https://chatgpt.com${target}`, { method: options.method || 'GET', headers }, (res) => {
+    const chunks = [];
+    let ended = false;
+    const aborted = () => {
+      const error = new Error(`ChatGPT upstream stream aborted: ${target}`);
+      error.code = 'UPSTREAM_ABORTED';
+      reject(error);
+    };
+    res.on('data', (chunk) => { options.onChunk?.(chunk); chunks.push(chunk); });
+    res.on('end', () => {
+      ended = true;
+      const text = Buffer.concat(chunks).toString('utf8');
+      const response = { status: res.statusCode, ...(parseBody ? { json: safeParse(text) } : { text }), contentType: res.headers['content-type'] || null, headers: { ...res.headers } };
+      exports.persistResponseHeaders(sessionHeaders, response.headers, options);
+      resolve(response);
+    });
+    res.on('aborted', aborted);
+    res.on('error', reject);
+    res.on('close', () => { if (!ended) aborted(); });
+  });
+  req.on('error', reject);
+  if (Number.isFinite(options.idleTimeoutMs) && options.idleTimeoutMs > 0 && typeof req.setTimeout === 'function') {
+    req.setTimeout(options.idleTimeoutMs, () => {
+      const error = new Error(`ChatGPT upstream stream idle timeout: ${target}`);
+      error.code = 'UPSTREAM_IDLE_TIMEOUT';
+      req.destroy(error);
+    });
+  }
+  if (payload) req.write(payload);
+  req.end();
+});
+const guardedRequest = async (target, token, sessionHeaders, options, parseBody) => {
+  const limited = localRateLimitResponse(token, options, parseBody);
+  if (limited) return limited;
+  const response = await rawRequest(target, token, sessionHeaders, options, parseBody);
+  recordRateLimitState(response, token, options);
+  return response;
+};
+exports.requestJson = (target, token, sessionHeaders = {}, options = {}) =>
+  guardedRequest(target, token, sessionHeaders, options, true);
+exports.requestText = (target, token, sessionHeaders = {}, options = {}) =>
+  guardedRequest(target, token, sessionHeaders, options, false);