weebcli 1.0.0

package/src/utils/speedtest.js

@@ -0,0 +1,30 @@
+import axios from "axios";
+import { setSpeed } from "../constants.js";
+
+export async function runSpeedTest() {
+    try {
+        const start = Date.now();
+        const response = await axios.get("https://speed.cloudflare.com/__down?bytes=1000000", {
+            responseType: "arraybuffer",
+            timeout: 5000
+        });
+        const end = Date.now();
+
+        const durationSeconds = (end - start) / 1000;
+        const sizeBits = response.data.length * 8;
+        const speedBps = sizeBits / durationSeconds;
+        const speedMbps = speedBps / (1024 * 1024);
+
+        const roundedSpeed = Math.round(speedMbps);
+
+        if (roundedSpeed > 0 && isFinite(roundedSpeed)) {
+            setSpeed(roundedSpeed);
+            return roundedSpeed;
+        } else {
+            return null;
+        }
+
+    } catch (error) {
+        return null;
+    }
+}

package/src/utils/spinner.js

@@ -0,0 +1,7 @@
+// @ts-check
+import chalk from "chalk";
+import ora from "ora";
+import { t } from "../i18n/index.js";
+
+/** @type {import("ora").Ora} */
+export const spinner = ora(chalk.gray(t("spinner.loading")));

package/src/utils/storage/cache.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const homeDir = os.homedir();
+const configDir = path.join(homeDir, ".animely");
+const cachePath = path.join(configDir, "anime_cache.json");
+const CACHE_DURATION_MS = 30 * 60 * 1000;
+
+export function getCachedAnimeList() {
+    if (!fs.existsSync(cachePath)) return null;
+
+    try {
+        const raw = fs.readFileSync(cachePath, "utf-8");
+        const cache = JSON.parse(raw);
+
+        const now = Date.now();
+        if (now - cache.timestamp > CACHE_DURATION_MS) {
+            return null;
+        }
+
+        return cache.data;
+    } catch (e) {
+        return null;
+    }
+}
+
+export function saveAnimeListToCache(data) {
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const cache = {
+        timestamp: Date.now(),
+        data: data
+    };
+
+    try {
+        fs.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    } catch (e) {
+    }
+}

package/src/utils/storage/config.js

@@ -0,0 +1,71 @@
+// @ts-check
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const homeDir = os.homedir();
+const configDir = path.join(homeDir, ".animely");
+const configPath = path.join(configDir, "config.json");
+
+if (!fs.existsSync(configDir)) {
+	fs.mkdirSync(configDir, { recursive: true });
+}
+
+const defaultConfig = {
+	maxConcurrent: 3,
+	downloadDir: path.join(process.cwd(), "animely-downloads"),
+	defaultPlayer: "", // "vlc" | "mpv"
+	defaultSource: "animely", // "animely" | "animecix" | "allanime"
+	retryCount: 3,
+	retryDelay: 3000,
+	useAria2: false,
+	aria2Connections: 16,
+	useYtDlp: false,
+	ytDlpConnections: 16,
+	retryEnabled: true,
+	showAnimeDetails: true,
+	language: "" // "tr" | "en"
+};
+
+/**
+ * @typedef {Object} Config
+ * @property {number} maxConcurrent
+ * @property {string} downloadDir
+ * @property {string} defaultPlayer
+ * @property {string} defaultSource
+ * @property {number} retryCount
+ * @property {number} retryDelay
+ * @property {boolean} useAria2
+ * @property {number} aria2Connections
+ * @property {boolean} useYtDlp
+ * @property {number} ytDlpConnections
+ * @property {boolean} retryEnabled
+ * @property {string} [anilistToken]
+ * @property {string} [anilistUsername]
+ * @property {boolean} [showAnimeDetails]
+ * @property {string} [language]
+ */
+
+/**
+ * @returns {Config}
+ */
+export function getConfig() {
+	if (!fs.existsSync(configPath)) {
+		saveConfig(defaultConfig);
+		return defaultConfig;
+	}
+
+	try {
+		const fileContent = fs.readFileSync(configPath, "utf-8");
+		return { ...defaultConfig, ...JSON.parse(fileContent) };
+	} catch (error) {
+		return defaultConfig;
+	}
+}
+
+/**
+ * @param {Config} config 
+ */
+export function saveConfig(config) {
+	fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}

package/src/utils/storage/history.js

@@ -0,0 +1,69 @@
+// @ts-check
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const homeDir = os.homedir();
+const historyDir = path.join(homeDir, ".animely");
+const historyPath = path.join(historyDir, "history.json");
+
+if (!fs.existsSync(historyDir)) {
+	fs.mkdirSync(historyDir, { recursive: true });
+}
+
+/**
+ * @typedef {Object} HistoryItem
+ * @property {string} name
+ * @property {number} lastEpisode
+ * @property {number} totalEpisodes
+ * @property {boolean} completed
+ * @property {number} [anilistId]
+ * @property {string} lastWatchedAt
+ */
+
+/**
+ * @typedef {Object.<string, HistoryItem>} History
+ */
+
+/**
+ * @returns {History}
+ */
+export function loadHistory() {
+	if (!fs.existsSync(historyPath)) {
+		return {};
+	}
+	try {
+		return JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+	} catch (error) {
+		return {};
+	}
+}
+
+/**
+ * @param {History} history 
+ */
+export function saveHistory(history) {
+	fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
+}
+
+/**
+ * @param {string} animeName 
+ * @param {number} episodeNumber 
+ * @param {number} totalEpisodes 
+ * @param {number} [anilistId] 
+ */
+export function updateHistory(animeName, episodeNumber, totalEpisodes, anilistId) {
+	const history = loadHistory();
+	const isCompleted = episodeNumber >= totalEpisodes;
+
+	history[animeName] = {
+		name: animeName,
+		lastEpisode: episodeNumber,
+		totalEpisodes: totalEpisodes,
+		completed: isCompleted,
+		anilistId: anilistId || (history[animeName] ? history[animeName].anilistId : undefined),
+		lastWatchedAt: new Date().toISOString()
+	};
+
+	saveHistory(history);
+}

package/src/utils/storage/queue.js

@@ -0,0 +1,43 @@
+// @ts-check
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const homeDir = os.homedir();
+const configDir = path.join(homeDir, ".animely");
+const queuePath = path.join(configDir, "queue.json");
+
+if (!fs.existsSync(configDir)) {
+	fs.mkdirSync(configDir, { recursive: true });
+}
+
+/**
+ * @typedef {Object} QueueItem
+ * @property {string} animeName
+ * @property {import("../../jsdoc.js").DownloadEpisode} episode
+ * @property {string} dirPath
+ * @property {string} safeAnimeName
+ */
+
+/**
+ * @returns {QueueItem[]}
+ */
+export function loadQueue() {
+	if (!fs.existsSync(queuePath)) {
+		return [];
+	}
+
+	try {
+		const fileContent = fs.readFileSync(queuePath, "utf-8");
+		return JSON.parse(fileContent);
+	} catch (error) {
+		return [];
+	}
+}
+
+/**
+ * @param {QueueItem[]} queue 
+ */
+export function saveQueue(queue) {
+	fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), "utf-8");
+}

package/src/utils/storage/watch_progress.js

@@ -0,0 +1,104 @@
+// @ts-check
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const homeDir = os.homedir();
+const configDir = path.join(homeDir, ".animely");
+const progressPath = path.join(configDir, "watch_progress.json");
+
+if (!fs.existsSync(configDir)) {
+	fs.mkdirSync(configDir, { recursive: true });
+}
+
+/**
+ * @typedef {Object} WatchProgressItem
+ * @property {string} animeName
+ * @property {number|string} episode
+ * @property {number} position 
+ * @property {number} duration 
+ * @property {string} updatedAt
+ */
+
+/**
+ * @typedef {Object.<string, WatchProgressItem>} WatchProgress
+ */
+
+/**
+ * @param {string} animeName
+ * @param {number|string} episode
+ * @returns {string}
+ */
+function getKey(animeName, episode) {
+	return `${animeName}::${episode}`;
+}
+
+/**
+ * @returns {WatchProgress}
+ */
+export function loadWatchProgress() {
+	if (!fs.existsSync(progressPath)) {
+		return {};
+	}
+	try {
+		return JSON.parse(fs.readFileSync(progressPath, "utf-8"));
+	} catch (error) {
+		return {};
+	}
+}
+
+/**
+ * @param {WatchProgress} progress
+ */
+export function saveWatchProgress(progress) {
+	fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2));
+}
+
+/**
+ * @param {string} animeName
+ * @param {number|string} episode
+ * @param {number} position
+ * @param {number} duration
+ */
+export function updateWatchPosition(animeName, episode, position, duration) {
+	const progress = loadWatchProgress();
+	const key = getKey(animeName, episode);
+
+	if (duration > 0 && position / duration > 0.9) {
+		delete progress[key];
+		saveWatchProgress(progress);
+		return;
+	}
+
+	progress[key] = {
+		animeName,
+		episode,
+		position,
+		duration,
+		updatedAt: new Date().toISOString()
+	};
+
+	saveWatchProgress(progress);
+}
+
+/**
+ * @param {string} animeName
+ * @param {number|string} episode
+ * @returns {WatchProgressItem|null}
+ */
+export function getWatchPosition(animeName, episode) {
+	const progress = loadWatchProgress();
+	const key = getKey(animeName, episode);
+	return progress[key] || null;
+}
+
+/**
+ * @param {string} animeName
+ * @param {number|string} episode
+ */
+export function clearWatchPosition(animeName, episode) {
+	const progress = loadWatchProgress();
+	const key = getKey(animeName, episode);
+	delete progress[key];
+	saveWatchProgress(progress);
+}

package/src/utils/system.js

@@ -0,0 +1,176 @@
+// @ts-check
+import { spawnSync, execSync } from "child_process";
+import os from "os";
+import chalk from "chalk";
+import { t } from "../i18n/index.js";
+
+/**
+ * @returns {"windows" | "linux" | "macos" | "unknown"}
+ */
+export function getOS() {
+    const platform = os.platform();
+    if (platform === "win32") return "windows";
+    if (platform === "darwin") return "macos";
+    if (platform === "linux") return "linux";
+    return "unknown";
+}
+
+/**
+ * @type {Object.<string, {cmd: string, win: string, mac: string, linux: string}>}
+ */
+const PACKAGES = {
+    aria2: {
+        cmd: "aria2c",
+        win: "aria2.aria2",
+        mac: "aria2",
+        linux: "aria2"
+    },
+    vlc: {
+        cmd: "vlc",
+        win: "VideoLAN.VLC",
+        mac: "--cask vlc",
+        linux: "vlc"
+    },
+    mpv: {
+        cmd: "mpv",
+        win: "mpv.mpv",
+        mac: "mpv",
+        linux: "mpv"
+    },
+    ffmpeg: {
+        cmd: "ffmpeg",
+        win: "Gyan.FFmpeg",
+        mac: "ffmpeg",
+        linux: "ffmpeg"
+    },
+    "yt-dlp": {
+        cmd: "yt-dlp",
+        win: "yt-dlp.yt-dlp",
+        mac: "yt-dlp",
+        linux: "yt-dlp"
+    }
+};
+
+/**
+ * @param {string} program
+ * @returns {boolean}
+ */
+export function commandExists(program) {
+    const osType = getOS();
+    const pkg = PACKAGES[program] || { cmd: program };
+    const command = pkg.cmd;
+
+    try {
+        if (osType === "windows") {
+            try {
+                execSync(`where ${command}`, { stdio: "ignore" });
+                return true;
+            } catch {
+                const paths = [
+                    `C:\\Program Files\\VideoLAN\\VLC\\vlc.exe`,
+                    `C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe`,
+                    `C:\\Program Files\\MPV\\mpv.exe`,
+                    `C:\\ProgramData\\chocolatey\\bin\\mpv.exe`,
+                    `${process.env.USERPROFILE}\\scoop\\apps\\mpv\\current\\mpv.exe`
+                ];
+
+                if (program === 'vlc') {
+                    if (require('fs').existsSync('C:\\Program Files\\VideoLAN\\VLC\\vlc.exe')) return true;
+                    if (require('fs').existsSync('C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe')) return true;
+                }
+
+                if (program === 'mpv') {
+                    if (require('fs').existsSync('C:\\Program Files\\MPV\\mpv.exe')) return true;
+                    if (require('fs').existsSync('C:\\ProgramData\\chocolatey\\bin\\mpv.exe')) return true;
+                    if (require('fs').existsSync(`${process.env.USERPROFILE}\\scoop\\apps\\mpv\\current\\mpv.exe`)) return true;
+                }
+
+                if (program === 'aria2') {
+                    if (require('fs').existsSync('C:\\ProgramData\\chocolatey\\bin\\aria2c.exe')) return true;
+                    if (require('fs').existsSync(`${process.env.USERPROFILE}\\scoop\\apps\\aria2\\current\\aria2c.exe`)) return true;
+                }
+
+                if (program === 'yt-dlp') {
+                    if (require('fs').existsSync('C:\\ProgramData\\chocolatey\\bin\\yt-dlp.exe')) return true;
+                    if (require('fs').existsSync(`${process.env.USERPROFILE}\\scoop\\apps\\yt-dlp\\current\\yt-dlp.exe`)) return true;
+                    if (require('fs').existsSync(`${process.env.LOCALAPPDATA}\\Microsoft\\WinGet\\Packages\\yt-dlp.yt-dlp_Microsoft.Winget.Source_8wekyb3d8bbwe\\yt-dlp.exe`)) return true;
+                }
+
+                return false;
+            }
+        } else {
+            execSync(`which ${command}`, { stdio: "ignore" });
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * @param {string} program
+ * @returns {boolean}
+ */
+export function installPackage(program) {
+    const osType = getOS();
+    const pkg = PACKAGES[program];
+
+    if (!pkg) {
+        console.log(chalk.red(t("errors.packageNotFound", { name: program })));
+        return false;
+    }
+
+    try {
+        if (osType === "windows") {
+            if (!checkCommand("winget")) {
+                console.log(chalk.red(t("errors.wingetNotFound")));
+                return false;
+            }
+            spawnSync("winget", ["install", "-e", "--id", pkg.win], { stdio: "inherit" });
+            return true;
+
+        } else if (osType === "macos") {
+            if (!checkCommand("brew")) {
+                console.log(chalk.red(t("errors.brewNotFound")));
+                return false;
+            }
+            const args = ["install", ...pkg.mac.split(" ")];
+            spawnSync("brew", args, { stdio: "inherit" });
+            return true;
+
+        } else if (osType === "linux") {
+            if (checkCommand("apt")) {
+                spawnSync("sudo", ["apt", "update"], { stdio: "inherit" });
+                spawnSync("sudo", ["apt", "install", "-y", pkg.linux], { stdio: "inherit" });
+                return true;
+            } else if (checkCommand("pacman")) {
+                spawnSync("sudo", ["pacman", "-S", "--noconfirm", pkg.linux], { stdio: "inherit" });
+                return true;
+            } else {
+                console.log(chalk.red(t("errors.packageManagerNotFound")));
+                return false;
+            }
+        }
+    } catch (error) {
+        console.error(chalk.red(t("errors.installError", { message: error.message })));
+        return false;
+    }
+    return false;
+}
+
+/**
+ * @param {string} cmd
+ */
+function checkCommand(cmd) {
+    const osType = getOS();
+    try {
+        if (osType === "windows") {
+            execSync(`where ${cmd}`, { stdio: "ignore" });
+        } else {
+            execSync(`which ${cmd}`, { stdio: "ignore" });
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}

package/src/utils/ui/box.js

@@ -0,0 +1,140 @@
+// @ts-check
+import chalk from "chalk";
+import { t } from "../../i18n/index.js";
+
+/**
+ * @returns {number}
+ */
+export function getTerminalWidth() {
+    return process.stdout.columns || 80;
+}
+
+/**
+ * @param {string} title 
+ * @param {object} [options]
+ * @param {"cyan"|"green"|"yellow"|"red"|"magenta"|"blue"} [options.color="cyan"]
+ */
+export function boxTitle(title, options = {}) {
+    const { color = "cyan" } = options;
+    
+    const bgColors = {
+        cyan: chalk.bgCyan.black,
+        green: chalk.bgGreen.black,
+        yellow: chalk.bgYellow.black,
+        red: chalk.bgRed.white,
+        magenta: chalk.bgMagenta.black,
+        blue: chalk.bgBlue.white
+    };
+    
+    const bgFn = bgColors[color] || bgColors.cyan;
+    console.log(bgFn(` ${title} `));
+}
+
+/**
+ * @param {string[]} lines 
+ */
+export function boxInfo(lines) {
+    for (const line of lines) {
+        console.log(`  ${line}`);
+    }
+}
+
+/**
+ * @param {string} title
+ * @param {string[]} content
+ * @param {object} [options]
+ * @param {"cyan"|"green"|"yellow"|"red"|"magenta"|"blue"} [options.titleColor="cyan"]
+ */
+export function boxWithTitle(title, content, options = {}) {
+    const { titleColor = "cyan" } = options;
+    
+    const bgColors = {
+        cyan: chalk.bgCyan.black,
+        green: chalk.bgGreen.black,
+        yellow: chalk.bgYellow.black,
+        red: chalk.bgRed.white,
+        magenta: chalk.bgMagenta.black,
+        blue: chalk.bgBlue.white,
+        gray: chalk.bgGray.white
+    };
+    
+    const bgFn = bgColors[titleColor] || bgColors.cyan;
+    console.log(bgFn(` ${title} `));
+    
+    for (const line of content) {
+        console.log(`  ${line}`);
+    }
+}
+
+/**
+ * @param {number} [width]
+ * @param {"gray"|"cyan"|"yellow"} [color="gray"]
+ */
+export function divider(width, color = "gray") {
+    const w = width || Math.min(50, getTerminalWidth() - 4);
+    const colorFn = chalk[color] || chalk.gray;
+    console.log(colorFn("─".repeat(w)));
+}
+
+/**
+ * @param {string} title
+ * @param {string} [subtitle]
+ * @param {"cyan"|"green"|"yellow"|"magenta"} [color="cyan"]
+ */
+export function banner(title, subtitle, color = "cyan") {
+    const bgColors = {
+        cyan: chalk.bgCyan.black,
+        green: chalk.bgGreen.black,
+        yellow: chalk.bgYellow.black,
+        magenta: chalk.bgMagenta.black
+    };
+    
+    const bgFn = bgColors[color] || bgColors.cyan;
+    const colorFn = chalk[color] || chalk.cyan;
+    
+    console.log("");
+    console.log(bgFn(` ${title} `));
+    if (subtitle) {
+        console.log(colorFn(subtitle));
+    }
+}
+
+/**
+ * @param {string} animeName
+ * @param {number} currentEp
+ * @param {number} totalEp
+ * @param {string} [resolution]
+ */
+export function menuHeader(animeName, currentEp, totalEp, resolution) {
+    const resText = resolution ? ` (${resolution})` : "";
+    const epText = currentEp > 0 ? ` | ${currentEp}/${totalEp}` : ` | ${t("episodes.episodeCount", { count: totalEp })}`;
+    console.log(chalk.bgYellow.black(` ${t("ui.nowPlaying")} `) + ` ${chalk.bold(animeName)}${chalk.gray(resText)}${chalk.yellow(epText)}`);
+}
+
+/**
+ * @param {string} message
+ */
+export function errorBox(message) {
+    console.log(chalk.red(`✗  ${message}`));
+}
+
+/**
+ * @param {string} message
+ */
+export function successBox(message) {
+    console.log(chalk.green(`✓  ${message}`));
+}
+
+/**
+ * @param {string} message
+ */
+export function infoBox(message) {
+    console.log(chalk.cyan(`●  ${message}`));
+}
+
+/**
+ * @param {string} message
+ */
+export function warnBox(message) {
+    console.log(chalk.yellow(`!  ${message}`));
+}