weebcli 1.0.0

package/src/utils/players/mpv.js

@@ -0,0 +1,251 @@
+// @ts-check
+import { spawn, execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import net from "net";
+import chalk from "chalk";
+import { t } from "../../i18n/index.js";
+
+const isWindows = os.platform() === "win32";
+
+/**
+ * @returns {Promise<string|null>}
+ */
+export async function getMpvPath() {
+	if (isWindows) {
+		const commonPaths = [
+			"C:\\Program Files\\MPV\\mpv.exe",
+			"C:\\Program Files (x86)\\MPV\\mpv.exe",
+			"C:\\ProgramData\\chocolatey\\bin\\mpv.exe",
+			`${process.env.USERPROFILE}\\scoop\\apps\\mpv\\current\\mpv.exe`
+		];
+
+		for (const p of commonPaths) {
+			if (fs.existsSync(p)) return p;
+		}
+
+		try {
+			const result = execSync("where mpv").toString().trim().split("\n")[0];
+			if (result && fs.existsSync(result)) return result;
+		} catch (e) {
+		}
+	} else {
+		try {
+			const result = execSync("which mpv").toString().trim();
+			if (result) return result;
+		} catch (e) {
+		}
+
+		if (fs.existsSync("/usr/bin/mpv")) return "/usr/bin/mpv";
+		if (fs.existsSync("/usr/local/bin/mpv")) return "/usr/local/bin/mpv";
+		if (fs.existsSync("/opt/homebrew/bin/mpv")) return "/opt/homebrew/bin/mpv";
+	}
+
+	return null;
+}
+
+/**
+ * @returns {Promise<boolean>}
+ */
+export async function installMpv() {
+	const platform = os.platform();
+
+	if (platform === "win32") {
+		console.log(chalk.cyan(t("errors.mpvNotFound", { manager: "Winget" })));
+		try {
+			execSync("winget install io.mpv.mpv -e --source winget", { stdio: "inherit" });
+			console.log(chalk.green(t("errors.mpvInstalled")));
+			return true;
+		} catch (error) {
+			console.error(chalk.red(t("errors.mpvInstallFailed")));
+			return false;
+		}
+	} else if (platform === "darwin") {
+		console.log(chalk.cyan(t("errors.mpvNotFound", { manager: "Homebrew" })));
+		try {
+			execSync("brew install mpv", { stdio: "inherit" });
+			console.log(chalk.green(t("errors.mpvInstalled")));
+			return true;
+		} catch (error) {
+			console.error(chalk.red(t("errors.mpvInstallFailedMac")));
+			return false;
+		}
+	} else if (platform === "linux") {
+		console.log(chalk.cyan(t("errors.mpvNotFound", { manager: "package manager" })));
+
+		const managers = [
+			{ cmd: "apt-get", install: "sudo apt-get update && sudo apt-get install mpv -y" },
+			{ cmd: "dnf", install: "sudo dnf install mpv -y" },
+			{ cmd: "pacman", install: "sudo pacman -S mpv --noconfirm" },
+			{ cmd: "zypper", install: "sudo zypper install mpv -y" },
+			{ cmd: "snap", install: "sudo snap install mpv" }
+		];
+
+		for (const mgr of managers) {
+			try {
+				execSync(`which ${mgr.cmd}`, { stdio: "ignore" });
+				console.log(chalk.yellow(t("errors.managerDetected", { manager: mgr.cmd })));
+				execSync(mgr.install, { stdio: "inherit" });
+				console.log(chalk.green(t("errors.mpvInstalled")));
+				return true;
+			} catch (e) {
+				continue;
+			}
+		}
+		return false;
+	}
+	return false;
+}
+
+/**
+ * @returns {string}
+ */
+function getSocketPath() {
+	if (isWindows) {
+		return "\\\\.\\pipe\\animely-mpv-socket";
+	}
+	return path.join(os.tmpdir(), `animely-mpv-${process.pid}.sock`);
+}
+
+/**
+ * @param {string} socketPath
+ * @param {string} command
+ * @returns {Promise<any>}
+ */
+function sendMpvCommand(socketPath, command) {
+	return new Promise((resolve, reject) => {
+		const client = net.createConnection(socketPath, () => {
+			client.write(command + "\n");
+		});
+
+		let data = "";
+		client.on("data", (chunk) => {
+			data += chunk.toString();
+			try {
+				const lines = data.split("\n").filter(l => l.trim());
+				for (const line of lines) {
+					const parsed = JSON.parse(line);
+					if (parsed.data !== undefined || parsed.error) {
+						client.end();
+						resolve(parsed);
+						return;
+					}
+				}
+			} catch (e) {
+
+			}
+		});
+
+		client.on("error", reject);
+		client.setTimeout(2000, () => {
+			client.end();
+			reject(new Error("Timeout"));
+		});
+	});
+}
+
+/**
+ * @param {string} socketPath
+ * @returns {Promise<{position: number, duration: number}|null>}
+ */
+async function getMpvPosition(socketPath) {
+	try {
+		const posResult = await sendMpvCommand(socketPath, '{"command": ["get_property", "time-pos"]}');
+		const durResult = await sendMpvCommand(socketPath, '{"command": ["get_property", "duration"]}');
+
+		if (posResult?.data !== undefined && durResult?.data !== undefined) {
+			return {
+				position: Math.floor(posResult.data),
+				duration: Math.floor(durResult.data)
+			};
+		}
+	} catch (e) {
+
+	}
+	return null;
+}
+
+/**
+ * @param {string} url
+ * @param {object} [options]
+ * @param {number} [options.startPosition] 
+ * @param {(position: number, duration: number) => void} [options.onClose]
+ * @returns {Promise<void>}
+ */
+export async function openInMpv(url, options = {}) {
+	let mpvPath = await getMpvPath();
+
+	if (!mpvPath) {
+		const installed = await installMpv();
+		if (installed) {
+			mpvPath = await getMpvPath();
+		} else {
+			throw new Error(t("errors.mpvNotFoundAndFailed"));
+		}
+	}
+
+	if (!mpvPath) throw new Error(t("errors.mpvPathNotFound"));
+
+	const socketPath = getSocketPath();
+
+	if (!isWindows && fs.existsSync(socketPath)) {
+		try {
+			fs.unlinkSync(socketPath);
+		} catch (e) {}
+	}
+
+	return new Promise((resolve, reject) => {
+		const args = [
+			url,
+			"--force-window",
+			"--fs",
+			`--input-ipc-server=${socketPath}`
+		];
+
+		// Başlangıç pozisyonu varsa ekle
+		if (options.startPosition && options.startPosition > 0) {
+			args.push(`--start=${options.startPosition}`);
+		}
+
+		const player = spawn(mpvPath, args, {
+			stdio: "ignore",
+			detached: false
+		});
+
+		let lastPosition = null;
+		let positionInterval = null;
+
+		const startTracking = () => {
+			positionInterval = setInterval(async () => {
+				const pos = await getMpvPosition(socketPath);
+				if (pos) {
+					lastPosition = pos;
+				}
+			}, 3000);
+		};
+
+		setTimeout(startTracking, 2000);
+
+		player.on("error", (err) => {
+			if (positionInterval) clearInterval(positionInterval);
+			reject(err);
+		});
+
+		player.on("close", () => {
+			if (positionInterval) clearInterval(positionInterval);
+
+			if (!isWindows && fs.existsSync(socketPath)) {
+				try {
+					fs.unlinkSync(socketPath);
+				} catch (e) {}
+			}
+
+			if (lastPosition && options.onClose) {
+				options.onClose(lastPosition.position, lastPosition.duration);
+			}
+
+			resolve();
+		});
+	});
+}

package/src/utils/players/vlc.js

@@ -0,0 +1,120 @@
+// @ts-check
+import { spawn, execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import chalk from "chalk";
+import { t } from "../../i18n/index.js";
+
+const isWindows = os.platform() === "win32";
+
+/**
+ * @returns {Promise<string|null>}
+ */
+export async function getVlcPath() {
+	if (isWindows) {
+		const commonPaths = [
+			"C:\\Program Files\\VideoLAN\\VLC\\vlc.exe",
+			"C:\\Program Files (x86)\\VideoLAN\\VLC\\vlc.exe"
+		];
+
+		for (const p of commonPaths) {
+			if (fs.existsSync(p)) return p;
+		}
+
+		try {
+			const result = execSync("where vlc").toString().trim().split("\n")[0];
+			if (result && fs.existsSync(result)) return result;
+		} catch (e) {}
+	} else {
+		try {
+			const result = execSync("which vlc").toString().trim();
+			if (result) return result;
+		} catch (e) {}
+
+		if (fs.existsSync("/usr/bin/vlc")) return "/usr/bin/vlc";
+		if (fs.existsSync("/Applications/VLC.app/Contents/MacOS/VLC")) return "/Applications/VLC.app/Contents/MacOS/VLC";
+	}
+
+	return null;
+}
+
+/**
+ * @returns {Promise<boolean>}
+ */
+export async function installVlc() {
+	const platform = os.platform();
+
+	if (platform === "win32") {
+		console.log(chalk.cyan(t("errors.vlcNotFound", { manager: "Winget" })));
+		try {
+			execSync("winget install VideoLAN.VLC -e --source winget", { stdio: "inherit" });
+			console.log(chalk.green(t("errors.vlcInstalled")));
+			return true;
+		} catch (error) {
+			console.error(chalk.red(t("errors.vlcInstallFailed")));
+			return false;
+		}
+	} else if (platform === "darwin") {
+		console.log(chalk.cyan(t("errors.vlcNotFound", { manager: "Homebrew" })));
+		try {
+			execSync("brew install --cask vlc", { stdio: "inherit" });
+			console.log(chalk.green(t("errors.vlcInstalled")));
+			return true;
+		} catch (error) {
+			console.error(chalk.red(t("errors.vlcInstallFailed")));
+			return false;
+		}
+	} else if (platform === "linux") {
+		const managers = [
+			{ cmd: "apt-get", install: "sudo apt-get update && sudo apt-get install vlc -y" },
+			{ cmd: "dnf", install: "sudo dnf install vlc -y" },
+			{ cmd: "pacman", install: "sudo pacman -S vlc --noconfirm" }
+		];
+
+		for (const mgr of managers) {
+			try {
+				execSync(`which ${mgr.cmd}`, { stdio: "ignore" });
+				execSync(mgr.install, { stdio: "inherit" });
+				console.log(chalk.green(t("errors.vlcInstalled")));
+				return true;
+			} catch (e) {
+				continue;
+			}
+		}
+		return false;
+	}
+	return false;
+}
+
+/**
+ * @param {string} url
+ * @param {object} [options]
+ * @param {number} [options.startPosition] - VLC'de desteklenmiyor
+ * @param {(position: number, duration: number) => void} [options.onClose] - VLC'de desteklenmiyor
+ * @returns {Promise<number|void>}
+ */
+export async function openInVlc(url, options = {}) {
+	let vlcPath = await getVlcPath();
+
+	if (!vlcPath) {
+		const installed = await installVlc();
+		if (installed) {
+			vlcPath = await getVlcPath();
+		} else {
+			throw new Error(t("errors.vlcNotFoundAndFailed"));
+		}
+	}
+
+	if (!vlcPath) throw new Error(t("errors.vlcPathNotFound"));
+
+	console.log(chalk.cyan(t("errors.vlcStarting")));
+
+	return new Promise((resolve, reject) => {
+		const child = spawn(vlcPath, ["--fullscreen", url], {
+			stdio: "ignore"
+		});
+
+		child.on("error", (err) => reject(err));
+		child.on("close", (code) => resolve(code));
+	});
+}

package/src/utils/process_queue.js

@@ -0,0 +1,121 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { getConfig } from "./storage/config.js";
+import { saveQueue } from "./storage/queue.js";
+import { batch } from "./download/concurrency.js";
+import { dl } from "./download/download.js";
+import { spinner } from "./spinner.js";
+import { ProgressBar } from "./download/progress.js";
+import { EstSpeed, EP_SIZE } from "../constants.js";
+import notifier from "node-notifier";
+import { t } from "../i18n/index.js";
+
+/**
+ * @param {import("./storage/queue.js").QueueItem[]} queue
+ */
+export async function processQueue(queue) {
+    console.clear();
+    const totalEpisodes = queue.length;
+    const estimatedSizeMB = totalEpisodes * EP_SIZE;
+    const estimatedSizeGB = (estimatedSizeMB / 1024).toFixed(2);
+
+    console.log(chalk.green(`\n${t("queue.title")}`));
+    console.log(chalk.gray(t("queue.totalEpisodes", { count: totalEpisodes })));
+    console.log(chalk.gray(t("queue.estimatedSize", { size: estimatedSizeGB })));
+
+    if (EstSpeed) {
+        const estimatedSeconds = estimatedSizeMB / (EstSpeed / 8);
+        const estimatedMinutes = Math.ceil(estimatedSeconds / 60);
+        console.log(chalk.gray(t("queue.estimatedTime", { minutes: estimatedMinutes, speed: EstSpeed })));
+    }
+
+    const { confirm } = await inquirer.prompt([{
+        type: "confirm",
+        name: "confirm",
+        message: t("queue.confirmStart"),
+        default: true
+    }]);
+
+    if (!confirm) return;
+
+    const config = getConfig();
+
+    const dirs = new Set(queue.map(item => item.dirPath));
+    dirs.forEach(dir => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    });
+
+    console.log(chalk.cyan(`\n${t("queue.downloading", { count: totalEpisodes, limit: config.maxConcurrent })}`));
+
+    const progressUI = new ProgressBar();
+
+    queue.forEach((item) => {
+        const key = `${item.safeAnimeName}-${item.episode.episode_number}`;
+        progressUI.update(key, {
+            name: `${item.animeName} - ${item.episode.episode_number}`,
+            status: t("progress.waiting"),
+            percent: 0
+        });
+    });
+
+    if (queue.length > 0) {
+        console.log("\n".repeat(Math.min(queue.length, config.maxConcurrent)));
+    }
+
+    const tasks = queue.map((item) => async () => {
+        const key = `${item.safeAnimeName}-${item.episode.episode_number}`;
+        const downloadPath = path.join(item.dirPath, `${item.safeAnimeName} - ${item.episode.episode_number}`);
+
+        if (!item.episode.link) {
+            progressUI.update(key, { status: t("progress.error"), percent: 0 });
+            return;
+        }
+
+        try {
+            progressUI.update(key, { status: t("progress.downloading"), percent: 0 });
+
+            await dl(item.episode.link, downloadPath, {
+                silent: true,
+                onProgress: (data) => {
+                    progressUI.update(key, {
+                        status: t("progress.downloading"),
+                        percent: data.percent,
+                        speed: data.speed,
+                        eta: data.eta,
+                        downloaded: data.downloaded,
+                        total: data.total
+                    });
+                }
+            }, {
+                count: config.retryEnabled ? (config.retryCount || 3) : 0,
+                delay: config.retryDelay || 3000
+            });
+
+            progressUI.update(key, { status: t("progress.completed"), percent: 100 });
+
+            const index = queue.indexOf(item);
+            if (index > -1) {
+                queue.splice(index, 1);
+                saveQueue(queue);
+            }
+        } catch (error) {
+            progressUI.update(key, { status: t("progress.error"), percent: 0 });
+        }
+    });
+
+    await batch(tasks, config.maxConcurrent);
+    progressUI.clear();
+    spinner.succeed(chalk.bold(t("queue.allComplete")));
+
+    notifier.notify({
+        title: 'Animely',
+        message: t("queue.notificationComplete"),
+        sound: true
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+}

package/src/utils/resume_watch.js

@@ -0,0 +1,137 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import axios from "axios";
+import { getConfig } from "./storage/config.js";
+import { formatName, getLink } from "../functions/episodes.js";
+import { openInVlc } from "./players/vlc.js";
+import { openInMpv } from "./players/mpv.js";
+import { setActivity, setWatchingActivity } from "./discord.js";
+import { updateHistory, loadHistory } from "./storage/history.js";
+import { getWatchPosition, updateWatchPosition, clearWatchPosition } from "./storage/watch_progress.js";
+import { searchAnime, updateAnilistProgress } from "./anilist.js";
+import { spinner } from "./spinner.js";
+import { API_URL } from "../constants.js";
+import { t } from "../i18n/index.js";
+
+/**
+ * @param {import("../jsdoc.js").Anime} anime
+ * @param {number} nextEpisodeNumber
+ */
+export async function resumeWatch(anime, nextEpisodeNumber) {
+    console.clear();
+    spinner.start(t("spinner.fetchingEpisodes", { name: anime.NAME }));
+
+    let episodes;
+    try {
+        const response = await axios.post(`${API_URL}/searchAnime`, { payload: anime.SLUG });
+        episodes = response.data.episodes;
+    } catch (error) {
+        spinner.fail(chalk.red(t("episodes.loadFailed")));
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        return;
+    }
+    spinner.stop();
+
+    const episode = episodes.find(e => e.episode_number == nextEpisodeNumber);
+
+    if (!episode) {
+        console.log(chalk.yellow(`\n${t("player.episodeNotFound", { episode: nextEpisodeNumber })}`));
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        return;
+    }
+
+    const links = [episode.backblaze_link, episode.watch_link_1, episode.watch_link_2, episode.watch_link_3];
+    const link = getLink(links);
+
+    if (!link) {
+        console.log(chalk.red("\n" + t("player.linkNotFound")));
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        return;
+    }
+
+    const config = getConfig();
+    const player = config.defaultPlayer || "vlc";
+
+    let startPosition = 0;
+    if (player === "mpv") {
+        const savedProgress = getWatchPosition(anime.NAME, nextEpisodeNumber);
+
+        if (savedProgress && savedProgress.position > 10) {
+            const minutes = Math.floor(savedProgress.position / 60);
+            const seconds = savedProgress.position % 60;
+            const { resumeFromSaved } = await inquirer.prompt([{
+                type: "confirm",
+                name: "resumeFromSaved",
+                message: t("player.resumePrompt", { time: `${minutes}:${seconds.toString().padStart(2, '0')}` }),
+                default: true
+            }]);
+
+            if (resumeFromSaved) {
+                startPosition = savedProgress.position;
+            } else {
+                clearWatchPosition(anime.NAME, nextEpisodeNumber);
+            }
+        }
+    }
+
+    console.log(chalk.green(`\n${t("player.episodeOpening", { name: anime.NAME, episode: nextEpisodeNumber, player })}`));
+    setWatchingActivity({
+        animeName: anime.NAME,
+        animeImage: anime.FIRST_IMAGE,
+        episode: nextEpisodeNumber,
+        totalEpisodes: episodes.length
+    });
+
+    try {
+        if (player === "mpv") {
+            const onPlayerClose = (position, duration) => {
+                if (position > 10 && duration > 0) {
+                    updateWatchPosition(anime.NAME, nextEpisodeNumber, position, duration);
+                }
+            };
+            await openInMpv(link, { startPosition, onClose: onPlayerClose });
+        } else {
+            await openInVlc(link);
+        }
+
+        setActivity(t("menu.browsingMenu"));
+
+        const { watched } = await inquirer.prompt([{
+            type: "confirm",
+            name: "watched",
+            message: t("player.markWatched"),
+            default: true
+        }]);
+
+        if (watched) {
+            const totalEpisodes = episodes.length;
+
+            let anilistId;
+            const history = loadHistory();
+            if (history[anime.NAME]) {
+                anilistId = history[anime.NAME].anilistId;
+            }
+
+            if (config.anilistToken && !anilistId) {
+                spinner.start(t("player.anilistSearching"));
+                anilistId = await searchAnime(anime.NAME);
+                spinner.stop();
+            }
+
+            updateHistory(anime.NAME, nextEpisodeNumber, totalEpisodes, anilistId);
+
+            if (config.anilistToken && anilistId) {
+                spinner.start(t("anilist.historyUpdating"));
+                const success = await updateAnilistProgress(anilistId, nextEpisodeNumber, nextEpisodeNumber >= totalEpisodes);
+                spinner.stop();
+                if (success) {
+                    console.log(chalk.green(""));
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 1500));
+        }
+    } catch (error) {
+        console.error(chalk.red(t("player.playerError", { message: error.message })));
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+}

package/src/utils/search.js

@@ -0,0 +1,39 @@
+/**
+ * @param {string} searchTerm 
+ * @param {import("../jsdoc.js").Anime[]} animes 
+ * @returns {import("../jsdoc.js").Anime[]}
+ */
+export function searchAnimes(searchTerm, animes) {
+    const lowerSearchTerm = searchTerm.toLowerCase().trim();
+
+    const exactMatches = animes.filter(({ NAME, OTHER_NAMES }) => {
+        const lowerName = NAME.toLowerCase();
+        const lowerOthers = OTHER_NAMES.map(n => n.toLowerCase());
+        return lowerName === lowerSearchTerm || lowerOthers.includes(lowerSearchTerm);
+    });
+
+    if (exactMatches.length > 0) {
+        return exactMatches;
+    }
+
+    const partialMatches = animes.filter(({ NAME, OTHER_NAMES }) => {
+        const lowerName = NAME.toLowerCase();
+        const lowerOthers = OTHER_NAMES.map(n => n.toLowerCase());
+        return lowerName.includes(lowerSearchTerm) ||
+            lowerOthers.some(name => name.includes(lowerSearchTerm));
+    });
+
+    if (partialMatches.length > 0) {
+        return partialMatches;
+    }
+
+    const fuzzyMatches = animes.filter(({ NAME, OTHER_NAMES }) => {
+        const allNames = [NAME, ...OTHER_NAMES].map(n => n.toLowerCase());
+        return allNames.some(name => {
+            const words = lowerSearchTerm.split(" ");
+            return words.every(word => name.includes(word));
+        });
+    });
+
+    return fuzzyMatches;
+}

package/src/utils/search_download.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { handleAnimecix } from "../sources/handlers/animecix.js";
+import { handleAnimely } from "../sources/handlers/animely.js";
+import { handleAllAnime } from "../sources/handlers/allanime.js";
+
+/**
+ * @param {import("../jsdoc.js").Anime[]|null} animes 
+ * @param {import("./storage/queue.js").QueueItem[]} downloadQueue
+ * @param {import("../sources/index.js").Source} source
+ */
+export async function searchAndDownload(animes, downloadQueue, source) {
+    if (source.id === "animecix") {
+        return handleAnimecix(downloadQueue, source);
+    }
+
+    if (source.id === "allanime") {
+        return handleAllAnime(downloadQueue, source);
+    }
+
+    return handleAnimely(animes, downloadQueue);
+}