fix(learningsuite): download encrypted HLS videos via segment capture

- LearningSuite uses encrypted HLS playlists (client-side decryption)
- Capture individual .ts segment URLs with their tokens during playback
- Implement segment-based download: download all segments then concat with ffmpeg
- Add 'segments:' URL scheme for passing captured URLs to downloader
- Fix video type mapping for segment-based downloads
- Remove debug logging from production code

Author: swernerx

src/cli/commands/syncLearningSuite.ts

@@ -449,11 +449,12 @@ export async function syncLearningSuiteCommand(
 
               // Queue video download
               if (!options.skipVideos && !syncStatus.video && content.video?.url) {
+                const videoUrl = content.video.hlsUrl ?? content.video.url;
                 videoTasks.push({
                   lessonId: lesson.id as unknown as number,
                   lessonName: lesson.title,
-                  videoUrl: content.video.hlsUrl ?? content.video.url,
-                  videoType: mapVideoType(content.video.type),
+                  videoUrl,
+                  videoType: mapVideoType(content.video.type, videoUrl),
                   outputPath: getVideoPath(moduleDir, lessonIndex, lesson.title),
                   preferredQuality: options.quality,
                 });
@@ -487,11 +488,12 @@ export async function syncLearningSuiteCommand(
               );
 
               if (content?.video?.url) {
+                const videoUrl = content.video.hlsUrl ?? content.video.url;
                 videoTasks.push({
                   lessonId: lesson.id as unknown as number,
                   lessonName: lesson.title,
-                  videoUrl: content.video.hlsUrl ?? content.video.url,
-                  videoType: mapVideoType(content.video.type),
+                  videoUrl,
+                  videoType: mapVideoType(content.video.type, videoUrl),
                   outputPath: getVideoPath(moduleDir, lessonIndex, lesson.title),
                   preferredQuality: options.quality,
                 });
@@ -547,10 +549,15 @@ export async function syncLearningSuiteCommand(
 /**
  * Maps LearningSuite video type to downloader video type.
  */
-function mapVideoType(type: string): VideoDownloadTask["videoType"] {
+function mapVideoType(type: string, url?: string): VideoDownloadTask["videoType"] {
+  // Special case: segments:... URLs use direct HLS segment download
+  if (url?.startsWith("segments:")) {
+    return "hls";
+  }
+
   switch (type) {
     case "hls":
-      return "highlevel"; // Use HLS downloader
+      return "highlevel"; // Use HLS downloader for standard HLS
     case "vimeo":
       return "vimeo";
     case "loom":

src/downloader/hlsDownloader.ts

@@ -236,6 +236,11 @@ export async function downloadHLSVideo(
     };
   }
 
+  // Handle special "segments:" URLs (for encrypted HLS with individual tokens)
+  if (hlsUrl.startsWith("segments:")) {
+    return downloadHLSSegments(hlsUrl, outputPath, onProgress);
+  }
+
   // Pre-validate the HLS URL before downloading
   try {
     const urlObj = new URL(hlsUrl);
@@ -466,3 +471,126 @@ export function parseHighLevelVideoUrl(url: string): {
     return null;
   }
 }
+
+/**
+ * Downloads HLS video from individual segment URLs (for encrypted HLS with per-segment tokens)
+ */
+async function downloadHLSSegments(
+  segmentsUrl: string,
+  outputPath: string,
+  onProgress?: (progress: DownloadProgress) => void
+): Promise<HLSDownloadResult> {
+  try {
+    // Decode segment URLs from base64-encoded JSON
+    const base64Data = segmentsUrl.replace("segments:", "");
+    const segmentData = Buffer.from(base64Data, "base64").toString("utf-8");
+    const segmentUrls: string[] = JSON.parse(segmentData) as string[];
+
+    if (segmentUrls.length === 0) {
+      return {
+        success: false,
+        error: "No segment URLs provided",
+        errorCode: "NO_SEGMENTS",
+      };
+    }
+
+    // Create temp directory for segments
+    const tempDir = path.join(path.dirname(outputPath), ".hls-segments");
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+
+    // Download all segments
+    const segmentPaths: string[] = [];
+    for (let i = 0; i < segmentUrls.length; i++) {
+      const segmentUrl = segmentUrls[i];
+      if (!segmentUrl) continue;
+
+      const segmentPath = path.join(tempDir, `segment${String(i).padStart(4, "0")}.ts`);
+      segmentPaths.push(segmentPath);
+
+      // Skip if already downloaded
+      if (fs.existsSync(segmentPath)) {
+        continue;
+      }
+
+      const response = await fetch(segmentUrl);
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Failed to download segment ${i}: HTTP ${response.status}`,
+          errorCode: "SEGMENT_FETCH_FAILED",
+        };
+      }
+
+      const buffer = await response.arrayBuffer();
+      fs.writeFileSync(segmentPath, Buffer.from(buffer));
+
+      // Report progress
+      if (onProgress) {
+        onProgress({
+          percent: Math.round(((i + 1) / segmentUrls.length) * 90), // Leave 10% for merging
+          phase: "downloading",
+        });
+      }
+    }
+
+    // Create concat file for ffmpeg
+    const concatPath = path.join(tempDir, "concat.txt");
+    const concatContent = segmentPaths.map((p) => `file '${p}'`).join("\n");
+    fs.writeFileSync(concatPath, concatContent);
+
+    // Merge segments with ffmpeg
+    if (onProgress) {
+      onProgress({ percent: 95, phase: "preparing" });
+    }
+
+    await execa("ffmpeg", [
+      "-y",
+      "-f",
+      "concat",
+      "-safe",
+      "0",
+      "-i",
+      concatPath,
+      "-c",
+      "copy",
+      outputPath,
+    ]);
+
+    // Clean up temp files
+    for (const p of segmentPaths) {
+      try {
+        fs.unlinkSync(p);
+      } catch {
+        /* ignore */
+      }
+    }
+    try {
+      fs.unlinkSync(concatPath);
+    } catch {
+      /* ignore */
+    }
+    try {
+      fs.rmdirSync(tempDir);
+    } catch {
+      /* ignore */
+    }
+
+    if (onProgress) {
+      onProgress({ percent: 100, phase: "complete" });
+    }
+
+    return {
+      success: true,
+      outputPath,
+    };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    return {
+      success: false,
+      error: `Segment download failed: ${error}`,
+      errorCode: "SEGMENT_DOWNLOAD_FAILED",
+    };
+  }
+}