Nightly release channel (#2012)

Julius Marminge committed 7 months agonightly-v0.0.17-nightly.20260415.44

Commit 409ff901 parent 0d2802649 files · +1203 −131Browse files

Showing the changes to scripts (7 of 49 files). Show all

Unified · Split

7 files

scripts/build-desktop-artifact.test.ts +51 −1
scripts/build-desktop-artifact.ts +101 −49
scripts/lib/brand-assets.ts +6 −0
scripts/release-smoke.ts +35 −1
scripts/resolve-nightly-release.test.ts +25 −0
scripts/resolve-nightly-release.ts +126 −0
scripts/resolve-previous-release-tag.ts +203 −0

scripts/build-desktop-artifact.test.ts+51−1

@@ -2,9 +2,59 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; · 1 unmodified line
2	import { assert, it } from "@effect/vitest";	2	import { assert, it } from "@effect/vitest";
3	import { ConfigProvider, Effect, Option } from "effect";	3	import { ConfigProvider, Effect, Option } from "effect";
4		4
5	import { resolveBuildOptions } from "./build-desktop-artifact.ts";	5	import {
		6	resolveBuildOptions,
		7	resolveDesktopBuildIconAssets,
		8	resolveDesktopUpdateChannel,
		9	resolveMockUpdateServerPort,
		10	resolveMockUpdateServerUrl,
		11	} from "./build-desktop-artifact.ts";
		12	import { BRAND_ASSET_PATHS } from "./lib/brand-assets.ts";
6		13
7	it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {	14	it.layer(NodeServices.layer)("build-desktop-artifact", (it) => {
		15	it("resolves the dedicated nightly updater channel from nightly versions", () => {
		16	assert.equal(resolveDesktopUpdateChannel("0.0.17-nightly.20260413.42"), "nightly");
		17	assert.equal(resolveDesktopUpdateChannel("0.0.17"), "latest");
		18	});
		19
		20	it("switches desktop packaging icons to the nightly artwork for nightly versions", () => {
		21	assert.deepStrictEqual(resolveDesktopBuildIconAssets("0.0.17"), {
		22	macIconPng: BRAND_ASSET_PATHS.productionMacIconPng,
		23	linuxIconPng: BRAND_ASSET_PATHS.productionLinuxIconPng,
		24	windowsIconIco: BRAND_ASSET_PATHS.productionWindowsIconIco,
		25	});
		26
		27	assert.deepStrictEqual(resolveDesktopBuildIconAssets("0.0.17-nightly.20260413.42"), {
		28	macIconPng: BRAND_ASSET_PATHS.nightlyMacIconPng,
		29	linuxIconPng: BRAND_ASSET_PATHS.nightlyLinuxIconPng,
		30	windowsIconIco: BRAND_ASSET_PATHS.nightlyWindowsIconIco,
		31	});
		32	});
		33
		34	it("falls back to the default mock update port when the configured port is blank", () => {
		35	assert.equal(resolveMockUpdateServerUrl(undefined), "http://localhost:3000");
		36	assert.equal(resolveMockUpdateServerUrl(4123), "http://localhost:4123");
		37	});
		38
		39	it.effect("normalizes mock update server ports from env-style strings", () =>
		40	Effect.gen(function* () {
		41	assert.equal(yield* resolveMockUpdateServerPort(undefined), undefined);
		42	assert.equal(yield* resolveMockUpdateServerPort(""), undefined);
		43	assert.equal(yield* resolveMockUpdateServerPort(" "), undefined);
		44	assert.equal(yield* resolveMockUpdateServerPort("4123"), 4123);
		45	}),
		46	);
		47
		48	it.effect("rejects non-numeric or out-of-range mock update ports", () =>
		49	Effect.gen(function* () {
		50	const invalidPorts = ["abc", "12.5", "0", "65536"];
		51	for (const port of invalidPorts) {
		52	const exit = yield* Effect.exit(resolveMockUpdateServerPort(port));
		53	assert.equal(exit._tag, "Failure");
		54	}
		55	}),
		56	);
		57
8	it.effect("preserves explicit false boolean flags over true env defaults", () =>	58	it.effect("preserves explicit false boolean flags over true env defaults", () =>
9	Effect.gen(function* () {	59	Effect.gen(function* () {
10	const resolved = yield* resolveBuildOptions({	60	const resolved = yield* resolveBuildOptions({

scripts/build-desktop-artifact.ts+101−49

 const RepoRoot = Effect.service(Path.Path).pipe(
   Effect.flatMap((path) => path.fromFileUrl(new URL("..", import.meta.url))),
 );
-const ProductionMacIconSource = Effect.zipWith(
-  RepoRoot,
-  Effect.service(Path.Path),
-  (repoRoot, path) => path.join(repoRoot, BRAND_ASSET_PATHS.productionMacIconPng),
-);
-const ProductionLinuxIconSource = Effect.zipWith(
-  RepoRoot,
-  Effect.service(Path.Path),
-  (repoRoot, path) => path.join(repoRoot, BRAND_ASSET_PATHS.productionLinuxIconPng),
-);
-const ProductionWindowsIconSource = Effect.zipWith(
-  RepoRoot,
-  Effect.service(Path.Path),
-  (repoRoot, path) => path.join(repoRoot, BRAND_ASSET_PATHS.productionWindowsIconIco),
-);
 const encodeJsonString = Schema.encodeEffect(Schema.UnknownFromJsonString);
+interface DesktopBuildIconAssets {
+  readonly macIconPng: string;
+  readonly linuxIconPng: string;
+  readonly windowsIconIco: string;
+}
 interface PlatformConfig {
   readonly cliFlag: "--mac" | "--linux" | "--win";
   readonly defaultTarget: string;
   readonly signed: Option.Option<boolean>;
   readonly verbose: Option.Option<boolean>;
   readonly mockUpdates: Option.Option<boolean>;
-  readonly mockUpdateServerPort: Option.Option<string>;
+  readonly mockUpdateServerPort: Option.Option<number>;
 }
 function detectHostBuildPlatform(hostPlatform: string): typeof BuildPlatform.Type | undefined {
   readonly signed: boolean;
   readonly verbose: boolean;
   readonly mockUpdates: boolean;
-  readonly mockUpdateServerPort: string | undefined;
+  readonly mockUpdateServerPort: number | undefined;
 }
 interface StagePackageJson {
   mockUpdateServerPort: Config.string("T3CODE_DESKTOP_MOCK_UPDATE_SERVER_PORT").pipe(Config.option),
 });
+const MockUpdateServerPortSchema = Schema.NumberFromString.check(
+  Schema.isInt(),
+  Schema.isBetween({ minimum: 1, maximum: 65535 }),
+);
+const decodeMockUpdateServerPort = Schema.decodeUnknownEffect(MockUpdateServerPortSchema);
 const resolveBooleanFlag = (flag: Option.Option<boolean>, envValue: boolean) =>
   Option.getOrElse(flag, () => envValue);
 const mergeOptions = <A>(a: Option.Option<A>, b: Option.Option<A>, defaultValue: A) =>
   Option.getOrElse(a, () => Option.getOrElse(b, () => defaultValue));
+export const resolveMockUpdateServerPort = Effect.fn("resolveMockUpdateServerPort")(function* (
+  mockUpdateServerPort: string | undefined,
+) {
+  const port = mockUpdateServerPort?.trim();
+  if (!port) {
+    return undefined;
+  }
+  return yield* decodeMockUpdateServerPort(port);
+});
 export const resolveBuildOptions = Effect.fn("resolveBuildOptions")(function* (
   input: BuildCliInput,
 ) {
   const verbose = resolveBooleanFlag(input.verbose, env.verbose);
   const mockUpdates = resolveBooleanFlag(input.mockUpdates, env.mockUpdates);
-  const mockUpdateServerPort = mergeOptions(
+  const mockUpdateServerPort =
-    input.mockUpdateServerPort,
+    Option.getOrUndefined(input.mockUpdateServerPort) ??
-    env.mockUpdateServerPort,
+    (yield* resolveMockUpdateServerPort(Option.getOrUndefined(env.mockUpdateServerPort)).pipe(
-    undefined,
+      Effect.mapError(
-  );
+        (cause) =>
+          new BuildScriptError({
+            message: "Invalid mock update server port.",
+            cause,
+          }),
+      ),
+    ));
   return {
     platform,
   });
 }
-function stageMacIcons(stageResourcesDir: string, verbose: boolean) {
+function stageMacIcons(stageResourcesDir: string, sourcePng: string, verbose: boolean) {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const iconSource = yield* ProductionMacIconSource;
+    if (!(yield* fs.exists(sourcePng))) {
-    if (!(yield* fs.exists(iconSource))) {
       return yield* new BuildScriptError({
-        message: `Production icon source is missing at ${iconSource}`,
+        message: `Desktop macOS icon source is missing at ${sourcePng}`,
       });
     }
     yield* runCommand(
       ChildProcess.make({
         ...commandOutputOptions(verbose),
-      })`sips -z 512 512 ${iconSource} --out ${iconPngPath}`,
+      })`sips -z 512 512 ${sourcePng} --out ${iconPngPath}`,
     );
-    yield* generateMacIconSet(iconSource, iconIcnsPath, tmpRoot, path, verbose);
+    yield* generateMacIconSet(sourcePng, iconIcnsPath, tmpRoot, path, verbose);
   });
 }
-function stageLinuxIcons(stageResourcesDir: string) {
+function stageLinuxIcons(stageResourcesDir: string, sourcePng: string) {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const iconSource = yield* ProductionLinuxIconSource;
+    if (!(yield* fs.exists(sourcePng))) {
-    if (!(yield* fs.exists(iconSource))) {
       return yield* new BuildScriptError({
-        message: `Production icon source is missing at ${iconSource}`,
+        message: `Desktop Linux icon source is missing at ${sourcePng}`,
       });
     }
     const iconPath = path.join(stageResourcesDir, "icon.png");
-    yield* fs.copyFile(iconSource, iconPath);
+    yield* fs.copyFile(sourcePng, iconPath);
   });
 }
-function stageWindowsIcons(stageResourcesDir: string) {
+function stageWindowsIcons(stageResourcesDir: string, sourceIco: string) {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const iconSource = yield* ProductionWindowsIconSource;
+    if (!(yield* fs.exists(sourceIco))) {
-    if (!(yield* fs.exists(iconSource))) {
       return yield* new BuildScriptError({
-        message: `Production Windows icon source is missing at ${iconSource}`,
+        message: `Desktop Windows icon source is missing at ${sourceIco}`,
       });
     }
     const iconPath = path.join(stageResourcesDir, "icon.ico");
-    yield* fs.copyFile(iconSource, iconPath);
+    yield* fs.copyFile(sourceIco, iconPath);
   });
 }
   return resolveCatalogDependencies(runtimeDependencies, catalog, "apps/desktop");
 }
-function resolveGitHubPublishConfig():
+function resolveGitHubPublishConfig(updateChannel: "latest" | "nightly"):
   | {
       readonly provider: "github";
       readonly owner: string;
       readonly repo: string;
-      readonly releaseType: "release";
+      readonly releaseType: "release" | "prerelease";
+      readonly channel?: "nightly";
     }
   | undefined {
   const rawRepo =
     provider: "github",
     owner,
     repo,
-    releaseType: "release",
+    releaseType: updateChannel === "nightly" ? "prerelease" : "release",
+    ...(updateChannel === "nightly" ? { channel: "nightly" as const } : {}),
   };
 }
+export function resolveDesktopUpdateChannel(version: string): "latest" | "nightly" {
+  return /-nightly\.\d{8}\.\d+$/.test(version) ? "nightly" : "latest";
+}
+export function resolveDesktopBuildIconAssets(version: string): DesktopBuildIconAssets {
+  if (resolveDesktopUpdateChannel(version) === "nightly") {
+    return {
+      macIconPng: BRAND_ASSET_PATHS.nightlyMacIconPng,
+      linuxIconPng: BRAND_ASSET_PATHS.nightlyLinuxIconPng,
+      windowsIconIco: BRAND_ASSET_PATHS.nightlyWindowsIconIco,
+    };
+  }
+  return {
+    macIconPng: BRAND_ASSET_PATHS.productionMacIconPng,
+    linuxIconPng: BRAND_ASSET_PATHS.productionLinuxIconPng,
+    windowsIconIco: BRAND_ASSET_PATHS.productionWindowsIconIco,
+  };
+}
+export function resolveMockUpdateServerUrl(mockUpdateServerPort: number | undefined): string {
+  return `http://localhost:${mockUpdateServerPort ?? 3000}`;
+}
 const createBuildConfig = Effect.fn("createBuildConfig")(function* (
   platform: typeof BuildPlatform.Type,
   target: string,
   productName: string,
+  version: string,
   signed: boolean,
   mockUpdates: boolean,
-  mockUpdateServerPort: string | undefined,
+  mockUpdateServerPort: number | undefined,
 ) {
   const buildConfig: Record<string, unknown> = {
     appId: "com.t3tools.t3code",
       buildResources: "apps/desktop/resources",
     },
   };
-  const publishConfig = resolveGitHubPublishConfig();
+  const updateChannel = resolveDesktopUpdateChannel(version);
+  const publishConfig = resolveGitHubPublishConfig(updateChannel);
   if (publishConfig) {
     buildConfig.publish = [publishConfig];
   } else if (mockUpdates) {
     buildConfig.publish = [
       {
         provider: "generic",
-        url: `http://localhost:${mockUpdateServerPort ?? 3000}`,
+        url: resolveMockUpdateServerUrl(mockUpdateServerPort),
       },
     ];
   }
 const assertPlatformBuildResources = Effect.fn("assertPlatformBuildResources")(function* (
   platform: typeof BuildPlatform.Type,
   stageResourcesDir: string,
+  iconAssets: DesktopBuildIconAssets,
   verbose: boolean,
 ) {
   if (platform === "mac") {
-    yield* stageMacIcons(stageResourcesDir, verbose);
+    yield* stageMacIcons(stageResourcesDir, iconAssets.macIconPng, verbose);
     return;
   }
   if (platform === "linux") {
-    yield* stageLinuxIcons(stageResourcesDir);
+    yield* stageLinuxIcons(stageResourcesDir, iconAssets.linuxIconPng);
     return;
   }
   if (platform === "win") {
-    yield* stageWindowsIcons(stageResourcesDir);
+    yield* stageWindowsIcons(stageResourcesDir, iconAssets.windowsIconIco);
   }
 });
   });
   const appVersion = options.version ?? serverPackageJson.version;
+  const iconAssets = resolveDesktopBuildIconAssets(appVersion);
   const commitHash = resolveGitCommitHash(repoRoot);
   const mkdir = options.keepStage ? fs.makeTempDirectory : fs.makeTempDirectoryScoped;
   const stageRoot = yield* mkdir({
   yield* fs.copy(distDirs.desktopResources, stageResourcesDir);
   yield* fs.copy(distDirs.serverDist, path.join(stageAppDir, "apps/server/dist"));
-  yield* assertPlatformBuildResources(options.platform, stageResourcesDir, options.verbose);
+  yield* assertPlatformBuildResources(
+    options.platform,
+    stageResourcesDir,
+    {
+      macIconPng: join(repoRoot, iconAssets.macIconPng),
+      linuxIconPng: join(repoRoot, iconAssets.linuxIconPng),
+      windowsIconIco: join(repoRoot, iconAssets.windowsIconIco),
+    },
+    options.verbose,
+  );
   // electron-builder is filtering out stageResourcesDir directory in the AppImage for production
   yield* fs.copy(stageResourcesDir, path.join(stageAppDir, "apps/desktop/prod-resources"));
       options.platform,
       options.target,
       desktopPackageJson.productName ?? "T3 Code",
+      appVersion,
       options.signed,
       options.mockUpdates,
       options.mockUpdateServerPort,
     Flag.withDescription("Enable mock updates (env: T3CODE_DESKTOP_MOCK_UPDATES)."),
     Flag.optional,
   ),
-  mockUpdateServerPort: Flag.string("mock-update-server-port").pipe(
+  mockUpdateServerPort: Flag.integer("mock-update-server-port").pipe(
+    Flag.withSchema(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))),
     Flag.withDescription("Mock update server port (env: T3CODE_DESKTOP_MOCK_UPDATE_SERVER_PORT)."),
     Flag.optional,
   ),

scripts/lib/brand-assets.ts+6−0

   productionWebFavicon16Png: "assets/prod/t3-black-web-favicon-16x16.png",
   productionWebFavicon32Png: "assets/prod/t3-black-web-favicon-32x32.png",
   productionWebAppleTouchIconPng: "assets/prod/t3-black-web-apple-touch-180.png",
+  nightlyMacIconPng: "assets/nightly/blueprint-macos-1024.png",
+  nightlyLinuxIconPng: "assets/nightly/blueprint-universal-1024.png",
+  nightlyWindowsIconIco: "assets/nightly/blueprint-windows.ico",
+  developmentDesktopIconPng: "assets/dev/blueprint-macos-1024.png",
   developmentWindowsIconIco: "assets/dev/blueprint-windows.ico",
   developmentWebFaviconIco: "assets/dev/blueprint-web-favicon.ico",
   developmentWebFavicon16Png: "assets/dev/blueprint-web-favicon-16x16.png",

scripts/release-smoke.ts+35−1

@@ -95,7 +95,7 @@ try { · 94 unmodified lines
95	},	95	},
96	);	96	);
97		97
98	execFileSync("bun", ["install", "--lockfile-only", "--ignore-scripts"], {	98	execFileSync("bun", ["install", "--ignore-scripts"], {
99	cwd: tempRoot,	99	cwd: tempRoot,
100	stdio: "inherit",	100	stdio: "inherit",
101	});	101	});
@@ -107,6 +107,40 @@ try { · 5 unmodified lines
107	"Expected bun.lock to contain the smoke version.",	107	"Expected bun.lock to contain the smoke version.",
108	);	108	);
109		109
		110	const nightlyReleaseMetadata = execFileSync(
		111	process.execPath,
		112	[
		113	resolve(repoRoot, "scripts/resolve-nightly-release.ts"),
		114	"--date",
		115	"20260413",
		116	"--run-number",
		117	"321",
		118	"--sha",
		119	"abcdef1234567890",
		120	"--root",
		121	tempRoot,
		122	],
		123	{
		124	cwd: repoRoot,
		125	encoding: "utf8",
		126	},
		127	);
		128	assertContains(
		129	nightlyReleaseMetadata,
		130	"version=9.9.9-nightly.20260413.321",
		131	"Expected nightly metadata to contain the derived nightly version.",
		132	);
		133	assertContains(
		134	nightlyReleaseMetadata,
		135	"tag=nightly-v9.9.9-nightly.20260413.321",
		136	"Expected nightly metadata to contain the derived nightly tag.",
		137	);
		138	assertContains(
		139	nightlyReleaseMetadata,
		140	"name=T3 Code Nightly 9.9.9-nightly.20260413.321 (abcdef123456)",
		141	"Expected nightly metadata to include the short commit SHA in the release name.",
		142	);
		143
110	const { arm64Path, x64Path } = writeMacManifestFixtures(tempRoot);	144	const { arm64Path, x64Path } = writeMacManifestFixtures(tempRoot);
111	execFileSync(	145	execFileSync(
112	process.execPath,	146	process.execPath,

scripts/resolve-nightly-release.test.ts+25−0

@@ -0,0 +1,25 @@
	1	import { assert, it } from "@effect/vitest";
	2
	3	import {
	4	resolveNightlyBaseVersion,
	5	resolveNightlyReleaseMetadata,
	6	} from "./resolve-nightly-release.ts";
	7
	8	it("strips prerelease and build metadata when deriving the nightly base version", () => {
	9	assert.equal(resolveNightlyBaseVersion("0.0.17"), "0.0.17");
	10	assert.equal(resolveNightlyBaseVersion("9.9.9-smoke.0"), "9.9.9");
	11	assert.equal(resolveNightlyBaseVersion("1.2.3-beta.4+build.9"), "1.2.3");
	12	});
	13
	14	it("derives nightly metadata including the short commit sha in the release name", () => {
	15	assert.deepStrictEqual(
	16	resolveNightlyReleaseMetadata("9.9.9", "20260413", 321, "abcdef1234567890"),
	17	{
	18	baseVersion: "9.9.9",
	19	version: "9.9.9-nightly.20260413.321",
	20	tag: "nightly-v9.9.9-nightly.20260413.321",
	21	name: "T3 Code Nightly 9.9.9-nightly.20260413.321 (abcdef123456)",
	22	shortSha: "abcdef123456",
	23	},
	24	);
	25	});

scripts/resolve-nightly-release.ts+126−0

@@ -0,0 +1,126 @@
	1	#!/usr/bin/env node
	2
	3	import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
	4	import * as NodeServices from "@effect/platform-node/NodeServices";
	5	import { Config, Effect, FileSystem, Option, Path, Schema } from "effect";
	6	import { Command, Flag } from "effect/unstable/cli";
	7
	8	interface NightlyReleaseMetadata {
	9	readonly baseVersion: string;
	10	readonly version: string;
	11	readonly tag: string;
	12	readonly name: string;
	13	readonly shortSha: string;
	14	}
	15
	16	const DateSchema = Schema.String.check(Schema.isPattern(/^\d{8}$/));
	17	const RunNumberSchema = Schema.FiniteFromString.check(
	18	Schema.isInt(),
	19	Schema.isGreaterThanOrEqualTo(1),
	20	);
	21	const ShaSchema = Schema.String.check(Schema.isPattern(/^[0-9a-f]{7,40}$/i));
	22	const DesktopPackageJsonSchema = Schema.Struct({
	23	version: Schema.NonEmptyString,
	24	});
	25
	26	const RepoRoot = Effect.service(Path.Path).pipe(
	27	Effect.flatMap((path) => path.fromFileUrl(new URL("..", import.meta.url))),
	28	);
	29	const decodeDesktopPackageJson = Schema.decodeUnknownEffect(
	30	Schema.fromJsonString(DesktopPackageJsonSchema),
	31	);
	32
	33	export const resolveNightlyBaseVersion = (version: string) => version.replace(/[-+].*$/, "");
	34
	35	export const resolveNightlyReleaseMetadata = (
	36	baseVersion: string,
	37	date: string,
	38	runNumber: number,
	39	sha: string,
	40	) => {
	41	const shortSha = sha.slice(0, 12);
	42	const version = `${baseVersion}-nightly.${date}.${runNumber}`;
	43	return {
	44	baseVersion,
	45	version,
	46	tag: `nightly-v${version}`,
	47	name: `T3 Code Nightly ${version} (${shortSha})`,
	48	shortSha,
	49	};
	50	};
	51
	52	const readDesktopBaseVersion = Effect.fn("readDesktopBaseVersion")(function* (
	53	rootDir: string \| undefined,
	54	) {
	55	const fs = yield* FileSystem.FileSystem;
	56	const path = yield* Path.Path;
	57	const workspaceRoot = rootDir ? path.resolve(rootDir) : yield* RepoRoot;
	58	const packageJsonPath = path.join(workspaceRoot, "apps/desktop/package.json");
	59	const packageJson = yield* fs
	60	.readFileString(packageJsonPath)
	61	.pipe(Effect.flatMap(decodeDesktopPackageJson));
	62	return resolveNightlyBaseVersion(packageJson.version);
	63	});
	64
	65	const writeOutput = Effect.fn("writeOutput")(function* (
	66	metadata: NightlyReleaseMetadata,
	67	writeGithubOutput: boolean,
	68	) {
	69	const fs = yield* FileSystem.FileSystem;
	70
	71	const entries = [
	72	["base_version", metadata.baseVersion],
	73	["version", metadata.version],
	74	["tag", metadata.tag],
	75	["name", metadata.name],
	76	["short_sha", metadata.shortSha],
	77	] as const;
	78
	79	if (writeGithubOutput) {
	80	const githubOutputPath = yield* Config.nonEmptyString("GITHUB_OUTPUT");
	81	const serialized = entries.map(([key, value]) => `${key}=${value}\n`).join("");
	82	yield* fs.writeFileString(githubOutputPath, serialized, { flag: "a" });
	83	} else {
	84	for (const [key, value] of entries) {
	85	console.log(`${key}=${value}`);
	86	}
	87	}
	88	});
	89
	90	const command = Command.make(
	91	"resolve-nightly-release",
	92	{
	93	date: Flag.string("date").pipe(
	94	Flag.withSchema(DateSchema),
	95	Flag.withDescription("Nightly build date in YYYYMMDD."),
	96	),
	97	runNumber: Flag.string("run-number").pipe(
	98	Flag.withSchema(RunNumberSchema),
	99	Flag.withDescription("GitHub Actions run number."),
	100	),
	101	sha: Flag.string("sha").pipe(
	102	Flag.withSchema(ShaSchema),
	103	Flag.withDescription("Commit sha for the nightly build."),
	104	),
	105	githubOutput: Flag.boolean("github-output").pipe(
	106	Flag.withDescription("Write values to GITHUB_OUTPUT instead of stdout."),
	107	Flag.withDefault(false),
	108	),
	109	root: Flag.string("root").pipe(
	110	Flag.withDescription("Workspace root used to resolve apps/desktop/package.json."),
	111	Flag.optional,
	112	),
	113	},
	114	({ date, runNumber, sha, githubOutput, root }) =>
	115	readDesktopBaseVersion(Option.getOrUndefined(root)).pipe(
	116	Effect.map((baseVersion) => resolveNightlyReleaseMetadata(baseVersion, date, runNumber, sha)),
	117	Effect.flatMap((metadata) => writeOutput(metadata, githubOutput)),
	118	),
	119	).pipe(Command.withDescription("Resolve nightly release version metadata."));
	120
	121	if (import.meta.main) {
	122	Command.run(command, { version: "0.0.0" }).pipe(
	123	Effect.provide(NodeServices.layer),
	124	NodeRuntime.runMain,
	125	);
	126	}

scripts/resolve-previous-release-tag.ts+203−0

@@ -0,0 +1,203 @@
	1	#!/usr/bin/env node
	2
	3	import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
	4	import * as NodeServices from "@effect/platform-node/NodeServices";
	5	import { Array, Config, Effect, FileSystem, Schema, Stream, String } from "effect";
	6	import { Command, Flag } from "effect/unstable/cli";
	7	import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
	8
	9	const ReleaseChannel = Schema.Literals(["stable", "nightly"]);
	10	type ReleaseChannel = typeof ReleaseChannel.Type;
	11
	12	interface StableVersion {
	13	readonly major: number;
	14	readonly minor: number;
	15	readonly patch: number;
	16	readonly prerelease: ReadonlyArray<string>;
	17	}
	18
	19	interface NightlyVersion {
	20	readonly major: number;
	21	readonly minor: number;
	22	readonly patch: number;
	23	readonly date: number;
	24	readonly runNumber: number;
	25	}
	26
	27	const parseNumericIdentifier = (identifier: string): number \| undefined =>
	28	/^\d+$/.test(identifier) ? Number(identifier) : undefined;
	29
	30	const comparePrereleaseIdentifiers = (left: string, right: string): number => {
	31	const leftNumeric = parseNumericIdentifier(left);
	32	const rightNumeric = parseNumericIdentifier(right);
	33
	34	if (leftNumeric !== undefined && rightNumeric !== undefined) {
	35	return leftNumeric - rightNumeric;
	36	}
	37	if (leftNumeric !== undefined) {
	38	return -1;
	39	}
	40	if (rightNumeric !== undefined) {
	41	return 1;
	42	}
	43	return left.localeCompare(right);
	44	};
	45
	46	const compareStableVersions = (left: StableVersion, right: StableVersion): number => {
	47	if (left.major !== right.major) return left.major - right.major;
	48	if (left.minor !== right.minor) return left.minor - right.minor;
	49	if (left.patch !== right.patch) return left.patch - right.patch;
	50
	51	const leftHasPrerelease = left.prerelease.length > 0;
	52	const rightHasPrerelease = right.prerelease.length > 0;
	53	if (!leftHasPrerelease && !rightHasPrerelease) return 0;
	54	if (!leftHasPrerelease) return 1;
	55	if (!rightHasPrerelease) return -1;
	56
	57	const maxLength = Math.max(left.prerelease.length, right.prerelease.length);
	58	for (let index = 0; index < maxLength; index += 1) {
	59	const leftIdentifier = left.prerelease[index];
	60	const rightIdentifier = right.prerelease[index];
	61	if (leftIdentifier === undefined) return -1;
	62	if (rightIdentifier === undefined) return 1;
	63
	64	const comparison = comparePrereleaseIdentifiers(leftIdentifier, rightIdentifier);
	65	if (comparison !== 0) return comparison;
	66	}
	67
	68	return 0;
	69	};
	70
	71	const parseStableTag = (tag: string): StableVersion \| undefined => {
	72	const match = /^v(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(tag);
	73	if (!match) return undefined;
	74
	75	const [, major, minor, patch, prerelease] = match;
	76	if (!major \|\| !minor \|\| !patch) return undefined;
	77
	78	return {
	79	major: Number(major),
	80	minor: Number(minor),
	81	patch: Number(patch),
	82	prerelease: prerelease ? prerelease.split(".") : [],
	83	};
	84	};
	85
	86	const compareNightlyVersions = (left: NightlyVersion, right: NightlyVersion): number => {
	87	if (left.major !== right.major) return left.major - right.major;
	88	if (left.minor !== right.minor) return left.minor - right.minor;
	89	if (left.patch !== right.patch) return left.patch - right.patch;
	90	if (left.date !== right.date) return left.date - right.date;
	91	return left.runNumber - right.runNumber;
	92	};
	93
	94	const parseNightlyTag = (tag: string): NightlyVersion \| undefined => {
	95	const match = /^nightly-v(\d+)\.(\d+)\.(\d+)-nightly\.(\d{8})\.(\d+)$/.exec(tag);
	96	if (!match) return undefined;
	97
	98	const [, major, minor, patch, date, runNumber] = match;
	99	if (!major \|\| !minor \|\| !patch \|\| !date \|\| !runNumber) return undefined;
	100
	101	return {
	102	major: Number(major),
	103	minor: Number(minor),
	104	patch: Number(patch),
	105	date: Number(date),
	106	runNumber: Number(runNumber),
	107	};
	108	};
	109
	110	const resolvePreviousReleaseTag = (
	111	channel: ReleaseChannel,
	112	currentTag: string,
	113	tags: ReadonlyArray<string>,
	114	): string \| undefined => {
	115	if (channel === "stable") {
	116	const current = parseStableTag(currentTag);
	117	if (!current) {
	118	throw new Error(`Invalid stable release tag '${currentTag}'.`);
	119	}
	120
	121	const candidates = tags
	122	.map((tag) => ({ tag, parsed: parseStableTag(tag) }))
	123	.filter(
	124	(entry): entry is { tag: string; parsed: StableVersion } => entry.parsed !== undefined,
	125	)
	126	.filter((entry) => compareStableVersions(entry.parsed, current) < 0)
	127	.toSorted((left, right) => compareStableVersions(right.parsed, left.parsed));
	128
	129	return candidates[0]?.tag;
	130	}
	131
	132	const current = parseNightlyTag(currentTag);
	133	if (!current) {
	134	throw new Error(`Invalid nightly release tag '${currentTag}'.`);
	135	}
	136
	137	const candidates = tags
	138	.map((tag) => ({ tag, parsed: parseNightlyTag(tag) }))
	139	.filter((entry): entry is { tag: string; parsed: NightlyVersion } => entry.parsed !== undefined)
	140	.filter((entry) => compareNightlyVersions(entry.parsed, current) < 0)
	141	.toSorted((left, right) => compareNightlyVersions(right.parsed, left.parsed));
	142
	143	return candidates[0]?.tag;
	144	};
	145
	146	const listGitTags = Effect.fn("listGitTags")(function* () {
	147	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
	148	const child = yield* spawner.spawn(ChildProcess.make("git", ["tag", "--list"]));
	149	const tags = yield* child.stdout.pipe(
	150	Stream.decodeText(),
	151	Stream.runFold(
	152	() => "",
	153	(acc, chunk) => acc + chunk,
	154	),
	155	Effect.map(String.split(/\r?\n/)),
	156	Effect.map(Array.map(String.trim)),
	157	Effect.map(Array.filter(String.isNonEmpty)),
	158	);
	159	return tags;
	160	});
	161
	162	const writeOutput = Effect.fn("writeOutput")(function* (
	163	previousTag: string \| undefined,
	164	writeGithubOutput: boolean,
	165	) {
	166	const entry = `previous_tag=${previousTag ?? ""}\n`;
	167
	168	if (writeGithubOutput) {
	169	const fs = yield* FileSystem.FileSystem;
	170	const githubOutputPath = yield* Config.nonEmptyString("GITHUB_OUTPUT");
	171	yield* fs.writeFileString(githubOutputPath, entry, { flag: "a" });
	172	return;
	173	}
	174
	175	process.stdout.write(entry);
	176	});
	177
	178	const command = Command.make(
	179	"resolve-previous-release-tag",
	180	{
	181	channel: Flag.choice("channel", ReleaseChannel.literals).pipe(
	182	Flag.withDescription("Release channel whose previous tag should be resolved."),
	183	),
	184	currentTag: Flag.string("current-tag").pipe(
	185	Flag.withDescription("Current release tag to compare against."),
	186	),
	187	githubOutput: Flag.boolean("github-output").pipe(
	188	Flag.withDescription("Write values to GITHUB_OUTPUT instead of stdout."),
	189	Flag.withDefault(false),
	190	),
	191	},
	192	({ channel, currentTag, githubOutput }) =>
	193	listGitTags().pipe(
	194	Effect.map((tags) => resolvePreviousReleaseTag(channel, currentTag, tags)),
	195	Effect.flatMap((previousTag) => writeOutput(previousTag, githubOutput)),
	196	),
	197	).pipe(Command.withDescription("Resolve the previous release tag for a stable or nightly series."));
	198
	199	Command.run(command, { version: "0.0.0" }).pipe(
	200	Effect.scoped,
	201	Effect.provide(NodeServices.layer),
	202	NodeRuntime.runMain,
	203	);

Nightly release channel (#2012)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code