removed floating nav, made the updater better...?

.gitignore

@@ -1,7 +1,6 @@
-# Dependencies
 node_modules/
+package-lock.json
 
-# Build outputs
 dist/
 dist-build/
 temp-validation-extract/
@@ -10,37 +9,32 @@ manifest.json
 integrity-report.json
 validation-report.json
 
-# Rust & Tauri
 src-tauri/target/
 
-# Encrypted files (build-time only)
 config/encrypted-credentials.json
 
-# Sensitive files
 credentials.json
 .env
 *.key
 *.pem
 
-# OS files
 .DS_Store
 Thumbs.db
 desktop.ini
 
-# IDE
 .vscode/
 .idea/
 *.swp
 *.swo
 *~
 
-# Logs
 *.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-# Temporary files
 *.tmp
 *.temp
-download-temp.zip
+download-temp.zip
+
+.env

DOCUEMENTATION/CLEAR.bash

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

DOCUEMENTATION/CLEAR.md

@@ -1,13 +0,0 @@
-taskkill /F /IM node.exe -ErrorAction SilentlyContinue
-taskkill /F /IM vyla-home.exe -ErrorAction SilentlyContinue
-
-Remove-Item -Recurse -Force "$env:APPDATA\com.vyla.home" -ErrorAction SilentlyContinue
-Remove-Item -Recurse -Force "$env:APPDATA\vyla-home" -ErrorAction SilentlyContinue
-
-Remove-Item -Force "$env:USERPROFILE\Downloads\vyla-*-debug*.log" -ErrorAction SilentlyContinue
-
-Remove-Item -Recurse -Force "src-tauri\target" -ErrorAction SilentlyContinue
-Remove-Item -Recurse -Force "dist-build" -ErrorAction SilentlyContinue
-Remove-Item -Force "update-payload.zip" -ErrorAction SilentlyContinue
-Remove-Item -Force "manifest.json" -ErrorAction SilentlyContinue
-Remove-Item -Force "validation-report.json" -ErrorAction SilentlyContinue

DOCUEMENTATION/CLEAR.powershell

@@ -0,0 +1,52 @@
+taskkill /F /IM "node.exe" 2>$null
+taskkill /F /IM "vyla-home.exe" 2>$null
+taskkill /F /IM "Vyla Home.exe" 2>$null
+taskkill /F /IM "msedgewebview2.exe" 2>$null
+
+Stop-Process -Name "node", "vyla-home", "Vyla Home", "msedgewebview2" -Force -ErrorAction SilentlyContinue
+
+$pathsToDelete = @(
+    "$env:APPDATA\com.vyla.home",
+    "$env:APPDATA\vyla-home",
+    "$env:APPDATA\Vyla Home",
+    "$env:LOCALAPPDATA\com.vyla.home",
+    "$env:LOCALAPPDATA\vyla-home",
+    "$env:LOCALAPPDATA\Vyla Home",
+    "$env:LOCALAPPDATA\EBWebView",
+    "$env:LOCALAPPDATA\Programs\Vyla Home",
+    "$env:LOCALAPPDATA\Programs\vyla-home",
+    "$env:USERPROFILE\AppData\LocalLow\com.vyla.home",
+    "$env:USERPROFILE\AppData\LocalLow\vyla-home",
+    "$env:USERPROFILE\AppData\LocalLow\Vyla Home",
+    "$env:USERPROFILE\.vyla-home",
+    "$env:ProgramFiles\Vyla Home",
+    "${env:ProgramFiles(x86)}\Vyla Home",
+    "$env:USERPROFILE\Desktop\Vyla Home.lnk",
+    "$env:PUBLIC\Desktop\Vyla Home.lnk",
+    "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Vyla Home.lnk",
+    "$env:PROGRAMDATA\Microsoft\Windows\Start Menu\Programs\Vyla Home.lnk",
+    "$env:USERPROFILE\Downloads\vyla-*-debug*.log",
+    "$env:USERPROFILE\Downloads\*-debug.log",
+    "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"
+)
+
+foreach ($path in $pathsToDelete) {
+    if (Test-Path $path) {
+        Remove-Item -Recurse -Force $path -ErrorAction SilentlyContinue
+    }
+}

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

DOCUEMENTATION/FORDEV.md

@@ -0,0 +1,25 @@
+How to start this without releasing it.
+
+Package everything into a local payload zip:
+
+```powershell
+npm run build:payload
+```
+
+Start the Tauri app in development mode:
+
+```powershell
+npm run dev
+```
+
+To release it, run:
+
+```powershell
+npm run release:full
+```
+
+Fixing os error 32
+
+```powershell
+Stop-Process -Name "vyla-home", "node", "cargo" -Force -ErrorAction SilentlyContinue
+```

DOCUEMENTATION/LOGS.md

@@ -0,0 +1,6 @@
+Logs of node and rust can be found here:
+
+%APPDATA%\vyla-home\vyla-home-files\logs
+
+**Full path:**
+C:\Users\<YourUsername>\AppData\Roaming\vyla-home\vyla-home-files\logs\

LICENSE

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

README.md

@@ -1,29 +1,24 @@
 # Vyla Home
 
-Vyla Home is a desktop version of Vyla, built to run entirely on your own computer instead of on [vyla.cc](https://vyla.cc).
+A 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.
 
-## Why this exists
+## What It Does
 
-Running Vyla as a hosted website has been a constant source of stress. Hosting providers routinely block or throttle traffic coming from data centers, which is exactly where most affordable hosting lives. Every workaround for that involves paid infrastructure — residential proxies, dedicated IPs, premium tiers — that isn't realistic to keep funding long-term.
+Vyla Home is a native desktop app that:
 
-On top of that, there's the standing fear that comes with depending on someone else's infrastructure: a provider changes their policy, a server gets flagged, an account gets suspended, and everything just stops working with no warning. That uncertainty has genuinely cost some sleep. Waking up wondering if the whole project got wiped overnight isn't a sustainable way to build something.
+- **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
 
-Vyla Home is the answer to that. Instead of fighting hosting providers forever, the app runs locally on your own machine. No data center traffic to block. No hosting bills. No one else's finger on the switch.
+## How It Works
 
-## What it actually is
+When you launch Vyla Home, it:
 
-Vyla Home packages up the same player, streaming, and live-sports features as the website, wrapped in a small desktop app. When you open it:
+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
 
-- It grabs the latest version automatically
-- It starts everything up locally on your computer
-- The interface opens in its own window, just like the website did
-
-Everything runs for you, on your machine, for your own personal use.
-
-## What this is not
-
-This isn't a public service or a way to redistribute anything. It's a personal media player for personal use — think of it as watching things you already have access to, through your own local player, instead of a public streaming platform. Nothing here is intended to be shared, resold, or run as a service for other people.
-
-## Status
-
-Might not be actively worked on. Expect various bugs — this is a solo project built to solve a real problem, not a polished commercial product.
+Everything happens on your machine - your data never leaves your computer except when communicating directly with streaming services.

bin/node-v22.14.0.marker

@@ -0,0 +1 @@
+v22.14.0

build-pipeline.js

@@ -1,12 +1,11 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const JavaScriptObfuscator = require('javascript-obfuscator');
 const AdmZip = require('adm-zip');
 const { execSync } = require('child_process');
 
 const BUILD_DIR = path.join(__dirname, 'dist-build');
-const REPOS = ['frontend', 'player', 'auth-proxy', 'stream-api'];
+const REPOS = ['frontend', 'player'];
 
 const TEMP_EXTRACT_DIR = path.join(__dirname, 'temp-validation-extract');
 
@@ -15,22 +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) {
-  const repoUrl = `https://gitlab.com/${GITLAB_GROUP}/${repoConfig.name}.git`;
+  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 });
-    }
-
     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}`);
   }
@@ -71,23 +73,6 @@ function cleanBuildDir() {
   fs.mkdirSync(BUILD_DIR, { recursive: true });
 }
 
-function obfuscateFile(filePath, isEsm = false) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  const result = JavaScriptObfuscator.obfuscate(content, {
-    compact: true,
-    controlFlowFlattening: false,
-    deadCodeInjection: false,
-    debugProtection: false,
-    numbersToExpressions: false,
-    simplify: true,
-    stringArray: true,
-    stringArrayThreshold: 0.4,
-    stringArrayEncoding: [],
-    module: isEsm
-  });
-  fs.writeFileSync(filePath, result.getObfuscatedCode(), 'utf8');
-}
-
 function encryptCredentialsFile() {
   const CryptoUtils = require('./crypto-utils');
 
@@ -168,13 +153,6 @@ function processFolder(src, dest) {
       if (pkg.type === 'module') isEsm = true;
     } catch (e) { }
   }
-
-  for (const filePath of jsFiles) {
-    try {
-      obfuscateFile(filePath, isEsm);
-    } catch (e) {
-    }
-  }
 }
 
 function getFileChecksum(filePath) {
@@ -194,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,6 +307,9 @@ async function build() {
   }
 
   const zipPath = path.join(__dirname, 'update-payload.zip');
+  if (fs.existsSync(zipPath)) {
+    fs.rmSync(zipPath, { force: true });
+  }
   zip.writeZip(zipPath);
 
   const checksum = validatePayload(zipPath);
@@ -352,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 });
+      }
     }
   }
 

codemagic.yaml

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

config/credentials-template.json

@@ -1,16 +1,5 @@
 {
     "player": {
-        "TMDB_KEY": "YOUR_TMDB_KEY_HERE",
-        "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"
     }
 }

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"
   }
 }

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": []
+  ]
 }

crypto-utils.js

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

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';

main.js

@@ -6,9 +6,27 @@ const ServiceManager = require('./service-manager');
 const Patcher = require('./patcher');
 const UpdateClient = require('./update-client');
 
-const debugLogPath = path.join(os.homedir(), 'Downloads', 'vyla-node-debug.log');
+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
+  : getDefaultAppData();
+
+const LOGS_DIR = path.join(APPDATA_DIR, 'logs');
+try { fs.mkdirSync(LOGS_DIR, { recursive: true }); } catch (e) { }
+
+const debugLogPath = path.join(LOGS_DIR, 'node-debug.log');
+
 function debugLog(msg) {
-  try { fs.appendFileSync(debugLogPath, `[NODE] ${msg}\n`, 'utf8'); } catch (e) { }
+  try { fs.appendFile(debugLogPath, `[NODE] ${msg}\n`, 'utf8', () => { }); } catch (e) { }
 }
 
 debugLog("--- Node.js Process Started ---");
@@ -16,42 +34,131 @@ debugLog("--- Node.js Process Started ---");
 let serviceManager;
 let expressApp;
 let expressServer;
-let playerExpressApp;
-let playerExpressServer;
+let updateDecisionHandler = null;
 
-const APPDATA_DIR = process.env.APPDATA_PATH || path.join(os.homedir(), 'AppData', 'Roaming', 'vyla-home', 'vyla-home-files');
-fs.mkdirSync(APPDATA_DIR, { recursive: true });
 debugLog(`AppData Dir: ${APPDATA_DIR}`);
 
-const envConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config/env.json'), 'utf8'));
-const replacementsConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config/replacements.json'), 'utf8'));
-
-const updateClient = new UpdateClient(APPDATA_DIR);
-
 function sendToTauri(event, data) {
   debugLog(`Emitting to Tauri: [${event}] -> ${JSON.stringify(data)}`);
   process.stdout.write(JSON.stringify({ event, data }) + '\n');
 }
 
-process.on('unhandledRejection', (reason) => {
-  const message = reason && reason.message ? reason.message : String(reason);
-  debugLog(`UNHANDLED REJECTION: ${message}`);
-  sendToTauri('error', { message });
+function sameTabNavMiddleware(rootDir) {
+  return (req, res, next) => {
+    if (req.method !== 'GET') return next();
+    const isHtmlRequest = req.path === '/' || req.path.endsWith('/') || req.path.endsWith('.html');
+    if (!isHtmlRequest) return next();
+
+    const filePath = req.path === '/' || req.path.endsWith('/')
+      ? path.join(rootDir, req.path, 'index.html')
+      : path.join(rootDir, req.path);
+
+    fs.readFile(filePath, 'utf8', (err, data) => {
+      if (err) return next();
+      const injected = data.replace(
+        '</head>',
+        `<script>
+document.addEventListener('click', function(e) {
+  const a = e.target.closest('a[target]');
+  if (a && a.target === '_blank') a.removeAttribute('target');
+}, true);
+window.open = function(url) {
+  if (url) window.location.href = url;
+  return window;
+};
+</script></head>`
+      );
+      res.set('Content-Type', 'text/html');
+      res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+      res.set('Expires', '-1');
+      res.set('Pragma', 'no-cache');
+      res.send(injected);
+    });
+  };
+}
+
+const cmdApp = express();
+cmdApp.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();
+});
+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 port 4892"));
+
+process.stdin.resume();
+process.stdin.on('end', () => {
+  debugLog('stdin closed - parent died. Self-terminating...');
+  process.exit(0);
+});
+process.stdin.on('error', () => {
+  process.exit(0);
 });
 
 process.on('uncaughtException', (err) => {
-  debugLog(`UNCAUGHT EXCEPTION: ${err.message}`);
-  sendToTauri('error', { message: err.message });
+  debugLog(`CRITICAL UNCAUGHT EXCEPTION: ${err.stack || err.message}`);
+  if (err.code === 'EPIPE' || err.code === 'EOF') {
+    debugLog('Pipe to parent closed - parent process gone, exiting');
+    process.exit(0);
+  }
+  try { sendToTauri('error', { message: err.message }); } catch (e) { }
 });
 
+process.on('unhandledRejection', (reason) => {
+  const msg = reason && reason.stack ? reason.stack : String(reason);
+  debugLog(`CRITICAL UNHANDLED REJECTION: ${msg}`);
+  sendToTauri('error', { message: reason && reason.message ? reason.message : String(reason) });
+});
+
+function getEnvConfig() {
+  try {
+    const appPath = path.join(APPDATA_DIR, 'config/env.json');
+    if (fs.existsSync(appPath)) return JSON.parse(fs.readFileSync(appPath, 'utf8'));
+    return JSON.parse(fs.readFileSync(path.join(__dirname, 'config/env.json'), 'utf8'));
+  } catch (e) { return {}; }
+}
+
+function getReplacementsConfig() {
+  try {
+    const appPath = path.join(APPDATA_DIR, 'config/replacements.json');
+    if (fs.existsSync(appPath)) return JSON.parse(fs.readFileSync(appPath, 'utf8'));
+    return JSON.parse(fs.readFileSync(path.join(__dirname, 'config/replacements.json'), 'utf8'));
+  } catch (e) { return {}; }
+}
+
+const updateClient = new UpdateClient(APPDATA_DIR);
+
 async function start() {
   debugLog("Inside start() function");
-  sendToTauri('status', { message: 'Initializing patcher...' });
+  sendToTauri('status', { message: 'Loading core configuration files...' });
+
   const patcher = new Patcher(APPDATA_DIR);
-  serviceManager = new ServiceManager(APPDATA_DIR, envConfig);
+  serviceManager = new ServiceManager(APPDATA_DIR, getEnvConfig());
 
   const installBuild = async (release) => {
     const tempZipPath = path.join(APPDATA_DIR, 'download-temp.zip');
+    if (fs.existsSync(tempZipPath)) {
+      try { fs.unlinkSync(tempZipPath); } catch (e) { }
+    }
     let attempts = 0;
     let downloadSuccess = false;
 
@@ -59,34 +166,43 @@ async function start() {
       attempts++;
       try {
         debugLog(`Attempting to download update (Attempt ${attempts})...`);
-        sendToTauri('status', { message: `Downloading update (Attempt ${attempts}/3)...` });
+        sendToTauri('status', { message: `Connecting to download servers (Attempt ${attempts}/3)...` });
 
+        let lastPercent = -1;
         await updateClient.downloadUpdate(release, tempZipPath, (downloaded, total) => {
           const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
-          sendToTauri('download-progress', { downloaded, total, percent });
+          if (percent !== lastPercent) {
+            lastPercent = percent;
+            sendToTauri('download-progress', { downloaded, total, percent });
+          }
         });
 
         debugLog('Download complete. Verifying checksum...');
-        sendToTauri('status', { message: 'Verifying payload checksum...' });
+        sendToTauri('status', { message: 'Verifying SHA-256 integrity...' });
         if (!patcher.verifyChecksum(tempZipPath, release.sha256)) {
           throw new Error('SHA-256 checksum verification failed.');
         }
 
         debugLog('Checksum verified. Extracting...');
-        sendToTauri('status', { message: 'Extracting update files...' });
+        sendToTauri('status', { message: 'Unpacking update archive...' });
         patcher.purgeOldCode();
         patcher.extractZipPayload(tempZipPath);
 
+        sendToTauri('status', { message: 'Verifying file integrity...' });
         if (!patcher.verifyExtraction()) {
           throw new Error('Extraction verification failed: critical startup files missing.');
         }
 
         debugLog('Extraction complete. Applying patches...');
-        sendToTauri('status', { message: 'Applying patches & configuring...' });
-        patcher.applyPatches(replacementsConfig);
+        sendToTauri('status', { message: 'Applying configuration patches...' });
+        patcher.applyPatches(getReplacementsConfig());
+
+        sendToTauri('status', { message: 'Migrating security credentials...' });
         patcher.bridgeCredentials(serviceManager.credentialManager);
         patcher.saveCurrentVersion(release.version, release.sha256);
 
+        serviceManager.envConfig = getEnvConfig();
+
         if (fs.existsSync(tempZipPath)) {
           fs.unlinkSync(tempZipPath);
         }
@@ -94,6 +210,7 @@ async function start() {
         debugLog('Update installed successfully!');
       } catch (err) {
         debugLog(`Download/Install error on attempt ${attempts}: ${err.message}`);
+        sendToTauri('status', { message: `Install error: ${err.message}. Retrying...` });
         if (fs.existsSync(tempZipPath)) {
           try { fs.unlinkSync(tempZipPath); } catch (e) { }
         }
@@ -106,101 +223,207 @@ async function start() {
   };
 
   try {
-    const isFirstRun = !patcher.verifyExtraction();
-    const localVersion = patcher.getCurrentVersion();
-    const localSha = patcher.getCurrentSha();
-    debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}`);
+    sendToTauri('status', { message: 'Inspecting local workspace and installed files...' });
+    let isFirstRun = false;
+    let localVersion = '0.0.0'; 
+    let localSha = 'force-update-sha';
+    debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}, Local SHA: ${localSha}`);
 
-    sendToTauri('status', { message: 'Checking for updates...' });
+    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;
     try {
       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();
+
     if (release) {
-      const hasUpdate = release.version !== localVersion || (release.sha256 && release.sha256 !== localSha);
+      const isNewerSha = release.sha256 && localSha && release.sha256 !== localSha;
+      const isDifferentVer = normalizeVer(release.version) !== normalizeVer(localVersion);
+      const hasUpdate = (isDifferentVer || isNewerSha) && !localZipPath;
+
       if (isFirstRun) {
-        debugLog("First run. Installing remote build...");
+        debugLog("First run with no local payload. Installing remote build...");
+        sendToTauri('status', { message: 'First run detected. Preparing initial installation...' });
         await installBuild(release);
       } else if (hasUpdate) {
+
         debugLog("Update available. Prompting user...");
-        sendToTauri('update-available', { current: localVersion, latest: release.version });
+        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;
-        tempApp.post('/update/yes', (req, res) => { userDecision = true; res.sendStatus(200); });
-        tempApp.post('/update/no', (req, res) => { userDecision = false; res.sendStatus(200); });
-        const tempServer = tempApp.listen(4891, '127.0.0.1');
+        updateDecisionHandler = (val) => { userDecision = val; };
 
+        tempApp.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();
+        });
+        tempApp.get('/update/info', (req, res) => {
+          res.json({ available: true, current: localVersion, latest: release.version });
+        });
+        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) {
-          await new Promise(r => setTimeout(r, 500));
+          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));
+        }
+
+        updateDecisionHandler = null;
+        if (tempServer) {
+          tempServer.close();
         }
-        tempServer.close();
 
         if (userDecision) {
           debugLog("User accepted update.");
           await installBuild(release);
         } else {
           debugLog("User skipped update.");
+          sendToTauri('status', { message: 'Update skipped. Continuing startup...' });
         }
       } else {
         debugLog("Already on the latest version.");
+        sendToTauri('status', { message: 'Up to date.' });
       }
     } else if (isFirstRun) {
       debugLog("No remote release found, but it's the first run. Looking for local update-payload.zip...");
+      sendToTauri('status', { message: 'Looking for local payload archive...' });
       const localZip = path.join(__dirname, 'update-payload.zip');
       if (fs.existsSync(localZip)) {
-        sendToTauri('status', { message: 'Extracting initial local payload...' });
+        sendToTauri('status', { message: 'Extracting local baseline payload...' });
         patcher.purgeOldCode();
         patcher.extractZipPayload(localZip);
-        patcher.applyPatches(replacementsConfig);
+        patcher.applyPatches(getReplacementsConfig());
         patcher.bridgeCredentials(serviceManager.credentialManager);
-        patcher.saveCurrentVersion("1.0.0");
+
+        let ver = "1.0.0";
+        try {
+          const man = JSON.parse(fs.readFileSync(path.join(__dirname, 'manifest.json'), 'utf8'));
+          ver = man.version || ver;
+        } catch (e) { }
+
+        patcher.saveCurrentVersion(ver);
+        serviceManager.envConfig = getEnvConfig();
         debugLog("Local payload extracted successfully.");
       } else {
         debugLog("No local payload found!");
       }
     }
 
+    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 credentials...' });
+    sendToTauri('status', { message: 'Loading encrypted credentials...' });
     serviceManager.credentialManager.loadCredentials();
 
-    sendToTauri('status', { message: 'Starting backend services...' });
+    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.");
 
-    const playerDir = path.join(APPDATA_DIR, 'player');
-    playerExpressApp = express();
-    playerExpressApp.use(express.static(playerDir, { maxAge: '1d', etag: true }));
-    playerExpressApp.get('*', (req, res) => { res.sendFile(path.join(playerDir, 'index.html')); });
-    playerExpressServer = playerExpressApp.listen(3001, '0.0.0.0');
-    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 ports 3000, 3001, 7860...' });
-    await serviceManager.waitForPorts([3000, 3001, 7860]);
-    debugLog("Ports 3000, 3001, 7860 are ready.");
-
-    const frontendDir = path.join(APPDATA_DIR, 'frontend');
-    expressApp = express();
-    expressApp.use(express.static(frontendDir, { maxAge: '1d', etag: true }));
-    expressApp.get('*', (req, res) => { res.sendFile(path.join(frontendDir, 'index.html')); });
-
-    const FRONTEND_PORT = 4890;
-    expressServer = expressApp.listen(FRONTEND_PORT, '0.0.0.0', () => {
-      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}`);
@@ -212,17 +435,23 @@ process.on('exit', () => {
   if (serviceManager) {
     for (const name of Object.keys(serviceManager.processes)) {
       const proc = serviceManager.processes[name];
-      if (proc && proc.child) {
-        try { proc.child.kill('SIGKILL'); } catch (e) { }
+      if (proc && proc.child && proc.child.pid) {
+        try {
+          if (process.platform === 'win32') {
+            require('child_process').spawnSync('taskkill', ['/F', '/T', '/PID', proc.child.pid.toString()], { stdio: 'ignore', windowsHide: true });
+          } else {
+            process.kill(-proc.child.pid, 'SIGKILL');
+          }
+        } catch (e) { }
       }
     }
   }
 });
 
-process.on('SIGINT', async () => {
-  if (expressServer) expressServer.close();
-  if (playerExpressServer) playerExpressServer.close();
-  if (serviceManager) await serviceManager.stopAll();
+process.on('SIGINT', () => {
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
   process.exit(0);
 });
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyla-home",
-  "version": "1.0.3",
+  "version": "1.1.45",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -11,16 +11,16 @@
     "release:full": "node release.js --installer"
   },
   "dependencies": {
-    "@tauri-apps/api": "^2.0.0",
-    "@tauri-apps/plugin-shell": "^2.0.0",
-    "@tauri-apps/plugin-process": "^2.0.0",
-    "@vyla-entertainment/sdk": "^1.10.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.18.0",
     "adm-zip": "^0.6.0",
     "express": "^4.19.2"
   },
   "devDependencies": {
-    "@tauri-apps/cli": "^2.0.0",
-    "javascript-obfuscator": "^4.1.0"
+    "@tauri-apps/cli": "^2.0.0"
   },
   "build": {
     "appId": "com.vyla.home",

patcher.js

@@ -63,22 +63,46 @@ class Patcher {
       const fullPath = path.join(this.appDataPath, dir);
       if (fs.existsSync(fullPath)) {
         try {
-          fs.rmSync(fullPath, { recursive: true, force: true });
+          const trashPath = path.join(this.appDataPath, `.trash_${dir}_${Date.now()}`);
+          fs.renameSync(fullPath, trashPath);
+          fs.rmSync(trashPath, { recursive: true, force: true });
         } catch (e) {
           try {
-            const trashPath = fullPath + '.trash.' + Date.now();
-            fs.renameSync(fullPath, trashPath);
-          } catch (renameErr) {
-            console.warn(`[PATCHER] Could not remove or rename ${fullPath}. It will be overwritten.`);
-          }
+            fs.rmSync(fullPath, { recursive: true, force: true });
+          } catch (err2) { }
         }
       }
     }
+    try {
+      const files = fs.readdirSync(this.appDataPath);
+      for (const file of files) {
+        if (file.startsWith('.trash_')) {
+          fs.rmSync(path.join(this.appDataPath, file), { recursive: true, force: true });
+        }
+      }
+    } catch (e) { }
   }
 
   extractZipPayload(zipPath) {
+    const AdmZip = require('adm-zip');
     const zip = new AdmZip(zipPath);
+    const entries = zip.getEntries();
+
+    if (!entries || entries.length === 0) {
+      throw new Error('Downloaded archive is empty, invalid, or truncated.');
+    }
+
     zip.extractAllTo(this.appDataPath, true);
+
+    const testPath = path.join(this.appDataPath, 'frontend', 'index.html');
+    if (!fs.existsSync(testPath)) {
+      const { execSync } = require('child_process');
+      if (process.platform === 'win32') {
+        execSync(`powershell.exe -NoProfile -NonInteractive -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${this.appDataPath}' -Force"`, { windowsHide: true });
+      } else {
+        execSync(`unzip -o "${zipPath}" -d "${this.appDataPath}"`);
+      }
+    }
   }
 
   verifyChecksum(zipPath, expectedSha256) {
@@ -92,10 +116,8 @@ class Patcher {
 
   verifyExtraction() {
     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) {
@@ -107,19 +129,23 @@ 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;
       }
     }
     return true;
   }
 
-  processDirectory(dir, replacementList) {
+  processDirectory(dir, replacementList = []) {
     const files = fs.readdirSync(dir);
     for (const file of files) {
       const fullPath = path.join(dir, file);
@@ -130,33 +156,30 @@ class Patcher {
         this.processDirectory(fullPath, replacementList);
       } else if (stat.isFile()) {
         const ext = path.extname(fullPath).toLowerCase();
-        if (['.js', '.html', '.css', '.json', '.xml', '.txt'].includes(ext)) {
-          let content = fs.readFileSync(fullPath, 'utf8');
-          let modified = false;
+        let content = fs.readFileSync(fullPath, 'utf8');
+        let modified = false;
 
-          for (const rep of replacementList) {
-            if (content.includes(rep.find)) {
-              content = content.split(rep.find).join(rep.replace);
-              modified = true;
-            }
+        for (const rep of replacementList) {
+          if (content.includes(rep.find)) {
+            content = content.split(rep.find).join(rep.replace);
+            modified = true;
           }
+        }
 
-          if (modified) {
-            fs.writeFileSync(fullPath, content, 'utf8');
-          }
+        if (modified) {
+          fs.writeFileSync(fullPath, content, 'utf8');
         }
       }
     }
   }
 
   applyPatches(replacements) {
-    for (const [componentName, replacementList] of Object.entries(replacements)) {
-      if (!replacementList || replacementList.length === 0) continue;
-
-      const componentDir = path.join(this.appDataPath, componentName);
-      if (!fs.existsSync(componentDir)) continue;
-
-      this.processDirectory(componentDir, replacementList);
+    const targetDirs = ['frontend', 'player'];
+    for (const dirName of targetDirs) {
+      const dirPath = path.join(this.appDataPath, dirName);
+      if (!fs.existsSync(dirPath)) continue;
+      const replacementList = replacements[dirName] || [];
+      this.processDirectory(dirPath, replacementList);
     }
   }
 }

release.js

@@ -78,57 +78,82 @@ function uploadFileToGitLabPackage(filePath, packageName, version, fileName) {
 }
 
 function createGitLabRelease(tag, releaseLinks) {
-    const sendRequest = (method, path) => {
+    const sendRequest = (method, reqPath, data = null) => {
         return new Promise((resolve, reject) => {
-            let currentRef = 'main';
-            try {
-                currentRef = execSync('git rev-parse HEAD').toString().trim();
-            } catch (e) { }
-
-            const postData = JSON.stringify({
-                name: `Vyla Home Release ${tag}`,
-                tag_name: tag,
-                ref: currentRef,
-                description: `Automated local release ${tag}`,
-                assets: {
-                    links: releaseLinks
-                }
-            });
-
-            const req = https.request({
+            const options = {
                 hostname: 'gitlab.com',
                 port: 443,
-                path: path,
+                path: reqPath,
                 method: method,
                 headers: {
                     'PRIVATE-TOKEN': TOKEN,
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(postData)
+                    'Content-Type': 'application/json'
                 }
-            }, (res) => {
+            };
+            let postData = '';
+            if (data) {
+                postData = JSON.stringify(data);
+                options.headers['Content-Length'] = Buffer.byteLength(postData);
+            }
+
+            const req = https.request(options, (res) => {
                 let body = '';
                 res.on('data', chunk => body += chunk);
                 res.on('end', () => {
-                    if (res.statusCode === 200 || res.statusCode === 201) {
-                        resolve(JSON.parse(body));
-                    } else if (res.statusCode === 409 && method === 'POST') {
-                        console.log(`Release ${tag} already exists, updating assets...`);
-                        sendRequest('PUT', `/api/v4/projects/${PROJECT_ID}/releases/${encodeURIComponent(tag)}`)
-                            .then(resolve)
-                            .catch(reject);
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        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}`));
                     }
                 });
             });
 
             req.on('error', reject);
-            req.write(postData);
+            if (data) req.write(postData);
             req.end();
         });
     };
 
-    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`);
+    let currentRef = 'main';
+    try {
+        currentRef = execSync('git rev-parse HEAD').toString().trim();
+    } catch (e) { }
+
+    const releaseData = {
+        name: `Vyla Home Release ${tag}`,
+        tag_name: tag,
+        ref: currentRef,
+        description: `Automated Multi-Platform Release ${tag}`,
+        assets: {
+            links: releaseLinks
+        }
+    };
+
+    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() {
@@ -137,7 +162,7 @@ async function main() {
 
     const version = customTag || `v${incrementVersion()}`;
 
-    console.log(`=== Building Vyla Home Release (${version}) ===`);
+    console.log(`Building Vyla Home Release (${version})`);
 
     console.log('[1/4] Building update payload and manifest...');
     execSync('node build-pipeline.js', { stdio: 'inherit' });
@@ -153,26 +178,53 @@ async function main() {
     let installerUploadName = null;
 
     if (isFullBuild) {
-        console.log('[Optional] Compiling Windows Tauri installer locally...');
+        console.log('Ensuring bundled Node.js runtime...');
+        await ensureBundledNode();
+        await ensureWebView2Loader();
+
+        const bundleDir = path.join(__dirname, 'src-tauri', 'target', 'release', 'bundle');
+        if (fs.existsSync(bundleDir)) {
+            fs.rmSync(bundleDir, { recursive: true, force: true });
+        }
+
+        console.log('Compiling 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 files = fs.readdirSync(nsisDir).filter(f => f.endsWith('.exe'));
-            if (files.length > 0) {
-                const originalName = files[0];
-                installerPath = path.join(nsisDir, originalName);
-                installerUploadName = originalName.replace(/\s+/g, '-');
+        const targetVersion = version.startsWith('v') ? version.substring(1) : version;
+
+        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}`);
+                }
             }
         }
     }
 
     console.log('[2/4] Uploading artifacts to GitLab Package Registry...');
+    const timestamp = Date.now();
+
     console.log('Uploading update-payload.zip...');
-    const payloadUrl = await uploadFileToGitLabPackage(payloadPath, 'vyla-home', version, 'update-payload.zip');
+    const payloadUrl = await uploadFileToGitLabPackage(payloadPath, 'vyla-home', version, `update-payload-${timestamp}.zip`);
 
     console.log('Uploading manifest.json...');
-    const manifestUrl = await uploadFileToGitLabPackage(manifestPath, 'vyla-home', version, 'manifest.json');
+    const manifestUrl = await uploadFileToGitLabPackage(manifestPath, 'vyla-home', version, `manifest-${timestamp}.json`);
 
     const releaseLinks = [
         { name: 'update-payload.zip', url: payloadUrl, link_type: 'other' },
@@ -181,13 +233,145 @@ async function main() {
 
     if (installerPath && installerUploadName) {
         console.log(`Uploading installer ${installerUploadName}...`);
-        const installerUrl = await uploadFileToGitLabPackage(installerPath, 'vyla-home', version, installerUploadName);
+        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 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`);
+
+    if (fs.existsSync(nodeExePath) && fs.existsSync(versionMarker)) {
+        return Promise.resolve();
+    }
+
+    fs.mkdirSync(binDir, { recursive: true });
+    console.log(`Downloading standalone Node.js ${nodeVersion} runtime for bundling...`);
+
+    return new Promise((resolve, reject) => {
+        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();
+            });
+        } 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 });
+
+    const targetDllPath = path.join(releaseDir, 'WebView2Loader.dll');
+
+    if (fs.existsSync(rootDllPath) && fs.existsSync(targetDllPath)) {
+        return Promise.resolve();
+    }
+
+    const AdmZip = require('adm-zip');
+    const tempNupkg = path.join(__dirname, 'temp-wv2.zip');
+    const nupkgUrl = 'https://www.nuget.org/api/v2/package/Microsoft.Web.WebView2/1.0.2903.40';
+
+    return new Promise((resolve, reject) => {
+        const fileStream = fs.createWriteStream(tempNupkg);
+        const request = (url) => {
+            https.get(url, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    return request(res.headers.location);
+                }
+                res.pipe(fileStream);
+                fileStream.on('finish', () => {
+                    fileStream.close();
+                    try {
+                        const zip = new AdmZip(tempNupkg);
+                        const zipEntries = zip.getEntries();
+                        const dllEntry = zipEntries.find(e =>
+                            e.entryName.includes('x64/WebView2Loader.dll') ||
+                            e.entryName.includes('x64\\WebView2Loader.dll')
+                        );
+                        if (dllEntry) {
+                            const buffer = dllEntry.getData();
+                            fs.writeFileSync(targetDllPath, buffer);
+                            fs.writeFileSync(rootDllPath, buffer);
+                        }
+                        try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                        resolve();
+                    } catch (e) {
+                        try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                        reject(e);
+                    }
+                });
+            }).on('error', (err) => {
+                try { fs.unlinkSync(tempNupkg); } catch (_) { }
+                reject(err);
+            });
+        };
+        request(nupkgUrl);
+    });
 }
 
 main().catch(err => {

service-manager.js

@@ -21,8 +21,7 @@ class ServiceManager {
     try {
       const logPath = path.join(this.logsDir, `${name}.log`);
       const timestamp = new Date().toISOString();
-      fs.appendFileSync(logPath, `[${timestamp}] ${line}\n`, 'utf8');
-
+      fs.appendFile(logPath, `[${timestamp}] ${line}\n`, 'utf8', () => { });
       process.stdout.write(JSON.stringify({ event: "service-log", data: { service: name, message: line } }) + '\n');
     } catch (e) {
     }
@@ -41,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) || {})
     };
@@ -90,6 +93,25 @@ class ServiceManager {
     child.stderr.on('data', (data) => {
       const text = data.toString().trim();
       this.logToFile(name, `STDERR: ${text}`);
+
+      if (text.includes('EADDRINUSE')) {
+        const match = text.match(/:(\d+)/);
+        const port = match ? match[1] : null;
+        if (port) {
+          try {
+            if (process.platform === 'win32') {
+              require('child_process').spawnSync('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `Get-NetTCPConnection -LocalPort ${port} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force }`
+              ], { stdio: 'ignore', windowsHide: true });
+            } else {
+              require('child_process').spawnSync('fuser', ['-k', '-9', `${port}/tcp`], { stdio: 'ignore' });
+            }
+          } catch (_) { }
+        }
+      }
     });
 
     child.on('exit', (code, signal) => {
@@ -111,7 +133,7 @@ class ServiceManager {
           this.startService(name, relativeDir, startScript).catch(err => {
             this.logToFile(name, `Failed to restart: ${err.message}`);
           });
-        }, 3000);
+        }, 1500);
       }
     });
   }
@@ -175,7 +197,7 @@ class ServiceManager {
       });
 
       if (connected) return true;
-      await new Promise(r => setTimeout(r, 500));
+      await new Promise(r => setTimeout(r, 40));
     }
     throw new Error(`Timeout waiting for port ${port}`);
   }

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.0.3"
+version = "1.1.45"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -8,9 +8,25 @@ edition = "2021"
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = ["devtools"] }
 tauri-plugin-opener = "2"
 tauri-plugin-process = "2"
 tauri-plugin-shell = "2"
 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
+codegen-units = 1
+strip = true
+panic = "abort"
+
+[profile.dev]
+opt-level = 0
+debug = true
+incremental = true

src-tauri/Info.plist

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

src-tauri/build.rs

@@ -1,3 +1,32 @@
 fn main() {
-    tauri_build::build()
+    println!("cargo:rerun-if-changed=src/main.rs");
+    println!("cargo:rerun-if-changed=tauri.conf.json");
+    
+    if std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default() == "windows" {
+        if let (Ok(manifest_dir), Ok(out_dir)) = (std::env::var("CARGO_MANIFEST_DIR"), std::env::var("OUT_DIR")) {
+            let mut target_dir = std::path::PathBuf::from(out_dir);
+            target_dir.pop();
+            target_dir.pop();
+            target_dir.pop();
+            let dll_src = std::path::Path::new(&manifest_dir).join("WebView2Loader.dll");
+            let dll_dest = target_dir.join("WebView2Loader.dll");
+            if dll_src.exists() {
+                let _ = std::fs::copy(dll_src, dll_dest);
+            }
+        }
+    }
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let node_path = std::path::Path::new("../bin/node");
+        if node_path.exists() {
+            let _ = std::fs::set_permissions(
+                node_path,
+                std::fs::Permissions::from_mode(0o755),
+            );
+        }
+    }
+    
+    tauri_build::build();
 }

src-tauri/capabilities/default.json

@@ -0,0 +1,40 @@
+{
+    "$schema": "../gen/schemas/desktop-schema.json",
+    "identifier": "default",
+    "description": "Default permissions for Vyla Home main window and popups",
+    "windows": [
+        "main",
+        "win_*"
+    ],
+    "remote": {
+        "urls": [
+            "http://localhost:4890/*",
+            "http://localhost:3001/*",
+            "http://localhost:3000/*",
+            "http://localhost:7860/*",
+            "http://127.0.0.1:4890/*",
+            "http://127.0.0.1:3001/*",
+            "http://127.0.0.1:3000/*",
+            "http://127.0.0.1:7860/*"
+        ]
+    },
+    "permissions": [
+        "core:default",
+        "core:window:allow-minimize",
+        "core:window:allow-maximize",
+        "core:window:allow-unmaximize",
+        "core:window:allow-is-maximized",
+        "core:window:allow-close",
+        "core:window:allow-start-dragging",
+        "core:webview:allow-create-webview-window",
+        "core:webview:allow-print",
+        "shell:allow-open",
+        "process:allow-exit",
+        "core:app:default",
+        "allow-win-minimize",
+        "allow-win-maximize",
+        "allow-win-close",
+        "allow-win-drag",
+        "allow-open-new-window"
+    ]
+}

src-tauri/gen/schemas/capabilities.json

@@ -1 +1 @@
-{}
+{"default":{"identifier":"default","description":"Default permissions for Vyla Home main window and popups","remote":{"urls":["http://localhost:4890/*","http://localhost:3001/*","http://localhost:3000/*","http://localhost:7860/*","http://127.0.0.1:4890/*","http://127.0.0.1:3001/*","http://127.0.0.1:3000/*","http://127.0.0.1:7860/*"]},"local":true,"windows":["main","win_*"],"permissions":["core:default","core:window:allow-minimize","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-is-maximized","core:window:allow-close","core:window:allow-start-dragging","core:webview:allow-create-webview-window","core:webview:allow-print","shell:allow-open","process:allow-exit","core:app:default","allow-win-minimize","allow-win-maximize","allow-win-close","allow-win-drag","allow-open-new-window"]}}

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

@@ -554,6 +554,42 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
+        {
+          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`",
+          "type": "string",
+          "const": "default",
+          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`"
+        },
+        {
+          "description": "Allows opening a new webview window",
+          "type": "string",
+          "const": "allow-open-new-window",
+          "markdownDescription": "Allows opening a new webview window"
+        },
+        {
+          "description": "Allows closing the window",
+          "type": "string",
+          "const": "allow-win-close",
+          "markdownDescription": "Allows closing the window"
+        },
+        {
+          "description": "Allows dragging the window",
+          "type": "string",
+          "const": "allow-win-drag",
+          "markdownDescription": "Allows dragging the window"
+        },
+        {
+          "description": "Allows maximizing/unmaximizing the window",
+          "type": "string",
+          "const": "allow-win-maximize",
+          "markdownDescription": "Allows maximizing/unmaximizing the window"
+        },
+        {
+          "description": "Allows minimizing the window",
+          "type": "string",
+          "const": "allow-win-minimize",
+          "markdownDescription": "Allows minimizing the window"
+        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",
@@ -590,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",
@@ -680,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",
@@ -1940,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",
@@ -2408,6 +2462,12 @@
           "const": "core:window:deny-set-fullscreen",
           "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Denies the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-fullscreen-on-monitor",
+          "markdownDescription": "Denies the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_icon command without any pre-configured scope.",
           "type": "string",

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

@@ -554,6 +554,42 @@
     "Identifier": {
       "description": "Permission identifier",
       "oneOf": [
+        {
+          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`",
+          "type": "string",
+          "const": "default",
+          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`"
+        },
+        {
+          "description": "Allows opening a new webview window",
+          "type": "string",
+          "const": "allow-open-new-window",
+          "markdownDescription": "Allows opening a new webview window"
+        },
+        {
+          "description": "Allows closing the window",
+          "type": "string",
+          "const": "allow-win-close",
+          "markdownDescription": "Allows closing the window"
+        },
+        {
+          "description": "Allows dragging the window",
+          "type": "string",
+          "const": "allow-win-drag",
+          "markdownDescription": "Allows dragging the window"
+        },
+        {
+          "description": "Allows maximizing/unmaximizing the window",
+          "type": "string",
+          "const": "allow-win-maximize",
+          "markdownDescription": "Allows maximizing/unmaximizing the window"
+        },
+        {
+          "description": "Allows minimizing the window",
+          "type": "string",
+          "const": "allow-win-minimize",
+          "markdownDescription": "Allows minimizing the window"
+        },
         {
           "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
           "type": "string",
@@ -590,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",
@@ -680,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",
@@ -1940,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",
@@ -2408,6 +2462,12 @@
           "const": "core:window:deny-set-fullscreen",
           "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
         },
+        {
+          "description": "Denies the set_fullscreen_on_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-fullscreen-on-monitor",
+          "markdownDescription": "Denies the set_fullscreen_on_monitor command without any pre-configured scope."
+        },
         {
           "description": "Denies the set_icon command without any pre-configured scope.",
           "type": "string",

src-tauri/permissions/default.toml

@@ -0,0 +1,37 @@
+"$schema" = "schemas/schema.json"
+
+[[permission]]
+identifier = "allow-win-minimize"
+description = "Allows minimizing the window"
+commands.allow = ["win_minimize"]
+
+[[permission]]
+identifier = "allow-win-maximize"
+description = "Allows maximizing/unmaximizing the window"
+commands.allow = ["win_maximize"]
+
+[[permission]]
+identifier = "allow-win-close"
+description = "Allows closing the window"
+commands.allow = ["win_close"]
+
+[[permission]]
+identifier = "allow-win-drag"
+description = "Allows dragging the window"
+commands.allow = ["win_drag"]
+
+[[permission]]
+identifier = "allow-open-new-window"
+description = "Allows opening a new webview window"
+commands.allow = ["open_new_window"]
+
+[[set]]
+identifier = "default"
+description = "Default permissions for Vyla Home app commands"
+permissions = [
+    "allow-win-minimize",
+    "allow-win-maximize",
+    "allow-win-close",
+    "allow-win-drag",
+    "allow-open-new-window"
+]

src-tauri/src/main.rs

@@ -6,12 +6,34 @@ use std::sync::Mutex;
 use tauri::{Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder};
 
 fn debug_log(msg: &str) {
-    if let Ok(user_profile) = std::env::var("USERPROFILE") {
-        let log_path = std::path::Path::new(&user_profile).join("Downloads").join("vyla-rust-debug.log");
-        if let Ok(mut file) = std::fs::OpenOptions::new().create(true).append(true).open(&log_path) {
-            use std::io::Write;
-            let _ = writeln!(file, "[RUST] {}", msg);
-        }
+    let log_dir = if let Ok(app_data) = std::env::var("APPDATA") {
+        std::path::PathBuf::from(app_data)
+            .join("vyla-home")
+            .join("vyla-home-files")
+            .join("logs")
+    } 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::env::temp_dir().join("vyla-home-logs")
+    };
+
+    let _ = std::fs::create_dir_all(&log_dir);
+    let log_path = log_dir.join("rust-debug.log");
+
+    if let Ok(mut file) = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&log_path)
+    {
+        use std::io::Write;
+        let _ = writeln!(file, "[RUST] {}", msg);
     }
 }
 
@@ -32,12 +54,39 @@ fn clean_path(path: &std::path::Path) -> String {
     }
 }
 
+fn kill_child_process(child: &mut Child) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        let _ = Command::new("taskkill")
+            .args(&["/F", "/T", "/PID", &child.id().to_string()])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+    }
+    let _ = child.kill();
+    let _ = child.wait();
+}
+
 fn find_node_binary(app: &tauri::App) -> Option<String> {
     if let Ok(resource_dir) = app.path().resource_dir() {
+        #[cfg(windows)]
         let candidates = [
-            resource_dir.join("node.exe"),
             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() {
@@ -46,18 +95,36 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
         }
     }
 
+    if let Ok(exe_path) = std::env::current_exe() {
+        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() {
+                    return Some(clean_path(&candidate));
+                }
+            }
+        }
+    }
+
     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));
             }
-            #[cfg(not(windows))]
-            {
-                let candidate_unix = p.join("node");
-                if candidate_unix.exists() {
-                    return Some(clean_path(&candidate_unix));
-                }
+                
+            let node = p.join("node");
+            if node.exists() {
+                return Some(clean_path(&node));
             }
         }
     }
@@ -84,13 +151,20 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
                 return Some(clean_path(&candidate));
             }
         }
+    }
 
-        if let Ok(app_data) = std::env::var("APPDATA") {
-            let candidate = std::path::PathBuf::from(app_data)
-                .join("npm")
-                .join("node.exe");
+    #[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));
+                return Some(clean_path(candidate));
             }
         }
     }
@@ -100,16 +174,13 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
 
 fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
     if let Ok(resource_dir) = app.path().resource_dir() {
-        debug_log(&format!("Resource dir found: {:?}", resource_dir));
-        
         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() {
-                debug_log(&format!("main.js found at: {:?}", candidate));
                 let root_dir = candidate.parent().unwrap();
                 return (clean_path(&candidate), clean_path(root_dir));
             }
@@ -121,20 +192,61 @@ fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
         dir.pop();
     }
     let candidate = dir.join("main.js");
-    debug_log(&format!("Fallback script path: {:?}", candidate));
     (clean_path(&candidate), clean_path(&dir))
 }
 
-const LINK_HANDLER_SCRIPT: &str = r#"
-    window.open = function(url) {
-        if (!url) return null;
-        if (url.startsWith('http://localhost') || url.startsWith('/') || url.startsWith(window.location.origin)) {
-            window.location.href = url;
-        } else if (window.__TAURI__ && window.__TAURI__.opener) {
-            window.__TAURI__.opener.openUrl(url);
-        } else if (window.__TAURI_INTERNALS__) {
-            window.__TAURI_INTERNALS__.invoke('plugin:opener|open_url', { rule: { url: url } });
+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 || {});
+        }
+        return Promise.resolve(null);
+    }
+
+    function minimizeWindow() { doInvoke('win_minimize'); }
+    function maximizeWindow() { doInvoke('win_maximize'); }
+    function closeWindow() { doInvoke('win_close'); }
+    function dragWindow() { doInvoke('win_drag'); }
+
+    function openExternalUrl(url) {
+        if (window.__TAURI__ && window.__TAURI__.opener) {
+            window.__TAURI__.opener.openUrl(url);
+        } else if (window.__TAURI__ && window.__TAURI__.shell) {
+            window.__TAURI__.shell.open(url);
+        } else {
+            window.open(url, '_blank');
+        }
+    }
+
+    window.open = function(url, target, features) {
+        doInvoke('open_new_window', { url: url });
         return null;
     };
 
@@ -142,20 +254,352 @@ const LINK_HANDLER_SCRIPT: &str = r#"
         const a = e.target.closest('a');
         if (!a || !a.href) return;
 
-        const isLocal = a.href.startsWith('http://localhost') || a.href.startsWith('tauri://') || a.href.startsWith(window.location.origin) || a.href.startsWith('/');
-
-        if (a.target === '_blank') {
+        if (a.href.includes('discord.gg') || a.href.includes('discord.com')) {
             e.preventDefault();
-            if (isLocal) {
-                window.location.href = a.href;
-            } else if (window.__TAURI__ && window.__TAURI__.opener) {
-                window.__TAURI__.opener.openUrl(a.href);
-            } else if (window.__TAURI_INTERNALS__) {
-                window.__TAURI_INTERNALS__.invoke('plugin:opener|open_url', { rule: { url: a.href } });
-            }
+            e.stopPropagation();
+            openExternalUrl(a.href);
+            return;
+        }
+
+        if (a.target === '_blank' || e.ctrlKey || e.metaKey || e.button === 1) {
+            e.preventDefault();
+            e.stopPropagation();
+            doInvoke('open_new_window', { url: a.href });
         }
     }, true);
-"#;
+
+    function injectLiquidNavBar() {
+        if (document.getElementById('tauri-custom-titlebar')) return;
+        if (!document.body) return;
+
+        const style = document.createElement('style');
+        style.innerHTML = `
+            #tauri-custom-titlebar {
+                position: fixed !important;
+                top: 0 !important;
+                left: 0 !important;
+                right: 0 !important;
+                height: 32px !important;
+                max-height: 32px !important;
+                display: flex !important;
+                justify-content: flex-end !important;
+                align-items: center !important;
+                z-index: 2147483647 !important;
+                background: transparent !important;
+                pointer-events: none !important;
+                box-sizing: border-box !important;
+                margin: 0 !important;
+                padding: 0 !important;
+            }
+                
+            .tauri-drag-region {
+                position: absolute !important;
+                inset: 0 !important;
+                height: 32px !important;
+                cursor: default !important;
+                pointer-events: auto !important;
+            }
+                
+            .tauri-window-controls {
+                display: flex !important;
+                height: 32px !important;
+                margin: 0 !important;
+                padding: 0 !important;
+                pointer-events: auto !important;
+                z-index: 2147483648 !important;
+            }
+                
+            button.tauri-btn {
+                width: 46px !important;
+                min-width: 46px !important;
+                max-width: 46px !important;
+                height: 32px !important;
+                background: transparent !important;
+                border: none !important;
+                color: #ffffff !important;
+                display: flex !important;
+                align-items: center !important;
+                justify-content: center !important;
+                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 tb = document.createElement('div');
+        tb.id = 'tauri-custom-titlebar';
+        tb.innerHTML = `
+            <div class="tauri-drag-region"></div>
+            <div class="tauri-window-controls">
+                <button class="tauri-btn" id="tauri-btn-min" title="Minimize"><svg viewBox="0 0 10 10"><rect x="1" y="4" width="8" height="1"/></svg></button>
+                <button class="tauri-btn" id="tauri-btn-max" title="Maximize"><svg viewBox="0 0 10 10"><path d="M1,1v8h8V1H1z M8,8H2V2h6V8z"/></svg></button>
+                <button class="tauri-btn" id="tauri-btn-close" title="Close"><svg viewBox="0 0 10 10"><path d="M10,1.4L8.6,0L5,3.6L1.4,0L0,1.4L3.6,5L0,8.6L1.4,10L5,6.4L8.6,10L10,8.6L6.4,5L10,1.4z"/></svg></button>
+            </div>
+        `;
+        document.body.appendChild(tb);
+
+        const btnMin = tb.querySelector('#tauri-btn-min');
+        const btnMax = tb.querySelector('#tauri-btn-max');
+        const btnClose = tb.querySelector('#tauri-btn-close');
+        const dragEl = tb.querySelector('.tauri-drag-region');
+
+        if (btnMin) btnMin.onclick = (e) => { e.preventDefault(); e.stopPropagation(); minimizeWindow(); };
+        if (btnMax) btnMax.onclick = (e) => { e.preventDefault(); e.stopPropagation(); maximizeWindow(); };
+        if (btnClose) btnClose.onclick = (e) => { e.preventDefault(); e.stopPropagation(); closeWindow(); };
+        if (dragEl) {
+            dragEl.onmousedown = (e) => {
+                if (e.buttons === 1) {
+                    e.preventDefault();
+                    dragWindow();
+                }
+            };
+        }
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', injectLiquidNavBar);
+    } else {
+        injectLiquidNavBar();
+    }
+
+    const navObserver = new MutationObserver(() => {
+        if (!document.getElementById('vyla-floating-nav')) {
+            injectLiquidNavBar();
+        }
+    });
+    navObserver.observe(document.documentElement, { childList: true, subtree: true });
+"##;
+
+#[tauri::command]
+fn win_minimize(window: tauri::Window) -> Result<(), String> {
+    window.minimize().map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+fn win_maximize(window: tauri::Window) -> Result<(), String> {
+    if let Ok(is_max) = window.is_maximized() {
+        if is_max {
+            window.unmaximize().map_err(|e| e.to_string())
+        } else {
+            window.maximize().map_err(|e| e.to_string())
+        }
+    } else {
+        Ok(())
+    }
+}
+
+#[tauri::command]
+fn win_close(window: tauri::Window) -> Result<(), String> {
+    window.close().map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+fn win_drag(window: tauri::Window) -> Result<(), String> {
+    window.start_dragging().map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
+    debug_log(&format!("[SAME-TAB] Redirecting main window to: {}", url));
+
+    let final_url = if url.starts_with("http") || url.starts_with("tauri://") {
+        url.clone()
+    } else if url.starts_with('/') {
+        format!("http://127.0.0.1:4890{}", url)
+    } else {
+        format!("http://127.0.0.1:4890/{}", url)
+    };
+
+    if let Some(window) = app.get_webview_window("main") {
+        window
+            .eval(&format!(
+                "window.location.href = '{}';",
+                final_url.replace('\'', "\\'")
+            ))
+            .map_err(|e| e.to_string())?;
+        Ok(())
+    } else {
+        Err("main window not found".to_string())
+    }
+}
+
+#[tauri::command]
+async fn kill_orphans() -> Result<(), String> {
+    debug_log("[KILL] User requested orphan process kill");
+
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+        let _ = std::process::Command::new("taskkill")
+            .args(&["/F", "/T", "/IM", "node.exe"])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+    }
+
+    #[cfg(not(windows))]
+    {
+        let _ = std::process::Command::new("pkill")
+            .args(&["-9", "-f", "node"])
+            .output();
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+fn get_logo_base64(app: tauri::AppHandle) -> Result<String, String> {
+    use std::io::Read;
+    let mut candidate_paths = Vec::new();
+
+    if let Ok(res_dir) = app.path().resource_dir() {
+        candidate_paths.push(res_dir.join("build").join("icon_white.png"));
+        candidate_paths.push(res_dir.join("_up_").join("build").join("icon_white.png"));
+    }
+
+    if let Ok(mut cur) = std::env::current_dir() {
+        candidate_paths.push(cur.join("build").join("icon_white.png"));
+        if cur.ends_with("src-tauri") {
+            cur.pop();
+            candidate_paths.push(cur.join("build").join("icon_white.png"));
+        }
+    }
+
+    for path in candidate_paths {
+        if path.exists() {
+            if let Ok(mut file) = std::fs::File::open(&path) {
+                let mut buffer = Vec::new();
+                if file.read_to_end(&mut buffer).is_ok() {
+                    use base64::Engine;
+                    return Ok(base64::engine::general_purpose::STANDARD.encode(buffer));
+                }
+            }
+        }
+    }
+
+    Err("icon_white.png not found".to_string())
+}
+
+fn 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 ===");
@@ -164,46 +608,78 @@ fn main() {
         .plugin(tauri_plugin_shell::init())
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_opener::init())
+        .invoke_handler(tauri::generate_handler![
+            win_minimize,
+            win_maximize,
+            win_close,
+            win_drag,
+            open_new_window,
+            get_logo_base64,
+            kill_orphans
+        ])
         .manage(NodeServices(Mutex::new(None)))
         .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);
-            debug_log(&format!("AppData path: {}", app_data_str));
+
+            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(true)
+                .decorations(false)
                 .resizable(true)
+                .devtools(true)
+                .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
                 .initialization_script(LINK_HANDLER_SCRIPT)
                 .build()?;
-            
-            debug_log("Webview created");
 
             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 => {
-                    debug_log("Node.js runtime not found anywhere");
-                    let _ = window.emit(
-                        "error",
-                        serde_json::json!({
-                            "message": "Node.js runtime not found on this system. Please install Node.js (https://nodejs.org) and restart Vyla Home."
-                        }),
-                    );
+                    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(());
                 }
             };
 
-            debug_log(&format!("Using Node binary: {}", node_bin));
-            debug_log(&format!("Spawning node with script: {}", main_js));
+            let vyla_files_str = clean_path(&vyla_files);
+            std::thread::sleep(std::time::Duration::from_millis(400));
 
             let mut cmd = Command::new(&node_bin);
             cmd.arg(&main_js)
                 .current_dir(&root_dir)
-                .env("APPDATA_PATH", &app_data_str)
+                .env("APPDATA_PATH", &vyla_files_str)
                 .env("NODE_EXE", &node_bin)
+                .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
 
@@ -216,34 +692,65 @@ fn main() {
 
             match cmd.spawn() {
                 Ok(mut child) => {
-                    debug_log("Node spawned successfully");
+                    debug_log(&format!(
+                        "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) }),
+                                    );
+                                }
+                            }
+                        });
+                    }
+
                     if let Some(stdout) = child.stdout.take() {
                         let w = window.clone();
                         std::thread::spawn(move || {
                             use std::io::{BufRead, BufReader};
                             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) {
-                                    let _ = w.emit(&msg.event, msg.data.clone());
-                                    if msg.event == "ready" {
-                                        if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
-                                            let _ = w.eval(&format!("window.location.href = '{}';", url));
+                                debug_log(&format!("[NODE STDOUT] {}", line));
+
+                                let msg = match serde_json::from_str::<BackendMessage>(&line) {
+                                    Ok(m) => m,
+                                    Err(_) => {
+                                        if !line.trim().is_empty() {
+                                            debug_log(&format!("[NODE RAW] {}", line));
                                         }
+                                        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());
                                     }
                                 }
                             }
                         });
                     }
-                    if let Some(stderr) = child.stderr.take() {
-                        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));
-                            }
-                        });
-                    }
 
                     let state: State<NodeServices> = app.state();
                     if let Ok(mut lock) = state.0.lock() {
@@ -251,13 +758,13 @@ 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)
-                        }),
+                    debug_log(&format!("Failed to spawn node: {}", 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);
                 }
             }
 
@@ -265,12 +772,15 @@ fn main() {
         })
         .on_window_event(|window, event| {
             if let tauri::WindowEvent::Destroyed = event {
-                let state: State<NodeServices> = window.state();
-                if let Ok(mut lock) = state.0.lock() {
-                    if let Some(mut child) = lock.take() {
-                        let _ = child.kill();
-                    }
-                };
+                if window.label() == "main" {
+                    let state: State<NodeServices> = window.state();
+                    if let Ok(mut lock) = state.0.lock() {
+                        if let Some(mut child) = lock.take() {
+                            debug_log("[SHUTDOWN] Main window destroyed, terminating node process natively");
+                            kill_child_process(&mut child);
+                        }
+                    };
+                }
             }
         })
         .run(tauri::generate_context!())

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
-    "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/tooling/cli/schema.json",
+    "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.0.3",
+    "version": "1.1.45",
     "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,13 +22,20 @@
             "icons/icon.icns",
             "icons/icon.ico"
         ],
+        "macOS": {
+            "exceptionDomain": "localhost",
+            "infoPlist": "Info.plist"
+        },
         "windows": {
             "webviewInstallMode": {
                 "type": "downloadBootstrapper"
             }
         },
         "resources": [
+            "WebView2Loader.dll",
+            "../bin/**/*",
             "../main.js",
+            "../preload.js",
             "../service-manager.js",
             "../patcher.js",
             "../crypto-utils.js",

update-client.js

@@ -10,6 +10,8 @@ const ALLOWED_REDIRECT_HOSTS = [
   'storage.googleapis.com'
 ];
 
+const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 32 });
+
 function isAllowedHost(url) {
   try {
     const hostname = new URL(url).hostname;
@@ -46,7 +48,8 @@ class UpdateClient {
         port: 443,
         path: urlObj.pathname + urlObj.search,
         method: 'GET',
-        headers
+        headers,
+        agent: httpsAgent
       };
 
       const req = https.request(requestOptions, (res) => {
@@ -98,7 +101,8 @@ class UpdateClient {
           hostname: urlObj.hostname,
           port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
           path: urlObj.pathname + urlObj.search,
-          headers
+          headers,
+          agent: httpsAgent
         };
 
         const req = https.get(requestOptions, (res) => {
@@ -132,7 +136,14 @@ class UpdateClient {
           });
 
           file.on('finish', () => {
-            file.close(resolve);
+            file.close(() => {
+              if (totalSize && downloadedSize < totalSize) {
+                fs.unlink(destPath, () => { });
+                reject(new Error(`Download truncated: Received ${downloadedSize} of ${totalSize} bytes. Connection dropped prematurely.`));
+              } else {
+                resolve();
+              }
+            });
           });
 
           file.on('error', (err) => {
@@ -146,10 +157,10 @@ class UpdateClient {
           reject(err);
         });
 
-        req.setTimeout(120000, () => {
+        req.setTimeout(900000, () => {
           req.destroy();
           fs.unlink(destPath, () => { });
-          reject(new Error('Download timeout'));
+          reject(new Error('Download timeout (15 minutes reached)'));
         });
       };
 
@@ -180,7 +191,8 @@ class UpdateClient {
           hostname: urlObj.hostname,
           port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
           path: urlObj.pathname + urlObj.search,
-          headers
+          headers,
+          agent: httpsAgent
         };
 
         const req = https.get(requestOptions, (res) => {
@@ -223,7 +235,8 @@ class UpdateClient {
   }
 
   async checkForUpdates() {
-    const releases = await this.fetchJson(RELEASES_API);
+    const cacheBuster = `?cb=${Date.now()}`;
+    const releases = await this.fetchJson(RELEASES_API + cacheBuster);
     if (!releases || releases.length === 0) {
       return null;
     }