wavesconv 1.4.9

package/README.md

@@ -0,0 +1,179 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/idunnowhytf/wavesconvsite/main/docs/og.png" alt="WavesConverter" width="100%"/>
+
+<br/>
+
+<h1>
+  <img src="https://img.shields.io/badge/WavesConverter-v1.2.0-7c3aed?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNMiAxMyBRNCA3IDYgMTMgUTggMTkgMTAgMTMgUTEyIDcgMTQgMTMgUTE2IDE5IDE4IDEzIFEyMCA3IDIyIDEzIiBzdHJva2U9IiNjMDg0ZmMiIHN0cm9rZS13aWR0aD0iMi41IiBzdHJva2UtbGluZWNhcD0icm91bmQiLz48L3N2Zz4=" alt="WavesConverter v1.2.0"/>
+</h1>
+
+**Download anything. Convert everything.**
+
+A premium desktop app for macOS & Windows that downloads YouTube videos and playlists,
+converts any media file — all offline, no account needed, completely free.
+
+<br/>
+
+[![Download](https://img.shields.io/badge/⬇_Download-macOS_&_Windows-7c3aed?style=for-the-badge)](https://idunnowhytf.github.io/wavesconvsite/#download)
+[![Website](https://img.shields.io/badge/🌐_Website-wavesconverter-a855f7?style=for-the-badge)](https://idunnowhytf.github.io/wavesconvsite/)
+[![Releases](https://img.shields.io/github/v/release/idunnowhytf/wavesconvsite?style=for-the-badge&color=d946ef&label=Latest)](https://github.com/idunnowhytf/wavesconvsite/releases)
+[![License](https://img.shields.io/badge/License-ISC-6d28d9?style=for-the-badge)](LICENSE)
+
+<br/>
+
+</div>
+
+---
+
+## ✨ Features
+
+| | Feature | Description |
+|---|---|---|
+| 📋 | **Playlist Support** | Download entire playlists or cherry-pick individual videos. Override format & quality per item. |
+| ⚡ | **Concurrent Queue** | Run multiple downloads simultaneously. Pause, resume, retry — full control. |
+| 🔢 | **Batch Paste** | Paste multiple YouTube URLs at once. Batch panel appears with shared format settings. |
+| 📊 | **ETA & Speed** | Live download speed (e.g. `3.2 MiB/s`) and time remaining (`ETA 00:42`) on every active item. |
+| 🎛️ | **Quality Control** | 360p → 4K for video, 96 → 320 kbps for audio. Apply globally or per video. |
+| 🔄 | **Local File Converter** | Convert any media file — change container, resolution, bitrate. No internet needed. |
+| 📖 | **Download History** | Every completed download logged with file path, format, and date. |
+| ⌨️ | **Keyboard Shortcuts** | `⌘V` paste & fetch, `⌘D` queue, `⌘1–5` tabs, `Space` start/pause. |
+| 🔔 | **Native Notifications** | System notification when a download finishes — even if the app is in the background. |
+| 🔒 | **100% Offline** | No servers, no accounts, no analytics. Powered by `yt-dlp` + `ffmpeg` bundled inside. |
+| ✨ | **Auto Updates** | Silent background updates via GitHub Releases. One click to install. |
+
+---
+
+## 📥 Download
+
+| Platform | Link |
+|---|---|
+| 🍎 **macOS Apple Silicon** (M1/M2/M3/M4) | [WavesConverter-arm64.dmg](https://github.com/idunnowhytf/wavesconvsite/releases/latest/download/WavesConverter-1.0.0-arm64.dmg) |
+| 🍎 **macOS Intel** (x64) | [WavesConverter.dmg](https://github.com/idunnowhytf/wavesconvsite/releases/latest/download/WavesConverter-1.0.0.dmg) |
+| 🪟 **Windows 10+** (x64) | [WavesConverter-Setup.exe](https://github.com/idunnowhytf/wavesconvsite/releases/latest/download/WavesConverter.Setup.1.0.0.exe) |
+
+> **Windows users:** SmartScreen may show a warning since the app isn't signed with a paid certificate.
+> Click **"More info" → "Run anyway"** to proceed. The source code is fully open and auditable here.
+
+---
+
+## 🚀 Quick Start
+
+### Download a video
+1. Paste any YouTube URL into the input field (or press `⌘V` to auto-paste)
+2. Click **Fetch** — video metadata loads instantly
+3. Pick your format (`MP4`, `MP3`, `WAV`…) and quality (`1080p`, `4K`, `320kbps`…)
+4. Click **Add to Queue**, switch to the Queue tab, hit **Start**
+
+### Batch download
+Paste multiple YouTube URLs (newline or space separated) — WavesConverter detects them automatically and switches to batch mode. Set format once, add all to queue.
+
+### Convert a local file
+Drag any media file onto the **Convert** tab, pick the output format and settings, click **Convert**.
+
+---
+
+## ⌨️ Keyboard Shortcuts
+
+| Shortcut | Action |
+|---|---|
+| `⌘V` | Paste URL & auto-fetch (from anywhere in the app) |
+| `⌘↵` | Fetch the current URL |
+| `⌘D` | Add fetched video to queue |
+| `⌘K` | Focus the URL input |
+| `⌘1` – `⌘5` | Switch between tabs |
+| `Space` | Start / pause queue (in Queue tab) |
+| `⌘⇧C` | Clear completed items from queue |
+
+---
+
+## 🛠️ Tech Stack
+
+- **[Electron](https://www.electronjs.org/)** — cross-platform desktop shell
+- **[yt-dlp](https://github.com/yt-dlp/yt-dlp)** — YouTube downloading engine
+- **[ffmpeg](https://ffmpeg.org/)** — media conversion & processing
+- **[@ffmpeg-installer/ffmpeg](https://github.com/nicehash/easy-ffmpeg-installer)** — bundled ffmpeg binary
+- **[electron-updater](https://www.electron.build/auto-update)** — automatic updates via GitHub Releases
+
+---
+
+## 🏗️ Build from Source
+
+```bash
+# Clone the repository
+git clone https://github.com/idunnowhytf/wavesconvsite.git
+cd wavesconvsite
+
+# Install dependencies
+npm install
+
+# Run in development
+npx electron .
+
+# Build for macOS
+npx electron-builder --mac --publish never
+
+# Build for Windows (works from macOS via Wine)
+npx electron-builder --win --x64 --publish never
+```
+
+> **Requirements:** Node.js 18+, npm
+
+---
+
+## 📁 Project Structure
+
+```
+wavesconvsite/
+├── main.js          # Electron main process — IPC, yt-dlp spawning, ffmpeg
+├── preload.js       # Context bridge — exposes safe APIs to renderer
+├── renderer.js      # UI logic — queue, history, batch paste, ETA
+├── index.html       # App shell — tabs, layout
+├── style.css        # App styles — glassmorphism dark purple theme
+├── assets/
+│   ├── icon.icns    # macOS app icon
+│   ├── icon.ico     # Windows app icon
+│   └── icon.png     # Generic icon
+└── docs/            # GitHub Pages website
+    ├── index.html   # Landing page
+    ├── changelog.html
+    └── docs.html
+```
+
+---
+
+## 📋 Changelog
+
+See [**Releases →**](https://github.com/idunnowhytf/wavesconvsite/releases) for full version history.
+
+| Version | Highlights |
+|---|---|
+| **v1.2.0** | Batch paste for multiple URLs, ETA & speed display on downloads |
+| **v1.1.0** | Download history tab, keyboard shortcuts, native notifications, drag & drop, Windows support |
+| **v1.0.0** | Initial release — macOS only |
+
+---
+
+## 🤝 Contributing
+
+Found a bug or have a feature idea? [Open an issue](https://github.com/idunnowhytf/wavesconvsite/issues) — all feedback welcome.
+
+---
+
+## ⚖️ Legal
+
+WavesConverter uses `yt-dlp` and `ffmpeg` under their respective open-source licenses.
+Downloading copyrighted content without permission may violate YouTube's Terms of Service and local laws.
+This tool is intended for downloading content you own or have permission to download.
+
+---
+
+<div align="center">
+
+**[Website](https://idunnowhytf.github.io/wavesconvsite/) · [Releases](https://github.com/idunnowhytf/wavesconvsite/releases) · [Docs](https://idunnowhytf.github.io/wavesconvsite/docs.html) · [Changelog](https://idunnowhytf.github.io/wavesconvsite/changelog.html)**
+
+<br/>
+
+Made with ❤️ using Electron, yt-dlp & ffmpeg · Free & Open Source
+
+</div>

package/cli.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const engine = require('./lib/engine');
+
+const VERSION = require('./package.json').version;
+
+const HELP = `
+WavesConverter CLI v${VERSION}
+
+Użycie:
+  wavesconv download <url> [opcje]     Pobierz wideo/audio z YouTube
+  wavesconv info <url>                 Pokaż metadane (JSON)
+  wavesconv convert <plik> [opcje]   Konwertuj plik lokalny
+  wavesconv tools install              Zainstaluj yt-dlp (do folderu użytkownika)
+  wavesconv tools status               Sprawdź yt-dlp i ffmpeg
+  wavesconv --help                     Ta pomoc
+  wavesconv --version                  Wersja
+
+Opcje download:
+  -o, --output <dir>       Folder docelowy (domyślnie: Downloads)
+  -f, --format <fmt>       mp4, mkv, webm, mp3, wav, flac… (domyślnie: mp4)
+  -q, --quality <q>        best, 1080p, 720p, 480p, 360p
+  -a, --audio              Tylko audio
+  --bitrate <rate>         np. 320k
+  --filename <szablon>     np. "%(title)s" lub "%(uploader)s - %(title)s"
+
+Opcje convert:
+  -o, --output <ścieżka>   Plik lub folder wyjściowy
+  -f, --format <fmt>       mp4, mp3, wav, gif…
+  -q, --quality <q>        Rozdzielczość wideo (1080p, 720p…)
+  --bitrate <rate>         Bitrate audio
+
+Przykłady:
+  wavesconv download "https://youtu.be/xxx" -a -f mp3
+  wavesconv download "https://youtube.com/watch?v=xxx" -q 1080p -o ~/Videos
+  wavesconv convert film.mp4 -f mp3 -o ~/Music/out.mp3
+  wavesconv info "https://youtu.be/xxx"
+
+Deep link (aplikacja graficzna):
+  wavesconverter://download?url=<encoded_url>
+  wavesconverter://queue?url=<encoded_url>&start=1
+`;
+
+function parseArgs(argv) {
+  const args = [...argv];
+  const positional = [];
+  const flags = {};
+
+  while (args.length) {
+    const a = args[0];
+    if (a === '--') {
+      args.shift();
+      positional.push(...args);
+      break;
+    }
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      args.shift();
+      if (['help', 'version', 'audio'].includes(key)) {
+        flags[key] = true;
+      } else if (args.length) {
+        flags[key] = args.shift();
+      } else {
+        flags[key] = true;
+      }
+    } else if (a.startsWith('-') && a.length === 2) {
+      const key = a.slice(1);
+      args.shift();
+      const map = { o: 'output', f: 'format', q: 'quality', a: 'audio' };
+      const flagKey = map[key] || key;
+      if (key === 'a') {
+        flags.audio = true;
+      } else if (args.length) {
+        flags[flagKey] = args.shift();
+      }
+    } else {
+      positional.push(args.shift());
+    }
+  }
+  return { positional, flags };
+}
+
+function log(msg) {
+  process.stderr.write(msg + '\n');
+}
+
+function formatBytes(n) {
+  if (n < 1024) return n + ' B';
+  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
+  return (n / (1024 * 1024)).toFixed(2) + ' MB';
+}
+
+async function cmdToolsInstall() {
+  await engine.ensureYtDlp(msg => log(msg));
+  log('yt-dlp: ' + (engine.findYtDlp() || 'błąd'));
+  log('ffmpeg: ' + (engine.findFfmpeg() || 'brak — zainstaluj systemowo lub z poziomu aplikacji'));
+}
+
+function cmdToolsStatus() {
+  log('yt-dlp: ' + (engine.findYtDlp() || 'BRAK'));
+  log('ffmpeg: ' + (engine.findFfmpeg() || 'BRAK'));
+  log('userData: ' + engine.getUserDataDir());
+}
+
+async function cmdInfo(url) {
+  const items = await engine.fetchInfo(url);
+  console.log(JSON.stringify(items, null, 2));
+}
+
+async function cmdDownload(url, flags) {
+  if (!engine.isYouTubeUrl(url)) {
+    throw new Error('Nieprawidłowy URL YouTube: ' + url);
+  }
+  await engine.ensureYtDlp(msg => log(msg));
+
+  const outputDir = path.resolve(flags.output || engine.getDefaultDownloadDir());
+  if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+  const audioOnly = !!flags.audio || ['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg'].includes((flags.format || '').toLowerCase());
+  const format = flags.format || (audioOnly ? 'mp3' : 'mp4');
+
+  let title = 'download';
+  try {
+    const items = await engine.fetchInfo(url);
+    if (items[0]) title = items[0].title || items[0].id || title;
+  } catch (_) {}
+
+  const job = {
+    id: 'cli-' + Date.now(),
+    title,
+    url,
+    audioOnly,
+    outputFormat: format,
+    quality: flags.quality || 'best',
+    bitrate: flags.bitrate || '',
+    outputDir,
+    filename: flags.filename || '%(title)s',
+  };
+
+  log(`Pobieranie: ${title}`);
+  log(`Folder: ${outputDir}`);
+  log(`Format: ${format}${audioOnly ? ' (audio)' : ''} | Jakość: ${job.quality}`);
+
+  let lastPct = -1;
+  const result = await engine.runDownload(job, {
+    onProgress: (pct, line) => {
+      const rounded = Math.floor(pct);
+      if (rounded !== lastPct && rounded % 5 === 0) {
+        lastPct = rounded;
+        process.stdout.write(`\r[${rounded}%] ${line.slice(0, 60).padEnd(60)}`);
+      }
+    },
+    onLog: line => {
+      if (line.includes('ERROR') || line.includes('error')) log(line);
+    },
+  });
+
+  process.stdout.write('\n');
+  if (result.path) {
+    log(`Gotowe: ${result.path} (${formatBytes(result.size)})`);
+  } else {
+    log('Pobrano (ścieżka nieznana — sprawdź folder docelowy)');
+  }
+}
+
+async function cmdConvert(inputPath, flags) {
+  const ffmpeg = engine.findFfmpeg();
+  if (!ffmpeg) throw new Error('ffmpeg nie znaleziony');
+
+  const resolvedIn = path.resolve(inputPath);
+  if (!fs.existsSync(resolvedIn)) throw new Error('Plik nie istnieje: ' + resolvedIn);
+
+  const format = (flags.format || 'mp4').toLowerCase();
+  let outputPath = flags.output ? path.resolve(flags.output) : null;
+
+  if (!outputPath) {
+    const base = path.basename(resolvedIn, path.extname(resolvedIn));
+    outputPath = path.join(path.dirname(resolvedIn), base + '.' + format);
+  } else if (fs.existsSync(outputPath) && fs.statSync(outputPath).isDirectory()) {
+    const base = path.basename(resolvedIn, path.extname(resolvedIn));
+    outputPath = path.join(outputPath, base + '.' + format);
+  }
+
+  const job = {
+    id: 'cli-convert-' + Date.now(),
+    inputPath: resolvedIn,
+    outputPath,
+    bitrate: flags.bitrate || '',
+    videoBitrate: flags['video-bitrate'] || '',
+    resolution: flags.quality || 'original',
+    gifStart: flags['gif-start'] || '00:00:00',
+    gifDuration: flags['gif-duration'] || 5,
+  };
+
+  log(`Konwersja → ${outputPath}`);
+  await engine.runConvert(job, {
+    onProgress: t => process.stdout.write(`\rCzas: ${t}    `),
+  });
+  process.stdout.write('\n');
+  log('Gotowe: ' + outputPath);
+}
+
+async function run(argv) {
+  const { positional, flags } = parseArgs(argv);
+
+  if (flags.help || positional[0] === 'help') {
+    console.log(HELP);
+    return 0;
+  }
+  if (flags.version) {
+    console.log(VERSION);
+    return 0;
+  }
+
+  const cmd = positional[0];
+  if (!cmd) {
+    console.log(HELP);
+    return 1;
+  }
+
+  try {
+    switch (cmd) {
+      case 'download': {
+        const url = positional[1];
+        if (!url) throw new Error('Podaj URL: wavesconv download <url>');
+        await cmdDownload(url, flags);
+        return 0;
+      }
+      case 'info': {
+        const url = positional[1];
+        if (!url) throw new Error('Podaj URL: wavesconv info <url>');
+        await cmdInfo(url);
+        return 0;
+      }
+      case 'convert': {
+        const file = positional[1];
+        if (!file) throw new Error('Podaj plik: wavesconv convert <plik>');
+        await cmdConvert(file, flags);
+        return 0;
+      }
+      case 'tools': {
+        const sub = positional[1];
+        if (sub === 'install') await cmdToolsInstall();
+        else if (sub === 'status') cmdToolsStatus();
+        else throw new Error('Użyj: wavesconv tools install|status');
+        return 0;
+      }
+      default:
+        throw new Error('Nieznane polecenie: ' + cmd);
+    }
+  } catch (e) {
+    log('Błąd: ' + (e.message || e));
+    return 1;
+  }
+}
+
+function shouldRunAsCli(argv) {
+  const args = argv || process.argv.slice(1);
+  if (args.includes('--cli')) return true;
+  const first = args.find(a => !a.startsWith('-') && a !== process.execPath);
+  return ['download', 'info', 'convert', 'tools', 'help'].includes(first);
+}
+
+if (require.main === module) {
+  run(process.argv.slice(2)).then(code => process.exit(code));
+}
+
+module.exports = { run, shouldRunAsCli, HELP };

package/lib/engine.js

@@ -0,0 +1,348 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const https = require('https');
+const { spawn, exec } = require('child_process');
+
+const APP_FOLDER = 'waves-converter';
+
+function getUserDataDir() {
+  if (process.env.WAVESCONVERTER_USER_DATA) return process.env.WAVESCONVERTER_USER_DATA;
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), APP_FOLDER);
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', APP_FOLDER);
+  }
+  return path.join(os.homedir(), '.config', APP_FOLDER);
+}
+
+function getBinDir() {
+  return path.join(getUserDataDir(), 'bin');
+}
+
+function findYtDlp() {
+  const isWin = process.platform === 'win32';
+  const name = isWin ? 'yt-dlp.exe' : 'yt-dlp';
+  const userBin = path.join(getBinDir(), name);
+  const root = path.join(__dirname, '..');
+  const candidates = [
+    userBin,
+    path.join(root, 'yt-dlp-bin', name),
+    path.join(root, 'node_modules', 'yt-dlp-wrap', 'bin', name),
+    isWin ? 'C:\\ProgramData\\chocolatey\\bin\\yt-dlp.exe' : null,
+    isWin ? 'C:\\scoop\\shims\\yt-dlp.exe' : null,
+    '/opt/homebrew/bin/yt-dlp',
+    '/usr/local/bin/yt-dlp',
+    '/usr/bin/yt-dlp',
+  ].filter(Boolean);
+  return candidates.find(c => fs.existsSync(c)) || null;
+}
+
+function findFfmpeg() {
+  const isWin = process.platform === 'win32';
+  const name = isWin ? 'ffmpeg.exe' : 'ffmpeg';
+  const userBin = path.join(getBinDir(), name);
+  if (fs.existsSync(userBin)) return userBin;
+
+  try {
+    const i = require('@ffmpeg-installer/ffmpeg');
+    let p = i.path;
+    if (process.env.ELECTRON_RUN_AS_NODE || (process.mainModule && process.mainModule.filename.includes('app.asar'))) {
+      p = p.replace('app.asar', 'app.asar.unpacked');
+    }
+    if (fs.existsSync(p)) return p;
+  } catch (_) {}
+
+  const candidates = [
+    isWin ? 'C:\\ProgramData\\chocolatey\\bin\\ffmpeg.exe' : null,
+    isWin ? 'C:\\scoop\\shims\\ffmpeg.exe' : null,
+    '/opt/homebrew/bin/ffmpeg',
+    '/usr/local/bin/ffmpeg',
+    '/usr/bin/ffmpeg',
+  ].filter(Boolean);
+  return candidates.find(c => fs.existsSync(c)) || null;
+}
+
+async function ensureYtDlp(onStatus) {
+  let bin = findYtDlp();
+  if (bin) return bin;
+  const binDir = getBinDir();
+  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true });
+  const isWin = process.platform === 'win32';
+  const binFile = path.join(binDir, isWin ? 'yt-dlp.exe' : 'yt-dlp');
+  if (onStatus) onStatus('Pobieranie yt-dlp…');
+  const YTDlpWrap = require('yt-dlp-wrap').default || require('yt-dlp-wrap');
+  await YTDlpWrap.downloadFromGithub(binFile);
+  if (!isWin) fs.chmodSync(binFile, 0o755);
+  return binFile;
+}
+
+function fetchInfo(url) {
+  const activeYtDlp = findYtDlp();
+  if (!activeYtDlp) {
+    return Promise.reject(new Error('yt-dlp nie znaleziony. Uruchom: wavesconv tools install'));
+  }
+  return new Promise((resolve, reject) => {
+    const args = ['--dump-json', '--flat-playlist', '--no-warnings', url];
+    let out = '';
+    let err = '';
+    const proc = spawn(activeYtDlp, args);
+    proc.stdout.on('data', d => { out += d; });
+    proc.stderr.on('data', d => { err += d; });
+    proc.on('close', () => {
+      if (!out.trim()) return reject(new Error(err.slice(0, 300) || 'Brak danych z yt-dlp'));
+      try {
+        resolve(out.trim().split('\n').filter(Boolean).map(l => JSON.parse(l)));
+      } catch {
+        reject(new Error('Nie udało się odczytać metadanych'));
+      }
+    });
+    proc.on('error', e => reject(e));
+  });
+}
+
+function buildDownloadArgs(job) {
+  const ffmpeg = findFfmpeg();
+  const { url, outputFormat, quality, bitrate, outputDir, filename, audioOnly } = job;
+  const safeName = (filename || '%(title)s').replace(/[<>:"/\\|?*]/g, '_');
+  const outTpl = path.join(outputDir, safeName + '.%(ext)s');
+  const args = ['--no-warnings', '--newline'];
+  if (ffmpeg) args.push('--ffmpeg-location', path.dirname(ffmpeg));
+  if (audioOnly) {
+    args.push('-x', '--audio-format', outputFormat || 'mp3');
+    if (bitrate) args.push('--audio-quality', bitrate.replace('k', '') + 'K');
+  } else {
+    const h = quality && quality !== 'best' ? quality.replace('p', '') : null;
+    args.push('-f', h ? `bestvideo[height<=${h}]+bestaudio/best[height<=${h}]/best` : 'bestvideo+bestaudio/best');
+    args.push('--merge-output-format', outputFormat || 'mp4');
+    if (!outputFormat || outputFormat === 'mp4') {
+      args.push('--postprocessor-args', 'Merger:-c:a aac');
+    }
+    if (bitrate) args.push('--postprocessor-args', `ffmpeg:-b:v ${bitrate}`);
+  }
+  args.push('-o', outTpl, url);
+  return args;
+}
+
+function resolveDownloadedPath(job, outputDir, detectedPath) {
+  let finalPath = '';
+  try {
+    if (detectedPath && fs.existsSync(detectedPath)) {
+      finalPath = detectedPath;
+    } else if (detectedPath && fs.existsSync(path.resolve(outputDir, detectedPath))) {
+      finalPath = path.resolve(outputDir, detectedPath);
+    } else {
+      const cleanTitle = (job.title || '').replace(/[<>:"/\\|?*]/g, '_');
+      const files = fs.readdirSync(outputDir);
+      const match = files.find(f => f.toLowerCase().includes(cleanTitle.toLowerCase()));
+      if (match) {
+        finalPath = path.join(outputDir, match);
+      } else {
+        const now = Date.now();
+        let bestFile = null;
+        let bestMtime = 0;
+        for (const f of files) {
+          const fp = path.join(outputDir, f);
+          try {
+            const stat = fs.statSync(fp);
+            if (stat.isFile() && (now - stat.mtimeMs < 15000) && stat.mtimeMs > bestMtime) {
+              bestMtime = stat.mtimeMs;
+              bestFile = fp;
+            }
+          } catch (_) {}
+        }
+        if (bestFile) finalPath = bestFile;
+      }
+    }
+  } catch (_) {}
+  return finalPath;
+}
+
+function runDownload(job, callbacks = {}) {
+  const activeYtDlp = findYtDlp();
+  if (!activeYtDlp) {
+    return Promise.reject(new Error('yt-dlp nie znaleziony. Uruchom: wavesconv tools install'));
+  }
+  const { onProgress, onLog } = callbacks;
+  const args = buildDownloadArgs(job);
+  let detectedPath = '';
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(activeYtDlp, args);
+    if (callbacks.onSpawn) callbacks.onSpawn(proc);
+
+    proc.stdout.on('data', d => {
+      const line = d.toString().trim();
+      const mDest = line.match(/Destination:\s+(.+)/i) ||
+        line.match(/Merging formats into\s+"([^"]+)"/i) ||
+        line.match(/Merging formats into\s+(.+)/i) ||
+        line.match(/\[download\]\s+(.+?)\s+has already been downloaded/i);
+      if (mDest) detectedPath = mDest[1].trim();
+      const m = line.match(/(\d+\.?\d*)%/);
+      if (m && onProgress) onProgress(parseFloat(m[1]), line);
+      if (onLog) onLog(line);
+    });
+
+    proc.stderr.on('data', d => {
+      if (onLog) onLog(d.toString().trim());
+    });
+
+    proc.on('close', code => {
+      if (code === 0) {
+        const finalPath = resolveDownloadedPath(job, job.outputDir, detectedPath);
+        let fileSize = 0;
+        if (finalPath && fs.existsSync(finalPath)) {
+          fileSize = fs.statSync(finalPath).size;
+        }
+        resolve({ success: true, size: fileSize, path: finalPath });
+      } else {
+        reject(new Error(`yt-dlp zakończył się kodem ${code}`));
+      }
+    });
+    proc.on('error', reject);
+  });
+}
+
+function runConvert(job, callbacks = {}) {
+  const ffmpeg = findFfmpeg();
+  if (!ffmpeg) {
+    return Promise.reject(new Error('ffmpeg nie znaleziony. Uruchom: wavesconv tools install'));
+  }
+  const { inputPath, outputPath, bitrate, videoBitrate, resolution, gifStart, gifDuration } = job;
+  const ext = outputPath.split('.').pop().toLowerCase();
+  const isGif = ext === 'gif';
+  const args = ['-y'];
+  if (isGif) {
+    if (gifStart) args.push('-ss', gifStart);
+    if (gifDuration) args.push('-t', String(gifDuration));
+  }
+  args.push('-i', inputPath);
+
+  if (isGif) {
+    args.push('-vf', 'fps=15,scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse');
+  } else {
+    if (resolution && resolution !== 'original') {
+      args.push('-vf', `scale=-2:${resolution.replace('p', '')}`);
+    }
+    const isVideo = ['mp4', 'mkv', 'mov', 'avi', 'webm'].includes(ext);
+    if (isVideo) {
+      if (ext === 'webm') {
+        args.push('-c:v', 'libvpx-vp9');
+        if (videoBitrate) args.push('-b:v', videoBitrate);
+        else args.push('-crf', '28', '-b:v', '0');
+        args.push('-c:a', 'libopus');
+        if (bitrate) args.push('-b:a', bitrate);
+        else args.push('-b:a', '128k');
+      } else {
+        args.push('-c:v', 'libx264', '-preset', 'fast');
+        if (videoBitrate) args.push('-b:v', videoBitrate);
+        else args.push('-crf', '18');
+        args.push('-c:a', 'aac');
+        if (bitrate) args.push('-b:a', bitrate);
+        else args.push('-b:a', '192k');
+      }
+    } else {
+      if (ext === 'mp3') {
+        args.push('-c:a', 'libmp3lame');
+        if (bitrate) args.push('-b:a', bitrate);
+        else args.push('-b:a', '256k');
+      } else if (ext === 'wav') {
+        args.push('-c:a', 'pcm_s16le');
+      } else if (ext === 'flac') {
+        args.push('-c:a', 'flac');
+      } else if (ext === 'aac' || ext === 'm4a') {
+        args.push('-c:a', 'aac');
+        if (bitrate) args.push('-b:a', bitrate);
+        else args.push('-b:a', '256k');
+      } else if (ext === 'ogg') {
+        args.push('-c:a', 'libvorbis');
+        if (bitrate) args.push('-b:a', bitrate);
+        else args.push('-b:a', '192k');
+      }
+    }
+  }
+  args.push(outputPath);
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(ffmpeg, args);
+    if (callbacks.onSpawn) callbacks.onSpawn(proc);
+    let errOut = '';
+    proc.stderr.on('data', d => {
+      const line = d.toString();
+      errOut += line;
+      const t = line.match(/time=(\d+:\d+:\d+)/);
+      if (t && callbacks.onProgress) callbacks.onProgress(t[1]);
+    });
+    proc.on('close', code => {
+      code === 0 ? resolve({ success: true }) : reject(new Error(errOut.slice(-300) || `ffmpeg kod ${code}`));
+    });
+    proc.on('error', reject);
+  });
+}
+
+function isYouTubeUrl(str) {
+  return /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be)\/.+/i.test((str || '').trim());
+}
+
+function parseDeepLink(raw) {
+  if (!raw || typeof raw !== 'string') return null;
+  const trimmed = raw.trim();
+  if (!trimmed.toLowerCase().startsWith('wavesconverter://')) return null;
+
+  try {
+    const u = new URL(trimmed);
+    const action = (u.hostname || 'open').toLowerCase();
+    const params = u.searchParams;
+
+    let targetUrl = params.get('url') || params.get('link');
+    if (!targetUrl) {
+      let pathPart = u.pathname.replace(/^\//, '');
+      if (pathPart) {
+        try { pathPart = decodeURIComponent(pathPart); } catch (_) {}
+        if (/^https?:\/\//i.test(pathPart)) targetUrl = pathPart;
+      }
+    }
+    if (targetUrl) {
+      try { targetUrl = decodeURIComponent(targetUrl); } catch (_) {}
+    }
+
+    return {
+      action,
+      url: targetUrl || null,
+      file: params.get('file') || null,
+      autoQueue: action === 'queue' || params.get('queue') === '1',
+      autoStart: params.get('start') === '1',
+      format: params.get('format') || null,
+      quality: params.get('quality') || params.get('q') || null,
+      audioOnly: params.get('audio') === '1' || params.get('type') === 'audio',
+      bitrate: params.get('bitrate') || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function findDeepLinkInArgv(argv) {
+  return (argv || process.argv).find(a => typeof a === 'string' && a.toLowerCase().startsWith('wavesconverter://')) || null;
+}
+
+function getDefaultDownloadDir() {
+  return path.join(os.homedir(), 'Downloads');
+}
+
+module.exports = {
+  getUserDataDir,
+  getBinDir,
+  getDefaultDownloadDir,
+  findYtDlp,
+  findFfmpeg,
+  ensureYtDlp,
+  fetchInfo,
+  buildDownloadArgs,
+  runDownload,
+  runConvert,
+  isYouTubeUrl,
+  parseDeepLink,
+  findDeepLinkInArgv,
+};

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "wavesconv",
+  "version": "1.4.9",
+  "description": "CLI: pobieranie YouTube (yt-dlp) i konwersja mediów (ffmpeg) — WavesConverter",
+  "main": "cli.js",
+  "bin": {
+    "wavesconv": "./cli.js"
+  },
+  "files": [
+    "cli.js",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/idunnowhytf/wavesconvsite.git"
+  },
+  "homepage": "https://github.com/idunnowhytf/wavesconvsite#readme",
+  "bugs": {
+    "url": "https://github.com/idunnowhytf/wavesconvsite/issues"
+  },
+  "keywords": [
+    "youtube",
+    "yt-dlp",
+    "ffmpeg",
+    "downloader",
+    "converter",
+    "cli",
+    "wavesconverter"
+  ],
+  "author": "WavesConverter",
+  "scripts": {
+    "start": "electron .",
+    "cli": "node cli.js",
+    "prepublishOnly": "node cli.js --version",
+    "build": "electron-builder",
+    "build:mac": "electron-builder --mac",
+    "publish:app": "electron-builder --publish always",
+    "publish:npm": "npm publish --access public"
+  },
+  "build": {
+    "appId": "com.wavesconverter.app",
+    "productName": "WavesConverter",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "main.js",
+      "cli.js",
+      "lib/**",
+      "preload.js",
+      "index.html",
+      "style.css",
+      "renderer.js",
+      "assets/**"
+    ],
+    "protocols": [
+      {
+        "name": "WavesConverter",
+        "schemes": ["wavesconverter"]
+      }
+    ],
+    "mac": {
+      "category": "public.app-category.video",
+      "icon": "assets/icon.icns",
+      "target": [
+        {
+          "target": "dmg",
+          "arch": [
+            "arm64",
+            "x64"
+          ]
+        }
+      ]
+    },
+    "win": {
+      "icon": "assets/icon.ico",
+      "artifactName": "${productName}-Setup-${version}.${ext}",
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        }
+      ]
+    },
+    "publish": {
+      "provider": "github",
+      "owner": "idunnowhytf",
+      "repo": "WavesConverter",
+      "releaseType": "release"
+    }
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "yt-dlp-wrap": "^2.3.12"
+  },
+  "devDependencies": {
+    "electron": "^42.3.0",
+    "electron-builder": "^26.8.1",
+    "electron-updater": "^6.8.3",
+    "qrcode": "^1.5.4"
+  }
+}