potentially fixed mac support

.gitignore

@@ -36,4 +36,6 @@ yarn-error.log*
 *.temp
 download-temp.zip
 
-.env
+.env
+
+release-assets/

DOCUEMENTATION/FORDEV.md

@@ -22,4 +22,16 @@ Fixing os error 32
 
 ```powershell
 Stop-Process -Name "vyla-home", "node", "cargo" -Force -ErrorAction SilentlyContinue
-```
+```
+
+Fake an old local version:
+
+```powershell
+'{"version":"0.0.1","sha256":null}' | Set-Content "$env:APPDATA\vyla-home\vyla-home-files\version.json"
+```
+
+Fake a test?
+
+```powershell
+$env:VYLA_TEST_UI="1"; npm run dev
+```

build-pipeline.js

@@ -73,6 +73,8 @@ function cleanBuildDir() {
   fs.mkdirSync(BUILD_DIR, { recursive: true });
 }
 
+let credentialsId = null;
+
 function encryptCredentialsFile() {
   const CryptoUtils = require('./crypto-utils');
 
@@ -109,6 +111,7 @@ function encryptCredentialsFile() {
       }
     }
 
+    credentialsId = crypto.createHash('sha256').update(JSON.stringify(credentials)).digest('hex');
     const buildKey = CryptoUtils.deriveKey('vyla-home-build-key', 'vyla-home-payload-salt-v1');
     const encryptedData = CryptoUtils.encryptObject(credentials, buildKey);
 
@@ -174,7 +177,7 @@ function validatePayload(zipPath) {
   const requiredFiles = [
     'frontend/index.html'
   ];
-  
+
   const validationResults = {
     valid: true,
     errors: [],
@@ -229,6 +232,32 @@ function validatePayload(zipPath) {
   return validationResults.checksum;
 }
 
+function directoryId(dir) {
+  const hash = crypto.createHash('sha256');
+  const walk = (current, rel) => {
+    for (const name of fs.readdirSync(current).sort()) {
+      const full = path.join(current, name);
+      const relPath = rel ? `${rel}/${name}` : name;
+      if (fs.statSync(full).isDirectory()) {
+        walk(full, relPath);
+      } else {
+        hash.update(`${relPath}\0${getFileChecksum(full)}\n`);
+      }
+    }
+  };
+  walk(dir, '');
+  return hash.digest('hex');
+}
+
+function signManifest(manifest) {
+  const key = process.env.VYLA_UPDATE_SIGNING_KEY;
+  if (!key) {
+    throw new Error('VYLA_UPDATE_SIGNING_KEY is required to sign the update manifest.');
+  }
+  const UpdateClient = require('./update-client');
+  return crypto.sign(null, Buffer.from(UpdateClient.canonicalManifest(manifest)), key.replace(/\\n/g, '\n')).toString('base64');
+}
+
 async function build() {
   try {
     cloneAllRepos();
@@ -319,13 +348,41 @@ async function build() {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
     wrapperVersion = pkg.version || '2.0.0';
   } catch (e) { }
+  const releaseVersion = (process.env.RELEASE_VERSION || wrapperVersion).replace(/^v/, '');
+
+  const assetsDir = path.join(__dirname, 'release-assets');
+  fs.rmSync(assetsDir, { recursive: true, force: true });
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  const components = {};
+  const addComponent = (name, fill, id) => {
+    const file = `${name}.zip`;
+    const target = path.join(assetsDir, file);
+    const componentZip = new AdmZip();
+    fill(componentZip);
+    componentZip.writeZip(target);
+    components[name] = { file, sha256: getFileChecksum(target), id, size: fs.statSync(target).size };
+  };
+
+  for (const repo of REPOS) {
+    const destRepo = path.join(BUILD_DIR, repo);
+    addComponent(repo, (z) => z.addLocalFolder(destRepo, repo), directoryId(destRepo));
+  }
+  addComponent('config', (z) => z.addLocalFolder(configDir, 'config'), directoryId(configDir));
+
+  const bundledCredentials = path.join(BUILD_DIR, 'encrypted-credentials.json');
+  if (fs.existsSync(bundledCredentials) && credentialsId) {
+    addComponent('secrets', (z) => z.addFile('encrypted-credentials.json', fs.readFileSync(bundledCredentials)), credentialsId);
+  }
 
   const manifest = {
-    version: wrapperVersion,
+    version: releaseVersion,
     sha256: checksum,
     timestamp: new Date().toISOString(),
-    hasEncryptedCredentials: !!encryptedCredentialsPath
+    hasEncryptedCredentials: !!encryptedCredentialsPath,
+    components
   };
+  manifest.signature = signManifest(manifest);
 
   fs.writeFileSync(path.join(__dirname, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
 

crypto-utils.js

@@ -1,31 +1,30 @@
 const crypto = require('crypto');
 const os = require('os');
-const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
 
 class CryptoUtils {
   static getMachineKey(cacheDir) {
-    const path = require('path');
-    const fs = require('fs');
     const cachePath = cacheDir ? path.join(cacheDir, '.machine-key-cache') : null;
 
     if (cachePath && fs.existsSync(cachePath)) {
       try {
         const cached = fs.readFileSync(cachePath, 'utf8').trim();
-        if (cached) return cached;
+        if (cached && cached.length === 64) return cached;
       } catch (e) {
       }
     }
 
     let key;
     try {
+      const isMac = os.platform() === 'darwin';
       const machineId = [
-        os.hostname(),
+        isMac ? '' : os.hostname(),
         os.platform(),
         os.arch(),
-        os.cpus()[0].model,
-        this.getMachineId(),
+        os.cpus()[0] ? os.cpus()[0].model : '',
         process.env.COMPUTERNAME || '',
-        process.env.USERNAME || ''
+        process.env.USERNAME || (isMac ? os.userInfo().username : '')
       ].join('|');
 
       const hash = crypto.createHash('sha256');
@@ -46,36 +45,6 @@ class CryptoUtils {
     return key;
   }
 
-  static getMachineId() {
-    const fs = require('fs');
-    if (os.platform() === 'win32') {
-      try {
-        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 {
-        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 {
-      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();
-    }
-  }
-
   static deriveKey(machineKey, salt = 'vyla-home-salt') {
     const hash = crypto.createHash('sha256');
     hash.update(machineKey + salt);
@@ -98,11 +67,11 @@ class CryptoUtils {
     }
   }
 
-  static decrypt(encryptedData, key) {
+  static decrypt(ciphertext, key) {
     try {
-      const parts = encryptedData.split(':');
+      const parts = ciphertext.split(':');
       if (parts.length !== 3) {
-        throw new Error('Invalid encrypted data format');
+        throw new Error('Invalid ciphertext format');
       }
 
       const iv = Buffer.from(parts[0], 'hex');
@@ -122,25 +91,14 @@ class CryptoUtils {
   }
 
   static encryptObject(obj, key) {
-    const json = JSON.stringify(obj);
-    return this.encrypt(json, key);
+    const jsonString = JSON.stringify(obj);
+    return this.encrypt(jsonString, key);
   }
 
-  static decryptObject(encryptedData, key) {
-    const json = this.decrypt(encryptedData, key);
-    return JSON.parse(json);
-  }
-
-  static hashData(data) {
-    const hash = crypto.createHash('sha256');
-    hash.update(data);
-    return hash.digest('hex');
-  }
-
-  static verifyHash(data, expectedHash) {
-    const actualHash = this.hashData(data);
-    return actualHash === expectedHash;
+  static decryptObject(ciphertext, key) {
+    const jsonString = this.decrypt(ciphertext, key);
+    return JSON.parse(jsonString);
   }
 }
 
-module.exports = CryptoUtils;
+module.exports = CryptoUtils;

file-updater.js

@@ -0,0 +1,612 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const zlib = require('zlib');
+const https = require('https');
+const AdmZip = require('adm-zip');
+
+const SDK_NAME = '@vyla-entertainment/sdk';
+const SDK_LATEST_URL = 'https://registry.npmjs.org/@vyla-entertainment%2Fsdk/latest';
+const ALLOWED_ROOTS = ['frontend', 'player'];
+const MAX_TARBALL = 100 * 1024 * 1024;
+const MAX_FILE = 50 * 1024 * 1024;
+const LIVE_HOSTS = ['gitlab.com'];
+const REPO_API = 'https://gitlab.com/api/v4/projects/vyla-entertainment%2F';
+
+const verParts = (v) => String(v || '').replace(/^v/, '').split(/[.\-+]/).map((n) => parseInt(n, 10) || 0);
+const cmpVer = (a, b) => {
+    const x = verParts(a);
+    const y = verParts(b);
+    for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        if ((x[i] || 0) !== (y[i] || 0)) return (x[i] || 0) - (y[i] || 0);
+    }
+    return 0;
+};
+
+const sha256Buf = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
+const sha256File = (p) => sha256Buf(fs.readFileSync(p));
+const gitBlobSha = (buf) => crypto.createHash('sha1').update(Buffer.concat([Buffer.from(`blob ${buf.length}\0`), buf])).digest('hex');
+
+const hooks = { notice: null };
+
+function fetchBuffer(url, { headers = {}, maxBytes, hosts, redirects = 0, retries = 0 }) {
+    return new Promise((resolve, reject) => {
+        if (redirects > 5) return reject(new Error('Too many redirects'));
+        let u;
+        try { u = new URL(url); } catch (e) { return reject(new Error('Invalid URL')); }
+        if (u.protocol !== 'https:' || !hosts.includes(u.hostname)) {
+            return reject(new Error(`Host not allowed: ${u.hostname}`));
+        }
+        const req = https.get({
+            hostname: u.hostname,
+            port: 443,
+            path: u.pathname + u.search,
+            headers: { 'User-Agent': 'VylaHome-Client', ...headers }
+        }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                const next = new URL(res.headers.location, url).toString();
+                const keep = new URL(next).hostname === u.hostname ? headers : {};
+                fetchBuffer(next, { headers: keep, maxBytes, hosts, redirects: redirects + 1 }).then(resolve, reject);
+                return;
+            }
+            if (res.statusCode === 429 && retries < 4) {
+                res.resume();
+                const wait = Math.min(parseInt(res.headers['retry-after'], 10) || 5, 30) * 1000;
+                if (hooks.notice) hooks.notice(`GitLab rate limit (HTTP 429). Retrying in ${Math.round(wait / 1000)}s (${retries + 1}/4)...`);
+                setTimeout(() => {
+                    fetchBuffer(url, { headers, maxBytes, hosts, redirects, retries: retries + 1 }).then(resolve, reject);
+                }, wait);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                reject(new Error(`HTTP ${res.statusCode}`));
+                return;
+            }
+            const chunks = [];
+            let size = 0;
+            res.on('data', (c) => {
+                size += c.length;
+                if (size > maxBytes) {
+                    req.destroy();
+                    reject(new Error('Response too large'));
+                    return;
+                }
+                chunks.push(c);
+            });
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(30000, () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+
+function safeRel(rel) {
+    if (typeof rel !== 'string' || !rel || rel.includes('\0') || rel.includes('\\')) return null;
+    const norm = path.posix.normalize(rel);
+    if (norm !== rel || norm.startsWith('/') || norm.endsWith('/')) return null;
+    const parts = norm.split('/');
+    if (parts.length < 2 || !ALLOWED_ROOTS.includes(parts[0])) return null;
+    if (parts.some((p) => p === '..' || p === '.' || p === 'node_modules' || p === '.git')) return null;
+    return norm;
+}
+
+function extractTar(tar, destDir) {
+    const root = path.resolve(destDir);
+    let offset = 0;
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every((b) => b === 0)) break;
+        let name = header.toString('utf8', 0, 100).replace(/\0.*$/, '');
+        const prefix = header.toString('utf8', 345, 500).replace(/\0.*$/, '');
+        if (prefix) name = `${prefix}/${name}`;
+        const size = parseInt(header.toString('utf8', 124, 136).replace(/\0.*$/, '').trim(), 8) || 0;
+        const type = String.fromCharCode(header[156]);
+        offset += 512;
+        const data = tar.subarray(offset, offset + size);
+        offset += Math.ceil(size / 512) * 512;
+        if ((type !== '0' && type !== '\0') || !name.startsWith('package/')) continue;
+        const rel = path.posix.normalize(name.slice('package/'.length));
+        if (!rel || rel.startsWith('..') || rel.startsWith('/') || rel.endsWith('/')) {
+            throw new Error(`Unsafe path in tarball: ${name}`);
+        }
+        const full = path.resolve(root, rel);
+        if (!full.startsWith(root + path.sep)) {
+            throw new Error(`Unsafe path in tarball: ${name}`);
+        }
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, data);
+    }
+}
+
+class FileUpdater {
+    constructor(appDataPath, updateClient) {
+        this.appDataPath = appDataPath;
+        this.updateClient = updateClient;
+        this.onProgress = null;
+        this.statePath = path.join(appDataPath, 'file-state.json');
+    }
+
+    set onNotice(fn) {
+        hooks.notice = fn;
+    }
+
+    sdkHeaders() {
+        const h = { Accept: 'application/json' };
+        if (process.env.NPM_TOKEN) h.Authorization = `Bearer ${process.env.NPM_TOKEN}`;
+        return h;
+    }
+
+    liveHeaders(extra = {}) {
+        const t = this.updateClient && this.updateClient.token;
+        return t ? { ...extra, 'PRIVATE-TOKEN': t } : extra;
+    }
+
+    target(rel) {
+        const root = path.resolve(this.appDataPath);
+        const full = path.resolve(root, ...rel.split('/'));
+        if (!full.startsWith(root + path.sep)) throw new Error(`Path escape: ${rel}`);
+        return full;
+    }
+
+    readState() {
+        try {
+            const s = JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
+            return {
+                seq: typeof s.seq === 'number' ? s.seq : null,
+                base: s.base && typeof s.base === 'object' ? s.base : {},
+                remote: s.remote && typeof s.remote === 'object' ? s.remote : {},
+                local: s.local && typeof s.local === 'object' ? s.local : {},
+                commits: s.commits && typeof s.commits === 'object' ? s.commits : {}
+            };
+        } catch (e) {
+            return { seq: null, base: {}, remote: {}, local: {}, commits: {} };
+        }
+    }
+
+    writeState(state) {
+        const cur = this.readState();
+        const next = {
+            seq: state.seq !== undefined ? state.seq : cur.seq,
+            base: state.base || cur.base,
+            remote: state.remote || cur.remote,
+            local: state.local || cur.local,
+            commits: state.commits || cur.commits
+        };
+        fs.mkdirSync(this.appDataPath, { recursive: true });
+        const tmp = `${this.statePath}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(next), 'utf8');
+        fs.renameSync(tmp, this.statePath);
+    }
+
+    snapshotBase() {
+        const base = {};
+        const walk = (dir, rel) => {
+            for (const name of fs.readdirSync(dir)) {
+                if (name === 'node_modules' || name === '.git') continue;
+                const full = path.join(dir, name);
+                const r = `${rel}/${name}`;
+                const st = fs.lstatSync(full);
+                if (st.isDirectory()) walk(full, r);
+                else if (st.isFile()) base[r] = sha256File(full);
+            }
+        };
+        for (const root of ALLOWED_ROOTS) {
+            const dir = path.join(this.appDataPath, root);
+            if (fs.existsSync(dir)) walk(dir, root);
+        }
+        this.writeState({ seq: this.readState().seq, base, remote: {}, local: {}, commits: {} });
+    }
+
+    zipMatches(zipPath, sha256) {
+        try {
+            return sha256File(zipPath) === String(sha256).trim().toLowerCase();
+        } catch (e) {
+            return false;
+        }
+    }
+
+    async checkFiles() {
+        const versionFile = path.join(this.appDataPath, 'version.json');
+        let local;
+        try {
+            local = JSON.parse(fs.readFileSync(versionFile, 'utf8'));
+        } catch (e) {
+            return { seq: 0, changes: [] };
+        }
+        const release = await this.updateClient.checkForUpdates();
+        const norm = (v) => String(v || '').replace(/^v/, '').trim();
+        if (!release || !release.sha256 || !local.sha256) return { seq: 0, changes: [] };
+        if (norm(release.version) !== norm(local.version) || release.sha256 === local.sha256) {
+            return { seq: 0, changes: [] };
+        }
+
+        const zipPath = path.join(this.appDataPath, 'pending-ui.zip');
+        if (!this.zipMatches(zipPath, release.sha256)) {
+            fs.rmSync(zipPath, { force: true });
+            await this.updateClient.downloadUpdate(release, zipPath, this.onProgress);
+            if (!this.zipMatches(zipPath, release.sha256)) {
+                fs.rmSync(zipPath, { force: true });
+                throw new Error('Update archive checksum mismatch');
+            }
+        }
+
+        const state = this.readState();
+        const zip = new AdmZip(zipPath);
+        const changes = [];
+        for (const entry of zip.getEntries()) {
+            if (entry.isDirectory) continue;
+            const rel = safeRel(entry.entryName);
+            if (!rel) continue;
+            const data = entry.getData();
+            const hash = sha256Buf(data);
+            const full = this.target(rel);
+            if (!fs.existsSync(full)) {
+                changes.push({ path: rel, sha256: hash, size: data.length, status: 'added' });
+                continue;
+            }
+            const baseline = state.base[rel] || sha256File(full);
+            if (baseline !== hash) {
+                changes.push({ path: rel, sha256: hash, size: data.length, status: 'modified' });
+            }
+        }
+
+        if (changes.length === 0) {
+            fs.writeFileSync(versionFile, JSON.stringify({ version: release.version, sha256: release.sha256 }, null, 2), 'utf8');
+            fs.rmSync(zipPath, { force: true });
+            return { seq: 0, changes: [] };
+        }
+
+        this.pending = { release, zipPath, total: changes.length };
+        return { seq: 0, changes };
+    }
+
+    async applyFiles(changes, seq, replacements, onFile) {
+        if (!this.pending) throw new Error('No pending update');
+        const { release, zipPath, total } = this.pending;
+        const zip = new AdmZip(zipPath);
+        const staged = [];
+        for (let i = 0; i < changes.length; i++) {
+            const c = changes[i];
+            const entry = zip.getEntry(c.path);
+            if (!entry) throw new Error(`Missing in archive: ${c.path}`);
+            const data = entry.getData();
+            if (sha256Buf(data) !== c.sha256) throw new Error(`Checksum mismatch: ${c.path}`);
+            staged.push({ c, data: this.applyReplacements(c.path, data, replacements) });
+            if (onFile) onFile(c.path, i + 1, changes.length);
+        }
+
+        const done = [];
+        try {
+            for (const s of staged) {
+                const full = this.target(s.c.path);
+                const prev = fs.existsSync(full) ? fs.readFileSync(full) : null;
+                fs.mkdirSync(path.dirname(full), { recursive: true });
+                fs.writeFileSync(`${full}.vyla-tmp`, s.data);
+                fs.renameSync(`${full}.vyla-tmp`, full);
+                done.push({ full, prev });
+            }
+        } catch (e) {
+            for (const d of done.reverse()) {
+                try {
+                    if (d.prev === null) fs.rmSync(d.full, { force: true });
+                    else fs.writeFileSync(d.full, d.prev);
+                } catch (x) { }
+            }
+            throw e;
+        }
+
+        const state = this.readState();
+        for (const s of staged) state.base[s.c.path] = s.c.sha256;
+        this.writeState({ seq: state.seq, base: state.base });
+
+        if (changes.length === total) {
+            fs.writeFileSync(
+                path.join(this.appDataPath, 'version.json'),
+                JSON.stringify({ version: release.version, sha256: release.sha256 }, null, 2),
+                'utf8'
+            );
+            fs.rmSync(zipPath, { force: true });
+            this.pending = null;
+        }
+    }
+
+    applyReplacements(rel, buf, replacements) {
+        const list = (replacements && replacements[rel.split('/')[0]]) || [];
+        if (!list.length) return buf;
+        let text = buf.toString('utf8');
+        let changed = false;
+        for (const rep of list) {
+            if (rep && rep.find && text.includes(rep.find)) {
+                text = text.split(rep.find).join(rep.replace);
+                changed = true;
+            }
+        }
+        return changed ? Buffer.from(text, 'utf8') : buf;
+    }
+
+    async loadArchive(root) {
+        const buf = await fetchBuffer(`${REPO_API}${root}/repository/archive.zip?sha=main`, { headers: this.liveHeaders(), maxBytes: 600 * 1024 * 1024, hosts: LIVE_HOSTS });
+        const zip = new AdmZip(buf);
+        const map = new Map();
+        for (const entry of zip.getEntries()) {
+            if (entry.isDirectory) continue;
+            const name = entry.entryName;
+            const i = name.indexOf('/');
+            if (i < 0) continue;
+            map.set(`${root}/${name.slice(i + 1)}`, entry);
+        }
+        return map;
+    }
+
+    fetchRepoFile(rel) {
+        const hit = this.archive && this.archive.get(rel);
+        if (hit) return Promise.resolve(hit.getData());
+        const parts = rel.split('/');
+        const root = parts.shift();
+        const file = encodeURIComponent(parts.join('/'));
+        return fetchBuffer(`${REPO_API}${root}/repository/files/${file}/raw?ref=main`, { headers: this.liveHeaders(), maxBytes: MAX_FILE, hosts: LIVE_HOSTS });
+    }
+
+    async headCommit(root) {
+        try {
+            const raw = await fetchBuffer(`${REPO_API}${root}/repository/commits/main`, {
+                headers: this.liveHeaders({ Accept: 'application/json' }),
+                maxBytes: 1024 * 1024,
+                hosts: LIVE_HOSTS,
+                retries: 3
+            });
+            const id = JSON.parse(raw.toString('utf8')).id;
+            return /^[0-9a-f]{40}$/.test(id) ? id : null;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    localIntact(root, state) {
+        const prefix = `${root}/`;
+        const keys = Object.keys(state.remote).filter((k) => k.startsWith(prefix));
+        if (keys.length === 0) return false;
+        for (const rel of keys) {
+            try {
+                if (sha256File(this.target(rel)) !== state.local[rel]) return false;
+            } catch (e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    async checkRepos() {
+        const state = this.readState();
+        const changes = [];
+        const remoteIds = {};
+        const checkedRoots = [];
+        const errors = [];
+        const verified = { remote: {}, local: {} };
+        const commits = {};
+        this.archive = new Map();
+        for (const root of ALLOWED_ROOTS) {
+            const head = await this.headCommit(root);
+            if (this.localIntact(root, state) && (!head || head === state.commits[root])) continue;
+            let map;
+            try {
+                map = await this.loadArchive(root);
+            } catch (e) {
+                errors.push(`${root}: ${e.message}`);
+                continue;
+            }
+            if (map.size === 0) {
+                errors.push(`${root}: empty archive`);
+                continue;
+            }
+            checkedRoots.push(root);
+            if (head) commits[root] = head;
+            for (const [key, entry] of map) {
+                const rel = safeRel(key);
+                if (!rel) continue;
+                const data = entry.getData();
+                const id = gitBlobSha(data);
+                remoteIds[rel] = id;
+                const full = this.target(rel);
+                let ok = false;
+                let localHash = null;
+                if (fs.existsSync(full)) {
+                    const buf = fs.readFileSync(full);
+                    localHash = sha256Buf(buf);
+                    ok = gitBlobSha(buf) === id || (state.remote[rel] === id && state.local[rel] === localHash);
+                }
+                if (ok) {
+                    verified.remote[rel] = id;
+                    verified.local[rel] = localHash;
+                } else {
+                    changes.push({ path: rel, sha256: id, size: data.length });
+                    this.archive.set(rel, entry);
+                }
+            }
+        }
+        if (checkedRoots.length === 0) {
+            if (errors.length) throw new Error(errors.join(' | '));
+            return { seq: state.seq === null ? 0 : state.seq, changes: [], removed: [], verified, commits };
+        }
+        const tracked = new Set([...Object.keys(state.base), ...Object.keys(state.remote)]);
+        const removed = [...tracked].filter((rel) =>
+            checkedRoots.includes(rel.split('/')[0]) &&
+            !remoteIds[rel] &&
+            safeRel(rel) &&
+            fs.existsSync(this.target(rel))
+        );
+        if (changes.length === 0 && removed.length === 0) {
+            for (const k of Object.keys(verified.remote)) {
+                state.remote[k] = verified.remote[k];
+                state.local[k] = verified.local[k];
+            }
+            this.writeState({ remote: state.remote, local: state.local, commits: { ...state.commits, ...commits } });
+            this.archive = null;
+        }
+        return { seq: state.seq === null ? 0 : state.seq, changes, removed, verified, commits };
+    }
+
+    async applyLive(info, replacements, onFile) {
+        const staged = [];
+        const total = info.changes.length;
+        let next = 0;
+        if (!this.archive) this.archive = new Map();
+        let finished = 0;
+        let failure = null;
+        const worker = async () => {
+            while (next < total && !failure) {
+                const c = info.changes[next++];
+                try {
+                    const data = await this.fetchRepoFile(c.path);
+                    if (gitBlobSha(data) !== c.sha256) throw new Error(`Checksum mismatch: ${c.path}`);
+                    staged.push({ c, data: this.applyReplacements(c.path, data, replacements) });
+                    finished++;
+                    if (onFile) onFile(c.path, finished, total);
+                } catch (e) {
+                    failure = e;
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(4, total) }, worker));
+        this.archive = null;
+        if (failure) throw failure;
+
+        const done = [];
+        try {
+            for (const s of staged) {
+                const full = this.target(s.c.path);
+                const prev = fs.existsSync(full) ? fs.readFileSync(full) : null;
+                fs.mkdirSync(path.dirname(full), { recursive: true });
+                fs.writeFileSync(`${full}.vyla-tmp`, s.data);
+                fs.renameSync(`${full}.vyla-tmp`, full);
+                done.push({ full, prev });
+            }
+            for (const rel of info.removed) {
+                const full = this.target(rel);
+                if (!fs.existsSync(full)) continue;
+                const prev = fs.readFileSync(full);
+                fs.rmSync(full, { force: true });
+                done.push({ full, prev });
+            }
+        } catch (e) {
+            for (const d of done.reverse()) {
+                try {
+                    if (d.prev === null) fs.rmSync(d.full, { force: true });
+                    else fs.writeFileSync(d.full, d.prev);
+                } catch (x) { }
+            }
+            throw e;
+        }
+
+        const state = this.readState();
+        for (const s of staged) {
+            state.base[s.c.path] = s.c.sha256;
+            state.remote[s.c.path] = s.c.sha256;
+            state.local[s.c.path] = sha256Buf(s.data);
+        }
+        for (const rel of info.removed) {
+            delete state.base[rel];
+            delete state.remote[rel];
+            delete state.local[rel];
+        }
+        const v = info.verified || { remote: {}, local: {} };
+        for (const k of Object.keys(v.remote)) {
+            state.remote[k] = v.remote[k];
+            state.local[k] = v.local[k];
+        }
+        state.commits = { ...state.commits, ...(info.commits || {}) };
+        this.writeState({ seq: info.seq, base: state.base, remote: state.remote, local: state.local, commits: state.commits });
+    }
+
+    installedSdk() {
+        const roots = [this.appDataPath, path.join(this.appDataPath, 'frontend'), path.join(this.appDataPath, 'player')];
+        const found = [];
+        for (const root of roots) {
+            const dir = path.join(root, 'node_modules', ...SDK_NAME.split('/'));
+            try {
+                const version = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).version;
+                if (version) found.push({ dir, version });
+            } catch (e) { }
+        }
+        return found;
+    }
+
+    recoverSdk() {
+        for (const root of [this.appDataPath, path.join(this.appDataPath, 'frontend'), path.join(this.appDataPath, 'player')]) {
+            const dir = path.join(root, 'node_modules', ...SDK_NAME.split('/'));
+            const old = `${dir}.vyla-old`;
+            const stage = `${dir}.vyla-new`;
+            try {
+                if (!fs.existsSync(dir) && fs.existsSync(old)) fs.renameSync(old, dir);
+                fs.rmSync(stage, { recursive: true, force: true });
+                if (fs.existsSync(dir)) fs.rmSync(old, { recursive: true, force: true });
+            } catch (e) { }
+        }
+    }
+
+    async checkSdk() {
+        const raw = await fetchBuffer(SDK_LATEST_URL, {
+            headers: this.sdkHeaders(),
+            maxBytes: 5 * 1024 * 1024,
+            hosts: ['registry.npmjs.org']
+        });
+        const meta = JSON.parse(raw.toString('utf8'));
+        const integrity = String((meta.dist && meta.dist.integrity) || '').split(' ').find((s) => s.startsWith('sha512-'));
+        if (!meta.version || !meta.dist || !meta.dist.tarball || !integrity) {
+            throw new Error('Registry response missing version or integrity');
+        }
+        const installed = this.installedSdk();
+        const targets = installed.filter((i) => cmpVer(i.version, meta.version) < 0);
+        const current = targets.length ? targets.map((t) => t.version).sort(cmpVer)[0] : meta.version;
+        return {
+            outdated: targets.length > 0,
+            current,
+            latest: meta.version,
+            tarball: meta.dist.tarball,
+            integrity,
+            dirs: targets.map((t) => t.dir)
+        };
+    }
+
+    async installSdk(info) {
+        const tgz = await fetchBuffer(info.tarball, {
+            headers: this.sdkHeaders(),
+            maxBytes: MAX_TARBALL,
+            hosts: ['registry.npmjs.org']
+        });
+        const digest = `sha512-${crypto.createHash('sha512').update(tgz).digest('base64')}`;
+        if (digest !== info.integrity) throw new Error('SDK integrity check failed');
+        const tar = zlib.gunzipSync(tgz, { maxOutputLength: 300 * 1024 * 1024 });
+
+        for (const dir of info.dirs) {
+            const stage = `${dir}.vyla-new`;
+            const old = `${dir}.vyla-old`;
+            fs.rmSync(stage, { recursive: true, force: true });
+            fs.rmSync(old, { recursive: true, force: true });
+            fs.mkdirSync(stage, { recursive: true });
+            extractTar(tar, stage);
+            const version = JSON.parse(fs.readFileSync(path.join(stage, 'package.json'), 'utf8')).version;
+            if (version !== info.latest) {
+                fs.rmSync(stage, { recursive: true, force: true });
+                throw new Error('SDK version mismatch in tarball');
+            }
+            const had = fs.existsSync(dir);
+            if (had) fs.renameSync(dir, old);
+            try {
+                fs.renameSync(stage, dir);
+            } catch (e) {
+                if (had) fs.renameSync(old, dir);
+                throw e;
+            }
+            fs.rmSync(old, { recursive: true, force: true });
+        }
+    }
+}
+
+module.exports = FileUpdater;

github-client.js

@@ -1,176 +0,0 @@
-const { execSync, spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const REPOS = {
-    frontend: { branch: 'main' },
-    player: { branch: 'main' }
-};
-
-const GITLAB_GROUP = 'vyla-entertainment';
-
-class GitlabClient {
-    constructor(appDataPath, credentialManager) {
-        this.appDataPath = appDataPath;
-        this.credentialManager = credentialManager;
-    }
-
-    getToken() {
-        return this.credentialManager.getCredential('gitlab', 'TOKEN') || null;
-    }
-
-    setToken(token) {
-        this.credentialManager.setCredential('gitlab', 'TOKEN', token);
-    }
-
-    hasToken() {
-        return !!this.getToken();
-    }
-
-    buildRepoUrl(repoName) {
-        const token = this.getToken();
-        if (token) {
-            return `https://oauth2:${token}@gitlab.com/${GITLAB_GROUP}/${repoName}.git`;
-        }
-        return `https://gitlab.com/${GITLAB_GROUP}/${repoName}.git`;
-    }
-
-    repoDir(repoName) {
-        return path.join(this.appDataPath, repoName);
-    }
-
-    isRepoCloned(repoName) {
-        const gitDir = path.join(this.repoDir(repoName), '.git');
-        return fs.existsSync(gitDir);
-    }
-
-    allReposCloned() {
-        return Object.keys(REPOS).every((name) => this.isRepoCloned(name));
-    }
-
-    cloneRepo(repoName, onLog) {
-        const { branch } = REPOS[repoName];
-        const targetDir = this.repoDir(repoName);
-        const url = this.buildRepoUrl(repoName);
-
-        if (fs.existsSync(targetDir)) {
-            fs.rmSync(targetDir, { recursive: true, force: true });
-        }
-
-        if (onLog) onLog(`Cloning ${repoName}...`);
-
-        const result = spawnSync('git', ['clone', '--depth', '1', '--branch', branch, url, targetDir], {
-            stdio: 'pipe',
-            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
-        });
-
-        if (result.status !== 0) {
-            const stderr = result.stderr ? result.stderr.toString() : 'unknown error';
-            throw new Error(`Failed to clone ${repoName}: ${stderr}`);
-        }
-    }
-
-    cloneAll(onLog) {
-        for (const repoName of Object.keys(REPOS)) {
-            this.cloneRepo(repoName, onLog);
-        }
-    }
-
-    installDependencies(repoName, onLog) {
-        const repoDir = this.repoDir(repoName);
-        const pkgJsonPath = path.join(repoDir, 'package.json');
-
-        if (!fs.existsSync(pkgJsonPath)) {
-            return;
-        }
-
-        if (onLog) onLog(`Installing dependencies for ${repoName}...`);
-
-        const result = spawnSync('npm', ['install', '--omit=dev'], {
-            cwd: repoDir,
-            stdio: 'pipe',
-            shell: process.platform === 'win32'
-        });
-
-        if (result.status !== 0) {
-            const stderr = result.stderr ? result.stderr.toString() : 'unknown error';
-            throw new Error(`npm install failed for ${repoName}: ${stderr}`);
-        }
-    }
-
-    installAllDependencies(onLog) {
-        for (const repoName of Object.keys(REPOS)) {
-            this.installDependencies(repoName, onLog);
-        }
-    }
-
-    getLocalHead(repoName) {
-        const repoDir = this.repoDir(repoName);
-        try {
-            return execSync('git rev-parse HEAD', { cwd: repoDir }).toString().trim();
-        } catch (e) {
-            return null;
-        }
-    }
-
-    getRemoteHead(repoName) {
-        const { branch } = REPOS[repoName];
-        const repoDir = this.repoDir(repoName);
-        const url = this.buildRepoUrl(repoName);
-        try {
-            const output = execSync(`git ls-remote "${url}" refs/heads/${branch}`, { cwd: repoDir }).toString().trim();
-            return output.split('\t')[0] || null;
-        } catch (e) {
-            return null;
-        }
-    }
-
-    checkForUpdates() {
-        const outdated = [];
-        for (const repoName of Object.keys(REPOS)) {
-            const local = this.getLocalHead(repoName);
-            const remote = this.getRemoteHead(repoName);
-            if (local && remote && local !== remote) {
-                outdated.push(repoName);
-            }
-        }
-        return outdated;
-    }
-
-    updateRepo(repoName, onLog) {
-        const { branch } = REPOS[repoName];
-        const repoDir = this.repoDir(repoName);
-
-        if (onLog) onLog(`Updating ${repoName}...`);
-
-        const fetchResult = spawnSync('git', ['fetch', 'origin', branch], {
-            cwd: repoDir,
-            stdio: 'pipe',
-            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }
-        });
-
-        if (fetchResult.status !== 0) {
-            const stderr = fetchResult.stderr ? fetchResult.stderr.toString() : 'unknown error';
-            throw new Error(`Failed to fetch ${repoName}: ${stderr}`);
-        }
-
-        const resetResult = spawnSync('git', ['reset', '--hard', `origin/${branch}`], {
-            cwd: repoDir,
-            stdio: 'pipe'
-        });
-
-        if (resetResult.status !== 0) {
-            const stderr = resetResult.stderr ? resetResult.stderr.toString() : 'unknown error';
-            throw new Error(`Failed to reset ${repoName}: ${stderr}`);
-        }
-    }
-
-    updateAll(repoNames, onLog) {
-        for (const repoName of repoNames) {
-            this.updateRepo(repoName, onLog);
-            this.installDependencies(repoName, onLog);
-        }
-    }
-}
-
-module.exports = GitlabClient

main.js

@@ -5,6 +5,7 @@ const express = require('express');
 const ServiceManager = require('./service-manager');
 const Patcher = require('./patcher');
 const UpdateClient = require('./update-client');
+const FileUpdater = require('./file-updater');
 
 function getDefaultAppData() {
   if (process.platform === 'darwin') {
@@ -32,8 +33,6 @@ function debugLog(msg) {
 debugLog("--- Node.js Process Started ---");
 
 let serviceManager;
-let expressApp;
-let expressServer;
 let updateDecisionHandler = null;
 
 debugLog(`AppData Dir: ${APPDATA_DIR}`);
@@ -43,68 +42,6 @@ function sendToTauri(event, data) {
   process.stdout.write(JSON.stringify({ event, data }) + '\n');
 }
 
-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...');
@@ -145,7 +82,43 @@ function getReplacementsConfig() {
   } catch (e) { return {}; }
 }
 
+function liveReposEnabled() {
+  const cfg = getEnvConfig();
+  return !!(cfg.updater && cfg.updater.liveRepos === true);
+}
+
 const updateClient = new UpdateClient(APPDATA_DIR);
+const fileUpdater = new FileUpdater(APPDATA_DIR, updateClient);
+fileUpdater.onNotice = (message) => sendToTauri('notice', { message });
+let lastFilePercent = -1;
+fileUpdater.onProgress = (downloaded, total) => {
+  const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
+  if (percent === lastFilePercent) return;
+  lastFilePercent = percent;
+  sendToTauri('download-progress', { downloaded, total, percent });
+};
+
+function withTimeout(promise, ms) {
+  return Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(null), ms))]);
+}
+
+function portInUse(port) {
+  return new Promise((resolve) => {
+    const socket = new (require('net').Socket)();
+    socket.setTimeout(500);
+    socket.once('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once('error', () => resolve(false));
+    socket.once('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, '127.0.0.1');
+  });
+}
+
 
 async function start() {
   debugLog("Inside start() function");
@@ -154,139 +127,129 @@ async function start() {
   const patcher = new Patcher(APPDATA_DIR);
   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;
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-    while (attempts < 3 && !downloadSuccess) {
-      attempts++;
+  const downloadVerified = async (name, item, dest) => {
+    let lastError;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      fs.rmSync(dest, { force: true });
       try {
-        debugLog(`Attempting to download update (Attempt ${attempts})...`);
-        sendToTauri('status', { message: `Connecting to download servers (Attempt ${attempts}/3)...` });
-
+        sendToTauri('status', { message: `Downloading ${name} (attempt ${attempt}/3)...` });
         let lastPercent = -1;
-        await updateClient.downloadUpdate(release, tempZipPath, (downloaded, total) => {
+        await updateClient.downloadUpdate(item, dest, (downloaded, total) => {
           const percent = total > 0 ? Math.round((downloaded / total) * 100) : 0;
           if (percent !== lastPercent) {
             lastPercent = percent;
             sendToTauri('download-progress', { downloaded, total, percent });
           }
         });
-
-        debugLog('Download complete. Verifying checksum...');
-        sendToTauri('status', { message: 'Verifying SHA-256 integrity...' });
-        if (!release.sha256) {
-          throw new Error('Release has no SHA-256 in manifest.json; refusing unverified install.');
-        }
-        if (!patcher.verifyChecksum(tempZipPath, release.sha256)) {
+        sendToTauri('status', { message: `Verifying ${name} SHA-256...` });
+        if (!patcher.verifyChecksum(dest, item.sha256)) {
           throw new Error('SHA-256 checksum verification failed.');
         }
+        return;
+      } catch (err) {
+        lastError = err;
+        fs.rmSync(dest, { force: true });
+        debugLog(`Download error for ${name} on attempt ${attempt}: ${err.message}`);
+        if (attempt < 3) {
+          await sleep(err.retryAfterMs || 2000 * 2 ** (attempt - 1) + Math.floor(Math.random() * 500));
+        }
+      }
+    }
+    throw new Error(`Failed to download ${name} after 3 attempts: ${lastError.message}`);
+  };
 
-        debugLog('Checksum verified. Extracting to staging...');
-        sendToTauri('status', { message: 'Unpacking update archive...' });
+  const installBuild = async (release) => {
+    const names = patcher.staleComponents(release);
+    if (names.length === 0) return;
+
+    const stagingDir = path.join(APPDATA_DIR, '.staging');
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+    fs.mkdirSync(stagingDir, { recursive: true });
+    const tempFiles = [];
+
+    try {
+      for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        const tempZip = path.join(APPDATA_DIR, `download-${name}.zip`);
+        tempFiles.push(tempZip);
+        await downloadVerified(name, release.components[name], tempZip);
+
+        sendToTauri('status', { message: `Unpacking ${name}...` });
         let lastEmit = 0;
-        const stagingDir = await patcher.extractToStaging(tempZipPath, (file, done, total) => {
+        await patcher.extractToStaging(tempZip, (file, done, total) => {
           const now = Date.now();
           if (done !== total && now - lastEmit < 40) return;
           lastEmit = now;
-          sendToTauri('extract-progress', {
-            file,
-            done,
-            total,
-            percent: Math.round((done / total) * 100)
-          });
-        });
-
-        sendToTauri('status', { message: 'Verifying file integrity...' });
-        if (!patcher.verifyExtraction(stagingDir)) {
-          fs.rmSync(stagingDir, { recursive: true, force: true });
-          throw new Error('Extraction verification failed: critical startup files missing.');
-        }
-
-        sendToTauri('status', { message: 'Replacing old version...' });
-        patcher.commitStaging(stagingDir);
-
-        debugLog('Extraction complete. Applying patches...');
-        sendToTauri('status', { message: 'Applying configuration patches...' });
-        patcher.applyPatches(getReplacementsConfig());
-
-        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);
-        }
-        downloadSuccess = true;
-        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) { }
-        }
-        if (attempts >= 3) {
-          throw new Error(`Failed to download and verify build after 3 attempts: ${err.message}`);
-        }
-        await new Promise(r => setTimeout(r, 2000));
+          sendToTauri('extract-progress', { file, done, total, percent: Math.round((done / total) * 100) });
+        }, i > 0);
+        fs.rmSync(tempZip, { force: true });
       }
+
+      sendToTauri('status', { message: 'Verifying file integrity...' });
+      if (!patcher.verifyStaged(stagingDir, names)) {
+        throw new Error('Extraction verification failed: critical startup files missing.');
+      }
+
+      sendToTauri('status', { message: 'Replacing old version...' });
+      patcher.commitStaging(stagingDir);
+    } catch (err) {
+      fs.rmSync(stagingDir, { recursive: true, force: true });
+      for (const f of tempFiles) fs.rmSync(f, { force: true });
+      throw err;
     }
+
+    try {
+      sendToTauri('status', { message: 'Applying configuration patches...' });
+      patcher.applyPatches(getReplacementsConfig(), names);
+
+      sendToTauri('status', { message: 'Migrating security credentials...' });
+      patcher.bridgeCredentials(serviceManager.credentialManager);
+
+      if (!patcher.verifyExtraction()) {
+        throw new Error('Post-install verification failed.');
+      }
+
+      const current = patcher.getCurrentComponents();
+      const next = {};
+      for (const name of Object.keys(release.components)) {
+        next[name] = names.includes(name) ? release.components[name].id : current[name];
+      }
+      patcher.saveCurrentVersion(release.version, release.sha256, next);
+      patcher.writeIntegrity(names);
+    } catch (err) {
+      try { patcher.rollback(); } catch (x) { debugLog(`Rollback failed: ${x.message}`); }
+      throw err;
+    }
+
+    patcher.finalizeCommit();
+    if (liveReposEnabled()) fileUpdater.snapshotBase();
+    serviceManager.envConfig = getEnvConfig();
+    debugLog(`Update installed successfully: ${names.join(', ')}`);
   };
 
   try {
+    if (patcher.recoverInterrupted()) {
+      debugLog('Recovered from an interrupted update.');
+      sendToTauri('notice', { message: 'Recovered from an interrupted update.' });
+    }
+    fileUpdater.recoverSdk();
     sendToTauri('status', { message: 'Inspecting local workspace and installed files...' });
     const isFirstRun = !patcher.verifyExtraction();
     const localVersion = patcher.getCurrentVersion();
     const localSha = patcher.getCurrentSha();
     debugLog(`Is First Run: ${isFirstRun}, Local Version: ${localVersion}, Local SHA: ${localSha}`);
 
-    function findLocalZip() {
-      const searchRoots = [__dirname, process.cwd(), path.join(__dirname, '../../..')];
-      for (const root of searchRoots) {
-        let cur = root;
-        for (let i = 0; i < 6; i++) {
-          try {
-            const zp = path.join(cur, 'update-payload.zip');
-            if (fs.existsSync(zp)) {
-              const mp = path.join(cur, 'manifest.json');
-              return { zipPath: zp, manifestPath: fs.existsSync(mp) ? mp : null };
-            }
-            const parent = path.dirname(cur);
-            if (parent === cur) break;
-            cur = parent;
-          } catch (e) { }
-        }
-      }
-      return null;
-    }
-
-    let localZipPath = null;
-    let localManifestPath = null;
-    let localZipManifest = null;
-
     sendToTauri('status', { message: 'Connecting to update servers...' });
     let release = null;
     try {
       debugLog("Fetching updates from updateClient...");
-      release = await updateClient.checkForUpdates();
+      release = await updateClient.checkForUpdates(isFirstRun);
       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})` });
+      debugLog(`Update check failed: ${e.message}`);
+      sendToTauri('notice', { message: `Update check skipped: ${e.message}` });
     }
 
     const normalizeVer = (v) => (v || '').toString().replace(/^v/, '').trim();
@@ -302,115 +265,96 @@ async function start() {
       return false;
     };
 
-    if (release) {
-      const versionNewer = isNewer(release.version, localVersion);
-      const sameVerNewBuild = normalizeVer(release.version) === normalizeVer(localVersion) &&
-        !!release.sha256 && !!localSha && release.sha256 !== localSha;
-      const hasUpdate = (versionNewer || sameVerNewBuild) && !localZipPath;
-
-      if (isFirstRun) {
-        debugLog("First run with no local payload. Installing remote build...");
-        sendToTauri('status', { message: 'First run detected. Preparing initial installation...' });
-        await installBuild(release);
-      } else if (hasUpdate) {
-
-        debugLog("Update available. Prompting user...");
-        sendToTauri('status', { message: `New update available (${release.version}).` });
-
+    if (release && release.installer && process.platform === 'win32' && process.env.VYLA_DEV !== '1') {
+      const appVersion = process.env.VYLA_APP_VERSION || '0.0.0';
+      const tried = updateClient.readCache().selfUpdate || {};
+      const recentlyTried = tried.version === release.installer.version && Date.now() - (tried.at || 0) < 24 * 60 * 60 * 1000;
+      if (isNewer(release.installer.version, appVersion) && !recentlyTried) {
         try {
-          if (process.platform === 'win32') {
-            require('child_process').spawnSync('powershell.exe', [
-              '-NoProfile', '-NonInteractive', '-Command',
-              `Get-NetTCPConnection -LocalPort 4891 -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force }`
-            ], { stdio: 'ignore', windowsHide: true });
-          } else {
-            require('child_process').spawnSync('fuser', ['-k', '-9', `4891/tcp`], { stdio: 'ignore' });
-          }
-        } catch (e) { }
-
-        const tempApp = express();
-        let userDecision = null;
-        updateDecisionHandler = (val) => { userDecision = val; };
-
-        tempApp.use((req, res, next) => {
-          res.header('Access-Control-Allow-Origin', '*');
-          res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
-          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) {
-          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));
+          const dest = path.join(APPDATA_DIR, `vyla-installer-${normalizeVer(release.installer.version)}.exe`);
+          sendToTauri('status', { message: 'Downloading launcher update...' });
+          await downloadVerified('launcher', release.installer, dest);
+          updateClient.writeCache({ selfUpdate: { version: release.installer.version, at: Date.now() } });
+          sendToTauri('status', { message: 'Installing launcher update...' });
+          sendToTauri('self-update', { path: dest });
+          await sleep(30000);
+          sendToTauri('notice', { message: 'Launcher update did not start. Continuing on the current version.' });
+        } catch (err) {
+          debugLog(`Launcher update failed: ${err.message}`);
+          sendToTauri('notice', { message: `Launcher update failed: ${err.message}` });
         }
+      }
+    }
 
-        updateDecisionHandler = null;
-        if (tempServer) {
-          tempServer.close();
-        }
+    if (release) {
+      const stale = patcher.staleComponents(release);
+      const broken = stale.some((name) => !patcher.componentIntact(name));
+      const sameVersion = normalizeVer(release.version) === normalizeVer(localVersion);
+      const hasUpdate = stale.length > 0 && (broken || isNewer(release.version, localVersion) || sameVersion);
 
-        if (userDecision) {
-          debugLog("User accepted update.");
+      if (hasUpdate) {
+        debugLog(`Installing components: ${stale.join(', ')}`);
+        sendToTauri('status', {
+          message: isFirstRun ? 'First run detected. Preparing initial installation...' : `Updating to ${release.version}...`
+        });
+        try {
           await installBuild(release);
-        } else {
-          debugLog("User skipped update.");
-          sendToTauri('status', { message: 'Update skipped. Continuing startup...' });
+          updateClient.recordSuccess();
+        } catch (err) {
+          updateClient.recordFailure();
+          debugLog(`Update failed: ${err.message}`);
+          sendToTauri('notice', { message: `Update failed: ${err.message}` });
         }
       } 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...");
+    }
+
+    if (!patcher.verifyExtraction()) {
+      debugLog("No usable install. 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)) {
+      const payloadRoots = [
+        process.env.VYLA_PAYLOAD_DIR,
+        __dirname,
+        process.cwd(),
+        path.resolve(__dirname, '..', '..', '..', '..'),
+        APPDATA_DIR
+      ].filter(Boolean);
+      const payloadRoot = payloadRoots.find((r) => fs.existsSync(path.join(r, 'update-payload.zip')));
+      const localZip = payloadRoot ? path.join(payloadRoot, 'update-payload.zip') : null;
+      if (localZip) {
         sendToTauri('status', { message: 'Extracting local baseline payload...' });
-        patcher.purgeOldCode();
-        patcher.extractZipPayload(localZip);
-        patcher.applyPatches(getReplacementsConfig());
-        patcher.bridgeCredentials(serviceManager.credentialManager);
+        const stagingDir = await patcher.extractToStaging(localZip);
+        if (!patcher.verifyStaged(stagingDir, ['frontend', 'player'])) {
+          fs.rmSync(stagingDir, { recursive: true, force: true });
+          throw new Error('Bundled payload is incomplete.');
+        }
+        patcher.commitStaging(stagingDir);
 
-        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.applyPatches(getReplacementsConfig());
+          patcher.bridgeCredentials(serviceManager.credentialManager);
 
-        patcher.saveCurrentVersion(ver);
+          let ver = "1.0.0";
+          let manSha = null;
+          let ids = {};
+          try {
+            const man = JSON.parse(fs.readFileSync(path.join(payloadRoot, 'manifest.json'), 'utf8'));
+            ver = man.version || ver;
+            manSha = man.sha256 || null;
+            ids = Object.fromEntries(Object.entries(man.components || {}).map(([k, v]) => [k, v.id]));
+          } catch (e) { }
+
+          patcher.saveCurrentVersion(ver, manSha, ids);
+          patcher.writeIntegrity(['frontend', 'player']);
+        } catch (e) {
+          try { patcher.rollback(); } catch (x) { }
+          throw e;
+        }
+
+        patcher.finalizeCommit();
+        if (liveReposEnabled()) fileUpdater.snapshotBase();
         serviceManager.envConfig = getEnvConfig();
         debugLog("Local payload extracted successfully.");
       } else {
@@ -420,23 +364,62 @@ async function start() {
 
     sendToTauri('status', { message: 'Validating critical components...' });
     if (!patcher.verifyExtraction()) {
-      throw new Error('No application files found. Ensure you ran "npm run build:payload" and the extraction succeeded.');
+      throw new Error('No usable install and no valid signed release or bundled payload was found. Check your internet connection and relaunch, or reinstall the app.');
+    }
+
+    const liveRepos = liveReposEnabled();
+    sendToTauri('status', { message: liveRepos ? 'Checking UI files and SDK...' : 'Checking SDK...' });
+    const [filesCheck, sdkCheck] = await Promise.all([
+      liveRepos
+        ? withTimeout(fileUpdater.checkRepos().catch((e) => {
+          debugLog(`Live file check failed: ${e.message}`);
+          sendToTauri('notice', { message: `File check failed: ${e.message}` });
+          return null;
+        }), 60000)
+        : Promise.resolve(null),
+      withTimeout(fileUpdater.checkSdk().catch((e) => {
+        debugLog(`SDK check failed: ${e.message}`);
+        sendToTauri('notice', { message: `SDK check failed: ${e.message}` });
+        return null;
+      }), 12000)
+    ]);
+    if (liveRepos) {
+      debugLog(`Repo check result: ${filesCheck ? `${filesCheck.changes.length} change(s)` : 'failed or timed out'}`);
+    }
+
+    if (filesCheck && (filesCheck.changes.length > 0 || filesCheck.removed.length > 0)) {
+      sendToTauri('status', { message: `Updating ${filesCheck.changes.length} file(s)...` });
+      try {
+        await fileUpdater.applyLive(filesCheck, getReplacementsConfig(), (file, done, total) => {
+          sendToTauri('extract-progress', { file, done, total, percent: Math.round((done / total) * 100) });
+        });
+        sendToTauri('status', { message: `Updated ${filesCheck.changes.length} file(s).` });
+      } catch (e) {
+        debugLog(`File update failed: ${e.message}`);
+        sendToTauri('notice', { message: `File update failed: ${e.message}` });
+      }
+    }
+
+    if (sdkCheck && sdkCheck.outdated) {
+      sendToTauri('status', { message: `Updating SDK (${sdkCheck.latest})...` });
+      try {
+        await fileUpdater.installSdk(sdkCheck);
+        sendToTauri('status', { message: `SDK updated to ${sdkCheck.latest}.` });
+      } catch (e) {
+        debugLog(`SDK install failed: ${e.message}`);
+        sendToTauri('status', { message: `SDK update failed: ${e.message}` });
+      }
     }
 
     sendToTauri('status', { message: 'Loading encrypted credentials...' });
     serviceManager.credentialManager.loadCredentials();
 
-    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'
-      });
+    const busyPorts = [];
+    for (const port of [3000, 4890]) {
+      if (await portInUse(port)) busyPorts.push(port);
+    }
+    if (busyPorts.length > 0) {
+      throw new Error(`Port ${busyPorts.join(' and ')} is already in use by another program. Close it or any other running Vyla Home, then relaunch.`);
     }
 
     sendToTauri('status', { message: 'Starting services (player, frontend)...' });
@@ -447,7 +430,11 @@ async function start() {
     debugLog("Backend services spawn requested.");
 
     sendToTauri('status', { message: 'Waiting for microservices to bind...' });
-    await serviceManager.waitForPorts([3000, 4890]);
+    try {
+      await serviceManager.waitForPorts([3000, 4890], 60000);
+    } catch (e) {
+      throw new Error(`${e.message}. Check logs in ${LOGS_DIR}`);
+    }
     debugLog("Ports 3000 and 4890 are ready.");
 
     sendToTauri('status', { message: 'All backend services running and healthy.' });
@@ -462,18 +449,7 @@ async function start() {
 
 process.on('exit', () => {
   if (serviceManager) {
-    for (const name of Object.keys(serviceManager.processes)) {
-      const proc = serviceManager.processes[name];
-      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) { }
-      }
-    }
+    serviceManager.stopAll();
   }
 });
 
@@ -483,5 +459,8 @@ process.on('SIGINT', () => {
 process.on('SIGTERM', () => {
   process.exit(0);
 });
+process.on('SIGHUP', () => {
+  process.exit(0);
+});
 
-start();
+start();

package-lock.json

@@ -1,20 +1,20 @@
 {
   "name": "vyla-home",
-  "version": "1.1.48",
+  "version": "1.1.56",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "vyla-home",
-      "version": "1.1.48",
+      "version": "1.1.56",
       "dependencies": {
         "@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.5.0",
-        "@vyla-entertainment/sdk": "^1.20.0",
-        "adm-zip": "^0.6.0",
-        "express": "^4.19.2"
+        "@vyla-entertainment/sdk": "latest",
+        "adm-zip": "^0.6.1",
+        "express": "^4.22.3"
       },
       "devDependencies": {
         "@tauri-apps/cli": "2.12.1"
@@ -602,9 +602,9 @@
       }
     },
     "node_modules/adm-zip": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.6.0.tgz",
-      "integrity": "sha512-XleryMhbuksdKtofnWZ9Sk+4CUTbms4Mb/EU32SZwToAyZ5RgVos/ki8n+yr0LWHOGKuakbXTuuYNHLQjhddgg==",
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.6.1.tgz",
+      "integrity": "sha512-Xwrja8nx9e5o2N1my4DsKCeKpdrnACyr1wtbPxBDgGzKzKyE9kRtBFA8mWldI+RVlD7CBZNWY/wQ2+ydwOR6kQ==",
       "license": "MIT",
       "engines": {
         "node": ">=14.0"
@@ -617,9 +617,9 @@
       "license": "MIT"
     },
     "node_modules/body-parser": {
-      "version": "1.20.6",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.6.tgz",
-      "integrity": "sha512-p5tAzS57i5MV9fZFDj9LeIiTZEufbSe2eDozP+ElheSUq1m74CRq1jI4mYNDdVs9vQztXFLuk/Gd6BWTdwRJ5g==",
+      "version": "1.20.9",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.9.tgz",
+      "integrity": "sha512-FISIQxV5u91Y9gvuFq3q/tA/qTqLJn3AhRcEvyozyhJTh5OBFFtv827AdHU7Rbyct4r+Ba1/99oFa1Y3yuFsdw==",
       "license": "MIT",
       "dependencies": {
         "bytes": "~3.1.2",
@@ -630,7 +630,7 @@
         "http-errors": "~2.0.1",
         "iconv-lite": "~0.4.24",
         "on-finished": "~2.4.1",
-        "qs": "~6.15.1",
+        "qs": "~6.16.0",
         "raw-body": "~2.5.3",
         "type-is": "~1.6.18",
         "unpipe": "~1.0.0"
@@ -836,9 +836,9 @@
       }
     },
     "node_modules/express": {
-      "version": "4.22.2",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
-      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
+      "version": "4.22.3",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.3.tgz",
+      "integrity": "sha512-Bdcs4+3qlpVlx2NRn6fgX2Ue2/gGRaPeawebgclM0ERSCqDpA+owF1fdPwjJUTAJWMTuAaxjDf+hzb0/4eKvvw==",
       "license": "MIT",
       "dependencies": {
         "accepts": "~1.3.8",
@@ -860,9 +860,9 @@
         "methods": "~1.1.2",
         "on-finished": "~2.4.1",
         "parseurl": "~1.3.3",
-        "path-to-regexp": "~0.1.12",
+        "path-to-regexp": "~0.1.13",
         "proxy-addr": "~2.0.7",
-        "qs": "~6.15.1",
+        "qs": "~6.16.0",
         "range-parser": "~1.2.1",
         "safe-buffer": "5.2.1",
         "send": "~0.19.0",
@@ -1204,9 +1204,9 @@
       }
     },
     "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
-      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "version": "2.0.8",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.8.tgz",
+      "integrity": "sha512-5nnx0yGyVUcY6t9RnWcARWtwT9F1D8O9rt08htPvnd49W1IgZtmLkhu9WfMzQj1cFxjHIO6connUNVW5k7AVyQ==",
       "license": "MIT",
       "dependencies": {
         "forwarded": "0.2.0",
@@ -1214,6 +1214,10 @@
       },
       "engines": {
         "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
       }
     },
     "node_modules/psl": {
@@ -1238,9 +1242,9 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.15.3",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz",
-      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
+      "version": "6.16.2",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.16.2.tgz",
+      "integrity": "sha512-VYdnB5S7/0IeXzBacUtwNAaM6d7Y/PgYnNC7bJCI6meqA/OgnsQbZMtVW8Dt2D1PHgbHGtYmhSoEIgvt7xZ2ZA==",
       "license": "BSD-3-Clause",
       "dependencies": {
         "es-define-property": "^1.0.1",
@@ -1531,4 +1535,4 @@
       }
     }
   }
-}
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyla-home",
-  "version": "1.1.48",
+  "version": "1.1.56",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -16,42 +16,10 @@
     "@tauri-apps/plugin-process": "2.4.0",
     "@tauri-apps/plugin-shell": "2.5.0",
     "@vyla-entertainment/sdk": "^1.20.0",
-    "adm-zip": "^0.6.0",
-    "express": "^4.19.2"
+    "adm-zip": "^0.6.1",
+    "express": "^4.22.3"
   },
   "devDependencies": {
     "@tauri-apps/cli": "2.12.1"
-  },
-  "build": {
-    "appId": "com.vyla.home",
-    "productName": "Vyla Home",
-    "directories": {
-      "output": "dist"
-    },
-    "files": [
-      "main.js",
-      "preload.js",
-      "service-manager.js",
-      "patcher.js",
-      "crypto-utils.js",
-      "credential-manager.js",
-      "update-client.js",
-      "gitlab-client.js",
-      "config/**/*",
-      "build/icon.ico",
-      "build/logo.txt",
-      "package.json"
-    ],
-    "win": {
-      "target": "nsis",
-      "icon": "build/icon.ico"
-    },
-    "nsis": {
-      "oneClick": false,
-      "allowToChangeInstallationDirectory": true,
-      "installerIcon": "build/icon.ico",
-      "uninstallerIcon": "build/icon.ico",
-      "installerHeaderIcon": "build/icon.ico"
-    }
   }
-}
+}

patcher.js

@@ -4,6 +4,29 @@ const crypto = require('crypto');
 const AdmZip = require('adm-zip');
 const CryptoUtils = require('./crypto-utils');
 
+const COMPONENT_PROBES = {
+  frontend: 'frontend/server.js',
+  player: 'player/server.js',
+  config: 'config/env.json',
+  secrets: 'encrypted-credentials.json'
+};
+const COMMIT_ALLOWED = new Set(['frontend', 'player', 'config', 'encrypted-credentials.json']);
+
+function renameSafe(from, to) {
+  let last;
+  for (let i = 0; i < 6; i++) {
+    try {
+      fs.renameSync(from, to);
+      return;
+    } catch (e) {
+      last = e;
+      if (!['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY'].includes(e.code)) throw e;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250 * (i + 1));
+    }
+  }
+  throw last;
+}
+
 class Patcher {
   constructor(appDataPath) {
     this.appDataPath = appDataPath;
@@ -51,10 +74,103 @@ class Patcher {
     return true;
   }
 
-  saveCurrentVersion(version, sha256 = null) {
+  saveCurrentVersion(version, sha256 = null, components = null) {
     const versionFile = path.join(this.appDataPath, 'version.json');
     fs.mkdirSync(this.appDataPath, { recursive: true });
-    fs.writeFileSync(versionFile, JSON.stringify({ version, sha256 }, null, 2), 'utf8');
+    const tmp = `${versionFile}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ version, sha256, components: components || {} }, null, 2), 'utf8');
+    renameSafe(tmp, versionFile);
+  }
+
+  getCurrentComponents() {
+    try {
+      const c = JSON.parse(fs.readFileSync(path.join(this.appDataPath, 'version.json'), 'utf8')).components;
+      return c && typeof c === 'object' ? c : {};
+    } catch (e) {
+      return {};
+    }
+  }
+
+  integrityPath() {
+    return path.join(this.appDataPath, 'integrity.json');
+  }
+
+  readIntegrity() {
+    try {
+      return JSON.parse(fs.readFileSync(this.integrityPath(), 'utf8'));
+    } catch (e) {
+      return {};
+    }
+  }
+
+  writeIntegrity(names) {
+    const all = this.readIntegrity();
+    for (const name of names) {
+      if (name !== 'frontend' && name !== 'player') continue;
+      const files = {};
+      const walk = (dir, rel) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, entry.name);
+          const r = `${rel}/${entry.name}`;
+          if (r.includes('/node_modules/@vyla-entertainment/sdk')) continue;
+          if (entry.isDirectory()) walk(full, r);
+          else if (entry.isFile()) files[r] = fs.statSync(full).size;
+        }
+      };
+      walk(path.join(this.appDataPath, name), name);
+      all[name] = files;
+    }
+    const tmp = `${this.integrityPath()}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(all), 'utf8');
+    renameSafe(tmp, this.integrityPath());
+  }
+
+  integrityOk(name) {
+    const files = this.readIntegrity()[name];
+    if (!files) return true;
+    for (const [rel, size] of Object.entries(files)) {
+      try {
+        if (fs.statSync(path.join(this.appDataPath, rel)).size !== size) return false;
+      } catch (e) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  componentIntact(name) {
+    const probe = COMPONENT_PROBES[name];
+    if (!probe || name === 'secrets') return true;
+    try {
+      if (fs.statSync(path.join(this.appDataPath, probe)).size <= 0) return false;
+    } catch (e) {
+      return false;
+    }
+    return this.integrityOk(name);
+  }
+
+  staleComponents(release) {
+    const local = this.getCurrentComponents();
+    const names = Object.keys(release.components);
+    const stale = new Set(names.filter((n) => !this.componentIntact(n) || local[n] !== release.components[n].id));
+    if (stale.has('config')) {
+      for (const n of ['frontend', 'player']) {
+        if (release.components[n]) stale.add(n);
+      }
+    }
+    return [...stale];
+  }
+
+  verifyStaged(stagingDir, names) {
+    return names.every((name) => {
+      const probe = COMPONENT_PROBES[name];
+      if (!probe) return true;
+      try {
+        return fs.statSync(path.join(stagingDir, probe)).size > 0;
+      } catch (e) {
+        return false;
+      }
+    });
   }
 
   purgeOldCode() {
@@ -63,57 +179,51 @@ class Patcher {
       const fullPath = path.join(this.appDataPath, dir);
       if (fs.existsSync(fullPath)) {
         try {
-          const trashPath = path.join(this.appDataPath, `.trash_${dir}_${Date.now()}`);
-          fs.renameSync(fullPath, trashPath);
-          fs.rmSync(trashPath, { recursive: true, force: true });
-        } catch (e) {
-          try {
-            fs.rmSync(fullPath, { recursive: true, force: true });
-          } catch (err2) { }
-        }
+          fs.rmSync(fullPath, { recursive: true, force: true });
+        } catch (e) { }
       }
     }
-    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.');
+      throw new Error('Archive is empty, invalid, or truncated.');
+    }
+
+    const targetDir = path.resolve(this.appDataPath);
+    for (const entry of entries) {
+      const entryPath = path.normalize(entry.entryName);
+      const resolvedPath = path.resolve(targetDir, entryPath);
+      if (!resolvedPath.startsWith(targetDir)) {
+        throw new Error(`Directory traversal attempt detected in archive: ${entry.entryName}`);
+      }
     }
 
     zip.extractAllTo(this.appDataPath, true);
-
-    const testPath = path.join(this.appDataPath, 'frontend', 'index.html');
-    if (!fs.existsSync(testPath)) {
-      const { execSync } = require('child_process');
-      if (process.platform === 'win32') {
-        execSync(`powershell.exe -NoProfile -NonInteractive -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${this.appDataPath}' -Force"`, { windowsHide: true });
-      } else {
-        execSync(`unzip -o "${zipPath}" -d "${this.appDataPath}"`);
-      }
-    }
   }
 
-  async extractToStaging(zipPath, onFile) {
+  async extractToStaging(zipPath, onFile, keep = false) {
     const stagingDir = path.join(this.appDataPath, '.staging');
-    fs.rmSync(stagingDir, { recursive: true, force: true });
+    if (!keep) fs.rmSync(stagingDir, { recursive: true, force: true });
     fs.mkdirSync(stagingDir, { recursive: true });
     const zip = new AdmZip(zipPath);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     if (entries.length === 0) {
       throw new Error('Downloaded archive is empty, invalid, or truncated.');
     }
+
+    const resolvedStaging = path.resolve(stagingDir);
+    for (const entry of entries) {
+      const entryPath = path.normalize(entry.entryName);
+      const resolvedPath = path.resolve(resolvedStaging, entryPath);
+      if (!resolvedPath.startsWith(resolvedStaging + path.sep)) {
+        throw new Error(`Directory traversal attempt detected: ${entry.entryName}`);
+      }
+    }
+
     for (let i = 0; i < entries.length; i++) {
       const entry = entries[i];
       zip.extractEntryTo(entry, stagingDir, true, true);
@@ -123,23 +233,133 @@ class Patcher {
     return stagingDir;
   }
 
+  journalPath() {
+    return path.join(this.appDataPath, '.update-journal.json');
+  }
+
+  backupDir() {
+    return path.join(this.appDataPath, '.backup');
+  }
+
   commitStaging(stagingDir) {
-    this.purgeOldCode();
-    for (const name of fs.readdirSync(stagingDir)) {
-      const dest = path.join(this.appDataPath, name);
-      fs.rmSync(dest, { recursive: true, force: true });
-      fs.renameSync(path.join(stagingDir, name), dest);
+    const names = fs.readdirSync(stagingDir);
+    const unexpected = names.filter((n) => !COMMIT_ALLOWED.has(n));
+    if (unexpected.length > 0) {
+      throw new Error(`Unexpected top-level entries in update: ${unexpected.join(', ')}`);
+    }
+
+    const backup = this.backupDir();
+    fs.rmSync(backup, { recursive: true, force: true });
+    fs.mkdirSync(backup, { recursive: true });
+
+    const versionFile = path.join(this.appDataPath, 'version.json');
+    if (fs.existsSync(versionFile)) {
+      fs.copyFileSync(versionFile, path.join(backup, 'version.json.bak'));
+    }
+
+    const journal = { names, hadOld: {}, installed: [] };
+    for (const name of names) {
+      journal.hadOld[name] = fs.existsSync(path.join(this.appDataPath, name));
+    }
+    const save = () => {
+      const tmp = `${this.journalPath()}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(journal), 'utf8');
+      renameSafe(tmp, this.journalPath());
+    };
+    save();
+
+    try {
+      for (const name of names) {
+        const dest = path.join(this.appDataPath, name);
+        if (journal.hadOld[name]) {
+          renameSafe(dest, path.join(backup, name));
+        }
+        journal.installed.push(name);
+        save();
+        renameSafe(path.join(stagingDir, name), dest);
+      }
+    } catch (e) {
+      try { this.rollback(); } catch (x) { }
+      throw e;
     }
     fs.rmSync(stagingDir, { recursive: true, force: true });
   }
 
+  rollback() {
+    let journal;
+    try {
+      journal = JSON.parse(fs.readFileSync(this.journalPath(), 'utf8'));
+    } catch (e) {
+      return false;
+    }
+
+    const backup = this.backupDir();
+    const hadOld = journal.hadOld || {};
+    const installed = journal.installed || [];
+    for (const name of journal.names || []) {
+      const dest = path.join(this.appDataPath, name);
+      const saved = path.join(backup, name);
+      if (hadOld[name]) {
+        if (fs.existsSync(saved)) {
+          fs.rmSync(dest, { recursive: true, force: true });
+          renameSafe(saved, dest);
+        }
+      } else if (installed.includes(name)) {
+        fs.rmSync(dest, { recursive: true, force: true });
+      }
+    }
+
+    const versionFile = path.join(this.appDataPath, 'version.json');
+    const savedVersion = path.join(backup, 'version.json.bak');
+    if (fs.existsSync(savedVersion)) {
+      fs.copyFileSync(savedVersion, versionFile);
+    } else {
+      fs.rmSync(versionFile, { force: true });
+    }
+
+    fs.rmSync(backup, { recursive: true, force: true });
+    fs.rmSync(this.journalPath(), { force: true });
+    fs.rmSync(path.join(this.appDataPath, '.staging'), { recursive: true, force: true });
+    return true;
+  }
+
+  finalizeCommit() {
+    fs.rmSync(this.backupDir(), { recursive: true, force: true });
+    fs.rmSync(this.journalPath(), { force: true });
+    for (const dir of ['stream-api', 'auth-proxy']) {
+      fs.rmSync(path.join(this.appDataPath, dir), { recursive: true, force: true });
+    }
+  }
+
+  recoverInterrupted() {
+    const had = fs.existsSync(this.journalPath());
+    if (had && !this.rollback()) {
+      fs.rmSync(this.journalPath(), { force: true });
+      fs.rmSync(this.backupDir(), { recursive: true, force: true });
+    }
+    fs.rmSync(path.join(this.appDataPath, '.staging'), { recursive: true, force: true });
+    try {
+      for (const f of fs.readdirSync(this.appDataPath)) {
+        if (/^download-.*\.zip$/.test(f)) fs.rmSync(path.join(this.appDataPath, f), { force: true });
+      }
+    } catch (e) { }
+    return had;
+  }
+
   verifyChecksum(zipPath, expectedSha256) {
     if (!expectedSha256) return false;
     const hash = crypto.createHash('sha256');
-    const data = fs.readFileSync(zipPath);
-    hash.update(data);
-    const calculated = hash.digest('hex');
-    return calculated === String(expectedSha256).trim().toLowerCase();
+    const fd = fs.openSync(zipPath, 'r');
+    const buf = Buffer.alloc(1024 * 1024);
+    try {
+      let n;
+      while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0) {
+        hash.update(buf.subarray(0, n));
+      }
+    } finally {
+      fs.closeSync(fd);
+    }
+    return hash.digest('hex') === String(expectedSha256).trim().toLowerCase();
   }
 
   verifyExtraction(root = this.appDataPath) {
@@ -183,7 +403,6 @@ class Patcher {
         if (file === 'node_modules' || file === '.git') continue;
         this.processDirectory(fullPath, replacementList);
       } else if (stat.isFile()) {
-        const ext = path.extname(fullPath).toLowerCase();
         let content = fs.readFileSync(fullPath, 'utf8');
         let modified = false;
 
@@ -201,8 +420,8 @@ class Patcher {
     }
   }
 
-  applyPatches(replacements) {
-    const targetDirs = ['frontend', 'player'];
+  applyPatches(replacements, only = null) {
+    const targetDirs = ['frontend', 'player'].filter((d) => !only || only.includes(d));
     for (const dirName of targetDirs) {
       const dirPath = path.join(this.appDataPath, dirName);
       if (!fs.existsSync(dirPath)) continue;
@@ -212,4 +431,4 @@ class Patcher {
   }
 }
 
-module.exports = Patcher;
+module.exports = Patcher;

preload.js

@@ -1,5 +0,0 @@
-const { contextBridge, ipcRenderer } = require('electron');
-
-contextBridge.exposeInMainWorld('vylaHome', {
-  sendUpdateChoice: (choice) => ipcRenderer.send('update-choice', choice)
-});

release.js

@@ -2,6 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 const { execSync } = require('child_process');
+const crypto = require('crypto');
+const UpdateClient = require('./update-client');
 
 const GITLAB_PROJECT_PATH = 'vyla-entertainment%2Fhome';
 const PROJECT_ID = process.env.CI_PROJECT_ID || GITLAB_PROJECT_PATH;
@@ -165,7 +167,7 @@ async function main() {
     console.log(`Building Vyla Home Release (${version})`);
 
     console.log('[1/4] Building update payload and manifest...');
-    execSync('node build-pipeline.js', { stdio: 'inherit' });
+    execSync('node build-pipeline.js', { stdio: 'inherit', env: { ...process.env, RELEASE_VERSION: version } });
 
     const payloadPath = path.join(__dirname, 'update-payload.zip');
     const manifestPath = path.join(__dirname, 'manifest.json');
@@ -217,12 +219,44 @@ async function main() {
         }
     }
 
+    if (installerPath && installerUploadName && process.platform === 'win32') {
+        const signingKey = process.env.VYLA_UPDATE_SIGNING_KEY;
+        if (!signingKey) {
+            throw new Error('VYLA_UPDATE_SIGNING_KEY is required to sign the installer entry.');
+        }
+        const installerBuf = fs.readFileSync(installerPath);
+        const signedManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        signedManifest.installer = {
+            file: installerUploadName,
+            sha256: crypto.createHash('sha256').update(installerBuf).digest('hex'),
+            size: installerBuf.length,
+            version: version.replace(/^v/, '')
+        };
+        delete signedManifest.signature;
+        signedManifest.signature = crypto.sign(null, Buffer.from(UpdateClient.canonicalManifest(signedManifest)), signingKey.replace(/\\n/g, '\n')).toString('base64');
+        fs.writeFileSync(manifestPath, JSON.stringify(signedManifest, null, 2), 'utf8');
+    }
+
     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-${timestamp}.zip`);
 
+    const manifestData = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    for (const [name, c] of Object.entries(manifestData.components || {})) {
+        console.log(`Uploading ${c.file}...`);
+        c.url = await uploadFileToGitLabPackage(path.join(__dirname, 'release-assets', c.file), 'vyla-home', version, `${name}-${timestamp}.zip`);
+    }
+
+    const signingKeyPem = process.env.VYLA_UPDATE_SIGNING_KEY;
+    if (!signingKeyPem) {
+        throw new Error('VYLA_UPDATE_SIGNING_KEY is required to sign the update manifest.');
+    }
+    delete manifestData.signature;
+    manifestData.signature = crypto.sign(null, Buffer.from(UpdateClient.canonicalManifest(manifestData)), signingKeyPem.replace(/\\n/g, '\n')).toString('base64');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifestData, null, 2), 'utf8');
+
     console.log('Uploading manifest.json...');
     const manifestUrl = await uploadFileToGitLabPackage(manifestPath, 'vyla-home', version, `manifest-${timestamp}.json`);
 

service-manager.js

@@ -54,6 +54,9 @@ class ServiceManager {
 
     const env = {
       ...process.env,
+      ...(process.platform === 'darwin'
+        ? { PATH: [process.env.PATH, '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'].filter(Boolean).join(path.delimiter) }
+        : {}),
       PORT: (this.envConfig[name] && this.envConfig[name].PORT) || defaultPorts[name] || process.env.PORT || 3000,
       TOKEN_SECRET: tokenSecret,
       ...(this.envConfig[name] || {}),
@@ -93,25 +96,6 @@ 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) => {
@@ -144,7 +128,7 @@ class ServiceManager {
     ));
   }
 
-  async stopAll() {
+  stopAll() {
     this.isStopping = true;
     for (const name of Object.keys(this.stableTimers)) {
       if (this.stableTimers[name]) {
@@ -152,20 +136,14 @@ class ServiceManager {
       }
     }
     this.stableTimers = {};
-    const killPromises = Object.keys(this.processes).map((name) => {
+    for (const name of Object.keys(this.processes)) {
       const procInfo = this.processes[name];
       if (procInfo && procInfo.child) {
-        this.logToFile(name, `Killing service`);
-        return new Promise((resolve) => {
-          procInfo.child.removeAllListeners('exit');
-          procInfo.child.on('exit', () => resolve());
-          procInfo.child.kill();
-        });
+        try {
+          procInfo.child.kill('SIGTERM');
+        } catch (e) { }
       }
-      return Promise.resolve();
-    });
-
-    await Promise.all(killPromises);
+    }
     this.processes = {};
   }
 
@@ -203,4 +181,4 @@ class ServiceManager {
   }
 }
 
-module.exports = ServiceManager;
+module.exports = ServiceManager;

src-tauri/Cargo.lock

@@ -861,15 +861,6 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 
-[[package]]
-name = "encoding_rs"
-version = "0.8.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
-dependencies = [
- "cfg-if",
-]
-
 [[package]]
 name = "endi"
 version = "1.1.1"
@@ -2383,16 +2374,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "os_pipe"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
-dependencies = [
- "libc",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "pango"
 version = "0.18.3"
@@ -3118,16 +3099,6 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "shared_child"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e362d9935bc50f019969e2f9ecd66786612daae13e8f277be7bfb66e8bed3f7"
-dependencies = [
- "libc",
- "windows-sys 0.60.2",
-]
-
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -3546,39 +3517,6 @@ dependencies = [
  "zbus",
 ]
 
-[[package]]
-name = "tauri-plugin-process"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74ae3d8549ae564c0397377373e262f340908eb23a5b9fbe03f2a00007dc0038"
-dependencies = [
- "tauri",
- "tauri-plugin",
-]
-
-[[package]]
-name = "tauri-plugin-shell"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8567d42b2c7264355daa1df415ec77f52aa42e885924c86a969be2e920e05521"
-dependencies = [
- "encoding_rs",
- "libc",
- "log",
- "open",
- "os_pipe",
- "regex",
- "schemars 0.8.22",
- "serde",
- "serde_json",
- "shared_child",
- "tauri",
- "tauri-plugin",
- "thiserror 2.0.20",
- "tokio",
- "windows-sys 0.60.2",
-]
-
 [[package]]
 name = "tauri-runtime"
 version = "2.12.1"
@@ -4135,17 +4073,16 @@ dependencies = [
 
 [[package]]
 name = "vyla-home"
-version = "1.1.48"
+version = "1.1.56"
 dependencies = [
- "base64 0.22.1",
+ "libc",
  "objc2 0.5.2",
  "serde",
  "serde_json",
  "tauri",
  "tauri-build",
  "tauri-plugin-opener",
- "tauri-plugin-process",
- "tauri-plugin-shell",
+ "window-vibrancy",
 ]
 
 [[package]]
@@ -4526,15 +4463,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -4568,30 +4496,13 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
+ "windows_i686_gnullvm",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.1",
- "windows_aarch64_msvc 0.53.1",
- "windows_i686_gnu 0.53.1",
- "windows_i686_gnullvm 0.53.1",
- "windows_i686_msvc 0.53.1",
- "windows_x86_64_gnu 0.53.1",
- "windows_x86_64_gnullvm 0.53.1",
- "windows_x86_64_msvc 0.53.1",
-]
-
 [[package]]
 name = "windows-threading"
 version = "0.2.1"
@@ -4622,12 +4533,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
@@ -4640,12 +4545,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
@@ -4658,24 +4557,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
@@ -4688,12 +4575,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
@@ -4706,12 +4587,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
@@ -4724,12 +4599,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
@@ -4742,12 +4611,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winnow"
 version = "0.5.40"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vyla-home"
-version = "1.1.48"
+version = "1.1.56"
 description = "Vyla Home Desktop App Launcher"
 edition = "2021"
 
@@ -8,17 +8,18 @@ edition = "2021"
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = ["devtools"] }
+tauri = { version = "2", features = [] }
 tauri-plugin-opener = "2"
-tauri-plugin-process = "2"
-tauri-plugin-shell = "2.5"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-base64 = "0.22"
+window-vibrancy = "0.8"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = "0.5"
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 [profile.release]
 opt-level = 3
 lto = true
@@ -29,4 +30,4 @@ panic = "abort"
 [profile.dev]
 opt-level = 0
 debug = true
-incremental = true
+incremental = true

src-tauri/Info.plist

@@ -8,6 +8,8 @@
     <true/>
     <key>NSAllowsArbitraryLoads</key>
     <true/>
+    <key>NSAllowsArbitraryLoadsInWebContent</key>
+    <true/>
   </dict>
 </dict>
 </plist>

src-tauri/build.rs

@@ -1,6 +1,19 @@
 fn main() {
     println!("cargo:rerun-if-changed=src/main.rs");
     println!("cargo:rerun-if-changed=tauri.conf.json");
+    println!("cargo:rerun-if-changed=capabilities");
+    for f in [
+        "main.js",
+        "service-manager.js",
+        "file-updater.js",
+        "patcher.js",
+        "crypto-utils.js",
+        "credential-manager.js",
+        "update-client.js",
+    ] {
+        println!("cargo:rerun-if-changed=../{}", f);
+    }
+    println!("cargo:rerun-if-changed=../config");
     
     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")) {
@@ -28,5 +41,16 @@ fn main() {
         }
     }
     
-    tauri_build::build();
+    tauri_build::try_build(
+        tauri_build::Attributes::new().app_manifest(
+            tauri_build::AppManifest::new().commands(&[
+                "win_minimize",
+                "win_maximize",
+                "win_close",
+                "win_drag",
+                "open_new_window",
+            ]),
+        ),
+    )
+    .expect("failed to run tauri-build");
 }

src-tauri/capabilities/default.json

@@ -1,40 +1,42 @@
 {
     "$schema": "../gen/schemas/desktop-schema.json",
     "identifier": "default",
-    "description": "Default permissions for Vyla Home main window and popups",
+    "description": "Window and opener permissions for local and localhost-served pages",
+    "local": true,
     "windows": [
-        "main",
-        "win_*"
+        "*"
+    ],
+    "webviews": [
+        "*"
     ],
     "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/*"
+            "http://localhost:*",
+            "http://localhost:*/*",
+            "http://127.0.0.1:*",
+            "http://127.0.0.1:*/*"
         ]
     },
     "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"
+        "allow-open-new-window",
+        "core:default",
+        "core:window:allow-start-dragging",
+        "core:window:allow-minimize",
+        "core:window:allow-maximize",
+        "core:window:allow-unmaximize",
+        "core:window:allow-toggle-maximize",
+        "core:window:allow-close",
+        "core:window:allow-destroy",
+        "core:window:allow-is-maximized",
+        "core:window:allow-is-fullscreen",
+        "core:window:allow-set-fullscreen",
+        "core:window:allow-set-focus",
+        "core:window:allow-show",
+        "core:window:allow-hide",
+        "opener:default"
     ]
 }

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"]}}
+{"default":{"identifier":"default","description":"Window and opener permissions for local and localhost-served pages","remote":{"urls":["http://localhost:*","http://localhost:*/*","http://127.0.0.1:*","http://127.0.0.1:*/*"]},"local":true,"windows":["*"],"webviews":["*"],"permissions":["allow-win-minimize","allow-win-maximize","allow-win-close","allow-win-drag","allow-open-new-window","core:default","core:window:allow-start-dragging","core:window:allow-minimize","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-toggle-maximize","core:window:allow-close","core:window:allow-destroy","core:window:allow-is-maximized","core:window:allow-is-fullscreen","core:window:allow-set-fullscreen","core:window:allow-set-focus","core:window:allow-show","core:window:allow-hide","opener:default"]}}

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

@@ -302,216 +302,6 @@
                 }
               }
             },
-            {
-              "if": {
-                "properties": {
-                  "identifier": {
-                    "anyOf": [
-                      {
-                        "description": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`",
-                        "type": "string",
-                        "const": "shell:default",
-                        "markdownDescription": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`"
-                      },
-                      {
-                        "description": "Enables the execute command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-execute",
-                        "markdownDescription": "Enables the execute command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the kill command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-kill",
-                        "markdownDescription": "Enables the kill command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the open command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-open",
-                        "markdownDescription": "Enables the open command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the spawn command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-spawn",
-                        "markdownDescription": "Enables the spawn command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the stdin_write command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-stdin-write",
-                        "markdownDescription": "Enables the stdin_write command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the execute command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-execute",
-                        "markdownDescription": "Denies the execute command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the kill command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-kill",
-                        "markdownDescription": "Denies the kill command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the open command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-open",
-                        "markdownDescription": "Denies the open command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the spawn command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-spawn",
-                        "markdownDescription": "Denies the spawn command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the stdin_write command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-stdin-write",
-                        "markdownDescription": "Denies the stdin_write command without any pre-configured scope."
-                      }
-                    ]
-                  }
-                }
-              },
-              "then": {
-                "properties": {
-                  "allow": {
-                    "items": {
-                      "title": "ShellScopeEntry",
-                      "description": "Shell scope entry.",
-                      "anyOf": [
-                        {
-                          "type": "object",
-                          "required": [
-                            "cmd",
-                            "name"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "cmd": {
-                              "description": "The command name. It can start with a variable that resolves to a system base directory. The variables are: `$AUDIO`, `$CACHE`, `$CONFIG`, `$DATA`, `$LOCALDATA`, `$DESKTOP`, `$DOCUMENT`, `$DOWNLOAD`, `$EXE`, `$FONT`, `$HOME`, `$PICTURE`, `$PUBLIC`, `$RUNTIME`, `$TEMPLATE`, `$VIDEO`, `$RESOURCE`, `$LOG`, `$TEMP`, `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`.",
-                              "type": "string"
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            }
-                          },
-                          "additionalProperties": false
-                        },
-                        {
-                          "type": "object",
-                          "required": [
-                            "name",
-                            "sidecar"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            },
-                            "sidecar": {
-                              "description": "If this command is a sidecar command.",
-                              "type": "boolean"
-                            }
-                          },
-                          "additionalProperties": false
-                        }
-                      ]
-                    }
-                  },
-                  "deny": {
-                    "items": {
-                      "title": "ShellScopeEntry",
-                      "description": "Shell scope entry.",
-                      "anyOf": [
-                        {
-                          "type": "object",
-                          "required": [
-                            "cmd",
-                            "name"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "cmd": {
-                              "description": "The command name. It can start with a variable that resolves to a system base directory. The variables are: `$AUDIO`, `$CACHE`, `$CONFIG`, `$DATA`, `$LOCALDATA`, `$DESKTOP`, `$DOCUMENT`, `$DOWNLOAD`, `$EXE`, `$FONT`, `$HOME`, `$PICTURE`, `$PUBLIC`, `$RUNTIME`, `$TEMPLATE`, `$VIDEO`, `$RESOURCE`, `$LOG`, `$TEMP`, `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`.",
-                              "type": "string"
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            }
-                          },
-                          "additionalProperties": false
-                        },
-                        {
-                          "type": "object",
-                          "required": [
-                            "name",
-                            "sidecar"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            },
-                            "sidecar": {
-                              "description": "If this command is a sidecar command.",
-                              "type": "boolean"
-                            }
-                          },
-                          "additionalProperties": false
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "properties": {
-                "identifier": {
-                  "description": "Identifier of the permission or permission set.",
-                  "allOf": [
-                    {
-                      "$ref": "#/definitions/Identifier"
-                    }
-                  ]
-                }
-              }
-            },
             {
               "properties": {
                 "identifier": {
@@ -590,6 +380,36 @@
           "const": "allow-win-minimize",
           "markdownDescription": "Allows minimizing the window"
         },
+        {
+          "description": "Denies the open_new_window command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-open-new-window",
+          "markdownDescription": "Denies the open_new_window command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_close command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-close",
+          "markdownDescription": "Denies the win_close command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-drag",
+          "markdownDescription": "Denies the win_drag command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-maximize",
+          "markdownDescription": "Denies the win_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_minimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-minimize",
+          "markdownDescription": "Denies the win_minimize command without any pre-configured scope."
+        },
         {
           "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",
@@ -2677,102 +2497,6 @@
           "type": "string",
           "const": "opener:deny-reveal-item-in-dir",
           "markdownDescription": "Denies the reveal_item_in_dir command without any pre-configured scope."
-        },
-        {
-          "description": "This permission set configures which\nprocess features are by default exposed.\n\n#### Granted Permissions\n\nThis enables to quit via `allow-exit` and restart via `allow-restart`\nthe application.\n\n#### This default permission set includes:\n\n- `allow-exit`\n- `allow-restart`",
-          "type": "string",
-          "const": "process:default",
-          "markdownDescription": "This permission set configures which\nprocess features are by default exposed.\n\n#### Granted Permissions\n\nThis enables to quit via `allow-exit` and restart via `allow-restart`\nthe application.\n\n#### This default permission set includes:\n\n- `allow-exit`\n- `allow-restart`"
-        },
-        {
-          "description": "Enables the exit command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:allow-exit",
-          "markdownDescription": "Enables the exit command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the restart command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:allow-restart",
-          "markdownDescription": "Enables the restart command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the exit command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:deny-exit",
-          "markdownDescription": "Denies the exit command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the restart command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:deny-restart",
-          "markdownDescription": "Denies the restart command without any pre-configured scope."
-        },
-        {
-          "description": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`",
-          "type": "string",
-          "const": "shell:default",
-          "markdownDescription": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`"
-        },
-        {
-          "description": "Enables the execute command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-execute",
-          "markdownDescription": "Enables the execute command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the kill command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-kill",
-          "markdownDescription": "Enables the kill command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the open command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-open",
-          "markdownDescription": "Enables the open command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the spawn command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-spawn",
-          "markdownDescription": "Enables the spawn command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the stdin_write command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-stdin-write",
-          "markdownDescription": "Enables the stdin_write command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the execute command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-execute",
-          "markdownDescription": "Denies the execute command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the kill command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-kill",
-          "markdownDescription": "Denies the kill command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the open command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-open",
-          "markdownDescription": "Denies the open command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the spawn command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-spawn",
-          "markdownDescription": "Denies the spawn command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the stdin_write command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-stdin-write",
-          "markdownDescription": "Denies the stdin_write command without any pre-configured scope."
         }
       ]
     },
@@ -2886,50 +2610,6 @@
           "type": "string"
         }
       ]
-    },
-    "ShellScopeEntryAllowedArg": {
-      "description": "A command argument allowed to be executed by the webview API.",
-      "anyOf": [
-        {
-          "description": "A non-configurable argument that is passed to the command in the order it was specified.",
-          "type": "string"
-        },
-        {
-          "description": "A variable that is set while calling the command from the webview API.",
-          "type": "object",
-          "required": [
-            "validator"
-          ],
-          "properties": {
-            "raw": {
-              "description": "Marks the validator as a raw regex, meaning the plugin should not make any modification at runtime.\n\nThis means the regex will not match on the entire string by default, which might be exploited if your regex allow unexpected input to be considered valid. When using this option, make sure your regex is correct.",
-              "default": false,
-              "type": "boolean"
-            },
-            "validator": {
-              "description": "[regex] validator to require passed values to conform to an expected input.\n\nThis will require the argument value passed to this variable to match the `validator` regex before it will be executed.\n\nThe regex string is by default surrounded by `^...$` to match the full string. For example the `https?://\\w+` regex would be registered as `^https?://\\w+$`.\n\n[regex]: <https://docs.rs/regex/latest/regex/#syntax>",
-              "type": "string"
-            }
-          },
-          "additionalProperties": false
-        }
-      ]
-    },
-    "ShellScopeEntryAllowedArgs": {
-      "description": "A set of command arguments allowed to be executed by the webview API.\n\nA value of `true` will allow any arguments to be passed to the command. `false` will disable all arguments. A list of [`ShellScopeEntryAllowedArg`] will set those arguments as the only valid arguments to be passed to the attached command configuration.",
-      "anyOf": [
-        {
-          "description": "Use a simple boolean to allow all or disable all arguments to this command configuration.",
-          "type": "boolean"
-        },
-        {
-          "description": "A specific set of [`ShellScopeEntryAllowedArg`] that are valid to call for the command configuration.",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/ShellScopeEntryAllowedArg"
-          }
-        }
-      ]
     }
   }
 }

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

@@ -302,216 +302,6 @@
                 }
               }
             },
-            {
-              "if": {
-                "properties": {
-                  "identifier": {
-                    "anyOf": [
-                      {
-                        "description": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`",
-                        "type": "string",
-                        "const": "shell:default",
-                        "markdownDescription": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`"
-                      },
-                      {
-                        "description": "Enables the execute command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-execute",
-                        "markdownDescription": "Enables the execute command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the kill command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-kill",
-                        "markdownDescription": "Enables the kill command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the open command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-open",
-                        "markdownDescription": "Enables the open command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the spawn command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-spawn",
-                        "markdownDescription": "Enables the spawn command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Enables the stdin_write command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:allow-stdin-write",
-                        "markdownDescription": "Enables the stdin_write command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the execute command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-execute",
-                        "markdownDescription": "Denies the execute command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the kill command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-kill",
-                        "markdownDescription": "Denies the kill command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the open command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-open",
-                        "markdownDescription": "Denies the open command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the spawn command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-spawn",
-                        "markdownDescription": "Denies the spawn command without any pre-configured scope."
-                      },
-                      {
-                        "description": "Denies the stdin_write command without any pre-configured scope.",
-                        "type": "string",
-                        "const": "shell:deny-stdin-write",
-                        "markdownDescription": "Denies the stdin_write command without any pre-configured scope."
-                      }
-                    ]
-                  }
-                }
-              },
-              "then": {
-                "properties": {
-                  "allow": {
-                    "items": {
-                      "title": "ShellScopeEntry",
-                      "description": "Shell scope entry.",
-                      "anyOf": [
-                        {
-                          "type": "object",
-                          "required": [
-                            "cmd",
-                            "name"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "cmd": {
-                              "description": "The command name. It can start with a variable that resolves to a system base directory. The variables are: `$AUDIO`, `$CACHE`, `$CONFIG`, `$DATA`, `$LOCALDATA`, `$DESKTOP`, `$DOCUMENT`, `$DOWNLOAD`, `$EXE`, `$FONT`, `$HOME`, `$PICTURE`, `$PUBLIC`, `$RUNTIME`, `$TEMPLATE`, `$VIDEO`, `$RESOURCE`, `$LOG`, `$TEMP`, `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`.",
-                              "type": "string"
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            }
-                          },
-                          "additionalProperties": false
-                        },
-                        {
-                          "type": "object",
-                          "required": [
-                            "name",
-                            "sidecar"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            },
-                            "sidecar": {
-                              "description": "If this command is a sidecar command.",
-                              "type": "boolean"
-                            }
-                          },
-                          "additionalProperties": false
-                        }
-                      ]
-                    }
-                  },
-                  "deny": {
-                    "items": {
-                      "title": "ShellScopeEntry",
-                      "description": "Shell scope entry.",
-                      "anyOf": [
-                        {
-                          "type": "object",
-                          "required": [
-                            "cmd",
-                            "name"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "cmd": {
-                              "description": "The command name. It can start with a variable that resolves to a system base directory. The variables are: `$AUDIO`, `$CACHE`, `$CONFIG`, `$DATA`, `$LOCALDATA`, `$DESKTOP`, `$DOCUMENT`, `$DOWNLOAD`, `$EXE`, `$FONT`, `$HOME`, `$PICTURE`, `$PUBLIC`, `$RUNTIME`, `$TEMPLATE`, `$VIDEO`, `$RESOURCE`, `$LOG`, `$TEMP`, `$APPCONFIG`, `$APPDATA`, `$APPLOCALDATA`, `$APPCACHE`, `$APPLOG`.",
-                              "type": "string"
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            }
-                          },
-                          "additionalProperties": false
-                        },
-                        {
-                          "type": "object",
-                          "required": [
-                            "name",
-                            "sidecar"
-                          ],
-                          "properties": {
-                            "args": {
-                              "description": "The allowed arguments for the command execution.",
-                              "allOf": [
-                                {
-                                  "$ref": "#/definitions/ShellScopeEntryAllowedArgs"
-                                }
-                              ]
-                            },
-                            "name": {
-                              "description": "The name for this allowed shell command configuration.\n\nThis name will be used inside of the webview API to call this command along with any specified arguments.",
-                              "type": "string"
-                            },
-                            "sidecar": {
-                              "description": "If this command is a sidecar command.",
-                              "type": "boolean"
-                            }
-                          },
-                          "additionalProperties": false
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "properties": {
-                "identifier": {
-                  "description": "Identifier of the permission or permission set.",
-                  "allOf": [
-                    {
-                      "$ref": "#/definitions/Identifier"
-                    }
-                  ]
-                }
-              }
-            },
             {
               "properties": {
                 "identifier": {
@@ -590,6 +380,36 @@
           "const": "allow-win-minimize",
           "markdownDescription": "Allows minimizing the window"
         },
+        {
+          "description": "Denies the open_new_window command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-open-new-window",
+          "markdownDescription": "Denies the open_new_window command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_close command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-close",
+          "markdownDescription": "Denies the win_close command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-drag",
+          "markdownDescription": "Denies the win_drag command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-maximize",
+          "markdownDescription": "Denies the win_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the win_minimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-win-minimize",
+          "markdownDescription": "Denies the win_minimize command without any pre-configured scope."
+        },
         {
           "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",
@@ -2677,102 +2497,6 @@
           "type": "string",
           "const": "opener:deny-reveal-item-in-dir",
           "markdownDescription": "Denies the reveal_item_in_dir command without any pre-configured scope."
-        },
-        {
-          "description": "This permission set configures which\nprocess features are by default exposed.\n\n#### Granted Permissions\n\nThis enables to quit via `allow-exit` and restart via `allow-restart`\nthe application.\n\n#### This default permission set includes:\n\n- `allow-exit`\n- `allow-restart`",
-          "type": "string",
-          "const": "process:default",
-          "markdownDescription": "This permission set configures which\nprocess features are by default exposed.\n\n#### Granted Permissions\n\nThis enables to quit via `allow-exit` and restart via `allow-restart`\nthe application.\n\n#### This default permission set includes:\n\n- `allow-exit`\n- `allow-restart`"
-        },
-        {
-          "description": "Enables the exit command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:allow-exit",
-          "markdownDescription": "Enables the exit command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the restart command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:allow-restart",
-          "markdownDescription": "Enables the restart command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the exit command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:deny-exit",
-          "markdownDescription": "Denies the exit command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the restart command without any pre-configured scope.",
-          "type": "string",
-          "const": "process:deny-restart",
-          "markdownDescription": "Denies the restart command without any pre-configured scope."
-        },
-        {
-          "description": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`",
-          "type": "string",
-          "const": "shell:default",
-          "markdownDescription": "This permission set configures which\nshell functionality is exposed by default.\n\n#### Granted Permissions\n\nIt allows to use the `open` functionality with a reasonable\nscope pre-configured. It will allow opening `http(s)://`,\n`tel:` and `mailto:` links.\n\n#### This default permission set includes:\n\n- `allow-open`"
-        },
-        {
-          "description": "Enables the execute command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-execute",
-          "markdownDescription": "Enables the execute command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the kill command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-kill",
-          "markdownDescription": "Enables the kill command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the open command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-open",
-          "markdownDescription": "Enables the open command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the spawn command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-spawn",
-          "markdownDescription": "Enables the spawn command without any pre-configured scope."
-        },
-        {
-          "description": "Enables the stdin_write command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:allow-stdin-write",
-          "markdownDescription": "Enables the stdin_write command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the execute command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-execute",
-          "markdownDescription": "Denies the execute command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the kill command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-kill",
-          "markdownDescription": "Denies the kill command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the open command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-open",
-          "markdownDescription": "Denies the open command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the spawn command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-spawn",
-          "markdownDescription": "Denies the spawn command without any pre-configured scope."
-        },
-        {
-          "description": "Denies the stdin_write command without any pre-configured scope.",
-          "type": "string",
-          "const": "shell:deny-stdin-write",
-          "markdownDescription": "Denies the stdin_write command without any pre-configured scope."
         }
       ]
     },
@@ -2886,50 +2610,6 @@
           "type": "string"
         }
       ]
-    },
-    "ShellScopeEntryAllowedArg": {
-      "description": "A command argument allowed to be executed by the webview API.",
-      "anyOf": [
-        {
-          "description": "A non-configurable argument that is passed to the command in the order it was specified.",
-          "type": "string"
-        },
-        {
-          "description": "A variable that is set while calling the command from the webview API.",
-          "type": "object",
-          "required": [
-            "validator"
-          ],
-          "properties": {
-            "raw": {
-              "description": "Marks the validator as a raw regex, meaning the plugin should not make any modification at runtime.\n\nThis means the regex will not match on the entire string by default, which might be exploited if your regex allow unexpected input to be considered valid. When using this option, make sure your regex is correct.",
-              "default": false,
-              "type": "boolean"
-            },
-            "validator": {
-              "description": "[regex] validator to require passed values to conform to an expected input.\n\nThis will require the argument value passed to this variable to match the `validator` regex before it will be executed.\n\nThe regex string is by default surrounded by `^...$` to match the full string. For example the `https?://\\w+` regex would be registered as `^https?://\\w+$`.\n\n[regex]: <https://docs.rs/regex/latest/regex/#syntax>",
-              "type": "string"
-            }
-          },
-          "additionalProperties": false
-        }
-      ]
-    },
-    "ShellScopeEntryAllowedArgs": {
-      "description": "A set of command arguments allowed to be executed by the webview API.\n\nA value of `true` will allow any arguments to be passed to the command. `false` will disable all arguments. A list of [`ShellScopeEntryAllowedArg`] will set those arguments as the only valid arguments to be passed to the attached command configuration.",
-      "anyOf": [
-        {
-          "description": "Use a simple boolean to allow all or disable all arguments to this command configuration.",
-          "type": "boolean"
-        },
-        {
-          "description": "A specific set of [`ShellScopeEntryAllowedArg`] that are valid to call for the command configuration.",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/ShellScopeEntryAllowedArg"
-          }
-        }
-      ]
     }
   }
 }

src-tauri/permissions/autogenerated/open_new_window.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-open-new-window"
+description = "Enables the open_new_window command without any pre-configured scope."
+commands.allow = ["open_new_window"]
+
+[[permission]]
+identifier = "deny-open-new-window"
+description = "Denies the open_new_window command without any pre-configured scope."
+commands.deny = ["open_new_window"]

src-tauri/permissions/autogenerated/win_close.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-win-close"
+description = "Enables the win_close command without any pre-configured scope."
+commands.allow = ["win_close"]
+
+[[permission]]
+identifier = "deny-win-close"
+description = "Denies the win_close command without any pre-configured scope."
+commands.deny = ["win_close"]

src-tauri/permissions/autogenerated/win_drag.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-win-drag"
+description = "Enables the win_drag command without any pre-configured scope."
+commands.allow = ["win_drag"]
+
+[[permission]]
+identifier = "deny-win-drag"
+description = "Denies the win_drag command without any pre-configured scope."
+commands.deny = ["win_drag"]

src-tauri/permissions/autogenerated/win_maximize.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-win-maximize"
+description = "Enables the win_maximize command without any pre-configured scope."
+commands.allow = ["win_maximize"]
+
+[[permission]]
+identifier = "deny-win-maximize"
+description = "Denies the win_maximize command without any pre-configured scope."
+commands.deny = ["win_maximize"]

src-tauri/permissions/autogenerated/win_minimize.toml

@@ -0,0 +1,11 @@
+# Automatically generated - DO NOT EDIT!
+
+[[permission]]
+identifier = "allow-win-minimize"
+description = "Enables the win_minimize command without any pre-configured scope."
+commands.allow = ["win_minimize"]
+
+[[permission]]
+identifier = "deny-win-minimize"
+description = "Denies the win_minimize command without any pre-configured scope."
+commands.deny = ["win_minimize"]

src-tauri/permissions/default.toml

@@ -3,27 +3,32 @@
 [[permission]]
 identifier = "allow-win-minimize"
 description = "Allows minimizing the window"
-commands.allow = ["win_minimize"]
+[[permission.allow]]
+cmd = "win_minimize"
 
 [[permission]]
 identifier = "allow-win-maximize"
 description = "Allows maximizing/unmaximizing the window"
-commands.allow = ["win_maximize"]
+[[permission.allow]]
+cmd = "win_maximize"
 
 [[permission]]
 identifier = "allow-win-close"
 description = "Allows closing the window"
-commands.allow = ["win_close"]
+[[permission.allow]]
+cmd = "win_close"
 
 [[permission]]
 identifier = "allow-win-drag"
 description = "Allows dragging the window"
-commands.allow = ["win_drag"]
+[[permission.allow]]
+cmd = "win_drag"
 
 [[permission]]
 identifier = "allow-open-new-window"
 description = "Allows opening a new webview window"
-commands.allow = ["open_new_window"]
+[[permission.allow]]
+cmd = "open_new_window"
 
 [[set]]
 identifier = "default"
@@ -34,4 +39,4 @@ permissions = [
     "allow-win-close",
     "allow-win-drag",
     "allow-open-new-window"
-]
+]

src-tauri/src/main.rs

@@ -2,8 +2,9 @@
 
 use std::path::PathBuf;
 use std::process::{Child, Command, Stdio};
-use std::sync::Mutex;
-use tauri::{Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder};
+use std::sync::{Arc, Mutex};
+use tauri::webview::NewWindowResponse;
+use tauri::{AppHandle, Emitter, Manager, State, WebviewUrl, WebviewWindowBuilder};
 
 fn debug_log(msg: &str) {
     let log_dir = if let Ok(app_data) = std::env::var("APPDATA") {
@@ -11,8 +12,8 @@ fn debug_log(msg: &str) {
             .join("vyla-home")
             .join("vyla-home-files")
             .join("logs")
-    } else if let Ok(home) = std::env::var("HOME") {
-        std::path::PathBuf::from(home)
+    } else if let Ok(_home) = std::env::var("HOME") {
+        std::path::PathBuf::from(_home)
             .join("Library")
             .join("Logs")
             .join("VylaHome")
@@ -39,15 +40,46 @@ fn debug_log(msg: &str) {
 
 struct NodeServices(Mutex<Option<Child>>);
 
+static WINDOW_COUNTER: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(1);
+
+static READY_URL: Mutex<Option<String>> = Mutex::new(None);
+
+static APP_LOADED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
+fn js_log(app: &AppHandle, msg: &str) {
+    debug_log(msg);
+    if let Some(w) = app.get_webview_window("main") {
+        let text = serde_json::to_string(&format!("[rust] {}", msg)).unwrap_or_default();
+        let _ = w.eval(&format!("console.log({});", text));
+    }
+}
+
 #[derive(serde::Deserialize, serde::Serialize, Clone)]
 struct BackendMessage {
     event: String,
     data: serde_json::Value,
 }
 
+struct UiGate {
+    ready: bool,
+    queue: Vec<BackendMessage>,
+}
+
+type SharedGate = Arc<Mutex<UiGate>>;
+
+fn dispatch(w: &tauri::WebviewWindow, gate: &SharedGate, msg: BackendMessage) {
+    if let Ok(mut lock) = gate.lock() {
+        if lock.ready {
+            let _ = w.emit(&msg.event, msg.data);
+        } else {
+            lock.queue.push(msg);
+        }
+    }
+}
+
 fn clean_path(path: &std::path::Path) -> String {
     let s = path.to_string_lossy().to_string();
-    if s.starts_with("\\\\?\\") {
+    if s.starts_with(r"\\?\") {
         s[4..].to_string()
     } else {
         s
@@ -64,6 +96,17 @@ fn kill_child_process(child: &mut Child) {
             .creation_flags(CREATE_NO_WINDOW)
             .output();
     }
+    #[cfg(unix)]
+    {
+        let pgid = child.id() as i32;
+        unsafe {
+            libc::killpg(pgid, libc::SIGTERM);
+        }
+        std::thread::sleep(std::time::Duration::from_millis(400));
+        unsafe {
+            libc::killpg(pgid, libc::SIGKILL);
+        }
+    }
     let _ = child.kill();
     let _ = child.wait();
 }
@@ -121,7 +164,7 @@ fn find_node_binary(app: &tauri::App) -> Option<String> {
             if node_exe.exists() {
                 return Some(clean_path(&node_exe));
             }
-                
+
             let node = p.join("node");
             if node.exists() {
                 return Some(clean_path(&node));
@@ -195,34 +238,7 @@ fn resolve_script_and_root(app: &tauri::App) -> (String, String) {
     (clean_path(&candidate), clean_path(&dir))
 }
 
-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);
-
+const LINK_HANDLER_SCRIPT: &str = r##"
     function doInvoke(cmd, args) {
         if (window.__TAURI__ && window.__TAURI__.core) {
             return window.__TAURI__.core.invoke(cmd, args || {});
@@ -230,28 +246,89 @@ const LINK_HANDLER_SCRIPT: &str =
         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 callWindow(method, fallbackCmd) {
+        const fallback = () => doInvoke(fallbackCmd).catch(err => console.error(fallbackCmd + ' failed:', err));
+        try {
+            if (window.__TAURI__ && window.__TAURI__.window) {
+                return window.__TAURI__.window.getCurrentWindow()[method]().catch(fallback);
+            }
+        } catch (err) {}
+        return fallback();
+    }
+    function minimizeWindow() {
+        return callWindow('minimize', 'win_minimize');
+    }
+    function maximizeWindow() {
+        return callWindow('toggleMaximize', 'win_maximize');
+    }
+    function closeWindow() {
+        return callWindow('close', 'win_close');
+    }
+    function dragWindow() {
+        return callWindow('startDragging', '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');
         }
     }
 
+    const nativeWindowOpen = window.open.bind(window);
+
+    function openInNewWindow(rawUrl) {
+        let abs;
+        try {
+            abs = new URL(rawUrl, location.href).href;
+        } catch (err) {
+            console.log('[vyla] bad url', rawUrl);
+            return;
+        }
+        console.log('[vyla] open new window', abs);
+        nativeWindowOpen(abs, '_blank');
+    }
+
     window.open = function(url, target, features) {
-        doInvoke('open_new_window', { url: url });
-        return null;
+        console.log('[vyla] window.open called', url, target, features);
+        const go = (v) => {
+            if (v && !/^(about:|javascript:|blob:|data:)/i.test(String(v))) {
+                openInNewWindow(String(v));
+            }
+        };
+        go(url);
+        const stub = {
+            closed: false,
+            close() {},
+            focus() {},
+            blur() {},
+            postMessage() {},
+            document: { write() {}, writeln() {}, close() {}, open() {} }
+        };
+        Object.defineProperty(stub, 'location', {
+            get() {
+                return { href: '', replace: go, assign: go };
+            },
+            set(v) {
+                go(v);
+            }
+        });
+        return stub;
     };
 
-    document.addEventListener('click', (e) => {
-        const a = e.target.closest('a');
+    const origAnchorClick = HTMLAnchorElement.prototype.click;
+    HTMLAnchorElement.prototype.click = function() {
+        if (this.href && this.target === '_blank' && !this.isConnected) {
+            console.log('[vyla] detached anchor click', this.href);
+            openInNewWindow(this.href);
+            return;
+        }
+        return origAnchorClick.apply(this, arguments);
+    };
+
+    function handleLinkClick(e) {
+        const a = e.target.closest && e.target.closest('a');
         if (!a || !a.href) return;
 
         if (a.href.includes('discord.gg') || a.href.includes('discord.com')) {
@@ -264,9 +341,12 @@ const LINK_HANDLER_SCRIPT: &str =
         if (a.target === '_blank' || e.ctrlKey || e.metaKey || e.button === 1) {
             e.preventDefault();
             e.stopPropagation();
-            doInvoke('open_new_window', { url: a.href });
+            openInNewWindow(a.href);
         }
-    }, true);
+    }
+
+    document.addEventListener('click', handleLinkClick, true);
+    document.addEventListener('auxclick', handleLinkClick, true);
 
     function injectLiquidNavBar() {
         if (document.getElementById('tauri-custom-titlebar')) return;
@@ -291,7 +371,7 @@ const LINK_HANDLER_SCRIPT: &str =
                 margin: 0 !important;
                 padding: 0 !important;
             }
-                
+
             .tauri-drag-region {
                 position: absolute !important;
                 inset: 0 !important;
@@ -299,7 +379,7 @@ const LINK_HANDLER_SCRIPT: &str =
                 cursor: default !important;
                 pointer-events: auto !important;
             }
-                
+
             .tauri-window-controls {
                 display: flex !important;
                 height: 32px !important;
@@ -308,7 +388,7 @@ const LINK_HANDLER_SCRIPT: &str =
                 pointer-events: auto !important;
                 z-index: 2147483648 !important;
             }
-                
+
             button.tauri-btn {
                 width: 46px !important;
                 min-width: 46px !important;
@@ -322,13 +402,17 @@ const LINK_HANDLER_SCRIPT: &str =
                 justify-content: center !important;
                 cursor: pointer !important;
                 outline: none !important;
+                pointer-events: auto !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);
+        if (!document.getElementById('tauri-custom-titlebar-style')) {
+            style.id = 'tauri-custom-titlebar-style';
+            (document.head || document.documentElement).appendChild(style);
+        }
 
         const tb = document.createElement('div');
         tb.id = 'tauri-custom-titlebar';
@@ -347,31 +431,60 @@ const LINK_HANDLER_SCRIPT: &str =
         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 (btnMin) {
+            btnMin.addEventListener('click', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                e.stopImmediatePropagation();
+                minimizeWindow();
+            }, true);
+        }
+        if (btnMax) {
+            btnMax.addEventListener('click', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                e.stopImmediatePropagation();
+                maximizeWindow();
+            }, true);
+        }
+        if (btnClose) {
+            btnClose.addEventListener('click', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                e.stopImmediatePropagation();
+                closeWindow();
+            }, true);
+        }
         if (dragEl) {
-            dragEl.onmousedown = (e) => {
-                if (e.buttons === 1) {
+            dragEl.addEventListener('mousedown', (e) => {
+                if (e.button === 0) {
                     e.preventDefault();
                     dragWindow();
                 }
-            };
+            });
         }
     }
 
+    function startNavObserver() {
+        const root = document.documentElement;
+        if (!root) {
+            setTimeout(startNavObserver, 5);
+            return;
+        }
+        const navObserver = new MutationObserver(() => {
+            if (!document.getElementById('tauri-custom-titlebar')) {
+                injectLiquidNavBar();
+            }
+        });
+        navObserver.observe(root, { childList: true, subtree: true });
+    }
+
     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 });
+    startNavObserver();
 "##;
 
 #[tauri::command]
@@ -402,179 +515,85 @@ 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));
-
+fn normalize_url(url: &str) -> Option<tauri::Url> {
     let final_url = if url.starts_with("http") || url.starts_with("tauri://") {
-        url.clone()
+        url.to_string()
     } 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())
+    match final_url.parse::<tauri::Url>() {
+        Ok(u) => Some(u),
+        Err(e) => {
+            debug_log(&format!("[NEW-WINDOW] bad url '{}': {}", final_url, e));
+            None
+        }
     }
 }
 
-#[tauri::command]
-async fn kill_orphans() -> Result<(), String> {
-    debug_log("[KILL] User requested orphan process kill");
+fn open_app_window(app: &AppHandle, url: tauri::Url) -> Result<(), String> {
+    js_log(app, &format!("[NEW-WINDOW] Opening: {}", url));
 
-    #[cfg(windows)]
+    let n = WINDOW_COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+    let label = format!("win_{}", n);
+    let nw_handle = app.clone();
+
+    let window = WebviewWindowBuilder::new(app, &label, WebviewUrl::External(url))
+        .title("Vyla Home")
+        .inner_size(1100.0, 700.0)
+        .center()
+        .decorations(false)
+        .resizable(true)
+        .transparent(true)
+        .devtools(true)
+        .focused(true)
+        .initialization_script(&format!("window.__VYLA_WINDOW_LABEL = '{}';", label))
+        .initialization_script(LINK_HANDLER_SCRIPT)
+        .on_new_window(move |new_url, _features| {
+            js_log(&nw_handle, &format!("[NEW-WINDOW] handler fired (child): {}", new_url));
+            let h = nw_handle.clone();
+            std::thread::spawn(move || {
+                let _ = open_app_window(&h, new_url);
+            });
+            NewWindowResponse::Deny
+        })
+        .build()
+        .map_err(|e| {
+            js_log(app, &format!("[NEW-WINDOW] build failed: {}", e));
+            e.to_string()
+        })?;
+
+    #[cfg(target_os = "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();
+        use window_vibrancy::{apply_acrylic, apply_mica};
+        if apply_mica(&window, Some(true)).is_err() {
+            let _ = apply_acrylic(&window, Some((15, 18, 25, 125)));
+        }
     }
 
-    #[cfg(not(windows))]
+    #[cfg(target_os = "macos")]
     {
-        let _ = std::process::Command::new("pkill")
-            .args(&["-9", "-f", "node"])
-            .output();
+        use window_vibrancy::{apply_vibrancy, NSVisualEffectMaterial};
+        let _ = apply_vibrancy(&window, NSVisualEffectMaterial::HudWindow, None, None);
     }
 
+    let _ = &window;
     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 open_new_window(app: AppHandle, url: String) -> Result<(), String> {
+    let parsed = normalize_url(&url).ok_or_else(|| "invalid url".to_string())?;
+    std::thread::spawn(move || {
+        let _ = open_app_window(&app, parsed);
+    });
+    Ok(())
 }
 
 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,
+        Some(u) => u.to_string(),
         None => return,
     };
 
@@ -586,36 +605,49 @@ fn handle_ready(w: &tauri::WebviewWindow, msg: &BackendMessage) {
     #[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");
+        use objc2::runtime::{AnyObject, Sel};
+        use objc2::sel;
+        let _ = w.with_webview(|webview| unsafe {
             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");
+            let selector: Sel = sel!(setUpgradeKnownHostsToHTTPS:);
+            let supported: bool = msg_send![config, respondsToSelector: selector];
+            if supported {
+                let _: () = msg_send![config, setUpgradeKnownHostsToHTTPS: false];
+            }
         });
-        debug_log(&format!("with_webview result: {:?}", result));
     }
 
-    let _ = w.navigate(url_parsed);
+    APP_LOADED.store(false, std::sync::atomic::Ordering::SeqCst);
+    let _ = w.navigate(url_parsed.clone());
+
+    let watcher = w.clone();
+    std::thread::spawn(move || {
+        for attempt in 1..=8 {
+            std::thread::sleep(std::time::Duration::from_secs(4));
+            if APP_LOADED.load(std::sync::atomic::Ordering::SeqCst) {
+                return;
+            }
+            debug_log(&format!("App page not loaded yet, retry {}", attempt));
+            let target = serde_json::to_string(&url_str).unwrap_or_default();
+            let _ = watcher.eval(&format!("window.location.replace({});", target));
+            let _ = watcher.navigate(url_parsed.clone());
+        }
+        debug_log("App page never loaded after retries");
+    });
 }
 
 fn main() {
     debug_log("=== Vyla Home Executable Started ===");
 
     tauri::Builder::default()
-        .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
+            open_new_window
         ])
         .manage(NodeServices(Mutex::new(None)))
         .setup(|app| {
@@ -626,13 +658,13 @@ fn main() {
                 std::path::PathBuf::from(appdata_env)
                     .join("vyla-home")
                     .join("vyla-home-files")
-            } else if let Ok(home) = std::env::var("HOME") {
+            } else if let Ok(_home) = std::env::var("HOME") {
                 #[cfg(target_os = "macos")]
-                let base = std::path::PathBuf::from(&home)
+                let base = std::path::PathBuf::from(&_home)
                     .join("Library")
                     .join("Application Support");
                 #[cfg(target_os = "linux")]
-                let base = std::path::PathBuf::from(&home)
+                let base = std::path::PathBuf::from(&_home)
                     .join(".local")
                     .join("share");
                 #[cfg(not(any(target_os = "macos", target_os = "linux")))]
@@ -644,16 +676,73 @@ fn main() {
 
             let _ = std::fs::create_dir_all(&vyla_files);
 
+            let main_nw_handle = app.handle().clone();
+            let gate: SharedGate = Arc::new(Mutex::new(UiGate {
+                ready: false,
+                queue: Vec::new(),
+            }));
+            let load_gate = gate.clone();
+
             let window = WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
                 .title("Vyla Home")
                 .inner_size(1280.0, 800.0)
                 .decorations(false)
                 .resizable(true)
+                .transparent(true)
                 .devtools(true)
                 .initialization_script("window.__VYLA_WINDOW_LABEL = 'main';")
+                .on_page_load(move |wv, payload| {
+                    if matches!(payload.event(), tauri::webview::PageLoadEvent::Finished) {
+                        if payload.url().host_str() == Some("127.0.0.1") {
+                            APP_LOADED.store(true, std::sync::atomic::Ordering::SeqCst);
+                        }
+                        if payload.url().host_str() != Some("127.0.0.1") {
+                            let known = READY_URL.lock().ok().and_then(|g| g.clone());
+                            if let Some(u) = known {
+                                if let Ok(parsed) = u.parse::<tauri::Url>() {
+                                    let _ = wv.navigate(parsed);
+                                    return;
+                                }
+                            }
+                        }
+                        let g = load_gate.clone();
+                        std::thread::spawn(move || {
+                            std::thread::sleep(std::time::Duration::from_millis(400));
+                            if let Ok(mut lock) = g.lock() {
+                                lock.ready = true;
+                                let pending: Vec<BackendMessage> = lock.queue.drain(..).collect();
+                                for m in pending {
+                                    let _ = wv.emit(&m.event, m.data);
+                                }
+                            }
+                        });
+                    }
+                })
                 .initialization_script(LINK_HANDLER_SCRIPT)
+                .on_new_window(move |new_url, _features| {
+                    js_log(&main_nw_handle, &format!("[NEW-WINDOW] handler fired (main): {}", new_url));
+                    let h = main_nw_handle.clone();
+                    std::thread::spawn(move || {
+                        let _ = open_app_window(&h, new_url);
+                    });
+                    NewWindowResponse::Deny
+                })
                 .build()?;
 
+            #[cfg(target_os = "windows")]
+            {
+                use window_vibrancy::{apply_acrylic, apply_mica};
+                if apply_mica(&window, Some(true)).is_err() {
+                    let _ = apply_acrylic(&window, Some((15, 18, 25, 125)));
+                }
+            }
+
+            #[cfg(target_os = "macos")]
+            {
+                use window_vibrancy::{apply_vibrancy, NSVisualEffectMaterial};
+                let _ = apply_vibrancy(&window, NSVisualEffectMaterial::HudWindow, None, None);
+            }
+
             let (main_js, root_dir) = resolve_script_and_root(app);
             debug_log("Searching for node binary...");
 
@@ -664,21 +753,31 @@ fn main() {
                 }
                 None => {
                     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(());
                 }
             };
 
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                if let Ok(meta) = std::fs::metadata(&node_bin) {
+                    let mut perms = meta.permissions();
+                    perms.set_mode(0o755);
+                    let _ = std::fs::set_permissions(&node_bin, perms);
+                }
+            }
+
             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", &vyla_files_str)
                 .env("NODE_EXE", &node_bin)
+                .env("VYLA_APP_VERSION", env!("CARGO_PKG_VERSION"))
+                .env("VYLA_DEV", if cfg!(debug_assertions) { "1" } else { "0" })
                 .stdin(Stdio::piped())
                 .stdout(Stdio::piped())
                 .stderr(Stdio::piped());
@@ -690,6 +789,12 @@ fn main() {
                 cmd.creation_flags(CREATE_NO_WINDOW);
             }
 
+            #[cfg(unix)]
+            {
+                use std::os::unix::process::CommandExt;
+                cmd.process_group(0);
+            }
+
             match cmd.spawn() {
                 Ok(mut child) => {
                     debug_log(&format!(
@@ -699,6 +804,7 @@ fn main() {
 
                     if let Some(stderr) = child.stderr.take() {
                         let w = window.clone();
+                        let g = gate.clone();
                         std::thread::spawn(move || {
                             use std::io::{BufRead, BufReader};
                             let reader = BufReader::new(stderr);
@@ -708,9 +814,13 @@ fn main() {
                                     || line.contains("Exception")
                                     || line.contains("MODULE_NOT_FOUND")
                                 {
-                                    let _ = w.emit(
-                                        "error",
-                                        serde_json::json!({ "message": format!("Backend failed: {}", line) }),
+                                    dispatch(
+                                        &w,
+                                        &g,
+                                        BackendMessage {
+                                            event: "error".to_string(),
+                                            data: serde_json::json!({ "message": format!("Backend failed: {}", line) }),
+                                        },
                                     );
                                 }
                             }
@@ -719,6 +829,7 @@ fn main() {
 
                     if let Some(stdout) = child.stdout.take() {
                         let w = window.clone();
+                        let g = gate.clone();
                         std::thread::spawn(move || {
                             use std::io::{BufRead, BufReader};
                             let reader = BufReader::new(stdout);
@@ -735,18 +846,50 @@ fn main() {
                                     }
                                 };
 
-                                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());
+                                    "self-update" => {
+                                        let target = msg
+                                            .data
+                                            .get("path")
+                                            .and_then(|p| p.as_str())
+                                            .map(PathBuf::from);
+                                        if let Some(p) = target {
+                                            let name = p
+                                                .file_name()
+                                                .and_then(|n| n.to_str())
+                                                .unwrap_or("")
+                                                .to_string();
+                                            if name.starts_with("vyla-installer-")
+                                                && name.ends_with(".exe")
+                                                && p.exists()
+                                            {
+                                                let state: State<NodeServices> = w.state();
+                                                if let Ok(mut lock) = state.0.lock() {
+                                                    if let Some(mut child) = lock.take() {
+                                                        kill_child_process(&mut child);
+                                                    }
+                                                };
+                                                let mut installer = Command::new(&p);
+                                                installer.args(["/S", "/UPDATE"]);
+                                                #[cfg(windows)]
+                                                {
+                                                    use std::os::windows::process::CommandExt;
+                                                    installer.creation_flags(0x00000008 | 0x00000200);
+                                                }
+                                                let _ = installer.spawn();
+                                                w.app_handle().exit(0);
+                                            }
+                                        }
                                     }
+                                    "ready" => {
+                                        if let Some(u) = msg.data.get("url").and_then(|u| u.as_str()) {
+                                            if let Ok(mut g) = READY_URL.lock() {
+                                                *g = Some(u.to_string());
+                                            }
+                                        }
+                                        handle_ready(&w, &msg)
+                                    }
+                                    _ => dispatch(&w, &g, msg.clone()),
                                 }
                             }
                         });
@@ -780,9 +923,20 @@ fn main() {
                             kill_child_process(&mut child);
                         }
                     };
+                    window.app_handle().exit(0);
                 }
             }
         })
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
+        .build(tauri::generate_context!())
+        .expect("error while building tauri application")
+        .run(|app, event| {
+            if let tauri::RunEvent::Exit = event {
+                let state: State<NodeServices> = app.state();
+                if let Ok(mut lock) = state.0.lock() {
+                    if let Some(mut child) = lock.take() {
+                        kill_child_process(&mut child);
+                    }
+                };
+            }
+        });
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.1.48",
+    "version": "1.1.56",
     "identifier": "com.vyla.home",
     "build": {
         "frontendDist": "../ui"
@@ -9,7 +9,7 @@
     "app": {
         "withGlobalTauri": true,
         "security": {
-            "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:*"
+            "csp": "default-src 'self' http://localhost:* http://127.0.0.1:*; script-src 'self' 'unsafe-inline' 'unsafe-eval' http://localhost:* http://127.0.0.1:*; style-src 'self' 'unsafe-inline' http://localhost:* http://127.0.0.1:*; img-src 'self' data: blob: https: http://localhost:* http://127.0.0.1:*; font-src 'self' data: http://localhost:* http://127.0.0.1:*; connect-src 'self' ipc: http://ipc.localhost http://localhost:* http://127.0.0.1:* ws://localhost:* ws://127.0.0.1:*"
         }
     },
     "bundle": {
@@ -35,8 +35,8 @@
             "WebView2Loader.dll",
             "../bin/**/*",
             "../main.js",
-            "../preload.js",
             "../service-manager.js",
+            "../file-updater.js",
             "../patcher.js",
             "../crypto-utils.js",
             "../credential-manager.js",

update-client.js

@@ -1,5 +1,14 @@
 const https = require('https');
 const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const UPDATE_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAKIuPPzTCGdTksi7hp+V4urau6mMQt2XhNlEfRVbjNZ4=
+-----END PUBLIC KEY-----`;
+const MIN_CHECK_INTERVAL_MS = 15 * 60 * 1000;
+const MAX_RETRY_AFTER_MS = 120000;
+const MAX_BACKOFF_MS = 6 * 60 * 60 * 1000;
 
 const GITLAB_GROUP = 'vyla-entertainment';
 const GITLAB_REPO = 'home';
@@ -25,25 +34,86 @@ function isAllowedHost(url) {
   }
 }
 
+function normalizeTag(v) {
+  return String(v || '').replace(/^v/, '').trim();
+}
+
+function canonicalManifest(manifest) {
+  const parts = Object.keys(manifest.components || {}).sort().map((name) => {
+    const c = manifest.components[name];
+    return `${name}:${c.file}:${c.sha256}:${c.id}:${c.size}`;
+  });
+  const lines = ['vyla-manifest-v2', normalizeTag(manifest.version), manifest.sha256, ...parts];
+  if (manifest.installer) {
+    const i = manifest.installer;
+    lines.push(`installer:${i.file}:${i.sha256}:${i.size}:${normalizeTag(i.version)}`);
+  }
+  return lines.join('\n');
+}
+
+function verifyManifest(manifest) {
+  if (!manifest || typeof manifest.signature !== 'string' || !manifest.components) return false;
+  try {
+    return crypto.verify(null, Buffer.from(canonicalManifest(manifest)), UPDATE_PUBLIC_KEY, Buffer.from(manifest.signature, 'base64'));
+  } catch (e) {
+    return false;
+  }
+}
+
 class UpdateClient {
   constructor(appDataPath, token = null) {
     this.appDataPath = appDataPath;
     this.token = token || process.env.GITLAB_TOKEN || process.env.VYLA_GITLAB_TOKEN || null;
   }
 
-  fetchJson(url) {
+  cachePath() {
+    return path.join(this.appDataPath, 'update-cache.json');
+  }
+
+  readCache() {
+    try {
+      return JSON.parse(fs.readFileSync(this.cachePath(), 'utf8'));
+    } catch (e) {
+      return {};
+    }
+  }
+
+  writeCache(patch) {
+    try {
+      fs.mkdirSync(this.appDataPath, { recursive: true });
+      fs.writeFileSync(this.cachePath(), JSON.stringify({ ...this.readCache(), ...patch }), 'utf8');
+    } catch (e) { }
+  }
+
+  recordFailure() {
+    const failures = (this.readCache().failures || 0) + 1;
+    const delay = Math.min(5 * 60 * 1000 * 2 ** (failures - 1), MAX_BACKOFF_MS);
+    this.writeCache({ failures, blockedUntil: Date.now() + delay });
+  }
+
+  recordSuccess() {
+    this.writeCache({ failures: 0, blockedUntil: 0 });
+  }
+
+  cacheUsable(release) {
+    return !!release && !!release.components && verifyManifest(release.manifest);
+  }
+
+  fetchJson(url, etag = null, attempt = 0) {
     return new Promise((resolve, reject) => {
       const urlObj = new URL(url);
       const headers = {
         'User-Agent': 'VylaHome-Client',
         'Accept': 'application/json',
-        'Cache-Control': 'no-cache',
-        'Pragma': 'no-cache'
+        'Cache-Control': 'no-cache'
       };
 
       if (this.token) {
         headers['PRIVATE-TOKEN'] = this.token;
       }
+      if (etag) {
+        headers['If-None-Match'] = etag;
+      }
 
       const requestOptions = {
         hostname: urlObj.hostname,
@@ -58,12 +128,23 @@ class UpdateClient {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
+          if (res.statusCode === 304) {
+            resolve({ notModified: true, etag });
+            return;
+          }
+          if ((res.statusCode === 429 || res.statusCode >= 500) && attempt < 3) {
+            const retryAfter = parseInt(res.headers['retry-after'], 10);
+            const base = Number.isFinite(retryAfter) ? retryAfter * 1000 : 1000 * 2 ** attempt;
+            const wait = Math.min(base, MAX_RETRY_AFTER_MS) + Math.floor(Math.random() * 1000);
+            setTimeout(() => this.fetchJson(url, etag, attempt + 1).then(resolve, reject), wait);
+            return;
+          }
           if (res.statusCode !== 200) {
             reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
             return;
           }
           try {
-            resolve(JSON.parse(data));
+            resolve({ data: JSON.parse(data), etag: res.headers.etag || null });
           } catch (e) {
             reject(new Error('Invalid JSON response'));
           }
@@ -120,7 +201,13 @@ class UpdateClient {
           }
 
           if (res.statusCode !== 200) {
-            reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+            res.resume();
+            const err = new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`);
+            const retryAfter = parseInt(res.headers['retry-after'], 10);
+            if (Number.isFinite(retryAfter)) {
+              err.retryAfterMs = Math.min(retryAfter * 1000, MAX_RETRY_AFTER_MS);
+            }
+            reject(err);
             return;
           }
 
@@ -141,7 +228,7 @@ class UpdateClient {
             file.close(() => {
               if (totalSize && downloadedSize < totalSize) {
                 fs.unlink(destPath, () => { });
-                reject(new Error(`Download truncated: Received ${downloadedSize} of ${totalSize} bytes. Connection dropped prematurely.`));
+                reject(new Error(`Download truncated: Received ${downloadedSize} of ${totalSize} bytes.`));
               } else {
                 resolve();
               }
@@ -236,12 +323,32 @@ class UpdateClient {
     });
   }
 
-  async checkForUpdates() {
-    const query = `?per_page=20&order_by=released_at&sort=desc&cb=${Date.now()}`;
-    const releases = await this.fetchJson(RELEASES_API + query);
-    if (!releases || releases.length === 0) {
+  async checkForUpdates(force = false) {
+    const cache = this.readCache();
+    const now = Date.now();
+
+    if (!force && cache.blockedUntil && now < cache.blockedUntil) {
       return null;
     }
+    if (!force && cache.checkedAt && now - cache.checkedAt < MIN_CHECK_INTERVAL_MS && this.cacheUsable(cache.release)) {
+      return cache.release;
+    }
+
+    const listUrl = `${RELEASES_API}?per_page=20&order_by=released_at&sort=desc`;
+    let result = await this.fetchJson(listUrl, force ? null : cache.etag);
+    if (result.notModified) {
+      if (this.cacheUsable(cache.release)) {
+        this.writeCache({ checkedAt: now });
+        return cache.release;
+      }
+      result = await this.fetchJson(listUrl, null);
+    }
+
+    const releases = result.data;
+    if (!Array.isArray(releases) || releases.length === 0) {
+      return null;
+    }
+
     const verParts = (v) => String(v || '').replace(/^v/, '').split(/[.\-+]/).map((n) => parseInt(n, 10) || 0);
     const cmp = (a, b) => {
       const x = verParts(a);
@@ -252,25 +359,59 @@ class UpdateClient {
       return 0;
     };
     const release = releases.slice().sort((a, b) => cmp(b.tag_name, a.tag_name))[0];
+    const links = release.assets && release.assets.links ? release.assets.links : [];
+    const manifestAsset = links.find((a) => a.name === 'manifest.json');
 
-    const payloadAsset = (release.assets && release.assets.links ? release.assets.links : []).find(a => a.name === 'update-payload.zip');
-    const manifestAsset = (release.assets && release.assets.links ? release.assets.links : []).find(a => a.name === 'manifest.json');
-
-    if (!payloadAsset) {
-      return null;
+    if (!manifestAsset) {
+      throw new Error(`Release ${release.tag_name} has no manifest.json.`);
     }
 
-    let sha256 = null;
-    if (manifestAsset) {
-      const manifest = await this.fetchAssetJson(manifestAsset.url);
-      sha256 = manifest.sha256 || null;
+    const manifest = await this.fetchAssetJson(manifestAsset.url);
+    if (!manifest.components) {
+      throw new Error(`Release ${release.tag_name} has no signed component manifest.`);
+    }
+    if (!verifyManifest(manifest)) {
+      throw new Error('Update manifest signature is invalid.');
+    }
+    if (normalizeTag(manifest.version) !== normalizeTag(release.tag_name)) {
+      throw new Error('Update manifest version does not match the release tag.');
     }
 
-    return {
+    const components = {};
+    for (const [name, c] of Object.entries(manifest.components)) {
+      const link = links.find((a) => a.name === c.file);
+      const direct = typeof c.url === 'string' &&
+        c.url.startsWith('https://gitlab.com/api/v4/projects/') &&
+        c.url.includes('/packages/generic/vyla-home/');
+      const url = direct ? c.url : (link && link.url);
+      if (!url) {
+        throw new Error(`Release is missing asset ${c.file}.`);
+      }
+      components[name] = { url, sha256: c.sha256, id: c.id, size: c.size };
+    }
+
+    let installer = null;
+    if (manifest.installer) {
+      const installerLink = links.find((a) => a.name === manifest.installer.file);
+      if (installerLink) {
+        installer = {
+          url: installerLink.url,
+          sha256: manifest.installer.sha256,
+          size: manifest.installer.size,
+          version: manifest.installer.version
+        };
+      }
+    }
+
+    const out = {
       version: release.tag_name,
-      url: payloadAsset.url,
-      sha256
+      sha256: manifest.sha256 || null,
+      manifest,
+      components,
+      installer
     };
+    this.writeCache({ checkedAt: now, etag: result.etag || null, release: out });
+    return out;
   }
 
   async downloadUpdate(release, destPath, onProgress) {
@@ -279,4 +420,7 @@ class UpdateClient {
   }
 }
 
-module.exports = UpdateClient;
+UpdateClient.canonicalManifest = canonicalManifest;
+UpdateClient.verifyManifest = verifyManifest;
+
+module.exports = UpdateClient;