TypeScript
fix(server): t3 update installs from the policy's update mirror (#29911)
Julius Marminge7681605d7375
diff --git a/apps/server/src/cli/update.test.ts b/apps/server/src/cli/update.test.tsindex 848c2c798df..ecd837e37ac 100644--- a/apps/server/src/cli/update.test.ts+++ b/apps/server/src/cli/update.test.ts@@ -18,7 +18,13 @@ import * as BootService from "../cloud/bootService.ts";import { prunePinnedRuntimes } from "../cloud/pinnedRuntime.ts";import * as ManagedPolicy from "../policy/ManagedPolicy.ts";import * as ProcessRunner from "../processRunner.ts";-import { repointLauncher, resolveLauncherPath, resolveNewestVersion, runUpdate } from "./update.ts";+import {+ repointLauncher,+ resolveLauncherPath,+ resolveMirrorVersion,+ resolveNewestVersion,+ runUpdate,+} from "./update.ts";// lsof listing one process, so prune sees a process list in which no runtime is running.const unrelatedLsof = ProcessRunner.ProcessRunner.of({@@ -60,10 +66,59 @@ it.effect("authenticates each release page until the requested channel is found"}),);+it.effect("reads the newest version from the update feed file a mirror publishes", () =>+ Effect.gen(function* () {+ const requested: string[] = [];+ const mirror = {+ organization: "Example Corp",+ feedUrl: "https://updates.example.com/t3code/?token=abc",+ };+ const resolve = (+ channel: "stable" | "nightly" | "preview",+ platform: NodeJS.Platform,+ arch: string,+ feed: string,+ ) =>+ resolveMirrorVersion(mirror, channel).pipe(+ Effect.map((version): string => version),+ Effect.catchTags({ CliUpdateError: (error) => Effect.succeed(`error: ${error.reason}`) }),+ Effect.provideService(HostProcess.Platform, platform),+ Effect.provideService(HostProcess.Architecture, arch),+ Effect.provideService(+ HttpClient.HttpClient,+ HttpClient.make((request) => {+ requested.push(request.url);+ return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(feed)));+ }),+ ),+ );++ assert.equal(+ yield* resolve("stable", "darwin", "arm64", "version: 1.4.0\nfiles: []\n"),+ "1.4.0",+ );+ assert.equal(+ yield* resolve("nightly", "linux", "arm64", "version: '1.5.0-nightly.20261101.2'\n"),+ "1.5.0-nightly.20261101.2",+ );+ assert.deepStrictEqual(requested, [+ "https://updates.example.com/t3code/latest-mac.yml?token=abc",+ "https://updates.example.com/t3code/nightly-linux-arm64.yml?token=abc",+ ]);+ // A feed for the wrong track is not trusted to mean the requested one.+ assert.include(+ yield* resolve("stable", "win32", "x64", "version: 1.5.0-nightly.20261101.2\n"),+ "Could not read latest.yml from Example Corp's update mirror.",+ );+ assert.include(yield* resolve("preview", "win32", "x64", ""), "has no preview builds");+ }),+);+it.layer(NodeServices.layer)("t3 update under a managed policy", (it) => {const runWithPolicy = (updates: ManagedUpdatesPolicy,input: { readonly channel?: "stable" | "nightly"; readonly requestedVersion?: string } = {},+ httpClient = HttpClient.make(() => Effect.die("unexpected release lookup")),) =>runUpdate({baseDir: "/unused",@@ -85,10 +140,7 @@ it.layer(NodeServices.layer)("t3 update under a managed policy", (it) => {// Refusals happen before the update touches the network, the service, or a process.Layer.mock(BootService.BootService, {}),Layer.mock(ProcessRunner.ProcessRunner, {}),- Layer.succeed(- HttpClient.HttpClient,- HttpClient.make(() => Effect.die("unexpected release lookup")),- ),+ Layer.succeed(HttpClient.HttpClient, httpClient),),),);@@ -118,6 +170,24 @@ it.layer(NodeServices.layer)("t3 update under a managed policy", (it) => {}}),);++ it.effect("looks for updates on the policy's mirror, never the public releases", () =>+ Effect.gen(function* () {+ const requested: string[] = [];+ const error = yield* runWithPolicy(+ { mode: "auto", feedUrl: "https://updates.example.com/t3code" },+ { channel: "stable" },+ HttpClient.make((request) => {+ requested.push(new URL(request.url).origin);+ return Effect.succeed(+ HttpClientResponse.fromWeb(request, new Response("", { status: 404 })),+ );+ }),+ );+ assert.include(error.message, "from Example Corp's update mirror");+ assert.deepStrictEqual(requested, ["https://updates.example.com"]);+ }),+ );});it.layer(NodeServices.layer)("t3 update launcher", (it) => {diff --git a/apps/server/src/cli/update.ts b/apps/server/src/cli/update.tsindex dc2e2934586..be36b1184d8 100644--- a/apps/server/src/cli/update.ts+++ b/apps/server/src/cli/update.ts@@ -5,6 +5,8 @@ import {cliReleaseIndexPageUrl,cliReleaseChannelOf,newestCliReleaseVersion,+ releaseAssetUrl,+ updateFeedFileName,type CliReleaseChannel,} from "@t3tools/shared/cliRelease";import * as Console from "effect/Console";@@ -24,6 +26,7 @@ import {ensurePinnedRuntimeInstalled,launcherOwnsVersionsDir,pinnedRuntimeCommand,+ isUnpublishedRelease,PinnedRuntimeInstallError,pinnedRuntimePaths,pinnedRuntimeVersionsDir,@@ -33,7 +36,7 @@ import {} from "../cloud/pinnedRuntime.ts";import { compareExactServiceVersions, isExactServiceVersion } from "../cloud/serviceProtocol.ts";import * as ManagedPolicy from "../policy/ManagedPolicy.ts";-import { managedUpdateRefusal } from "../policy/managedUpdates.ts";+import { managedUpdateMirror, managedUpdateRefusal } from "../policy/managedUpdates.ts";import * as ProcessRunner from "../processRunner.ts";import { isProcessAlive, readPersistedServerRuntimeState } from "../serverRuntimeState.ts";import { projectLocationFlags, resolveCliAuthConfig } from "./config.ts";@@ -94,6 +97,47 @@ export const resolveNewestVersion = Effect.fn("cli.update.resolve_newest")(functreturn yield* new CliUpdateError({ reason: `No published ${channel} release was found.` });});+/** The version an update mirror's feed file for this platform offers on `channel`. */+export const resolveMirrorVersion = Effect.fn("cli.update.resolve_mirror")(function* (+ mirror: { readonly organization: string; readonly feedUrl: string },+ channel: CliReleaseChannel,+) {+ if (channel === "preview") {+ return yield* new CliUpdateError({+ reason: `${mirror.organization}'s update mirror has no preview builds.`,+ });+ }+ const httpClient = yield* HttpClient.HttpClient;+ const fileName = updateFeedFileName(+ channel === "nightly" ? "nightly" : "latest",+ yield* HostProcess.Platform,+ yield* HostProcess.Architecture,+ );+ const url = releaseAssetUrl(mirror.feedUrl, fileName);+ // Not the URL, whose query can hold the mirror's access token.+ const unreadable = new CliUpdateError({+ reason: `Could not read ${fileName} from ${mirror.organization}'s update mirror.`,+ });+ const body = yield* httpClient.get(url).pipe(+ Effect.flatMap(HttpClientResponse.filterStatusOk),+ Effect.flatMap((response) => response.text),+ Effect.mapError(() => unreadable),+ Effect.timeoutOrElse({+ duration: RELEASE_INDEX_TIMEOUT,+ orElse: () => Effect.fail(unreadable),+ }),+ );+ const version = /^version:\s*["']?([^"'\s]+)/m.exec(body)?.[1];+ if (+ version === undefined ||+ !isExactServiceVersion(version) ||+ cliReleaseChannelOf(version) !== channel+ ) {+ return yield* unreadable;+ }+ return version;+});+/*** Only a launcher that already points into this home's `runtime/versions` tree is touched; a* plain copy of the executable, or a launcher for some other install, is left alone. It is@@ -320,6 +364,7 @@ export const runUpdate = Effect.fn("cli.update.run")(function* (input: {const httpClient = yield* HttpClient.HttpClient;const service = yield* BootService.BootService;const policy = yield* ManagedPolicy.ManagedPolicy;+ const mirror = managedUpdateMirror(policy.document);const currentVersion = packageJson.version;const channel = input.channel ?? cliReleaseChannelOf(currentVersion);@@ -338,9 +383,11 @@ export const runUpdate = Effect.fn("cli.update.run")(function* (input: {const progress = createUpdateProgress();progress.status("Checking for updates...");const targetVersion = yield* (- input.requestedVersion === undefined- ? resolveNewestVersion(channel)- : Effect.succeed(input.requestedVersion)+ input.requestedVersion !== undefined+ ? Effect.succeed(input.requestedVersion)+ : mirror === undefined+ ? resolveNewestVersion(channel)+ : resolveMirrorVersion(mirror, channel)).pipe(Effect.ensuring(Effect.sync(progress.finish)));const targetChannel = cliReleaseChannelOf(targetVersion);@@ -455,7 +502,8 @@ export const runUpdate = Effect.fn("cli.update.run")(function* (input: {httpClient,platform,arch,- releaseBaseUrl: environment[CLI_RELEASE_BASE_URL_ENV]?.trim() || undefined,+ releaseBaseUrl: mirror?.feedUrl ?? (environment[CLI_RELEASE_BASE_URL_ENV]?.trim() || undefined),+ requirePublishedRelease: mirror !== undefined,validate: (paths) =>runner.run({@@ -481,17 +529,15 @@ export const runUpdate = Effect.fn("cli.update.run")(function* (input: {),}).pipe(Effect.ensuring(Effect.sync(progress.finish)),- Effect.catchIf(- (error): error is PinnedRuntimeInstallError =>- error._tag === "PinnedRuntimeInstallError" &&- error.step.startsWith("downloading the t3 release checksums") &&- String(error.cause).includes("404"),- () =>- Effect.fail(- new CliUpdateError({- reason: `No release archive was published for t3@${targetVersion}.`,- }),- ),+ Effect.catchIf(isUnpublishedRelease, () =>+ Effect.fail(+ new CliUpdateError({+ reason:+ mirror === undefined+ ? `No release archive was published for t3@${targetVersion}.`+ : `${mirror.organization}'s update mirror has no t3@${targetVersion} for this machine.`,+ }),+ ),),);diff --git a/apps/server/src/cloud/pinnedRuntime.test.ts b/apps/server/src/cloud/pinnedRuntime.test.tsindex 7babf123b9d..38e56b30388 100644--- a/apps/server/src/cloud/pinnedRuntime.test.ts+++ b/apps/server/src/cloud/pinnedRuntime.test.ts@@ -16,6 +16,7 @@ import * as HostProcess from "@t3tools/shared/HostProcess";import * as ProcessRunner from "../processRunner.ts";import {ensurePinnedRuntimeInstalled,+ isUnpublishedRelease,pinnedRuntimeCommand,pinnedRuntimePaths,PinnedRuntimeInstallError,@@ -39,7 +40,7 @@ const validChecksums = archiveHex(archiveBytes).pipe(const releaseHttpClient = (checksums: string, requests: string[] = []) =>HttpClient.make((request) => {requests.push(request.url);- const body = request.url.endsWith("/SHA256SUMS") ? checksums : archiveBytes;+ const body = new URL(request.url).pathname.endsWith("/SHA256SUMS") ? checksums : archiveBytes;return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(body)));});const extractingRunner = (fs: FileSystem.FileSystem, path: Path.Path, commands: string[] = []) =>@@ -155,6 +156,40 @@ it.layer(NodeServices.layer)("ensurePinnedRuntimeInstalled", (it) => {}),);+ it.effect("reports a release that lists an archive it does not serve as unpublished", () =>+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const path = yield* Path.Path;+ const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-archive-missing-" });+ const checksums = yield* validChecksums;+ const failsWith = (status: number) =>+ ensurePinnedRuntimeInstalled({+ baseDir,+ version,+ fs,+ path,+ platform: "linux",+ arch: "x64",+ httpClient: HttpClient.make((request) =>+ Effect.succeed(+ HttpClientResponse.fromWeb(+ request,+ request.url.endsWith("/SHA256SUMS")+ ? new Response(checksums)+ : new Response("", { status }),+ ),+ ),+ ),+ // "404" in the mirror's path must not read a server error as a missing release.+ releaseBaseUrl: "https://updates.example.com/404/t3code",+ runner: extractingRunner(fs, path),+ validate: () => Effect.die("must not validate a missing archive"),+ }).pipe(Effect.flip);+ assert.isTrue(isUnpublishedRelease(yield* failsWith(404)));+ assert.isFalse(isUnpublishedRelease(yield* failsWith(500)));+ }),+ );+it.effect("refuses an archive whose checksum does not match the release", () =>Effect.gen(function* () {const fs = yield* FileSystem.FileSystem;@@ -267,6 +302,42 @@ it.layer(NodeServices.layer)("ensurePinnedRuntimeInstalled", (it) => {}),);+ it.effect("reuses a cached runtime under a mirror only while the mirror lists it", () =>+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const path = yield* Path.Path;+ const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-mirror-" });+ const cached = pinnedRuntimePaths(path, baseDir, version, "linux");+ yield* fs.makeDirectory(path.dirname(cached.entryPath), { recursive: true });+ yield* fs.writeFileString(cached.entryPath, "#!/bin/sh\n");+ yield* fs.writeFileString(cached.sentinelPath, `${version}\n`);+ const install = (checksums: string, requests: string[]) =>+ ensurePinnedRuntimeInstalled({+ baseDir,+ version,+ fs,+ path,+ platform: "linux",+ arch: "x64",+ httpClient: releaseHttpClient(checksums, requests),+ // A signed mirror URL keeps its query on every file it serves.+ releaseBaseUrl: "https://updates.example.com/t3code/?token=abc",+ requirePublishedRelease: true,+ runner: extractingRunner(fs, path),+ validate: () => Effect.void,+ });++ const withdrawn = yield* install("", []).pipe(Effect.flip);+ assert.include(withdrawn.message, `finding ${archiveName} in the t3 release checksums`);+ const requests: string[] = [];+ assert.equal((yield* install(yield* validChecksums, requests)).entryPath, cached.entryPath);+ // Listed, so the cached runtime is used without downloading it again.+ assert.deepEqual(requests, [+ `https://updates.example.com/t3code/v${version}/SHA256SUMS?token=abc`,+ ]);+ }),+ );+it.effect("preserves a completed runtime when validation fails", () =>Effect.gen(function* () {const fs = yield* FileSystem.FileSystem;diff --git a/apps/server/src/cloud/pinnedRuntime.ts b/apps/server/src/cloud/pinnedRuntime.tsindex 96745fe85bf..4e8df29f302 100644--- a/apps/server/src/cloud/pinnedRuntime.ts+++ b/apps/server/src/cloud/pinnedRuntime.ts@@ -9,14 +9,15 @@ import * as Schema from "effect/Schema";import * as Option from "effect/Option";import * as Stream from "effect/Stream";import * as Semaphore from "effect/Semaphore";-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";import {CLI_RELEASE_CHECKSUMS_FILE,cliArchiveFileName,cliArchivePlatformKey,cliArchiveTarCommand,- cliReleaseDownloadBaseUrl,+ cliReleaseAssetUrl,+ type CliArchivePlatformKey,parseChecksums,} from "@t3tools/shared/cliRelease";@@ -111,6 +112,8 @@ interface PinnedRuntimeInstallInput {readonly arch: string;readonly httpClient: HttpClient.HttpClient;readonly releaseBaseUrl?: string | undefined;+ /** Reuse a cached runtime only while the release source still lists it, as a policy mirror does. */+ readonly requirePublishedRelease?: boolean;readonly onProgress?: (progress: PinnedRuntimeProgress) => void;}@@ -178,28 +181,11 @@ const installFromArchive = Effect.fn("cloud.pinned_runtime.install_archive")(fun});}const httpClient = input.httpClient;- const baseUrl = cliReleaseDownloadBaseUrl(input.version, input.releaseBaseUrl);- const fileName = cliArchiveFileName(input.version, platformKey);-input.onProgress?.({ stage: "download", received: 0, total: undefined });- const checksums = parseChecksums(- new TextDecoder().decode(- yield* fetchReleaseAsset(- httpClient,- `${baseUrl}/${CLI_RELEASE_CHECKSUMS_FILE}`,- "downloading the t3 release checksums",- ),- ),- );- const expected = checksums.get(fileName);- if (expected === undefined) {- return yield* new PinnedRuntimeInstallError({- step: `finding ${fileName} in the t3 release checksums`,- });- }+ const { fileName, expected } = yield* publishedArchive(input, platformKey);const archive = yield* fetchReleaseAsset(httpClient,- `${baseUrl}/${fileName}`,+ cliReleaseAssetUrl(input.version, fileName, input.releaseBaseUrl),"downloading the t3 release archive",input.onProgress,);@@ -248,6 +234,40 @@ const installFromArchive = Effect.fn("cloud.pinned_runtime.install_archive")(funyield* fs.remove(archivePath, { force: true }).pipe(Effect.ignore);});+/** The release's archive for this machine and its checksum; fails when the release lists none. */+const publishedArchive = Effect.fn("cloud.pinned_runtime.published_archive")(function* (+ input: PinnedRuntimeInstallInput,+ platformKey: CliArchivePlatformKey,+) {+ const fileName = cliArchiveFileName(input.version, platformKey);+ const checksums = parseChecksums(+ new TextDecoder().decode(+ yield* fetchReleaseAsset(+ input.httpClient,+ cliReleaseAssetUrl(input.version, CLI_RELEASE_CHECKSUMS_FILE, input.releaseBaseUrl),+ "downloading the t3 release checksums",+ ),+ ),+ );+ const expected = checksums.get(fileName);+ if (expected === undefined) {+ return yield* new PinnedRuntimeInstallError({+ step: `finding ${fileName} in the t3 release checksums`,+ });+ }+ return { fileName, expected };+});++const isPinnedRuntimeInstallError = Schema.is(PinnedRuntimeInstallError);++/** Whether an install failed because the release source does not publish the version for this machine. */+export const isUnpublishedRelease = (error: unknown): error is PinnedRuntimeInstallError =>+ isPinnedRuntimeInstallError(error) &&+ (error.step.startsWith("finding ") ||+ (error.step.startsWith("downloading the t3 release") &&+ HttpClientError.isHttpClientError(error.cause) &&+ error.cause.response?.status === 404));+const installPinnedRuntime = Effect.fn("cloud.pinned_runtime.ensure_installed")(function* (input: PinnedRuntimeInstallInput,) {@@ -265,6 +285,15 @@ const installPinnedRuntime = Effect.fn("cloud.pinned_runtime.ensure_installed")(const alreadyPinned =entryExists && Option.isSome(sentinel) && sentinel.value.trim() === input.version;if (alreadyPinned) {+ if (input.requirePublishedRelease === true) {+ const platformKey = cliArchivePlatformKey(input.platform, input.arch);+ if (platformKey === undefined) {+ return yield* new PinnedRuntimeInstallError({+ step: `selecting a t3 release archive for ${input.platform}-${input.arch}`,+ });+ }+ yield* publishedArchive(input, platformKey);+ }input.onProgress?.({ stage: "cached" });yield* input.validate(paths);return paths;diff --git a/apps/server/src/cloud/selfUpdate.test.ts b/apps/server/src/cloud/selfUpdate.test.tsindex 9e1aee9c095..a938d677882 100644--- a/apps/server/src/cloud/selfUpdate.test.ts+++ b/apps/server/src/cloud/selfUpdate.test.ts@@ -36,9 +36,10 @@ interface HarnessOptions {}const archiveBytes = new TextEncoder().encode("not really a tarball");-const releaseHttpClient = (order: string[], beforeDownload?: Effect.Effect<void>) =>+const releaseHttpClient = (order: string[], urls: string[], beforeDownload?: Effect.Effect<void>) =>HttpClient.make((request) =>Effect.gen(function* () {+ urls.push(request.url);if (request.url.endsWith("/SHA256SUMS")) {const digest = yield* Effect.promise(() => crypto.subtle.digest("SHA-256", archiveBytes));const hex = Array.from(new Uint8Array(digest), (byte) =>@@ -62,6 +63,7 @@ const makeHarness = Effect.fn("test.make_self_update_harness")(function* (const path = yield* Path.Path;const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-self-update-test-" });const order: string[] = [];+ const urls: string[] = [];const runner = ProcessRunner.ProcessRunner.of({run: (input) =>Effect.gen(function* () {@@ -141,7 +143,10 @@ const makeHarness = Effect.fn("test.make_self_update_harness")(function* (run: () => Effect.die("unexpected desktop app update run"),},),- Effect.provideService(HttpClient.HttpClient, releaseHttpClient(order, options.beforeDownload)),+ Effect.provideService(+ HttpClient.HttpClient,+ releaseHttpClient(order, urls, options.beforeDownload),+ ),Effect.provideService(HostProcess.Platform, "linux"),Effect.provideService(HostProcess.Architecture, "x64"),Effect.provide(@@ -151,7 +156,7 @@ const makeHarness = Effect.fn("test.make_self_update_harness")(function* (),),);- return { selfUpdate, order };+ return { selfUpdate, order, urls };});it.layer(NodeServices.layer)("server self update", (it) => {@@ -198,11 +203,17 @@ it.layer(NodeServices.layer)("server self update", (it) => {it.effect("lets a user start an update, but only to stable without nightly", () =>Effect.gen(function* () {- const { selfUpdate, order } = yield* makeHarness({+ const { selfUpdate, order, urls } = yield* makeHarness({policy: {schemaVersion: 1,organization: "Example Corp",- limits: { updates: { mode: "auto", allowNightly: false } },+ limits: {+ updates: {+ mode: "auto",+ allowNightly: false,+ feedUrl: "https://updates.example.com/t3code/",+ },+ },},});expect(@@ -210,7 +221,15 @@ it.layer(NodeServices.layer)("server self update", (it) => {.reason,).toBe("Example Corp manages T3 Code updates. Only stable releases can be installed.");expect(order).toEqual([]);+ // The mirror lists only 1.1.0's archive.+ expect((yield* selfUpdate.update({ targetVersion: "1.2.0" }).pipe(Effect.flip)).reason).toBe(+ "Example Corp's update mirror has no [email protected] for this machine.",+ );expect((yield* selfUpdate.update({ targetVersion: "1.1.0" })).updateId).toBe("launcher-id");+ // The release comes from the policy's mirror, not GitHub.+ expect(urls.length).toBeGreaterThan(0);+ for (const url of urls)+ expect(url).toMatch(/^https:\/\/updates\.example\.com\/t3code\/v1\.[12]\.0\//);}),);diff --git a/apps/server/src/cloud/selfUpdate.ts b/apps/server/src/cloud/selfUpdate.tsindex 1f285b9b652..58baa160adf 100644--- a/apps/server/src/cloud/selfUpdate.ts+++ b/apps/server/src/cloud/selfUpdate.ts@@ -31,10 +31,11 @@ import * as ServerConfig from "../config.ts";import * as DesktopAppUpdate from "../desktopUpdate/DesktopAppUpdate.ts";import { databaseMigrationHead } from "../persistence/databaseMigrationHead.ts";import * as ManagedPolicy from "../policy/ManagedPolicy.ts";-import { managedUpdateRefusal } from "../policy/managedUpdates.ts";+import { managedUpdateMirror, managedUpdateRefusal } from "../policy/managedUpdates.ts";import * as ProcessRunner from "../processRunner.ts";import {ensurePinnedRuntimeInstalled,+ isUnpublishedRelease,pinnedRuntimeCommand,PinnedRuntimeInstallError,pinnedRuntimePaths,@@ -132,9 +133,10 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {const platform = yield* HostProcess.Platform;const arch = yield* HostProcess.Architecture;const httpClient = yield* HttpClient.HttpClient;- const releaseBaseUrl = Option.getOrUndefined(- yield* Config.String(CLI_RELEASE_BASE_URL_ENV).pipe(Config.option),- );+ const mirror = managedUpdateMirror(policy.document);+ const releaseBaseUrl =+ mirror?.feedUrl ??+ Option.getOrUndefined(yield* Config.String(CLI_RELEASE_BASE_URL_ENV).pipe(Config.option));const inFlight = yield* Ref.make(false);yield* pruneRuntimesOnStart({ baseDir: serverConfig.baseDir, managed: launcher.managed }).pipe(@@ -209,6 +211,7 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {platform,arch,releaseBaseUrl,+ requirePublishedRelease: mirror !== undefined,validate: (runtime) =>runner.run({@@ -282,7 +285,12 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {Effect.mapError((error) =>error._tag === "PinnedRuntimePreflightBlockedError"? failWith(error.reason, error)- : failWith(`Could not prepare t3@${targetVersion}.`, error),+ : mirror !== undefined && isUnpublishedRelease(error)+ ? failWith(+ `${mirror.organization}'s update mirror has no t3@${targetVersion} for this machine.`,+ error,+ )+ : failWith(`Could not prepare t3@${targetVersion}.`, error),),);diff --git a/apps/server/src/policy/managedUpdates.ts b/apps/server/src/policy/managedUpdates.tsindex 32adc6e4f38..d805cfa028e 100644--- a/apps/server/src/policy/managedUpdates.ts+++ b/apps/server/src/policy/managedUpdates.ts@@ -5,6 +5,17 @@ import {} from "@t3tools/contracts";import type { CliReleaseChannel } from "@t3tools/shared/cliRelease";+/**+ * The update mirror the policy sends updates to, or `undefined` for the public releases. It wins+ * over the environment, which a user can set.+ */+export function managedUpdateMirror(document: ManagedPolicyDocument | undefined) {+ const feedUrl = document?.limits?.updates?.feedUrl;+ return feedUrl === undefined || document === undefined+ ? undefined+ : { organization: document.organization, feedUrl };+}+/*** Why the managed policy refuses an update a user or maintainer asked for, or `undefined` when it* allows it. The server never updates on its own, so `auto` allows every explicit request.diff --git a/docs/user/managed-policy.md b/docs/user/managed-policy.mdindex 6df53756848..f9d170624bd 100644--- a/docs/user/managed-policy.md+++ b/docs/user/managed-policy.md@@ -250,9 +250,13 @@ starts the binary you set.- `mode`: `auto` keeps the normal update flow. `off` stops T3 Code from checking for updates, formachines that get T3 Code through device management.-- `feedUrl`: the desktop app updates from your own mirror of the release feed instead of GitHub.- Publish only the versions you have approved. The `t3` command-line server updates through npm,- so pin it with your package tooling.+- `feedUrl`: T3 Code updates from your own mirror instead of GitHub: the desktop app, `t3 update`,+ and updates started from another device. Publish only the versions you have approved, laid out+ as on a GitHub release. The release's update files (`latest.yml`, `latest-mac.yml`,+ `latest-linux.yml`, `latest-linux-arm64.yml`, and their `nightly` versions if you allow nightly)+ and the desktop installers they list go at the URL's root. The release's `t3-*` archives and+ `SHA256SUMS` go under `v<version>/`. A `t3` run through `npx` comes from npm, so pin it with your+ package tooling.- `allowNightly: false`: the nightly channel is unavailable.## What a policy does not coverdiff --git a/packages/shared/src/cliRelease.ts b/packages/shared/src/cliRelease.tsindex 66777cc0444..80eeec43975 100644--- a/packages/shared/src/cliRelease.ts+++ b/packages/shared/src/cliRelease.ts@@ -50,6 +50,22 @@ export function cliReleaseDownloadBaseUrl(return `${(baseUrl?.trim() || CLI_RELEASE_DEFAULT_BASE_URL).replace(/\/+$/, "")}/v${version}`;}+/** `segments` added to `baseUrl`'s path, keeping its query, such as a signed mirror URL's token. */+export function releaseAssetUrl(baseUrl: string, ...segments: ReadonlyArray<string>): string {+ const url = new URL(baseUrl);+ url.pathname = [url.pathname.replace(/\/+$/, ""), ...segments.map(encodeURIComponent)].join("/");+ return url.toString();+}++/** A file of release `version`, from `baseUrl` laid out as GitHub's release downloads. */+export function cliReleaseAssetUrl(+ version: string,+ fileName: string,+ baseUrl: string | undefined = CLI_RELEASE_DEFAULT_BASE_URL,+): string {+ return releaseAssetUrl(baseUrl?.trim() || CLI_RELEASE_DEFAULT_BASE_URL, `v${version}`, fileName);+}+export function parseChecksums(text: string): ReadonlyMap<string, string> {const checksums = new Map<string, string>();for (const line of text.split(/\r?\n/)) {@@ -86,6 +102,21 @@ export function desktopUpdateChannelOf(version: string): "latest" | "nightly" {return cliReleaseChannelOf(version) === "nightly" ? "nightly" : "latest";}+/**+ * The update feed file a desktop app on this platform reads, which an update mirror publishes at+ * its root beside the release's CLI archives.+ */+export function updateFeedFileName(+ channel: "latest" | "nightly",+ platform: NodeJS.Platform,+ arch: string,+): string {+ if (platform === "darwin") return `${channel}-mac.yml`;+ if (platform === "linux")+ return arch === "arm64" ? `${channel}-linux-arm64.yml` : `${channel}-linux.yml`;+ return `${channel}.yml`;+}+/** Whether a track switch may install `found` after its database check cleared `checked`: any build* on the switch's track at least as new, since later releases only add migrations. */export function acceptsTrackSwitchRelease(