@tutti-os/desktop-update-admission 0.0.266

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025-2026 The Tutti Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,112 @@
+# @tutti-os/desktop-update-admission
+
+Product-neutral minimum-version admission and forced desktop update mechanics
+shared by Tutti Desktop and TSH Desktop.
+
+The package owns the client contract, response validation, startup and
+foreground admission lifecycle, mandatory updater lease, Electron upgrade
+window binding, preload API factory, shared React presentation, and default
+i18n resources.
+
+Consumers still own:
+
+- policy transport (`outboundFetch` for Tutti, desktopd for TSH)
+- release-feed resolution and the concrete updater driver
+- normal update preferences and scheduling
+- product download URLs, logging sinks, window assets, and business-window
+  enumeration
+
+The server remains authoritative for deciding whether the installed version is
+allowed. The client compares the updater target with the returned minimum only
+to prevent installing a release that cannot satisfy the active policy.
+
+## Development scenarios
+
+Both desktop hosts resolve one immutable client scenario from the
+`DESKTOP_UPDATE_ADMISSION_*` environment variables. Packaged applications
+ignore these variables before parsing them. Invalid enabled scenarios fail
+startup instead of falling back to production values.
+
+Client-owned variables are:
+
+| Variable                                          | Meaning                                                                             |
+| ------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| `DESKTOP_UPDATE_ADMISSION_DEV`                    | Enables the unpackaged-only scenario.                                               |
+| `DESKTOP_UPDATE_ADMISSION_CURRENT_VERSION`        | Supplies the one current version used by admission requests and the updater driver. |
+| `DESKTOP_UPDATE_ADMISSION_LATEST_VERSION`         | Supplies the updater target for available/downloaded outcomes.                      |
+| `DESKTOP_UPDATE_ADMISSION_UPDATER`                | Selects `available`, `downloaded`, `unavailable`, `error`, or `targetBelowMinimum`. |
+| `DESKTOP_UPDATE_ADMISSION_DOWNLOAD`               | Selects `success` or `error`.                                                       |
+| `DESKTOP_UPDATE_ADMISSION_INSTALL`                | Selects `simulated` or `error`; neither performs a real installation.               |
+| `DESKTOP_UPDATE_ADMISSION_FOREGROUND_INTERVAL_MS` | Overrides the foreground admission interval with an integer of at least 100 ms.     |
+| `DESKTOP_UPDATE_ADMISSION_TRANSPORT`              | Selects `in-process` (default) or `loopback`.                                       |
+| `DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_URL`        | Supplies the exact `http://127.0.0.1` origin required by loopback clients.          |
+
+Policy variables are parsed by the in-process client checker or by the
+standalone loopback server, never by both:
+
+| Variable                                    | Meaning                                                                                         |
+| ------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| `DESKTOP_UPDATE_ADMISSION_MINIMUM_VERSION`  | Supplies the default minimum for policy steps that require one.                                 |
+| `DESKTOP_UPDATE_ADMISSION_POLICY`           | Selects one policy outcome.                                                                     |
+| `DESKTOP_UPDATE_ADMISSION_POLICY_SEQUENCE`  | Selects a comma-separated per-client outcome sequence such as `upgradeRequired@1.1.0,disabled`. |
+| `DESKTOP_UPDATE_ADMISSION_SCENARIO`         | Selects one named policy scenario instead of individual policy fields.                          |
+| `DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_PORT` | Selects the loopback CLI port; omit it for an ephemeral port.                                   |
+
+The shortest startup-blocking scenario is:
+
+```bash
+DESKTOP_UPDATE_ADMISSION_DEV=1 \
+DESKTOP_UPDATE_ADMISSION_POLICY=upgradeRequired \
+DESKTOP_UPDATE_ADMISSION_CURRENT_VERSION=1.0.0 \
+DESKTOP_UPDATE_ADMISSION_MINIMUM_VERSION=1.1.0 \
+DESKTOP_UPDATE_ADMISSION_LATEST_VERSION=1.2.0 \
+DESKTOP_UPDATE_ADMISSION_UPDATER=available
+```
+
+Policy sequences make cross-request behavior deterministic. For example,
+`upgradeRequired@1.1.0,disabled` releases the block on retry, while
+`allowed@1.0.0,upgradeRequired@1.1.0` allows startup and prompts after the
+foreground interval.
+
+Named scenarios are also available:
+
+- `startup-force-success`
+- `startup-policy-timeout`
+- `startup-updater-unavailable`
+- `startup-target-below-minimum`
+- `startup-download-error`
+- `retry-policy-released`
+- `foreground-upgrade-required`
+
+The default `in-process` transport parses client and policy variables in one
+process for fast state-machine tests.
+
+To exercise the real HTTP path, give policy variables only to the loopback
+server:
+
+```bash
+DESKTOP_UPDATE_ADMISSION_DEV=1 \
+DESKTOP_UPDATE_ADMISSION_POLICY=upgradeRequired \
+DESKTOP_UPDATE_ADMISSION_MINIMUM_VERSION=1.4.0 \
+DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_PORT=43210 \
+pnpm exec desktop-update-admission-mock-server
+```
+
+Then start a client with only client-owned variables:
+
+```bash
+DESKTOP_UPDATE_ADMISSION_DEV=1 \
+DESKTOP_UPDATE_ADMISSION_CURRENT_VERSION=1.0.0 \
+DESKTOP_UPDATE_ADMISSION_TRANSPORT=loopback \
+DESKTOP_UPDATE_ADMISSION_MOCK_SERVER_URL=http://127.0.0.1:43210
+```
+
+The loopback client defaults its updater to `unavailable`. To exercise a forced
+updater flow, add `DESKTOP_UPDATE_ADMISSION_UPDATER=available` and
+`DESKTOP_UPDATE_ADMISSION_LATEST_VERSION=1.5.0` to the client command. Policy
+variables supplied to a loopback client are rejected so an HTTP test cannot
+accidentally gain a second policy source.
+
+The server binds only to `127.0.0.1`. Simulated installation never invokes a
+real installer or application restart and is rendered as a distinct
+development-only completion state.

package/dist/chunk-GONYAEKF.js

@@ -0,0 +1,139 @@
+import {
+  updaterTargetMeetsMinimum
+} from "./chunk-LV67FBCG.js";
+
+// src/mandatory-updater/mandatoryUpdaterSession.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var MandatoryUpdateTargetError = class extends Error {
+  latestVersion;
+  minimumVersion;
+  constructor(latestVersion, minimumVersion) {
+    super(
+      `mandatory update target ${latestVersion ?? "unknown"} is below ${minimumVersion}`
+    );
+    this.name = "MandatoryUpdateTargetError";
+    this.latestVersion = latestVersion;
+    this.minimumVersion = minimumVersion;
+  }
+};
+function createMandatoryUpdaterLeaseManager(options) {
+  const mandatoryContext = new AsyncLocalStorage();
+  const normalRestoreContext = new AsyncLocalStorage();
+  let mandatoryOwner = null;
+  const assertAccess = () => {
+    if (mandatoryOwner && mandatoryContext.getStore() !== mandatoryOwner) {
+      throw new Error(
+        "application updater is owned by the mandatory update session"
+      );
+    }
+  };
+  return {
+    assertAccess,
+    isMandatoryAccess: () => mandatoryOwner !== null && mandatoryContext.getStore() === mandatoryOwner && normalRestoreContext.getStore() !== mandatoryOwner,
+    async acquire(input) {
+      if (mandatoryOwner) {
+        throw new Error("a mandatory update session is already active");
+      }
+      const owner = /* @__PURE__ */ Symbol(
+        `mandatory-update:${input.policyRevision}:${input.minimumVersion}`
+      );
+      mandatoryOwner = owner;
+      const configurationToRestore = options.captureNormalConfiguration();
+      try {
+        await options.suspendNormalUpdates();
+      } catch (error) {
+        if (mandatoryOwner === owner) {
+          mandatoryOwner = null;
+        }
+        throw error;
+      }
+      let target = input;
+      let released = false;
+      let releasePromise = null;
+      const run = (operation) => {
+        if (released || mandatoryOwner !== owner) {
+          return Promise.reject(
+            new Error("mandatory update session is no longer active")
+          );
+        }
+        return mandatoryContext.run(owner, operation);
+      };
+      const assertTargetVersion = (update) => {
+        if (!updaterTargetMeetsMinimum(
+          update.latestVersion,
+          target.minimumVersion
+        )) {
+          throw new MandatoryUpdateTargetError(
+            update.latestVersion,
+            target.minimumVersion
+          );
+        }
+      };
+      const assertTargetWhenPresent = (update) => {
+        if (update.status === "available" || update.status === "downloaded") {
+          assertTargetVersion(update);
+        }
+      };
+      return {
+        retarget: (nextTarget) => {
+          if (released || mandatoryOwner !== owner) {
+            throw new Error("mandatory update session is no longer active");
+          }
+          target = nextTarget;
+        },
+        prepare: () => run(async () => {
+          const update = await options.prepareMandatoryUpdate({
+            channel: target.channel,
+            policy: "prompt"
+          });
+          assertTargetWhenPresent(update);
+          return update;
+        }),
+        downloadUpdate: () => run(async () => {
+          const update = await options.downloadUpdate();
+          if (update.status === "downloaded") {
+            assertTargetVersion(update);
+          }
+          return update;
+        }),
+        installUpdate: () => run(async () => {
+          assertTargetVersion(options.getState());
+          await options.installUpdate();
+        }),
+        release: (releaseOptions) => {
+          if (releasePromise) {
+            return releasePromise;
+          }
+          releasePromise = (async () => {
+            released = true;
+            if (mandatoryOwner !== owner) {
+              return;
+            }
+            try {
+              if (releaseOptions?.restoreNormal !== false && configurationToRestore) {
+                await mandatoryContext.run(
+                  owner,
+                  () => normalRestoreContext.run(
+                    owner,
+                    () => options.restoreNormalConfiguration(configurationToRestore)
+                  )
+                );
+              }
+            } finally {
+              if (mandatoryOwner === owner) {
+                mandatoryOwner = null;
+              }
+            }
+          })();
+          return releasePromise;
+        }
+      };
+    }
+  };
+}
+
+export {
+  MandatoryUpdateTargetError,
+  createMandatoryUpdaterLeaseManager
+};
+//# sourceMappingURL=chunk-GONYAEKF.js.map

package/dist/chunk-GONYAEKF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mandatory-updater/mandatoryUpdaterSession.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type {\n  ConfigureDesktopUpdatesInput,\n  DesktopUpdateState,\n  MandatoryDesktopUpdateSession,\n  MandatoryDesktopUpdateTarget\n} from \"../contracts/index.ts\";\nimport { updaterTargetMeetsMinimum } from \"../core/index.ts\";\n\nexport class MandatoryUpdateTargetError extends Error {\n  public readonly latestVersion: string | null;\n  public readonly minimumVersion: string;\n\n  public constructor(latestVersion: string | null, minimumVersion: string) {\n    super(\n      `mandatory update target ${latestVersion ?? \"unknown\"} is below ${minimumVersion}`\n    );\n    this.name = \"MandatoryUpdateTargetError\";\n    this.latestVersion = latestVersion;\n    this.minimumVersion = minimumVersion;\n  }\n}\n\nexport interface MandatoryUpdaterLeaseManager {\n  assertAccess(): void;\n  isMandatoryAccess(): boolean;\n  acquire(\n    input: MandatoryDesktopUpdateTarget\n  ): Promise<MandatoryDesktopUpdateSession>;\n}\n\nexport function createMandatoryUpdaterLeaseManager<\n  TNormalConfiguration\n>(options: {\n  captureNormalConfiguration(): TNormalConfiguration | null;\n  suspendNormalUpdates(): Promise<void>;\n  prepareMandatoryUpdate(\n    input: ConfigureDesktopUpdatesInput\n  ): Promise<DesktopUpdateState>;\n  downloadUpdate(): Promise<DesktopUpdateState>;\n  installUpdate(): Promise<void>;\n  getState(): DesktopUpdateState;\n  restoreNormalConfiguration(\n    configuration: TNormalConfiguration\n  ): Promise<void>;\n}): MandatoryUpdaterLeaseManager {\n  const mandatoryContext = new AsyncLocalStorage<symbol>();\n  const normalRestoreContext = new AsyncLocalStorage<symbol>();\n  let mandatoryOwner: symbol | null = null;\n\n  const assertAccess = (): void => {\n    if (mandatoryOwner && mandatoryContext.getStore() !== mandatoryOwner) {\n      throw new Error(\n        \"application updater is owned by the mandatory update session\"\n      );\n    }\n  };\n\n  return {\n    assertAccess,\n    isMandatoryAccess: () =>\n      mandatoryOwner !== null &&\n      mandatoryContext.getStore() === mandatoryOwner &&\n      normalRestoreContext.getStore() !== mandatoryOwner,\n    async acquire(input) {\n      if (mandatoryOwner) {\n        throw new Error(\"a mandatory update session is already active\");\n      }\n      const owner = Symbol(\n        `mandatory-update:${input.policyRevision}:${input.minimumVersion}`\n      );\n      mandatoryOwner = owner;\n      const configurationToRestore = options.captureNormalConfiguration();\n      try {\n        await options.suspendNormalUpdates();\n      } catch (error) {\n        if (mandatoryOwner === owner) {\n          mandatoryOwner = null;\n        }\n        throw error;\n      }\n\n      let target = input;\n      let released = false;\n      let releasePromise: Promise<void> | null = null;\n      const run = <T>(operation: () => Promise<T>): Promise<T> => {\n        if (released || mandatoryOwner !== owner) {\n          return Promise.reject(\n            new Error(\"mandatory update session is no longer active\")\n          );\n        }\n        return mandatoryContext.run(owner, operation);\n      };\n      const assertTargetVersion = (update: DesktopUpdateState): void => {\n        if (\n          !updaterTargetMeetsMinimum(\n            update.latestVersion,\n            target.minimumVersion\n          )\n        ) {\n          throw new MandatoryUpdateTargetError(\n            update.latestVersion,\n            target.minimumVersion\n          );\n        }\n      };\n      const assertTargetWhenPresent = (update: DesktopUpdateState): void => {\n        if (update.status === \"available\" || update.status === \"downloaded\") {\n          assertTargetVersion(update);\n        }\n      };\n\n      return {\n        retarget: (nextTarget) => {\n          if (released || mandatoryOwner !== owner) {\n            throw new Error(\"mandatory update session is no longer active\");\n          }\n          target = nextTarget;\n        },\n        prepare: () =>\n          run(async () => {\n            const update = await options.prepareMandatoryUpdate({\n              channel: target.channel,\n              policy: \"prompt\"\n            });\n            assertTargetWhenPresent(update);\n            return update;\n          }),\n        downloadUpdate: () =>\n          run(async () => {\n            const update = await options.downloadUpdate();\n            if (update.status === \"downloaded\") {\n              assertTargetVersion(update);\n            }\n            return update;\n          }),\n        installUpdate: () =>\n          run(async () => {\n            assertTargetVersion(options.getState());\n            await options.installUpdate();\n          }),\n        release: (releaseOptions) => {\n          if (releasePromise) {\n            return releasePromise;\n          }\n          releasePromise = (async () => {\n            released = true;\n            if (mandatoryOwner !== owner) {\n              return;\n            }\n            try {\n              if (\n                releaseOptions?.restoreNormal !== false &&\n                configurationToRestore\n              ) {\n                await mandatoryContext.run(owner, () =>\n                  normalRestoreContext.run(owner, () =>\n                    options.restoreNormalConfiguration(configurationToRestore)\n                  )\n                );\n              }\n            } finally {\n              if (mandatoryOwner === owner) {\n                mandatoryOwner = null;\n              }\n            }\n          })();\n          return releasePromise;\n        }\n      };\n    }\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LV67FBCG.js

@@ -0,0 +1,112 @@
+// src/core/minimumVersion.ts
+function parseManagedVersion(value) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-rc\.(0|[1-9]\d*))?$/u.exec(
+    value.trim()
+  );
+  if (!match) {
+    return null;
+  }
+  return {
+    major: match[1],
+    minor: match[2],
+    patch: match[3],
+    rc: match[4] === void 0 ? null : match[4]
+  };
+}
+function compareNumericIdentifier(left, right) {
+  if (left.length !== right.length) {
+    return left.length < right.length ? -1 : 1;
+  }
+  return left === right ? 0 : left < right ? -1 : 1;
+}
+function compareManagedVersions(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) {
+      return compareNumericIdentifier(left[key], right[key]);
+    }
+  }
+  if (left.rc === right.rc) {
+    return 0;
+  }
+  if (left.rc === null) {
+    return 1;
+  }
+  if (right.rc === null) {
+    return -1;
+  }
+  return compareNumericIdentifier(left.rc, right.rc);
+}
+function updaterTargetMeetsMinimum(releaseVersion, minimumVersion) {
+  if (!releaseVersion) {
+    return false;
+  }
+  const release = parseManagedVersion(releaseVersion);
+  const minimum = parseManagedVersion(minimumVersion);
+  return Boolean(
+    release && minimum && compareManagedVersions(release, minimum) >= 0
+  );
+}
+function resolveMinimumVersionRuntimeTarget(platform, architecture) {
+  const normalizedPlatform = platform === "darwin" ? "macos" : platform === "win32" ? "windows" : platform === "linux" ? "linux" : null;
+  const normalizedArchitecture = architecture === "arm64" ? "arm64" : architecture === "x64" ? "x64" : null;
+  if (!normalizedPlatform || !normalizedArchitecture) {
+    return null;
+  }
+  return {
+    architecture: normalizedArchitecture,
+    platform: normalizedPlatform
+  };
+}
+function shouldCheckMinimumVersionAfterForeground(input) {
+  return !(input.disposed || !input.checksEnabled || input.foregroundPrompted || input.startupBlocked || input.now - input.lastCheckAt < input.foregroundCheckIntervalMs);
+}
+function validateMinimumVersionResponse(value, request) {
+  if (!value || typeof value !== "object") {
+    throw new Error("minimum version response must be an object");
+  }
+  const response = value;
+  if (response.product !== request.product || response.platform !== request.platform || response.architecture !== request.architecture || response.currentVersion !== request.currentVersion) {
+    throw new Error("minimum version response identity does not match request");
+  }
+  if (typeof response.policyRevision !== "string" || response.policyRevision.trim() === "") {
+    throw new Error("minimum version response has invalid policy revision");
+  }
+  if (response.channel === "unmanaged") {
+    if (response.decision !== "notApplicable" || response.reason !== "unmanagedPrerelease" || response.minimumVersion !== "" || response.policySource !== "") {
+      throw new Error("minimum version response has invalid unmanaged policy");
+    }
+    return response;
+  }
+  if (response.channel !== "stable" && response.channel !== "rc") {
+    throw new Error("minimum version response has invalid channel");
+  }
+  if (response.decision === "notApplicable") {
+    if (!["productDisabled", "unsupportedRelease"].includes(
+      String(response.reason)
+    ) || response.minimumVersion !== "" || response.policySource !== "") {
+      throw new Error(
+        "minimum version response has invalid non-applicable policy"
+      );
+    }
+    return response;
+  }
+  if (response.decision !== "allowed" && response.decision !== "upgradeRequired") {
+    throw new Error("minimum version response has invalid decision");
+  }
+  const pattern = response.channel === "rc" ? /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-rc\.(0|[1-9]\d*)$/u : /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+  const expectedReason = response.decision === "allowed" ? "meetsMinimum" : "belowMinimum";
+  if (typeof response.minimumVersion !== "string" || !pattern.test(response.minimumVersion) || !["defaultMinimum", "platformOverride"].includes(
+    String(response.policySource)
+  ) || response.reason !== expectedReason) {
+    throw new Error("minimum version response has invalid managed policy");
+  }
+  return response;
+}
+
+export {
+  updaterTargetMeetsMinimum,
+  resolveMinimumVersionRuntimeTarget,
+  shouldCheckMinimumVersionAfterForeground,
+  validateMinimumVersionResponse
+};
+//# sourceMappingURL=chunk-LV67FBCG.js.map

package/dist/chunk-LV67FBCG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/minimumVersion.ts"],"sourcesContent":["import type {\n  DesktopArchitecture,\n  DesktopPlatform,\n  DesktopProduct,\n  MinimumVersionCheckRequest,\n  MinimumVersionCheckResponse\n} from \"../contracts/index.ts\";\n\ntype ManagedVersion = {\n  major: string;\n  minor: string;\n  patch: string;\n  rc: string | null;\n};\n\nfunction parseManagedVersion(value: string): ManagedVersion | null {\n  const match =\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-rc\\.(0|[1-9]\\d*))?$/u.exec(\n      value.trim()\n    );\n  if (!match) {\n    return null;\n  }\n  return {\n    major: match[1]!,\n    minor: match[2]!,\n    patch: match[3]!,\n    rc: match[4] === undefined ? null : match[4]\n  };\n}\n\nfunction compareNumericIdentifier(left: string, right: string): number {\n  if (left.length !== right.length) {\n    return left.length < right.length ? -1 : 1;\n  }\n  return left === right ? 0 : left < right ? -1 : 1;\n}\n\nfunction compareManagedVersions(\n  left: ManagedVersion,\n  right: ManagedVersion\n): number {\n  for (const key of [\"major\", \"minor\", \"patch\"] as const) {\n    if (left[key] !== right[key]) {\n      return compareNumericIdentifier(left[key], right[key]);\n    }\n  }\n  if (left.rc === right.rc) {\n    return 0;\n  }\n  if (left.rc === null) {\n    return 1;\n  }\n  if (right.rc === null) {\n    return -1;\n  }\n  return compareNumericIdentifier(left.rc, right.rc);\n}\n\nexport function updaterTargetMeetsMinimum(\n  releaseVersion: string | null,\n  minimumVersion: string\n): boolean {\n  if (!releaseVersion) {\n    return false;\n  }\n  const release = parseManagedVersion(releaseVersion);\n  const minimum = parseManagedVersion(minimumVersion);\n  return Boolean(\n    release && minimum && compareManagedVersions(release, minimum) >= 0\n  );\n}\n\nexport function resolveMinimumVersionRuntimeTarget(\n  platform: NodeJS.Platform,\n  architecture: string\n): {\n  platform: DesktopPlatform;\n  architecture: DesktopArchitecture;\n} | null {\n  const normalizedPlatform =\n    platform === \"darwin\"\n      ? \"macos\"\n      : platform === \"win32\"\n        ? \"windows\"\n        : platform === \"linux\"\n          ? \"linux\"\n          : null;\n  const normalizedArchitecture =\n    architecture === \"arm64\" ? \"arm64\" : architecture === \"x64\" ? \"x64\" : null;\n  if (!normalizedPlatform || !normalizedArchitecture) {\n    return null;\n  }\n  return {\n    architecture: normalizedArchitecture,\n    platform: normalizedPlatform\n  };\n}\n\nexport function shouldCheckMinimumVersionAfterForeground(input: {\n  disposed: boolean;\n  checksEnabled: boolean;\n  foregroundCheckIntervalMs: number;\n  foregroundPrompted: boolean;\n  startupBlocked: boolean;\n  lastCheckAt: number;\n  now: number;\n}): boolean {\n  return !(\n    input.disposed ||\n    !input.checksEnabled ||\n    input.foregroundPrompted ||\n    input.startupBlocked ||\n    input.now - input.lastCheckAt < input.foregroundCheckIntervalMs\n  );\n}\n\nexport function validateMinimumVersionResponse<TProduct extends DesktopProduct>(\n  value: unknown,\n  request: MinimumVersionCheckRequest<TProduct>\n): MinimumVersionCheckResponse<TProduct> {\n  if (!value || typeof value !== \"object\") {\n    throw new Error(\"minimum version response must be an object\");\n  }\n  const response = value as Record<string, unknown>;\n  if (\n    response.product !== request.product ||\n    response.platform !== request.platform ||\n    response.architecture !== request.architecture ||\n    response.currentVersion !== request.currentVersion\n  ) {\n    throw new Error(\"minimum version response identity does not match request\");\n  }\n  if (\n    typeof response.policyRevision !== \"string\" ||\n    response.policyRevision.trim() === \"\"\n  ) {\n    throw new Error(\"minimum version response has invalid policy revision\");\n  }\n  if (response.channel === \"unmanaged\") {\n    if (\n      response.decision !== \"notApplicable\" ||\n      response.reason !== \"unmanagedPrerelease\" ||\n      response.minimumVersion !== \"\" ||\n      response.policySource !== \"\"\n    ) {\n      throw new Error(\"minimum version response has invalid unmanaged policy\");\n    }\n    return response as unknown as MinimumVersionCheckResponse<TProduct>;\n  }\n  if (response.channel !== \"stable\" && response.channel !== \"rc\") {\n    throw new Error(\"minimum version response has invalid channel\");\n  }\n  if (response.decision === \"notApplicable\") {\n    if (\n      ![\"productDisabled\", \"unsupportedRelease\"].includes(\n        String(response.reason)\n      ) ||\n      response.minimumVersion !== \"\" ||\n      response.policySource !== \"\"\n    ) {\n      throw new Error(\n        \"minimum version response has invalid non-applicable policy\"\n      );\n    }\n    return response as unknown as MinimumVersionCheckResponse<TProduct>;\n  }\n  if (\n    response.decision !== \"allowed\" &&\n    response.decision !== \"upgradeRequired\"\n  ) {\n    throw new Error(\"minimum version response has invalid decision\");\n  }\n  const pattern =\n    response.channel === \"rc\"\n      ? /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)-rc\\.(0|[1-9]\\d*)$/u\n      : /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$/u;\n  const expectedReason =\n    response.decision === \"allowed\" ? \"meetsMinimum\" : \"belowMinimum\";\n  if (\n    typeof response.minimumVersion !== \"string\" ||\n    !pattern.test(response.minimumVersion) ||\n    ![\"defaultMinimum\", \"platformOverride\"].includes(\n      String(response.policySource)\n    ) ||\n    response.reason !== expectedReason\n  ) {\n    throw new Error(\"minimum version response has invalid managed policy\");\n  }\n  return response as unknown as MinimumVersionCheckResponse<TProduct>;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-TRALK3GT.js

@@ -0,0 +1,33 @@
+// src/contracts/index.ts
+var desktopUpdatePolicies = ["off", "prompt", "auto"];
+var desktopUpdateChannels = ["stable", "rc"];
+var desktopUpdateStatuses = [
+  "disabled",
+  "unsupported",
+  "idle",
+  "checking",
+  "available",
+  "downloading",
+  "downloaded",
+  "up_to_date",
+  "error"
+];
+var desktopProducts = ["tsh-desktop", "tutti-desktop"];
+var desktopUpdateAdmissionIpcChannels = {
+  exit: "desktop-update-admission:exit",
+  getState: "desktop-update-admission:get-state",
+  later: "desktop-update-admission:later",
+  manualDownload: "desktop-update-admission:manual-download",
+  retry: "desktop-update-admission:retry",
+  start: "desktop-update-admission:start",
+  state: "desktop-update-admission:state"
+};
+
+export {
+  desktopUpdatePolicies,
+  desktopUpdateChannels,
+  desktopUpdateStatuses,
+  desktopProducts,
+  desktopUpdateAdmissionIpcChannels
+};
+//# sourceMappingURL=chunk-TRALK3GT.js.map

package/dist/chunk-TRALK3GT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contracts/index.ts"],"sourcesContent":["export const desktopUpdatePolicies = [\"off\", \"prompt\", \"auto\"] as const;\nexport type DesktopUpdatePolicy = (typeof desktopUpdatePolicies)[number];\n\nexport const desktopUpdateChannels = [\"stable\", \"rc\"] as const;\nexport type DesktopUpdateChannel = (typeof desktopUpdateChannels)[number];\n\nexport const desktopUpdateStatuses = [\n  \"disabled\",\n  \"unsupported\",\n  \"idle\",\n  \"checking\",\n  \"available\",\n  \"downloading\",\n  \"downloaded\",\n  \"up_to_date\",\n  \"error\"\n] as const;\nexport type DesktopUpdateStatus = (typeof desktopUpdateStatuses)[number];\n\nexport interface ConfigureDesktopUpdatesInput {\n  channel: DesktopUpdateChannel;\n  policy: DesktopUpdatePolicy;\n}\n\nexport interface DesktopUpdateState {\n  channel: DesktopUpdateChannel;\n  checkedAt: string | null;\n  currentVersion: string;\n  downloadedBytes: number | null;\n  downloadPercent: number | null;\n  latestVersion: string | null;\n  message: string | null;\n  policy: DesktopUpdatePolicy;\n  releaseDate: string | null;\n  releaseName: string | null;\n  releaseNotesUrl: string | null;\n  status: DesktopUpdateStatus;\n  totalBytes: number | null;\n}\n\nexport const desktopProducts = [\"tsh-desktop\", \"tutti-desktop\"] as const;\nexport type DesktopProduct = (typeof desktopProducts)[number];\nexport type DesktopPlatform = \"macos\" | \"windows\" | \"linux\";\nexport type DesktopArchitecture = \"arm64\" | \"x64\";\n\nexport interface MinimumVersionCheckRequest<\n  TProduct extends DesktopProduct = DesktopProduct\n> {\n  product: TProduct;\n  platform: DesktopPlatform;\n  architecture: DesktopArchitecture;\n  currentVersion: string;\n}\n\nexport type MinimumVersionDecision =\n  | \"allowed\"\n  | \"upgradeRequired\"\n  | \"notApplicable\";\n\nexport interface MinimumVersionCheckResponse<\n  TProduct extends DesktopProduct = DesktopProduct\n> extends MinimumVersionCheckRequest<TProduct> {\n  channel: DesktopUpdateChannel | \"unmanaged\";\n  minimumVersion: string;\n  decision: MinimumVersionDecision;\n  reason:\n    | \"unmanagedPrerelease\"\n    | \"productDisabled\"\n    | \"unsupportedRelease\"\n    | \"belowMinimum\"\n    | \"meetsMinimum\";\n  policySource: \"\" | \"defaultMinimum\" | \"platformOverride\";\n  policyRevision: string;\n}\n\nexport type MinimumVersionUpgradePhase =\n  | \"blocked\"\n  | \"checking\"\n  | \"ready\"\n  | \"downloading\"\n  | \"downloaded\"\n  | \"simulationComplete\"\n  | \"error\"\n  | \"released\";\n\nexport type MinimumVersionUpgradeError =\n  | \"releaseBelowMinimum\"\n  | \"updateUnavailable\"\n  | \"policyCheckFailed\"\n  | \"installFailed\"\n  | \"updateFailed\";\n\nexport interface MinimumVersionUpgradeState<\n  TProduct extends DesktopProduct = DesktopProduct\n> {\n  phase: MinimumVersionUpgradePhase;\n  check: MinimumVersionCheckResponse<TProduct>;\n  update: DesktopUpdateState;\n  message: MinimumVersionUpgradeError | null;\n}\n\nexport interface MandatoryDesktopUpdateTarget {\n  channel: DesktopUpdateChannel;\n  minimumVersion: string;\n  policyRevision: string;\n}\n\nexport interface MandatoryDesktopUpdateSession {\n  retarget(input: MandatoryDesktopUpdateTarget): void;\n  prepare(): Promise<DesktopUpdateState>;\n  downloadUpdate(): Promise<DesktopUpdateState>;\n  installUpdate(): Promise<void>;\n  release(options?: { restoreNormal?: boolean }): Promise<void>;\n}\n\nexport interface MinimumVersionAppUpdateService {\n  getState(): DesktopUpdateState;\n  acquireMandatorySession(\n    input: MandatoryDesktopUpdateTarget\n  ): Promise<MandatoryDesktopUpdateSession>;\n  subscribe(listener: (state: DesktopUpdateState) => void): () => void;\n}\n\nexport interface DesktopUpdateAdmissionRuntime {\n  checksEnabled: boolean;\n  currentVersion: string;\n  development: boolean;\n  foregroundCheckIntervalMs: number;\n}\n\nexport const desktopUpdateAdmissionIpcChannels = {\n  exit: \"desktop-update-admission:exit\",\n  getState: \"desktop-update-admission:get-state\",\n  later: \"desktop-update-admission:later\",\n  manualDownload: \"desktop-update-admission:manual-download\",\n  retry: \"desktop-update-admission:retry\",\n  start: \"desktop-update-admission:start\",\n  state: \"desktop-update-admission:state\"\n} as const;\n\nexport interface DesktopMinimumVersionApi {\n  getState(): Promise<MinimumVersionUpgradeState | null>;\n  start(): Promise<MinimumVersionUpgradeState | null>;\n  retry(): Promise<MinimumVersionUpgradeState | null>;\n  later(): Promise<void>;\n  openManualDownload(): Promise<void>;\n  exit(): Promise<void>;\n  onState(listener: (state: MinimumVersionUpgradeState) => void): () => void;\n}\n"],"mappings":";AAAO,IAAM,wBAAwB,CAAC,OAAO,UAAU,MAAM;AAGtD,IAAM,wBAAwB,CAAC,UAAU,IAAI;AAG7C,IAAM,wBAAwB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAwBO,IAAM,kBAAkB,CAAC,eAAe,eAAe;AA0FvD,IAAM,oCAAoC;AAAA,EAC/C,MAAM;AAAA,EACN,UAAU;AAAA,EACV,OAAO;AAAA,EACP,gBAAgB;AAAA,EAChB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,OAAO;AACT;","names":[]}