livedesk 0.1.618 → 0.1.620

package/README.md

@@ -69,11 +69,12 @@ and startup retry, then exits without looping.
 npx -y --prefer-online livedesk@latest client 3
 ```
 
-The `client` form remains as a legacy compatibility alias. It records the
-Client role and uses the same unified runtime lock. The client signs in with
-Google, discovers the active Hub, and connects to the wall. On Windows, enable
-**Start with Windows** on the connection page to reconnect automatically after
-reboot; the generated startup command uses the unified launcher.
+The `client` form remains as a legacy compatibility alias. It records the
+Client role and uses the same unified runtime lock. The client signs in with
+Google, discovers the active Hub, and connects to the wall. Installed Windows,
+macOS, and Linux desktop apps start automatically after sign-in by default,
+reuse the saved session, and reconnect without opening the window. Turn this
+off in **Settings > Desktop app** when a computer should remain manual.
 
 ## macOS physical diagnostic
 

package/client/README.md

@@ -30,9 +30,10 @@ discovers the newly published Hub without another Google login. Omit the number
 for first-available placement, or pass `1` to `999` to pin this machine to a
 screen wall slot.
 
-On Windows, check **Start with Windows** on the connection page to reconnect this
-client automatically after reboot. The startup entry reuses the saved Google
-session and only opens the connection page again if sign-in is needed.
+Installed VuvoDesk desktop apps start automatically after sign-in on Windows,
+macOS, and Linux by default. The startup entry reuses the saved Google session,
+reconnects quietly, and only opens the connection page again if sign-in or
+first-run role setup is needed. Turn this off in **Settings > Desktop app**.
 
 On the Hub computer, open the VuvoDesk dashboard, sign in, and run **Sync
 Server** once. The dashboard transfers the signed-in session to the local Hub;

package/electron/after-pack.cjs

@@ -0,0 +1,31 @@
+const { chmodSync, existsSync, statSync } = require('node:fs');
+const { join } = require('node:path');
+
+module.exports = async function afterPack(context) {
+  if (context.electronPlatformName !== 'linux') {
+    return;
+  }
+
+  const remoteFastExecutable = join(
+    context.appOutDir,
+    'resources',
+    'app.asar.unpacked',
+    'node_modules',
+    '@livedesk',
+    'fast-linux-x64',
+    'fast',
+    'livedesk-client-fast'
+  );
+
+  if (!existsSync(remoteFastExecutable)) {
+    throw new Error(`Packaged Linux RemoteFast executable is missing: ${remoteFastExecutable}`);
+  }
+
+  chmodSync(remoteFastExecutable, 0o755);
+  const executableMode = statSync(remoteFastExecutable).mode & 0o777;
+  if ((executableMode & 0o111) !== 0o111) {
+    throw new Error(
+      `Packaged Linux RemoteFast must be executable before AppImage/deb assembly; mode=${executableMode.toString(8)}`
+    );
+  }
+};

package/electron/desktop-auto-start.mjs

@@ -0,0 +1,190 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+export const DESKTOP_AUTO_START_ARGUMENT = '--autostart';
+export const DESKTOP_AUTO_START_ENTRY_NAME = 'LiveDesk Desktop';
+const DESKTOP_AUTO_START_PREFERENCE_VERSION = 1;
+const SUPPORTED_PLATFORMS = new Set(['win32', 'darwin', 'linux']);
+
+function readPreference(path) {
+  try {
+    const record = JSON.parse(readFileSync(path, 'utf8'));
+    return record?.version === DESKTOP_AUTO_START_PREFERENCE_VERSION && typeof record.enabled === 'boolean'
+      ? record.enabled
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function writePreference(path, enabled) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify({
+    version: DESKTOP_AUTO_START_PREFERENCE_VERSION,
+    enabled: Boolean(enabled),
+    savedAt: new Date().toISOString()
+  }, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+}
+
+function quoteDesktopExecArgument(value) {
+  const escaped = String(value || '')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`');
+  return `"${escaped}"`;
+}
+
+function linuxDesktopEntry(executablePath) {
+  return [
+    '[Desktop Entry]',
+    'Type=Application',
+    'Version=1.0',
+    'Name=VuvoDesk',
+    'Comment=Start VuvoDesk and reconnect this computer automatically',
+    `Exec=${quoteDesktopExecArgument(executablePath)} ${DESKTOP_AUTO_START_ARGUMENT}`,
+    'Terminal=false',
+    'StartupNotify=false',
+    'X-GNOME-Autostart-enabled=true',
+    'X-VuvoDesk-Managed=true',
+    ''
+  ].join('\n');
+}
+
+export function createDesktopAutoStartOwner({
+  app,
+  stateRoot,
+  platform = process.platform,
+  environment = process.env,
+  executablePath = process.execPath,
+  argv = process.argv,
+  userHome = homedir(),
+  isPackaged = app?.isPackaged === true,
+  log = () => {}
+}) {
+  const supported = isPackaged && SUPPORTED_PLATFORMS.has(platform);
+  const preferencePath = join(stateRoot, 'desktop-auto-start.json');
+  const linuxConfigRoot = environment.XDG_CONFIG_HOME
+    ? resolve(environment.XDG_CONFIG_HOME)
+    : join(userHome, '.config');
+  const linuxEntryPath = join(linuxConfigRoot, 'autostart', 'vuvodesk.desktop');
+  const linuxExecutablePath = resolve(String(environment.APPIMAGE || executablePath));
+  const windowsLoginOptions = {
+    path: executablePath,
+    args: [DESKTOP_AUTO_START_ARGUMENT]
+  };
+
+  function desiredEnabled() {
+    return readPreference(preferencePath) ?? true;
+  }
+
+  function platformRegistered() {
+    if (!supported) return false;
+    if (platform === 'linux') {
+      try {
+        const entry = readFileSync(linuxEntryPath, 'utf8');
+        return entry.includes('X-VuvoDesk-Managed=true')
+          && entry.includes(DESKTOP_AUTO_START_ARGUMENT)
+          && entry.includes(quoteDesktopExecArgument(linuxExecutablePath));
+      } catch {
+        return false;
+      }
+    }
+    try {
+      const settings = platform === 'win32'
+        ? app.getLoginItemSettings(windowsLoginOptions)
+        : app.getLoginItemSettings();
+      return settings?.openAtLogin === true;
+    } catch {
+      return false;
+    }
+  }
+
+  function status(extra = {}) {
+    return {
+      supported,
+      enabled: desiredEnabled(),
+      registered: platformRegistered(),
+      platform,
+      ...extra
+    };
+  }
+
+  function apply(enabled) {
+    if (platform === 'linux') {
+      if (!enabled) {
+        rmSync(linuxEntryPath, { force: true });
+        return;
+      }
+      mkdirSync(dirname(linuxEntryPath), { recursive: true });
+      writeFileSync(linuxEntryPath, linuxDesktopEntry(linuxExecutablePath), { encoding: 'utf8', mode: 0o600 });
+      return;
+    }
+    if (platform === 'win32') {
+      app.setLoginItemSettings({
+        openAtLogin: enabled,
+        name: DESKTOP_AUTO_START_ENTRY_NAME,
+        ...windowsLoginOptions
+      });
+      return;
+    }
+    app.setLoginItemSettings({
+      openAtLogin: enabled,
+      openAsHidden: enabled
+    });
+  }
+
+  function reconcile() {
+    if (!supported) return status({ ok: false, error: 'desktop-auto-start-unavailable' });
+    const saved = readPreference(preferencePath);
+    const enabled = saved ?? true;
+    if (saved === null) writePreference(preferencePath, enabled);
+    try {
+      apply(enabled);
+      const next = status();
+      const ok = next.registered === enabled;
+      if (!ok) log(`desktop auto-start reconcile did not reach enabled=${enabled}`);
+      return { ...next, ok, error: ok ? '' : 'desktop-auto-start-registration-mismatch' };
+    } catch (error) {
+      const message = String(error?.message || error);
+      log(`desktop auto-start reconcile failed: ${message}`);
+      return status({ ok: false, error: message });
+    }
+  }
+
+  function setEnabled(enabled) {
+    if (!supported) return status({ ok: false, error: 'desktop-auto-start-unavailable' });
+    const desired = Boolean(enabled);
+    writePreference(preferencePath, desired);
+    try {
+      apply(desired);
+      const next = status();
+      const ok = next.registered === desired;
+      return { ...next, ok, error: ok ? '' : 'desktop-auto-start-registration-mismatch' };
+    } catch (error) {
+      const message = String(error?.message || error);
+      log(`desktop auto-start update failed: ${message}`);
+      return status({ ok: false, error: message });
+    }
+  }
+
+  function wasOpenedAutomatically() {
+    if (argv.includes(DESKTOP_AUTO_START_ARGUMENT)) return true;
+    if (platform !== 'darwin' || !supported) return false;
+    try {
+      return app.getLoginItemSettings()?.wasOpenedAtLogin === true;
+    } catch {
+      return false;
+    }
+  }
+
+  return {
+    getStatus: status,
+    reconcile,
+    setEnabled,
+    wasOpenedAutomatically,
+    preferencePath,
+    linuxEntryPath
+  };
+}

package/electron/electron-builder.linux-x64.yml

@@ -1,5 +1,6 @@
-extends: file:packages/livedesk/electron/electron-builder.yml
-files:
+extends: file:packages/livedesk/electron/electron-builder.yml
+afterPack: packages/livedesk/electron/after-pack.cjs
+files:
   - bin/**
   - bootstrap/**
   - client/**

package/electron/main.mjs

@@ -47,6 +47,7 @@ import {
 } from './runtime-role-transition.mjs';
 import { createDesktopClipboardOwner } from './desktop-clipboard-owner.mjs';
 import { createRuntimeWindowLoadOwner } from './runtime-window-load-owner.mjs';
+import { createDesktopAutoStartOwner } from './desktop-auto-start.mjs';
 
 // Chromium otherwise leaves an out-of-process Audio Service (~80-90 MiB on
 // Windows) alive after the exact Remote Audio owner, AudioContext, worklet,
@@ -55,9 +56,8 @@ import { createRuntimeWindowLoadOwner } from './runtime-window-load-owner.mjs';
 // warm-idle process baseline instead of retaining a hidden utility process.
 app.commandLine.appendSwitch('disable-features', 'AudioServiceOutOfProcess');
 
-const APP_NAME = 'VuvoDesk Desktop';
-const DESKTOP_STARTUP_ENTRY_NAME = 'LiveDesk Desktop';
-const appWindowTitle = () => `${APP_NAME} · ${app.getVersion()}`;
+const APP_NAME = 'VuvoDesk Desktop';
+const appWindowTitle = () => `${APP_NAME} · ${app.getVersion()}`;
 const LOCAL_RUNTIME_PORT = Number(process.env.LIVEDESK_LOCAL_RUNTIME_PORT || 5179);
 const LOCAL_RUNTIME_URL = `http://127.0.0.1:${Number.isInteger(LOCAL_RUNTIME_PORT) && LOCAL_RUNTIME_PORT > 0 ? LOCAL_RUNTIME_PORT : 5179}/`;
 function readDesktopPackageMetadata() {
@@ -172,6 +172,7 @@ let desktopSessionEpoch = 0;
 let lastKnownDesktopSession = null;
 let desktopClipboardOwner = null;
 let runtimeWindowLoadOwner = null;
+let desktopAutoStartOwner = null;
 const desktopAuthInvalidationGuard = createDesktopAuthInvalidationGuard();
 const installerQuitGate = createInstallerQuitGate({
   requestQuit: () => app.quit()
@@ -1089,7 +1090,7 @@ function showWindow() {
   requestDesktopResumeAuthRecovery('window-show');
 }
 
-function createMainWindow() {
+function createMainWindow({ showOnInitialLoad = true } = {}) {
   const iconPath = appResource('electron', 'icon.png');
   Menu.setApplicationMenu(null);
   runtimeWindowLoadOwner?.stop();
@@ -1126,7 +1127,7 @@ function createMainWindow() {
       if (window.webContents.getURL() !== DESKTOP_RUNTIME_RECOVERY_PAGE_URL) {
         await window.loadURL(DESKTOP_RUNTIME_RECOVERY_PAGE_URL);
       }
-      if (process.env.LIVEDESK_E2E_HEADLESS !== '1') showWindow();
+      if (showOnInitialLoad && process.env.LIVEDESK_E2E_HEADLESS !== '1') showWindow();
     },
     loadRuntime: async () => {
       if (window.isDestroyed() || window.webContents.isDestroyed()) {
@@ -1138,7 +1139,7 @@ function createMainWindow() {
       loadFailureCount = 0;
       updateTray('Running');
       log(`desktop renderer loaded current runtime; generation=${context.generation}; attempt=${context.attempt}`);
-      if (process.env.LIVEDESK_E2E_HEADLESS !== '1') showWindow();
+      if (showOnInitialLoad && process.env.LIVEDESK_E2E_HEADLESS !== '1') showWindow();
     },
     onAttemptError: (error, context) => {
       reportWindowLoadFailure(`${context.phase}: ${error?.message || error}`, context);
@@ -1258,9 +1259,13 @@ function registerIpc() {
     // Supabase may emit a null renderer session after a temporary failure.
     // Durable auth is cleared only by the explicit auth:sign-out IPC.
     return { ok: true, ignoredImplicitSignOut: true };
-  });
-  handle('app:quit', () => { app.quit(); return { ok: true }; });
-  handle('runtime:get-status', async () => {
+  });
+  handle('app:quit', () => { app.quit(); return { ok: true }; });
+  handle('app:get-auto-start', () => desktopAutoStartOwner?.getStatus()
+    || { supported: false, enabled: false, registered: false, platform: process.platform });
+  handle('app:set-auto-start', enabled => desktopAutoStartOwner?.setEnabled(Boolean(enabled))
+    || { ok: false, supported: false, enabled: false, registered: false, platform: process.platform, error: 'desktop-auto-start-unavailable' });
+  handle('runtime:get-status', async () => {
     try { return await fetch(`${LOCAL_RUNTIME_URL}api/runtime/status`).then(response => response.json()); }
     catch (error) { return { ok: false, error: mask(error?.message || error) }; }
   });
@@ -1321,7 +1326,15 @@ function createTray() {
     { label: 'About VuvoDesk', click: () => { void dialog.showMessageBox(mainWindow, { type: 'info', title: APP_NAME, message: APP_NAME, detail: `Version ${app.getVersion()}\nOne VuvoDesk runtime with Hub and Client roles.` }); } },
     { label: 'Open logs', click: () => { void shell.openPath(logDir); } },
     { type: 'separator' },
-    { label: 'Start with Windows', type: 'checkbox', checked: app.getLoginItemSettings().openAtLogin, click: item => app.setLoginItemSettings({ openAtLogin: item.checked, name: DESKTOP_STARTUP_ENTRY_NAME }) },
+    {
+      label: 'Start automatically',
+      type: 'checkbox',
+      checked: desktopAutoStartOwner?.getStatus().enabled === true,
+      click: item => {
+        const result = desktopAutoStartOwner?.setEnabled(item.checked);
+        if (result && result.ok !== true) item.checked = !item.checked;
+      }
+    },
     { label: 'Quit VuvoDesk', click: () => { app.quit(); } }
   ]);
   tray.setContextMenu(menu);
@@ -1350,10 +1363,18 @@ if (!app.requestSingleInstanceLock()) {
     if (protocolUrl) void handleProtocolUrl(protocolUrl);
     showWindow();
   });
-  app.whenReady().then(async () => {
+  app.whenReady().then(async () => {
     app.setAsDefaultProtocolClient('livedesk');
     removeLegacyStartupEntries();
     migrateLegacyPlaintextSession();
+    desktopAutoStartOwner = createDesktopAutoStartOwner({
+      app,
+      stateRoot,
+      isPackaged: app.isPackaged && DESKTOP_BUILD_FLAVOR !== 'e2e',
+      log
+    });
+    const autoStartStatus = desktopAutoStartOwner.reconcile();
+    log(`desktop auto-start enabled=${autoStartStatus.enabled} registered=${autoStartStatus.registered} platform=${autoStartStatus.platform} ok=${autoStartStatus.ok === true}`);
     let lastProductUpdateLogSignature = '';
     productUpdates = createProductUpdateManager({
       app,
@@ -1422,7 +1443,10 @@ if (!app.requestSingleInstanceLock()) {
         log(`secure auth session runtime sync failed: ${error?.message || error}`);
       }
     }
-    createMainWindow();
+    const showOnInitialLoad = !desktopAutoStartOwner.wasOpenedAutomatically()
+      || !startupSession
+      || !startupRole?.role;
+    createMainWindow({ showOnInitialLoad });
     createTray();
     if (DESKTOP_BUILD_FLAVOR !== 'e2e') recurringProductUpdates.start();
     if (DESKTOP_BUILD_FLAVOR === 'e2e') {

package/electron/preload.cjs

@@ -3,10 +3,12 @@ const { contextBridge, ipcRenderer } = require('electron');
 contextBridge.exposeInMainWorld('liveDesk', {
   app: {
     getVersion: () => ipcRenderer.invoke('app:get-version'),
-    restart: () => ipcRenderer.invoke('app:restart'),
-    quit: () => ipcRenderer.invoke('app:quit'),
-    about: () => ipcRenderer.invoke('app:about'),
-    showWindow: () => ipcRenderer.invoke('app:show-window')
+    restart: () => ipcRenderer.invoke('app:restart'),
+    quit: () => ipcRenderer.invoke('app:quit'),
+    about: () => ipcRenderer.invoke('app:about'),
+    showWindow: () => ipcRenderer.invoke('app:show-window'),
+    getAutoStart: () => ipcRenderer.invoke('app:get-auto-start'),
+    setAutoStart: enabled => ipcRenderer.invoke('app:set-auto-start', Boolean(enabled))
   },
   auth: {
     signInWithGoogle: () => ipcRenderer.invoke('auth:sign-in-google'),

package/hub/src/server.js

@@ -4342,27 +4342,35 @@ app.post('/api/settings/agent/summary', async (req, res) => {
   }
 });
 
-app.get('/api/remote/status', (_req, res) => {
-  noStore(res);
-  if (runtimeRole !== 'hub') {
+app.get('/api/remote/status', async (_req, res) => {
+  noStore(res);
+  if (runtimeRole !== 'hub') {
     res.status(403).json({ ok: false, error: 'role-not-allowed' });
     return;
   }
-  const secretStatus = remoteHub.getStatus({ includeSecrets: true });
-  res.json({
-    ...remoteHub.getStatus({ includeSecrets: false }),
-    pairingPin: secretStatus.pairingPin,
-    product: 'LiveDesk',
-    runtimeRole,
-    deviceId: runtimeDeviceId,
-    deviceName: runtimeDeviceName,
-    roleSource: runtimeRoleSource,
-    agentPackage: '@livedesk/client',
-    consoleRelay: hubConsoleRelay?.inspect() || { enabled: false, state: 'starting' },
-    frameLanes: snapshotFrameLaneResourceHealth(),
-    update: getLiveDeskUpdateStatus()
-  });
-});
+  try {
+    const [secretStatus, wallPreferences] = await Promise.all([
+      Promise.resolve(remoteHub.getStatus({ includeSecrets: true })),
+      liveDeskSettingsStore.getWallPreferencesRecord()
+    ]);
+    res.json({
+      ...remoteHub.getStatus({ includeSecrets: false }),
+      pairingPin: secretStatus.pairingPin,
+      product: 'LiveDesk',
+      runtimeRole,
+      deviceId: runtimeDeviceId,
+      deviceName: runtimeDeviceName,
+      roleSource: runtimeRoleSource,
+      agentPackage: '@livedesk/client',
+      wallPreferences,
+      consoleRelay: hubConsoleRelay?.inspect() || { enabled: false, state: 'starting' },
+      frameLanes: snapshotFrameLaneResourceHealth(),
+      update: getLiveDeskUpdateStatus()
+    });
+  } catch (error) {
+    res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
 
 app.post('/api/remote/diagnostics/transport/start', async (req, res) => {
   noStore(res);

package/hub/src/settings/settings-schema.js

@@ -46,9 +46,11 @@ export const DEFAULT_LIVEDESK_SETTINGS = Object.freeze({
     rememberLastMonitor: true,
     keepControlReadyBetweenPages: true
   },
-  wall: {
-    performanceMode: 'auto',
-    autoStart: true,
+  wall: {
+    performanceMode: 'auto',
+    cadence: 'fast',
+    viewScale: 100,
+    autoStart: true,
     connectedOnly: false,
     keepEmptySlots: true,
     showDeviceStatus: true,
@@ -110,9 +112,10 @@ export const DEFAULT_LIVEDESK_SETTINGS = Object.freeze({
   }
 });
 
-const ENUMS = {
+const ENUMS = {
   accessMode: new Set(['trusted-only', 'ask-every-time', 'view-only', 'block-remote-access']),
-  performanceMode: new Set(['auto', 'responsive', 'quality', 'custom']),
+  performanceMode: new Set(['auto', 'responsive', 'quality', 'custom']),
+  wallCadence: new Set(['slow', 'fast']),
   permissionMode: new Set(['ask', 'safe-auto', 'full-access', 'custom']),
   wallFrameMode: new Set(['auto', 'mode2-lzo', 'mode3-h264-hw', 'mode4-h264-atlas']),
   controlFrameMode: new Set(['mode3-h264-hw', 'mode5-lzo-delta']),
@@ -169,9 +172,11 @@ const RULES = {
   control: {
     ...bools(['allowKeyboardMouse', 'allowSystemShortcuts', 'allowClipboardText', 'allowRemoteRestart', 'reconnectAfterRemoteRestart', 'allowSwitchingMonitors', 'showConnectionToolbar', 'showRemoteCursor', 'openControlOnDoubleClick', 'startRemoteAudioWithControl', 'fitRemoteScreen', 'rememberLastMonitor', 'keepControlReadyBetweenPages'])
   },
-  wall: {
-    performanceMode: { type: 'enum', values: ENUMS.performanceMode },
-    ...bools(['autoStart', 'connectedOnly', 'keepEmptySlots', 'showDeviceStatus', 'showPerformanceDetails', 'pauseHiddenTiles', 'reduceWhenHidden', 'autoAdjustTileQuality', 'rememberDevicePositions'])
+  wall: {
+    performanceMode: { type: 'enum', values: ENUMS.performanceMode },
+    cadence: { type: 'enum', values: ENUMS.wallCadence },
+    viewScale: { type: 'number', min: 0, max: 100 },
+    ...bools(['autoStart', 'connectedOnly', 'keepEmptySlots', 'showDeviceStatus', 'showPerformanceDetails', 'pauseHiddenTiles', 'reduceWhenHidden', 'autoAdjustTileQuality', 'rememberDevicePositions'])
   },
   filesAudio: {
     ...bools(['allowFileTransfer', 'allowFolderSync', 'askBeforeReceivingFiles', 'openReceivedFolder', 'notifyTransferComplete', 'allowOverwrite', 'allowRemoteAudio', 'startAudioMuted', 'rememberVolume', 'automaticallyRecoverAudio', 'showAudioTroubleshooting', 'rollingBufferEnabled', 'includeRemoteCursor']),

package/hub/src/settings/settings-store.js

@@ -40,12 +40,22 @@ export class LiveDeskSettingsStore {
     return structuredClone(this.record);
   }
 
-  getCached() {
-    if (!this.record) return DEFAULT_LIVEDESK_SETTINGS;
-    return { ...this.record.settings, revision: this.record.revision };
-  }
-
-  async get() {
+  getCached() {
+    if (!this.record) return DEFAULT_LIVEDESK_SETTINGS;
+    return { ...this.record.settings, revision: this.record.revision };
+  }
+
+  async getWallPreferencesRecord() {
+    if (!this.record) await this.getRecord();
+    return {
+      revision: this.record.revision,
+      updatedAt: this.record.updatedAt,
+      cadence: this.record.settings.wall.cadence,
+      viewScale: this.record.settings.wall.viewScale
+    };
+  }
+
+  async get() {
     return publicSettings((await this.getRecord()).settings);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.618",
+  "version": "0.1.620",
   "livedeskClientVersion": "0.1.266",
   "buildFlavor": "production",
   "description": "VuvoDesk Hub and client launcher",

package/web/dist/app.webmanifest

@@ -4,7 +4,7 @@
   "short_name": "VuvoDesk",
   "description": "Monitor and control your VuvoDesk computers from your phone.",
   "lang": "en",
-  "start_url": "/app?pwa=0.1.618",
+  "start_url": "/app?pwa=0.1.619",
   "scope": "/",
   "display": "standalone",
   "orientation": "any",