Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

make release manifest parsing forward-compatible (#2370)

kte9d68d92c584
diff --git a/packages/coding-agent/.changes/release-manifest-forward-compat.md b/packages/coding-agent/.changes/release-manifest-forward-compat.md
new file mode 100644
index 0000000000..f6f842474c
--- /dev/null
+++ b/packages/coding-agent/.changes/release-manifest-forward-compat.md
@@ -0,0 +1,2 @@
+- Fixed release manifest parsing rejecting all native binary entries when encountering an unknown future platform; unknown platforms are now skipped while known-platform entries remain strictly validated.
+- Added versioned native binary metadata so the v1 manifest schema stays compatible while the v2 schema advertises every musl and baseline archive.
diff --git a/packages/coding-agent/src/utils/version-check.ts b/packages/coding-agent/src/utils/version-check.ts
index 8a2996b2cf..741314ae75 100644
--- a/packages/coding-agent/src/utils/version-check.ts
+++ b/packages/coding-agent/src/utils/version-check.ts
@@ -186,6 +186,7 @@ export async function getLatestPiRelease(
tarball?: unknown;
version?: unknown;
binaries?: unknown;
+ binariesV2?: unknown;
};
if (typeof data.version !== "string" || !data.version.trim()) {
return undefined;
@@ -204,17 +205,23 @@ export async function getLatestPiRelease(
if (installSpec) {
release.installSpec = installSpec;
}
- if (Array.isArray(data.binaries)) {
- // Invalid optional native metadata must not discard a valid npm release.
- // Publish the list only after every entry passes validation.
+ // Prefer the complete v2 schema, with the v1 schema as a compatibility
+ // fallback. Structurally valid entries for future platforms are ignored,
+ // while malformed or duplicate supported-platform entries reject the list.
+ const binarySource = Array.isArray(data.binariesV2)
+ ? data.binariesV2
+ : Array.isArray(data.binaries)
+ ? data.binaries
+ : undefined;
+ if (binarySource) {
const binaries: NativeReleaseArtifact[] = [];
const platforms = new Set<string>();
- for (const candidate of data.binaries) {
+ for (const candidate of binarySource) {
if (!candidate || typeof candidate !== "object") return release;
const artifact = candidate as Partial<NativeReleaseArtifact>;
+ if (typeof artifact.platform !== "string") return release;
+ if (!isNativePlatform(artifact.platform)) continue;
if (
- typeof artifact.platform !== "string" ||
- !isNativePlatform(artifact.platform) ||
platforms.has(artifact.platform) ||
artifact.file !== `prime-agent-${release.version}-${artifact.platform}.tar.gz` ||
typeof artifact.sha256 !== "string" ||
@@ -224,7 +231,7 @@ export async function getLatestPiRelease(
platforms.add(artifact.platform);
binaries.push({ platform: artifact.platform, file: artifact.file, sha256: artifact.sha256 });
}
- release.binaries = binaries;
+ if (binaries.length > 0) release.binaries = binaries;
}
return release;
}
diff --git a/packages/coding-agent/test/release-workflow.test.ts b/packages/coding-agent/test/release-workflow.test.ts
index 3716c2c906..dba83727bc 100644
--- a/packages/coding-agent/test/release-workflow.test.ts
+++ b/packages/coding-agent/test/release-workflow.test.ts
@@ -245,3 +245,75 @@ ${step(validation, "Verify and exercise exact final Mac archives").run}`,
},
);
});
+
+describe("release manifest schemas", () => {
+ const manifestV1Platforms = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64"];
+ const binaries = releasePlatforms.map((platform, index) => ({
+ platform,
+ file: `prime-agent-1.2.4-${platform}.tar.gz`,
+ sha256: (index + 1).toString(16).padStart(64, "0"),
+ executableSha256: (index + 11).toString(16).padStart(64, "0"),
+ }));
+ const tarballs = [
+ ["prime-agent-ai", "1"],
+ ["prime-agent-core", "2"],
+ ["prime-agent-tui", "3"],
+ ["prime-agent", "4"],
+ ].map(([name, hash]) => ({
+ name,
+ file: `${name}-1.2.4.tgz`,
+ sha256: hash.repeat(64),
+ }));
+
+ it.each([
+ ["stable", "latest.json"],
+ ["beta", "beta.json"],
+ ] as const)("writes the %s channel with v1 and v2 binary schemas", (channel, manifestName) => {
+ const directory = mkdtempSync(join(tmpdir(), "prime-release-manifest-"));
+ try {
+ const result = spawnSync(
+ process.execPath,
+ [
+ "--input-type=module",
+ "-e",
+ `import { writeReleaseMetadata } from ${JSON.stringify(join(repository, "scripts/pack-prime-agent-release.mjs"))}; writeReleaseMetadata(${JSON.stringify(
+ {
+ artifactsDir: directory,
+ channel,
+ releaseVersion: "1.2.4",
+ codingAgentTarball: "prime-agent-1.2.4.tgz",
+ tarballs,
+ binaries,
+ },
+ )});`,
+ ],
+ { encoding: "utf8" },
+ );
+ expect(result.status, result.stderr).toBe(0);
+
+ const manifest = JSON.parse(readFileSync(join(directory, manifestName), "utf8"));
+ expect(manifest.version).toBe("v1.2.4");
+ expect(manifest.tarballs).toEqual(
+ tarballs.map(({ name: packageName, file, sha256 }) => ({ package: packageName, file, sha256 })),
+ );
+ expect(manifest.binaries.map((entry: { platform: string }) => entry.platform)).toEqual(manifestV1Platforms);
+ expect(manifest.binariesV2.map((entry: { platform: string }) => entry.platform)).toEqual(releasePlatforms);
+ expect(manifest.binariesV2.map((entry: { platform: string }) => entry.platform)).toEqual(
+ expect.arrayContaining([
+ "linux-arm64-musl",
+ "linux-x64-baseline",
+ "linux-x64-musl",
+ "linux-x64-musl-baseline",
+ ]),
+ );
+ expect(readFileSync(join(directory, channel), "utf8")).toBe("v1.2.4\n");
+
+ const expectedChecksums = [...tarballs, ...binaries]
+ .map((artifact) => `${artifact.sha256} ${artifact.file}`)
+ .join("\n");
+ expect(readFileSync(join(directory, "SHA256SUMS"), "utf8")).toBe(`${expectedChecksums}\n`);
+ } finally {
+ rmSync(directory, { recursive: true, force: true });
+ }
+ });
+});
diff --git a/packages/coding-agent/test/version-check.test.ts b/packages/coding-agent/test/version-check.test.ts
index e41ddb6cd1..ca76ba7910 100644
--- a/packages/coding-agent/test/version-check.test.ts
+++ b/packages/coding-agent/test/version-check.test.ts
@@ -1,4 +1,5 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { NATIVE_PLATFORMS } from "../src/utils/native-installation.js";
import {
checkForNewPiVersion,
comparePackageVersions,
@@ -161,3 +162,97 @@ describe("update channel preference", () => {
await expect(checkForNewPiVersion("1.2.4", "nightly")).resolves.toBe("1.2.5-beta.1.1.abcdef0");
});
});
+
+describe("manifest binary schema compatibility", () => {
+ const artifact = (platform: string, sha256 = "a".repeat(64)) => ({
+ platform,
+ file: `prime-agent-1.2.4-${platform}.tar.gz`,
+ sha256,
+ });
+
+ function stubManifest(fields: Record<string, unknown>): void {
+ vi.stubGlobal(
+ "fetch",
+ vi.fn(async () =>
+ Response.json({
+ version: "v1.2.4",
+ package: "prime-agent",
+ tarball: "releases/v1.2.4/prime-agent-1.2.4.tgz",
+ ...fields,
+ }),
+ ),
+ );
+ }
+
+ it("prefers binariesV2, keeps every supported platform, and skips future platforms", async () => {
+ stubManifest({
+ binaries: [artifact("darwin-arm64", "b".repeat(64))],
+ binariesV2: [
+ ...NATIVE_PLATFORMS.map((platform, index) => artifact(platform, index.toString(16).padStart(64, "0"))),
+ artifact("future-riscv128", "f".repeat(64)),
+ ],
+ });
+
+ const release = await getLatestPiRelease("1.2.3");
+ expect(release?.binaries?.map(({ platform }) => platform)).toEqual(NATIVE_PLATFORMS);
+ expect(release?.binaries?.map(({ platform }) => platform)).toEqual(
+ expect.arrayContaining([
+ "linux-arm64-musl",
+ "linux-x64-baseline",
+ "linux-x64-musl",
+ "linux-x64-musl-baseline",
+ ]),
+ );
+ });
+
+ it("falls back to binaries when binariesV2 is absent", async () => {
+ stubManifest({ binaries: [artifact("darwin-arm64")] });
+
+ await expect(getLatestPiRelease("1.2.3")).resolves.toMatchObject({
+ binaries: [artifact("darwin-arm64")],
+ });
+ });
+
+ it("rejects the selected list when an entry is structurally malformed", async () => {
+ stubManifest({
+ binaries: [artifact("darwin-arm64")],
+ binariesV2: [artifact("linux-x64"), null],
+ });
+
+ const release = await getLatestPiRelease("1.2.3");
+ expect(release?.version).toBe("1.2.4");
+ expect(release?.binaries).toBeUndefined();
+ });
+
+ it("rejects the selected list when a supported platform entry is malformed", async () => {
+ stubManifest({
+ binaries: [artifact("darwin-arm64")],
+ binariesV2: [artifact("linux-x64"), artifact("linux-x64-musl", "not-hex")],
+ });
+
+ const release = await getLatestPiRelease("1.2.3");
+ expect(release?.version).toBe("1.2.4");
+ expect(release?.binaries).toBeUndefined();
+ });
+
+ it("rejects the selected list when a supported platform is duplicated", async () => {
+ stubManifest({
+ binaries: [artifact("darwin-arm64")],
+ binariesV2: [artifact("linux-x64"), artifact("linux-x64", "b".repeat(64))],
+ });
+
+ const release = await getLatestPiRelease("1.2.3");
+ expect(release?.version).toBe("1.2.4");
+ expect(release?.binaries).toBeUndefined();
+ });
+
+ it("preserves npm release info when the selected list contains only future platforms", async () => {
+ stubManifest({ binariesV2: [artifact("future-riscv128", "b".repeat(64))] });
+
+ await expect(getLatestPiRelease("1.2.3")).resolves.toEqual({
+ version: "1.2.4",
+ packageName: "prime-agent",
+ installSpec: `${defaultPrimeAgentDownloadBaseUrl}/releases/v1.2.4/prime-agent-1.2.4.tgz`,
+ });
+ });
+});
diff --git a/scripts/pack-prime-agent-release.mjs b/scripts/pack-prime-agent-release.mjs
index 2e05753362..b34ac9800a 100644
--- a/scripts/pack-prime-agent-release.mjs
+++ b/scripts/pack-prime-agent-release.mjs
@@ -13,8 +13,9 @@ import {
writeFileSync,
} from "node:fs";
import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
import { assembleBinaryArchives } from "./assemble-release-archives.mjs";
+import { manifestV1Platforms } from "./release-platforms.mjs";
const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const defaultOutputDir = join(root, "packages", "coding-agent", "release");
@@ -243,6 +244,37 @@ function sha256File(path) {
return hash.digest("hex");
}
+export function writeReleaseMetadata({
+ artifactsDir,
+ channel,
+ releaseVersion,
+ codingAgentTarball,
+ tarballs,
+ binaries,
+}) {
+ writeFileSync(
+ join(artifactsDir, "SHA256SUMS"),
+ [...tarballs, ...binaries].map((artifact) => `${artifact.sha256} ${artifact.file}`).join("\n") + "\n",
+ );
+ writeFileSync(join(artifactsDir, channel), `v${releaseVersion}\n`);
+
+ const manifestName = channel === "stable" ? "latest.json" : "beta.json";
+ const manifestV1PlatformSet = new Set(manifestV1Platforms);
+ const binariesV1 = binaries.filter((entry) => manifestV1PlatformSet.has(entry.platform));
+ writeJson(join(artifactsDir, manifestName), {
+ version: `v${releaseVersion}`,
+ package: publicPackageName,
+ tarball: `releases/v${releaseVersion}/${codingAgentTarball}`,
+ ...(binariesV1.length > 0 ? { binaries: binariesV1 } : {}),
+ ...(binaries.length > 0 ? { binariesV2: binaries } : {}),
+ tarballs: tarballs.map((tarball) => ({
+ package: tarball.name,
+ file: tarball.file,
+ sha256: tarball.sha256,
+ })),
+ });
+}
+
function main() {
const args = parseArgs(process.argv.slice(2));
const sourcePackages = new Map(
@@ -340,22 +372,13 @@ function main() {
const binaries = args.binaryDir
? assembleBinaryArchives({ binaryDir: args.binaryDir, artifactsDir, version: releaseVersion })
: [];
- writeFileSync(
- join(artifactsDir, "SHA256SUMS"),
- [...tarballs, ...binaries].map((artifact) => `${artifact.sha256} ${artifact.file}`).join("\n") + "\n",
- );
- writeFileSync(join(artifactsDir, args.channel), `v${releaseVersion}\n`);
- const manifestName = args.channel === "stable" ? "latest.json" : "beta.json";
- writeJson(join(artifactsDir, manifestName), {
- version: `v${releaseVersion}`,
- package: publicPackageName,
- tarball: `releases/v${releaseVersion}/${artifactFiles.get("coding-agent")}`,
- ...(binaries.length > 0 ? { binaries } : {}),
- tarballs: tarballs.map((tarball) => ({
- package: tarball.name,
- file: tarball.file,
- sha256: tarball.sha256,
- })),
+ writeReleaseMetadata({
+ artifactsDir,
+ channel: args.channel,
+ releaseVersion,
+ codingAgentTarball: artifactFiles.get("coding-agent"),
+ tarballs,
+ binaries,
});
for (const artifact of [...tarballs, ...binaries]) {
@@ -363,9 +386,11 @@ function main() {
}
}
-try {
- main();
-} catch (error) {
- console.error(error instanceof Error ? error.message : String(error));
- process.exit(1);
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+ try {
+ main();
+ } catch (error) {
+ console.error(error instanceof Error ? error.message : String(error));
+ process.exit(1);
+ }
}
diff --git a/scripts/release-platforms.mjs b/scripts/release-platforms.mjs
index 20e78946ed..27f04f8d52 100644
--- a/scripts/release-platforms.mjs
+++ b/scripts/release-platforms.mjs
@@ -22,6 +22,16 @@ export const releasePlatforms = [
"linux-x64-musl-baseline",
];
+// The v1 manifest field stays limited to the original platform schema.
+// The v2 field uses releasePlatforms so current clients can select every
+// supported archive without changing the v1 compatibility contract.
+export const manifestV1Platforms = [
+ "darwin-arm64",
+ "darwin-x64",
+ "linux-arm64",
+ "linux-x64",
+];
+
export const darwinReleasePlatforms = releasePlatforms.filter((platform) => platform.startsWith("darwin-"));
if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {