ytdwn 1.1.2 → 1.1.3

package/README.md

@@ -24,12 +24,12 @@
 - 📁 **Custom Folders** - Set a default download directory
 - 🚀 **Fast Downloads** - Parallel fragment downloading
 - 🎨 **Beautiful UI** - Gradient banner, spinners, progress bars
-- 📦 **Auto-Setup** - Downloads yt-dlp binary automatically
+- 📦 **Auto-Setup** - Downloads yt-dlp binary and uses static FFmpeg automatically
 
 ## 📋 Requirements
 
 - [Node.js](https://nodejs.org) >= 18.0.0 or [Bun](https://bun.sh) >= 1.0.0
-- [FFmpeg](https://ffmpeg.org) (for video merging and audio conversion)
+- *FFmpeg is handled automatically via static binaries*
 
 ## 🚀 Quick Start
 

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // index.ts
 import { program } from "commander";
@@ -7,7 +25,7 @@ import { program } from "commander";
 import { join } from "path";
 var APP_NAME = "ytdwn";
 var APP_TAGLINE = "YouTube to MP3/MP4 • Fast & Simple";
-var APP_VERSION = "1.1.2";
+var APP_VERSION = "1.1.3";
 var DEFAULT_AUDIO_FORMAT = "mp3";
 var DEFAULT_AUDIO_QUALITY = "0";
 var CONCURRENT_FRAGMENTS = "8";
@@ -141,6 +159,7 @@ var SettingsServiceLive = Layer.succeed(SettingsService, {
 // src/services/BinaryService.ts
 import { Effect as Effect4, Context as Context2, Layer as Layer2 } from "effect";
 import YTDlpWrapModule from "yt-dlp-wrap";
+import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
 import { platform } from "os";
 import { join as join3 } from "path";
 
@@ -158,6 +177,7 @@ var fetchBinaryWithRetry = (url, maxRetries = 2) => Effect3.tryPromise({
 }).pipe(Effect3.retry(Schedule.recurs(maxRetries).pipe(Schedule.addDelay(() => "1 second"))));
 
 // src/services/BinaryService.ts
+var ffmpegPath = ffmpegInstaller.path;
 var YTDlpWrap = YTDlpWrapModule.default ?? YTDlpWrapModule;
 var BINARY_NAMES = {
   win32: ["yt-dlp.exe"],
@@ -231,6 +251,25 @@ var BinaryServiceLive = Layer2.effect(BinaryService, Effect4.gen(function* () {
       message: "yt-dlp binary not found. Run 'ytdwn prepare' first."
     }));
   });
+  const requireFFmpeg = Effect4.gen(function* () {
+    const systemPath = yield* Effect4.tryPromise({
+      try: async () => {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("util");
+        const execAsync = promisify(exec);
+        const cmd = process.platform === "win32" ? "where ffmpeg" : "which ffmpeg";
+        const { stdout } = await execAsync(cmd);
+        const outStr = String(stdout);
+        const firstLine = outStr.trim().split(`
+`)[0];
+        return firstLine ? firstLine.trim() : null;
+      },
+      catch: () => new Error("FFmpeg lookup failed")
+    }).pipe(Effect4.orElseSucceed(() => null));
+    if (systemPath)
+      return systemPath;
+    return ffmpegPath;
+  });
   const getYtDlpWrap = Effect4.gen(function* () {
     const binaryPath = yield* requireBinary;
     return new YTDlpWrap(binaryPath);
@@ -253,15 +292,13 @@ var BinaryServiceLive = Layer2.effect(BinaryService, Effect4.gen(function* () {
     const asset = yield* pickAsset(release);
     const binaryPath = join3(BIN_DIR, asset.name);
     const exists = yield* isExecutable(binaryPath);
-    if (exists) {
-      yield* settings.setCachedBinaryPath(binaryPath).pipe(Effect4.ignore);
-      return binaryPath;
-    }
-    yield* ensureDirectory(BIN_DIR);
-    const data = yield* fetchBinaryWithRetry(asset.browser_download_url);
-    yield* writeFileBinary(binaryPath, data);
-    if (platform() !== "win32") {
-      yield* makeExecutable(binaryPath);
+    if (!exists) {
+      yield* ensureDirectory(BIN_DIR);
+      const data = yield* fetchBinaryWithRetry(asset.browser_download_url);
+      yield* writeFileBinary(binaryPath, data);
+      if (platform() !== "win32") {
+        yield* makeExecutable(binaryPath);
+      }
     }
     yield* settings.setCachedBinaryPath(binaryPath).pipe(Effect4.ignore);
     return binaryPath;
@@ -270,39 +307,13 @@ var BinaryServiceLive = Layer2.effect(BinaryService, Effect4.gen(function* () {
     findBinary,
     requireBinary,
     getYtDlpWrap,
-    downloadLatestBinary
+    downloadLatestBinary,
+    requireFFmpeg
   };
 }));
 
 // src/services/DownloadService.ts
-import { Effect as Effect6, Context as Context3, Layer as Layer3 } from "effect";
-
-// src/timestamp.ts
-import { Effect as Effect5 } from "effect";
-var TIME_FORMAT_ERROR = "Invalid time format. Use MM:SS or HH:MM:SS (e.g. 0:02 or 01:23:45).";
-var RANGE_FORMAT_ERROR = "Range must be in 'start-end' format (e.g. 0:02-23:10).";
-var pad = (value) => value.padStart(2, "0");
-function normalizeTimeParts(parts) {
-  if (parts.length === 2) {
-    return ["0", parts[0] ?? "0", parts[1] ?? "0"];
-  }
-  return [parts[0] ?? "0", parts[1] ?? "0", parts[2] ?? "0"];
-}
-function parseTimestamp(raw) {
-  const parts = raw.split(":").map((p) => p.trim());
-  if (parts.length < 2 || parts.length > 3) {
-    throw new Error(TIME_FORMAT_ERROR);
-  }
-  const [h, m, s] = normalizeTimeParts(parts);
-  return `${pad(h)}:${pad(m)}:${pad(s)}`;
-}
-function parseClipRange(range) {
-  const parts = range.split("-").map((p) => p.trim());
-  if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new Error(RANGE_FORMAT_ERROR);
-  }
-  return `${parseTimestamp(parts[0])}-${parseTimestamp(parts[1])}`;
-}
+import { Effect as Effect5, Context as Context3, Layer as Layer3 } from "effect";
 
 // src/colors.ts
 import pc from "picocolors";
@@ -331,6 +342,9 @@ var c = {
 };
 
 // src/services/DownloadService.ts
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
 var SPINNER_FRAMES = [
   "⠋",
   "⠙",
@@ -416,7 +430,7 @@ function mapExitCodeToError(code, url) {
 }
 var VIDEO_FORMATS = ["mp4", "mkv", "webm", "avi", "mov"];
 var isVideoFormat = (format) => VIDEO_FORMATS.includes(format.toLowerCase());
-function buildArgs(url, options, downloadDir) {
+function buildArgs(url, options, downloadDir, ffmpegPath2) {
   const format = options.format.toLowerCase();
   const isVideo = isVideoFormat(format);
   const baseArgs = [
@@ -428,8 +442,12 @@ function buildArgs(url, options, downloadDir) {
     "--progress",
     "--concurrent-fragments",
     CONCURRENT_FRAGMENTS,
-    "--no-check-certificates"
+    "--no-check-certificates",
+    "--restrict-filenames"
   ];
+  if (ffmpegPath2) {
+    baseArgs.push("--ffmpeg-location", ffmpegPath2);
+  }
   const formatArgs = isVideo ? [
     "-f",
     "bestvideo+bestaudio/best",
@@ -445,14 +463,15 @@ function buildArgs(url, options, downloadDir) {
     DEFAULT_AUDIO_QUALITY,
     "--prefer-free-formats"
   ];
-  const clipArgs = options.clip ? ["--download-sections", `*${parseClipRange(options.clip)}`] : [];
+  const clipArgs = [];
   return [...baseArgs, ...formatArgs, ...clipArgs];
 }
 
 class DownloadService extends Context3.Tag("DownloadService")() {
 }
-function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
-  return Effect6.async((resume) => {
+function executeDownload(ytDlpWrap, args, downloadDir, url, options) {
+  const quiet = options.quiet ?? false;
+  return Effect5.async((resume) => {
     const spinner = createSpinner("Getting ready...", quiet);
     const state = {
       phase: "init",
@@ -469,7 +488,87 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
       if (!quiet)
         clearLine();
     };
+    const parseDurationSeconds = (timeStr) => {
+      const parts = timeStr.split(":").map(Number);
+      if (parts.length === 3)
+        return (parts[0] || 0) * 3600 + (parts[1] || 0) * 60 + (parts[2] || 0);
+      if (parts.length === 2)
+        return (parts[0] || 0) * 60 + (parts[1] || 0);
+      return parts[0] || 0;
+    };
+    const parseSizeToBytes = (sizeStr) => {
+      const match = sizeStr.match(/([\d.]+)\s*([KMG]i?B)/i);
+      if (!match || !match[1] || !match[2])
+        return 0;
+      const val = parseFloat(match[1]);
+      const unit = match[2].toUpperCase();
+      const multipliers = {
+        KB: 1024,
+        KIB: 1024,
+        MB: 1024 * 1024,
+        MIB: 1024 * 1024,
+        GB: 1024 * 1024 * 1024,
+        GIB: 1024 * 1024 * 1024
+      };
+      return val * (multipliers[unit] || 1);
+    };
+    const formatSpeed = (bytesPerSec) => {
+      if (bytesPerSec > 1024 * 1024)
+        return `${(bytesPerSec / (1024 * 1024)).toFixed(2)}MiB/s`;
+      if (bytesPerSec > 1024)
+        return `${(bytesPerSec / 1024).toFixed(2)}KiB/s`;
+      return `${bytesPerSec.toFixed(0)}B/s`;
+    };
+    let lastBytes = 0;
+    let lastTime = Date.now();
+    let currentSpeedStr;
+    let totalClipDuration = 0;
+    if (options.clip) {
+      const parts = options.clip.split("-");
+      if (parts.length === 2 && parts[0] && parts[1]) {
+        const start = parseDurationSeconds(parts[0]);
+        const end = parseDurationSeconds(parts[1]);
+        totalClipDuration = end - start;
+      }
+    }
     const emitter = ytDlpWrap.exec(args);
+    if (emitter.ytDlpProcess?.stderr) {
+      emitter.ytDlpProcess.stderr.on("data", (data) => {
+        const text = data.toString();
+        if (text.includes("frame=") && text.includes("time=")) {
+          if (state.phase === "init") {
+            state.phase = "downloading";
+            spinner.stop();
+          }
+          const timeMatch = text.match(/time=([\d:.]+)/);
+          const sizeMatch = text.match(/(?:Lsize|size)=\s*([\d.]+\s*[KMG]i?B)/i);
+          if (timeMatch?.[1]) {
+            const currentTime = parseDurationSeconds(timeMatch[1]);
+            let percent = 0;
+            if (totalClipDuration > 0) {
+              percent = currentTime / totalClipDuration * 100;
+              if (percent > 100)
+                percent = 100;
+            }
+            if (sizeMatch?.[1]) {
+              const currentBytes = parseSizeToBytes(sizeMatch[1]);
+              const now = Date.now();
+              const deltaMs = now - lastTime;
+              if (deltaMs > 500) {
+                const deltaBytes = currentBytes - lastBytes;
+                if (deltaBytes > 0) {
+                  const bytesPerSec = deltaBytes / deltaMs * 1000;
+                  currentSpeedStr = formatSpeed(bytesPerSec);
+                }
+                lastBytes = currentBytes;
+                lastTime = now;
+              }
+            }
+            renderProgress(percent, currentSpeedStr, quiet);
+          }
+        }
+      });
+    }
     emitter.on("progress", (progress) => {
       if (state.phase === "init") {
         state.phase = "downloading";
@@ -483,12 +582,25 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
       state.outputBuffer += `[${eventType}] ${eventData}
 `;
       if (eventType === "ExtractAudio" || eventType === "Merger") {
-        const match = eventData.match(/Destination:\s*(.+)/);
+        let match = eventData.match(/Destination:\s*(.+)/);
+        if (!match) {
+          match = eventData.match(/Merging formats into "(.+)"/);
+        }
         if (match?.[1]) {
           state.fileName = match[1].split("/").pop() || null;
         }
       }
+      if (eventType === "info" && eventData.includes("Downloading 1 time ranges")) {
+        if (state.phase === "init") {
+          state.phase = "downloading";
+          spinner.stop();
+        }
+      }
       if (eventType === "download") {
+        if (state.phase === "init") {
+          state.phase = "downloading";
+          spinner.stop();
+        }
         const destMatch = eventData.match(/Destination:\s*(.+)/);
         if (destMatch?.[1]) {
           state.fileName = destMatch[1].split("/").pop() || null;
@@ -497,6 +609,18 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
         if (sizeMatch?.[1]) {
           state.fileSize = sizeMatch[1];
         }
+        const cleanData = eventData.replace(/\u001b\[.*?m/g, "");
+        const percentMatch = cleanData.match(/(\d+(?:\.\d+)?)%/);
+        if (percentMatch?.[1]) {
+          if (state.phase !== "downloading") {
+            state.phase = "downloading";
+            spinner.stop();
+          }
+          const percent = parseFloat(percentMatch[1]);
+          const speedMatch = cleanData.match(/at\s+([~\d.]+\s*[KMG]i?B\/s)/);
+          const speed = speedMatch?.[1];
+          renderProgress(percent, speed || undefined, quiet);
+        }
       }
       if ((eventType === "ExtractAudio" || eventType === "ffmpeg") && state.phase !== "converting") {
         state.phase = "converting";
@@ -521,7 +645,7 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
     emitter.on("error", (error) => {
       cleanup();
       const outputError = mapOutputToError(String(error), url);
-      resume(Effect6.fail(outputError ?? new BinaryExecutionError({
+      resume(Effect5.fail(outputError ?? new BinaryExecutionError({
         exitCode: -1,
         message: String(error)
       })));
@@ -530,15 +654,15 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
       cleanup();
       const outputError = mapOutputToError(state.outputBuffer, url);
       if (outputError) {
-        resume(Effect6.fail(outputError));
+        resume(Effect5.fail(outputError));
         return;
       }
       const exitCode = emitter.ytDlpProcess?.exitCode;
       if (exitCode !== null && exitCode !== undefined && exitCode !== 0) {
-        resume(Effect6.fail(mapExitCodeToError(exitCode, url)));
+        resume(Effect5.fail(mapExitCodeToError(exitCode, url)));
         return;
       }
-      resume(Effect6.succeed({
+      resume(Effect5.succeed({
         filePath: downloadDir,
         fileName: state.fileName || "audio",
         fileSize: state.fileSize || undefined
@@ -546,18 +670,76 @@ function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
     });
   });
 }
-var DownloadServiceLive = Layer3.effect(DownloadService, Effect6.gen(function* () {
+var DownloadServiceLive = Layer3.effect(DownloadService, Effect5.gen(function* () {
   const binary = yield* BinaryService;
   const settings = yield* SettingsService;
   return {
-    download: (url, options) => Effect6.gen(function* () {
-      const [downloadDir, ytDlpWrap] = yield* Effect6.all([
-        settings.getDownloadDir.pipe(Effect6.flatMap((dir) => ensureDirectory(dir))),
-        binary.getYtDlpWrap
+    download: (url, options) => Effect5.gen(function* () {
+      const [downloadDir, ytDlpWrap, ffmpegPath2] = yield* Effect5.all([
+        settings.getDownloadDir.pipe(Effect5.flatMap((dir) => ensureDirectory(dir))),
+        binary.getYtDlpWrap,
+        binary.requireFFmpeg
       ]);
       const quiet = options.quiet ?? false;
-      const args = buildArgs(url, options, downloadDir);
-      return yield* executeDownload(ytDlpWrap, args, downloadDir, url, quiet);
+      const args = buildArgs(url, options, downloadDir, ffmpegPath2);
+      const result = yield* executeDownload(ytDlpWrap, args, downloadDir, url, options);
+      if (options.clip && ffmpegPath2 && result.fileName && result.filePath) {
+        const fullFilePath = path.join(result.filePath, result.fileName);
+        if (!fs.existsSync(fullFilePath)) {
+          if (!quiet)
+            console.error(c.error(`
+Could not find full file for cutting: ${fullFilePath}`));
+          return result;
+        }
+        const parts = options.clip.split("-");
+        if (parts.length === 2 && parts[0] && parts[1]) {
+          const startTime = parts[0];
+          const endTime = parts[1];
+          const ext = path.extname(result.fileName);
+          const baseName = path.basename(result.fileName, ext);
+          const clipFileName = `${baseName}_clip${ext}`;
+          const clipFilePath = path.join(result.filePath, clipFileName);
+          if (!quiet)
+            console.log(c.dim(`
+Cutting clip: ${startTime} to ${endTime}...`));
+          yield* Effect5.async((resume) => {
+            const ffmpeg = spawn(ffmpegPath2, [
+              "-i",
+              fullFilePath,
+              "-ss",
+              startTime,
+              "-to",
+              endTime,
+              "-c",
+              "copy",
+              "-y",
+              clipFilePath
+            ]);
+            ffmpeg.on("close", (code) => {
+              if (code === 0) {
+                try {
+                  fs.unlinkSync(fullFilePath);
+                } catch (e) {}
+                result.fileName = clipFileName;
+                result.fileSize = undefined;
+                resume(Effect5.void);
+              } else {
+                resume(Effect5.fail(new BinaryExecutionError({
+                  exitCode: code || -1,
+                  message: "Failed to cut clip with ffmpeg"
+                })));
+              }
+            });
+            ffmpeg.on("error", (err) => {
+              resume(Effect5.fail(new BinaryExecutionError({
+                exitCode: -1,
+                message: `FFmpeg spawn error: ${err.message}`
+              })));
+            });
+          });
+        }
+      }
+      return result;
     })
   };
 }));
@@ -567,8 +749,8 @@ var AppLive = DownloadServiceLive.pipe(Layer4.provide(BinaryServiceLive), Layer4
 var SettingsLive = SettingsServiceLive;
 var BinaryLive = BinaryServiceLive.pipe(Layer4.provide(SettingsServiceLive));
 // src/cli/errors.ts
-import { Effect as Effect7, Match, Console, pipe } from "effect";
-var formatAppError = (error) => Match.value(error).pipe(Match.tag("BinaryNotFoundError", (e) => e.message), Match.tag("VideoNotFoundError", () => "Video not found or private"), Match.tag("InvalidUrlError", () => "Invalid URL format"), Match.tag("AgeRestrictedError", () => "Age-restricted video (login required)"), Match.tag("ConnectionError", (e) => e.message), Match.tag("BinaryExecutionError", (e) => e.message), Match.tag("BinaryDownloadError", () => "Failed to download yt-dlp binary"), Match.tag("NetworkError", (e) => e.message), Match.tag("FileWriteError", () => "Failed to write file"), Match.tag("DirectoryCreateError", () => "Failed to create directory"), Match.exhaustive);
+import { Effect as Effect6, Match, Console, pipe } from "effect";
+var formatAppError = (error) => Match.value(error).pipe(Match.tag("BinaryNotFoundError", (e) => e.message), Match.tag("VideoNotFoundError", () => "Video not found or private"), Match.tag("InvalidUrlError", () => "Invalid URL format"), Match.tag("AgeRestrictedError", () => "Age-restricted video (login required)"), Match.tag("ConnectionError", (e) => e.message), Match.tag("BinaryExecutionError", (e) => e.message), Match.tag("BinaryDownloadError", () => "Failed to download yt-dlp binary"), Match.tag("DownloadError", (e) => `Download failed: ${e.url}`), Match.tag("NetworkError", (e) => e.message), Match.tag("FileWriteError", () => "Failed to write file"), Match.tag("DirectoryCreateError", () => "Failed to create directory"), Match.exhaustive);
 var isAppError = (error) => error !== null && typeof error === "object" && ("_tag" in error) && typeof error._tag === "string";
 var formatError = (error) => {
   if (isAppError(error))
@@ -577,10 +759,10 @@ var formatError = (error) => {
     return error.message;
   return String(error);
 };
-var withErrorHandler = (effect) => pipe(effect, Effect7.catchAll((error) => pipe(Console.error(`${c.sym.error} ${c.error("Error:")} ${formatError(error)}`), Effect7.flatMap(() => Effect7.sync(() => process.exit(1))))));
-var runCommand = (effect, layer) => Effect7.runPromise(pipe(effect, Effect7.provide(layer), withErrorHandler));
+var withErrorHandler = (effect) => pipe(effect, Effect6.catchAll((error) => pipe(Console.error(`${c.sym.error} ${c.error("Error:")} ${formatError(error)}`), Effect6.flatMap(() => Effect6.sync(() => process.exit(1))))));
+var runCommand = (effect, layer) => Effect6.runPromise(pipe(effect, Effect6.provide(layer), withErrorHandler));
 // src/cli/commands.ts
-import { Effect as Effect8 } from "effect";
+import { Effect as Effect7 } from "effect";
 // src/banner.ts
 import cfonts from "cfonts";
 import gradient from "gradient-string";
@@ -607,40 +789,41 @@ function showBanner() {
 }
 
 // src/cli/commands.ts
-var log = (message) => Effect8.sync(() => console.log(message));
+var log = (message) => Effect7.sync(() => console.log(message));
 var logSuccess = (message) => log(`${c.sym.success} ${c.success(message)}`);
 var logInfo = (message) => log(c.info(message));
 var logDim = (message) => log(c.dim(message));
-var prepareCommand = Effect8.gen(function* () {
+var prepareCommand = Effect7.gen(function* () {
   const binary = yield* BinaryService;
   const existing = yield* binary.findBinary;
-  if (existing) {
+  const ffmpeg = yield* binary.requireFFmpeg;
+  if (existing && ffmpeg) {
     yield* logSuccess("Ready");
     return;
   }
-  yield* logDim("Downloading yt-dlp...");
+  yield* logDim("Downloading dependencies...");
   yield* binary.downloadLatestBinary;
   yield* logSuccess("Ready");
 });
-var setFolderCommand = (path, options) => Effect8.gen(function* () {
+var setFolderCommand = (path2, options) => Effect7.gen(function* () {
   const settings = yield* SettingsService;
   if (options?.reset) {
     yield* settings.resetDownloadDir;
     yield* logSuccess("Reset to current directory");
     return;
   }
-  if (path) {
-    yield* settings.setDownloadDir(path);
-    yield* log(`${c.sym.success} ${c.info(path)}`);
+  if (path2) {
+    yield* settings.setDownloadDir(path2);
+    yield* log(`${c.sym.success} ${c.info(path2)}`);
   } else {
     const dir = yield* settings.getDownloadDir;
     yield* logInfo(dir);
   }
 });
-var downloadCommand = (url, options) => Effect8.gen(function* () {
+var downloadCommand = (url, options) => Effect7.gen(function* () {
   const quiet = options.quiet ?? false;
   if (!quiet) {
-    yield* Effect8.sync(() => showBanner());
+    yield* Effect7.sync(() => showBanner());
     yield* log(`${c.dim("URL:")} ${c.info(url)}
 `);
   }
@@ -674,7 +857,7 @@ var configureCli = () => {
     }
   });
   program.command("prepare").description("Download yt-dlp binary").action(() => runCommand(prepareCommand, BinaryLive));
-  program.command("setDefaultFolder [path]").description("Set or view default download folder").option("-r, --reset", "Reset to current directory").action((path, opts) => runCommand(setFolderCommand(path, opts), SettingsLive));
+  program.command("setDefaultFolder [path]").description("Set or view default download folder").option("-r, --reset", "Reset to current directory").action((path2, opts) => runCommand(setFolderCommand(path2, opts), SettingsLive));
   return program;
 };
 var main = () => {

package/dist/src/cli/errors.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Layer } from "effect";
-import { BinaryNotFoundError, VideoNotFoundError, InvalidUrlError, AgeRestrictedError, ConnectionError, BinaryExecutionError, BinaryDownloadError, NetworkError, FileWriteError, DirectoryCreateError } from "../lib/errors";
-export type AppError = BinaryNotFoundError | VideoNotFoundError | InvalidUrlError | AgeRestrictedError | ConnectionError | BinaryExecutionError | BinaryDownloadError | NetworkError | FileWriteError | DirectoryCreateError;
+import { BinaryNotFoundError, VideoNotFoundError, InvalidUrlError, AgeRestrictedError, ConnectionError, BinaryExecutionError, BinaryDownloadError, DownloadError, NetworkError, FileWriteError, DirectoryCreateError } from "../lib/errors";
+export type AppError = BinaryNotFoundError | VideoNotFoundError | InvalidUrlError | AgeRestrictedError | ConnectionError | BinaryExecutionError | BinaryDownloadError | DownloadError | NetworkError | FileWriteError | DirectoryCreateError;
 export declare const formatError: (error: unknown) => string;
 /**
  * Runs an effect with error handling. Main entry point for CLI commands.

package/dist/src/config.d.ts

@@ -1,6 +1,6 @@
 export declare const APP_NAME = "ytdwn";
 export declare const APP_TAGLINE = "YouTube to MP3/MP4 \u2022 Fast & Simple";
-export declare const APP_VERSION = "1.1.2";
+export declare const APP_VERSION = "1.1.3";
 export declare const DEFAULT_AUDIO_FORMAT = "mp3";
 export declare const DEFAULT_AUDIO_QUALITY = "0";
 export declare const DEFAULT_VIDEO_FORMAT = "mp4";

package/dist/src/services/BinaryService.d.ts

@@ -5,9 +5,10 @@ import { BinaryNotFoundError, BinaryDownloadError, type DownloadError, type File
 import { SettingsService } from "./SettingsService";
 declare const BinaryService_base: Context.TagClass<BinaryService, "BinaryService", {
     readonly findBinary: Effect.Effect<string | null>;
-    readonly requireBinary: Effect.Effect<string, BinaryNotFoundError>;
+    readonly requireFFmpeg: Effect.Effect<string>;
     readonly getYtDlpWrap: Effect.Effect<InstanceType<typeof YTDlpWrap>, BinaryNotFoundError>;
     readonly downloadLatestBinary: Effect.Effect<string, BinaryDownloadError | DownloadError | FileWriteError | DirectoryCreateError>;
+    readonly requireBinary: Effect.Effect<string, BinaryNotFoundError>;
 }>;
 export declare class BinaryService extends BinaryService_base {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ytdwn",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "A fast and simple CLI tool to download audio and video from YouTube",
   "author": {
     "name": "Batikan Kutluer",
@@ -54,6 +54,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "cfonts": "^3.3.1",
     "commander": "^14.0.2",
     "effect": "^3.19.14",
@@ -66,4 +67,4 @@
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
   }
-}
+}