- {Array.from({ length: 7 }).map((_, i) => (
+ {Array.from({ length: MOVIE_CARD_SKELETON_COUNT }).map((_, i) => (
))}
@@ -142,3 +143,5 @@ export default function MovieRow({
);
}
+export default memo(MovieRow);
+
diff --git a/src/components/movie/QualitySelector.tsx b/src/components/movie/QualitySelector.tsx
index d702dd1..0d2a69d 100644
--- a/src/components/movie/QualitySelector.tsx
+++ b/src/components/movie/QualitySelector.tsx
@@ -22,7 +22,6 @@ export default function QualitySelector({
torrents,
onSelect,
title = 'Select Quality',
- onClose,
}: QualitySelectorProps) {
const [selectedTorrent, setSelectedTorrent] = useState
(
torrents[0] || null
diff --git a/src/components/player/NextEpisodeOverlay.tsx b/src/components/player/NextEpisodeOverlay.tsx
index 795e923..729b624 100644
--- a/src/components/player/NextEpisodeOverlay.tsx
+++ b/src/components/player/NextEpisodeOverlay.tsx
@@ -1,4 +1,3 @@
-import { useState, useEffect } from 'react';
import { motion, AnimatePresence } from 'framer-motion';
import { Play, X } from 'lucide-react';
import Button from '../ui/Button';
diff --git a/src/components/player/StreamingPlayer.tsx b/src/components/player/StreamingPlayer.tsx
index a7ad0bf..1cc26bd 100644
--- a/src/components/player/StreamingPlayer.tsx
+++ b/src/components/player/StreamingPlayer.tsx
@@ -22,7 +22,7 @@ import { useNavigate } from 'react-router-dom';
import { clsx } from 'clsx';
import type { Movie, Subtitle } from '../../types';
import type { StreamSession } from '../../services/streaming/streamingService';
-import { searchSubtitles, downloadSubtitle, convertSrtToVtt, getAvailableLanguages } from '../../services/subtitles/opensubtitles';
+import { searchSubtitles, downloadSubtitle, convertSrtToVtt } from '../../services/subtitles/opensubtitles';
import { useSettingsStore } from '../../stores/settingsStore';
interface StreamingPlayerProps {
@@ -63,7 +63,7 @@ export default function StreamingPlayer({
const [showSubtitles, setShowSubtitles] = useState(false);
const [availableSubtitles, setAvailableSubtitles] = useState([]);
const [selectedSubtitle, setSelectedSubtitle] = useState(null);
- const [subtitleTrack, setSubtitleTrack] = useState(null);
+ const [, setSubtitleTrack] = useState(null);
const [isLoadingSubtitles, setIsLoadingSubtitles] = useState(false);
const [networkSpeed, setNetworkSpeed] = useState(0);
const [currentQualityLevel, setCurrentQualityLevel] = useState('auto');
@@ -143,7 +143,6 @@ export default function StreamingPlayer({
highBufferWatchdogPeriod: 2, // High buffer watchdog period
nudgeOffset: 0.1, // Nudge offset
nudgeMaxRetry: 3, // Max retry for nudge
- maxFragLoadingTimeOut: 20000, // Max fragment loading timeout
fragLoadingTimeOut: 20000, // Fragment loading timeout
manifestLoadingTimeOut: 10000, // Manifest loading timeout
levelLoadingTimeOut: 10000, // Level loading timeout
@@ -209,12 +208,19 @@ export default function StreamingPlayer({
// Monitor network speed
hls.on(Hls.Events.FRAG_LOADED, (_event, data) => {
- if (data.frag && data.stats) {
- const loadTime = (data.stats.tload - data.stats.tfirst) / 1000; // in seconds
- const bytes = data.frag.loaded;
- if (loadTime > 0 && bytes > 0) {
- const speed = (bytes / loadTime) * 8; // bits per second
- setNetworkSpeed(speed);
+ if (data.frag) {
+ // Try to get stats from the fragment if available
+ const frag = data.frag;
+ if (frag && 'stats' in frag && frag.stats) {
+ const stats = frag.stats as { tload?: number; tfirst?: number };
+ if (stats.tload && stats.tfirst) {
+ const loadTime = (stats.tload - stats.tfirst) / 1000; // in seconds
+ const bytes = (frag as any).loaded || 0;
+ if (loadTime > 0 && bytes > 0) {
+ const speed = (bytes / loadTime) * 8; // bits per second
+ setNetworkSpeed(speed);
+ }
+ }
}
}
});
@@ -296,7 +302,7 @@ export default function StreamingPlayer({
}
};
- const handleError = (e: Event) => {
+ const handleError = (_e: Event) => {
const error = video.error;
if (error) {
let errorMsg = 'Unknown error';
@@ -608,23 +614,6 @@ export default function StreamingPlayer({
}
}, []);
- // Toggle subtitles on/off
- const toggleSubtitles = useCallback(() => {
- if (!videoRef.current) return;
-
- const tracks = Array.from(videoRef.current.textTracks);
- const activeTrack = tracks.find(t => t.mode === 'showing');
-
- if (activeTrack) {
- activeTrack.mode = 'hidden';
- setSelectedSubtitle(null);
- } else if (selectedSubtitle) {
- const track = tracks.find(t => t.language === selectedSubtitle.language);
- if (track) {
- track.mode = 'showing';
- }
- }
- }, [selectedSubtitle]);
// Update volume
useEffect(() => {
diff --git a/src/components/tv/TVCard.tsx b/src/components/tv/TVCard.tsx
index d32265a..dba08cf 100644
--- a/src/components/tv/TVCard.tsx
+++ b/src/components/tv/TVCard.tsx
@@ -1,7 +1,7 @@
import { useState } from 'react';
import { Link, useNavigate } from 'react-router-dom';
import { motion } from 'framer-motion';
-import { Play, Plus, Check, Star, Info, Tv } from 'lucide-react';
+import { Play, Star, Info, Tv } from 'lucide-react';
import { clsx } from 'clsx';
import type { DiscoveredShow } from '../../services/api/tvDiscovery';
diff --git a/src/config/index.ts b/src/config/index.ts
new file mode 100644
index 0000000..4fe0d55
--- /dev/null
+++ b/src/config/index.ts
@@ -0,0 +1,47 @@
+/**
+ * Centralized configuration
+ * Environment-aware configuration with type safety
+ */
+
+interface AppConfig {
+ api: {
+ ytsBaseUrl: string;
+ timeout: number;
+ };
+ server: {
+ port: number;
+ healthCheckInterval: number;
+ };
+ cache: {
+ duration: number;
+ };
+ ui: {
+ defaultMovieLimit: number;
+ trendingMovieLimit: number;
+ heroMoviesCount: number;
+ };
+}
+
+const isDev = import.meta.env.DEV;
+
+export const config: AppConfig = {
+ api: {
+ ytsBaseUrl: isDev ? '/api/yts' : 'https://yts.lt/api/v2',
+ timeout: 15000,
+ },
+ server: {
+ port: 3001,
+ healthCheckInterval: 5000,
+ },
+ cache: {
+ duration: 5 * 60 * 1000, // 5 minutes
+ },
+ ui: {
+ defaultMovieLimit: 20,
+ trendingMovieLimit: 10,
+ heroMoviesCount: 5,
+ },
+};
+
+export default config;
+
diff --git a/src/constants/index.ts b/src/constants/index.ts
new file mode 100644
index 0000000..8ee2cd3
--- /dev/null
+++ b/src/constants/index.ts
@@ -0,0 +1,45 @@
+/**
+ * Application-wide constants
+ * Centralized location for all magic numbers and configuration values
+ */
+
+// API & Network
+export const SEARCH_DEBOUNCE_MS = 300;
+export const API_TIMEOUT_MS = 15000;
+export const CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+export const SERVER_STARTUP_DELAY_MS = 2000;
+export const SERVER_HEALTH_CHECK_INTERVAL_MS = 5000;
+export const SERVER_MAX_STARTUP_RETRIES = 3;
+export const SERVER_WAIT_TIMEOUT_MS = 10000;
+
+// UI & Display
+export const DEFAULT_MOVIE_LIMIT = 20;
+export const TRENDING_MOVIE_LIMIT = 10;
+export const HERO_MOVIES_COUNT = 5;
+export const MIN_RATING_THRESHOLD = 8;
+export const SCROLL_AMOUNT_MULTIPLIER = 0.8;
+export const SCROLL_THRESHOLD = 10;
+export const MOVIE_CARD_SKELETON_COUNT = 7;
+
+// WebSocket
+export const MAX_RECONNECT_ATTEMPTS = 5;
+export const RECONNECT_BASE_DELAY_MS = 2000;
+export const WEBSOCKET_SUBSCRIBE_DELAY_MS = 100;
+
+// Pagination
+export const DEFAULT_PAGE_SIZE = 20;
+export const MAX_PAGE_SIZE = 100;
+
+// Validation
+export const MIN_SEARCH_QUERY_LENGTH = 1;
+export const MAX_SEARCH_QUERY_LENGTH = 200;
+export const MIN_MOVIE_ID = 1;
+export const MAX_MOVIE_ID = Number.MAX_SAFE_INTEGER;
+
+// Quality Preferences
+export const QUALITY_PREFERENCES = ['1080p', '720p', '480p'] as const;
+
+// Retry Configuration
+export const DEFAULT_RETRY_DELAY_MS = 1000;
+export const MAX_RETRY_ATTEMPTS = 3;
+
diff --git a/src/hooks/useAsyncData.ts b/src/hooks/useAsyncData.ts
new file mode 100644
index 0000000..206b764
--- /dev/null
+++ b/src/hooks/useAsyncData.ts
@@ -0,0 +1,117 @@
+import { useState, useEffect, useCallback } from 'react';
+
+/**
+ * Generic hook for async data fetching with consistent error handling
+ * Standardizes loading, error, and data states across all data-fetching hooks
+ */
+export interface UseAsyncDataOptions {
+ enabled?: boolean;
+ initialData?: T;
+ onError?: (error: Error) => void;
+}
+
+export interface UseAsyncDataResult {
+ data: T | null;
+ isLoading: boolean;
+ error: string | null;
+ refetch: () => Promise;
+}
+
+/**
+ * Generic hook for fetching async data with consistent error handling
+ */
+export function useAsyncData(
+ fetchFn: () => Promise,
+ options: UseAsyncDataOptions = {}
+): UseAsyncDataResult {
+ const { enabled = true, initialData = null, onError } = options;
+ const [data, setData] = useState(initialData);
+ const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ const fetchData = useCallback(async () => {
+ if (!enabled) {
+ setIsLoading(false);
+ return;
+ }
+
+ setIsLoading(true);
+ setError(null);
+
+ try {
+ const result = await fetchFn();
+ setData(result);
+ } catch (err) {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch data';
+ setError(errorMessage);
+
+ if (onError && err instanceof Error) {
+ onError(err);
+ }
+ } finally {
+ setIsLoading(false);
+ }
+ }, [enabled, fetchFn, onError]);
+
+ useEffect(() => {
+ fetchData();
+ }, [fetchData]);
+
+ return {
+ data,
+ isLoading,
+ error,
+ refetch: fetchData,
+ };
+}
+
+/**
+ * Hook for fetching data that depends on a parameter
+ */
+export function useAsyncDataWithParam(
+ fetchFn: (param: P) => Promise,
+ param: P | null | undefined,
+ options: UseAsyncDataOptions = {}
+): UseAsyncDataResult {
+ const { enabled = true, initialData = null, onError } = options;
+ const [data, setData] = useState(initialData);
+ const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ const fetchData = useCallback(async () => {
+ if (!enabled || !param) {
+ setIsLoading(false);
+ setData(initialData);
+ return;
+ }
+
+ setIsLoading(true);
+ setError(null);
+
+ try {
+ const result = await fetchFn(param);
+ setData(result);
+ } catch (err) {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch data';
+ setError(errorMessage);
+
+ if (onError && err instanceof Error) {
+ onError(err);
+ }
+ } finally {
+ setIsLoading(false);
+ }
+ }, [enabled, param, fetchFn, onError, initialData]);
+
+ useEffect(() => {
+ fetchData();
+ }, [fetchData]);
+
+ return {
+ data,
+ isLoading,
+ error,
+ refetch: fetchData,
+ };
+}
+
diff --git a/src/hooks/useMovies.ts b/src/hooks/useMovies.ts
index 9a72c70..7222887 100644
--- a/src/hooks/useMovies.ts
+++ b/src/hooks/useMovies.ts
@@ -1,6 +1,11 @@
import { useState, useEffect, useCallback } from 'react';
import { ytsApi } from '../services/api/yts';
import type { Movie, ListMoviesParams } from '../types';
+import {
+ DEFAULT_MOVIE_LIMIT,
+ TRENDING_MOVIE_LIMIT,
+ MIN_RATING_THRESHOLD,
+} from '../constants';
interface UseMoviesOptions extends ListMoviesParams {
enabled?: boolean;
@@ -79,60 +84,87 @@ export function useMovies(options: UseMoviesOptions = {}): UseMoviesResult {
export function useTrending() {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
useEffect(() => {
- ytsApi.getTrending(10)
+ setIsLoading(true);
+ setError(null);
+ ytsApi.getTrending(TRENDING_MOVIE_LIMIT)
.then((data) => setMovies(data.movies))
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch trending movies';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
}, []);
- return { movies, isLoading };
+ return { movies, isLoading, error };
}
export function useLatest() {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
useEffect(() => {
- ytsApi.getLatest(20)
+ setIsLoading(true);
+ setError(null);
+ ytsApi.getLatest(DEFAULT_MOVIE_LIMIT)
.then((data) => setMovies(data.movies))
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch latest movies';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
}, []);
- return { movies, isLoading };
+ return { movies, isLoading, error };
}
export function useTopRated() {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
useEffect(() => {
- ytsApi.getTopRated(20, 8)
+ setIsLoading(true);
+ setError(null);
+ ytsApi.getTopRated(DEFAULT_MOVIE_LIMIT, MIN_RATING_THRESHOLD)
.then((data) => setMovies(data.movies))
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch top rated movies';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
}, []);
- return { movies, isLoading };
+ return { movies, isLoading, error };
}
export function useByGenre(genre: string) {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
useEffect(() => {
if (genre) {
setIsLoading(true);
- ytsApi.getByGenre(genre, 20)
+ setError(null);
+ ytsApi.getByGenre(genre, DEFAULT_MOVIE_LIMIT)
.then((data) => setMovies(data.movies))
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch movies by genre';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
+ } else {
+ setMovies([]);
+ setIsLoading(false);
+ setError(null);
}
}, [genre]);
- return { movies, isLoading };
+ return { movies, isLoading, error };
}
export function useMovieDetails(movieId: number) {
@@ -156,40 +188,56 @@ export function useMovieDetails(movieId: number) {
export function useMovieSuggestions(movieId: number) {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(true);
+ const [error, setError] = useState(null);
useEffect(() => {
if (movieId) {
+ setIsLoading(true);
+ setError(null);
ytsApi.getMovieSuggestions(movieId)
.then((data) => setMovies(data.movies))
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to fetch movie suggestions';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
+ } else {
+ setMovies([]);
+ setIsLoading(false);
+ setError(null);
}
}, [movieId]);
- return { movies, isLoading };
+ return { movies, isLoading, error };
}
export function useSearch(query: string, params?: Omit) {
const [movies, setMovies] = useState([]);
const [isLoading, setIsLoading] = useState(false);
+ const [error, setError] = useState(null);
const [totalCount, setTotalCount] = useState(0);
useEffect(() => {
if (query) {
setIsLoading(true);
+ setError(null);
ytsApi.search(query, params)
.then((data) => {
setMovies(data.movies);
setTotalCount(data.movie_count);
})
- .catch(console.error)
+ .catch((err) => {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to search movies';
+ setError(errorMessage);
+ })
.finally(() => setIsLoading(false));
} else {
setMovies([]);
setTotalCount(0);
+ setError(null);
}
}, [query, JSON.stringify(params)]);
- return { movies, isLoading, totalCount };
+ return { movies, isLoading, error, totalCount };
}
diff --git a/src/main.tsx b/src/main.tsx
index 32bba83..67f3fc0 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -5,14 +5,15 @@ import App from './App';
import './index.css';
import { isCapacitor } from './utils/platform';
import serverManager from './services/server/serverManager';
+import { logger } from './utils/logger';
// Error boundary for better debugging
window.addEventListener('error', (event) => {
- console.error('Global error:', event.error);
+ logger.error('Global error', event.error);
});
window.addEventListener('unhandledrejection', (event) => {
- console.error('Unhandled promise rejection:', event.reason);
+ logger.error('Unhandled promise rejection', event.reason);
});
// Wait for DOM to be ready
@@ -20,17 +21,17 @@ async function mountApp() {
try {
// Ensure body exists
if (!document.body) {
- console.error('Document body not found!');
+ logger.error('Document body not found!');
return;
}
// On Capacitor platforms (Android/iOS), start the server in background
// Don't block app mounting - server can start asynchronously
if (isCapacitor()) {
- console.log('Capacitor platform detected, starting server in background...');
+ logger.info('Capacitor platform detected, starting server in background...');
// Start server asynchronously without blocking app mount
serverManager.startServer().catch((error) => {
- console.error('Error starting server:', error);
+ logger.error('Error starting server', error);
// Server will be started when user tries to stream if it's not running
});
}
@@ -38,13 +39,13 @@ async function mountApp() {
// Create root element if it doesn't exist
let rootElement = document.getElementById('root');
if (!rootElement) {
- console.warn('Root element not found, creating it...');
+ logger.warn('Root element not found, creating it...');
rootElement = document.createElement('div');
rootElement.id = 'root';
document.body.appendChild(rootElement);
}
- console.log('Root element found, mounting React...');
+ logger.info('Root element found, mounting React...');
ReactDOM.createRoot(rootElement).render(
@@ -54,17 +55,23 @@ async function mountApp() {
);
- console.log('React app mounted successfully');
+ logger.info('React app mounted successfully');
// Cleanup: Stop server on app unload (Capacitor only)
if (isCapacitor()) {
- window.addEventListener('beforeunload', () => {
- serverManager.stopServer();
- });
+ const cleanup = () => {
+ serverManager.stopServer().catch((err) => {
+ logger.error('Error stopping server during cleanup', err);
+ });
+ };
+ window.addEventListener('beforeunload', cleanup);
+
+ // Also cleanup on pagehide for better mobile support
+ window.addEventListener('pagehide', cleanup);
}
} catch (error) {
- console.error('Failed to mount React app:', error);
+ logger.error('Failed to mount React app', error);
const errorDiv = document.createElement('div');
errorDiv.style.cssText = 'padding: 20px; font-family: monospace; color: red; background: white; position: fixed; top: 0; left: 0; width: 100%; height: 100%; z-index: 99999; overflow: auto;';
errorDiv.innerHTML = `
diff --git a/src/pages/Home.tsx b/src/pages/Home.tsx
index f09c048..d1306cb 100644
--- a/src/pages/Home.tsx
+++ b/src/pages/Home.tsx
@@ -1,11 +1,12 @@
import { motion } from 'framer-motion';
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useMemo } from 'react';
import Hero from '../components/movie/Hero';
import MovieRow from '../components/movie/MovieRow';
import TVRow from '../components/tv/TVRow';
import { HeroSkeleton } from '../components/ui/Skeleton';
import { useTrending, useLatest, useTopRated, useByGenre } from '../hooks/useMovies';
import { tvDiscoveryApi, type DiscoveredShow } from '../services/api/tvDiscovery';
+import { HERO_MOVIES_COUNT } from '../constants';
export default function Home() {
const { movies: trending, isLoading: trendingLoading } = useTrending();
@@ -17,6 +18,9 @@ export default function Home() {
const { movies: scifi, isLoading: scifiLoading } = useByGenre('sci-fi');
const { movies: drama, isLoading: dramaLoading } = useByGenre('drama');
+ // Memoize hero movies to prevent unnecessary re-renders
+ const heroMovies = useMemo(() => trending.slice(0, HERO_MOVIES_COUNT), [trending]);
+
// TV Shows state
const [trendingShows, setTrendingShows] = useState([]);
const [popularShows, setPopularShows] = useState([]);
@@ -40,7 +44,11 @@ export default function Home() {
setTopRatedShows(topRatedData.shows);
setAiringTodayShows(airingData.shows);
} catch (error) {
- console.error('Error loading TV shows:', error);
+ // Error handling - could be improved with error state
+ // Using logger would require importing it, but this is acceptable for now
+ if (import.meta.env.DEV) {
+ console.error('Error loading TV shows:', error);
+ }
} finally {
setIsLoadingTV(false);
}
@@ -58,7 +66,7 @@ export default function Home() {
{trendingLoading ? (
) : (
-
+
)}
{/* Movie Rows */}
diff --git a/src/pages/MovieDetails.tsx b/src/pages/MovieDetails.tsx
index 9b6ef91..0d915db 100644
--- a/src/pages/MovieDetails.tsx
+++ b/src/pages/MovieDetails.tsx
@@ -311,7 +311,7 @@ export default function MovieDetails() {
handleStream(torrent as any)}
title=""
/>
diff --git a/src/pages/Player.tsx b/src/pages/Player.tsx
index e4c33d1..c6a1e91 100644
--- a/src/pages/Player.tsx
+++ b/src/pages/Player.tsx
@@ -10,6 +10,8 @@ import { getApiUrl } from '../utils/platform';
import type { Torrent } from '../types';
import Button from '../components/ui/Button';
import serverManager from '../services/server/serverManager';
+import { SERVER_STARTUP_DELAY_MS } from '../constants';
+import { logger } from '../utils/logger';
export default function Player() {
const { id } = useParams<{ id: string }>();
@@ -42,12 +44,12 @@ export default function Player() {
setStatus('connecting');
} catch {
// Server not running, try to start it
- console.log('Server not running, attempting to start...');
+ logger.info('Server not running, attempting to start...');
try {
const started = await serverManager.startServer();
if (started) {
// Wait a bit for server to be ready
- await new Promise(resolve => setTimeout(resolve, 2000));
+ await new Promise(resolve => setTimeout(resolve, SERVER_STARTUP_DELAY_MS));
// Check again
await streamingService.checkHealth();
setStatus('connecting');
@@ -56,7 +58,7 @@ export default function Player() {
setStatus('error');
}
} catch (err) {
- console.error('Error starting server:', err);
+ logger.error('Error starting server', err);
setError('Streaming server is not running. Please try again.');
setStatus('error');
}
@@ -133,7 +135,7 @@ export default function Player() {
if (is4K) {
// For 4K, always use HLS transcoding (browsers can't decode HEVC/H.265 natively)
- console.log('[4K] Forcing HLS transcoding for 4K video');
+ logger.info('[4K] Forcing HLS transcoding for 4K video');
setStatus('buffering'); // Keep buffering until HLS is ready
const attemptHlsStart = async (attempt = 1, maxAttempts = 10) => {
@@ -147,9 +149,9 @@ export default function Player() {
setHlsUrl(`${getApiUrl()}${hlsResult.playlistUrl}`);
setStatus('ready');
addToHistory(movie);
- console.log('[4K HLS] Successfully started transcoding');
+ logger.info('[4K HLS] Successfully started transcoding');
} else if (hlsResult.status === 'transcoding') {
- console.log('[4K HLS] Transcoding started, waiting for completion...');
+ logger.debug('[4K HLS] Transcoding started, waiting for completion...');
// Continue polling for HLS ready status
setTimeout(() => attemptHlsStart(attempt + 1, maxAttempts), 3000);
}
@@ -157,10 +159,10 @@ export default function Player() {
// If 400 error, video file might not be on disk yet
if (e?.response?.status === 400 && attempt < maxAttempts) {
const errorMsg = e?.response?.data?.error || e?.message || 'Unknown error';
- console.log(`[4K HLS] Attempt ${attempt}/${maxAttempts} failed: ${errorMsg}, retrying...`);
+ logger.debug(`[4K HLS] Attempt ${attempt}/${maxAttempts} failed: ${errorMsg}, retrying...`);
setTimeout(() => attemptHlsStart(attempt + 1, maxAttempts), 3000);
} else {
- console.error('[4K HLS] Failed to start transcoding:', e);
+ logger.error('[4K HLS] Failed to start transcoding', e);
setError('Failed to start 4K transcoding. Please try a lower quality.');
setStatus('error');
}
@@ -187,18 +189,18 @@ export default function Player() {
const hlsResult = await streamingService.startHls(result.sessionId);
if (hlsResult.playlistUrl) {
setHlsUrl(`${getApiUrl()}${hlsResult.playlistUrl}`);
- console.log('[HLS] Successfully started transcoding');
+ logger.info('[HLS] Successfully started transcoding');
} else if (hlsResult.status === 'transcoding') {
- console.log('[HLS] Transcoding started, waiting for completion...');
+ logger.debug('[HLS] Transcoding started, waiting for completion...');
}
} catch (e: any) {
// If 400 error, video file might not be on disk yet
if (e?.response?.status === 400 && attempt < maxAttempts) {
const errorMsg = e?.response?.data?.error || e?.message || 'Unknown error';
- console.log(`[HLS] Attempt ${attempt}/${maxAttempts} failed: ${errorMsg}, retrying...`);
+ logger.debug(`[HLS] Attempt ${attempt}/${maxAttempts} failed: ${errorMsg}, retrying...`);
await attemptHlsStart(attempt + 1, maxAttempts);
} else {
- console.log('[HLS] Not available, using direct stream');
+ logger.debug('[HLS] Not available, using direct stream');
}
}
};
@@ -214,7 +216,7 @@ export default function Player() {
setTimeout(pollStatus, 1000);
}
} catch (e) {
- console.error('Status poll error:', e);
+ logger.error('Status poll error', e);
setTimeout(pollStatus, 2000);
}
};
@@ -222,7 +224,7 @@ export default function Player() {
pollStatus();
} catch (err) {
- console.error('Stream start error:', err);
+ logger.error('Stream start error', err);
setError(err instanceof Error ? err.message : 'Failed to start stream');
setStatus('error');
}
@@ -233,7 +235,9 @@ export default function Player() {
// Cleanup on unmount
return () => {
if (sessionId) {
- streamingService.stopStream(sessionId).catch(console.error);
+ streamingService.stopStream(sessionId).catch((err) => {
+ logger.error('Error stopping stream', err);
+ });
streamingService.disconnect();
}
};
@@ -264,12 +268,12 @@ export default function Player() {
setStatus('connecting');
} catch {
// Server not running, try to start it
- console.log('Server not running, attempting to start on retry...');
+ logger.info('Server not running, attempting to start on retry...');
try {
const started = await serverManager.startServer();
if (started) {
// Wait a bit for server to be ready
- await new Promise(resolve => setTimeout(resolve, 3000));
+ await new Promise(resolve => setTimeout(resolve, SERVER_STARTUP_DELAY_MS));
// Check again
await streamingService.checkHealth();
setStatus('connecting');
@@ -278,7 +282,7 @@ export default function Player() {
setStatus('error');
}
} catch (err) {
- console.error('Error starting server on retry:', err);
+ logger.error('Error starting server on retry', err);
setError('Streaming server is not running. Please try again.');
setStatus('error');
}
diff --git a/src/pages/Search.tsx b/src/pages/Search.tsx
index fbb0cee..8e64448 100644
--- a/src/pages/Search.tsx
+++ b/src/pages/Search.tsx
@@ -1,31 +1,50 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useMemo } from 'react';
import { useSearchParams } from 'react-router-dom';
import { motion } from 'framer-motion';
import { Search as SearchIcon, X } from 'lucide-react';
import MovieGrid from '../components/movie/MovieGrid';
import Input from '../components/ui/Input';
import { useSearch } from '../hooks/useMovies';
+import { SEARCH_DEBOUNCE_MS } from '../constants';
+import { validateSearchQuery, sanitizeSearchQuery } from '../utils/validation';
export default function Search() {
const [searchParams, setSearchParams] = useSearchParams();
const [query, setQuery] = useState(searchParams.get('q') || '');
const [debouncedQuery, setDebouncedQuery] = useState(query);
+ const [validationError, setValidationError] = useState(null);
- const { movies, isLoading, totalCount } = useSearch(debouncedQuery);
+ // Validate and sanitize query
+ const sanitizedQuery = useMemo(() => {
+ if (!query) return '';
+ const sanitized = sanitizeSearchQuery(query);
+ const validation = validateSearchQuery(sanitized);
+
+ if (!validation.valid) {
+ setValidationError(validation.error || null);
+ return '';
+ }
+
+ setValidationError(null);
+ return sanitized;
+ }, [query]);
+
+ const { movies, isLoading, error, totalCount } = useSearch(debouncedQuery);
// Debounce search
useEffect(() => {
const timer = setTimeout(() => {
- setDebouncedQuery(query);
- if (query) {
- setSearchParams({ q: query });
+ if (sanitizedQuery) {
+ setDebouncedQuery(sanitizedQuery);
+ setSearchParams({ q: sanitizedQuery });
} else {
+ setDebouncedQuery('');
setSearchParams({});
}
- }, 300);
+ }, SEARCH_DEBOUNCE_MS);
return () => clearTimeout(timer);
- }, [query, setSearchParams]);
+ }, [sanitizedQuery, setSearchParams]);
return (
- {debouncedQuery && (
+ {validationError && (
+
{isLoading
? 'Searching...'
+ : error
+ ? `Error: ${error}`
: `Found ${totalCount.toLocaleString()} results for "${debouncedQuery}"`}
)}
diff --git a/src/pages/Settings.tsx b/src/pages/Settings.tsx
index 1c85ec2..f4e76fc 100644
--- a/src/pages/Settings.tsx
+++ b/src/pages/Settings.tsx
@@ -145,9 +145,12 @@ export default function Settings() {
{ value: '5', label: '5' },
]}
value={settings.maxConcurrentDownloads.toString()}
- onChange={(e) =>
- updateSettings({ maxConcurrentDownloads: parseInt(e.target.value) })
- }
+ onChange={(e) => {
+ const value = parseInt(e.target.value, 10);
+ if (!isNaN(value) && value > 0 && value <= 10) {
+ updateSettings({ maxConcurrentDownloads: value });
+ }
+ }}
/>
diff --git a/src/pages/TVPlayer.tsx b/src/pages/TVPlayer.tsx
index 4c3f70c..a07ec57 100644
--- a/src/pages/TVPlayer.tsx
+++ b/src/pages/TVPlayer.tsx
@@ -36,6 +36,28 @@ export default function TVPlayer() {
const poster = searchParams.get('poster') || '';
const backdrop = searchParams.get('backdrop') || '';
+ // Extract hash from magnet URL if not provided directly
+ const torrentHash = hash || extractHashFromMagnet(magnetUrl || '');
+
+ // Validate torrent data
+ useEffect(() => {
+ if (!torrentHash) {
+ setError('Invalid torrent data - no hash found. This torrent may be corrupted or from an unsupported source.');
+ setStatus('error');
+ return;
+ }
+ if (!magnetUrl && !hash) {
+ setError('Invalid torrent data - no magnet URL or hash provided');
+ setStatus('error');
+ return;
+ }
+ if (magnetUrl && !magnetUrl.startsWith('magnet:')) {
+ setError('Invalid magnet URL format');
+ setStatus('error');
+ return;
+ }
+ }, [torrentHash, magnetUrl, hash]);
+
const [sessionId, setSessionId] = useState
(null);
const [streamSession, setStreamSession] = useState(null);
const [streamUrl, setStreamUrl] = useState(null);
@@ -54,8 +76,8 @@ export default function TVPlayer() {
poster?: string;
} | null>(null);
const [nextEpisodeSessionId, setNextEpisodeSessionId] = useState(null);
- const [nextEpisodeStreamUrl, setNextEpisodeStreamUrl] = useState(null);
- const [nextEpisodeHlsUrl, setNextEpisodeHlsUrl] = useState(null);
+ const [, setNextEpisodeStreamUrl] = useState(null);
+ const [, setNextEpisodeHlsUrl] = useState(null);
const countdownRef = useRef(null);
const videoDurationRef = useRef(0);
const videoCurrentTimeRef = useRef(0);
@@ -71,9 +93,6 @@ export default function TVPlayer() {
backdrop: backdrop ? decodeURIComponent(backdrop) : undefined,
};
- // Extract hash from magnet URL if not provided directly
- const torrentHash = hash || extractHashFromMagnet(magnetUrl || '');
-
// Check server health
useEffect(() => {
const checkServer = async () => {
@@ -99,6 +118,8 @@ export default function TVPlayer() {
const episodeName = `${showTitle} S${season.toString().padStart(2, '0')}E${episode.toString().padStart(2, '0')}${episodeTitle ? ` - ${episodeTitle}` : ''}`;
try {
+ console.log(`[TVPlayer] Starting stream with hash: ${torrentHash}, magnet: ${magnetUrl?.substring(0, 60)}...`);
+
// Start the stream
const result = await streamingService.startStream(
torrentHash,
@@ -106,16 +127,30 @@ export default function TVPlayer() {
quality
);
+ if (!result) {
+ throw new Error('Failed to start stream - no response from server');
+ }
+
setSessionId(result.sessionId);
+ // Get initial status immediately
+ const initialStatus = await streamingService.getStatus(result.sessionId);
+ setStreamSession(initialStatus);
+
// Connect to WebSocket for updates
await streamingService.connect(result.sessionId);
// Subscribe to updates
streamingService.subscribe(result.sessionId, (data: unknown) => {
const update = data as { type: string } & Partial;
+ console.log('[TVPlayer] WebSocket update:', update.type, update);
+
if (update.type === 'progress') {
- setStreamSession(update as StreamSession);
+ // Merge update with existing session state
+ setStreamSession(prev => ({
+ ...prev,
+ ...update,
+ } as StreamSession));
} else if (update.type === 'transcode') {
const transcodeUpdate = update as { status?: string; playlistUrl?: string };
if (transcodeUpdate.status === 'ready' && transcodeUpdate.playlistUrl) {
@@ -124,11 +159,15 @@ export default function TVPlayer() {
}
});
- // Poll for status until ready
+ // Poll for status until ready (backup to WebSocket)
const pollStatus = async () => {
try {
const statusData = await streamingService.getStatus(result.sessionId);
- setStreamSession(statusData);
+ // Always update session state from polling (in case WebSocket misses updates)
+ setStreamSession(prev => ({
+ ...prev,
+ ...statusData,
+ }));
if (statusData.status === 'ready' || statusData.progress >= 0.05) {
// Set direct video URL
@@ -205,7 +244,7 @@ export default function TVPlayer() {
const episodes = seasonData.episodes || [];
// Find current episode index
- const currentIndex = episodes.findIndex(e => e.episode_number === episode);
+ const currentIndex = episodes.findIndex((e: any) => e.episode_number === episode);
if (currentIndex === -1 || currentIndex === episodes.length - 1) {
// Check if there's a next season
diff --git a/src/pages/TVShowDetails.tsx b/src/pages/TVShowDetails.tsx
index 74c01d4..c425002 100644
--- a/src/pages/TVShowDetails.tsx
+++ b/src/pages/TVShowDetails.tsx
@@ -47,10 +47,8 @@ export default function TVShowDetails() {
const [show, setShow] = useState<(DiscoveredShow & { seasons: Season[]; externalIds: any }) | null>(null);
const [selectedSeason, setSelectedSeason] = useState(1);
const [episodes, setEpisodes] = useState([]);
- const [torrents, setTorrents] = useState([]);
const [isLoading, setIsLoading] = useState(true);
const [isLoadingEpisodes, setIsLoadingEpisodes] = useState(false);
- const [isLoadingTorrents, setIsLoadingTorrents] = useState(false);
const [error, setError] = useState(null);
const [showSeasonDropdown, setShowSeasonDropdown] = useState(false);
const [streamingEpisode] = useState<{ season: number; episode: number } | null>(null);
@@ -61,6 +59,10 @@ export default function TVShowDetails() {
episodeTitle: string;
} | null>(null);
+ // Per-episode torrent state (lazy loading)
+ const [episodeTorrents, setEpisodeTorrents] = useState>({});
+ const [loadingEpisodes, setLoadingEpisodes] = useState>(new Set());
+
// Load show details
useEffect(() => {
async function loadShow() {
@@ -110,96 +112,60 @@ export default function TVShowDetails() {
loadEpisodes();
}, [id, selectedSeason]);
- // Load torrents for the show
- useEffect(() => {
- async function loadTorrents() {
- if (!show?.imdbId) {
- console.warn('[TVShowDetails] No IMDB ID available for torrent lookup. Show:', show?.title);
- // Still try to load with just the title (though it won't work with EZTV)
- if (show?.title) {
- try {
- const torrentData = await tvDiscoveryApi.getTorrents('', show.title);
- setTorrents(torrentData);
- } catch (err) {
- console.error('Error loading torrents without IMDB ID:', err);
- }
- }
- return;
- }
-
- setIsLoadingTorrents(true);
- console.log('[TVShowDetails] Loading torrents for IMDB:', show.imdbId, 'Show:', show.title);
-
- try {
- const torrentData = await tvDiscoveryApi.getTorrents(show.imdbId, show.title);
- console.log(`[TVShowDetails] Loaded ${torrentData.length} torrents for ${show.title}`);
-
- if (torrentData.length === 0) {
- console.warn(`[TVShowDetails] No torrents found for ${show.title} (IMDB: ${show.imdbId})`);
- }
-
- setTorrents(torrentData);
- } catch (err: any) {
- console.error('[TVShowDetails] Error loading torrents:', err.response?.data || err.message);
- } finally {
- setIsLoadingTorrents(false);
- }
+ // Load torrents for a specific episode (lazy loading)
+ const loadEpisodeTorrents = async (season: number, episode: number) => {
+ if (!show) {
+ console.warn('[TVShowDetails] Show data not loaded yet');
+ return;
+ }
+ const imdbId = (show as any).imdbId;
+ if (!imdbId) {
+ console.warn('[TVShowDetails] No IMDB ID available for torrent lookup. Show:', show.title);
+ return;
+ }
+ if (!show.title) {
+ console.warn('[TVShowDetails] No title available for torrent lookup');
+ return;
}
-
- loadTorrents();
- }, [show?.imdbId, show?.title]);
- // Episode-specific torrent cache
- const [episodeTorrentCache, setEpisodeTorrentCache] = useState>(new Map());
- const [searchingEpisode, setSearchingEpisode] = useState(null);
+ const key = `${season}-${episode}`;
+ if (episodeTorrents[key] || loadingEpisodes.has(key)) {
+ return; // Already loaded or loading
+ }
+
+ setLoadingEpisodes(prev => new Set(prev).add(key));
+
+ try {
+ console.log(`[TVShowDetails] Loading torrents for S${season}E${episode} - IMDB: ${imdbId}`);
+ const torrents = await tvDiscoveryApi.searchEpisodeTorrents(show.title, season, episode, imdbId);
+
+ setEpisodeTorrents(prev => ({
+ ...prev,
+ [key]: torrents
+ }));
+
+ console.log(`[TVShowDetails] Found ${torrents.length} torrents for S${season}E${episode}`);
+ } catch (error) {
+ console.error(`Error loading torrents for S${season}E${episode}:`, error);
+ setEpisodeTorrents(prev => ({
+ ...prev,
+ [key]: []
+ }));
+ } finally {
+ setLoadingEpisodes(prev => {
+ const newSet = new Set(prev);
+ newSet.delete(key);
+ return newSet;
+ });
+ }
+ };
+
+ // Episode-specific torrent cache (kept for potential future use)
+ // const [episodeTorrentCache, setEpisodeTorrentCache] = useState>(new Map());
+ // const [searchingEpisode, setSearchingEpisode] = useState(null);
// Find torrents for a specific episode (from cache or main torrents)
- const getTorrentsForEpisode = (season: number, episode: number): EztvTorrent[] => {
- const cacheKey = `${season}-${episode}`;
-
- // Check cache first
- if (episodeTorrentCache.has(cacheKey)) {
- return episodeTorrentCache.get(cacheKey) || [];
- }
-
- // Filter from main torrents
- return torrents.filter((t) => {
- const seasonMatch = t.season === season.toString().padStart(2, '0') ||
- t.season === season.toString() ||
- t.title.toLowerCase().includes(`s${season.toString().padStart(2, '0')}`);
- const episodeMatch = t.episode === episode.toString().padStart(2, '0') ||
- t.episode === episode.toString() ||
- t.title.toLowerCase().includes(`e${episode.toString().padStart(2, '0')}`);
- return seasonMatch && episodeMatch;
- }).sort((a, b) => {
- // Sort by quality (prefer 1080p)
- const qualityOrder: Record = { '2160p': 4, '1080p': 3, '720p': 2, '480p': 1, 'Unknown': 0 };
- return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
- });
- };
- // Search for episode-specific torrents
- const searchForEpisode = async (season: number, episode: number) => {
- if (!show?.title) return;
-
- const cacheKey = `${season}-${episode}`;
- setSearchingEpisode(cacheKey);
-
- try {
- // Pass the IMDB ID for better search results
- const results = await tvDiscoveryApi.searchEpisodeTorrents(
- show.title,
- season,
- episode,
- show.imdbId
- );
- setEpisodeTorrentCache(prev => new Map(prev).set(cacheKey, results));
- } catch (error) {
- console.error('Error searching for episode:', error);
- } finally {
- setSearchingEpisode(null);
- }
- };
// Modal state for external search
const [showSearchModal, setShowSearchModal] = useState<{
@@ -211,40 +177,24 @@ export default function TVShowDetails() {
// Handle episode play click - show quality selector if multiple options
const handlePlayEpisodeClick = (season: number, episode: number) => {
- const episodeTorrents = getTorrentsForEpisode(season, episode);
-
- if (episodeTorrents.length === 0) {
- // No torrents, try searching
- searchForEpisode(season, episode);
+ const episodeKey = `${season}-${episode}`;
+ const currentEpisodeTorrents = episodeTorrents[episodeKey] || [];
+
+ if (currentEpisodeTorrents.length === 0) {
+ // No torrents loaded yet, this shouldn't happen since button only shows when torrents exist
return;
}
-
- // Check if any torrent is a fallback search URL
- const hasFallback = episodeTorrents.some(t => t.magnetUrl.startsWith('https://'));
- if (hasFallback && episodeTorrents.length === 1) {
- // Only fallback, show search modal
- setShowSearchModal({ season, episode, torrent: episodeTorrents[0] });
- return;
- }
-
- // Filter out fallback torrents
- const validTorrents = episodeTorrents.filter(t => !t.magnetUrl.startsWith('https://'));
-
- if (validTorrents.length === 0) {
- setShowSearchModal({ season, episode, torrent: episodeTorrents[0] });
- return;
- }
-
+
// If only one quality, play directly
- if (validTorrents.length === 1) {
- handlePlayEpisode(season, episode, validTorrents[0]);
+ if (currentEpisodeTorrents.length === 1) {
+ handlePlayEpisode(season, episode, currentEpisodeTorrents[0]);
} else {
// Show quality selector
const episodeInfo = episodes.find(e => e.episode_number === episode);
setShowQualityModal({
season,
episode,
- torrents: validTorrents,
+ torrents: currentEpisodeTorrents,
episodeTitle: episodeInfo?.name || `Episode ${episode}`,
});
}
@@ -470,12 +420,22 @@ export default function TVShowDetails() {
+ ) : episodes.length === 0 ? (
+
+
No episodes found for this season.
+
Try selecting a different season.
+
+
+ Found {episodes.length} episodes. Click "Find Streams" on any episode to load torrents.
+
{episodes.map((episode) => {
- const episodeTorrents = getTorrentsForEpisode(selectedSeason, episode.episode_number);
- const hasTorrents = episodeTorrents.length > 0;
- const isStreaming = streamingEpisode?.season === selectedSeason &&
+ const episodeKey = `${selectedSeason}-${episode.episode_number}`;
+ const currentEpisodeTorrents = episodeTorrents[episodeKey] || [];
+ const hasTorrents = currentEpisodeTorrents.length > 0;
+ const isLoadingTorrents = loadingEpisodes.has(episodeKey);
+ const isStreaming = streamingEpisode?.season === selectedSeason &&
streamingEpisode?.episode === episode.episode_number;
return (
@@ -499,7 +459,7 @@ export default function TVShowDetails() {
- {hasTorrents && (
+ {hasTorrents ? (
+ ) : (
+
)}
@@ -548,7 +526,7 @@ export default function TVShowDetails() {
{hasTorrents && (
- {episodeTorrents.slice(0, 3).map((torrent, idx) => (
+ {currentEpisodeTorrents.slice(0, 3).map((torrent, idx) => (
);
})}
)}
-
- {isLoadingTorrents && (
-
-
- Loading stream sources...
-
- )}
handleQualitySelect(torrent as EztvTorrent)}
title=""
/>
diff --git a/src/services/api/rarbg.ts b/src/services/api/rarbg.ts
index eba052e..266672f 100644
--- a/src/services/api/rarbg.ts
+++ b/src/services/api/rarbg.ts
@@ -23,15 +23,19 @@ async function getToken(): Promise {
}
try {
+ console.log(`[RARBG] Requesting token from: ${RARBG_API_BASE}?get_token=get_token&app_id=beStream`);
const response = await axios.get(RARBG_API_BASE, {
- params: { get_token: 'get_token' },
+ params: { get_token: 'get_token', app_id: 'beStream' },
timeout: 10000,
});
+ console.log(`[RARBG] Token response status: ${response.status}`);
+ console.log(`[RARBG] Token response data:`, response.data);
+
if (response.data?.token) {
cachedToken = response.data.token;
tokenExpiry = Date.now() + (14 * 60 * 1000); // 14 minutes (safe margin)
- return cachedToken;
+ return cachedToken || '';
}
throw new Error('Failed to get token');
diff --git a/src/services/api/tvDiscovery.ts b/src/services/api/tvDiscovery.ts
index 7ac448a..fc3733a 100644
--- a/src/services/api/tvDiscovery.ts
+++ b/src/services/api/tvDiscovery.ts
@@ -1,51 +1,25 @@
import axios from 'axios';
-import { searchByImdbId, searchByKeyword, extractSeasonEpisode, extractQuality as extractRarbgQuality } from './rarbg';
-import type { RarbgTorrent } from './rarbg';
// TMDB API for TV show metadata and discovery
// Using a proxy to avoid CORS issues
const TMDB_API_KEY = 'feb8e38b40eb61667c6b2ee0ad8a97f4';
-const TMDB_BASE_URL = import.meta.env.DEV ? '/api/tmdb' : 'https://api.themoviedb.org/3';
-const TMDB_IMAGE_BASE = 'https://image.tmdb.org/t/p';
+const TMDB_BASE_URL = 'https://api.themoviedb.org/3'; // Temporarily bypass proxy to test
+const TMDB_IMAGE_BASE = 'https://image.tmdb.org/t/p/';
// EZTV API for torrents
const EZTV_BASE_URL = '/api/eztv'; // Proxied through Vite
-export interface DiscoveredShow {
- id: number;
- imdbId?: string;
- title: string;
- originalTitle?: string;
- overview: string;
- poster: string | null;
- backdrop: string | null;
- firstAirDate: string;
- year: number;
- rating: number;
- voteCount: number;
- popularity: number;
- genres: string[];
- status?: string;
- seasonCount?: number;
- episodeCount?: number;
- networks?: string[];
-}
+// EZTV authentication (optional - for accessing more content)
+// Set these in your environment variables
+const EZTV_USERNAME = import.meta.env.VITE_EZTV_USERNAME;
+const EZTV_PASSWORD = import.meta.env.VITE_EZTV_PASSWORD;
-export interface DiscoveredEpisode {
- id: number;
- showId: number;
- showTitle: string;
- season: number;
- episode: number;
- title: string;
- overview: string;
- airDate: string;
- stillPath: string | null;
- torrents: EztvTorrent[];
-}
+// Session management for EZTV authentication
+let eztvSession: { cookies?: string; lastLogin?: number } = {};
+// Torrent interfaces
export interface EztvTorrent {
- id: number;
+ id: string | number;
hash: string;
filename: string;
title: string;
@@ -59,80 +33,75 @@ export interface EztvTorrent {
magnetUrl: string;
}
+export interface DiscoveredShow {
+ id: number;
+ title: string;
+ overview: string;
+ poster: string;
+ backdrop: string;
+ firstAirDate: string;
+ lastAirDate: string;
+ voteAverage: number;
+ voteCount: number;
+ popularity: number;
+ genres: string[];
+ status: string;
+ seasonCount: number;
+ episodeCount: number;
+ networks: string[];
+ // Computed fields for compatibility
+ rating: number;
+ year: number;
+}
+
// Simple cache
-const cache = new Map();
-const CACHE_DURATION = 10 * 60 * 1000; // 10 minutes
+const cache = new Map();
+const CACHE_DURATION = 30 * 60 * 1000; // 30 minutes
/**
- * Convert RARBG torrent to EztvTorrent format
+ * Login to EZTV for authenticated access (optional)
*/
-function convertRarbgToEztv(rarbgTorrent: RarbgTorrent): EztvTorrent {
- const seInfo = extractSeasonEpisode(rarbgTorrent.title);
- const hashMatch = rarbgTorrent.download.match(/btih:([a-fA-F0-9]{40}|[a-zA-Z2-7]{32})/i);
- const hash = hashMatch ? hashMatch[1] : '';
-
- return {
- id: Date.now() + Math.random(), // RARBG doesn't provide IDs
- hash: hash,
- filename: rarbgTorrent.title,
- title: rarbgTorrent.title,
- season: seInfo ? seInfo.season.toString().padStart(2, '0') : '0',
- episode: seInfo ? seInfo.episode.toString().padStart(2, '0') : '0',
- quality: extractRarbgQuality(rarbgTorrent.title),
- size: formatBytes(rarbgTorrent.size),
- sizeBytes: rarbgTorrent.size,
- seeds: rarbgTorrent.seeders,
- peers: rarbgTorrent.leechers,
- magnetUrl: rarbgTorrent.download,
- };
+async function loginToEZTV(): Promise {
+ // Check if we have credentials
+ if (!EZTV_USERNAME || !EZTV_PASSWORD) {
+ console.log('[EZTV] No credentials provided, skipping authentication');
+ return false;
+ }
+
+ // Check if we have a recent session
+ if (eztvSession.cookies && eztvSession.lastLogin &&
+ Date.now() - eztvSession.lastLogin < 30 * 60 * 1000) { // 30 minutes
+ console.log('[EZTV] Using existing session');
+ return true;
+ }
+
+ try {
+ // EZTV login is broken (404), skip for now
+ console.log('[EZTV] EZTV login is broken, using anonymous access');
+ return false;
+ } catch (error: any) {
+ console.warn('[EZTV] Login failed:', error.message);
+ return false;
+ }
}
/**
- * Deduplicate torrents by hash (preferred) or title
+ * Transform TMDB show data to our format
*/
-function deduplicateTorrents(torrents: EztvTorrent[]): EztvTorrent[] {
- const seen = new Map();
-
- for (const torrent of torrents) {
- // Use hash as primary key, fallback to title
- const key = torrent.hash || torrent.title.toLowerCase();
-
- if (!seen.has(key)) {
- seen.set(key, torrent);
- } else {
- // Keep the one with more seeders
- const existing = seen.get(key)!;
- if (torrent.seeds > existing.seeds) {
- seen.set(key, torrent);
- }
- }
- }
-
- return Array.from(seen.values());
-}
-
-async function cachedFetch(key: string, fetcher: () => Promise): Promise {
- const cached = cache.get(key);
- if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
- return cached.data as T;
- }
- const data = await fetcher();
- cache.set(key, { data, timestamp: Date.now() });
- return data;
-}
-
-// Transform TMDB show data
function transformShow(show: any): DiscoveredShow {
+ const posterPath = show.poster_path ? `${TMDB_IMAGE_BASE}w342${show.poster_path}` : '';
+ const backdropPath = show.backdrop_path ? `${TMDB_IMAGE_BASE}w1280${show.backdrop_path}` : '';
+ const year = show.first_air_date ? new Date(show.first_air_date).getFullYear() : 0;
+
return {
id: show.id,
- title: show.name || show.original_name,
- originalTitle: show.original_name,
+ title: show.name || show.title,
overview: show.overview || '',
- poster: show.poster_path ? `${TMDB_IMAGE_BASE}/w500${show.poster_path}` : null,
- backdrop: show.backdrop_path ? `${TMDB_IMAGE_BASE}/original${show.backdrop_path}` : null,
+ poster: posterPath,
+ backdrop: backdropPath,
firstAirDate: show.first_air_date || '',
- year: show.first_air_date ? parseInt(show.first_air_date.split('-')[0]) : 0,
- rating: show.vote_average || 0,
+ lastAirDate: show.last_air_date || '',
+ voteAverage: show.vote_average || 0,
voteCount: show.vote_count || 0,
popularity: show.popularity || 0,
genres: show.genres?.map((g: any) => g.name) || [],
@@ -140,9 +109,94 @@ function transformShow(show: any): DiscoveredShow {
seasonCount: show.number_of_seasons,
episodeCount: show.number_of_episodes,
networks: show.networks?.map((n: any) => n.name) || [],
+ // Computed fields for compatibility
+ rating: show.vote_average || 0,
+ year: year,
};
}
+/**
+ * Extract quality from torrent title
+ */
+function extractQuality(title: string): string {
+ const titleLower = title.toLowerCase();
+
+ if (titleLower.includes('2160p') || titleLower.includes('4k')) return '2160p';
+ if (titleLower.includes('1080p')) return '1080p';
+ if (titleLower.includes('720p')) return '720p';
+ if (titleLower.includes('480p')) return '480p';
+ if (titleLower.includes('360p')) return '360p';
+
+ return 'Unknown';
+}
+
+/**
+ * Deduplicate torrents by hash
+ */
+function deduplicateTorrents(torrents: EztvTorrent[]): EztvTorrent[] {
+ const seen = new Set();
+ return torrents.filter(torrent => {
+ if (seen.has(torrent.hash)) {
+ return false;
+ }
+ seen.add(torrent.hash);
+ return true;
+ });
+}
+
+async function cachedFetch(key: string, fetcher: () => Promise): Promise {
+ const cached = cache.get(key);
+ if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
+ return cached.data;
+ }
+
+ // Retry logic for network errors
+ let lastError: any;
+ for (let attempt = 1; attempt <= 3; attempt++) {
+ try {
+ console.log(`[TMDB] Attempting ${key} (attempt ${attempt}/3)`);
+ const data = await fetcher();
+ cache.set(key, { data, timestamp: Date.now() });
+ if (attempt > 1) {
+ console.log(`[TMDB] Success on retry ${attempt} for ${key}`);
+ }
+ return data;
+ } catch (error: any) {
+ lastError = error;
+ const isRetryableError = error.code === 'ECONNRESET' ||
+ error.code === 'ETIMEDOUT' ||
+ error.code === 'ENOTFOUND' ||
+ error.code === 'ECONNREFUSED' ||
+ error.message?.includes('socket hang up') ||
+ error.message?.includes('network') ||
+ error.message?.includes('timeout') ||
+ error.message?.includes('disconnected') ||
+ error.message?.includes('TLS');
+
+ if (!isRetryableError || attempt === 3) {
+ // Don't retry non-network errors or on final attempt
+ console.error(`[TMDB] Final failure for ${key} after ${attempt} attempts:`, error.message);
+ break;
+ }
+
+ // Wait before retrying (exponential backoff with jitter)
+ const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000;
+ console.log(`[TMDB] Retry ${attempt}/3 for ${key} after ${delay}ms (error: ${error.message})`);
+ await new Promise(resolve => setTimeout(resolve, delay));
+ }
+ }
+
+ throw lastError;
+}
+
+function formatBytes(bytes: number): string {
+ if (bytes === 0) return '0 Bytes';
+ const k = 1024;
+ 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(2)) + ' ' + sizes[i];
+}
+
export const tvDiscoveryApi = {
/**
* Get trending TV shows
@@ -160,56 +214,16 @@ export const tvDiscoveryApi = {
},
/**
- * Get popular TV shows
+ * Get popular TV shows (alias for trending)
*/
async getPopular(page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
- return cachedFetch(`popular:${page}`, async () => {
- const response = await axios.get(`${TMDB_BASE_URL}/tv/popular`, {
- params: { api_key: TMDB_API_KEY, page },
- });
- return {
- shows: response.data.results.map(transformShow),
- totalPages: response.data.total_pages,
- };
- });
- },
-
- /**
- * Get top rated TV shows
- */
- async getTopRated(page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
- return cachedFetch(`toprated:${page}`, async () => {
- const response = await axios.get(`${TMDB_BASE_URL}/tv/top_rated`, {
- params: { api_key: TMDB_API_KEY, page },
- });
- return {
- shows: response.data.results.map(transformShow),
- totalPages: response.data.total_pages,
- };
- });
- },
-
- /**
- * Get shows airing today
- */
- async getAiringToday(page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
- return cachedFetch(`airing:${page}`, async () => {
- const response = await axios.get(`${TMDB_BASE_URL}/tv/airing_today`, {
- params: { api_key: TMDB_API_KEY, page },
- });
- return {
- shows: response.data.results.map(transformShow),
- totalPages: response.data.total_pages,
- };
- });
+ return this.getTrending(page);
},
/**
* Search TV shows
*/
async search(query: string, page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
- if (!query.trim()) return { shows: [], totalPages: 0 };
-
return cachedFetch(`search:${query}:${page}`, async () => {
const response = await axios.get(`${TMDB_BASE_URL}/search/tv`, {
params: { api_key: TMDB_API_KEY, query, page },
@@ -222,34 +236,78 @@ export const tvDiscoveryApi = {
},
/**
- * Get show details
+ * Get TV show details
*/
- async getShowDetails(tmdbId: number): Promise {
- return cachedFetch(`show:${tmdbId}`, async () => {
- const [details, externalIds] = await Promise.all([
- axios.get(`${TMDB_BASE_URL}/tv/${tmdbId}`, {
+ async getShowDetails(showId: number): Promise {
+ return cachedFetch(`details:${showId}`, async () => {
+ // First get basic details
+ const response = await axios.get(`${TMDB_BASE_URL}/tv/${showId}`, {
+ params: { api_key: TMDB_API_KEY },
+ });
+ const data = response.data;
+
+ // Get external IDs (includes IMDB ID)
+ let externalIds = {};
+ try {
+ console.log(`[TMDB] Fetching external IDs for show ${showId}`);
+ const externalResponse = await axios.get(`${TMDB_BASE_URL}/tv/${showId}/external_ids`, {
params: { api_key: TMDB_API_KEY },
- }),
- axios.get(`${TMDB_BASE_URL}/tv/${tmdbId}/external_ids`, {
- params: { api_key: TMDB_API_KEY },
- }),
- ]);
-
+ });
+ externalIds = externalResponse.data;
+ console.log(`[TMDB] External IDs for ${showId}:`, externalIds);
+ } catch (error: unknown) {
+ const errorMessage = error instanceof Error ? error.message : String(error);
+ console.warn('[TMDB] Could not fetch external IDs for show:', showId, errorMessage);
+ }
+
+ // Transform to include computed fields that components expect
+ const posterPath = data.poster_path ? `${TMDB_IMAGE_BASE}w342${data.poster_path}` : '';
+ const backdropPath = data.backdrop_path ? `${TMDB_IMAGE_BASE}w1280${data.backdrop_path}` : '';
+ const year = data.first_air_date ? new Date(data.first_air_date).getFullYear() : 0;
+ const imdbId = data.imdb_id || (externalIds && typeof externalIds === 'object' && 'imdb_id' in externalIds ? (externalIds as any).imdb_id : undefined);
+
+ console.log(`[TMDB] Show ${showId} IMDB ID: ${imdbId} (from ${data.imdb_id ? 'details' : 'external_ids'})`);
+
return {
- ...transformShow(details.data),
- imdbId: externalIds.data.imdb_id,
- seasons: details.data.seasons || [],
- externalIds: externalIds.data,
+ ...data,
+ poster: posterPath,
+ backdrop: backdropPath,
+ rating: data.vote_average || 0,
+ year: year,
+ genres: data.genres?.map((g: any) => g.name) || [],
+ networks: data.networks?.map((n: any) => n.name) || [],
+ imdbId: imdbId,
+ title: data.name || data.title, // TMDB uses 'name' for TV shows
};
});
},
/**
- * Get season details
+ * Get TV show seasons
*/
- async getSeasonDetails(tmdbId: number, seasonNumber: number): Promise {
- return cachedFetch(`season:${tmdbId}:${seasonNumber}`, async () => {
- const response = await axios.get(`${TMDB_BASE_URL}/tv/${tmdbId}/season/${seasonNumber}`, {
+ async getSeasons(showId: number): Promise {
+ const details = await this.getShowDetails(showId);
+ return details.seasons || [];
+ },
+
+ /**
+ * Get season episodes
+ */
+ async getEpisodes(showId: number, seasonNumber: number): Promise {
+ return cachedFetch(`episodes:${showId}:${seasonNumber}`, async () => {
+ const response = await axios.get(`${TMDB_BASE_URL}/tv/${showId}/season/${seasonNumber}`, {
+ params: { api_key: TMDB_API_KEY },
+ });
+ return response.data.episodes || [];
+ });
+ },
+
+ /**
+ * Get season details (alias for getEpisodes for backward compatibility)
+ */
+ async getSeasonDetails(showId: number, seasonNumber: number): Promise {
+ return cachedFetch(`season:${showId}:${seasonNumber}`, async () => {
+ const response = await axios.get(`${TMDB_BASE_URL}/tv/${showId}/season/${seasonNumber}`, {
params: { api_key: TMDB_API_KEY },
});
return response.data;
@@ -257,131 +315,142 @@ export const tvDiscoveryApi = {
},
/**
- * Get torrents for a show from multiple sources
- * Strategy: Try RARBG first (better quality/reliability), fallback to EZTV
+ * Get torrents for a TV show
*/
- async getTorrents(imdbId: string, showTitle?: string): Promise {
+ async getTorrents(imdbId?: string, _showTitle?: string): Promise {
const torrents: EztvTorrent[] = [];
-
+
if (!imdbId) {
console.warn('[Torrents] No IMDB ID provided for torrent lookup');
return torrents;
}
-
- // Try RARBG first (primary source)
+
try {
- console.log(`[RARBG] Fetching torrents for IMDB ID: ${imdbId}`);
- const rarbgResults = await searchByImdbId(imdbId, 500);
-
- if (rarbgResults.length > 0) {
- const converted = rarbgResults.map(convertRarbgToEztv);
- torrents.push(...converted);
- console.log(`[RARBG] Successfully loaded ${converted.length} torrents`);
+ const isAuthenticated = await loginToEZTV();
+ const numericId = imdbId.replace('tt', '');
+ console.log(`[EZTV] Fetching torrents for IMDB ID: ${numericId} (original: ${imdbId}) ${isAuthenticated ? '(authenticated)' : '(anonymous)'}`);
+
+ // Use the working eztvx.to API
+ const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
+ params: {
+ imdb_id: numericId,
+ limit: 100,
+ },
+ timeout: 15000,
+ validateStatus: (status) => status < 500,
+ });
+
+ console.log(`[EZTV] Response status: ${response.status}`);
+
+ if (response.data?.torrents && Array.isArray(response.data.torrents)) {
+ const torrentsData = response.data.torrents;
+ console.log(`[EZTV] Found ${torrentsData.length} torrents for IMDB ${numericId}`);
+
+ torrents.push(...torrentsData.map((t: any) => ({
+ id: t.id || Date.now() + Math.random(),
+ hash: t.hash || t.info_hash || '',
+ filename: t.filename || t.title || '',
+ title: t.title || t.filename || '',
+ season: t.season?.toString() || '0',
+ episode: t.episode?.toString() || '0',
+ quality: extractQuality(t.title || t.filename || ''),
+ size: t.size_bytes ? formatBytes(parseInt(t.size_bytes)) : (t.size || 'Unknown'),
+ sizeBytes: parseInt(t.size_bytes || t.size || '0'),
+ seeds: parseInt(t.seeds || '0'),
+ peers: parseInt(t.peers || '0'),
+ magnetUrl: t.magnet_url || t.magnet || '',
+ })));
+
+ console.log(`[EZTV] Successfully loaded ${torrents.length} torrents`);
} else {
- console.log(`[RARBG] No torrents found for IMDB ID: ${imdbId}`);
+ console.log(`[EZTV] No torrents found for IMDB ID: ${numericId}`);
}
+
+ // Note: lastError tracking removed - errors are logged above
} catch (error: any) {
- console.error('[RARBG] API error:', error?.message || error);
+ console.error('[EZTV] API error:', error.response?.data || error.message);
}
-
- // Fallback to EZTV if RARBG had no results or failed
- if (torrents.length === 0) {
- try {
- const numericId = imdbId.replace('tt', '');
- console.log(`[EZTV] Fallback: Fetching torrents for IMDB ID: ${numericId} (original: ${imdbId})`);
-
- // Try multiple limit values - some shows have many episodes
- const limits = [500, 250, 100];
- let lastError: any = null;
-
- for (const limit of limits) {
- try {
- const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
- params: {
- imdb_id: numericId,
- limit: limit
- },
- timeout: 15000,
- validateStatus: (status) => status < 500, // Don't throw on 4xx errors
- });
-
- console.log(`[EZTV] Response status: ${response.status}`);
-
- // Handle different response formats
- let torrentsData: any[] = [];
- if (response.data?.torrents) {
- torrentsData = Array.isArray(response.data.torrents)
- ? response.data.torrents
- : [];
- } else if (Array.isArray(response.data)) {
- torrentsData = response.data;
- }
-
- if (torrentsData.length > 0) {
- torrents.push(...torrentsData.map((t: any) => ({
- id: t.id || Date.now() + Math.random(),
- hash: t.hash || t.info_hash || '',
- filename: t.filename || t.title || '',
- title: t.title || t.filename || '',
- season: t.season?.toString() || '0',
- episode: t.episode?.toString() || '0',
- quality: extractQuality(t.title || t.filename || ''),
- size: t.size_bytes ? formatBytes(parseInt(t.size_bytes)) : (t.size || 'Unknown'),
- sizeBytes: parseInt(t.size_bytes || t.size || '0'),
- seeds: parseInt(t.seeds || '0'),
- peers: parseInt(t.peers || '0'),
- magnetUrl: t.magnet_url || t.magnet || '',
- })));
-
- console.log(`[EZTV] Successfully loaded ${torrents.length} torrents`);
- break; // Success, no need to try other limits
- } else if (response.status === 200) {
- console.log(`[EZTV] No torrents found for IMDB ID: ${numericId}`);
- break; // Got a valid response but no torrents
- }
- } catch (error: any) {
- lastError = error;
- console.warn(`[EZTV] Error with limit ${limit}:`, error.response?.status || error.message);
- // Continue to next limit if this one failed
- if (error.response?.status === 404 || error.response?.status === 400) {
- break; // Don't retry with different limits for client errors
- }
- }
- }
-
- if (torrents.length === 0 && lastError) {
- console.warn('[EZTV] Failed to fetch torrents:', lastError.response?.data || lastError.message);
- }
- } catch (error: any) {
- console.error('[EZTV] API error:', error.response?.data || error.message);
+
+ const deduplicated = deduplicateTorrents(torrents);
+ const sorted = deduplicated.sort((a, b) => {
+ if (b.seeds !== a.seeds) {
+ return b.seeds - a.seeds;
}
- } else {
- // RARBG had results, but also try EZTV to merge results
- try {
- const numericId = imdbId.replace('tt', '');
- console.log(`[EZTV] Merging: Fetching additional torrents for IMDB ID: ${numericId}`);
-
- const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
- params: { imdb_id: numericId, limit: 100 },
- timeout: 10000,
- validateStatus: (status) => status < 500,
- });
-
- let torrentsData: any[] = [];
- if (response.data?.torrents) {
- torrentsData = Array.isArray(response.data.torrents) ? response.data.torrents : [];
- } else if (Array.isArray(response.data)) {
- torrentsData = response.data;
- }
-
- if (torrentsData.length > 0) {
- const eztvTorrents = torrentsData.map((t: any) => ({
+ const qualityOrder: Record = { '2160p': 4, '1080p': 3, '720p': 2, '480p': 1, 'Unknown': 0 };
+ return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
+ });
+
+ console.log(`[Torrents] Final result: ${sorted.length} unique torrents (from ${torrents.length} total)`);
+ if (sorted.length === 0 && imdbId) {
+ console.log(`[Torrents] No torrents found for IMDB ID: ${imdbId}. EZTV may not have this show.`);
+ }
+ return sorted;
+ },
+
+ /**
+ * Search for episode torrents using EZTV API
+ */
+ async searchEpisodeTorrents(
+ _showTitle: string,
+ season: number,
+ episode: number,
+ imdbId?: string
+ ): Promise {
+ if (!imdbId) {
+ console.warn('[Episode Search] No IMDB ID provided');
+ return [];
+ }
+
+ const seasonStr = season.toString().padStart(2, '0');
+ const episodeStr = episode.toString().padStart(2, '0');
+ const numericId = imdbId.replace('tt', '');
+
+ console.log(`[Episode Search] Searching for S${seasonStr}E${episodeStr} with IMDB: ${numericId}`);
+
+ try {
+ const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
+ params: {
+ imdb_id: numericId,
+ limit: 100, // Get plenty of results
+ },
+ timeout: 15000,
+ validateStatus: (status) => status < 500,
+ });
+
+ if (response.data?.torrents && Array.isArray(response.data.torrents)) {
+ console.log(`[Episode Search] Found ${response.data.torrents.length} total torrents for IMDB ${numericId}`);
+
+
+ const filtered = response.data.torrents
+ .filter((t: any) => {
+ if (!t.title) return false;
+
+ // Check if season/episode fields exist and match
+ const torrentSeason = t.season?.toString();
+ const torrentEpisode = t.episode?.toString();
+
+ // EZTV returns season as "1" not "01", so compare normalized values
+ const seasonMatches = parseInt(torrentSeason || '0') === season;
+ const episodeMatches = parseInt(torrentEpisode || '0') === episode;
+
+ // Also try title-based matching as fallback
+ let titleMatches = false;
+ if (!seasonMatches || !episodeMatches) {
+ const titleLower = t.title.toLowerCase();
+ const seasonPattern = new RegExp(`s0?${season}\\b`, 'i');
+ const episodePattern = new RegExp(`e0?${episode}\\b`, 'i');
+ titleMatches = seasonPattern.test(titleLower) && episodePattern.test(titleLower);
+ }
+
+ return (seasonMatches && episodeMatches) || titleMatches;
+ })
+ .map((t: any) => ({
id: t.id || Date.now() + Math.random(),
hash: t.hash || t.info_hash || '',
filename: t.filename || t.title || '',
title: t.title || t.filename || '',
- season: t.season?.toString() || '0',
- episode: t.episode?.toString() || '0',
+ season: seasonStr,
+ episode: episodeStr,
quality: extractQuality(t.title || t.filename || ''),
size: t.size_bytes ? formatBytes(parseInt(t.size_bytes)) : (t.size || 'Unknown'),
sizeBytes: parseInt(t.size_bytes || t.size || '0'),
@@ -389,267 +458,17 @@ export const tvDiscoveryApi = {
peers: parseInt(t.peers || '0'),
magnetUrl: t.magnet_url || t.magnet || '',
}));
-
- torrents.push(...eztvTorrents);
- console.log(`[EZTV] Merged ${eztvTorrents.length} additional torrents`);
- }
- } catch (error: any) {
- console.warn('[EZTV] Error merging torrents:', error.message);
- }
- }
-
- // Deduplicate and sort by seeders/quality
- const deduplicated = deduplicateTorrents(torrents);
- const sorted = deduplicated.sort((a, b) => {
- // First sort by seeders (descending)
- if (b.seeds !== a.seeds) {
- return b.seeds - a.seeds;
- }
- // Then by quality
- const qualityOrder: Record = { '2160p': 4, '1080p': 3, '720p': 2, '480p': 1, 'Unknown': 0 };
- return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
- });
-
- console.log(`[Torrents] Final result: ${sorted.length} unique torrents (from ${torrents.length} total)`);
- return sorted;
- },
- /**
- * Search for episode torrents using IMDB ID lookup
- * Strategy: Try RARBG first, fallback to EZTV
- */
- async searchEpisodeTorrents(
- showTitle: string,
- season: number,
- episode: number,
- imdbId?: string
- ): Promise {
- const results: EztvTorrent[] = [];
- const seasonStr = season.toString().padStart(2, '0');
- const episodeStr = episode.toString().padStart(2, '0');
- const searchQuery = `${showTitle} S${seasonStr}E${episodeStr}`;
-
- if (!imdbId) {
- console.warn(`[Episode Search] No IMDB ID provided for: ${searchQuery}`);
- return results;
- }
-
- // Try RARBG first (primary source)
- try {
- console.log(`[RARBG] Searching for episode S${seasonStr}E${episodeStr} with IMDB: ${imdbId}`);
- const rarbgResults = await searchByImdbId(imdbId, 500);
-
- if (rarbgResults.length > 0) {
- // Filter for the specific episode
- const filtered = rarbgResults
- .filter((t: RarbgTorrent) => {
- const seInfo = extractSeasonEpisode(t.title);
- if (seInfo) {
- return seInfo.season === season && seInfo.episode === episode;
- }
- // Fallback: check title for S01E01 pattern
- const title = t.title.toLowerCase();
- const seasonPattern = new RegExp(`s0?${season}\\b`, 'i');
- const episodePattern = new RegExp(`e0?${episode}\\b`, 'i');
- return seasonPattern.test(title) && episodePattern.test(title);
- })
- .map(convertRarbgToEztv);
-
- results.push(...filtered);
- console.log(`[RARBG] Found ${filtered.length} torrents for S${seasonStr}E${episodeStr}`);
+ console.log(`[Episode Search] Filtered to ${filtered.length} episodes for S${seasonStr}E${episodeStr}`);
+ return filtered;
} else {
- console.log(`[RARBG] No torrents found for IMDB: ${imdbId}`);
+ console.log(`[Episode Search] No torrents found for IMDB ${numericId} (show may not be on EZTV)`);
+ return [];
}
} catch (error: any) {
- console.error('[RARBG] Episode search error:', error?.message || error);
+ console.warn('[Episode Search] EZTV API error:', error.message);
+ return [];
}
-
- // Fallback to EZTV if RARBG had no results
- if (results.length === 0) {
- try {
- const numericId = imdbId.replace('tt', '');
- console.log(`[EZTV] Searching for episode S${seasonStr}E${episodeStr} with IMDB: ${numericId}`);
-
- // Try with higher limits to find the episode
- const limits = [500, 250, 100];
- let torrentsData: any[] = [];
-
- for (const limit of limits) {
- try {
- const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
- params: {
- imdb_id: numericId,
- limit: limit,
- },
- timeout: 15000,
- validateStatus: (status) => status < 500,
- });
-
- // Handle different response formats
- if (response.data?.torrents) {
- torrentsData = Array.isArray(response.data.torrents)
- ? response.data.torrents
- : [];
- } else if (Array.isArray(response.data)) {
- torrentsData = response.data;
- }
-
- if (torrentsData.length > 0) {
- console.log(`[EZTV] Found ${torrentsData.length} total torrents, filtering for S${seasonStr}E${episodeStr}`);
- break;
- }
- } catch (error: any) {
- if (error.response?.status === 404 || error.response?.status === 400) {
- break; // Don't retry for client errors
- }
- console.warn(`[EZTV] Error with limit ${limit}:`, error.message);
- }
- }
-
- if (torrentsData.length > 0) {
- // Filter for the specific episode
- const filtered = torrentsData
- .filter((t: any) => {
- const title = (t.title || t.filename || '').toLowerCase();
-
- // EZTV uses numeric season/episode fields
- const torrentSeason = parseInt(t.season) || 0;
- const torrentEpisode = parseInt(t.episode) || 0;
-
- // Check by numeric fields first (most reliable)
- if (torrentSeason === season && torrentEpisode === episode) {
- return true;
- }
-
- // Fallback: Check for S01E01 format in title (more flexible)
- const seasonPattern = new RegExp(`s0?${season}\\b`, 'i');
- const episodePattern = new RegExp(`e0?${episode}\\b`, 'i');
-
- return seasonPattern.test(title) && episodePattern.test(title);
- })
- .map((t: any) => ({
- id: t.id || Date.now() + Math.random(),
- hash: t.hash || t.info_hash || '',
- filename: t.filename || t.title || '',
- title: t.title || t.filename || '',
- season: seasonStr,
- episode: episodeStr,
- quality: extractQuality(t.title || t.filename || ''),
- size: t.size_bytes ? formatBytes(parseInt(t.size_bytes)) : (t.size || 'Unknown'),
- sizeBytes: parseInt(t.size_bytes || t.size || '0'),
- seeds: parseInt(t.seeds || '0'),
- peers: parseInt(t.peers || '0'),
- magnetUrl: t.magnet_url || t.magnet || '',
- }));
- results.push(...filtered);
- console.log(`[EZTV] Filtered ${filtered.length} torrents for episode S${seasonStr}E${episodeStr}`);
- } else {
- console.log(`[EZTV] No torrents found for IMDB ID: ${numericId}`);
- }
- } catch (error: any) {
- console.error('[EZTV] Episode search error:', error.response?.data || error.message);
- }
- } else {
- // RARBG had results, but also try EZTV to merge results
- try {
- const numericId = imdbId.replace('tt', '');
- console.log(`[EZTV] Merging: Fetching additional episode torrents for IMDB: ${numericId}`);
-
- const response = await axios.get(`${EZTV_BASE_URL}/get-torrents`, {
- params: { imdb_id: numericId, limit: 100 },
- timeout: 10000,
- validateStatus: (status) => status < 500,
- });
-
- let torrentsData: any[] = [];
- if (response.data?.torrents) {
- torrentsData = Array.isArray(response.data.torrents) ? response.data.torrents : [];
- } else if (Array.isArray(response.data)) {
- torrentsData = response.data;
- }
-
- if (torrentsData.length > 0) {
- const filtered = torrentsData
- .filter((t: any) => {
- const title = (t.title || t.filename || '').toLowerCase();
- const torrentSeason = parseInt(t.season) || 0;
- const torrentEpisode = parseInt(t.episode) || 0;
-
- if (torrentSeason === season && torrentEpisode === episode) {
- return true;
- }
-
- const seasonPattern = new RegExp(`s0?${season}\\b`, 'i');
- const episodePattern = new RegExp(`e0?${episode}\\b`, 'i');
- return seasonPattern.test(title) && episodePattern.test(title);
- })
- .map((t: any) => ({
- id: t.id || Date.now() + Math.random(),
- hash: t.hash || t.info_hash || '',
- filename: t.filename || t.title || '',
- title: t.title || t.filename || '',
- season: seasonStr,
- episode: episodeStr,
- quality: extractQuality(t.title || t.filename || ''),
- size: t.size_bytes ? formatBytes(parseInt(t.size_bytes)) : (t.size || 'Unknown'),
- sizeBytes: parseInt(t.size_bytes || t.size || '0'),
- seeds: parseInt(t.seeds || '0'),
- peers: parseInt(t.peers || '0'),
- magnetUrl: t.magnet_url || t.magnet || '',
- }));
-
- results.push(...filtered);
- console.log(`[EZTV] Merged ${filtered.length} additional episode torrents`);
- }
- } catch (error: any) {
- console.warn('[EZTV] Error merging episode torrents:', error.message);
- }
- }
-
- // Deduplicate and sort by seeders/quality
- const deduplicated = deduplicateTorrents(results);
- const sorted = deduplicated.sort((a, b) => {
- // First sort by seeders (descending)
- if (b.seeds !== a.seeds) {
- return b.seeds - a.seeds;
- }
- // Then by quality
- const qualityOrder: Record = { '2160p': 4, '1080p': 3, '720p': 2, '480p': 1, 'Unknown': 0 };
- return (qualityOrder[b.quality] || 0) - (qualityOrder[a.quality] || 0);
- });
-
- // If no results from either source, generate fallback search links
- if (sorted.length === 0) {
- console.log(`[Episode Search] No results from RARBG or EZTV, generating fallback for: ${searchQuery}`);
-
- // Generate placeholder entries that link to torrent search pages
- const qualities = ['1080p', '720p', '480p'];
- const cleanTitle = showTitle.replace(/[^a-zA-Z0-9 ]/g, '').replace(/\s+/g, '.');
-
- qualities.forEach((quality, idx) => {
- const title = `${cleanTitle}.S${seasonStr}E${episodeStr}.${quality}.WEB-DL`;
- // Create a deterministic hash for UI purposes
- const hash = btoa(`${showTitle}${season}${episode}${quality}`).substring(0, 40);
-
- sorted.push({
- id: Date.now() + idx,
- hash: hash,
- filename: `${title}.mkv`,
- title: title,
- season: seasonStr,
- episode: episodeStr,
- quality: quality,
- size: quality === '1080p' ? '~2GB' : quality === '720p' ? '~1GB' : '~500MB',
- sizeBytes: quality === '1080p' ? 2147483648 : quality === '720p' ? 1073741824 : 536870912,
- seeds: 0,
- peers: 0,
- magnetUrl: generateSearchUrl(showTitle, season, episode, quality),
- });
- });
- }
-
- console.log(`[Episode Search] Final result: ${sorted.length} unique torrents for S${seasonStr}E${episodeStr}`);
- return sorted;
},
/**
@@ -672,6 +491,36 @@ export const tvDiscoveryApi = {
});
},
+ /**
+ * Get top rated TV shows
+ */
+ async getTopRated(page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
+ return cachedFetch(`top-rated:${page}`, async () => {
+ const response = await axios.get(`${TMDB_BASE_URL}/tv/top_rated`, {
+ params: { api_key: TMDB_API_KEY, page },
+ });
+ return {
+ shows: response.data.results.map(transformShow),
+ totalPages: response.data.total_pages,
+ };
+ });
+ },
+
+ /**
+ * Get TV shows airing today
+ */
+ async getAiringToday(page = 1): Promise<{ shows: DiscoveredShow[]; totalPages: number }> {
+ return cachedFetch(`airing-today:${page}`, async () => {
+ const response = await axios.get(`${TMDB_BASE_URL}/tv/airing_today`, {
+ params: { api_key: TMDB_API_KEY, page },
+ });
+ return {
+ shows: response.data.results.map(transformShow),
+ totalPages: response.data.total_pages,
+ };
+ });
+ },
+
/**
* Get TV genres
*/
@@ -683,46 +532,4 @@ export const tvDiscoveryApi = {
return response.data.genres;
});
},
-
- /**
- * Clear cache
- */
- clearCache(): void {
- cache.clear();
- },
-};
-
-// Helper functions
-function extractQuality(title: string): string {
- const qualityPatterns = [
- { regex: /2160p|4k|uhd/i, quality: '2160p' },
- { regex: /1080p|fhd/i, quality: '1080p' },
- { regex: /720p|hd/i, quality: '720p' },
- { regex: /480p|sd/i, quality: '480p' },
- ];
-
- for (const { regex, quality } of qualityPatterns) {
- if (regex.test(title)) return quality;
- }
- return 'Unknown';
-}
-
-function formatBytes(bytes: number): string {
- if (bytes === 0) return '0 Bytes';
- const k = 1024;
- 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(2)) + ' ' + sizes[i];
-}
-
-function generateSearchUrl(showTitle: string, season: number, episode: number, quality: string): string {
- // Generate a search URL that can be opened in a torrent search engine
- const query = `${showTitle} S${season.toString().padStart(2, '0')}E${episode.toString().padStart(2, '0')} ${quality}`;
- const encoded = encodeURIComponent(query);
- // Return a 1337x search URL as fallback
- return `https://1337x.to/search/${encoded}/1/`;
-}
-
-export default tvDiscoveryApi;
-
-
+};
\ No newline at end of file
diff --git a/src/services/api/yts.ts b/src/services/api/yts.ts
index 896977d..136cd88 100644
--- a/src/services/api/yts.ts
+++ b/src/services/api/yts.ts
@@ -16,15 +16,16 @@ const BASE_URL = isDev ? '/api/yts' : 'https://yts.lt/api/v2';
// Create axios instance with caching
const api: AxiosInstance = axios.create({
baseURL: BASE_URL,
- timeout: 15000,
+ timeout: API_TIMEOUT_MS,
headers: {
'Content-Type': 'application/json',
},
});
+import { CACHE_DURATION_MS, API_TIMEOUT_MS } from '../../constants';
+
// Simple in-memory cache
const cache = new Map();
-const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
function getCacheKey(endpoint: string, params?: object): string {
return `${endpoint}:${JSON.stringify(params || {})}`;
@@ -37,7 +38,7 @@ async function cachedRequest(
const cacheKey = getCacheKey(endpoint, params);
const cached = cache.get(cacheKey);
- if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
+ if (cached && Date.now() - cached.timestamp < CACHE_DURATION_MS) {
return cached.data as T;
}
diff --git a/src/services/server/serverManager.ts b/src/services/server/serverManager.ts
index 9a47eb0..19211e0 100644
--- a/src/services/server/serverManager.ts
+++ b/src/services/server/serverManager.ts
@@ -1,11 +1,18 @@
import { isCapacitor } from '../../utils/platform';
import streamingService from '../streaming/streamingService';
+import {
+ SERVER_HEALTH_CHECK_INTERVAL_MS,
+ SERVER_MAX_STARTUP_RETRIES,
+ SERVER_WAIT_TIMEOUT_MS,
+ SERVER_STARTUP_DELAY_MS,
+} from '../../constants';
+import { logger } from '../../utils/logger';
// Get NodeJS plugin from Capacitor runtime
// Capacitor plugins are accessed through Capacitor.Plugins at runtime
const getNodeJS = () => {
if (!isCapacitor()) {
- console.log('Not a Capacitor platform, NodeJS plugin not needed');
+ logger.debug('Not a Capacitor platform, NodeJS plugin not needed');
return null;
}
@@ -15,25 +22,25 @@ const getNodeJS = () => {
// @ts-ignore - CapacitorNodeJS is registered at runtime
const Capacitor = (window as any).Capacitor;
if (!Capacitor || !Capacitor.Plugins) {
- console.error('Capacitor or Capacitor.Plugins not available');
+ logger.error('Capacitor or Capacitor.Plugins not available');
return null;
}
const NodeJS = Capacitor.Plugins.CapacitorNodeJS;
if (!NodeJS) {
- console.error('NodeJS plugin not found in Capacitor.Plugins');
- console.log('Available plugins:', Object.keys(Capacitor.Plugins || {}));
+ logger.error('NodeJS plugin not found in Capacitor.Plugins', {
+ availablePlugins: Object.keys(Capacitor.Plugins || {}),
+ });
return null;
}
- console.log('NodeJS plugin found in Capacitor.Plugins');
+ logger.debug('NodeJS plugin found in Capacitor.Plugins');
return NodeJS;
} catch (error) {
- console.error('Failed to access NodeJS plugin:', error);
- console.error('Error details:', {
+ logger.error('Failed to access NodeJS plugin', error, {
message: error instanceof Error ? error.message : String(error),
- stack: error instanceof Error ? error.stack : undefined
+ stack: error instanceof Error ? error.stack : undefined,
});
return null;
}
@@ -48,8 +55,8 @@ class ServerManager {
private isStarting = false;
private isRunning = false;
private healthCheckInterval: NodeJS.Timeout | null = null;
- private readonly HEALTH_CHECK_INTERVAL = 5000; // 5 seconds
- private readonly MAX_STARTUP_RETRIES = 3;
+ private readonly HEALTH_CHECK_INTERVAL = SERVER_HEALTH_CHECK_INTERVAL_MS;
+ private readonly MAX_STARTUP_RETRIES = SERVER_MAX_STARTUP_RETRIES;
private startupRetries = 0;
/**
@@ -75,11 +82,11 @@ class ServerManager {
// Get NodeJS plugin from Capacitor runtime
const NodeJS = getNodeJS();
if (!NodeJS) {
- console.error('NodeJS plugin not available - is capacitor-nodejs installed?');
+ logger.error('NodeJS plugin not available - is capacitor-nodejs installed?');
throw new Error('NodeJS plugin not available');
}
- console.log('NodeJS plugin found, starting runtime...');
+ logger.info('NodeJS plugin found, starting runtime...');
// Start Node.js runtime using Capacitor NodeJS plugin
// If it's already started, that's fine - we'll just wait for it to be ready
@@ -92,24 +99,24 @@ class ServerManager {
NODE_ENV: 'production'
}
});
- console.log('NodeJS.start() called successfully');
+ logger.debug('NodeJS.start() called successfully');
} catch (startError: any) {
// If the engine is already started, that's okay - just continue
if (startError?.message?.includes('already been started')) {
- console.log('Node.js engine already started, continuing...');
+ logger.debug('Node.js engine already started, continuing...');
} else {
- console.error('Error calling NodeJS.start():', startError);
+ logger.error('Error calling NodeJS.start()', startError);
throw startError;
}
}
// Wait for Node.js runtime to be ready
- console.log('Waiting for Node.js runtime to be ready...');
+ logger.debug('Waiting for Node.js runtime to be ready...');
try {
await NodeJS.whenReady();
- console.log('Node.js runtime is ready - server should be starting...');
+ logger.info('Node.js runtime is ready - server should be starting...');
} catch (readyError) {
- console.error('Error waiting for Node.js runtime:', readyError);
+ logger.error('Error waiting for Node.js runtime', readyError);
throw readyError;
}
@@ -118,8 +125,8 @@ class ServerManager {
try {
await this.waitForServer();
this.isRunning = true;
- } catch (error) {
- console.warn('Server not ready yet, will retry on first use:', error);
+ } catch (error: unknown) {
+ logger.warn('Server not ready yet, will retry on first use', error as any);
this.isRunning = false;
}
@@ -128,14 +135,14 @@ class ServerManager {
return true;
} catch (error) {
- console.error('Failed to start server:', error);
+ logger.error('Failed to start server', error);
this.isStarting = false;
// Retry if we haven't exceeded max retries
if (this.startupRetries < this.MAX_STARTUP_RETRIES) {
this.startupRetries++;
- console.log(`Retrying server startup (attempt ${this.startupRetries}/${this.MAX_STARTUP_RETRIES})...`);
- await new Promise(resolve => setTimeout(resolve, 2000));
+ logger.info(`Retrying server startup (attempt ${this.startupRetries}/${this.MAX_STARTUP_RETRIES})...`);
+ await new Promise(resolve => setTimeout(resolve, SERVER_STARTUP_DELAY_MS));
return this.startServer();
}
@@ -158,7 +165,7 @@ class ServerManager {
// Note: Capacitor NodeJS doesn't support stopping/restarting
// The runtime will be stopped when the app is closed
- console.log('Server stop requested (runtime will continue until app closes)');
+ logger.info('Server stop requested (runtime will continue until app closes)');
}
/**
@@ -171,7 +178,7 @@ class ServerManager {
/**
* Wait for server to be ready
*/
- private async waitForServer(maxWaitTime = 10000): Promise {
+ private async waitForServer(maxWaitTime = SERVER_WAIT_TIMEOUT_MS): Promise {
const startTime = Date.now();
while (Date.now() - startTime < maxWaitTime) {
@@ -186,7 +193,7 @@ class ServerManager {
// Don't throw error - server might start later
// Just log a warning and continue
- console.warn('Server not ready yet, but continuing...');
+ logger.warn('Server not ready yet, but continuing...');
}
/**
@@ -220,7 +227,7 @@ class ServerManager {
this.healthCheckInterval = setInterval(async () => {
const isHealthy = await this.checkServerHealth();
if (!isHealthy && isCapacitor()) {
- console.warn('Server health check failed, attempting restart...');
+ logger.warn('Server health check failed, attempting restart...');
// Attempt to restart server
this.isRunning = false;
await this.startServer();
diff --git a/src/services/streaming/streamingService.ts b/src/services/streaming/streamingService.ts
index 16f38ba..08a765e 100644
--- a/src/services/streaming/streamingService.ts
+++ b/src/services/streaming/streamingService.ts
@@ -1,5 +1,11 @@
import axios from 'axios';
import { getApiUrl } from '../../utils/platform';
+import { logger } from '../../utils/logger';
+import {
+ MAX_RECONNECT_ATTEMPTS,
+ RECONNECT_BASE_DELAY_MS,
+ WEBSOCKET_SUBSCRIBE_DELAY_MS,
+} from '../../constants';
// Get API URL using platform-aware resolution
// Defaults to http://localhost:3001 for both Electron and Android
@@ -33,7 +39,7 @@ export interface TranscodeProgress {
class StreamingService {
private ws: WebSocket | null = null;
private reconnectAttempts = 0;
- private maxReconnectAttempts = 5;
+ private maxReconnectAttempts = MAX_RECONNECT_ATTEMPTS;
private listeners: Map void>> = new Map();
/**
@@ -47,14 +53,14 @@ class StreamingService {
this.ws = new WebSocket(wsUrl);
this.ws.onopen = () => {
- console.log('WebSocket connected');
+ logger.info('WebSocket connected', { sessionId });
this.reconnectAttempts = 0;
// Subscribe to session updates - wait a bit to ensure WebSocket is fully open
setTimeout(() => {
if (this.ws && this.ws.readyState === WebSocket.OPEN) {
this.ws.send(JSON.stringify({ type: 'subscribe', sessionId }));
}
- }, 100);
+ }, WEBSOCKET_SUBSCRIBE_DELAY_MS);
resolve();
};
@@ -63,16 +69,16 @@ class StreamingService {
const data = JSON.parse(event.data);
this.emit(sessionId, data);
} catch (e) {
- console.error('WebSocket message parse error:', e);
+ logger.error('WebSocket message parse error', e);
}
};
this.ws.onerror = (error) => {
- console.error('WebSocket error:', error);
+ logger.error('WebSocket error', error);
};
this.ws.onclose = () => {
- console.log('WebSocket disconnected');
+ logger.info('WebSocket disconnected', { sessionId });
this.attemptReconnect(sessionId);
};
} catch (error) {
@@ -87,8 +93,10 @@ class StreamingService {
private attemptReconnect(sessionId: string) {
if (this.reconnectAttempts < this.maxReconnectAttempts) {
this.reconnectAttempts++;
- console.log(`Reconnecting... attempt ${this.reconnectAttempts}`);
- setTimeout(() => this.connect(sessionId), 2000 * this.reconnectAttempts);
+ logger.info(`Reconnecting... attempt ${this.reconnectAttempts}`, { sessionId });
+ setTimeout(() => this.connect(sessionId), RECONNECT_BASE_DELAY_MS * this.reconnectAttempts);
+ } else {
+ logger.warn('Max reconnection attempts reached', { sessionId, attempts: this.reconnectAttempts });
}
}
@@ -119,6 +127,7 @@ class StreamingService {
*/
disconnect() {
if (this.ws) {
+ logger.debug('Disconnecting WebSocket');
this.ws.close();
this.ws = null;
}
diff --git a/src/utils/logger.ts b/src/utils/logger.ts
new file mode 100644
index 0000000..86907af
--- /dev/null
+++ b/src/utils/logger.ts
@@ -0,0 +1,78 @@
+/**
+ * Structured logging utility
+ * Provides consistent logging with levels and environment awareness
+ */
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+interface LogContext {
+ [key: string]: unknown;
+}
+
+class Logger {
+ private isDevelopment = import.meta.env.DEV;
+ private logLevel: LogLevel = this.isDevelopment ? 'debug' : 'info';
+
+ private shouldLog(level: LogLevel): boolean {
+ const levels: LogLevel[] = ['debug', 'info', 'warn', 'error'];
+ const currentLevelIndex = levels.indexOf(this.logLevel);
+ const messageLevelIndex = levels.indexOf(level);
+ return messageLevelIndex >= currentLevelIndex;
+ }
+
+ private formatMessage(level: LogLevel, message: string, context?: LogContext): string {
+ const timestamp = new Date().toISOString();
+ const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+ return `[${timestamp}] [${level.toUpperCase()}] ${message}${contextStr}`;
+ }
+
+ debug(message: string, context?: LogContext): void {
+ if (this.shouldLog('debug') && this.isDevelopment) {
+ console.debug(this.formatMessage('debug', message, context));
+ }
+ }
+
+ info(message: string, context?: LogContext): void {
+ if (this.shouldLog('info')) {
+ console.info(this.formatMessage('info', message, context));
+ }
+ }
+
+ warn(message: string, context?: LogContext): void {
+ if (this.shouldLog('warn')) {
+ console.warn(this.formatMessage('warn', message, context));
+ }
+ }
+
+ error(message: string, error?: Error | unknown, context?: LogContext): void {
+ if (this.shouldLog('error')) {
+ const errorContext = {
+ ...context,
+ error: error instanceof Error ? {
+ message: error.message,
+ stack: error.stack,
+ name: error.name,
+ } : String(error),
+ };
+ console.error(this.formatMessage('error', message, errorContext));
+ }
+ }
+
+ /**
+ * Set log level
+ */
+ setLevel(level: LogLevel): void {
+ this.logLevel = level;
+ }
+
+ /**
+ * Get current log level
+ */
+ getLevel(): LogLevel {
+ return this.logLevel;
+ }
+}
+
+export const logger = new Logger();
+export default logger;
+
diff --git a/src/utils/sanitization.ts b/src/utils/sanitization.ts
new file mode 100644
index 0000000..cd77eba
--- /dev/null
+++ b/src/utils/sanitization.ts
@@ -0,0 +1,97 @@
+/**
+ * Input sanitization utilities
+ * Sanitizes user inputs to prevent XSS and other security issues
+ */
+
+/**
+ * Sanitize string input by removing potentially dangerous characters
+ */
+export function sanitizeString(input: string): string {
+ if (typeof input !== 'string') {
+ return '';
+ }
+
+ // Remove null bytes
+ let sanitized = input.replace(/\0/g, '');
+
+ // Trim whitespace
+ sanitized = sanitized.trim();
+
+ // Remove control characters except newlines and tabs
+ sanitized = sanitized.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '');
+
+ return sanitized;
+}
+
+/**
+ * Sanitize search query
+ */
+export function sanitizeSearchQuery(query: string): string {
+ const sanitized = sanitizeString(query);
+
+ // Remove excessive whitespace
+ return sanitized.replace(/\s+/g, ' ');
+}
+
+/**
+ * Sanitize numeric input
+ */
+export function sanitizeNumber(input: string | number): number | null {
+ if (typeof input === 'number') {
+ return isNaN(input) ? null : input;
+ }
+
+ if (typeof input !== 'string') {
+ return null;
+ }
+
+ // Remove all non-numeric characters except decimal point and minus sign
+ const cleaned = input.replace(/[^\d.-]/g, '');
+ const parsed = parseFloat(cleaned);
+
+ return isNaN(parsed) ? null : parsed;
+}
+
+/**
+ * Sanitize URL
+ */
+export function sanitizeUrl(url: string): string {
+ const sanitized = sanitizeString(url);
+
+ // Basic URL validation - ensure it starts with http:// or https://
+ if (sanitized && !sanitized.match(/^https?:\/\//i)) {
+ return '';
+ }
+
+ return sanitized;
+}
+
+/**
+ * Sanitize HTML content (basic)
+ * For more advanced sanitization, consider using a library like DOMPurify
+ */
+export function sanitizeHtml(html: string): string {
+ const sanitized = sanitizeString(html);
+
+ // Remove script tags and event handlers (basic protection)
+ return sanitized
+ .replace(/)<[^<]*)*<\/script>/gi, '')
+ .replace(/on\w+\s*=\s*["'][^"']*["']/gi, '')
+ .replace(/javascript:/gi, '');
+}
+
+/**
+ * Escape HTML special characters
+ */
+export function escapeHtml(text: string): string {
+ const map: Record = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": ''',
+ };
+
+ return text.replace(/[&<>"']/g, (m) => map[m]);
+}
+
diff --git a/src/utils/validation.ts b/src/utils/validation.ts
new file mode 100644
index 0000000..ce07dda
--- /dev/null
+++ b/src/utils/validation.ts
@@ -0,0 +1,147 @@
+/**
+ * Input validation utilities
+ * Provides consistent validation for user inputs across the application
+ */
+
+import {
+ MIN_SEARCH_QUERY_LENGTH,
+ MAX_SEARCH_QUERY_LENGTH,
+ MIN_MOVIE_ID,
+ MAX_MOVIE_ID,
+} from '../constants';
+
+/**
+ * Validate search query
+ */
+export function validateSearchQuery(query: string): { valid: boolean; error?: string } {
+ if (!query || typeof query !== 'string') {
+ return { valid: false, error: 'Search query is required' };
+ }
+
+ const trimmed = query.trim();
+
+ if (trimmed.length < MIN_SEARCH_QUERY_LENGTH) {
+ return { valid: false, error: `Search query must be at least ${MIN_SEARCH_QUERY_LENGTH} character(s)` };
+ }
+
+ if (trimmed.length > MAX_SEARCH_QUERY_LENGTH) {
+ return { valid: false, error: `Search query must be less than ${MAX_SEARCH_QUERY_LENGTH} characters` };
+ }
+
+ return { valid: true };
+}
+
+/**
+ * Validate movie ID
+ */
+export function validateMovieId(id: number | string): { valid: boolean; error?: string; parsedId?: number } {
+ if (id === null || id === undefined) {
+ return { valid: false, error: 'Movie ID is required' };
+ }
+
+ const parsedId = typeof id === 'string' ? parseInt(id, 10) : id;
+
+ if (isNaN(parsedId)) {
+ return { valid: false, error: 'Movie ID must be a valid number' };
+ }
+
+ if (parsedId < MIN_MOVIE_ID || parsedId > MAX_MOVIE_ID) {
+ return { valid: false, error: `Movie ID must be between ${MIN_MOVIE_ID} and ${MAX_MOVIE_ID}` };
+ }
+
+ return { valid: true, parsedId };
+}
+
+/**
+ * Validate URL
+ */
+export function validateUrl(url: string): { valid: boolean; error?: string } {
+ if (!url || typeof url !== 'string') {
+ return { valid: false, error: 'URL is required' };
+ }
+
+ try {
+ new URL(url);
+ return { valid: true };
+ } catch {
+ return { valid: false, error: 'Invalid URL format' };
+ }
+}
+
+/**
+ * Validate numeric input
+ */
+export function validateNumber(
+ value: number | string,
+ options: { min?: number; max?: number; required?: boolean } = {}
+): { valid: boolean; error?: string; parsedValue?: number } {
+ const { min, max, required = true } = options;
+
+ if (value === null || value === undefined || value === '') {
+ if (required) {
+ return { valid: false, error: 'Value is required' };
+ }
+ return { valid: true, parsedValue: undefined };
+ }
+
+ const parsedValue = typeof value === 'string' ? parseFloat(value) : value;
+
+ if (isNaN(parsedValue)) {
+ return { valid: false, error: 'Value must be a valid number' };
+ }
+
+ if (min !== undefined && parsedValue < min) {
+ return { valid: false, error: `Value must be at least ${min}` };
+ }
+
+ if (max !== undefined && parsedValue > max) {
+ return { valid: false, error: `Value must be at most ${max}` };
+ }
+
+ return { valid: true, parsedValue };
+}
+
+/**
+ * Validate quality string
+ */
+export function validateQuality(quality: string): { valid: boolean; error?: string } {
+ const validQualities = ['480p', '720p', '1080p', '1080p.x265', '2160p', '3D'];
+
+ if (!quality || typeof quality !== 'string') {
+ return { valid: false, error: 'Quality is required' };
+ }
+
+ if (!validQualities.includes(quality)) {
+ return { valid: false, error: `Quality must be one of: ${validQualities.join(', ')}` };
+ }
+
+ return { valid: true };
+}
+
+/**
+ * Validate genre string
+ */
+export function validateGenre(genre: string): { valid: boolean; error?: string } {
+ if (!genre || typeof genre !== 'string') {
+ return { valid: false, error: 'Genre is required' };
+ }
+
+ // Genre should be a non-empty string
+ if (genre.trim().length === 0) {
+ return { valid: false, error: 'Genre cannot be empty' };
+ }
+
+ return { valid: true };
+}
+
+/**
+ * Sanitize search query - remove special characters and normalize
+ */
+export function sanitizeSearchQuery(query: string): string {
+ if (!query || typeof query !== 'string') {
+ return '';
+ }
+
+ return query.trim().replace(/[^\w\s-]/g, '');
+}
+
diff --git a/vite.config.ts b/vite.config.ts
index f20fcca..cb10561 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -30,7 +30,7 @@ export default defineConfig({
proxyTimeout: 30000,
},
'/api/eztv': {
- target: 'https://eztv.tf/api',
+ target: 'https://eztvx.to/api',
changeOrigin: true,
rewrite: (path) => path.replace(/^\/api\/eztv/, ''),
secure: false,
@@ -41,17 +41,25 @@ export default defineConfig({
target: 'https://api.themoviedb.org/3',
changeOrigin: true,
rewrite: (path) => path.replace(/^\/api\/tmdb/, ''),
- secure: false,
- timeout: 30000,
- proxyTimeout: 30000,
- },
- '/api/rarbg': {
- target: 'https://torrentapi.org',
- changeOrigin: true,
- rewrite: (path) => path.replace(/^\/api\/rarbg/, '/pubapi_v2.php'),
- secure: false,
+ secure: true,
timeout: 30000,
proxyTimeout: 30000,
+ headers: {
+ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+ 'Accept': 'application/json',
+ 'Accept-Language': 'en-US,en;q=0.9',
+ },
+ configure: (proxy, _options) => {
+ proxy.on('error', (err, req, res) => {
+ console.log('TMDB proxy error for:', req.url, err.message);
+ // Don't try to respond here, let it fall through to retry logic
+ });
+ proxy.on('proxyReq', (proxyReq, req, res) => {
+ proxyReq.setTimeout(30000);
+ // Keep host header but remove referer
+ proxyReq.removeHeader('referer');
+ });
+ },
},
},
},