ytdwn 1.0.0 → 1.1.0

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

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { BinaryService, DownloadService, SettingsService } from "../services";
+import type { DownloadOptions } from "../services";
+export interface FolderOptions {
+    readonly reset?: boolean;
+}
+/**
+ * Prepare command: Downloads yt-dlp binary if not present.
+ */
+export declare const prepareCommand: Effect.Effect<void, import("../lib").FileWriteError | import("../lib").DirectoryCreateError | import("../lib").DownloadError | import("../lib").BinaryDownloadError, BinaryService>;
+/**
+ * Set folder command: Manages default download directory.
+ */
+export declare const setFolderCommand: (path?: string, options?: FolderOptions) => Effect.Effect<void, import("../lib").FileWriteError, SettingsService>;
+/**
+ * Download command: Downloads audio from YouTube URL.
+ */
+export declare const downloadCommand: (url: string, options: DownloadOptions) => Effect.Effect<void, import("../lib").DirectoryCreateError | import("../lib").BinaryNotFoundError | (import("../lib").BinaryExecutionError | import("../lib").VideoNotFoundError | import("../lib").InvalidUrlError | import("../lib").AgeRestrictedError | import("../lib").ConnectionError), DownloadService>;

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

@@ -0,0 +1,8 @@
+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;
+export declare const formatError: (error: unknown) => string;
+/**
+ * Runs an effect with error handling. Main entry point for CLI commands.
+ */
+export declare const runCommand: <A, E, R>(effect: Effect.Effect<A, E, R>, layer: Layer.Layer<R>) => Promise<A>;

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

@@ -0,0 +1,2 @@
+export { runCommand, formatError, type AppError } from "./errors";
+export { prepareCommand, setFolderCommand, downloadCommand, type FolderOptions, } from "./commands";

package/dist/src/config.d.ts

@@ -1,8 +1,11 @@
 export declare const APP_NAME = "ytdwn";
-export declare const APP_TAGLINE = "YouTube to MP3 \u2022 Fast & Simple";
-export declare const APP_VERSION = "1.0.0";
-export declare const DEFAULT_FORMAT = "mp3";
+export declare const APP_TAGLINE = "YouTube to MP3/MP4 \u2022 Fast & Simple";
+export declare const APP_VERSION = "1.1.0";
+export declare const DEFAULT_AUDIO_FORMAT = "mp3";
 export declare const DEFAULT_AUDIO_QUALITY = "0";
+export declare const DEFAULT_VIDEO_FORMAT = "mp4";
+export declare const DEFAULT_VIDEO_QUALITY = "best";
 export declare const CONCURRENT_FRAGMENTS = "8";
+export declare const DEFAULT_FORMAT = "mp3";
 export declare const BIN_DIR: string;
 export declare const getOutputTemplate: (downloadDir: string) => string;

package/dist/src/layers/AppLive.d.ts

@@ -0,0 +1,14 @@
+import { Layer } from "effect";
+/**
+ * Composes all service layers into a single application layer.
+ * This is the production layer used at the application boundary.
+ */
+export declare const AppLive: Layer.Layer<import("../services/DownloadService").DownloadService, never, never>;
+/**
+ * Settings-only layer for commands that don't need download capabilities.
+ */
+export declare const SettingsLive: Layer.Layer<import("../services/SettingsService").SettingsService, never, never>;
+/**
+ * Binary management layer (includes settings).
+ */
+export declare const BinaryLive: Layer.Layer<import("../services/BinaryService").BinaryService, never, never>;

package/dist/src/layers/index.d.ts

@@ -0,0 +1 @@
+export { AppLive, SettingsLive, BinaryLive } from "./AppLive";

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

@@ -0,0 +1,92 @@
+declare const FileWriteError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FileWriteError";
+} & Readonly<A>;
+export declare class FileWriteError extends FileWriteError_base<{
+    readonly path: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const DirectoryCreateError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DirectoryCreateError";
+} & Readonly<A>;
+export declare class DirectoryCreateError extends DirectoryCreateError_base<{
+    readonly path: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const NetworkError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NetworkError";
+} & Readonly<A>;
+export declare class NetworkError extends NetworkError_base<{
+    readonly url?: string;
+    readonly message: string;
+}> {
+}
+declare const DownloadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "DownloadError";
+} & Readonly<A>;
+export declare class DownloadError extends DownloadError_base<{
+    readonly url: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const BinaryNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BinaryNotFoundError";
+} & Readonly<A>;
+export declare class BinaryNotFoundError extends BinaryNotFoundError_base<{
+    readonly message: string;
+}> {
+}
+declare const BinaryDownloadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BinaryDownloadError";
+} & Readonly<A>;
+export declare class BinaryDownloadError extends BinaryDownloadError_base<{
+    readonly platform: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const BinaryExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BinaryExecutionError";
+} & Readonly<A>;
+export declare class BinaryExecutionError extends BinaryExecutionError_base<{
+    readonly exitCode: number;
+    readonly message: string;
+}> {
+}
+declare const TimestampParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TimestampParseError";
+} & Readonly<A>;
+export declare class TimestampParseError extends TimestampParseError_base<{
+    readonly input: string;
+    readonly message: string;
+}> {
+}
+declare const VideoNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "VideoNotFoundError";
+} & Readonly<A>;
+export declare class VideoNotFoundError extends VideoNotFoundError_base<{
+    readonly url: string;
+}> {
+}
+declare const InvalidUrlError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidUrlError";
+} & Readonly<A>;
+export declare class InvalidUrlError extends InvalidUrlError_base<{
+    readonly url: string;
+}> {
+}
+declare const AgeRestrictedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AgeRestrictedError";
+} & Readonly<A>;
+export declare class AgeRestrictedError extends AgeRestrictedError_base<{
+    readonly url: string;
+}> {
+}
+declare const ConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConnectionError";
+} & Readonly<A>;
+export declare class ConnectionError extends ConnectionError_base<{
+    readonly message: string;
+}> {
+}
+export {};

package/dist/src/lib/filesystem.d.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import { FileWriteError, DirectoryCreateError } from "./errors";
+/**
+ * Checks if a file exists and is executable.
+ */
+export declare const isExecutable: (path: string) => Effect.Effect<boolean>;
+/**
+ * Reads and parses a JSON file, returning default if it fails.
+ */
+export declare const readJsonFileOrDefault: <T>(path: string, defaultValue: T) => Effect.Effect<T>;
+/**
+ * Writes an object as JSON to a file.
+ */
+export declare const writeJsonFile: <T>(path: string, data: T) => Effect.Effect<void, FileWriteError>;
+/**
+ * Writes binary data to a file.
+ */
+export declare const writeFileBinary: (path: string, data: Buffer) => Effect.Effect<void, FileWriteError>;
+/**
+ * Ensures a directory exists, creating it if necessary.
+ * Returns the path for chaining.
+ */
+export declare const ensureDirectory: (path: string) => Effect.Effect<string, DirectoryCreateError>;
+/**
+ * Makes a file executable (chmod +x).
+ */
+export declare const makeExecutable: (path: string) => Effect.Effect<void, FileWriteError>;

package/dist/src/lib/http.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { DownloadError } from "./errors";
+/**
+ * Fetches binary data from a URL with automatic retry.
+ */
+export declare const fetchBinaryWithRetry: (url: string, maxRetries?: number) => Effect.Effect<Buffer, DownloadError>;

package/dist/src/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { FileWriteError, DirectoryCreateError, NetworkError, DownloadError, BinaryNotFoundError, BinaryDownloadError, BinaryExecutionError, TimestampParseError, VideoNotFoundError, InvalidUrlError, AgeRestrictedError, ConnectionError, } from "./errors";
+export { isExecutable, readJsonFileOrDefault, writeJsonFile, writeFileBinary, ensureDirectory, makeExecutable, } from "./filesystem";
+export { fetchBinaryWithRetry } from "./http";

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

@@ -0,0 +1,14 @@
+import { Effect, Context, Layer } from "effect";
+import YTDlpWrap from "yt-dlp-wrap";
+import { BinaryNotFoundError, BinaryDownloadError, type DownloadError, type FileWriteError, type DirectoryCreateError } from "../lib/errors";
+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 getYtDlpWrap: Effect.Effect<YTDlpWrap, BinaryNotFoundError>;
+    readonly downloadLatestBinary: Effect.Effect<string, BinaryDownloadError | DownloadError | FileWriteError | DirectoryCreateError>;
+}>;
+export declare class BinaryService extends BinaryService_base {
+}
+export declare const BinaryServiceLive: Layer.Layer<BinaryService, never, SettingsService>;
+export {};

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

@@ -0,0 +1,22 @@
+import { Effect, Context, Layer } from "effect";
+import { BinaryExecutionError, VideoNotFoundError, InvalidUrlError, AgeRestrictedError, ConnectionError, type BinaryNotFoundError, type DirectoryCreateError } from "../lib/errors";
+import { BinaryService } from "./BinaryService";
+import { SettingsService } from "./SettingsService";
+export interface DownloadOptions {
+    format: string;
+    clip?: string;
+    quiet?: boolean;
+}
+export interface DownloadResult {
+    filePath: string;
+    fileName: string;
+    fileSize?: string;
+}
+type DownloadPipelineError = BinaryExecutionError | VideoNotFoundError | InvalidUrlError | AgeRestrictedError | ConnectionError;
+declare const DownloadService_base: Context.TagClass<DownloadService, "DownloadService", {
+    readonly download: (url: string, options: DownloadOptions) => Effect.Effect<DownloadResult, BinaryNotFoundError | DirectoryCreateError | DownloadPipelineError>;
+}>;
+export declare class DownloadService extends DownloadService_base {
+}
+export declare const DownloadServiceLive: Layer.Layer<DownloadService, never, SettingsService | BinaryService>;
+export {};

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

@@ -0,0 +1,14 @@
+import { Effect, Context, Layer } from "effect";
+import type { FileWriteError } from "../lib/errors";
+declare const SettingsService_base: Context.TagClass<SettingsService, "SettingsService", {
+    readonly getDownloadDir: Effect.Effect<string>;
+    readonly setDownloadDir: (dir: string) => Effect.Effect<void, FileWriteError>;
+    readonly resetDownloadDir: Effect.Effect<void, FileWriteError>;
+    readonly getCachedBinaryPath: Effect.Effect<string | null>;
+    readonly setCachedBinaryPath: (path: string) => Effect.Effect<void, FileWriteError>;
+    readonly clearCachedBinaryPath: Effect.Effect<void, FileWriteError>;
+}>;
+export declare class SettingsService extends SettingsService_base {
+}
+export declare const SettingsServiceLive: Layer.Layer<SettingsService, never, never>;
+export {};

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

@@ -0,0 +1,3 @@
+export { SettingsService, SettingsServiceLive } from "./SettingsService";
+export { BinaryService, BinaryServiceLive } from "./BinaryService";
+export { DownloadService, DownloadServiceLive, type DownloadOptions, type DownloadResult, } from "./DownloadService";

package/dist/src/timestamp.d.ts

@@ -1,9 +1,25 @@
+import { Effect } from "effect";
+import { TimestampParseError } from "./lib/errors";
 /**
  * Parses a raw timestamp string into HH:MM:SS format.
  * Accepts MM:SS or HH:MM:SS formats.
+ * Returns an Effect that fails with TimestampParseError if invalid.
+ */
+export declare const parseTimestampEffect: (raw: string) => Effect.Effect<string, TimestampParseError>;
+/**
+ * Parses a clip range string (start-end) into normalized format.
+ * Returns an Effect that fails with TimestampParseError if invalid.
+ */
+export declare const parseClipRangeEffect: (range: string) => Effect.Effect<string, TimestampParseError>;
+/**
+ * Parses a raw timestamp string into HH:MM:SS format.
+ * @throws Error if format is invalid
+ * @deprecated Use parseTimestampEffect for type-safe error handling
  */
 export declare function parseTimestamp(raw: string): string;
 /**
  * Parses a clip range string (start-end) into normalized format.
+ * @throws Error if format is invalid
+ * @deprecated Use parseClipRangeEffect for type-safe error handling
  */
 export declare function parseClipRange(range: string): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ytdwn",
-  "version": "1.0.0",
-  "description": "A fast and simple CLI tool to download audio from YouTube videos",
+  "version": "1.1.0",
+  "description": "A fast and simple CLI tool to download audio and video from YouTube",
   "author": {
     "name": "Batikan Kutluer",
     "url": "https://github.com/batikankutluer"
@@ -19,6 +19,8 @@
     "youtube",
     "download",
     "mp3",
+    "mp4",
+    "video",
     "audio",
     "yt-dlp",
     "cli",
@@ -48,12 +50,13 @@
     "build:types": "bun x tsc --project tsconfig.build.json --emitDeclarationOnly",
     "build:chmod": "chmod +x dist/index.js",
     "typecheck": "bun x tsc --noEmit",
+    "test": "bun test",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "cfonts": "^3.3.1",
     "commander": "^14.0.2",
+    "effect": "^3.19.14",
     "gradient-string": "^3.0.0",
     "picocolors": "^1.1.1",
     "yt-dlp-wrap": "^2.3.12"

package/dist/src/binary.d.ts

@@ -1,12 +0,0 @@
-/**
- * Finds an existing prepared binary. Uses cache for speed.
- */
-export declare function findBinary(): Promise<string | null>;
-/**
- * Ensures a prepared binary exists, throws if not.
- */
-export declare function requireBinary(): Promise<string>;
-/**
- * Downloads the latest yt-dlp binary from GitHub.
- */
-export declare function downloadLatestBinary(): Promise<string>;

package/dist/src/download.d.ts

@@ -1,16 +0,0 @@
-interface DownloadOptions {
-    format: string;
-    clip?: string;
-    quiet?: boolean;
-}
-interface DownloadResult {
-    filePath: string;
-    fileName: string;
-    fileSize?: string;
-}
-/**
- * Downloads audio from a URL using yt-dlp.
- * @returns Download result with file info
- */
-export declare function downloadAudio(url: string, options: DownloadOptions): Promise<DownloadResult>;
-export {};

package/dist/src/settings.d.ts

@@ -1,24 +0,0 @@
-/**
- * Gets the download directory. Falls back to current directory if not set.
- */
-export declare function getDownloadDir(): Promise<string>;
-/**
- * Sets the download directory.
- */
-export declare function setDownloadDir(dir: string): Promise<void>;
-/**
- * Resets the download directory to default (current directory).
- */
-export declare function resetDownloadDir(): Promise<void>;
-/**
- * Gets the cached binary path.
- */
-export declare function getCachedBinaryPath(): Promise<string | null>;
-/**
- * Sets the cached binary path.
- */
-export declare function setCachedBinaryPath(path: string): Promise<void>;
-/**
- * Clears the cached binary path.
- */
-export declare function clearCachedBinaryPath(): Promise<void>;