@platforma-sdk/package-builder-lib 1.1.0

package/src/core/schemas/test-artifacts.ts

@@ -0,0 +1,362 @@
+export const PackageVersion: string = "1.2.3";
+export const PackageNameNoAt: string = "the-software";
+export const PackageName: string = "@" + PackageNameNoAt;
+
+export const BinaryRegistry: string = "some-binary-registry";
+export const BinaryRegistryURL: string = "http://example.com/registry";
+export const BinaryCustomName1: string = "custom-package-name-1";
+export const BinaryCustomVersion: string = "4.4.4";
+
+export const EPNameAsset: string = "pAsset";
+export const EPNameBinary: string = "binary-package";
+export const EPNameCustomName: string = "custom-name";
+export const EPNameJavaEnvironment: string = "java-environment";
+export const EPNamePythonEnvironment: string = "python-environment";
+export const EPNameREnvironment: string = "R-environment";
+export const EPNameJava: string = "java-package";
+export const EPNameDocker: string = "docker-test-entrypoint";
+
+const merge = (data: string, patch: Record<string, unknown>): string => {
+  const v = JSON.parse(data) as Record<string, unknown>;
+  return JSON.stringify({ ...v, ...patch });
+};
+
+export const PackageJsonNoSoftware = `{
+    "name": "${PackageName}",
+    "version": "${PackageVersion}"
+}`;
+
+export const AssetArtifact = `{
+  "registry": "${BinaryRegistry}",
+  "root": "./src"
+}`;
+
+export const BinaryArtifact = `{
+  "type": "binary",
+  "roots": {
+    "linux-x64": "./src/",
+    "linux-aarch64": "./src/",
+    "macosx-x64": "./src/",
+    "macosx-aarch64": "./src/",
+    "windows-x64": "./src/"
+  }
+}`;
+
+export const CondaArtifact = `{
+  "roots": {
+    "linux-x64": "./src/",
+    "linux-aarch64": "./src/",
+    "macosx-x64": "./src/",
+    "macosx-aarch64": "./src/",
+    "windows-x64": "./src/"
+  }
+}`;
+
+export const CondaArtifactWithType = merge(CondaArtifact, { type: "conda" });
+export const CondaArtifactWithSpec = merge(CondaArtifactWithType, {
+  spec: "./some-specification.yaml",
+});
+export const CondaArtifactWithMicromambaVersion = merge(CondaArtifactWithSpec, {
+  "micromamba-version": "2.3.2-0",
+});
+
+export const PythonArtifact = `{
+  "type": "python",
+
+  "root": "./src",
+  "environment": ":${EPNamePythonEnvironment}"
+}`;
+
+export const RArtifact = `{
+  "type": "R",
+
+  "root": "./src",
+  "environment": ":${EPNameREnvironment}"
+}`;
+
+export const CustomVersionArtifact = `{
+  "type": "binary",
+
+  "registry": {
+    "name": "${BinaryRegistry}"
+  },
+  "name": "${BinaryCustomName1}",
+  "version": "${BinaryCustomVersion}",
+
+  "roots": {
+    "linux-x64": "./src/",
+    "linux-aarch64": "./src/",
+    "macosx-x64": "./src/",
+    "macosx-aarch64": "./src/",
+    "windows-x64": "./src/"
+  }
+}`;
+
+export const JavaArtifact = `{
+  "type": "java",
+
+  "registry": {
+    "name": "${BinaryRegistry}"
+  },
+
+  "root": "./src",
+  "environment": ":${EPNameJavaEnvironment}"
+}`;
+
+export const JavaEnvironmentArtifact = `{
+  "runtime": "java",
+
+  "registry": {
+    "name": "${BinaryRegistry}"
+  },
+
+  "roots": {
+    "linux-x64": "./src/",
+    "linux-aarch64": "./src/",
+    "macosx-x64": "./src/",
+    "macosx-aarch64": "./src/",
+    "windows-x64": "./src/"
+  },
+  "binDir": "."
+}`;
+
+export const JavaEnvironmentArtifactWithType = merge(JavaEnvironmentArtifact, {
+  type: "environment",
+});
+
+export const DockerArtifact = `{
+  "context": "./src"
+}`;
+
+export const DockerArtifactWithType = merge(DockerArtifact, { type: "docker" });
+export const DockerArtifactWithPkg = merge(DockerArtifactWithType, { pkg: "/app" });
+export const DockerArtifactWithDockerfile = merge(DockerArtifactWithType, {
+  dockerfile: "Dockerfile",
+});
+
+export const DockerAsset = `{
+  "tag": "some-docker-tag",
+  "entrypoint": ["/usr/bin/env", "printf"],
+  "cmd": ["Hello, world!"]
+}`;
+
+export const EPNameLimitedPlatformsBinary = "multi-root-bin";
+
+// This binary artifact intentionally has only part of roots, meaning
+// software is not available for some platforms.
+export const LimitedPlatformsBinary = `{
+  "type": "binary",
+
+  "registry": {
+    "name": "${BinaryRegistry}"
+  },
+
+  "roots": {
+    "linux-x64": "./linux-x64/",
+    "macosx-aarch64": "./macosx-aarch64/"
+  }
+}`;
+
+export const AssetEntrypoint = `{
+  "asset": ${AssetArtifact}
+}`;
+
+export const BinaryEntrypoint = `{
+  "binary": {
+    "artifact": ${BinaryArtifact},
+    "cmd": ["aaa"]
+  }
+}`;
+
+export const BinaryEntrypointWithDocker = `{
+  "binary": {
+    "artifact": ${BinaryArtifact},
+    "cmd": ["aaa"]
+  },
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["aaa"]
+  }
+}`;
+
+export const BinaryEntrypointWithReference = `{
+  "binary": {
+    "artifact": "binaryArtifactID",
+    "cmd": ["aaa"]
+  }
+}`;
+
+export const CustomBinaryEntrypoint = `{
+  "binary": {
+    "artifact": ${CustomVersionArtifact},
+    "cmd": ["bbb"]
+  }
+}`;
+
+export const LimitedPlatformsBinaryEntrypoint = `{
+  "binary": {
+    "artifact": ${LimitedPlatformsBinary},
+    "cmd": ["bbb"]
+  }
+}`;
+
+export const JavaEnvironmentEntrypoint = `{
+  "environment": {
+    "artifact": ${JavaEnvironmentArtifact}
+  }
+}`;
+
+export const JavaEnvironmentEntrypointWithReference = `{
+  "environment": {
+    "artifact": "javaEnvironmentArtifactID"
+  }
+}`;
+
+export const JavaEntrypoint = `{
+  "binary": {
+    "artifact": ${JavaArtifact},
+    "cmd": ["java", "-jar", "hello.jar"]
+  }
+}`;
+
+export const JavaEntrypointWithReference = `{
+  "binary": {
+    "artifact": "javaArtifactID",
+    "cmd": ["java", "-jar", "hello.jar"]
+  }
+}`;
+
+export const JavaEntrypointWithDocker = `{
+  "binary": {
+    "artifact": ${JavaArtifact},
+    "cmd": ["java", "-jar", "hello.jar"]
+  },
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["java", "-jar", "hello.jar"]
+  }
+}`;
+
+export const PythonEntrypoint = `{
+  "binary": {
+    "artifact": ${PythonArtifact},
+    "cmd": ["python", "hello.py"]
+  }
+}`;
+
+export const PythonEntrypointWithReference = `{
+  "binary": {
+    "artifact": "pythonArtifactID",
+    "cmd": ["python", "hello.py"]
+  }
+}`;
+
+export const PythonEntrypointWithDocker = `{
+  "binary": {
+    "artifact": ${PythonArtifact},
+    "cmd": ["python", "hello.py"]
+  },
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["python", "hello.py"]
+  }
+}`;
+
+export const REntrypoint = `{
+  "binary": {
+    "artifact": ${RArtifact},
+    "cmd": ["Rscript", "hello.R"]
+  }
+}`;
+
+export const REntrypointWithReference = `{
+  "binary": {
+    "artifact": "RArtifactID",
+    "cmd": ["Rscript", "hello.R"]
+  }
+}`;
+
+export const REntrypointWithDocker = `{
+  "binary": {
+    "artifact": ${RArtifact},
+    "cmd": ["Rscript", "hello.R"]
+  },
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["Rscript", "hello.R"]
+  }
+}`;
+
+export const CondaEntrypoint = `{
+  "conda": {
+    "artifact": ${CondaArtifact},
+    "cmd": ["python", "hello.py"]
+  }
+}`;
+
+export const CondaEntrypointWithReference = `{
+  "conda": {
+    "artifact": "condaArtifactID",
+    "cmd": ["ANARCI"]
+  }
+}`;
+
+export const CondaEntrypointWithDocker = `{
+  "conda": {
+    "artifact": ${CondaArtifactWithMicromambaVersion},
+    "cmd": ["ls"]
+  },
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["ls"]
+  }
+}`;
+
+export const DockerEntrypoint = `{
+  "docker": {
+    "artifact": ${DockerArtifact},
+    "cmd": ["echo", "hello"]
+  }
+}`;
+
+export const DockerEntrypointWithReference = `{
+  "docker": {
+    "artifact": "dockerArtifactID",
+    "cmd": ["echo", "hello"]
+  }
+}`;
+
+export const PackageJson = `{
+    "name": "${PackageName}",
+    "version": "${PackageVersion}",
+    "block-software": {
+      "registries": {
+        "binary": {
+          "${BinaryRegistry}": {"downloadURL": "${BinaryRegistryURL}"}
+        }
+      },
+      "entrypoints": {
+        "${EPNameAsset}":                  ${AssetEntrypoint},
+        "${EPNameCustomName}":             ${CustomBinaryEntrypoint},
+        "${EPNameLimitedPlatformsBinary}": ${LimitedPlatformsBinaryEntrypoint},
+        "${EPNameJavaEnvironment}":        ${JavaEnvironmentEntrypoint},
+        "${EPNameJava}":                   ${JavaEntrypointWithDocker},
+        "${EPNameDocker}":                 ${DockerEntrypoint}
+      }
+    }
+}`;
+
+export const SingleBinaryackageJson = `{
+  "name": "${PackageName}",
+  "version": "${PackageVersion}",
+  "block-software": {
+    "entrypoints": {
+      "${EPNameBinary}": {
+        "binary": {
+          "artifact": ${BinaryArtifact},
+          "cmd": ["run-some-binary"]
+        }
+      }
+    }
+  }
+}`;

package/src/core/storage.ts

@@ -0,0 +1,125 @@
+import pathPosix from "node:path/posix";
+import { S3 } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import path from "node:path";
+import * as util from "./util";
+import type { Readable } from "node:stream";
+
+export const supportedTypes = ["S3"] as const; // add other types when we support them
+export type storageType = (typeof supportedTypes)[number];
+
+export function typeToURLScheme(sType: storageType): string {
+  switch (sType) {
+    case "S3":
+      return "s3";
+    default:
+      util.assertNever(sType);
+      throw new Error("no schema defined for storage type"); // just to calm down TS type analyzer
+  }
+}
+
+export interface RegistryStorage {
+  exists(file: string): Promise<boolean>;
+  putFile(file: string, data: Buffer | Readable): Promise<void>;
+}
+
+async function objectExists(client: S3, bucket: string, key: string): Promise<boolean> {
+  try {
+    await client.headObject({
+      Bucket: bucket,
+      Key: key,
+    });
+
+    return true;
+  } catch (error) {
+    if (error instanceof Error && error.name === "NotFound") {
+      return false;
+    }
+
+    throw util.wrapErr(error, `failed to check if object exists in S3 bucket ${bucket}`);
+  }
+}
+
+async function newS3(
+  options: NonNullable<ConstructorParameters<typeof S3>[0]>,
+  bucket: string,
+): Promise<S3> {
+  const client = new S3(options);
+
+  try {
+    await objectExists(client, bucket, "/");
+  } catch (error) {
+    throw util.CLIError(
+      `credentials given to package builder do not have access to S3 bucket '${bucket}': ${error}`,
+    );
+  }
+
+  return client;
+}
+
+export class S3Storage implements RegistryStorage {
+  constructor(
+    public readonly client: S3,
+    public readonly bucket: string,
+    public readonly root: string = "",
+  ) {}
+
+  async exists(file: string): Promise<boolean> {
+    return objectExists(this.client, this.bucket, pathPosix.join(this.root, file));
+  }
+
+  async putFile(file: string, data: Buffer | Readable): Promise<void> {
+    try {
+      const upload = new Upload({
+        client: this.client,
+        params: {
+          Bucket: this.bucket,
+          Key: pathPosix.join(this.root, file),
+          Body: data,
+        },
+      });
+
+      await upload.done();
+    } catch (e) {
+      throw util.wrapErr(e, `failed to put object into S3 bucket ${this.bucket}`);
+    }
+  }
+}
+
+export async function initByUrl(address: string, pkgRoot: string): Promise<RegistryStorage> {
+  if (address === "") {
+    throw util.CLIError(`Empty registry storage address`);
+  }
+
+  try {
+    const url = new URL(address, `file:${pkgRoot.split(path.sep).join(pathPosix.sep)}/`);
+    switch (url.protocol) {
+      case "s3:": {
+        const s3Options: NonNullable<ConstructorParameters<typeof S3>[0]> = {};
+        const s3Region = url.searchParams.get("region");
+        if (s3Region) s3Options.region = s3Region;
+        const s3Bucket = url.hostname;
+        const s3KeyPrefix = util.trimPrefix(url.pathname, "/");
+        const s3Client = await newS3(s3Options, s3Bucket);
+        return new S3Storage(s3Client, s3Bucket, s3KeyPrefix);
+      }
+      case "s3e:": {
+        const s3eOptions: NonNullable<ConstructorParameters<typeof S3>[0]> = {};
+        const s3eRegion = url.searchParams.get("region");
+        if (s3eRegion) s3eOptions.region = s3eRegion;
+
+        const s3ePath = url.pathname.split("/").slice(1); // '/bucket/keyPrefix' -> ['', 'bucket', 'keyPrefix'] -> ['bucket', 'keyPrefix']
+        const s3eBucket = s3ePath[0];
+        const s3eKeyPrefix = s3ePath.length > 1 ? util.trimPrefix(s3ePath[1], "/") : "";
+        const s3eClient = await newS3(s3eOptions, s3eBucket);
+        return new S3Storage(s3eClient, s3eBucket, s3eKeyPrefix);
+      }
+      default:
+        throw util.CLIError(
+          `Protocol ${url.protocol} is not supported for software registries yet. Use your own tooling for package upload`,
+        );
+    }
+  } catch (e) {
+    throw util.wrapErr(e, `failed to init storage driver from URL`);
+  }
+}

package/src/core/sw-json-render.test.ts

@@ -0,0 +1,215 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomBytes } from "node:crypto";
+
+import * as defaults from "../defaults";
+import * as artifacts from "./schemas/artifacts";
+import { PackageInfo } from "./package-info";
+import { descriptorFilePath, readDescriptorFile } from "./resolver";
+import { SwJsonRenderer, writeBuiltArtifactInfo } from "./sw-json-render";
+import * as test_assets from "./schemas/test-artifacts";
+import { createLogger } from "./util";
+import { describe, test, expect, beforeAll, beforeEach, afterAll } from "vitest";
+import * as docker from "./docker";
+import * as util from "./util";
+
+describe("Renderer tests", () => {
+  let tempDir: string;
+  let i: PackageInfo;
+  const l = createLogger("error");
+
+  beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "vitest-temp-dir-"));
+  });
+
+  beforeEach(() => {
+    const fakePackageRoot = path.join(tempDir, randomBytes(16).toString("hex"));
+    i = new PackageInfo(l, { pkgJsonData: test_assets.PackageJson, packageRoot: fakePackageRoot });
+  });
+
+  afterAll(() => {
+    fs.rmSync(tempDir, { recursive: true });
+  });
+
+  test("render asset", () => {
+    const epName = test_assets.EPNameAsset;
+    const assetPkg = i.getArtifact(epName, "asset");
+    const sw = new SwJsonRenderer(l, i);
+
+    writeTestArtifactInfo(i, "archive", assetPkg);
+    const eps = new Map([[epName, i.getMainEntrypoint(epName)]]);
+    const descriptor = sw.renderSoftwareEntrypoints("release", eps).get(epName)!;
+
+    const url = descriptor.asset!.url;
+    const expectedPath = `${test_assets.BinaryRegistryURL}/assets/${test_assets.PackageNameNoAt}/pAsset/${test_assets.PackageVersion}.zip`;
+    expect(url).toEqual(expectedPath);
+  });
+
+  test("render os-dependant", () => {
+    const epName = test_assets.EPNameCustomName;
+    const binPkg = i.getArtifact(epName, "binary");
+    const sw = new SwJsonRenderer(l, i);
+
+    writeTestArtifactInfo(i, "archive", binPkg);
+    const eps = new Map([[epName, i.getMainEntrypoint(epName)]]);
+    const descriptor = sw.renderSoftwareEntrypoints("release", eps).get(epName)!;
+
+    expect(descriptor.binary!.package).toEqual(
+      `software/${test_assets.BinaryCustomName1}/${test_assets.BinaryCustomVersion}-{os}-{arch}.tgz`,
+    );
+  });
+
+  test("render environment", () => {
+    const epName = test_assets.EPNameJavaEnvironment;
+    const envPkg = i.getArtifact(epName, "environment");
+    const sw = new SwJsonRenderer(l, i);
+
+    writeTestArtifactInfo(i, "archive", envPkg);
+    const eps = new Map([[epName, i.entrypoints.get(epName)!]]);
+    const descriptor = sw.renderSoftwareEntrypoints("release", eps).get(epName)!;
+
+    expect(descriptor.runEnv!.package).toEqual(
+      `software/${test_assets.PackageNameNoAt}/${test_assets.EPNameJavaEnvironment}/${test_assets.PackageVersion}-{os}-{arch}.tgz`,
+    );
+    expect(descriptor.runEnv!.type).toEqual("java");
+    expect(descriptor.runEnv!.binDir).toEqual(".");
+  });
+
+  test("read descriptor after render", () => {
+    const epName = test_assets.EPNameCustomName;
+    const binPkg = i.getArtifact(epName, "binary");
+    const sw = new SwJsonRenderer(l, i);
+
+    writeTestArtifactInfo(i, "archive", binPkg);
+    const eps = new Map([[epName, i.getMainEntrypoint(epName)]]);
+    const renderedDescriptor = sw.renderSoftwareEntrypoints("release", eps).get(epName)!;
+    sw.writeSwJson(renderedDescriptor);
+
+    const epPath = descriptorFilePath(
+      i.packageRoot,
+      renderedDescriptor.asset ? "asset" : "software",
+      epName,
+    );
+    const parsedDescriptor = readDescriptorFile(i.packageName, epName, epPath);
+
+    expect(parsedDescriptor.binary).toEqual(renderedDescriptor.binary);
+  });
+
+  test("render with environment dependency", () => {
+    const envEpName = test_assets.EPNameJavaEnvironment;
+    const envPkg = i.getArtifact(envEpName, "environment");
+    const epName = test_assets.EPNameJava;
+    const javaPkg = i.getArtifact(epName, "java");
+
+    const renderer = new SwJsonRenderer(l, i);
+
+    writeTestArtifactInfo(i, "archive", envPkg);
+    const envEps = new Map([[envEpName, i.getMainEntrypoint(envEpName)]]);
+    const envDescriptor = renderer.renderSoftwareEntrypoints("release", envEps).get(envEpName)!;
+    renderer.writeSwJson(envDescriptor);
+
+    writeTestArtifactInfo(i, "archive", javaPkg);
+    const eps = new Map([[epName, i.getMainEntrypoint(epName)]]);
+    const descriptor = renderer.renderSoftwareEntrypoints("release", eps).get(epName)!;
+    expect(descriptor.binary!.package).toEqual(
+      `software/${test_assets.PackageNameNoAt}/${test_assets.EPNameJava}/${test_assets.PackageVersion}.tgz`,
+    );
+  });
+
+  test("render docker with binary", () => {
+    const envEpName = test_assets.EPNameJavaEnvironment;
+    const envArtifact = i.getArtifact(envEpName, "environment");
+    writeTestArtifactInfo(i, "archive", envArtifact);
+
+    const javaEpName = test_assets.EPNameJava;
+    const javaArtifact = i.getArtifact(javaEpName, "java");
+    writeTestArtifactInfo(i, "archive", javaArtifact);
+
+    const javaDockerEpName = docker.entrypointName(javaEpName);
+    const dockerPkg = i.getArtifact(javaEpName, "docker");
+    writeTestArtifactInfo(i, "docker", dockerPkg);
+
+    fs.mkdirSync(path.join(i.packageRoot, i.packageRoot), { recursive: true });
+    fs.mkdirSync(path.join(i.packageRoot, "docker-context"), { recursive: true });
+    fs.writeFileSync(path.join(i.packageRoot, "Dockerfile"), "FROM scratch");
+    fs.writeFileSync(path.join(i.packageRoot, "package.json"), test_assets.PackageJson);
+
+    const render = new SwJsonRenderer(l, i);
+
+    const envEps = new Map([[envEpName, i.getMainEntrypoint(envEpName)]]);
+    const envDescriptor = render.renderSoftwareEntrypoints("release", envEps).get(envEpName)!;
+    render.writeSwJson(envDescriptor);
+
+    const eps = new Map([
+      [javaDockerEpName, i.getMainEntrypoint(javaDockerEpName)],
+      [javaEpName, i.getMainEntrypoint(javaEpName)],
+    ]);
+    const javaDescriptor = render.renderSoftwareEntrypoints("release", eps).get(javaEpName)!;
+    render.writeSwJson(javaDescriptor);
+
+    const expectedTag = new RegExp(
+      `${defaults.DOCKER_REGISTRY}:${test_assets.PackageNameNoAt}\\.${javaEpName}\\.(?<hash>.*)`,
+    );
+    expect(javaDescriptor.docker).toBeDefined();
+    expect(javaDescriptor.docker!.tag).toMatch(expectedTag);
+    expect(javaDescriptor.docker!.cmd).toEqual(["java", "-jar", "hello.jar"]);
+  });
+
+  test("render docker indinvidual entrypoint", () => {
+    const dockerEpName = test_assets.EPNameDocker;
+    const dockerPkg = i.getArtifact(dockerEpName, "docker");
+    writeTestArtifactInfo(i, "docker", dockerPkg);
+
+    fs.mkdirSync(path.join(i.packageRoot, i.packageRoot), { recursive: true });
+    fs.mkdirSync(path.join(i.packageRoot, "docker-context"), { recursive: true });
+    fs.writeFileSync(path.join(i.packageRoot, "Dockerfile"), "FROM scratch");
+    fs.writeFileSync(path.join(i.packageRoot, "package.json"), test_assets.PackageJson);
+
+    const render = new SwJsonRenderer(l, i);
+
+    const eps = new Map([[dockerEpName, i.getMainEntrypoint(dockerEpName)]]);
+    const dockerDescriptor = render.renderSoftwareEntrypoints("release", eps).get(dockerEpName)!;
+
+    const expectedTag = new RegExp(
+      `${defaults.DOCKER_REGISTRY}:${test_assets.PackageNameNoAt}\\.${dockerEpName}\\.(?<hash>.*)`,
+    );
+    expect(dockerDescriptor.docker).toBeDefined();
+    expect(dockerDescriptor.docker!.tag).toMatch(expectedTag);
+    expect(dockerDescriptor.docker!.cmd).toEqual(["echo", "hello"]);
+  });
+});
+
+function writeTestArtifactInfo(
+  i: PackageInfo,
+  artifactType: "docker" | "archive",
+  artifact: artifacts.withId<artifacts.anyArtifactType>,
+) {
+  let artInfoPath: string;
+  if (artifactType === "docker") {
+    // Docker artifacts are always cross-compiled to linux/amd64 (see
+    // core.buildDockerImage + sw-json-render.renderDockerInfo).
+    artInfoPath = i.artifactInfoLocation(artifact.id, "docker", "x64");
+  } else if (artifacts.isCrossPlatform(artifact.type)) {
+    artInfoPath = i.artifactInfoLocation(artifact.id, "archive", undefined);
+  } else {
+    artInfoPath = i.artifactInfoLocation(artifact.id, "archive", util.currentPlatform());
+  }
+
+  const registry = i.artifactRegistrySettings(artifact);
+
+  writeBuiltArtifactInfo(artInfoPath, {
+    type: artifact.type,
+    platform: util.currentPlatform(),
+    registryURL: artifact.type === "asset" ? registry.downloadURL : undefined,
+    registryName: registry.name,
+    remoteArtifactLocation:
+      artifactType === "docker"
+        ? docker.generateRemoteTagName(i.artifactName(artifact), "beefface")
+        : i.artifactArchiveAddressPattern(artifact),
+    uploadPath:
+      artifactType === "docker"
+        ? undefined
+        : i.artifactArchiveFullName(artifact, util.currentPlatform()),
+  });
+}