weebcli 1.0.0

package/src/jsdoc.js

@@ -0,0 +1,72 @@
+/**
+ * @typedef {{
+ * _id: string;
+ * NAME: string;
+ * TOTAL_EPISODES: number;
+ * FIRST_IMAGE: string;
+ * CATEGORIES: string[];
+ * DESCRIPTION: string;
+ * SLUG: string;
+ * SEASON_NUMBER: number;
+ * OTHER_NAMES: string[];
+ * }} Anime
+ */
+
+/**
+ * @typedef {{
+ * id: string;
+ * episode_number: number;
+ * backblaze_link: string;
+ * watch_link_1: string;
+ * watch_link_2: string;
+ * watch_link_3: string;
+ * type: string;
+ * fansub: string;
+ * }} Episode
+ */
+
+/**
+ * @typedef {{
+ * id: string;
+ * episode_number: number|string;
+ * link: string;
+ * }} DownloadEpisode
+ */
+
+/**
+ * @typedef {{
+ * id: string;
+ * name: string;
+ * poster?: string;
+ * type?: string;
+ * totalEpisodes?: number;
+ * otherNames?: string[];
+ * _raw?: any;
+ * _isMovie?: boolean;
+ * }} SearchResult
+ */
+
+/**
+ * @typedef {{
+ * id: string;
+ * episode_number: number|string;
+ * name?: string;
+ * season?: number;
+ * type?: string;
+ * fansub?: string;
+ * _links?: string[];
+ * _url?: string;
+ * _animeId?: string;
+ * }} SourceEpisode
+ */
+
+/**
+ * @typedef {{
+ * url: string;
+ * quality?: string;
+ * label?: string;
+ * }} StreamLink
+ */
+
+
+export { };

package/src/sources/allanime.js

@@ -0,0 +1,195 @@
+// @ts-check
+import axios from "axios";
+
+const ALLANIME_API = "https://api.allanime.day";
+const ALLANIME_REFR = "https://allmanga.to";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0";
+
+function decodeProviderUrl(encoded) {
+    const hexMap = {
+        "79": "A", "7a": "B", "7b": "C", "7c": "D", "7d": "E", "7e": "F", "7f": "G",
+        "70": "H", "71": "I", "72": "J", "73": "K", "74": "L", "75": "M", "76": "N", "77": "O",
+        "68": "P", "69": "Q", "6a": "R", "6b": "S", "6c": "T", "6d": "U", "6e": "V", "6f": "W",
+        "60": "X", "61": "Y", "62": "Z",
+        "59": "a", "5a": "b", "5b": "c", "5c": "d", "5d": "e", "5e": "f", "5f": "g",
+        "50": "h", "51": "i", "52": "j", "53": "k", "54": "l", "55": "m", "56": "n", "57": "o",
+        "48": "p", "49": "q", "4a": "r", "4b": "s", "4c": "t", "4d": "u", "4e": "v", "4f": "w",
+        "40": "x", "41": "y", "42": "z",
+        "08": "0", "09": "1", "0a": "2", "0b": "3", "0c": "4", "0d": "5", "0e": "6", "0f": "7",
+        "00": "8", "01": "9",
+        "15": "-", "16": ".", "67": "_", "46": "~", "02": ":", "17": "/", "07": "?",
+        "1b": "#", "63": "[", "65": "]", "78": "@", "19": "!", "1c": "$", "1e": "&",
+        "10": "(", "11": ")", "12": "*", "13": "+", "14": ",", "03": ";", "05": "=", "1d": "%"
+    };
+
+    let result = "";
+    for (let i = 0; i < encoded.length; i += 2) {
+        const hex = encoded.substring(i, i + 2).toLowerCase();
+        result += hexMap[hex] || "";
+    }
+    return result.replace("/clock", "/clock.json");
+}
+
+export class AllAnimeSource {
+    constructor() {
+        this.name = "AllAnime";
+        this.id = "allanime";
+        this.language = "en";
+        this.supportsLocalSearch = false;
+        this.mode = "sub";
+    }
+
+    async _gqlRequest(params) {
+        try {
+            const response = await axios.get(`${ALLANIME_API}/api`, {
+                params,
+                headers: {
+                    "User-Agent": USER_AGENT,
+                    "Referer": ALLANIME_REFR
+                },
+                timeout: 15000
+            });
+            return response.data;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async search(query) {
+        const searchGql = `query($search: SearchInput $limit: Int $page: Int $translationType: VaildTranslationTypeEnumType $countryOrigin: VaildCountryOriginEnumType) {
+            shows(search: $search limit: $limit page: $page translationType: $translationType countryOrigin: $countryOrigin) {
+                edges { _id name availableEpisodes __typename }
+            }
+        }`;
+
+        const variables = JSON.stringify({
+            search: { allowAdult: false, allowUnknown: false, query },
+            limit: 40,
+            page: 1,
+            translationType: this.mode,
+            countryOrigin: "ALL"
+        });
+
+        const data = await this._gqlRequest({ variables, query: searchGql });
+        if (!data?.data?.shows?.edges) return [];
+
+        return data.data.shows.edges
+            .filter(show => show.availableEpisodes?.[this.mode] > 0)
+            .map(show => ({
+                id: show._id,
+                name: show.name,
+                totalEpisodes: show.availableEpisodes?.[this.mode] || 0,
+                _mode: this.mode
+            }));
+    }
+
+    async getEpisodes(showId) {
+        const episodesGql = `query($showId: String!) {
+            show(_id: $showId) { _id availableEpisodesDetail }
+        }`;
+
+        const variables = JSON.stringify({ showId });
+        const data = await this._gqlRequest({ variables, query: episodesGql });
+
+        const episodeList = data?.data?.show?.availableEpisodesDetail?.[this.mode];
+        if (!episodeList || !Array.isArray(episodeList)) return [];
+
+        const sorted = [...episodeList].sort((a, b) => parseFloat(a) - parseFloat(b));
+
+        return sorted.map((epNum, idx) => ({
+            id: `${showId}_${epNum}`,
+            episode_number: parseFloat(epNum) || idx + 1,
+            name: `Episode ${epNum}`,
+            _showId: showId,
+            _epString: epNum
+        }));
+    }
+
+    async _getLinksFromProvider(providerId) {
+        try {
+            const response = await axios.get(`https://allanime.day${providerId}`, {
+                headers: {
+                    "User-Agent": USER_AGENT,
+                    "Referer": ALLANIME_REFR
+                },
+                timeout: 10000
+            });
+
+            const data = response.data;
+            const links = [];
+
+            if (data.links) {
+                for (const link of data.links) {
+                    if (link.hls && link.link) {
+                        links.push({ quality: link.resolutionStr || "auto", url: link.link, _type: "hls" });
+                    } else if (link.mp4 && link.link) {
+                        links.push({ quality: link.resolutionStr || "auto", url: link.link, _type: "mp4" });
+                    } else if (link.link) {
+                        links.push({ quality: link.resolutionStr || "auto", url: link.link });
+                    }
+                }
+            }
+
+            return links;
+        } catch (e) {
+            return [];
+        }
+    }
+
+    async getStreamLinks(episodeData) {
+        const showId = episodeData._showId;
+        const epString = episodeData._epString;
+
+        if (!showId || !epString) return [];
+
+        const episodeGql = `query($showId: String!, $translationType: VaildTranslationTypeEnumType!, $episodeString: String!) {
+            episode(showId: $showId translationType: $translationType episodeString: $episodeString) {
+                episodeString sourceUrls
+            }
+        }`;
+
+        const variables = JSON.stringify({
+            showId,
+            translationType: this.mode,
+            episodeString: epString
+        });
+
+        const data = await this._gqlRequest({ variables, query: episodeGql });
+
+        const sourceUrls = data?.data?.episode?.sourceUrls;
+        if (!sourceUrls || !Array.isArray(sourceUrls)) return [];
+
+        const providers = [];
+        for (const source of sourceUrls) {
+            if (source.sourceUrl && source.sourceName) {
+                const encodedUrl = source.sourceUrl.replace("--", "");
+                const decodedUrl = decodeProviderUrl(encodedUrl);
+                providers.push({ name: source.sourceName, url: decodedUrl });
+            }
+        }
+
+        const preferredOrder = ["Luf-Mp4", "Default", "S-mp4", "Yt-mp4"];
+        const sortedProviders = providers.sort((a, b) => {
+            const aIdx = preferredOrder.indexOf(a.name);
+            const bIdx = preferredOrder.indexOf(b.name);
+            return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
+        });
+
+        for (const provider of sortedProviders) {
+            const links = await this._getLinksFromProvider(provider.url);
+            if (links.length > 0) {
+                return links.map(l => ({
+                    url: l.url,
+                    quality: l.quality,
+                    label: `${l.quality} (${provider.name})`
+                }));
+            }
+        }
+
+        return [];
+    }
+
+    setMode(mode) {
+        this.mode = mode;
+    }
+}

package/src/sources/animecix.js

@@ -0,0 +1,223 @@
+// @ts-check
+import axios from "axios";
+
+const BASE_URL = "https://animecix.tv/";
+const MANGACIX_URL = "https://mangacix.net";
+const VIDEO_PLAYER = "tau-video.xyz";
+
+const HEADERS = {
+	"Accept": "application/json",
+	"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
+};
+
+/**
+ * Animecix.tv kaynağı - API üzerinden arama yapar
+ */
+export class AnimecixSource {
+	constructor() {
+		this.name = "Animecix";
+		this.id = "animecix";
+		this.language = "tr";
+		this.supportsLocalSearch = false;
+	}
+
+	/**
+	 * @param {string} url
+	 * @returns {Promise<any>}
+	 */
+	async _getJson(url) {
+		try {
+			const response = await axios.get(url, { headers: HEADERS, timeout: 10000 });
+			return response.data;
+		} catch (e) {
+			return null;
+		}
+	}
+
+	/**
+	 * Anime arama (API üzerinden)
+	 * @param {string} query
+	 * @returns {Promise<import("./index.js").SearchResult[]>}
+	 */
+	async search(query) {
+		const url = `${BASE_URL}secure/search/${encodeURIComponent(query)}?type=&limit=20`;
+		const data = await this._getJson(url);
+
+		if (!data || !data.results) return [];
+
+		return data.results.map(item => ({
+			id: String(item.id),
+			name: item.name,
+			poster: item.poster,
+			type: item.title_type || item.type,
+			_isMovie: item.title_type === "movie" || item.type === "movie",
+			_originalTitle: item.original_title
+		}));
+	}
+
+	/**
+	 * Sezon listesi
+	 * @param {string} animeId
+	 * @returns {Promise<number[]>}
+	 */
+	async _getSeasons(animeId) {
+		const url = `${MANGACIX_URL}/secure/related-videos?episode=1&season=1&titleId=${animeId}&videoId=637113`;
+		const data = await this._getJson(url);
+
+		if (!data || !data.videos || !data.videos[0]) return [];
+
+		const seasons = data.videos[0]?.title?.seasons;
+		if (Array.isArray(seasons)) {
+			return seasons.map((_, i) => i);
+		}
+		return [];
+	}
+
+	/**
+	 * Bölüm listesi
+	 * @param {string} animeId
+	 * @returns {Promise<import("./index.js").Episode[]>}
+	 */
+	async getEpisodes(animeId) {
+		const seasons = await this._getSeasons(animeId);
+		
+		// Eğer sezon bulunamazsa, tek sezon varsay
+		const seasonList = seasons.length > 0 ? seasons : [0];
+		
+		const episodes = [];
+		const seenNames = new Set();
+
+		for (const seasonIndex of seasonList) {
+			const url = `${MANGACIX_URL}/secure/related-videos?episode=1&season=${seasonIndex + 1}&titleId=${animeId}&videoId=637113`;
+			const data = await this._getJson(url);
+
+			if (!data || !data.videos) continue;
+
+			for (const item of data.videos) {
+				const name = item.name || "Bilinmeyen";
+				if (seenNames.has(name)) continue;
+
+				seenNames.add(name);
+				episodes.push({
+					id: `${animeId}_${seasonIndex + 1}_${episodes.length + 1}`,
+					episode_number: episodes.length + 1,
+					name: name,
+					season: item.season_num || seasonIndex + 1,
+					_url: item.url // Bu URL'i izleme için kullanacağız
+				});
+			}
+		}
+
+		return episodes;
+	}
+
+	/**
+	 * Episode URL'den stream linklerini çıkar (Python'daki fetch_anime_watch_api_url)
+	 * @param {string} episodeUrl - Episode URL (örn: "izle/anime-adi/bolum-1")
+	 * @returns {Promise<import("./index.js").StreamLink[]>}
+	 */
+	async _getStreamLinksFromUrl(episodeUrl) {
+		try {
+			// URL'i tam hale getir
+			const fullUrl = episodeUrl.startsWith("http") ? episodeUrl : `${BASE_URL}${episodeUrl}`;
+			
+			// Redirect'i takip et
+			const response = await axios.get(fullUrl, {
+				headers: HEADERS,
+				maxRedirects: 10,
+				timeout: 15000,
+				validateStatus: () => true
+			});
+
+			const finalUrl = response.request?.res?.responseUrl || response.request?.responseURL || fullUrl;
+			
+			const urlObj = new URL(finalUrl);
+			const pathParts = urlObj.pathname.split("/").filter(p => p);
+			
+			let embedId = null;
+			for (let i = 0; i < pathParts.length; i++) {
+				if (pathParts[i] === "e" || pathParts[i] === "embed") {
+					embedId = pathParts[i + 1];
+					break;
+				}
+			}
+			
+			if (!embedId && pathParts.length >= 2) {
+				embedId = pathParts[pathParts.length - 1];
+			}
+
+			if (!embedId) {
+				console.log("Embed ID not found:", finalUrl);
+				return [];
+			}
+
+			const vid = urlObj.searchParams.get("vid");
+
+			const apiUrl = `https://${VIDEO_PLAYER}/api/video/${embedId}${vid ? `?vid=${vid}` : ""}`;
+			
+			const apiResponse = await axios.get(apiUrl, { 
+				timeout: 10000,
+				headers: {
+					"User-Agent": HEADERS["User-Agent"],
+					"Referer": finalUrl
+				}
+			});
+			
+			const urls = apiResponse.data?.urls || [];
+
+			return urls.map(item => ({
+				url: item.url,
+				quality: item.label || "default",
+				label: item.label
+			}));
+		} catch (e) {
+			console.error("Stream link error:", e.message);
+			return [];
+		}
+	}
+
+	/**
+	 * @param {string} titleId
+	 * @returns {Promise<import("./index.js").StreamLink[]>}
+	 */
+	async _getMovieStreamLinks(titleId) {
+		const url = `${BASE_URL}secure/titles/${titleId}?titleId=${titleId}`;
+		const headers = { ...HEADERS, "x-e-h": "=.a" };
+
+		try {
+			const response = await axios.get(url, { headers, timeout: 10000 });
+			const data = response.data;
+			const videos = data?.title?.videos || [];
+
+			for (const video of videos) {
+				const videoUrl = video.url;
+				if (!videoUrl) continue;
+
+				const streamLinks = await this._getStreamLinksFromUrl(videoUrl);
+				if (streamLinks.length > 0) return streamLinks;
+			}
+		} catch (e) {
+			console.error("Movie stream error:", e.message);
+		}
+
+		return [];
+	}
+
+	/**
+	 * @param {any} episodeData
+	 * @returns {Promise<import("./index.js").StreamLink[]>}
+	 */
+	async getStreamLinks(episodeData) {
+		if (episodeData._isMovie) {
+			return this._getMovieStreamLinks(episodeData._animeId);
+		}
+
+		const videoUrl = episodeData._url;
+		if (!videoUrl) {
+			console.log("Episode URL not found:", episodeData);
+			return [];
+		}
+
+		return this._getStreamLinksFromUrl(videoUrl);
+	}
+}

package/src/sources/animely.js

@@ -0,0 +1,100 @@
+// @ts-check
+import axios from "axios";
+import { API_URL } from "../constants.js";
+import { getCachedAnimeList, saveAnimeListToCache } from "../utils/storage/cache.js";
+
+/**
+ * Animely.net
+ */
+export class AnimelySource {
+	constructor() {
+		this.name = "Animely";
+		this.id = "animely";
+		this.language = "tr";
+		this.supportsLocalSearch = true;
+	}
+
+	/**
+	 * @returns {Promise<import("../jsdoc.js").Anime[]>}
+	 */
+	async getAnimeList() {
+		const cached = getCachedAnimeList();
+		if (cached) return cached;
+
+		const response = await axios.get(`${API_URL}/animes`);
+		const animes = response.data;
+		saveAnimeListToCache(animes);
+		return animes;
+	}
+
+	/**
+	 * @param {string} query
+	 * @returns {Promise<import("./index.js").SearchResult[]>}
+	 */
+	async search(query) {
+		const animes = await this.getAnimeList();
+		const lowerQuery = query.toLowerCase().trim();
+
+		let results = animes.filter(({ NAME, OTHER_NAMES }) => {
+			const lowerName = NAME.toLowerCase();
+			const lowerOthers = OTHER_NAMES.map(n => n.toLowerCase());
+			return lowerName === lowerQuery || lowerOthers.includes(lowerQuery);
+		});
+
+		if (results.length === 0) {
+			results = animes.filter(({ NAME, OTHER_NAMES }) => {
+				const lowerName = NAME.toLowerCase();
+				const lowerOthers = OTHER_NAMES.map(n => n.toLowerCase());
+				return lowerName.includes(lowerQuery) || lowerOthers.some(n => n.includes(lowerQuery));
+			});
+		}
+
+		if (results.length === 0) {
+			results = animes.filter(({ NAME, OTHER_NAMES }) => {
+				const allNames = [NAME, ...OTHER_NAMES].map(n => n.toLowerCase());
+				const words = lowerQuery.split(" ");
+				return allNames.some(name => words.every(word => name.includes(word)));
+			});
+		}
+
+		return results.map(anime => ({
+			id: anime.SLUG,
+			name: anime.NAME,
+			poster: anime.FIRST_IMAGE,
+			totalEpisodes: anime.TOTAL_EPISODES,
+			otherNames: anime.OTHER_NAMES,
+			_raw: anime
+		}));
+	}
+
+	/**
+	 * @param {string} animeSlug
+	 * @returns {Promise<import("./index.js").Episode[]>}
+	 */
+	async getEpisodes(animeSlug) {
+		const response = await axios.post(`${API_URL}/searchAnime`, { payload: animeSlug });
+		const episodes = response.data.episodes || [];
+
+		return episodes.map(ep => ({
+			id: ep.id,
+			episode_number: ep.episode_number,
+			name: `${ep.episode_number}. Bölüm`,
+			type: ep.type,
+			fansub: ep.fansub,
+			_links: [ep.backblaze_link, ep.watch_link_1, ep.watch_link_2, ep.watch_link_3]
+		}));
+	}
+
+	/**
+	 * @param {any} episodeData
+	 * @returns {Promise<import("./index.js").StreamLink[]>}
+	 */
+	async getStreamLinks(episodeData) {
+		const links = episodeData._links || [];
+		const validLink = links.find(l => l && typeof l === "string" && l.trim() !== "");
+
+		if (!validLink) return [];
+
+		return [{ url: validLink, quality: "default" }];
+	}
+}