@tutti-os/desktop-update-admission 0.0.266

package/dist/development/mock-server-cli.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  resolveDesktopUpdateDevelopmentPolicyScenario,
+  startDesktopUpdateDevelopmentMockServer
+} from "../chunk-ZQTIYDGZ.js";
+import "../chunk-LV67FBCG.js";
+
+// src/development/mockServerCli.ts
+function log(level, details) {
+  const output = `[minimum-version-check] ${JSON.stringify(details)}`;
+  if (level === "error") {
+    process.stderr.write(`${output}
+`);
+  } else {
+    process.stdout.write(`${output}
+`);
+  }
+}
+async function main() {
+  const policy = resolveDesktopUpdateDevelopmentPolicyScenario({
+    env: process.env
+  });
+  if (!policy) {
+    throw new Error(
+      "DESKTOP_UPDATE_ADMISSION_DEV=1 is required to start the mock server"
+    );
+  }
+  const rawPort = process.env.DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_PORT?.trim();
+  const port = rawPort ? Number(rawPort) : void 0;
+  const server = await startDesktopUpdateDevelopmentMockServer({
+    port,
+    policy
+  });
+  log("info", {
+    baseUrl: server.baseUrl,
+    result: "listening",
+    stage: "development-mock-server"
+  });
+  let closing = false;
+  const close = async (signal) => {
+    if (closing) {
+      return;
+    }
+    closing = true;
+    await server.close();
+    log("info", {
+      result: "stopped",
+      signal,
+      stage: "development-mock-server"
+    });
+  };
+  process.once("SIGINT", () => {
+    void close("SIGINT");
+  });
+  process.once("SIGTERM", () => {
+    void close("SIGTERM");
+  });
+}
+void main().catch((error) => {
+  log("error", {
+    error: error instanceof Error ? error.message : String(error),
+    result: "failure",
+    stage: "development-mock-server"
+  });
+  process.exitCode = 1;
+});
+//# sourceMappingURL=mock-server-cli.js.map

package/dist/development/mock-server-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/development/mockServerCli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { resolveDesktopUpdateDevelopmentPolicyScenario } from \"./policyScenario.ts\";\nimport { startDesktopUpdateDevelopmentMockServer } from \"./mockServer.ts\";\n\nfunction log(level: \"info\" | \"error\", details: Record<string, unknown>): void {\n  const output = `[minimum-version-check] ${JSON.stringify(details)}`;\n  if (level === \"error\") {\n    process.stderr.write(`${output}\\n`);\n  } else {\n    process.stdout.write(`${output}\\n`);\n  }\n}\n\nasync function main(): Promise<void> {\n  const policy = resolveDesktopUpdateDevelopmentPolicyScenario({\n    env: process.env\n  });\n  if (!policy) {\n    throw new Error(\n      \"DESKTOP_UPDATE_ADMISSION_DEV=1 is required to start the mock server\"\n    );\n  }\n  const rawPort = process.env.DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_PORT?.trim();\n  const port = rawPort ? Number(rawPort) : undefined;\n  const server = await startDesktopUpdateDevelopmentMockServer({\n    port,\n    policy\n  });\n  log(\"info\", {\n    baseUrl: server.baseUrl,\n    result: \"listening\",\n    stage: \"development-mock-server\"\n  });\n  let closing = false;\n  const close = async (signal: string): Promise<void> => {\n    if (closing) {\n      return;\n    }\n    closing = true;\n    await server.close();\n    log(\"info\", {\n      result: \"stopped\",\n      signal,\n      stage: \"development-mock-server\"\n    });\n  };\n  process.once(\"SIGINT\", () => {\n    void close(\"SIGINT\");\n  });\n  process.once(\"SIGTERM\", () => {\n    void close(\"SIGTERM\");\n  });\n}\n\nvoid main().catch((error) => {\n  log(\"error\", {\n    error: error instanceof Error ? error.message : String(error),\n    result: \"failure\",\n    stage: \"development-mock-server\"\n  });\n  process.exitCode = 1;\n});\n"],"mappings":";;;;;;;;AAKA,SAAS,IAAI,OAAyB,SAAwC;AAC5E,QAAM,SAAS,2BAA2B,KAAK,UAAU,OAAO,CAAC;AACjE,MAAI,UAAU,SAAS;AACrB,YAAQ,OAAO,MAAM,GAAG,MAAM;AAAA,CAAI;AAAA,EACpC,OAAO;AACL,YAAQ,OAAO,MAAM,GAAG,MAAM;AAAA,CAAI;AAAA,EACpC;AACF;AAEA,eAAe,OAAsB;AACnC,QAAM,SAAS,8CAA8C;AAAA,IAC3D,KAAK,QAAQ;AAAA,EACf,CAAC;AACD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,QAAM,UAAU,QAAQ,IAAI,2CAA2C,KAAK;AAC5E,QAAM,OAAO,UAAU,OAAO,OAAO,IAAI;AACzC,QAAM,SAAS,MAAM,wCAAwC;AAAA,IAC3D;AAAA,IACA;AAAA,EACF,CAAC;AACD,MAAI,QAAQ;AAAA,IACV,SAAS,OAAO;AAAA,IAChB,QAAQ;AAAA,IACR,OAAO;AAAA,EACT,CAAC;AACD,MAAI,UAAU;AACd,QAAM,QAAQ,OAAO,WAAkC;AACrD,QAAI,SAAS;AACX;AAAA,IACF;AACA,cAAU;AACV,UAAM,OAAO,MAAM;AACnB,QAAI,QAAQ;AAAA,MACV,QAAQ;AAAA,MACR;AAAA,MACA,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AACA,UAAQ,KAAK,UAAU,MAAM;AAC3B,SAAK,MAAM,QAAQ;AAAA,EACrB,CAAC;AACD,UAAQ,KAAK,WAAW,MAAM;AAC5B,SAAK,MAAM,SAAS;AAAA,EACtB,CAAC;AACH;AAEA,KAAK,KAAK,EAAE,MAAM,CAAC,UAAU;AAC3B,MAAI,SAAS;AAAA,IACX,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAAA,IAC5D,QAAQ;AAAA,IACR,OAAO;AAAA,EACT,CAAC;AACD,UAAQ,WAAW;AACrB,CAAC;","names":[]}

package/dist/electron-main/index.d.ts

@@ -0,0 +1,38 @@
+import * as electron from 'electron';
+import { BrowserWindow, BrowserWindowConstructorOptions } from 'electron';
+import { DesktopProduct, DesktopUpdateAdmissionRuntime, MinimumVersionCheckRequest, MinimumVersionAppUpdateService, MinimumVersionCheckResponse } from '../contracts/index.js';
+
+interface DesktopUpdateAdmissionElectronRuntime {
+    app: typeof electron.app;
+    BrowserWindow: typeof electron.BrowserWindow;
+    ipcMain: typeof electron.ipcMain;
+    shell: typeof electron.shell;
+}
+interface DesktopUpdateAdmissionLogger {
+    info(message: string): void;
+    error(message: string): void;
+}
+interface DesktopUpdateAdmissionController {
+    runStartupCheck(): Promise<boolean>;
+    checkAfterForegroundRestore(): Promise<void>;
+    dispose(): void;
+}
+interface DesktopUpdateAdmissionControllerOptions<TProduct extends DesktopProduct> {
+    product: TProduct;
+    runtime: DesktopUpdateAdmissionRuntime;
+    electron: DesktopUpdateAdmissionElectronRuntime;
+    checkMinimumVersion(request: MinimumVersionCheckRequest<TProduct>, signal: AbortSignal): Promise<unknown>;
+    updateService: MinimumVersionAppUpdateService;
+    logger: DesktopUpdateAdmissionLogger;
+    onPolicyReleased(): void | Promise<void>;
+    preloadPath: string;
+    rendererFilePath: string;
+    rendererUrl?: string;
+    manualDownloadUrl(response: MinimumVersionCheckResponse<TProduct>): string;
+    listBusinessWindows(): BrowserWindow[];
+    icon?: BrowserWindowConstructorOptions["icon"];
+    now?: () => number;
+}
+declare function createDesktopUpdateAdmissionController<TProduct extends DesktopProduct>(options: DesktopUpdateAdmissionControllerOptions<TProduct>): DesktopUpdateAdmissionController;
+
+export { type DesktopUpdateAdmissionController, type DesktopUpdateAdmissionControllerOptions, type DesktopUpdateAdmissionLogger, createDesktopUpdateAdmissionController };

package/dist/electron-main/index.js

@@ -0,0 +1,498 @@
+import {
+  desktopUpdateAdmissionIpcChannels
+} from "../chunk-TRALK3GT.js";
+import {
+  DevelopmentInstallSuppressedError
+} from "../chunk-X4U7GODT.js";
+import {
+  MandatoryUpdateTargetError
+} from "../chunk-GONYAEKF.js";
+import {
+  resolveMinimumVersionRuntimeTarget,
+  shouldCheckMinimumVersionAfterForeground,
+  validateMinimumVersionResponse
+} from "../chunk-LV67FBCG.js";
+
+// src/electron-main/createDesktopUpdateAdmissionController.ts
+var startupCheckTimeoutMs = 3e3;
+var foregroundCheckTimeoutMs = 1e4;
+function logMinimumVersionCheck(logger, level, details) {
+  logger[level](`[minimum-version-check] ${JSON.stringify(details)}`);
+}
+function createDesktopUpdateAdmissionController(options) {
+  const { app, BrowserWindow, ipcMain, shell } = options.electron;
+  const now = options.now ?? Date.now;
+  let lastCheckAt = 0;
+  let foregroundPrompted = false;
+  let state = null;
+  let upgradeWindow = null;
+  let mode = "startup";
+  let forcedFlowStarted = false;
+  let installRequested = false;
+  let disposed = false;
+  let activeCheck = null;
+  let activeForcedFlow = null;
+  let appQuitStarted = false;
+  let mandatoryUpdateSession = null;
+  let isolatedBusinessWindows = null;
+  const lifecycleAbort = new AbortController();
+  const handleBeforeQuit = () => {
+    appQuitStarted = true;
+  };
+  app.on("before-quit", handleBeforeQuit);
+  const emitState = () => {
+    if (state && upgradeWindow && !upgradeWindow.isDestroyed()) {
+      upgradeWindow.webContents.send(
+        desktopUpdateAdmissionIpcChannels.state,
+        state
+      );
+    }
+  };
+  const applyState = (phase, update = options.updateService.getState(), message = null) => {
+    if (!state) {
+      return;
+    }
+    state = { ...state, message, phase, update };
+    emitState();
+  };
+  const closeUpgradeWindow = () => {
+    const currentWindow = upgradeWindow;
+    upgradeWindow = null;
+    if (currentWindow && !currentWindow.isDestroyed()) {
+      currentWindow.destroy();
+    }
+  };
+  const isolateBusinessWindows = () => {
+    if (isolatedBusinessWindows) {
+      return;
+    }
+    isolatedBusinessWindows = options.listBusinessWindows().filter(
+      (candidate) => candidate !== upgradeWindow && !candidate.isDestroyed()
+    ).map((candidate) => ({
+      wasFocused: candidate.isFocused(),
+      wasMinimized: candidate.isMinimized(),
+      wasVisible: candidate.isVisible(),
+      window: candidate
+    }));
+    for (const snapshot of isolatedBusinessWindows) {
+      snapshot.window.hide();
+    }
+  };
+  const restoreBusinessWindows = () => {
+    const snapshots = isolatedBusinessWindows;
+    isolatedBusinessWindows = null;
+    if (!snapshots) {
+      return;
+    }
+    let focusedWindow = null;
+    for (const snapshot of snapshots) {
+      if (snapshot.window.isDestroyed()) {
+        continue;
+      }
+      if (snapshot.wasMinimized) {
+        snapshot.window.show();
+        snapshot.window.minimize();
+      } else if (snapshot.wasVisible) {
+        snapshot.window.show();
+      }
+      if (snapshot.wasFocused) {
+        focusedWindow = snapshot.window;
+      }
+    }
+    if (focusedWindow && !focusedWindow.isDestroyed() && !focusedWindow.isMinimized()) {
+      focusedWindow.focus();
+    }
+  };
+  const openUpgradeWindow = (nextMode) => {
+    if (upgradeWindow && !upgradeWindow.isDestroyed()) {
+      upgradeWindow.show();
+      upgradeWindow.focus();
+      return;
+    }
+    mode = nextMode;
+    const window = new BrowserWindow({
+      autoHideMenuBar: true,
+      fullscreenable: false,
+      height: 420,
+      icon: options.icon,
+      maximizable: false,
+      minHeight: 380,
+      minWidth: 480,
+      resizable: false,
+      show: false,
+      webPreferences: {
+        contextIsolation: true,
+        nodeIntegration: false,
+        preload: options.preloadPath,
+        sandbox: true
+      },
+      width: 520
+    });
+    upgradeWindow = window;
+    window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+    window.webContents.on("will-navigate", (event) => event.preventDefault());
+    window.on("close", (event) => {
+      if (!appQuitStarted && (mode === "startup" || forcedFlowStarted)) {
+        event.preventDefault();
+        app.quit();
+      }
+    });
+    window.on("closed", () => {
+      if (upgradeWindow === window) {
+        upgradeWindow = null;
+      }
+    });
+    window.once("ready-to-show", () => {
+      if (!window.isDestroyed()) {
+        window.show();
+      }
+    });
+    const search = `mode=${nextMode}`;
+    if (options.rendererUrl) {
+      void window.loadURL(`${options.rendererUrl}?${search}`);
+    } else {
+      void window.loadFile(options.rendererFilePath, { search });
+    }
+  };
+  const requestPayload = () => {
+    const target = resolveMinimumVersionRuntimeTarget(
+      process.platform,
+      process.arch
+    );
+    if (!target) {
+      return null;
+    }
+    return {
+      ...target,
+      currentVersion: options.runtime.currentVersion,
+      product: options.product
+    };
+  };
+  const runPolicyCheck = async (bounded) => {
+    const request = requestPayload();
+    if (!request) {
+      lastCheckAt = now();
+      logMinimumVersionCheck(options.logger, "info", {
+        architecture: process.arch,
+        decision: "notApplicable",
+        platform: process.platform,
+        reason: "unsupportedRuntime",
+        result: "success",
+        stage: bounded ? "startup" : "foreground"
+      });
+      return null;
+    }
+    const startedAt = now();
+    const controller = new AbortController();
+    const abortForLifecycle = () => controller.abort();
+    lifecycleAbort.signal.addEventListener("abort", abortForLifecycle, {
+      once: true
+    });
+    let timer = null;
+    try {
+      const timeoutMs = bounded ? startupCheckTimeoutMs : foregroundCheckTimeoutMs;
+      const response = await Promise.race([
+        options.checkMinimumVersion(request, controller.signal),
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`minimum version check exceeded ${timeoutMs}ms`));
+          }, timeoutMs);
+        })
+      ]);
+      const validated = validateMinimumVersionResponse(response, request);
+      lastCheckAt = now();
+      logMinimumVersionCheck(options.logger, "info", {
+        currentVersion: validated.currentVersion,
+        decision: validated.decision,
+        elapsedMs: now() - startedAt,
+        minimumVersion: validated.minimumVersion,
+        policyRevision: validated.policyRevision,
+        reason: validated.reason,
+        result: "success",
+        stage: bounded ? "startup" : "foreground"
+      });
+      return validated;
+    } catch (error) {
+      lastCheckAt = now();
+      logMinimumVersionCheck(options.logger, "error", {
+        elapsedMs: now() - startedAt,
+        error: error instanceof Error ? error.message : String(error),
+        result: "failure",
+        stage: bounded ? "startup" : "foreground"
+      });
+      return null;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      lifecycleAbort.signal.removeEventListener("abort", abortForLifecycle);
+    }
+  };
+  const checkPolicy = async (bounded) => {
+    if (activeCheck) {
+      return activeCheck;
+    }
+    const pendingCheck = runPolicyCheck(bounded);
+    activeCheck = pendingCheck;
+    try {
+      return await pendingCheck;
+    } finally {
+      if (activeCheck === pendingCheck) {
+        activeCheck = null;
+      }
+    }
+  };
+  const releaseMandatoryUpdater = async (restoreNormal = true) => {
+    const session = mandatoryUpdateSession;
+    mandatoryUpdateSession = null;
+    try {
+      await session?.release({ restoreNormal });
+    } catch (error) {
+      logMinimumVersionCheck(options.logger, "error", {
+        error: error instanceof Error ? error.message : String(error),
+        result: "failure",
+        stage: "normal-update-restore"
+      });
+    }
+  };
+  const releasePolicyBlock = async () => {
+    applyState("released");
+    forcedFlowStarted = false;
+    installRequested = false;
+    await releaseMandatoryUpdater();
+    closeUpgradeWindow();
+    restoreBusinessWindows();
+    await options.onPolicyReleased();
+  };
+  const installForcedUpdate = async () => {
+    if (installRequested) {
+      return;
+    }
+    installRequested = true;
+    try {
+      if (!mandatoryUpdateSession) {
+        throw new Error("mandatory update session is unavailable");
+      }
+      await mandatoryUpdateSession.installUpdate();
+    } catch (error) {
+      installRequested = false;
+      if (error instanceof DevelopmentInstallSuppressedError) {
+        logMinimumVersionCheck(options.logger, "info", {
+          result: "simulated",
+          stage: "install"
+        });
+        applyState("simulationComplete", options.updateService.getState());
+        return;
+      }
+      logMinimumVersionCheck(options.logger, "error", {
+        error: error instanceof Error ? error.message : String(error),
+        result: "failure",
+        stage: "install"
+      });
+      applyState("error", options.updateService.getState(), "installFailed");
+    }
+  };
+  const prepareAndDownloadForcedUpdate = async () => {
+    if (!state) {
+      return;
+    }
+    try {
+      forcedFlowStarted = true;
+      applyState("checking");
+      const target = {
+        channel: state.check.channel === "rc" ? "rc" : "stable",
+        minimumVersion: state.check.minimumVersion,
+        policyRevision: state.check.policyRevision
+      };
+      if (mandatoryUpdateSession) {
+        mandatoryUpdateSession.retarget(target);
+      } else {
+        const acquiredSession = await options.updateService.acquireMandatorySession(target);
+        if (disposed) {
+          await acquiredSession.release({ restoreNormal: false });
+          return;
+        }
+        mandatoryUpdateSession = acquiredSession;
+      }
+      const prepared = await mandatoryUpdateSession.prepare();
+      if (prepared.status === "downloaded") {
+        applyState("downloaded", prepared);
+        await installForcedUpdate();
+        return;
+      }
+      if (prepared.status !== "available") {
+        applyState("error", prepared, "updateUnavailable");
+        return;
+      }
+      applyState("ready", prepared);
+      const downloaded = await mandatoryUpdateSession.downloadUpdate();
+      if (downloaded.status !== "downloaded") {
+        applyState("error", downloaded, "updateFailed");
+        return;
+      }
+      applyState("downloaded", downloaded);
+      await installForcedUpdate();
+    } catch (error) {
+      logMinimumVersionCheck(options.logger, "error", {
+        error: error instanceof Error ? error.message : String(error),
+        result: "failure",
+        stage: "forced-update"
+      });
+      applyState(
+        "error",
+        options.updateService.getState(),
+        error instanceof MandatoryUpdateTargetError ? "releaseBelowMinimum" : "updateFailed"
+      );
+    }
+  };
+  const runForcedUpdateFlow = () => {
+    if (activeForcedFlow) {
+      return activeForcedFlow;
+    }
+    const pending = prepareAndDownloadForcedUpdate();
+    activeForcedFlow = pending;
+    void pending.then(
+      () => {
+        if (activeForcedFlow === pending) {
+          activeForcedFlow = null;
+        }
+      },
+      () => {
+        if (activeForcedFlow === pending) {
+          activeForcedFlow = null;
+        }
+      }
+    );
+    return pending;
+  };
+  const unsubscribeUpdate = options.updateService.subscribe((update) => {
+    if (!state || !forcedFlowStarted) {
+      return;
+    }
+    if (update.status === "downloading") {
+      applyState("downloading", update);
+    } else if (update.status === "error") {
+      installRequested = false;
+      applyState("error", update, "updateFailed");
+    }
+  });
+  const assertUpgradeWindowSender = (senderId) => {
+    if (!upgradeWindow || upgradeWindow.isDestroyed() || upgradeWindow.webContents.id !== senderId) {
+      throw new Error(
+        "desktop update admission IPC is restricted to the upgrade window"
+      );
+    }
+  };
+  ipcMain.handle(desktopUpdateAdmissionIpcChannels.getState, (event) => {
+    assertUpgradeWindowSender(event.sender.id);
+    return state;
+  });
+  ipcMain.handle(desktopUpdateAdmissionIpcChannels.start, async (event) => {
+    assertUpgradeWindowSender(event.sender.id);
+    if (mode === "foreground") {
+      isolateBusinessWindows();
+    }
+    await runForcedUpdateFlow();
+    return state;
+  });
+  ipcMain.handle(desktopUpdateAdmissionIpcChannels.retry, async (event) => {
+    assertUpgradeWindowSender(event.sender.id);
+    await activeForcedFlow;
+    const response = await checkPolicy(false);
+    if (!response) {
+      applyState(
+        "error",
+        options.updateService.getState(),
+        "policyCheckFailed"
+      );
+    } else if (response.decision !== "upgradeRequired") {
+      await releasePolicyBlock();
+    } else if (state) {
+      state = { ...state, check: response };
+      await runForcedUpdateFlow();
+    }
+    return state;
+  });
+  ipcMain.handle(desktopUpdateAdmissionIpcChannels.later, (event) => {
+    assertUpgradeWindowSender(event.sender.id);
+    if (mode === "foreground" && !forcedFlowStarted) {
+      closeUpgradeWindow();
+    }
+  });
+  ipcMain.handle(
+    desktopUpdateAdmissionIpcChannels.manualDownload,
+    async (event) => {
+      assertUpgradeWindowSender(event.sender.id);
+      if (!state) {
+        return;
+      }
+      await shell.openExternal(options.manualDownloadUrl(state.check));
+    }
+  );
+  ipcMain.handle(desktopUpdateAdmissionIpcChannels.exit, (event) => {
+    assertUpgradeWindowSender(event.sender.id);
+    app.quit();
+  });
+  return {
+    async runStartupCheck() {
+      if (!options.runtime.checksEnabled) {
+        return false;
+      }
+      const response = await checkPolicy(true);
+      if (!response || response.decision !== "upgradeRequired") {
+        return false;
+      }
+      state = {
+        check: response,
+        message: null,
+        phase: "blocked",
+        update: options.updateService.getState()
+      };
+      openUpgradeWindow("startup");
+      return true;
+    },
+    async checkAfterForegroundRestore() {
+      if (!shouldCheckMinimumVersionAfterForeground({
+        checksEnabled: options.runtime.checksEnabled,
+        disposed,
+        foregroundCheckIntervalMs: options.runtime.foregroundCheckIntervalMs,
+        foregroundPrompted,
+        lastCheckAt,
+        now: now(),
+        startupBlocked: mode === "startup" && upgradeWindow !== null && !upgradeWindow.isDestroyed()
+      })) {
+        return;
+      }
+      const response = await checkPolicy(false);
+      if (disposed || !response || response.decision !== "upgradeRequired") {
+        return;
+      }
+      foregroundPrompted = true;
+      state = {
+        check: response,
+        message: null,
+        phase: "blocked",
+        update: options.updateService.getState()
+      };
+      openUpgradeWindow("foreground");
+    },
+    dispose() {
+      disposed = true;
+      lifecycleAbort.abort();
+      void releaseMandatoryUpdater(false);
+      app.removeListener("before-quit", handleBeforeQuit);
+      unsubscribeUpdate();
+      closeUpgradeWindow();
+      for (const channel of Object.values(desktopUpdateAdmissionIpcChannels)) {
+        if (channel !== desktopUpdateAdmissionIpcChannels.state) {
+          ipcMain.removeHandler(channel);
+        }
+      }
+    }
+  };
+}
+export {
+  createDesktopUpdateAdmissionController
+};
+//# sourceMappingURL=index.js.map

package/dist/electron-main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/electron-main/createDesktopUpdateAdmissionController.ts"],"sourcesContent":["import type {\n  BrowserWindow as ElectronBrowserWindow,\n  BrowserWindowConstructorOptions\n} from \"electron\";\nimport {\n  desktopUpdateAdmissionIpcChannels,\n  type DesktopUpdateAdmissionRuntime,\n  type DesktopProduct,\n  type MinimumVersionAppUpdateService,\n  type MinimumVersionCheckRequest,\n  type MinimumVersionCheckResponse,\n  type MinimumVersionUpgradeError,\n  type MinimumVersionUpgradeState,\n  type MandatoryDesktopUpdateSession,\n  type MandatoryDesktopUpdateTarget\n} from \"../contracts/index.ts\";\nimport {\n  resolveMinimumVersionRuntimeTarget,\n  shouldCheckMinimumVersionAfterForeground,\n  validateMinimumVersionResponse\n} from \"../core/index.ts\";\nimport { DevelopmentInstallSuppressedError } from \"../development/updaterDriver.ts\";\nimport { MandatoryUpdateTargetError } from \"../mandatory-updater/index.ts\";\n\nconst startupCheckTimeoutMs = 3_000;\nconst foregroundCheckTimeoutMs = 10_000;\n\nexport interface DesktopUpdateAdmissionElectronRuntime {\n  app: typeof import(\"electron\").app;\n  BrowserWindow: typeof import(\"electron\").BrowserWindow;\n  ipcMain: typeof import(\"electron\").ipcMain;\n  shell: typeof import(\"electron\").shell;\n}\n\nexport interface DesktopUpdateAdmissionLogger {\n  info(message: string): void;\n  error(message: string): void;\n}\n\nexport interface DesktopUpdateAdmissionController {\n  runStartupCheck(): Promise<boolean>;\n  checkAfterForegroundRestore(): Promise<void>;\n  dispose(): void;\n}\n\nexport interface DesktopUpdateAdmissionControllerOptions<\n  TProduct extends DesktopProduct\n> {\n  product: TProduct;\n  runtime: DesktopUpdateAdmissionRuntime;\n  electron: DesktopUpdateAdmissionElectronRuntime;\n  checkMinimumVersion(\n    request: MinimumVersionCheckRequest<TProduct>,\n    signal: AbortSignal\n  ): Promise<unknown>;\n  updateService: MinimumVersionAppUpdateService;\n  logger: DesktopUpdateAdmissionLogger;\n  onPolicyReleased(): void | Promise<void>;\n  preloadPath: string;\n  rendererFilePath: string;\n  rendererUrl?: string;\n  manualDownloadUrl(response: MinimumVersionCheckResponse<TProduct>): string;\n  listBusinessWindows(): ElectronBrowserWindow[];\n  icon?: BrowserWindowConstructorOptions[\"icon\"];\n  now?: () => number;\n}\n\nfunction logMinimumVersionCheck(\n  logger: DesktopUpdateAdmissionLogger,\n  level: \"info\" | \"error\",\n  details: Record<string, unknown>\n): void {\n  logger[level](`[minimum-version-check] ${JSON.stringify(details)}`);\n}\n\nexport function createDesktopUpdateAdmissionController<\n  TProduct extends DesktopProduct\n>(\n  options: DesktopUpdateAdmissionControllerOptions<TProduct>\n): DesktopUpdateAdmissionController {\n  const { app, BrowserWindow, ipcMain, shell } = options.electron;\n  const now = options.now ?? Date.now;\n  let lastCheckAt = 0;\n  let foregroundPrompted = false;\n  let state: MinimumVersionUpgradeState<TProduct> | null = null;\n  let upgradeWindow: ElectronBrowserWindow | null = null;\n  let mode: \"startup\" | \"foreground\" = \"startup\";\n  let forcedFlowStarted = false;\n  let installRequested = false;\n  let disposed = false;\n  let activeCheck: Promise<MinimumVersionCheckResponse<TProduct> | null> | null =\n    null;\n  let activeForcedFlow: Promise<void> | null = null;\n  let appQuitStarted = false;\n  let mandatoryUpdateSession: MandatoryDesktopUpdateSession | null = null;\n  let isolatedBusinessWindows: Array<{\n    window: ElectronBrowserWindow;\n    wasFocused: boolean;\n    wasMinimized: boolean;\n    wasVisible: boolean;\n  }> | null = null;\n  const lifecycleAbort = new AbortController();\n\n  const handleBeforeQuit = (): void => {\n    appQuitStarted = true;\n  };\n  app.on(\"before-quit\", handleBeforeQuit);\n\n  const emitState = (): void => {\n    if (state && upgradeWindow && !upgradeWindow.isDestroyed()) {\n      upgradeWindow.webContents.send(\n        desktopUpdateAdmissionIpcChannels.state,\n        state\n      );\n    }\n  };\n\n  const applyState = (\n    phase: MinimumVersionUpgradeState[\"phase\"],\n    update = options.updateService.getState(),\n    message: MinimumVersionUpgradeError | null = null\n  ): void => {\n    if (!state) {\n      return;\n    }\n    state = { ...state, message, phase, update };\n    emitState();\n  };\n\n  const closeUpgradeWindow = (): void => {\n    const currentWindow = upgradeWindow;\n    upgradeWindow = null;\n    if (currentWindow && !currentWindow.isDestroyed()) {\n      currentWindow.destroy();\n    }\n  };\n\n  const isolateBusinessWindows = (): void => {\n    if (isolatedBusinessWindows) {\n      return;\n    }\n    isolatedBusinessWindows = options\n      .listBusinessWindows()\n      .filter(\n        (candidate) => candidate !== upgradeWindow && !candidate.isDestroyed()\n      )\n      .map((candidate) => ({\n        wasFocused: candidate.isFocused(),\n        wasMinimized: candidate.isMinimized(),\n        wasVisible: candidate.isVisible(),\n        window: candidate\n      }));\n    for (const snapshot of isolatedBusinessWindows) {\n      snapshot.window.hide();\n    }\n  };\n\n  const restoreBusinessWindows = (): void => {\n    const snapshots = isolatedBusinessWindows;\n    isolatedBusinessWindows = null;\n    if (!snapshots) {\n      return;\n    }\n    let focusedWindow: ElectronBrowserWindow | null = null;\n    for (const snapshot of snapshots) {\n      if (snapshot.window.isDestroyed()) {\n        continue;\n      }\n      if (snapshot.wasMinimized) {\n        snapshot.window.show();\n        snapshot.window.minimize();\n      } else if (snapshot.wasVisible) {\n        snapshot.window.show();\n      }\n      if (snapshot.wasFocused) {\n        focusedWindow = snapshot.window;\n      }\n    }\n    if (\n      focusedWindow &&\n      !focusedWindow.isDestroyed() &&\n      !focusedWindow.isMinimized()\n    ) {\n      focusedWindow.focus();\n    }\n  };\n\n  const openUpgradeWindow = (nextMode: \"startup\" | \"foreground\"): void => {\n    if (upgradeWindow && !upgradeWindow.isDestroyed()) {\n      upgradeWindow.show();\n      upgradeWindow.focus();\n      return;\n    }\n    mode = nextMode;\n    const window = new BrowserWindow({\n      autoHideMenuBar: true,\n      fullscreenable: false,\n      height: 420,\n      icon: options.icon,\n      maximizable: false,\n      minHeight: 380,\n      minWidth: 480,\n      resizable: false,\n      show: false,\n      webPreferences: {\n        contextIsolation: true,\n        nodeIntegration: false,\n        preload: options.preloadPath,\n        sandbox: true\n      },\n      width: 520\n    });\n    upgradeWindow = window;\n    window.webContents.setWindowOpenHandler(() => ({ action: \"deny\" }));\n    window.webContents.on(\"will-navigate\", (event) => event.preventDefault());\n    window.on(\"close\", (event) => {\n      if (!appQuitStarted && (mode === \"startup\" || forcedFlowStarted)) {\n        event.preventDefault();\n        app.quit();\n      }\n    });\n    window.on(\"closed\", () => {\n      if (upgradeWindow === window) {\n        upgradeWindow = null;\n      }\n    });\n    window.once(\"ready-to-show\", () => {\n      if (!window.isDestroyed()) {\n        window.show();\n      }\n    });\n    const search = `mode=${nextMode}`;\n    if (options.rendererUrl) {\n      void window.loadURL(`${options.rendererUrl}?${search}`);\n    } else {\n      void window.loadFile(options.rendererFilePath, { search });\n    }\n  };\n\n  const requestPayload = (): MinimumVersionCheckRequest<TProduct> | null => {\n    const target = resolveMinimumVersionRuntimeTarget(\n      process.platform,\n      process.arch\n    );\n    if (!target) {\n      return null;\n    }\n    return {\n      ...target,\n      currentVersion: options.runtime.currentVersion,\n      product: options.product\n    };\n  };\n\n  const runPolicyCheck = async (\n    bounded: boolean\n  ): Promise<MinimumVersionCheckResponse<TProduct> | null> => {\n    const request = requestPayload();\n    if (!request) {\n      lastCheckAt = now();\n      logMinimumVersionCheck(options.logger, \"info\", {\n        architecture: process.arch,\n        decision: \"notApplicable\",\n        platform: process.platform,\n        reason: \"unsupportedRuntime\",\n        result: \"success\",\n        stage: bounded ? \"startup\" : \"foreground\"\n      });\n      return null;\n    }\n    const startedAt = now();\n    const controller = new AbortController();\n    const abortForLifecycle = (): void => controller.abort();\n    lifecycleAbort.signal.addEventListener(\"abort\", abortForLifecycle, {\n      once: true\n    });\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    try {\n      const timeoutMs = bounded\n        ? startupCheckTimeoutMs\n        : foregroundCheckTimeoutMs;\n      const response = await Promise.race([\n        options.checkMinimumVersion(request, controller.signal),\n        new Promise<never>((_resolve, reject) => {\n          timer = setTimeout(() => {\n            controller.abort();\n            reject(new Error(`minimum version check exceeded ${timeoutMs}ms`));\n          }, timeoutMs);\n        })\n      ]);\n      const validated = validateMinimumVersionResponse(response, request);\n      lastCheckAt = now();\n      logMinimumVersionCheck(options.logger, \"info\", {\n        currentVersion: validated.currentVersion,\n        decision: validated.decision,\n        elapsedMs: now() - startedAt,\n        minimumVersion: validated.minimumVersion,\n        policyRevision: validated.policyRevision,\n        reason: validated.reason,\n        result: \"success\",\n        stage: bounded ? \"startup\" : \"foreground\"\n      });\n      return validated;\n    } catch (error) {\n      lastCheckAt = now();\n      logMinimumVersionCheck(options.logger, \"error\", {\n        elapsedMs: now() - startedAt,\n        error: error instanceof Error ? error.message : String(error),\n        result: \"failure\",\n        stage: bounded ? \"startup\" : \"foreground\"\n      });\n      return null;\n    } finally {\n      if (timer) {\n        clearTimeout(timer);\n      }\n      lifecycleAbort.signal.removeEventListener(\"abort\", abortForLifecycle);\n    }\n  };\n\n  const checkPolicy = async (\n    bounded: boolean\n  ): Promise<MinimumVersionCheckResponse<TProduct> | null> => {\n    if (activeCheck) {\n      return activeCheck;\n    }\n    const pendingCheck = runPolicyCheck(bounded);\n    activeCheck = pendingCheck;\n    try {\n      return await pendingCheck;\n    } finally {\n      if (activeCheck === pendingCheck) {\n        activeCheck = null;\n      }\n    }\n  };\n\n  const releaseMandatoryUpdater = async (\n    restoreNormal = true\n  ): Promise<void> => {\n    const session = mandatoryUpdateSession;\n    mandatoryUpdateSession = null;\n    try {\n      await session?.release({ restoreNormal });\n    } catch (error) {\n      logMinimumVersionCheck(options.logger, \"error\", {\n        error: error instanceof Error ? error.message : String(error),\n        result: \"failure\",\n        stage: \"normal-update-restore\"\n      });\n    }\n  };\n\n  const releasePolicyBlock = async (): Promise<void> => {\n    applyState(\"released\");\n    forcedFlowStarted = false;\n    installRequested = false;\n    await releaseMandatoryUpdater();\n    closeUpgradeWindow();\n    restoreBusinessWindows();\n    await options.onPolicyReleased();\n  };\n\n  const installForcedUpdate = async (): Promise<void> => {\n    if (installRequested) {\n      return;\n    }\n    installRequested = true;\n    try {\n      if (!mandatoryUpdateSession) {\n        throw new Error(\"mandatory update session is unavailable\");\n      }\n      await mandatoryUpdateSession.installUpdate();\n    } catch (error) {\n      installRequested = false;\n      if (error instanceof DevelopmentInstallSuppressedError) {\n        logMinimumVersionCheck(options.logger, \"info\", {\n          result: \"simulated\",\n          stage: \"install\"\n        });\n        applyState(\"simulationComplete\", options.updateService.getState());\n        return;\n      }\n      logMinimumVersionCheck(options.logger, \"error\", {\n        error: error instanceof Error ? error.message : String(error),\n        result: \"failure\",\n        stage: \"install\"\n      });\n      applyState(\"error\", options.updateService.getState(), \"installFailed\");\n    }\n  };\n\n  const prepareAndDownloadForcedUpdate = async (): Promise<void> => {\n    if (!state) {\n      return;\n    }\n    try {\n      forcedFlowStarted = true;\n      applyState(\"checking\");\n      const target: MandatoryDesktopUpdateTarget = {\n        channel: state.check.channel === \"rc\" ? \"rc\" : \"stable\",\n        minimumVersion: state.check.minimumVersion,\n        policyRevision: state.check.policyRevision\n      };\n      if (mandatoryUpdateSession) {\n        mandatoryUpdateSession.retarget(target);\n      } else {\n        const acquiredSession =\n          await options.updateService.acquireMandatorySession(target);\n        if (disposed) {\n          await acquiredSession.release({ restoreNormal: false });\n          return;\n        }\n        mandatoryUpdateSession = acquiredSession;\n      }\n      const prepared = await mandatoryUpdateSession.prepare();\n      if (prepared.status === \"downloaded\") {\n        applyState(\"downloaded\", prepared);\n        await installForcedUpdate();\n        return;\n      }\n      if (prepared.status !== \"available\") {\n        applyState(\"error\", prepared, \"updateUnavailable\");\n        return;\n      }\n      applyState(\"ready\", prepared);\n      const downloaded = await mandatoryUpdateSession.downloadUpdate();\n      if (downloaded.status !== \"downloaded\") {\n        applyState(\"error\", downloaded, \"updateFailed\");\n        return;\n      }\n      applyState(\"downloaded\", downloaded);\n      await installForcedUpdate();\n    } catch (error) {\n      logMinimumVersionCheck(options.logger, \"error\", {\n        error: error instanceof Error ? error.message : String(error),\n        result: \"failure\",\n        stage: \"forced-update\"\n      });\n      applyState(\n        \"error\",\n        options.updateService.getState(),\n        error instanceof MandatoryUpdateTargetError\n          ? \"releaseBelowMinimum\"\n          : \"updateFailed\"\n      );\n    }\n  };\n\n  const runForcedUpdateFlow = (): Promise<void> => {\n    if (activeForcedFlow) {\n      return activeForcedFlow;\n    }\n    const pending = prepareAndDownloadForcedUpdate();\n    activeForcedFlow = pending;\n    void pending.then(\n      () => {\n        if (activeForcedFlow === pending) {\n          activeForcedFlow = null;\n        }\n      },\n      () => {\n        if (activeForcedFlow === pending) {\n          activeForcedFlow = null;\n        }\n      }\n    );\n    return pending;\n  };\n\n  const unsubscribeUpdate = options.updateService.subscribe((update) => {\n    if (!state || !forcedFlowStarted) {\n      return;\n    }\n    if (update.status === \"downloading\") {\n      applyState(\"downloading\", update);\n    } else if (update.status === \"error\") {\n      installRequested = false;\n      applyState(\"error\", update, \"updateFailed\");\n    }\n  });\n\n  const assertUpgradeWindowSender = (senderId: number): void => {\n    if (\n      !upgradeWindow ||\n      upgradeWindow.isDestroyed() ||\n      upgradeWindow.webContents.id !== senderId\n    ) {\n      throw new Error(\n        \"desktop update admission IPC is restricted to the upgrade window\"\n      );\n    }\n  };\n\n  ipcMain.handle(desktopUpdateAdmissionIpcChannels.getState, (event) => {\n    assertUpgradeWindowSender(event.sender.id);\n    return state;\n  });\n  ipcMain.handle(desktopUpdateAdmissionIpcChannels.start, async (event) => {\n    assertUpgradeWindowSender(event.sender.id);\n    if (mode === \"foreground\") {\n      isolateBusinessWindows();\n    }\n    await runForcedUpdateFlow();\n    return state;\n  });\n  ipcMain.handle(desktopUpdateAdmissionIpcChannels.retry, async (event) => {\n    assertUpgradeWindowSender(event.sender.id);\n    await activeForcedFlow;\n    const response = await checkPolicy(false);\n    if (!response) {\n      applyState(\n        \"error\",\n        options.updateService.getState(),\n        \"policyCheckFailed\"\n      );\n    } else if (response.decision !== \"upgradeRequired\") {\n      await releasePolicyBlock();\n    } else if (state) {\n      state = { ...state, check: response };\n      await runForcedUpdateFlow();\n    }\n    return state;\n  });\n  ipcMain.handle(desktopUpdateAdmissionIpcChannels.later, (event) => {\n    assertUpgradeWindowSender(event.sender.id);\n    if (mode === \"foreground\" && !forcedFlowStarted) {\n      closeUpgradeWindow();\n    }\n  });\n  ipcMain.handle(\n    desktopUpdateAdmissionIpcChannels.manualDownload,\n    async (event) => {\n      assertUpgradeWindowSender(event.sender.id);\n      if (!state) {\n        return;\n      }\n      await shell.openExternal(options.manualDownloadUrl(state.check));\n    }\n  );\n  ipcMain.handle(desktopUpdateAdmissionIpcChannels.exit, (event) => {\n    assertUpgradeWindowSender(event.sender.id);\n    app.quit();\n  });\n\n  return {\n    async runStartupCheck() {\n      if (!options.runtime.checksEnabled) {\n        return false;\n      }\n      const response = await checkPolicy(true);\n      if (!response || response.decision !== \"upgradeRequired\") {\n        return false;\n      }\n      state = {\n        check: response,\n        message: null,\n        phase: \"blocked\",\n        update: options.updateService.getState()\n      };\n      openUpgradeWindow(\"startup\");\n      return true;\n    },\n    async checkAfterForegroundRestore() {\n      if (\n        !shouldCheckMinimumVersionAfterForeground({\n          checksEnabled: options.runtime.checksEnabled,\n          disposed,\n          foregroundCheckIntervalMs: options.runtime.foregroundCheckIntervalMs,\n          foregroundPrompted,\n          lastCheckAt,\n          now: now(),\n          startupBlocked:\n            mode === \"startup\" &&\n            upgradeWindow !== null &&\n            !upgradeWindow.isDestroyed()\n        })\n      ) {\n        return;\n      }\n      const response = await checkPolicy(false);\n      if (disposed || !response || response.decision !== \"upgradeRequired\") {\n        return;\n      }\n      foregroundPrompted = true;\n      state = {\n        check: response,\n        message: null,\n        phase: \"blocked\",\n        update: options.updateService.getState()\n      };\n      openUpgradeWindow(\"foreground\");\n    },\n    dispose() {\n      disposed = true;\n      lifecycleAbort.abort();\n      void releaseMandatoryUpdater(false);\n      app.removeListener(\"before-quit\", handleBeforeQuit);\n      unsubscribeUpdate();\n      closeUpgradeWindow();\n      for (const channel of Object.values(desktopUpdateAdmissionIpcChannels)) {\n        if (channel !== desktopUpdateAdmissionIpcChannels.state) {\n          ipcMain.removeHandler(channel);\n        }\n      }\n    }\n  };\n}\n"],"mappings":"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","names":[]}