feat: add large M3U playlist warning (50K+ channels)

server/routes/sources.js

@@ -4,6 +4,7 @@ const { sources } = require('../db');
 const { getDb } = require('../db/sqlite');
 const xtreamApi = require('../services/xtreamApi');
 const syncService = require('../services/syncService');
+const m3uParser = require('../services/m3uParser');
 
 // Get all sources
 router.get('/', async (req, res) => {
@@ -204,6 +205,66 @@ router.post('/:id/test', async (req, res) => {
     }
 });
 
+// Estimate M3U playlist size (for large playlist warning)
+const M3U_LARGE_THRESHOLD = 50000;
+
+// Estimate by URL (for new sources before creation)
+router.post('/estimate', async (req, res) => {
+    try {
+        const { url, type } = req.body;
+
+        if (!url) {
+            return res.status(400).json({ error: 'URL is required' });
+        }
+
+        // Only M3U sources need estimation
+        if (type !== 'm3u') {
+            return res.json({ count: 0, needsWarning: false, threshold: M3U_LARGE_THRESHOLD });
+        }
+
+        console.log(`[Sources] Estimating M3U size for URL...`);
+        const count = await m3uParser.countEntries(url);
+        console.log(`[Sources] M3U estimate: ${count} entries`);
+
+        res.json({
+            count,
+            needsWarning: count > M3U_LARGE_THRESHOLD,
+            threshold: M3U_LARGE_THRESHOLD
+        });
+    } catch (err) {
+        console.error('Error estimating M3U size:', err);
+        res.status(500).json({ error: 'Failed to estimate playlist size', message: err.message });
+    }
+});
+
+// Estimate by source ID (for existing sources)
+router.get('/:id/estimate', async (req, res) => {
+    try {
+        const source = await sources.getById(req.params.id);
+        if (!source) {
+            return res.status(404).json({ error: 'Source not found' });
+        }
+
+        // Only M3U sources need estimation
+        if (source.type !== 'm3u') {
+            return res.json({ count: 0, needsWarning: false, threshold: M3U_LARGE_THRESHOLD });
+        }
+
+        console.log(`[Sources] Estimating M3U size for ${source.name}...`);
+        const count = await m3uParser.countEntries(source.url);
+        console.log(`[Sources] M3U estimate: ${count} entries`);
+
+        res.json({
+            count,
+            needsWarning: count > M3U_LARGE_THRESHOLD,
+            threshold: M3U_LARGE_THRESHOLD
+        });
+    } catch (err) {
+        console.error('Error estimating M3U size:', err);
+        res.status(500).json({ error: 'Failed to estimate playlist size', message: err.message });
+    }
+});
+
 // Global Sync - sync all enabled sources
 router.post('/sync-all', async (req, res) => {
     try {

server/services/m3uParser.js

@@ -271,5 +271,46 @@ async function* fetchAndParseStreaming(url, batchSize = 500) {
     yield* parseStreaming(stream, batchSize);
 }
 
-module.exports = { parse, parseExtinf, fetchAndParse, parseStreaming, fetchAndParseStreaming };
+/**
+ * Fast count of entries in an M3U playlist (for size estimation)
+ * Streams the file and counts #EXTINF lines without full parsing
+ * @param {string} url - URL of the M3U playlist
+ * @returns {Promise<number>} Number of entries
+ */
+async function countEntries(url) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`Failed to fetch playlist: ${response.status}`);
+    }
+
+    let stream;
+    if (response.body && typeof response.body.pipe === 'function') {
+        stream = response.body;
+    } else if (response.body) {
+        stream = Readable.fromWeb(response.body);
+    } else {
+        return 0;
+    }
+
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+        rl.on('line', (line) => {
+            if (line.startsWith('#EXTINF:')) {
+                count++;
+            }
+        });
+
+        rl.on('close', () => resolve(count));
+        rl.on('error', reject);
+    });
+}
+
+module.exports = { parse, parseExtinf, fetchAndParse, parseStreaming, fetchAndParseStreaming, countEntries };