voxflow 1.14.0 → 1.15.1

package/lib/core/ffmpeg.js

@@ -0,0 +1,476 @@
+/**
+ * VoxFlow CLI — FFmpeg utility layer
+ *
+ * Provides ffmpeg/ffprobe operations via child_process.execFile.
+ * Zero external dependencies — requires ffmpeg to be installed on PATH.
+ * Also provides a one-time dependency hint for users without FFmpeg.
+ */
+
+const { execFile } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Run a command via execFile and return { stdout, stderr }.
+ * Rejects on non-zero exit code or spawn error.
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {object} [opts]
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function runCommand(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: 600_000, ...opts }, (error, stdout, stderr) => {
+      if (error) {
+        error.stderr = stderr;
+        error.stdout = stdout;
+        reject(error);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+
+/**
+ * Check if ffmpeg and ffprobe are available.
+ * @returns {Promise<{available: boolean, version?: string, ffprobeAvailable?: boolean}>}
+ */
+async function checkFfmpeg() {
+  try {
+    const { stdout } = await runCommand('ffmpeg', ['-version']);
+    const versionMatch = stdout.match(/ffmpeg version (\S+)/);
+    const version = versionMatch ? versionMatch[1] : 'unknown';
+
+    // Also check ffprobe
+    let ffprobeOk = false;
+    try {
+      await runCommand('ffprobe', ['-version']);
+      ffprobeOk = true;
+    } catch {
+      // ffprobe not available
+    }
+
+    return {
+      available: true,
+      version,
+      ffprobeAvailable: ffprobeOk,
+    };
+  } catch {
+    return { available: false };
+  }
+}
+
+/**
+ * Get the duration of an audio or video file in milliseconds.
+ * Uses ffprobe to extract duration.
+ * @param {string} filePath - Path to audio/video file
+ * @returns {Promise<number>} Duration in milliseconds
+ */
+async function getAudioDuration(filePath) {
+  const resolved = path.resolve(filePath);
+  try {
+    const { stdout } = await runCommand('ffprobe', [
+      '-v', 'error',
+      '-show_entries', 'format=duration',
+      '-of', 'default=noprint_wrappers=1:nokey=1',
+      resolved,
+    ]);
+
+    const seconds = parseFloat(stdout.trim());
+    if (isNaN(seconds)) {
+      throw new Error(`Could not parse duration from ffprobe output: "${stdout.trim()}"`);
+    }
+    return Math.round(seconds * 1000);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('ffprobe not found. Please install ffmpeg: https://ffmpeg.org/download.html');
+    }
+    throw new Error(`Failed to get duration of ${filePath}: ${err.message}`);
+  }
+}
+
+/**
+ * Extract audio track from a video file as WAV (24kHz, 16-bit, mono).
+ * @param {string} videoPath - Input video file
+ * @param {string} outputPath - Output WAV file path
+ * @returns {Promise<string>} Output file path
+ */
+async function extractAudio(videoPath, outputPath) {
+  const resolvedVideo = path.resolve(videoPath);
+  const resolvedOutput = path.resolve(outputPath);
+
+  try {
+    await runCommand('ffmpeg', [
+      '-i', resolvedVideo,
+      '-vn',                  // no video
+      '-acodec', 'pcm_s16le', // 16-bit PCM
+      '-ar', '24000',         // 24kHz sample rate
+      '-ac', '1',             // mono
+      '-y',                   // overwrite
+      resolvedOutput,
+    ]);
+    return resolvedOutput;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('ffmpeg not found. Please install ffmpeg: https://ffmpeg.org/download.html');
+    }
+    throw new Error(`Failed to extract audio from ${videoPath}: ${err.stderr || err.message}`);
+  }
+}
+
+/**
+ * Merge an audio track into a video file, replacing original audio.
+ * @param {string} videoPath - Input video file
+ * @param {string} audioPath - Input audio file (WAV/MP3)
+ * @param {string} outputPath - Output video file path
+ * @returns {Promise<string>} Output file path
+ */
+async function mergeAudioVideo(videoPath, audioPath, outputPath) {
+  const resolvedVideo = path.resolve(videoPath);
+  const resolvedAudio = path.resolve(audioPath);
+  const resolvedOutput = path.resolve(outputPath);
+
+  try {
+    await runCommand('ffmpeg', [
+      '-i', resolvedVideo,
+      '-i', resolvedAudio,
+      '-c:v', 'copy',         // copy video stream
+      '-map', '0:v:0',        // video from first input
+      '-map', '1:a:0',        // audio from second input
+      '-shortest',            // match shortest stream
+      '-y',                   // overwrite
+      resolvedOutput,
+    ]);
+    return resolvedOutput;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('ffmpeg not found. Please install ffmpeg: https://ffmpeg.org/download.html');
+    }
+    throw new Error(`Failed to merge audio/video: ${err.stderr || err.message}`);
+  }
+}
+
+/**
+ * Mix main audio with background music using volume ducking.
+ * BGM is reduced to the ducking level and mixed under the main audio.
+ * @param {string} mainAudioPath - Main audio (dubbing voice)
+ * @param {string} bgmPath - Background music file
+ * @param {string} outputPath - Output mixed audio path
+ * @param {object} [opts]
+ * @param {number} [opts.ducking=0.2] - BGM volume level (0-1, default 0.2 = 20%)
+ * @returns {Promise<string>} Output file path
+ */
+async function mixWithBgm(mainAudioPath, bgmPath, outputPath, opts = {}) {
+  const ducking = opts.ducking ?? 0.2;
+  const resolvedMain = path.resolve(mainAudioPath);
+  const resolvedBgm = path.resolve(bgmPath);
+  const resolvedOutput = path.resolve(outputPath);
+
+  try {
+    await runCommand('ffmpeg', [
+      '-i', resolvedMain,
+      '-i', resolvedBgm,
+      '-filter_complex',
+      `[1:a]volume=${ducking}[bgm_low];` +
+      `[0:a][bgm_low]amix=inputs=2:duration=first:dropout_transition=2[out]`,
+      '-map', '[out]',
+      '-acodec', 'pcm_s16le',
+      '-ar', '24000',
+      '-ac', '1',
+      '-y',
+      resolvedOutput,
+    ]);
+    return resolvedOutput;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('ffmpeg not found. Please install ffmpeg: https://ffmpeg.org/download.html');
+    }
+    throw new Error(`Failed to mix audio with BGM: ${err.stderr || err.message}`);
+  }
+}
+
+// ─── Dependency hint ────────────────────────────────────────────────────────
+
+/**
+ * Show a one-time friendly hint if FFmpeg is not installed.
+ * Does NOT block execution — just prints a warning once.
+ * The hint is suppressed after the first display (flag stored in config dir).
+ *
+ * @param {string} configDir - Path to the config directory (e.g. ~/.config/voxflow)
+ * @param {string} command - The command being run (e.g. 'dub', 'asr')
+ * @returns {Promise<{available: boolean, version?: string}>}
+ */
+async function warnIfMissingFfmpeg(configDir, command) {
+  const info = await checkFfmpeg();
+  if (info.available) return info;
+
+  // Check if we already showed the hint
+  const hintFlag = path.join(configDir, '.ffmpeg-hint-shown');
+  try {
+    if (fs.existsSync(hintFlag)) return info;
+  } catch {
+    // ignore fs errors, just show the hint
+  }
+
+  // Show the hint
+  const features = {
+    dub: 'video merging (--video), BGM mixing (--bgm), speed adjustment (--speed-auto)',
+    asr: 'audio format conversion, video audio extraction',
+  };
+  const featureDesc = features[command] || 'audio/video processing';
+
+  console.log(
+    '\n\x1b[33m' +
+    `[hint] ffmpeg not found — needed for ${featureDesc}.\n` +
+    '  Install: brew install ffmpeg (macOS) / sudo apt install ffmpeg (Linux)\n' +
+    '  Without ffmpeg, some features will be unavailable.\x1b[0m\n'
+  );
+
+  // Persist the flag so the hint only shows once
+  try {
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(hintFlag, new Date().toISOString(), 'utf8');
+  } catch {
+    // non-critical — next run will show hint again
+  }
+
+  return info;
+}
+
+// ─── Video summarize helpers ────────────────────────────────────────────────
+
+/**
+ * Cut a segment from a video file.
+ * @param {string} input - Input video path
+ * @param {string} output - Output segment path
+ * @param {number} startSec - Start time in seconds
+ * @param {number} endSec - End time in seconds
+ */
+async function cutVideo(input, output, startSec, endSec) {
+  await runCommand('ffmpeg', [
+    '-i', path.resolve(input),
+    '-ss', String(startSec),
+    '-to', String(endSec),
+    '-c', 'copy',
+    '-y', path.resolve(output),
+  ]);
+}
+
+/**
+ * Overlay text on video with a semi-transparent bottom bar.
+ * @param {string} input - Input video path
+ * @param {string} output - Output video path
+ * @param {string} text - Text to display
+ * @param {object} [opts]
+ * @param {string} [opts.fontfile] - Path to font file
+ * @param {number} [opts.fontSize=28] - Font size
+ */
+async function overlayText(input, output) {
+  // Copy through — text overlay requires drawtext (libfreetype).
+  // Future: install FFmpeg with --enable-libfreetype for text overlays.
+  fs.copyFileSync(path.resolve(input), path.resolve(output));
+}
+
+/**
+ * Generate a title card video (solid color background + centered text).
+ * @param {string} output - Output video path
+ * @param {string} text - Title text
+ * @param {object} [opts]
+ * @param {number} [opts.duration=3] - Duration in seconds
+ * @param {string} [opts.bgColor='0x0F172A'] - Background color
+ * @param {string} [opts.resolution='1920x1080'] - Video resolution
+ * @param {string} [opts.fontfile] - Path to font file
+ * @param {number} [opts.fontSize=52] - Font size
+ */
+/**
+ * Generate a title card from the first frame of a video (darkened + blurred).
+ * Falls back to solid color if no source video is provided.
+ * No drawtext/libfreetype needed — narration provides the context.
+ *
+ * @param {string} output - Output video path
+ * @param {string} text - Title text (unused — reserved for future drawtext support)
+ * @param {object} [opts]
+ * @param {number} [opts.duration=3] - Duration in seconds
+ * @param {string} [opts.sourceVideo] - Source video to extract first frame from
+ * @param {string} [opts.bgColor='0x0F172A'] - Fallback background color
+ * @param {string} [opts.resolution='1920x1080'] - Video resolution
+ */
+async function generateTitleCard(output, text, opts = {}) {
+  const duration = opts.duration || 3;
+  const resolution = opts.resolution || '1920x1080';
+
+  if (opts.sourceVideo && fs.existsSync(path.resolve(opts.sourceVideo))) {
+    // Extract first frame, darken + slight blur → cinematic title card
+    const tmpFrame = output + '.frame.jpg';
+    try {
+      await runCommand('ffmpeg', [
+        '-i', path.resolve(opts.sourceVideo),
+        '-vframes', '1', '-q:v', '2',
+        '-y', tmpFrame,
+      ]);
+
+      // Loop the darkened frame as a video clip with silent audio
+      await runCommand('ffmpeg', [
+        '-loop', '1', '-i', tmpFrame,
+        '-f', 'lavfi', '-i', 'anullsrc=r=24000:cl=mono',
+        '-t', String(duration),
+        '-vf', 'eq=brightness=-0.4:saturation=0.6,boxblur=8:2',
+        '-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-preset', 'fast',
+        '-c:a', 'aac', '-shortest',
+        '-y', path.resolve(output),
+      ]);
+      return;
+    } catch {
+      // Fall through to solid color
+    } finally {
+      try { fs.unlinkSync(tmpFrame); } catch {}
+    }
+  }
+
+  // Fallback: solid color card
+  const bgColor = opts.bgColor || '0x0F172A';
+  await runCommand('ffmpeg', [
+    '-f', 'lavfi', '-i', `color=c=${bgColor}:s=${resolution}:d=${duration}`,
+    '-f', 'lavfi', '-i', 'anullsrc=r=24000:cl=mono',
+    '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
+    '-c:a', 'aac', '-shortest',
+    '-y', path.resolve(output),
+  ]);
+}
+
+/**
+ * Replace the audio track of a video with a new audio file.
+ * @param {string} videoInput - Input video path
+ * @param {string} audioInput - New audio file (WAV)
+ * @param {string} output - Output video path
+ */
+async function replaceAudio(videoInput, audioInput, output) {
+  await runCommand('ffmpeg', [
+    '-i', path.resolve(videoInput),
+    '-i', path.resolve(audioInput),
+    '-c:v', 'copy',
+    '-map', '0:v:0',
+    '-map', '1:a:0',
+    '-shortest',
+    '-y', path.resolve(output),
+  ]);
+}
+
+/**
+ * Concatenate multiple video files using the concat demuxer.
+ * All inputs must have the same codec, resolution, and frame rate.
+ * @param {string[]} inputs - Array of input video file paths
+ * @param {string} output - Output concatenated video path
+ */
+async function concatVideos(inputs, output) {
+  const tmpDir = path.dirname(output);
+  const listFile = path.join(tmpDir, `concat-list-${Date.now()}.txt`);
+  const content = inputs.map(f => `file '${path.resolve(f)}'`).join('\n');
+  fs.writeFileSync(listFile, content, 'utf8');
+
+  try {
+    await runCommand('ffmpeg', [
+      '-f', 'concat', '-safe', '0',
+      '-i', listFile,
+      '-c', 'copy',
+      '-y', path.resolve(output),
+    ]);
+  } finally {
+    try { fs.unlinkSync(listFile); } catch {}
+  }
+}
+
+/**
+ * Re-encode a video to a standard format (H.264 + AAC) for concat compatibility.
+ * @param {string} input - Input video path
+ * @param {string} output - Output normalized video path
+ * @param {object} [opts]
+ * @param {string} [opts.resolution] - Target resolution (e.g. '1920x1080')
+ */
+async function normalizeVideo(input, output, opts = {}) {
+  const args = [
+    '-i', path.resolve(input),
+    '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+    '-c:a', 'aac', '-ar', '24000', '-ac', '1',
+    '-pix_fmt', 'yuv420p',
+  ];
+  if (opts.resolution) {
+    args.push('-vf', `scale=${opts.resolution.replace('x', ':')}:force_original_aspect_ratio=decrease,pad=${opts.resolution.replace('x', ':')}:(ow-iw)/2:(oh-ih)/2`);
+  }
+  args.push('-y', path.resolve(output));
+  await runCommand('ffmpeg', args, { timeout: 600_000 });
+}
+
+/**
+ * Detect a suitable CJK font on the current system.
+ * @returns {string|null} Font file path or null
+ */
+function detectCjkFont() {
+  const candidates = [
+    // macOS
+    '/System/Library/Fonts/PingFang.ttc',
+    '/System/Library/Fonts/STHeiti Light.ttc',
+    '/System/Library/Fonts/Hiragino Sans GB.ttc',
+    // Linux
+    '/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc',
+    '/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc',
+    '/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc',
+    // Windows
+    'C:\\Windows\\Fonts\\msyh.ttc',
+    'C:\\Windows\\Fonts\\simhei.ttf',
+  ];
+  for (const f of candidates) {
+    if (fs.existsSync(f)) return f;
+  }
+  return null;
+}
+
+/**
+ * Convert an audio file to a different format via ffmpeg.
+ * Used when the pipeline produces WAV but the user requested .mp3 output.
+ * @param {string} inputPath - Input audio file (e.g. WAV)
+ * @param {string} outputPath - Output audio file (e.g. MP3)
+ * @returns {Promise<string>} Output file path
+ */
+async function convertAudioFormat(inputPath, outputPath) {
+  const resolvedInput = path.resolve(inputPath);
+  const resolvedOutput = path.resolve(outputPath);
+
+  if (resolvedInput === resolvedOutput) {
+    throw new Error('convertAudioFormat: input and output paths must differ');
+  }
+
+  try {
+    await runCommand('ffmpeg', [
+      '-i', resolvedInput,
+      '-y',
+      resolvedOutput,
+    ]);
+    return resolvedOutput;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error('ffmpeg not found. Please install ffmpeg: https://ffmpeg.org/download.html');
+    }
+    throw new Error(`Failed to convert audio format: ${err.stderr || err.message}`);
+  }
+}
+
+module.exports = {
+  runCommand,
+  checkFfmpeg,
+  getAudioDuration,
+  extractAudio,
+  mergeAudioVideo,
+  mixWithBgm,
+  warnIfMissingFfmpeg,
+  convertAudioFormat,
+  // Video summarize helpers
+  cutVideo,
+  overlayText,
+  generateTitleCard,
+  replaceAudio,
+  concatVideos,
+  normalizeVideo,
+  detectCjkFont,
+};

package/lib/core/http.js

@@ -0,0 +1,188 @@
+/**
+ * VoxFlow CLI — HTTP request helper and API error types
+ */
+
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+const { logger } = require('./logger');
+const pkg = require('../../package.json');
+
+// ─── Error types ─────────────────────────────────────────────────────────────
+
+class ApiError extends Error {
+  constructor(message, code, status, retryAfterSec) {
+    super(message);
+    this.name = 'ApiError';
+    this.code = code;
+    this.status = status;
+    if (Number.isFinite(retryAfterSec)) this.retryAfterSec = retryAfterSec;
+  }
+}
+
+/**
+ * Resolve a Retry-After value from a 429 response.
+ * Standard HTTP header (seconds OR HTTP-date) takes precedence; fall back to
+ * a `retryAfter` / `retry_after` field in the JSON body, which some VoxFlow
+ * routes echo for client convenience.
+ *
+ * @returns {number|null} seconds to wait, or null if absent / unparseable
+ */
+function parseRetryAfterSeconds(headers, data) {
+  const headerVal = headers && (headers['retry-after'] || headers['Retry-After']);
+  if (headerVal) {
+    const numeric = Number(headerVal);
+    if (Number.isFinite(numeric) && numeric > 0) return Math.ceil(numeric);
+    const dateMs = Date.parse(headerVal);
+    if (Number.isFinite(dateMs)) {
+      const sec = Math.ceil((dateMs - Date.now()) / 1000);
+      if (sec > 0) return sec;
+    }
+  }
+  const body = data?.retryAfter ?? data?.retry_after;
+  if (Number.isFinite(body) && body > 0) return Math.ceil(body);
+  return null;
+}
+
+function throwApiError(status, data, context, headers) {
+  if (status === 401) {
+    throw new ApiError(
+      `Token expired or invalid. Run: voxflow login`,
+      'token_expired',
+      401
+    );
+  }
+  // 402 = Payment Required (quota exhausted) → distinct from 429 (rate limit).
+  // Conflating them was misleading: a podcast user with full bonus quota who
+  // tripped the per-minute TTS limit (20/min) would see "Monthly quota exceeded"
+  // and assume their account was empty. Now we keep them split, and retry-after
+  // is surfaced when the server returns it.
+  if (status === 402 || (data && data.code === 'quota_exceeded')) {
+    const remaining = data?.quotaInfo?.remainingTotal;
+    const detail = Number.isFinite(remaining)
+      ? ` Remaining: ${remaining.toLocaleString()}.`
+      : '';
+    throw new ApiError(
+      `Insufficient quota for this request.${detail} Top up at https://voxflow.studio/pricing or check: voxflow status`,
+      'insufficient_quota',
+      status
+    );
+  }
+  if (status === 429) {
+    const ra = parseRetryAfterSeconds(headers, data);
+    const wait = ra ? ` Retry after ${ra}s.` : ' Slow down and retry.';
+    throw new ApiError(
+      `Rate limit hit (too many requests in a short window).${wait} Quota is unaffected.`,
+      'rate_limited',
+      429,
+      ra ?? undefined
+    );
+  }
+  if (status >= 500) {
+    // Surface the backend's error code and message when available — the
+    // older generic "Server error (500). Please try again later." swallowed
+    // the actual cause (e.g. LLM provider failure on `slides`, issue #2916)
+    // and made it impossible to debug from the CLI alone.
+    const backendCode = data?.code;
+    const detail = data?.message || data?.error;
+    let suffix;
+    if (detail || backendCode) {
+      const codeLabel = backendCode ? `[${backendCode}] ` : '';
+      suffix = `: ${codeLabel}${detail || 'no message from server'}`;
+    } else {
+      suffix = '. Please try again later.';
+    }
+    throw new ApiError(
+      `Server error (${status})${suffix}`,
+      'server_error',
+      status
+    );
+  }
+  const detail = data?.message || data?.code || JSON.stringify(data);
+  throw new ApiError(`${context} failed (${status}): ${detail}`, 'api_error', status);
+}
+
+function throwNetworkError(err, apiBase) {
+  const code = err.code || '';
+  if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'ETIMEDOUT') {
+    throw new ApiError(
+      `Cannot reach API server at ${apiBase}. Check your internet connection or try --api <url>`,
+      'network_error',
+      0
+    );
+  }
+  throw err;
+}
+
+// ─── HTTP Helper ────────────────────────────────────────────────────────────
+
+/**
+ * Fire an HTTP request and parse a JSON response.
+ *
+ * `options.timeoutMs` (default 60s) is the inactivity timeout — long-running
+ * synth calls (TTS for a paragraph, LLM slide generation) are expected to
+ * exceed the default and pass an explicit larger value.
+ */
+function request(url, options, body) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const mod = parsedUrl.protocol === 'https:' ? https : http;
+
+    const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 60_000;
+
+    // Inject CLI client source header into every request, plus a
+    // per-request UUID for tracing + deduct_quota idempotency (#3194).
+    // Caller can override X-Request-Id explicitly to chain a retry to
+    // the same logical request — without that, each call gets a fresh
+    // ID. crypto.randomUUID is built-in on Node 19+ (we require 20+).
+    if (!options.headers) {
+      options.headers = {};
+    }
+    options.headers['X-Client-Source'] = 'cli';
+    options.headers['X-VoxFlow-Client'] = `voxflow-cli/${pkg.version}`;
+    if (!options.headers['X-Request-Id']) {
+      options.headers['X-Request-Id'] = crypto.randomUUID();
+    }
+
+    const startMs = Date.now();
+    const method = (options.method || 'GET').toUpperCase();
+    // Trim path query down to something greppable without dumping auth tokens.
+    logger.debug({ method, host: parsedUrl.host, path: parsedUrl.pathname }, 'http request');
+
+    const req = mod.request(parsedUrl, options, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        const durationMs = Date.now() - startMs;
+        logger.debug({
+          method,
+          path: parsedUrl.pathname,
+          status: res.statusCode,
+          durationMs,
+          responseBytes: raw.length
+        }, 'http response');
+        try {
+          resolve({ status: res.statusCode, headers: res.headers, data: JSON.parse(raw) });
+        } catch {
+          reject(new Error(`Non-JSON response (${res.statusCode}): ${raw.slice(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      logger.debug({ method, path: parsedUrl.pathname, err }, 'http error');
+      reject(err);
+    });
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      const seconds = Math.round(timeoutMs / 1000);
+      reject(new Error(`Request timeout (${seconds}s)`));
+    });
+
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+module.exports = { request, ApiError, throwApiError, throwNetworkError };