refactor: rename builders to server

packages/server/src/utils/builders/compose.ts

@@ -0,0 +1,216 @@
+import {
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { paths } from "@/server/constants";
+import type { InferResultType } from "@/server/types/with";
+import boxen from "boxen";
+import {
+	writeDomainsToCompose,
+	writeDomainsToComposeRemote,
+} from "../docker/domain";
+import { encodeBase64, prepareEnvironmentVariables } from "../docker/utils";
+import { execAsyncRemote } from "../process/execAsync";
+import { spawnAsync } from "../process/spawnAsync";
+
+export type ComposeNested = InferResultType<
+	"compose",
+	{ project: true; mounts: true; domains: true }
+>;
+export const buildCompose = async (compose: ComposeNested, logPath: string) => {
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const { sourceType, appName, mounts, composeType, domains } = compose;
+	try {
+		const { COMPOSE_PATH } = paths();
+		const command = createCommand(compose);
+		await writeDomainsToCompose(compose, domains);
+		createEnvFile(compose);
+
+		const logContent = `
+App Name: ${appName}
+Build Compose 🐳
+Detected: ${mounts.length} mounts 📂
+Command: docker ${command}
+Source Type: docker ${sourceType} ✅
+Compose Type: ${composeType} ✅`;
+		const logBox = boxen(logContent, {
+			padding: {
+				left: 1,
+				right: 1,
+				bottom: 1,
+			},
+			width: 80,
+			borderStyle: "double",
+		});
+		writeStream.write(`\n${logBox}\n`);
+
+		const projectPath = join(COMPOSE_PATH, compose.appName, "code");
+		await spawnAsync(
+			"docker",
+			[...command.split(" ")],
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data.toString());
+				}
+			},
+			{
+				cwd: projectPath,
+				env: {
+					NODE_ENV: process.env.NODE_ENV,
+					PATH: process.env.PATH,
+				},
+			},
+		);
+
+		writeStream.write("Docker Compose Deployed: ✅");
+	} catch (error) {
+		writeStream.write("Error ❌");
+		throw error;
+	} finally {
+		writeStream.end();
+	}
+};
+
+export const getBuildComposeCommand = async (
+	compose: ComposeNested,
+	logPath: string,
+) => {
+	const { COMPOSE_PATH } = paths(true);
+	const { sourceType, appName, mounts, composeType, domains, composePath } =
+		compose;
+	const command = createCommand(compose);
+	const envCommand = getCreateEnvFileCommand(compose);
+	const projectPath = join(COMPOSE_PATH, compose.appName, "code");
+
+	const newCompose = await writeDomainsToComposeRemote(
+		compose,
+		domains,
+		logPath,
+	);
+	const logContent = `
+App Name: ${appName}
+Build Compose 🐳
+Detected: ${mounts.length} mounts 📂
+Command: docker ${command}
+Source Type: docker ${sourceType} ✅
+Compose Type: ${composeType} ✅`;
+
+	const logBox = boxen(logContent, {
+		padding: {
+			left: 1,
+			right: 1,
+			bottom: 1,
+		},
+		width: 80,
+		borderStyle: "double",
+	});
+
+	const bashCommand = `
+	set -e
+	{
+		echo "${logBox}" >> "${logPath}"
+	
+		${newCompose}
+	
+		${envCommand}
+	
+		cd "${projectPath}";
+
+		docker ${command.split(" ").join(" ")} >> "${logPath}" 2>&1 || { echo "Error: ❌ Docker command failed" >> "${logPath}"; exit 1; }
+	
+		echo "Docker Compose Deployed: ✅" >> "${logPath}"
+	} || {
+		echo "Error: ❌ Script execution failed" >> "${logPath}"
+		exit 1
+	}
+	`;
+
+	return await execAsyncRemote(compose.serverId, bashCommand);
+};
+
+const sanitizeCommand = (command: string) => {
+	const sanitizedCommand = command.trim();
+
+	const parts = sanitizedCommand.split(/\s+/);
+
+	const restCommand = parts.map((arg) => arg.replace(/^"(.*)"$/, "$1"));
+
+	return restCommand.join(" ");
+};
+
+export const createCommand = (compose: ComposeNested) => {
+	const { composeType, appName, sourceType } = compose;
+
+	const path =
+		sourceType === "raw" ? "docker-compose.yml" : compose.composePath;
+	let command = "";
+
+	if (composeType === "docker-compose") {
+		command = `compose -p ${appName} -f ${path} up -d --build --remove-orphans`;
+	} else if (composeType === "stack") {
+		command = `stack deploy -c ${path} ${appName} --prune`;
+	}
+
+	const customCommand = sanitizeCommand(compose.command);
+
+	if (customCommand) {
+		command = `${command} ${customCommand}`;
+	}
+
+	return command;
+};
+
+const createEnvFile = (compose: ComposeNested) => {
+	const { COMPOSE_PATH } = paths();
+	const { env, composePath, appName } = compose;
+	const composeFilePath =
+		join(COMPOSE_PATH, appName, "code", composePath) ||
+		join(COMPOSE_PATH, appName, "code", "docker-compose.yml");
+
+	const envFilePath = join(dirname(composeFilePath), ".env");
+	let envContent = env || "";
+	if (!envContent.includes("DOCKER_CONFIG")) {
+		envContent += "\nDOCKER_CONFIG=/root/.docker/config.json";
+	}
+
+	if (compose.randomize) {
+		envContent += `\nCOMPOSE_PREFIX=${compose.suffix}`;
+	}
+
+	const envFileContent = prepareEnvironmentVariables(envContent).join("\n");
+
+	if (!existsSync(dirname(envFilePath))) {
+		mkdirSync(dirname(envFilePath), { recursive: true });
+	}
+	writeFileSync(envFilePath, envFileContent);
+};
+
+export const getCreateEnvFileCommand = (compose: ComposeNested) => {
+	const { COMPOSE_PATH } = paths(true);
+	const { env, composePath, appName } = compose;
+	const composeFilePath =
+		join(COMPOSE_PATH, appName, "code", composePath) ||
+		join(COMPOSE_PATH, appName, "code", "docker-compose.yml");
+
+	const envFilePath = join(dirname(composeFilePath), ".env");
+
+	let envContent = env || "";
+	if (!envContent.includes("DOCKER_CONFIG")) {
+		envContent += "\nDOCKER_CONFIG=/root/.docker/config.json";
+	}
+
+	if (compose.randomize) {
+		envContent += `\nCOMPOSE_PREFIX=${compose.suffix}`;
+	}
+
+	const envFileContent = prepareEnvironmentVariables(envContent).join("\n");
+
+	const encodedContent = encodeBase64(envFileContent);
+	return `
+touch ${envFilePath};
+echo "${encodedContent}" | base64 -d > "${envFilePath}";
+	`;
+};

packages/server/src/utils/builders/docker-file.ts

@@ -0,0 +1,116 @@
+import type { WriteStream } from "node:fs";
+import { prepareEnvironmentVariables } from "@/server/utils/docker/utils";
+import type { ApplicationNested } from ".";
+import {
+	getBuildAppDirectory,
+	getDockerContextPath,
+} from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
+import { createEnvFile, createEnvFileCommand } from "./utils";
+
+export const buildCustomDocker = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { appName, env, publishDirectory, buildArgs, dockerBuildStage } =
+		application;
+	const dockerFilePath = getBuildAppDirectory(application);
+	try {
+		const image = `${appName}`;
+
+		const defaultContextPath =
+			dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
+		const args = prepareEnvironmentVariables(buildArgs);
+
+		const dockerContextPath = getDockerContextPath(application);
+
+		const commandArgs = ["build", "-t", image, "-f", dockerFilePath, "."];
+
+		if (dockerBuildStage) {
+			commandArgs.push("--target", dockerBuildStage);
+		}
+
+		for (const arg of args) {
+			commandArgs.push("--build-arg", arg);
+		}
+		/*
+			Do not generate an environment file when publishDirectory is specified,
+			as it could be publicly exposed.
+		*/
+		if (!publishDirectory) {
+			createEnvFile(dockerFilePath, env);
+		}
+
+		await spawnAsync(
+			"docker",
+			commandArgs,
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data);
+				}
+			},
+			{
+				cwd: dockerContextPath || defaultContextPath,
+			},
+		);
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const getDockerCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { appName, env, publishDirectory, buildArgs, dockerBuildStage } =
+		application;
+	const dockerFilePath = getBuildAppDirectory(application);
+
+	try {
+		const image = `${appName}`;
+
+		const defaultContextPath =
+			dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
+		const args = prepareEnvironmentVariables(buildArgs);
+
+		const dockerContextPath =
+			getDockerContextPath(application) || defaultContextPath;
+
+		const commandArgs = ["build", "-t", image, "-f", dockerFilePath, "."];
+
+		if (dockerBuildStage) {
+			commandArgs.push("--target", dockerBuildStage);
+		}
+
+		for (const arg of args) {
+			commandArgs.push("--build-arg", arg);
+		}
+
+		/*
+			Do not generate an environment file when publishDirectory is specified,
+			as it could be publicly exposed.
+		*/
+		let command = "";
+		if (!publishDirectory) {
+			command += createEnvFileCommand(dockerFilePath, env);
+		}
+
+		command = `
+echo "Building ${appName}" >> ${logPath};
+cd ${dockerContextPath} >> ${logPath} 2>> ${logPath} || { 
+  echo "❌ The path ${dockerContextPath} does not exist" >> ${logPath};
+  exit 1;
+}
+
+docker ${commandArgs.join(" ")} >> ${logPath} 2>> ${logPath} || { 
+  echo "❌ Docker build failed" >> ${logPath};
+  exit 1;
+}
+echo "✅ Docker build completed." >> ${logPath};
+		`;
+
+		return command;
+	} catch (error) {
+		throw error;
+	}
+};

packages/server/src/utils/builders/drop.ts

@@ -0,0 +1,122 @@
+import fs from "node:fs/promises";
+import path, { join } from "node:path";
+import { paths } from "@/server/constants";
+import type { Application } from "@/server/services/application";
+import { findServerById } from "@/server/services/server";
+import AdmZip from "adm-zip";
+import { Client, type SFTPWrapper } from "ssh2";
+import {
+	recreateDirectory,
+	recreateDirectoryRemote,
+} from "../filesystem/directory";
+import { execAsyncRemote } from "../process/execAsync";
+
+export const unzipDrop = async (zipFile: File, application: Application) => {
+	let sftp: SFTPWrapper | null = null;
+
+	try {
+		const { appName } = application;
+		const { APPLICATIONS_PATH } = paths(!!application.serverId);
+		const outputPath = join(APPLICATIONS_PATH, appName, "code");
+		if (application.serverId) {
+			await recreateDirectoryRemote(outputPath, application.serverId);
+		} else {
+			await recreateDirectory(outputPath);
+		}
+		const arrayBuffer = await zipFile.arrayBuffer();
+		const buffer = Buffer.from(arrayBuffer);
+
+		const zip = new AdmZip(buffer);
+		const zipEntries = zip.getEntries();
+
+		const rootEntries = zipEntries.filter(
+			(entry) =>
+				entry.entryName.split("/").length === 1 ||
+				(entry.entryName.split("/").length === 2 &&
+					entry.entryName.endsWith("/")),
+		);
+
+		const hasSingleRootFolder = !!(
+			rootEntries.length === 1 && rootEntries[0]?.isDirectory
+		);
+		const rootFolderName = hasSingleRootFolder
+			? rootEntries[0]?.entryName.split("/")[0]
+			: "";
+
+		if (application.serverId) {
+			sftp = await getSFTPConnection(application.serverId);
+		}
+		for (const entry of zipEntries) {
+			let filePath = entry.entryName;
+
+			if (
+				hasSingleRootFolder &&
+				rootFolderName &&
+				filePath.startsWith(`${rootFolderName}/`)
+			) {
+				filePath = filePath.slice(rootFolderName?.length + 1);
+			}
+
+			if (!filePath) continue;
+
+			const fullPath = path.join(outputPath, filePath);
+
+			if (application.serverId) {
+				if (entry.isDirectory) {
+					await execAsyncRemote(application.serverId, `mkdir -p ${fullPath}`);
+				} else {
+					if (sftp === null) throw new Error("No SFTP connection available");
+					await uploadFileToServer(sftp, entry.getData(), fullPath);
+				}
+			} else {
+				if (entry.isDirectory) {
+					await fs.mkdir(fullPath, { recursive: true });
+				} else {
+					await fs.mkdir(path.dirname(fullPath), { recursive: true });
+					await fs.writeFile(fullPath, entry.getData());
+				}
+			}
+		}
+	} catch (error) {
+		console.error("Error processing ZIP file:", error);
+		throw error;
+	} finally {
+		sftp?.end();
+	}
+};
+
+const getSFTPConnection = async (serverId: string): Promise<SFTPWrapper> => {
+	const server = await findServerById(serverId);
+	if (!server.sshKeyId) throw new Error("No SSH key available for this server");
+
+	return new Promise((resolve, reject) => {
+		const conn = new Client();
+		conn
+			.on("ready", () => {
+				conn.sftp((err, sftp) => {
+					if (err) return reject(err);
+					resolve(sftp);
+				});
+			})
+			.connect({
+				host: server.ipAddress,
+				port: server.port,
+				username: server.username,
+				privateKey: server.sshKey?.privateKey,
+				timeout: 99999,
+			});
+	});
+};
+
+const uploadFileToServer = (
+	sftp: SFTPWrapper,
+	data: Buffer,
+	remotePath: string,
+): Promise<void> => {
+	return new Promise((resolve, reject) => {
+		sftp.writeFile(remotePath, data, (err) => {
+			if (err) return reject(err);
+			resolve();
+		});
+	});
+};

packages/server/src/utils/builders/heroku.ts

@@ -0,0 +1,73 @@
+import type { WriteStream } from "node:fs";
+import type { ApplicationNested } from ".";
+import { prepareEnvironmentVariables } from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
+
+// TODO: integrate in the vps sudo chown -R $(whoami) ~/.docker
+export const buildHeroku = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { env, appName } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(env);
+	try {
+		const args = [
+			"build",
+			appName,
+			"--path",
+			buildAppDirectory,
+			"--builder",
+			"heroku/builder:24",
+		];
+
+		for (const env of envVariables) {
+			args.push("--env", env);
+		}
+
+		await spawnAsync("pack", args, (data) => {
+			if (writeStream.writable) {
+				writeStream.write(data);
+			}
+		});
+		return true;
+	} catch (e) {
+		throw e;
+	}
+};
+
+export const getHerokuCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { env, appName } = application;
+
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(env);
+
+	const args = [
+		"build",
+		appName,
+		"--path",
+		buildAppDirectory,
+		"--builder",
+		"heroku/builder:24",
+	];
+
+	for (const env of envVariables) {
+		args.push("--env", env);
+	}
+
+	const command = `pack ${args.join(" ")}`;
+	const bashCommand = `
+echo "Starting heroku build..." >> ${logPath};
+${command} >> ${logPath} 2>> ${logPath} || { 
+  echo "❌ Heroku build failed" >> ${logPath};
+  exit 1;
+}
+echo "✅ Heroku build completed." >> ${logPath};
+		`;
+
+	return bashCommand;
+};

packages/server/src/utils/builders/index.ts

@@ -0,0 +1,216 @@
+import { createWriteStream } from "node:fs";
+import type { InferResultType } from "@/server/types/with";
+import type { CreateServiceOptions } from "dockerode";
+import { uploadImage } from "../cluster/upload";
+import {
+	calculateResources,
+	generateBindMounts,
+	generateConfigContainer,
+	generateFileMounts,
+	generateVolumeMounts,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import { getRemoteDocker } from "../servers/remote-docker";
+import { buildCustomDocker, getDockerCommand } from "./docker-file";
+import { buildHeroku, getHerokuCommand } from "./heroku";
+import { buildNixpacks, getNixpacksCommand } from "./nixpacks";
+import { buildPaketo, getPaketoCommand } from "./paketo";
+import { buildStatic, getStaticCommand } from "./static";
+
+// NIXPACKS codeDirectory = where is the path of the code directory
+// HEROKU codeDirectory = where is the path of the code directory
+// PAKETO codeDirectory = where is the path of the code directory
+// DOCKERFILE codeDirectory = where is the exact path of the (Dockerfile)
+export type ApplicationNested = InferResultType<
+	"applications",
+	{ mounts: true; security: true; redirects: true; ports: true; registry: true }
+>;
+export const buildApplication = async (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const { buildType, sourceType } = application;
+	try {
+		writeStream.write(
+			`\nBuild ${buildType}: ✅\nSource Type: ${sourceType}: ✅\n`,
+		);
+		console.log(`Build ${buildType}: ✅`);
+		if (buildType === "nixpacks") {
+			await buildNixpacks(application, writeStream);
+		} else if (buildType === "heroku_buildpacks") {
+			await buildHeroku(application, writeStream);
+		} else if (buildType === "paketo_buildpacks") {
+			await buildPaketo(application, writeStream);
+		} else if (buildType === "dockerfile") {
+			await buildCustomDocker(application, writeStream);
+		} else if (buildType === "static") {
+			await buildStatic(application, writeStream);
+		}
+
+		if (application.registryId) {
+			await uploadImage(application, writeStream);
+		}
+		await mechanizeDockerContainer(application);
+		writeStream.write("Docker Deployed: ✅");
+	} catch (error) {
+		if (error instanceof Error) {
+			writeStream.write(`Error ❌\n${error?.message}`);
+		} else {
+			writeStream.write("Error ❌");
+		}
+		throw error;
+	} finally {
+		writeStream.end();
+	}
+};
+
+export const getBuildCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { buildType } = application;
+	switch (buildType) {
+		case "nixpacks":
+			return getNixpacksCommand(application, logPath);
+		case "heroku_buildpacks":
+			return getHerokuCommand(application, logPath);
+		case "paketo_buildpacks":
+			return getPaketoCommand(application, logPath);
+		case "static":
+			return getStaticCommand(application, logPath);
+		case "dockerfile":
+			return getDockerCommand(application, logPath);
+	}
+};
+
+export const mechanizeDockerContainer = async (
+	application: ApplicationNested,
+) => {
+	const {
+		appName,
+		env,
+		mounts,
+		cpuLimit,
+		memoryLimit,
+		memoryReservation,
+		cpuReservation,
+		command,
+		ports,
+	} = application;
+
+	const resources = calculateResources({
+		memoryLimit,
+		memoryReservation,
+		cpuLimit,
+		cpuReservation,
+	});
+
+	const volumesMount = generateVolumeMounts(mounts);
+
+	const {
+		HealthCheck,
+		RestartPolicy,
+		Placement,
+		Labels,
+		Mode,
+		RollbackConfig,
+		UpdateConfig,
+		Networks,
+	} = generateConfigContainer(application);
+
+	const bindsMount = generateBindMounts(mounts);
+	const filesMount = generateFileMounts(appName, application);
+	const envVariables = prepareEnvironmentVariables(env);
+
+	const image = getImageName(application);
+	const authConfig = getAuthConfig(application);
+	const docker = await getRemoteDocker(application.serverId);
+
+	const settings: CreateServiceOptions = {
+		authconfig: authConfig,
+		Name: appName,
+		TaskTemplate: {
+			ContainerSpec: {
+				HealthCheck,
+				Image: image,
+				Env: envVariables,
+				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
+				...(command
+					? {
+							Command: ["/bin/sh"],
+							Args: ["-c", command],
+						}
+					: {}),
+				Labels,
+			},
+			Networks,
+			RestartPolicy,
+			Placement,
+			Resources: {
+				...resources,
+			},
+		},
+		Mode,
+		RollbackConfig,
+		EndpointSpec: {
+			Ports: ports.map((port) => ({
+				Protocol: port.protocol,
+				TargetPort: port.targetPort,
+				PublishedPort: port.publishedPort,
+			})),
+		},
+		UpdateConfig,
+	};
+
+	try {
+		const service = docker.getService(appName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+			TaskTemplate: {
+				...settings.TaskTemplate,
+				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
+			},
+		});
+	} catch (error) {
+		await docker.createService(settings);
+	}
+};
+
+const getImageName = (application: ApplicationNested) => {
+	const { appName, sourceType, dockerImage, registry } = application;
+
+	if (sourceType === "docker") {
+		return dockerImage || "ERROR-NO-IMAGE-PROVIDED";
+	}
+
+	const registryUrl = registry?.registryUrl || "";
+	const imagePrefix = registry?.imagePrefix ? `${registry.imagePrefix}/` : "";
+	return registry
+		? `${registryUrl}/${imagePrefix}${appName}`
+		: `${appName}:latest`;
+};
+
+const getAuthConfig = (application: ApplicationNested) => {
+	const { registry, username, password, sourceType } = application;
+
+	if (sourceType === "docker") {
+		if (username && password) {
+			return {
+				password,
+				username,
+				serveraddress: "https://index.docker.io/v1/",
+			};
+		}
+	} else if (registry) {
+		return {
+			password: registry.password,
+			username: registry.username,
+			serveraddress: registry.registryUrl,
+		};
+	}
+
+	return undefined;
+};

packages/server/src/utils/builders/nixpacks.ts

@@ -0,0 +1,138 @@
+import { type WriteStream, existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { buildStatic, getStaticCommand } from "@/server/utils/builders/static";
+import { nanoid } from "nanoid";
+import type { ApplicationNested } from ".";
+import { prepareEnvironmentVariables } from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
+
+export const buildNixpacks = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { env, appName, publishDirectory, serverId } = application;
+
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const buildContainerId = `${appName}-${nanoid(10)}`;
+	const envVariables = prepareEnvironmentVariables(env);
+
+	const writeToStream = (data: string) => {
+		if (writeStream.writable) {
+			writeStream.write(data);
+		}
+	};
+
+	try {
+		const args = ["build", buildAppDirectory, "--name", appName];
+
+		for (const env of envVariables) {
+			args.push("--env", env);
+		}
+
+		if (publishDirectory) {
+			/* No need for any start command, since we'll use nginx later on */
+			args.push("--no-error-without-start");
+		}
+
+		await spawnAsync("nixpacks", args, writeToStream);
+
+		/*
+			Run the container with the image created by nixpacks,
+			and copy the artifacts on the host filesystem.
+			Then, remove the container and create a static build.
+		*/
+		if (publishDirectory) {
+			await spawnAsync(
+				"docker",
+				["create", "--name", buildContainerId, appName],
+				writeToStream,
+			);
+
+			const localPath = path.join(buildAppDirectory, publishDirectory);
+
+			if (!existsSync(path.dirname(localPath))) {
+				mkdirSync(path.dirname(localPath), { recursive: true });
+			}
+
+			// https://docs.docker.com/reference/cli/docker/container/cp/
+			const isDirectory =
+				publishDirectory.endsWith("/") || !path.extname(publishDirectory);
+
+			await spawnAsync(
+				"docker",
+				[
+					"cp",
+					`${buildContainerId}:/app/${publishDirectory}${isDirectory ? "/." : ""}`,
+					localPath,
+				],
+				writeToStream,
+			);
+
+			await spawnAsync("docker", ["rm", buildContainerId], writeToStream);
+
+			await buildStatic(application, writeStream);
+		}
+		return true;
+	} catch (e) {
+		await spawnAsync("docker", ["rm", buildContainerId], writeToStream);
+
+		throw e;
+	}
+};
+
+export const getNixpacksCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { env, appName, publishDirectory, serverId } = application;
+
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const buildContainerId = `${appName}-${nanoid(10)}`;
+	const envVariables = prepareEnvironmentVariables(env);
+
+	const args = ["build", buildAppDirectory, "--name", appName];
+
+	for (const env of envVariables) {
+		args.push("--env", env);
+	}
+
+	if (publishDirectory) {
+		/* No need for any start command, since we'll use nginx later on */
+		args.push("--no-error-without-start");
+	}
+	const command = `nixpacks ${args.join(" ")}`;
+	let bashCommand = `
+echo "Starting nixpacks build..." >> ${logPath};
+${command} >> ${logPath} 2>> ${logPath} || { 
+  echo "❌ Nixpacks build failed" >> ${logPath};
+  exit 1;
+}
+echo "✅ Nixpacks build completed." >> ${logPath};
+		`;
+
+	/*
+		Run the container with the image created by nixpacks,
+		and copy the artifacts on the host filesystem.
+		Then, remove the container and create a static build.
+	 */
+	if (publishDirectory) {
+		const localPath = path.join(buildAppDirectory, publishDirectory);
+		const isDirectory =
+			publishDirectory.endsWith("/") || !path.extname(publishDirectory);
+
+		bashCommand += `
+docker create --name ${buildContainerId} ${appName}
+mkdir -p ${localPath}
+docker cp ${buildContainerId}:/app/${publishDirectory}${isDirectory ? "/." : ""} ${path.join(buildAppDirectory, publishDirectory)} >> ${logPath} 2>> ${logPath} || { 
+	docker rm ${buildContainerId}
+	echo "❌ Copying ${publishDirectory} to ${path.join(buildAppDirectory, publishDirectory)} failed" >> ${logPath};
+	exit 1;
+}
+docker rm ${buildContainerId}
+${getStaticCommand(application, logPath)}
+			`;
+	}
+
+	return bashCommand;
+};

packages/server/src/utils/builders/paketo.ts

@@ -0,0 +1,72 @@
+import type { WriteStream } from "node:fs";
+import type { ApplicationNested } from ".";
+import { prepareEnvironmentVariables } from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
+
+export const buildPaketo = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { env, appName } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(env);
+	try {
+		const args = [
+			"build",
+			appName,
+			"--path",
+			buildAppDirectory,
+			"--builder",
+			"paketobuildpacks/builder-jammy-full",
+		];
+
+		for (const env of envVariables) {
+			args.push("--env", env);
+		}
+
+		await spawnAsync("pack", args, (data) => {
+			if (writeStream.writable) {
+				writeStream.write(data);
+			}
+		});
+		return true;
+	} catch (e) {
+		throw e;
+	}
+};
+
+export const getPaketoCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { env, appName } = application;
+
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(env);
+
+	const args = [
+		"build",
+		appName,
+		"--path",
+		buildAppDirectory,
+		"--builder",
+		"paketobuildpacks/builder-jammy-full",
+	];
+
+	for (const env of envVariables) {
+		args.push("--env", env);
+	}
+
+	const command = `pack ${args.join(" ")}`;
+	const bashCommand = `
+echo "Starting Paketo build..." >> ${logPath};
+${command} >> ${logPath} 2>> ${logPath} || { 
+  echo "❌ Paketo build failed" >> ${logPath};
+  exit 1;
+}
+echo "✅ Paketo build completed." >> ${logPath};
+		`;
+
+	return bashCommand;
+};

packages/server/src/utils/builders/static.ts

@@ -0,0 +1,69 @@
+import type { WriteStream } from "node:fs";
+import {
+	buildCustomDocker,
+	getDockerCommand,
+} from "@/server/utils/builders/docker-file";
+import type { ApplicationNested } from ".";
+import { createFile, getCreateFileCommand } from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+
+export const buildStatic = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { publishDirectory } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+
+	try {
+		createFile(
+			buildAppDirectory,
+			"Dockerfile",
+			[
+				"FROM nginx:alpine",
+				"WORKDIR /usr/share/nginx/html/",
+				`COPY ${publishDirectory || "."} .`,
+			].join("\n"),
+		);
+
+		await buildCustomDocker(
+			{
+				...application,
+				buildType: "dockerfile",
+				dockerfile: "Dockerfile",
+			},
+			writeStream,
+		);
+
+		return true;
+	} catch (e) {
+		throw e;
+	}
+};
+
+export const getStaticCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { publishDirectory } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+
+	let command = getCreateFileCommand(
+		buildAppDirectory,
+		"Dockerfile",
+		[
+			"FROM nginx:alpine",
+			"WORKDIR /usr/share/nginx/html/",
+			`COPY ${publishDirectory || "."} .`,
+		].join("\n"),
+	);
+
+	command += getDockerCommand(
+		{
+			...application,
+			buildType: "dockerfile",
+			dockerfile: "Dockerfile",
+		},
+		logPath,
+	);
+	return command;
+};

packages/server/src/utils/builders/utils.ts

@@ -0,0 +1,21 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { prepareEnvironmentVariables } from "../docker/utils";
+
+export const createEnvFile = (directory: string, env: string | null) => {
+	const envFilePath = join(dirname(directory), ".env");
+	if (!existsSync(dirname(envFilePath))) {
+		mkdirSync(dirname(envFilePath), { recursive: true });
+	}
+	const envFileContent = prepareEnvironmentVariables(env).join("\n");
+	writeFileSync(envFilePath, envFileContent);
+};
+
+export const createEnvFileCommand = (directory: string, env: string | null) => {
+	const envFilePath = join(dirname(directory), ".env");
+	if (!existsSync(dirname(envFilePath))) {
+		mkdirSync(dirname(envFilePath), { recursive: true });
+	}
+	const envFileContent = prepareEnvironmentVariables(env).join("\n");
+	return `echo "${envFileContent}" > ${envFilePath}`;
+};