disable express static caching to resolve stale UI on app updates

DOCUEMENTATION/FORDEV.md

@@ -16,4 +16,10 @@ To release it, run:
 
 ```powershell
 npm run release:full
+```
+
+Fixing os error 32
+
+```powershell
+Stop-Process -Name "vyla-home", "node", "cargo" -Force -ErrorAction SilentlyContinue
 ```

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

@@ -20,11 +20,13 @@ const REPO_CONFIG = {
 };
 
 function clonePrivateRepo(repoConfig, targetDir) {
-  const repoUrl = `https://gitlab.com/${GITLAB_GROUP}/${repoConfig.name}.git`;
+  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 });
+      fs.rmSync(targetDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
 
     execSync(`git clone --depth 1 --branch ${repoConfig.branch} ${repoUrl} ${targetDir}`, {
@@ -332,6 +334,9 @@ async function build() {
   }
 
   const zipPath = path.join(__dirname, 'update-payload.zip');
+  if (fs.existsSync(zipPath)) {
+    fs.rmSync(zipPath, { force: true });
+  }
   zip.writeZip(zipPath);
 
   const checksum = validatePayload(zipPath);

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,7 +82,7 @@ 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.on('uncaughtException', (err) => {
   debugLog(`CRITICAL UNCAUGHT EXCEPTION: ${err.stack || err.message}`);
@@ -102,7 +106,8 @@ const updateClient = new UpdateClient(APPDATA_DIR);
 
 async function start() {
   debugLog("Inside start() function");
-  sendToTauri('status', { message: 'Initializing patcher...' });
+  sendToTauri('status', { message: 'Loading core configuration files...' });
+
   const patcher = new Patcher(APPDATA_DIR);
   serviceManager = new ServiceManager(APPDATA_DIR, envConfig);
 
@@ -115,7 +120,7 @@ async function start() {
       attempts++;
       try {
         debugLog(`Attempting to download update (Attempt ${attempts})...`);
-        sendToTauri('status', { message: `Downloading update (Attempt ${attempts}/3)...` });
+        sendToTauri('status', { message: `Connecting to download servers (Attempt ${attempts}/3)...` });
 
         await updateClient.downloadUpdate(release, tempZipPath, (downloaded, total) => {
           const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
@@ -123,23 +128,26 @@ async function start() {
         });
 
         debugLog('Download complete. Verifying checksum...');
-        sendToTauri('status', { message: 'Verifying payload checksum...' });
+        sendToTauri('status', { message: 'Verifying SHA-256 integrity...' });
         if (!patcher.verifyChecksum(tempZipPath, release.sha256)) {
           throw new Error('SHA-256 checksum verification failed.');
         }
 
         debugLog('Checksum verified. Extracting...');
-        sendToTauri('status', { message: 'Extracting update files...' });
+        sendToTauri('status', { message: 'Unpacking update archive...' });
         patcher.purgeOldCode();
         patcher.extractZipPayload(tempZipPath);
 
+        sendToTauri('status', { message: 'Verifying file integrity...' });
         if (!patcher.verifyExtraction()) {
           throw new Error('Extraction verification failed: critical startup files missing.');
         }
 
         debugLog('Extraction complete. Applying patches...');
-        sendToTauri('status', { message: 'Applying patches & configuring...' });
+        sendToTauri('status', { message: 'Applying configuration patches...' });
         patcher.applyPatches(replacementsConfig);
+
+        sendToTauri('status', { message: 'Migrating security credentials...' });
         patcher.bridgeCredentials(serviceManager.credentialManager);
         patcher.saveCurrentVersion(release.version, release.sha256);
 
@@ -150,6 +158,7 @@ async function start() {
         debugLog('Update installed successfully!');
       } catch (err) {
         debugLog(`Download/Install error on attempt ${attempts}: ${err.message}`);
+        sendToTauri('status', { message: `Install error: ${err.message}. Retrying...` });
         if (fs.existsSync(tempZipPath)) {
           try { fs.unlinkSync(tempZipPath); } catch (e) { }
         }
@@ -162,12 +171,13 @@ async function start() {
   };
 
   try {
+    sendToTauri('status', { message: 'Inspecting local workspace and installed files...' });
     const isFirstRun = !patcher.verifyExtraction();
     const localVersion = patcher.getCurrentVersion();
     const localSha = patcher.getCurrentSha();
     debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}`);
 
-    sendToTauri('status', { message: 'Checking for updates...' });
+    sendToTauri('status', { message: 'Connecting to update servers...' });
     let release = null;
     try {
       debugLog("Fetching updates from updateClient...");
@@ -175,15 +185,19 @@ async function start() {
       debugLog(`Update check finished. Found: ${release ? release.version : 'None'}`);
     } catch (e) {
       debugLog(`Update check failed (offline?): ${e.message}`);
+      sendToTauri('status', { message: `Update server check skipped (${e.message})` });
     }
 
     if (release) {
       const hasUpdate = release.version !== localVersion || (release.sha256 && release.sha256 !== localSha);
       if (isFirstRun) {
         debugLog("First run. Installing remote build...");
+        sendToTauri('status', { message: 'First run detected. Preparing initial installation...' });
         await installBuild(release);
       } else if (hasUpdate) {
         debugLog("Update available. Prompting user...");
+        sendToTauri('status', { message: `New update available (${release.version}). Awaiting confirmation...` });
+
         const tempApp = express();
         let userDecision = null;
         tempApp.use((req, res, next) => {
@@ -206,7 +220,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));
@@ -216,15 +230,18 @@ async function start() {
           await installBuild(release);
         } else {
           debugLog("User skipped update.");
+          sendToTauri('status', { message: 'Update skipped. Continuing startup...' });
         }
       } else {
         debugLog("Already on the latest version.");
+        sendToTauri('status', { message: 'Up to date.' });
       }
     } else if (isFirstRun) {
       debugLog("No remote release found, but it's the first run. Looking for local update-payload.zip...");
+      sendToTauri('status', { message: 'Looking for local payload archive...' });
       const localZip = path.join(__dirname, 'update-payload.zip');
       if (fs.existsSync(localZip)) {
-        sendToTauri('status', { message: 'Extracting initial local payload...' });
+        sendToTauri('status', { message: 'Extracting local baseline payload...' });
         patcher.purgeOldCode();
         patcher.extractZipPayload(localZip);
         patcher.applyPatches(replacementsConfig);
@@ -236,20 +253,22 @@ async function start() {
       }
     }
 
+    sendToTauri('status', { message: 'Validating critical components...' });
     if (!patcher.verifyExtraction()) {
       throw new Error('No application files found. Check your internet connection and try again.');
     }
 
-    sendToTauri('status', { message: 'Loading credentials...' });
+    sendToTauri('status', { message: 'Loading encrypted credentials...' });
     serviceManager.credentialManager.loadCredentials();
 
-    sendToTauri('status', { message: 'Starting backend services...' });
+    sendToTauri('status', { message: 'Starting background services (auth-proxy, stream-api)...' });
     await serviceManager.startServices([
       { name: 'auth-proxy', relativeDir: 'auth-proxy' },
       { name: 'stream-api', relativeDir: 'stream-api' },
     ]);
     debugLog("Backend services spawn requested.");
 
+    sendToTauri('status', { message: 'Binding player web server on port 3001...' });
     const playerDir = path.join(APPDATA_DIR, 'player');
     playerExpressApp = express();
     playerExpressApp.use((req, res, next) => {
@@ -265,15 +284,24 @@ 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 ports 3000, 3001, 7860...' });
+    sendToTauri('status', { message: 'Waiting for microservices to bind ports (3000, 3001, 7860)...' });
     await serviceManager.waitForPorts([3000, 3001, 7860]);
     debugLog("Ports 3000, 3001, 7860 are ready.");
 
+    sendToTauri('status', { message: 'Binding UI server on port 4890...' });
     const frontendDir = path.join(APPDATA_DIR, 'frontend');
     expressApp = express();
     expressApp.use((req, res, next) => {
@@ -288,12 +316,27 @@ 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;
-    expressServer = expressApp.listen(FRONTEND_PORT, '0.0.0.0', () => {
+    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, '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}` });
     });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyla-home",
-  "version": "1.1.1",
+  "version": "1.1.8",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -12,9 +12,10 @@
   },
   "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",
-    "@vyla-entertainment/sdk": "^1.10.0",
+    "@tauri-apps/plugin-shell": "^2.0.0",
+    "@vyla-entertainment/sdk": "^1.11.0",
     "adm-zip": "^0.6.0",
     "express": "^4.19.2"
   },
@@ -54,4 +55,4 @@
       "installerHeaderIcon": "build/icon.ico"
     }
   }
-}
+}

patcher.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const AdmZip = require('adm-zip');
+const JavaScriptObfuscator = require('javascript-obfuscator');
 const CryptoUtils = require('./crypto-utils');
 
 class Patcher {
@@ -119,7 +120,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 +131,67 @@ 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 (ext === '.js') {
-            fs.writeFileSync(fullPath, content, 'utf8');
+          try {
-          }
+            content = JavaScriptObfuscator.obfuscate(content, {
+              compact: true,
+              controlFlowFlattening: true,
+              controlFlowFlatteningThreshold: 1,
+              deadCodeInjection: true,
+              deadCodeInjectionThreshold: 0.4,
+              debugProtection: false,
+              disableConsoleOutput: false,
+              identifierNamesGenerator: 'hexadecimal',
+              log: false,
+              numbersToExpressions: true,
+              renameGlobals: false,
+              selfDefending: true,
+              simplify: true,
+              splitStrings: true,
+              splitStringsChunkLength: 5,
+              stringArray: true,
+              stringArrayCallsTransform: true,
+              stringArrayCallsTransformThreshold: 1,
+              stringArrayEncoding: ['rc4'],
+              stringArrayIndexShift: true,
+              stringArrayRotate: true,
+              stringArrayShuffle: true,
+              stringArrayWrappersCount: 5,
+              stringArrayWrappersChainedCalls: true,
+              stringArrayWrappersParametersMaxCount: 5,
+              stringArrayWrappersType: 'function',
+              stringArrayThreshold: 1,
+              transformObjectKeys: true,
+              unicodeEscapeSequence: false
+            }).getObfuscatedCode();
+            modified = true;
+          } catch (e) { }
+        }
+
+        if (modified) {
+          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,42 +78,38 @@ function uploadFileToGitLabPackage(filePath, packageName, version, fileName) {
 }
 
 function createGitLabRelease(tag, releaseLinks) {
-    const sendRequest = (method, path) => {
+    const sendRequest = (method, path, data = null) => {
         return new Promise((resolve, reject) => {
-            let currentRef = 'main';
+            const options = {
-            try {
-                currentRef = execSync('git rev-parse HEAD').toString().trim();
-            } catch (e) { }
-
-            const postData = JSON.stringify({
-                name: `Vyla Home Release ${tag}`,
-                tag_name: tag,
-                ref: currentRef,
-                description: `Automated local release ${tag}`,
-                assets: {
-                    links: releaseLinks
-                }
-            });
-
-            const req = https.request({
                 hostname: 'gitlab.com',
                 port: 443,
                 path: path,
                 method: method,
                 headers: {
                     'PRIVATE-TOKEN': TOKEN,
-                    'Content-Type': 'application/json',
+                    'Content-Type': 'application/json'
-                    'Content-Length': Buffer.byteLength(postData)
                 }
-            }, (res) => {
+            };
+            let postData = '';
+            if (data) {
+                postData = JSON.stringify(data);
+                options.headers['Content-Length'] = Buffer.byteLength(postData);
+            }
+
+            const req = https.request(options, (res) => {
                 let body = '';
                 res.on('data', chunk => body += chunk);
                 res.on('end', () => {
-                    if (res.statusCode === 200 || res.statusCode === 201) {
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
-                        resolve(JSON.parse(body));
+                        try {
+                            resolve(body ? JSON.parse(body) : {});
+                        } catch (e) {
+                            resolve({});
+                        }
                     } else if (res.statusCode === 409 && method === 'POST') {
-                        console.log(`Release ${tag} already exists, updating assets...`);
+                        console.log(`Release ${tag} already exists, deleting and recreating...`);
-                        sendRequest('PUT', `/api/v4/projects/${PROJECT_ID}/releases/${encodeURIComponent(tag)}`)
+                        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 {
@@ -123,12 +119,27 @@ function createGitLabRelease(tag, releaseLinks) {
             });
 
             req.on('error', reject);
-            req.write(postData);
+            if (data) req.write(postData);
             req.end();
         });
     };
 
-    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`);
+    let currentRef = 'main';
+    try {
+        currentRef = execSync('git rev-parse HEAD').toString().trim();
+    } catch (e) { }
+
+    const releaseData = {
+        name: `Vyla Home Release ${tag}`,
+        tag_name: tag,
+        ref: currentRef,
+        description: `Automated local release ${tag}`,
+        assets: {
+            links: releaseLinks
+        }
+    };
+
+    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`, releaseData);
 }
 
 async function main() {
@@ -156,15 +167,23 @@ async function main() {
         console.log('Ensuring bundled Node.js runtime...');
         await ensureBundledNode();
 
+        await ensureWebView2Loader();
+
+        const bundleDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle');
+        if (fs.existsSync(bundleDir)) {
+            fs.rmSync(bundleDir, { recursive: true, force: true });
+        }
+
         console.log('Compiling Windows Tauri installer locally...');
         execSync('npm run build', {
-            stdio: 'inherit',
+            stdio: 'inherit'
-            env: Object.assign({}, process.env, { WEBVIEW2_STATIC_LIB: '1' })
         });
 
         const nsisDir = path.join(__dirname, 'src-tauri/target/release/bundle/nsis');
         if (fs.existsSync(nsisDir)) {
-            const files = fs.readdirSync(nsisDir).filter(f => f.endsWith('.exe'));
+            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) {
                 const originalName = files[0];
                 installerPath = path.join(nsisDir, originalName);
@@ -174,11 +193,13 @@ async function main() {
     }
 
     console.log('[2/4] Uploading artifacts to GitLab Package Registry...');
+    const timestamp = Date.now();
+
     console.log('Uploading update-payload.zip...');
-    const payloadUrl = await uploadFileToGitLabPackage(payloadPath, 'vyla-home', version, 'update-payload.zip');
+    const payloadUrl = await uploadFileToGitLabPackage(payloadPath, 'vyla-home', version, `update-payload-${timestamp}.zip`);
 
     console.log('Uploading manifest.json...');
-    const manifestUrl = await uploadFileToGitLabPackage(manifestPath, 'vyla-home', version, 'manifest.json');
+    const manifestUrl = await uploadFileToGitLabPackage(manifestPath, 'vyla-home', version, `manifest-${timestamp}.json`);
 
     const releaseLinks = [
         { name: 'update-payload.zip', url: payloadUrl, link_type: 'other' },
@@ -187,7 +208,8 @@ async function main() {
 
     if (installerPath && installerUploadName) {
         console.log(`Uploading installer ${installerUploadName}...`);
-        const installerUrl = await uploadFileToGitLabPackage(installerPath, 'vyla-home', version, installerUploadName);
+        const installerUnique = installerUploadName.replace('.exe', `-${timestamp}.exe`);
+        const installerUrl = await uploadFileToGitLabPackage(installerPath, 'vyla-home', version, installerUnique);
         releaseLinks.push({ name: installerUploadName, url: installerUrl, link_type: 'package' });
     }
 
@@ -238,6 +260,59 @@ function ensureBundledNode() {
     });
 }
 
+function ensureWebView2Loader() {
+    const releaseDir = path.join(__dirname, 'src-tauri', 'target', 'release');
+    const rootDllPath = path.join(__dirname, 'src-tauri', 'WebView2Loader.dll');
+    fs.mkdirSync(releaseDir, { recursive: true });
+
+    const targetDllPath = path.join(releaseDir, 'WebView2Loader.dll');
+
+    if (fs.existsSync(rootDllPath) && fs.existsSync(targetDllPath)) {
+        return Promise.resolve();
+    }
+
+    const AdmZip = require('adm-zip');
+    const tempNupkg = path.join(__dirname, 'temp-wv2.zip');
+    const nupkgUrl = 'https://www.nuget.org/api/v2/package/Microsoft.Web.WebView2/1.0.2903.40';
+
+    return new Promise((resolve, reject) => {
+        const fileStream = fs.createWriteStream(tempNupkg);
+        const request = (url) => {
+            https.get(url, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    return request(res.headers.location);
+                }
+                res.pipe(fileStream);
+                fileStream.on('finish', () => {
+                    fileStream.close();
+                    try {
+                        const zip = new AdmZip(tempNupkg);
+                        const zipEntries = zip.getEntries();
+                        const dllEntry = zipEntries.find(e =>
+                            e.entryName.includes('x64/WebView2Loader.dll') ||
+                            e.entryName.includes('x64\\WebView2Loader.dll')
+                        );
+                        if (dllEntry) {
+                            const buffer = dllEntry.getData();
+                            fs.writeFileSync(targetDllPath, buffer);
+                            fs.writeFileSync(rootDllPath, buffer);
+                        }
+                        try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                        resolve();
+                    } catch (e) {
+                        try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                        reject(e);
+                    }
+                });
+            }).on('error', (err) => {
+                try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                reject(err);
+            });
+        };
+        request(nupkgUrl);
+    });
+}
+
 main().catch(err => {
     console.error('Release failed:', err.message);
     process.exit(1);

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) {
     }
@@ -90,6 +89,25 @@ class ServiceManager {
     child.stderr.on('data', (data) => {
       const text = data.toString().trim();
       this.logToFile(name, `STDERR: ${text}`);
+
+      if (text.includes('EADDRINUSE')) {
+        const match = text.match(/:(\d+)/);
+        const port = match ? match[1] : null;
+        if (port) {
+          try {
+            if (process.platform === 'win32') {
+              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').spawnSync('fuser', ['-k', '-9', `${port}/tcp`], { stdio: 'ignore' });
+            }
+          } catch (_) { }
+        }
+      }
     });
 
     child.on('exit', (code, signal) => {
@@ -111,7 +129,7 @@ class ServiceManager {
           this.startService(name, relativeDir, startScript).catch(err => {
             this.logToFile(name, `Failed to restart: ${err.message}`);
           });
-        }, 3000);
+        }, 1500);
       }
     });
   }
@@ -175,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,8 +4222,9 @@ dependencies = [
 
 [[package]]
 name = "vyla-home"
-version = "1.1.1"
+version = "1.1.8"
 dependencies = [
+ "base64 0.22.1",
  "serde",
  "serde_json",
  "tauri",
@@ -4231,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.1"
+version = "1.1.8"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -14,4 +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,5 @@
 fn main() {
+    println!("cargo:rerun-if-changed=src/main.rs");
+    println!("cargo:rerun-if-changed=tauri.conf.json");
     tauri_build::build();
 }

src-tauri/src/main.rs

@@ -7,9 +7,14 @@ 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).join("vyla-home").join("vyla-home-files").join("logs")
+        std::path::PathBuf::from(app_data)
+            .join("vyla-home")
+            .join("vyla-home-files")
+            .join("logs")
     } else if let Ok(user_profile) = std::env::var("USERPROFILE") {
-        std::path::PathBuf::from(user_profile).join(".vyla-home").join("logs")
+        std::path::PathBuf::from(user_profile)
+            .join(".vyla-home")
+            .join("logs")
     } else {
         std::path::PathBuf::from("logs")
     };
@@ -17,7 +22,11 @@ fn debug_log(msg: &str) {
     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().create(true).append(true).open(&log_path) {
+    if let Ok(mut file) = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&log_path)
+    {
         use std::io::Write;
         let _ = writeln!(file, "[RUST] {}", msg);
     }
@@ -40,38 +49,9 @@ fn clean_path(path: &std::path::Path) -> String {
     }
 }
 
-#[cfg(windows)]
+fn kill_child_process(child: &mut Child) {
-fn kill_process_tree(pid: u32) {
+    let _ = child.kill();
-    use std::os::windows::process::CommandExt;
+    let _ = child.wait();
-    const CREATE_NO_WINDOW: u32 = 0x08000000;
-    let result = Command::new("taskkill")
-        .args(["/PID", &pid.to_string(), "/T", "/F"])
-        .creation_flags(CREATE_NO_WINDOW)
-        .output();
-    match result {
-        Ok(output) => debug_log(&format!(
-            "[KILL-TREE] taskkill on PID {} -> status: {}, stdout: {}, stderr: {}",
-            pid,
-            output.status,
-            String::from_utf8_lossy(&output.stdout).trim(),
-            String::from_utf8_lossy(&output.stderr).trim()
-        )),
-        Err(e) => debug_log(&format!("[KILL-TREE] taskkill failed to spawn for PID {}: {}", pid, e)),
-    }
-}
-
-#[cfg(not(windows))]
-fn kill_process_tree(pid: u32) {
-    unsafe {
-        libc_kill_pgid(pid);
-    }
-}
-
-#[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> {
@@ -164,11 +144,12 @@ fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
     (clean_path(&candidate), clean_path(&dir))
 }
 
-const LINK_HANDLER_SCRIPT: &str = r#"
+const LINK_HANDLER_SCRIPT: &str = r##"
     function doInvoke(cmd, args) {
         if (window.__TAURI__ && window.__TAURI__.core) {
-            window.__TAURI__.core.invoke(cmd, args || {});
+            return window.__TAURI__.core.invoke(cmd, args || {});
         }
+        return Promise.resolve(null);
     }
 
     function minimizeWindow() { doInvoke('win_minimize'); }
@@ -176,6 +157,16 @@ const LINK_HANDLER_SCRIPT: &str = r#"
     function closeWindow() { doInvoke('win_close'); }
     function dragWindow() { doInvoke('win_drag'); }
 
+    function openExternalUrl(url) {
+        if (window.__TAURI__ && window.__TAURI__.opener) {
+            window.__TAURI__.opener.openUrl(url);
+        } else if (window.__TAURI__ && window.__TAURI__.shell) {
+            window.__TAURI__.shell.open(url);
+        } else {
+            window.open(url, '_blank');
+        }
+    }
+
     window.open = function(url, target, features) {
         doInvoke('open_new_window', { url: url });
         return null;
@@ -185,6 +176,13 @@ const LINK_HANDLER_SCRIPT: &str = r#"
         const a = e.target.closest('a');
         if (!a || !a.href) return;
 
+        if (a.href.includes('discord.gg') || a.href.includes('discord.com')) {
+            e.preventDefault();
+            e.stopPropagation();
+            openExternalUrl(a.href);
+            return;
+        }
+
         if (a.target === '_blank' || e.ctrlKey || e.metaKey || e.button === 1) {
             e.preventDefault();
             e.stopPropagation();
@@ -192,16 +190,125 @@ const LINK_HANDLER_SCRIPT: &str = r#"
         }
     }, true);
 
-    function injectTitlebar() {
+    function injectLiquidNavBar() {
-        if (document.getElementById('tauri-custom-titlebar')) {
+        if (document.getElementById('vyla-floating-nav')) return;
-            return;
+        if (!document.body) return;
-        }
-        if (!document.body) {
-            return;
-        }
 
         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;
+                left: 12px !important;
+                z-index: 2147483647 !important;
+                height: 42px !important;
+                width: 42px !important;
+                border-radius: 9999px !important;
+                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;
+                -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;
+                overflow: hidden !important;
+                padding: 0 !important;
+                user-select: none !important;
+                pointer-events: auto !important;
+                -webkit-app-region: no-drag !important;
+            }
+
+            #vyla-floating-nav:hover {
+                width: 82px !important;
+                padding-right: 6px !important;
+            }
+
+            .vyla-nav-logo-wrap {
+                width: 42px !important;
+                min-width: 42px !important;
+                height: 42px !important;
+                display: flex !important;
+                align-items: center !important;
+                justify-content: center !important;
+                cursor: pointer !important;
+                border-radius: 9999px !important;
+                position: relative !important;
+                z-index: 2147483647 !important;
+                pointer-events: auto !important;
+                padding: 0 !important;
+            }
+
+            .vyla-nav-logo-wrap img {
+                width: 26px !important;
+                height: 26px !important;
+                min-width: 26px !important;
+                min-height: 26px !important;
+                object-fit: contain !important;
+                pointer-events: none !important;
+                display: block !important;
+            }
+
+            .vyla-nav-links {
+                display: flex !important;
+                align-items: center !important;
+                gap: 4px !important;
+                opacity: 0 !important;
+                transform: translateX(-6px) !important;
+                transition: opacity 0.2s ease, transform 0.25s cubic-bezier(0.16, 1, 0.3, 1) !important;
+                pointer-events: none !important;
+                position: relative !important;
+                z-index: 2 !important;
+                margin-left: 2px !important;
+            }
+
+            #vyla-floating-nav:hover .vyla-nav-links {
+                opacity: 1 !important;
+                transform: translateX(0) !important;
+                pointer-events: auto !important;
+            }
+
+            .vyla-nav-btn {
+                width: 32px !important;
+                min-width: 32px !important;
+                height: 32px !important;
+                border-radius: 9999px !important;
+                border: none !important;
+                outline: none !important;
+                background: transparent !important;
+                box-shadow: none !important;
+                color: #ffffff !important;
+                display: flex !important;
+                align-items: center !important;
+                justify-content: center !important;
+                cursor: pointer !important;
+                transition: transform 0.15s ease, opacity 0.2s ease !important;
+                opacity: 0.85 !important;
+                padding: 0 !important;
+            }
+
+            .vyla-nav-btn:hover {
+                opacity: 1 !important;
+            }
+
+            .vyla-nav-btn svg {
+                width: 20px !important;
+                height: 20px !important;
+                fill: #ffffff !important;
+                pointer-events: none !important;
+                display: block !important;
+            }
+
             #tauri-custom-titlebar {
                 position: fixed !important;
                 top: 0 !important;
@@ -210,7 +317,7 @@ const LINK_HANDLER_SCRIPT: &str = r#"
                 height: 32px !important;
                 max-height: 32px !important;
                 display: flex !important;
-                justify-content: space-between !important;
+                justify-content: flex-end !important;
                 align-items: center !important;
                 z-index: 2147483647 !important;
                 background: transparent !important;
@@ -219,13 +326,15 @@ const LINK_HANDLER_SCRIPT: &str = r#"
                 margin: 0 !important;
                 padding: 0 !important;
             }
+
             .tauri-drag-region {
-                flex: 1 !important;
+                position: absolute !important;
+                inset: 0 !important;
                 height: 32px !important;
-                margin-left: 100px !important;
                 cursor: default !important;
                 pointer-events: auto !important;
             }
+
             .tauri-window-controls {
                 display: flex !important;
                 height: 32px !important;
@@ -234,13 +343,12 @@ const LINK_HANDLER_SCRIPT: &str = r#"
                 pointer-events: auto !important;
                 z-index: 2147483648 !important;
             }
+
             button.tauri-btn {
                 width: 46px !important;
                 min-width: 46px !important;
                 max-width: 46px !important;
                 height: 32px !important;
-                min-height: 32px !important;
-                max-height: 32px !important;
                 background: transparent !important;
                 border: none !important;
                 color: #ffffff !important;
@@ -249,22 +357,114 @@ const LINK_HANDLER_SCRIPT: &str = r#"
                 justify-content: center !important;
                 cursor: pointer !important;
                 outline: none !important;
-                padding: 0 !important;
-                margin: 0 !important;
-                border-radius: 0 !important;
-                box-shadow: none !important;
-                appearance: none !important;
-                opacity: 1 !important;
-                transform: none !important;
-                pointer-events: auto !important;
-                user-select: none !important;
             }
+
             button.tauri-btn:hover { background: rgba(255, 255, 255, 0.2) !important; }
             button#tauri-btn-close:hover { background: #e81123 !important; color: #ffffff !important; }
-            button.tauri-btn svg { width: 10px !important; height: 10px !important; fill: currentColor !important; pointer-events: none !important; display: block !important; }
+            button.tauri-btn svg { width: 10px !important; height: 10px !important; fill: currentColor !important; pointer-events: none !important; }
         `;
         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 = `
+            <div class="vyla-nav-logo-wrap" title="Go to Home">
+                <img src="https://gitlab.com/vyla-entertainment/home-frontend/-/raw/main/assets/images/icons/logo_white.png" alt="Logo" />
+            </div>
+            <div class="vyla-nav-links">
+                <button class="vyla-nav-btn" id="vyla-btn-discord" title="Discord Community">
+                    <svg viewBox="0 0 127.14 96.36"><path d="M107.7,8.07A105.15,105.15,0,0,0,81.47,0a72.06,72.06,0,0,0-3.36,6.83A97.68,97.68,0,0,0,49,6.83,72.37,72.37,0,0,0,45.64,0,105.89,105.89,0,0,0,19.39,8.09C2.79,32.65-1.71,56.6.54,80.21h0A105.73,105.73,0,0,0,32.71,96.36,77.7,77.7,0,0,0,39.6,85.25a68.42,68.42,0,0,1-10.85-5.18c.91-.66,1.8-1.34,2.66-2a75.57,75.57,0,0,0,64.32,0c.87.71,1.76,1.39,2.66,2a68.68,68.68,0,0,1-10.87,5.19,77,77,0,0,0,6.89,11.1A105.25,105.25,0,0,0,126.6,80.22h0C129.24,52.84,122.09,29.11,107.7,8.07ZM42.45,65.69C36.18,65.69,31,60,31,53s5-12.74,11.43-12.74S54,45.91,53.89,53,48.84,65.69,42.45,65.69Zm42.24,0C78.41,65.69,73.25,60,73.25,53s5-12.74,11.44-12.74S96.23,45.91,96.12,53,91.08,65.69,84.69,65.69Z"/></svg>
+                </button>
+            </div>
+        `;
+        document.body.appendChild(nav);
+
+        const logoBtn = nav.querySelector('.vyla-nav-logo-wrap');
+        if (logoBtn) {
+            logoBtn.onclick = (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                window.location.href = 'http://localhost:4890';
+            };
+        }
+
+        const btnDiscord = nav.querySelector('#vyla-btn-discord');
+        if (btnDiscord) {
+            btnDiscord.onclick = (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                openExternalUrl('https://discord.gg/5eqRhKeywG');
+            };
+        }
+
+        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 = `
@@ -275,7 +475,6 @@ const LINK_HANDLER_SCRIPT: &str = r#"
                 <button class="tauri-btn" id="tauri-btn-close" title="Close"><svg viewBox="0 0 10 10"><path d="M10,1.4L8.6,0L5,3.6L1.4,0L0,1.4L3.6,5L0,8.6L1.4,10L5,6.4L8.6,10L10,8.6L6.4,5L10,1.4z"/></svg></button>
             </div>
         `;
-
         document.body.appendChild(tb);
 
         const btnMin = tb.querySelector('#tauri-btn-min');
@@ -295,18 +494,19 @@ const LINK_HANDLER_SCRIPT: &str = r#"
             };
         }
     }
-    
-    injectTitlebar();
-    setInterval(injectTitlebar, 1000);
 
-    if (document.readyState === 'loading') {
+  if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', injectTitlebar);
+        document.addEventListener('DOMContentLoaded', injectLiquidNavBar);
     } else {
-        injectTitlebar();
+        injectLiquidNavBar();
     }
-
+    const navObserver = new MutationObserver(() => {
-    window.addEventListener('load', injectTitlebar);
+        if (!document.getElementById('vyla-floating-nav')) {
-"#;
+            injectLiquidNavBar();
+        }
+    });
+    navObserver.observe(document.documentElement, { childList: true, subtree: true });
+"##;
 
 #[tauri::command]
 fn win_minimize(window: tauri::Window) -> Result<(), String> {
@@ -350,7 +550,10 @@ fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
 
     if let Some(window) = app.get_webview_window("main") {
         window
-            .eval(&format!("window.location.href = '{}';", final_url.replace('\'', "\\'")))
+            .eval(&format!(
+                "window.location.href = '{}';",
+                final_url.replace('\'', "\\'")
+            ))
             .map_err(|e| e.to_string())?;
         Ok(())
     } else {
@@ -358,6 +561,39 @@ fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
     }
 }
 
+#[tauri::command]
+fn get_logo_base64(app: tauri::AppHandle) -> Result<String, String> {
+    use std::io::Read;
+    let mut candidate_paths = Vec::new();
+
+    if let Ok(res_dir) = app.path().resource_dir() {
+        candidate_paths.push(res_dir.join("build").join("icon_white.png"));
+        candidate_paths.push(res_dir.join("_up_").join("build").join("icon_white.png"));
+    }
+
+    if let Ok(mut cur) = std::env::current_dir() {
+        candidate_paths.push(cur.join("build").join("icon_white.png"));
+        if cur.ends_with("src-tauri") {
+            cur.pop();
+            candidate_paths.push(cur.join("build").join("icon_white.png"));
+        }
+    }
+
+    for path in candidate_paths {
+        if path.exists() {
+            if let Ok(mut file) = std::fs::File::open(&path) {
+                let mut buffer = Vec::new();
+                if file.read_to_end(&mut buffer).is_ok() {
+                    use base64::Engine;
+                    return Ok(base64::engine::general_purpose::STANDARD.encode(buffer));
+                }
+            }
+        }
+    }
+
+    Err("icon_white.png not found".to_string())
+}
+
 fn main() {
     debug_log("=== Vyla Home Executable Started ===");
 
@@ -370,24 +606,25 @@ fn main() {
             win_maximize,
             win_close,
             win_drag,
-            open_new_window
+            open_new_window,
+            get_logo_base64
         ])
         .manage(NodeServices(Mutex::new(None)))
-        .setup(|app| {
+.setup(|app| {
             debug_log("Tauri setup started");
             let app_data = app.path().app_data_dir().unwrap_or_default();
             let app_data_str = clean_path(&app_data);
 
-let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
+            let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
-    .title("Vyla Home")
+                .title("Vyla Home")
-    .inner_size(1280.0, 800.0)
+                .inner_size(1280.0, 800.0)
-    .decorations(false)
+                .decorations(false)
-    .transparent(true)
+                .transparent(true)
-    .resizable(true)
+                .resizable(true)
-    .devtools(true)
+                .devtools(cfg!(debug_assertions))
-    .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
+                .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
-    .initialization_script(LINK_HANDLER_SCRIPT)
+                .initialization_script(LINK_HANDLER_SCRIPT)
-    .build()?;
+                .build()?;
 
             let (main_js, root_dir) = resolve_script_and_root(app);
             let node_bin = match find_node_binary(app) {
@@ -420,7 +657,10 @@ let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html"
 
             match cmd.spawn() {
                 Ok(mut child) => {
-                    debug_log(&format!("Node child process spawned successfully, PID: {}", child.id()));
+                    debug_log(&format!(
+                        "Node child process spawned successfully, PID: {}",
+                        child.id()
+                    ));
                     if let Some(stderr) = child.stderr.take() {
                         std::thread::spawn(move || {
                             use std::io::{BufRead, BufReader};
@@ -440,76 +680,143 @@ let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html"
                                 debug_log(&format!("[NODE STDOUT] {}", line));
                                 if let Ok(msg) = serde_json::from_str::<BackendMessage>(&line) {
                                     debug_log(&format!("[MAIN-DEBUG] Received event: {}", msg.event));
-                                    debug_log(&format!("[MAIN-DEBUG] Event data: {}", serde_json::to_string(&msg.data).unwrap_or_default()));
+                                    debug_log(&format!(
+                                        "[MAIN-DEBUG] Event data: {}",
+                                        serde_json::to_string(&msg.data).unwrap_or_default()
+                                    ));
                                     if msg.event == "tauri-cmd" {
-                                        let window_label = msg.data.get("window").and_then(|val| val.as_str()).unwrap_or("main");
+                                        let window_label = msg
-                                        debug_log(&format!("[MAIN-DEBUG] Finding window by label: {}", window_label));
+                                            .data
+                                            .get("window")
+                                            .and_then(|val| val.as_str())
+                                            .unwrap_or("main");
+                                        debug_log(&format!(
+                                            "[MAIN-DEBUG] Finding window by label: {}",
+                                            window_label
+                                        ));
 
-                                        if let Some(cmd_window) = w.app_handle().get_webview_window(window_label) {
+                                        if let Some(cmd_window) =
-                                            if let Some(cmd) = msg.data.get("cmd").and_then(|c| c.as_str()) {
+                                            w.app_handle().get_webview_window(window_label)
-                                                debug_log(&format!("[TAURI-CMD] Executing action: {}", cmd));
+                                        {
+                                            if let Some(cmd) =
+                                                msg.data.get("cmd").and_then(|c| c.as_str())
+                                            {
+                                                debug_log(&format!(
+                                                    "[TAURI-CMD] Executing action: {}",
+                                                    cmd
+                                                ));
                                                 match cmd {
                                                     "win_minimize" => {
                                                         let res = cmd_window.minimize();
-                                                        debug_log(&format!("[TAURI-CMD] Minimize result: {:?}", res));
+                                                        debug_log(&format!(
-                                                    },
+                                                            "[TAURI-CMD] Minimize result: {:?}",
+                                                            res
+                                                        ));
+                                                    }
                                                     "win_maximize" => {
-                                                        let is_max = cmd_window.is_maximized().unwrap_or(false);
+                                                        let is_max = cmd_window
-                                                        debug_log(&format!("[TAURI-CMD] Currently maximized: {}", is_max));
+                                                            .is_maximized()
-                                                        let res = if is_max { cmd_window.unmaximize() } else { cmd_window.maximize() };
+                                                            .unwrap_or(false);
-                                                        debug_log(&format!("[TAURI-CMD] Maximize/Unmaximize result: {:?}", res));
+                                                        debug_log(&format!(
-                                                    },
+                                                            "[TAURI-CMD] Currently maximized: {}",
+                                                            is_max
+                                                        ));
+                                                        let res = if is_max {
+                                                            cmd_window.unmaximize()
+                                                        } else {
+                                                            cmd_window.maximize()
+                                                        };
+                                                        debug_log(&format!(
+                                                            "[TAURI-CMD] Maximize/Unmaximize result: {:?}",
+                                                            res
+                                                        ));
+                                                    }
                                                     "win_close" => {
                                                         let res = cmd_window.close();
-                                                        debug_log(&format!("[TAURI-CMD] Close result: {:?}", res));
+                                                        debug_log(&format!(
-                                                    },
+                                                            "[TAURI-CMD] Close result: {:?}",
+                                                            res
+                                                        ));
+                                                    }
                                                     "win_drag" => {
                                                         let res = cmd_window.start_dragging();
-                                                        debug_log(&format!("[TAURI-CMD] Drag result: {:?}", res));
+                                                        debug_log(&format!(
-                                                    },
+                                                            "[TAURI-CMD] Drag result: {:?}",
-"open_new_window" => {
+                                                            res
-    debug_log("[TAURI-CMD-DEBUG] open_new_window command received");
+                                                        ));
-    debug_log(&format!("[TAURI-CMD-DEBUG] Full message data: {}", serde_json::to_string(&msg.data).unwrap_or_default()));
+                                                    }
-    if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
+                                                    "open_new_window" => {
-        debug_log(&format!("[TAURI-CMD-DEBUG] URL extracted: {}", url));
+                                                        debug_log("[TAURI-CMD-DEBUG] open_new_window command received");
-        debug_log(&format!("[TAURI-CMD-DEBUG] URL length: {}", url.len()));
+                                                        debug_log(&format!(
-        debug_log("[TAURI-CMD-DEBUG] Attempting to dispatch to main thread");
+                                                            "[TAURI-CMD-DEBUG] Full message data: {}",
-        let app_handle = w.app_handle().clone();
+                                                            serde_json::to_string(&msg.data)
-        let closure_handle = app_handle.clone();
+                                                                .unwrap_or_default()
-        let url_owned = url.to_string();
+                                                        ));
-        let dispatch_result = app_handle.run_on_main_thread(move || {
+                                                        if let Some(url) = msg
-            debug_log("[TAURI-CMD-DEBUG] Now on main thread, calling open_new_window");
+                                                            .data
-            match open_new_window(closure_handle, url_owned) {
+                                                            .get("url")
-                Ok(_) => {
+                                                            .and_then(|u| u.as_str())
-                    debug_log("[TAURI-CMD-DEBUG] open_new_window succeeded");
+                                                        {
-                },
+                                                            debug_log(&format!(
-                Err(e) => {
+                                                                "[TAURI-CMD-DEBUG] URL extracted: {}",
-                    debug_log(&format!("[TAURI-CMD-DEBUG] open_new_window error: {}", e));
+                                                                url
-                },
+                                                            ));
-            }
+                                                            debug_log(&format!(
-        });
+                                                                "[TAURI-CMD-DEBUG] URL length: {}",
-        match dispatch_result {
+                                                                url.len()
-            Ok(_) => debug_log("[TAURI-CMD-DEBUG] Main thread dispatch succeeded"),
+                                                            ));
-            Err(e) => debug_log(&format!("[TAURI-CMD-DEBUG] Main thread dispatch failed: {}", e)),
+                                                            debug_log("[TAURI-CMD-DEBUG] Attempting to dispatch to main thread");
-        }
+                                                            let app_handle = w.app_handle().clone();
-    } else {
+                                                            let closure_handle = app_handle.clone();
-        debug_log("[TAURI-CMD-DEBUG] ERROR: No URL found in message data");
+                                                            let url_owned = url.to_string();
-        debug_log(&format!("[TAURI-CMD-DEBUG] Available keys: {:?}", msg.data.as_object().map(|o| o.keys().collect::<Vec<_>>())));
+                                                            let dispatch_result = app_handle
-    }
+                                                                .run_on_main_thread(move || {
-},
+                                                                    debug_log("[TAURI-CMD-DEBUG] Now on main thread, calling open_new_window");
+                                                                    match open_new_window(
+                                                                        closure_handle,
+                                                                        url_owned,
+                                                                    ) {
+                                                                        Ok(_) => {
+                                                                            debug_log("[TAURI-CMD-DEBUG] open_new_window succeeded");
+                                                                        }
+                                                                        Err(e) => {
+                                                                            debug_log(&format!(
+                                                                                "[TAURI-CMD-DEBUG] open_new_window error: {}",
+                                                                                e
+                                                                            ));
+                                                                        }
+                                                                    }
+                                                                });
+                                                            match dispatch_result {
+                                                                Ok(_) => debug_log(
+                                                                    "[TAURI-CMD-DEBUG] Main thread dispatch succeeded",
+                                                                ),
+                                                                Err(e) => debug_log(&format!(
+                                                                    "[TAURI-CMD-DEBUG] Main thread dispatch failed: {}",
+                                                                    e
+                                                                )),
+                                                            }
+                                                        } else {
+                                                            debug_log("[TAURI-CMD-DEBUG] ERROR: No URL found in message data");
+                                                            debug_log(&format!(
+                                                                "[TAURI-CMD-DEBUG] Available keys: {:?}",
+                                                                msg.data
+                                                                    .as_object()
+                                                                    .map(|o| o.keys().collect::<Vec<_>>())
+                                                            ));
+                                                        }
+                                                    }
                                                     _ => {}
                                                 }
                                             }
                                         } else {
-                                            debug_log(&format!("[TAURI-CMD] Window '{}' NOT FOUND!", window_label));
+                                            debug_log(&format!(
+                                                "[TAURI-CMD] Window '{}' NOT FOUND!",
+                                                window_label
+                                            ));
                                         }
                                     } else {
                                         let _ = w.emit(&msg.event, msg.data.clone());
-                                        if msg.event == "ready" {
-                                            if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
-                                                let _ = w.eval(&format!("window.location.href = '{}';", url));
-                                            }
-                                        }
                                     }
                                 }
                             }
@@ -523,21 +830,25 @@ let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html"
                 }
                 Err(e) => {
                     debug_log(&format!("Failed to spawn node: {}", e));
-                    let _ = window.emit("error", serde_json::json!({ "message": format!("Failed to launch backend runtime: {}", e) }));
+                    let _ = window.emit(
+                        "error",
+                        serde_json::json!({
+                            "message": format!("Failed to launch backend runtime: {}", e)
+                        }),
+                    );
                 }
             }
 
             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!("[SHUTDOWN] Main window destroyed, killing process tree for PID {}", pid));
+                            kill_child_process(&mut child);
-                            kill_process_tree(pid);
                         }
                     };
                 }

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.1.1",
+    "version": "1.1.8",
     "identifier": "com.vyla.home",
     "build": {
         "frontendDist": "../ui"
@@ -28,6 +28,7 @@
             }
         },
         "resources": [
+            "WebView2Loader.dll",
             "../bin/*",
             "../main.js",
             "../service-manager.js",

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) => {