@mindexec/cli 0.2.478 → 0.2.480

package/electron/update-manager.cjs

@@ -1,297 +1,297 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { resolveDesktopUpdateFeed } = require('./update-feed-resolver.cjs');
-
-function createProductUpdateManager({
-  app,
-  onStatus = () => undefined,
-  beforeInstall = async () => undefined,
-  onInstallError = async () => undefined,
-  updater = null,
-  platform = process.platform,
-  arch = process.arch,
-  installKind = 'installed',
-  startupCheckTimeoutMs = 2_500,
-  updateFeedConfig = null,
-  updateChannel = '',
-  overrideUrl = process.env.MINDEXEC_UPDATE_URL || ''
-} = {}) {
-  if (!app) throw new TypeError('desktop-update-app-required');
-  if (!updater) updater = require('electron-updater').autoUpdater;
-
-  let feedConfig = updateFeedConfig;
-  let packageMetadata = {};
-  try {
-    packageMetadata = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'package.json'), 'utf8'));
-  } catch {
-    packageMetadata = {};
-  }
-  if (!feedConfig) {
-    try {
-      feedConfig = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'electron', 'update-feed.json'), 'utf8'));
-    } catch {
-      feedConfig = {};
-    }
-  }
-
-  const packagedChannel = String(updateChannel || packageMetadata?.desktopUpdateChannel || '')
-    .trim()
-    .toLowerCase();
-  if (packagedChannel) feedConfig = { ...feedConfig, channel: packagedChannel };
-  const feed = resolveDesktopUpdateFeed({ config: feedConfig, overrideUrl, platform, arch });
-  const updateSupported = Boolean(app.isPackaged && installKind === 'installed' && platform === 'win32');
-
-  let status = {
-    state: 'idle',
-    currentVersion: app.getVersion(),
-    availableVersion: '',
-    downloaded: false,
-    progress: 0,
-    error: '',
-    configured: feed.configured,
-    feedUrl: feed.url,
-    channel: feed.channel,
-    platform: feed.platform,
-    arch: feed.arch,
-    installKind,
-    updateSupported,
-    startupCheck: 'idle'
-  };
-  let installPromise = null;
-  let checkPromise = null;
-  let downloadPromise = null;
-  let cyclePromise = null;
-  let startupPromise = null;
-  let checkOutcome = 'idle';
-  let installRuntimePreparationStarted = false;
-  let installRecoveryPromise = null;
-
-  const publish = patch => {
-    status = { ...status, ...patch };
-    onStatus({ ...status });
-  };
-  const snapshot = () => ({ ...status, packaged: Boolean(app.isPackaged) });
-  const recoverPreparedRuntime = error => {
-    if (!installRuntimePreparationStarted) return Promise.resolve();
-    installRuntimePreparationStarted = false;
-    if (!installRecoveryPromise) {
-      installRecoveryPromise = Promise.resolve(onInstallError(error))
-        .catch(() => undefined)
-        .finally(() => {
-          installRecoveryPromise = null;
-          if (status.state === 'error') installPromise = null;
-        });
-    }
-    return installRecoveryPromise;
-  };
-
-  updater.autoDownload = false;
-  updater.autoInstallOnAppQuit = false;
-  if (feed.url) updater.setFeedURL({ provider: 'generic', url: feed.url });
-
-  updater.on('checking-for-update', () => {
-    checkOutcome = 'checking';
-    publish({ state: 'checking', error: '' });
-  });
-  updater.on('update-available', info => {
-    checkOutcome = 'available';
-    publish({
-      state: 'available',
-      availableVersion: String(info?.version || ''),
-      downloaded: false,
-      progress: 0,
-      error: ''
-    });
-  });
-  updater.on('update-not-available', () => {
-    checkOutcome = 'current';
-    publish({ state: 'current', availableVersion: '', downloaded: false, progress: 0, error: '' });
-  });
-  updater.on('download-progress', progress => {
-    publish({ state: 'downloading', progress: Number(progress?.percent || 0), error: '' });
-  });
-  updater.on('update-downloaded', info => {
-    publish({
-      state: 'downloaded',
-      downloaded: true,
-      progress: 100,
-      availableVersion: String(info?.version || status.availableVersion || ''),
-      error: ''
-    });
-  });
-  updater.on('error', error => {
-    checkOutcome = 'error';
-    publish({ state: 'error', error: String(error?.message || error) });
-    void recoverPreparedRuntime(error);
-  });
-
-  const blockedStatus = () => {
-    if (!app.isPackaged) {
-      return { ...snapshot(), state: 'development', error: 'desktop-updates-require-packaged-app' };
-    }
-    if (!updateSupported) {
-      return { ...snapshot(), state: 'unsupported', error: 'desktop-updates-require-installed-windows-app' };
-    }
-    return null;
-  };
-  const unavailableStatus = () => ({
-    ...snapshot(),
-    state: 'unavailable',
-    error: feed.error || 'desktop-update-feed-not-configured'
-  });
-
-  const checkForUpdates = async () => {
-    const blocked = blockedStatus();
-    if (blocked) return blocked;
-    if (!feed.url) return unavailableStatus();
-    if (checkPromise) return checkPromise;
-
-    const operation = (async () => {
-      checkOutcome = 'checking';
-      publish({ state: 'checking', error: '' });
-      try {
-        const result = await updater.checkForUpdates();
-        if (checkOutcome === 'checking') {
-          const availableVersion = String(result?.updateInfo?.version || status.availableVersion || '');
-          const updateAvailable = Boolean(availableVersion && availableVersion !== app.getVersion());
-          checkOutcome = updateAvailable ? 'available' : 'current';
-          publish({
-            state: checkOutcome,
-            availableVersion: updateAvailable ? availableVersion : '',
-            downloaded: updateAvailable ? status.downloaded : false,
-            progress: updateAvailable ? status.progress : 0,
-            error: ''
-          });
-        }
-      } catch (error) {
-        checkOutcome = 'error';
-        publish({ state: 'error', error: String(error?.message || error) });
-      }
-      return snapshot();
-    })();
-    checkPromise = operation;
-    try {
-      return await operation;
-    } finally {
-      if (checkPromise === operation) checkPromise = null;
-    }
-  };
-
-  const downloadUpdate = async () => {
-    const blocked = blockedStatus();
-    if (blocked) return blocked;
-    if (!feed.url) return unavailableStatus();
-    if (status.downloaded) return snapshot();
-    if (downloadPromise) return downloadPromise;
-
-    const operation = (async () => {
-      try {
-        publish({ state: 'downloading', progress: Math.max(0, Number(status.progress || 0)), error: '' });
-        await updater.downloadUpdate();
-        if (!status.downloaded) {
-          publish({ state: 'downloaded', downloaded: true, progress: 100, error: '' });
-        }
-      } catch (error) {
-        publish({ state: 'error', error: String(error?.message || error) });
-      }
-      return snapshot();
-    })();
-    downloadPromise = operation;
-    try {
-      return await operation;
-    } finally {
-      if (downloadPromise === operation) downloadPromise = null;
-    }
-  };
-
-  const checkAndDownload = async () => {
-    if (cyclePromise) return cyclePromise;
-    const operation = (async () => {
-      const checked = await checkForUpdates();
-      if (checked.state === 'available') return downloadUpdate();
-      return checked;
-    })();
-    cyclePromise = operation;
-    try {
-      return await operation;
-    } finally {
-      if (cyclePromise === operation) cyclePromise = null;
-    }
-  };
-
-  return {
-    getStatus() {
-      return snapshot();
-    },
-    async check() {
-      return checkAndDownload();
-    },
-    async checkAtStartup() {
-      if (startupPromise) return startupPromise;
-      const operation = (async () => {
-        const blocked = blockedStatus();
-        if (blocked || !feed.url) return checkForUpdates();
-
-        publish({ startupCheck: 'checking' });
-        const background = checkAndDownload().finally(() => {
-          publish({ startupCheck: 'complete' });
-        });
-        let timeoutId;
-        const timeout = new Promise(resolve => {
-          timeoutId = setTimeout(
-            () => resolve('timeout'),
-            Math.max(10, Number(startupCheckTimeoutMs) || 2_500)
-          );
-          timeoutId.unref?.();
-        });
-        const result = await Promise.race([background, timeout]);
-        clearTimeout(timeoutId);
-        if (result === 'timeout') {
-          publish({ startupCheck: 'timed-out' });
-          return snapshot();
-        }
-        return result;
-      })();
-      startupPromise = operation;
-      try {
-        return await operation;
-      } finally {
-        if (startupPromise === operation) startupPromise = null;
-      }
-    },
-    async install() {
-      const blocked = blockedStatus();
-      if (blocked) return blocked;
-      if (!feed.url) return unavailableStatus();
-      if (installPromise) return installPromise;
-
-      const operation = (async () => {
-        try {
-          if (!status.downloaded) {
-            const downloadResult = await downloadUpdate();
-            if (!downloadResult.downloaded) return downloadResult;
-          }
-          installRuntimePreparationStarted = true;
-          await beforeInstall();
-          publish({ state: 'installing', error: '' });
-          updater.quitAndInstall(true, true);
-          return snapshot();
-        } catch (error) {
-          await recoverPreparedRuntime(error);
-          publish({ state: 'error', error: String(error?.message || error) });
-          return snapshot();
-        }
-      })();
-      installPromise = operation;
-      try {
-        return await operation;
-      } finally {
-        if (installPromise === operation && status.state !== 'installing') installPromise = null;
-      }
-    }
-  };
-}
-
-module.exports = { createProductUpdateManager };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveDesktopUpdateFeed } = require('./update-feed-resolver.cjs');
+
+function createProductUpdateManager({
+  app,
+  onStatus = () => undefined,
+  beforeInstall = async () => undefined,
+  onInstallError = async () => undefined,
+  updater = null,
+  platform = process.platform,
+  arch = process.arch,
+  installKind = 'installed',
+  startupCheckTimeoutMs = 2_500,
+  updateFeedConfig = null,
+  updateChannel = '',
+  overrideUrl = process.env.MINDEXEC_UPDATE_URL || ''
+} = {}) {
+  if (!app) throw new TypeError('desktop-update-app-required');
+  if (!updater) updater = require('electron-updater').autoUpdater;
+
+  let feedConfig = updateFeedConfig;
+  let packageMetadata = {};
+  try {
+    packageMetadata = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'package.json'), 'utf8'));
+  } catch {
+    packageMetadata = {};
+  }
+  if (!feedConfig) {
+    try {
+      feedConfig = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'electron', 'update-feed.json'), 'utf8'));
+    } catch {
+      feedConfig = {};
+    }
+  }
+
+  const packagedChannel = String(updateChannel || packageMetadata?.desktopUpdateChannel || '')
+    .trim()
+    .toLowerCase();
+  if (packagedChannel) feedConfig = { ...feedConfig, channel: packagedChannel };
+  const feed = resolveDesktopUpdateFeed({ config: feedConfig, overrideUrl, platform, arch });
+  const updateSupported = Boolean(app.isPackaged && installKind === 'installed' && platform === 'win32');
+
+  let status = {
+    state: 'idle',
+    currentVersion: app.getVersion(),
+    availableVersion: '',
+    downloaded: false,
+    progress: 0,
+    error: '',
+    configured: feed.configured,
+    feedUrl: feed.url,
+    channel: feed.channel,
+    platform: feed.platform,
+    arch: feed.arch,
+    installKind,
+    updateSupported,
+    startupCheck: 'idle'
+  };
+  let installPromise = null;
+  let checkPromise = null;
+  let downloadPromise = null;
+  let cyclePromise = null;
+  let startupPromise = null;
+  let checkOutcome = 'idle';
+  let installRuntimePreparationStarted = false;
+  let installRecoveryPromise = null;
+
+  const publish = patch => {
+    status = { ...status, ...patch };
+    onStatus({ ...status });
+  };
+  const snapshot = () => ({ ...status, packaged: Boolean(app.isPackaged) });
+  const recoverPreparedRuntime = error => {
+    if (!installRuntimePreparationStarted) return Promise.resolve();
+    installRuntimePreparationStarted = false;
+    if (!installRecoveryPromise) {
+      installRecoveryPromise = Promise.resolve(onInstallError(error))
+        .catch(() => undefined)
+        .finally(() => {
+          installRecoveryPromise = null;
+          if (status.state === 'error') installPromise = null;
+        });
+    }
+    return installRecoveryPromise;
+  };
+
+  updater.autoDownload = false;
+  updater.autoInstallOnAppQuit = false;
+  if (feed.url) updater.setFeedURL({ provider: 'generic', url: feed.url });
+
+  updater.on('checking-for-update', () => {
+    checkOutcome = 'checking';
+    publish({ state: 'checking', error: '' });
+  });
+  updater.on('update-available', info => {
+    checkOutcome = 'available';
+    publish({
+      state: 'available',
+      availableVersion: String(info?.version || ''),
+      downloaded: false,
+      progress: 0,
+      error: ''
+    });
+  });
+  updater.on('update-not-available', () => {
+    checkOutcome = 'current';
+    publish({ state: 'current', availableVersion: '', downloaded: false, progress: 0, error: '' });
+  });
+  updater.on('download-progress', progress => {
+    publish({ state: 'downloading', progress: Number(progress?.percent || 0), error: '' });
+  });
+  updater.on('update-downloaded', info => {
+    publish({
+      state: 'downloaded',
+      downloaded: true,
+      progress: 100,
+      availableVersion: String(info?.version || status.availableVersion || ''),
+      error: ''
+    });
+  });
+  updater.on('error', error => {
+    checkOutcome = 'error';
+    publish({ state: 'error', error: String(error?.message || error) });
+    void recoverPreparedRuntime(error);
+  });
+
+  const blockedStatus = () => {
+    if (!app.isPackaged) {
+      return { ...snapshot(), state: 'development', error: 'desktop-updates-require-packaged-app' };
+    }
+    if (!updateSupported) {
+      return { ...snapshot(), state: 'unsupported', error: 'desktop-updates-require-installed-windows-app' };
+    }
+    return null;
+  };
+  const unavailableStatus = () => ({
+    ...snapshot(),
+    state: 'unavailable',
+    error: feed.error || 'desktop-update-feed-not-configured'
+  });
+
+  const checkForUpdates = async () => {
+    const blocked = blockedStatus();
+    if (blocked) return blocked;
+    if (!feed.url) return unavailableStatus();
+    if (checkPromise) return checkPromise;
+
+    const operation = (async () => {
+      checkOutcome = 'checking';
+      publish({ state: 'checking', error: '' });
+      try {
+        const result = await updater.checkForUpdates();
+        if (checkOutcome === 'checking') {
+          const availableVersion = String(result?.updateInfo?.version || status.availableVersion || '');
+          const updateAvailable = Boolean(availableVersion && availableVersion !== app.getVersion());
+          checkOutcome = updateAvailable ? 'available' : 'current';
+          publish({
+            state: checkOutcome,
+            availableVersion: updateAvailable ? availableVersion : '',
+            downloaded: updateAvailable ? status.downloaded : false,
+            progress: updateAvailable ? status.progress : 0,
+            error: ''
+          });
+        }
+      } catch (error) {
+        checkOutcome = 'error';
+        publish({ state: 'error', error: String(error?.message || error) });
+      }
+      return snapshot();
+    })();
+    checkPromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (checkPromise === operation) checkPromise = null;
+    }
+  };
+
+  const downloadUpdate = async () => {
+    const blocked = blockedStatus();
+    if (blocked) return blocked;
+    if (!feed.url) return unavailableStatus();
+    if (status.downloaded) return snapshot();
+    if (downloadPromise) return downloadPromise;
+
+    const operation = (async () => {
+      try {
+        publish({ state: 'downloading', progress: Math.max(0, Number(status.progress || 0)), error: '' });
+        await updater.downloadUpdate();
+        if (!status.downloaded) {
+          publish({ state: 'downloaded', downloaded: true, progress: 100, error: '' });
+        }
+      } catch (error) {
+        publish({ state: 'error', error: String(error?.message || error) });
+      }
+      return snapshot();
+    })();
+    downloadPromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (downloadPromise === operation) downloadPromise = null;
+    }
+  };
+
+  const checkAndDownload = async () => {
+    if (cyclePromise) return cyclePromise;
+    const operation = (async () => {
+      const checked = await checkForUpdates();
+      if (checked.state === 'available') return downloadUpdate();
+      return checked;
+    })();
+    cyclePromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (cyclePromise === operation) cyclePromise = null;
+    }
+  };
+
+  return {
+    getStatus() {
+      return snapshot();
+    },
+    async check() {
+      return checkAndDownload();
+    },
+    async checkAtStartup() {
+      if (startupPromise) return startupPromise;
+      const operation = (async () => {
+        const blocked = blockedStatus();
+        if (blocked || !feed.url) return checkForUpdates();
+
+        publish({ startupCheck: 'checking' });
+        const background = checkAndDownload().finally(() => {
+          publish({ startupCheck: 'complete' });
+        });
+        let timeoutId;
+        const timeout = new Promise(resolve => {
+          timeoutId = setTimeout(
+            () => resolve('timeout'),
+            Math.max(10, Number(startupCheckTimeoutMs) || 2_500)
+          );
+          timeoutId.unref?.();
+        });
+        const result = await Promise.race([background, timeout]);
+        clearTimeout(timeoutId);
+        if (result === 'timeout') {
+          publish({ startupCheck: 'timed-out' });
+          return snapshot();
+        }
+        return result;
+      })();
+      startupPromise = operation;
+      try {
+        return await operation;
+      } finally {
+        if (startupPromise === operation) startupPromise = null;
+      }
+    },
+    async install() {
+      const blocked = blockedStatus();
+      if (blocked) return blocked;
+      if (!feed.url) return unavailableStatus();
+      if (installPromise) return installPromise;
+
+      const operation = (async () => {
+        try {
+          if (!status.downloaded) {
+            const downloadResult = await downloadUpdate();
+            if (!downloadResult.downloaded) return downloadResult;
+          }
+          installRuntimePreparationStarted = true;
+          await beforeInstall();
+          publish({ state: 'installing', error: '' });
+          updater.quitAndInstall(true, true);
+          return snapshot();
+        } catch (error) {
+          await recoverPreparedRuntime(error);
+          publish({ state: 'error', error: String(error?.message || error) });
+          return snapshot();
+        }
+      })();
+      installPromise = operation;
+      try {
+        return await operation;
+      } finally {
+        if (installPromise === operation && status.state !== 'installing') installPromise = null;
+      }
+    }
+  };
+}
+
+module.exports = { createProductUpdateManager };