made this better

DOCUEMENTATION/CLEAR.md

@@ -1,13 +1,53 @@
-taskkill /F /IM node.exe -ErrorAction SilentlyContinue
+taskkill /F /IM "node.exe" 2>$null
-taskkill /F /IM vyla-home.exe -ErrorAction SilentlyContinue
+taskkill /F /IM "vyla-home.exe" 2>$null
+taskkill /F /IM "Vyla Home.exe" 2>$null
+taskkill /F /IM "msedgewebview2.exe" 2>$null
 
-Remove-Item -Recurse -Force "$env:APPDATA\com.vyla.home" -ErrorAction SilentlyContinue
+Stop-Process -Name "node", "vyla-home", "Vyla Home", "msedgewebview2" -Force -ErrorAction SilentlyContinue
-Remove-Item -Recurse -Force "$env:APPDATA\vyla-home" -ErrorAction SilentlyContinue
 
-Remove-Item -Force "$env:USERPROFILE\Downloads\vyla-*-debug*.log" -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",
+    "bin",
+    "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"
+)
 
-Remove-Item -Recurse -Force "src-tauri\target" -ErrorAction SilentlyContinue
+foreach ($path in $pathsToDelete) {
-Remove-Item -Recurse -Force "dist-build" -ErrorAction SilentlyContinue
+    if (Test-Path $path) {
-Remove-Item -Force "update-payload.zip" -ErrorAction SilentlyContinue
+        Remove-Item -Recurse -Force $path -ErrorAction SilentlyContinue
-Remove-Item -Force "manifest.json" -ErrorAction SilentlyContinue
+    }
-Remove-Item -Force "validation-report.json" -ErrorAction SilentlyContinue
+}

DOCUEMENTATION/FORDEV.md

@@ -0,0 +1,19 @@
+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
+```

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\

main.js

@@ -6,7 +6,11 @@ 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');
+const APPDATA_DIR = process.env.APPDATA_PATH || path.join(os.homedir(), 'AppData', 'Roaming', 'vyla-home', 'vyla-home-files');
+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) { }
 }
@@ -19,8 +23,6 @@ let expressServer;
 let playerExpressApp;
 let playerExpressServer;
 
-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'));
@@ -123,9 +125,40 @@ async function start() {
 
     if (release) {
       const hasUpdate = release.version !== localVersion || (release.sha256 && release.sha256 !== localSha);
-      if (isFirstRun || hasUpdate) {
+      if (isFirstRun) {
-        debugLog("Update required or first run. Installing remote build...");
+        debugLog("First run. Installing remote build...");
         await installBuild(release);
+      } else if (hasUpdate) {
+        debugLog("Update available. Prompting user...");
+        const tempApp = express();
+        let userDecision = null;
+        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 });
+        });
+        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');
+
+        sendToTauri('update-available', { current: localVersion, latest: release.version });
+
+        while (userDecision === null) {
+          await new Promise(r => setTimeout(r, 500));
+        }
+        tempServer.close();
+
+        if (userDecision) {
+          debugLog("User accepted update.");
+          await installBuild(release);
+        } else {
+          debugLog("User skipped update.");
+        }
       } else {
         debugLog("Already on the latest version.");
       }
@@ -161,6 +194,16 @@ async function start() {
 
     const playerDir = path.join(APPDATA_DIR, 'player');
     playerExpressApp = express();
+    playerExpressApp.use((req, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*');
+      res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+      if (req.method === 'OPTIONS') return res.sendStatus(200);
+      next();
+    });
+    playerExpressApp.get('/__tauri_cmd/:cmd', (req, res) => {
+      sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
+      res.sendStatus(200);
+    });
     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');
@@ -172,6 +215,16 @@ async function start() {
 
     const frontendDir = path.join(APPDATA_DIR, 'frontend');
     expressApp = express();
+    expressApp.use((req, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*');
+      res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+      if (req.method === 'OPTIONS') return res.sendStatus(200);
+      next();
+    });
+    expressApp.get('/__tauri_cmd/:cmd', (req, res) => {
+      sendToTauri('tauri-cmd', { cmd: req.params.cmd, url: req.query.url, window: req.query.window });
+      res.sendStatus(200);
+    });
     expressApp.use(express.static(frontendDir, { maxAge: '1d', etag: true }));
     expressApp.get('*', (req, res) => { res.sendFile(path.join(frontendDir, 'index.html')); });
 

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "vyla-home",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "vyla-home",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "dependencies": {
         "@tauri-apps/api": "^2.0.0",
         "@tauri-apps/plugin-process": "^2.0.0",

package.json

@@ -1,12 +1,12 @@
 {
   "name": "vyla-home",
-  "version": "1.0.0",
+  "version": "1.0.6",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
     "dev": "tauri dev",
     "build:payload": "node build-pipeline.js",
-    "build": "tauri build",
+    "build": "node -e \"require('child_process').execSync('tauri build', {stdio:'inherit', env:Object.assign({}, process.env, {WEBVIEW2_STATIC_LIB:'1'})})\"",
     "release": "node release.js",
     "release:full": "node release.js --installer"
   },

release.js

@@ -12,9 +12,32 @@ if (!TOKEN) {
     process.exit(1);
 }
 
-function getPackageVersion() {
+function incrementVersion() {
-    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+    const pkgPath = path.join(__dirname, 'package.json');
-    return pkg.version || '1.0.0';
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+    let [major, minor, patch] = (pkg.version || '1.0.0').split('.').map(Number);
+    patch = (patch || 0) + 1;
+    const newVersion = `${major}.${minor}.${patch}`;
+
+    pkg.version = newVersion;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+
+    const tauriPath = path.join(__dirname, 'src-tauri', 'tauri.conf.json');
+    if (fs.existsSync(tauriPath)) {
+        const tauriConf = JSON.parse(fs.readFileSync(tauriPath, 'utf8'));
+        tauriConf.version = newVersion;
+        fs.writeFileSync(tauriPath, JSON.stringify(tauriConf, null, 4) + '\n', 'utf8');
+    }
+
+    const cargoPath = path.join(__dirname, 'src-tauri', 'Cargo.toml');
+    if (fs.existsSync(cargoPath)) {
+        let cargo = fs.readFileSync(cargoPath, 'utf8');
+        cargo = cargo.replace(/^version\s*=\s*".*"/m, `version = "${newVersion}"`);
+        fs.writeFileSync(cargoPath, cargo, 'utf8');
+    }
+
+    return newVersion;
 }
 
 function uploadFileToGitLabPackage(filePath, packageName, version, fileName) {
@@ -55,55 +78,64 @@ function uploadFileToGitLabPackage(filePath, packageName, version, fileName) {
 }
 
 function createGitLabRelease(tag, releaseLinks) {
-    return new Promise((resolve, reject) => {
+    const sendRequest = (method, path) => {
-        let currentRef = 'main';
+        return new Promise((resolve, reject) => {
-        try {
+            let currentRef = 'main';
-            currentRef = execSync('git rev-parse HEAD').toString().trim();
+            try {
-        } catch (e) { }
+                currentRef = execSync('git rev-parse HEAD').toString().trim();
+            } catch (e) { }
 
-        const postData = JSON.stringify({
+            const postData = JSON.stringify({
-            name: `Vyla Home Release ${tag}`,
+                name: `Vyla Home Release ${tag}`,
-            tag_name: tag,
+                tag_name: tag,
-            ref: currentRef,
+                ref: currentRef,
-            description: `Automated local release ${tag}`,
+                description: `Automated local release ${tag}`,
-            assets: {
+                assets: {
-                links: releaseLinks
+                    links: releaseLinks
-            }
-        });
-
-        const req = https.request({
-            hostname: 'gitlab.com',
-            port: 443,
-            path: `/api/v4/projects/${PROJECT_ID}/releases`,
-            method: 'POST',
-            headers: {
-                'PRIVATE-TOKEN': TOKEN,
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(postData)
-            }
-        }, (res) => {
-            let body = '';
-            res.on('data', chunk => body += chunk);
-            res.on('end', () => {
-                if (res.statusCode === 201 || res.statusCode === 200) {
-                    resolve(JSON.parse(body));
-                } else {
-                    reject(new Error(`Failed to create release (HTTP ${res.statusCode}): ${body}`));
                 }
             });
-        });
 
-        req.on('error', reject);
+            const req = https.request({
-        req.write(postData);
+                hostname: 'gitlab.com',
-        req.end();
+                port: 443,
-    });
+                path: path,
+                method: method,
+                headers: {
+                    'PRIVATE-TOKEN': TOKEN,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(postData)
+                }
+            }, (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);
+                    } else {
+                        reject(new Error(`Failed to publish release (HTTP ${res.statusCode}): ${body}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.write(postData);
+            req.end();
+        });
+    };
+
+    return sendRequest('POST', `/api/v4/projects/${PROJECT_ID}/releases`);
 }
 
 async function main() {
     const isFullBuild = process.argv.includes('--installer');
     const customTag = process.argv.find(arg => arg.startsWith('--tag='))?.split('=')[1];
 
-    const version = customTag || `v${getPackageVersion()}`;
+    const version = customTag || `v${incrementVersion()}`;
 
     console.log(`=== Building Vyla Home Release (${version}) ===`);
 
@@ -121,8 +153,14 @@ async function main() {
     let installerUploadName = null;
 
     if (isFullBuild) {
+        console.log('[Optional] Ensuring bundled Node.js runtime...');
+        await ensureBundledNode();
+
         console.log('[Optional] Compiling Windows Tauri installer locally...');
-        execSync('npm run build', { stdio: 'inherit' });
+        execSync('npm run build', {
+            stdio: 'inherit',
+            env: Object.assign({}, process.env, { WEBVIEW2_STATIC_LIB: '1' })
+        });
 
         const nsisDir = path.join(__dirname, 'src-tauri/target/release/bundle/nsis');
         if (fs.existsSync(nsisDir)) {
@@ -158,6 +196,48 @@ async function main() {
     console.log(`[4/4] Release successfully created: ${release.name} (${release.tag_name})`);
 }
 
+function ensureBundledNode() {
+    const binDir = path.join(__dirname, 'bin');
+    const nodeExePath = path.join(binDir, 'node.exe');
+
+    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...`);
+
+    const nodeUrl = `https://nodejs.org/dist/${nodeVersion}/win-x64/node.exe`;
+    return new Promise((resolve, reject) => {
+        const fileStream = fs.createWriteStream(nodeExePath);
+        https.get(nodeUrl, (res) => {
+            if (res.statusCode === 302 || res.statusCode === 301) {
+                https.get(res.headers.location, (redirectRes) => {
+                    redirectRes.pipe(fileStream);
+                    fileStream.on('finish', () => {
+                        fileStream.close();
+                        fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
+                        resolve();
+                    });
+                }).on('error', reject);
+                return;
+            }
+            res.pipe(fileStream);
+            fileStream.on('finish', () => {
+                fileStream.close();
+                fs.writeFileSync(versionMarker, nodeVersion, 'utf8');
+                resolve();
+            });
+        }).on('error', (err) => {
+            try { fs.unlinkSync(nodeExePath); } catch (e) { }
+            reject(err);
+        });
+    });
+}
+
 main().catch(err => {
     console.error('Release failed:', err.message);
     process.exit(1);

service-manager.js

@@ -59,11 +59,13 @@ class ServiceManager {
 
     this.logToFile(name, `--- Starting ${name} in ${serviceDir} ---`);
 
-    const child = spawn('node', [scriptPath], {
+    const nodeExecutable = process.env.NODE_EXE || 'node';
+
+    const child = spawn(nodeExecutable, [scriptPath], {
       cwd: serviceDir,
       env,
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: process.platform === 'win32'
+      shell: false
     });
 
     this.processes[name] = {

src-tauri/Cargo.lock

@@ -4222,7 +4222,7 @@ dependencies = [
 
 [[package]]
 name = "vyla-home"
-version = "1.0.0"
+version = "1.0.6"
 dependencies = [
  "serde",
  "serde_json",
@@ -4231,6 +4231,7 @@ dependencies = [
  "tauri-plugin-opener",
  "tauri-plugin-process",
  "tauri-plugin-shell",
+ "url",
 ]
 
 [[package]]

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.0.0"
+version = "1.0.6"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -9,8 +9,9 @@ tauri-build = { version = "2", features = [] }
 
 [dependencies]
 tauri = { version = "2", features = [] }
-tauri-plugin-shell = "2"
-tauri-plugin-process = "2"
 tauri-plugin-opener = "2"
-serde = { version = "1.0", features = ["derive"] }
+tauri-plugin-process = "2"
-serde_json = "1.0"
+tauri-plugin-shell = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+url = "2"

src-tauri/src/main.rs

@@ -6,12 +6,20 @@ 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_dir = if let Ok(app_data) = std::env::var("APPDATA") {
-        let log_path = std::path::Path::new(&user_profile).join("Downloads").join("vyla-rust-debug.log");
+        std::path::PathBuf::from(app_data).join("vyla-home").join("vyla-home-files").join("logs")
-        if let Ok(mut file) = std::fs::OpenOptions::new().create(true).append(true).open(&log_path) {
+    } else if let Ok(user_profile) = std::env::var("USERPROFILE") {
-            use std::io::Write;
+        std::path::PathBuf::from(user_profile).join(".vyla-home").join("logs")
-            let _ = writeln!(file, "[RUST] {}", msg);
+    } else {
-        }
+        std::path::PathBuf::from("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);
     }
 }
 
@@ -23,7 +31,6 @@ struct BackendMessage {
     data: serde_json::Value,
 }
 
-// Helper to remove the \\?\ prefix that Node.js chokes on
 fn clean_path(path: &std::path::Path) -> String {
     let s = path.to_string_lossy().to_string();
     if s.starts_with("\\\\?\\") {
@@ -33,10 +40,75 @@ fn clean_path(path: &std::path::Path) -> String {
     }
 }
 
+fn find_node_binary(app: &tauri::App) -> Option<String> {
+    if let Ok(resource_dir) = app.path().resource_dir() {
+        let candidates = [
+            resource_dir.join("bin").join("node.exe"),
+            resource_dir.join("node.exe"),
+            resource_dir.join("_up_").join("bin").join("node.exe"),
+            resource_dir.join("_up_").join("node.exe"),
+        ];
+        for candidate in candidates {
+            if candidate.exists() {
+                return Some(clean_path(&candidate));
+            }
+        }
+    }
+
+    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("node.exe"),
+                parent.join("resources").join("bin").join("node.exe"),
+                parent.join("resources").join("node.exe"),
+            ];
+            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));
+            }
+        }
+    }
+
+    #[cfg(windows)]
+    {
+        let default_paths = [
+            r"C:\Program Files\nodejs\node.exe",
+            r"C:\Program Files (x86)\nodejs\node.exe",
+        ];
+        for path in default_paths {
+            let candidate = std::path::Path::new(path);
+            if candidate.exists() {
+                return Some(clean_path(candidate));
+            }
+        }
+
+        if let Ok(local_app_data) = std::env::var("LOCALAPPDATA") {
+            let candidate = std::path::PathBuf::from(local_app_data)
+                .join("Programs")
+                .join("nodejs")
+                .join("node.exe");
+            if candidate.exists() {
+                return Some(clean_path(&candidate));
+            }
+        }
+    }
+
+    None
+}
+
 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"),
@@ -44,7 +116,6 @@ fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
 
         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));
             }
@@ -56,20 +127,42 @@ 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) {
+    function doInvoke(cmd, args) {
-        if (!url) return null;
+        let baseUrl = window.location.protocol.startsWith('http') ? window.location.origin : 'http://127.0.0.1:4890';
-        if (url.startsWith('http://localhost') || url.startsWith('/') || url.startsWith(window.location.origin)) {
+        let label = window.__VYLA_WINDOW_LABEL || 'main';
-            window.location.href = url;
+        let url = `${baseUrl}/__tauri_cmd/${cmd}?window=${label}`;
-        } else if (window.__TAURI__ && window.__TAURI__.opener) {
+        if (args && args.url) {
-            window.__TAURI__.opener.openUrl(url);
+            url += `&url=${encodeURIComponent(args.url)}`;
-        } else if (window.__TAURI_INTERNALS__) {
-            window.__TAURI_INTERNALS__.invoke('plugin:opener|open_url', { rule: { url: url } });
         }
+        fetch(url).catch(err => {
+            const inv = window.__TAURI_INTERNALS__?.invoke || window.__TAURI__?.core?.invoke || window.__TAURI__?.invoke;
+            if (inv) inv(cmd, args || {}).catch(e => console.error(e));
+        });
+    }
+
+    function minimizeWindow() {
+        doInvoke('win_minimize');
+    }
+
+    function maximizeWindow() {
+        doInvoke('win_maximize');
+    }
+
+    function closeWindow() {
+        doInvoke('win_close');
+    }
+
+    function dragWindow() {
+        doInvoke('win_drag');
+    }
+
+    window.open = function(url, target, features) {
+        if (!url) return null;
+        doInvoke('open_new_window', { url: url });
         return null;
     };
 
@@ -77,21 +170,197 @@ 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' || e.ctrlKey || e.metaKey || e.button === 1) {
-
-        if (a.target === '_blank') {
             e.preventDefault();
-            if (isLocal) {
+            e.stopPropagation();
-                window.location.href = a.href;
+            doInvoke('open_new_window', { url: 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 } });
-            }
         }
     }, true);
+
+    function injectTitlebar() {
+        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; display: flex !important; justify-content: space-between !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 {
+                flex: 1 !important; height: 100% !important; cursor: default !important; pointer-events: auto !important;
+            }
+            .tauri-window-controls {
+                display: flex !important; pointer-events: auto !important; height: 32px !important; margin: 0 !important; padding: 0 !important;
+                position: relative !important; z-index: 2147483648 !important;
+            }
+            button.tauri-btn {
+                width: 46px !important; max-width: 46px !important; min-width: 46px !important;
+                height: 32px !important; max-height: 32px !important; min-height: 32px !important;
+                background: transparent !important; border: none !important;
+                color: #fff !important; display: flex !important; align-items: center !important; 
+                justify-content: center !important; cursor: pointer !important; 
+                outline: none !important; padding: 0 !important; margin: 0 !important;
+                border-radius: 0 !important; box-shadow: none !important;
+                appearance: none !important; opacity: 1 !important; transform: none !important;
+                position: relative !important; z-index: 2147483649 !important;
+            }
+            button.tauri-btn:hover { background: rgba(255, 255, 255, 0.15) !important; }
+            button#tauri-btn-close:hover { background: #E81123 !important; color: white !important; }
+            button.tauri-btn svg { width: 10px !important; height: 10px !important; fill: currentColor !important; display: block !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" data-action="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" data-action="maximize"><svg viewBox="0 0 10 10"><path d="M1,1v8h8V1H1z M8,8H2V2h6V8z"/></svg></button>
+                <button class="tauri-btn" id="tauri-btn-close" data-action="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);
+
+        document.addEventListener('click', (e) => {
+            const btn = e.target.closest('.tauri-btn');
+            if (!btn) return;
+            
+            const action = btn.getAttribute('data-action');
+            
+            e.preventDefault();
+            e.stopPropagation();
+            e.stopImmediatePropagation();
+            
+            if (action === 'minimize') {
+                minimizeWindow();
+            } else if (action === 'maximize') {
+                maximizeWindow();
+            } else if (action === 'close') {
+                closeWindow();
+            }
+        }, true);
+
+        const dragRegion = tb.querySelector('.tauri-drag-region');
+        if (dragRegion) {
+            dragRegion.addEventListener('mousedown', (e) => {
+                if (e.buttons === 1) { 
+                    e.preventDefault(); 
+                    e.stopPropagation(); 
+                    dragWindow();
+                }
+            });
+        }
+    }
+
+    injectTitlebar();
+    
+    setInterval(injectTitlebar, 1000);
+    
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', injectTitlebar);
+    } else {
+        injectTitlebar();
+    }
+    
+    window.addEventListener('load', injectTitlebar);
 "#;
 
+#[tauri::command]
+fn win_minimize(window: tauri::Window) -> Result<(), String> {
+    debug_log("win_minimize command called");
+    window.minimize().map_err(|e| {
+        debug_log(&format!("win_minimize error: {}", e));
+        e.to_string()
+    })
+}
+
+#[tauri::command]
+fn win_maximize(window: tauri::Window) -> Result<(), String> {
+    debug_log("win_maximize command called");
+    if let Ok(is_max) = window.is_maximized() {
+        if is_max {
+            debug_log("Window is maximized, unmaximizing");
+            window.unmaximize().map_err(|e| {
+                debug_log(&format!("win_unmaximize error: {}", e));
+                e.to_string()
+            })
+        } else {
+            debug_log("Window is not maximized, maximizing");
+            window.maximize().map_err(|e| {
+                debug_log(&format!("win_maximize error: {}", e));
+                e.to_string()
+            })
+        }
+    } else {
+        debug_log("Could not determine maximized state");
+        Ok(())
+    }
+}
+
+#[tauri::command]
+fn win_close(window: tauri::Window) -> Result<(), String> {
+    debug_log("win_close command called");
+    window.close().map_err(|e| {
+        debug_log(&format!("win_close error: {}", e));
+        e.to_string()
+    })
+}
+
+#[tauri::command]
+fn win_drag(window: tauri::Window) -> Result<(), String> {
+    debug_log("win_drag command called");
+    window.start_dragging().map_err(|e| {
+        debug_log(&format!("win_drag error: {}", e));
+        e.to_string()
+    })
+}
+
+#[tauri::command]
+fn open_new_window(app: tauri::AppHandle, url: String) -> Result<(), String> {
+    debug_log(&format!("Requested to open new window for: {}", url));
+    
+    let label = format!("win_{}", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis());
+    
+    let final_url = if url.starts_with("http") || url.starts_with("tauri://") {
+        url.clone()
+    } else if url.starts_with('/') {
+        format!("http://localhost:4890{}", url)
+    } else {
+        format!("http://localhost:4890/{}", url)
+    };
+
+    let parsed_url = url::Url::parse(&final_url)
+        .unwrap_or_else(|_| url::Url::parse("http://localhost:4890").unwrap());
+
+ match tauri::WebviewWindowBuilder::new(&app, label.clone(), tauri::WebviewUrl::External(parsed_url))
+        .title("Vyla Home")
+        .inner_size(1280.0, 800.0)
+        .decorations(false)
+        .transparent(true)
+        .initialization_script(&format!("window.__VYLA_WINDOW_LABEL = '{}';", label))
+        .initialization_script(LINK_HANDLER_SCRIPT)
+        .build()
+    {
+        Ok(_) => {
+            debug_log("Successfully spawned new window");
+            Ok(())
+        },
+        Err(e) => {
+            debug_log(&format!("ERROR: Failed to create new window: {}", e));
+            Err(e.to_string())
+        }
+    }
+}
+
 fn main() {
     debug_log("=== Vyla Home Executable Started ===");
 
@@ -99,31 +368,48 @@ 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
+        ])
         .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 window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
+    let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
                 .title("Vyla Home")
                 .inner_size(1280.0, 800.0)
-                .decorations(true)
+                .decorations(false)
+                .transparent(true)
                 .resizable(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);
+            let node_bin = match find_node_binary(app) {
+                Some(bin) => bin,
+                None => {
+                    let _ = window.emit(
+                        "error",
+                        serde_json::json!({
+                            "message": "Node.js runtime not found. Please ensure Node.js is installed or bundled correctly."
+                        }),
+                    );
+                    return Ok(());
+                }
+            };
 
-            debug_log(&format!("Spawning node with script: {}", main_js));
+            let mut cmd = Command::new(&node_bin);
-
-            let mut cmd = Command::new("node");
             cmd.arg(&main_js)
                 .current_dir(&root_dir)
                 .env("APPDATA_PATH", &app_data_str)
+                .env("NODE_EXE", &node_bin)
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
 
@@ -136,34 +422,46 @@ fn main() {
 
             match cmd.spawn() {
                 Ok(mut child) => {
-                    debug_log("Node spawned successfully");
                     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() {
+ 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 == "tauri-cmd" {
-                                    if msg.event == "ready" {
+                                        let window_label = msg.data.get("window").and_then(|w| w.as_str()).unwrap_or("main");
-                                        if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
+                                        if let Some(cmd_window) = w.app_handle().get_webview_window(window_label) {
-                                            let _ = w.eval(&format!("window.location.href = '{}';", url));
+                                            if let Some(cmd) = msg.data.get("cmd").and_then(|c| c.as_str()) {
+                                                match cmd {
+                                                    "win_minimize" => { let _ = cmd_window.minimize(); },
+                                                    "win_maximize" => {
+                                                        if let Ok(true) = cmd_window.is_maximized() { let _ = cmd_window.unmaximize(); }
+                                                        else { let _ = cmd_window.maximize(); }
+                                                    },
+                                                    "win_close" => { let _ = cmd_window.close(); },
+                                                    "win_drag" => { let _ = cmd_window.start_dragging(); },
+                                                    "open_new_window" => {
+                                                        if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
+                                                            let _ = open_new_window(w.app_handle().clone(), url.to_string());
+                                                        }
+                                                    },
+                                                    _ => {}
+                                                }
+                                            }
+                                        }
+                                    } else {
+                                        let _ = w.emit(&msg.event, msg.data.clone());
+                                        if msg.event == "ready" {
+                                            if let Some(url) = msg.data.get("url").and_then(|u| u.as_str()) {
+                                                let _ = w.eval(&format!("window.location.href = '{}';", url));
+                                            }
                                         }
                                     }
                                 }
                             }
                         });
                     }
-                    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() {
@@ -171,7 +469,7 @@ 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) }));
                 }
             }
 
@@ -179,12 +477,14 @@ fn main() {
         })
         .on_window_event(|window, event| {
             if let tauri::WindowEvent::Destroyed = event {
-                let state: State<NodeServices> = window.state();
+                if window.label() == "main" {
-                if let Ok(mut lock) = state.0.lock() {
+                    let state: State<NodeServices> = window.state();
-                    if let Some(mut child) = lock.take() {
+                    if let Ok(mut lock) = state.0.lock() {
-                        let _ = child.kill();
+                        if let Some(mut child) = lock.take() {
-                    }
+                            let _ = child.kill();
-                };
+                        }
+                    };
+                }
             }
         })
         .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",
     "productName": "Vyla Home",
-    "version": "1.0.0",
+    "version": "1.0.6",
     "identifier": "com.vyla.home",
     "build": {
         "frontendDist": "../ui"
@@ -22,7 +22,13 @@
             "icons/icon.icns",
             "icons/icon.ico"
         ],
+        "windows": {
+            "webviewInstallMode": {
+                "type": "downloadBootstrapper"
+            }
+        },
         "resources": [
+            "../bin/**/*",
             "../main.js",
             "../service-manager.js",
             "../patcher.js",

ui/index.html

@@ -633,6 +633,21 @@
         </div>
     </div>
 
+    <div id="view-update" class="view-state">
+        <div class="container">
+            <svg class="icon icon-loader" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
+                style="color:#0a84ff; animation:none; transform:none;">
+                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M7 10l5 5 5-5M12 15V3" />
+            </svg>
+            <h1>Update Available</h1>
+            <p id="update-msg">A new version is available.</p>
+            <div class="buttons">
+                <button class="secondary" onclick="skipUpdate()">Skip</button>
+                <button class="primary" onclick="installUpdate()">Install Update</button>
+            </div>
+        </div>
+    </div>
+
     <div id="view-error" class="view-state">
         <div class="container">
             <svg class="icon icon-error" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -653,6 +668,7 @@
     <script>
         const viewLoader = document.getElementById('view-loader');
         const viewError = document.getElementById('view-error');
+        const viewUpdate = document.getElementById('view-update');
 
         const statusMsg = document.getElementById('status-msg');
         const errorMsg = document.getElementById('error-msg');
@@ -665,14 +681,27 @@
             viewElement.classList.add('active');
         }
 
-        if (window.__TAURI__ && window.__TAURI__.event) {
+        function setupTauriListeners() {
-            window.__TAURI__.event.listen('status', (e) => {
+            const eventApi = window.__TAURI__?.event || window.__TAURI_INTERNALS__;
+            if (!eventApi || typeof eventApi.listen !== 'function') {
+                setTimeout(setupTauriListeners, 200);
+                return;
+            }
+
+            eventApi.listen('update-available', (e) => {
+                if (e.payload) {
+                    document.getElementById('update-msg').textContent = `Version ${e.payload.latest} is available (Current: ${e.payload.current}).`;
+                    showView(viewUpdate);
+                }
+            });
+
+            eventApi.listen('status', (e) => {
                 if (e.payload && e.payload.message) {
                     statusMsg.textContent = e.payload.message;
                 }
             });
 
-            window.__TAURI__.event.listen('download-progress', (e) => {
+            eventApi.listen('download-progress', (e) => {
                 if (e.payload) {
                     statusMsg.textContent = `Downloading update: ${e.payload.percent}%`;
                     progressWrap.style.display = 'block';
@@ -680,19 +709,47 @@
                 }
             });
 
-            window.__TAURI__.event.listen('error', (e) => {
+            eventApi.listen('error', (e) => {
                 if (e.payload && e.payload.message) {
                     errorMsg.textContent = e.payload.message;
                     showView(viewError);
                 }
             });
 
-            window.__TAURI__.event.listen('ready', (e) => {
+            eventApi.listen('ready', (e) => {
                 if (e.payload && e.payload.url) {
                     window.location.href = e.payload.url;
                 }
             });
         }
+        setupTauriListeners();
+
+        function checkUpdateApi() {
+            fetch('http://127.0.0.1:4891/update/info')
+                .then(r => r.json())
+                .then(data => {
+                    if (data && data.available) {
+                        document.getElementById('update-msg').textContent = `Version ${data.latest} is available (Current: ${data.current}).`;
+                        showView(viewUpdate);
+                    }
+                })
+                .catch(() => { });
+        }
+        const updateInterval = setInterval(checkUpdateApi, 500);
+
+        function installUpdate() {
+            clearInterval(updateInterval);
+            fetch('http://127.0.0.1:4891/update/yes', { method: 'POST' }).catch(() => { });
+            statusMsg.textContent = 'Starting update...';
+            showView(viewLoader);
+        }
+
+        function skipUpdate() {
+            clearInterval(updateInterval);
+            fetch('http://127.0.0.1:4891/update/no', { method: 'POST' }).catch(() => { });
+            statusMsg.textContent = 'Continuing to app...';
+            showView(viewLoader);
+        }
 
         function pollBackend() {
             fetch('http://localhost:4890')