Cancel superseded Enigma2 startup and select programs throughout playback

server/routes/probe.js

@@ -1,3 +1,4 @@
+const { parseProgram, selectProgramStreams } = require('../services/mpegTsProgram');
 const { redactUrl, redactText, validateHttpUrl, FFMPEG_PROTOCOL_WHITELIST } = require('../services/urlSecurity');
 const express = require('express');
 const router = express.Router();
@@ -41,6 +42,7 @@ function probeStream(url, ffprobePath, userAgent = null, timeout = 15000) {
             '-reconnect_delay_max', '10',
             '-print_format', 'json',
             '-show_streams',
+            '-show_programs',
             '-show_format',
             '-protocol_whitelist', FFMPEG_PROTOCOL_WHITELIST,
             '-probesize', '5000000',
@@ -84,8 +86,8 @@ function probeStream(url, ffprobePath, userAgent = null, timeout = 15000) {
 /**
  * Analyze probe result and determine compatibility
  */
-function analyzeProbeResult(probeResult, url) {
-    const streams = probeResult.streams || [];
+function analyzeProbeResult(probeResult, url, program = null) {
+    const streams = selectProgramStreams(probeResult, program);
     const format = probeResult.format || {};
 
     const videoStream = streams.find(s => s.codec_type === 'video');
@@ -152,13 +154,15 @@ function analyzeProbeResult(probeResult, url) {
 
 router.get('/', async (req, res) => {
     const { url, ua } = req.query;
+    let program;
+    try { program = parseProgram(req.query.program); } catch (error) { return res.status(400).json({ error: error.message }); }
     try { validateHttpUrl(url); } catch (error) { return res.status(400).json({ error: error.message }); }
     if (!url) {
         return res.status(400).json({ error: 'URL parameter is required' });
     }
 
     const ffprobePath = req.app.locals.ffprobePath;
-    const cacheKey = `${url}${ua ? `|${ua}` : ''}`;
+    const cacheKey = JSON.stringify([url, ua || '', program]);
 
     if (!ffprobePath) {
         // No ffprobe available - assume needs transcoding to be safe
@@ -184,7 +188,7 @@ router.get('/', async (req, res) => {
 
     try {
         const probeResult = await probeStream(url, ffprobePath, ua);
-        const analysis = analyzeProbeResult(probeResult, url);
+        const analysis = analyzeProbeResult(probeResult, url, program);
 
         // Cache result
         probeCache.set(cacheKey, { result: analysis, timestamp: Date.now() });

server/routes/remux.js

@@ -1,3 +1,4 @@
+const { parseProgram } = require('../services/mpegTsProgram');
 const { redactUrl, redactText, validateHttpUrl } = require('../services/urlSecurity');
 const express = require('express');
 const router = express.Router();
@@ -73,8 +74,9 @@ router.get('/', async (req, res) => {
         return res.status(400).json({ error: 'URL must be an http:// or https:// stream URL' });
     }
 
-    let audioCodecs;
+    let audioCodecs, program;
     try {
+        program = parseProgram(req.query.program);
         audioCodecs = parseAudioCodecs(req.query.audioCodecs);
     } catch (error) {
         return res.status(400).json({ error: error.message });
@@ -120,8 +122,8 @@ router.get('/', async (req, res) => {
         '-i', safeUrl,
         // STRICT MAPPING: Only map video and audio, ignore subtitles/data/attachments
         // This prevents remux failure when source container has incompatible subtitle tracks (e.g. MKV -> MP4)
-        '-map', '0:v',
-        '-map', '0:a',
+        '-map', program === null ? '0:v' : `0:p:${program}:v:0`,
+        '-map', program === null ? '0:a' : `0:p:${program}:a?`,
         // Drop subtitles (-sn) and data (-dn) explicitly
         '-sn', '-dn',
         // Copy streams without re-encoding

server/routes/sources.js

@@ -1,5 +1,9 @@
 const express = require('express');
 const router = express.Router();
+const zapDelayValue = value => {
+    const delay = Number(value ?? 1500);
+    return Number.isFinite(delay) ? Math.max(0, Math.min(10000, Math.trunc(delay))) : 1500;
+};
 const { sources } = require('../db');
 const { getDb } = require('../db/sqlite');
 const xtreamApi = require('../services/xtreamApi');
@@ -73,7 +77,7 @@ router.post('/', async (req, res) => {
             return res.status(400).json({ error: 'Invalid source type' });
         }
 
-        const source = await sources.create({ type, name, url, username, password, zapBeforeStreaming: zapBeforeStreaming === true, zapDelay: parseInt(zapDelay) || 1500 });
+        const source = await sources.create({ type, name, url, username, password, zapBeforeStreaming: zapBeforeStreaming === true, zapDelay: zapDelayValue(zapDelay) });
         // Trigger Sync
         syncService.syncSource(source.id).catch(console.error);
         res.status(201).json(source);
@@ -100,7 +104,7 @@ router.put('/:id', async (req, res) => {
         if (username !== undefined) updates.username = username;
         if (password !== undefined) updates.password = password;
         if (zapBeforeStreaming !== undefined) updates.zapBeforeStreaming = zapBeforeStreaming === true;
-        if (zapDelay !== undefined) updates.zapDelay = parseInt(zapDelay) || 1500;
+        if (zapDelay !== undefined) updates.zapDelay = zapDelayValue(zapDelay);
         const updated = await sources.update(req.params.id, updates);
         if (!updated) return res.status(404).json({ error: 'Source not found' });
         // Trigger Sync (if critical fields changed? safely just trigger it)

server/routes/transcode.js

@@ -1,3 +1,4 @@
+const { parseProgram } = require('../services/mpegTsProgram');
 const { redactUrl, redactText, validateHttpUrl, FFMPEG_PROTOCOL_WHITELIST } = require('../services/urlSecurity');
 const express = require('express');
 const router = express.Router();
@@ -34,8 +35,8 @@ transcodeSession.startCleanupInterval();
  */
 router.post('/session', startupLimit, async (req, res) => {
     const { url, seekOffset, videoMode, videoCodec, audioCodec, audioChannels, videoHeight, playbackLeaseId, requestSequence, isLive, program } = req.body;
-    // MPEG-TS program number (Enigma2 multi-program streams); digits only
-    const programNumber = /^\d+$/.test(String(program ?? '')) ? String(program) : null;
+    let programNumber;
+    try { programNumber = parseProgram(program); } catch (error) { return res.status(400).json({ error: error.message }); }
     const normalizedSeek = Number(seekOffset ?? 0);
     if (!Number.isFinite(normalizedSeek) || normalizedSeek < 0) return res.status(400).json({ error: "Invalid seek offset" });
     let session = null, disconnected = false;

server/services/mpegTsProgram.js

@@ -0,0 +1,19 @@
+/** Optional MPEG-TS service/program identifier; reject structured or malformed input. */
+function parseProgram(value) {
+    if (value === undefined || value === null) return null;
+    if (!['string', 'number'].includes(typeof value) || !/^\d{1,5}$/.test(String(value))) {
+        throw new Error('Program must be an integer from 1 to 65535');
+    }
+    const program = Number(value);
+    if (program < 1 || program > 65535) throw new Error('Program must be an integer from 1 to 65535');
+    return String(program);
+}
+
+function selectProgramStreams(result, program) {
+    if (program === null) return result.streams || [];
+    const selected = result.programs?.find(item => String(item.program_id ?? item.program_num) === program);
+    if (!selected) throw new Error('Requested program was not found in the stream');
+    return selected.streams || [];
+}
+
+module.exports = { parseProgram, selectProgramStreams };

server/services/transcodeSession.js

@@ -1,3 +1,4 @@
+const { parseProgram } = require('./mpegTsProgram');
 const { redactUrl, redactText, validateHttpUrl, FFMPEG_PROTOCOL_WHITELIST } = require('./urlSecurity');
 /**
  * Transcode Session Service
@@ -103,7 +104,8 @@ class TranscodeSession extends EventEmitter {
             upscaleEnabled: options.upscaleEnabled || false,
             upscaleMethod: options.upscaleMethod || 'hardware', // 'hardware' or 'software'
             upscaleTarget: options.upscaleTarget || '1080p',
-            ...options
+            ...options,
+            program: parseProgram(options.program)
         };
     }