trigger.dev 0.0.0-v3-prerelease-20250108141813 → 0.0.0-v4-prerelease-20250916125920

package/dist/esm/deploy/buildImage.js

@@ -1,38 +1,43 @@
-import { join } from "node:path";
-import { createTempDir, writeJSONFile } from "../utilities/fileSystem.js";
 import { logger } from "../utilities/logger.js";
 import { depot } from "@depot/cli";
 import { x } from "tinyexec";
+import { networkInterfaces } from "os";
+import { join } from "path";
+import { safeReadJSONFile } from "../utilities/fileSystem.js";
+import { readFileSync } from "fs";
+import { isLinux } from "std-env";
+import { z } from "zod";
+import { assertExhaustive } from "../utilities/assertExhaustive.js";
 export async function buildImage(options) {
-    const { selfHosted, buildPlatform, noCache, push, registry, loadImage, registryHost, authAccessToken, imageTag, deploymentId, deploymentVersion, contentHash, externalBuildId, externalBuildToken, externalBuildProjectId, compilationPath, projectId, projectRef, extraCACerts, apiUrl, apiKey, buildEnvVars, } = options;
-    if (selfHosted) {
-        return selfHostedBuildImage({
-            registryHost: registryHost,
-            imageTag: imageTag,
+    const { isLocalBuild, imagePlatform, noCache, push, load, authAccessToken, imageTag, deploymentId, deploymentVersion, contentHash, externalBuildId, externalBuildToken, externalBuildProjectId, compilationPath, projectId, projectRef, extraCACerts, apiUrl, apiKey, branchName, buildEnvVars, network, builder, onLog, } = options;
+    if (isLocalBuild) {
+        return localBuildImage({
+            imageTag,
+            imagePlatform,
             cwd: compilationPath,
-            projectId: projectId,
-            deploymentId: deploymentId,
-            deploymentVersion: deploymentVersion,
-            contentHash: contentHash,
-            projectRef: projectRef,
-            buildPlatform: buildPlatform,
-            pushImage: push,
-            selfHostedRegistry: !!registry,
-            noCache: noCache,
-            extraCACerts: extraCACerts,
+            projectId,
+            deploymentId,
+            deploymentVersion,
+            contentHash,
+            projectRef,
+            push,
+            load,
+            noCache,
+            extraCACerts,
             apiUrl,
             apiKey,
+            branchName,
             buildEnvVars,
-            network: options.network,
+            network,
+            builder,
+            onLog,
         });
     }
     if (!externalBuildId || !externalBuildToken || !externalBuildProjectId) {
         throw new Error("Failed to initialize deployment. The deployment does not have any external build data. To deploy this project, you must use the --self-hosted flag to build and push the image yourself.");
     }
-    return depotBuildImage({
-        registryHost,
+    return remoteBuildImage({
         auth: authAccessToken,
-        imageTag,
         buildId: externalBuildId,
         buildToken: externalBuildToken,
         buildProjectId: externalBuildProjectId,
@@ -42,22 +47,18 @@ export async function buildImage(options) {
         deploymentVersion,
         contentHash,
         projectRef,
-        loadImage,
-        buildPlatform,
+        load,
+        imagePlatform,
         noCache,
         extraCACerts,
         apiUrl,
         apiKey,
+        branchName,
         buildEnvVars,
+        onLog,
     });
 }
-async function depotBuildImage(options) {
-    // Step 3: Ensure we are "logged in" to our registry by writing to $HOME/.docker/config.json
-    // TODO: make sure this works on windows
-    const dockerConfigDir = await ensureLoggedIntoDockerRegistry(options.registryHost, {
-        username: "trigger",
-        password: options.auth,
-    });
+async function remoteBuildImage(options) {
     const buildArgs = Object.entries(options.buildEnvVars || {})
         .filter(([key, value]) => value)
         .flatMap(([key, value]) => ["--build-arg", `${key}=${value}`]);
@@ -67,9 +68,12 @@ async function depotBuildImage(options) {
         "Containerfile",
         options.noCache ? "--no-cache" : undefined,
         "--platform",
-        options.buildPlatform,
+        options.imagePlatform,
+        options.load ? "--load" : undefined,
         "--provenance",
         "false",
+        "--metadata-file",
+        "metadata.json",
         "--build-arg",
         `TRIGGER_PROJECT_ID=${options.projectId}`,
         "--build-arg",
@@ -83,18 +87,17 @@ async function depotBuildImage(options) {
         "--build-arg",
         `TRIGGER_API_URL=${options.apiUrl}`,
         "--build-arg",
+        `TRIGGER_PREVIEW_BRANCH=${options.branchName ?? ""}`,
+        "--build-arg",
         `TRIGGER_SECRET_KEY=${options.apiKey}`,
         ...(buildArgs || []),
         ...(options.extraCACerts ? ["--build-arg", `NODE_EXTRA_CA_CERTS=${options.extraCACerts}`] : []),
         "--progress",
         "plain",
-        "-t",
-        `${options.registryHost}/${options.imageTag}`,
         ".",
-        "--push",
-        options.loadImage ? "--load" : undefined,
+        "--save",
     ].filter(Boolean);
-    logger.debug(`depot ${args.join(" ")}`);
+    logger.debug(`depot ${args.join(" ")}`, { cwd: options.cwd });
     // Step 4: Build and push the image
     const childProcess = depot(args, {
         cwd: options.cwd,
@@ -104,7 +107,6 @@ async function depotBuildImage(options) {
             DEPOT_PROJECT_ID: options.buildProjectId,
             DEPOT_NO_SUMMARY_LINK: "1",
             DEPOT_NO_UPDATE_NOTIFIER: "1",
-            DOCKER_CONFIG: dockerConfigDir,
         },
     });
     const errors = [];
@@ -115,6 +117,9 @@ async function depotBuildImage(options) {
                 const text = data.toString();
                 // Emitted data chunks can contain multiple lines. Remove empty lines.
                 const lines = text.split("\n").filter(Boolean);
+                for (const line of lines) {
+                    options.onLog?.(line);
+                }
                 errors.push(...lines);
                 logger.debug(text);
             });
@@ -129,10 +134,23 @@ async function depotBuildImage(options) {
                 logs,
             };
         }
-        const digest = extractImageDigest(errors);
+        const metadataPath = join(options.cwd, "metadata.json");
+        const rawMetadata = await safeReadJSONFile(metadataPath);
+        const meta = BuildKitMetadata.safeParse(rawMetadata);
+        let digest;
+        if (!meta.success) {
+            logger.error("Failed to parse metadata.json", {
+                errors: meta.error.message,
+                path: metadataPath,
+            });
+        }
+        else {
+            logger.debug("Parsed metadata.json", { metadata: meta.data, path: metadataPath });
+            digest = meta.data["containerimage.digest"];
+        }
         return {
             ok: true,
-            image: options.imageTag,
+            imageSizeBytes: 0,
             logs,
             digest,
         };
@@ -145,19 +163,114 @@ async function depotBuildImage(options) {
         };
     }
 }
-async function selfHostedBuildImage(options) {
-    const imageRef = `${options.registryHost ? `${options.registryHost}/` : ""}${options.imageTag}`;
+async function localBuildImage(options) {
+    const { builder, imageTag } = options;
+    // Ensure multi-platform build is supported on the local machine
+    let builderExists = false;
+    const lsLogs = [];
+    // List existing builders
+    const lsProcess = x("docker", ["buildx", "ls", "--format", "{{.Name}}"]);
+    for await (const line of lsProcess) {
+        lsLogs.push(line);
+        logger.debug(line);
+        if (line === builder) {
+            builderExists = true;
+        }
+    }
+    if (lsProcess.exitCode !== 0) {
+        return {
+            ok: false,
+            error: `Failed to list buildx builders`,
+            logs: lsLogs.join("\n"),
+        };
+    }
+    if (builderExists && options.network) {
+        // We need to ensure the current builder network matches
+        const inspectProcess = x("docker", ["buildx", "inspect", builder]);
+        const inspectLogs = [];
+        let hasCorrectNetwork = false;
+        for await (const line of inspectProcess) {
+            inspectLogs.push(line);
+            if (line.match(/Driver Options:\s+network="([^"]+)"/)?.at(1) === options.network) {
+                hasCorrectNetwork = true;
+            }
+        }
+        if (inspectProcess.exitCode !== 0) {
+            return {
+                ok: false,
+                error: `Failed to inspect buildx builder '${builder}'`,
+                logs: inspectLogs.join("\n"),
+            };
+        }
+        if (!hasCorrectNetwork) {
+            // Delete the existing builder and signal to create a new one
+            const deleteProcess = x("docker", ["buildx", "rm", builder]);
+            const deleteLogs = [];
+            for await (const line of deleteProcess) {
+                deleteLogs.push(line);
+            }
+            if (deleteProcess.exitCode !== 0) {
+                return {
+                    ok: false,
+                    error: `Failed to delete buildx builder '${builder}'`,
+                    logs: deleteLogs.join("\n"),
+                };
+            }
+            builderExists = false;
+        }
+    }
+    // If the builder does not exist, create it and is compatible with multi-platform builds
+    if (!builderExists) {
+        const createLogs = [];
+        const args = [
+            "buildx",
+            "create",
+            "--name",
+            builder,
+            "--driver",
+            "docker-container",
+            options.network ? `--driver-opt=network=${options.network}` : undefined,
+        ].filter(Boolean);
+        const createProcess = x("docker", args);
+        for await (const line of createProcess) {
+            createLogs.push(line);
+            logger.debug(line);
+            options.onLog?.(line);
+        }
+        if (createProcess.exitCode !== 0) {
+            return {
+                ok: false,
+                error: `Failed to create buildx builder '${builder}'`,
+                logs: [...lsLogs, ...createLogs].join("\n"),
+            };
+        }
+    }
     const buildArgs = Object.entries(options.buildEnvVars || {})
         .filter(([key, value]) => value)
         .flatMap(([key, value]) => ["--build-arg", `${key}=${value}`]);
+    const apiUrl = normalizeApiUrlForBuild(options.apiUrl);
+    const addHost = getAddHost(apiUrl);
+    const push = shouldPush(options.imageTag, options.push);
+    const load = shouldLoad(options.load, push);
+    await ensureQemuRegistered(options.imagePlatform);
     const args = [
+        "buildx",
         "build",
+        "--builder",
+        builder,
         "-f",
         "Containerfile",
         options.noCache ? "--no-cache" : undefined,
         "--platform",
-        options.buildPlatform,
-        ...(options.network ? ["--network", options.network] : []),
+        options.imagePlatform,
+        options.network ? `--network=${options.network}` : undefined,
+        addHost ? `--add-host=${addHost}` : undefined,
+        push ? "--push" : undefined,
+        load ? "--load" : undefined,
+        "--provenance",
+        "false",
+        "--metadata-file",
+        "metadata.json",
         "--build-arg",
         `TRIGGER_PROJECT_ID=${options.projectId}`,
         "--build-arg",
@@ -169,7 +282,9 @@ async function selfHostedBuildImage(options) {
         "--build-arg",
         `TRIGGER_PROJECT_REF=${options.projectRef}`,
         "--build-arg",
-        `TRIGGER_API_URL=${options.apiUrl}`,
+        `TRIGGER_API_URL=${apiUrl}`,
+        "--build-arg",
+        `TRIGGER_PREVIEW_BRANCH=${options.branchName ?? ""}`,
         "--build-arg",
         `TRIGGER_SECRET_KEY=${options.apiKey}`,
         ...(buildArgs || []),
@@ -177,14 +292,11 @@ async function selfHostedBuildImage(options) {
         "--progress",
         "plain",
         "-t",
-        imageRef,
+        options.imageTag,
         ".", // The build context
     ].filter(Boolean);
-    logger.debug(`docker ${args.join(" ")}`, {
-        cwd: options.cwd,
-    });
+    logger.debug(`docker ${args.join(" ")}`, { cwd: options.cwd });
     const errors = [];
-    let digest;
     // Build the image
     const buildProcess = x("docker", args, {
         nodeOptions: { cwd: options.cwd },
@@ -193,6 +305,7 @@ async function selfHostedBuildImage(options) {
         // line will be from stderr/stdout in the order you'd see it in a term
         errors.push(line);
         logger.debug(line);
+        options.onLog?.(line);
     }
     if (buildProcess.exitCode !== 0) {
         return {
@@ -201,67 +314,59 @@ async function selfHostedBuildImage(options) {
             logs: extractLogs(errors),
         };
     }
-    digest = extractImageDigest(errors);
-    if (options.selfHostedRegistry || options.pushImage) {
-        const pushArgs = ["push", imageRef].filter(Boolean);
-        logger.debug(`docker ${pushArgs.join(" ")}`);
-        // Push the image
-        const pushProcess = x("docker", pushArgs, {
-            nodeOptions: { cwd: options.cwd },
+    const metadataPath = join(options.cwd, "metadata.json");
+    const rawMetadata = await safeReadJSONFile(metadataPath);
+    const meta = BuildKitMetadata.safeParse(rawMetadata);
+    let digest;
+    if (!meta.success) {
+        logger.error("Failed to parse metadata.json", {
+            errors: meta.error.message,
+            path: metadataPath,
         });
-        for await (const line of pushProcess) {
-            logger.debug(line);
-            errors.push(line);
-        }
-        if (pushProcess.exitCode !== 0) {
-            return {
-                ok: false,
-                error: "Error pushing image",
-                logs: extractLogs(errors),
-            };
+    }
+    else {
+        logger.debug("Parsed metadata.json", { metadata: meta.data, path: metadataPath });
+        // Always use the manifest (list) digest
+        digest = meta.data["containerimage.digest"];
+    }
+    // Get the image size
+    const sizeProcess = x("docker", ["image", "inspect", options.imageTag, "--format={{.Size}}"], {
+        nodeOptions: { cwd: options.cwd },
+    });
+    let imageSizeBytes = 0;
+    for await (const line of sizeProcess) {
+        if (line.trim() === "") {
+            continue;
         }
+        imageSizeBytes = parseInt(line, 10);
+        break;
+    }
+    if (imageSizeBytes) {
+        // Convert to MB and log
+        options.onLog?.(`Image size: ${(imageSizeBytes / (1024 * 1024)).toFixed(2)} MB`);
     }
     return {
         ok: true,
-        image: options.imageTag,
+        imageSizeBytes,
         digest,
         logs: extractLogs(errors),
     };
 }
-async function ensureLoggedIntoDockerRegistry(registryHost, auth) {
-    const tmpDir = await createTempDir();
-    // Read the current docker config
-    const dockerConfigPath = join(tmpDir, "config.json");
-    await writeJSONFile(dockerConfigPath, {
-        auths: {
-            [registryHost]: {
-                auth: Buffer.from(`${auth.username}:${auth.password}`).toString("base64"),
-            },
-        },
-    });
-    logger.debug(`Writing docker config to ${dockerConfigPath}`);
-    return tmpDir;
-}
 function extractLogs(outputs) {
     // Remove empty lines
     const cleanedOutputs = outputs.map((line) => line.trim()).filter((line) => line !== "");
     return cleanedOutputs.map((line) => line.trim()).join("\n");
 }
-function extractImageDigest(outputs) {
-    const imageDigestRegex = /pushing manifest for .+(?<digest>sha256:[a-f0-9]{64})/;
-    for (const line of outputs) {
-        const imageDigestMatch = line.match(imageDigestRegex);
-        const digest = imageDigestMatch?.groups?.digest;
-        if (digest) {
-            return digest;
-        }
-    }
-    return;
-}
+const BASE_IMAGE = {
+    bun: "imbios/bun-node:1.2.20-20-slim@sha256:a20d1f90ee079b80dffc0041cf8a73aa05cdb135e3b3aff1ba3eba91608dba22",
+    node: "node:21.7.3-bookworm-slim@sha256:dfc05dee209a1d7adf2ef189bd97396daad4e97c6eaa85778d6f75205ba1b0fb",
+    "node-22": "node:22.16.0-bookworm-slim@sha256:048ed02c5fd52e86fda6fbd2f6a76cf0d4492fd6c6fee9e2c463ed5108da0e34",
+};
 const DEFAULT_PACKAGES = ["busybox", "ca-certificates", "dumb-init", "git", "openssl"];
 export async function generateContainerfile(options) {
     switch (options.runtime) {
-        case "node": {
+        case "node":
+        case "node-22": {
             return await generateNodeContainerfile(options);
         }
         case "bun": {
@@ -269,7 +374,7 @@ export async function generateContainerfile(options) {
         }
     }
 }
-async function generateBunContainerfile(options) {
+const parseGenerateOptions = (options) => {
     const buildArgs = Object.entries(options.build.env || {})
         .flatMap(([key]) => `ARG ${key}`)
         .join("\n");
@@ -279,19 +384,35 @@ async function generateBunContainerfile(options) {
     const postInstallCommands = (options.build.commands || []).map((cmd) => `RUN ${cmd}`).join("\n");
     const baseInstructions = (options.image?.instructions || []).join("\n");
     const packages = Array.from(new Set(DEFAULT_PACKAGES.concat(options.image?.pkgs || []))).join(" ");
+    return {
+        baseImage: BASE_IMAGE[options.runtime],
+        baseInstructions,
+        buildArgs,
+        buildEnvVars,
+        packages,
+        postInstallCommands,
+    };
+};
+async function generateBunContainerfile(options) {
+    const { baseImage, buildArgs, buildEnvVars, postInstallCommands, baseInstructions, packages } = parseGenerateOptions(options);
     return `# syntax=docker/dockerfile:1
-FROM imbios/bun-node:1.1.24-22-slim@sha256:9cfb7cd87529261c482fe17d8894c0986263f3a5ccf84ad65c00ec0e1ed539c6 AS base
+FROM ${baseImage} AS base
 
 ${baseInstructions}
 
 ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && apt-get --fix-broken install -y && apt-get install -y --no-install-recommends ${packages} && apt-get clean && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && \
+  apt-get --fix-broken install -y && \
+  apt-get install -y --no-install-recommends ${packages} && \
+  apt-get clean && \
+  rm -rf /var/lib/apt/lists/*
 
 FROM base AS build
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    python3 make g++ && \
-    apt-get clean && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && \
+  apt-get install -y --no-install-recommends python3 make g++ && \
+  apt-get clean && \
+  rm -rf /var/lib/apt/lists/*
 
 USER bun
 WORKDIR /app
@@ -322,6 +443,7 @@ ARG TRIGGER_PROJECT_REF
 ARG NODE_EXTRA_CA_CERTS
 ARG TRIGGER_SECRET_KEY
 ARG TRIGGER_API_URL
+ARG TRIGGER_PREVIEW_BRANCH
 
 ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_DEPLOYMENT_ID=\${TRIGGER_DEPLOYMENT_ID} \
@@ -330,9 +452,14 @@ ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_CONTENT_HASH=\${TRIGGER_CONTENT_HASH} \
     TRIGGER_SECRET_KEY=\${TRIGGER_SECRET_KEY} \
     TRIGGER_API_URL=\${TRIGGER_API_URL} \
+    TRIGGER_PREVIEW_BRANCH=\${TRIGGER_PREVIEW_BRANCH} \
     NODE_EXTRA_CA_CERTS=\${NODE_EXTRA_CA_CERTS} \
     NODE_ENV=production
 
+ARG TARGETPLATFORM
+ARG BUILDPLATFORM
+ENV BUILDPLATFORM=$BUILDPLATFORM TARGETPLATFORM=$TARGETPLATFORM
+
 # Run the indexer
 RUN bun run ${options.indexScript}
 
@@ -354,6 +481,7 @@ ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_DEPLOYMENT_VERSION=\${TRIGGER_DEPLOYMENT_VERSION} \
     TRIGGER_CONTENT_HASH=\${TRIGGER_CONTENT_HASH} \
     TRIGGER_PROJECT_REF=\${TRIGGER_PROJECT_REF} \
+    UV_USE_IO_URING=0 \
     NODE_EXTRA_CA_CERTS=\${NODE_EXTRA_CA_CERTS} \
     NODE_ENV=production
 
@@ -368,29 +496,25 @@ CMD []
   `;
 }
 async function generateNodeContainerfile(options) {
-    const buildArgs = Object.entries(options.build.env || {})
-        .flatMap(([key]) => `ARG ${key}`)
-        .join("\n");
-    const buildEnvVars = Object.entries(options.build.env || {})
-        .flatMap(([key]) => `ENV ${key}=$${key}`)
-        .join("\n");
-    const postInstallCommands = (options.build.commands || []).map((cmd) => `RUN ${cmd}`).join("\n");
-    const baseInstructions = (options.image?.instructions || []).join("\n");
-    const packages = Array.from(new Set(DEFAULT_PACKAGES.concat(options.image?.pkgs || []))).join(" ");
+    const { baseImage, buildArgs, buildEnvVars, postInstallCommands, baseInstructions, packages } = parseGenerateOptions(options);
     return `# syntax=docker/dockerfile:1
-FROM node:21-bookworm-slim@sha256:99afef5df7400a8d118e0504576d32ca700de5034c4f9271d2ff7c91cc12d170 AS base
+FROM ${baseImage} AS base
 
 ${baseInstructions}
 
 ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && apt-get --fix-broken install -y && apt-get install -y --no-install-recommends ${packages} && apt-get clean && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && \
+  apt-get --fix-broken install -y && \
+  apt-get install -y --no-install-recommends ${packages} && \
+  apt-get clean && rm -rf /var/lib/apt/lists/*
 
 FROM base AS build
 
 # Install build dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    python3 make g++ && \
-    apt-get clean && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && \
+  apt-get install -y --no-install-recommends python3 make g++ && \
+  apt-get clean && \
+  rm -rf /var/lib/apt/lists/*
 
 USER node
 WORKDIR /app
@@ -427,6 +551,7 @@ ARG TRIGGER_PROJECT_REF
 ARG NODE_EXTRA_CA_CERTS
 ARG TRIGGER_SECRET_KEY
 ARG TRIGGER_API_URL
+ARG TRIGGER_PREVIEW_BRANCH
 
 ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_DEPLOYMENT_ID=\${TRIGGER_DEPLOYMENT_ID} \
@@ -435,11 +560,16 @@ ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_CONTENT_HASH=\${TRIGGER_CONTENT_HASH} \
     TRIGGER_SECRET_KEY=\${TRIGGER_SECRET_KEY} \
     TRIGGER_API_URL=\${TRIGGER_API_URL} \
+    TRIGGER_PREVIEW_BRANCH=\${TRIGGER_PREVIEW_BRANCH} \
     TRIGGER_LOG_LEVEL=debug \
     NODE_EXTRA_CA_CERTS=\${NODE_EXTRA_CA_CERTS} \
     NODE_ENV=production \
     NODE_OPTIONS="--max_old_space_size=8192"
 
+ARG TARGETPLATFORM
+ARG BUILDPLATFORM
+ENV BUILDPLATFORM=$BUILDPLATFORM TARGETPLATFORM=$TARGETPLATFORM
+
 # Run the indexer
 RUN node ${options.indexScript}
 
@@ -461,9 +591,9 @@ ENV TRIGGER_PROJECT_ID=\${TRIGGER_PROJECT_ID} \
     TRIGGER_DEPLOYMENT_VERSION=\${TRIGGER_DEPLOYMENT_VERSION} \
     TRIGGER_CONTENT_HASH=\${TRIGGER_CONTENT_HASH} \
     TRIGGER_PROJECT_REF=\${TRIGGER_PROJECT_REF} \
+    UV_USE_IO_URING=0 \
     NODE_EXTRA_CA_CERTS=\${NODE_EXTRA_CA_CERTS} \
-    NODE_ENV=production \
-    NODE_OPTIONS="--max_old_space_size=8192"
+    NODE_ENV=production
 
 # Copy the files from the install stage
 COPY --from=build --chown=node:node /app ./
@@ -475,4 +605,119 @@ ENTRYPOINT [ "dumb-init", "node", "${options.entrypoint}" ]
 CMD []
   `;
 }
+// If apiUrl is something like http://localhost:3030, we need to convert it to http://host.docker.internal:3030
+// this way the indexing will work because the docker image can reach the local server
+function normalizeApiUrlForBuild(apiUrl) {
+    return apiUrl.replace("localhost", "host.docker.internal");
+}
+function getHostIP() {
+    const interfaces = networkInterfaces();
+    for (const [name, iface] of Object.entries(interfaces)) {
+        if (!iface) {
+            continue;
+        }
+        for (const net of iface) {
+            // Skip internal/loopback and non-IPv4 addresses
+            if (!net.internal && net.family === "IPv4") {
+                return net.address;
+            }
+        }
+    }
+    return "127.0.0.1";
+}
+function getAddHost(apiUrl) {
+    if (apiUrl.includes("host.docker.internal")) {
+        return `host.docker.internal:${getHostIP()}`;
+    }
+    return;
+}
+function isQemuRegistered() {
+    try {
+        // Check a single QEMU handler
+        const binfmt = readFileSync("/proc/sys/fs/binfmt_misc/qemu-aarch64", "utf8");
+        return binfmt.includes("enabled");
+    }
+    catch (e) {
+        return false;
+    }
+}
+function isMultiPlatform(imagePlatform) {
+    return imagePlatform.split(",").length > 1;
+}
+async function ensureQemuRegistered(imagePlatform) {
+    if (isLinux && isMultiPlatform(imagePlatform) && !isQemuRegistered()) {
+        logger.debug("Registering QEMU for multi-platform build...");
+        const ensureQemuProcess = x("docker", [
+            "run",
+            "--rm",
+            "--privileged",
+            "multiarch/qemu-user-static",
+            "--reset",
+            "-p",
+            "yes",
+        ]);
+        const logs = [];
+        for await (const line of ensureQemuProcess) {
+            logger.debug(line);
+            logs.push(line);
+        }
+        if (ensureQemuProcess.exitCode !== 0) {
+            logger.error("Failed to register QEMU for multi-platform build", {
+                exitCode: ensureQemuProcess.exitCode,
+                logs: logs.join("\n"),
+            });
+        }
+    }
+}
+const BuildKitMetadata = z.object({
+    "buildx.build.ref": z.string().optional(),
+    "containerimage.descriptor": z
+        .object({
+        mediaType: z.string(),
+        digest: z.string(),
+        size: z.number(),
+    })
+        .optional(),
+    "containerimage.digest": z.string().optional(),
+    "containerimage.config.digest": z.string().optional(),
+    "image.name": z.string().optional(),
+});
+// Don't push if the image tag is a local address, unless the user explicitly wants to push
+function shouldPush(imageTag, push) {
+    switch (push) {
+        case true: {
+            return true;
+        }
+        case false: {
+            return false;
+        }
+        case undefined: {
+            return imageTag.startsWith("localhost") ||
+                imageTag.startsWith("127.0.0.1") ||
+                imageTag.startsWith("0.0.0.0")
+                ? false
+                : true;
+        }
+        default: {
+            assertExhaustive(push);
+        }
+    }
+}
+// Don't load if we're pushing, unless the user explicitly wants to load
+function shouldLoad(load, push) {
+    switch (load) {
+        case true: {
+            return true;
+        }
+        case false: {
+            return false;
+        }
+        case undefined: {
+            return push ? false : true;
+        }
+        default: {
+            assertExhaustive(load);
+        }
+    }
+}
 //# sourceMappingURL=buildImage.js.map