v1.1.42

.gitignore

@@ -35,4 +35,6 @@ yarn-error.log*
 
 *.tmp
 *.temp
-download-temp.zip
+download-temp.zip
+
+.env

DOCUEMENTATION/CLEAR.bash

@@ -0,0 +1 @@
+bash -c 'pkill -9 -x node 2>/dev/null; pkill -9 -x "Vyla Home" 2>/dev/null; pkill -9 -x "vyla-home" 2>/dev/null; rm -rf "$HOME/Library/Application Support/com.vyla.home" "$HOME/Library/Application Support/vyla-home" "$HOME/Library/Application Support/Vyla Home" "$HOME/Library/Caches/com.vyla.home" "$HOME/Library/Caches/vyla-home" "$HOME/Library/Caches/Vyla Home" "$HOME/Library/WebKit/com.vyla.home" "$HOME/Library/WebKit/vyla-home" "$HOME/Library/WebKit/Vyla Home" "$HOME/Library/Logs/Vyla Home" "$HOME/Library/Preferences/com.vyla.home.plist" "$HOME/.vyla-home" "/Applications/Vyla Home.app" "/Applications/vyla-home.app" "$HOME/Applications/Vyla Home.app" "$HOME/Applications/vyla-home.app" "src-tauri/target" "dist-build" "temp-validation-extract" "dist" "frontend" "player" "auth-proxy" "stream-api" "logs" "*.log" "download-temp.zip" "update-payload.zip" "manifest.json" "validation-report.json" "config/encrypted-credentials.json" "config/credentials.json"; echo "Vyla Home cleanup complete."'

DOCUEMENTATION/FIXES.md

@@ -0,0 +1,3 @@
+If someone get's a Webview2 error, they need to download the WebView2Loader.dll and drag it in bin
+
+bin\WebView2Loader.dll

LICENSE

@@ -0,0 +1,47 @@
+Vyla Home Attribution License (VHAL) v1.0
+
+Copyright (c) 2026 Vyla Entertainment
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Vyla Home source code and associated documentation (the “Software”), to use, copy, modify, merge, publish, and distribute the Software, subject to the following conditions:
+
+1. Attribution
+
+Any public distribution, publication, derivative work, modified version, or substantial use of the Software must provide clear and visible credit to Vyla Entertainment and Vyla Home.
+
+The attribution must substantially state:
+
+“Based on Vyla Home by Vyla Entertainment”
+
+The attribution must appear in a location reasonably visible to users of the Software, such as an About page, credits section, documentation, repository, application information page, or other comparable location.
+
+2. Preservation of License
+
+Copies or substantial portions of the Software must include a copy of this license and the original copyright notice.
+
+3. Modified Versions
+
+Modified versions may be created and distributed under different terms, provided that the attribution requirements of Section 1 and the preservation requirements of Section 2 remain in effect.
+
+4. No Implication of Endorsement
+
+Use of the Software does not grant permission to imply that Vyla Entertainment endorses, sponsors, or officially supports any modified version or derivative work unless Vyla Entertainment has provided explicit written permission.
+
+5. Trademarks
+
+This license does not grant permission to use the Vyla Entertainment or Vyla Home names, logos, trademarks, service marks, or other branding except as necessary to satisfy the attribution requirement of this license.
+
+6. Commercial Use
+
+Commercial use, sale, and distribution of the Software and derivative works are permitted, provided that all applicable requirements of this license are satisfied.
+
+7. No Warranty
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+IN NO EVENT SHALL VYLA ENTERTAINMENT OR THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+8. Acceptance
+
+By using, copying, modifying, publishing, or distributing the Software, you agree to the terms of this license.
+
+If any provision of this license is found to be unenforceable, the remaining provisions shall remain in effect.

README.md

@@ -1,30 +1,24 @@
-# Vyla Home Engine
+# Vyla Home
 
-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.
+A desktop application that provides a fast, secure, and private way to access the Vyla media ecosystem. Vyla Home runs everything locally on your computer, giving you quick access to streaming services without relying on external servers.
 
-## Architecture & Security
+## What It Does
 
-Vyla Home is designed around complete local isolation to maximize speed, privacy, and reliability:
+Vyla Home is a native desktop app that:
 
-- **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.
+- **Runs locally** - All services run on your computer for maximum privacy and speed
-- **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.
+- **Manages streaming services** - Handles authentication and streaming APIs automatically
-- **Cryptographic Obfuscation**: Client configurations and credentials are secured on-disk via hardware-derived AES-256-GCM encryption.
+- **Updates automatically** - Keeps itself up to date with the latest features and fixes
-- **Automated Integrity Patching**: Payloads are dynamically verified using SHA-256 checksums and patched in-memory via C-level buffer scans.
+- **Works offline** - Core functionality doesn't require constant internet connectivity
+- **Keeps your data secure** - Your credentials and settings are encrypted and stored locally
 
-## Build Requirements
+## How It Works
 
-- [Rust](https://www.rust-lang.org/) (Latest Stable)
+When you launch Vyla Home, it:
-- [Node.js](https://nodejs.org/) (v20+ LTS)
-- Tauri CLI (`npm install -g @tauri-apps/cli`)
 
-## Compilation
+1. Starts the necessary background services (media player server)
+2. Loads your saved settings and credentials (encrypted for security)
+3. Checks for updates and installs them if available
+4. Opens the user interface in a secure, embedded browser window
 
-The build pipeline has been optimized with Fat LTO and aggressive panic aborts to generate the smallest possible binary footprint.
+Everything happens on your machine - your data never leaves your computer except when communicating directly with streaming services.
-
-```bash
-npm install
-
-npm run build:payload
-
-npm run build
-```

build-pipeline.js

@@ -1,12 +1,11 @@
 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');
 
 const BUILD_DIR = path.join(__dirname, 'dist-build');
-const REPOS = ['frontend', 'player', 'auth-proxy', 'stream-api'];
+const REPOS = ['frontend', 'player'];
 
 const TEMP_EXTRACT_DIR = path.join(__dirname, 'temp-validation-extract');
 
@@ -15,24 +14,25 @@ const GITLAB_GROUP = 'vyla-entertainment';
 const REPO_CONFIG = {
   'frontend': { name: 'frontend', branch: 'main' },
   'player': { name: 'player', branch: 'main' },
-  'auth-proxy': { name: 'auth-proxy', branch: 'main' },
-  'stream-api': { name: 'stream-api', branch: 'main' },
 };
 
+const clonedRepos = new Set();
+
 function clonePrivateRepo(repoConfig, targetDir) {
+  if (fs.existsSync(targetDir)) {
+    console.log(`Removing stale ${repoConfig.name} before fresh clone...`);
+    fs.rmSync(targetDir, { recursive: true, force: true });
+  }
+
   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 +73,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 +153,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) {
@@ -196,12 +172,9 @@ function validatePayload(zipPath) {
   zip.extractAllTo(TEMP_EXTRACT_DIR, true);
 
   const requiredFiles = [
-    'player/index.html',
-    'auth-proxy/server.js',
-    'stream-api/server.js',
     'frontend/index.html'
   ];
-
+  
   const validationResults = {
     valid: true,
     errors: [],
@@ -357,9 +330,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,46 @@
+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"
+      - name: Verify bundled node permissions
+        script: |
+          if [ -f "bin/node" ]; then
+            chmod +x bin/node
+            xattr -cr bin/node || true
+            ls -la bin/node
+            file bin/node
+          fi
+          APP_NODE=$(find src-tauri/target/release/bundle -name "node" -path "*bin*" 2>/dev/null | head -1)
+          if [ -n "$APP_NODE" ]; then
+            chmod +x "$APP_NODE"
+            xattr -cr "$APP_NODE" || true
+            ls -la "$APP_NODE"
+          fi
+    artifacts:
+      - src-tauri/target/release/bundle/dmg/*.dmg
+      - src-tauri/target/release/bundle/macos/*.app

config/credentials-template.json

@@ -1,16 +1,5 @@
 {
     "player": {
-        "TMDB_KEY": "YOUR_TMDB_KEY_HERE",
+        "TMDB_KEY": "YOUR_TMDB_KEY_HERE"
-        "API_KEY": "YOUR_API_KEY_HERE"
-    },
-    "auth-proxy": {
-        "VITE_API_KEY": "YOUR_VITE_API_KEY_HERE",
-        "PROXY_VITE_API_KEY": "YOUR_PROXY_VITE_API_KEY_HERE"
-    },
-    "stream-api": {
-        "TMDB_API_KEY": "YOUR_TMDB_API_KEY_HERE",
-        "GA_MEASUREMENT_ID": "YOUR_GA_MEASUREMENT_ID_HERE",
-        "GA_API_SECRET": "YOUR_GA_API_SECRET_HERE",
-        "TOKEN_SECRET": "YOUR_TOKEN_SECRET_HERE"
     }
 }

config/env.json

@@ -1,20 +1,5 @@
 {
   "player": {
-    "PORT": "3001",
+    "PORT": "3000"
-    "BASE_URL": "http://localhost:7860",
-    "BYPASS_AUTH": "true"
-  },
-  "auth-proxy": {
-    "PORT": "3000",
-    "VITE_BASE_URL": "http://localhost:7860",
-    "DEV_BYPASS_AUTH": "true"
-  },
-  "stream-api": {
-    "PORT": "7860",
-    "PROXY_URL": "https://txt.primebox.workers.dev",
-    "PROXY_STREAMS": "true",
-    "ENABLE_DEBUG_ROUTE": "true",
-    "BYPASS_AUTH": "true",
-    "TOKEN_SECRET": "vyla_default_secure_token_secret_local_dev_32chars"
   }
 }

config/replacements.json

@@ -2,40 +2,17 @@
   "frontend": [
     {
       "find": "https://player.vyla.cc",
-      "replace": "http://localhost:3001"
+      "replace": "http://localhost:3000"
     },
     {
       "find": "http://player.vyla.cc",
-      "replace": "http://localhost:3001"
-    },
-    {
-      "find": "https://api.vyla.cc",
-      "replace": "http://localhost:7860"
-    },
-    {
-      "find": "https://auth.vyla.cc",
       "replace": "http://localhost:3000"
     }
   ],
   "player": [
-    {
-      "find": "https://api.vyla.cc",
-      "replace": "http://localhost:7860"
-    },
-    {
-      "find": "https://auth.vyla.cc",
-      "replace": "http://localhost:3000"
-    },
     {
       "find": "https://player.vyla.cc",
       "replace": "http://localhost:4890"
     }
-  ],
+  ]
-  "auth-proxy": [
-    {
-      "find": "https://player.vyla.cc",
-      "replace": "http://localhost:3001"
-    }
-  ],
-  "stream-api": []
 }

github-client.js

@@ -4,9 +4,7 @@ const path = require('path');
 
 const REPOS = {
     frontend: { branch: 'main' },
-    player: { branch: 'main' },
+    player: { branch: 'main' }
-    'stream-api': { branch: 'main' },
-    'auth-proxy': { branch: 'main' }
 };
 
 const GITLAB_GROUP = 'vyla-entertainment';

main.js

@@ -6,10 +6,19 @@ const ServiceManager = require('./service-manager');
 const Patcher = require('./patcher');
 const UpdateClient = require('./update-client');
 
-const defaultAppData = path.join(os.homedir(), 'AppData', 'Roaming', 'vyla-home', 'vyla-home-files');
+function getDefaultAppData() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'vyla-home', 'vyla-home-files');
+  }
+  if (process.platform === 'linux') {
+    return path.join(os.homedir(), '.local', 'share', 'vyla-home', 'vyla-home-files');
+  }
+  return path.join(os.homedir(), 'AppData', 'Roaming', 'vyla-home', 'vyla-home-files');
+}
+
 const APPDATA_DIR = (process.env.APPDATA_PATH && !process.env.APPDATA_PATH.includes('com.vyla.home'))
   ? process.env.APPDATA_PATH
-  : defaultAppData;
+  : getDefaultAppData();
 
 const LOGS_DIR = path.join(APPDATA_DIR, 'logs');
 try { fs.mkdirSync(LOGS_DIR, { recursive: true }); } catch (e) { }
@@ -25,8 +34,7 @@ debugLog("--- Node.js Process Started ---");
 let serviceManager;
 let expressApp;
 let expressServer;
-let playerExpressApp;
+let updateDecisionHandler = null;
-let playerExpressServer;
 
 debugLog(`AppData Dir: ${APPDATA_DIR}`);
 
@@ -77,18 +85,40 @@ cmdApp.use((req, res, next) => {
   if (req.method === 'OPTIONS') return res.sendStatus(200);
   next();
 });
+cmdApp.all('/update/:choice', (req, res) => {
+  const c = String(req.params.choice).toLowerCase();
+  if (updateDecisionHandler) {
+    if (c === 'yes' || c === 'true' || c === 'install') updateDecisionHandler(true);
+    if (c === 'no' || c === 'false' || c === 'skip') updateDecisionHandler(false);
+  }
+  res.sendStatus(200);
+});
 cmdApp.get('/__tauri_cmd/:cmd', (req, res) => {
+  const cmd = req.params.cmd;
+  if (updateDecisionHandler) {
+    if (cmd === 'update_yes' || cmd === 'update_install') updateDecisionHandler(true);
+    if (cmd === 'update_no' || cmd === 'update_skip') updateDecisionHandler(false);
+  }
   debugLog(`[CMD-SERVER:4892] Command received: ${req.params.cmd} (window: ${req.query.window || 'main'})`);
   sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
   res.sendStatus(200);
 });
-cmdApp.listen(4892, '127.0.0.1', () => debugLog("[CMD-SERVER] Dedicated command server listening on 127.0.0.1:4892"));
+cmdApp.listen(4892, '127.0.0.1', () => debugLog("[CMD-SERVER] Dedicated command server listening on port 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) { }
 });
@@ -99,8 +129,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);
 
@@ -109,10 +152,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;
 
@@ -122,9 +168,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...');
@@ -145,12 +195,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);
         }
@@ -172,10 +224,60 @@ 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}`);
+
+    function findLocalZip() {
+      const searchRoots = [__dirname, process.cwd(), path.join(__dirname, '../../..')];
+      for (const root of searchRoots) {
+        let cur = root;
+        for (let i = 0; i < 6; i++) {
+          try {
+            const zp = path.join(cur, 'update-payload.zip');
+            if (fs.existsSync(zp)) {
+              const mp = path.join(cur, 'manifest.json');
+              return { zipPath: zp, manifestPath: fs.existsSync(mp) ? mp : null };
+            }
+            const parent = path.dirname(cur);
+            if (parent === cur) break;
+            cur = parent;
+          } catch (e) { }
+        }
+      }
+      return null;
+    }
+
+    const localFound = findLocalZip();
+    let localZipPath = localFound ? localFound.zipPath : null;
+    let localManifestPath = localFound ? localFound.manifestPath : null;
+    let localZipManifest = null;
+
+    if (localManifestPath) {
+      try {
+        localZipManifest = JSON.parse(fs.readFileSync(localManifestPath, 'utf8'));
+      } catch (e) { }
+    }
+
+    if (localZipPath && (isFirstRun || (localZipManifest && localZipManifest.sha256 !== localSha))) {
+      debugLog(`Applying local development payload from: ${localZipPath}`);
+      sendToTauri('status', { message: 'Extracting local development payload...' });
+      patcher.purgeOldCode();
+      patcher.extractZipPayload(localZipPath);
+      patcher.applyPatches(getReplacementsConfig());
+      patcher.bridgeCredentials(serviceManager.credentialManager);
+
+      const ver = localZipManifest ? localZipManifest.version : '1.1.32';
+      const sha = localZipManifest ? localZipManifest.sha256 : null;
+      patcher.saveCurrentVersion(ver, sha);
+      serviceManager.envConfig = getEnvConfig();
+
+      isFirstRun = false;
+      localVersion = ver;
+      localSha = sha;
+      debugLog("Local payload applied successfully.");
+    }
 
     sendToTauri('status', { message: 'Connecting to update servers...' });
     let release = null;
@@ -183,23 +285,61 @@ async function start() {
       debugLog("Fetching updates from updateClient...");
       release = await updateClient.checkForUpdates();
       debugLog(`Update check finished. Found: ${release ? release.version : 'None'}`);
+
+      let appPkgVer = '0.0.0';
+      try {
+        appPkgVer = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')).version || '0.0.0';
+      } catch (e) { }
+
+      if (release && release.version) {
+        const rVer = release.version.replace('v', '').split('.').map(Number);
+        const aVer = appPkgVer.split('.').map(Number);
+        let isOlder = false;
+        for (let i = 0; i < 3; i++) {
+          if ((rVer[i] || 0) < (aVer[i] || 0)) { isOlder = true; break; }
+          if ((rVer[i] || 0) > (aVer[i] || 0)) { break; }
+        }
+        if (isOlder) {
+          debugLog(`Remote version ${release.version} is older than local package ${appPkgVer}. Ignoring remote release.`);
+          release = null;
+        }
+      }
     } catch (e) {
       debugLog(`Update check failed (offline?): ${e.message}`);
       sendToTauri('status', { message: `Update server check skipped (${e.message})` });
     }
 
+    const normalizeVer = (v) => (v || '').toString().replace(/^v/, '').trim();
+
     if (release) {
-      const hasUpdate = release.version !== localVersion || (release.sha256 && release.sha256 !== localSha);
+      const isNewerSha = release.sha256 && localSha && release.sha256 !== localSha;
+      const isDifferentVer = normalizeVer(release.version) !== normalizeVer(localVersion);
+      const hasUpdate = (isDifferentVer || isNewerSha) && !localZipPath;
+
       if (isFirstRun) {
-        debugLog("First run. Installing remote build...");
+        debugLog("First run with no local payload. 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...` });
 
+        try {
+          if (process.platform === 'win32') {
+            require('child_process').spawnSync('powershell.exe', [
+              '-NoProfile', '-NonInteractive', '-Command',
+              `Get-NetTCPConnection -LocalPort 4891 -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force }`
+            ], { stdio: 'ignore', windowsHide: true });
+          } else {
+            require('child_process').spawnSync('fuser', ['-k', '-9', `4891/tcp`], { stdio: 'ignore' });
+          }
+        } catch (e) { }
+
         const tempApp = express();
         let userDecision = null;
+        updateDecisionHandler = (val) => { userDecision = val; };
+
         tempApp.use((req, res, next) => {
           res.header('Access-Control-Allow-Origin', '*');
           res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
@@ -210,20 +350,45 @@ async function start() {
         tempApp.get('/update/info', (req, res) => {
           res.json({ available: true, current: localVersion, latest: release.version });
         });
-        tempApp.post('/update/yes', (req, res) => { userDecision = true; res.sendStatus(200); });
+        const handleYes = (req, res) => { debugLog("tempApp received YES"); userDecision = true; res.sendStatus(200); };
-        tempApp.post('/update/no', (req, res) => { userDecision = false; res.sendStatus(200); });
+        const handleNo = (req, res) => { debugLog("tempApp received NO"); userDecision = false; res.sendStatus(200); };
+
+        tempApp.all('/update/yes', handleYes);
+        tempApp.all('/update/install', handleYes);
+        tempApp.all('/update/no', handleNo);
+        tempApp.all('/update/skip', handleNo);
+        tempApp.all('/update/:choice', (req, res) => {
+          const c = String(req.params.choice || '').toLowerCase();
+          if (c === 'yes' || c === 'install' || c === 'true') userDecision = true;
+          if (c === 'no' || c === 'skip' || c === 'false') userDecision = false;
+          res.sendStatus(200);
+        });
 
         const tempServer = await new Promise((resolve) => {
           const s = tempApp.listen(4891, '127.0.0.1', () => resolve(s));
+          s.on('error', (err) => {
+            debugLog(`Update server bind error: ${err.message}`);
+            resolve(null);
+          });
         });
 
         sendToTauri('update-available', { current: localVersion, latest: release.version });
 
+        let waitLoops = 0;
         while (userDecision === null) {
+          if (waitLoops > 24000) {
+            debugLog("Update decision timed out after 10 minutes, defaulting to skip.");
+            userDecision = false;
+            break;
+          }
+          waitLoops++;
           await new Promise(r => setTimeout(r, 25));
         }
 
-        await new Promise((resolve) => tempServer.close(resolve));
+        updateDecisionHandler = null;
+        if (tempServer) {
+          tempServer.close();
+        }
 
         if (userDecision) {
           debugLog("User accepted update.");
@@ -244,9 +409,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!");
@@ -255,51 +428,21 @@ 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.');
+      throw new Error('No application files found. Ensure you ran "npm run build:payload" and the extraction succeeded.');
     }
 
     sendToTauri('status', { message: 'Loading encrypted credentials...' });
     serviceManager.credentialManager.loadCredentials();
 
-    sendToTauri('status', { message: 'Starting background services (auth-proxy, stream-api)...' });
+    sendToTauri('status', { message: 'Starting background services (player)...' });
     await serviceManager.startServices([
-      { name: 'auth-proxy', relativeDir: 'auth-proxy' },
+      { name: 'player', relativeDir: 'player', startScript: 'server.js' }
-      { name: 'stream-api', relativeDir: 'stream-api' },
     ]);
     debugLog("Backend services spawn requested.");
 
-    sendToTauri('status', { message: 'Binding player web server on port 3001...' });
+    sendToTauri('status', { message: 'Waiting for microservices to bind port 3000...' });
-    const playerDir = path.join(APPDATA_DIR, 'player');
+    await serviceManager.waitForPorts([3000]);
-    playerExpressApp = express();
+    debugLog("Port 3000 is ready.");
-    playerExpressApp.use((req, res, next) => {
-      res.header('Access-Control-Allow-Origin', '*');
-      res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
-      res.header('Access-Control-Allow-Headers', '*');
-      if (req.method === 'OPTIONS') return res.sendStatus(200);
-      next();
-    });
-    playerExpressApp.get('/__tauri_cmd/:cmd', (req, res) => {
-      debugLog(`[PLAYER-SERVER:3001] Command received: ${req.params.cmd} (window: ${req.query.window || 'main'})`);
-      sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
-      res.sendStatus(200);
-    });
-    playerExpressApp.use(sameTabNavMiddleware(playerDir));
-    playerExpressApp.use(express.static(playerDir, {
-      etag: false,
-      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)...' });
-    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');
@@ -324,6 +467,12 @@ async function start() {
         res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
       }
     }));
+    expressApp.use(express.static(path.join(frontendDir, 'src'), {
+      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'));
@@ -331,14 +480,11 @@ async function start() {
 
     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, '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}` });
+      sendToTauri('ready', { url: `http://127.0.0.1:${FRONTEND_PORT}` });
     });
 
   } catch (error) {
@@ -351,17 +497,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.8",
+  "version": "1.1.42",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -11,17 +11,16 @@
     "release:full": "node release.js --installer"
   },
   "dependencies": {
-    "@tauri-apps/api": "^2.0.0",
+    "@tauri-apps/api": "^2.12.1",
-    "@tauri-apps/plugin-opener": "^2.0.0",
+    "@tauri-apps/plugin-opener": "^2.7.0",
-    "@tauri-apps/plugin-process": "^2.0.0",
+    "@tauri-apps/plugin-process": "^2.4.0",
-    "@tauri-apps/plugin-shell": "^2.0.0",
+    "@tauri-apps/plugin-shell": "^2.4.0",
-    "@vyla-entertainment/sdk": "^1.11.0",
+    "@vyla-entertainment/sdk": "^1.16.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",
@@ -55,4 +54,4 @@
       "installerHeaderIcon": "build/icon.ico"
     }
   }
-}
+}

patcher.js

@@ -2,7 +2,6 @@ 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 {
@@ -64,22 +63,46 @@ 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) {
+    const AdmZip = require('adm-zip');
     const zip = new AdmZip(zipPath);
+    const entries = zip.getEntries();
+
+    if (!entries || entries.length === 0) {
+      throw new Error('Downloaded archive is empty, invalid, or truncated.');
+    }
+
     zip.extractAllTo(this.appDataPath, true);
+
+    const testPath = path.join(this.appDataPath, 'frontend', 'index.html');
+    if (!fs.existsSync(testPath)) {
+      const { execSync } = require('child_process');
+      if (process.platform === 'win32') {
+        execSync(`powershell.exe -NoProfile -NonInteractive -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${this.appDataPath}' -Force"`, { windowsHide: true });
+      } else {
+        execSync(`unzip -o "${zipPath}" -d "${this.appDataPath}"`);
+      }
+    }
   }
 
   verifyChecksum(zipPath, expectedSha256) {
@@ -93,10 +116,8 @@ class Patcher {
 
   verifyExtraction() {
     const requiredFiles = [
-      'player/index.html',
+      'frontend/index.html',
-      'auth-proxy/server.js',
+      'player/server.js'
-      'stream-api/server.js',
-      'frontend/index.html'
     ];
 
     for (const file of requiredFiles) {
@@ -108,12 +129,16 @@ class Patcher {
       if (stat.size === 0) {
         return false;
       }
-      const sampleSize = Math.min(stat.size, 4096);
+      try {
-      const fd = fs.openSync(fullPath, 'r');
+        const sampleSize = Math.min(stat.size, 4096);
-      const buffer = Buffer.alloc(sampleSize);
+        const fd = fs.openSync(fullPath, 'r');
-      fs.readSync(fd, buffer, 0, sampleSize, 0);
+        const buffer = Buffer.alloc(sampleSize);
-      fs.closeSync(fd);
+        fs.readSync(fd, buffer, 0, sampleSize, 0);
-      if (buffer.every(byte => byte === 0)) {
+        fs.closeSync(fd);
+        if (buffer.every(byte => byte === 0)) {
+          return false;
+        }
+      } catch (e) {
         return false;
       }
     }
@@ -141,43 +166,6 @@ class Patcher {
           }
         }
 
-        if (ext === '.js') {
-          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');
         }
@@ -186,7 +174,7 @@ class Patcher {
   }
 
   applyPatches(replacements) {
-    const targetDirs = ['frontend', 'player', 'auth-proxy', 'stream-api'];
+    const targetDirs = ['frontend', 'player'];
     for (const dirName of targetDirs) {
       const dirPath = path.join(this.appDataPath, dirName);
       if (!fs.existsSync(dirPath)) continue;

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,65 @@ 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 });
+
+                    const extractedNode = path.join(binDir, tarName, 'bin', 'node');
+                    const finalNode = path.join(binDir, 'node');
+
+                    fs.renameSync(extractedNode, finalNode);
+                    fs.rmSync(path.join(binDir, tarName), { recursive: true, force: true });
+                    fs.unlinkSync(tarPath);
+
+                    fs.chmodSync(finalNode, 0o755);
+
+                    try {
+                        execSync(`xattr -d com.apple.quarantine "${finalNode}"`);
+                    } catch (_) { }
+
+                    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

@@ -40,18 +40,16 @@ class ServiceManager {
     }
 
     let tokenSecret = process.env.TOKEN_SECRET ||
-      process.env.STREAM_API_TOKEN_SECRET ||
+      this.credentialManager.getCredential('player', 'TOKEN_SECRET');
-      this.credentialManager.getCredential('stream-api', 'TOKEN_SECRET');
 
     if (!tokenSecret || tokenSecret.length < 32) {
       tokenSecret = require('crypto').randomBytes(32).toString('hex');
-      this.credentialManager.setCredential('stream-api', 'TOKEN_SECRET', tokenSecret);
+      this.credentialManager.setCredential('player', 'TOKEN_SECRET', tokenSecret);
     }
 
     const env = {
       ...process.env,
       TOKEN_SECRET: tokenSecret,
-      STREAM_API_TOKEN_SECRET: tokenSecret,
       ...(this.envConfig[name] || {}),
       ...(this.credentialManager.getServiceCredentials(name) || {})
     };

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.1.8"
+version = "1.1.42"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -16,6 +16,9 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 base64 = "0.22"
 
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.5"
+
 [profile.release]
 opt-level = 3
 lto = true

src-tauri/Info.plist

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>NSAppTransportSecurity</key>
+  <dict>
+    <key>NSAllowsLocalNetworking</key>
+    <true/>
+    <key>NSAllowsArbitraryLoads</key>
+    <true/>
+  </dict>
+</dict>
+</plist>

src-tauri/build.rs

@@ -1,5 +1,32 @@
 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);
+            }
+        }
+    }
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let node_path = std::path::Path::new("../bin/node");
+        if node_path.exists() {
+            let _ = std::fs::set_permissions(
+                node_path,
+                std::fs::Permissions::from_mode(0o755),
+            );
+        }
+    }
+    
     tauri_build::build();
 }

src-tauri/gen/schemas/desktop-schema.json

@@ -626,6 +626,12 @@
           "const": "core:app:allow-default-window-icon",
           "markdownDescription": "Enables the default_window_icon command without any pre-configured scope."
         },
+        {
+          "description": "Enables the exit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-exit",
+          "markdownDescription": "Enables the exit command without any pre-configured scope."
+        },
         {
           "description": "Enables the fetch_data_store_identifiers command without any pre-configured scope.",
           "type": "string",
@@ -716,6 +722,12 @@
           "const": "core:app:deny-default-window-icon",
           "markdownDescription": "Denies the default_window_icon command without any pre-configured scope."
         },
+        {
+          "description": "Denies the exit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-exit",
+          "markdownDescription": "Denies the exit command without any pre-configured scope."
+        },
         {
           "description": "Denies the fetch_data_store_identifiers command without any pre-configured scope.",
           "type": "string",
@@ -1976,6 +1988,12 @@
           "const": "core:window:allow-set-fullscreen",
           "markdownDescription": "Enables the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Enables the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-fullscreen-on-monitor",
+          "markdownDescription": "Enables the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_icon command without any pre-configured scope.",
           "type": "string",
@@ -2444,6 +2462,12 @@
           "const": "core:window:deny-set-fullscreen",
           "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Denies the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-fullscreen-on-monitor",
+          "markdownDescription": "Denies the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_icon command without any pre-configured scope.",
           "type": "string",

src-tauri/gen/schemas/windows-schema.json

@@ -626,6 +626,12 @@
           "const": "core:app:allow-default-window-icon",
           "markdownDescription": "Enables the default_window_icon command without any pre-configured scope."
         },
+        {
+          "description": "Enables the exit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-exit",
+          "markdownDescription": "Enables the exit command without any pre-configured scope."
+        },
         {
           "description": "Enables the fetch_data_store_identifiers command without any pre-configured scope.",
           "type": "string",
@@ -716,6 +722,12 @@
           "const": "core:app:deny-default-window-icon",
           "markdownDescription": "Denies the default_window_icon command without any pre-configured scope."
         },
+        {
+          "description": "Denies the exit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-exit",
+          "markdownDescription": "Denies the exit command without any pre-configured scope."
+        },
         {
           "description": "Denies the fetch_data_store_identifiers command without any pre-configured scope.",
           "type": "string",
@@ -1976,6 +1988,12 @@
           "const": "core:window:allow-set-fullscreen",
           "markdownDescription": "Enables the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Enables the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-fullscreen-on-monitor",
+          "markdownDescription": "Enables the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Enables the set_icon command without any pre-configured scope.",
           "type": "string",
@@ -2444,6 +2462,12 @@
           "const": "core:window:deny-set-fullscreen",
           "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Denies the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-fullscreen-on-monitor",
+          "markdownDescription": "Denies the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_icon command without any pre-configured scope.",
           "type": "string",

src-tauri/src/main.rs

@@ -11,12 +11,17 @@ fn debug_log(msg: &str) {
             .join("vyla-home")
             .join("vyla-home-files")
             .join("logs")
+    } else if let Ok(home) = std::env::var("HOME") {
+        std::path::PathBuf::from(home)
+            .join("Library")
+            .join("Logs")
+            .join("VylaHome")
     } else if let Ok(user_profile) = std::env::var("USERPROFILE") {
         std::path::PathBuf::from(user_profile)
             .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);
@@ -50,17 +55,38 @@ fn clean_path(path: &std::path::Path) -> String {
 }
 
 fn kill_child_process(child: &mut Child) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        let _ = Command::new("taskkill")
+            .args(&["/F", "/T", "/PID", &child.id().to_string()])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+    }
     let _ = child.kill();
     let _ = child.wait();
 }
 
 fn find_node_binary(app: &tauri::App) -> Option<String> {
     if let Ok(resource_dir) = app.path().resource_dir() {
+        #[cfg(windows)]
         let candidates = [
             resource_dir.join("bin").join("node.exe"),
             resource_dir.join("node.exe"),
             resource_dir.join("_up_").join("bin").join("node.exe"),
             resource_dir.join("_up_").join("node.exe"),
+            resource_dir.join("up").join("bin").join("node.exe"),
+            resource_dir.join("up").join("node.exe"),
+        ];
+        #[cfg(not(windows))]
+        let candidates = [
+            resource_dir.join("bin").join("node"),
+            resource_dir.join("node"),
+            resource_dir.join("_up_").join("bin").join("node"),
+            resource_dir.join("_up_").join("node"),
+            resource_dir.join("up").join("bin").join("node"),
+            resource_dir.join("up").join("node"),
         ];
         for candidate in candidates {
             if candidate.exists() {
@@ -73,9 +99,13 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
         if let Some(parent) = exe_path.parent() {
             let candidates = [
                 parent.join("bin").join("node.exe"),
+                parent.join("bin").join("node"),
                 parent.join("node.exe"),
+                parent.join("node"),
                 parent.join("resources").join("bin").join("node.exe"),
+                parent.join("resources").join("bin").join("node"),
                 parent.join("resources").join("node.exe"),
+                parent.join("resources").join("node"),
             ];
             for candidate in candidates {
                 if candidate.exists() {
@@ -87,9 +117,14 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
 
     if let Ok(path_var) = std::env::var("PATH") {
         for p in std::env::split_paths(&path_var) {
-            let candidate = p.join("node.exe");
+            let node_exe = p.join("node.exe");
-            if candidate.exists() {
+            if node_exe.exists() {
-                return Some(clean_path(&candidate));
+                return Some(clean_path(&node_exe));
+            }
+                
+            let node = p.join("node");
+            if node.exists() {
+                return Some(clean_path(&node));
             }
         }
     }
@@ -118,6 +153,22 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
         }
     }
 
+    #[cfg(not(windows))]
+    {
+        let default_paths = [
+            "/usr/local/bin/node",
+            "/usr/bin/node",
+            "/opt/homebrew/bin/node",
+            "/opt/local/bin/node",
+        ];
+        for path in default_paths {
+            let candidate = std::path::Path::new(path);
+            if candidate.exists() {
+                return Some(clean_path(candidate));
+            }
+        }
+    }
+
     None
 }
 
@@ -126,8 +177,8 @@ fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
         let candidates = vec![
             resource_dir.join("main.js"),
             resource_dir.join("_up_").join("main.js"),
+            resource_dir.join("up").join("main.js"),
         ];
-
         for candidate in candidates {
             if candidate.exists() {
                 let root_dir = candidate.parent().unwrap();
@@ -144,7 +195,34 @@ 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##"
+
+    window.vylaHome = {
+        sendUpdateChoice: function(choice) {
+            var action = choice ? 'yes' : 'no';
+            [4891, 4892].forEach(function(port) {
+                ['127.0.0.1', 'localhost'].forEach(function(host) {
+                    fetch('http://' + host + ':' + port + '/update/' + action, { method: 'POST' }).catch(function() {});
+                    fetch('http://' + host + ':' + port + '/update/' + action, { method: 'GET' }).catch(function() {});
+                    fetch('http://' + host + ':' + port + '/__tauri_cmd/update_' + action, { method: 'GET' }).catch(function() {});
+                });
+            });
+        }
+    };
+
+    document.addEventListener('click', function(e) {
+        var el = e.target.closest('button, a, .btn');
+        if (!el) return;
+        var text = (el.innerText || el.textContent || '').toLowerCase();
+        var id = (el.id || '').toLowerCase();
+        if (id.includes('install') || id.includes('update-yes') || text.includes('install update')) {
+            window.vylaHome.sendUpdateChoice(true);
+        } else if (id.includes('skip') || id.includes('update-no') || text.includes('skip')) {
+            window.vylaHome.sendUpdateChoice(false);
+        }
+    }, true);
+
     function doInvoke(cmd, args) {
         if (window.__TAURI__ && window.__TAURI__.core) {
             return window.__TAURI__.core.invoke(cmd, args || {});
@@ -196,17 +274,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;
@@ -218,7 +285,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;
@@ -228,12 +295,12 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 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;
@@ -248,7 +315,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 pointer-events: auto !important;
                 padding: 0 !important;
             }
-
+                
             .vyla-nav-logo-wrap img {
                 width: 26px !important;
                 height: 26px !important;
@@ -258,7 +325,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 pointer-events: none !important;
                 display: block !important;
             }
-
+                
             .vyla-nav-links {
                 display: flex !important;
                 align-items: center !important;
@@ -271,13 +338,13 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 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;
@@ -296,11 +363,8 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 opacity: 0.85 !important;
                 padding: 0 !important;
             }
-
+                
-            .vyla-nav-btn:hover {
+            .vyla-nav-btn:hover { opacity: 1 !important; }
-                opacity: 1 !important;
-            }
-
             .vyla-nav-btn svg {
                 width: 20px !important;
                 height: 20px !important;
@@ -308,7 +372,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 pointer-events: none !important;
                 display: block !important;
             }
-
+                
             #tauri-custom-titlebar {
                 position: fixed !important;
                 top: 0 !important;
@@ -326,7 +390,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 margin: 0 !important;
                 padding: 0 !important;
             }
-
+                
             .tauri-drag-region {
                 position: absolute !important;
                 inset: 0 !important;
@@ -334,7 +398,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 cursor: default !important;
                 pointer-events: auto !important;
             }
-
+                
             .tauri-window-controls {
                 display: flex !important;
                 height: 32px !important;
@@ -343,7 +407,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 pointer-events: auto !important;
                 z-index: 2147483648 !important;
             }
-
+                
             button.tauri-btn {
                 width: 46px !important;
                 min-width: 46px !important;
@@ -358,33 +422,13 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                 cursor: pointer !important;
                 outline: 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; }
         `;
         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 = `
@@ -404,7 +448,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
             logoBtn.onclick = (e) => {
                 e.preventDefault();
                 e.stopPropagation();
-                window.location.href = 'http://localhost:4890';
+                window.location.href = 'http://127.0.0.1:4890';
             };
         }
 
@@ -417,54 +461,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 = `
@@ -495,11 +491,12 @@ const LINK_HANDLER_SCRIPT: &str = r##"
         }
     }
 
-  if (document.readyState === 'loading') {
+    if (document.readyState === 'loading') {
         document.addEventListener('DOMContentLoaded', injectLiquidNavBar);
     } else {
         injectLiquidNavBar();
     }
+
     const navObserver = new MutationObserver(() => {
         if (!document.getElementById('vyla-floating-nav')) {
             injectLiquidNavBar();
@@ -543,9 +540,9 @@ fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
     let final_url = if url.starts_with("http") || url.starts_with("tauri://") {
         url.clone()
     } else if url.starts_with('/') {
-        format!("http://localhost:4890{}", url)
+        format!("http://127.0.0.1:4890{}", url)
     } else {
-        format!("http://localhost:4890/{}", url)
+        format!("http://127.0.0.1:4890/{}", url)
     };
 
     if let Some(window) = app.get_webview_window("main") {
@@ -561,6 +558,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;
@@ -594,6 +615,123 @@ fn get_logo_base64(app: tauri::AppHandle) -> Result<String, String> {
     Err("icon_white.png not found".to_string())
 }
 
+fn handle_tauri_cmd(w: &tauri::WebviewWindow, msg: &BackendMessage) {
+    let window_label = msg
+        .data
+        .get("window")
+        .and_then(|v| v.as_str())
+        .unwrap_or("main");
+
+    debug_log(&format!("[MAIN-DEBUG] Finding window by label: {}", window_label));
+
+    let cmd_window = match w.app_handle().get_webview_window(window_label) {
+        Some(win) => win,
+        None => {
+            debug_log(&format!("[TAURI-CMD] Window '{}' NOT FOUND!", window_label));
+            return;
+        }
+    };
+
+    let cmd = match msg.data.get("cmd").and_then(|c| c.as_str()) {
+        Some(c) => c,
+        None => return,
+    };
+
+    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));
+        }
+        "win_maximize" => {
+            let is_max = cmd_window.is_maximized().unwrap_or(false);
+            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));
+        }
+        "win_drag" => {
+            let res = cmd_window.start_dragging();
+            debug_log(&format!("[TAURI-CMD] Drag result: {:?}", res));
+        }
+        "open_new_window" => {
+            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()
+            ));
+
+            let url = match msg.data.get("url").and_then(|u| u.as_str()) {
+                Some(u) => u.to_string(),
+                None => {
+                    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<_>>())
+                    ));
+                    return;
+                }
+            };
+
+            debug_log(&format!("[TAURI-CMD-DEBUG] URL extracted: {}", url));
+            debug_log(&format!("[TAURI-CMD-DEBUG] URL length: {}", url.len()));
+            debug_log("[TAURI-CMD-DEBUG] Attempting to dispatch to main thread");
+
+            let app_handle = w.app_handle().clone();
+            let closure_handle = app_handle.clone();
+
+            match 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) {
+                    Ok(_) => debug_log("[TAURI-CMD-DEBUG] open_new_window succeeded"),
+                    Err(e) => debug_log(&format!("[TAURI-CMD-DEBUG] open_new_window error: {}", e)),
+                }
+            }) {
+                Ok(_) => debug_log("[TAURI-CMD-DEBUG] Main thread dispatch succeeded"),
+                Err(e) => debug_log(&format!("[TAURI-CMD-DEBUG] Main thread dispatch failed: {}", e)),
+            }
+        }
+        _ => {}
+    }
+}
+
+fn handle_ready(w: &tauri::WebviewWindow, msg: &BackendMessage) {
+    let url_str = match msg.data.get("url").and_then(|u| u.as_str()) {
+        Some(u) => u,
+        None => return,
+    };
+
+    let url_parsed = match url_str.parse::<tauri::Url>() {
+        Ok(u) => u,
+        Err(_) => return,
+    };
+
+    #[cfg(target_os = "macos")]
+    {
+        use objc2::msg_send;
+        use objc2::runtime::AnyObject;
+        debug_log("Attempting with_webview on ready event");
+        let result = w.with_webview(|webview| unsafe {
+            debug_log("Inside with_webview closure");
+            let wk_webview = webview.inner() as *mut AnyObject;
+            let config: *mut AnyObject = msg_send![wk_webview, configuration];
+            let _: () = msg_send![config, setUpgradeKnownHostsToHTTPS: false];
+            debug_log("setUpgradeKnownHostsToHTTPS set to false");
+        });
+        debug_log(&format!("with_webview result: {:?}", result));
+    }
+
+    let _ = w.navigate(url_parsed);
+}
+
 fn main() {
     debug_log("=== Vyla Home Executable Started ===");
 
@@ -607,44 +745,72 @@ fn main() {
             win_close,
             win_drag,
             open_new_window,
-            get_logo_base64
+            get_logo_base64,
+            kill_orphans
         ])
         .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 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 if let Ok(home) = std::env::var("HOME") {
+                #[cfg(target_os = "macos")]
+                let base = std::path::PathBuf::from(&home)
+                    .join("Library")
+                    .join("Application Support");
+                #[cfg(target_os = "linux")]
+                let base = std::path::PathBuf::from(&home)
+                    .join(".local")
+                    .join("share");
+                #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+                let base = app_data.clone();
+                base.join("vyla-home").join("vyla-home-files")
+            } else {
+                app_data.join("vyla-home-files")
+            };
+
+            let _ = std::fs::create_dir_all(&vyla_files);
 
             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(cfg!(debug_assertions))
+                .devtools(true)
                 .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
                 .initialization_script(LINK_HANDLER_SCRIPT)
                 .build()?;
 
             let (main_js, root_dir) = resolve_script_and_root(app);
+            debug_log("Searching for node binary...");
+
             let node_bin = match find_node_binary(app) {
-                Some(bin) => bin,
+                Some(bin) => {
+                    debug_log(&format!("Found node binary: {}", bin));
+                    bin
+                }
                 None => {
-                    let _ = window.emit(
+                    debug_log("FATAL: No node binary found in bundle or PATH.");
-                        "error",
+                    std::thread::sleep(std::time::Duration::from_millis(600));
-                        serde_json::json!({
+                    let _ = window.eval("document.getElementById('status-message').textContent='Error: Node runtime missing. Please reinstall.';");
-                            "message": "Node.js runtime not found. Please ensure Node.js is installed or bundled correctly."
+                    let _ = window.eval("var b=document.getElementById('debug-log-box');b.style.display='block';b.textContent='Node binary not found. bin/node missing from app bundle or not executable.';");
-                        }),
-                    );
                     return Ok(());
                 }
             };
 
+            let vyla_files_str = clean_path(&vyla_files);
+            std::thread::sleep(std::time::Duration::from_millis(400));
+
             let mut cmd = Command::new(&node_bin);
             cmd.arg(&main_js)
                 .current_dir(&root_dir)
-                .env("APPDATA_PATH", &app_data_str)
+                .env("APPDATA_PATH", &vyla_files_str)
                 .env("NODE_EXE", &node_bin)
+                .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
 
@@ -661,12 +827,23 @@ fn main() {
                         "Node child process spawned successfully, PID: {}",
                         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) }),
+                                    );
+                                }
                             }
                         });
                     }
@@ -678,144 +855,27 @@ fn main() {
                             let reader = BufReader::new(stdout);
                             for line in reader.lines().flatten() {
                                 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()
-                                    ));
-                                    if msg.event == "tauri-cmd" {
-                                        let window_label = msg
-                                            .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) =
+                                let msg = match serde_json::from_str::<BackendMessage>(&line) {
-                                            w.app_handle().get_webview_window(window_label)
+                                    Ok(m) => m,
-                                        {
+                                    Err(_) => {
-                                            if let Some(cmd) =
+                                        if !line.trim().is_empty() {
-                                                msg.data.get("cmd").and_then(|c| c.as_str())
+                                            debug_log(&format!("[NODE RAW] {}", line));
-                                            {
-                                                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
-                                                        ));
-                                                    }
-                                                    "win_maximize" => {
-                                                        let is_max = cmd_window
-                                                            .is_maximized()
-                                                            .unwrap_or(false);
-                                                        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
-                                                        ));
-                                                    }
-                                                    "win_drag" => {
-                                                        let res = cmd_window.start_dragging();
-                                                        debug_log(&format!(
-                                                            "[TAURI-CMD] Drag result: {:?}",
-                                                            res
-                                                        ));
-                                                    }
-                                                    "open_new_window" => {
-                                                        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())
-                                                        {
-                                                            debug_log(&format!(
-                                                                "[TAURI-CMD-DEBUG] URL extracted: {}",
-                                                                url
-                                                            ));
-                                                            debug_log(&format!(
-                                                                "[TAURI-CMD-DEBUG] URL length: {}",
-                                                                url.len()
-                                                            ));
-                                                            debug_log("[TAURI-CMD-DEBUG] Attempting to dispatch to main thread");
-                                                            let app_handle = w.app_handle().clone();
-                                                            let closure_handle = app_handle.clone();
-                                                            let url_owned = url.to_string();
-                                                            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
-                                            ));
                                         }
-                                    } else {
+                                        continue;
+                                    }
+                                };
+
+                                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()
+                                ));
+
+                                match msg.event.as_str() {
+                                    "tauri-cmd" => handle_tauri_cmd(&w, &msg),
+                                    "ready" => handle_ready(&w, &msg),
+                                    _ => {
                                         let _ = w.emit(&msg.event, msg.data.clone());
                                     }
                                 }
@@ -830,18 +890,18 @@ fn main() {
                 }
                 Err(e) => {
                     debug_log(&format!("Failed to spawn node: {}", e));
-                    let _ = window.emit(
+                    let emsg = format!("Failed to spawn node: {}", e);
-                        "error",
+                    let js = format!(
-                        serde_json::json!({
+                        "document.getElementById('status-message').textContent='Spawn Error';var b=document.getElementById('debug-log-box');b.style.display='block';b.textContent={};",
-                            "message": format!("Failed to launch backend runtime: {}", e)
+                        serde_json::to_string(&emsg).unwrap_or_default()
-                        }),
                     );
+                    let _ = window.eval(&js);
                 }
             }
 
             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();

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.1.8",
+    "version": "1.1.42",
     "identifier": "com.vyla.home",
     "build": {
         "frontendDist": "../ui"
@@ -9,7 +9,7 @@
     "app": {
         "withGlobalTauri": true,
         "security": {
-            "csp": null
+            "csp": "default-src 'self' http://localhost:4890 http://127.0.0.1:4890; script-src 'self' 'unsafe-inline' 'unsafe-eval' http://localhost:4890 http://127.0.0.1:4890 https://esm.sh; style-src 'self' 'unsafe-inline' http://localhost:4890 http://127.0.0.1:4890; img-src 'self' data: https: http://localhost:4890 http://127.0.0.1:4890; font-src 'self' data: http://localhost:4890 http://127.0.0.1:4890; connect-src 'self' http://localhost:* http://127.0.0.1:*"
         }
     },
     "bundle": {
@@ -22,6 +22,10 @@
             "icons/icon.icns",
             "icons/icon.ico"
         ],
+        "macOS": {
+            "exceptionDomain": "localhost",
+            "infoPlist": "Info.plist"
+        },
         "windows": {
             "webviewInstallMode": {
                 "type": "downloadBootstrapper"
@@ -29,8 +33,9 @@
         },
         "resources": [
             "WebView2Loader.dll",
-            "../bin/*",
+            "../bin/**/*",
             "../main.js",
+            "../preload.js",
             "../service-manager.js",
             "../patcher.js",
             "../crypto-utils.js",
@@ -40,4 +45,4 @@
             "../node_modules/**/*"
         ]
     }
-}
+}

ui/index.html

@@ -195,6 +195,9 @@
     <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>
@@ -256,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>
 
@@ -284,61 +271,66 @@
             console.warn("OGL Shader background failed to load (offline):", err);
         }
 
-        if (!window.__OGL_LOADED__) {
+        window.dispatchEvent(new Event('ogl-ready'));
-            document.body.style.background = "radial-gradient(circle at 80% 20%, #1e1b4b 0%, #050505 70%)";
+    </script>
-        } else {
-            const { Renderer, Program, Triangle, Mesh } = window.__OGL_LOADED__;
-            const rayContainer = document.getElementById("side-rays");
-            const settings = {
-                speed: 2.5,
-                rayColor1: "#EAB308",
-                rayColor2: "#96c8ff",
-                intensity: 2,
-                spread: 2,
-                origin: "top-right",
-                tilt: 0,
-                saturation: 1.5,
-                blend: 0.75,
-                falloff: 1.6,
-                opacity: 1
-            };
 
-            function hexToRgb(hex) {
+    <script>
-                const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        window.addEventListener('ogl-ready', () => {
-                if (!match) return [1, 1, 1];
+            if (!window.__OGL_LOADED__) {
-                return [
+                document.body.style.background = "radial-gradient(circle at 80% 20%, #1e1b4b 0%, #050505 70%)";
-                    parseInt(match[1], 16) / 255,
+            } else {
-                    parseInt(match[2], 16) / 255,
+                const { Renderer, Program, Triangle, Mesh } = window.__OGL_LOADED__;
-                    parseInt(match[3], 16) / 255
+                const rayContainer = document.getElementById("side-rays");
-                ];
+                const settings = {
-            }
+                    speed: 2.5,
+                    rayColor1: "#EAB308",
+                    rayColor2: "#96c8ff",
+                    intensity: 2,
+                    spread: 2,
+                    origin: "top-right",
+                    tilt: 0,
+                    saturation: 1.5,
+                    blend: 0.75,
+                    falloff: 1.6,
+                    opacity: 1
+                };
 
-            function originToFlip(origin) {
+                function hexToRgb(hex) {
-                switch (origin) {
+                    const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-                    case "top-left": return [1, 0];
+                    if (!match) return [1, 1, 1];
-                    case "bottom-right": return [0, 1];
+                    return [
-                    case "bottom-left": return [1, 1];
+                        parseInt(match[1], 16) / 255,
-                    default: return [0, 0];
+                        parseInt(match[2], 16) / 255,
+                        parseInt(match[3], 16) / 255
+                    ];
                 }
-            }
 
-            const renderer = new Renderer({
+                function originToFlip(origin) {
-                dpr: Math.min(window.devicePixelRatio, 2),
+                    switch (origin) {
-                alpha: true
+                        case "top-left": return [1, 0];
-            });
+                        case "bottom-right": return [0, 1];
-            const gl = renderer.gl;
+                        case "bottom-left": return [1, 1];
-            gl.canvas.style.width = "100%";
+                        default: return [0, 0];
-            gl.canvas.style.height = "100%";
+                    }
-            rayContainer.appendChild(gl.canvas);
+                }
 
-            const vertexShader = `
+                const renderer = new Renderer({
+                    dpr: Math.min(window.devicePixelRatio, 2),
+                    alpha: true
+                });
+                const gl = renderer.gl;
+                gl.canvas.style.width = "100%";
+                gl.canvas.style.height = "100%";
+                rayContainer.appendChild(gl.canvas);
+
+                const vertexShader = `
 attribute vec2 position;
 void main() {
   gl_Position = vec4(position, 0.0, 1.0);
 }
 `;
 
-            const fragmentShader = `
+                const fragmentShader = `
 precision highp float;
 uniform float iTime;
 uniform vec2 iResolution;
@@ -399,77 +391,77 @@ void main() {
 }
 `;
 
-            const [flipX, flipY] = originToFlip(settings.origin);
+                const [flipX, flipY] = originToFlip(settings.origin);
-            const uniforms = {
+                const uniforms = {
-                iTime: { value: 0 },
+                    iTime: { value: 0 },
-                iResolution: { value: [1, 1] },
+                    iResolution: { value: [1, 1] },
-                iSpeed: { value: settings.speed },
+                    iSpeed: { value: settings.speed },
-                iRayColor1: { value: hexToRgb(settings.rayColor1) },
+                    iRayColor1: { value: hexToRgb(settings.rayColor1) },
-                iRayColor2: { value: hexToRgb(settings.rayColor2) },
+                    iRayColor2: { value: hexToRgb(settings.rayColor2) },
-                iIntensity: { value: settings.intensity },
+                    iIntensity: { value: settings.intensity },
-                iSpread: { value: settings.spread },
+                    iSpread: { value: settings.spread },
-                iFlipX: { value: flipX },
+                    iFlipX: { value: flipX },
-                iFlipY: { value: flipY },
+                    iFlipY: { value: flipY },
-                iTilt: { value: settings.tilt },
+                    iTilt: { value: settings.tilt },
-                iSaturation: { value: settings.saturation },
+                    iSaturation: { value: settings.saturation },
-                iBlend: { value: settings.blend },
+                    iBlend: { value: settings.blend },
-                iFalloff: { value: settings.falloff },
+                    iFalloff: { value: settings.falloff },
-                iOpacity: { value: settings.opacity }
+                    iOpacity: { value: settings.opacity }
-            };
+                };
 
-            const geometry = new Triangle(gl);
+                const geometry = new Triangle(gl);
-            const program = new Program(gl, { vertex: vertexShader, fragment: fragmentShader, uniforms });
+                const program = new Program(gl, { vertex: vertexShader, fragment: fragmentShader, uniforms });
-            const mesh = new Mesh(gl, { geometry, program });
+                const mesh = new Mesh(gl, { geometry, program });
 
-            function resize() {
+                function resize() {
-                const width = rayContainer.clientWidth;
+                    const width = rayContainer.clientWidth;
-                const height = rayContainer.clientHeight;
+                    const height = rayContainer.clientHeight;
-                renderer.dpr = Math.min(window.devicePixelRatio, 2);
+                    renderer.dpr = Math.min(window.devicePixelRatio, 2);
-                renderer.setSize(width, height);
+                    renderer.setSize(width, height);
-                uniforms.iResolution.value = [width * renderer.dpr, height * renderer.dpr];
+                    uniforms.iResolution.value = [width * renderer.dpr, height * renderer.dpr];
-            }
+                }
 
-            window.addEventListener("resize", resize);
+                window.addEventListener("resize", resize);
-            resize();
+                resize();
 
-            function animate(time) {
+                function animate(time) {
-                uniforms.iTime.value = time * 0.001;
+                    uniforms.iTime.value = time * 0.001;
-                renderer.render({ scene: mesh });
+                    renderer.render({ scene: mesh });
+                    requestAnimationFrame(animate);
+                }
                 requestAnimationFrame(animate);
-            }
-            requestAnimationFrame(animate);
 
-            function initLiquidButtons() {
+                function initLiquidButtons() {
-                const borderWidth = 0.16;
+                    const borderWidth = 0.16;
-                const brightness = 35;
+                    const brightness = 35;
-                const opacity = 0.55;
+                    const opacity = 0.55;
-                const blur = 4;
+                    const blur = 4;
-                const displace = 1.2;
+                    const displace = 1.2;
-                const borderRadius = 9999;
+                    const borderRadius = 9999;
-                const distortionScale = -380;
+                    const distortionScale = -380;
-                const redOffset = -25;
+                    const redOffset = -25;
-                const greenOffset = 0;
+                    const greenOffset = 0;
-                const blueOffset = 25;
+                    const blueOffset = 25;
-                const xChannel = "R";
+                    const xChannel = "R";
-                const yChannel = "G";
+                    const yChannel = "G";
-                const mixBlendMode = "screen";
+                    const mixBlendMode = "screen";
 
-                document.querySelectorAll(".liquid-glass-btn").forEach((btn, index) => {
+                    document.querySelectorAll(".liquid-glass-btn").forEach((btn, index) => {
-                    const filterId = `glass-filter-${index + 1}`;
+                        const filterId = `glass-filter-${index + 1}`;
-                    btn.style.setProperty("--filter-id", `url(#${filterId})`);
+                        btn.style.setProperty("--filter-id", `url(#${filterId})`);
 
-                    const feImage = btn.querySelector(".fe-image");
+                        const feImage = btn.querySelector(".fe-image");
-                    const redChannel = btn.querySelector(".redchannel");
+                        const redChannel = btn.querySelector(".redchannel");
-                    const greenChannel = btn.querySelector(".greenchannel");
+                        const greenChannel = btn.querySelector(".greenchannel");
-                    const blueChannel = btn.querySelector(".bluechannel");
+                        const blueChannel = btn.querySelector(".bluechannel");
-                    const gaussianBlur = btn.querySelector(".gaussianBlur");
+                        const gaussianBlur = btn.querySelector(".gaussianBlur");
 
-                    function generateDisplacementMap() {
+                        function generateDisplacementMap() {
-                        const rect = btn.getBoundingClientRect();
+                            const rect = btn.getBoundingClientRect();
-                        const actualWidth = rect.width || 140;
+                            const actualWidth = rect.width || 140;
-                        const actualHeight = rect.height || 48;
+                            const actualHeight = rect.height || 48;
 
-                        const svgContent = `
+                            const svgContent = `
         <svg viewBox="0 0 ${actualWidth} ${actualHeight}" xmlns="http://www.w3.org/2000/svg">
           <defs>
             <linearGradient id="red-grad-${index}" x1="100%" y1="0%" x2="0%" y2="0%">
@@ -486,42 +478,47 @@ void main() {
           <rect width="${actualWidth}" height="${actualHeight}" rx="${borderRadius}" fill="url(#blue-grad-${index})" style="mix-blend-mode:${mixBlendMode}"/>
         </svg>
       `;
-                        return "data:image/svg+xml," + encodeURIComponent(svgContent);
+                            return "data:image/svg+xml," + encodeURIComponent(svgContent);
-                    }
+                        }
 
-                    function update() {
+                        function update() {
-                        feImage.setAttribute("href", generateDisplacementMap());
+                            feImage.setAttribute("href", generateDisplacementMap());
-                        redChannel.setAttribute("scale", distortionScale + redOffset);
+                            redChannel.setAttribute("scale", distortionScale + redOffset);
-                        greenChannel.setAttribute("scale", distortionScale + greenOffset);
+                            greenChannel.setAttribute("scale", distortionScale + greenOffset);
-                        blueChannel.setAttribute("scale", distortionScale + blueOffset);
+                            blueChannel.setAttribute("scale", distortionScale + blueOffset);
-                        [redChannel, greenChannel, blueChannel].forEach((ch) => {
+                            [redChannel, greenChannel, blueChannel].forEach((ch) => {
-                            ch.setAttribute("xChannelSelector", xChannel);
+                                ch.setAttribute("xChannelSelector", xChannel);
-                            ch.setAttribute("yChannelSelector", yChannel);
+                                ch.setAttribute("yChannelSelector", yChannel);
-                        });
+                            });
-                        gaussianBlur.setAttribute("stdDeviation", displace);
+                            gaussianBlur.setAttribute("stdDeviation", displace);
-                    }
+                        }
 
-                    update();
+                        update();
-                    btn.classList.remove("glass-surface--fallback");
+                        btn.classList.remove("glass-surface--fallback");
-                    btn.classList.add("glass-surface--svg");
+                        btn.classList.add("glass-surface--svg");
 
-                    const observer = new ResizeObserver(() => setTimeout(update, 0));
+                        const observer = new ResizeObserver(() => setTimeout(update, 0));
-                    observer.observe(btn);
+                        observer.observe(btn);
-                });
+                    });
+                }
+
+                initLiquidButtons();
             }
-
+        });
-            initLiquidButtons();
-        }
     </script>
 
     <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");
         const btnYes = document.getElementById("btn-update-yes");
         const btnNo = document.getElementById("btn-update-no");
 
+        if (actionsEl) actionsEl.style.display = "none";
+        if (progressTrack) progressTrack.style.display = "none";
+
         let currentStatusText = "";
 
         function setStatus(text, color = "rgba(255, 255, 255, 0.85)") {
@@ -540,9 +537,24 @@ void main() {
             });
         }
 
+        function showDebug(msg) {
+            if (!debugBox) return;
+            debugBox.style.display = "block";
+            debugBox.textContent = msg;
+        }
+
         async function initTauriEvents() {
-            const eventApi = window.__TAURI__?.event || window.__TAURI_INTERNALS__;
+            let eventApi = null;
-            if (!eventApi || typeof eventApi.listen !== 'function') {
+
+            if (window.__TAURI__?.event && typeof window.__TAURI__.event.listen === 'function') {
+                eventApi = window.__TAURI__.event;
+            } else if (window.__TAURI_INTERNALS__ && typeof window.__TAURI_INTERNALS__.listen === 'function') {
+                eventApi = window.__TAURI_INTERNALS__;
+            } else if (window.__TAURI__ && typeof window.__TAURI__.listen === 'function') {
+                eventApi = window.__TAURI__;
+            }
+
+            if (!eventApi) {
                 setTimeout(initTauriEvents, 50);
                 return;
             }
@@ -558,15 +570,16 @@ void main() {
                 const data = e.payload || e;
                 if (data) {
                     if (progressTrack) progressTrack.style.display = "block";
-                    const percent = data.percent || 0;
+                    if (progressFill) progressFill.style.width = "100%";
-                    if (progressFill) progressFill.style.width = percent + "%";
+                    if (actionsEl) actionsEl.style.display = "none";
-                    setStatus(`Downloading update... ${percent}%`);
+                    setStatus("Downloading update...");
                 }
             });
 
             eventApi.listen("update-available", (e) => {
                 const data = e.payload || e;
-                if (data) {
+                if (data && data.latest) {
+                    if (progressTrack) progressTrack.style.display = "none";
                     setStatus(`Update Available: ${data.latest} (Current: ${data.current})`);
                     if (actionsEl) actionsEl.style.display = "flex";
                 }
@@ -575,23 +588,27 @@ void main() {
             eventApi.listen("ready", (e) => {
                 const data = e.payload || e;
                 if (data && data.url) {
+                    if (progressTrack) progressTrack.style.display = "none";
+                    if (actionsEl) actionsEl.style.display = "none";
                     setStatus("Launching...");
-                    window.location.href = data.url;
                 }
             });
 
             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);
             });
         }
 
         btnYes.addEventListener("click", () => {
             if (actionsEl) actionsEl.style.display = "none";
             setStatus("Starting update installation...");
-            fetch("http://127.0.0.1:4891/update/yes", { method: "POST" }).catch(() => { });
+            fetch("http://127.0.0.1:4891/update/yes", { method: "POST" }).catch((err) => {
+                setStatus("Failed to reach update service. Retrying...", "#fca5a5");
+                showDebug(err.message);
+            });
         });
 
         btnNo.addEventListener("click", () => {

update-client.js

@@ -136,7 +136,14 @@ class UpdateClient {
           });
 
           file.on('finish', () => {
-            file.close(resolve);
+            file.close(() => {
+              if (totalSize && downloadedSize < totalSize) {
+                fs.unlink(destPath, () => { });
+                reject(new Error(`Download truncated: Received ${downloadedSize} of ${totalSize} bytes. Connection dropped prematurely.`));
+              } else {
+                resolve();
+              }
+            });
           });
 
           file.on('error', (err) => {
@@ -150,10 +157,10 @@ class UpdateClient {
           reject(err);
         });
 
-        req.setTimeout(120000, () => {
+        req.setTimeout(900000, () => {
           req.destroy();
           fs.unlink(destPath, () => { });
-          reject(new Error('Download timeout'));
+          reject(new Error('Download timeout (15 minutes reached)'));
         });
       };
 
@@ -228,7 +235,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;
     }