v1.1.60

.gitignore

@@ -1,5 +1,4 @@
 node_modules/
-package-lock.json
 
 dist/
 dist-build/
@@ -37,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');
 

codemagic.yaml

@@ -21,7 +21,7 @@ workflows:
       - name: Install dependencies
         script: |
           export PATH="$HOME/.cargo/bin:$PATH"
-          npm install
+          npm ci
       - name: Build & Publish macOS Release
         script: |
           export PATH="$HOME/.cargo/bin:$PATH"

config/env.json

@@ -1,5 +1,11 @@
 {
   "player": {
     "PORT": "3000"
+  },
+  "discord": {
+    "enabled": true,
+    "clientId": "1394887879154598038",
+    "logoImage": "vyla_logo",
+    "tmdbApiKey": "3f6703f3e2a0b2b40fe4fbb3e1546244"
   }
-}
+}

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;

discord-rpc.js

@@ -0,0 +1,442 @@
+const net = require('net');
+const path = require('path');
+const https = require('https');
+const crypto = require('crypto');
+
+const DEFAULT_CLIENT_ID = '1394887879154598038';
+const DEFAULT_LOGO = 'vyla_logo';
+
+const TMDB_IMAGE_BASE = 'https://image.tmdb.org/t/p/w500';
+const OP = { HANDSHAKE: 0, FRAME: 1, CLOSE: 2, PING: 3, PONG: 4 };
+
+function ipcPaths() {
+    const out = [];
+    if (process.platform === 'win32') {
+        for (let i = 0; i < 10; i++) out.push(`\\\\?\\pipe\\discord-ipc-${i}`);
+        return out;
+    }
+    const bases = [...new Set([process.env.XDG_RUNTIME_DIR, process.env.TMPDIR, process.env.TMP, process.env.TEMP, '/tmp'].filter(Boolean))];
+    for (const base of bases) {
+        for (let i = 0; i < 10; i++) {
+            out.push(path.join(base, `discord-ipc-${i}`));
+            out.push(path.join(base, 'app', 'com.discordapp.Discord', `discord-ipc-${i}`));
+            out.push(path.join(base, 'snap.discord', `discord-ipc-${i}`));
+        }
+    }
+    return out;
+}
+
+class DiscordIpc {
+    constructor(clientId, log) {
+        this.clientId = clientId;
+        this.log = log || (() => { });
+        this.socket = null;
+        this.ready = false;
+        this.connecting = false;
+        this.stopped = true;
+        this.buffer = Buffer.alloc(0);
+        this.retryTimer = null;
+        this.desired = null;
+    }
+
+    start() {
+        this.stopped = false;
+        this.connect();
+    }
+
+    stop() {
+        this.stopped = true;
+        clearTimeout(this.retryTimer);
+        const s = this.socket;
+        this.socket = null;
+        this.ready = false;
+        if (s) {
+            try { s.destroy(); } catch (e) { }
+        }
+    }
+
+    scheduleRetry() {
+        if (this.stopped) return;
+        clearTimeout(this.retryTimer);
+        this.retryTimer = setTimeout(() => this.connect(), 15000);
+    }
+
+    connect() {
+        if (this.stopped || this.socket || this.connecting) return;
+        this.connecting = true;
+        const paths = ipcPaths();
+        const attempt = (i) => {
+            if (this.stopped) { this.connecting = false; return; }
+            if (i >= paths.length) {
+                this.connecting = false;
+                this.scheduleRetry();
+                return;
+            }
+            const sock = net.createConnection(paths[i]);
+            let opened = false;
+            sock.once('error', () => {
+                if (!opened) {
+                    sock.destroy();
+                    attempt(i + 1);
+                }
+            });
+            sock.once('connect', () => {
+                opened = true;
+                this.connecting = false;
+                this.attach(sock);
+            });
+        };
+        attempt(0);
+    }
+
+    attach(sock) {
+        this.socket = sock;
+        this.buffer = Buffer.alloc(0);
+        this.ready = false;
+        sock.on('data', (chunk) => this.onData(sock, chunk));
+        sock.on('error', () => { });
+        sock.on('close', () => {
+            if (this.socket === sock) {
+                this.socket = null;
+                this.ready = false;
+                this.log('Discord IPC closed');
+                this.scheduleRetry();
+            }
+        });
+        this.send(OP.HANDSHAKE, { v: 1, client_id: this.clientId });
+    }
+
+    send(op, payload) {
+        if (!this.socket) return;
+        const body = Buffer.from(JSON.stringify(payload), 'utf8');
+        const header = Buffer.alloc(8);
+        header.writeInt32LE(op, 0);
+        header.writeInt32LE(body.length, 4);
+        try {
+            this.socket.write(Buffer.concat([header, body]));
+        } catch (e) { }
+    }
+
+    onData(sock, chunk) {
+        if (this.socket !== sock) return;
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 8) {
+            const op = this.buffer.readInt32LE(0);
+            const len = this.buffer.readInt32LE(4);
+            if (len < 0 || len > 1024 * 1024) {
+                sock.destroy();
+                return;
+            }
+            if (this.buffer.length < 8 + len) return;
+            const raw = this.buffer.slice(8, 8 + len).toString('utf8');
+            this.buffer = this.buffer.slice(8 + len);
+            let payload = {};
+            try { payload = JSON.parse(raw); } catch (e) { }
+            this.handle(sock, op, payload);
+        }
+    }
+
+    handle(sock, op, payload) {
+        if (op === OP.PING) {
+            this.send(OP.PONG, payload);
+        } else if (op === OP.CLOSE) {
+            this.log(`Discord closed the connection: ${JSON.stringify(payload)}`);
+            sock.destroy();
+        } else if (op === OP.FRAME) {
+            if (payload.evt === 'READY') {
+                this.ready = true;
+                this.log('Discord RPC ready');
+                this.flush();
+            } else if (payload.evt === 'ERROR') {
+                this.log(`Discord RPC error: ${JSON.stringify(payload.data)}`);
+            }
+        }
+    }
+
+    flush() {
+        if (!this.ready) return;
+        const args = { pid: process.pid };
+        if (this.desired) args.activity = this.desired;
+        this.send(OP.FRAME, { cmd: 'SET_ACTIVITY', args, nonce: crypto.randomUUID() });
+    }
+
+    setActivity(activity) {
+        this.desired = activity || null;
+        this.flush();
+    }
+}
+
+function parseRoute(href) {
+    let u;
+    try { u = new URL(href); } catch (e) { return { kind: 'idle' }; }
+    if (u.pathname !== '/' && u.pathname !== '/index.html') return { kind: 'idle' };
+
+    const p = u.searchParams;
+    const id = (p.get('id') || '').trim();
+    if (!/^\d+$/.test(id)) return { kind: 'idle' };
+
+    const type = (p.get('type') || '').toLowerCase();
+    if (type === 'movie' || type === 'tv') {
+        return { kind: 'browse', type, id };
+    }
+
+    const season = parseInt(p.get('season'), 10);
+    const episode = parseInt(p.get('episode'), 10);
+    if (Number.isFinite(season) && Number.isFinite(episode)) {
+        return { kind: 'watch', type: 'tv', id, season, episode };
+    }
+    return { kind: 'watch', type: 'movie', id };
+}
+
+function getJson(url, headers) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'VylaHome-Client', 'Accept': 'application/json', ...(headers || {}) } }, (res) => {
+            let data = '';
+            res.on('data', (c) => { data += c; });
+            res.on('end', () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                try { resolve(JSON.parse(data)); } catch (e) { reject(new Error('Invalid JSON')); }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(8000, () => {
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+
+function clip(s, max = 128) {
+    const str = String(s || '').trim();
+    return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+function cleanPageTitle(t) {
+    const s = String(t || '').replace(/\s*[-|–—•]\s*Vyla.*$/i, '').trim();
+    if (!s || /^vyla/i.test(s)) return null;
+    return s;
+}
+
+class VylaPresence {
+    constructor({ getConfig, log }) {
+        this.getConfig = getConfig || (() => ({}));
+        this.log = log || (() => { });
+        this.windows = new Map();
+        this.ipc = null;
+        this.started = false;
+        this.metaCache = new Map();
+        this.pageMemory = new Map();
+        this.lastStart = 0;
+        this.watchKey = null;
+        this.watchStart = 0;
+        this.lastActivityKey = null;
+        this.timer = null;
+        this.token = 0;
+    }
+
+    settings() {
+        const cfg = (this.getConfig() || {}).discord || {};
+        const clientId = [process.env.VYLA_DISCORD_CLIENT_ID, cfg.clientId, DEFAULT_CLIENT_ID]
+            .map((v) => String(v || '').trim())
+            .find((v) => /^\d{17,20}$/.test(v)) || '';
+        const tmdbKey = String(process.env.VYLA_TMDB_API_KEY || cfg.tmdbApiKey || '').trim();
+        return {
+            enabled: cfg.enabled !== false,
+            clientId: /^\d{17,20}$/.test(clientId) ? clientId : '',
+            logo: cfg.logoImage || DEFAULT_LOGO,
+            tmdbKey: /^YOUR_/i.test(tmdbKey) ? '' : tmdbKey
+        };
+    }
+
+    start() {
+        if (this.started) return;
+        const s = this.settings();
+        if (!s.enabled) {
+            this.log('Discord presence disabled in config.');
+            return;
+        }
+        if (!s.clientId) {
+            this.log('Discord presence not started: no clientId configured.');
+            return;
+        }
+        this.started = true;
+        this.ipc = new DiscordIpc(s.clientId, (m) => this.log(m));
+        this.ipc.start();
+        this.refresh();
+    }
+
+    stop() {
+        clearTimeout(this.timer);
+        this.started = false;
+        if (this.ipc) {
+            this.ipc.stop();
+            this.ipc = null;
+        }
+    }
+
+    report(payload) {
+        if (!payload || !payload.label) return;
+        this.log(`report ${payload.label}: ${payload.closed ? 'closed' : payload.url}`);
+        if (payload.closed) {
+            this.windows.delete(payload.label);
+        } else {
+            this.windows.set(payload.label, {
+                url: String(payload.url || ''),
+                title: String(payload.title || ''),
+                image: String(payload.image || ''),
+                position: Number(payload.position),
+                duration: Number(payload.duration),
+                paused: payload.paused === true,
+                at: Date.now()
+            });
+        }
+        this.refresh();
+    }
+
+    current() {
+        let best = null;
+        for (const w of this.windows.values()) {
+            if (!best || w.at >= best.at) best = w;
+        }
+        return best;
+    }
+
+    refresh() {
+        if (!this.started) return;
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.apply().catch((e) => this.log(`Presence update failed: ${e.message}`)), 400);
+    }
+
+    async fetchMeta(route) {
+        const s = this.settings();
+        if (!s.tmdbKey) return null;
+        const key = `${route.type}:${route.id}`;
+        if (this.metaCache.has(key)) return this.metaCache.get(key);
+        try {
+            const bearer = s.tmdbKey.length > 40;
+            const url = `https://api.themoviedb.org/3/${route.type}/${route.id}` + (bearer ? '' : `?api_key=${encodeURIComponent(s.tmdbKey)}`);
+            const d = await getJson(url, bearer ? { Authorization: `Bearer ${s.tmdbKey}` } : null);
+            const meta = {
+                title: d.title || d.name || null,
+                poster: d.poster_path ? `${TMDB_IMAGE_BASE}${d.poster_path}` : null,
+                runtime: d.runtime || (Array.isArray(d.episode_run_time) && d.episode_run_time[0]) || 0
+            };
+            this.metaCache.set(key, meta);
+            return meta;
+        } catch (e) {
+            this.log(`TMDB lookup failed for ${key}: ${e.message}`);
+            return null;
+        }
+    }
+
+    async fetchEpisodeName(route) {
+        const s = this.settings();
+        if (!s.tmdbKey) return null;
+        const key = `ep:${route.id}:${route.season}:${route.episode}`;
+        if (this.metaCache.has(key)) return this.metaCache.get(key);
+        try {
+            const bearer = s.tmdbKey.length > 40;
+            const url = `https://api.themoviedb.org/3/tv/${route.id}/season/${route.season}/episode/${route.episode}` + (bearer ? '' : `?api_key=${encodeURIComponent(s.tmdbKey)}`);
+            const d = await getJson(url, bearer ? { Authorization: `Bearer ${s.tmdbKey}` } : null);
+            const info = { name: d.name || null, runtime: d.runtime || 0 };
+            this.metaCache.set(key, info);
+            return info;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async apply() {
+        const token = ++this.token;
+        const s = this.settings();
+        const win = this.current();
+        const route = win ? parseRoute(win.url) : { kind: 'idle' };
+
+        let activity;
+        if (route.kind === 'idle') {
+            this.watchKey = null;
+            activity = {
+                type: 0,
+                details: 'On Vyla Home',
+                assets: { large_image: s.logo, large_text: 'Vyla Home' }
+            };
+        } else {
+            const meta = await this.fetchMeta(route);
+            const episode = (route.kind === 'watch' && route.type === 'tv' ? await this.fetchEpisodeName(route) : null) || {};
+            if (token !== this.token) return;
+
+            const pageTitle = win ? cleanPageTitle(win.title) : null;
+            const pageImage = win && /^https:\/\//i.test(win.image) ? win.image : null;
+            const memKey = `${route.type}:${route.id}`;
+            const mem = this.pageMemory.get(memKey) || {};
+            if (pageTitle) mem.title = pageTitle;
+            if (pageImage) mem.poster = pageImage;
+            this.pageMemory.set(memKey, mem);
+            const title = (meta && meta.title) || pageTitle || mem.title || (route.type === 'tv' ? 'a TV show' : 'a movie');
+            const poster = (meta && meta.poster) || pageImage || mem.poster;
+
+            const assets = {
+                large_image: poster || s.logo,
+                large_text: clip(title)
+            };
+            if (poster) {
+                assets.small_image = s.logo;
+                assets.small_text = 'Vyla Home';
+            }
+
+            if (route.kind === 'browse') {
+                this.watchKey = null;
+                activity = {
+                    type: 0,
+                    details: 'Browsing Vyla',
+                    state: clip(`Browsing ${title}`),
+                    assets
+                };
+            } else {
+                const key = route.type === 'tv' ? `tv:${route.id}:${route.season}:${route.episode}` : `movie:${route.id}`;
+                if (this.watchKey !== key) {
+                    this.watchKey = key;
+                    this.watchStart = Date.now();
+                    this.lastStart = 0;
+                }
+                const runtimeMin = episode.runtime || (meta && meta.runtime) || 0;
+                let timestamps;
+                if (win && Number.isFinite(win.duration) && win.duration > 0) {
+                    if (win.paused) {
+                        this.lastStart = 0;
+                    } else {
+                        let start = Date.now() - Math.round(win.position * 1000);
+                        if (this.lastStart && Math.abs(start - this.lastStart) < 4000) start = this.lastStart;
+                        this.lastStart = start;
+                        timestamps = { start, end: start + Math.round(win.duration * 1000) };
+                    }
+                } else if (runtimeMin) {
+                    timestamps = { start: this.watchStart, end: this.watchStart + runtimeMin * 60000 };
+                } else {
+                    timestamps = { start: this.watchStart };
+                }
+                activity = {
+                    type: 3,
+                    details: clip(`Watching ${title}`),
+                    assets
+                };
+                if (timestamps) activity.timestamps = timestamps;
+                if (route.type === 'tv') {
+                    activity.state = clip(`Season ${route.season}, Episode ${route.episode}` + (episode.name ? ` · ${episode.name}` : ''));
+                }
+            }
+        }
+
+        const sig = JSON.stringify(activity);
+        if (sig === this.lastActivityKey) return;
+        this.lastActivityKey = sig;
+        this.log(`activity: ${sig}`);
+        if (this.ipc) this.ipc.setActivity(activity);
+    }
+}
+
+VylaPresence.parseRoute = parseRoute;
+module.exports = VylaPresence;

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,8 @@ const express = require('express');
 const ServiceManager = require('./service-manager');
 const Patcher = require('./patcher');
 const UpdateClient = require('./update-client');
+const FileUpdater = require('./file-updater');
+const VylaPresence = require('./discord-rpc');
 
 function getDefaultAppData() {
   if (process.platform === 'darwin') {
@@ -32,8 +34,6 @@ function debugLog(msg) {
 debugLog("--- Node.js Process Started ---");
 
 let serviceManager;
-let expressApp;
-let expressServer;
 let updateDecisionHandler = null;
 
 debugLog(`AppData Dir: ${APPDATA_DIR}`);
@@ -43,69 +43,13 @@ 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();
+require('readline').createInterface({ input: process.stdin }).on('line', (line) => {
+  try {
+    const msg = JSON.parse(line);
+    if (msg && msg.type === 'presence') presence.report(msg.payload);
+  } catch (e) { }
+});
 process.stdin.on('end', () => {
   debugLog('stdin closed - parent died. Self-terminating...');
   process.exit(0);
@@ -145,7 +89,44 @@ function getReplacementsConfig() {
   } catch (e) { return {}; }
 }
 
+function liveReposEnabled() {
+  const cfg = getEnvConfig();
+  return !!(cfg.updater && cfg.updater.liveRepos === true);
+}
+
 const updateClient = new UpdateClient(APPDATA_DIR);
+const presence = new VylaPresence({ getConfig: getEnvConfig, log: debugLog });
+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 +135,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 +273,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) < 10 * 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: 'Removing old version and installing the latest...' });
+          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 +372,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,8 +438,13 @@ 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.");
+    try { presence.start(); } catch (e) { debugLog(`Presence start failed: ${e.message}`); }
 
     sendToTauri('status', { message: 'All backend services running and healthy.' });
     debugLog("Sending READY to Tauri.");
@@ -461,19 +457,9 @@ async function start() {
 }
 
 process.on('exit', () => {
+  try { presence.stop(); } catch (e) { }
   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 +469,8 @@ process.on('SIGINT', () => {
 process.on('SIGTERM', () => {
   process.exit(0);
 });
+process.on('SIGHUP', () => {
+  process.exit(0);
+});
 
-start();
+start();

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vyla-home",
-  "version": "1.1.46",
+  "version": "1.1.60",
   "description": "Vyla Home Desktop App Launcher",
   "main": "main.js",
   "scripts": {
@@ -11,47 +11,15 @@
     "release:full": "node release.js --installer"
   },
   "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.4.0",
+    "@tauri-apps/api": "2.12.1",
+    "@tauri-apps/plugin-opener": "2.7.0",
+    "@tauri-apps/plugin-process": "2.4.0",
+    "@tauri-apps/plugin-shell": "2.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.0.0"
-  },
-  "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"
-    }
+    "@tauri-apps/cli": "2.12.1"
   }
 }

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;
@@ -156,6 +158,24 @@ function createGitLabRelease(tag, releaseLinks) {
         });
 }
 
+function injectDiscordConfig() {
+    const envPath = path.join(__dirname, 'config', 'env.json');
+    const cfg = fs.existsSync(envPath) ? JSON.parse(fs.readFileSync(envPath, 'utf8')) : {};
+    const tmdb = process.env.TMDB_API_KEY || process.env.TMDB_KEY || '3f6703f3e2a0b2b40fe4fbb3e1546244';
+    const clientId = process.env.DISCORD_CLIENT_ID || '';
+
+    cfg.discord = cfg.discord || {};
+    if (tmdb) {
+        cfg.discord.tmdbApiKey = tmdb;
+    } else {
+        console.log('[WARNING] No TMDB_API_KEY or TMDB_KEY set. Discord posters will fall back to page data.');
+    }
+    if (clientId) cfg.discord.clientId = clientId;
+
+    fs.mkdirSync(path.dirname(envPath), { recursive: true });
+    fs.writeFileSync(envPath, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
 async function main() {
     const isFullBuild = process.argv.includes('--installer');
     const customTag = process.argv.find(arg => arg.startsWith('--tag='))?.split('=')[1];
@@ -164,8 +184,10 @@ async function main() {
 
     console.log(`Building Vyla Home Release (${version})`);
 
+    injectDiscordConfig();
+
     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 +239,47 @@ 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`);
+        if (!c.url || !c.url.includes('/packages/generic/vyla-home/')) {
+            throw new Error(`Upload for ${name} did not return a package URL.`);
+        }
+    }
+
+    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

@@ -741,7 +741,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -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"
@@ -921,7 +912,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2062,7 +2053,7 @@ dependencies = [
  "png 0.18.1",
  "serde",
  "thiserror 2.0.20",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -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.60.2",
-]
-
 [[package]]
 name = "pango"
 version = "0.18.3"
@@ -2844,7 +2825,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3118,44 +3099,12 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "shared_child"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e362d9935bc50f019969e2f9ecd66786612daae13e8f277be7bfb66e8bed3f7"
-dependencies = [
- "libc",
- "sigchld",
- "windows-sys 0.60.2",
-]
-
 [[package]]
 name = "shlex"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
-[[package]]
-name = "sigchld"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47106eded3c154e70176fc83df9737335c94ce22f821c32d17ed1db1f83badb1"
-dependencies = [
- "libc",
- "os_pipe",
- "signal-hook",
-]
-
-[[package]]
-name = "signal-hook"
-version = "0.3.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.8"
@@ -3197,7 +3146,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3568,37 +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.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "094bdbc47e5efe36544ba21b3a53ab5c724150236cf55e6c9be46191deb6eab6"
-dependencies = [
- "encoding_rs",
- "log",
- "open",
- "os_pipe",
- "regex",
- "schemars 0.8.22",
- "serde",
- "serde_json",
- "shared_child",
- "tauri",
- "tauri-plugin",
- "thiserror 2.0.20",
- "tokio",
-]
-
 [[package]]
 name = "tauri-runtime"
 version = "2.12.1"
@@ -3709,7 +3627,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4034,7 +3952,7 @@ dependencies = [
  "png 0.18.1",
  "serde",
  "thiserror 2.0.20",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4063,7 +3981,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
 dependencies = [
  "memoffset",
  "tempfile",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4155,17 +4073,16 @@ dependencies = [
 
 [[package]]
 name = "vyla-home"
-version = "1.1.46"
+version = "1.1.60"
 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]]
@@ -4402,7 +4319,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4423,7 +4340,7 @@ dependencies = [
  "objc2-foundation",
  "objc2-quartz-core",
  "raw-window-handle",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
  "windows-version",
 ]
 
@@ -4546,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"
@@ -4588,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"
@@ -4642,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"
@@ -4660,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"
@@ -4678,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"
@@ -4708,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"
@@ -4726,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"
@@ -4744,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"
@@ -4762,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.46"
+version = "1.1.60"
 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"
 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

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,20 @@
 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",
+        "discord-rpc.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 +42,17 @@ 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",
+                "report_location",
+            ]),
+        ),
+    )
+    .expect("failed to run tauri-build");
 }

src-tauri/capabilities/default.json

@@ -1,40 +1,43 @@
 {
     "$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",
+        "allow-report-location",
+        "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","allow-report-location","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": {
@@ -555,10 +345,10 @@
       "description": "Permission identifier",
       "oneOf": [
         {
-          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`",
+          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`\n- `allow-report-location`",
           "type": "string",
           "const": "default",
-          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`"
+          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`\n- `allow-report-location`"
         },
         {
           "description": "Allows opening a new webview window",
@@ -566,6 +356,12 @@
           "const": "allow-open-new-window",
           "markdownDescription": "Allows opening a new webview window"
         },
+        {
+          "description": "Allows reporting the current page to the backend",
+          "type": "string",
+          "const": "allow-report-location",
+          "markdownDescription": "Allows reporting the current page to the backend"
+        },
         {
           "description": "Allows closing the window",
           "type": "string",
@@ -590,6 +386,42 @@
           "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 report_location command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-report-location",
+          "markdownDescription": "Denies the report_location 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 +2509,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 +2622,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": {
@@ -555,10 +345,10 @@
       "description": "Permission identifier",
       "oneOf": [
         {
-          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`",
+          "description": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`\n- `allow-report-location`",
           "type": "string",
           "const": "default",
-          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`"
+          "markdownDescription": "Default permissions for Vyla Home app commands\n#### This permission set includes:\n\n- `allow-win-minimize`\n- `allow-win-maximize`\n- `allow-win-close`\n- `allow-win-drag`\n- `allow-open-new-window`\n- `allow-report-location`"
         },
         {
           "description": "Allows opening a new webview window",
@@ -566,6 +356,12 @@
           "const": "allow-open-new-window",
           "markdownDescription": "Allows opening a new webview window"
         },
+        {
+          "description": "Allows reporting the current page to the backend",
+          "type": "string",
+          "const": "allow-report-location",
+          "markdownDescription": "Allows reporting the current page to the backend"
+        },
         {
           "description": "Allows closing the window",
           "type": "string",
@@ -590,6 +386,42 @@
           "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 report_location command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-report-location",
+          "markdownDescription": "Denies the report_location 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 +2509,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 +2622,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/report_location.toml

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

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,38 @@
 [[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"
+
+[[permission]]
+identifier = "allow-report-location"
+description = "Allows reporting the current page to the backend"
+[[permission.allow]]
+cmd = "report_location"
 
 [[set]]
 identifier = "default"
@@ -33,5 +44,6 @@ permissions = [
     "allow-win-maximize",
     "allow-win-close",
     "allow-win-drag",
-    "allow-open-new-window"
+    "allow-open-new-window",
+    "allow-report-location"
 ]

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "Vyla Home",
-    "version": "1.1.46",
+    "version": "1.1.60",
     "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,12 +35,13 @@
             "WebView2Loader.dll",
             "../bin/**/*",
             "../main.js",
-            "../preload.js",
             "../service-manager.js",
+            "../file-updater.js",
             "../patcher.js",
             "../crypto-utils.js",
             "../credential-manager.js",
             "../update-client.js",
+            "../discord-rpc.js",
             "../config/**/*",
             "../node_modules/**/*"
         ]

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);
@@ -251,26 +358,87 @@ class UpdateClient {
       }
       return 0;
     };
-    const release = releases.slice().sort((a, b) => cmp(b.tag_name, a.tag_name))[0];
+    const ordered = releases.slice().sort((a, b) => cmp(b.tag_name, a.tag_name));
+    const release = ordered[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 direct = typeof c.url === 'string' &&
+        c.url.startsWith('https://') &&
+        isAllowedHost(c.url) &&
+        c.url.includes('/packages/generic/vyla-home/');
+      const url = direct ? c.url : null;
+      if (!url) {
+        throw new Error(`Release ${release.tag_name} manifest has no download URL for ${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
+        };
+      }
+    }
+
+    if (!installer) {
+      installer = await this.findInstaller(ordered, release.tag_name);
+    }
+
+    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 findInstaller(ordered, skipTag) {
+    for (const r of ordered.slice(0, 6)) {
+      if (r.tag_name === skipTag) continue;
+      const rl = r.assets && r.assets.links ? r.assets.links : [];
+      const ma = rl.find((a) => a.name === 'manifest.json');
+      if (!ma) continue;
+      try {
+        const m = await this.fetchAssetJson(ma.url);
+        if (!m.installer || !verifyManifest(m)) continue;
+        const link = rl.find((a) => a.name === m.installer.file);
+        if (!link) continue;
+        return {
+          url: link.url,
+          sha256: m.installer.sha256,
+          size: m.installer.size,
+          version: m.installer.version
+        };
+      } catch (e) { }
+    }
+    return null;
   }
 
   async downloadUpdate(release, destPath, onProgress) {
@@ -279,4 +447,7 @@ class UpdateClient {
   }
 }
 
-module.exports = UpdateClient;
+UpdateClient.canonicalManifest = canonicalManifest;
+UpdateClient.verifyManifest = verifyManifest;
+
+module.exports = UpdateClient;