@mindexec/cli 0.2.460 → 0.2.461

package/electron/main.cjs

@@ -1,12 +1,14 @@
 'use strict';
 
-const { app, BrowserWindow, dialog } = require('electron');
+const { app, BrowserWindow, dialog, ipcMain } = require('electron');
 const { spawn } = require('child_process');
 const fs = require('fs');
 const http = require('http');
 const net = require('net');
 const path = require('path');
 const workspaceState = require('../desktop-workspace-state.cjs');
+const { createProductUpdateManager } = require('./update-manager.cjs');
+const { createRecurringProductUpdateOwner } = require('./recurring-update-owner.cjs');
 
 const { resolveDesktopWorkspace } = workspaceState;
 
@@ -14,6 +16,7 @@ const DEFAULT_BRIDGE_PORT = 5147;
 const DEFAULT_REMOTE_HUB_PORT = 5198;
 const STARTUP_TIMEOUT_MS = 45_000;
 const HEALTH_POLL_MS = 250;
+const UPDATE_RUNTIME_RELEASE_TIMEOUT_MS = 10_000;
 const DESKTOP_APP_ID = 'com.mindexec.desktop';
 
 let mainWindow = null;
@@ -24,12 +27,24 @@ let activeBridgePort = DEFAULT_BRIDGE_PORT;
 let activeRemoteHubPort = DEFAULT_REMOTE_HUB_PORT;
 let activeWorkspace = '';
 let desktopWorkspaceStatePath = '';
+let productUpdates = null;
+let recurringProductUpdates = null;
+let updateInstallSequenceStarted = false;
+let updatePromptPromise = null;
+let updatePromptedVersion = '';
 
 function resolveDesktopIconPath() {
   const iconPath = path.resolve(__dirname, '..', 'wwwroot', 'icon-512.png');
   return fs.existsSync(iconPath) ? iconPath : undefined;
 }
 
+function resolveDesktopInstallKind() {
+  if (!app.isPackaged) return 'development';
+  if (process.env.PORTABLE_EXECUTABLE_FILE || process.env.PORTABLE_EXECUTABLE_DIR) return 'portable';
+  if (path.basename(path.dirname(process.execPath)).toLowerCase() === 'win-unpacked') return 'unpacked';
+  return process.platform === 'win32' ? 'installed' : 'unsupported-platform';
+}
+
 function parsePort(value) {
   const parsed = Number.parseInt(String(value ?? ''), 10);
   return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : 0;
@@ -205,6 +220,87 @@ async function prepareBundledRuntime() {
   return waitForBundledBridge();
 }
 
+function assertTrustedUpdateIpc(event) {
+  const senderUrl = event?.senderFrame?.url || event?.sender?.getURL?.() || '';
+  let sender;
+  try {
+    sender = new URL(senderUrl);
+  } catch {
+    throw new Error('desktop-update-ipc-sender-invalid');
+  }
+  if (sender.protocol !== 'http:' || sender.hostname !== '127.0.0.1' || sender.port !== String(activeBridgePort)) {
+    throw new Error('desktop-update-ipc-sender-untrusted');
+  }
+}
+
+function registerUpdateIpc() {
+  const handle = (channel, callback) => {
+    ipcMain.handle(channel, async (event) => {
+      assertTrustedUpdateIpc(event);
+      return callback();
+    });
+  };
+  handle('updates:get-status', () => productUpdates?.getStatus() || { state: 'unavailable' });
+  handle('updates:check', () => productUpdates?.check() || Promise.resolve({ state: 'unavailable' }));
+  handle('updates:install', () => productUpdates?.install() || Promise.resolve({ state: 'unavailable' }));
+}
+
+function sendUpdateStatus(status) {
+  appendDesktopLog(
+    `[update] state=${status.state} current=${status.currentVersion || ''} ` +
+    `available=${status.availableVersion || ''} progress=${Math.round(status.progress || 0)} ` +
+    `kind=${status.installKind || ''}${status.error ? ` error=${status.error}` : ''}`
+  );
+  if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.webContents.isDestroyed()) {
+    mainWindow.webContents.send('updates:status', status);
+  }
+  if (status.state === 'downloaded') void promptForDownloadedUpdate(status);
+}
+
+async function promptForDownloadedUpdate(status = productUpdates?.getStatus()) {
+  if (!status?.downloaded || !status.availableVersion || !mainWindow || mainWindow.isDestroyed()) return;
+  if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') return;
+  if (updatePromptedVersion === status.availableVersion || updatePromptPromise) return updatePromptPromise;
+
+  updatePromptedVersion = status.availableVersion;
+  updatePromptPromise = dialog.showMessageBox(mainWindow, {
+    type: 'info',
+    title: 'MindExec update ready',
+    message: `MindExec ${status.availableVersion} is ready.`,
+    detail: 'Restart now to use the new development build. Your project folder and saved data stay unchanged.',
+    buttons: ['Restart and update', 'Later'],
+    defaultId: 0,
+    cancelId: 1,
+    noLink: true
+  }).then(result => {
+    if (result.response === 0) return productUpdates?.install();
+    return productUpdates?.getStatus();
+  }).catch(error => {
+    appendDesktopLog(`[update:prompt-error] ${error?.stack || error}`);
+    return productUpdates?.getStatus();
+  }).finally(() => {
+    updatePromptPromise = null;
+  });
+  return updatePromptPromise;
+}
+
+function initializeProductUpdates() {
+  productUpdates = createProductUpdateManager({
+    app,
+    installKind: resolveDesktopInstallKind(),
+    onStatus: sendUpdateStatus,
+    beforeInstall: prepareRuntimeForUpdateInstall,
+    onInstallError: recoverRuntimeAfterUpdateInstallError
+  });
+  recurringProductUpdates = createRecurringProductUpdateOwner({
+    manager: productUpdates,
+    canRun: () => !isQuitting && !updateInstallSequenceStarted,
+    initialDelayMs: 30 * 60_000,
+    intervalMs: 30 * 60_000,
+    onError: error => appendDesktopLog(`[update:recurring-error] ${error?.stack || error}`)
+  });
+}
+
 function createMainWindow() {
   const hiddenSmokeMode = process.env.MINDEXEC_DESKTOP_SMOKE === '1';
   const window = new BrowserWindow({
@@ -218,6 +314,7 @@ function createMainWindow() {
     title: 'MindExec',
     icon: resolveDesktopIconPath(),
     webPreferences: {
+      preload: path.join(__dirname, 'preload.cjs'),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: true,
@@ -297,11 +394,48 @@ async function stopBundledBridge() {
   });
 }
 
+async function waitForBundledRuntimePortsReleased(timeoutMs = UPDATE_RUNTIME_RELEASE_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const [bridgeReleased, remoteHubReleased] = await Promise.all([
+      isPortAvailable(activeBridgePort),
+      isPortAvailable(activeRemoteHubPort)
+    ]);
+    if (bridgeReleased && remoteHubReleased) return;
+    await new Promise(resolve => setTimeout(resolve, HEALTH_POLL_MS));
+  }
+  throw new Error(
+    `Bundled runtime ports did not release before update: bridge=${activeBridgePort}, remoteHub=${activeRemoteHubPort}`
+  );
+}
+
+async function prepareRuntimeForUpdateInstall() {
+  if (updateInstallSequenceStarted) return;
+  updateInstallSequenceStarted = true;
+  recurringProductUpdates?.stop();
+  isQuitting = true;
+  appendDesktopLog('[update] stopping bundled runtime before installer launch');
+  await stopBundledBridge();
+  await waitForBundledRuntimePortsReleased();
+  appendDesktopLog('[update] bundled runtime and ports are fully released');
+}
+
+async function recoverRuntimeAfterUpdateInstallError(error) {
+  appendDesktopLog(`[update:install-recovery] ${error?.stack || error}`);
+  isQuitting = false;
+  updateInstallSequenceStarted = false;
+  if (!bridgeChild || bridgeChild.exitCode !== null) {
+    await prepareBundledRuntime();
+  }
+  recurringProductUpdates?.start();
+}
+
 async function launchDesktop() {
   const status = await prepareBundledRuntime();
   const window = createMainWindow();
   const appUrl = `http://127.0.0.1:${activeBridgePort}/mindcanvas`;
   await window.loadURL(appUrl);
+  void promptForDownloadedUpdate();
 
   if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') {
     writeSmokeResult({
@@ -312,7 +446,8 @@ async function launchDesktop() {
       bridgePort: activeBridgePort,
       remoteHubPort: activeRemoteHubPort,
       workspace: activeWorkspace,
-      url: appUrl
+      url: appUrl,
+      desktopUpdate: productUpdates?.getStatus() || null
     });
     setTimeout(() => app.quit(), 250).unref();
   }
@@ -345,12 +480,21 @@ if (!hasSingleInstanceLock) {
     }
 
     event.preventDefault();
+    recurringProductUpdates?.stop();
     isQuitting = true;
     stopBundledBridge().finally(() => app.exit(requestedExitCode));
   });
 
   app.whenReady()
-    .then(launchDesktop)
+    .then(async () => {
+      initializeProductUpdates();
+      registerUpdateIpc();
+      void productUpdates.checkAtStartup().catch(error => {
+        appendDesktopLog(`[update:startup-error] ${error?.stack || error}`);
+      });
+      await launchDesktop();
+      recurringProductUpdates.start();
+    })
     .catch((error) => {
       const message = error?.stack || String(error);
       appendDesktopLog(`[desktop:start-error] ${message}`);

package/electron/preload.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('mindExecDesktop', {
+  updates: {
+    getStatus: () => ipcRenderer.invoke('updates:get-status'),
+    check: () => ipcRenderer.invoke('updates:check'),
+    install: () => ipcRenderer.invoke('updates:install'),
+    onStatus: callback => {
+      if (typeof callback !== 'function') return () => undefined;
+      const listener = (_event, payload) => callback(payload);
+      ipcRenderer.on('updates:status', listener);
+      return () => ipcRenderer.removeListener('updates:status', listener);
+    }
+  }
+});

package/electron/recurring-update-owner-smoke.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import recurringOwnerModule from './recurring-update-owner.cjs';
+
+const { createRecurringProductUpdateOwner } = recurringOwnerModule;
+
+test('one recurring owner checks once and never installs without user approval', async () => {
+  let checkCalls = 0;
+  let installCalls = 0;
+  let timerCallback = null;
+  const manager = {
+    getStatus: () => ({ state: 'downloaded', downloaded: true }),
+    check: async () => {
+      checkCalls += 1;
+      await new Promise(resolve => setTimeout(resolve, 5));
+      return { state: 'downloaded', downloaded: true };
+    },
+    install: async () => { installCalls += 1; }
+  };
+  const owner = createRecurringProductUpdateOwner({
+    manager,
+    initialDelayMs: 1_000,
+    intervalMs: 1_000,
+    setTimer: callback => { timerCallback = callback; return { unref() {} }; },
+    clearTimer: () => { timerCallback = null; }
+  });
+
+  owner.start();
+  assert.equal(owner.inspect().timerCount, 1);
+  const [first, second] = await Promise.all([owner.runNow(), owner.runNow()]);
+  assert.equal(first.downloaded, true);
+  assert.equal(second.downloaded, true);
+  assert.equal(checkCalls, 1);
+  assert.equal(installCalls, 0);
+  assert.ok(timerCallback, 'the single next check must be re-armed');
+  owner.stop();
+  assert.equal(owner.inspect().timerCount, 0);
+});

package/electron/recurring-update-owner.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+const MINIMUM_UPDATE_DELAY_MS = 1_000;
+
+function normalizeDelay(value, fallback) {
+  const delay = Number(value);
+  return Number.isFinite(delay) && delay >= MINIMUM_UPDATE_DELAY_MS
+    ? Math.round(delay)
+    : fallback;
+}
+
+function createRecurringProductUpdateOwner({
+  manager,
+  canRun = () => true,
+  initialDelayMs = 30 * 60_000,
+  intervalMs = 30 * 60_000,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  onError = () => undefined
+} = {}) {
+  if (!manager || typeof manager.check !== 'function') {
+    throw new TypeError('recurring-product-update-manager-required');
+  }
+
+  const initialDelay = normalizeDelay(initialDelayMs, 30 * 60_000);
+  const interval = normalizeDelay(intervalMs, 30 * 60_000);
+  let stopped = true;
+  let generation = 0;
+  let timer = null;
+  let running = null;
+
+  const clearOwnedTimer = () => {
+    if (!timer) return;
+    clearTimer(timer);
+    timer = null;
+  };
+
+  const arm = (delay, ownerGeneration) => {
+    if (stopped || ownerGeneration !== generation || !canRun()) return;
+    clearOwnedTimer();
+    timer = setTimer(() => {
+      if (stopped || ownerGeneration !== generation) return;
+      timer = null;
+      void runCycle(ownerGeneration);
+    }, delay);
+    timer?.unref?.();
+  };
+
+  const runCycle = ownerGeneration => {
+    if (stopped || ownerGeneration !== generation || !canRun()) {
+      return Promise.resolve(manager.getStatus?.() || { state: 'stopped' });
+    }
+    if (running) return running;
+
+    const operation = Promise.resolve(manager.check());
+    running = operation;
+    void operation.catch(error => onError(error)).finally(() => {
+      if (running === operation) running = null;
+      arm(interval, ownerGeneration);
+    });
+    return operation;
+  };
+
+  return {
+    start() {
+      if (!stopped) return;
+      stopped = false;
+      generation += 1;
+      arm(initialDelay, generation);
+    },
+    stop() {
+      stopped = true;
+      generation += 1;
+      clearOwnedTimer();
+    },
+    runNow() {
+      clearOwnedTimer();
+      return runCycle(generation);
+    },
+    inspect() {
+      return {
+        stopped,
+        generation,
+        timerCount: timer ? 1 : 0,
+        running: Boolean(running),
+        initialDelayMs: initialDelay,
+        intervalMs: interval
+      };
+    }
+  };
+}
+
+module.exports = { createRecurringProductUpdateOwner };

package/electron/source-smoke.mjs

@@ -8,6 +8,9 @@ const electronDirectory = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(electronDirectory, '..');
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
 const mainSource = fs.readFileSync(path.join(electronDirectory, 'main.cjs'), 'utf8');
+const preloadSource = fs.readFileSync(path.join(electronDirectory, 'preload.cjs'), 'utf8');
+const updateManagerSource = fs.readFileSync(path.join(electronDirectory, 'update-manager.cjs'), 'utf8');
+const updateFeed = JSON.parse(fs.readFileSync(path.join(electronDirectory, 'update-feed.json'), 'utf8'));
 const serverSource = fs.readFileSync(path.join(packageRoot, 'server.js'), 'utf8');
 
 assert.equal(packageJson.build?.appId, 'com.mindexec.desktop', 'Stable desktop appId is required.');
@@ -18,6 +21,18 @@ assert.ok(packageJson.files?.includes('electron/'), 'The npm package must includ
 assert.ok(packageJson.files?.includes('desktop-workspace-state.cjs'), 'The npm package must include desktop workspace state.');
 assert.match(packageJson.scripts?.['desktop:build:win'] || '', /electron-builder/, 'Windows build script is missing.');
 assert.match(packageJson.scripts?.['test:desktop:win'] || '', /windows-package-smoke/, 'Packaged smoke test is missing.');
+assert.match(packageJson.scripts?.['desktop:publish:update:dev'] || '', /--channel dev[\s\S]*--allow-unsigned[\s\S]*--publish/,
+  'The explicit development update publishing command is missing.');
+assert.equal(packageJson.dependencies?.['electron-updater'], '^6.8.9', 'The packaged updater dependency is missing.');
+assert.equal(packageJson.build?.extraMetadata?.desktopUpdateChannel, 'dev', 'Development installers must stay on the dev feed.');
+assert.equal(packageJson.build?.publish?.provider, 'generic', 'Desktop updates must use the generic R2-backed provider.');
+assert.equal(
+  packageJson.build?.publish?.url,
+  'https://mindexec.lovecrdm.workers.dev/dev/windows/x64',
+  'The packaged development update URL changed unexpectedly.'
+);
+assert.equal(updateFeed.baseUrl, 'https://mindexec.lovecrdm.workers.dev', 'MindExec update hostname has a typo.');
+assert.equal(updateFeed.channel, 'dev', 'The packaged update feed must default to the isolated dev channel.');
 
 assert.equal(
   packageJson.build?.win?.icon,
@@ -52,6 +67,7 @@ assert.ok(targets.some((target) => target.target === 'portable'), 'Portable targ
 assert.match(mainSource, /contextIsolation:\s*true/, 'Electron renderer isolation must remain enabled.');
 assert.match(mainSource, /nodeIntegration:\s*false/, 'Node integration must remain disabled.');
 assert.match(mainSource, /sandbox:\s*true/, 'Electron renderer sandbox must remain enabled.');
+assert.match(mainSource, /preload:\s*path\.join\(__dirname, 'preload\.cjs'\)/, 'The isolated updater preload is missing.');
 assert.match(mainSource, /runtimeMode:\s*'bundled'/, 'Packaged runtime must report bundled mode.');
 assert.match(mainSource, /spawnBundledBridge/, 'Electron must start its bundled LocalBridge.');
 assert.match(mainSource, /wwwroot.*index\.html/s, 'Electron must verify its bundled frontend.');
@@ -62,6 +78,21 @@ assert.match(mainSource, /icon:\s*resolveDesktopIconPath\(\)/, 'Electron windows
 assert.match(mainSource, /app\.setAppUserModelId\(DESKTOP_APP_ID\)/, 'Windows taskbar identity must use the stable app id.');
 assert.match(mainSource, /resolveDesktopWorkspace/, 'Electron startup must restore the last desktop workspace.');
 assert.match(mainSource, /MINDEXEC_DESKTOP_WORKSPACE_STATE_PATH/, 'Electron must share its workspace state path with LocalBridge.');
+assert.match(mainSource, /resolveDesktopInstallKind/, 'Installed, portable, and unpacked update behavior must remain separate.');
+assert.match(mainSource, /createProductUpdateManager/, 'The Electron update manager is not wired into the app.');
+assert.match(mainSource, /updates:get-status/, 'The updater status IPC contract is missing.');
+assert.match(mainSource, /updates:check/, 'The manual updater check IPC contract is missing.');
+assert.match(mainSource, /updates:install/, 'The updater install IPC contract is missing.');
+assert.match(mainSource, /await stopBundledBridge\(\)[\s\S]{0,180}await waitForBundledRuntimePortsReleased\(\)/,
+  'The Bridge and RemoteHub ports must reach zero before the installer starts.');
+assert.match(mainSource, /Restart and update/, 'A downloaded update must ask before restarting active work.');
+assert.match(preloadSource, /mindExecDesktop/, 'The updater preload namespace changed unexpectedly.');
+assert.match(preloadSource, /updates:\s*\{/, 'The updater preload API is missing.');
+assert.match(updateManagerSource, /autoDownload\s*=\s*false/, 'Updates must not download through an unowned implicit path.');
+assert.match(updateManagerSource, /autoInstallOnAppQuit\s*=\s*false/, 'Updates must not restart without the explicit prompt path.');
+assert.match(updateManagerSource, /quitAndInstall\(true, true\)/, 'Downloaded updates must relaunch silently after approval.');
+assert.match(updateManagerSource, /desktop-updates-require-installed-windows-app/,
+  'Portable and unpacked builds must fail closed instead of replacing themselves.');
 assert.match(serverSource, /saveDesktopWorkspaceState\(DESKTOP_WORKSPACE_STATE_PATH, resolvedPath\)/,
   'A successful desktop workspace switch must be saved for the next launch.');
 
@@ -71,5 +102,6 @@ console.log(JSON.stringify({
   version: packageJson.version,
   runtimeMode: 'bundled',
   icon: packageJson.build.win.icon,
+  updateFeed: `${updateFeed.baseUrl}/${updateFeed.channel}/windows/x64`,
   targets: targets.map((target) => `${target.target}:${target.arch.join(',')}`)
 }));

package/electron/update-feed-resolver.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+const LOCAL_HTTP_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
+const CHANNEL_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const SEGMENT_PATTERN = /^[a-z0-9][a-z0-9/-]{0,127}$/;
+
+function normalizeUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function validateFeedUrl(value) {
+  const normalized = normalizeUrl(value);
+  if (!normalized) return { url: '', error: 'desktop-update-feed-not-configured' };
+
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    return { url: '', error: 'desktop-update-feed-invalid' };
+  }
+
+  const localHttp = parsed.protocol === 'http:' && LOCAL_HTTP_HOSTS.has(parsed.hostname);
+  if (parsed.protocol !== 'https:' && !localHttp) {
+    return { url: '', error: 'desktop-update-feed-insecure' };
+  }
+  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    return { url: '', error: 'desktop-update-feed-invalid' };
+  }
+
+  return { url: normalizeUrl(parsed.toString()), error: '' };
+}
+
+function resolveDesktopUpdateFeed({
+  config = {},
+  overrideUrl = '',
+  platform = process.platform,
+  arch = process.arch
+} = {}) {
+  const exactOverride = validateFeedUrl(overrideUrl);
+  if (String(overrideUrl || '').trim()) {
+    return {
+      ...exactOverride,
+      configured: Boolean(exactOverride.url),
+      platform,
+      arch,
+      channel: 'override'
+    };
+  }
+
+  const channel = String(config?.channel || 'dev').trim().toLowerCase();
+  const pathSegment = String(config?.paths?.[platform]?.[arch] || '')
+    .trim()
+    .replace(/^\/+|\/+$/g, '');
+  if (!CHANNEL_PATTERN.test(channel)) {
+    return { url: '', configured: false, error: 'desktop-update-channel-invalid', platform, arch, channel };
+  }
+  if (!SEGMENT_PATTERN.test(pathSegment)) {
+    return { url: '', configured: false, error: 'desktop-update-platform-unsupported', platform, arch, channel };
+  }
+
+  const base = validateFeedUrl(config?.baseUrl);
+  if (!base.url) {
+    return { ...base, configured: false, platform, arch, channel };
+  }
+
+  return {
+    url: `${base.url}/${channel}/${pathSegment}`,
+    configured: true,
+    error: '',
+    platform,
+    arch,
+    channel
+  };
+}
+
+module.exports = {
+  resolveDesktopUpdateFeed,
+  validateFeedUrl
+};

package/electron/update-feed.json

@@ -0,0 +1,10 @@
+{
+  "provider": "generic",
+  "baseUrl": "https://mindexec.lovecrdm.workers.dev",
+  "channel": "dev",
+  "paths": {
+    "win32": {
+      "x64": "windows/x64"
+    }
+  }
+}

package/electron/update-manager-smoke.mjs

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import test from 'node:test';
+import updateManagerModule from './update-manager.cjs';
+import updateFeedResolverModule from './update-feed-resolver.cjs';
+
+const { createProductUpdateManager } = updateManagerModule;
+const { resolveDesktopUpdateFeed } = updateFeedResolverModule;
+
+const feedConfig = {
+  baseUrl: 'https://updates.example',
+  channel: 'dev',
+  paths: { win32: { x64: 'windows/x64' } }
+};
+
+class FakeUpdater extends EventEmitter {
+  checkCalls = 0;
+  downloadCalls = 0;
+  feed = null;
+  installStarted = false;
+
+  setFeedURL(feed) { this.feed = feed; }
+
+  async checkForUpdates() {
+    this.checkCalls += 1;
+    this.emit('checking-for-update');
+    await new Promise(resolve => setTimeout(resolve, 5));
+    this.emit('update-available', { version: '1.1.0' });
+    return { updateInfo: { version: '1.1.0' } };
+  }
+
+  async downloadUpdate() {
+    this.downloadCalls += 1;
+    this.emit('download-progress', { percent: 42 });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    this.emit('update-downloaded', { version: '1.1.0' });
+  }
+
+  quitAndInstall() { this.installStarted = true; }
+}
+
+function createManager(updater, hooks = {}) {
+  return createProductUpdateManager({
+    app: {
+      isPackaged: true,
+      getVersion: () => '1.0.0',
+      getAppPath: () => process.cwd()
+    },
+    updater,
+    platform: 'win32',
+    arch: 'x64',
+    installKind: 'installed',
+    updateFeedConfig: feedConfig,
+    overrideUrl: '',
+    ...hooks
+  });
+}
+
+test('feed resolver pins Windows x64 to the exact development path and rejects insecure servers', () => {
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'x64' }).url,
+    'https://updates.example/dev/windows/x64'
+  );
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: { ...feedConfig, baseUrl: 'http://updates.example' }, platform: 'win32', arch: 'x64' }).error,
+    'desktop-update-feed-insecure'
+  );
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'arm64' }).error,
+    'desktop-update-platform-unsupported'
+  );
+});
+
+test('concurrent checks share one version request and one download', async () => {
+  const updater = new FakeUpdater();
+  const manager = createManager(updater);
+  const [first, second] = await Promise.all([manager.check(), manager.check()]);
+  assert.equal(first.state, 'downloaded');
+  assert.equal(second.state, 'downloaded');
+  assert.equal(updater.checkCalls, 1);
+  assert.equal(updater.downloadCalls, 1);
+  assert.deepEqual(updater.feed, { provider: 'generic', url: 'https://updates.example/dev/windows/x64' });
+});
+
+test('portable and unpacked executables never call electron-updater', async () => {
+  for (const installKind of ['portable', 'unpacked']) {
+    const updater = new FakeUpdater();
+    const manager = createManager(updater, { installKind });
+    const result = await manager.check();
+    assert.equal(result.state, 'unsupported');
+    assert.equal(result.updateSupported, false);
+    assert.equal(updater.checkCalls, 0);
+    assert.equal(updater.downloadCalls, 0);
+  }
+});
+
+test('install starts only after the owned runtime and ports are released', async () => {
+  const order = [];
+  const updater = new FakeUpdater();
+  updater.quitAndInstall = () => { order.push('installer'); updater.installStarted = true; };
+  const manager = createManager(updater, {
+    beforeInstall: async () => { order.push('runtime-and-ports-zero'); }
+  });
+  await manager.check();
+  await manager.install();
+  assert.deepEqual(order, ['runtime-and-ports-zero', 'installer']);
+  assert.equal(updater.installStarted, true);
+});
+
+test('a preparation or installer failure restores runtime ownership and allows retry', async () => {
+  const order = [];
+  const updater = new FakeUpdater();
+  let prepareAttempts = 0;
+  const manager = createManager(updater, {
+    beforeInstall: async () => {
+      prepareAttempts += 1;
+      order.push(`prepare-${prepareAttempts}`);
+      if (prepareAttempts === 1) throw new Error('runtime-release-failed');
+    },
+    onInstallError: async () => { order.push('runtime-restored'); }
+  });
+  await manager.check();
+  assert.equal((await manager.install()).state, 'error');
+  assert.equal((await manager.install()).state, 'installing');
+  assert.deepEqual(order, ['prepare-1', 'runtime-restored', 'prepare-2']);
+  assert.equal(updater.installStarted, true);
+});
+
+test('a slow update server never holds startup beyond its small budget', async () => {
+  const updater = new FakeUpdater();
+  updater.checkForUpdates = async () => {
+    updater.checkCalls += 1;
+    updater.emit('checking-for-update');
+    await new Promise(resolve => setTimeout(resolve, 80));
+    updater.emit('update-not-available');
+    return { updateInfo: { version: '1.0.0' } };
+  };
+  const manager = createManager(updater, { startupCheckTimeoutMs: 20 });
+  const startedAt = Date.now();
+  const status = await manager.checkAtStartup();
+  assert.ok(Date.now() - startedAt < 70, 'startup must continue while a slow check finishes in the background');
+  assert.equal(status.startupCheck, 'timed-out');
+  await new Promise(resolve => setTimeout(resolve, 90));
+  assert.equal(manager.getStatus().state, 'current');
+  assert.equal(manager.getStatus().startupCheck, 'complete');
+});