added debug text

README.md

@@ -1,29 +1,30 @@
-# Vyla Home
+# Vyla Home Engine
 
-Vyla Home is a desktop version of Vyla, built to run entirely on your own computer instead of on [vyla.cc](https://vyla.cc).
+A high-performance, locally executed environment for the Vyla media ecosystem. Built on the Tauri v2 framework, Vyla Home acts as a secure native bridge between local microservices and a lightweight WebView2 rendering engine.
 
-## Why this exists
+## Architecture & Security
 
-Running Vyla as a hosted website has been a constant source of stress. Hosting providers routinely block or throttle traffic coming from data centers, which is exactly where most affordable hosting lives. Every workaround for that involves paid infrastructure — residential proxies, dedicated IPs, premium tiers — that isn't realistic to keep funding long-term.
+Vyla Home is designed around complete local isolation to maximize speed, privacy, and reliability:
 
-On top of that, there's the standing fear that comes with depending on someone else's infrastructure: a provider changes their policy, a server gets flagged, an account gets suspended, and everything just stops working with no warning. That uncertainty has genuinely cost some sleep. Waking up wondering if the whole project got wiped overnight isn't a sustainable way to build something.
+- **Zero External Reverse-Proxies**: All routing, API endpoints, and authentication middleware run strictly on local loopback interfaces (`127.0.0.1`), eliminating ISP throttling and data-center IP bans.
+- **Native Memory Management**: Background Node.js lifecycle states are managed directly via OS-level memory handles (bypassing slow shell wrappers) for instant startup and teardown.
+- **Cryptographic Obfuscation**: Client configurations and credentials are secured on-disk via hardware-derived AES-256-GCM encryption.
+- **Automated Integrity Patching**: Payloads are dynamically verified using SHA-256 checksums and patched in-memory via C-level buffer scans.
 
-Vyla Home is the answer to that. Instead of fighting hosting providers forever, the app runs locally on your own machine. No data center traffic to block. No hosting bills. No one else's finger on the switch.
+## Build Requirements
 
-## What it actually is
+- [Rust](https://www.rust-lang.org/) (Latest Stable)
+- [Node.js](https://nodejs.org/) (v20+ LTS)
+- Tauri CLI (`npm install -g @tauri-apps/cli`)
 
-Vyla Home packages up the same player, streaming, and live-sports features as the website, wrapped in a small desktop app. When you open it:
+## Compilation
 
-- It grabs the latest version automatically
+The build pipeline has been optimized with Fat LTO and aggressive panic aborts to generate the smallest possible binary footprint.
-- It starts everything up locally on your computer
-- The interface opens in its own window, just like the website did
 
-Everything runs for you, on your machine, for your own personal use.
+```bash
+npm install
 
-## What this is not
+npm run build:payload
 
-This isn't a public service or a way to redistribute anything. It's a personal media player for personal use — think of it as watching things you already have access to, through your own local player, instead of a public streaming platform. Nothing here is intended to be shared, resold, or run as a service for other people.
+npm run build
-
+```
-## Status
-
-Might not be actively worked on. Expect various bugs — this is a solo project built to solve a real problem, not a polished commercial product.

build-pipeline.js

@@ -1,7 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const JavaScriptObfuscator = require('javascript-obfuscator');
 const AdmZip = require('adm-zip');
 const { execSync } = require('child_process');
 
@@ -19,20 +18,23 @@ const REPO_CONFIG = {
   'stream-api': { name: 'stream-api', branch: 'main' },
 };
 
+const clonedRepos = new Set();
+
 function clonePrivateRepo(repoConfig, targetDir) {
+  if (fs.existsSync(targetDir)) {
+    console.log(`[DEV] ${repoConfig.name} already exists locally. Skipping clone to use local changes.`);
+    return;
+  }
+
   const token = process.env.GITLAB_TOKEN || process.env.VYLA_GITLAB_TOKEN;
   const auth = token ? `oauth2:${token}@` : '';
   const repoUrl = `https://${auth}gitlab.com/${GITLAB_GROUP}/${repoConfig.name}.git`;
 
   try {
-    if (fs.existsSync(targetDir)) {
-      fs.rmSync(targetDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-    }
-
     execSync(`git clone --depth 1 --branch ${repoConfig.branch} ${repoUrl} ${targetDir}`, {
       stdio: 'inherit'
     });
-
+    clonedRepos.add(repoConfig.name);
   } catch (error) {
     throw new Error(`Failed to clone ${repoConfig.name}: ${error.message}`);
   }
@@ -73,23 +75,6 @@ function cleanBuildDir() {
   fs.mkdirSync(BUILD_DIR, { recursive: true });
 }
 
-function obfuscateFile(filePath, isEsm = false) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  const result = JavaScriptObfuscator.obfuscate(content, {
-    compact: true,
-    controlFlowFlattening: false,
-    deadCodeInjection: false,
-    debugProtection: false,
-    numbersToExpressions: false,
-    simplify: true,
-    stringArray: true,
-    stringArrayThreshold: 0.4,
-    stringArrayEncoding: [],
-    module: isEsm
-  });
-  fs.writeFileSync(filePath, result.getObfuscatedCode(), 'utf8');
-}
-
 function encryptCredentialsFile() {
   const CryptoUtils = require('./crypto-utils');
 
@@ -170,13 +155,6 @@ function processFolder(src, dest) {
       if (pkg.type === 'module') isEsm = true;
     } catch (e) { }
   }
-
-  for (const filePath of jsFiles) {
-    try {
-      obfuscateFile(filePath, isEsm);
-    } catch (e) {
-    }
-  }
 }
 
 function getFileChecksum(filePath) {
@@ -357,9 +335,11 @@ async function build() {
   fs.writeFileSync(path.join(__dirname, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
 
   for (const repo of REPOS) {
-    const repoPath = path.join(__dirname, repo);
+    if (clonedRepos.has(repo)) {
-    if (fs.existsSync(repoPath)) {
+      const repoPath = path.join(__dirname, repo);
-      fs.rmSync(repoPath, { recursive: true, force: true });
+      if (fs.existsSync(repoPath)) {
+        fs.rmSync(repoPath, { recursive: true, force: true });
+      }
     }
   }
 

codemagic.yaml

@@ -0,0 +1,32 @@
+workflows:
+  macos-release:
+    name: Build macOS Release
+    max_build_duration: 60
+    instance_type: mac_mini_m2
+    environment:
+      groups:
+        - gitlab_credentials
+      node: 22.14.0
+    cache:
+      cache_paths:
+        - $HOME/.cargo/registry
+        - $HOME/.cargo/git
+        - src-tauri/target
+    scripts:
+      - name: Setup Rust toolchain
+        script: |
+          if ! command -v cargo &> /dev/null; then
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+          fi
+      - name: Install dependencies
+        script: |
+          export PATH="$HOME/.cargo/bin:$PATH"
+          npm install
+      - name: Build & Publish macOS Release
+        script: |
+          export PATH="$HOME/.cargo/bin:$PATH"
+          PACKAGE_VERSION=$(node -p "require('./package.json').version")
+          node release.js --installer --tag="v$PACKAGE_VERSION"
+    artifacts:
+      - src-tauri/target/release/bundle/dmg/*.dmg
+      - src-tauri/target/release/bundle/macos/*.app

crypto-utils.js

@@ -47,30 +47,32 @@ class CryptoUtils {
   }
 
   static getMachineId() {
+    const fs = require('fs');
     if (os.platform() === 'win32') {
       try {
-        return execSync('wmic csproduct get uuid').toString().split('\n')[1].trim();
+        const { spawnSync } = require('child_process');
-      } catch (e) {
+        const res = spawnSync('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf8' });
-      }
+        if (res.stdout) {
-      try {
+          const match = res.stdout.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/);
-        const out = execSync('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid').toString();
+          if (match) return match[1].trim();
-        const match = out.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/);
+        }
-        if (match) return match[1].trim();
+      } catch (e) { }
-      } catch (e) {
+      return 'windows-node-' + os.hostname();
-      }
-      return 'unknown-machine';
     } else if (os.platform() === 'darwin') {
       try {
-        return execSync('ioreg -rd1 -c IOPlatformExpertDevice | awk -F\'"\' \'/IOPlatformUUID/{print $4}\'').toString().trim();
+        const { spawnSync } = require('child_process');
-      } catch (e) {
+        const res = spawnSync('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], { encoding: 'utf8' });
-        return 'unknown-machine';
+        const match = res.stdout.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
-      }
+        if (match) return match[1].trim();
+      } catch (e) { }
+      return 'darwin-node-' + os.hostname();
     } else {
-      try {
+      for (const idPath of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
-        return execSync('cat /etc/machine-id 2>/dev/null || cat /var/lib/dbus/machine-id 2>/dev/null').toString().trim();
+        try {
-      } catch (e) {
+          if (fs.existsSync(idPath)) return fs.readFileSync(idPath, 'utf8').trim();
-        return 'unknown-machine';
+        } catch (e) { }
       }
+      return 'linux-node-' + os.hostname();
     }
   }
 

main.js

@@ -15,8 +15,9 @@ const LOGS_DIR = path.join(APPDATA_DIR, 'logs');
 try { fs.mkdirSync(LOGS_DIR, { recursive: true }); } catch (e) { }
 
 const debugLogPath = path.join(LOGS_DIR, 'node-debug.log');
+
 function debugLog(msg) {
-  try { fs.appendFileSync(debugLogPath, `[NODE] ${msg}\n`, 'utf8'); } catch (e) { }
+  try { fs.appendFile(debugLogPath, `[NODE] ${msg}\n`, 'utf8', () => { }); } catch (e) { }
 }
 
 debugLog("--- Node.js Process Started ---");
@@ -60,6 +61,9 @@ window.open = function(url) {
 </script></head>`
       );
       res.set('Content-Type', 'text/html');
+      res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      res.set('Expires', '-1');
+      res.set('Pragma', 'no-cache');
       res.send(injected);
     });
   };
@@ -78,13 +82,22 @@ cmdApp.get('/__tauri_cmd/:cmd', (req, res) => {
   sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
   res.sendStatus(200);
 });
-cmdApp.listen(4892, '0.0.0.0', () => debugLog("[CMD-SERVER] Dedicated command server listening on 0.0.0.0:4892"));
+cmdApp.listen(4892, '127.0.0.1', () => debugLog("[CMD-SERVER] Dedicated command server listening on 127.0.0.1:4892"));
+
+process.stdin.resume();
+process.stdin.on('end', () => {
+  debugLog('stdin closed - parent died. Self-terminating...');
+  process.exit(0);
+});
+process.stdin.on('error', () => {
+  process.exit(0);
+});
 
 process.on('uncaughtException', (err) => {
   debugLog(`CRITICAL UNCAUGHT EXCEPTION: ${err.stack || err.message}`);
-  if (err.code === 'EPIPE') {
+  if (err.code === 'EPIPE' || err.code === 'EOF') {
     debugLog('Pipe to parent closed - parent process gone, exiting');
-    process.exit(1);
+    process.exit(0);
   }
   try { sendToTauri('error', { message: err.message }); } catch (e) { }
 });
@@ -95,8 +108,21 @@ process.on('unhandledRejection', (reason) => {
   sendToTauri('error', { message: reason && reason.message ? reason.message : String(reason) });
 });
 
-const envConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config/env.json'), 'utf8'));
+function getEnvConfig() {
-const replacementsConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config/replacements.json'), 'utf8'));
+  try {
+    const appPath = path.join(APPDATA_DIR, 'config/env.json');
+    if (fs.existsSync(appPath)) return JSON.parse(fs.readFileSync(appPath, 'utf8'));
+    return JSON.parse(fs.readFileSync(path.join(__dirname, 'config/env.json'), 'utf8'));
+  } catch (e) { return {}; }
+}
+
+function getReplacementsConfig() {
+  try {
+    const appPath = path.join(APPDATA_DIR, 'config/replacements.json');
+    if (fs.existsSync(appPath)) return JSON.parse(fs.readFileSync(appPath, 'utf8'));
+    return JSON.parse(fs.readFileSync(path.join(__dirname, 'config/replacements.json'), 'utf8'));
+  } catch (e) { return {}; }
+}
 
 const updateClient = new UpdateClient(APPDATA_DIR);
 
@@ -105,10 +131,13 @@ async function start() {
   sendToTauri('status', { message: 'Loading core configuration files...' });
 
   const patcher = new Patcher(APPDATA_DIR);
-  serviceManager = new ServiceManager(APPDATA_DIR, envConfig);
+  serviceManager = new ServiceManager(APPDATA_DIR, getEnvConfig());
 
   const installBuild = async (release) => {
     const tempZipPath = path.join(APPDATA_DIR, 'download-temp.zip');
+    if (fs.existsSync(tempZipPath)) {
+      try { fs.unlinkSync(tempZipPath); } catch (e) { }
+    }
     let attempts = 0;
     let downloadSuccess = false;
 
@@ -118,9 +147,13 @@ async function start() {
         debugLog(`Attempting to download update (Attempt ${attempts})...`);
         sendToTauri('status', { message: `Connecting to download servers (Attempt ${attempts}/3)...` });
 
+        let lastPercent = -1;
         await updateClient.downloadUpdate(release, tempZipPath, (downloaded, total) => {
           const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
-          sendToTauri('download-progress', { downloaded, total, percent });
+          if (percent !== lastPercent) {
+            lastPercent = percent;
+            sendToTauri('download-progress', { downloaded, total, percent });
+          }
         });
 
         debugLog('Download complete. Verifying checksum...');
@@ -141,12 +174,14 @@ async function start() {
 
         debugLog('Extraction complete. Applying patches...');
         sendToTauri('status', { message: 'Applying configuration patches...' });
-        patcher.applyPatches(replacementsConfig);
+        patcher.applyPatches(getReplacementsConfig());
 
         sendToTauri('status', { message: 'Migrating security credentials...' });
         patcher.bridgeCredentials(serviceManager.credentialManager);
         patcher.saveCurrentVersion(release.version, release.sha256);
 
+        serviceManager.envConfig = getEnvConfig();
+
         if (fs.existsSync(tempZipPath)) {
           fs.unlinkSync(tempZipPath);
         }
@@ -168,10 +203,34 @@ async function start() {
 
   try {
     sendToTauri('status', { message: 'Inspecting local workspace and installed files...' });
-    const isFirstRun = !patcher.verifyExtraction();
+    let isFirstRun = !patcher.verifyExtraction();
-    const localVersion = patcher.getCurrentVersion();
+    let localVersion = patcher.getCurrentVersion();
-    const localSha = patcher.getCurrentSha();
+    let localSha = patcher.getCurrentSha();
-    debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}`);
+    debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}, Local SHA: ${localSha}`);
+
+    const localZipPath = path.join(__dirname, 'update-payload.zip');
+    const localManifestPath = path.join(__dirname, 'manifest.json');
+    let localZipManifest = null;
+
+    if (fs.existsSync(localZipPath) && fs.existsSync(localManifestPath)) {
+      try { localZipManifest = JSON.parse(fs.readFileSync(localManifestPath, 'utf8')); } catch (e) { }
+    }
+
+    if (localZipManifest && (isFirstRun || localZipManifest.sha256 !== localSha)) {
+      debugLog("New local payload detected! Applying local build...");
+      sendToTauri('status', { message: 'Extracting local development payload...' });
+      patcher.purgeOldCode();
+      patcher.extractZipPayload(localZipPath);
+      patcher.applyPatches(getReplacementsConfig());
+      patcher.bridgeCredentials(serviceManager.credentialManager);
+      patcher.saveCurrentVersion(localZipManifest.version, localZipManifest.sha256);
+      serviceManager.envConfig = getEnvConfig();
+
+      isFirstRun = false;
+      localVersion = localZipManifest.version;
+      localSha = localZipManifest.sha256;
+      debugLog("Local payload applied successfully.");
+    }
 
     sendToTauri('status', { message: 'Connecting to update servers...' });
     let release = null;
@@ -216,7 +275,7 @@ async function start() {
         sendToTauri('update-available', { current: localVersion, latest: release.version });
 
         while (userDecision === null) {
-          await new Promise(r => setTimeout(r, 200));
+          await new Promise(r => setTimeout(r, 25));
         }
 
         await new Promise((resolve) => tempServer.close(resolve));
@@ -240,9 +299,17 @@ async function start() {
         sendToTauri('status', { message: 'Extracting local baseline payload...' });
         patcher.purgeOldCode();
         patcher.extractZipPayload(localZip);
-        patcher.applyPatches(replacementsConfig);
+        patcher.applyPatches(getReplacementsConfig());
         patcher.bridgeCredentials(serviceManager.credentialManager);
-        patcher.saveCurrentVersion("1.0.0");
+
+        let ver = "1.0.0";
+        try {
+          const man = JSON.parse(fs.readFileSync(path.join(__dirname, 'manifest.json'), 'utf8'));
+          ver = man.version || ver;
+        } catch (e) { }
+
+        patcher.saveCurrentVersion(ver);
+        serviceManager.envConfig = getEnvConfig();
         debugLog("Local payload extracted successfully.");
       } else {
         debugLog("No local payload found!");
@@ -257,18 +324,6 @@ async function start() {
     sendToTauri('status', { message: 'Loading encrypted credentials...' });
     serviceManager.credentialManager.loadCredentials();
 
-    sendToTauri('status', { message: 'Checking SDK dependencies...' });
-    try {
-      require('child_process').execSync('npm install @vyla-entertainment/sdk@latest --no-save --no-audit --no-fund', {
-        cwd: APPDATA_DIR,
-        stdio: 'ignore',
-        windowsHide: true
-      });
-      debugLog("Vyla SDK updated to latest successfully.");
-    } catch (e) {
-      debugLog(`Failed to install Vyla SDK: ${e.message}`);
-    }
-
     sendToTauri('status', { message: 'Starting background services (auth-proxy, stream-api)...' });
     await serviceManager.startServices([
       { name: 'auth-proxy', relativeDir: 'auth-proxy' },
@@ -292,9 +347,17 @@ async function start() {
       res.sendStatus(200);
     });
     playerExpressApp.use(sameTabNavMiddleware(playerDir));
-    playerExpressApp.use(express.static(playerDir, { maxAge: '1d', etag: true }));
+    playerExpressApp.use(express.static(playerDir, {
-    playerExpressApp.get('*', (req, res) => { res.sendFile(path.join(playerDir, 'index.html')); });
+      etag: false,
-    playerExpressServer = playerExpressApp.listen(3001, '0.0.0.0');
+      setHeaders: (res) => {
+        res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      }
+    }));
+    playerExpressApp.get('*', (req, res) => {
+      res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      res.sendFile(path.join(playerDir, 'index.html'));
+    });
+    playerExpressServer = playerExpressApp.listen(3001, '127.0.0.1');
     debugLog("Player Express running on 3001");
 
     sendToTauri('status', { message: 'Waiting for microservices to bind ports (3000, 3001, 7860)...' });
@@ -316,17 +379,26 @@ async function start() {
       sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
       res.sendStatus(200);
     });
+
     expressApp.use(sameTabNavMiddleware(frontendDir));
-    expressApp.use(express.static(frontendDir, { maxAge: '1d', etag: true }));
+    expressApp.use(express.static(frontendDir, {
-    expressApp.get('*', (req, res) => { res.sendFile(path.join(frontendDir, 'index.html')); });
+      etag: false,
+      setHeaders: (res) => {
+        res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      }
+    }));
+    expressApp.get('*', (req, res) => {
+      res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      res.sendFile(path.join(frontendDir, 'index.html'));
+    });
 
     const FRONTEND_PORT = 4890;
     expressApp.use('/build', express.static(path.join(__dirname, 'build')));
     if (playerExpressApp) {
       playerExpressApp.use('/build', express.static(path.join(__dirname, 'build')));
     }
-    
+
-    expressServer = expressApp.listen(FRONTEND_PORT, '0.0.0.0', () => {
+    expressServer = expressApp.listen(FRONTEND_PORT, '127.0.0.1', () => {
       sendToTauri('status', { message: 'All backend services running and healthy.' });
       debugLog("Frontend Express running on 4890. Sending READY to Tauri.");
       sendToTauri('ready', { url: `http://localhost:${FRONTEND_PORT}` });
@@ -342,17 +414,23 @@ process.on('exit', () => {
   if (serviceManager) {
     for (const name of Object.keys(serviceManager.processes)) {
       const proc = serviceManager.processes[name];
-      if (proc && proc.child) {
+      if (proc && proc.child && proc.child.pid) {
-        try { proc.child.kill('SIGKILL'); } catch (e) { }
+        try {
+          if (process.platform === 'win32') {
+            require('child_process').spawnSync('taskkill', ['/F', '/T', '/PID', proc.child.pid.toString()], { stdio: 'ignore', windowsHide: true });
+          } else {
+            process.kill(-proc.child.pid, 'SIGKILL');
+          }
+        } catch (e) { }
       }
     }
   }
 });
 
-process.on('SIGINT', async () => {
+process.on('SIGINT', () => {
-  if (expressServer) expressServer.close();
+  process.exit(0);
-  if (playerExpressServer) playerExpressServer.close();
+});
-  if (serviceManager) await serviceManager.stopAll();
+process.on('SIGTERM', () => {
   process.exit(0);
 });
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyla-home",
-  "version": "1.1.6",
+  "version": "1.1.13",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -12,15 +12,15 @@
   },
   "dependencies": {
     "@tauri-apps/api": "^2.0.0",
-    "@tauri-apps/plugin-shell": "^2.0.0",
+    "@tauri-apps/plugin-opener": "^2.0.0",
     "@tauri-apps/plugin-process": "^2.0.0",
+    "@tauri-apps/plugin-shell": "^2.0.0",
     "@vyla-entertainment/sdk": "^1.11.0",
     "adm-zip": "^0.6.0",
     "express": "^4.19.2"
   },
   "devDependencies": {
-    "@tauri-apps/cli": "^2.0.0",
+    "@tauri-apps/cli": "^2.0.0"
-    "javascript-obfuscator": "^4.1.0"
   },
   "build": {
     "appId": "com.vyla.home",
@@ -54,4 +54,4 @@
       "installerHeaderIcon": "build/icon.ico"
     }
   }
-}
+}

patcher.js

@@ -63,17 +63,24 @@ class Patcher {
       const fullPath = path.join(this.appDataPath, dir);
       if (fs.existsSync(fullPath)) {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true });
+          const trashPath = path.join(this.appDataPath, `.trash_${dir}_${Date.now()}`);
+          fs.renameSync(fullPath, trashPath);
+          fs.rmSync(trashPath, { recursive: true, force: true });
         } catch (e) {
           try {
-            const trashPath = fullPath + '.trash.' + Date.now();
+            fs.rmSync(fullPath, { recursive: true, force: true });
-            fs.renameSync(fullPath, trashPath);
+          } catch (err2) { }
-          } catch (renameErr) {
-            console.warn(`Could not remove or rename ${fullPath}. It will be overwritten.`);
-          }
         }
       }
     }
+    try {
+      const files = fs.readdirSync(this.appDataPath);
+      for (const file of files) {
+        if (file.startsWith('.trash_')) {
+          fs.rmSync(path.join(this.appDataPath, file), { recursive: true, force: true });
+        }
+      }
+    } catch (e) { }
   }
 
   extractZipPayload(zipPath) {
@@ -119,7 +126,7 @@ class Patcher {
     return true;
   }
 
-  processDirectory(dir, replacementList) {
+  processDirectory(dir, replacementList = []) {
     const files = fs.readdirSync(dir);
     for (const file of files) {
       const fullPath = path.join(dir, file);
@@ -130,33 +137,30 @@ class Patcher {
         this.processDirectory(fullPath, replacementList);
       } else if (stat.isFile()) {
         const ext = path.extname(fullPath).toLowerCase();
-        if (['.js', '.html', '.css', '.json', '.xml', '.txt'].includes(ext)) {
+        let content = fs.readFileSync(fullPath, 'utf8');
-          let content = fs.readFileSync(fullPath, 'utf8');
+        let modified = false;
-          let modified = false;
 
-          for (const rep of replacementList) {
+        for (const rep of replacementList) {
-            if (content.includes(rep.find)) {
+          if (content.includes(rep.find)) {
-              content = content.split(rep.find).join(rep.replace);
+            content = content.split(rep.find).join(rep.replace);
-              modified = true;
+            modified = true;
-            }
           }
+        }
 
-          if (modified) {
+        if (modified) {
-            fs.writeFileSync(fullPath, content, 'utf8');
+          fs.writeFileSync(fullPath, content, 'utf8');
-          }
         }
       }
     }
   }
 
   applyPatches(replacements) {
-    for (const [componentName, replacementList] of Object.entries(replacements)) {
+    const targetDirs = ['frontend', 'player', 'auth-proxy', 'stream-api'];
-      if (!replacementList || replacementList.length === 0) continue;
+    for (const dirName of targetDirs) {
-
+      const dirPath = path.join(this.appDataPath, dirName);
-      const componentDir = path.join(this.appDataPath, componentName);
+      if (!fs.existsSync(dirPath)) continue;
-      if (!fs.existsSync(componentDir)) continue;
+      const replacementList = replacements[dirName] || [];
-
+      this.processDirectory(dirPath, replacementList);
-      this.processDirectory(componentDir, replacementList);
     }
   }
 }

release.js

@@ -78,12 +78,12 @@ function uploadFileToGitLabPackage(filePath, packageName, version, fileName) {
 }
 
 function createGitLabRelease(tag, releaseLinks) {
-    const sendRequest = (method, path, data = null) => {
+    const sendRequest = (method, reqPath, data = null) => {
         return new Promise((resolve, reject) => {
             const options = {
                 hostname: 'gitlab.com',
                 port: 443,
-                path: path,
+                path: reqPath,
                 method: method,
                 headers: {
                     'PRIVATE-TOKEN': TOKEN,
@@ -101,19 +101,9 @@ function createGitLabRelease(tag, releaseLinks) {
                 res.on('data', chunk => body += chunk);
                 res.on('end', () => {
                     if (res.statusCode >= 200 && res.statusCode < 300) {
-                        try {
+                        try { resolve(body ? JSON.parse(body) : {}); } catch (e) { resolve({}); }
-                            resolve(body ? JSON.parse(body) : {});
-                        } catch (e) {
-                            resolve({});
-                        }
-                    } else if (res.statusCode === 409 && method === 'POST') {
-                        console.log(`Release ${tag} already exists, deleting and recreating...`);
-                        sendRequest('DELETE', `/api/v4/projects/${PROJECT_ID}/releases/${encodeURIComponent(tag)}`)
-                            .then(() => sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`, data))
-                            .then(resolve)
-                            .catch(reject);
                     } else {
-                        reject(new Error(`Failed to publish release (HTTP ${res.statusCode}): ${body}`));
+                        reject(new Error(`HTTP ${res.statusCode}: ${body}`));
                     }
                 });
             });
@@ -133,13 +123,37 @@ function createGitLabRelease(tag, releaseLinks) {
         name: `Vyla Home Release ${tag}`,
         tag_name: tag,
         ref: currentRef,
-        description: `Automated local release ${tag}`,
+        description: `Automated Multi-Platform Release ${tag}`,
         assets: {
             links: releaseLinks
         }
     };
 
-    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`, releaseData);
+    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`, releaseData)
+        .catch(err => {
+            if (err.message.includes('HTTP 409')) {
+                console.log(`[CI Sync] Release ${tag} already exists. Appending our OS-specific files to it...`);
+                let promiseChain = Promise.resolve();
+
+                for (const link of releaseLinks) {
+                    promiseChain = promiseChain.then(() => {
+                        return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases/${encodeURIComponent(tag)}/assets/links`, {
+                            name: link.name,
+                            url: link.url,
+                            link_type: link.link_type
+                        }).catch(e => {
+                            if (e.message.includes('already been taken') || e.message.includes('HTTP 409') || e.message.includes('HTTP 400')) {
+                                console.log(`[CI Sync] Asset link '${link.name}' is already attached. Skipping.`);
+                                return Promise.resolve();
+                            }
+                            throw e;
+                        });
+                    });
+                }
+                return promiseChain.then(() => ({ name: `Vyla Home Release ${tag}`, tag_name: tag }));
+            }
+            throw err;
+        });
 }
 
 async function main() {
@@ -166,7 +180,6 @@ async function main() {
     if (isFullBuild) {
         console.log('Ensuring bundled Node.js runtime...');
         await ensureBundledNode();
-
         await ensureWebView2Loader();
 
         const bundleDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle');
@@ -174,20 +187,32 @@ async function main() {
             fs.rmSync(bundleDir, { recursive: true, force: true });
         }
 
-        console.log('Compiling Windows Tauri installer locally...');
+        console.log('Compiling native Tauri application...');
-        execSync('npm run build', {
+        execSync('npm run build', { stdio: 'inherit' });
-            stdio: 'inherit'
-        });
 
-        const nsisDir = path.join(__dirname, 'src-tauri/target/release/bundle/nsis');
+        const targetVersion = version.startsWith('v') ? version.substring(1) : version;
-        if (fs.existsSync(nsisDir)) {
-            const targetVersion = version.startsWith('v') ? version.substring(1) : version;
-            const files = fs.readdirSync(nsisDir).filter(f => f.endsWith('.exe') && f.includes(targetVersion));
 
-            if (files.length > 0) {
+        if (process.platform === 'win32') {
-                const originalName = files[0];
+            const nsisDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle', 'nsis');
-                installerPath = path.join(nsisDir, originalName);
+            if (fs.existsSync(nsisDir)) {
-                installerUploadName = originalName.replace(/\s+/g, '-');
+                const files = fs.readdirSync(nsisDir).filter(f => f.endsWith('.exe') && f.includes(targetVersion));
+                if (files.length > 0) {
+                    installerPath = path.join(nsisDir, files[0]);
+                    installerUploadName = files[0].replace(/\s+/g, '-');
+                }
+            }
+        } else {
+            const dmgDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle', 'dmg');
+            console.log(`Checking for Mac installer in: ${dmgDir}`);
+            if (fs.existsSync(dmgDir)) {
+                const files = fs.readdirSync(dmgDir).filter(f => f.endsWith('.dmg') && f.includes(targetVersion));
+                if (files.length > 0) {
+                    installerPath = path.join(dmgDir, files[0]);
+                    installerUploadName = files[0].replace(/\s+/g, '-');
+                    console.log(`Found Mac installer: ${installerUploadName}`);
+                } else {
+                    console.log(`[WARNING] No .dmg found containing version ${targetVersion}`);
+                }
             }
         }
     }
@@ -208,19 +233,25 @@ async function main() {
 
     if (installerPath && installerUploadName) {
         console.log(`Uploading installer ${installerUploadName}...`);
-        const installerUnique = installerUploadName.replace('.exe', `-${timestamp}.exe`);
+        const ext = path.extname(installerUploadName);
+        const installerUnique = installerUploadName.replace(ext, `-${timestamp}${ext}`);
         const installerUrl = await uploadFileToGitLabPackage(installerPath, 'vyla-home', version, installerUnique);
         releaseLinks.push({ name: installerUploadName, url: installerUrl, link_type: 'package' });
+    } else {
+        console.log(`[WARNING] No installer was selected for upload! (isFullBuild: ${isFullBuild})`);
     }
 
     console.log('[3/4] Publishing GitLab Release...');
-    const release = await createGitLabRelease(version, releaseLinks);
+    await createGitLabRelease(version, releaseLinks);
-    console.log(`[4/4] Release successfully created: ${release.name} (${release.tag_name})`);
+    console.log(`[4/4] Release process successfully completed for ${version}!`);
 }
 
 function ensureBundledNode() {
+    const os = require('os');
     const binDir = path.join(__dirname, 'bin');
-    const nodeExePath = path.join(binDir, 'node.exe');
+    const isWin = os.platform() === 'win32';
+    const nodeExeName = isWin ? 'node.exe' : 'node';
+    const nodeExePath = path.join(binDir, nodeExeName);
 
     const nodeVersion = 'v22.14.0';
     const versionMarker = path.join(binDir, `node-${nodeVersion}.marker`);
@@ -232,35 +263,58 @@ function ensureBundledNode() {
     fs.mkdirSync(binDir, { recursive: true });
     console.log(`Downloading standalone Node.js ${nodeVersion} runtime for bundling...`);
 
-    const nodeUrl = `https://nodejs.org/dist/${nodeVersion}/win-x64/node.exe`;
     return new Promise((resolve, reject) => {
-        const fileStream = fs.createWriteStream(nodeExePath);
+        const download = (url, dest, cb) => {
-        https.get(nodeUrl, (res) => {
+            https.get(url, (res) => {
-            if (res.statusCode === 302 || res.statusCode === 301) {
+                if (res.statusCode === 302 || res.statusCode === 301) {
-                https.get(res.headers.location, (redirectRes) => {
+                    return download(res.headers.location, dest, cb);
-                    redirectRes.pipe(fileStream);
+                }
-                    fileStream.on('finish', () => {
+                const fileStream = fs.createWriteStream(dest);
-                        fileStream.close();
+                res.pipe(fileStream);
-                        fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
+                fileStream.on('finish', () => {
-                        resolve();
+                    fileStream.close();
-                    });
+                    cb();
-                }).on('error', reject);
+                });
-                return;
+            }).on('error', reject);
-            }
+        };
-            res.pipe(fileStream);
+
-            fileStream.on('finish', () => {
+        if (isWin) {
-                fileStream.close();
+            const nodeUrl = `https://nodejs.org/dist/${nodeVersion}/win-x64/node.exe`;
+            download(nodeUrl, nodeExePath, () => {
                 fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
                 resolve();
             });
-        }).on('error', (err) => {
+        } else {
-            try { fs.unlinkSync(nodeExePath); } catch (e) { }
+            const arch = os.arch() === 'arm64' ? 'arm64' : 'x64';
-            reject(err);
+            const platform = os.platform() === 'darwin' ? 'darwin' : 'linux';
-        });
+            const tarName = `node-${nodeVersion}-${platform}-${arch}`;
+            const nodeUrl = `https://nodejs.org/dist/${nodeVersion}/${tarName}.tar.gz`;
+            const tarPath = path.join(binDir, 'node.tar.gz');
+
+            download(nodeUrl, tarPath, () => {
+                try {
+                    execSync(`tar -xzf node.tar.gz ${tarName}/bin/node`, { cwd: binDir });
+
+                    fs.renameSync(path.join(binDir, tarName, 'bin', 'node'), path.join(binDir, 'node'));
+                    fs.rmSync(path.join(binDir, tarName), { recursive: true, force: true });
+                    fs.unlinkSync(tarPath);
+
+                    execSync(`chmod +x node`, { cwd: binDir });
+
+                    fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
+                    resolve();
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        }
     });
 }
 
 function ensureWebView2Loader() {
+    const os = require('os');
+    if (os.platform() !== 'win32') return Promise.resolve();
+
     const releaseDir = path.join(__dirname, 'src-tauri', 'target', 'release');
     const rootDllPath = path.join(__dirname, 'src-tauri', 'WebView2Loader.dll');
     fs.mkdirSync(releaseDir, { recursive: true });

service-manager.js

@@ -21,8 +21,7 @@ class ServiceManager {
     try {
       const logPath = path.join(this.logsDir, `${name}.log`);
       const timestamp = new Date().toISOString();
-      fs.appendFileSync(logPath, `[${timestamp}] ${line}\n`, 'utf8');
+      fs.appendFile(logPath, `[${timestamp}] ${line}\n`, 'utf8', () => { });
-
       process.stdout.write(JSON.stringify({ event: "service-log", data: { service: name, message: line } }) + '\n');
     } catch (e) {
     }
@@ -97,9 +96,14 @@ class ServiceManager {
         if (port) {
           try {
             if (process.platform === 'win32') {
-              require('child_process').execSync(`powershell -Command "Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force }"`, { stdio: 'ignore' });
+              require('child_process').spawnSync('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force }`
+              ], { stdio: 'ignore', windowsHide: true });
             } else {
-              require('child_process').execSync(`fuser -k -9 ${port}/tcp`, { stdio: 'ignore' });
+              require('child_process').spawnSync('fuser', ['-k', '-9', `${port}/tcp`], { stdio: 'ignore' });
             }
           } catch (_) { }
         }
@@ -189,7 +193,7 @@ class ServiceManager {
       });
 
       if (connected) return true;
-      await new Promise(r => setTimeout(r, 500));
+      await new Promise(r => setTimeout(r, 40));
     }
     throw new Error(`Timeout waiting for port ${port}`);
   }

src-tauri/Cargo.lock

@@ -4222,7 +4222,7 @@ dependencies = [
 
 [[package]]
 name = "vyla-home"
-version = "1.1.6"
+version = "1.1.13"
 dependencies = [
  "base64 0.22.1",
  "serde",
@@ -4232,7 +4232,6 @@ dependencies = [
  "tauri-plugin-opener",
  "tauri-plugin-process",
  "tauri-plugin-shell",
- "url",
 ]
 
 [[package]]

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.1.6"
+version = "1.1.13"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -14,5 +14,16 @@ tauri-plugin-process = "2"
 tauri-plugin-shell = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-url = "2"
 base64 = "0.22"
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+strip = true
+panic = "abort"
+
+[profile.dev]
+opt-level = 0
+debug = true
+incremental = true

src-tauri/build.rs

@@ -1,3 +1,20 @@
 fn main() {
+    println!("cargo:rerun-if-changed=src/main.rs");
+    println!("cargo:rerun-if-changed=tauri.conf.json");
+    
+    if std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default() == "windows" {
+        if let (Ok(manifest_dir), Ok(out_dir)) = (std::env::var("CARGO_MANIFEST_DIR"), std::env::var("OUT_DIR")) {
+            let mut target_dir = std::path::PathBuf::from(out_dir);
+            target_dir.pop();
+            target_dir.pop();
+            target_dir.pop();
+            let dll_src = std::path::Path::new(&manifest_dir).join("WebView2Loader.dll");
+            let dll_dest = target_dir.join("WebView2Loader.dll");
+            if dll_src.exists() {
+                let _ = std::fs::copy(dll_src, dll_dest);
+            }
+        }
+    }
+    
     tauri_build::build();
 }

src-tauri/src/main.rs

@@ -7,26 +7,19 @@ use tauri::{Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder};
 
 fn debug_log(msg: &str) {
     let log_dir = if let Ok(app_data) = std::env::var("APPDATA") {
-        std::path::PathBuf::from(app_data)
+        std::path::PathBuf::from(app_data).join("vyla-home").join("vyla-home-files").join("logs")
-            .join("vyla-home")
+    } else if let Ok(home) = std::env::var("HOME") {
-            .join("vyla-home-files")
+        std::path::PathBuf::from(home).join("Library").join("Logs").join("VylaHome")
-            .join("logs")
     } else if let Ok(user_profile) = std::env::var("USERPROFILE") {
-        std::path::PathBuf::from(user_profile)
+        std::path::PathBuf::from(user_profile).join(".vyla-home").join("logs")
-            .join(".vyla-home")
-            .join("logs")
     } else {
-        std::path::PathBuf::from("logs")
+        std::env::temp_dir().join("vyla-home-logs")
     };
 
     let _ = std::fs::create_dir_all(&log_dir);
     let log_path = log_dir.join("rust-debug.log");
 
-    if let Ok(mut file) = std::fs::OpenOptions::new()
+    if let Ok(mut file) = std::fs::OpenOptions::new().create(true).append(true).open(&log_path) {
-        .create(true)
-        .append(true)
-        .open(&log_path)
-    {
         use std::io::Write;
         let _ = writeln!(file, "[RUST] {}", msg);
     }
@@ -49,75 +42,18 @@ fn clean_path(path: &std::path::Path) -> String {
     }
 }
 
-#[cfg(windows)]
+fn kill_child_process(child: &mut Child) {
-fn kill_processes_on_ports(ports: &[u16]) {
+    #[cfg(windows)]
-    use std::os::windows::process::CommandExt;
+    {
-    const CREATE_NO_WINDOW: u32 = 0x08000000;
+        use std::os::windows::process::CommandExt;
-
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
-    let output = Command::new("netstat")
+        let _ = Command::new("taskkill")
-        .args(["-ano", "-p", "tcp"])
+            .args(&["/F", "/T", "/PID", &child.id().to_string()])
-        .creation_flags(CREATE_NO_WINDOW)
+            .creation_flags(CREATE_NO_WINDOW)
-        .output();
-
-    if let Ok(out) = output {
-        let text = String::from_utf8_lossy(&out.stdout);
-        for line in text.lines() {
-            for port in ports {
-                let pattern = format!(":{}", port);
-                if line.contains(&pattern) && line.contains("LISTENING") {
-                    if let Some(pid_str) = line.split_whitespace().last() {
-                        if let Ok(pid) = pid_str.parse::<u32>() {
-                            if pid > 0 && pid != std::process::id() {
-                                let _ = Command::new("taskkill")
-                                    .args(["/PID", &pid.to_string(), "/T", "/F"])
-                                    .creation_flags(CREATE_NO_WINDOW)
-                                    .output();
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[cfg(not(windows))]
-fn kill_processes_on_ports(ports: &[u16]) {
-    for port in ports {
-        let _ = Command::new("sh")
-            .arg("-c")
-            .arg(format!(
-                "fuser -k -9 {}/tcp 2>/dev/null || lsof -ti :{} | xargs -r kill -9",
-                port, port
-            ))
             .output();
     }
-}
+    let _ = child.kill();
-
+    let _ = child.wait();
-#[cfg(windows)]
-fn kill_process_tree(pid: u32) {
-    use std::os::windows::process::CommandExt;
-    const CREATE_NO_WINDOW: u32 = 0x08000000;
-    let _ = Command::new("taskkill")
-        .args(["/PID", &pid.to_string(), "/T", "/F"])
-        .creation_flags(CREATE_NO_WINDOW)
-        .output();
-    kill_processes_on_ports(&[3000, 3001, 4890, 4891, 4892, 7860]);
-}
-
-#[cfg(not(windows))]
-fn kill_process_tree(pid: u32) {
-    unsafe {
-        libc_kill_pgid(pid);
-    }
-    kill_processes_on_ports(&[3000, 3001, 4890, 4891, 4892, 7860]);
-}
-
-#[cfg(not(windows))]
-unsafe fn libc_kill_pgid(pid: u32) {
-    let _ = Command::new("kill")
-        .args(["-9", &format!("-{}", pid)])
-        .output();
 }
 
 fn find_node_binary(app: &tauri::App) -> Option<String> {
@@ -262,17 +198,6 @@ const LINK_HANDLER_SCRIPT: &str = r##"
 
         const style = document.createElement('style');
         style.innerHTML = `
-            #vyla-nav-filter-svg {
-                position: fixed !important;
-                top: 0 !important;
-                left: 0 !important;
-                width: 0 !important;
-                height: 0 !important;
-                pointer-events: none !important;
-                opacity: 0 !important;
-                z-index: -1 !important;
-            }
-
             #vyla-floating-nav {
                 position: fixed !important;
                 top: 12px !important;
@@ -284,7 +209,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 display: flex !important;
                 align-items: center !important;
                 background: rgba(255, 255, 255, 0.04) !important;
-                backdrop-filter: url(#vyla-glass-filter) blur(16px) saturate(1.8) contrast(1.1) !important;
+                backdrop-filter: blur(16px) saturate(1.8) contrast(1.1) !important;
                 -webkit-backdrop-filter: blur(16px) saturate(1.8) contrast(1.1) !important;
                 box-shadow: 0 8px 32px rgba(0, 0, 0, 0.45) !important;
                 transition: width 0.3s cubic-bezier(0.16, 1, 0.3, 1), padding 0.3s cubic-bezier(0.16, 1, 0.3, 1) !important;
@@ -364,7 +289,6 @@ const LINK_HANDLER_SCRIPT: &str = r##"
             }
 
             .vyla-nav-btn:hover {
-                transform: scale(1.15) !important;
                 opacity: 1 !important;
             }
 
@@ -432,26 +356,6 @@ const LINK_HANDLER_SCRIPT: &str = r##"
         `;
         document.head.appendChild(style);
 
-        const filterSvg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-        filterSvg.id = 'vyla-nav-filter-svg';
-        filterSvg.innerHTML = `
-            <defs>
-                <filter id="vyla-glass-filter" color-interpolation-filters="sRGB" x="0%" y="0%" width="100%" height="100%">
-                    <feImage id="vyla-nav-fe-img" x="0" y="0" width="100%" height="100%" preserveAspectRatio="none" result="map" />
-                    <feDisplacementMap id="vyla-nav-red" in="SourceGraphic" in2="map" result="dispRed" />
-                    <feColorMatrix in="dispRed" type="matrix" values="1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0" result="red" />
-                    <feDisplacementMap id="vyla-nav-green" in="SourceGraphic" in2="map" result="dispGreen" />
-                    <feColorMatrix in="dispGreen" type="matrix" values="0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0" result="green" />
-                    <feDisplacementMap id="vyla-nav-blue" in="SourceGraphic" in2="map" result="dispBlue" />
-                    <feColorMatrix in="dispBlue" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0" result="blue" />
-                    <feBlend in="red" in2="green" mode="screen" result="rg" />
-                    <feBlend in="rg" in2="blue" mode="screen" result="output" />
-                    <feGaussianBlur in="output" stdDeviation="0.8" />
-                </filter>
-            </defs>
-        `;
-        document.body.appendChild(filterSvg);
-
         const nav = document.createElement('div');
         nav.id = 'vyla-floating-nav';
         nav.innerHTML = `
@@ -484,54 +388,6 @@ const LINK_HANDLER_SCRIPT: &str = r##"
             };
         }
 
-        const feImage = document.getElementById('vyla-nav-fe-img');
-        const redChannel = document.getElementById('vyla-nav-red');
-        const greenChannel = document.getElementById('vyla-nav-green');
-        const blueChannel = document.getElementById('vyla-nav-blue');
-
-        function generateNavMap() {
-            const rect = nav.getBoundingClientRect();
-            const w = Math.round(rect.width) || 42;
-            const h = Math.round(rect.height) || 42;
-            const edgeSize = Math.min(w, h) * 0.08;
-            const svgContent = `
-                <svg viewBox="0 0 ${w} ${h}" xmlns="http://www.w3.org/2000/svg">
-                    <defs>
-                        <linearGradient id="vyla-nav-red-g" x1="100%" y1="0%" x2="0%" y2="0%">
-                            <stop offset="0%" stop-color="#000000" stop-opacity="0"/>
-                            <stop offset="100%" stop-color="red"/>
-                        </linearGradient>
-                        <linearGradient id="vyla-nav-blue-g" x1="0%" y1="0%" x2="0%" y2="100%">
-                            <stop offset="0%" stop-color="#000000" stop-opacity="0"/>
-                            <stop offset="100%" stop-color="blue"/>
-                        </linearGradient>
-                    </defs>
-                    <rect width="${w}" height="${h}" fill="black"/>
-                    <rect width="${w}" height="${h}" rx="9999" fill="url(#vyla-nav-red-g)"/>
-                    <rect width="${w}" height="${h}" rx="9999" fill="url(#vyla-nav-blue-g)" style="mix-blend-mode: screen;"/>
-                    <rect x="${edgeSize}" y="${edgeSize}" width="${w - edgeSize * 2}" height="${h - edgeSize * 2}" rx="9999" fill="rgba(255,255,255,0.4)" style="filter: blur(4px);"/>
-                </svg>
-            `;
-            return "data:image/svg+xml," + encodeURIComponent(svgContent);
-        }
-
-        function updateNavGlass() {
-            if (!feImage) return;
-            feImage.setAttribute("href", generateNavMap());
-            const distortionScale = -180;
-            redChannel.setAttribute("scale", distortionScale - 10);
-            greenChannel.setAttribute("scale", distortionScale);
-            blueChannel.setAttribute("scale", distortionScale + 10);
-            [redChannel, greenChannel, blueChannel].forEach((ch) => {
-                ch.setAttribute("xChannelSelector", "R");
-                ch.setAttribute("yChannelSelector", "G");
-            });
-        }
-
-        updateNavGlass();
-        const obs = new ResizeObserver(() => setTimeout(updateNavGlass, 0));
-        obs.observe(nav);
-
         const tb = document.createElement('div');
         tb.id = 'tauri-custom-titlebar';
         tb.innerHTML = `
@@ -562,12 +418,17 @@ const LINK_HANDLER_SCRIPT: &str = r##"
         }
     }
 
-    if (document.readyState === 'loading') {
+  if (document.readyState === 'loading') {
         document.addEventListener('DOMContentLoaded', injectLiquidNavBar);
     } else {
         injectLiquidNavBar();
     }
-    setInterval(injectLiquidNavBar, 1000);
+    const navObserver = new MutationObserver(() => {
+        if (!document.getElementById('vyla-floating-nav')) {
+            injectLiquidNavBar();
+        }
+    });
+    navObserver.observe(document.documentElement, { childList: true, subtree: true });
 "##;
 
 #[tauri::command]
@@ -623,6 +484,30 @@ fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
     }
 }
 
+#[tauri::command]
+async fn kill_orphans() -> Result<(), String> {
+    debug_log("[KILL] User requested orphan process kill");
+
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        let _ = std::process::Command::new("taskkill")
+            .args(&["/F", "/T", "/IM", "node.exe"])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+    }
+
+    #[cfg(not(windows))]
+    {
+        let _ = std::process::Command::new("pkill")
+            .args(&["-9", "-f", "node"])
+            .output();
+    }
+    
+    Ok(())
+}
+
 #[tauri::command]
 fn get_logo_base64(app: tauri::AppHandle) -> Result<String, String> {
     use std::io::Read;
@@ -669,22 +554,56 @@ fn main() {
             win_close,
             win_drag,
             open_new_window,
-            get_logo_base64
+            get_logo_base64,
+            kill_orphans
         ])
         .manage(NodeServices(Mutex::new(None)))
         .setup(|app| {
             debug_log("Tauri setup started");
-            kill_processes_on_ports(&[3000, 3001, 4890, 4891, 4892, 7860]);
             let app_data = app.path().app_data_dir().unwrap_or_default();
             let app_data_str = clean_path(&app_data);
 
+            let vyla_files = if let Ok(appdata_env) = std::env::var("APPDATA") {
+                std::path::PathBuf::from(appdata_env).join("vyla-home").join("vyla-home-files")
+            } else {
+                app_data.join("vyla-home-files")
+            };
+
+            let version_file = vyla_files.join("version.json");
+            let current_app_version = app.package_info().version.to_string();
+            let mut version_mismatch = false;
+
+            if version_file.exists() {
+                if let Ok(content) = std::fs::read_to_string(&version_file) {
+                    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
+                        if let Some(version) = json.get("version").and_then(|v| v.as_str()) {
+                            if version != current_app_version {
+                                version_mismatch = true;
+                            }
+                        } else {
+                            version_mismatch = true;
+                        }
+                    } else {
+                        version_mismatch = true;
+                    }
+                }
+            }
+
+            if version_mismatch {
+                debug_log(&format!("App version updated to {}. Cleaning old files.", current_app_version));
+                let dirs_to_remove = ["frontend", "player", "stream-api", "auth-proxy", "config"];
+                for d in dirs_to_remove {
+                    let _ = std::fs::remove_dir_all(vyla_files.join(d));
+                }
+                let _ = std::fs::remove_file(&version_file);
+            }
+
             let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
                 .title("Vyla Home")
                 .inner_size(1280.0, 800.0)
                 .decorations(false)
-                .transparent(true)
                 .resizable(true)
-                .devtools(true)
+                .devtools(cfg!(debug_assertions))
                 .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
                 .initialization_script(LINK_HANDLER_SCRIPT)
                 .build()?;
@@ -708,6 +627,7 @@ fn main() {
                 .current_dir(&root_dir)
                 .env("APPDATA_PATH", &app_data_str)
                 .env("NODE_EXE", &node_bin)
+                .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
 
@@ -725,11 +645,15 @@ fn main() {
                         child.id()
                     ));
                     if let Some(stderr) = child.stderr.take() {
+                        let w = window.clone();
                         std::thread::spawn(move || {
                             use std::io::{BufRead, BufReader};
                             let reader = BufReader::new(stderr);
                             for line in reader.lines().flatten() {
                                 debug_log(&format!("[NODE STDERR] {}", line));
+                                if line.contains("Error") || line.contains("Exception") || line.contains("MODULE_NOT_FOUND") {
+                                    let _ = w.emit("error", serde_json::json!({ "message": format!("Backend failed: {}", line) }));
+                                }
                             }
                         });
                     }
@@ -904,21 +828,16 @@ fn main() {
 
             Ok(())
         })
-        .on_window_event(|window, event| {
+ .on_window_event(|window, event| {
             if let tauri::WindowEvent::Destroyed = event {
                 if window.label() == "main" {
                     let state: State<NodeServices> = window.state();
                     if let Ok(mut lock) = state.0.lock() {
-                        if let Some(child) = lock.take() {
+                        if let Some(mut child) = lock.take() {
-                            let pid = child.id();
+                            debug_log("[SHUTDOWN] Main window destroyed, terminating node process natively");
-                            debug_log(&format!(
+                            kill_child_process(&mut child);
-                                "[SHUTDOWN] Main window destroyed, killing process tree for PID {}",
-                                pid
-                            ));
-                            kill_process_tree(pid);
                         }
                     };
-                    kill_processes_on_ports(&[3000, 3001, 4890, 4891, 4892, 7860]);
                 }
             }
         })

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.1.6",
+    "version": "1.1.13",
     "identifier": "com.vyla.home",
     "build": {
         "frontendDist": "../ui"
@@ -29,8 +29,9 @@
         },
         "resources": [
             "WebView2Loader.dll",
-            "../bin/*",
+            "../bin/**/*",
             "../main.js",
+            "../preload.js",
             "../service-manager.js",
             "../patcher.js",
             "../crypto-utils.js",
@@ -40,4 +41,4 @@
             "../node_modules/**/*"
         ]
     }
-}
+}

ui/index.html

@@ -195,40 +195,13 @@
     <div class="loader-container">
         <div class="loader-card">
             <div class="status-text" id="status-message">Starting runtime engine...</div>
+            <div id="debug-log-box"
+                style="display: none; width: 100%; max-height: 180px; overflow-y: auto; background: rgba(255, 50, 50, 0.12); border: 1px solid rgba(255, 100, 100, 0.3); border-radius: 8px; padding: 12px; font-family: monospace; font-size: 12px; color: #fca5a5; text-align: left; white-space: pre-wrap; word-break: break-all; margin-bottom: 20px; user-select: text;">
+            </div>
             <div class="progress-track" id="progress-track" style="display: none;">
                 <div class="progress-fill" id="progress-fill"></div>
             </div>
 
-            <div class="button-group" id="launch-actions" style="display: none; margin-top: 8px;">
-                <div class="glass-surface glass-surface--fallback liquid-glass-btn">
-                    <svg class="glass-surface__filter" xmlns="http://www.w3.org/2000/svg">
-                        <defs>
-                            <filter id="glass-filter-launch" color-interpolation-filters="sRGB" x="0%" y="0%"
-                                width="100%" height="100%">
-                                <feImage class="fe-image" x="0" y="0" width="100%" height="100%"
-                                    preserveAspectRatio="none" result="map" />
-                                <feDisplacementMap class="redchannel" in="SourceGraphic" in2="map" result="dispRed" />
-                                <feColorMatrix in="dispRed" type="matrix"
-                                    values="1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0" result="red" />
-                                <feDisplacementMap class="greenchannel" in="SourceGraphic" in2="map"
-                                    result="dispGreen" />
-                                <feColorMatrix in="dispGreen" type="matrix"
-                                    values="0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0" result="green" />
-                                <feDisplacementMap class="bluechannel" in="SourceGraphic" in2="map" result="dispBlue" />
-                                <feColorMatrix in="dispBlue" type="matrix"
-                                    values="0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0" result="blue" />
-                                <feBlend in="red" in2="green" mode="screen" result="rg" />
-                                <feBlend in="rg" in2="blue" mode="screen" result="output" />
-                                <feGaussianBlur class="gaussianBlur" in="output" stdDeviation="0" />
-                            </filter>
-                        </defs>
-                    </svg>
-                    <div class="glass-surface__content">
-                        <button class="glass-button" id="btn-launch-vyla">Launch Vyla Home</button>
-                    </div>
-                </div>
-            </div>
-
             <div class="button-group" id="update-actions" style="display: none;">
                 <div class="glass-surface glass-surface--fallback liquid-glass-btn">
                     <svg class="glass-surface__filter" xmlns="http://www.w3.org/2000/svg">
@@ -286,23 +259,7 @@
                     </div>
                 </div>
             </div>
-        </div>
-    </div>
 
-    <div id="view-error" class="view-state">
-        <div class="container">
-            <svg class="icon icon-error" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                <circle cx="12" cy="12" r="10" />
-                <line x1="12" y1="7" x2="12" y2="13" />
-                <circle cx="12" cy="17" r="1" />
-            </svg>
-
-            <h1>Couldn't start Vyla Home</h1>
-            <p id="error-msg"></p>
-
-            <div class="buttons">
-                <button class="primary" onclick="location.reload()">Try Again</button>
-            </div>
         </div>
     </div>
 
@@ -546,6 +503,7 @@ void main() {
 
     <script>
         const statusEl = document.getElementById("status-message");
+        const debugBox = document.getElementById("debug-log-box");
         const progressTrack = document.getElementById("progress-track");
         const progressFill = document.getElementById("progress-fill");
         const actionsEl = document.getElementById("update-actions");
@@ -570,16 +528,11 @@ void main() {
             });
         }
 
-        const launchActionsEl = document.getElementById("launch-actions");
+        function showDebug(msg) {
-        const btnLaunch = document.getElementById("btn-launch-vyla");
+            if (!debugBox) return;
-        let readyUrl = null;
+            debugBox.style.display = "block";
-
+            debugBox.textContent = msg;
-        btnLaunch.addEventListener("click", () => {
+        }
-            if (readyUrl) {
-                setStatus("Launching...");
-                window.location.href = readyUrl;
-            }
-        });
 
         async function initTauriEvents() {
             const eventApi = window.__TAURI__?.event || window.__TAURI_INTERNALS__;
@@ -601,7 +554,9 @@ void main() {
                     if (progressTrack) progressTrack.style.display = "block";
                     const percent = data.percent || 0;
                     if (progressFill) progressFill.style.width = percent + "%";
-                    setStatus(`Downloading update... ${percent}%`);
+                    if (!currentStatusText.startsWith("Downloading update...")) {
+                        setStatus("Downloading update...");
+                    }
                 }
             });
 
@@ -616,20 +571,16 @@ void main() {
             eventApi.listen("ready", (e) => {
                 const data = e.payload || e;
                 if (data && data.url) {
-                    readyUrl = data.url;
+                    setStatus("Launching...");
-                    if (progressTrack) progressTrack.style.display = "none";
+                    window.location.href = data.url;
-                    if (actionsEl) actionsEl.style.display = "none";
-                    if (statusEl) statusEl.innerHTML = "";
-                    currentStatusText = "";
-                    if (launchActionsEl) launchActionsEl.style.display = "flex";
                 }
             });
 
             eventApi.listen("error", (e) => {
                 const data = e.payload || e;
-                if (data && data.message) {
+                const msg = data && data.message ? data.message : JSON.stringify(data);
-                    setStatus(`Error: ${data.message}`, "#ef4444");
+                setStatus("Runtime Error", "#fca5a5");
-                }
+                showDebug(msg);
             });
         }
 

update-client.js

@@ -10,6 +10,8 @@ const ALLOWED_REDIRECT_HOSTS = [
   'storage.googleapis.com'
 ];
 
+const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 32 });
+
 function isAllowedHost(url) {
   try {
     const hostname = new URL(url).hostname;
@@ -46,7 +48,8 @@ class UpdateClient {
         port: 443,
         path: urlObj.pathname + urlObj.search,
         method: 'GET',
-        headers
+        headers,
+        agent: httpsAgent
       };
 
       const req = https.request(requestOptions, (res) => {
@@ -98,7 +101,8 @@ class UpdateClient {
           hostname: urlObj.hostname,
           port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
           path: urlObj.pathname + urlObj.search,
-          headers
+          headers,
+          agent: httpsAgent
         };
 
         const req = https.get(requestOptions, (res) => {
@@ -180,7 +184,8 @@ class UpdateClient {
           hostname: urlObj.hostname,
           port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
           path: urlObj.pathname + urlObj.search,
-          headers
+          headers,
+          agent: httpsAgent
         };
 
         const req = https.get(requestOptions, (res) => {
@@ -223,7 +228,8 @@ class UpdateClient {
   }
 
   async checkForUpdates() {
-    const releases = await this.fetchJson(RELEASES_API);
+    const cacheBuster = `?cb=${Date.now()}`;
+    const releases = await this.fetchJson(RELEASES_API + cacheBuster);
     if (!releases || releases.length === 0) {
       return null;
     }