ani-web 1.5.8

package/server/dist/google.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.googleDriveService = exports.GoogleDriveService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const promises_1 = require("stream/promises");
+const logger_1 = __importDefault(require("./logger"));
+const config_1 = require("./config");
+const httpAgent = new http_1.default.Agent({ keepAlive: false });
+const httpsAgent = new https_1.default.Agent({ keepAlive: false });
+httpsAgent.setMaxListeners(100);
+httpAgent.setMaxListeners(100);
+const googleAxios = axios_1.default.create({
+    httpAgent,
+    httpsAgent,
+    timeout: 30000,
+});
+class GoogleDriveService {
+    tokens = {};
+    constructor() {
+        if (!config_1.CONFIG.GOOGLE_CLIENT_ID) {
+            logger_1.default.error('GOOGLE_CLIENT_ID is missing from .env!');
+        }
+        this.loadTokens();
+    }
+    loadTokens() {
+        if (fs_1.default.existsSync(config_1.CONFIG.TOKEN_PATH)) {
+            try {
+                this.tokens = JSON.parse(fs_1.default.readFileSync(config_1.CONFIG.TOKEN_PATH, 'utf-8'));
+            }
+            catch (error) {
+                logger_1.default.error({ err: error }, 'Failed to load Google tokens');
+            }
+        }
+    }
+    saveTokens(tokens) {
+        const merged = { ...this.tokens, ...tokens };
+        if (merged.expires_in && !merged.expiry_date) {
+            merged.expiry_date = Date.now() + merged.expires_in * 1000;
+        }
+        this.tokens = merged;
+        try {
+            fs_1.default.writeFileSync(config_1.CONFIG.TOKEN_PATH, JSON.stringify(this.tokens));
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to save refreshed tokens');
+        }
+    }
+    getGoogleClientConfig() {
+        if (!config_1.CONFIG.GOOGLE_CLIENT_ID || !config_1.CONFIG.GOOGLE_CLIENT_SECRET) {
+            throw new Error('Google OAuth credentials are not configured');
+        }
+        return {
+            clientId: config_1.CONFIG.GOOGLE_CLIENT_ID,
+            clientSecret: config_1.CONFIG.GOOGLE_CLIENT_SECRET,
+        };
+    }
+    async refreshAccessToken() {
+        if (!this.tokens.refresh_token) {
+            throw new Error('Missing refresh token');
+        }
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        const params = new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            refresh_token: this.tokens.refresh_token,
+            grant_type: 'refresh_token',
+        });
+        const { data } = await googleAxios.post('https://oauth2.googleapis.com/token', params.toString(), {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        this.saveTokens(data);
+    }
+    async ensureAccessToken() {
+        const expiresSoon = !this.tokens.expiry_date || Date.now() >= this.tokens.expiry_date - 60_000;
+        if (!this.tokens.access_token || expiresSoon) {
+            await this.refreshAccessToken();
+        }
+    }
+    async googleRequest(config) {
+        await this.ensureAccessToken();
+        return googleAxios.request({
+            ...config,
+            headers: {
+                Authorization: `Bearer ${this.tokens.access_token}`,
+                ...(config.headers ?? {}),
+            },
+        });
+    }
+    isAuthenticated() {
+        return !!this.tokens.refresh_token;
+    }
+    getAuthUrl() {
+        const { clientId } = this.getGoogleClientConfig();
+        const url = new URL('https://accounts.google.com/o/oauth2/v2/auth');
+        url.searchParams.set('client_id', clientId);
+        url.searchParams.set('redirect_uri', config_1.CONFIG.GOOGLE_REDIRECT_URI);
+        url.searchParams.set('response_type', 'code');
+        url.searchParams.set('access_type', 'offline');
+        url.searchParams.set('prompt', 'consent');
+        url.searchParams.set('scope', config_1.CONFIG.GOOGLE_SCOPES.join(' '));
+        return url.toString();
+    }
+    async handleCallback(code) {
+        const { clientId, clientSecret } = this.getGoogleClientConfig();
+        const params = new URLSearchParams({
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: config_1.CONFIG.GOOGLE_REDIRECT_URI,
+            grant_type: 'authorization_code',
+        });
+        const { data } = await googleAxios.post('https://oauth2.googleapis.com/token', params.toString(), {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        this.saveTokens(data);
+        return this.tokens;
+    }
+    async getUserProfile() {
+        if (!this.isAuthenticated())
+            return null;
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/oauth2/v2/userinfo',
+            });
+            return res.data;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, 'Failed to fetch user profile');
+            return null;
+        }
+    }
+    async logout() {
+        if (fs_1.default.existsSync(config_1.CONFIG.TOKEN_PATH)) {
+            fs_1.default.unlinkSync(config_1.CONFIG.TOKEN_PATH);
+        }
+        this.tokens = {};
+    }
+    async ensureFolder(folderName) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        const existing = await this.findFile(folderName, undefined, 'application/vnd.google-apps.folder');
+        if (existing) {
+            return existing.id;
+        }
+        const fileMetadata = {
+            name: folderName,
+            mimeType: 'application/vnd.google-apps.folder',
+        };
+        try {
+            const res = await this.googleRequest({
+                method: 'POST',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: { fields: 'id' },
+                data: fileMetadata,
+                headers: { 'Content-Type': 'application/json' },
+            });
+            return res.data.id;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Failed to create folder ${folderName}`);
+            throw error;
+        }
+    }
+    async findFile(filename, parentId, mimeType) {
+        if (!this.isAuthenticated())
+            return null;
+        const safeName = filename.replace(/'/g, "\\'");
+        let query = `name = '${safeName}' and trashed = false`;
+        if (parentId) {
+            const safeParentId = parentId.replace(/'/g, "\\'");
+            query += ` and '${safeParentId}' in parents`;
+        }
+        if (mimeType) {
+            const safeMimeType = mimeType.replace(/'/g, "\\'");
+            query += ` and mimeType = '${safeMimeType}'`;
+        }
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: 'https://www.googleapis.com/drive/v3/files',
+                params: {
+                    q: query,
+                    fields: 'files(id, name)',
+                    spaces: 'drive',
+                    orderBy: 'createdTime desc',
+                },
+            });
+            if (res.data.files && res.data.files.length > 0) {
+                return { id: res.data.files[0].id, name: res.data.files[0].name };
+            }
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Failed to find file ${filename}`);
+            return null;
+        }
+    }
+    async downloadFile(fileId, destPath) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        const dest = fs_1.default.createWriteStream(destPath);
+        try {
+            const res = await this.googleRequest({
+                method: 'GET',
+                url: `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}`,
+                params: { alt: 'media' },
+                responseType: 'stream',
+            });
+            await (0, promises_1.pipeline)(res.data, dest);
+        }
+        catch (error) {
+            dest.destroy();
+            throw error;
+        }
+    }
+    async uploadFile(filePath, filename, mimeType = 'application/octet-stream', parentId, existingFileId) {
+        if (!this.isAuthenticated())
+            throw new Error('Not authenticated');
+        let targetId = existingFileId;
+        if (!targetId) {
+            const existing = await this.findFile(filename, parentId, mimeType);
+            if (existing)
+                targetId = existing.id;
+        }
+        const media = {
+            mimeType,
+            body: fs_1.default.createReadStream(filePath),
+        };
+        try {
+            if (targetId) {
+                await this.googleRequest({
+                    method: 'PATCH',
+                    url: `https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(targetId)}`,
+                    params: { uploadType: 'media' },
+                    data: media.body,
+                    headers: { 'Content-Type': media.mimeType },
+                });
+            }
+            else {
+                const resource = { name: filename };
+                if (parentId) {
+                    resource.parents = [parentId];
+                }
+                const created = await this.googleRequest({
+                    method: 'POST',
+                    url: 'https://www.googleapis.com/drive/v3/files',
+                    params: { fields: 'id' },
+                    data: resource,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                await this.googleRequest({
+                    method: 'PATCH',
+                    url: `https://www.googleapis.com/upload/drive/v3/files/${encodeURIComponent(created.data.id)}`,
+                    params: { uploadType: 'media' },
+                    data: media.body,
+                    headers: { 'Content-Type': media.mimeType },
+                });
+            }
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, `Failed to upload file ${filename}`);
+            throw error;
+        }
+    }
+}
+exports.GoogleDriveService = GoogleDriveService;
+exports.googleDriveService = new GoogleDriveService();

package/server/dist/logger.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+const isDevelopment = process.env.NODE_ENV !== 'production';
+const logger = (0, pino_1.default)({
+    level: isDevelopment ? 'debug' : 'info',
+    transport: isDevelopment
+        ? {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
+            },
+        }
+        : undefined,
+});
+exports.default = logger;

package/server/dist/providers/123anime.provider.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._123AnimeProvider = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const BASE_URL = 'https://shirayuki-scrapper-api.onrender.com';
+class _123AnimeProvider {
+    name = '123Anime';
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    createSlug(title) {
+        return title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    normalizeSlugForSearch(title) {
+        return title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/['"]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+    /**
+     * Picks the best-matching show from a list of search results by comparing
+     * how closely each result's title / id matches the query.
+     * Scoring (highest wins):
+     *   3 – id/slug exact match
+     *   2 – title exact match (case-insensitive)
+     *   1 – title starts with query
+     *   0 – title contains query word (partial)
+     *  -1 – no match (but still returned as last resort)
+     */
+    bestMatch(results, query) {
+        const q = query.toLowerCase().trim();
+        const qSlug = this.normalizeSlugForSearch(q);
+        let best = results[0];
+        let bestScore = -1;
+        for (const s of results) {
+            const id = (s.id || s._id || '').toLowerCase();
+            const title = (s.name || '').toLowerCase();
+            let score = -1;
+            if (id === qSlug || id === q) {
+                score = 3;
+            }
+            else if (title === q) {
+                score = 2;
+            }
+            else if (title.startsWith(q)) {
+                score = 1;
+            }
+            else if (title.includes(q) || id.startsWith(qSlug)) {
+                score = 0;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                best = s;
+                if (score === 3)
+                    break; // can't do better
+            }
+        }
+        return best;
+    }
+    extractSlugFromUrl(url) {
+        if (!url)
+            return null;
+        try {
+            const parts = url.split('/');
+            const lastPart = parts[parts.length - 1];
+            if (lastPart) {
+                return lastPart.replace(/\.(jpg|jpeg|png|webp|gif)$/i, '');
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+        return null;
+    }
+    async search(options) {
+        try {
+            const rawQuery = options.query || '';
+            const query = rawQuery.replace(/[""]/g, '').replace(/[']/g, '').replace(/\s+/g, ' ').trim();
+            const url = `${BASE_URL}/search?keyword=${encodeURIComponent(query)}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                logger_1.default.warn({ url, status: response.status }, '123Anime search failed with non-200 status');
+                return [];
+            }
+            const data = (await response.json());
+            if (!data.success || !data.data) {
+                return [];
+            }
+            return (data.data || []).map((anime) => {
+                const imageUrl = anime.thumbnail || anime.image || anime.poster;
+                const slugFromUrl = this.extractSlugFromUrl(imageUrl);
+                const titleForSlug = anime.japanese_title || anime.title;
+                const id = anime.id || slugFromUrl || this.normalizeSlugForSearch(titleForSlug);
+                return {
+                    _id: id,
+                    id: id,
+                    name: anime.title,
+                    englishName: anime.title,
+                    thumbnail: imageUrl,
+                    type: anime.type,
+                    availableEpisodesDetail: {
+                        sub: Array.from({ length: Number(anime.episode) || 0 }, (_, i) => (i + 1).toString()),
+                        dub: [],
+                    },
+                };
+            });
+        }
+        catch (error) {
+            logger_1.default.error({ err: error }, '123Anime search failed');
+            return [];
+        }
+    }
+    async getEpisodes(showId) {
+        try {
+            const cacheKey = `123anime_eps_${showId}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+            const results = await this.search({ query: showId.replace(/ /g, '-') });
+            const show = results.find((s) => s.id === showId || s._id === showId) ||
+                (results.length > 0 ? this.bestMatch(results, showId) : undefined);
+            if (!show || !show.availableEpisodesDetail) {
+                return null;
+            }
+            const episodes = show.availableEpisodesDetail.sub || [];
+            const result = {
+                episodes,
+                description: '',
+            };
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ err: error, showId }, '123Anime getEpisodes failed');
+            return null;
+        }
+    }
+    async getStreamUrls(showId, episodeNumber) {
+        try {
+            const query = showId.replace(/ /g, '-');
+            const searchResults = await this.search({ query });
+            if (!searchResults || searchResults.length === 0) {
+                return null;
+            }
+            const match = searchResults.find((s) => s.id === showId || s._id === showId) ||
+                this.bestMatch(searchResults, showId);
+            const animeId = match.id || match._id;
+            const url = `${BASE_URL}/episode-stream?id=${animeId}&ep=${episodeNumber}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                logger_1.default.warn({ url, status: response.status }, '123Anime stream request failed');
+                return null;
+            }
+            const data = (await response.json());
+            if (!data.success || !data.data) {
+                return null;
+            }
+            const streamingLink = data.data['streaming_link'] || data.data['stream'] || data.data['url'];
+            if (!streamingLink) {
+                logger_1.default.warn({ data }, '123Anime No streaming link found in response data');
+                return null;
+            }
+            const separator = streamingLink.includes('?') ? '&' : '?';
+            const finalUrl = `${streamingLink}${separator}autoplay=1`;
+            return [
+                {
+                    sourceName: '123Anime',
+                    links: [
+                        {
+                            resolutionStr: 'auto',
+                            link: finalUrl,
+                            hls: false,
+                        },
+                    ],
+                    type: 'iframe',
+                },
+            ];
+        }
+        catch (error) {
+            logger_1.default.error({ err: error, showId, episodeNumber }, '123Anime getStreamUrls failed');
+            return null;
+        }
+    }
+    async getShowMeta(showId) {
+        const results = await this.search({ query: showId.replace(/ /g, '-') });
+        return results.find((s) => s.id === showId || s._id === showId) || null;
+    }
+    async getPopular() {
+        return [];
+    }
+    async getSchedule() {
+        return [];
+    }
+    async getSeasonal() {
+        return [];
+    }
+    async getLatestReleases() {
+        return [];
+    }
+    async getSkipTimes() {
+        return { found: false, results: [] };
+    }
+    async getShowDetails() {
+        return { status: 'Unknown' };
+    }
+    async getAllmangaDetails() {
+        return {
+            Rating: 'N/A',
+            Season: 'N/A',
+            Episodes: 'N/A',
+            Date: 'N/A',
+            'Original Broadcast': 'N/A',
+        };
+    }
+}
+exports._123AnimeProvider = _123AnimeProvider;