ani-auto 1.0.0

package/src/scraper.js

@@ -0,0 +1,137 @@
+'use strict';
+
+/**
+ * scraper.js
+ *
+ * Thin adapter over the k-anime-cli utils.
+ * This is the ONLY file that touches the sister CLI project.
+ *
+ * Expected peer dependency layout:
+ *   ../k-anime/utils.js   ← the existing CLI's utils
+ *
+ * If you keep ani-auto as a separate repo, set KANIME_UTILS_PATH
+ * in your environment or config to point to utils.js.
+ */
+
+const path = require('path');
+const fetch = require('node-fetch');
+
+// ── Resolve the sibling CLI utils ─────────────────────────────────────────
+const UTILS_PATH = process.env.KANIME_UTILS_PATH
+    || path.resolve(__dirname, '../utils.js');
+
+let _utils = null;
+function utils() {
+    if (_utils) return _utils;
+    try {
+        _utils = require(UTILS_PATH);
+    } catch (e) {
+        throw new Error(
+            `Cannot find k-anime utils at "${UTILS_PATH}".\n` +
+            `Set KANIME_UTILS_PATH env var to the correct path.\n` +
+            `Original error: ${e.message}`
+        );
+    }
+    return _utils;
+}
+
+// ── Public surface ────────────────────────────────────────────────────────
+
+/**
+ * Search the site for an anime by title.
+ * Returns the best match or null.
+ *
+ * @param {string} title
+ * @returns {Promise<SiteAnime|null>}
+ */
+async function searchAnime(title) {
+    const results = await searchAll(title);
+    if (!results.length) return null;
+    const lower = title.toLowerCase();
+    const exact = results.find(r => r.title?.toLowerCase() === lower);
+    return exact || results[0];
+}
+
+/** Returns all search results (up to API limit) for user confirmation. */
+async function searchAll(title) {
+    const { SEARCH_API, USER_AGENT } = utils();
+    const url = `${SEARCH_API}?q=${encodeURIComponent(title)}`;
+    const res = await fetch(url, { headers: { 'User-Agent': USER_AGENT } });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.results || [];
+}
+
+/**
+ * Fetch episode list for a given site anime session id.
+ *
+ * @param {string} animeId  (session field from searchAnime result)
+ * @returns {Promise<SiteEpisode[]>}
+ */
+async function getEpisodes(animeId) {
+    const { INFO_API, USER_AGENT } = utils();
+    const res = await fetch(`${INFO_API}?id=${animeId}`, { headers: { 'User-Agent': USER_AGENT } });
+    if (!res.ok) throw new Error(`Failed to fetch episode list for ${animeId}`);
+    const data = await res.json();
+    return data.results?.episodes || [];
+}
+
+/**
+ * Fetch download links for a single episode.
+ *
+ * @param {string} animeId
+ * @param {string} episodeId  (session field from episode object)
+ * @returns {Promise<DownloadLink[]>}
+ */
+async function getDownloadLinks(animeId, episodeId) {
+    const { DOWNLOAD_API, USER_AGENT } = utils();
+    const res = await fetch(
+        `${DOWNLOAD_API}?animeId=${animeId}&episodeId=${episodeId}`,
+        { headers: { 'User-Agent': USER_AGENT } }
+    );
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.results?.downloadLinks || [];
+}
+
+/**
+ * Pick the best download link given quality + language preferences.
+ * Falls back gracefully: exact → quality-only → first available.
+ *
+ * @param {DownloadLink[]} links
+ * @param {string} quality   e.g. '1080p'
+ * @param {string} language  e.g. 'sub'
+ * @returns {DownloadLink|null}
+ */
+function pickLink(links, quality, language) {
+    if (!links.length) return null;
+    return (
+        links.find(l => l.resolution === quality && l.audio === language) ||
+        links.find(l => l.resolution === quality) ||
+        links[0]
+    );
+}
+
+/**
+ * Download a single episode file.
+ * Delegates entirely to the existing CLI's downloadFile().
+ *
+ * @param {string} url
+ * @param {string} filename
+ * @param {string} outputDir
+ * @param {*}      multiBar   cliProgress.MultiBar instance (or null for silent)
+ * @param {number} episodeNum
+ */
+async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum) {
+    const { downloadFile } = utils();
+    await downloadFile(url, filename, outputDir, multiBar, episodeNum);
+}
+
+module.exports = {
+    searchAnime,
+    searchAll,
+    getEpisodes,
+    getDownloadLinks,
+    pickLink,
+    downloadEpisode,
+};

package/utils.js

@@ -0,0 +1,118 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+
+// --- Configuration ---
+const API_DOMAIN = 'https://arcane-nx-cipher-pol.hf.space/api';
+const SEARCH_API = `${API_DOMAIN}/anime/search`;
+const INFO_API = `${API_DOMAIN}/anime/info`;
+const DOWNLOAD_API = `${API_DOMAIN}/anime/download`;
+const USER_AGENT = 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36';
+
+// --- Helpers ---
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+const getTerminalWidth = () => process.stdout.columns || 80;
+
+const formatBytes = (bytes, decimals = 2) => {
+    if (!+bytes) return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+
+// --- Download Logic ---
+async function downloadFile(url, filename, folder, multiBar, episode) {
+    const filePath = path.join(folder, filename);
+    let downloadedBytes = 0;
+    let fileExists = false;
+
+    if (fs.existsSync(filePath)) {
+        downloadedBytes = fs.statSync(filePath).size;
+        fileExists = true;
+    }
+
+    const progressBar = multiBar ? multiBar.create(100, 0, {
+        episode: episode,
+        speed: '0 B/s',
+        value_formatted: formatBytes(downloadedBytes),
+        total_formatted: 'Unknown'
+    }) : null;
+
+    try {
+        const headers = {
+            'User-Agent': USER_AGENT,
+            'Referer': 'https://kwik.cx/'
+        };
+
+        if (fileExists) headers['Range'] = `bytes=${downloadedBytes}-`;
+
+        const response = await fetch(url, { headers });
+
+        if (response.status === 416) {
+            if (progressBar) { progressBar.update(100, { episode, value_formatted: 'Complete', total_formatted: 'Complete', speed: '0 B/s' }); progressBar.stop(); }
+            return true;
+        }
+
+        if (!response.ok && response.status !== 206) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+
+        const isResuming = response.status === 206;
+        const contentLength = parseInt(response.headers.get('content-length'), 10);
+        const totalBytes = isResuming ? downloadedBytes + contentLength : contentLength;
+
+        if (progressBar) {
+            progressBar.setTotal(totalBytes);
+            progressBar.update(downloadedBytes, { episode, total_formatted: formatBytes(totalBytes) });
+        }
+
+        const fileStream = fs.createWriteStream(filePath, { flags: isResuming ? 'a' : 'w' });
+        const reader = response.body.getReader();
+        let currentProgress = downloadedBytes;
+        const startTime = Date.now();
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            fileStream.write(Buffer.from(value));
+            currentProgress += value.length;
+
+            if (progressBar) {
+                const elapsed = (Date.now() - startTime) / 1000;
+                const speed = elapsed > 0 ? (currentProgress - downloadedBytes) / elapsed : 0;
+                progressBar.update(currentProgress, {
+                    episode,
+                    value_formatted: formatBytes(currentProgress),
+                    speed: formatBytes(speed) + '/s'
+                });
+            } else {
+                process.stdout.write(`\r  EP${episode}: ${formatBytes(currentProgress)}${totalBytes ? ' / ' + formatBytes(totalBytes) : ''}`);
+            }
+        }
+
+        fileStream.end();
+        if (progressBar) progressBar.stop();
+        else process.stdout.write('\n');
+        return true;
+
+    } catch (err) {
+        if (progressBar) progressBar.stop();
+        throw err;
+    }
+}
+
+module.exports = {
+    SEARCH_API,
+    INFO_API,
+    DOWNLOAD_API,
+    USER_AGENT,
+    sleep,
+    getTerminalWidth,
+    formatBytes,
+    downloadFile,
+};