Add picture_quality support and FFmpeg fixes

Propagate a new picture_quality field through download portal and app-ffmpeg routes and handlers. Include picture_quality in job IDs and temporary filenames, add schema validation, and sanitize filenames (cleanName/cleanNameV2). Improve file discovery to filter by picture_quality and remove corrupted files. Enhance ffprobe error reporting to include JSON with code/message, fix console.error typo, log resource usage, ensure task_failed is called on stdout errors, and return meaningful results for ops=just_check. Misc small refactors: S3 dir/path changes, content-disposition uses original filename, and formatting/typo cleanups.

src/lib/ffmpeg.ts

@@ -407,7 +407,13 @@ async function F_probe_v2(arg0: {
 
   if (exitCode !== 0) {
     clearTimeout(t);
-    throw new Error(`Probe failed with code (${exitCode}): ${stderr}`);
+    throw new Error(
+      JSON.stringify({
+        message: `Probe failed with code [${exitCode}]: ${stderr}`,
+        code: exitCode,
+        stderr: stderr
+      })
+    );
   }
 
   const metadata: FfprobeData = JSON.parse(txt);

src/sub-router/ffmpeg.ts

@@ -24,6 +24,7 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
       let gen = body?.gen;
       let playback_type = body?.playback_type;
       const sbe_id = body?.sbe_id;
+      const picture_quality = body?.picture_quality;
 
       const REQ0 = request.url;
       const REQ_ORIGIN = (ctx as any).publicOrigin || new URL(REQ0).origin;
@@ -76,7 +77,7 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
 
       if (E_ || !R_ || !R_.probe_data) {
         console.log("\n");
-        console.eroor("E_", E_);
+        console.error("E_", E_);
         console.log("\n");
         const { status, message } = NS_error.F_collect_error_status_n_message({
           ERR: E_
@@ -99,7 +100,7 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         output_filename,
         subtitles
       } = gen;
-      
+
       const is_valid_progress_feedback_url = (() => {
         if (!progress_feedback_url) return;
 
@@ -198,7 +199,8 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         probe_data,
         progress_update_endpoint,
         playback_type,
-        sbe_id
+        sbe_id,
+        picture_quality
       };
 
       const data_str = devalue.stringify(data);
@@ -218,7 +220,7 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         });
 
         let key = `ffmpeg:${track_id}`;
-        if(APP_ACCOUNT_ABC) key = `${key}:${APP_ACCOUNT_ABC}`
+        if (APP_ACCOUNT_ABC) key = `${key}:${APP_ACCOUNT_ABC}`;
 
         // 30 days = 30 * 24 * 60 * 60 = 2,592,000 seconds
         const ONE_MONTH_IN_SECONDS = 2592000;
@@ -268,6 +270,14 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
             }
           })
         ),
+        picture_quality: t.Optional(
+          t.String({
+            minLength: 1,
+            error() {
+              return "Invalid picture quality";
+            }
+          })
+        ),
         gen: t.Optional(
           t.Object(
             {

src/sub-router/showtime.ts

@@ -81,11 +81,19 @@ const sub_router = new Elysia({ prefix: "/showtime" })
           })
         ),
         ops: t.Optional(
-          t.Union([t.Literal("cmd"), t.Literal("raw"), t.Literal("decode"), t.Literal("just_check")], {
-            error() {
-              return "Invalid operation, must be one of: cmd, raw, decode";
+          t.Union(
+            [
+              t.Literal("cmd"),
+              t.Literal("raw"),
+              t.Literal("decode"),
+              t.Literal("just_check")
+            ],
+            {
+              error() {
+                return "Invalid operation, must be one of: cmd, raw, decode";
+              }
             }
-          })
+          )
         )
       })
     }
@@ -136,6 +144,17 @@ const sub_router = new Elysia({ prefix: "/showtime" })
     }
   );
 
+function cleanName(name: string): string {
+  // Replace any character that is not a letter, number, bracket, -, or _ with an underscore
+  return name.replace(/[^\w\-()[\]{}]/g, "_");
+}
+
+function cleanNameV2(name: string): string {
+  // Keep only letters, numbers, -, _, (, ), [, ], {, }, and .
+  // Replace everything else with _
+  return name.replace(/[^\w\-()[\]{}.]/g, "_");
+}
+
 async function F_handle_process(arg0: {
   data: string;
   live: string;
@@ -197,7 +216,8 @@ async function F_handle_process(arg0: {
     probe_data,
     progress_update_endpoint,
     playback_type,
-    sbe_id
+    sbe_id,
+    picture_quality
   } = start_data;
 
   const REQ0 = new URL(request.url);
@@ -225,10 +245,6 @@ async function F_handle_process(arg0: {
     throw createError(400, "Please provide a valid playback URL");
   }
 
-  if (!is_valid_playback_url) {
-    throw createError(400, "Please provide a valid playback URL");
-  }
-
   if (!output_format) {
     output_format = "mp4";
   }
@@ -258,6 +274,22 @@ async function F_handle_process(arg0: {
     output_destination = `${output_destination}.${output_format}`;
   }
 
+  const og_output_destination = output_destination;
+
+  output_destination = cleanNameV2(output_destination);
+
+  if (typeof picture_quality === "string") {
+    picture_quality = picture_quality.trim();
+
+    if (picture_quality) {
+      picture_quality = cleanName(picture_quality);
+    } else {
+      picture_quality = undefined;
+    }
+  } else {
+    picture_quality = undefined;
+  }
+
   const tcp_progress = is_valid_progress_feedback_url ? true : false;
 
   const subtitles_ary = (() => {
@@ -342,7 +374,9 @@ async function F_handle_process(arg0: {
   // -------------------------------
   const is_download = live === "download" && sbe_id;
 
-  const job_id = is_download ? `${sbe_id}-${output_destination}` : undefined;
+  const job_id = is_download
+    ? `${sbe_id}${picture_quality ? `-${picture_quality.trim()}` : ""}-${output_destination}`
+    : undefined;
 
   let last_failed = false;
 
@@ -386,7 +420,8 @@ async function F_handle_process(arg0: {
             percent,
             transcoded_size,
             track_process: progress_endpoint,
-            ...(ops === 'just_check' ? {passed: true} : {})
+            file: og_output_destination,
+            ...(ops === "just_check" ? { passed: true } : {})
           };
         }
         break;
@@ -394,14 +429,22 @@ async function F_handle_process(arg0: {
       case "done":
         {
           const file_path = current_job?.tmp_path;
+          const percent = current_job?.percent;
+          const percentage = typeof percent === "number" ? `${percent} %` : "";
+          const transcoded_size = current_job?.transcoded_size;
+          const progress_endpoint = current_job?.progress_endpoint;
 
           const _ = await serve_download({ file_path, job_id, ctx, request });
 
           if (_) {
-            if(ops === 'just_check') {
+            if (ops === "just_check") {
               return {
-                passed: true
-              }
+                passed: true,
+                percent,
+                transcoded_size,
+                track_process: progress_endpoint,
+                file: og_output_destination
+              };
             }
             console.log("SERVING FILE ============ ", file_path, "\n");
             return _;
@@ -412,20 +455,23 @@ async function F_handle_process(arg0: {
     }
   }
 
-  const tmpDir = path.join(STORAGE_ROOT, "cache", `${sbe_id}`);
+  const S3Dir = path.join(STORAGE_ROOT, "cache", `${sbe_id}`);
 
   let tmp_download_path: string | null | undefined = await (async () => {
     if (!is_download) return;
     try {
-      // await Bun.mkdir(tmpDir, { recursive: true }).catch(() => {});
+      // await Bun.mkdir(S3Dir, { recursive: true }).catch(() => {});
 
-      node_fs.mkdirSync(tmpDir, { recursive: true });
+      node_fs.mkdirSync(S3Dir, { recursive: true });
 
-      const tmpPath = path.join(tmpDir, `${Date.now()}-${output_destination}`);
+      const filePath = path.join(
+        S3Dir,
+        `${Date.now()}${picture_quality ? `-${picture_quality.trim()}` : ""}-${output_destination}`
+      );
 
-      console.log("\n", "PATH:", tmpPath, "\n");
+      console.log("\n", "FILE PATH:", filePath, "\n");
 
-      return tmpPath;
+      return filePath;
     } catch (e) {
       console.error({ e });
     }
@@ -436,29 +482,32 @@ async function F_handle_process(arg0: {
   if (file_mode) {
     const found_file = await find_latest_valid_file({
       sbe_id,
-      output_destination
+      picture_quality,
+      output_destination,
+      S3Dir
     });
 
     console.log("FOUND A FILE ============ ", found_file, "\n");
 
-    if (typeof found_file === "string" && found_file) {
+    if (typeof found_file === "string" && found_file.trim()) {
       const _ = await serve_download({
-        file_path: found_file,
+        file_path: found_file.trim(),
         job_id,
         ctx,
         request
       });
 
       if (_) {
-        if(ops === 'just_check') {
+        if (ops === "just_check") {
           return {
+            file: og_output_destination,
             passed: true
-          }
+          };
         }
         return _;
       }
     } else if (last_failed) {
-      throw Error;
+      throw new Error("Something went wrong");
     }
   }
 
@@ -549,11 +598,18 @@ async function F_handle_process(arg0: {
     })();
   }
 
-  function task_processing(arg0: { percent: number, size?: string, progress_endpoint?: string }) {
+  function task_processing(arg0: {
+    percent: number;
+    size?: string;
+    progress_endpoint?: string;
+  }) {
     const { percent } = arg0;
 
-    const size = typeof arg0.size === 'string' ? arg0.size : undefined;
-    const progress_endpoint = arg0.progress_endpoint && NS_misc.isValidUrlFormat(arg0.progress_endpoint) ? arg0.progress_endpoint : undefined;
+    const size = typeof arg0.size === "string" ? arg0.size : undefined;
+    const progress_endpoint =
+      arg0.progress_endpoint && NS_misc.isValidUrlFormat(arg0.progress_endpoint)
+        ? arg0.progress_endpoint
+        : undefined;
 
     (() => {
       if (!job_id) return;
@@ -565,7 +621,8 @@ async function F_handle_process(arg0: {
           status: "in-progress",
           tmp_path: tmp_download_path,
           percent,
-          transcoded_size: size, progress_endpoint,
+          transcoded_size: size,
+          progress_endpoint,
           created_at: Date.now()
         });
       } else {
@@ -573,7 +630,8 @@ async function F_handle_process(arg0: {
           ...current_job,
           status: "in-progress",
           percent,
-          transcoded_size: size, progress_endpoint
+          transcoded_size: size,
+          progress_endpoint
         });
       }
     })();
@@ -617,7 +675,7 @@ async function F_handle_process(arg0: {
     }
 
     ctx.set.headers["content-disposition"] =
-      `attachment; filename="${output_destination}"`;
+      `attachment; filename="${og_output_destination || output_destination}"`;
     ctx.set.headers["cache-control"] = "no-cache";
     ctx.set.headers["accept-ranges"] = "bytes";
 
@@ -647,20 +705,49 @@ async function F_handle_process(arg0: {
     return file;
   }
 
+  function isValidUnixTimestamp(timestamp: number): boolean {
+    const date = new Date(timestamp);
+    return !isNaN(date.getTime());
+  }
+
   // ── helper (module level) ───────
   async function find_latest_valid_file(arg0: {
     sbe_id: string;
+    picture_quality?: string;
     output_destination: string;
+    S3Dir: string;
   }): Promise<string | null | undefined> {
-    const { sbe_id, output_destination } = arg0;
+    const { sbe_id, picture_quality, output_destination, S3Dir } = arg0;
+
+    const dir = S3Dir;
 
-    const dir = path.join(process.cwd(), "S3", "ffmpeg-downloads", `${sbe_id}`);
+    console.log(
+      "\n",
+      `🔎 ==== FIELD SEARCHING FOR: ${picture_quality?.trim() ? picture_quality.trim() : "ALL"} ${output_destination} ====`,
+      "\n"
+    );
 
     try {
       const entries = await node_fs.promises.readdir(dir);
 
       // keep only files that contain output_destination in the name
-      const matches = entries.filter((f) => f.includes(output_destination));
+      let matches = entries.filter((f) =>
+        f.toLowerCase().includes(output_destination.toLowerCase())
+      );
+
+      if (!matches.length) return null;
+
+      // keep only files that contain picture_quality in the name
+      if (picture_quality?.trim()) {
+        const query = picture_quality.trim().toLowerCase();
+        matches = matches.filter((f) => f.toLowerCase().includes(query));
+      } else {
+        matches = matches.filter((f) => {
+          const _ = f.toLowerCase().split("-");
+          const __ = _.slice(1);
+          return __.join("-").startsWith(`${output_destination.toLowerCase()}`);
+        });
+      }
 
       if (!matches.length) return null;
 
@@ -679,7 +766,6 @@ async function F_handle_process(arg0: {
           try {
             const stat = await node_fs.promises.stat(full_path);
             if (!(stat.size > 0)) {
-              node_fs.promises.unlink(full_path).catch(() => {});
               continue;
             }
 
@@ -698,7 +784,60 @@ async function F_handle_process(arg0: {
             }
 
             if (E_) {
+              const message = E_.message;
+
+              if (typeof message === "string") {
+                try {
+                  const data = JSON.parse(message);
+                  const code = parseInt(`${data?.code}`);
+
+                  if (code && (code === 143 || code === 0)) {
+                    return full_path;
+                  }
+                } catch {}
+              }
+            }
+          } catch (e) {
+            continue;
+          }
+        }
+      })();
+
+      // clean corrupted files
+      (async () => {
+        for (const filename of matches) {
+          const full_path = path.join(dir, filename);
+
+          try {
+            const stat = await node_fs.promises.stat(full_path);
+            if (!(stat.size > 0)) {
               node_fs.promises.unlink(full_path).catch(() => {});
+              continue;
+            }
+
+            const [E_, R_] = await NS_promise.F_catch_promise({
+              promise: NS_ffmpeg.F_probe_v2({
+                playback_url: new URL("http://localhost:0000/"),
+                context: ctx as any,
+                file_mode: {
+                  path: full_path
+                }
+              })
+            });
+
+            if (E_) {
+              const message = E_.message;
+
+              if (typeof message === "string") {
+                try {
+                  const data = JSON.parse(message);
+                  const code = parseInt(`${data?.code}`);
+
+                  if (code && code !== 143) {
+                    node_fs.promises.unlink(full_path).catch(() => {});
+                  }
+                } catch {}
+              }
             }
           } catch (e) {
             continue;
@@ -711,13 +850,39 @@ async function F_handle_process(arg0: {
       }
     } catch (e) {
       // dir doesn't exist yet or unreadable
+      console.error("HERE >>>", e);
       return null;
     }
   }
 
+  if (ops === "just_check") {
+    if (file_mode) {
+      const found_file = await find_latest_valid_file({
+        sbe_id,
+        picture_quality,
+        output_destination,
+        S3Dir: S3Dir
+      });
+
+      return {
+        passed: found_file
+          ? true
+          : (() => {
+              if (!last_failed) {
+                return { passed: true };
+              }
+              return false;
+            })()
+      };
+    }
+
+    return {};
+  }
+
   if (abort_signal) {
     if (abort_signal.aborted) {
       kill_controller();
+      return
     } else {
       abort_signal.addEventListener(
         "abort",
@@ -731,26 +896,6 @@ async function F_handle_process(arg0: {
     }
   }
 
-  if(ops === 'just_check') {
-    if (file_mode) {
-      const found_file = await find_latest_valid_file({
-        sbe_id,
-        output_destination
-      });
-
-      return {passed: found_file ? true : (() => {
-          if(!last_failed) {
-            return {passed: true}
-          }
-          return false
-      })()}
-    }
-
-
-
-    return {}
-  }
-
   console.log("\n", "PINGING FFMPEG NOW", "\n");
 
   // -------------------------------
@@ -868,6 +1013,8 @@ async function F_handle_process(arg0: {
     return proc;
   })();
 
+  bun_proc.killed;
+
   const logged_proc_errors: string[] = [];
 
   const has_pipe_3 = (bun_proc as any).extraPipe && bun_proc.stdio[3];
@@ -963,7 +1110,11 @@ async function F_handle_process(arg0: {
         })();
 
         if (APP_ENV === "dev") {
-          console.log("[ffmpeg PROGRESS]:", { progress_update }, "\n");
+          console.log(
+            "[ffmpeg PROGRESS]:",
+            { progress_update, file: og_output_destination },
+            "\n"
+          );
         }
 
         const ws_client_id = ctx.request.headers.get("x-ws-client-id");
@@ -982,7 +1133,11 @@ async function F_handle_process(arg0: {
         (() => {
           const percent = (progress_update as any)?.percentage;
           if (percent && parseFloat(`${percent}`) && file_mode) {
-            task_processing({ percent: parseFloat(`${percent}`), size: forward_progress.current_filesize, progress_endpoint: progress_update_endpoint });
+            task_processing({
+              percent: parseFloat(`${percent}`),
+              size: (forward_progress as any)?.current_filesize,
+              progress_endpoint: progress_update_endpoint
+            });
 
             if (parseFloat(`${percent}`) >= 100) {
               task_finished();
@@ -1043,12 +1198,15 @@ async function F_handle_process(arg0: {
           })();
 
           const { done, value } = await reader.read();
+
           if (done) {
             task_finished();
 
             console.log("\n");
             console.log(
               `FFMPEG finished -> ${schemed_data?.current_filesize} ${tmp_download_path}`,
+              "\n",
+              bun_proc.resourceUsage(),
               "\n"
             );
             break;
@@ -1060,6 +1218,7 @@ async function F_handle_process(arg0: {
         }
       } catch (e) {
         console.error("Error reading stdout:", e);
+        task_failed();
       }
       return;
     }
@@ -1097,7 +1256,9 @@ async function F_handle_process(arg0: {
 
     if (code === 0) {
       console.log(
-        `FFMPEG finished -> ${schemed_data?.current_filesize} ${output_destination}`,
+        `FFMPEG finished -> ${schemed_data?.current_filesize} ${og_output_destination || output_destination}`,
+        "\n",
+        bun_proc.resourceUsage(),
         "\n"
       );
     } else {