wavesconv 1.7.0 → 1.7.1

package/cli.js

@@ -68,6 +68,7 @@ function cmdToolsStatus(color) {
 }
 
 async function cmdInfo(url, flags, color) {
+  url = resolveCliMediaUrl(url);
   const spin = new ui.Spinner('Pobieranie metadanych', color);
   spin.start();
   let items;
@@ -100,10 +101,16 @@ async function cmdInfo(url, flags, color) {
   console.log('');
 }
 
-async function cmdDownload(url, flags, color) {
-  if (!engine.isSupportedMediaUrl(url)) {
-    throw new Error('Nieobsługiwany URL. Użyj linku YouTube lub Instagram (post / Reel / Stories).');
+function resolveCliMediaUrl(raw) {
+  const { mediaUrl } = engine.resolveInputUrl(raw);
+  if (!mediaUrl) {
+    throw new Error('Nieobsługiwany URL. Wklej YouTube/Instagram lub wavesconverter:// przed linkiem.');
   }
+  return mediaUrl;
+}
+
+async function cmdDownload(url, flags, color) {
+  url = resolveCliMediaUrl(url);
 
   const setupSpin = new ui.Spinner('Przygotowanie yt-dlp', color);
   setupSpin.start();
@@ -257,7 +264,7 @@ async function run(argv) {
     switch (cmd) {
       case 'download': {
         const url = positional[1];
-        if (!url) throw new Error('Podaj URL: wavesconv download <url>');
+        if (!url) throw new Error('Podaj URL: wavesconv download <url> (możesz dodać wavesconverter:// przed linkiem)');
         await cmdDownload(url, flags, color);
         return 0;
       }
@@ -296,7 +303,8 @@ function shouldRunAsCli(argv) {
   return ['download', 'info', 'convert', 'tools', 'help'].includes(first);
 }
 
-if (require.main === module) {
+// Gdy Electron ładuje ten plik przez pomyłkę (zły "main" w package.json), nie uruchamiaj CLI.
+if (require.main === module && !process.versions.electron) {
   run(process.argv.slice(2)).then(code => process.exit(code));
 }
 

package/lib/cli-install.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { spawn } = require('child_process');
+
+function run(cmd, args = []) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { shell: true, windowsHide: true });
+    let out = '';
+    let err = '';
+    proc.stdout?.on('data', d => { out += d.toString(); });
+    proc.stderr?.on('data', d => { err += d.toString(); });
+    proc.on('error', reject);
+    proc.on('close', code => {
+      if (code === 0) resolve((out || err).trim());
+      else reject(new Error((err || out || `Kod wyjścia ${code}`).trim().slice(0, 400)));
+    });
+  });
+}
+
+async function checkCliEnvironment() {
+  const result = { node: null, npm: null, cli: null, cliInstalled: false };
+  try {
+    result.node = await run('node', ['--version']);
+  } catch (e) {
+    result.nodeError = e.message;
+    return result;
+  }
+  try {
+    result.npm = await run('npm', ['--version']);
+  } catch (e) {
+    result.npmError = e.message;
+  }
+  try {
+    result.cli = await run('wavesconv', ['--version']);
+    result.cliInstalled = true;
+  } catch (_) {
+    result.cliInstalled = false;
+  }
+  return result;
+}
+
+function installCliGlobal(onStatus) {
+  const notify = (data) => { if (onStatus) onStatus(data); };
+  return new Promise((resolve, reject) => {
+    notify({ status: 'installing', message: 'Instalacja wavesconv z npm…', progress: 10 });
+    const proc = spawn('npm', ['install', '-g', 'wavesconv@latest'], {
+      shell: true,
+      windowsHide: true,
+    });
+    let err = '';
+    proc.stderr?.on('data', d => {
+      err += d.toString();
+      notify({ status: 'installing', message: d.toString().trim().slice(-80) || 'Instalowanie…', progress: 50 });
+    });
+    proc.stdout?.on('data', d => {
+      notify({ status: 'installing', message: d.toString().trim().slice(-80) || 'Instalowanie…', progress: 70 });
+    });
+    proc.on('error', reject);
+    proc.on('close', async code => {
+      if (code !== 0) {
+        reject(new Error(err.trim() || `npm zakończył się kodem ${code}`));
+        return;
+      }
+      notify({ status: 'verifying', message: 'Sprawdzanie instalacji…', progress: 90 });
+      try {
+        const ver = await run('wavesconv', ['--version']);
+        resolve({ success: true, version: ver });
+      } catch (e) {
+        reject(new Error('Instalacja zakończona, ale polecenie wavesconv nie działa. Uruchom terminal ponownie lub dodaj npm global bin do PATH.'));
+      }
+    });
+  });
+}
+
+module.exports = { checkCliEnvironment, installCliGlobal, run };

package/lib/cli-interactive.js

@@ -192,11 +192,12 @@ async function runInteractive(handlers, version, color) {
       case 'info':
       case 'i': {
         const url = arg || '';
-        if (!url || !engine.isSupportedMediaUrl(url)) {
-          ui.warn(color, 'Użyj: /info <url> (YouTube lub Instagram)');
+        const media = url ? engine.resolveInputUrl(url).mediaUrl : null;
+        if (!media) {
+          ui.warn(color, 'Użyj: /info <url> (YouTube, Instagram lub wavesconverter://…)');
           return;
         }
-        await handlers.info(url, {}, color);
+        await handlers.info(media, {}, color);
         return;
       }
       case 'clear':
@@ -242,7 +243,7 @@ async function runInteractive(handlers, version, color) {
 
         const urls = extractYouTubeUrls(trimmed);
         if (!urls.length) {
-          ui.warn(color, 'Nie wykryto linku YouTube/Instagram. Wklej URL lub wpisz /help');
+          ui.warn(color, 'Nie wykryto linku. Wklej URL (opcjonalnie z wavesconverter://) lub wpisz /help');
           rl.resume();
           loop();
           return;

package/lib/engine.js

@@ -321,6 +321,21 @@ function parseDeepLink(raw) {
   const trimmed = raw.trim();
   if (!trimmed.toLowerCase().startsWith('wavesconverter://')) return null;
 
+  const quickMedia = urls.unwrapWavesProtocolLink(trimmed);
+  if (quickMedia) {
+    return {
+      action: 'download',
+      url: quickMedia,
+      file: null,
+      autoQueue: false,
+      autoStart: false,
+      format: null,
+      quality: null,
+      audioOnly: false,
+      bitrate: null,
+    };
+  }
+
   try {
     const u = new URL(trimmed);
     const action = (u.hostname || 'open').toLowerCase();
@@ -332,8 +347,12 @@ function parseDeepLink(raw) {
       if (pathPart) {
         try { pathPart = decodeURIComponent(pathPart); } catch (_) {}
         if (/^https?:\/\//i.test(pathPart)) targetUrl = pathPart;
+        else if (pathPart.startsWith('//')) targetUrl = `https:${pathPart}`;
       }
     }
+    if (!targetUrl && (u.hostname === 'https' || u.hostname === 'http') && u.pathname.startsWith('//')) {
+      targetUrl = `${u.hostname}:${u.pathname}`;
+    }
     if (targetUrl) {
       try { targetUrl = decodeURIComponent(targetUrl); } catch (_) {}
     }
@@ -358,6 +377,28 @@ function findDeepLinkInArgv(argv) {
   return (argv || process.argv).find(a => typeof a === 'string' && a.toLowerCase().startsWith('wavesconverter://')) || null;
 }
 
+/** Rozpoznaje zwykły URL, wavesconverter://https://… lub pełny deep link. */
+function resolveInputUrl(text) {
+  const raw = (text || '').trim();
+  if (!raw) return { mediaUrl: null, deeplink: null };
+
+  const deeplink = parseDeepLink(raw);
+  if (deeplink?.url) {
+    return { mediaUrl: deeplink.url, deeplink };
+  }
+  if (deeplink && !deeplink.url) {
+    return { mediaUrl: null, deeplink };
+  }
+
+  const unwrapped = urls.unwrapWavesProtocolLink(raw);
+  if (unwrapped) return { mediaUrl: unwrapped, deeplink: null };
+
+  const plain = urls.normalizeUrl(raw);
+  if (urls.isSupportedMediaUrl(plain)) return { mediaUrl: plain, deeplink: null };
+
+  return { mediaUrl: null, deeplink: null };
+}
+
 function getDefaultDownloadDir() {
   return path.join(os.homedir(), 'Downloads');
 }
@@ -380,4 +421,5 @@ module.exports = {
   getInstagramContentKind: urls.getInstagramContentKind,
   parseDeepLink,
   findDeepLinkInArgv,
+  resolveInputUrl,
 };

package/lib/urls.js

@@ -40,16 +40,80 @@ function getInstagramContentKind(url) {
   return 'post';
 }
 
+const PROTO_PREFIX = /^wavesconverter:\/\//i;
+
+function stripWavesProtocol(text) {
+  return (text || '').trim().replace(PROTO_PREFIX, '');
+}
+
+/** wavesconverter://https://youtu.be/… lub wavesconverter://youtu.be/… → zwykły https URL */
+function unwrapWavesProtocolLink(text) {
+  const raw = (text || '').trim();
+  if (!PROTO_PREFIX.test(raw)) return null;
+
+  const after = stripWavesProtocol(raw);
+
+  const embedded = after.match(/https?:\/\/[^\s<>"']+/i);
+  if (embedded) {
+    const u = normalizeUrl(embedded[0]);
+    if (isSupportedMediaUrl(u)) return u;
+  }
+
+  try {
+    const u = new URL(raw);
+    const action = (u.hostname || '').toLowerCase();
+    const knownActions = new Set(['download', 'queue', 'open', 'convert']);
+    if (!knownActions.has(action) && u.hostname) {
+      const candidate = normalizeUrl(`https://${u.hostname}${u.pathname}${u.search}${u.hash}`);
+      if (isSupportedMediaUrl(candidate)) return candidate;
+    }
+    let pathPart = u.pathname.replace(/^\//, '');
+    if (pathPart.startsWith('//')) {
+      const candidate = normalizeUrl(`https:${pathPart}${u.search}${u.hash}`);
+      if (isSupportedMediaUrl(candidate)) return candidate;
+    }
+    if (/^https?:\/\//i.test(pathPart)) {
+      const candidate = normalizeUrl(pathPart);
+      if (isSupportedMediaUrl(candidate)) return candidate;
+    }
+  } catch (_) {}
+
+  if (after && !/^https?:\/\//i.test(after)) {
+    const candidate = normalizeUrl(`https://${after.replace(/^\/+/, '')}`);
+    if (isSupportedMediaUrl(candidate)) return candidate;
+  }
+
+  return null;
+}
+
 function extractMediaUrls(text) {
   const found = new Set();
   const raw = text || '';
-  const re = /https?:\/\/[^\s<>"']+/gi;
+
+  const protoWrapped = /wavesconverter:\/\/\/?\/?(https?:\/\/[^\s<>"']+)/gi;
   let m;
+  while ((m = protoWrapped.exec(raw)) !== null) {
+    const cleaned = normalizeUrl(m[1]);
+    if (isSupportedMediaUrl(cleaned)) found.add(cleaned);
+  }
+
+  const protoBare = /wavesconverter:\/\/([^\s<>"']+)/gi;
+  while ((m = protoBare.exec(raw)) !== null) {
+    const unwrapped = unwrapWavesProtocolLink(`wavesconverter://${m[1]}`);
+    if (unwrapped) found.add(unwrapped);
+  }
+
+  const re = /https?:\/\/[^\s<>"']+/gi;
   while ((m = re.exec(raw)) !== null) {
     const cleaned = normalizeUrl(m[0]);
     if (isSupportedMediaUrl(cleaned)) found.add(cleaned);
   }
   raw.split(/\s+/).filter(Boolean).forEach(part => {
+    const unwrapped = unwrapWavesProtocolLink(part);
+    if (unwrapped) {
+      found.add(unwrapped);
+      return;
+    }
     const cleaned = normalizeUrl(part);
     if (isSupportedMediaUrl(cleaned)) found.add(cleaned);
   });
@@ -64,4 +128,6 @@ module.exports = {
   isInstagramUrl,
   getInstagramContentKind,
   extractMediaUrls,
+  unwrapWavesProtocolLink,
+  stripWavesProtocol,
 };

package/main.js

@@ -0,0 +1,647 @@
+const path = require('path');
+const fs = require('fs');
+const { exec } = require('child_process');
+const os = require('os');
+const https = require('https');
+const http = require('http');
+const engine = require('./lib/engine');
+const cli = require('./cli');
+
+// Tryb CLI: node cli.js …  lub  npx electron . --cli download …
+const rawArgv = process.argv.slice(1);
+const cliFlagIdx = rawArgv.indexOf('--cli');
+if (cliFlagIdx !== -1) {
+  cli.run(rawArgv.slice(cliFlagIdx + 1)).then(code => process.exit(code ?? 0)).catch(e => {
+    console.error(e.message || e);
+    process.exit(1);
+  });
+} else {
+  startElectronApp();
+}
+
+function startElectronApp() {
+const { app, BrowserWindow, ipcMain, dialog, shell, Menu, Tray, globalShortcut, clipboard } = require('electron');
+const isDev = !app.isPackaged;
+
+function loadQRCode() {
+  try {
+    return require('qrcode');
+  } catch (e) {
+    console.error('qrcode module missing:', e.message);
+    return null;
+  }
+}
+
+let mainWindow;
+let ytDlpPath;
+let tray = null;
+let shareServer = null;
+let isQuitting = false;
+let pendingDeepLink = null;
+let pendingClipboardText = null;
+
+const PROTOCOL = 'wavesconverter';
+
+function isMainWindowAlive() {
+  try {
+    return !!(mainWindow && !mainWindow.isDestroyed());
+  } catch (_) {
+    return false;
+  }
+}
+
+function safeSend(channel, data) {
+  try {
+    if (!isMainWindowAlive()) return false;
+    const wc = mainWindow.webContents;
+    if (!wc || wc.isDestroyed()) return false;
+    mainWindow.webContents.send(channel, data);
+    return true;
+  } catch (e) {
+    console.error('safeSend:', e.message);
+    return false;
+  }
+}
+
+function focusMainWindow() {
+  try {
+    if (!isMainWindowAlive()) return;
+    if (mainWindow.isMinimized()) mainWindow.restore();
+    mainWindow.show();
+    mainWindow.focus();
+  } catch (_) {}
+}
+
+function ensureMainWindow() {
+  if (isMainWindowAlive()) return true;
+  createWindow();
+  return isMainWindowAlive();
+}
+
+function flushPendingToRenderer() {
+  flushPendingDeepLink();
+  if (pendingClipboardText) {
+    safeSend('clipboard-search-trigger', pendingClipboardText);
+    pendingClipboardText = null;
+  }
+}
+
+function syncEngineUserData() {
+  if (app.isReady()) process.env.WAVESCONVERTER_USER_DATA = app.getPath('userData');
+}
+
+function findYtDlp() {
+  syncEngineUserData();
+  return engine.findYtDlp();
+}
+
+function findFfmpeg() {
+  syncEngineUserData();
+  let p = engine.findFfmpeg();
+  if (p) return p;
+  try {
+    const i = require('@ffmpeg-installer/ffmpeg');
+    let fp = i.path;
+    if (app.isPackaged) fp = fp.replace('app.asar', 'app.asar.unpacked');
+    if (fs.existsSync(fp)) return fp;
+  } catch (_) {}
+  return null;
+}
+
+function registerProtocol() {
+  if (process.defaultApp) {
+    if (process.argv.length >= 2) {
+      app.setAsDefaultProtocolClient(PROTOCOL, process.execPath, [path.resolve(process.argv[1])]);
+    }
+  } else {
+    app.setAsDefaultProtocolClient(PROTOCOL);
+  }
+}
+
+function deliverDeepLink(payload) {
+  if (!payload) return;
+  if (isMainWindowAlive()) {
+    const wc = mainWindow.webContents;
+    if (wc && !wc.isDestroyed() && !wc.isLoading()) {
+      focusMainWindow();
+      safeSend('deep-link', payload);
+      pendingDeepLink = null;
+      return;
+    }
+  }
+  pendingDeepLink = payload;
+}
+
+function handleDeepLinkUrl(url) {
+  const payload = engine.parseDeepLink(url);
+  if (payload) deliverDeepLink(payload);
+}
+
+function flushPendingDeepLink() {
+  if (pendingDeepLink) deliverDeepLink(pendingDeepLink);
+}
+
+// Helper: Get ffbinaries platform tag
+function getFfmpegPlatformTag() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === 'win32') return a === 'ia32' ? 'windows-32' : 'windows-64';
+  if (p === 'darwin') return 'osx-64';
+  if (p === 'linux') {
+    if (a === 'arm64') return 'linux-arm-64';
+    if (a === 'arm') return 'linux-armhf';
+    return 'linux-64';
+  }
+  return 'windows-64';
+}
+
+// Helper: Get ffmpeg URL
+function getFfmpegDownloadUrl() {
+  return new Promise((resolve) => {
+    const tag = getFfmpegPlatformTag();
+    const fallbackUrl = `https://github.com/ffbinaries/ffbinaries-prebuilt/releases/download/v6.1/ffmpeg-6.1-${tag === 'osx-64' ? 'osx-64' : tag === 'windows-64' ? 'win-64' : tag === 'windows-32' ? 'win-32' : tag}.zip`;
+    
+    https.get('https://ffbinaries.com/api/v1/version/latest', { headers: { 'User-Agent': 'WavesConverter' } }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const url = json?.bin?.[tag]?.ffmpeg;
+          if (url) resolve(url);
+          else resolve(fallbackUrl);
+        } catch (_) {
+          resolve(fallbackUrl);
+        }
+      });
+    }).on('error', () => {
+      resolve(fallbackUrl);
+    });
+  });
+}
+
+// Helper: Download file following redirects
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    
+    function get(fileUrl) {
+      https.get(fileUrl, { headers: { 'User-Agent': 'WavesConverter' } }, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          get(response.headers.location);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: Status ${response.statusCode}`));
+          return;
+        }
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        try { fs.unlinkSync(dest); } catch (_) {}
+        reject(err);
+      });
+    }
+    
+    get(url);
+  });
+}
+
+// Helper: Extract Zip
+function extractZip(zipPath, destDir) {
+  return new Promise((resolve, reject) => {
+    const isWin = process.platform === 'win32';
+    if (isWin) {
+      const cmd = `powershell.exe -NoProfile -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`;
+      exec(cmd, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    } else {
+      const cmd = `unzip -o "${zipPath}" -d "${destDir}"`;
+      exec(cmd, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    }
+  });
+}
+
+// Helper: Find File Recursively
+function findFileRecursively(dir, fileName) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      const found = findFileRecursively(fullPath, fileName);
+      if (found) return found;
+    } else if (file.toLowerCase() === fileName.toLowerCase()) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+// Helper: Clean nested folders in bin
+function cleanupExtractedFolders(dir) {
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      try {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      } catch (_) {}
+    }
+  }
+}
+
+function createWindow() {
+  if (isMainWindowAlive()) return;
+
+  const isWin = process.platform === 'win32';
+  // On Windows, transparent + vibrancy-like effects are a common cause of "app runs but window is invisible".
+  // Keep the premium glass look for macOS, but force a safe, opaque window on Windows.
+  const windowOpts = {
+    width: 1300, height: 860, minWidth: 920, minHeight: 660,
+    frame: false,
+    transparent: !isWin,
+    backgroundColor: isWin ? '#0a0118' : '#00000000',
+    webPreferences: { preload: path.join(__dirname, 'preload.js'), contextIsolation: true, nodeIntegration: false },
+    title: 'WavesConverter',
+    show: false,
+  };
+  if (!isWin) {
+    windowOpts.vibrancy = 'under-window';
+    windowOpts.visualEffectState = 'active';
+  }
+
+  mainWindow = new BrowserWindow(windowOpts);
+  mainWindow.loadFile('index.html');
+  mainWindow.once('ready-to-show', () => {
+    if (isMainWindowAlive()) mainWindow.show();
+  });
+  // Fallback: if ready-to-show never fires, still show the window.
+  setTimeout(() => {
+    try {
+      if (isMainWindowAlive() && !mainWindow.isVisible()) mainWindow.show();
+    } catch (_) {}
+  }, 2500);
+  mainWindow.webContents.on('did-finish-load', flushPendingToRenderer);
+  mainWindow.on('maximize', () => safeSend('window-state', 'maximized'));
+  mainWindow.on('unmaximize', () => safeSend('window-state', 'normal'));
+  mainWindow.on('closed', () => { mainWindow = null; });
+
+  // Close to tray logic
+  mainWindow.on('close', (event) => {
+    if (!isQuitting && !isDev) {
+      event.preventDefault();
+      mainWindow.hide();
+      return false;
+    }
+  });
+}
+
+function createTray() {
+  const iconPath = path.join(__dirname, 'assets', process.platform === 'win32' ? 'icon.ico' : 'icon.png');
+  if (!fs.existsSync(iconPath)) return;
+  
+  tray = new Tray(iconPath);
+  const contextMenu = Menu.buildFromTemplate([
+    { label: 'Pokaż WavesConverter', click: () => { showAndCheckClipboard(); } },
+    { label: 'Minimalizuj do zasobnika', click: () => { mainWindow?.hide(); } },
+    { type: 'separator' },
+    { label: 'Zakończ', click: () => { isQuitting = true; app.quit(); } }
+  ]);
+  
+  tray.setToolTip('WavesConverter');
+  tray.setContextMenu(contextMenu);
+  
+  tray.on('click', () => {
+    if (isMainWindowAlive() && mainWindow.isVisible()) {
+      mainWindow.hide();
+    } else {
+      showAndCheckClipboard();
+    }
+  });
+}
+
+function registerGlobalShortcut() {
+  // Alt+Shift+W is a safe global shortcut combination
+  globalShortcut.register('Alt+Shift+W', () => {
+    if (isMainWindowAlive() && mainWindow.isVisible() && mainWindow.isFocused()) {
+      mainWindow.hide();
+    } else {
+      showAndCheckClipboard();
+    }
+  });
+}
+
+function showAndCheckClipboard() {
+  const text = clipboard.readText();
+  if (!ensureMainWindow()) {
+    if (text) pendingClipboardText = text;
+    return;
+  }
+  focusMainWindow();
+  if (text) {
+    if (!safeSend('clipboard-search-trigger', text)) {
+      pendingClipboardText = text;
+    }
+  }
+}
+
+const gotSingleInstanceLock = app.requestSingleInstanceLock();
+if (!gotSingleInstanceLock) {
+  app.quit();
+} else {
+  app.on('second-instance', (_, argv) => {
+    const link = engine.findDeepLinkInArgv(argv);
+    if (link) handleDeepLinkUrl(link);
+    if (!isMainWindowAlive()) ensureMainWindow();
+    else focusMainWindow();
+  });
+
+  app.on('open-url', (event, url) => {
+    event.preventDefault();
+    handleDeepLinkUrl(url);
+  });
+
+  app.whenReady().then(async () => {
+    syncEngineUserData();
+    registerProtocol();
+
+    const startupLink = engine.findDeepLinkInArgv(process.argv);
+    if (startupLink) handleDeepLinkUrl(startupLink);
+
+    ytDlpPath = findYtDlp();
+    if (!ytDlpPath) {
+      try {
+        ytDlpPath = await engine.ensureYtDlp();
+      } catch (e) { console.error('yt-dlp download failed on startup:', e.message); }
+    }
+    createWindow();
+    if (!isDev) {
+      createTray();
+      registerGlobalShortcut();
+    }
+    // In dev mode, always force focus/visibility to avoid "running but no window" confusion.
+    if (isDev) {
+      setTimeout(() => focusMainWindow(), 800);
+    }
+    setupAutoUpdater();
+  });
+
+  app.on('will-quit', () => {
+    globalShortcut.unregisterAll();
+  });
+
+  app.on('window-all-closed', () => {
+    // Keep running in system tray
+  });
+
+  app.on('activate', () => {
+    if (!isMainWindowAlive()) createWindow();
+    else focusMainWindow();
+  });
+}
+
+function setupAutoUpdater() {
+  if (!app.isPackaged) return;
+  try {
+    const { autoUpdater } = require('electron-updater');
+    autoUpdater.autoDownload = true;
+    autoUpdater.autoInstallOnAppQuit = true;
+    autoUpdater.on('checking-for-update', () => safeSend('update-status', { type: 'checking' }));
+    autoUpdater.on('update-available', info => safeSend('update-status', { type: 'available', version: info.version }));
+    autoUpdater.on('update-not-available', () => safeSend('update-status', { type: 'latest' }));
+    autoUpdater.on('download-progress', p => safeSend('update-status', { type: 'downloading', percent: Math.round(p.percent) }));
+    autoUpdater.on('update-downloaded', info => safeSend('update-status', { type: 'ready', version: info.version }));
+    autoUpdater.on('error', err => safeSend('update-status', { type: 'error', message: err.message }));
+    autoUpdater.checkForUpdatesAndNotify();
+  } catch (e) { console.error('Updater error:', e.message); }
+}
+
+ipcMain.on('install-update', () => { if (app.isPackaged) try { require('electron-updater').autoUpdater.quitAndInstall(); } catch (_) {} });
+ipcMain.handle('check-update', async () => { if (!app.isPackaged) return { type: 'dev' }; try { await require('electron-updater').autoUpdater.checkForUpdates(); } catch (e) { return { type: 'error', message: e.message }; } });
+ipcMain.handle('get-version', () => app.getVersion());
+
+ipcMain.on('window-minimize', () => { if (isMainWindowAlive()) mainWindow.minimize(); });
+ipcMain.on('window-maximize', () => {
+  if (!isMainWindowAlive()) return;
+  mainWindow.isMaximized() ? mainWindow.unmaximize() : mainWindow.maximize();
+});
+ipcMain.on('window-close', () => { if (isMainWindowAlive()) mainWindow.close(); });
+
+ipcMain.handle('choose-folder', async () => { const r = await dialog.showOpenDialog(mainWindow, { properties: ['openDirectory'] }); return r.canceled ? null : r.filePaths[0]; });
+ipcMain.handle('choose-file', async () => { const r = await dialog.showOpenDialog(mainWindow, { properties: ['openFile'], filters: [{ name: 'Media', extensions: ['mp4','mkv','avi','mov','webm','mp3','wav','flac','aac','m4a','ogg'] }] }); return r.canceled ? null : r.filePaths[0]; });
+ipcMain.on('open-folder', (_, p) => shell.openPath(p));
+ipcMain.handle('get-default-dir', () => path.join(os.homedir(), 'Downloads'));
+ipcMain.handle('check-ytdlp', () => !!findYtDlp());
+ipcMain.handle('check-ffmpeg', () => !!findFfmpeg());
+
+// Tool Installer IPC handler
+ipcMain.handle('install-tools', async (event) => {
+  const binDir = path.join(app.getPath('userData'), 'bin');
+  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true });
+  const isWin = process.platform === 'win32';
+
+  // 1. Download yt-dlp
+  try {
+    event.sender.send('install-status', { status: 'downloading-ytdlp', progress: 10, message: 'Downloading yt-dlp...' });
+    const YTDlpWrap = require('yt-dlp-wrap').default || require('yt-dlp-wrap');
+    const binFile = path.join(binDir, isWin ? 'yt-dlp.exe' : 'yt-dlp');
+    await YTDlpWrap.downloadFromGithub(binFile);
+    if (!isWin) fs.chmodSync(binFile, 0o755);
+    ytDlpPath = binFile;
+  } catch (e) {
+    console.error('yt-dlp install failed:', e);
+    throw new Error('Failed to install yt-dlp: ' + e.message);
+  }
+
+  // 2. Download ffmpeg
+  try {
+    event.sender.send('install-status', { status: 'downloading-ffmpeg', progress: 40, message: 'Downloading ffmpeg...' });
+    const ffmpegUrl = await getFfmpegDownloadUrl();
+    const zipFile = path.join(binDir, 'ffmpeg.zip');
+    await downloadFile(ffmpegUrl, zipFile);
+
+    event.sender.send('install-status', { status: 'extracting-ffmpeg', progress: 80, message: 'Extracting ffmpeg...' });
+    await extractZip(zipFile, binDir);
+    try { fs.unlinkSync(zipFile); } catch (_) {}
+
+    const ffmpegExeName = isWin ? 'ffmpeg.exe' : 'ffmpeg';
+    const foundFfmpeg = findFileRecursively(binDir, ffmpegExeName);
+    if (foundFfmpeg && foundFfmpeg !== path.join(binDir, ffmpegExeName)) {
+      fs.renameSync(foundFfmpeg, path.join(binDir, ffmpegExeName));
+    }
+
+    const finalFfmpegPath = path.join(binDir, ffmpegExeName);
+    if (!fs.existsSync(finalFfmpegPath)) {
+      throw new Error('ffmpeg binary not found in extracted files');
+    }
+
+    if (!isWin) fs.chmodSync(finalFfmpegPath, 0o755);
+    cleanupExtractedFolders(binDir);
+  } catch (e) {
+    console.error('ffmpeg install failed:', e);
+    throw new Error('Failed to install ffmpeg: ' + e.message);
+  }
+
+  event.sender.send('install-status', { status: 'success', progress: 100, message: 'Tools installed successfully!' });
+  return { success: true };
+});
+
+ipcMain.handle('fetch-info', async (_, url, options) => engine.fetchInfo(url, options || {}));
+ipcMain.handle('resolve-input-url', (_, text) => engine.resolveInputUrl(text));
+ipcMain.handle('is-supported-url', (_, url) => !!engine.resolveInputUrl(url).mediaUrl);
+ipcMain.handle('get-url-platform', (_, url) => {
+  const media = engine.resolveInputUrl(url).mediaUrl;
+  return media ? engine.getMediaPlatform(media) : null;
+});
+ipcMain.handle('choose-cookies-file', async () => {
+  const r = await dialog.showOpenDialog(mainWindow, {
+    properties: ['openFile'],
+    filters: [{ name: 'Cookies', extensions: ['txt'] }],
+  });
+  return r.canceled ? null : r.filePaths[0];
+});
+
+const cliInstall = require('./lib/cli-install');
+
+ipcMain.handle('check-cli', async () => cliInstall.checkCliEnvironment());
+
+ipcMain.handle('install-cli', async (event) => {
+  const env = await cliInstall.checkCliEnvironment();
+  if (!env.node) {
+    throw new Error('Node.js nie jest zainstalowany. Pobierz Node 18+ z nodejs.org i spróbuj ponownie.');
+  }
+  if (!env.npm) {
+    throw new Error('npm nie jest dostępny. Zainstaluj Node.js (zawiera npm) i spróbuj ponownie.');
+  }
+  return cliInstall.installCliGlobal(data => {
+    event.sender.send('cli-install-status', data);
+  });
+});
+
+ipcMain.handle('copy-text', (_, text) => {
+  clipboard.writeText(text || '');
+  return true;
+});
+
+ipcMain.handle('open-external', (_, url) => shell.openExternal(url));
+
+const active = new Map();
+
+ipcMain.handle('start-download', (_, job) => {
+  if (!findYtDlp()) return Promise.reject(new Error('yt-dlp not found. Please click the "Install / Repair Tools" button in Settings.'));
+  const { id } = job;
+  return engine.runDownload(job, {
+    onSpawn: proc => active.set(id, proc),
+    onProgress: (progress, line) => {
+      safeSend('download-progress', { id, progress, line });
+      safeSend('download-log', { id, line });
+    },
+    onLog: line => safeSend('download-log', { id, line }),
+  }).finally(() => active.delete(id));
+});
+
+ipcMain.on('cancel-download', (_, id) => { const p = active.get(id); if (p) { p.kill('SIGTERM'); active.delete(id); } });
+
+ipcMain.handle('convert-file', (_, job) => {
+  if (!findFfmpeg()) return Promise.reject(new Error('ffmpeg not found. Please click the "Install / Repair Tools" button in Settings.'));
+  const { id } = job;
+  return engine.runConvert(job, {
+    onSpawn: proc => active.set(id, proc),
+    onProgress: time => safeSend('convert-progress', { id, time }),
+  }).finally(() => active.delete(id));
+});
+
+// Expose download-thumbnail handler
+ipcMain.handle('download-thumbnail', async (_, { url, dest }) => {
+  return downloadFile(url, dest);
+});
+
+// Wi-Fi Local File Sharing Server Handlers
+ipcMain.handle('start-share-server', async (event, { filePath, fileName }) => {
+  if (!fs.existsSync(filePath)) {
+    throw new Error('Plik nie istnieje lub został usunięty z dysku.');
+  }
+
+  if (shareServer) {
+    try {
+      shareServer.close();
+    } catch (_) {}
+    shareServer = null;
+  }
+
+  // Get local IP address
+  const networkInterfaces = os.networkInterfaces();
+  let localIp = '127.0.0.1';
+  for (const name of Object.keys(networkInterfaces)) {
+    for (const iface of networkInterfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        localIp = iface.address;
+        break;
+      }
+    }
+    if (localIp !== '127.0.0.1') break;
+  }
+
+  return new Promise((resolve, reject) => {
+    shareServer = http.createServer((req, res) => {
+      if (fs.existsSync(filePath)) {
+        const stat = fs.statSync(filePath);
+        const safeFileName = fileName.replace(/["\\]/g, ''); // strip quotes and backslashes
+        res.writeHead(200, {
+          'Content-Type': 'application/octet-stream',
+          'Content-Length': stat.size,
+          'Content-Disposition': `attachment; filename="${encodeURIComponent(safeFileName)}"; filename*=UTF-8''${encodeURIComponent(safeFileName)}`
+        });
+        const readStream = fs.createReadStream(filePath);
+        readStream.pipe(res);
+      } else {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Plik nie istnieje lub został usunięty.');
+      }
+    });
+
+    shareServer.listen(0, localIp, async () => {
+      const port = shareServer.address().port;
+      const shareUrl = `http://${localIp}:${port}/download`;
+      try {
+        const QRCode = loadQRCode();
+        let qrDataUrl = null;
+        if (QRCode) {
+          qrDataUrl = await QRCode.toDataURL(shareUrl, {
+            color: {
+              dark: '#1e0b36',
+              light: '#f0e6ff'
+            },
+            margin: 2
+          });
+        }
+        resolve({ shareUrl, qrDataUrl });
+      } catch (err) {
+        reject(err);
+      }
+    });
+
+    shareServer.on('error', (err) => {
+      reject(err);
+    });
+  });
+});
+
+ipcMain.handle('stop-share-server', async () => {
+  if (shareServer) {
+    shareServer.close();
+    shareServer = null;
+  }
+  return { success: true };
+});
+
+} // startElectronApp

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "wavesconv",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "CLI: pobieranie YouTube (yt-dlp) i konwersja mediów (ffmpeg) — WavesConverter",
-  "main": "cli.js",
+  "main": "main.js",
   "bin": {
     "wavesconv": "./cli.js"
   },
@@ -16,11 +16,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/idunnowhytf/wavesconvsite.git"
+    "url": "git+https://github.com/idunnowhytf/WavesConverter.git"
   },
-  "homepage": "https://github.com/idunnowhytf/wavesconvsite#readme",
+  "homepage": "https://github.com/idunnowhytf/WavesConverter#readme",
   "bugs": {
-    "url": "https://github.com/idunnowhytf/wavesconvsite/issues"
+    "url": "https://github.com/idunnowhytf/WavesConverter/issues"
   },
   "keywords": [
     "youtube",
@@ -34,6 +34,7 @@
   "author": "WavesConverter",
   "scripts": {
     "start": "electron .",
+    "start:cli": "node cli.js",
     "cli": "node cli.js",
     "prepublishOnly": "node cli.js --version",
     "build": "electron-builder",
@@ -98,12 +99,12 @@
   "license": "ISC",
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "electron-updater": "^6.8.3",
+    "qrcode": "^1.5.4",
     "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"
+    "electron-builder": "^26.8.1"
   }
 }