ytdwn 1.0.1 → 1.1.1

package/dist/index.js

@@ -1,22 +1,4 @@
 #!/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";
@@ -24,59 +6,159 @@ import { program } from "commander";
 // src/config.ts
 import { join } from "path";
 var APP_NAME = "ytdwn";
-var APP_TAGLINE = "YouTube to MP3 • Fast & Simple";
-var APP_VERSION = "1.0.0";
-var DEFAULT_FORMAT = "mp3";
+var APP_TAGLINE = "YouTube to MP3/MP4 • Fast & Simple";
+var APP_VERSION = "1.1.1";
+var DEFAULT_AUDIO_FORMAT = "mp3";
 var DEFAULT_AUDIO_QUALITY = "0";
 var CONCURRENT_FRAGMENTS = "8";
+var DEFAULT_FORMAT = DEFAULT_AUDIO_FORMAT;
 var BIN_DIR = join(process.cwd(), "bin");
 var getOutputTemplate = (downloadDir) => join(downloadDir, "%(title)s.%(ext)s");
 
-// src/binary.ts
-import { constants as fsConstants } from "fs";
-import { access, chmod, mkdir, writeFile as writeFile2 } from "fs/promises";
-import { platform } from "os";
-import { join as join3, dirname } from "path";
+// src/layers/AppLive.ts
+import { Layer as Layer4 } from "effect";
 
-// src/settings.ts
-import { readFile, writeFile } from "fs/promises";
+// src/services/SettingsService.ts
+import { Effect as Effect2, Context, Layer } from "effect";
 import { homedir } from "os";
 import { join as join2, resolve } from "path";
-var SETTINGS_PATH = join2(homedir(), ".ytdwn.json");
-async function load() {
-  try {
-    return JSON.parse(await readFile(SETTINGS_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
+
+// src/lib/filesystem.ts
+import { Effect } from "effect";
+import {
+  access,
+  chmod,
+  mkdir,
+  readFile,
+  writeFile,
+  constants as fsConstants
+} from "fs/promises";
+
+// src/lib/errors.ts
+import { Data } from "effect";
+
+class FileWriteError extends Data.TaggedError("FileWriteError") {
+}
+
+class DirectoryCreateError extends Data.TaggedError("DirectoryCreateError") {
+}
+
+class NetworkError extends Data.TaggedError("NetworkError") {
+}
+
+class DownloadError extends Data.TaggedError("DownloadError") {
 }
-var save = (settings) => writeFile(SETTINGS_PATH, JSON.stringify(settings, null, 2));
-async function getDownloadDir() {
-  const { downloadDir } = await load();
-  return downloadDir ?? process.cwd();
+
+class BinaryNotFoundError extends Data.TaggedError("BinaryNotFoundError") {
 }
-async function setDownloadDir(dir) {
-  const settings = await load();
-  await save({ ...settings, downloadDir: resolve(dir) });
+
+class BinaryDownloadError extends Data.TaggedError("BinaryDownloadError") {
 }
-async function resetDownloadDir() {
-  const { downloadDir, ...rest } = await load();
-  await save(rest);
+
+class BinaryExecutionError extends Data.TaggedError("BinaryExecutionError") {
 }
-async function getCachedBinaryPath() {
-  const { binaryPath } = await load();
-  return binaryPath ?? null;
+
+class TimestampParseError extends Data.TaggedError("TimestampParseError") {
+}
+
+class VideoNotFoundError extends Data.TaggedError("VideoNotFoundError") {
+}
+
+class InvalidUrlError extends Data.TaggedError("InvalidUrlError") {
 }
-async function setCachedBinaryPath(path) {
-  const settings = await load();
-  await save({ ...settings, binaryPath: path });
+
+class AgeRestrictedError extends Data.TaggedError("AgeRestrictedError") {
 }
-async function clearCachedBinaryPath() {
-  const { binaryPath, ...rest } = await load();
-  await save(rest);
+
+class ConnectionError extends Data.TaggedError("ConnectionError") {
 }
 
-// src/binary.ts
+// src/lib/filesystem.ts
+var isExecutable = (path) => Effect.tryPromise({
+  try: async () => {
+    await access(path, fsConstants.X_OK);
+    return true;
+  },
+  catch: () => false
+}).pipe(Effect.orElseSucceed(() => false));
+var readJsonFileOrDefault = (path, defaultValue) => Effect.tryPromise({
+  try: async () => JSON.parse(await readFile(path, "utf-8")),
+  catch: () => defaultValue
+}).pipe(Effect.orElseSucceed(() => defaultValue));
+var writeJsonFile = (path, data) => Effect.tryPromise({
+  try: () => writeFile(path, JSON.stringify(data, null, 2), "utf-8"),
+  catch: (cause) => new FileWriteError({ path, cause })
+});
+var writeFileBinary = (path, data) => Effect.tryPromise({
+  try: () => writeFile(path, data),
+  catch: (cause) => new FileWriteError({ path, cause })
+});
+var ensureDirectory = (path) => Effect.tryPromise({
+  try: () => mkdir(path, { recursive: true }),
+  catch: (cause) => new DirectoryCreateError({ path, cause })
+}).pipe(Effect.as(path));
+var makeExecutable = (path) => Effect.tryPromise({
+  try: () => chmod(path, 493),
+  catch: (cause) => new FileWriteError({ path, cause })
+});
+
+// src/services/SettingsService.ts
+var SETTINGS_PATH = join2(homedir(), ".ytdwn.json");
+
+class SettingsService extends Context.Tag("SettingsService")() {
+}
+var loadSettings = () => readJsonFileOrDefault(SETTINGS_PATH, {});
+var saveSettings = (settings) => writeJsonFile(SETTINGS_PATH, settings);
+var SettingsServiceLive = Layer.succeed(SettingsService, {
+  getDownloadDir: Effect2.gen(function* () {
+    const { downloadDir } = yield* loadSettings();
+    return downloadDir ?? process.cwd();
+  }),
+  setDownloadDir: (dir) => Effect2.gen(function* () {
+    const settings = yield* loadSettings();
+    yield* saveSettings({ ...settings, downloadDir: resolve(dir) });
+  }),
+  resetDownloadDir: Effect2.gen(function* () {
+    const settings = yield* loadSettings();
+    const { downloadDir: _, ...rest } = settings;
+    yield* saveSettings(rest);
+  }),
+  getCachedBinaryPath: Effect2.gen(function* () {
+    const { binaryPath } = yield* loadSettings();
+    return binaryPath ?? null;
+  }),
+  setCachedBinaryPath: (path) => Effect2.gen(function* () {
+    const settings = yield* loadSettings();
+    yield* saveSettings({ ...settings, binaryPath: path });
+  }),
+  clearCachedBinaryPath: Effect2.gen(function* () {
+    const settings = yield* loadSettings();
+    const { binaryPath: _, ...rest } = settings;
+    yield* saveSettings(rest);
+  })
+});
+
+// src/services/BinaryService.ts
+import { Effect as Effect4, Context as Context2, Layer as Layer2 } from "effect";
+import YTDlpWrapModule from "yt-dlp-wrap";
+import { platform } from "os";
+import { join as join3 } from "path";
+
+// src/lib/http.ts
+import { Effect as Effect3, Schedule } from "effect";
+var fetchBinaryWithRetry = (url, maxRetries = 2) => Effect3.tryPromise({
+  try: async () => {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  },
+  catch: (cause) => new DownloadError({ url, cause })
+}).pipe(Effect3.retry(Schedule.recurs(maxRetries).pipe(Schedule.addDelay(() => "1 second"))));
+
+// src/services/BinaryService.ts
+var YTDlpWrap = YTDlpWrapModule.default ?? YTDlpWrapModule;
 var BINARY_NAMES = {
   win32: ["yt-dlp.exe"],
   darwin: {
@@ -89,7 +171,7 @@ var BINARY_NAMES = {
   }
 };
 var FALLBACK_BINARY = "yt-dlp";
-function getCandidateNames() {
+var getCandidateNames = () => {
   const platformNames = BINARY_NAMES[process.platform];
   if (!platformNames)
     return [FALLBACK_BINARY];
@@ -97,96 +179,106 @@ function getCandidateNames() {
     return platformNames;
   const archNames = platformNames[process.arch];
   return archNames ?? [FALLBACK_BINARY];
-}
-function getCandidatePaths() {
-  return getCandidateNames().map((name) => join3(BIN_DIR, name));
-}
-async function isExecutable(filePath) {
-  try {
-    await access(filePath, fsConstants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function downloadFile(url, targetPath) {
-  await mkdir(dirname(targetPath), { recursive: true });
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
-  }
-  await writeFile2(targetPath, Buffer.from(await response.arrayBuffer()));
-  if (platform() !== "win32") {
-    await chmod(targetPath, 493);
-  }
-}
-function pickAsset(release) {
+};
+var getCandidatePaths = () => getCandidateNames().map((name) => join3(BIN_DIR, name));
+var pickAsset = (release) => {
   const assets = release.assets ?? [];
   const candidates = getCandidateNames();
   const match = assets.find((a) => candidates.includes(a.name)) ?? assets.find((a) => a.name === FALLBACK_BINARY);
   if (!match) {
-    throw new Error("Suitable yt-dlp binary not found for this platform.");
+    return Effect4.fail(new BinaryDownloadError({
+      platform: `${process.platform}-${process.arch}`,
+      cause: "No suitable binary found for this platform"
+    }));
   }
-  return match;
-}
-async function findBinary() {
-  const cached = await getCachedBinaryPath();
-  if (cached && await isExecutable(cached)) {
-    return cached;
-  }
-  for (const candidate of getCandidatePaths()) {
-    if (await isExecutable(candidate)) {
-      await setCachedBinaryPath(candidate);
-      return candidate;
+  return Effect4.succeed(match);
+};
+
+class BinaryService extends Context2.Tag("BinaryService")() {
+}
+var BinaryServiceLive = Layer2.effect(BinaryService, Effect4.gen(function* () {
+  const settings = yield* SettingsService;
+  const searchForBinary = Effect4.gen(function* () {
+    for (const candidate of getCandidatePaths()) {
+      const executable = yield* isExecutable(candidate);
+      if (executable) {
+        yield* settings.setCachedBinaryPath(candidate).pipe(Effect4.ignore);
+        return candidate;
+      }
     }
-  }
-  if (cached)
-    await clearCachedBinaryPath();
-  return null;
-}
-async function requireBinary() {
-  const existing = await findBinary();
-  if (existing)
-    return existing;
-  throw new Error("yt-dlp binary not found. Run 'ytdwn prepare' first.");
-}
-async function downloadLatestBinary() {
-  let release = null;
-  try {
-    const ytDlpWrapModule = await import("yt-dlp-wrap");
-    const YTDlpWrap = ytDlpWrapModule.default;
-    if (typeof YTDlpWrap?.getGithubReleases === "function") {
-      const releases = await YTDlpWrap.getGithubReleases(1, 1);
-      release = Array.isArray(releases) ? releases[0] : releases;
+    return null;
+  });
+  const findBinary = Effect4.gen(function* () {
+    const cached = yield* settings.getCachedBinaryPath;
+    if (cached) {
+      const executable = yield* isExecutable(cached);
+      if (executable)
+        return cached;
     }
-  } catch (err) {}
-  if (!release) {
-    const response = await fetch("https://api.github.com/repos/yt-dlp/yt-dlp/releases/latest");
-    if (!response.ok) {
-      throw new Error(`Failed to fetch yt-dlp release: ${response.status} ${response.statusText}`);
+    const found = yield* searchForBinary;
+    if (found)
+      return found;
+    if (cached) {
+      yield* settings.clearCachedBinaryPath.pipe(Effect4.ignore);
     }
-    release = await response.json();
-  }
-  if (!release) {
-    throw new Error("Failed to fetch yt-dlp release from GitHub.");
-  }
-  const asset = pickAsset(release);
-  const binaryPath = join3(BIN_DIR, asset.name);
-  if (await isExecutable(binaryPath)) {
-    await setCachedBinaryPath(binaryPath);
+    return null;
+  });
+  const requireBinary = Effect4.gen(function* () {
+    const existing = yield* findBinary;
+    if (existing)
+      return existing;
+    return yield* Effect4.fail(new BinaryNotFoundError({
+      message: "yt-dlp binary not found. Run 'ytdwn prepare' first."
+    }));
+  });
+  const getYtDlpWrap = Effect4.gen(function* () {
+    const binaryPath = yield* requireBinary;
+    return new YTDlpWrap(binaryPath);
+  });
+  const downloadLatestBinary = Effect4.gen(function* () {
+    const releases = yield* Effect4.tryPromise({
+      try: () => YTDlpWrap.getGithubReleases(1, 1),
+      catch: (cause) => new BinaryDownloadError({
+        platform: `${process.platform}-${process.arch}`,
+        cause
+      })
+    });
+    const release = Array.isArray(releases) ? releases[0] : releases;
+    if (!release) {
+      return yield* Effect4.fail(new BinaryDownloadError({
+        platform: `${process.platform}-${process.arch}`,
+        cause: "No releases found"
+      }));
+    }
+    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);
+    }
+    yield* settings.setCachedBinaryPath(binaryPath).pipe(Effect4.ignore);
     return binaryPath;
-  }
-  await downloadFile(asset.browser_download_url, binaryPath);
-  await setCachedBinaryPath(binaryPath);
-  return binaryPath;
-}
+  });
+  return {
+    findBinary,
+    requireBinary,
+    getYtDlpWrap,
+    downloadLatestBinary
+  };
+}));
 
-// src/download.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { spawn } from "child_process";
-import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
+// 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");
@@ -238,7 +330,7 @@ var c = {
   }
 };
 
-// src/download.ts
+// src/services/DownloadService.ts
 var SPINNER_FRAMES = [
   "⠋",
   "⠙",
@@ -254,20 +346,6 @@ var SPINNER_FRAMES = [
 var SPINNER_INTERVAL_MS = 80;
 var PROGRESS_BAR_WIDTH = 12;
 var LINE_CLEAR_WIDTH = 60;
-var REGEX = {
-  percent: /(\d+\.?\d*)%/,
-  total: /of\s+~?([\d.]+\s*\w+)/i,
-  speed: /at\s+([\d.]+\s*\w+\/s)/i,
-  size: /([\d.]+)\s*(\w+)/,
-  binaryUnits: /([KMG])iB/g,
-  destination: /\[(?:ExtractAudio|Merger)\].*?Destination:\s*(.+)$/m,
-  downloadDest: /\[download\]\s+Destination:\s*(.+)$/m,
-  fileSize: /~?([\d.]+\s*[KMG]i?B)/i
-};
-var PHASE_MESSAGES = new Map([
-  ["Extracting URL", "Extracting..."],
-  ["Downloading webpage", "Fetching info..."]
-]);
 var write = (text) => process.stdout.write(text);
 var clearLine = () => write(`\r${" ".repeat(LINE_CLEAR_WIDTH)}\r`);
 function createSpinner(initialMessage = "Getting ready...", quiet = false) {
@@ -275,10 +353,7 @@ function createSpinner(initialMessage = "Getting ready...", quiet = false) {
   let message = initialMessage;
   let stopped = false;
   if (quiet) {
-    return {
-      update: () => {},
-      stop: () => {}
-    };
+    return { update: () => {}, stop: () => {} };
   }
   const interval = setInterval(() => {
     if (!stopped) {
@@ -299,7 +374,7 @@ function createSpinner(initialMessage = "Getting ready...", quiet = false) {
     }
   };
 }
-function renderProgress({ percent, speed }, quiet = false) {
+function renderProgress(percent, speed, quiet = false) {
   if (quiet)
     return;
   const filled = Math.round(percent / 100 * PROGRESS_BAR_WIDTH);
@@ -307,58 +382,45 @@ function renderProgress({ percent, speed }, quiet = false) {
   const speedText = speed ? ` ${c.speed(speed)}` : "";
   write(`\r${c.bold("Downloading:")} ${bar} ${c.bar.percent(`${percent.toFixed(0)}%`)}${speedText}   `);
 }
-var normalizeUnit = (value) => value.replace(REGEX.binaryUnits, "$1B");
-function parseProgress(text) {
-  const percentMatch = text.match(REGEX.percent);
-  if (!percentMatch?.[1])
-    return null;
-  const percent = parseFloat(percentMatch[1]);
-  const total = text.match(REGEX.total)?.[1]?.trim();
-  const speed = text.match(REGEX.speed)?.[1];
-  let downloaded;
-  if (total) {
-    const [, size, unit] = total.match(REGEX.size) ?? [];
-    if (size && unit) {
-      downloaded = normalizeUnit(`${(percent / 100 * parseFloat(size)).toFixed(1)}${unit}`);
-    }
+function mapOutputToError(output, url) {
+  const ageRestrictedPatterns = [
+    /age[- ]?restrict/i,
+    /age[- ]?gate/i,
+    /sign in to confirm your age/i,
+    /this video is age-restricted/i,
+    /confirm your age/i
+  ];
+  if (ageRestrictedPatterns.some((p) => p.test(output))) {
+    return new AgeRestrictedError({ url });
   }
-  return {
-    percent,
-    downloaded,
-    total: total ? normalizeUnit(total) : undefined,
-    speed: speed ? normalizeUnit(speed) : undefined
-  };
-}
-function detectPhase(text) {
-  for (const [pattern, message] of PHASE_MESSAGES) {
-    if (text.includes(pattern))
-      return message;
+  if (/\b(network|connection)\s+(error|failed|refused)/i.test(output)) {
+    return new ConnectionError({ message: "Connection error, try again" });
   }
-  return text.includes("Downloading") && !text.includes("%") ? "Preparing..." : null;
-}
-var isConvertingPhase = (text) => text.includes("ExtractAudio") || text.includes("Converting");
-function extractFileName(text) {
-  const match = text.match(REGEX.destination) || text.match(REGEX.downloadDest);
-  if (match?.[1]) {
-    const fullPath = match[1].trim();
-    return fullPath.split("/").pop() || null;
+  if (/video unavailable/i.test(output) || /private video/i.test(output)) {
+    return new VideoNotFoundError({ url });
   }
   return null;
 }
-function extractFileSize(text) {
-  const match = text.match(REGEX.fileSize);
-  return match?.[1] || null;
+function mapExitCodeToError(code, url) {
+  switch (code) {
+    case 1:
+      return new VideoNotFoundError({ url });
+    case 2:
+      return new InvalidUrlError({ url });
+    default:
+      return new BinaryExecutionError({
+        exitCode: code,
+        message: `Download failed with exit code ${code}`
+      });
+  }
 }
+var VIDEO_FORMATS = ["mp4", "mkv", "webm", "avi", "mov"];
+var isVideoFormat = (format) => VIDEO_FORMATS.includes(format.toLowerCase());
 function buildArgs(url, options, downloadDir) {
+  const format = options.format.toLowerCase();
+  const isVideo = isVideoFormat(format);
   const baseArgs = [
     url,
-    "-f",
-    "bestaudio/best",
-    "-x",
-    "--audio-format",
-    options.format,
-    "--audio-quality",
-    DEFAULT_AUDIO_QUALITY,
     "-o",
     getOutputTemplate(downloadDir),
     "--no-playlist",
@@ -366,68 +428,39 @@ function buildArgs(url, options, downloadDir) {
     "--progress",
     "--concurrent-fragments",
     CONCURRENT_FRAGMENTS,
-    "--no-check-certificates",
+    "--no-check-certificates"
+  ];
+  const formatArgs = isVideo ? [
+    "-f",
+    `bestvideo[ext=${format}]+bestaudio/best[ext=${format}]/best`,
+    "--merge-output-format",
+    format
+  ] : [
+    "-f",
+    "bestaudio/best",
+    "-x",
+    "--audio-format",
+    format,
+    "--audio-quality",
+    DEFAULT_AUDIO_QUALITY,
     "--prefer-free-formats"
   ];
-  const conditionalArgs = [];
-  if (options.clip) {
-    conditionalArgs.push("--download-sections", `*${parseClipRange(options.clip)}`);
-  }
-  if (ffmpegInstaller?.path) {
-    conditionalArgs.push("--ffmpeg-location", ffmpegInstaller.path);
-  }
-  return [...baseArgs, ...conditionalArgs];
+  const clipArgs = options.clip ? ["--download-sections", `*${parseClipRange(options.clip)}`] : [];
+  return [...baseArgs, ...formatArgs, ...clipArgs];
 }
-function createOutputHandler(spinner, state) {
-  return (data) => {
-    const text = data.toString();
-    const fileName = extractFileName(text);
-    if (fileName)
-      state.fileName = fileName;
-    const fileSize = extractFileSize(text);
-    if (fileSize)
-      state.fileSize = fileSize;
-    if (state.phase !== "converting" && isConvertingPhase(text)) {
-      state.phase = "converting";
-      spinner.stop();
-      clearLine();
-      if (!state.quiet) {
-        let frame = 0;
-        state.convertingInterval = setInterval(() => {
-          const frameChar = SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length] ?? "⠋";
-          write(`\r${c.info(frameChar)} ${c.dim("Converting...")}`);
-        }, SPINNER_INTERVAL_MS);
-      }
-      return;
-    }
-    const progress = parseProgress(text);
-    if (progress && progress.percent > state.lastPercent) {
-      if (state.phase === "init") {
-        state.phase = "downloading";
-        spinner.stop();
-      }
-      state.lastPercent = progress.percent;
-      renderProgress(progress, state.quiet);
-      return;
-    }
-    if (state.phase === "init") {
-      const message = detectPhase(text);
-      if (message)
-        spinner.update(message);
-    }
-  };
+
+class DownloadService extends Context3.Tag("DownloadService")() {
 }
-function attachProcessHandlers(child, spinner, downloadDir, quiet) {
-  return new Promise((resolve2, reject) => {
+function executeDownload(ytDlpWrap, args, downloadDir, url, quiet) {
+  return Effect6.async((resume) => {
+    const spinner = createSpinner("Getting ready...", quiet);
     const state = {
       phase: "init",
-      lastPercent: 0,
       fileName: null,
       fileSize: null,
-      quiet,
+      outputBuffer: "",
       convertingInterval: null
     };
-    const handleOutput = createOutputHandler(spinner, state);
     const cleanup = () => {
       spinner.stop();
       if (state.convertingInterval) {
@@ -436,40 +469,118 @@ function attachProcessHandlers(child, spinner, downloadDir, quiet) {
       if (!quiet)
         clearLine();
     };
-    child.stdout?.on("data", handleOutput);
-    child.stderr?.on("data", handleOutput);
-    child.on("close", (code) => {
-      cleanup();
-      if (code === 0) {
-        resolve2({
-          filePath: downloadDir,
-          fileName: state.fileName || "audio",
-          fileSize: state.fileSize || undefined
-        });
-      } else {
-        reject(new Error(`Download failed (code ${code})`));
+    const emitter = ytDlpWrap.exec(args);
+    emitter.on("progress", (progress) => {
+      if (state.phase === "init") {
+        state.phase = "downloading";
+        spinner.stop();
+      }
+      if (progress.percent !== undefined) {
+        renderProgress(progress.percent, progress.currentSpeed, quiet);
       }
     });
-    child.on("error", (err) => {
+    emitter.on("ytDlpEvent", (eventType, eventData) => {
+      state.outputBuffer += `[${eventType}] ${eventData}
+`;
+      if (eventType === "ExtractAudio" || eventType === "Merger") {
+        const match = eventData.match(/Destination:\s*(.+)/);
+        if (match?.[1]) {
+          state.fileName = match[1].split("/").pop() || null;
+        }
+      }
+      if (eventType === "download") {
+        const destMatch = eventData.match(/Destination:\s*(.+)/);
+        if (destMatch?.[1]) {
+          state.fileName = destMatch[1].split("/").pop() || null;
+        }
+        const sizeMatch = eventData.match(/~?([\d.]+\s*[KMG]i?B)/i);
+        if (sizeMatch?.[1]) {
+          state.fileSize = sizeMatch[1];
+        }
+      }
+      if ((eventType === "ExtractAudio" || eventType === "ffmpeg") && state.phase !== "converting") {
+        state.phase = "converting";
+        spinner.stop();
+        clearLine();
+        if (!quiet) {
+          let frame = 0;
+          state.convertingInterval = setInterval(() => {
+            const frameChar = SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length] ?? "⠋";
+            write(`\r${c.info(frameChar)} ${c.dim("Converting...")}`);
+          }, SPINNER_INTERVAL_MS);
+        }
+      }
+      if (state.phase === "init") {
+        if (eventType === "youtube" && eventData.includes("Extracting")) {
+          spinner.update("Extracting...");
+        } else if (eventType === "youtube" && eventData.includes("Downloading webpage")) {
+          spinner.update("Fetching info...");
+        }
+      }
+    });
+    emitter.on("error", (error) => {
+      cleanup();
+      const outputError = mapOutputToError(String(error), url);
+      resume(Effect6.fail(outputError ?? new BinaryExecutionError({
+        exitCode: -1,
+        message: String(error)
+      })));
+    });
+    emitter.on("close", () => {
       cleanup();
-      reject(err);
+      const outputError = mapOutputToError(state.outputBuffer, url);
+      if (outputError) {
+        resume(Effect6.fail(outputError));
+        return;
+      }
+      const exitCode = emitter.ytDlpProcess?.exitCode;
+      if (exitCode !== null && exitCode !== undefined && exitCode !== 0) {
+        resume(Effect6.fail(mapExitCodeToError(exitCode, url)));
+        return;
+      }
+      resume(Effect6.succeed({
+        filePath: downloadDir,
+        fileName: state.fileName || "audio",
+        fileSize: state.fileSize || undefined
+      }));
     });
   });
 }
-async function downloadAudio(url, options) {
-  const [downloadDir, binaryPath] = await Promise.all([
-    getDownloadDir().then(async (dir) => {
-      await mkdir2(dir, { recursive: true });
-      return dir;
-    }),
-    requireBinary()
-  ]);
-  const quiet = options.quiet ?? false;
-  const spinner = createSpinner("Getting ready...", quiet);
-  const child = spawn(binaryPath, buildArgs(url, options, downloadDir));
-  return attachProcessHandlers(child, spinner, downloadDir, quiet);
-}
+var DownloadServiceLive = Layer3.effect(DownloadService, Effect6.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
+      ]);
+      const quiet = options.quiet ?? false;
+      const args = buildArgs(url, options, downloadDir);
+      return yield* executeDownload(ytDlpWrap, args, downloadDir, url, quiet);
+    })
+  };
+}));
 
+// src/layers/AppLive.ts
+var AppLive = DownloadServiceLive.pipe(Layer4.provide(BinaryServiceLive), Layer4.provide(SettingsServiceLive));
+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);
+var isAppError = (error) => error !== null && typeof error === "object" && ("_tag" in error) && typeof error._tag === "string";
+var formatError = (error) => {
+  if (isAppError(error))
+    return formatAppError(error);
+  if (error instanceof 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));
+// src/cli/commands.ts
+import { Effect as Effect8 } from "effect";
 // src/banner.ts
 import cfonts from "cfonts";
 import gradient from "gradient-string";
@@ -495,100 +606,86 @@ function showBanner() {
 `));
 }
 
-// index.ts
-var formatError = (err) => {
-  const msg = err instanceof Error ? err.message : String(err);
-  if (msg.includes("code 1") || msg.includes("Video unavailable")) {
-    return "Video not found or private";
-  }
-  if (msg.includes("code 2")) {
-    return "Invalid URL format";
+// src/cli/commands.ts
+var log = (message) => Effect8.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* () {
+  const binary = yield* BinaryService;
+  const existing = yield* binary.findBinary;
+  if (existing) {
+    yield* logSuccess("Ready");
+    return;
   }
-  if (msg.includes("age")) {
-    return "Age-restricted video (login required)";
+  yield* logDim("Downloading yt-dlp...");
+  yield* binary.downloadLatestBinary;
+  yield* logSuccess("Ready");
+});
+var setFolderCommand = (path, options) => Effect8.gen(function* () {
+  const settings = yield* SettingsService;
+  if (options?.reset) {
+    yield* settings.resetDownloadDir;
+    yield* logSuccess("Reset to current directory");
+    return;
   }
-  if (msg.includes("network") || msg.includes("connect")) {
-    return "Connection error, try again";
+  if (path) {
+    yield* settings.setDownloadDir(path);
+    yield* log(`${c.sym.success} ${c.info(path)}`);
+  } else {
+    const dir = yield* settings.getDownloadDir;
+    yield* logInfo(dir);
   }
-  return msg;
-};
-var exitWithError = (err) => {
-  console.error(`${c.sym.error} ${c.error("Error:")} ${formatError(err)}`);
-  process.exit(1);
-};
-var isUrl = (arg) => arg.startsWith("http://") || arg.startsWith("https://");
-async function handlePrepare() {
-  try {
-    if (await findBinary()) {
-      console.log(`${c.sym.success} ${c.success("Ready")}`);
-      return;
-    }
-    console.log(`${c.dim("Downloading yt-dlp...")}`);
-    await downloadLatestBinary();
-    console.log(`${c.sym.success} ${c.success("Ready")}`);
-  } catch (err) {
-    exitWithError(err);
+});
+var downloadCommand = (url, options) => Effect8.gen(function* () {
+  const quiet = options.quiet ?? false;
+  if (!quiet) {
+    yield* Effect8.sync(() => showBanner());
+    yield* log(`${c.dim("URL:")} ${c.info(url)}
+`);
   }
-}
-async function handleSetFolder(folderPath, opts) {
-  try {
-    if (opts?.reset) {
-      await resetDownloadDir();
-      console.log(`${c.sym.success} ${c.success("Reset to current directory")}`);
-      return;
-    }
-    if (folderPath) {
-      await setDownloadDir(folderPath);
-      console.log(`${c.sym.success} ${c.info(folderPath)}`);
-    } else {
-      console.log(c.info(await getDownloadDir()));
-    }
-  } catch (err) {
-    exitWithError(err);
+  const download = yield* DownloadService;
+  const result = yield* download.download(url, options);
+  if (quiet) {
+    yield* log(result.fileName);
+  } else {
+    yield* log("");
+    yield* logSuccess("Process done!");
+    yield* log("");
+    const sizeInfo = result.fileSize ? ` ${c.size(`(${result.fileSize})`)}` : "";
+    yield* log(`${c.file(result.fileName)}${sizeInfo}`);
   }
-}
-async function handleDownload(url, opts) {
-  try {
-    if (!opts.quiet) {
+});
+// index.ts
+var isUrl = (arg) => arg.startsWith("http://") || arg.startsWith("https://");
+var configureCli = () => {
+  program.name(APP_NAME).usage("<url> [options]").description("Download audio or video from YouTube").version(APP_VERSION, "-v, --version").argument("[url]", "YouTube URL to download").option("-f, --format <format>", "Output format (mp3, mp4, mkv, etc.)", DEFAULT_FORMAT).option("-c, --clip <range>", "Clip range (e.g. 1:30-2:45)").option("-q, --quiet", "Minimal output (only file name)").addHelpText("beforeAll", "").hook("preAction", (cmd) => {
+    const isHelp = cmd.args.includes("help") || process.argv.includes("--help") || process.argv.includes("-h");
+    if (isHelp)
       showBanner();
-      console.log(`${c.dim("URL:")} ${c.info(url)}
-`);
-    }
-    const result = await downloadAudio(url, {
-      format: opts.format,
-      clip: opts.clip,
-      quiet: opts.quiet
-    });
-    if (opts.quiet) {
-      console.log(result.fileName);
-    } else {
-      console.log();
-      console.log(`${c.sym.success} ${c.success("Process done!")}
-`);
-      const sizeInfo = result.fileSize ? ` ${c.size(`(${result.fileSize})`)}` : "";
-      console.log(`${c.file(result.fileName)}${sizeInfo}`);
+  }).action((url, opts) => {
+    if (url && isUrl(url)) {
+      const options = {
+        format: opts?.format ?? DEFAULT_FORMAT,
+        clip: opts?.clip,
+        quiet: opts?.quiet
+      };
+      return runCommand(downloadCommand(url, options), AppLive);
     }
-  } catch (err) {
-    exitWithError(err);
+  });
+  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));
+  return program;
+};
+var main = () => {
+  if (process.argv.length <= 2) {
+    showBanner();
+    configureCli().help();
+    return;
   }
-}
-program.name(APP_NAME).usage("<url> [options]").description("Download audio from YouTube").version(APP_VERSION, "-v, --version").option("-f, --format <format>", "Audio format", DEFAULT_FORMAT).option("-c, --clip <range>", "Clip range (e.g. 1:30-2:45)").option("-q, --quiet", "Minimal output (only file name)").addHelpText("beforeAll", "").hook("preAction", (thisCommand) => {
-  if (thisCommand.args.includes("help") || process.argv.includes("--help") || process.argv.includes("-h")) {
+  if (process.argv.includes("-v") || process.argv.includes("--version")) {
     showBanner();
   }
-});
-program.command("prepare").description("Download yt-dlp binary").action(handlePrepare);
-program.command("setDefaultFolder [path]").description("Set or view default download folder").option("-r, --reset", "Reset to current directory").action(handleSetFolder);
-program.command("download <url>", { hidden: true }).description("Download audio from YouTube URL").option("-f, --format <format>", "Audio format", DEFAULT_FORMAT).option("-c, --clip <range>", "Clip range (e.g. 1:30-2:45)").option("-q, --quiet", "Minimal output").action(handleDownload);
-var firstArg = process.argv[2];
-if (firstArg && isUrl(firstArg)) {
-  process.argv.splice(2, 0, "download");
-}
-if (process.argv.length <= 2) {
-  showBanner();
-  program.help();
-}
-if (process.argv.includes("-v") || process.argv.includes("--version")) {
-  showBanner();
-}
-program.parse();
+  configureCli().parse();
+};
+main();