Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(ci): accept compatible Node patches for shared artifacts (#1165)

Generff5d25299e32
diff --git a/scripts/ci/e2e-build-artifact.mjs b/scripts/ci/e2e-build-artifact.mjs
index 9a4f6f381..5a2b93415 100644
--- a/scripts/ci/e2e-build-artifact.mjs
+++ b/scripts/ci/e2e-build-artifact.mjs
@@ -16,7 +16,7 @@ import { tmpdir } from "node:os"
import { join, resolve, sep } from "node:path"
import { spawnSync } from "node:child_process"
import { fileURLToPath } from "node:url"
-import { executeTurbo, taskEnvironment } from "./run-turbo.mjs"
+import { queryTurboTasks, taskEnvironment } from "./run-turbo.mjs"
export const BUILD_ARTIFACT_VERSION = 2
export const BUILD_ARCHIVE_NAME = "ui-e2e-build.tgz"
@@ -33,9 +33,9 @@ export function buildOutputRoots(zones = ["web", "blog"]) {
return ["web", "blog"].filter(zone => zones.includes(zone)).map(zone => zone === "web" ? "src/web/.open-next" : "src/web/blog/.open-next")
}
-function nativeBuildHashes(root, outputRoots) {
+function nativeBuildHashes(root, outputRoots, nodeVersion) {
const tasks = outputRoots.map(path => path.includes("/blog/") ? "@alook/web#build:blog" : "@alook/web#build")
- const result = executeTurbo(["run", ...tasks, "--dry=json"], { root, stdio: ["ignore", "pipe", "pipe"] })
+ const result = queryTurboTasks(tasks, { root, nodeVersion })
if (result.error || result.status !== 0) throw new Error("native build identity query failed")
const report = JSON.parse(result.stdout)
const hashes = Object.fromEntries(report.tasks.filter(task => tasks.includes(task.taskId))
@@ -46,7 +46,7 @@ function nativeBuildHashes(root, outputRoots) {
return hashes
}
-function buildIdentity(root, outputRoots) {
+function buildIdentity(root, outputRoots, nodeVersionForHash) {
const packageManager = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8")).packageManager
requiredString(packageManager, "package manager")
const turbo = JSON.parse(readFileSync(resolve(root, "turbo.json"), "utf8"))
@@ -66,7 +66,7 @@ function buildIdentity(root, outputRoots) {
}
const environment = taskEnvironment(root)
return {
- taskHashes: nativeBuildHashes(root, outputRoots),
+ taskHashes: nativeBuildHashes(root, outputRoots, nodeVersionForHash),
toolchain: { node: environment.ALOOK_TASK_NODE, bun: environment.ALOOK_TASK_BUN, platform: environment.ALOOK_TASK_PLATFORM, packageManager, workspace: realpathSync(root) },
environmentSha256: createHash("sha256").update(JSON.stringify({ env, files })).digest("hex"),
}
@@ -253,6 +253,13 @@ function assertEqual(actual, expected, label) {
}
}
+function compatibleToolchain(toolchain) {
+ if (typeof toolchain?.node !== "string" || !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)*$/.test(toolchain.node)) {
+ throw new Error("build Node version is invalid")
+ }
+ return { ...toolchain, node: toolchain.node.split(".")[0] }
+}
+
export function verifyBuildArtifact({ root, directory, runId, attempt, headSha, zones }) {
const repositoryRoot = resolve(root)
const paths = artifactPaths(repositoryRoot, directory)
@@ -288,8 +295,9 @@ export function verifyBuildArtifact({ root, directory, runId, attempt, headSha,
assertRegularFile(lockfile, "pnpm lockfile")
assertEqual(sha256File(lockfile), manifest.lockfileSha256, "build lockfile SHA-256")
assertEqual(sha256File(paths.archive), manifest.archiveSha256, "build archive SHA-256")
- const currentIdentity = buildIdentity(repositoryRoot, outputRoots)
- assertEqual(JSON.stringify(manifest.toolchain), JSON.stringify(currentIdentity.toolchain), "build toolchain")
+ const producerToolchain = compatibleToolchain(manifest.toolchain)
+ const currentIdentity = buildIdentity(repositoryRoot, outputRoots, manifest.toolchain.node)
+ assertEqual(JSON.stringify(producerToolchain), JSON.stringify(compatibleToolchain(currentIdentity.toolchain)), "build toolchain")
assertManifestDigest(manifest.environmentSha256, "build environment digest")
assertEqual(manifest.environmentSha256, currentIdentity.environmentSha256, "build environment")
assertEqual(JSON.stringify(manifest.taskHashes), JSON.stringify(currentIdentity.taskHashes), "native build task hashes")
diff --git a/scripts/ci/e2e-build-artifact.test.ts b/scripts/ci/e2e-build-artifact.test.ts
index 6517bdff5..3bb8d3998 100644
--- a/scripts/ci/e2e-build-artifact.test.ts
+++ b/scripts/ci/e2e-build-artifact.test.ts
@@ -23,6 +23,7 @@ import {
verifyArchiveMembers,
verifyBuildArtifact,
} from "./e2e-build-artifact.mjs"
+import { executeTurbo, queryTurboTasks, taskEnvironment } from "./run-turbo.mjs"
const HEAD_SHA = "a".repeat(40)
const roots: string[] = []
@@ -32,7 +33,7 @@ afterEach(() => {
vi.unstubAllEnvs()
})
-function fixture(zones?: string[]) {
+function fixture(zones?: string[], producerNode?: string) {
const root = mkdtempSync(join(tmpdir(), "alook-ui-e2e-build-"))
roots.push(root)
writeFileSync(join(root, "package.json"), JSON.stringify({ name: "artifact-fixture", packageManager: "[email protected]" }))
@@ -60,14 +61,83 @@ function fixture(zones?: string[]) {
headSha: HEAD_SHA,
zones,
})
+ if (producerNode !== undefined) {
+ const tasks = result.manifestData.roots.map(path => path.includes("/blog/") ? "@alook/web#build:blog" : "@alook/web#build")
+ const query = queryTurboTasks(tasks, { root, nodeVersion: producerNode })
+ expect(query.status).toBe(0)
+ const report = JSON.parse(query.stdout)
+ result.manifestData.toolchain.node = producerNode
+ result.manifestData.taskHashes = Object.fromEntries(report.tasks.filter(task => tasks.includes(task.taskId))
+ .sort((left, right) => left.taskId.localeCompare(right.taskId)).map(task => [task.taskId, task.hash]))
+ writeFileSync(result.manifest, JSON.stringify(result.manifestData))
+ }
return { root, ...result }
}
+function otherPatch() {
+ const [major, minor, patch] = process.versions.node.split(".")
+ return [major, minor, Number(patch) > 0 ? Number(patch) - 1 : 1].join(".")
+}
+
function removeBuildOutputs(root: string) {
for (const output of BUILD_OUTPUT_ROOTS) rmSync(join(root, output), { recursive: true })
}
describe("UI E2E build artifact", () => {
+ it("accepts a same-major producer patch while preserving its full version and native source identity", () => {
+ const producerNode = otherPatch()
+ const artifact = fixture(undefined, producerNode)
+ const current = queryTurboTasks(["@alook/web#build"], { root: artifact.root })
+ expect(current.status).toBe(0)
+ const currentHash = JSON.parse(current.stdout).tasks.find(task => task.taskId === "@alook/web#build").hash
+ expect(currentHash).not.toBe(artifact.manifestData.taskHashes["@alook/web#build"])
+ const result = verifyBuildArtifact({ root: artifact.root, directory: ".ci/ui-e2e-build", runId: "123", attempt: 2, headSha: HEAD_SHA })
+ expect(result.toolchain.node).toBe(producerNode)
+ expect(taskEnvironment(artifact.root).ALOOK_TASK_NODE).toBe(process.versions.node)
+ })
+
+ it("keeps a producer dry context read-only and normal execution on the actual full Node", () => {
+ const artifact = fixture(["web"])
+ expect(artifact.manifestData.toolchain.node).toBe(process.versions.node)
+ const web = join(artifact.root, "src/web")
+ const capture = join(web, "normal-node.json")
+ writeFileSync(join(web, "capture.cjs"), 'require("node:fs").writeFileSync("normal-node.json", JSON.stringify({node:process.versions.node,taskNode:process.env.ALOOK_TASK_NODE}))')
+ const pkg = JSON.parse(readFileSync(join(web, "package.json"), "utf8"))
+ pkg.scripts.build = "node capture.cjs"
+ writeFileSync(join(web, "package.json"), JSON.stringify(pkg))
+ const config = JSON.parse(readFileSync(join(artifact.root, "turbo.json"), "utf8"))
+ config.tasks["@alook/web#build"].inputs.push("capture.cjs")
+ writeFileSync(join(artifact.root, "turbo.json"), JSON.stringify(config))
+ vi.stubEnv("ALOOK_TASK_NODE", "0.0.0")
+ const query = queryTurboTasks(["@alook/web#build"], { root: artifact.root, nodeVersion: otherPatch() })
+ expect(query.status).toBe(0)
+ expect(() => readFileSync(capture)).toThrow()
+ expect(() => queryTurboTasks(["--", "@alook/web#build"], { root: artifact.root, nodeVersion: otherPatch() })).toThrow("requires named tasks")
+ const executed = executeTurbo(["run", "@alook/web#build"], { root: artifact.root, stdio: ["ignore", "pipe", "pipe"] })
+ expect(executed.status, executed.stderr).toBe(0)
+ expect(JSON.parse(readFileSync(capture, "utf8"))).toEqual({ node: process.versions.node, taskNode: process.versions.node })
+ expect(process.env.ALOOK_TASK_NODE).toBe("0.0.0")
+ })
+
+ it.each([
+ { field: "node", value: `${Number(process.versions.node.split(".")[0]) + 1}.0.0` },
+ { field: "platform", value: "incompatible-platform" },
+ ])("rejects an incompatible producer $field", ({ field, value }) => {
+ const artifact = fixture()
+ const manifest = JSON.parse(readFileSync(artifact.manifest, "utf8"))
+ manifest.toolchain[field] = value
+ writeFileSync(artifact.manifest, JSON.stringify(manifest))
+ expect(() => verifyBuildArtifact({ root: artifact.root, directory: ".ci/ui-e2e-build", runId: "123", attempt: 2, headSha: HEAD_SHA })).toThrow("build toolchain mismatch")
+ })
+
+ it("rejects a malformed producer Node identity", () => {
+ const artifact = fixture()
+ const manifest = JSON.parse(readFileSync(artifact.manifest, "utf8"))
+ manifest.toolchain.node = "22.invalid"
+ writeFileSync(artifact.manifest, JSON.stringify(manifest))
+ expect(() => verifyBuildArtifact({ root: artifact.root, directory: ".ci/ui-e2e-build", runId: "123", attempt: 2, headSha: HEAD_SHA })).toThrow("build Node version is invalid")
+ })
+
it("preserves archived executable modes under a restrictive consumer umask", () => {
const artifact = fixture()
const entry = join(artifact.root, BUILD_OUTPUT_ROOTS[0]!, "worker.js")
@@ -93,14 +163,17 @@ describe("UI E2E build artifact", () => {
expect(verifyArchiveMembers(artifact.archive, [BUILD_OUTPUT_ROOTS[0]]).some(path => path.includes("/blog/"))).toBe(false)
})
- it("rejects a different build environment without exposing its values", () => {
- const artifact = fixture()
+ it.each(["current", "compatible patch"])("rejects a different build environment for %s without exposing its values", producer => {
+ const artifact = fixture(undefined, producer === "current" ? undefined : otherPatch())
vi.stubEnv("NEXT_PUBLIC_WS_DO_PORT", "8765")
expect(() => verifyBuildArtifact({ root: artifact.root, directory: ".ci/ui-e2e-build", runId: "123", attempt: 2, headSha: HEAD_SHA })).toThrow("build environment mismatch")
})
- it.each(["source", "configuration"])("rejects changed %s through native Turbo task hashes", kind => {
- const artifact = fixture()
+ it.each([
+ { kind: "source", producer: "current" }, { kind: "configuration", producer: "current" },
+ { kind: "source", producer: "compatible patch" }, { kind: "configuration", producer: "compatible patch" },
+ ])("rejects changed $kind through native Turbo task hashes for $producer", ({ kind, producer }) => {
+ const artifact = fixture(undefined, producer === "current" ? undefined : otherPatch())
if (kind === "source") writeFileSync(join(artifact.root, "src/web/source.ts"), "export const value = 2\n")
else {
const path = join(artifact.root, "turbo.json")
diff --git a/scripts/ci/run-turbo.mjs b/scripts/ci/run-turbo.mjs
index eaa5e59cf..59f97d9c3 100644
--- a/scripts/ci/run-turbo.mjs
+++ b/scripts/ci/run-turbo.mjs
@@ -19,10 +19,10 @@ export function taskEnvironment(root = ROOT) {
}
}
-export function executeTurbo(args, { root = ROOT, stdio = "inherit" } = {}) {
+function invokeTurbo(args, { root, stdio, environment }) {
return spawnSync("pnpm", ["exec", "turbo", ...args], {
cwd: root,
- env: taskEnvironment(root),
+ env: environment,
stdio,
encoding: "utf8",
maxBuffer: 16 * 1024 * 1024,
@@ -30,6 +30,21 @@ export function executeTurbo(args, { root = ROOT, stdio = "inherit" } = {}) {
})
}
+export function executeTurbo(args, { root = ROOT, stdio = "inherit" } = {}) {
+ return invokeTurbo(args, { root, stdio, environment: taskEnvironment(root) })
+}
+
+export function queryTurboTasks(tasks, { root = ROOT, nodeVersion } = {}) {
+ if (!tasks.length || tasks.some(task => typeof task !== "string" || !task || task.startsWith("-"))) {
+ throw new Error("native dry query requires named tasks")
+ }
+ const environment = taskEnvironment(root)
+ if (nodeVersion !== undefined) environment.ALOOK_TASK_NODE = nodeVersion
+ return invokeTurbo(["run", ...tasks, "--dry=json"], {
+ root, stdio: ["ignore", "pipe", "pipe"], environment,
+ })
+}
+
export function runCli(argv = process.argv.slice(2)) {
let args = argv
if (args[0] === "--plan-group") {