v1.1.47

potentially fixed auto updater, made sdk also up to date
v1.1.46
2026-11-13 21:57:21 -05:00 · 2026-10-25 19:32:10 -07:00 · 2026-10-25 19:27:25 -07:00 · 2026-10-24 18:32:54 -07:00 · 2026-10-24 18:28:09 -07:00 · 2026-10-24 18:13:14 -07:00
28 changed files with 1301 additions and 1017 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -35,4 +35,6 @@ yarn-error.log*

 *.tmp
 *.temp
-download-temp.zip
+download-temp.zip
+
+.env
--- a/DOCUEMENTATION/CLEAR.bash
+++ b/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."'
--- a/DOCUEMENTATION/FIXES.md
+++ b/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
--- a/47
+++ b/47
@@ -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.
--- a/README.md
+++ b/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.
- **Native Memory Management**: Background Node.js lifecycle states are managed directly via OS-level memory handles (bypassing slow shell wrappers) for instant startup and teardown.
- **Cryptographic Obfuscation**: Client configurations and credentials are secured on-disk via hardware-derived AES-256-GCM encryption.
- **Automated Integrity Patching**: Payloads are dynamically verified using SHA-256 checksums and patched in-memory via C-level buffer scans.
+- **Runs locally** - All services run on your computer for maximum privacy and speed
+- **Manages streaming services** - Handles authentication and streaming APIs automatically
+- **Updates automatically** - Keeps itself up to date with the latest features and fixes
+- **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)
- [Node.js](https://nodejs.org/) (v20+ LTS)
- Tauri CLI (`npm install -g @tauri-apps/cli`)
+When you launch Vyla Home, it:

-## 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.
-
-```bash
-npm install
-
-npm run build:payload
-
-npm run build
-```
+Everything happens on your machine - your data never leaves your computer except when communicating directly with streaming services.
--- a/build-pipeline.js
+++ b/build-pipeline.js
@@ -5,7 +5,7 @@ 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');

@@ -14,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}`);
  }
@@ -171,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: [],
@@ -332,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 (fs.existsSync(repoPath)) {
-      fs.rmSync(repoPath, { recursive: true, force: true });
+    if (clonedRepos.has(repo)) {
+      const repoPath = path.join(__dirname, repo);
+      if (fs.existsSync(repoPath)) {
+        fs.rmSync(repoPath, { recursive: true, force: true });
+      }
    }
  }

--- a/build/white_favicon.png
+++ b/build/white_favicon.png
--- a/codemagic.yaml
+++ b/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
--- a/config/credentials-template.json
+++ b/config/credentials-template.json
@@ -1,16 +1,5 @@
 {
    "player": {
-        "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"
+        "TMDB_KEY": "YOUR_TMDB_KEY_HERE"
    }
 }
--- a/config/env.json
+++ b/config/env.json
@@ -1,20 +1,5 @@
 {
  "player": {
-    "PORT": "3001",
-    "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"
+    "PORT": "3000"
  }
 }
--- a/config/replacements.json
+++ b/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": []
+  ]
 }
--- a/github-client.js
+++ b/github-client.js
@@ -4,9 +4,7 @@ const path = require('path');

 const REPOS = {
    frontend: { branch: 'main' },
-    player: { branch: 'main' },
-    'stream-api': { branch: 'main' },
-    'auth-proxy': { branch: 'main' }
+    player: { branch: 'main' }
 };

 const GITLAB_GROUP = 'vyla-entertainment';
--- a/main.js
+++ b/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 playerExpressServer;
+let updateDecisionHandler = null;

 debugLog(`AppData Dir: ${APPDATA_DIR}`);

@@ -77,12 +85,25 @@ 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', () => {
@@ -158,20 +179,37 @@ async function start() {

        debugLog('Download complete. Verifying checksum...');
        sendToTauri('status', { message: 'Verifying SHA-256 integrity...' });
+        if (!release.sha256) {
+          throw new Error('Release has no SHA-256 in manifest.json; refusing unverified install.');
+        }
        if (!patcher.verifyChecksum(tempZipPath, release.sha256)) {
          throw new Error('SHA-256 checksum verification failed.');
        }

-        debugLog('Checksum verified. Extracting...');
+        debugLog('Checksum verified. Extracting to staging...');
        sendToTauri('status', { message: 'Unpacking update archive...' });
-        patcher.purgeOldCode();
-        patcher.extractZipPayload(tempZipPath);
+        let lastEmit = 0;
+        const stagingDir = await patcher.extractToStaging(tempZipPath, (file, done, total) => {
+          const now = Date.now();
+          if (done !== total && now - lastEmit < 40) return;
+          lastEmit = now;
+          sendToTauri('extract-progress', {
+            file,
+            done,
+            total,
+            percent: Math.round((done / total) * 100)
+          });
+        });

        sendToTauri('status', { message: 'Verifying file integrity...' });
-        if (!patcher.verifyExtraction()) {
+        if (!patcher.verifyExtraction(stagingDir)) {
+          fs.rmSync(stagingDir, { recursive: true, force: true });
          throw new Error('Extraction verification failed: critical startup files missing.');
        }

+        sendToTauri('status', { message: 'Replacing old version...' });
+        patcher.commitStaging(stagingDir);
+
        debugLog('Extraction complete. Applying patches...');
        sendToTauri('status', { message: 'Applying configuration patches...' });
        patcher.applyPatches(getReplacementsConfig());
@@ -206,7 +244,31 @@ async function start() {
    const isFirstRun = !patcher.verifyExtraction();
    const localVersion = patcher.getCurrentVersion();
    const 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;
+    }
+
+    let localZipPath = null;
+    let localManifestPath = null;
+    let localZipManifest = null;

    sendToTauri('status', { message: 'Connecting to update servers...' });
    let release = null;
@@ -214,23 +276,62 @@ 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) {
+      }
    } 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();
+    const parseVer = (v) => normalizeVer(v).split(/[.\-+]/).map((n) => parseInt(n, 10) || 0);
+    const isNewer = (remote, local) => {
+      const a = parseVer(remote);
+      const b = parseVer(local);
+      for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const x = a[i] || 0;
+        const y = b[i] || 0;
+        if (x !== y) return x > y;
+      }
+      return false;
+    };
+
    if (release) {
-      const hasUpdate = release.version !== localVersion || (release.sha256 && release.sha256 !== localSha);
+      const versionNewer = isNewer(release.version, localVersion);
+      const sameVerNewBuild = normalizeVer(release.version) === normalizeVer(localVersion) &&
+        !!release.sha256 && !!localSha && release.sha256 !== localSha;
+      const hasUpdate = (versionNewer || sameVerNewBuild) && !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...` });
+        sendToTauri('status', { message: `New update available (${release.version}).` });
+
+        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');
@@ -241,20 +342,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); });
-        tempApp.post('/update/no', (req, res) => { userDecision = false; res.sendStatus(200); });
+        const handleYes = (req, res) => { debugLog("tempApp received YES"); userDecision = true; 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.");
@@ -277,7 +403,14 @@ async function start() {
        patcher.extractZipPayload(localZip);
        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 {
@@ -287,91 +420,39 @@ 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: 'Installing dependencies...' });
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const frontendDir = path.join(APPDATA_DIR, 'frontend');
+    if (fs.existsSync(path.join(frontendDir, 'package.json'))) {
+      const { spawnSync } = require('child_process');
+      spawnSync(npmCmd, ['install'], {
+        cwd: frontendDir,
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: process.platform === 'win32'
+      });
+    }
+
+    sendToTauri('status', { message: 'Starting services (player, frontend)...' });
    await serviceManager.startServices([
-      { name: 'auth-proxy', relativeDir: 'auth-proxy' },
-      { name: 'stream-api', relativeDir: 'stream-api' },
+      { name: 'player', relativeDir: 'player', startScript: 'server.js' },
+      { name: 'frontend', relativeDir: 'frontend', startScript: 'server.js' }
    ]);
    debugLog("Backend services spawn requested.");

-    sendToTauri('status', { message: 'Binding player web server on port 3001...' });
-    const playerDir = path.join(APPDATA_DIR, 'player');
-    playerExpressApp = express();
-    playerExpressApp.use((req, res, next) => {
-      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...' });
+    await serviceManager.waitForPorts([3000, 4890]);
+    debugLog("Ports 3000 and 4890 are ready.");

-    sendToTauri('status', { message: 'Waiting for microservices to bind ports (3000, 3001, 7860)...' });
-    await serviceManager.waitForPorts([3000, 3001, 7860]);
-    debugLog("Ports 3000, 3001, 7860 are ready.");
-
-    sendToTauri('status', { message: 'Binding UI server on port 4890...' });
-    const frontendDir = path.join(APPDATA_DIR, 'frontend');
-    expressApp = express();
-    expressApp.use((req, res, next) => {
-      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();
-    });
-    expressApp.get('/__tauri_cmd/:cmd', (req, res) => {
-      debugLog(`[FRONTEND-SERVER:4890] 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);
-    });
-
-    expressApp.use(sameTabNavMiddleware(frontendDir));
-    expressApp.use(express.static(frontendDir, {
-      etag: false,
-      setHeaders: (res) => {
-        res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
-      }
-    }));
-    expressApp.get('*', (req, res) => {
-      res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
-      res.sendFile(path.join(frontendDir, 'index.html'));
-    });
-
-    const FRONTEND_PORT = 4890;
-    expressApp.use('/build', express.static(path.join(__dirname, 'build')));
-    if (playerExpressApp) {
-      playerExpressApp.use('/build', express.static(path.join(__dirname, 'build')));
-    }
-
-    expressServer = expressApp.listen(FRONTEND_PORT, '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('status', { message: 'All backend services running and healthy.' });
+    debugLog("Sending READY to Tauri.");
+    sendToTauri('ready', { url: 'http://127.0.0.1:4890' });

  } catch (error) {
    debugLog(`Fatal Start Error: ${error.message}`);
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "vyla-home",
-  "version": "1.1.12",
+  "version": "1.1.47",
  "description": "Vyla Home Desktop App Launcher",
  "main": "main.js",
  "scripts": {
@@ -11,11 +11,11 @@
    "release:full": "node release.js --installer"
  },
  "dependencies": {
-    "@tauri-apps/api": "^2.0.0",
-    "@tauri-apps/plugin-opener": "^2.0.0",
-    "@tauri-apps/plugin-process": "^2.0.0",
-    "@tauri-apps/plugin-shell": "^2.0.0",
-    "@vyla-entertainment/sdk": "^1.11.0",
+    "@tauri-apps/api": "^2.12.1",
+    "@tauri-apps/plugin-opener": "^2.7.0",
+    "@tauri-apps/plugin-process": "^2.4.0",
+    "@tauri-apps/plugin-shell": "^2.4.0",
+    "@vyla-entertainment/sdk": "^1.20.0",
    "adm-zip": "^0.6.0",
    "express": "^4.19.2"
  },
--- a/patcher.js
+++ b/patcher.js
@@ -84,29 +84,72 @@ class Patcher {
  }

  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}"`);
+      }
+    }
+  }
+
+  async extractToStaging(zipPath, onFile) {
+    const stagingDir = path.join(this.appDataPath, '.staging');
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+    fs.mkdirSync(stagingDir, { recursive: true });
+    const zip = new AdmZip(zipPath);
+    const entries = zip.getEntries().filter((e) => !e.isDirectory);
+    if (entries.length === 0) {
+      throw new Error('Downloaded archive is empty, invalid, or truncated.');
+    }
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      zip.extractEntryTo(entry, stagingDir, true, true);
+      if (onFile) onFile(entry.entryName, i + 1, entries.length);
+      if (i % 20 === 0) await new Promise((resolve) => setImmediate(resolve));
+    }
+    return stagingDir;
+  }
+
+  commitStaging(stagingDir) {
+    this.purgeOldCode();
+    for (const name of fs.readdirSync(stagingDir)) {
+      const dest = path.join(this.appDataPath, name);
+      fs.rmSync(dest, { recursive: true, force: true });
+      fs.renameSync(path.join(stagingDir, name), dest);
+    }
+    fs.rmSync(stagingDir, { recursive: true, force: true });
  }

  verifyChecksum(zipPath, expectedSha256) {
-    if (!expectedSha256) return true;
+    if (!expectedSha256) return false;
    const hash = crypto.createHash('sha256');
    const data = fs.readFileSync(zipPath);
    hash.update(data);
    const calculated = hash.digest('hex');
-    return calculated === expectedSha256;
+    return calculated === String(expectedSha256).trim().toLowerCase();
  }

-  verifyExtraction() {
+  verifyExtraction(root = this.appDataPath) {
    const requiredFiles = [
-      'player/index.html',
-      'auth-proxy/server.js',
-      'stream-api/server.js',
-      'frontend/index.html'
+      'frontend/server.js',
+      'player/server.js'
    ];

    for (const file of requiredFiles) {
-      const fullPath = path.join(this.appDataPath, file);
+      const fullPath = path.join(root, file);
      if (!fs.existsSync(fullPath)) {
        return false;
      }
@@ -114,12 +157,16 @@ class Patcher {
      if (stat.size === 0) {
        return false;
      }
-      const sampleSize = Math.min(stat.size, 4096);
-      const fd = fs.openSync(fullPath, 'r');
-      const buffer = Buffer.alloc(sampleSize);
-      fs.readSync(fd, buffer, 0, sampleSize, 0);
-      fs.closeSync(fd);
-      if (buffer.every(byte => byte === 0)) {
+      try {
+        const sampleSize = Math.min(stat.size, 4096);
+        const fd = fs.openSync(fullPath, 'r');
+        const buffer = Buffer.alloc(sampleSize);
+        fs.readSync(fd, buffer, 0, sampleSize, 0);
+        fs.closeSync(fd);
+        if (buffer.every(byte => byte === 0)) {
+          return false;
+        }
+      } catch (e) {
        return false;
      }
    }
@@ -155,7 +202,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;
--- a/release.js
+++ b/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 {
-                            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);
+                        try { resolve(body ? JSON.parse(body) : {}); } catch (e) { resolve({}); }
                    } 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...');
-        execSync('npm run build', {
-            stdio: 'inherit'
-        });
+        console.log('Compiling native Tauri application...');
+        execSync('npm run build', { stdio: 'inherit' });

-        const nsisDir = path.join(__dirname, 'src-tauri/target/release/bundle/nsis');
-        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));
+        const targetVersion = version.startsWith('v') ? version.substring(1) : version;

-            if (files.length > 0) {
-                const originalName = files[0];
-                installerPath = path.join(nsisDir, originalName);
-                installerUploadName = originalName.replace(/\s+/g, '-');
+        if (process.platform === 'win32') {
+            const nsisDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle', 'nsis');
+            if (fs.existsSync(nsisDir)) {
+                const files = fs.readdirSync(nsisDir).filter(f => f.endsWith('.exe') && 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);
-    console.log(`[4/4] Release successfully created: ${release.name} (${release.tag_name})`);
+    await createGitLabRelease(version, releaseLinks);
+    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);
-        https.get(nodeUrl, (res) => {
-            if (res.statusCode === 302 || res.statusCode === 301) {
-                https.get(res.headers.location, (redirectRes) => {
-                    redirectRes.pipe(fileStream);
-                    fileStream.on('finish', () => {
-                        fileStream.close();
-                        fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
-                        resolve();
-                    });
-                }).on('error', reject);
-                return;
-            }
-            res.pipe(fileStream);
-            fileStream.on('finish', () => {
-                fileStream.close();
+        const download = (url, dest, cb) => {
+            https.get(url, (res) => {
+                if (res.statusCode === 302 || res.statusCode === 301) {
+                    return download(res.headers.location, dest, cb);
+                }
+                const fileStream = fs.createWriteStream(dest);
+                res.pipe(fileStream);
+                fileStream.on('finish', () => {
+                    fileStream.close();
+                    cb();
+                });
+            }).on('error', reject);
+        };
+
+        if (isWin) {
+            const nodeUrl = `https://nodejs.org/dist/${nodeVersion}/win-x64/node.exe`;
+            download(nodeUrl, nodeExePath, () => {
                fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
                resolve();
            });
-        }).on('error', (err) => {
-            try { fs.unlinkSync(nodeExePath); } catch (e) { }
-            reject(err);
-        });
+        } else {
+            const arch = os.arch() === 'arm64' ? 'arm64' : 'x64';
+            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 });
--- a/service-manager.js
+++ b/service-manager.js
@@ -40,18 +40,22 @@ class ServiceManager {
    }

    let tokenSecret = process.env.TOKEN_SECRET ||
-      process.env.STREAM_API_TOKEN_SECRET ||
-      this.credentialManager.getCredential('stream-api', 'TOKEN_SECRET');
+      this.credentialManager.getCredential('player', '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 defaultPorts = {
+      player: 3000,
+      frontend: 4890
+    };
+
    const env = {
      ...process.env,
+      PORT: (this.envConfig[name] && this.envConfig[name].PORT) || defaultPorts[name] || process.env.PORT || 3000,
      TOKEN_SECRET: tokenSecret,
-      STREAM_API_TOKEN_SECRET: tokenSecret,
      ...(this.envConfig[name] || {}),
      ...(this.credentialManager.getServiceCredentials(name) || {})
    };
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.1.12"
+version = "1.1.47"
 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
--- a/src-tauri/Info.plist
+++ b/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>
--- a/src-tauri/build.rs
+++ b/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();
 }
--- a/src-tauri/gen/schemas/acl-manifests.json
+++ b/src-tauri/gen/schemas/acl-manifests.json
--- a/src-tauri/gen/schemas/desktop-schema.json
+++ b/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",
--- a/src-tauri/gen/schemas/windows-schema.json
+++ b/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",
--- a/src-tauri/src/main.rs
+++ b/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);
@@ -65,11 +70,23 @@ fn kill_child_process(child: &mut Child) {

 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() {
@@ -82,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() {
@@ -96,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");
-            if candidate.exists() {
-                return Some(clean_path(&candidate));
+            let node_exe = p.join("node.exe");
+            if node_exe.exists() {
+                return Some(clean_path(&node_exe));
+            }
+                
+            let node = p.join("node");
+            if node.exists() {
+                return Some(clean_path(&node));
            }
        }
    }
@@ -127,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
 }

@@ -135,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();
@@ -153,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 || {});
@@ -200,113 +269,11 @@ const LINK_HANDLER_SCRIPT: &str = r##"
    }, true);

    function injectLiquidNavBar() {
-        if (document.getElementById('vyla-floating-nav')) return;
+        if (document.getElementById('tauri-custom-titlebar')) return;
        if (!document.body) return;

        const style = document.createElement('style');
        style.innerHTML = `
-            #vyla-floating-nav {
-                position: fixed !important;
-                top: 12px !important;
-                left: 12px !important;
-                z-index: 2147483647 !important;
-                height: 42px !important;
-                width: 42px !important;
-                border-radius: 9999px !important;
-                display: flex !important;
-                align-items: center !important;
-                background: rgba(255, 255, 255, 0.04) !important;
-                backdrop-filter: blur(16px) saturate(1.8) contrast(1.1) !important;
-                -webkit-backdrop-filter: blur(16px) saturate(1.8) contrast(1.1) !important;
-                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.45) !important;
-                transition: width 0.3s cubic-bezier(0.16, 1, 0.3, 1), padding 0.3s cubic-bezier(0.16, 1, 0.3, 1) !important;
-                overflow: hidden !important;
-                padding: 0 !important;
-                user-select: none !important;
-                pointer-events: auto !important;
-                -webkit-app-region: no-drag !important;
-            }
-
-            #vyla-floating-nav:hover {
-                width: 82px !important;
-                padding-right: 6px !important;
-            }
-
-            .vyla-nav-logo-wrap {
-                width: 42px !important;
-                min-width: 42px !important;
-                height: 42px !important;
-                display: flex !important;
-                align-items: center !important;
-                justify-content: center !important;
-                cursor: pointer !important;
-                border-radius: 9999px !important;
-                position: relative !important;
-                z-index: 2147483647 !important;
-                pointer-events: auto !important;
-                padding: 0 !important;
-            }
-
-            .vyla-nav-logo-wrap img {
-                width: 26px !important;
-                height: 26px !important;
-                min-width: 26px !important;
-                min-height: 26px !important;
-                object-fit: contain !important;
-                pointer-events: none !important;
-                display: block !important;
-            }
-
-            .vyla-nav-links {
-                display: flex !important;
-                align-items: center !important;
-                gap: 4px !important;
-                opacity: 0 !important;
-                transform: translateX(-6px) !important;
-                transition: opacity 0.2s ease, transform 0.25s cubic-bezier(0.16, 1, 0.3, 1) !important;
-                pointer-events: none !important;
-                position: relative !important;
-                z-index: 2 !important;
-                margin-left: 2px !important;
-            }
-
-            #vyla-floating-nav:hover .vyla-nav-links {
-                opacity: 1 !important;
-                transform: translateX(0) !important;
-                pointer-events: auto !important;
-            }
-
-            .vyla-nav-btn {
-                width: 32px !important;
-                min-width: 32px !important;
-                height: 32px !important;
-                border-radius: 9999px !important;
-                border: none !important;
-                outline: none !important;
-                background: transparent !important;
-                box-shadow: none !important;
-                color: #ffffff !important;
-                display: flex !important;
-                align-items: center !important;
-                justify-content: center !important;
-                cursor: pointer !important;
-                transition: transform 0.15s ease, opacity 0.2s ease !important;
-                opacity: 0.85 !important;
-                padding: 0 !important;
-            }
-
-            .vyla-nav-btn:hover {
-                opacity: 1 !important;
-            }
-
-            .vyla-nav-btn svg {
-                width: 20px !important;
-                height: 20px !important;
-                fill: #ffffff !important;
-                pointer-events: none !important;
-                display: block !important;
-            }
-
            #tauri-custom-titlebar {
                position: fixed !important;
                top: 0 !important;
@@ -324,7 +291,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                margin: 0 !important;
                padding: 0 !important;
            }
-
+                
            .tauri-drag-region {
                position: absolute !important;
                inset: 0 !important;
@@ -332,7 +299,7 @@ const LINK_HANDLER_SCRIPT: &str = r##"
                cursor: default !important;
                pointer-events: auto !important;
            }
-
+                
            .tauri-window-controls {
                display: flex !important;
                height: 32px !important;
@@ -341,7 +308,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;
@@ -356,45 +323,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 nav = document.createElement('div');
-        nav.id = 'vyla-floating-nav';
-        nav.innerHTML = `
-            <div class="vyla-nav-logo-wrap" title="Go to Home">
-                <img src="https://gitlab.com/vyla-entertainment/home-frontend/-/raw/main/assets/images/icons/logo_white.png" alt="Logo" />
-            </div>
-            <div class="vyla-nav-links">
-                <button class="vyla-nav-btn" id="vyla-btn-discord" title="Discord Community">
-                    <svg viewBox="0 0 127.14 96.36"><path d="M107.7,8.07A105.15,105.15,0,0,0,81.47,0a72.06,72.06,0,0,0-3.36,6.83A97.68,97.68,0,0,0,49,6.83,72.37,72.37,0,0,0,45.64,0,105.89,105.89,0,0,0,19.39,8.09C2.79,32.65-1.71,56.6.54,80.21h0A105.73,105.73,0,0,0,32.71,96.36,77.7,77.7,0,0,0,39.6,85.25a68.42,68.42,0,0,1-10.85-5.18c.91-.66,1.8-1.34,2.66-2a75.57,75.57,0,0,0,64.32,0c.87.71,1.76,1.39,2.66,2a68.68,68.68,0,0,1-10.87,5.19,77,77,0,0,0,6.89,11.1A105.25,105.25,0,0,0,126.6,80.22h0C129.24,52.84,122.09,29.11,107.7,8.07ZM42.45,65.69C36.18,65.69,31,60,31,53s5-12.74,11.43-12.74S54,45.91,53.89,53,48.84,65.69,42.45,65.69Zm42.24,0C78.41,65.69,73.25,60,73.25,53s5-12.74,11.44-12.74S96.23,45.91,96.12,53,91.08,65.69,84.69,65.69Z"/></svg>
-                </button>
-            </div>
-        `;
-        document.body.appendChild(nav);
-
-        const logoBtn = nav.querySelector('.vyla-nav-logo-wrap');
-        if (logoBtn) {
-            logoBtn.onclick = (e) => {
-                e.preventDefault();
-                e.stopPropagation();
-                window.location.href = 'http://localhost:4890';
-            };
-        }
-
-        const btnDiscord = nav.querySelector('#vyla-btn-discord');
-        if (btnDiscord) {
-            btnDiscord.onclick = (e) => {
-                e.preventDefault();
-                e.stopPropagation();
-                openExternalUrl('https://discord.gg/5eqRhKeywG');
-            };
-        }
-
        const tb = document.createElement('div');
        tb.id = 'tauri-custom-titlebar';
        tb.innerHTML = `
@@ -425,11 +360,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();
@@ -473,9 +409,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") {
@@ -511,7 +447,7 @@ async fn kill_orphans() -> Result<(), String> {
            .args(&["-9", "-f", "node"])
            .output();
    }
-    
+
    Ok(())
 }

@@ -548,6 +484,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 ===");

@@ -568,37 +621,63 @@ fn main() {
        .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(false)
                .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(
-                        "error",
-                        serde_json::json!({
-                            "message": "Node.js runtime not found. Please ensure Node.js is installed or bundled correctly."
-                        }),
-                    );
+                    debug_log("FATAL: No node binary found in bundle or PATH.");
+                    std::thread::sleep(std::time::Duration::from_millis(600));
+                    let _ = window.eval("document.getElementById('status-message').textContent='Error: Node runtime missing. Please reinstall.';");
+                    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())
@@ -617,12 +696,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) }),
+                                    );
+                                }
                            }
                        });
                    }
@@ -634,144 +724,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) =
-                                            w.app_handle().get_webview_window(window_label)
-                                        {
-                                            if let Some(cmd) =
-                                                msg.data.get("cmd").and_then(|c| c.as_str())
-                                            {
-                                                debug_log(&format!(
-                                                    "[TAURI-CMD] Executing action: {}",
-                                                    cmd
-                                                ));
-                                                match cmd {
-                                                    "win_minimize" => {
-                                                        let res = cmd_window.minimize();
-                                                        debug_log(&format!(
-                                                            "[TAURI-CMD] Minimize result: {:?}",
-                                                            res
-                                                        ));
-                                                    }
-                                                    "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
-                                            ));
+                                let msg = match serde_json::from_str::<BackendMessage>(&line) {
+                                    Ok(m) => m,
+                                    Err(_) => {
+                                        if !line.trim().is_empty() {
+                                            debug_log(&format!("[NODE RAW] {}", line));
                                        }
-                                    } 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());
                                    }
                                }
@@ -786,18 +759,18 @@ fn main() {
                }
                Err(e) => {
                    debug_log(&format!("Failed to spawn node: {}", e));
-                    let _ = window.emit(
-                        "error",
-                        serde_json::json!({
-                            "message": format!("Failed to launch backend runtime: {}", e)
-                        }),
+                    let emsg = format!("Failed to spawn node: {}", e);
+                    let js = format!(
+                        "document.getElementById('status-message').textContent='Spawn Error';var b=document.getElementById('debug-log-box');b.style.display='block';b.textContent={};",
+                        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();
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
    "$schema": "https://schema.tauri.app/config/2",
    "productName": "Vyla Home",
-    "version": "1.1.12",
+    "version": "1.1.47",
    "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",
--- a/ui/index.html
+++ b/ui/index.html
@@ -87,6 +87,21 @@
            }
        }

+        .file-line {
+            width: 100%;
+            min-height: 16px;
+            margin-top: -12px;
+            margin-bottom: 14px;
+            font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+            font-size: 11px;
+            color: rgba(255, 255, 255, 0.45);
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            direction: rtl;
+            text-align: center;
+        }
+
        .progress-track {
            width: 100%;
            height: 10px;
@@ -195,6 +210,10 @@
    <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-radius: 15px; 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="file-line" id="file-line"></div>
            <div class="progress-track" id="progress-track" style="display: none;">
                <div class="progress-fill" id="progress-fill"></div>
            </div>
@@ -257,7 +276,7 @@
                </div>
            </div>

-            </div>
+        </div>
    </div>

    <script type="module">
@@ -268,61 +287,66 @@
            console.warn("OGL Shader background failed to load (offline):", err);
        }

-        if (!window.__OGL_LOADED__) {
-            document.body.style.background = "radial-gradient(circle at 80% 20%, #1e1b4b 0%, #050505 70%)";
-        } 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
-            };
+        window.dispatchEvent(new Event('ogl-ready'));
+    </script>

-            function hexToRgb(hex) {
-                const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-                if (!match) return [1, 1, 1];
-                return [
-                    parseInt(match[1], 16) / 255,
-                    parseInt(match[2], 16) / 255,
-                    parseInt(match[3], 16) / 255
-                ];
-            }
+    <script>
+        window.addEventListener('ogl-ready', () => {
+            if (!window.__OGL_LOADED__) {
+                document.body.style.background = "radial-gradient(circle at 80% 20%, #1e1b4b 0%, #050505 70%)";
+            } 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 originToFlip(origin) {
-                switch (origin) {
-                    case "top-left": return [1, 0];
-                    case "bottom-right": return [0, 1];
-                    case "bottom-left": return [1, 1];
-                    default: return [0, 0];
+                function hexToRgb(hex) {
+                    const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+                    if (!match) return [1, 1, 1];
+                    return [
+                        parseInt(match[1], 16) / 255,
+                        parseInt(match[2], 16) / 255,
+                        parseInt(match[3], 16) / 255
+                    ];
                }
-            }

-            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);
+                function originToFlip(origin) {
+                    switch (origin) {
+                        case "top-left": return [1, 0];
+                        case "bottom-right": return [0, 1];
+                        case "bottom-left": return [1, 1];
+                        default: return [0, 0];
+                    }
+                }

-            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;
@@ -383,77 +407,77 @@ void main() {
 }
 `;

-            const [flipX, flipY] = originToFlip(settings.origin);
-            const uniforms = {
-                iTime: { value: 0 },
-                iResolution: { value: [1, 1] },
-                iSpeed: { value: settings.speed },
-                iRayColor1: { value: hexToRgb(settings.rayColor1) },
-                iRayColor2: { value: hexToRgb(settings.rayColor2) },
-                iIntensity: { value: settings.intensity },
-                iSpread: { value: settings.spread },
-                iFlipX: { value: flipX },
-                iFlipY: { value: flipY },
-                iTilt: { value: settings.tilt },
-                iSaturation: { value: settings.saturation },
-                iBlend: { value: settings.blend },
-                iFalloff: { value: settings.falloff },
-                iOpacity: { value: settings.opacity }
-            };
+                const [flipX, flipY] = originToFlip(settings.origin);
+                const uniforms = {
+                    iTime: { value: 0 },
+                    iResolution: { value: [1, 1] },
+                    iSpeed: { value: settings.speed },
+                    iRayColor1: { value: hexToRgb(settings.rayColor1) },
+                    iRayColor2: { value: hexToRgb(settings.rayColor2) },
+                    iIntensity: { value: settings.intensity },
+                    iSpread: { value: settings.spread },
+                    iFlipX: { value: flipX },
+                    iFlipY: { value: flipY },
+                    iTilt: { value: settings.tilt },
+                    iSaturation: { value: settings.saturation },
+                    iBlend: { value: settings.blend },
+                    iFalloff: { value: settings.falloff },
+                    iOpacity: { value: settings.opacity }
+                };

-            const geometry = new Triangle(gl);
-            const program = new Program(gl, { vertex: vertexShader, fragment: fragmentShader, uniforms });
-            const mesh = new Mesh(gl, { geometry, program });
+                const geometry = new Triangle(gl);
+                const program = new Program(gl, { vertex: vertexShader, fragment: fragmentShader, uniforms });
+                const mesh = new Mesh(gl, { geometry, program });

-            function resize() {
-                const width = rayContainer.clientWidth;
-                const height = rayContainer.clientHeight;
-                renderer.dpr = Math.min(window.devicePixelRatio, 2);
-                renderer.setSize(width, height);
-                uniforms.iResolution.value = [width * renderer.dpr, height * renderer.dpr];
-            }
+                function resize() {
+                    const width = rayContainer.clientWidth;
+                    const height = rayContainer.clientHeight;
+                    renderer.dpr = Math.min(window.devicePixelRatio, 2);
+                    renderer.setSize(width, height);
+                    uniforms.iResolution.value = [width * renderer.dpr, height * renderer.dpr];
+                }

-            window.addEventListener("resize", resize);
-            resize();
+                window.addEventListener("resize", resize);
+                resize();

-            function animate(time) {
-                uniforms.iTime.value = time * 0.001;
-                renderer.render({ scene: mesh });
+                function animate(time) {
+                    uniforms.iTime.value = time * 0.001;
+                    renderer.render({ scene: mesh });
+                    requestAnimationFrame(animate);
+                }
                requestAnimationFrame(animate);
-            }
-            requestAnimationFrame(animate);

-            function initLiquidButtons() {
-                const borderWidth = 0.16;
-                const brightness = 35;
-                const opacity = 0.55;
-                const blur = 4;
-                const displace = 1.2;
-                const borderRadius = 9999;
-                const distortionScale = -380;
-                const redOffset = -25;
-                const greenOffset = 0;
-                const blueOffset = 25;
-                const xChannel = "R";
-                const yChannel = "G";
-                const mixBlendMode = "screen";
+                function initLiquidButtons() {
+                    const borderWidth = 0.16;
+                    const brightness = 35;
+                    const opacity = 0.55;
+                    const blur = 4;
+                    const displace = 1.2;
+                    const borderRadius = 9999;
+                    const distortionScale = -380;
+                    const redOffset = -25;
+                    const greenOffset = 0;
+                    const blueOffset = 25;
+                    const xChannel = "R";
+                    const yChannel = "G";
+                    const mixBlendMode = "screen";

-                document.querySelectorAll(".liquid-glass-btn").forEach((btn, index) => {
-                    const filterId = `glass-filter-${index + 1}`;
-                    btn.style.setProperty("--filter-id", `url(#${filterId})`);
+                    document.querySelectorAll(".liquid-glass-btn").forEach((btn, index) => {
+                        const filterId = `glass-filter-${index + 1}`;
+                        btn.style.setProperty("--filter-id", `url(#${filterId})`);

-                    const feImage = btn.querySelector(".fe-image");
-                    const redChannel = btn.querySelector(".redchannel");
-                    const greenChannel = btn.querySelector(".greenchannel");
-                    const blueChannel = btn.querySelector(".bluechannel");
-                    const gaussianBlur = btn.querySelector(".gaussianBlur");
+                        const feImage = btn.querySelector(".fe-image");
+                        const redChannel = btn.querySelector(".redchannel");
+                        const greenChannel = btn.querySelector(".greenchannel");
+                        const blueChannel = btn.querySelector(".bluechannel");
+                        const gaussianBlur = btn.querySelector(".gaussianBlur");

-                    function generateDisplacementMap() {
-                        const rect = btn.getBoundingClientRect();
-                        const actualWidth = rect.width || 140;
-                        const actualHeight = rect.height || 48;
+                        function generateDisplacementMap() {
+                            const rect = btn.getBoundingClientRect();
+                            const actualWidth = rect.width || 140;
+                            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%">
@@ -470,41 +494,48 @@ 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() {
-                        feImage.setAttribute("href", generateDisplacementMap());
-                        redChannel.setAttribute("scale", distortionScale + redOffset);
-                        greenChannel.setAttribute("scale", distortionScale + greenOffset);
-                        blueChannel.setAttribute("scale", distortionScale + blueOffset);
-                        [redChannel, greenChannel, blueChannel].forEach((ch) => {
-                            ch.setAttribute("xChannelSelector", xChannel);
-                            ch.setAttribute("yChannelSelector", yChannel);
-                        });
-                        gaussianBlur.setAttribute("stdDeviation", displace);
-                    }
+                        function update() {
+                            feImage.setAttribute("href", generateDisplacementMap());
+                            redChannel.setAttribute("scale", distortionScale + redOffset);
+                            greenChannel.setAttribute("scale", distortionScale + greenOffset);
+                            blueChannel.setAttribute("scale", distortionScale + blueOffset);
+                            [redChannel, greenChannel, blueChannel].forEach((ch) => {
+                                ch.setAttribute("xChannelSelector", xChannel);
+                                ch.setAttribute("yChannelSelector", yChannel);
+                            });
+                            gaussianBlur.setAttribute("stdDeviation", displace);
+                        }

-                    update();
-                    btn.classList.remove("glass-surface--fallback");
-                    btn.classList.add("glass-surface--svg");
+                        update();
+                        btn.classList.remove("glass-surface--fallback");
+                        btn.classList.add("glass-surface--svg");

-                    const observer = new ResizeObserver(() => setTimeout(update, 0));
-                    observer.observe(btn);
-                });
+                        const observer = new ResizeObserver(() => setTimeout(update, 0));
+                        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");
+        const fileLine = document.getElementById("file-line");
+        let currentService = "";
+
+        if (actionsEl) actionsEl.style.display = "none";
+        if (progressTrack) progressTrack.style.display = "none";

        let currentStatusText = "";

@@ -524,9 +555,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__;
-            if (!eventApi || typeof eventApi.listen !== 'function') {
+            let eventApi = null;
+
+            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;
            }
@@ -534,25 +580,44 @@ void main() {
            eventApi.listen("status", (e) => {
                const data = e.payload || e;
                if (data && data.message) {
+                    if (fileLine) fileLine.textContent = "";
+                    currentService = "";
                    setStatus(data.message);
                }
            });

+            eventApi.listen("extract-progress", (e) => {
+                const data = e.payload || e;
+                if (!data || !data.file) return;
+                if (progressTrack) progressTrack.style.display = "block";
+                if (actionsEl) actionsEl.style.display = "none";
+                if (progressFill) progressFill.style.width = `${data.percent}%`;
+
+                const parts = String(data.file).split("/");
+                const service = parts.length > 1 ? parts[0] : "core files";
+                if (service !== currentService) {
+                    currentService = service;
+                    setStatus(`Installing ${service}...`);
+                }
+                if (fileLine) fileLine.textContent = `${data.file}  (${data.done}/${data.total})`;
+            });
+
            eventApi.listen("download-progress", (e) => {
                const data = e.payload || e;
                if (data) {
                    if (progressTrack) progressTrack.style.display = "block";
-                    const percent = data.percent || 0;
-                    if (progressFill) progressFill.style.width = percent + "%";
-                    if (!currentStatusText.startsWith("Downloading update...")) {
-                        setStatus("Downloading update...");
+                    if (progressFill && data.percent !== undefined) {
+                        progressFill.style.width = `${data.percent}%`;
                    }
+                    if (actionsEl) actionsEl.style.display = "none";
+                    setStatus(`Downloading update... ${data.percent !== undefined ? data.percent + '%' : ''}`);
                }
            });

            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";
                }
@@ -561,31 +626,29 @@ 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";
+                    if (fileLine) fileLine.textContent = "";
                    setStatus("Launching...");
-                    window.location.href = data.url;
                }
            });

            eventApi.listen("error", (e) => {
-                setStatus("Cleaning up background processes...", "#fca5a5");
-                try {
-                    const core = window.__TAURI__?.core;
-                    if (core) {
-                        core.invoke("kill_orphans").finally(() => {
-                            setTimeout(() => {
-                                core.invoke("win_close").catch(() => {});
-                            }, 500);
-                        });
-                    }
-                } catch (err) { }
+                const data = e.payload || e;
+                const msg = data && data.message ? data.message : JSON.stringify(data);
+                if (fileLine) fileLine.textContent = "";
+                setStatus("Runtime Error", "#fca5a5");
+                showDebug(msg);
            });
        }

        btnYes.addEventListener("click", () => {
-
-        if (actionsEl) actionsEl.style.display = "none";
+            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", () => {
--- a/update-client.js
+++ b/update-client.js
@@ -36,7 +36,9 @@ class UpdateClient {
      const urlObj = new URL(url);
      const headers = {
        'User-Agent': 'VylaHome-Client',
-        'Accept': 'application/json'
+        'Accept': 'application/json',
+        'Cache-Control': 'no-cache',
+        'Pragma': 'no-cache'
      };

      if (this.token) {
@@ -136,7 +138,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 +159,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,12 +237,21 @@ class UpdateClient {
  }

  async checkForUpdates() {
-    const cacheBuster = `?cb=${Date.now()}`;
-    const releases = await this.fetchJson(RELEASES_API + cacheBuster);
+    const query = `?per_page=20&order_by=released_at&sort=desc&cb=${Date.now()}`;
+    const releases = await this.fetchJson(RELEASES_API + query);
    if (!releases || releases.length === 0) {
      return null;
    }
-    const release = releases[0];
+    const verParts = (v) => String(v || '').replace(/^v/, '').split(/[.\-+]/).map((n) => parseInt(n, 10) || 0);
+    const cmp = (a, b) => {
+      const x = verParts(a);
+      const y = verParts(b);
+      for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        if ((x[i] || 0) !== (y[i] || 0)) return (x[i] || 0) - (y[i] || 0);
+      }
+      return 0;
+    };
+    const release = releases.slice().sort((a, b) => cmp(b.tag_name, a.tag_name))[0];

    const payloadAsset = (release.assets && release.assets.links ? release.assets.links : []).find(a => a.name === 'update-payload.zip');
    const manifestAsset = (release.assets && release.assets.links ? release.assets.links : []).find(a => a.name === 'manifest.json');
Author	SHA1	Message	Date
Devin Bot	4ed853b5ae	v1.1.47	2026-10-25 19:32:10 -07:00
Devin Bot	1b2c97e74b	potentially fixed auto updater, made sdk also up to date	2026-10-25 19:27:25 -07:00
Devin Bot	d9ae75e9cb	v1.1.46	2026-10-24 18:32:54 -07:00
Devin Bot	51951ac192	removed floating nav, made the updater better...?	2026-10-24 18:28:09 -07:00
Devin Bot	c131515209	added white icon	2026-10-24 18:13:14 -07:00
Devin Bot	b44f59f4b7	v1.1.45	2026-10-23 20:47:05 -07:00
Devin Bot	35087d24e8	fixed logo, updated sdk , changed frontend to support server.js n it runs it well	2026-10-23 20:13:01 -07:00
alwaysmesmerizingyou	2435ee51e6	fixed image path	2026-10-12 19:19:36 -07:00
alwaysmesmerizingyou	59f4d9855f	v1.1.43	2026-10-11 16:38:00 -07:00
alwaysmesmerizingyou	928b40230c	v1.1.42	2026-10-11 16:27:46 -07:00
alwaysmesmerizingyou	59bc589a85	updated	2026-10-11 16:22:36 -07:00
alwaysmesmerizingyou	63809ba2af	v1.1.42	2026-10-11 16:16:54 -07:00
alwaysmesmerizingyou	0918f8e8aa	v1.1.43	2026-10-11 16:15:58 -07:00
alwaysmesmerizingyou	4d085c33e1	Fix Tauri dependency version mismatch	2026-10-03 10:49:46 -07:00
alwaysmesmerizingyou	e71e73d166	v1.1.42	2026-10-03 10:38:23 -07:00
alwaysmesmerizingyou	d5e54939a8	v1.1.41	2026-09-26 12:13:10 -07:00
alwaysmesmerizingyou	76296cc7c2	allow localhost connections for update service in CSP	2026-09-26 12:07:52 -07:00
alwaysmesmerizingyou	c416f17e81	v1.1.40	2026-09-26 11:54:15 -07:00
alwaysmesmerizingyou	2c4501fa5f	ui tweaks	2026-09-26 11:49:14 -07:00
alwaysmesmerizingyou	eca4d017de	v1.1.39	2026-09-21 19:33:06 -07:00
alwaysmesmerizingyou	33727a79c5	possibly fixed auto updater? hid buttons untill shown and made the yes/no actually respond to something	2026-09-21 19:22:18 -07:00
alwaysmesmerizingyou	99e45fd7ff	Merge branch 'main' of https://gitlab.com/vyla-entertainment/home	2026-09-21 18:43:21 -07:00
alwaysmesmerizingyou	adf237dac0	v1.1.38	2026-09-21 18:43:20 -07:00
mesmerize	23021d6524	Add new file	2026-09-18 10:11:09 -07:00
alwaysmesmerizingyou	97ba68bd97	v1.1.37	2026-09-13 19:38:39 -07:00
alwaysmesmerizingyou	2de96960d9	fixed update issue	2026-09-13 19:32:21 -07:00
alwaysmesmerizingyou	8fd8be0d05	v1.1.36	2026-09-13 18:59:54 -07:00
alwaysmesmerizingyou	e3283fff45	updated sdk	2026-09-13 18:51:05 -07:00
alwaysmesmerizingyou	64ed5981be	v1.1.35	2026-09-07 11:26:23 -07:00
alwaysmesmerizingyou	ba8266bd86	fixed files not downloading properly	2026-09-07 11:21:39 -07:00
alwaysmesmerizingyou	bb39db0272	v1.1.34	2026-09-06 19:37:27 -07:00
alwaysmesmerizingyou	d799da3d2a	v1.1.33	2026-09-06 11:01:48 -07:00
alwaysmesmerizingyou	f4aaf2fa7c	removed stream-api & auth no need, fixed some issues aswell	2026-09-06 10:55:14 -07:00
alwaysmesmerizingyou	8ce4edc251	prevented unnecessary automatic updates	2026-09-05 17:03:18 -07:00
alwaysmesmerizingyou	bef6fd2326	updated md's	2026-09-05 16:49:20 -07:00
alwaysmesmerizingyou	774f9a5e03	V1.1.32	2026-09-05 11:51:46 -07:00
alwaysmesmerizingyou	250e7972f2	v1.1.31	2026-09-05 11:25:38 -07:00
alwaysmesmerizingyou	5082d51ebc	fixed	2026-09-05 11:24:28 -07:00
alwaysmesmerizingyou	ed66b894c1	v1.1.30	2026-09-05 11:07:49 -07:00
alwaysmesmerizingyou	11d6c346e8	resolve Rust state lifetime errors in Node service handlers	2026-09-05 11:00:31 -07:00
alwaysmesmerizingyou	c986194e64	v1.1.29	2026-09-05 10:26:01 -07:00
alwaysmesmerizingyou	33e285953c	prevent macOS HTTPS upgrade for localhost resources	2026-09-05 10:21:18 -07:00
alwaysmesmerizingyou	f46869f967	v1.1.28	2026-09-05 09:31:35 -07:00
alwaysmesmerizingyou	b19e6b21c9	use 127.0.0.1 for macOS localhost navigation to avoid ATS SSL errors	2026-09-05 09:15:27 -07:00
alwaysmesmerizingyou	c8ea2598b9	v1.1.27	2026-09-04 23:20:34 -07:00
alwaysmesmerizingyou	e3257b8a3a	v1.1.25	2026-09-04 23:16:26 -07:00
alwaysmesmerizingyou	fbb5a4437d	v1.1.25	2026-09-04 23:01:44 -07:00
alwaysmesmerizingyou	dbaab9a00e	fixed mismatch	2026-09-04 22:55:31 -07:00
alwaysmesmerizingyou	fc49bb93a7	allow localhost subresource loads in WKWebView	2026-09-04 22:52:34 -07:00
alwaysmesmerizingyou	9229f0c2dd	added this	2026-09-04 22:45:47 -07:00
alwaysmesmerizingyou	843abf7df4	supported devtools	2026-09-04 22:39:33 -07:00
alwaysmesmerizingyou	27fda0430b	v1.1.23	2026-09-04 22:37:36 -07:00
alwaysmesmerizingyou	8b49d679bd	add macOS ATS exception domain for localhost webview requests	2026-09-04 22:37:15 -07:00
alwaysmesmerizingyou	62883b3180	v1.1.22	2026-09-04 22:27:50 -07:00
alwaysmesmerizingyou	3c6ae0125b	use location.replace for WKWebView navigation	2026-09-04 22:27:24 -07:00
alwaysmesmerizingyou	be0810ea6d	fix: only check platform-matching node binary extension; bump to 1.1.20	2026-09-04 22:02:38 -07:00
alwaysmesmerizingyou	dff55060e7	fix: only check platform-matching node binary extension	2026-09-04 22:02:16 -07:00
alwaysmesmerizingyou	df767b5ffc	v1.1.20	2026-09-04 21:54:10 -07:00
alwaysmesmerizingyou	1b70c6784a	resolve bundled resources under both _up_ and up folder names	2026-09-04 21:53:44 -07:00
alwaysmesmerizingyou	e25e1c93f9	chore: bump version to 1.1.19	2026-09-04 21:37:32 -07:00
alwaysmesmerizingyou	4c708ad97c	preserve execute bit on bundled macOS node binary	2026-09-04 21:34:41 -07:00
alwaysmesmerizingyou	b81a4e044b	v1.1.18	2026-09-04 21:19:06 -07:00
alwaysmesmerizingyou	f6aa2daa01	fixed (os error 13)	2026-09-04 21:13:11 -07:00
alwaysmesmerizingyou	e03eb38adc	v1.1.17	2026-09-04 21:04:44 -07:00
alwaysmesmerizingyou	2b690b47c1	fixed typo	2026-09-04 20:58:53 -07:00
alwaysmesmerizingyou	dffbdb92a5	v1.1.16	2026-09-04 20:52:21 -07:00
alwaysmesmerizingyou	45d6515f2e	fixed some issues...?	2026-09-04 20:46:08 -07:00
alwaysmesmerizingyou	a3e6a278fe	v1.1.15	2026-09-04 20:15:10 -07:00
alwaysmesmerizingyou	7ffc20ee48	fixed harmless warning	2026-09-04 20:11:01 -07:00
alwaysmesmerizingyou	ddf3abb314	add macOS Node runtime and appdata support	2026-09-04 20:08:27 -07:00
alwaysmesmerizingyou	ec50c4e07f	v1.1.14	2026-09-04 19:55:59 -07:00
alwaysmesmerizingyou	49b2a7622b	added debug text	2026-09-04 19:51:27 -07:00
alwaysmesmerizingyou	b8e474cb92	Fix Mac tar extraction argument parsing	2026-09-04 19:35:21 -07:00
alwaysmesmerizingyou	8b29c9e3c7	Fix Mac Node architecture and resources bundle	2026-09-04 19:30:40 -07:00
alwaysmesmerizingyou	5dab61b359	Fix release installer path detection	2026-09-04 19:17:05 -07:00
alwaysmesmerizingyou	eab843aa16	Detect and upload macOS DMG bundle	2026-09-04 19:10:21 -07:00
alwaysmesmerizingyou	b757f741b7	Fix release log object and multi-platform extension replacement	2026-09-04 19:04:10 -07:00
alwaysmesmerizingyou	5f4c47a07c	Handle duplicate release asset links	2026-09-04 18:58:51 -07:00
alwaysmesmerizingyou	32677c9fb2	Fix Tauri window builder for macOS	2026-09-04 18:53:56 -07:00
alwaysmesmerizingyou	7eab57cfd9	Fix Rust PATH and lock release version	2026-09-04 18:50:17 -07:00
alwaysmesmerizingyou	c8fc7da64d	Configure free Mac cloud workflow	2026-09-04 18:47:30 -07:00
alwaysmesmerizingyou	88c1824bf7	removed the gitlab yml	2026-09-04 18:45:22 -07:00
alwaysmesmerizingyou	a50cb2b6b8	Fix Windows instance type	2026-09-04 18:45:15 -07:00
alwaysmesmerizingyou	971eae4af1	Add Windows and macOS Codemagic workflows	2026-09-04 18:44:28 -07:00
alwaysmesmerizingyou	1400d538f3	support mac user test	2026-09-04 18:32:40 -07:00
alwaysmesmerizingyou	b1d01d94da	v1.1.13	2026-09-04 14:38:43 -07:00
				`@@ -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."'