Merge branch 'canary' into 2731-wrong-extension-for-mongo-backup-file

packages/server/src/utils/access-log/handler.ts

@@ -1,6 +1,10 @@
+import fs from "node:fs";
+import path from "node:path";
 import { paths } from "@dokploy/server/constants";
-import { findAdmin } from "@dokploy/server/services/admin";
-import { updateUser } from "@dokploy/server/services/user";
+import {
+	getWebServerSettings,
+	updateWebServerSettings,
+} from "@dokploy/server/services/web-server-settings";
 import { scheduledJobs, scheduleJob } from "node-schedule";
 import { execAsync } from "../process/execAsync";
 
@@ -10,8 +14,6 @@ export const startLogCleanup = async (
 	cronExpression = "0 0 * * *",
 ): Promise<boolean> => {
 	try {
-		const { DYNAMIC_TRAEFIK_PATH } = paths();
-
 		const existingJob = scheduledJobs[LOG_CLEANUP_JOB_NAME];
 		if (existingJob) {
 			existingJob.cancel();
@@ -19,22 +21,26 @@ export const startLogCleanup = async (
 
 		scheduleJob(LOG_CLEANUP_JOB_NAME, cronExpression, async () => {
 			try {
-				await execAsync(
-					`tail -n 1000 ${DYNAMIC_TRAEFIK_PATH}/access.log > ${DYNAMIC_TRAEFIK_PATH}/access.log.tmp && mv ${DYNAMIC_TRAEFIK_PATH}/access.log.tmp ${DYNAMIC_TRAEFIK_PATH}/access.log`,
-				);
+				const { DYNAMIC_TRAEFIK_PATH } = paths();
+				const accessLogPath = path.join(DYNAMIC_TRAEFIK_PATH, "access.log");
 
+				if (!fs.existsSync(accessLogPath)) {
+					console.error("Access log file does not exist");
+					return;
+				}
+
+				await execAsync(
+					`tail -n 1000 ${accessLogPath} > ${accessLogPath}.tmp && mv ${accessLogPath}.tmp ${accessLogPath}`,
+				);
 				await execAsync("docker exec dokploy-traefik kill -USR1 1");
 			} catch (error) {
 				console.error("Error during log cleanup:", error);
 			}
 		});
 
-		const admin = await findAdmin();
-		if (admin) {
-			await updateUser(admin.user.id, {
-				logCleanupCron: cronExpression,
-			});
-		}
+		await updateWebServerSettings({
+			logCleanupCron: cronExpression,
+		});
 
 		return true;
 	} catch (error) {
@@ -51,12 +57,9 @@ export const stopLogCleanup = async (): Promise<boolean> => {
 		}
 
 		// Update database
-		const admin = await findAdmin();
-		if (admin) {
-			await updateUser(admin.user.id, {
-				logCleanupCron: null,
-			});
-		}
+		await updateWebServerSettings({
+			logCleanupCron: null,
+		});
 
 		return true;
 	} catch (error) {
@@ -69,8 +72,8 @@ export const getLogCleanupStatus = async (): Promise<{
 	enabled: boolean;
 	cronExpression: string | null;
 }> => {
-	const admin = await findAdmin();
-	const cronExpression = admin?.user.logCleanupCron ?? null;
+	const settings = await getWebServerSettings();
+	const cronExpression = settings?.logCleanupCron ?? null;
 	return {
 		enabled: cronExpression !== null,
 		cronExpression,

packages/server/src/utils/access-log/utils.ts

@@ -99,6 +99,11 @@ export function parseRawConfig(
 			.compact()
 			.value();
 
+		// Filter out Dokploy dashboard requests
+		parsedLogs = parsedLogs.filter(
+			(log) => log.ServiceName !== "dokploy-service-app@file",
+		);
+
 		// Apply date range filter if provided
 		if (dateRange?.start || dateRange?.end) {
 			parsedLogs = parsedLogs.filter((log) => {

packages/server/src/utils/ai/select-ai-provider.ts

@@ -16,6 +16,7 @@ export function getProviderName(apiUrl: string) {
 	if (apiUrl.includes("api.mistral.ai")) return "mistral";
 	if (apiUrl.includes(":11434") || apiUrl.includes("ollama")) return "ollama";
 	if (apiUrl.includes("api.deepinfra.com")) return "deepinfra";
+	if (apiUrl.includes("generativelanguage.googleapis.com")) return "gemini";
 	return "custom";
 }
 
@@ -29,6 +30,18 @@ export function selectAIProvider(config: { apiUrl: string; apiKey: string }) {
 				baseURL: config.apiUrl,
 			});
 		case "azure":
+			// Azure OpenAI-compatible endpoints already include /v1 in the path.
+			// Using createAzure with such URLs causes a doubled /v1//v1/ suffix.
+			if (config.apiUrl.includes("/v1")) {
+				return createOpenAICompatible({
+					name: "azure",
+					baseURL: config.apiUrl,
+					headers: {
+						"api-key": config.apiKey,
+						Authorization: `Bearer ${config.apiKey}`,
+					},
+				});
+			}
 			return createAzure({
 				apiKey: config.apiKey,
 				baseURL: config.apiUrl,
@@ -66,6 +79,14 @@ export function selectAIProvider(config: { apiUrl: string; apiKey: string }) {
 				baseURL: config.apiUrl,
 				apiKey: config.apiKey,
 			});
+		case "gemini":
+			return createOpenAICompatible({
+				name: "gemini",
+				baseURL: config.apiUrl,
+				headers: {
+					Authorization: `Bearer ${config.apiKey}`,
+				},
+			});
 		case "custom":
 			return createOpenAICompatible({
 				name: "custom",
@@ -94,7 +115,7 @@ export const getProviderHeaders = (
 	// Mistral
 	if (apiUrl.includes("mistral")) {
 		return {
-			Authorization: apiKey,
+			Authorization: `Bearer ${apiKey}`,
 		};
 	}
 

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

@@ -14,13 +14,14 @@ export const runComposeBackup = async (
 	compose: Compose,
 	backup: BackupSchedule,
 ) => {
-	const { environmentId, name } = compose;
+	const { environmentId, name, appName } = compose;
 	const environment = await findEnvironmentById(environmentId);
 	const project = await findProjectById(environment.projectId);
-	const { prefix, databaseType } = backup;
+	const { prefix, databaseType, serviceName } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const s3AppName = serviceName ? `${appName}_${serviceName}` : appName;
+	const bucketDestination = `${s3AppName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	const deployment = await createDeploymentBackup({
 		backupId: backup.backupId,
 		title: "Compose Backup",

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

@@ -1,19 +1,16 @@
-import path from "node:path";
+import { CLEANUP_CRON_JOB } from "@dokploy/server/constants";
 import { member } from "@dokploy/server/db/schema";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import { getAllServers } from "@dokploy/server/services/server";
+import { getWebServerSettings } from "@dokploy/server/services/web-server-settings";
 import { eq } from "drizzle-orm";
 import { scheduleJob } from "node-schedule";
 import { db } from "../../db/index";
 import { startLogCleanup } from "../access-log/handler";
-import {
-	cleanUpDockerBuilder,
-	cleanUpSystemPrune,
-	cleanUpUnusedImages,
-} from "../docker/utils";
+import { cleanupAll } from "../docker/utils";
 import { sendDockerCleanupNotifications } from "../notifications/docker-cleanup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials, scheduleBackup } from "./utils";
+import { getS3Credentials, normalizeS3Path, scheduleBackup } from "./utils";
 
 export const initCronJobs = async () => {
 	console.log("Setting up cron jobs....");
@@ -29,16 +26,22 @@ export const initCronJobs = async () => {
 		return;
 	}
 
-	if (admin.user.enableDockerCleanup) {
-		scheduleJob("docker-cleanup", "0 0 * * *", async () => {
-			console.log(
-				`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
-			);
-			await cleanUpUnusedImages();
-			await cleanUpDockerBuilder();
-			await cleanUpSystemPrune();
-			await sendDockerCleanupNotifications(admin.user.id);
-		});
+	const webServerSettings = await getWebServerSettings();
+
+	if (webServerSettings?.enableDockerCleanup) {
+		try {
+			scheduleJob("docker-cleanup", CLEANUP_CRON_JOB, async () => {
+				console.log(
+					`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
+				);
+
+				await cleanupAll();
+
+				await sendDockerCleanupNotifications(admin.user.id);
+			});
+		} catch (error) {
+			console.error("[Backup] Docker Cleanup Error", error);
+		}
 	}
 
 	const servers = await getAllServers();
@@ -46,18 +49,22 @@ export const initCronJobs = async () => {
 	for (const server of servers) {
 		const { serverId, enableDockerCleanup, name } = server;
 		if (enableDockerCleanup) {
-			scheduleJob(serverId, "0 0 * * *", async () => {
-				console.log(
-					`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${name}`,
-				);
-				await cleanUpUnusedImages(serverId);
-				await cleanUpDockerBuilder(serverId);
-				await cleanUpSystemPrune(serverId);
-				await sendDockerCleanupNotifications(
-					admin.user.id,
-					`Docker cleanup for Server ${name} (${serverId})`,
-				);
-			});
+			try {
+				scheduleJob(serverId, CLEANUP_CRON_JOB, async () => {
+					console.log(
+						`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${name}`,
+					);
+
+					await cleanupAll(serverId);
+
+					await sendDockerCleanupNotifications(
+						admin.user.id,
+						`Docker cleanup for Server ${name} (${serverId})`,
+					);
+				});
+			} catch (error) {
+				console.error(`[Backup] ${error}`);
+			}
 		}
 	}
 
@@ -68,6 +75,7 @@ export const initCronJobs = async () => {
 			mariadb: true,
 			mysql: true,
 			mongo: true,
+			libsql: true,
 			user: true,
 			compose: true,
 		},
@@ -86,12 +94,34 @@ export const initCronJobs = async () => {
 		}
 	}
 
-	if (admin?.user.logCleanupCron) {
-		console.log("Starting log requests cleanup", admin.user.logCleanupCron);
-		await startLogCleanup(admin.user.logCleanupCron);
+	if (webServerSettings?.logCleanupCron) {
+		try {
+			console.log(
+				"Starting log requests cleanup",
+				webServerSettings.logCleanupCron,
+			);
+			await startLogCleanup(webServerSettings.logCleanupCron);
+		} catch (error) {
+			console.error("[Backup] Log Cleanup Error", error);
+		}
 	}
 };
 
+const getServiceAppName = (backup: BackupSchedule): string => {
+	if (backup.compose?.appName) {
+		return backup.serviceName
+			? `${backup.compose.appName}_${backup.serviceName}`
+			: backup.compose.appName;
+	}
+	const serviceAppName =
+		backup.postgres?.appName ||
+		backup.mysql?.appName ||
+		backup.mariadb?.appName ||
+		backup.mongo?.appName ||
+		backup.libsql?.appName;
+	return serviceAppName || backup.appName;
+};
+
 export const keepLatestNBackups = async (
 	backup: BackupSchedule,
 	serverId?: string | null,
@@ -102,18 +132,16 @@ export const keepLatestNBackups = async (
 
 	try {
 		const rcloneFlags = getS3Credentials(backup.destination);
-		const backupFilesPath = path.join(
-			`:s3:${backup.destination.bucket}`,
-			backup.prefix,
-		);
+		const appName = getServiceAppName(backup);
+		const backupFilesPath = `:s3:${backup.destination.bucket}/${appName}/${normalizeS3Path(backup.prefix)}`;
 
 		// --include "*.bson.gz" or "*.sql.gz" or "*.zip" ensures nothing else other than the dokploy backup files are touched by rclone
 		const rcloneList = `rclone lsf ${rcloneFlags.join(" ")} --include "*${backup.databaseType === "web-server" ? ".zip" : ".{sql.gz,bson.gz}"}" ${backupFilesPath}`;
 		// when we pipe the above command with this one, we only get the list of files we want to delete
 		const sortAndPickUnwantedBackups = `sort -r | tail -n +$((${backup.keepLatestCount}+1)) | xargs -I{}`;
 		// this command deletes the files
-		// to test the deletion before actually deleting we can add --dry-run before ${backupFilesPath}/{}
-		const rcloneDelete = `rclone delete ${rcloneFlags.join(" ")} ${backupFilesPath}/{}`;
+		// to test the deletion before actually deleting we can add --dry-run before ${backupFilesPath}{}
+		const rcloneDelete = `rclone delete ${rcloneFlags.join(" ")} ${backupFilesPath}{}`;
 
 		const rcloneCommand = `${rcloneList} | ${sortAndPickUnwantedBackups} ${rcloneDelete}`;
 

packages/server/src/utils/backups/libsql.ts

@@ -0,0 +1,75 @@
+import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
+import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Libsql } from "@dokploy/server/services/libsql";
+import { findProjectById } from "@dokploy/server/services/project";
+import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
+
+export const runLibsqlBackup = async (
+	libsql: Libsql,
+	backup: BackupSchedule,
+) => {
+	const { name, environmentId, appName } = libsql;
+	const environment = await findEnvironmentById(environmentId);
+	const project = await findProjectById(environment.projectId);
+
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "Initializing Backup",
+		description: "Initializing Backup",
+	});
+	const { prefix } = backup;
+	const destination = backup.destination;
+	const backupFileName = `${new Date().toISOString()}.sql.gz`;
+	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
+	try {
+		const rcloneFlags = getS3Credentials(destination);
+		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
+
+		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
+
+		const backupCommand = getBackupCommand(
+			backup,
+			rcloneCommand,
+			deployment.logPath,
+		);
+		if (libsql.serverId) {
+			await execAsyncRemote(libsql.serverId, backupCommand);
+		} else {
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
+		}
+
+		await sendDatabaseBackupNotifications({
+			applicationName: name,
+			projectName: project.name,
+			databaseType: "libsql",
+			type: "success",
+			organizationId: project.organizationId,
+			databaseName: backup.database,
+		});
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+	} catch (error) {
+		await sendDatabaseBackupNotifications({
+			applicationName: name,
+			projectName: project.name,
+			databaseType: "libsql",
+			type: "error",
+			// @ts-ignore
+			errorMessage: error?.message || "Error message not provided",
+			organizationId: project.organizationId,
+			databaseName: backup.database,
+		});
+
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+
+		throw error;
+	}
+};

packages/server/src/utils/backups/mariadb.ts

@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -14,13 +14,13 @@ export const runMariadbBackup = async (
 	mariadb: Mariadb,
 	backup: BackupSchedule,
 ) => {
-	const { environmentId, name } = mariadb;
+	const { environmentId, name, appName } = mariadb;
 	const environment = await findEnvironmentById(environmentId);
 	const project = await findProjectById(environment.projectId);
 	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	const deployment = await createDeploymentBackup({
 		backupId: backup.backupId,
 		title: "MariaDB Backup",

packages/server/src/utils/backups/mongo.ts

@@ -3,21 +3,21 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Mongo } from "@dokploy/server/services/mongo";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
-	const { environmentId, name } = mongo;
+	const { environmentId, name, appName } = mongo;
 	const environment = await findEnvironmentById(environmentId);
 	const project = await findProjectById(environment.projectId);
 	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.bson.gz`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	const deployment = await createDeploymentBackup({
 		backupId: backup.backupId,
 		title: "MongoDB Backup",

packages/server/src/utils/backups/mysql.ts

@@ -3,21 +3,21 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { MySql } from "@dokploy/server/services/mysql";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
-	const { environmentId, name } = mysql;
+	const { environmentId, name, appName } = mysql;
 	const environment = await findEnvironmentById(environmentId);
 	const project = await findProjectById(environment.projectId);
 	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	const deployment = await createDeploymentBackup({
 		backupId: backup.backupId,
 		title: "MySQL Backup",

packages/server/src/utils/backups/postgres.ts

@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Postgres } from "@dokploy/server/services/postgres";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -14,7 +14,7 @@ export const runPostgresBackup = async (
 	postgres: Postgres,
 	backup: BackupSchedule,
 ) => {
-	const { name, environmentId } = postgres;
+	const { name, environmentId, appName } = postgres;
 	const environment = await findEnvironmentById(environmentId);
 	const project = await findProjectById(environment.projectId);
 
@@ -26,7 +26,7 @@ export const runPostgresBackup = async (
 	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const bucketDestination = `${appName}/${normalizeS3Path(prefix)}${backupFileName}`;
 	try {
 		const rcloneFlags = getS3Credentials(destination);
 		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;

packages/server/src/utils/backups/utils.ts

@@ -4,6 +4,7 @@ import type { Destination } from "@dokploy/server/services/destination";
 import { scheduledJobs, scheduleJob } from "node-schedule";
 import { keepLatestNBackups } from ".";
 import { runComposeBackup } from "./compose";
+import { runLibsqlBackup } from "./libsql";
 import { runMariadbBackup } from "./mariadb";
 import { runMongoBackup } from "./mongo";
 import { runMySqlBackup } from "./mysql";
@@ -19,6 +20,7 @@ export const scheduleBackup = (backup: BackupSchedule) => {
 		mysql,
 		mongo,
 		mariadb,
+		libsql,
 		compose,
 	} = backup;
 	scheduleJob(backupId, schedule, async () => {
@@ -35,6 +37,9 @@ export const scheduleBackup = (backup: BackupSchedule) => {
 			} else if (databaseType === "mariadb" && mariadb) {
 				await runMariadbBackup(mariadb, backup);
 				await keepLatestNBackups(backup, mariadb.serverId);
+			} else if (databaseType === "libsql" && libsql) {
+				await runLibsqlBackup(libsql, backup);
+				await keepLatestNBackups(backup, libsql.serverId);
 			} else if (databaseType === "web-server") {
 				await runWebServerBackup(backup);
 				await keepLatestNBackups(backup);
@@ -62,16 +67,16 @@ export const getS3Credentials = (destination: Destination) => {
 	const { accessKey, secretAccessKey, region, endpoint, provider } =
 		destination;
 	const rcloneFlags = [
-		`--s3-access-key-id=${accessKey}`,
-		`--s3-secret-access-key=${secretAccessKey}`,
-		`--s3-region=${region}`,
-		`--s3-endpoint=${endpoint}`,
+		`--s3-access-key-id="${accessKey}"`,
+		`--s3-secret-access-key="${secretAccessKey}"`,
+		`--s3-region="${region}"`,
+		`--s3-endpoint="${endpoint}"`,
 		"--s3-no-check-bucket",
 		"--s3-force-path-style",
 	];
 
 	if (provider) {
-		rcloneFlags.unshift(`--s3-provider=${provider}`);
+		rcloneFlags.unshift(`--s3-provider="${provider}"`);
 	}
 
 	return rcloneFlags;
@@ -107,6 +112,10 @@ export const getMongoBackupCommand = (
 	return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mongodump -d '${database}' -u '${databaseUser}' -p '${databasePassword}' --archive --authenticationDatabase admin --gzip"`;
 };
 
+export const getLibsqlBackupCommand = (database: string) => {
+	return `docker exec -i $CONTAINER_ID sh -c "tar cf - -C /var/lib/sqld ${database} | gzip"`;
+};
+
 export const getServiceContainerCommand = (appName: string) => {
 	return `docker ps -q --filter "status=running" --filter "label=com.docker.swarm.service.name=${appName}" | head -n 1`;
 };
@@ -123,12 +132,24 @@ export const getComposeContainerCommand = (
 };
 
 const getContainerSearchCommand = (backup: BackupSchedule) => {
-	const { backupType, postgres, mysql, mariadb, mongo, compose, serviceName } =
-		backup;
+	const {
+		backupType,
+		postgres,
+		mysql,
+		mariadb,
+		mongo,
+		libsql,
+		compose,
+		serviceName,
+	} = backup;
 
 	if (backupType === "database") {
 		const appName =
-			postgres?.appName || mysql?.appName || mariadb?.appName || mongo?.appName;
+			postgres?.appName ||
+			mysql?.appName ||
+			mariadb?.appName ||
+			mongo?.appName ||
+			libsql?.appName;
 		return getServiceContainerCommand(appName || "");
 	}
 	if (backupType === "compose") {
@@ -209,6 +230,12 @@ export const generateBackupCommand = (backup: BackupSchedule) => {
 			}
 			break;
 		}
+		case "libsql": {
+			if (backupType === "database") {
+				return getLibsqlBackupCommand(backup.database);
+			}
+			break;
+		}
 		default:
 			throw new Error(`Database type not supported: ${databaseType}`);
 	}

packages/server/src/utils/backups/web-server.ts

@@ -31,7 +31,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 		const { BASE_PATH } = paths();
 		const tempDir = await mkdtemp(join(tmpdir(), "dokploy-backup-"));
 		const backupFileName = `webserver-backup-${timestamp}.zip`;
-		const s3Path = `:s3:${destination.bucket}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
+		const s3Path = `:s3:${destination.bucket}/${backup.appName}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
 
 		try {
 			await execAsync(`mkdir -p ${tempDir}/filesystem`);
@@ -67,7 +67,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 			await execAsync(cleanupCommand);
 
 			await execAsync(
-				`rsync -a --ignore-errors ${BASE_PATH}/ ${tempDir}/filesystem/`,
+				`rsync -a --ignore-errors --no-specials --no-devices --exclude='volume-backups/' ${BASE_PATH}/ ${tempDir}/filesystem/`,
 			);
 
 			writeStream.write("Copied filesystem to temp directory\n");

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

@@ -1,117 +1,29 @@
-import {
-	createWriteStream,
-	existsSync,
-	mkdirSync,
-	writeFileSync,
-} from "node:fs";
 import { dirname, join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { InferResultType } from "@dokploy/server/types/with";
 import boxen from "boxen";
-import {
-	writeDomainsToCompose,
-	writeDomainsToComposeRemote,
-} from "../docker/domain";
+import { quote } from "shell-quote";
+import { writeDomainsToCompose } from "../docker/domain";
 import {
 	encodeBase64,
 	getEnviromentVariablesObject,
 	prepareEnvironmentVariables,
 } from "../docker/utils";
-import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export type ComposeNested = InferResultType<
 	"compose",
 	{ environment: { with: { 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);
 
-		if (compose.isolatedDeployment) {
-			await execAsync(
-				`docker network inspect ${compose.appName} >/dev/null 2>&1 || docker network create ${composeType === "stack" ? "--driver overlay" : ""} --attachable ${compose.appName}`,
-			);
-		}
-
-		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,
-					...(composeType === "stack" && {
-						...getEnviromentVariablesObject(
-							compose.env,
-							compose.environment.project.env,
-						),
-					}),
-				},
-			},
-		);
-
-		if (compose.isolatedDeployment) {
-			await execAsync(
-				`docker network connect ${compose.appName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1`,
-			).catch(() => {});
-		}
-
-		writeStream.write("Docker Compose Deployed: ✅");
-	} catch (error) {
-		writeStream.write(`Error ❌ ${(error as Error).message}`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getBuildComposeCommand = async (
-	compose: ComposeNested,
-	logPath: string,
-) => {
-	const { COMPOSE_PATH } = paths(true);
+export const getBuildComposeCommand = async (compose: ComposeNested) => {
+	const { COMPOSE_PATH } = paths(!!compose.serverId);
 	const { sourceType, appName, mounts, composeType, domains } = compose;
 	const command = createCommand(compose);
 	const envCommand = getCreateEnvFileCommand(compose);
 	const projectPath = join(COMPOSE_PATH, compose.appName, "code");
 	const exportEnvCommand = getExportEnvCommand(compose);
 
-	const newCompose = await writeDomainsToComposeRemote(
-		compose,
-		domains,
-		logPath,
-	);
+	const newCompose = await writeDomainsToCompose(compose, domains);
 	const logContent = `
 App Name: ${appName}
 Build Compose 🐳
@@ -133,7 +45,7 @@ Compose Type: ${composeType} ✅`;
 	const bashCommand = `
 	set -e
 	{
-		echo "${logBox}" >> "${logPath}"
+		echo "${logBox}";
 	
 		${newCompose}
 	
@@ -141,19 +53,18 @@ Compose Type: ${composeType} ✅`;
 	
 		cd "${projectPath}";
 
-        ${exportEnvCommand}
-		${compose.isolatedDeployment ? `docker network inspect ${compose.appName} >/dev/null 2>&1 || docker network create --attachable ${compose.appName}` : ""}
-		docker ${command.split(" ").join(" ")} >> "${logPath}" 2>&1 || { echo "Error: ❌ Docker command failed" >> "${logPath}"; exit 1; }
+		${compose.isolatedDeployment ? `docker network inspect ${compose.appName} >/dev/null 2>&1 || docker network create ${compose.composeType === "stack" ? "--driver overlay" : ""} --attachable ${compose.appName}` : ""}
+		env -i PATH="$PATH" ${exportEnvCommand} docker ${command.split(" ").join(" ")} 2>&1 || { echo "Error: ❌ Docker command failed"; exit 1; }
 		${compose.isolatedDeployment ? `docker network connect ${compose.appName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1` : ""}
 	
-		echo "Docker Compose Deployed: ✅" >> "${logPath}"
+		echo "Docker Compose Deployed: ✅";
 	} || {
-		echo "Error: ❌ Script execution failed" >> "${logPath}"
+		echo "Error: ❌ Script execution failed";
 		exit 1
 	}
 	`;
 
-	return await execAsyncRemote(compose.serverId, bashCommand);
+	return bashCommand;
 };
 
 const sanitizeCommand = (command: string) => {
@@ -179,44 +90,14 @@ export const createCommand = (compose: ComposeNested) => {
 	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`;
+		command = `stack deploy -c ${path} ${appName} --prune --with-registry-auth`;
 	}
 
 	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 = `APP_NAME=${appName}\n`;
-	envContent += env || "";
-	if (!envContent.includes("DOCKER_CONFIG")) {
-		envContent += "\nDOCKER_CONFIG=/root/.docker";
-	}
-
-	if (compose.randomize) {
-		envContent += `\nCOMPOSE_PREFIX=${compose.suffix}`;
-	}
-
-	const envFileContent = prepareEnvironmentVariables(
-		envContent,
-		compose.environment.project.env,
-		compose.environment.env,
-	).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 { COMPOSE_PATH } = paths(!!compose.serverId);
 	const { env, composePath, appName } = compose;
 	const composeFilePath =
 		join(COMPOSE_PATH, appName, "code", composePath) ||
@@ -253,10 +134,11 @@ const getExportEnvCommand = (compose: ComposeNested) => {
 	const envVars = getEnviromentVariablesObject(
 		compose.env,
 		compose.environment.project.env,
+		compose.environment.env,
 	);
 	const exports = Object.entries(envVars)
-		.map(([key, value]) => `export ${key}=${JSON.stringify(value)}`)
-		.join("\n");
+		.map(([key, value]) => `${key}=${quote([value])}`)
+		.join(" ");
 
-	return exports ? `\n# Export environment variables\n${exports}\n` : "";
+	return exports ? `${exports}` : "";
 };

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

@@ -1,93 +1,25 @@
-import type { WriteStream } from "node:fs";
-import { prepareEnvironmentVariables } from "@dokploy/server/utils/docker/utils";
+import {
+	getEnviromentVariablesObject,
+	prepareEnvironmentVariablesForShell,
+} from "@dokploy/server/utils/docker/utils";
+import { quote } from "shell-quote";
 import {
 	getBuildAppDirectory,
 	getDockerContextPath,
 } from "../filesystem/directory";
-import { spawnAsync } from "../process/spawnAsync";
 import type { ApplicationNested } from ".";
-import { createEnvFile, createEnvFileCommand } from "./utils";
+import { createEnvFileCommand } from "./utils";
 
-export const buildCustomDocker = async (
-	application: ApplicationNested,
-	writeStream: WriteStream,
-) => {
-	const {
-		appName,
-		env,
-		publishDirectory,
-		buildArgs,
-		dockerBuildStage,
-		cleanCache,
-	} = application;
-	const dockerFilePath = getBuildAppDirectory(application);
-	try {
-		const image = `${appName}`;
-
-		const defaultContextPath =
-			dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
-		const args = prepareEnvironmentVariables(
-			buildArgs,
-			application.environment.project.env,
-			application.environment.env,
-		);
-
-		const dockerContextPath = getDockerContextPath(application);
-
-		const commandArgs = ["build", "-t", image, "-f", dockerFilePath, "."];
-
-		if (cleanCache) {
-			commandArgs.push("--no-cache");
-		}
-
-		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,
-				application.environment.project.env,
-				application.environment.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,
-) => {
+export const getDockerCommand = (application: ApplicationNested) => {
 	const {
 		appName,
 		env,
 		publishDirectory,
 		buildArgs,
+		buildSecrets,
 		dockerBuildStage,
 		cleanCache,
+		createEnvFile,
 	} = application;
 	const dockerFilePath = getBuildAppDirectory(application);
 
@@ -96,11 +28,6 @@ export const getDockerCommand = (
 
 		const defaultContextPath =
 			dockerFilePath.substring(0, dockerFilePath.lastIndexOf("/") + 1) || ".";
-		const args = prepareEnvironmentVariables(
-			buildArgs,
-			application.environment.project.env,
-			application.environment.env,
-		);
 
 		const dockerContextPath =
 			getDockerContextPath(application) || defaultContextPath;
@@ -115,16 +42,33 @@ export const getDockerCommand = (
 			commandArgs.push("--no-cache");
 		}
 
+		const args = prepareEnvironmentVariablesForShell(
+			buildArgs,
+			application.environment.project.env,
+			application.environment.env,
+		);
+
 		for (const arg of args) {
-			commandArgs.push("--build-arg", `'${arg}'`);
+			commandArgs.push("--build-arg", arg);
 		}
 
+		const secrets = getEnviromentVariablesObject(
+			buildSecrets,
+			application.environment.project.env,
+			application.environment.env,
+		);
+
+		const joinedSecrets = Object.entries(secrets)
+			.map(([key, value]) => `${key}=${quote([value])}`)
+			.join(" ");
+
 		/*
 			Do not generate an environment file when publishDirectory is specified,
 			as it could be publicly exposed.
+			Also respect the createEnvFile flag.
 		*/
 		let command = "";
-		if (!publishDirectory) {
+		if (!publishDirectory && createEnvFile) {
 			command += createEnvFileCommand(
 				dockerFilePath,
 				env,
@@ -133,18 +77,25 @@ export const getDockerCommand = (
 			);
 		}
 
+		for (const key in secrets) {
+			// Although buildx is smart enough to know we may be referring to an environment variable name,
+			// we still make sure it doesn't fall back to `type=file`.
+			// See: https://docs.docker.com/reference/cli/docker/buildx/build/#secret
+			commandArgs.push("--secret", `type=env,id=${key}`);
+		}
+
 		command += `
-echo "Building ${appName}" >> ${logPath};
-cd ${dockerContextPath} >> ${logPath} 2>> ${logPath} || { 
-  echo "❌ The path ${dockerContextPath} does not exist" >> ${logPath};
+echo "Building ${appName}" ;
+cd ${dockerContextPath} || { 
+  echo "❌ The path ${dockerContextPath} does not exist" ;
   exit 1;
 }
 
-docker ${commandArgs.join(" ")} >> ${logPath} 2>> ${logPath} || { 
-  echo "❌ Docker build failed" >> ${logPath};
+${joinedSecrets} docker ${commandArgs.join(" ")} || { 
+  echo "❌ Docker build failed" ;
   exit 1;
 }
-echo "✅ Docker build completed." >> ${logPath};
+echo "✅ Docker build completed." ;
 		`;
 
 		return command;

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

@@ -3,6 +3,7 @@ import path, { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { Application } from "@dokploy/server/services/application";
 import { findServerById } from "@dokploy/server/services/server";
+import { readValidDirectory } from "@dokploy/server/wss/utils";
 import AdmZip from "adm-zip";
 import { Client, type SFTPWrapper } from "ssh2";
 import {
@@ -16,10 +17,13 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 
 	try {
 		const { appName } = application;
-		const { APPLICATIONS_PATH } = paths(!!application.serverId);
+		// Use buildServerId if set, otherwise fall back to serverId
+		// This ensures the code is extracted to the server where the build will run
+		const targetServerId = application.buildServerId || application.serverId;
+		const { APPLICATIONS_PATH } = paths(!!targetServerId);
 		const outputPath = join(APPLICATIONS_PATH, appName, "code");
-		if (application.serverId) {
-			await recreateDirectoryRemote(outputPath, application.serverId);
+		if (targetServerId) {
+			await recreateDirectoryRemote(outputPath, targetServerId);
 		} else {
 			await recreateDirectory(outputPath);
 		}
@@ -45,8 +49,8 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 			? rootEntries[0]?.entryName.split("/")[0]
 			: "";
 
-		if (application.serverId) {
-			sftp = await getSFTPConnection(application.serverId);
+		if (targetServerId) {
+			sftp = await getSFTPConnection(targetServerId);
 		}
 		for (const entry of zipEntries) {
 			let filePath = entry.entryName;
@@ -62,16 +66,24 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 			if (!filePath) continue;
 
 			const fullPath = path.join(outputPath, filePath).replace(/\\/g, "/");
+			if (!readValidDirectory(fullPath, application.serverId)) {
+				throw new Error(
+					`Path traversal detected: resolved path escapes output directory: ${filePath}`,
+				);
+			}
 
-			if (application.serverId) {
+			if (isDangerousNode(entry)) {
+				throw new Error(
+					`Dangerous node entries are not allowed: ${entry.entryName}`,
+				);
+			}
+
+			if (targetServerId) {
 				if (!entry.isDirectory) {
 					if (sftp === null) throw new Error("No SFTP connection available");
 					try {
 						const dirPath = path.dirname(fullPath);
-						await execAsyncRemote(
-							application.serverId,
-							`mkdir -p "${dirPath}"`,
-						);
+						await execAsyncRemote(targetServerId, `mkdir -p "${dirPath}"`);
 						await uploadFileToServer(sftp, entry.getData(), fullPath);
 					} catch (err) {
 						console.error(`Error uploading file ${fullPath}:`, err);
@@ -132,3 +144,14 @@ const uploadFileToServer = (
 		});
 	});
 };
+
+function isDangerousNode(entry: AdmZip.IZipEntry) {
+	const type = (entry.header.attr >> 16) & 0o170000;
+
+	return (
+		type === 0o120000 || // symlink
+		type === 0o060000 || // block device
+		type === 0o020000 || // char device
+		type === 0o010000 // fifo/pipe
+	);
+}

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

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

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

@@ -1,7 +1,6 @@
-import { createWriteStream } from "node:fs";
 import type { InferResultType } from "@dokploy/server/types/with";
 import type { CreateServiceOptions } from "dockerode";
-import { uploadImage, uploadImageRemoteCommand } from "../cluster/upload";
+import { getRegistryTag, uploadImageRemoteCommand } from "../cluster/upload";
 import {
 	calculateResources,
 	generateBindMounts,
@@ -11,12 +10,12 @@ import {
 	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 { buildRailpack, getRailpackCommand } from "./railpack";
-import { buildStatic, getStaticCommand } from "./static";
+import { getDockerCommand } from "./docker-file";
+import { getHerokuCommand } from "./heroku";
+import { getNixpacksCommand } from "./nixpacks";
+import { getPaketoCommand } from "./paketo";
+import { getRailpackCommand } from "./railpack";
+import { getStaticCommand } from "./static";
 
 // NIXPACKS codeDirectory = where is the path of the code directory
 // HEROKU codeDirectory = where is the path of the code directory
@@ -30,80 +29,46 @@ export type ApplicationNested = InferResultType<
 		redirects: true;
 		ports: true;
 		registry: true;
+		buildRegistry: true;
+		rollbackRegistry: true;
+		deployments: true;
 		environment: { with: { project: 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);
-		} else if (buildType === "railpack") {
-			await buildRailpack(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,
-) => {
+export const getBuildCommand = async (application: ApplicationNested) => {
 	let command = "";
-	const { buildType, registry } = application;
-	switch (buildType) {
-		case "nixpacks":
-			command = getNixpacksCommand(application, logPath);
-			break;
-		case "heroku_buildpacks":
-			command = getHerokuCommand(application, logPath);
-			break;
-		case "paketo_buildpacks":
-			command = getPaketoCommand(application, logPath);
-			break;
-		case "static":
-			command = getStaticCommand(application, logPath);
-			break;
-		case "dockerfile":
-			command = getDockerCommand(application, logPath);
-			break;
-		case "railpack":
-			command = getRailpackCommand(application, logPath);
-			break;
+
+	if (application.sourceType !== "docker") {
+		const { buildType } = application;
+		switch (buildType) {
+			case "nixpacks":
+				command = getNixpacksCommand(application);
+				break;
+			case "heroku_buildpacks":
+				command = getHerokuCommand(application);
+				break;
+			case "paketo_buildpacks":
+				command = getPaketoCommand(application);
+				break;
+			case "static":
+				command = getStaticCommand(application);
+				break;
+			case "dockerfile":
+				command = getDockerCommand(application);
+				break;
+			case "railpack":
+				command = getRailpackCommand(application);
+				break;
+		}
 	}
-	if (registry) {
-		command += uploadImageRemoteCommand(application, logPath);
+
+	if (
+		application.registry ||
+		application.buildRegistry ||
+		application.rollbackRegistry
+	) {
+		command += await uploadImageRemoteCommand(application);
 	}
 
 	return command;
@@ -121,6 +86,7 @@ export const mechanizeDockerContainer = async (
 		memoryReservation,
 		cpuReservation,
 		command,
+		args,
 		ports,
 	} = application;
 
@@ -143,6 +109,8 @@ export const mechanizeDockerContainer = async (
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(application);
 
 	const bindsMount = generateBindMounts(mounts);
@@ -166,12 +134,16 @@ export const mechanizeDockerContainer = async (
 				Image: image,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				...(command
-					? {
-							Command: ["/bin/sh"],
-							Args: ["-c", command],
-						}
-					: {}),
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
+				...(command && {
+					Command: command.split(" "),
+				}),
+				...(args &&
+					args.length > 0 && {
+						Args: args,
+					}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -183,17 +155,17 @@ export const mechanizeDockerContainer = async (
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Ports: ports.map((port) => ({
-				PublishMode: port.publishMode,
-				Protocol: port.protocol,
-				TargetPort: port.targetPort,
-				PublishedPort: port.publishedPort,
-			})),
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Ports: ports.map((port) => ({
+						PublishMode: port.publishMode,
+						Protocol: port.protocol,
+						TargetPort: port.targetPort,
+						PublishedPort: port.publishedPort,
+					})),
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 
 	try {
@@ -208,23 +180,30 @@ export const mechanizeDockerContainer = async (
 				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
 			},
 		});
-	} catch {
-		await docker.createService(settings);
+	} catch (error) {
+		console.log(error);
+		if (authConfig) {
+			await docker.createService(authConfig, settings);
+		} else {
+			await docker.createService(settings);
+		}
 	}
 };
 
 const getImageName = (application: ApplicationNested) => {
-	const { appName, sourceType, dockerImage, registry } = application;
+	const { appName, sourceType, dockerImage, registry, buildRegistry } =
+		application;
 	const imageName = `${appName}:latest`;
 	if (sourceType === "docker") {
 		return dockerImage || "ERROR-NO-IMAGE-PROVIDED";
 	}
 
 	if (registry) {
-		const { registryUrl, imagePrefix, username } = registry;
-		const registryTag = imagePrefix
-			? `${registryUrl ? `${registryUrl}/` : ""}${imagePrefix}/${imageName}`
-			: `${registryUrl ? `${registryUrl}/` : ""}${username}/${imageName}`;
+		const registryTag = getRegistryTag(registry, imageName);
+		return registryTag;
+	}
+	if (buildRegistry) {
+		const registryTag = getRegistryTag(buildRegistry, imageName);
 		return registryTag;
 	}
 
@@ -232,7 +211,14 @@ const getImageName = (application: ApplicationNested) => {
 };
 
 export const getAuthConfig = (application: ApplicationNested) => {
-	const { registry, username, password, sourceType, registryUrl } = application;
+	const {
+		registry,
+		buildRegistry,
+		username,
+		password,
+		sourceType,
+		registryUrl,
+	} = application;
 
 	if (sourceType === "docker") {
 		if (username && password) {
@@ -248,6 +234,12 @@ export const getAuthConfig = (application: ApplicationNested) => {
 			username: registry.username,
 			serveraddress: registry.registryUrl,
 		};
+	} else if (buildRegistry) {
+		return {
+			password: buildRegistry.password,
+			username: buildRegistry.username,
+			serveraddress: buildRegistry.registryUrl,
+		};
 	}
 
 	return undefined;

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

@@ -1,106 +1,16 @@
-import { existsSync, mkdirSync, type WriteStream } from "node:fs";
 import path from "node:path";
-import {
-	buildStatic,
-	getStaticCommand,
-} from "@dokploy/server/utils/builders/static";
+import { getStaticCommand } from "@dokploy/server/utils/builders/static";
 import { nanoid } from "nanoid";
-import { prepareEnvironmentVariables } from "../docker/utils";
+import { prepareEnvironmentVariablesForShell } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
-import { spawnAsync } from "../process/spawnAsync";
 import type { ApplicationNested } from ".";
 
-export const buildNixpacks = async (
-	application: ApplicationNested,
-	writeStream: WriteStream,
-) => {
+export const getNixpacksCommand = (application: ApplicationNested) => {
 	const { env, appName, publishDirectory, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const buildContainerId = `${appName}-${nanoid(10)}`;
-	const envVariables = prepareEnvironmentVariables(
-		env,
-		application.environment.project.env,
-		application.environment.env,
-	);
-
-	const writeToStream = (data: string) => {
-		if (writeStream.writable) {
-			writeStream.write(data);
-		}
-	};
-
-	try {
-		const args = ["build", buildAppDirectory, "--name", appName];
-
-		if (cleanCache) {
-			args.push("--no-cache");
-		}
-
-		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, cleanCache } = application;
-
-	const buildAppDirectory = getBuildAppDirectory(application);
-	const buildContainerId = `${appName}-${nanoid(10)}`;
-	const envVariables = prepareEnvironmentVariables(
+	const envVariables = prepareEnvironmentVariablesForShell(
 		env,
 		application.environment.project.env,
 		application.environment.env,
@@ -113,7 +23,7 @@ export const getNixpacksCommand = (
 	}
 
 	for (const env of envVariables) {
-		args.push("--env", `'${env}'`);
+		args.push("--env", env);
 	}
 
 	if (publishDirectory) {
@@ -122,12 +32,12 @@ export const getNixpacksCommand = (
 	}
 	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};
+		echo "Starting nixpacks build..." ;
+		${command} || {
+			echo "❌ Nixpacks build failed" ;
+			exit 1;
+		}
+		echo "✅ Nixpacks build completed." ;
 		`;
 
 	/*
@@ -141,16 +51,16 @@ echo "✅ Nixpacks build completed." >> ${logPath};
 			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 create --name ${buildContainerId} ${appName}
+	mkdir -p ${localPath}
+	docker cp ${buildContainerId}:/app/${publishDirectory}${isDirectory ? "/." : ""} ${path.join(buildAppDirectory, publishDirectory)} || {
+		docker rm ${buildContainerId}
+		echo "❌ Copying ${publishDirectory} to ${path.join(buildAppDirectory, publishDirectory)} failed" ;
+		exit 1;
+	}
 	docker rm ${buildContainerId}
-	echo "❌ Copying ${publishDirectory} to ${path.join(buildAppDirectory, publishDirectory)} failed" >> ${logPath};
-	exit 1;
-}
-docker rm ${buildContainerId}
-${getStaticCommand(application, logPath)}
-			`;
+	${getStaticCommand(application)}
+				`;
 	}
 
 	return bashCommand;

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

@@ -1,57 +1,12 @@
-import type { WriteStream } from "node:fs";
-import { prepareEnvironmentVariables } from "../docker/utils";
+import { prepareEnvironmentVariablesForShell } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
-import { spawnAsync } from "../process/spawnAsync";
 import type { ApplicationNested } from ".";
 
-export const buildPaketo = async (
-	application: ApplicationNested,
-	writeStream: WriteStream,
-) => {
-	const { env, appName, cleanCache } = application;
-	const buildAppDirectory = getBuildAppDirectory(application);
-	const envVariables = prepareEnvironmentVariables(
-		env,
-		application.environment.project.env,
-		application.environment.env,
-	);
-	try {
-		const args = [
-			"build",
-			appName,
-			"--path",
-			buildAppDirectory,
-			"--builder",
-			"paketobuildpacks/builder-jammy-full",
-		];
-
-		if (cleanCache) {
-			args.push("--clear-cache");
-		}
-
-		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,
-) => {
+export const getPaketoCommand = (application: ApplicationNested) => {
 	const { env, appName, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
-	const envVariables = prepareEnvironmentVariables(
+	const envVariables = prepareEnvironmentVariablesForShell(
 		env,
 		application.environment.project.env,
 		application.environment.env,
@@ -71,17 +26,17 @@ export const getPaketoCommand = (
 	}
 
 	for (const env of envVariables) {
-		args.push("--env", `'${env}'`);
+		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};
+echo "Starting Paketo build..." ;
+${command} || { 
+  echo "❌ Paketo build failed" ;
   exit 1;
 }
-echo "✅ Paketo build completed." >> ${logPath};
+echo "✅ Paketo build completed." ;
 		`;
 
 	return bashCommand;

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

@@ -1,13 +1,12 @@
 import { createHash } from "node:crypto";
-import type { WriteStream } from "node:fs";
 import { nanoid } from "nanoid";
+import { quote } from "shell-quote";
 import {
 	parseEnvironmentKeyValuePair,
 	prepareEnvironmentVariables,
+	prepareEnvironmentVariablesForShell,
 } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
-import { execAsync } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 import type { ApplicationNested } from ".";
 
 const calculateSecretsHash = (envVariables: string[]): string => {
@@ -18,111 +17,10 @@ const calculateSecretsHash = (envVariables: string[]): string => {
 	return hash.digest("hex");
 };
 
-export const buildRailpack = async (
-	application: ApplicationNested,
-	writeStream: WriteStream,
-) => {
+export const getRailpackCommand = (application: ApplicationNested) => {
 	const { env, appName, cleanCache } = application;
 	const buildAppDirectory = getBuildAppDirectory(application);
-	const envVariables = prepareEnvironmentVariables(
-		env,
-		application.environment.project.env,
-		application.environment.env,
-	);
-
-	try {
-		await execAsync(
-			"docker buildx create --use --name builder-containerd --driver docker-container || true",
-		);
-
-		await execAsync("docker buildx use builder-containerd");
-
-		// First prepare the build plan and info
-		const prepareArgs = [
-			"prepare",
-			buildAppDirectory,
-			"--plan-out",
-			`${buildAppDirectory}/railpack-plan.json`,
-			"--info-out",
-			`${buildAppDirectory}/railpack-info.json`,
-		];
-
-		// Add environment variables to prepare command
-		for (const env of envVariables) {
-			prepareArgs.push("--env", env);
-		}
-
-		// Run prepare command
-		await spawnAsync("railpack", prepareArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-
-		// Calculate secrets hash for layer invalidation
-		const secretsHash = calculateSecretsHash(envVariables);
-
-		// Build with BuildKit using the Railpack frontend
-		const cacheKey = cleanCache ? nanoid(10) : undefined;
-		const buildArgs = [
-			"buildx",
-			"build",
-			...(cacheKey
-				? [
-						"--build-arg",
-						`secrets-hash=${secretsHash}`,
-						"--build-arg",
-						`cache-key=${cacheKey}`,
-					]
-				: []),
-			"--build-arg",
-			`BUILDKIT_SYNTAX=ghcr.io/railwayapp/railpack-frontend:v${application.railpackVersion}`,
-			"-f",
-			`${buildAppDirectory}/railpack-plan.json`,
-			"--output",
-			`type=docker,name=${appName}`,
-		];
-
-		// Add secrets properly formatted
-		const env: { [key: string]: string } = {};
-		for (const pair of envVariables) {
-			const [key, value] = parseEnvironmentKeyValuePair(pair);
-			if (key && value) {
-				buildArgs.push("--secret", `id=${key},env=${key}`);
-				env[key] = value;
-			}
-		}
-
-		buildArgs.push(buildAppDirectory);
-
-		await spawnAsync(
-			"docker",
-			buildArgs,
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-			{
-				env: { ...process.env, ...env },
-			},
-		);
-
-		return true;
-	} catch (e) {
-		throw e;
-	} finally {
-		await execAsync("docker buildx rm builder-containerd");
-	}
-};
-
-export const getRailpackCommand = (
-	application: ApplicationNested,
-	logPath: string,
-) => {
-	const { env, appName, cleanCache } = application;
-	const buildAppDirectory = getBuildAppDirectory(application);
-	const envVariables = prepareEnvironmentVariables(
+	const envVariables = prepareEnvironmentVariablesForShell(
 		env,
 		application.environment.project.env,
 		application.environment.env,
@@ -139,7 +37,7 @@ export const getRailpackCommand = (
 	];
 
 	for (const env of envVariables) {
-		prepareArgs.push("--env", `'${env}'`);
+		prepareArgs.push("--env", env);
 	}
 
 	// Calculate secrets hash for layer invalidation
@@ -167,37 +65,49 @@ export const getRailpackCommand = (
 	];
 
 	// Add secrets properly formatted
+	// Use prepareEnvironmentVariables (without ForShell) to get raw values for parsing
+	const rawEnvVariables = prepareEnvironmentVariables(
+		env,
+		application.environment.project.env,
+		application.environment.env,
+	);
 	const exportEnvs = [];
-	for (const pair of envVariables) {
+	for (const pair of rawEnvVariables) {
 		const [key, value] = parseEnvironmentKeyValuePair(pair);
 		if (key && value) {
 			buildArgs.push("--secret", `id=${key},env=${key}`);
-			exportEnvs.push(`export ${key}='${value}'`);
+			exportEnvs.push(`export ${key}=${quote([value])}`);
 		}
 	}
 
 	buildArgs.push(buildAppDirectory);
 
 	const bashCommand = `
+
 # Ensure we have a builder with containerd
+
+export RAILPACK_VERSION=${application.railpackVersion}
+bash -c "$(curl -fsSL https://railpack.com/install.sh)"
 docker buildx create --use --name builder-containerd --driver docker-container || true
 docker buildx use builder-containerd
 
-echo "Preparing Railpack build plan..." >> "${logPath}";
-railpack ${prepareArgs.join(" ")} >> ${logPath} 2>> ${logPath} || { 
-	echo "❌ Railpack prepare failed" >> ${logPath};
+echo "Preparing Railpack build plan..." ;
+railpack ${prepareArgs.join(" ")} || { 
+	echo "❌ Railpack prepare failed" ;
+	docker buildx rm builder-containerd || true
 	exit 1;
 }
-echo "✅ Railpack prepare completed." >> ${logPath};
+echo "✅ Railpack prepare completed." ;
 
-echo "Building with Railpack frontend..." >> "${logPath}";
+echo "Building with Railpack frontend..." ;
 # Export environment variables for secrets
 ${exportEnvs.join("\n")}
-docker ${buildArgs.join(" ")} >> ${logPath} 2>> ${logPath} || { 
-	echo "❌ Railpack build failed" >> ${logPath};
+docker ${buildArgs.join(" ")} || { 
+	echo "❌ Railpack build failed" ;
+	docker buildx rm builder-containerd || true
 	exit 1;
 }
-echo "✅ Railpack build completed." >> ${logPath};
+echo "✅ Railpack build completed." ;
 docker buildx rm builder-containerd
 `;
 

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

@@ -1,9 +1,5 @@
-import type { WriteStream } from "node:fs";
-import {
-	buildCustomDocker,
-	getDockerCommand,
-} from "@dokploy/server/utils/builders/docker-file";
-import { createFile, getCreateFileCommand } from "../docker/utils";
+import { getDockerCommand } from "@dokploy/server/utils/builders/docker-file";
+import { getCreateFileCommand } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
 import type { ApplicationNested } from ".";
 
@@ -32,81 +28,40 @@ http {
 }
 `;
 
-export const buildStatic = async (
-	application: ApplicationNested,
-	writeStream: WriteStream,
-) => {
+export const getStaticCommand = (application: ApplicationNested) => {
 	const { publishDirectory, isStaticSpa } = application;
 	const buildAppDirectory = getBuildAppDirectory(application);
-
-	try {
-		if (isStaticSpa) {
-			createFile(buildAppDirectory, "nginx.conf", nginxSpaConfig);
-		}
-
-		createFile(
+	let command = "";
+	if (isStaticSpa) {
+		command += getCreateFileCommand(
 			buildAppDirectory,
-			".dockerignore",
-			[".git", ".env", "Dockerfile", ".dockerignore"].join("\n"),
+			"nginx.conf",
+			nginxSpaConfig,
 		);
-
-		createFile(
-			buildAppDirectory,
-			"Dockerfile",
-			[
-				"FROM nginx:alpine",
-				"WORKDIR /usr/share/nginx/html/",
-				isStaticSpa ? "COPY nginx.conf /etc/nginx/nginx.conf" : "",
-				`COPY ${publishDirectory || "."} .`,
-				'CMD ["nginx", "-g", "daemon off;"]',
-			].join("\n"),
-		);
-
-		createFile(
-			buildAppDirectory,
-			".dockerignore",
-			[".git", ".env", "Dockerfile", ".dockerignore"].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);
+	command += getCreateFileCommand(
+		buildAppDirectory,
+		".dockerignore",
+		[".git", ".env", "Dockerfile", ".dockerignore"].join("\n"),
+	);
 
-	let command = getCreateFileCommand(
+	command += getCreateFileCommand(
 		buildAppDirectory,
 		"Dockerfile",
 		[
 			"FROM nginx:alpine",
 			"WORKDIR /usr/share/nginx/html/",
+			isStaticSpa ? "COPY nginx.conf /etc/nginx/nginx.conf" : "",
 			`COPY ${publishDirectory || "."} .`,
+			'CMD ["nginx", "-g", "daemon off;"]',
 		].join("\n"),
 	);
 
-	command += getDockerCommand(
-		{
-			...application,
-			buildType: "dockerfile",
-			dockerfile: "Dockerfile",
-		},
-		logPath,
-	);
+	command += getDockerCommand({
+		...application,
+		buildType: "dockerfile",
+		dockerfile: "Dockerfile",
+	});
 	return command;
 };

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

@@ -1,25 +1,6 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { encodeBase64, prepareEnvironmentVariables } from "../docker/utils";
 
-export const createEnvFile = (
-	directory: string,
-	env: string | null,
-	projectEnv?: string | null,
-	environmentEnv?: string | null,
-) => {
-	const envFilePath = join(dirname(directory), ".env");
-	if (!existsSync(dirname(envFilePath))) {
-		mkdirSync(dirname(envFilePath), { recursive: true });
-	}
-	const envFileContent = prepareEnvironmentVariables(
-		env,
-		projectEnv,
-		environmentEnv,
-	).join("\n");
-	writeFileSync(envFilePath, envFileContent);
-};
-
 export const createEnvFileCommand = (
 	directory: string,
 	env: string | null,

packages/server/src/utils/cluster/upload.ts

@@ -1,106 +1,136 @@
-import type { WriteStream } from "node:fs";
+import { findAllDeploymentsByApplicationId } from "@dokploy/server/services/deployment";
+import type { Registry } from "@dokploy/server/services/registry";
+import { createRollback } from "@dokploy/server/services/rollbacks";
 import type { ApplicationNested } from "../builders";
-import { spawnAsync } from "../process/spawnAsync";
 
-export const uploadImage = async (
+export const uploadImageRemoteCommand = async (
 	application: ApplicationNested,
-	writeStream: WriteStream,
 ) => {
 	const registry = application.registry;
+	const buildRegistry = application.buildRegistry;
+	const rollbackRegistry = application.rollbackRegistry;
 
-	if (!registry) {
-		throw new Error("Registry not found");
+	if (!registry && !buildRegistry && !rollbackRegistry) {
+		throw new Error("No registry found");
 	}
 
-	const { registryUrl, imagePrefix, username } = registry;
 	const { appName } = application;
-	const imageName = `${appName}:latest`;
+	const imageName =
+		application.sourceType === "docker"
+			? application.dockerImage || ""
+			: `${appName}:latest`;
 
-	const finalURL = registryUrl;
+	const commands: string[] = [];
+	if (registry) {
+		const registryTag = getRegistryTag(registry, imageName);
+		if (registryTag) {
+			commands.push(`echo "📦 [Enabled Registry Swarm]"`);
+			commands.push(getRegistryCommands(registry, imageName, registryTag));
+		}
+	}
+	if (buildRegistry) {
+		const buildRegistryTag = getRegistryTag(buildRegistry, imageName);
+		if (buildRegistryTag) {
+			commands.push(`echo "🔑 [Enabled Build Registry]"`);
+			commands.push(
+				getRegistryCommands(buildRegistry, imageName, buildRegistryTag),
+			);
+			commands.push(
+				`echo "⚠️ INFO: After the build is finished, you need to wait a few seconds for the server to download the image and run the container."`,
+			);
+			commands.push(
+				`echo "📊 Check the Logs tab to see when the container starts running."`,
+			);
+		}
+	}
 
-	// Build registry tag in correct format: registry.com/owner/image:tag
-	// For ghcr.io: ghcr.io/username/image:tag
-	// For docker.io: docker.io/username/image:tag
-	const registryTag = imagePrefix
-		? `${registryUrl ? `${registryUrl}/` : ""}${imagePrefix}/${imageName}`
-		: `${registryUrl ? `${registryUrl}/` : ""}${username}/${imageName}`;
-
-	try {
-		writeStream.write(
-			`📦 [Enabled Registry] Uploading image to ${registry.registryType} | ${imageName} | ${finalURL} | ${registryTag}\n`,
+	if (rollbackRegistry && application.rollbackActive) {
+		const deployment = await findAllDeploymentsByApplicationId(
+			application.applicationId,
 		);
-		const loginCommand = spawnAsync(
-			"docker",
-			["login", finalURL, "-u", registry.username, "--password-stdin"],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
-		loginCommand.child?.stdin?.write(registry.password);
-		loginCommand.child?.stdin?.end();
-		await loginCommand;
-
-		await spawnAsync("docker", ["tag", imageName, registryTag], (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
+		if (!deployment || !deployment[0]) {
+			throw new Error("Deployment not found");
+		}
+		const deploymentId = deployment[0].deploymentId;
+		const rollback = await createRollback({
+			appName: appName,
+			deploymentId: deploymentId,
 		});
 
-		await spawnAsync("docker", ["push", registryTag], (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-	} catch (error) {
-		console.log(error);
-		throw error;
+		const rollbackRegistryTag = getRegistryTag(
+			rollbackRegistry,
+			rollback?.image || "",
+		);
+		if (rollbackRegistryTag) {
+			commands.push(`echo "🔄 [Enabled Rollback Registry]"`);
+			commands.push(
+				getRegistryCommands(rollbackRegistry, imageName, rollbackRegistryTag),
+			);
+		}
 	}
-};
-
-export const uploadImageRemoteCommand = (
-	application: ApplicationNested,
-	logPath: string,
-) => {
-	const registry = application.registry;
-
-	if (!registry) {
-		throw new Error("Registry not found");
-	}
-
-	const { registryUrl, imagePrefix, username } = registry;
-	const { appName } = application;
-	const imageName = `${appName}:latest`;
-
-	const finalURL = registryUrl;
-
-	// Build registry tag in correct format: registry.com/owner/image:tag
-	const registryTag = imagePrefix
-		? `${registryUrl}/${imagePrefix}/${imageName}`
-		: `${registryUrl}/${username}/${imageName}`;
-
 	try {
-		const command = `
-		echo "📦 [Enabled Registry] Uploading image to '${registry.registryType}' | '${registryTag}'" >> ${logPath};
-		echo "${registry.password}" | docker login ${finalURL} -u ${registry.username} --password-stdin >> ${logPath} 2>> ${logPath} || { 
-			echo "❌ DockerHub Failed" >> ${logPath};
-			exit 1;
-		}
-		echo "✅ Registry Login Success" >> ${logPath};
-		docker tag ${imageName} ${registryTag} >> ${logPath} 2>> ${logPath} || { 
-			echo "❌ Error tagging image" >> ${logPath};
-			exit 1;
-		}
-		echo "✅ Image Tagged" >> ${logPath};
-		docker push ${registryTag} 2>> ${logPath} || { 
-			echo "❌ Error pushing image" >> ${logPath};
-			exit 1;
-		}
-			echo "✅ Image Pushed" >> ${logPath};
-		`;
-		return command;
+		return commands.join("\n");
 	} catch (error) {
 		throw error;
 	}
 };
+/**
+ * Extract the repository name from imageName by taking the last part after '/'
+ * Examples:
+ * - "nginx" -> "nginx"
+ * - "nginx:latest" -> "nginx:latest"
+ * - "myuser/myrepo" -> "myrepo"
+ * - "myuser/myrepo:tag" -> "myrepo:tag"
+ * - "docker.io/myuser/myrepo" -> "myrepo"
+ */
+const extractRepositoryName = (imageName: string): string => {
+	const lastSlashIndex = imageName.lastIndexOf("/");
+
+	// If no '/', return the imageName as is
+	if (lastSlashIndex === -1) {
+		return imageName;
+	}
+
+	// Extract everything after the last '/'
+	return imageName.substring(lastSlashIndex + 1);
+};
+
+export const getRegistryTag = (registry: Registry, imageName: string) => {
+	const { registryUrl, imagePrefix, username } = registry;
+
+	// Extract the repository name (last part after '/')
+	const repositoryName = extractRepositoryName(imageName);
+
+	// Build the final tag using registry's username/prefix
+	const targetPrefix = imagePrefix || username;
+	const finalRegistry = registryUrl || "";
+
+	return finalRegistry
+		? `${finalRegistry}/${targetPrefix}/${repositoryName}`
+		: `${targetPrefix}/${repositoryName}`;
+};
+
+const getRegistryCommands = (
+	registry: Registry,
+	imageName: string,
+	registryTag: string,
+): string => {
+	return `
+echo "📦 [Enabled Registry] Uploading image to '${registry.registryType}' | '${registryTag}'" ;
+echo "${registry.password}" | docker login ${registry.registryUrl} -u '${registry.username}' --password-stdin || { 
+	echo "❌ DockerHub Failed" ;
+	exit 1;
+}
+echo "✅ Registry Login Success" ;
+docker tag ${imageName} ${registryTag} || { 
+	echo "❌ Error tagging image" ;
+	exit 1;
+}
+echo "✅ Image Tagged" ;
+docker push ${registryTag} || { 
+	echo "❌ Error pushing image" ;
+	exit 1;
+}
+	echo "✅ Image Pushed" ;
+`;
+};

packages/server/src/utils/crons/enterprise.ts

@@ -0,0 +1,68 @@
+import { getPublicIpWithFallback } from "@dokploy/server/wss/utils";
+import { and, eq, isNotNull } from "drizzle-orm";
+import { scheduleJob } from "node-schedule";
+import { db } from "../../db/index";
+import { user as userSchema } from "../../db/schema/user";
+
+export const LICENSE_KEY_URL =
+	// process.env.NODE_ENV === "development"
+	// 	? "http://localhost:4002"
+	"https://licenses-api.dokploy.com";
+
+export const initEnterpriseBackupCronJobs = async () => {
+	scheduleJob("enterprise-check", "0 0 */3 * *", async () => {
+		const users = await db.query.user.findMany({
+			where: and(
+				isNotNull(userSchema.licenseKey),
+				isNotNull(userSchema.enableEnterpriseFeatures),
+				eq(userSchema.isValidEnterpriseLicense, true),
+			),
+		});
+		for (const user of users) {
+			if (user.isValidEnterpriseLicense) {
+				console.log(
+					"Validating license key....",
+					user.firstName,
+					user.lastName,
+				);
+				try {
+					const isValid = await validateLicenseKey(user.licenseKey || "");
+					if (!isValid) {
+						throw new Error("License key is invalid");
+					}
+				} catch (error) {
+					await db
+						.update(userSchema)
+						.set({ isValidEnterpriseLicense: false })
+						.where(eq(userSchema.id, user.id));
+				}
+			}
+		}
+	});
+};
+
+export const validateLicenseKey = async (licenseKey: string) => {
+	try {
+		const ip = await getPublicIpWithFallback();
+		const result = await fetch(`${LICENSE_KEY_URL}/licenses/validate`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ licenseKey, ip }),
+		});
+
+		if (!result.ok) {
+			const errorData = await result.json().catch(() => ({}));
+			throw new Error(errorData.message || "Failed to validate license key");
+		}
+
+		const data = await result.json();
+		return data.valid;
+	} catch (error) {
+		console.error(
+			error instanceof Error ? error.message : "Failed to validate license key",
+		);
+		throw error;
+	}
+};

packages/server/src/utils/databases/libsql.ts

@@ -0,0 +1,155 @@
+import type { InferResultType } from "@dokploy/server/types/with";
+import type { CreateServiceOptions, PortConfig } from "dockerode";
+import {
+	calculateResources,
+	generateBindMounts,
+	generateConfigContainer,
+	generateFileMounts,
+	generateVolumeMounts,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import { getRemoteDocker } from "../servers/remote-docker";
+
+export type LibsqlNested = InferResultType<
+	"libsql",
+	{
+		mounts: true;
+		environment: { with: { project: true } };
+	}
+>;
+export const buildLibsql = async (libsql: LibsqlNested) => {
+	const {
+		appName,
+		env,
+		externalPort,
+		externalGRPCPort,
+		externalAdminPort,
+		memoryLimit,
+		memoryReservation,
+		databaseUser,
+		databasePassword,
+		sqldNode,
+		sqldPrimaryUrl,
+		cpuLimit,
+		cpuReservation,
+		command,
+		mounts,
+		enableNamespaces,
+	} = libsql;
+
+	const basicAuth = Buffer.from(
+		`${databaseUser}:${databasePassword}`,
+		"utf-8",
+	).toString("base64");
+
+	const defaultLibsqlEnv = `SQLD_NODE="${sqldNode}"\nSQLD_HTTP_AUTH="basic:${basicAuth}"${
+		env ? `\n${env}` : ""
+	}${sqldNode === "replica" ? `\nSQLD_PRIMARY_URL="${sqldPrimaryUrl}"` : ""}`;
+
+	const {
+		HealthCheck,
+		RestartPolicy,
+		Placement,
+		Labels,
+		Mode,
+		RollbackConfig,
+		UpdateConfig,
+		Networks,
+	} = generateConfigContainer(libsql);
+	const resources = calculateResources({
+		memoryLimit,
+		memoryReservation,
+		cpuLimit,
+		cpuReservation,
+	});
+	const envVariables = prepareEnvironmentVariables(
+		defaultLibsqlEnv,
+		libsql.environment.project.env,
+		libsql.environment.env,
+	);
+	const volumesMount = generateVolumeMounts(mounts);
+	const bindsMount = generateBindMounts(mounts);
+	const filesMount = generateFileMounts(appName, libsql);
+
+	const docker = await getRemoteDocker(libsql.serverId);
+
+	let finalCommand =
+		command ??
+		"sqld --db-path iku.db --http-listen-addr 0.0.0.0:8080 --grpc-listen-addr 0.0.0.0:5001 --admin-listen-addr 0.0.0.0:5000";
+	if (enableNamespaces) {
+		finalCommand += " --enable-namespaces";
+	}
+
+	const settings: CreateServiceOptions = {
+		Name: appName,
+		TaskTemplate: {
+			ContainerSpec: {
+				HealthCheck,
+				Image: "ghcr.io/tursodatabase/libsql-server:v0.24.32",
+				Env: envVariables,
+				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
+				...(finalCommand
+					? {
+							Command: ["/bin/sh"],
+							Args: ["-c", finalCommand],
+						}
+					: {}),
+				Labels,
+			},
+			Networks,
+			RestartPolicy,
+			Placement,
+			Resources: {
+				...resources,
+			},
+		},
+		Mode,
+		RollbackConfig,
+		EndpointSpec: {
+			Mode: "dnsrr",
+			Ports: [
+				...(externalPort
+					? [
+							{
+								Protocol: "tcp",
+								TargetPort: 8080,
+								PublishedPort: externalPort,
+								PublishMode: "host",
+							} as PortConfig,
+						]
+					: []),
+				...(externalGRPCPort
+					? [
+							{
+								Protocol: "tcp",
+								TargetPort: 5001,
+								PublishedPort: externalGRPCPort,
+								PublishMode: "host",
+							} as PortConfig,
+						]
+					: []),
+				...(externalAdminPort
+					? [
+							{
+								Protocol: "tcp",
+								TargetPort: 5000,
+								PublishedPort: externalAdminPort,
+								PublishMode: "host",
+							} as PortConfig,
+						]
+					: []),
+			],
+		},
+		UpdateConfig,
+	};
+	try {
+		const service = docker.getService(appName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+		});
+	} catch {
+		await docker.createService(settings);
+	}
+};

packages/server/src/utils/databases/mariadb.ts

@@ -29,6 +29,7 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 		cpuLimit,
 		cpuReservation,
 		command,
+		args,
 		mounts,
 	} = mariadb;
 
@@ -46,6 +47,8 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(mariadb);
 	const resources = calculateResources({
 		memoryLimit,
@@ -72,12 +75,16 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				...(command
-					? {
-							Command: ["/bin/sh"],
-							Args: ["-c", command],
-						}
-					: {}),
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
+				...(command && {
+					Command: command.split(" "),
+				}),
+				...(args &&
+					args.length > 0 && {
+						Args: args,
+					}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -89,22 +96,22 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Mode: "dnsrr",
-			Ports: externalPort
-				? [
-						{
-							Protocol: "tcp",
-							TargetPort: 3306,
-							PublishedPort: externalPort,
-							PublishMode: "host",
-						},
-					]
-				: [],
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Mode: "dnsrr" as const,
+					Ports: externalPort
+						? [
+								{
+									Protocol: "tcp" as const,
+									TargetPort: 3306,
+									PublishedPort: externalPort,
+									PublishMode: "host" as const,
+								},
+							]
+						: [],
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 	try {
 		const service = docker.getService(appName);

packages/server/src/utils/databases/mongo.ts

@@ -28,6 +28,7 @@ export const buildMongo = async (mongo: MongoNested) => {
 		databaseUser,
 		databasePassword,
 		command,
+		args,
 		mounts,
 		replicaSets,
 	} = mongo;
@@ -53,7 +54,7 @@ if [ "$REPLICA_STATUS" != "1" ]; then
 	mongosh --eval '
 	rs.initiate({
 		_id: "rs0",
-		members: [{ _id: 0, host: "localhost:27017", priority: 1 }]
+		members: [{ _id: 0, host: "${appName}:27017", priority: 1 }]
 	});
 
     // Wait for the replica set to initialize
@@ -92,6 +93,8 @@ ${command ?? "wait $MONGOD_PID"}`;
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(mongo);
 
 	const resources = calculateResources({
@@ -120,17 +123,24 @@ ${command ?? "wait $MONGOD_PID"}`;
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
 				...(replicaSets
 					? {
 							Command: ["/bin/bash"],
 							Args: ["-c", startupScript],
 						}
-					: {
-							...(command && {
-								Command: ["/bin/bash"],
-								Args: ["-c", command],
-							}),
-						}),
+					: {}),
+				...(command &&
+					!replicaSets && {
+						Command: command.split(" "),
+					}),
+				...(args &&
+					args.length > 0 &&
+					!replicaSets && {
+						Args: args,
+					}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -142,22 +152,22 @@ ${command ?? "wait $MONGOD_PID"}`;
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Mode: "dnsrr",
-			Ports: externalPort
-				? [
-						{
-							Protocol: "tcp",
-							TargetPort: 27017,
-							PublishedPort: externalPort,
-							PublishMode: "host",
-						},
-					]
-				: [],
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Mode: "dnsrr" as const,
+					Ports: externalPort
+						? [
+								{
+									Protocol: "tcp" as const,
+									TargetPort: 27017,
+									PublishedPort: externalPort,
+									PublishMode: "host" as const,
+								},
+							]
+						: [],
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 
 	try {

packages/server/src/utils/databases/mysql.ts

@@ -30,6 +30,7 @@ export const buildMysql = async (mysql: MysqlNested) => {
 		cpuLimit,
 		cpuReservation,
 		command,
+		args,
 		mounts,
 	} = mysql;
 
@@ -52,6 +53,8 @@ export const buildMysql = async (mysql: MysqlNested) => {
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(mysql);
 	const resources = calculateResources({
 		memoryLimit,
@@ -78,12 +81,16 @@ export const buildMysql = async (mysql: MysqlNested) => {
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				...(command
-					? {
-							Command: ["/bin/sh"],
-							Args: ["-c", command],
-						}
-					: {}),
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
+				...(command && {
+					Command: command.split(" "),
+				}),
+				...(args &&
+					args.length > 0 && {
+						Args: args,
+					}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -95,22 +102,22 @@ export const buildMysql = async (mysql: MysqlNested) => {
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Mode: "dnsrr",
-			Ports: externalPort
-				? [
-						{
-							Protocol: "tcp",
-							TargetPort: 3306,
-							PublishedPort: externalPort,
-							PublishMode: "host",
-						},
-					]
-				: [],
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Mode: "dnsrr" as const,
+					Ports: externalPort
+						? [
+								{
+									Protocol: "tcp" as const,
+									TargetPort: 3306,
+									PublishedPort: externalPort,
+									PublishMode: "host" as const,
+								},
+							]
+						: [],
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 	try {
 		const service = docker.getService(appName);

packages/server/src/utils/databases/postgres.ts

@@ -28,6 +28,7 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 		databaseUser,
 		databasePassword,
 		command,
+		args,
 		mounts,
 	} = postgres;
 
@@ -45,6 +46,8 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(postgres);
 	const resources = calculateResources({
 		memoryLimit,
@@ -71,12 +74,16 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				...(command
-					? {
-							Command: ["/bin/sh"],
-							Args: ["-c", command],
-						}
-					: {}),
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
+				...(command && {
+					Command: command.split(" "),
+				}),
+				...(args &&
+					args.length > 0 && {
+						Args: args,
+					}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -88,22 +95,22 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Mode: "dnsrr",
-			Ports: externalPort
-				? [
-						{
-							Protocol: "tcp",
-							TargetPort: 5432,
-							PublishedPort: externalPort,
-							PublishMode: "host",
-						},
-					]
-				: [],
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Mode: "dnsrr" as const,
+					Ports: externalPort
+						? [
+								{
+									Protocol: "tcp" as const,
+									TargetPort: 5432,
+									PublishedPort: externalPort,
+									PublishMode: "host" as const,
+								},
+							]
+						: [],
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 	try {
 		const service = docker.getService(appName);

packages/server/src/utils/databases/rebuild.ts

@@ -1,11 +1,13 @@
 import { db } from "@dokploy/server/db";
 import {
+	libsql,
 	mariadb,
 	mongo,
 	mysql,
 	postgres,
 	redis,
 } from "@dokploy/server/db/schema";
+import { deployLibsql } from "@dokploy/server/services/libsql";
 import { deployMariadb } from "@dokploy/server/services/mariadb";
 import { deployMongo } from "@dokploy/server/services/mongo";
 import { deployMySql } from "@dokploy/server/services/mysql";
@@ -15,7 +17,13 @@ import { eq } from "drizzle-orm";
 import { removeService } from "../docker/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 
-type DatabaseType = "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
+type DatabaseType =
+	| "libsql"
+	| "mariadb"
+	| "mongo"
+	| "mysql"
+	| "postgres"
+	| "redis";
 
 export const rebuildDatabase = async (
 	databaseId: string,
@@ -41,31 +49,25 @@ export const rebuildDatabase = async (
 		}
 	}
 
-	if (type === "postgres") {
-		await deployPostgres(databaseId);
-	} else if (type === "mysql") {
-		await deployMySql(databaseId);
+	if (type === "libsql") {
+		await deployLibsql(databaseId);
 	} else if (type === "mariadb") {
 		await deployMariadb(databaseId);
 	} else if (type === "mongo") {
 		await deployMongo(databaseId);
+	} else if (type === "mysql") {
+		await deployMySql(databaseId);
+	} else if (type === "postgres") {
+		await deployPostgres(databaseId);
 	} else if (type === "redis") {
 		await deployRedis(databaseId);
 	}
 };
 
 const findDatabaseById = async (databaseId: string, type: DatabaseType) => {
-	if (type === "postgres") {
-		return await db.query.postgres.findFirst({
-			where: eq(postgres.postgresId, databaseId),
-			with: {
-				mounts: true,
-			},
-		});
-	}
-	if (type === "mysql") {
-		return await db.query.mysql.findFirst({
-			where: eq(mysql.mysqlId, databaseId),
+	if (type === "libsql") {
+		return await db.query.libsql.findFirst({
+			where: eq(libsql.libsqlId, databaseId),
 			with: {
 				mounts: true,
 			},
@@ -87,6 +89,22 @@ const findDatabaseById = async (databaseId: string, type: DatabaseType) => {
 			},
 		});
 	}
+	if (type === "mysql") {
+		return await db.query.mysql.findFirst({
+			where: eq(mysql.mysqlId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+	if (type === "postgres") {
+		return await db.query.postgres.findFirst({
+			where: eq(postgres.postgresId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
 	if (type === "redis") {
 		return await db.query.redis.findFirst({
 			where: eq(redis.redisId, databaseId),

packages/server/src/utils/databases/redis.ts

@@ -26,6 +26,7 @@ export const buildRedis = async (redis: RedisNested) => {
 		cpuLimit,
 		cpuReservation,
 		command,
+		args,
 		mounts,
 	} = redis;
 
@@ -43,6 +44,8 @@ export const buildRedis = async (redis: RedisNested) => {
 		UpdateConfig,
 		Networks,
 		StopGracePeriod,
+		EndpointSpec,
+		Ulimits,
 	} = generateConfigContainer(redis);
 	const resources = calculateResources({
 		memoryLimit,
@@ -69,11 +72,23 @@ export const buildRedis = async (redis: RedisNested) => {
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				Command: ["/bin/sh"],
-				Args: [
-					"-c",
-					command ? command : `redis-server --requirepass ${databasePassword}`,
-				],
+				...(StopGracePeriod !== null &&
+					StopGracePeriod !== undefined && { StopGracePeriod }),
+				...(command || args
+					? {
+							...(command && {
+								Command: command.split(" "),
+							}),
+							...(args &&
+								args.length > 0 && {
+									Args: args,
+								}),
+						}
+					: {
+							Command: ["/bin/sh"],
+							Args: ["-c", `redis-server --requirepass ${databasePassword}`],
+						}),
+				...(Ulimits && { Ulimits }),
 				Labels,
 			},
 			Networks,
@@ -85,22 +100,22 @@ export const buildRedis = async (redis: RedisNested) => {
 		},
 		Mode,
 		RollbackConfig,
-		EndpointSpec: {
-			Mode: "dnsrr",
-			Ports: externalPort
-				? [
-						{
-							Protocol: "tcp",
-							TargetPort: 6379,
-							PublishedPort: externalPort,
-							PublishMode: "host",
-						},
-					]
-				: [],
-		},
+		EndpointSpec: EndpointSpec
+			? EndpointSpec
+			: {
+					Mode: "dnsrr" as const,
+					Ports: externalPort
+						? [
+								{
+									Protocol: "tcp" as const,
+									TargetPort: 6379,
+									PublishedPort: externalPort,
+									PublishMode: "host" as const,
+								},
+							]
+						: [],
+				},
 		UpdateConfig,
-		...(StopGracePeriod !== undefined &&
-			StopGracePeriod !== null && { StopGracePeriod }),
 	};
 
 	try {

packages/server/src/utils/docker/collision.ts

@@ -1,11 +1,11 @@
 import { findComposeById } from "@dokploy/server/services/compose";
 import { stringify } from "yaml";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { addAppNameToAllServiceNames } from "./collision/root-network";
 import { generateRandomHash } from "./compose";
 import { addSuffixToAllVolumes } from "./compose/volume";
 import {
 	cloneCompose,
-	cloneComposeRemote,
 	loadDockerCompose,
 	loadDockerComposeRemote,
 } from "./domain";
@@ -31,10 +31,11 @@ export const randomizeIsolatedDeploymentComposeFile = async (
 ) => {
 	const compose = await findComposeById(composeId);
 
+	const command = await cloneCompose(compose);
 	if (compose.serverId) {
-		await cloneComposeRemote(compose);
+		await execAsyncRemote(compose.serverId, command);
 	} else {
-		await cloneCompose(compose);
+		await execAsync(command);
 	}
 
 	let composeData: ComposeSpecification | null;

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

@@ -18,7 +18,9 @@ export const randomizeComposeFile = async (
 ) => {
 	const compose = await findComposeById(composeId);
 	const composeFile = compose.composeFile;
-	const composeData = parse(composeFile) as ComposeSpecification;
+	const composeData = parse(composeFile, {
+		maxAliasCount: 10000,
+	}) as ComposeSpecification;
 
 	const randomSuffix = suffix || generateRandomHash();
 

packages/server/src/utils/docker/domain.ts

@@ -1,35 +1,16 @@
 import fs, { existsSync, readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { Compose } from "@dokploy/server/services/compose";
 import type { Domain } from "@dokploy/server/services/domain";
 import { parse, stringify } from "yaml";
 import { execAsyncRemote } from "../process/execAsync";
-import {
-	cloneRawBitbucketRepository,
-	cloneRawBitbucketRepositoryRemote,
-} from "../providers/bitbucket";
-import {
-	cloneGitRawRepository,
-	cloneRawGitRepositoryRemote,
-} from "../providers/git";
-import {
-	cloneRawGiteaRepository,
-	cloneRawGiteaRepositoryRemote,
-} from "../providers/gitea";
-import {
-	cloneRawGithubRepository,
-	cloneRawGithubRepositoryRemote,
-} from "../providers/github";
-import {
-	cloneRawGitlabRepository,
-	cloneRawGitlabRepositoryRemote,
-} from "../providers/gitlab";
-import {
-	createComposeFileRaw,
-	createComposeFileRawRemote,
-} from "../providers/raw";
+import { cloneBitbucketRepository } from "../providers/bitbucket";
+import { cloneGitRepository } from "../providers/git";
+import { cloneGiteaRepository } from "../providers/gitea";
+import { cloneGithubRepository } from "../providers/github";
+import { cloneGitlabRepository } from "../providers/gitlab";
+import { getCreateComposeFileCommand } from "../providers/raw";
 import { randomizeDeployableSpecificationFile } from "./collision";
 import { randomizeSpecificationFile } from "./compose";
 import type {
@@ -40,35 +21,25 @@ import type {
 import { encodeBase64 } from "./utils";
 
 export const cloneCompose = async (compose: Compose) => {
+	let command = "set -e;";
+	const entity = {
+		...compose,
+		type: "compose" as const,
+	};
 	if (compose.sourceType === "github") {
-		await cloneRawGithubRepository(compose);
+		command += await cloneGithubRepository(entity);
 	} else if (compose.sourceType === "gitlab") {
-		await cloneRawGitlabRepository(compose);
+		command += await cloneGitlabRepository(entity);
 	} else if (compose.sourceType === "bitbucket") {
-		await cloneRawBitbucketRepository(compose);
+		command += await cloneBitbucketRepository(entity);
 	} else if (compose.sourceType === "git") {
-		await cloneGitRawRepository(compose);
+		command += await cloneGitRepository(entity);
 	} else if (compose.sourceType === "gitea") {
-		await cloneRawGiteaRepository(compose);
+		command += await cloneGiteaRepository(entity);
 	} else if (compose.sourceType === "raw") {
-		await createComposeFileRaw(compose);
-	}
-};
-
-export const cloneComposeRemote = async (compose: Compose) => {
-	if (compose.sourceType === "github") {
-		await cloneRawGithubRepositoryRemote(compose);
-	} else if (compose.sourceType === "gitlab") {
-		await cloneRawGitlabRepositoryRemote(compose);
-	} else if (compose.sourceType === "bitbucket") {
-		await cloneRawBitbucketRepositoryRemote(compose);
-	} else if (compose.sourceType === "git") {
-		await cloneRawGitRepositoryRemote(compose);
-	} else if (compose.sourceType === "gitea") {
-		await cloneRawGiteaRepositoryRemote(compose);
-	} else if (compose.sourceType === "raw") {
-		await createComposeFileRawRemote(compose);
+		command += getCreateComposeFileCommand(compose);
 	}
+	return command;
 };
 
 export const getComposePath = (compose: Compose) => {
@@ -92,7 +63,9 @@ export const loadDockerCompose = async (
 
 	if (existsSync(path)) {
 		const yamlStr = readFileSync(path, "utf8");
-		const parsedConfig = parse(yamlStr) as ComposeSpecification;
+		const parsedConfig = parse(yamlStr, {
+			maxAliasCount: 10000,
+		}) as ComposeSpecification;
 		return parsedConfig;
 	}
 	return null;
@@ -115,7 +88,9 @@ export const loadDockerComposeRemote = async (
 			return null;
 		}
 		if (!stdout) return null;
-		const parsedConfig = parse(stdout) as ComposeSpecification;
+		const parsedConfig = parse(stdout, {
+			maxAliasCount: 10000,
+		}) as ComposeSpecification;
 		return parsedConfig;
 	} catch {
 		return null;
@@ -135,52 +110,27 @@ export const writeDomainsToCompose = async (
 	compose: Compose,
 	domains: Domain[],
 ) => {
-	if (!domains.length) {
-		return;
-	}
-	const composeConverted = await addDomainToCompose(compose, domains);
-
-	const path = getComposePath(compose);
-	const composeString = stringify(composeConverted, { lineWidth: 1000 });
-	try {
-		await writeFile(path, composeString, "utf8");
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const writeDomainsToComposeRemote = async (
-	compose: Compose,
-	domains: Domain[],
-	logPath: string,
-) => {
-	if (!domains.length) {
-		return "";
-	}
-
 	try {
 		const composeConverted = await addDomainToCompose(compose, domains);
 		const path = getComposePath(compose);
 
 		if (!composeConverted) {
 			return `
-echo "❌ Error: Compose file not found" >> ${logPath};
+echo "❌ Error: Compose file not found";
 exit 1;
 			`;
 		}
-		if (compose.serverId) {
-			const composeString = stringify(composeConverted, { lineWidth: 1000 });
-			const encodedContent = encodeBase64(composeString);
-			return `echo "${encodedContent}" | base64 -d > "${path}";`;
-		}
+
+		const composeString = stringify(composeConverted, { lineWidth: 1000 });
+		const encodedContent = encodeBase64(composeString);
+		return `echo "${encodedContent}" | base64 -d > "${path}";`;
 	} catch (error) {
 		// @ts-ignore
-		return `echo "❌ Has occured an error: ${error?.message || error}" >> ${logPath};
+		return `echo "❌ Has occurred an error: ${error?.message || error}";
 exit 1;
 		`;
 	}
 };
-// (node:59875) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 SIGTERM listeners added to [process]. Use emitter.setMaxListeners() to increase limit
 export const addDomainToCompose = async (
 	compose: Compose,
 	domains: Domain[],
@@ -190,12 +140,12 @@ export const addDomainToCompose = async (
 	let result: ComposeSpecification | null;
 
 	if (compose.serverId) {
-		result = await loadDockerComposeRemote(compose); // aca hay que ir al servidor e ir a traer el compose file al servidor
+		result = await loadDockerComposeRemote(compose);
 	} else {
 		result = await loadDockerCompose(compose);
 	}
 
-	if (!result || domains.length === 0) {
+	if (!result) {
 		return null;
 	}
 
@@ -214,10 +164,12 @@ export const addDomainToCompose = async (
 	for (const domain of domains) {
 		const { serviceName, https } = domain;
 		if (!serviceName) {
-			throw new Error("Service name not found");
+			throw new Error(`Domain "${domain.host}" is missing a service name`);
 		}
 		if (!result?.services?.[serviceName]) {
-			throw new Error(`The service ${serviceName} not found in the compose`);
+			throw new Error(
+				`Domain "${domain.host}" is attached to service "${serviceName}" which does not exist in the compose`,
+			);
 		}
 
 		const httpLabels = createDomainLabels(appName, domain, "web");
@@ -380,6 +332,7 @@ export const addDokployNetworkToService = (
 ) => {
 	let networks = networkService;
 	const network = "dokploy-network";
+	const defaultNetwork = "default";
 	if (!networks) {
 		networks = [];
 	}
@@ -388,10 +341,16 @@ export const addDokployNetworkToService = (
 		if (!networks.includes(network)) {
 			networks.push(network);
 		}
+		if (!networks.includes(defaultNetwork)) {
+			networks.push(defaultNetwork);
+		}
 	} else if (networks && typeof networks === "object") {
 		if (!(network in networks)) {
 			networks[network] = {};
 		}
+		if (!(defaultNetwork in networks)) {
+			networks[defaultNetwork] = {};
+		}
 	}
 
 	return networks;

packages/server/src/utils/docker/utils.ts

@@ -5,7 +5,9 @@ import { docker, paths } from "@dokploy/server/constants";
 import type { Compose } from "@dokploy/server/services/compose";
 import type { ContainerInfo, ResourceRequirements } from "dockerode";
 import { parse } from "dotenv";
+import { quote } from "shell-quote";
 import type { ApplicationNested } from "../builders";
+import type { LibsqlNested } from "../databases/libsql";
 import type { MariadbNested } from "../databases/mariadb";
 import type { MongoNested } from "../databases/mongo";
 import type { MysqlNested } from "../databases/mysql";
@@ -143,81 +145,177 @@ export const getContainerByName = (name: string): Promise<ContainerInfo> => {
 		});
 	});
 };
-export const cleanUpUnusedImages = async (serverId?: string) => {
+
+/**
+ * Docker commands sent using this method are held in a hold when Docker is busy.
+ *
+ * https://github.com/Dokploy/dokploy/pull/3064
+ */
+export const dockerSafeExec = (exec: string) => `
+CHECK_INTERVAL=10
+
+echo "Preparing for execution..."
+
+while true; do
+    PROCESSES=$(ps aux | grep -E "^.*docker [A-Za-z]" | grep -v grep)
+
+    if [ -z "$PROCESSES" ]; then
+        echo "Docker is idle. Starting execution..."
+        break
+    else
+        echo "Docker is busy. Will check again in $CHECK_INTERVAL seconds..."
+        sleep $CHECK_INTERVAL
+    fi
+done
+
+${exec}
+
+echo "Execution completed."
+`;
+
+const cleanupCommands = {
+	containers: "docker container prune --force",
+	images: "docker image prune --all --force",
+	volumes: "docker volume prune --all --force",
+	builders: "docker builder prune --all --force",
+	system: "docker system prune --all --force",
+};
+
+export const cleanupContainers = async (serverId?: string) => {
 	try {
-		const command = "docker image prune --force";
+		const command = cleanupCommands.containers;
+
 		if (serverId) {
-			await execAsyncRemote(serverId, command);
+			await execAsyncRemote(serverId, dockerSafeExec(command));
 		} else {
-			await execAsync(command);
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
 		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanStoppedContainers = async (serverId?: string) => {
+export const cleanupImages = async (serverId?: string) => {
 	try {
-		const command = "docker container prune --force";
+		const command = cleanupCommands.images;
+
 		if (serverId) {
-			await execAsyncRemote(serverId, command);
+			await execAsyncRemote(serverId, dockerSafeExec(command));
+		} else await execAsync(dockerSafeExec(command));
+	} catch (error) {
+		console.error(error);
+
+		throw error;
+	}
+};
+
+export const cleanupVolumes = async (serverId?: string) => {
+	try {
+		const command = cleanupCommands.volumes;
+
+		if (serverId) {
+			await execAsyncRemote(serverId, dockerSafeExec(command));
 		} else {
-			await execAsync(command);
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
 		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanUpUnusedVolumes = async (serverId?: string) => {
+export const cleanupBuilders = async (serverId?: string) => {
 	try {
-		const command = "docker volume prune --force";
+		const command = cleanupCommands.builders;
+
 		if (serverId) {
-			await execAsyncRemote(serverId, command);
+			await execAsyncRemote(serverId, dockerSafeExec(command));
 		} else {
-			await execAsync(command);
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
 		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanUpInactiveContainers = async () => {
+export const cleanupSystem = async (serverId?: string) => {
 	try {
-		const containers = await docker.listContainers({ all: true });
-		const inactiveContainers = containers.filter(
-			(container) => container.State !== "running",
-		);
+		const command = cleanupCommands.system;
 
-		for (const container of inactiveContainers) {
-			await docker.getContainer(container.Id).remove({ force: true });
-			console.log(`Cleaning up inactive container: ${container.Id}`);
+		if (serverId) {
+			await execAsyncRemote(serverId, dockerSafeExec(command));
+		} else {
+			await execAsync(dockerSafeExec(command));
 		}
 	} catch (error) {
-		console.error("Error cleaning up inactive containers:", error);
+		console.error(error);
+
 		throw error;
 	}
 };
 
-export const cleanUpDockerBuilder = async (serverId?: string) => {
-	const command = "docker builder prune --all --force";
-	if (serverId) {
-		await execAsyncRemote(serverId, command);
-	} else {
-		await execAsync(command);
+/**
+ * Volume cleanup should always be performed manually by the user. The reason is that during automatic cleanup, a volume may be deleted due to a stopped container, which is a dangerous situation.
+ *
+ * https://github.com/Dokploy/dokploy/pull/3267
+ */
+const excludedCleanupAllCommands: (keyof typeof cleanupCommands)[] = [
+	"volumes",
+];
+
+export const cleanupAll = async (serverId?: string) => {
+	for (const [key, command] of Object.entries(cleanupCommands) as [
+		keyof typeof cleanupCommands,
+		string,
+	][]) {
+		if (excludedCleanupAllCommands.includes(key)) continue;
+
+		try {
+			if (serverId) {
+				await execAsyncRemote(serverId, dockerSafeExec(command));
+			} else {
+				await execAsync(dockerSafeExec(command));
+			}
+		} catch {}
 	}
 };
 
-export const cleanUpSystemPrune = async (serverId?: string) => {
-	const command = "docker system prune --force --volumes";
-	if (serverId) {
-		await execAsyncRemote(serverId, command);
-	} else {
-		await execAsync(command);
-	}
+export const cleanupAllBackground = async (serverId?: string) => {
+	Promise.allSettled(
+		(
+			Object.entries(cleanupCommands) as [
+				keyof typeof cleanupCommands,
+				string,
+			][]
+		)
+			.filter(([key]) => !excludedCleanupAllCommands.includes(key))
+			.map(async ([, command]) => {
+				if (serverId) {
+					await execAsyncRemote(serverId, dockerSafeExec(command));
+				} else {
+					await execAsync(dockerSafeExec(command));
+				}
+			}),
+	)
+		.then((results) => {
+			const failed = results.filter((r) => r.status === "rejected");
+			if (failed.length > 0) {
+				console.error(`Docker cleanup: ${failed.length} operations failed`);
+			} else {
+				console.log("Docker cleanup completed successfully");
+			}
+		})
+		.catch((error) => console.error("Error in cleanup:", error));
+
+	return {
+		status: "scheduled",
+		message: "Docker cleanup has been initiated in the background",
+	};
 };
 
 export const startService = async (appName: string) => {
@@ -310,6 +408,21 @@ export const prepareEnvironmentVariables = (
 	return resolvedVars;
 };
 
+export const prepareEnvironmentVariablesForShell = (
+	serviceEnv: string | null,
+	projectEnv?: string | null,
+	environmentEnv?: string | null,
+): string[] => {
+	const envVars = prepareEnvironmentVariables(
+		serviceEnv,
+		projectEnv,
+		environmentEnv,
+	);
+	// Using shell-quote library to properly escape shell arguments
+	// This is the standard way to handle special characters in shell commands
+	return envVars.map((env) => quote([env]));
+};
+
 export const parseEnvironmentKeyValuePair = (
 	pair: string,
 ): [string, string] => {
@@ -395,6 +508,8 @@ export const generateConfigContainer = (
 		mounts,
 		networkSwarm,
 		stopGracePeriodSwarm,
+		endpointSpecSwarm,
+		ulimitsSwarm,
 	} = application;
 
 	const sanitizedStopGracePeriodSwarm =
@@ -408,11 +523,9 @@ export const generateConfigContainer = (
 		...(healthCheckSwarm && {
 			HealthCheck: healthCheckSwarm,
 		}),
-		...(restartPolicySwarm
-			? {
-					RestartPolicy: restartPolicySwarm,
-				}
-			: {}),
+		...(restartPolicySwarm && {
+			RestartPolicy: restartPolicySwarm,
+		}),
 		...(placementSwarm
 			? {
 					Placement: placementSwarm,
@@ -461,6 +574,22 @@ export const generateConfigContainer = (
 			: {
 					Networks: [{ Target: "dokploy-network" }],
 				}),
+		...(endpointSpecSwarm && {
+			EndpointSpec: {
+				...(endpointSpecSwarm.Mode && { Mode: endpointSpecSwarm.Mode }),
+				Ports:
+					endpointSpecSwarm.Ports?.map((port) => ({
+						Protocol: (port.Protocol || "tcp") as "tcp" | "udp" | "sctp",
+						TargetPort: port.TargetPort || 0,
+						PublishedPort: port.PublishedPort || 0,
+						PublishMode: (port.PublishMode || "host") as "ingress" | "host",
+					})) || [],
+			},
+		}),
+		...(ulimitsSwarm &&
+			ulimitsSwarm.length > 0 && {
+				Ulimits: ulimitsSwarm,
+			}),
 	};
 };
 
@@ -482,6 +611,7 @@ export const generateFileMounts = (
 	appName: string,
 	service:
 		| ApplicationNested
+		| LibsqlNested
 		| MongoNested
 		| MariadbNested
 		| MysqlNested
@@ -613,3 +743,177 @@ export const getComposeContainer = async (
 		throw error;
 	}
 };
+
+type ServiceHealthStatus = {
+	status: "healthy" | "unhealthy";
+	message?: string;
+};
+
+const checkSwarmServiceRunning = async (
+	serviceName: string,
+): Promise<ServiceHealthStatus> => {
+	try {
+		const service = docker.getService(serviceName);
+		const info = await service.inspect();
+		const replicas = info.Spec?.Mode?.Replicated?.Replicas ?? 0;
+		if (replicas === 0) {
+			return {
+				status: "unhealthy",
+				message: "Service has 0 replicas configured",
+			};
+		}
+
+		// Check that at least one task is actually running
+		const tasks = await docker.listTasks({
+			filters: JSON.stringify({
+				service: [serviceName],
+				"desired-state": ["running"],
+			}),
+		});
+
+		const runningTask = tasks.find((t) => t.Status?.State === "running");
+
+		if (!runningTask) {
+			const latestTask = tasks[0];
+			const taskState = latestTask?.Status?.State ?? "unknown";
+			return {
+				status: "unhealthy",
+				message: `No running tasks (current state: ${taskState})`,
+			};
+		}
+
+		return { status: "healthy" };
+	} catch (error) {
+		return {
+			status: "unhealthy",
+			message: error instanceof Error ? error.message : "Service not found",
+		};
+	}
+};
+
+const getSwarmServiceContainerId = async (
+	serviceName: string,
+): Promise<string | null> => {
+	try {
+		const tasks = await docker.listTasks({
+			filters: JSON.stringify({
+				service: [serviceName],
+				"desired-state": ["running"],
+			}),
+		});
+
+		const runningTask = tasks.find((t) => t.Status?.State === "running");
+
+		return runningTask?.Status?.ContainerStatus?.ContainerID ?? null;
+	} catch {
+		return null;
+	}
+};
+
+export const checkPostgresHealth = async (): Promise<ServiceHealthStatus> => {
+	const serviceCheck = await checkSwarmServiceRunning("dokploy-postgres");
+	if (serviceCheck.status === "unhealthy") {
+		return serviceCheck;
+	}
+
+	// Verify PostgreSQL actually accepts connections
+	const containerId = await getSwarmServiceContainerId("dokploy-postgres");
+	if (!containerId) {
+		return { status: "unhealthy", message: "Could not find running container" };
+	}
+
+	try {
+		const exec = await docker.getContainer(containerId).exec({
+			Cmd: ["pg_isready", "-U", "dokploy"],
+			AttachStdout: true,
+			AttachStderr: true,
+		});
+		const stream = await exec.start({});
+
+		const output = await new Promise<string>((resolve) => {
+			let data = "";
+			stream.on("data", (chunk: Buffer) => {
+				data += chunk.toString();
+			});
+			stream.on("end", () => resolve(data));
+		});
+
+		const inspectResult = await exec.inspect();
+		if (inspectResult.ExitCode !== 0) {
+			return {
+				status: "unhealthy",
+				message: `PostgreSQL not ready: ${output.trim()}`,
+			};
+		}
+
+		return { status: "healthy" };
+	} catch (error) {
+		return {
+			status: "unhealthy",
+			message:
+				error instanceof Error ? error.message : "Failed to check PostgreSQL",
+		};
+	}
+};
+
+export const checkRedisHealth = async (): Promise<ServiceHealthStatus> => {
+	const serviceCheck = await checkSwarmServiceRunning("dokploy-redis");
+	if (serviceCheck.status === "unhealthy") {
+		return serviceCheck;
+	}
+
+	// Verify Redis actually responds to PING
+	const containerId = await getSwarmServiceContainerId("dokploy-redis");
+	if (!containerId) {
+		return { status: "unhealthy", message: "Could not find running container" };
+	}
+
+	try {
+		const exec = await docker.getContainer(containerId).exec({
+			Cmd: ["redis-cli", "ping"],
+			AttachStdout: true,
+			AttachStderr: true,
+		});
+		const stream = await exec.start({});
+
+		const output = await new Promise<string>((resolve) => {
+			let data = "";
+			stream.on("data", (chunk: Buffer) => {
+				data += chunk.toString();
+			});
+			stream.on("end", () => resolve(data));
+		});
+
+		if (!output.includes("PONG")) {
+			return {
+				status: "unhealthy",
+				message: `Redis did not respond with PONG: ${output.trim()}`,
+			};
+		}
+
+		return { status: "healthy" };
+	} catch (error) {
+		return {
+			status: "unhealthy",
+			message: error instanceof Error ? error.message : "Failed to check Redis",
+		};
+	}
+};
+
+export const checkTraefikHealth = async (): Promise<ServiceHealthStatus> => {
+	// Traefik can run as a standalone container or a swarm service
+	try {
+		const container = docker.getContainer("dokploy-traefik");
+		const info = await container.inspect();
+		if (!info.State.Running) {
+			return {
+				status: "unhealthy",
+				message: "Container is not running",
+			};
+		}
+		return { status: "healthy" };
+	} catch {
+		// Not a standalone container, check as swarm service
+		return checkSwarmServiceRunning("dokploy-traefik");
+	}
+};

packages/server/src/utils/filesystem/directory.ts

@@ -102,7 +102,8 @@ export const removeMonitoringDirectory = async (
 };
 
 export const getBuildAppDirectory = (application: Application) => {
-	const { APPLICATIONS_PATH } = paths(!!application.serverId);
+	const serverId = application.buildServerId || application.serverId;
+	const { APPLICATIONS_PATH } = paths(!!serverId);
 	const { appName, buildType, sourceType, customGitBuildPath, dockerfile } =
 		application;
 	let buildPath = "";
@@ -126,7 +127,7 @@ export const getBuildAppDirectory = (application: Application) => {
 			appName,
 			"code",
 			buildPath ?? "",
-			dockerfile || "",
+			dockerfile || "Dockerfile",
 		);
 	}
 

packages/server/src/utils/notifications/build-error.ts

@@ -5,11 +5,17 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
 	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
@@ -42,174 +48,388 @@ export const sendBuildErrorNotifications = async ({
 			discord: true,
 			telegram: true,
 			slack: true,
+			resend: true,
 			gotify: true,
 			ntfy: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack, gotify, ntfy } = notification;
-		if (email) {
-			const template = await renderAsync(
-				BuildFailedEmail({
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
+		try {
+			if (email || resend) {
+				const template = await renderAsync(
+					BuildFailedEmail({
+						projectName,
+						applicationName,
+						applicationType,
+						errorMessage: errorMessage,
+						buildLink,
+						date: date.toLocaleString(),
+					}),
+				).catch();
+
+				if (email) {
+					await sendEmailNotification(
+						email,
+						"Build failed for dokploy",
+						template,
+					);
+				}
+
+				if (resend) {
+					await sendResendNotification(
+						resend,
+						"Build failed for dokploy",
+						template,
+					);
+				}
+			}
+
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+				const limitCharacter = 800;
+				const truncatedErrorMessage = errorMessage.substring(0, limitCharacter);
+				await sendDiscordNotification(discord, {
+					title: decorate(">", "`⚠️` Build Failed"),
+					color: 0xed4245,
+					fields: [
+						{
+							name: decorate("`🛠️`", "Project"),
+							value: projectName,
+							inline: true,
+						},
+						{
+							name: decorate("`⚙️`", "Application"),
+							value: applicationName,
+							inline: true,
+						},
+						{
+							name: decorate("`❔`", "Type"),
+							value: applicationType,
+							inline: true,
+						},
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate("`❓`", "Type"),
+							value: "Failed",
+							inline: true,
+						},
+						{
+							name: decorate("`⚠️`", "Error Message"),
+							value: `\`\`\`${truncatedErrorMessage}\`\`\``,
+						},
+						{
+							name: decorate("`🧷`", "Build Link"),
+							value: `[Click here to access build link](${buildLink})`,
+						},
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Build Notification",
+					},
+				});
+			}
+
+			if (gotify) {
+				const decorate = (decoration: string, text: string) =>
+					`${gotify.decoration ? decoration : ""} ${text}\n`;
+				await sendGotifyNotification(
+					gotify,
+					decorate("⚠️", "Build Failed"),
+					`${decorate("🛠️", `Project: ${projectName}`)}` +
+						`${decorate("⚙️", `Application: ${applicationName}`)}` +
+						`${decorate("❔", `Type: ${applicationType}`)}` +
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+						`${decorate("⚠️", `Error:\n${errorMessage}`)}` +
+						`${decorate("🔗", `Build details:\n${buildLink}`)}`,
+				);
+			}
+
+			if (ntfy) {
+				await sendNtfyNotification(
+					ntfy,
+					"Build Failed",
+					"warning",
+					`view, Build details, ${buildLink}, clear=true;`,
+					`🛠️Project: ${projectName}\n` +
+						`⚙️Application: ${applicationName}\n` +
+						`❔Type: ${applicationType}\n` +
+						`🕒Date: ${date.toLocaleString()}\n` +
+						`⚠️Error:\n${errorMessage}`,
+				);
+			}
+
+			if (telegram) {
+				const inlineButton = [
+					[
+						{
+							text: "Deployment Logs",
+							url: buildLink,
+						},
+					],
+				];
+
+				await sendTelegramNotification(
+					telegram,
+					`<b>⚠️ Build Failed</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Type:</b> ${applicationType}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`,
+					inlineButton,
+				);
+			}
+
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: "#FF0000",
+							pretext: ":warning: *Build Failed*",
+							fields: [
+								{
+									title: "Project",
+									value: projectName,
+									short: true,
+								},
+								{
+									title: "Application",
+									value: applicationName,
+									short: true,
+								},
+								{
+									title: "Type",
+									value: applicationType,
+									short: true,
+								},
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+								{
+									title: "Error",
+									value: `\`\`\`${errorMessage}\`\`\``,
+									short: false,
+								},
+							],
+							actions: [
+								{
+									type: "button",
+									text: "View Build Details",
+									url: buildLink,
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				await sendMattermostNotification(mattermost, {
+					text: `:warning: **Build Failed**
+
+**Project:** ${projectName}
+**Application:** ${applicationName}
+**Type:** ${applicationType}
+**Time:** ${date.toLocaleString()}
+
+**Error:**
+\`\`\`
+${errorMessage}
+\`\`\`
+
+[View Build Details](${buildLink})`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy Bot",
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: "Build Error",
+					message: "Build failed with errors",
 					projectName,
 					applicationName,
 					applicationType,
-					errorMessage: errorMessage,
+					errorMessage,
 					buildLink,
+					timestamp: date.toISOString(),
 					date: date.toLocaleString(),
-				}),
-			).catch();
-			await sendEmailNotification(email, "Build failed for dokploy", template);
-		}
+					status: "error",
+					type: "build",
+				});
+			}
 
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+			if (lark) {
+				const limitCharacter = 800;
+				const truncatedErrorMessage = errorMessage.substring(0, limitCharacter);
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
+								},
+							},
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content: "⚠️ Build Failed",
+							},
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: "red",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Project:**\n${projectName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Type:**\n${applicationType}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Error Message:**\n\`\`\`\n${truncatedErrorMessage}\n\`\`\``,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Application:**\n${applicationName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Date:**\n${format(date, "PP pp")}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+								{
+									tag: "button",
+									text: {
+										tag: "plain_text",
+										content: "View Build Details",
+									},
+									type: "danger",
+									width: "default",
+									size: "medium",
+									behaviors: [
+										{
+											type: "open_url",
+											default_url: buildLink,
+											pc_url: "",
+											ios_url: "",
+											android_url: "",
+										},
+									],
+									margin: "0px 0px 0px 0px",
+								},
+							],
+						},
+					},
+				});
+			}
 
-			const limitCharacter = 800;
-			const truncatedErrorMessage = errorMessage.substring(0, limitCharacter);
-			await sendDiscordNotification(discord, {
-				title: decorate(">", "`⚠️` Build Failed"),
-				color: 0xed4245,
-				fields: [
-					{
-						name: decorate("`🛠️`", "Project"),
-						value: projectName,
-						inline: true,
-					},
-					{
-						name: decorate("`⚙️`", "Application"),
-						value: applicationName,
-						inline: true,
-					},
-					{
-						name: decorate("`❔`", "Type"),
-						value: applicationType,
-						inline: true,
-					},
-					{
-						name: decorate("`📅`", "Date"),
-						value: `<t:${unixDate}:D>`,
-						inline: true,
-					},
-					{
-						name: decorate("`⌚`", "Time"),
-						value: `<t:${unixDate}:t>`,
-						inline: true,
-					},
-					{
-						name: decorate("`❓`", "Type"),
-						value: "Failed",
-						inline: true,
-					},
-					{
-						name: decorate("`⚠️`", "Error Message"),
-						value: `\`\`\`${truncatedErrorMessage}\`\`\``,
-					},
-					{
-						name: decorate("`🧷`", "Build Link"),
-						value: `[Click here to access build link](${buildLink})`,
-					},
-				],
-				timestamp: date.toISOString(),
-				footer: {
-					text: "Dokploy Build Notification",
-				},
-			});
-		}
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					"Build Failed",
+					`Project: ${projectName}\nApplication: ${applicationName}\nType: ${applicationType}\nDate: ${date.toLocaleString()}\nError: ${errorMessage}`,
+				);
+			}
 
-		if (gotify) {
-			const decorate = (decoration: string, text: string) =>
-				`${gotify.decoration ? decoration : ""} ${text}\n`;
-			await sendGotifyNotification(
-				gotify,
-				decorate("⚠️", "Build Failed"),
-				`${decorate("🛠️", `Project: ${projectName}`)}` +
-					`${decorate("⚙️", `Application: ${applicationName}`)}` +
-					`${decorate("❔", `Type: ${applicationType}`)}` +
-					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
-					`${decorate("⚠️", `Error:\n${errorMessage}`)}` +
-					`${decorate("🔗", `Build details:\n${buildLink}`)}`,
-			);
-		}
-
-		if (ntfy) {
-			await sendNtfyNotification(
-				ntfy,
-				"Build Failed",
-				"warning",
-				`view, Build details, ${buildLink}, clear=true;`,
-				`🛠️Project: ${projectName}\n` +
-					`⚙️Application: ${applicationName}\n` +
-					`❔Type: ${applicationType}\n` +
-					`🕒Date: ${date.toLocaleString()}\n` +
-					`⚠️Error:\n${errorMessage}`,
-			);
-		}
-
-		if (telegram) {
-			const inlineButton = [
-				[
-					{
-						text: "Deployment Logs",
+			if (teams) {
+				const limitCharacter = 800;
+				const truncatedErrorMessage = errorMessage.substring(0, limitCharacter);
+				await sendTeamsNotification(teams, {
+					title: "⚠️ Build Failed",
+					facts: [
+						{ name: "Project", value: projectName },
+						{ name: "Application", value: applicationName },
+						{ name: "Type", value: applicationType },
+						{ name: "Date", value: format(date, "PP pp") },
+						{ name: "Error Message", value: truncatedErrorMessage },
+					],
+					potentialAction: {
+						type: "Action.OpenUrl",
+						title: "View Build Details",
 						url: buildLink,
 					},
-				],
-			];
-
-			await sendTelegramNotification(
-				telegram,
-				`<b>⚠️ Build Failed</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Type:</b> ${applicationType}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`,
-				inlineButton,
-			);
-		}
-
-		if (slack) {
-			const { channel } = slack;
-			await sendSlackNotification(slack, {
-				channel: channel,
-				attachments: [
-					{
-						color: "#FF0000",
-						pretext: ":warning: *Build Failed*",
-						fields: [
-							{
-								title: "Project",
-								value: projectName,
-								short: true,
-							},
-							{
-								title: "Application",
-								value: applicationName,
-								short: true,
-							},
-							{
-								title: "Type",
-								value: applicationType,
-								short: true,
-							},
-							{
-								title: "Time",
-								value: date.toLocaleString(),
-								short: true,
-							},
-							{
-								title: "Error",
-								value: `\`\`\`${errorMessage}\`\`\``,
-								short: false,
-							},
-						],
-						actions: [
-							{
-								type: "button",
-								text: "View Build Details",
-								url: buildLink,
-							},
-						],
-					},
-				],
-			});
+				});
+			}
+		} catch (error) {
+			console.log(error);
 		}
 	}
 };

packages/server/src/utils/notifications/build-success.ts

@@ -6,11 +6,17 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
 	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
@@ -21,6 +27,7 @@ interface Props {
 	buildLink: string;
 	organizationId: string;
 	domains: Domain[];
+	environmentName: string;
 }
 
 export const sendBuildSuccessNotifications = async ({
@@ -30,6 +37,7 @@ export const sendBuildSuccessNotifications = async ({
 	buildLink,
 	organizationId,
 	domains,
+	environmentName,
 }: Props) => {
 	const date = new Date();
 	const unixDate = ~~(Number(date) / 1000);
@@ -43,172 +51,385 @@ export const sendBuildSuccessNotifications = async ({
 			discord: true,
 			telegram: true,
 			slack: true,
+			resend: true,
 			gotify: true,
 			ntfy: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack, gotify, ntfy } = notification;
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
+		try {
+			if (email || resend) {
+				const template = await renderAsync(
+					BuildSuccessEmail({
+						projectName,
+						applicationName,
+						applicationType,
+						buildLink,
+						date: date.toLocaleString(),
+						environmentName,
+					}),
+				).catch();
 
-		if (email) {
-			const template = await renderAsync(
-				BuildSuccessEmail({
+				if (email) {
+					await sendEmailNotification(
+						email,
+						"Build success for dokploy",
+						template,
+					);
+				}
+
+				if (resend) {
+					await sendResendNotification(
+						resend,
+						"Build success for dokploy",
+						template,
+					);
+				}
+			}
+
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+				await sendDiscordNotification(discord, {
+					title: decorate(">", "`✅` Build Successes"),
+					color: 0x57f287,
+					fields: [
+						{
+							name: decorate("`🛠️`", "Project"),
+							value: projectName,
+							inline: true,
+						},
+						{
+							name: decorate("`⚙️`", "Application"),
+							value: applicationName,
+							inline: true,
+						},
+						{
+							name: decorate("`🌍`", "Environment"),
+							value: environmentName,
+							inline: true,
+						},
+						{
+							name: decorate("`❔`", "Type"),
+							value: applicationType,
+							inline: true,
+						},
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate("`❓`", "Type"),
+							value: "Successful",
+							inline: true,
+						},
+						{
+							name: decorate("`🧷`", "Build Link"),
+							value: `[Click here to access build link](${buildLink})`,
+						},
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Build Notification",
+					},
+				});
+			}
+
+			if (gotify) {
+				const decorate = (decoration: string, text: string) =>
+					`${gotify.decoration ? decoration : ""} ${text}\n`;
+				await sendGotifyNotification(
+					gotify,
+					decorate("✅", "Build Success"),
+					`${decorate("🛠️", `Project: ${projectName}`)}` +
+						`${decorate("⚙️", `Application: ${applicationName}`)}` +
+						`${decorate("🌍", `Environment: ${environmentName}`)}` +
+						`${decorate("❔", `Type: ${applicationType}`)}` +
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+						`${decorate("🔗", `Build details:\n${buildLink}`)}`,
+				);
+			}
+
+			if (ntfy) {
+				await sendNtfyNotification(
+					ntfy,
+					"Build Success",
+					"white_check_mark",
+					`view, Build details, ${buildLink}, clear=true;`,
+					`🛠Project: ${projectName}\n` +
+						`⚙️Application: ${applicationName}\n` +
+						`🌍Environment: ${environmentName}\n` +
+						`❔Type: ${applicationType}\n` +
+						`🕒Date: ${date.toLocaleString()}`,
+				);
+			}
+
+			if (telegram) {
+				const chunkArray = <T>(array: T[], chunkSize: number): T[][] =>
+					Array.from({ length: Math.ceil(array.length / chunkSize) }, (_, i) =>
+						array.slice(i * chunkSize, i * chunkSize + chunkSize),
+					);
+
+				const inlineButton = [
+					[
+						{
+							text: "Deployment Logs",
+							url: buildLink,
+						},
+					],
+					...chunkArray(domains, 2).map((chunk) =>
+						chunk.map((data) => ({
+							text: data.host,
+							url: `${data.https ? "https" : "http"}://${data.host}`,
+						})),
+					),
+				];
+
+				await sendTelegramNotification(
+					telegram,
+					`<b>✅ Build Success</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Environment:</b> ${environmentName}\n<b>Type:</b> ${applicationType}\n<b>Date:</b> ${format(
+						date,
+						"PP",
+					)}\n<b>Time:</b> ${format(date, "pp")}`,
+					inlineButton,
+				);
+			}
+
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: "#00FF00",
+							pretext: ":white_check_mark: *Build Success*",
+							fields: [
+								{
+									title: "Project",
+									value: projectName,
+									short: true,
+								},
+								{
+									title: "Application",
+									value: applicationName,
+									short: true,
+								},
+								{
+									title: "Environment",
+									value: environmentName,
+									short: true,
+								},
+								{
+									title: "Type",
+									value: applicationType,
+									short: true,
+								},
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+							],
+							actions: [
+								{
+									type: "button",
+									text: "View Build Details",
+									url: buildLink,
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				await sendMattermostNotification(mattermost, {
+					text: `**✅ Build Success**\n\n**Project:** ${projectName}\n**Application:** ${applicationName}\n**Type:** ${applicationType}\n**Date:** ${format(date, "PP")}\n**Time:** ${format(date, "pp")}\n\n[View Build Details](${buildLink})`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy",
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: "Build Success",
+					message: "Build completed successfully",
 					projectName,
 					applicationName,
 					applicationType,
 					buildLink,
+					timestamp: date.toISOString(),
 					date: date.toLocaleString(),
-				}),
-			).catch();
-			await sendEmailNotification(email, "Build success for dokploy", template);
-		}
+					domains: domains.map((domain) => domain.host).join(", "),
+					status: "success",
+					type: "build",
+				});
+			}
 
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+			if (lark) {
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
+								},
+							},
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content: "✅ Build Success",
+							},
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: "green",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Project:**\n${projectName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Environment:**\n${environmentName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Type:**\n${applicationType}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Application:**\n${applicationName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Date:**\n${format(date, "PP pp")}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+								{
+									tag: "button",
+									text: {
+										tag: "plain_text",
+										content: "View Build Details",
+									},
+									type: "primary",
+									width: "default",
+									size: "medium",
+									behaviors: [
+										{
+											type: "open_url",
+											default_url: buildLink,
+											pc_url: "",
+											ios_url: "",
+											android_url: "",
+										},
+									],
+									margin: "0px 0px 0px 0px",
+								},
+							],
+						},
+					},
+				});
+			}
 
-			await sendDiscordNotification(discord, {
-				title: decorate(">", "`✅` Build Success"),
-				color: 0x57f287,
-				fields: [
-					{
-						name: decorate("`🛠️`", "Project"),
-						value: projectName,
-						inline: true,
-					},
-					{
-						name: decorate("`⚙️`", "Application"),
-						value: applicationName,
-						inline: true,
-					},
-					{
-						name: decorate("`❔`", "Type"),
-						value: applicationType,
-						inline: true,
-					},
-					{
-						name: decorate("`📅`", "Date"),
-						value: `<t:${unixDate}:D>`,
-						inline: true,
-					},
-					{
-						name: decorate("`⌚`", "Time"),
-						value: `<t:${unixDate}:t>`,
-						inline: true,
-					},
-					{
-						name: decorate("`❓`", "Type"),
-						value: "Successful",
-						inline: true,
-					},
-					{
-						name: decorate("`🧷`", "Build Link"),
-						value: `[Click here to access build link](${buildLink})`,
-					},
-				],
-				timestamp: date.toISOString(),
-				footer: {
-					text: "Dokploy Build Notification",
-				},
-			});
-		}
-
-		if (gotify) {
-			const decorate = (decoration: string, text: string) =>
-				`${gotify.decoration ? decoration : ""} ${text}\n`;
-			await sendGotifyNotification(
-				gotify,
-				decorate("✅", "Build Success"),
-				`${decorate("🛠️", `Project: ${projectName}`)}` +
-					`${decorate("⚙️", `Application: ${applicationName}`)}` +
-					`${decorate("❔", `Type: ${applicationType}`)}` +
-					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
-					`${decorate("🔗", `Build details:\n${buildLink}`)}`,
-			);
-		}
-
-		if (ntfy) {
-			await sendNtfyNotification(
-				ntfy,
-				"Build Success",
-				"white_check_mark",
-				`view, Build details, ${buildLink}, clear=true;`,
-				`🛠Project: ${projectName}\n` +
-					`⚙️Application: ${applicationName}\n` +
-					`❔Type: ${applicationType}\n` +
-					`🕒Date: ${date.toLocaleString()}`,
-			);
-		}
-
-		if (telegram) {
-			const chunkArray = <T>(array: T[], chunkSize: number): T[][] =>
-				Array.from({ length: Math.ceil(array.length / chunkSize) }, (_, i) =>
-					array.slice(i * chunkSize, i * chunkSize + chunkSize),
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					"Build Success",
+					`Project: ${projectName}\nApplication: ${applicationName}\nEnvironment: ${environmentName}\nType: ${applicationType}\nDate: ${date.toLocaleString()}`,
 				);
+			}
 
-			const inlineButton = [
-				[
-					{
-						text: "Deployment Logs",
+			if (teams) {
+				await sendTeamsNotification(teams, {
+					title: "✅ Build Success",
+					facts: [
+						{ name: "Project", value: projectName },
+						{ name: "Application", value: applicationName },
+						{ name: "Environment", value: environmentName },
+						{ name: "Type", value: applicationType },
+						{ name: "Date", value: format(date, "PP pp") },
+					],
+					potentialAction: {
+						type: "Action.OpenUrl",
+						title: "View Build Details",
 						url: buildLink,
 					},
-				],
-				...chunkArray(domains, 2).map((chunk) =>
-					chunk.map((data) => ({
-						text: data.host,
-						url: `${data.https ? "https" : "http"}://${data.host}`,
-					})),
-				),
-			];
-
-			await sendTelegramNotification(
-				telegram,
-				`<b>✅ Build Success</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Type:</b> ${applicationType}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}`,
-				inlineButton,
-			);
-		}
-
-		if (slack) {
-			const { channel } = slack;
-			await sendSlackNotification(slack, {
-				channel: channel,
-				attachments: [
-					{
-						color: "#00FF00",
-						pretext: ":white_check_mark: *Build Success*",
-						fields: [
-							{
-								title: "Project",
-								value: projectName,
-								short: true,
-							},
-							{
-								title: "Application",
-								value: applicationName,
-								short: true,
-							},
-							{
-								title: "Type",
-								value: applicationType,
-								short: true,
-							},
-							{
-								title: "Time",
-								value: date.toLocaleString(),
-								short: true,
-							},
-						],
-						actions: [
-							{
-								type: "button",
-								text: "View Build Details",
-								url: buildLink,
-							},
-						],
-					},
-				],
-			});
+				});
+			}
+		} catch (error) {
+			console.log(error);
 		}
 	}
 };

packages/server/src/utils/notifications/database-backup.ts

@@ -5,11 +5,17 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
 	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
@@ -24,7 +30,7 @@ export const sendDatabaseBackupNotifications = async ({
 }: {
 	projectName: string;
 	applicationName: string;
-	databaseType: "postgres" | "mysql" | "mongodb" | "mariadb";
+	databaseType: "postgres" | "mysql" | "mongodb" | "mariadb" | "libsql";
 	type: "error" | "success";
 	organizationId: string;
 	errorMessage?: string;
@@ -42,201 +48,415 @@ export const sendDatabaseBackupNotifications = async ({
 			discord: true,
 			telegram: true,
 			slack: true,
+			resend: true,
 			gotify: true,
 			ntfy: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack, gotify, ntfy } = notification;
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
+		try {
+			if (email || resend) {
+				const template = await renderAsync(
+					DatabaseBackupEmail({
+						projectName,
+						applicationName,
+						databaseType,
+						type,
+						errorMessage,
+						date: date.toLocaleString(),
+					}),
+				).catch();
 
-		if (email) {
-			const template = await renderAsync(
-				DatabaseBackupEmail({
+				if (email) {
+					await sendEmailNotification(
+						email,
+						"Database backup for dokploy",
+						template,
+					);
+				}
+
+				if (resend) {
+					await sendResendNotification(
+						resend,
+						"Database backup for dokploy",
+						template,
+					);
+				}
+			}
+
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+				await sendDiscordNotification(discord, {
+					title:
+						type === "success"
+							? decorate(">", "`✅` Database Backup Successful")
+							: decorate(">", "`❌` Database Backup Failed"),
+					color: type === "success" ? 0x57f287 : 0xed4245,
+					fields: [
+						{
+							name: decorate("`🛠️`", "Project"),
+							value: projectName,
+							inline: true,
+						},
+						{
+							name: decorate("`⚙️`", "Application"),
+							value: applicationName,
+							inline: true,
+						},
+						{
+							name: decorate("`❔`", "Database"),
+							value: databaseType,
+							inline: true,
+						},
+						{
+							name: decorate("`📂`", "Database Name"),
+							value: databaseName,
+							inline: true,
+						},
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate("`❓`", "Type"),
+							value: type
+								.replace("error", "Failed")
+								.replace("success", "Successful"),
+							inline: true,
+						},
+						...(type === "error" && errorMessage
+							? [
+									{
+										name: decorate("`⚠️`", "Error Message"),
+										value: `\`\`\`${errorMessage.length > 1010 ? `${errorMessage.substring(0, 1010)}...` : errorMessage}\`\`\``,
+									},
+								]
+							: []),
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Database Backup Notification",
+					},
+				});
+			}
+
+			if (gotify) {
+				const decorate = (decoration: string, text: string) =>
+					`${gotify.decoration ? decoration : ""} ${text}\n`;
+
+				await sendGotifyNotification(
+					gotify,
+					decorate(
+						type === "success" ? "✅" : "❌",
+						`Database Backup ${type === "success" ? "Successful" : "Failed"}`,
+					),
+					`${decorate("🛠️", `Project: ${projectName}`)}` +
+						`${decorate("⚙️", `Application: ${applicationName}`)}` +
+						`${decorate("❔", `Type: ${databaseType}`)}` +
+						`${decorate("📂", `Database Name: ${databaseName}`)}` +
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+						`${type === "error" && errorMessage ? decorate("❌", `Error:\n${errorMessage}`) : ""}`,
+				);
+			}
+
+			if (ntfy) {
+				await sendNtfyNotification(
+					ntfy,
+					`Database Backup ${type === "success" ? "Successful" : "Failed"}`,
+					`${type === "success" ? "white_check_mark" : "x"}`,
+					"",
+					`🛠Project: ${projectName}\n` +
+						`⚙️Application: ${applicationName}\n` +
+						`❔Type: ${databaseType}\n` +
+						`📂Database Name: ${databaseName}` +
+						`🕒Date: ${date.toLocaleString()}\n` +
+						`${type === "error" && errorMessage ? `❌Error:\n${errorMessage}` : ""}`,
+				);
+			}
+
+			if (telegram) {
+				const isError = type === "error" && errorMessage;
+
+				const statusEmoji = type === "success" ? "✅" : "❌";
+				const typeStatus = type === "success" ? "Successful" : "Failed";
+				const errorMsg = isError
+					? `\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`
+					: "";
+
+				const messageText = `<b>${statusEmoji} Database Backup ${typeStatus}</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Type:</b> ${databaseType}\n<b>Database Name:</b> ${databaseName}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}${isError ? errorMsg : ""}`;
+
+				await sendTelegramNotification(telegram, messageText);
+			}
+
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: type === "success" ? "#00FF00" : "#FF0000",
+							pretext:
+								type === "success"
+									? ":white_check_mark: *Database Backup Successful*"
+									: ":x: *Database Backup Failed*",
+							fields: [
+								...(type === "error" && errorMessage
+									? [
+											{
+												title: "Error Message",
+												value: errorMessage,
+												short: false,
+											},
+										]
+									: []),
+								{
+									title: "Project",
+									value: projectName,
+									short: true,
+								},
+								{
+									title: "Application",
+									value: applicationName,
+									short: true,
+								},
+								{
+									title: "Type",
+									value: databaseType,
+									short: true,
+								},
+								{
+									title: "Database Name",
+									value: databaseName,
+								},
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+								{
+									title: "Type",
+									value: type,
+								},
+								{
+									title: "Status",
+									value: type === "success" ? "Successful" : "Failed",
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				const statusEmoji = type === "success" ? "✅" : "❌";
+				const typeStatus = type === "success" ? "Successful" : "Failed";
+				const errorMsg =
+					type === "error" && errorMessage
+						? `\n\n**Error:**\n\`\`\`\n${errorMessage}\n\`\`\``
+						: "";
+
+				await sendMattermostNotification(mattermost, {
+					text: `**${statusEmoji} Database Backup ${typeStatus}**\n\n**Project:** ${projectName}\n**Application:** ${applicationName}\n**Type:** ${databaseType}\n**Database Name:** ${databaseName}\n**Date:** ${format(date, "PP")}\n**Time:** ${format(date, "pp")}${errorMsg}`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy",
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: `Database Backup ${type === "success" ? "Successful" : "Failed"}`,
+					message:
+						type === "success"
+							? "Database backup completed successfully"
+							: "Database backup failed",
 					projectName,
 					applicationName,
 					databaseType,
+					databaseName,
 					type,
-					errorMessage,
+					errorMessage: errorMessage || "",
+					timestamp: date.toISOString(),
 					date: date.toLocaleString(),
-				}),
-			).catch();
-			await sendEmailNotification(
-				email,
-				"Database backup for dokploy",
-				template,
-			);
-		}
+					status: type,
+				});
+			}
 
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+			if (lark) {
+				const limitCharacter = 800;
+				const truncatedErrorMessage =
+					errorMessage && errorMessage.length > limitCharacter
+						? errorMessage.substring(0, limitCharacter)
+						: errorMessage;
 
-			await sendDiscordNotification(discord, {
-				title:
-					type === "success"
-						? decorate(">", "`✅` Database Backup Successful")
-						: decorate(">", "`❌` Database Backup Failed"),
-				color: type === "success" ? 0x57f287 : 0xed4245,
-				fields: [
-					{
-						name: decorate("`🛠️`", "Project"),
-						value: projectName,
-						inline: true,
-					},
-					{
-						name: decorate("`⚙️`", "Application"),
-						value: applicationName,
-						inline: true,
-					},
-					{
-						name: decorate("`❔`", "Database"),
-						value: databaseType,
-						inline: true,
-					},
-					{
-						name: decorate("`📂`", "Database Name"),
-						value: databaseName,
-						inline: true,
-					},
-					{
-						name: decorate("`📅`", "Date"),
-						value: `<t:${unixDate}:D>`,
-						inline: true,
-					},
-					{
-						name: decorate("`⌚`", "Time"),
-						value: `<t:${unixDate}:t>`,
-						inline: true,
-					},
-					{
-						name: decorate("`❓`", "Type"),
-						value: type
-							.replace("error", "Failed")
-							.replace("success", "Successful"),
-						inline: true,
-					},
-					...(type === "error" && errorMessage
-						? [
-								{
-									name: decorate("`⚠️`", "Error Message"),
-									value: `\`\`\`${errorMessage}\`\`\``,
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
 								},
-							]
-						: []),
-				],
-				timestamp: date.toISOString(),
-				footer: {
-					text: "Dokploy Database Backup Notification",
-				},
-			});
-		}
-
-		if (gotify) {
-			const decorate = (decoration: string, text: string) =>
-				`${gotify.decoration ? decoration : ""} ${text}\n`;
-
-			await sendGotifyNotification(
-				gotify,
-				decorate(
-					type === "success" ? "✅" : "❌",
-					`Database Backup ${type === "success" ? "Successful" : "Failed"}`,
-				),
-				`${decorate("🛠️", `Project: ${projectName}`)}` +
-					`${decorate("⚙️", `Application: ${applicationName}`)}` +
-					`${decorate("❔", `Type: ${databaseType}`)}` +
-					`${decorate("📂", `Database Name: ${databaseName}`)}` +
-					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
-					`${type === "error" && errorMessage ? decorate("❌", `Error:\n${errorMessage}`) : ""}`,
-			);
-		}
-
-		if (ntfy) {
-			await sendNtfyNotification(
-				ntfy,
-				`Database Backup ${type === "success" ? "Successful" : "Failed"}`,
-				`${type === "success" ? "white_check_mark" : "x"}`,
-				"",
-				`🛠Project: ${projectName}\n` +
-					`⚙️Application: ${applicationName}\n` +
-					`❔Type: ${databaseType}\n` +
-					`📂Database Name: ${databaseName}` +
-					`🕒Date: ${date.toLocaleString()}\n` +
-					`${type === "error" && errorMessage ? `❌Error:\n${errorMessage}` : ""}`,
-			);
-		}
-
-		if (telegram) {
-			const isError = type === "error" && errorMessage;
-
-			const statusEmoji = type === "success" ? "✅" : "❌";
-			const typeStatus = type === "success" ? "Successful" : "Failed";
-			const errorMsg = isError
-				? `\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`
-				: "";
-
-			const messageText = `<b>${statusEmoji} Database Backup ${typeStatus}</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Type:</b> ${databaseType}\n<b>Database Name:</b> ${databaseName}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}${isError ? errorMsg : ""}`;
-
-			await sendTelegramNotification(telegram, messageText);
-		}
-
-		if (slack) {
-			const { channel } = slack;
-			await sendSlackNotification(slack, {
-				channel: channel,
-				attachments: [
-					{
-						color: type === "success" ? "#00FF00" : "#FF0000",
-						pretext:
-							type === "success"
-								? ":white_check_mark: *Database Backup Successful*"
-								: ":x: *Database Backup Failed*",
-						fields: [
-							...(type === "error" && errorMessage
-								? [
+							},
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content:
+									type === "success"
+										? "✅ Database Backup Successful"
+										: "❌ Database Backup Failed",
+							},
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: type === "success" ? "green" : "red",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
 										{
-											title: "Error Message",
-											value: errorMessage,
-											short: false,
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Project:**\n${projectName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Database Type:**\n${databaseType}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Status:**\n${type === "success" ? "Successful" : "Failed"}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
 										},
-									]
-								: []),
-							{
-								title: "Project",
-								value: projectName,
-								short: true,
-							},
-							{
-								title: "Application",
-								value: applicationName,
-								short: true,
-							},
-							{
-								title: "Type",
-								value: databaseType,
-								short: true,
-							},
-							{
-								title: "Database Name",
-								value: databaseName,
-							},
-							{
-								title: "Time",
-								value: date.toLocaleString(),
-								short: true,
-							},
-							{
-								title: "Type",
-								value: type,
-							},
-							{
-								title: "Status",
-								value: type === "success" ? "Successful" : "Failed",
-							},
-						],
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Application:**\n${applicationName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Database Name:**\n${databaseName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Date:**\n${format(date, "PP pp")}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+								...(type === "error" && truncatedErrorMessage
+									? [
+											{
+												tag: "markdown",
+												content: `**Error Message:**\n\`\`\`\n${truncatedErrorMessage}\n\`\`\``,
+												text_align: "left",
+												text_size: "normal_v2",
+											},
+										]
+									: []),
+							],
+						},
 					},
-				],
-			});
+				});
+			}
+
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					`Database Backup ${type === "success" ? "Successful" : "Failed"}`,
+					`Project: ${projectName}\nApplication: ${applicationName}\nDatabase: ${databaseType}\nDatabase Name: ${databaseName}\nDate: ${date.toLocaleString()}${type === "error" && errorMessage ? `\nError: ${errorMessage}` : ""}`,
+				);
+			}
+
+			if (teams) {
+				const facts = [
+					{ name: "Project", value: projectName },
+					{ name: "Application", value: applicationName },
+					{ name: "Database Type", value: databaseType },
+					{ name: "Database Name", value: databaseName },
+					{ name: "Date", value: format(date, "PP pp") },
+					{
+						name: "Status",
+						value: type === "success" ? "Successful" : "Failed",
+					},
+				];
+				if (type === "error" && errorMessage) {
+					facts.push({ name: "Error", value: errorMessage.substring(0, 500) });
+				}
+				await sendTeamsNotification(teams, {
+					title:
+						type === "success"
+							? "✅ Database Backup Successful"
+							: "❌ Database Backup Failed",
+					facts,
+				});
+			}
+		} catch (error) {
+			console.log(error);
 		}
 	}
 };

packages/server/src/utils/notifications/docker-cleanup.ts

@@ -5,11 +5,17 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
 	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
@@ -29,111 +35,259 @@ export const sendDockerCleanupNotifications = async (
 			discord: true,
 			telegram: true,
 			slack: true,
+			resend: true,
 			gotify: true,
 			ntfy: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack, gotify, ntfy } = notification;
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
+		try {
+			if (email || resend) {
+				const template = await renderAsync(
+					DockerCleanupEmail({ message, date: date.toLocaleString() }),
+				).catch();
 
-		if (email) {
-			const template = await renderAsync(
-				DockerCleanupEmail({ message, date: date.toLocaleString() }),
-			).catch();
+				if (email) {
+					await sendEmailNotification(
+						email,
+						"Docker cleanup for dokploy",
+						template,
+					);
+				}
 
-			await sendEmailNotification(
-				email,
-				"Docker cleanup for dokploy",
-				template,
-			);
-		}
+				if (resend) {
+					await sendResendNotification(
+						resend,
+						"Docker cleanup for dokploy",
+						template,
+					);
+				}
+			}
 
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
 
-			await sendDiscordNotification(discord, {
-				title: decorate(">", "`✅` Docker Cleanup"),
-				color: 0x57f287,
-				fields: [
-					{
-						name: decorate("`📅`", "Date"),
-						value: `<t:${unixDate}:D>`,
-						inline: true,
+				await sendDiscordNotification(discord, {
+					title: decorate(">", "`✅` Docker Cleanup"),
+					color: 0x57f287,
+					fields: [
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate("`❓`", "Type"),
+							value: "Successful",
+							inline: true,
+						},
+						{
+							name: decorate("`📜`", "Message"),
+							value: `\`\`\`${message}\`\`\``,
+						},
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Docker Cleanup Notification",
 					},
-					{
-						name: decorate("`⌚`", "Time"),
-						value: `<t:${unixDate}:t>`,
-						inline: true,
-					},
-					{
-						name: decorate("`❓`", "Type"),
-						value: "Successful",
-						inline: true,
-					},
-					{
-						name: decorate("`📜`", "Message"),
-						value: `\`\`\`${message}\`\`\``,
-					},
-				],
-				timestamp: date.toISOString(),
-				footer: {
-					text: "Dokploy Docker Cleanup Notification",
-				},
-			});
-		}
+				});
+			}
 
-		if (gotify) {
-			const decorate = (decoration: string, text: string) =>
-				`${gotify.decoration ? decoration : ""} ${text}\n`;
-			await sendGotifyNotification(
-				gotify,
-				decorate("✅", "Docker Cleanup"),
-				`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
-					`${decorate("📜", `Message:\n${message}`)}`,
-			);
-		}
+			if (gotify) {
+				const decorate = (decoration: string, text: string) =>
+					`${gotify.decoration ? decoration : ""} ${text}\n`;
+				await sendGotifyNotification(
+					gotify,
+					decorate("✅", "Docker Cleanup"),
+					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+						`${decorate("📜", `Message:\n${message}`)}`,
+				);
+			}
 
-		if (ntfy) {
-			await sendNtfyNotification(
-				ntfy,
-				"Docker Cleanup",
-				"white_check_mark",
-				"",
-				`🕒Date: ${date.toLocaleString()}\n` + `📜Message:\n${message}`,
-			);
-		}
+			if (ntfy) {
+				await sendNtfyNotification(
+					ntfy,
+					"Docker Cleanup",
+					"white_check_mark",
+					"",
+					`🕒Date: ${date.toLocaleString()}\n` + `📜Message:\n${message}`,
+				);
+			}
 
-		if (telegram) {
-			await sendTelegramNotification(
-				telegram,
-				`<b>✅ Docker Cleanup</b>\n\n<b>Message:</b> ${message}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}`,
-			);
-		}
+			if (telegram) {
+				await sendTelegramNotification(
+					telegram,
+					`<b>✅ Docker Cleanup</b>\n\n<b>Message:</b> ${message}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}`,
+				);
+			}
 
-		if (slack) {
-			const { channel } = slack;
-			await sendSlackNotification(slack, {
-				channel: channel,
-				attachments: [
-					{
-						color: "#00FF00",
-						pretext: ":white_check_mark: *Docker Cleanup*",
-						fields: [
-							{
-								title: "Message",
-								value: message,
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: "#00FF00",
+							pretext: ":white_check_mark: *Docker Cleanup*",
+							fields: [
+								{
+									title: "Message",
+									value: message,
+								},
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				await sendMattermostNotification(mattermost, {
+					text: `**✅ Docker Cleanup**\n\n**Message:** ${message}\n**Date:** ${format(date, "PP")}\n**Time:** ${format(date, "pp")}`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy",
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: "Docker Cleanup",
+					message: "Docker cleanup completed successfully",
+					cleanupMessage: message,
+					timestamp: date.toISOString(),
+					date: date.toLocaleString(),
+					status: "success",
+					type: "docker-cleanup",
+				});
+			}
+
+			if (lark) {
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
+								},
 							},
-							{
-								title: "Time",
-								value: date.toLocaleString(),
-								short: true,
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content: "✅ Docker Cleanup",
 							},
-						],
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: "green",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: "**Status:**\nSuccessful",
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Cleanup Details:**\n${message}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Date:**\n${format(date, "PP pp")}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+							],
+						},
 					},
-				],
-			});
+				});
+			}
+
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					"Docker Cleanup",
+					`Date: ${date.toLocaleString()}\nMessage: ${message}`,
+				);
+			}
+
+			if (teams) {
+				await sendTeamsNotification(teams, {
+					title: "✅ Docker Cleanup",
+					facts: [
+						{ name: "Date", value: format(date, "PP pp") },
+						{ name: "Message", value: message },
+					],
+				});
+			}
+		} catch (error) {
+			console.log(error);
 		}
 	}
 };

packages/server/src/utils/notifications/dokploy-restart.ts

@@ -5,135 +5,282 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
 	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
 export const sendDokployRestartNotifications = async () => {
-	const date = new Date();
-	const unixDate = ~~(Number(date) / 1000);
-	const notificationList = await db.query.notifications.findMany({
-		where: eq(notifications.dokployRestart, true),
-		with: {
-			email: true,
-			discord: true,
-			telegram: true,
-			slack: true,
-			gotify: true,
-			ntfy: true,
-		},
-	});
+	try {
+		const date = new Date();
+		const unixDate = ~~(Number(date) / 1000);
+		const notificationList = await db.query.notifications.findMany({
+			where: eq(notifications.dokployRestart, true),
+			with: {
+				email: true,
+				discord: true,
+				telegram: true,
+				slack: true,
+				resend: true,
+				gotify: true,
+				ntfy: true,
+				mattermost: true,
+				custom: true,
+				lark: true,
+				pushover: true,
+				teams: true,
+			},
+		});
 
-	for (const notification of notificationList) {
-		const { email, discord, telegram, slack, gotify, ntfy } = notification;
-
-		if (email) {
-			const template = await renderAsync(
-				DokployRestartEmail({ date: date.toLocaleString() }),
-			).catch();
-			await sendEmailNotification(email, "Dokploy Server Restarted", template);
-		}
-
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+		for (const notification of notificationList) {
+			const {
+				email,
+				resend,
+				discord,
+				telegram,
+				slack,
+				gotify,
+				ntfy,
+				mattermost,
+				custom,
+				lark,
+				pushover,
+				teams,
+			} = notification;
 
 			try {
-				await sendDiscordNotification(discord, {
-					title: decorate(">", "`✅` Dokploy Server Restarted"),
-					color: 0x57f287,
-					fields: [
-						{
-							name: decorate("`📅`", "Date"),
-							value: `<t:${unixDate}:D>`,
-							inline: true,
+				if (email || resend) {
+					const template = await renderAsync(
+						DokployRestartEmail({ date: date.toLocaleString() }),
+					).catch();
+
+					if (email) {
+						await sendEmailNotification(
+							email,
+							"Dokploy Server Restarted",
+							template,
+						);
+					}
+
+					if (resend) {
+						await sendResendNotification(
+							resend,
+							"Dokploy Server Restarted",
+							template,
+						);
+					}
+				}
+
+				if (discord) {
+					const decorate = (decoration: string, text: string) =>
+						`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+					await sendDiscordNotification(discord, {
+						title: decorate(">", "`✅` Dokploy Server Restarted"),
+						color: 0x57f287,
+						fields: [
+							{
+								name: decorate("`📅`", "Date"),
+								value: `<t:${unixDate}:D>`,
+								inline: true,
+							},
+							{
+								name: decorate("`⌚`", "Time"),
+								value: `<t:${unixDate}:t>`,
+								inline: true,
+							},
+							{
+								name: decorate("`❓`", "Type"),
+								value: "Successful",
+								inline: true,
+							},
+						],
+						timestamp: date.toISOString(),
+						footer: {
+							text: "Dokploy Restart Notification",
 						},
-						{
-							name: decorate("`⌚`", "Time"),
-							value: `<t:${unixDate}:t>`,
-							inline: true,
-						},
-						{
-							name: decorate("`❓`", "Type"),
-							value: "Successful",
-							inline: true,
-						},
-					],
-					timestamp: date.toISOString(),
-					footer: {
-						text: "Dokploy Restart Notification",
-					},
-				});
-			} catch (error) {
-				console.log(error);
-			}
-		}
+					});
+				}
 
-		if (gotify) {
-			const decorate = (decoration: string, text: string) =>
-				`${gotify.decoration ? decoration : ""} ${text}\n`;
-			try {
-				await sendGotifyNotification(
-					gotify,
-					decorate("✅", "Dokploy Server Restarted"),
-					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}`,
-				);
-			} catch (error) {
-				console.log(error);
-			}
-		}
+				if (gotify) {
+					const decorate = (decoration: string, text: string) =>
+						`${gotify.decoration ? decoration : ""} ${text}\n`;
+					await sendGotifyNotification(
+						gotify,
+						decorate("✅", "Dokploy Server Restarted"),
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}`,
+					);
+				}
 
-		if (ntfy) {
-			try {
-				await sendNtfyNotification(
-					ntfy,
-					"Dokploy Server Restarted",
-					"white_check_mark",
-					"",
-					`🕒Date: ${date.toLocaleString()}`,
-				);
-			} catch (error) {
-				console.log(error);
-			}
-		}
+				if (ntfy) {
+					await sendNtfyNotification(
+						ntfy,
+						"Dokploy Server Restarted",
+						"white_check_mark",
+						"",
+						`🕒Date: ${date.toLocaleString()}`,
+					);
+				}
 
-		if (telegram) {
-			try {
-				await sendTelegramNotification(
-					telegram,
-					`<b>✅ Dokploy Server Restarted</b>\n\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}`,
-				);
-			} catch (error) {
-				console.log(error);
-			}
-		}
+				if (telegram) {
+					await sendTelegramNotification(
+						telegram,
+						`<b>✅ Dokploy Server Restarted</b>\n\n<b>Date:</b> ${format(
+							date,
+							"PP",
+						)}\n<b>Time:</b> ${format(date, "pp")}`,
+					);
+				}
 
-		if (slack) {
-			const { channel } = slack;
-			try {
-				await sendSlackNotification(slack, {
-					channel: channel,
-					attachments: [
-						{
-							color: "#00FF00",
-							pretext: ":white_check_mark: *Dokploy Server Restarted*",
-							fields: [
-								{
-									title: "Time",
-									value: date.toLocaleString(),
-									short: true,
+				if (slack) {
+					const { channel } = slack;
+					await sendSlackNotification(slack, {
+						channel: channel,
+						attachments: [
+							{
+								color: "#00FF00",
+								pretext: ":white_check_mark: *Dokploy Server Restarted*",
+								fields: [
+									{
+										title: "Time",
+										value: date.toLocaleString(),
+										short: true,
+									},
+								],
+							},
+						],
+					});
+				}
+
+				if (mattermost) {
+					await sendMattermostNotification(mattermost, {
+						text: `**✅ Dokploy Server Restarted**\n\n**Date:** ${format(date, "PP")}\n**Time:** ${format(date, "pp")}`,
+						channel: mattermost.channel,
+						username: mattermost.username || "Dokploy",
+					});
+				}
+
+				if (custom) {
+					try {
+						await sendCustomNotification(custom, {
+							title: "Dokploy Server Restarted",
+							message: "Dokploy server has been restarted successfully",
+							timestamp: date.toISOString(),
+							date: date.toLocaleString(),
+							status: "success",
+							type: "dokploy-restart",
+						});
+					} catch (error) {
+						console.log(error);
+					}
+				}
+
+				if (lark) {
+					await sendLarkNotification(lark, {
+						msg_type: "interactive",
+						card: {
+							schema: "2.0",
+							config: {
+								update_multi: true,
+								style: {
+									text_size: {
+										normal_v2: {
+											default: "normal",
+											pc: "normal",
+											mobile: "heading",
+										},
+									},
 								},
-							],
+							},
+							header: {
+								title: {
+									tag: "plain_text",
+									content: "✅ Dokploy Server Restarted",
+								},
+								subtitle: {
+									tag: "plain_text",
+									content: "",
+								},
+								template: "green",
+								padding: "12px 12px 12px 12px",
+							},
+							body: {
+								direction: "vertical",
+								padding: "12px 12px 12px 12px",
+								elements: [
+									{
+										tag: "column_set",
+										columns: [
+											{
+												tag: "column",
+												width: "weighted",
+												elements: [
+													{
+														tag: "markdown",
+														content: "**Status:**\nSuccessful",
+														text_align: "left",
+														text_size: "normal_v2",
+													},
+												],
+												vertical_align: "top",
+												weight: 1,
+											},
+											{
+												tag: "column",
+												width: "weighted",
+												elements: [
+													{
+														tag: "markdown",
+														content: `**Restart Time:**\n${format(
+															date,
+															"PP pp",
+														)}`,
+														text_align: "left",
+														text_size: "normal_v2",
+													},
+												],
+												vertical_align: "top",
+												weight: 1,
+											},
+										],
+									},
+								],
+							},
 						},
-					],
-				});
+					});
+				}
+
+				if (pushover) {
+					await sendPushoverNotification(
+						pushover,
+						"Dokploy Server Restarted",
+						`Date: ${date.toLocaleString()}`,
+					);
+				}
+
+				if (teams) {
+					await sendTeamsNotification(teams, {
+						title: "✅ Dokploy Server Restarted",
+						facts: [
+							{ name: "Status", value: "Successful" },
+							{ name: "Restart Time", value: format(date, "PP pp") },
+						],
+					});
+				}
 			} catch (error) {
 				console.log(error);
 			}
 		}
+	} catch (error) {
+		console.error("[Dokploy] Restart notifications failed:", error);
 	}
 };

packages/server/src/utils/notifications/server-threshold.ts

@@ -2,8 +2,13 @@ import { and, eq } from "drizzle-orm";
 import { db } from "../../db";
 import { notifications } from "../../db/schema";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
+	sendPushoverNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";
 
@@ -34,6 +39,11 @@ export const sendServerThresholdNotifications = async (
 			discord: true,
 			telegram: true,
 			slack: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
 		},
 	});
 
@@ -41,62 +51,72 @@ export const sendServerThresholdNotifications = async (
 	const typeColor = 0xff0000; // Rojo para indicar alerta
 
 	for (const notification of notificationList) {
-		const { discord, telegram, slack } = notification;
+		const {
+			discord,
+			telegram,
+			slack,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
 
-		if (discord) {
-			const decorate = (decoration: string, text: string) =>
-				`${discord.decoration ? decoration : ""} ${text}`.trim();
+		try {
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
 
-			await sendDiscordNotification(discord, {
-				title: decorate(">", `\`⚠️\` Server ${payload.Type} Alert`),
-				color: typeColor,
-				fields: [
-					{
-						name: decorate("`🏷️`", "Server Name"),
-						value: payload.ServerName,
-						inline: true,
+				await sendDiscordNotification(discord, {
+					title: decorate(">", `\`⚠️\` Server ${payload.Type} Alert`),
+					color: typeColor,
+					fields: [
+						{
+							name: decorate("`🏷️`", "Server Name"),
+							value: payload.ServerName,
+							inline: true,
+						},
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate(typeEmoji, "Type"),
+							value: payload.Type,
+							inline: true,
+						},
+						{
+							name: decorate("📊", "Current Value"),
+							value: `${payload.Value.toFixed(2)}%`,
+							inline: true,
+						},
+						{
+							name: decorate("⚠️", "Threshold"),
+							value: `${payload.Threshold.toFixed(2)}%`,
+							inline: true,
+						},
+						{
+							name: decorate("`📜`", "Message"),
+							value: `\`\`\`${payload.Message}\`\`\``,
+						},
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Server Monitoring Alert",
 					},
-					{
-						name: decorate("`📅`", "Date"),
-						value: `<t:${unixDate}:D>`,
-						inline: true,
-					},
-					{
-						name: decorate("`⌚`", "Time"),
-						value: `<t:${unixDate}:t>`,
-						inline: true,
-					},
-					{
-						name: decorate(typeEmoji, "Type"),
-						value: payload.Type,
-						inline: true,
-					},
-					{
-						name: decorate("📊", "Current Value"),
-						value: `${payload.Value.toFixed(2)}%`,
-						inline: true,
-					},
-					{
-						name: decorate("⚠️", "Threshold"),
-						value: `${payload.Threshold.toFixed(2)}%`,
-						inline: true,
-					},
-					{
-						name: decorate("`📜`", "Message"),
-						value: `\`\`\`${payload.Message}\`\`\``,
-					},
-				],
-				timestamp: date.toISOString(),
-				footer: {
-					text: "Dokploy Server Monitoring Alert",
-				},
-			});
-		}
+				});
+			}
 
-		if (telegram) {
-			await sendTelegramNotification(
-				telegram,
-				`
+			if (telegram) {
+				await sendTelegramNotification(
+					telegram,
+					`
 				<b>⚠️ Server ${payload.Type} Alert</b>
                 <b>Server Name:</b> ${payload.ServerName}
 				<b>Type:</b> ${payload.Type}
@@ -105,49 +125,193 @@ export const sendServerThresholdNotifications = async (
 				<b>Message:</b> ${payload.Message}
 				<b>Time:</b> ${date.toLocaleString()}
 			`,
-			);
+				);
+			}
+
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: "#FF0000",
+							pretext: `:warning: *Server ${payload.Type} Alert*`,
+							fields: [
+								{
+									title: "Server Name",
+									value: payload.ServerName,
+									short: true,
+								},
+								{
+									title: "Type",
+									value: payload.Type,
+									short: true,
+								},
+								{
+									title: "Current Value",
+									value: `${payload.Value.toFixed(2)}%`,
+									short: true,
+								},
+								{
+									title: "Threshold",
+									value: `${payload.Threshold.toFixed(2)}%`,
+									short: true,
+								},
+								{
+									title: "Message",
+									value: payload.Message,
+								},
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				await sendMattermostNotification(mattermost, {
+					text: `**⚠️ Server ${payload.Type} Alert**\n\n**Server Name:** ${payload.ServerName}\n**Type:** ${payload.Type}\n**Current Value:** ${payload.Value.toFixed(2)}%\n**Threshold:** ${payload.Threshold.toFixed(2)}%\n**Message:** ${payload.Message}\n**Time:** ${date.toLocaleString()}`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy",
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: `Server ${payload.Type} Alert`,
+					message: payload.Message,
+					serverName: payload.ServerName,
+					type: payload.Type,
+					currentValue: payload.Value,
+					threshold: payload.Threshold,
+					timestamp: date.toISOString(),
+					date: date.toLocaleString(),
+					status: "alert",
+					alertType: "server-threshold",
+				});
+			}
+
+			if (lark) {
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
+								},
+							},
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content: `⚠️ Server ${payload.Type} Alert`,
+							},
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: "red",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Server Name:**\n${payload.ServerName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Current Value:**\n${payload.Value.toFixed(2)}%`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Alert Message:**\n${payload.Message}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Type:**\n${payload.Type === "CPU" ? "🔲" : "💾"} ${payload.Type}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Threshold:**\n${payload.Threshold.toFixed(2)}%`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Alert Time:**\n${date.toLocaleString()}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+							],
+						},
+					},
+				});
+			}
+
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					`Server ${payload.Type} Alert`,
+					`Server: ${payload.ServerName}\nType: ${payload.Type}\nCurrent: ${payload.Value.toFixed(2)}%\nThreshold: ${payload.Threshold.toFixed(2)}%\nMessage: ${payload.Message}\nTime: ${date.toLocaleString()}`,
+				);
+			}
+		} catch (error) {
+			console.log(error);
 		}
 
-		if (slack) {
-			const { channel } = slack;
-			await sendSlackNotification(slack, {
-				channel: channel,
-				attachments: [
-					{
-						color: "#FF0000",
-						pretext: `:warning: *Server ${payload.Type} Alert*`,
-						fields: [
-							{
-								title: "Server Name",
-								value: payload.ServerName,
-								short: true,
-							},
-							{
-								title: "Type",
-								value: payload.Type,
-								short: true,
-							},
-							{
-								title: "Current Value",
-								value: `${payload.Value.toFixed(2)}%`,
-								short: true,
-							},
-							{
-								title: "Threshold",
-								value: `${payload.Threshold.toFixed(2)}%`,
-								short: true,
-							},
-							{
-								title: "Message",
-								value: payload.Message,
-							},
-							{
-								title: "Time",
-								value: date.toLocaleString(),
-								short: true,
-							},
-						],
-					},
+		if (teams) {
+			await sendTeamsNotification(teams, {
+				title: `⚠️ Server ${payload.Type} Alert`,
+				facts: [
+					{ name: "Server Name", value: payload.ServerName },
+					{ name: "Type", value: payload.Type },
+					{ name: "Current Value", value: `${payload.Value.toFixed(2)}%` },
+					{ name: "Threshold", value: `${payload.Threshold.toFixed(2)}%` },
+					{ name: "Time", value: date.toLocaleString() },
+					{ name: "Message", value: payload.Message },
 				],
 			});
 		}

packages/server/src/utils/notifications/utils.ts

@@ -1,12 +1,19 @@
 import type {
+	custom,
 	discord,
 	email,
 	gotify,
+	lark,
+	mattermost,
 	ntfy,
+	pushover,
+	resend,
 	slack,
+	teams,
 	telegram,
 } from "@dokploy/server/db/schema";
 import nodemailer from "nodemailer";
+import { Resend } from "resend";
 
 export const sendEmailNotification = async (
 	connection: typeof email.$inferInsert,
@@ -37,6 +44,35 @@ export const sendEmailNotification = async (
 		});
 	} catch (err) {
 		console.log(err);
+		throw new Error(
+			`Failed to send email notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
+	}
+};
+
+export const sendResendNotification = async (
+	connection: typeof resend.$inferInsert,
+	subject: string,
+	htmlContent: string,
+) => {
+	try {
+		const client = new Resend(connection.apiKey);
+
+		const result = await client.emails.send({
+			from: connection.fromAddress,
+			to: connection.toAddresses,
+			subject,
+			html: htmlContent,
+		});
+
+		if (result.error) {
+			throw new Error(result.error.message);
+		}
+	} catch (err) {
+		console.log(err);
+		throw new Error(
+			`Failed to send Resend notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
 	}
 };
 
@@ -44,15 +80,23 @@ export const sendDiscordNotification = async (
 	connection: typeof discord.$inferInsert,
 	embed: any,
 ) => {
-	// try {
-	await fetch(connection.webhookUrl, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify({ embeds: [embed] }),
-	});
-	// } catch (err) {
-	// 	console.log(err);
-	// }
+	try {
+		const response = await fetch(connection.webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ embeds: [embed] }),
+		});
+		if (!response.ok) {
+			throw new Error(
+				`Failed to send discord notification ${response.statusText}`,
+			);
+		}
+	} catch (err) {
+		console.log("error", err);
+		throw new Error(
+			`Failed to send discord notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
+	}
 };
 
 export const sendTelegramNotification = async (
@@ -89,13 +133,21 @@ export const sendSlackNotification = async (
 	message: any,
 ) => {
 	try {
-		await fetch(connection.webhookUrl, {
+		const response = await fetch(connection.webhookUrl, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(message),
 		});
+		if (!response.ok) {
+			throw new Error(
+				`Failed to send slack notification ${response.statusText}`,
+			);
+		}
 	} catch (err) {
-		console.log(err);
+		console.log("error", err);
+		throw new Error(
+			`Failed to send slack notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
 	}
 };
 
@@ -139,7 +191,9 @@ export const sendNtfyNotification = async (
 	const response = await fetch(`${connection.serverUrl}/${connection.topic}`, {
 		method: "POST",
 		headers: {
-			Authorization: `Bearer ${connection.accessToken}`,
+			...(connection.accessToken && {
+				Authorization: `Bearer ${connection.accessToken}`,
+			}),
 			"X-Priority": connection.priority?.toString() || "3",
 			"X-Title": title,
 			"X-Tags": tags,
@@ -152,3 +206,186 @@ export const sendNtfyNotification = async (
 		throw new Error(`Failed to send ntfy notification: ${response.statusText}`);
 	}
 };
+
+export const sendMattermostNotification = async (
+	connection: typeof mattermost.$inferInsert,
+	message: any,
+) => {
+	const payload = {
+		...message,
+		// Only include username if it's provided and not empty
+		...(message.username?.trim() && { username: message.username }),
+		// Only include channel if it's provided and not empty
+		...(message.channel?.trim() && {
+			channel: `#${message.channel.replace("#", "")}`,
+		}),
+	};
+
+	const response = await fetch(connection.webhookUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload),
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`Failed to send Mattermost notification: ${response.statusText}`,
+		);
+	}
+};
+
+export const sendCustomNotification = async (
+	connection: typeof custom.$inferInsert,
+	payload: Record<string, any>,
+) => {
+	try {
+		// Merge default headers with custom headers (now already an object from jsonb)
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			...(connection.headers || {}),
+		};
+
+		// Default body with payload
+		const body = JSON.stringify(payload);
+
+		const response = await fetch(connection.endpoint, {
+			method: "POST",
+			headers,
+			body,
+		});
+
+		if (!response.ok) {
+			throw new Error(
+				`Failed to send custom notification: ${response.statusText}`,
+			);
+		}
+
+		return response;
+	} catch (error) {
+		console.error("Error sending custom notification:", error);
+		throw error;
+	}
+};
+
+export const sendLarkNotification = async (
+	connection: typeof lark.$inferInsert,
+	message: any,
+) => {
+	try {
+		await fetch(connection.webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(message),
+		});
+	} catch (err) {
+		console.log(err);
+	}
+};
+
+export interface TeamsAdaptiveCardMessage {
+	title: string;
+	themeColor?: string;
+	facts?: { name: string; value: string }[];
+	potentialAction?: { type: "Action.OpenUrl"; title: string; url: string };
+}
+
+export const sendTeamsNotification = async (
+	connection: typeof teams.$inferInsert,
+	message: TeamsAdaptiveCardMessage,
+) => {
+	try {
+		const bodyElements: Record<string, unknown>[] = [
+			{
+				type: "TextBlock",
+				text: message.title,
+				size: "Medium",
+				weight: "Bolder",
+				wrap: true,
+			},
+		];
+
+		if (message.facts && message.facts.length > 0) {
+			bodyElements.push({
+				type: "FactSet",
+				facts: message.facts.map((f) => ({
+					title: f.name,
+					value: f.value,
+				})),
+			});
+		}
+
+		const cardContent: Record<string, unknown> = {
+			type: "AdaptiveCard",
+			$schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+			version: "1.4",
+			body: bodyElements,
+		};
+
+		if (message.potentialAction) {
+			cardContent.actions = [
+				{
+					type: "Action.OpenUrl",
+					title: message.potentialAction.title,
+					url: message.potentialAction.url,
+				},
+			];
+		}
+
+		const payload = {
+			type: "message",
+			attachments: [
+				{
+					contentType: "application/vnd.microsoft.card.adaptive",
+					content: cardContent,
+				},
+			],
+		};
+
+		const response = await fetch(connection.webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+		});
+
+		if (!response.ok) {
+			throw new Error(
+				`Failed to send Teams notification: ${response.statusText}`,
+			);
+		}
+	} catch (err) {
+		console.log(err);
+		throw new Error(
+			`Failed to send Teams notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
+	}
+};
+
+export const sendPushoverNotification = async (
+	connection: typeof pushover.$inferInsert,
+	title: string,
+	message: string,
+) => {
+	const formData = new URLSearchParams();
+	formData.append("token", connection.apiToken);
+	formData.append("user", connection.userKey);
+	formData.append("title", title);
+	formData.append("message", message);
+	formData.append("priority", connection.priority?.toString() || "0");
+
+	// For emergency priority (2), retry and expire are required
+	if (connection.priority === 2) {
+		formData.append("retry", connection.retry?.toString() || "30");
+		formData.append("expire", connection.expire?.toString() || "3600");
+	}
+
+	const response = await fetch("https://api.pushover.net/1/messages.json", {
+		method: "POST",
+		body: formData,
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`Failed to send Pushover notification: ${response.statusText}`,
+		);
+	}
+};

packages/server/src/utils/notifications/volume-backup.ts

@@ -0,0 +1,497 @@
+import { db } from "@dokploy/server/db";
+import { notifications } from "@dokploy/server/db/schema";
+import { VolumeBackupEmail } from "@dokploy/server/emails/emails/volume-backup";
+import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
+import { and, eq } from "drizzle-orm";
+import {
+	sendCustomNotification,
+	sendDiscordNotification,
+	sendEmailNotification,
+	sendGotifyNotification,
+	sendLarkNotification,
+	sendMattermostNotification,
+	sendNtfyNotification,
+	sendPushoverNotification,
+	sendResendNotification,
+	sendSlackNotification,
+	sendTeamsNotification,
+	sendTelegramNotification,
+} from "./utils";
+
+export const sendVolumeBackupNotifications = async ({
+	projectName,
+	applicationName,
+	volumeName,
+	serviceType,
+	type,
+	errorMessage,
+	organizationId,
+	backupSize,
+}: {
+	projectName: string;
+	applicationName: string;
+	volumeName: string;
+	serviceType:
+		| "application"
+		| "postgres"
+		| "mysql"
+		| "mongodb"
+		| "mariadb"
+		| "redis"
+		| "compose"
+		| "libsql";
+	type: "error" | "success";
+	organizationId: string;
+	errorMessage?: string;
+	backupSize?: string;
+}) => {
+	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
+	const notificationList = await db.query.notifications.findMany({
+		where: and(
+			eq(notifications.volumeBackup, true),
+			eq(notifications.organizationId, organizationId),
+		),
+		with: {
+			email: true,
+			discord: true,
+			telegram: true,
+			slack: true,
+			resend: true,
+			gotify: true,
+			ntfy: true,
+			mattermost: true,
+			custom: true,
+			lark: true,
+			pushover: true,
+			teams: true,
+		},
+	});
+
+	for (const notification of notificationList) {
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			mattermost,
+			custom,
+			lark,
+			pushover,
+			teams,
+		} = notification;
+
+		try {
+			if (email || resend) {
+				const subject = `Volume Backup ${type === "success" ? "Successful" : "Failed"} - ${applicationName}`;
+				const htmlContent = await renderAsync(
+					VolumeBackupEmail({
+						projectName,
+						applicationName,
+						volumeName,
+						serviceType,
+						type,
+						errorMessage,
+						backupSize,
+						date: date.toISOString(),
+					}),
+				);
+				if (email) {
+					await sendEmailNotification(email, subject, htmlContent);
+				}
+				if (resend) {
+					await sendResendNotification(resend, subject, htmlContent);
+				}
+			}
+
+			if (discord) {
+				const decorate = (decoration: string, text: string) =>
+					`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+				await sendDiscordNotification(discord, {
+					title:
+						type === "success"
+							? decorate(">", "`✅` Volume Backup Successful")
+							: decorate(">", "`❌` Volume Backup Failed"),
+					color: type === "success" ? 0x57f287 : 0xed4245,
+					fields: [
+						{
+							name: decorate("`🛠️`", "Project"),
+							value: projectName,
+							inline: true,
+						},
+						{
+							name: decorate("`⚙️`", "Application"),
+							value: applicationName,
+							inline: true,
+						},
+						{
+							name: decorate("`💾`", "Volume Name"),
+							value: volumeName,
+							inline: true,
+						},
+						{
+							name: decorate("`🔧`", "Service Type"),
+							value: serviceType,
+							inline: true,
+						},
+						...(backupSize
+							? [
+									{
+										name: decorate("`📊`", "Backup Size"),
+										value: backupSize,
+										inline: true,
+									},
+								]
+							: []),
+						{
+							name: decorate("`📅`", "Date"),
+							value: `<t:${unixDate}:D>`,
+							inline: true,
+						},
+						{
+							name: decorate("`⌚`", "Time"),
+							value: `<t:${unixDate}:t>`,
+							inline: true,
+						},
+						{
+							name: decorate("`❓`", "Type"),
+							value: type
+								.replace("error", "Failed")
+								.replace("success", "Successful"),
+							inline: true,
+						},
+						...(type === "error" && errorMessage
+							? [
+									{
+										name: decorate("`⚠️`", "Error Message"),
+										value: `\`\`\`${errorMessage}\`\`\``,
+									},
+								]
+							: []),
+					],
+					timestamp: date.toISOString(),
+					footer: {
+						text: "Dokploy Volume Backup Notification",
+					},
+				});
+			}
+
+			if (gotify) {
+				const decorate = (decoration: string, text: string) =>
+					`${gotify.decoration ? decoration : ""} ${text}\n`;
+
+				await sendGotifyNotification(
+					gotify,
+					decorate(
+						type === "success" ? "✅" : "❌",
+						`Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+					),
+					`${decorate("🛠️", `Project: ${projectName}`)}` +
+						`${decorate("⚙️", `Application: ${applicationName}`)}` +
+						`${decorate("💾", `Volume Name: ${volumeName}`)}` +
+						`${decorate("🔧", `Service Type: ${serviceType}`)}` +
+						`${backupSize ? decorate("📊", `Backup Size: ${backupSize}`) : ""}` +
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}` +
+						`${type === "error" && errorMessage ? decorate("❌", `Error:\n${errorMessage}`) : ""}`,
+				);
+			}
+
+			if (ntfy) {
+				await sendNtfyNotification(
+					ntfy,
+					`Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+					`${type === "success" ? "white_check_mark" : "x"}`,
+					"",
+					`🛠️Project: ${projectName}\n` +
+						`⚙️Application: ${applicationName}\n` +
+						`💾Volume Name: ${volumeName}\n` +
+						`🔧Service Type: ${serviceType}\n` +
+						`${backupSize ? `📊Backup Size: ${backupSize}\n` : ""}` +
+						`🕒Date: ${date.toLocaleString()}\n` +
+						`${type === "error" && errorMessage ? `❌Error:\n${errorMessage}` : ""}`,
+				);
+			}
+
+			if (telegram) {
+				const isError = type === "error" && errorMessage;
+
+				const statusEmoji = type === "success" ? "✅" : "❌";
+				const typeStatus = type === "success" ? "Successful" : "Failed";
+				const errorMsg = isError
+					? `\n\n<b>Error:</b>\n<pre>${errorMessage}</pre>`
+					: "";
+				const sizeInfo = backupSize
+					? `\n<b>Backup Size:</b> ${backupSize}`
+					: "";
+
+				const messageText = `<b>${statusEmoji} Volume Backup ${typeStatus}</b>\n\n<b>Project:</b> ${projectName}\n<b>Application:</b> ${applicationName}\n<b>Volume Name:</b> ${volumeName}\n<b>Service Type:</b> ${serviceType}${sizeInfo}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}${isError ? errorMsg : ""}`;
+
+				await sendTelegramNotification(telegram, messageText);
+			}
+
+			if (slack) {
+				const { channel } = slack;
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: type === "success" ? "#00FF00" : "#FF0000",
+							pretext:
+								type === "success"
+									? ":white_check_mark: *Volume Backup Successful*"
+									: ":x: *Volume Backup Failed*",
+							fields: [
+								...(type === "error" && errorMessage
+									? [
+											{
+												title: "Error Message",
+												value: errorMessage,
+												short: false,
+											},
+										]
+									: []),
+								{
+									title: "Project",
+									value: projectName,
+									short: true,
+								},
+								{
+									title: "Application",
+									value: applicationName,
+									short: true,
+								},
+								{
+									title: "Volume Name",
+									value: volumeName,
+									short: true,
+								},
+								{
+									title: "Service Type",
+									value: serviceType,
+									short: true,
+								},
+								...(backupSize
+									? [
+											{
+												title: "Backup Size",
+												value: backupSize,
+												short: true,
+											},
+										]
+									: []),
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+								{
+									title: "Type",
+									value: type,
+									short: true,
+								},
+								{
+									title: "Status",
+									value: type === "success" ? "Successful" : "Failed",
+									short: true,
+								},
+							],
+						},
+					],
+				});
+			}
+
+			if (mattermost) {
+				const statusEmoji = type === "success" ? "✅" : "❌";
+				const typeStatus = type === "success" ? "Successful" : "Failed";
+				const errorMsg =
+					type === "error" && errorMessage
+						? `\n\n**Error:**\n\`\`\`\n${errorMessage}\n\`\`\``
+						: "";
+				const sizeInfo = backupSize ? `\n**Backup Size:** ${backupSize}` : "";
+
+				await sendMattermostNotification(mattermost, {
+					text: `**${statusEmoji} Volume Backup ${typeStatus}**\n\n**Project:** ${projectName}\n**Application:** ${applicationName}\n**Volume Name:** ${volumeName}\n**Service Type:** ${serviceType}${sizeInfo}\n**Date:** ${format(date, "PP")}\n**Time:** ${format(date, "pp")}${errorMsg}`,
+					channel: mattermost.channel,
+					username: mattermost.username || "Dokploy",
+				});
+			}
+
+			if (lark) {
+				const limitCharacter = 800;
+				const truncatedErrorMessage =
+					errorMessage && errorMessage.length > limitCharacter
+						? errorMessage.substring(0, limitCharacter)
+						: errorMessage;
+
+				await sendLarkNotification(lark, {
+					msg_type: "interactive",
+					card: {
+						schema: "2.0",
+						config: {
+							update_multi: true,
+							style: {
+								text_size: {
+									normal_v2: {
+										default: "normal",
+										pc: "normal",
+										mobile: "heading",
+									},
+								},
+							},
+						},
+						header: {
+							title: {
+								tag: "plain_text",
+								content:
+									type === "success"
+										? "✅ Volume Backup Successful"
+										: "❌ Volume Backup Failed",
+							},
+							subtitle: {
+								tag: "plain_text",
+								content: "",
+							},
+							template: type === "success" ? "green" : "red",
+							padding: "12px 12px 12px 12px",
+						},
+						body: {
+							direction: "vertical",
+							padding: "12px 12px 12px 12px",
+							elements: [
+								{
+									tag: "column_set",
+									columns: [
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Project:**\n${projectName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Volume Name:**\n${volumeName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Status:**\n${type === "success" ? "Successful" : "Failed"}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+										{
+											tag: "column",
+											width: "weighted",
+											elements: [
+												{
+													tag: "markdown",
+													content: `**Application:**\n${applicationName}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Service Type:**\n${serviceType}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+												{
+													tag: "markdown",
+													content: `**Date:**\n${format(date, "PP pp")}`,
+													text_align: "left",
+													text_size: "normal_v2",
+												},
+											],
+											vertical_align: "top",
+											weight: 1,
+										},
+									],
+								},
+								...(type === "error" && truncatedErrorMessage
+									? [
+											{
+												tag: "markdown",
+												content: `**Error Message:**\n\`\`\`\n${truncatedErrorMessage}\n\`\`\``,
+												text_align: "left",
+												text_size: "normal_v2",
+											},
+										]
+									: []),
+							],
+						},
+					},
+				});
+			}
+
+			if (pushover) {
+				await sendPushoverNotification(
+					pushover,
+					`Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+					`Project: ${projectName}\nApplication: ${applicationName}\nVolume: ${volumeName}\nService Type: ${serviceType}${backupSize ? `\nBackup Size: ${backupSize}` : ""}\nDate: ${date.toLocaleString()}${type === "error" && errorMessage ? `\nError: ${errorMessage}` : ""}`,
+				);
+			}
+
+			if (teams) {
+				const facts = [
+					{ name: "Project", value: projectName },
+					{ name: "Application", value: applicationName },
+					{ name: "Volume Name", value: volumeName },
+					{ name: "Service Type", value: serviceType },
+					{ name: "Date", value: format(date, "PP pp") },
+					{
+						name: "Status",
+						value: type === "success" ? "Successful" : "Failed",
+					},
+				];
+				if (backupSize) {
+					facts.push({ name: "Backup Size", value: backupSize });
+				}
+				if (type === "error" && errorMessage) {
+					facts.push({ name: "Error", value: errorMessage.substring(0, 500) });
+				}
+				await sendTeamsNotification(teams, {
+					title:
+						type === "success"
+							? "✅ Volume Backup Successful"
+							: "❌ Volume Backup Failed",
+					facts,
+				});
+			}
+
+			if (custom) {
+				await sendCustomNotification(custom, {
+					title: `Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+					message:
+						type === "success"
+							? "Volume backup completed successfully"
+							: "Volume backup failed",
+					projectName,
+					applicationName,
+					volumeName,
+					serviceType,
+					type,
+					errorMessage: errorMessage ?? "",
+					backupSize: backupSize ?? "",
+					timestamp: date.toISOString(),
+					date: date.toLocaleString(),
+					status: type,
+				});
+			}
+		} catch (error) {
+			console.log(error);
+		}
+	}
+};

packages/server/src/utils/process/ExecError.ts

@@ -0,0 +1,55 @@
+export interface ExecErrorDetails {
+	command: string;
+	stdout?: string;
+	stderr?: string;
+	exitCode?: number;
+	originalError?: Error;
+	serverId?: string | null;
+}
+
+export class ExecError extends Error {
+	public readonly command: string;
+	public readonly stdout?: string;
+	public readonly stderr?: string;
+	public readonly exitCode?: number;
+	public readonly originalError?: Error;
+	public readonly serverId?: string | null;
+
+	constructor(message: string, details: ExecErrorDetails) {
+		super(message);
+		this.name = "ExecError";
+		this.command = details.command;
+		this.stdout = details.stdout;
+		this.stderr = details.stderr;
+		this.exitCode = details.exitCode;
+		this.originalError = details.originalError;
+		this.serverId = details.serverId;
+
+		// Maintains proper stack trace for where our error was thrown (only available on V8)
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, ExecError);
+		}
+	}
+
+	/**
+	 * Get a formatted error message with all details
+	 */
+	getDetailedMessage(): string {
+		const parts = [
+			`Command: ${this.command}`,
+			this.exitCode !== undefined ? `Exit Code: ${this.exitCode}` : null,
+			this.serverId ? `Server ID: ${this.serverId}` : "Location: Local",
+			this.stderr ? `Stderr: ${this.stderr}` : null,
+			this.stdout ? `Stdout: ${this.stdout}` : null,
+		].filter(Boolean);
+
+		return `${this.message}\n${parts.join("\n")}`;
+	}
+
+	/**
+	 * Check if this error is from a remote execution
+	 */
+	isRemote(): boolean {
+		return !!this.serverId;
+	}
+}

packages/server/src/utils/process/execAsync.ts

@@ -2,8 +2,43 @@ import { exec, execFile } from "node:child_process";
 import util from "node:util";
 import { findServerById } from "@dokploy/server/services/server";
 import { Client } from "ssh2";
+import { ExecError } from "./ExecError";
 
-export const execAsync = util.promisify(exec);
+// Re-export ExecError for easier imports
+export { ExecError } from "./ExecError";
+
+const execAsyncBase = util.promisify(exec);
+
+export const execAsync = async (
+	command: string,
+	options?: { cwd?: string; env?: NodeJS.ProcessEnv; shell?: string },
+): Promise<{ stdout: string; stderr: string }> => {
+	try {
+		const result = await execAsyncBase(command, options);
+		return {
+			stdout: result.stdout.toString(),
+			stderr: result.stderr.toString(),
+		};
+	} catch (error) {
+		if (error instanceof Error) {
+			// @ts-ignore - exec error has these properties
+			const exitCode = error.code;
+			// @ts-ignore
+			const stdout = error.stdout?.toString() || "";
+			// @ts-ignore
+			const stderr = error.stderr?.toString() || "";
+
+			throw new ExecError(`Command execution failed: ${error.message}`, {
+				command,
+				stdout,
+				stderr,
+				exitCode,
+				originalError: error,
+			});
+		}
+		throw error;
+	}
+};
 
 interface ExecOptions {
 	cwd?: string;
@@ -21,7 +56,16 @@ export const execAsyncStream = (
 
 		const childProcess = exec(command, options, (error) => {
 			if (error) {
-				reject(error);
+				reject(
+					new ExecError(`Command execution failed: ${error.message}`, {
+						command,
+						stdout: stdoutComplete,
+						stderr: stderrComplete,
+						// @ts-ignore
+						exitCode: error.code,
+						originalError: error,
+					}),
+				);
 				return;
 			}
 			resolve({ stdout: stdoutComplete, stderr: stderrComplete });
@@ -45,7 +89,14 @@ export const execAsyncStream = (
 
 		childProcess.on("error", (error) => {
 			console.log(error);
-			reject(error);
+			reject(
+				new ExecError(`Command execution error: ${error.message}`, {
+					command,
+					stdout: stdoutComplete,
+					stderr: stderrComplete,
+					originalError: error,
+				}),
+			);
 		});
 	});
 };
@@ -108,7 +159,14 @@ export const execAsyncRemote = async (
 				conn.exec(command, (err, stream) => {
 					if (err) {
 						onData?.(err.message);
-						throw err;
+						reject(
+							new ExecError(`Remote command execution failed: ${err.message}`, {
+								command,
+								serverId,
+								originalError: err,
+							}),
+						);
+						return;
 					}
 					stream
 						.on("close", (code: number, _signal: string) => {
@@ -117,8 +175,15 @@ export const execAsyncRemote = async (
 								resolve({ stdout, stderr });
 							} else {
 								reject(
-									new Error(
-										`Command exited with code ${code}. Stderr: ${stderr}, command: ${command}`,
+									new ExecError(
+										`Remote command failed with exit code ${code}`,
+										{
+											command,
+											stdout,
+											stderr,
+											exitCode: code,
+											serverId,
+										},
 									),
 								);
 							}
@@ -136,17 +201,42 @@ export const execAsyncRemote = async (
 			.on("error", (err) => {
 				conn.end();
 				if (err.level === "client-authentication") {
-					onData?.(
-						`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
-					);
+					const technicalDetail = `Error: ${err.message} ${err.level}`;
+					const friendlyMessage = [
+						"",
+						"❌ Couldn't connect to your server — the SSH key was not accepted.",
+						"",
+						"This usually means the key doesn't match what's on the server, or the key format is invalid.",
+						"",
+						`Technical details: ${technicalDetail}`,
+						"",
+						"💡 Hints:",
+						"  • Check that the SSH key you added in Dokploy is the same one installed on the server (e.g. in ~/.ssh/authorized_keys).",
+						"  • Try generating a new SSH key in Dokploy and add only the public key to the server, then try again.",
+						"  • Make sure to follow the instructions on the Setup Server Button on the SSH Keys tab and then click on deployments tab and check the logs for more details.",
+					].join("\n");
+					const errorMsg = `Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`;
+					onData?.(friendlyMessage);
 					reject(
-						new Error(
-							`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
+						new ExecError(
+							`Authentication failed: Invalid SSH private key. ${friendlyMessage}`,
+							{
+								command,
+								serverId,
+								originalError: err,
+							},
 						),
 					);
 				} else {
-					onData?.(`SSH connection error: ${err.message}`);
-					reject(new Error(`SSH connection error: ${err.message}`));
+					const errorMsg = `SSH connection error: ${err.message}`;
+					onData?.(errorMsg);
+					reject(
+						new ExecError(errorMsg, {
+							command,
+							serverId,
+							originalError: err,
+						}),
+					);
 				}
 			})
 			.connect({

packages/server/src/utils/providers/bitbucket.ts

@@ -1,4 +1,3 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type {
@@ -9,12 +8,9 @@ import {
 	type Bitbucket,
 	findBitbucketById,
 } from "@dokploy/server/services/bitbucket";
-import type { Compose } from "@dokploy/server/services/compose";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
+import type { z } from "zod";
 
 export type ApplicationWithBitbucket = InferResultType<
 	"applications",
@@ -81,202 +77,56 @@ export const getBitbucketHeaders = (bitbucketProvider: Bitbucket) => {
 	};
 };
 
-export const cloneBitbucketRepository = async (
-	entity: ApplicationWithBitbucket | ComposeWithBitbucket,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths();
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+interface CloneBitbucketRepository {
+	appName: string;
+	bitbucketRepository: string | null;
+	bitbucketRepositorySlug?: string | null;
+	bitbucketOwner: string | null;
+	bitbucketBranch: string | null;
+	bitbucketId: string | null;
+	enableSubmodules: boolean;
+	serverId: string | null;
+	type?: "application" | "compose";
+	outputPathOverride?: string;
+}
+
+export const cloneBitbucketRepository = async ({
+	type = "application",
+	...entity
+}: CloneBitbucketRepository) => {
+	let command = "set -e;";
 	const {
 		appName,
 		bitbucketRepository,
 		bitbucketOwner,
 		bitbucketBranch,
 		bitbucketId,
-		bitbucket,
 		enableSubmodules,
+		serverId,
+		outputPathOverride,
 	} = entity;
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
+		command += `echo "Error: ❌ Bitbucket Provider not found"; exit 1;`;
+		return command;
 	}
+	const bitbucket = await findBitbucketById(bitbucketId);
 
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
+	if (!bitbucket) {
+		command += `echo "Error: ❌ Bitbucket Provider not found"; exit 1;`;
+		return command;
+	}
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
+	const repoToUse = entity.bitbucketRepositorySlug || bitbucketRepository;
+	const repoclone = `bitbucket.org/${bitbucketOwner}/${repoToUse}.git`;
 	const cloneUrl = getBitbucketCloneUrl(bitbucket, repoclone);
-	try {
-		writeStream.write(`\nCloning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			bitbucketBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoclone} to ${outputPath}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const cloneRawBitbucketRepository = async (entity: Compose) => {
-	const { COMPOSE_PATH } = paths();
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		enableSubmodules,
-	} = entity;
-
-	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			bitbucketBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawBitbucketRepositoryRemote = async (compose: Compose) => {
-	const { COMPOSE_PATH } = paths(true);
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	try {
-		const cloneCommand = `
-			rm -rf ${outputPath};
-			git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, cloneCommand);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const getBitbucketCloneCommand = async (
-	entity: ApplicationWithBitbucket | ComposeWithBitbucket,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!bitbucketId) {
-		const command = `
-			echo  "Error: ❌ Bitbucket Provider not found" >> ${logPath};
-			exit 1;
-		`;
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone the repository ${repoclone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
+	command += `echo "Cloning Repo ${repoclone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const getBitbucketRepositories = async (bitbucketId?: string) => {
@@ -292,6 +142,7 @@ export const getBitbucketRepositories = async (bitbucketId?: string) => {
 	let repositories: {
 		name: string;
 		url: string;
+		slug: string;
 		owner: { username: string };
 	}[] = [];
 
@@ -314,6 +165,7 @@ export const getBitbucketRepositories = async (bitbucketId?: string) => {
 			const mappedData = data.values.map((repo: any) => ({
 				name: repo.name,
 				url: repo.links.html.href,
+				slug: repo.slug,
 				owner: {
 					username: repo.workspace.slug,
 				},
@@ -328,7 +180,7 @@ export const getBitbucketRepositories = async (bitbucketId?: string) => {
 };
 
 export const getBitbucketBranches = async (
-	input: typeof apiFindBitbucketBranches._type,
+	input: z.infer<typeof apiFindBitbucketBranches>,
 ) => {
 	if (!input.bitbucketId) {
 		return [];
@@ -383,7 +235,7 @@ export const getBitbucketBranches = async (
 };
 
 export const testBitbucketConnection = async (
-	input: typeof apiBitbucketTestConnection._type,
+	input: z.infer<typeof apiBitbucketTestConnection>,
 ) => {
 	const bitbucketProvider = await findBitbucketById(input.bitbucketId);
 

packages/server/src/utils/providers/docker.ts

@@ -1,60 +1,6 @@
-import { createWriteStream } from "node:fs";
-import { type ApplicationNested, mechanizeDockerContainer } from "../builders";
-import { pullImage } from "../docker/utils";
+import type { ApplicationNested } from "../builders";
 
-interface RegistryAuth {
-	username: string;
-	password: string;
-	registryUrl: string;
-}
-
-export const buildDocker = async (
-	application: ApplicationNested,
-	logPath: string,
-): Promise<void> => {
-	const { buildType, dockerImage, username, password } = application;
-	const authConfig: Partial<RegistryAuth> = {
-		username: username || "",
-		password: password || "",
-		registryUrl: application.registryUrl || "",
-	};
-
-	const writeStream = createWriteStream(logPath, { flags: "a" });
-
-	writeStream.write(`\nBuild ${buildType}\n`);
-
-	writeStream.write(`Pulling ${dockerImage}: ✅\n`);
-
-	try {
-		if (!dockerImage) {
-			throw new Error("Docker image not found");
-		}
-
-		await pullImage(
-			dockerImage,
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(`${data}\n`);
-				}
-			},
-			authConfig,
-		);
-		await mechanizeDockerContainer(application);
-		writeStream.write("\nDocker Deployed: ✅\n");
-	} catch (error) {
-		writeStream.write(
-			`❌ Error: ${error instanceof Error ? error.message : String(error)}`,
-		);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const buildRemoteDocker = async (
-	application: ApplicationNested,
-	logPath: string,
-) => {
+export const buildRemoteDocker = async (application: ApplicationNested) => {
 	const { registryUrl, dockerImage, username, password } = application;
 
 	try {
@@ -62,25 +8,25 @@ export const buildRemoteDocker = async (
 			throw new Error("Docker image not found");
 		}
 		let command = `
-echo "Pulling ${dockerImage}" >> ${logPath};		
+echo "Pulling ${dockerImage}";		
 		`;
 
 		if (username && password) {
 			command += `
-if ! echo "${password}" | docker login --username "${username}" --password-stdin "${registryUrl || ""}" >> ${logPath} 2>&1; then
-	echo "❌ Login failed" >> ${logPath};
+if ! echo "${password}" | docker login --username "${username}" --password-stdin "${registryUrl || ""}" 2>&1; then
+	echo "❌ Login failed";
 	exit 1;
 fi
 `;
 		}
 
 		command += `
-docker pull ${dockerImage} >> ${logPath} 2>> ${logPath} || { 
-  echo "❌ Pulling image failed" >> ${logPath};
+docker pull ${dockerImage} 2>&1 || { 
+  echo "❌ Pulling image failed";
   exit 1;
 }
 
-echo "✅ Pulling image completed." >> ${logPath};
+echo "✅ Pulling image completed.";
 `;
 		return command;
 	} catch (error) {

packages/server/src/utils/providers/git.ts

@@ -1,159 +1,67 @@
-import { createWriteStream } from "node:fs";
 import path, { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { Compose } from "@dokploy/server/services/compose";
 import {
 	findSSHKeyById,
 	updateSSHKeyById,
 } from "@dokploy/server/services/ssh-key";
-import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
-export const cloneGitRepository = async (
-	entity: {
-		appName: string;
-		customGitUrl?: string | null;
-		customGitBranch?: string | null;
-		customGitSSHKeyId?: string | null;
-		enableSubmodules?: boolean;
-	},
-	logPath: string,
-	isCompose = false,
-) => {
-	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths();
+interface CloneGitRepository {
+	appName: string;
+	customGitUrl?: string | null;
+	customGitBranch?: string | null;
+	customGitSSHKeyId?: string | null;
+	enableSubmodules?: boolean;
+	serverId: string | null;
+	type?: "application" | "compose";
+	outputPathOverride?: string;
+}
+
+export const cloneGitRepository = async ({
+	type = "application",
+	...entity
+}: CloneGitRepository) => {
+	let command = "set -e;";
 	const {
 		appName,
 		customGitUrl,
 		customGitBranch,
 		customGitSSHKeyId,
 		enableSubmodules,
+		serverId,
+		outputPathOverride,
 	} = entity;
+	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!customGitUrl || !customGitBranch) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
+		command += `echo "Error: ❌ Repository not found"; exit 1;`;
+		return command;
 	}
 
-	const writeStream = createWriteStream(logPath, { flags: "a" });
 	const temporalKeyPath = path.join("/tmp", "id_rsa");
 
 	if (customGitSSHKeyId) {
 		const sshKey = await findSSHKeyById(customGitSSHKeyId);
 
-		await execAsync(`
+		command += `
 			echo "${sshKey.privateKey}" > ${temporalKeyPath}
-			chmod 600 ${temporalKeyPath}
-			`);
+			chmod 600 ${temporalKeyPath};
+			`;
 	}
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
 
-	try {
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				throw new TRPCError({
-					code: "BAD_REQUEST",
-					message:
-						"Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key",
-				});
-			}
-			await addHostToKnownHosts(customGitUrl);
+	if (!isHttpOrHttps(customGitUrl)) {
+		if (!customGitSSHKeyId) {
+			command += `echo "Error: ❌ You are trying to clone a ssh repository without a ssh key, please set a ssh key"; exit 1;`;
+			return command;
 		}
-		await recreateDirectory(outputPath);
-		writeStream.write(
-			`\nCloning Repo Custom ${customGitUrl} to ${outputPath}: ✅\n`,
-		);
-
-		if (customGitSSHKeyId) {
-			await updateSSHKeyById({
-				sshKeyId: customGitSSHKeyId,
-				lastUsedAt: new Date().toISOString(),
-			});
-		}
-
-		const { port } = sanitizeRepoPathSSH(customGitUrl);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			customGitBranch,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			customGitUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync(
-			"git",
-			cloneArgs,
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-			{
-				env: {
-					...process.env,
-					...(customGitSSHKeyId && {
-						GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath}${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`,
-					}),
-				},
-			},
-		);
-
-		writeStream.write(`\nCloned Custom Git ${customGitUrl}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`\nERROR Cloning Custom Git: ${error}: ❌\n`);
-		throw error;
-	} finally {
-		writeStream.end();
+		command += addHostToKnownHostsCommand(customGitUrl);
 	}
-};
-
-export const getCustomGitCloneCommand = async (
-	entity: {
-		appName: string;
-		customGitUrl?: string | null;
-		customGitBranch?: string | null;
-		customGitSSHKeyId?: string | null;
-		serverId: string | null;
-		enableSubmodules: boolean;
-	},
-	logPath: string,
-	isCompose = false,
-) => {
-	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const {
-		appName,
-		customGitUrl,
-		customGitBranch,
-		customGitSSHKeyId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!customGitUrl || !customGitBranch) {
-		const command = `
-			echo  "Error: ❌ Repository not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
-	}
-
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
+	command += `echo "Cloning Repo Custom ${customGitUrl} to ${outputPath}: ✅";`;
 
 	if (customGitSSHKeyId) {
 		await updateSSHKeyById({
@@ -161,48 +69,22 @@ export const getCustomGitCloneCommand = async (
 			lastUsedAt: new Date().toISOString(),
 		});
 	}
-	try {
-		const command = [];
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				command.push(
-					`echo "Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key ❌" >> ${logPath};
-					 exit 1;
-					`,
-				);
-			}
-			command.push(addHostToKnownHostsCommand(customGitUrl));
-		}
-		command.push(`rm -rf ${outputPath};`);
-		command.push(`mkdir -p ${outputPath};`);
-		command.push(
-			`echo "Cloning Custom Git ${customGitUrl}" to ${outputPath}: ✅ >> ${logPath};`,
-		);
-		if (customGitSSHKeyId) {
-			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const { port } = sanitizeRepoPathSSH(customGitUrl);
-			const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
-			command.push(
-				`
-				echo "${sshKey.privateKey}" > /tmp/id_rsa
-				chmod 600 /tmp/id_rsa
-				export GIT_SSH_COMMAND="${gitSshCommand}"
-				`,
-			);
-		}
 
-		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath} >> ${logPath} 2>&1; then
-				echo "❌ [ERROR] Fail to clone the repository ${customGitUrl}" >> ${logPath};
+	if (customGitSSHKeyId) {
+		const sshKey = await findSSHKeyById(customGitSSHKeyId);
+		const { port } = sanitizeRepoPathSSH(customGitUrl);
+		const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
+		command += `echo "${sshKey.privateKey}" > /tmp/id_rsa;`;
+		command += "chmod 600 /tmp/id_rsa;";
+		command += `export GIT_SSH_COMMAND="${gitSshCommand}";`;
+	}
+	command += `if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath}; then
+				echo "❌ [ERROR] Fail to clone the repository ${customGitUrl}";
 				exit 1;
 			fi
-			`,
-		);
-		command.push(`echo "Cloned Custom Git ${customGitUrl}: ✅" >> ${logPath};`);
-		return command.join("\n");
-	} catch (error) {
-		throw error;
-	}
+			`;
+
+	return command;
 };
 
 const isHttpOrHttps = (url: string): boolean => {
@@ -210,19 +92,19 @@ const isHttpOrHttps = (url: string): boolean => {
 	return regex.test(url);
 };
 
-const addHostToKnownHosts = async (repositoryURL: string) => {
-	const { SSH_PATH } = paths();
-	const { domain, port } = sanitizeRepoPathSSH(repositoryURL);
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
+// const addHostToKnownHosts = async (repositoryURL: string) => {
+// 	const { SSH_PATH } = paths();
+// 	const { domain, port } = sanitizeRepoPathSSH(repositoryURL);
+// 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
 
-	const command = `ssh-keyscan -p ${port} ${domain} >> ${knownHostsPath}`;
-	try {
-		await execAsync(command);
-	} catch (error) {
-		console.error(`Error adding host to known_hosts: ${error}`);
-		throw error;
-	}
-};
+// 	const command = `ssh-keyscan -p ${port} ${domain} >> ${knownHostsPath}`;
+// 	try {
+// 		await execAsync(command);
+// 	} catch (error) {
+// 		console.error(`Error adding host to known_hosts: ${error}`);
+// 		throw error;
+// 	}
+// };
 
 const addHostToKnownHostsCommand = (repositoryURL: string) => {
 	const { SSH_PATH } = paths(true);
@@ -267,160 +149,43 @@ const sanitizeRepoPathSSH = (input: string) => {
 	};
 };
 
-export const cloneGitRawRepository = async (entity: {
+interface Props {
 	appName: string;
-	customGitUrl?: string | null;
-	customGitBranch?: string | null;
-	customGitSSHKeyId?: string | null;
-	enableSubmodules?: boolean;
-}) => {
-	const {
-		appName,
-		customGitUrl,
-		customGitBranch,
-		customGitSSHKeyId,
-		enableSubmodules,
-	} = entity;
+	type?: "application" | "compose";
+	serverId: string | null;
+}
 
-	if (!customGitUrl || !customGitBranch) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
-	}
-
-	const { SSH_PATH, COMPOSE_PATH } = paths();
-	const temporalKeyPath = path.join("/tmp", "id_rsa");
-	const basePath = COMPOSE_PATH;
+export const getGitCommitInfo = async ({
+	appName,
+	type = "application",
+	serverId,
+}: Props) => {
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
-
-	if (customGitSSHKeyId) {
-		const sshKey = await findSSHKeyById(customGitSSHKeyId);
-
-		await execAsync(`
-			echo "${sshKey.privateKey}" > ${temporalKeyPath}
-			chmod 600 ${temporalKeyPath}
-			`);
-	}
-
+	let stdoutResult = "";
+	const result = {
+		message: "",
+		hash: "",
+	};
 	try {
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				throw new TRPCError({
-					code: "BAD_REQUEST",
-					message:
-						"Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key",
-				});
-			}
-			await addHostToKnownHosts(customGitUrl);
-		}
-		await recreateDirectory(outputPath);
-
-		if (customGitSSHKeyId) {
-			await updateSSHKeyById({
-				sshKeyId: customGitSSHKeyId,
-				lastUsedAt: new Date().toISOString(),
-			});
+		const gitCommand = `git -C ${outputPath} log -1 --pretty=format:"%H---DELIMITER---%B"`;
+		if (serverId) {
+			const { stdout } = await execAsyncRemote(serverId, gitCommand);
+			stdoutResult = stdout.trim();
+		} else {
+			const { stdout } = await execAsync(gitCommand);
+			stdoutResult = stdout.trim();
 		}
 
-		const { port } = sanitizeRepoPathSSH(customGitUrl);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			customGitBranch,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			customGitUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (_data) => {}, {
-			env: {
-				...process.env,
-				...(customGitSSHKeyId && {
-					GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath}${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`,
-				}),
-			},
-		});
+		const parts = stdoutResult.split("---DELIMITER---");
+		if (parts && parts.length === 2) {
+			result.hash = parts[0]?.trim() || "";
+			result.message = parts[1]?.trim() || "";
+		}
 	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGitRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		customGitBranch,
-		customGitUrl,
-		customGitSSHKeyId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!customGitUrl) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Git Provider not found",
-		});
-	}
-
-	const { SSH_PATH, COMPOSE_PATH } = paths(true);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
-
-	if (customGitSSHKeyId) {
-		await updateSSHKeyById({
-			sshKeyId: customGitSSHKeyId,
-			lastUsedAt: new Date().toISOString(),
-		});
-	}
-	try {
-		const command = [];
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				command.push(
-					`echo "Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key ❌" ;
-					 exit 1;
-					`,
-				);
-			}
-			command.push(addHostToKnownHostsCommand(customGitUrl));
-		}
-		command.push(`rm -rf ${outputPath};`);
-		command.push(`mkdir -p ${outputPath};`);
-		if (customGitSSHKeyId) {
-			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const { port } = sanitizeRepoPathSSH(customGitUrl);
-			const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
-			command.push(
-				`
-				echo "${sshKey.privateKey}" > /tmp/id_rsa
-				chmod 600 /tmp/id_rsa
-				export GIT_SSH_COMMAND="${gitSshCommand}"
-				`,
-			);
-		}
-
-		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath} ; then
-				echo "[ERROR] Fail to clone the repository ";
-				exit 1;
-			fi
-			`,
-		);
-
-		await execAsyncRemote(serverId, command.join("\n"));
-	} catch (error) {
-		throw error;
+		console.error(`Error getting git commit info: ${error}`);
+		return null;
 	}
+	return result;
 };

packages/server/src/utils/providers/gitea.ts

@@ -1,7 +1,5 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { Compose } from "@dokploy/server/services/compose";
 import {
 	findGiteaById,
 	type Gitea,
@@ -9,9 +7,6 @@ import {
 } from "@dokploy/server/services/gitea";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const getErrorCloneRequirements = (entity: {
 	giteaRepository?: string | null;
@@ -54,7 +49,9 @@ export const refreshGiteaToken = async (giteaProviderId: string) => {
 		}
 
 		// Token is expired or about to expire, refresh it
-		const tokenEndpoint = `${giteaProvider.giteaUrl}/login/oauth/access_token`;
+		// Use internal URL when Gitea is on same instance as Dokploy
+		const baseUrl = giteaProvider.giteaInternalUrl || giteaProvider.giteaUrl;
+		const tokenEndpoint = `${baseUrl}/login/oauth/access_token`;
 		const params = new URLSearchParams({
 			grant_type: "refresh_token",
 			refresh_token: giteaProvider.refreshToken,
@@ -119,79 +116,28 @@ export type ApplicationWithGitea = InferResultType<
 
 export type ComposeWithGitea = InferResultType<"compose", { gitea: true }>;
 
-export const getGiteaCloneCommand = async (
-	entity: ApplicationWithGitea | ComposeWithGitea,
-	logPath: string,
-	isCompose = false,
-) => {
-	const {
-		appName,
-		giteaBranch,
-		giteaId,
-		giteaOwner,
-		giteaRepository,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!giteaId) {
-		const command = `
-		echo  "Error: ❌ Gitlab Provider not found" >> ${logPath};
-		exit 1;
-	`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-
-	// Use paths(true) for remote operations
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	await refreshGiteaToken(giteaId);
-	const gitea = await findGiteaById(giteaId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-
-	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
-	const cloneUrl = buildGiteaCloneUrl(
-		gitea?.giteaUrl!,
-		gitea?.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	const cloneCommand = `
-    rm -rf ${outputPath};
-    mkdir -p ${outputPath};
-
-    if ! git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-      echo "❌ [ERROR] Failed to clone the repository ${repoClone}" >> ${logPath};
-      exit 1;
-    fi
-
-    echo "Cloned ${repoClone} to ${outputPath}: ✅" >> ${logPath};
-  `;
-
-	return cloneCommand;
+type GiteaClone = (ApplicationWithGitea | ComposeWithGitea) & {
+	serverId: string | null;
+	type?: "application" | "compose";
 };
 
-export const cloneGiteaRepository = async (
-	entity: ApplicationWithGitea | ComposeWithGitea,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
+interface CloneGiteaRepository {
+	appName: string;
+	giteaBranch: string | null;
+	giteaId: string | null;
+	giteaOwner: string | null;
+	giteaRepository: string | null;
+	enableSubmodules: boolean;
+	serverId: string | null;
+	type?: "application" | "compose";
+	outputPathOverride?: string;
+}
 
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+export const cloneGiteaRepository = async ({
+	type = "application",
+	...entity
+}: CloneGiteaRepository) => {
+	let command = "set -e;";
 	const {
 		appName,
 		giteaBranch,
@@ -199,27 +145,28 @@ export const cloneGiteaRepository = async (
 		giteaOwner,
 		giteaRepository,
 		enableSubmodules,
+		serverId,
+		outputPathOverride,
 	} = entity;
+	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);
 
 	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
+		command += `echo "Error: ❌ Gitea Provider not found"; exit 1;`;
+		return command;
 	}
 
 	await refreshGiteaToken(giteaId);
 	const giteaProvider = await findGiteaById(giteaId);
+
 	if (!giteaProvider) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea provider not found in the database",
-		});
+		command += `echo "❌ [ERROR] Gitea provider not found in the database"; exit 1;`;
+		return command;
 	}
 
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 
 	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
 	const cloneUrl = buildGiteaCloneUrl(
@@ -229,134 +176,9 @@ export const cloneGiteaRepository = async (
 		giteaRepository!,
 	);
 
-	writeStream.write(`\nCloning Repo ${repoClone} to ${outputPath}...\n`);
-
-	try {
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				giteaBranch!,
-				"--depth",
-				"1",
-				...(enableSubmodules ? ["--recurse-submodules"] : []),
-				cloneUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
-		writeStream.write(`\nCloned ${repoClone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const cloneRawGiteaRepository = async (entity: Compose) => {
-	const {
-		appName,
-		giteaRepository,
-		giteaOwner,
-		giteaBranch,
-		giteaId,
-		enableSubmodules,
-	} = entity;
-	const { COMPOSE_PATH } = paths();
-
-	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-	await refreshGiteaToken(giteaId);
-	const giteaProvider = await findGiteaById(giteaId);
-	if (!giteaProvider) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea provider not found in the database",
-		});
-	}
-
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-
-	const cloneUrl = buildGiteaCloneUrl(
-		giteaProvider.giteaUrl,
-		giteaProvider.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	try {
-		await spawnAsync("git", [
-			"clone",
-			"--branch",
-			giteaBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		]);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGiteaRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		giteaRepository,
-		giteaOwner,
-		giteaBranch,
-		giteaId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths(true);
-	const giteaProvider = await findGiteaById(giteaId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const cloneUrl = buildGiteaCloneUrl(
-		giteaProvider.giteaUrl,
-		giteaProvider.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
+	command += `echo "Cloning Repo ${repoClone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const haveGiteaRequirements = (giteaProvider: Gitea) => {
@@ -389,7 +211,10 @@ export const testGiteaConnection = async (input: { giteaId: string }) => {
 			});
 		}
 
-		const baseUrl = provider.giteaUrl.replace(/\/+$/, "");
+		const baseUrl = (provider.giteaInternalUrl || provider.giteaUrl).replace(
+			/\/+$/,
+			"",
+		);
 
 		// Use /user/repos to get authenticated user's repositories with pagination
 		let allRepos = 0;
@@ -446,7 +271,9 @@ export const getGiteaRepositories = async (giteaId?: string) => {
 	await refreshGiteaToken(giteaId);
 	const giteaProvider = await findGiteaById(giteaId);
 
-	const baseUrl = giteaProvider.giteaUrl.replace(/\/+$/, "");
+	const baseUrl = (
+		giteaProvider.giteaInternalUrl || giteaProvider.giteaUrl
+	).replace(/\/+$/, "");
 
 	// Use /user/repos to get authenticated user's repositories with pagination
 	let allRepositories: any[] = [];
@@ -511,7 +338,9 @@ export const getGiteaBranches = async (input: {
 
 	const giteaProvider = await findGiteaById(input.giteaId);
 
-	const baseUrl = giteaProvider.giteaUrl.replace(/\/+$/, "");
+	const baseUrl = (
+		giteaProvider.giteaInternalUrl || giteaProvider.giteaUrl
+	).replace(/\/+$/, "");
 
 	// Handle pagination for branches
 	let allBranches: any[] = [];

packages/server/src/utils/providers/github.ts

@@ -1,16 +1,12 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { apiFindGithubBranches } from "@dokploy/server/db/schema";
-import type { Compose } from "@dokploy/server/services/compose";
 import { findGithubById, type Github } from "@dokploy/server/services/github";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { createAppAuth } from "@octokit/auth-app";
 import { TRPCError } from "@trpc/server";
+import type { z } from "zod";
 import { Octokit } from "octokit";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const authGithub = (githubProvider: Github): Octokit => {
 	if (!haveGithubRequirements(githubProvider)) {
@@ -123,237 +119,57 @@ interface CloneGithubRepository {
 	branch: string | null;
 	githubId: string | null;
 	repository: string | null;
-	logPath: string;
 	type?: "application" | "compose";
 	enableSubmodules: boolean;
+	serverId: string | null;
+	outputPathOverride?: string;
 }
 export const cloneGithubRepository = async ({
-	logPath,
 	type = "application",
 	...entity
 }: CloneGithubRepository) => {
+	let command = "set -e;";
 	const isCompose = type === "compose";
-	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
-	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const { appName, repository, owner, branch, githubId, enableSubmodules } =
-		entity;
+	const {
+		appName,
+		repository,
+		owner,
+		branch,
+		githubId,
+		enableSubmodules,
+		serverId,
+		outputPathOverride,
+	} = entity;
+	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);
 
 	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
+		command += `echo "Error: ❌ Github Provider not found"; exit 1;`;
+
+		return command;
 	}
 
 	const requirements = getErrorCloneRequirements(entity);
 
 	// Check if requirements are met
 	if (requirements.length > 0) {
-		writeStream.write(
-			`\nGitHub Repository configuration failed for application: ${appName}\n`,
-		);
-		writeStream.write("Reasons:\n");
-		writeStream.write(requirements.join("\n"));
-		writeStream.end();
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: GitHub repository information is incomplete.",
-		});
+		command += `echo "GitHub Repository configuration failed for application: ${appName}"; echo "Reasons:"; echo "${requirements.join("\n")}"; exit 1;`;
+		return command;
 	}
 
 	const githubProvider = await findGithubById(githubId);
 	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	const octokit = authGithub(githubProvider);
 	const token = await getGithubToken(octokit);
 	const repoclone = `github.com/${owner}/${repository}.git`;
-	await recreateDirectory(outputPath);
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
 
-	try {
-		writeStream.write(`\nCloning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			branch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
+	command += `echo "Cloning Repo ${repoclone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
 
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoclone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getGithubCloneCommand = async ({
-	logPath,
-	type = "application",
-	...entity
-}: CloneGithubRepository & { serverId: string }) => {
-	const {
-		appName,
-		repository,
-		owner,
-		branch,
-		githubId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-	const isCompose = type === "compose";
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!githubId) {
-		const command = `
-			echo  "Error: ❌ Github Provider not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-
-	const requirements = getErrorCloneRequirements(entity);
-
-	// Build log messages
-	let logMessages = "";
-	if (requirements.length > 0) {
-		logMessages += `\nGitHub Repository configuration failed for application: ${appName}\n`;
-		logMessages += "Reasons:\n";
-		logMessages += requirements.join("\n");
-		const escapedLogMessages = logMessages
-			.replace(/\\/g, "\\\\")
-			.replace(/"/g, '\\"')
-			.replace(/\n/g, "\\n");
-
-		const bashCommand = `
-            echo "${escapedLogMessages}" >> ${logPath};
-            exit 1;  # Exit with error code
-        `;
-
-		await execAsyncRemote(serverId, bashCommand);
-		return;
-	}
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const githubProvider = await findGithubById(githubId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone repository ${repoclone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
-};
-
-export const cloneRawGithubRepository = async (entity: Compose) => {
-	const { appName, repository, owner, branch, githubId, enableSubmodules } =
-		entity;
-
-	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths();
-	const githubProvider = await findGithubById(githubId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	await recreateDirectory(outputPath);
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			branch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGithubRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		repository,
-		owner,
-		branch,
-		githubId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-
-	const { COMPOSE_PATH } = paths(true);
-	const githubProvider = await findGithubById(githubId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
+	return command;
 };
 
 export const getGithubRepositories = async (githubId?: string) => {
@@ -382,7 +198,7 @@ export const getGithubRepositories = async (githubId?: string) => {
 };
 
 export const getGithubBranches = async (
-	input: typeof apiFindGithubBranches._type,
+	input: z.infer<typeof apiFindGithubBranches>,
 ) => {
 	if (!input.githubId) {
 		return [];

packages/server/src/utils/providers/gitlab.ts

@@ -1,8 +1,7 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { apiGitlabTestConnection } from "@dokploy/server/db/schema";
-import type { Compose } from "@dokploy/server/services/compose";
+import type { z } from "zod";
 import {
 	findGitlabById,
 	type Gitlab,
@@ -10,9 +9,6 @@ import {
 } from "@dokploy/server/services/gitlab";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const refreshGitlabToken = async (gitlabProviderId: string) => {
 	const gitlabProvider = await findGitlabById(gitlabProviderId);
@@ -26,7 +22,9 @@ export const refreshGitlabToken = async (gitlabProviderId: string) => {
 		return;
 	}
 
-	const response = await fetch(`${gitlabProvider.gitlabUrl}/oauth/token`, {
+	// Use internal URL for token refresh when GitLab is on same instance as Dokploy
+	const baseUrl = gitlabProvider.gitlabInternalUrl || gitlabProvider.gitlabUrl;
+	const response = await fetch(`${baseUrl}/oauth/token`, {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/x-www-form-urlencoded",
@@ -102,25 +100,36 @@ const getGitlabCloneUrl = (gitlab: GitlabInfo, repoClone: string) => {
 	return cloneUrl;
 };
 
-export const cloneGitlabRepository = async (
-	entity: ApplicationWithGitlab | ComposeWithGitlab,
-	logPath: string,
-	isCompose = false,
-) => {
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+interface CloneGitlabRepository {
+	appName: string;
+	gitlabBranch: string | null;
+	gitlabId: string | null;
+	gitlabPathNamespace: string | null;
+	enableSubmodules: boolean;
+	serverId: string | null;
+	type?: "application" | "compose";
+	outputPathOverride?: string;
+}
+
+export const cloneGitlabRepository = async ({
+	type = "application",
+	...entity
+}: CloneGitlabRepository) => {
+	let command = "set -e;";
 	const {
 		appName,
 		gitlabBranch,
 		gitlabId,
 		gitlabPathNamespace,
 		enableSubmodules,
+		serverId,
+		outputPathOverride,
 	} = entity;
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
+		command += `echo "Error: ❌ Gitlab Provider not found"; exit 1;`;
+		return command;
 	}
 
 	await refreshGitlabToken(gitlabId);
@@ -130,127 +139,19 @@ export const cloneGitlabRepository = async (
 
 	// Check if requirements are met
 	if (requirements.length > 0) {
-		writeStream.write(
-			`\nGitLab Repository configuration failed for application: ${appName}\n`,
-		);
-		writeStream.write("Reasons:\n");
-		writeStream.write(requirements.join("\n"));
-		writeStream.end();
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: GitLab repository information is incomplete.",
-		});
+		command += `echo "❌ [ERROR] GitLab Repository configuration failed for application: ${appName}"; echo "Reasons:"; echo "${requirements.join("\n")}"; exit 1;`;
+		return command;
 	}
 
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths();
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
 	const cloneUrl = getGitlabCloneUrl(gitlab, repoClone);
-	try {
-		writeStream.write(`\nCloning Repo ${repoClone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			gitlabBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoClone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getGitlabCloneCommand = async (
-	entity: ApplicationWithGitlab | ComposeWithGitlab,
-	logPath: string,
-	isCompose = false,
-) => {
-	const {
-		appName,
-		gitlabPathNamespace,
-		gitlabBranch,
-		gitlabId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!gitlabId) {
-		const command = `
-			echo  "Error: ❌ Gitlab Provider not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-
-	const requirements = getErrorCloneRequirements(entity);
-
-	// Build log messages
-	let logMessages = "";
-	if (requirements.length > 0) {
-		logMessages += `\nGitLab Repository configuration failed for application: ${appName}\n`;
-		logMessages += "Reasons:\n";
-		logMessages += requirements.join("\n");
-		const escapedLogMessages = logMessages
-			.replace(/\\/g, "\\\\")
-			.replace(/"/g, '\\"')
-			.replace(/\n/g, "\\n");
-
-		const bashCommand = `
-            echo "${escapedLogMessages}" >> ${logPath};
-            exit 1;  # Exit with error code
-        `;
-
-		await execAsyncRemote(serverId, bashCommand);
-		return;
-	}
-
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	await refreshGitlabToken(gitlabId);
-	const gitlab = await findGitlabById(gitlabId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlab, repoClone);
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone the repository ${repoClone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoClone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
+	command += `echo "Cloning Repo ${repoClone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const getGitlabRepositories = async (gitlabId?: string) => {
@@ -271,7 +172,7 @@ export const getGitlabRepositories = async (gitlabId?: string) => {
 		if (groupName) {
 			return groupName
 				.split(",")
-				.some((name) =>
+				.some((name: string) =>
 					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
 				);
 		}
@@ -313,10 +214,13 @@ export const getGitlabBranches = async (input: {
 	const allBranches = [];
 	let page = 1;
 	const perPage = 100; // GitLab's max per page is 100
+	const baseUrl = (
+		gitlabProvider.gitlabInternalUrl || gitlabProvider.gitlabUrl
+	).replace(/\/+$/, "");
 
 	while (true) {
 		const branchesResponse = await fetch(
-			`${gitlabProvider.gitlabUrl}/api/v4/projects/${input.id}/repository/branches?page=${page}&per_page=${perPage}`,
+			`${baseUrl}/api/v4/projects/${input.id}/repository/branches?page=${page}&per_page=${perPage}`,
 			{
 				headers: {
 					Authorization: `Bearer ${gitlabProvider.accessToken}`,
@@ -355,90 +259,8 @@ export const getGitlabBranches = async (input: {
 	}[];
 };
 
-export const cloneRawGitlabRepository = async (entity: Compose) => {
-	const {
-		appName,
-		gitlabBranch,
-		gitlabId,
-		gitlabPathNamespace,
-		enableSubmodules,
-	} = entity;
-
-	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-
-	const { COMPOSE_PATH } = paths();
-	await refreshGitlabToken(gitlabId);
-	const gitlabProvider = await findGitlabById(gitlabId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			gitlabBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGitlabRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		gitlabPathNamespace,
-		gitlabBranch,
-		gitlabId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths(true);
-	await refreshGitlabToken(gitlabId);
-	const gitlabProvider = await findGitlabById(gitlabId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
-};
-
 export const testGitlabConnection = async (
-	input: typeof apiGitlabTestConnection._type,
+	input: z.infer<typeof apiGitlabTestConnection>,
 ) => {
 	const { gitlabId, groupName } = input;
 
@@ -458,7 +280,7 @@ export const testGitlabConnection = async (
 		if (groupName) {
 			return groupName
 				.split(",")
-				.some((name) =>
+				.some((name: string) =>
 					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
 				);
 		}
@@ -473,10 +295,13 @@ export const validateGitlabProvider = async (gitlabProvider: Gitlab) => {
 		const allProjects = [];
 		let page = 1;
 		const perPage = 100; // GitLab's max per page is 100
+		const baseUrl = (
+			gitlabProvider.gitlabInternalUrl || gitlabProvider.gitlabUrl
+		).replace(/\/+$/, "");
 
 		while (true) {
 			const response = await fetch(
-				`${gitlabProvider.gitlabUrl}/api/v4/projects?membership=true&owned=true&page=${page}&per_page=${perPage}`,
+				`${baseUrl}/api/v4/projects?membership=true&page=${page}&per_page=${perPage}`,
 				{
 					headers: {
 						Authorization: `Bearer ${gitlabProvider.accessToken}`,

packages/server/src/utils/providers/raw.ts

@@ -1,40 +1,10 @@
-import { createWriteStream } from "node:fs";
-import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { Compose } from "@dokploy/server/services/compose";
 import { encodeBase64 } from "../docker/utils";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
 
-export const createComposeFile = async (compose: Compose, logPath: string) => {
-	const { COMPOSE_PATH } = paths();
-	const { appName, composeFile } = compose;
-	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const outputPath = join(COMPOSE_PATH, appName, "code");
-
-	try {
-		await recreateDirectory(outputPath);
-		writeStream.write(
-			`\nCreating File 'docker-compose.yml' to ${outputPath}: ✅\n`,
-		);
-
-		await writeFile(join(outputPath, "docker-compose.yml"), composeFile);
-
-		writeStream.write(`\nFile 'docker-compose.yml' created: ✅\n`);
-	} catch (error) {
-		writeStream.write(`\nERROR Creating Compose File: ${error}: ❌\n`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getCreateComposeFileCommand = (
-	compose: Compose,
-	logPath: string,
-) => {
-	const { COMPOSE_PATH } = paths(true);
+export const getCreateComposeFileCommand = (compose: Compose) => {
+	const { COMPOSE_PATH } = paths(!!compose.serverId);
 	const { appName, composeFile } = compose;
 	const outputPath = join(COMPOSE_PATH, appName, "code");
 	const filePath = join(outputPath, "docker-compose.yml");
@@ -43,39 +13,7 @@ export const getCreateComposeFileCommand = (
 		rm -rf ${outputPath};
 		mkdir -p ${outputPath};
 		echo "${encodedContent}" | base64 -d > "${filePath}";
-		echo "File 'docker-compose.yml' created: ✅" >> ${logPath};
+		echo "File 'docker-compose.yml' created: ✅";
 	`;
 	return bashCommand;
 };
-
-export const createComposeFileRaw = async (compose: Compose) => {
-	const { COMPOSE_PATH } = paths();
-	const { appName, composeFile } = compose;
-	const outputPath = join(COMPOSE_PATH, appName, "code");
-	const filePath = join(outputPath, "docker-compose.yml");
-	try {
-		await recreateDirectory(outputPath);
-		await writeFile(filePath, composeFile);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const createComposeFileRawRemote = async (compose: Compose) => {
-	const { COMPOSE_PATH } = paths(true);
-	const { appName, composeFile, serverId } = compose;
-	const outputPath = join(COMPOSE_PATH, appName, "code");
-	const filePath = join(outputPath, "docker-compose.yml");
-
-	try {
-		const encodedContent = encodeBase64(composeFile);
-		const command = `
-			rm -rf ${outputPath};
-			mkdir -p ${outputPath};
-			echo "${encodedContent}" | base64 -d > "${filePath}";
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
-};

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

@@ -32,7 +32,7 @@ export const restoreComposeBackup = async (
 			rcloneCommand = `rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
 		}
 
-		let credentials: DatabaseCredentials;
+		let credentials: DatabaseCredentials = {};
 
 		switch (backupInput.databaseType) {
 			case "postgres":
@@ -62,13 +62,18 @@ export const restoreComposeBackup = async (
 		const restoreCommand = getRestoreCommand({
 			appName: appName,
 			serviceName: backupInput.metadata?.serviceName,
-			type: backupInput.databaseType,
+			type: backupInput.databaseType as
+				| "postgres"
+				| "mariadb"
+				| "mysql"
+				| "mongo",
 			credentials: {
 				database: backupInput.databaseName,
 				...credentials,
 			},
 			restoreType: composeType,
 			rcloneCommand,
+			backupFile: backupInput.backupFile,
 		});
 
 		emit("Starting restore...");

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

@@ -1,4 +1,5 @@
 export { restoreComposeBackup } from "./compose";
+export { restoreLibsqlBackup } from "./libsql";
 export { restoreMariadbBackup } from "./mariadb";
 export { restoreMongoBackup } from "./mongo";
 export { restoreMySqlBackup } from "./mysql";

packages/server/src/utils/restore/libsql.ts

@@ -0,0 +1,49 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Libsql } from "@dokploy/server/services/libsql";
+import type { z } from "zod";
+import { getS3Credentials, getServiceContainerCommand } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+
+export const restoreLibsqlBackup = async (
+	libsql: Libsql,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, serverId } = libsql;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+
+		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}"`;
+
+		emit("Starting restore...");
+		emit(`Backup path: ${backupPath}`);
+
+		const containerSearch = getServiceContainerCommand(appName);
+		const restoreCommand = `docker exec -i $CONTAINER_ID sh -c "tar xzf - -C /var/lib/sqld"`;
+
+		const command = `CONTAINER_ID=$(${containerSearch}) && ${rcloneCommand} | ${restoreCommand}`;
+
+		emit(`Executing command: ${command}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring libsql backup"
+			}`,
+		);
+		throw error;
+	}
+};

packages/server/src/utils/restore/utils.ts

@@ -7,7 +7,7 @@ export const getPostgresRestoreCommand = (
 	database: string,
 	databaseUser: string,
 ) => {
-	return `docker exec -i $CONTAINER_ID sh -c "pg_restore -U ${databaseUser} -d ${database} -O --clean --if-exists"`;
+	return `docker exec -i $CONTAINER_ID sh -c "pg_restore -U '${databaseUser}' -d ${database} -O --clean --if-exists"`;
 };
 
 export const getMariadbRestoreCommand = (
@@ -15,14 +15,14 @@ export const getMariadbRestoreCommand = (
 	databaseUser: string,
 	databasePassword: string,
 ) => {
-	return `docker exec -i $CONTAINER_ID sh -c "mariadb -u ${databaseUser} -p${databasePassword} ${database}"`;
+	return `docker exec -i $CONTAINER_ID sh -c "mariadb -u '${databaseUser}' -p'${databasePassword}' ${database}"`;
 };
 
 export const getMysqlRestoreCommand = (
 	database: string,
 	databasePassword: string,
 ) => {
-	return `docker exec -i $CONTAINER_ID sh -c "mysql -u root -p${databasePassword} ${database}"`;
+	return `docker exec -i $CONTAINER_ID sh -c "mysql -u root -p'${databasePassword}' ${database}"`;
 };
 
 export const getMongoRestoreCommand = (
@@ -30,7 +30,7 @@ export const getMongoRestoreCommand = (
 	databaseUser: string,
 	databasePassword: string,
 ) => {
-	return `docker exec -i $CONTAINER_ID sh -c "mongorestore --username ${databaseUser} --password ${databasePassword} --authenticationDatabase admin --db ${database} --archive"`;
+	return `docker exec -i $CONTAINER_ID sh -c "mongorestore --username '${databaseUser}' --password '${databasePassword}' --authenticationDatabase admin --db ${database} --archive --drop"`;
 };
 
 export const getComposeSearchCommand = (

packages/server/src/utils/schedules/utils.ts

@@ -1,6 +1,6 @@
 import { createWriteStream } from "node:fs";
 import path from "node:path";
-import { paths } from "@dokploy/server/constants";
+import { IS_CLOUD, paths } from "@dokploy/server/constants";
 import type { Schedule } from "@dokploy/server/db/schema/schedule";
 import {
 	createDeploymentSchedule,
@@ -14,11 +14,21 @@ import { execAsyncRemote } from "../process/execAsync";
 import { spawnAsync } from "../process/spawnAsync";
 
 export const scheduleJob = (schedule: Schedule) => {
-	const { cronExpression, scheduleId } = schedule;
+	const { cronExpression, scheduleId, timezone } = schedule;
 
-	scheduleJobNode(scheduleId, cronExpression, async () => {
-		await runCommand(scheduleId);
-	});
+	// Use timezone from schedule, default to UTC if not specified
+	const tz = timezone || "UTC";
+
+	scheduleJobNode(
+		scheduleId,
+		{
+			tz,
+			rule: cronExpression,
+		},
+		async () => {
+			await runCommand(scheduleId);
+		},
+	);
 };
 
 export const removeScheduleJob = (scheduleId: string) => {
@@ -83,6 +93,13 @@ export const runCommand = async (scheduleId: string) => {
 			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
 
 			try {
+				if (IS_CLOUD) {
+					writeStream.write(
+						"This feature is not available in the cloud version.",
+					);
+					writeStream.end();
+					return;
+				}
 				writeStream.write(
 					`docker exec ${containerId} ${shellType} -c ${command}\n`,
 				);

packages/server/src/utils/tracking/hubspot.ts

@@ -0,0 +1,125 @@
+interface HubSpotFormField {
+	objectTypeId: string;
+	name: string;
+	value: string;
+}
+
+interface HubSpotFormData {
+	fields: HubSpotFormField[];
+	context: {
+		pageUri: string;
+		pageName: string;
+		hutk?: string; // HubSpot UTK from cookies
+	};
+}
+
+interface SignUpFormData {
+	firstName?: string;
+	lastName?: string;
+	email?: string;
+}
+
+/**
+ * Extract HubSpot UTK (User Token) from cookies
+ * This is used for tracking and attribution in HubSpot
+ */
+export function getHubSpotUTK(cookieHeader?: string): string | null {
+	if (!cookieHeader) return null;
+
+	const name = "hubspotutk=";
+	const decodedCookie = decodeURIComponent(cookieHeader);
+	const cookieArray = decodedCookie.split(";");
+
+	for (let i = 0; i < cookieArray.length; i++) {
+		const cookie = cookieArray[i]?.trim();
+		if (!cookie) continue;
+		if (cookie.indexOf(name) === 0) {
+			return cookie.substring(name.length, cookie.length);
+		}
+	}
+	return null;
+}
+
+/**
+ * Convert contact form data to HubSpot form format
+ */
+export function formatContactDataForHubSpot(
+	contactData: SignUpFormData,
+	hutk?: string | null,
+): HubSpotFormData {
+	const formData: HubSpotFormData = {
+		fields: [
+			{
+				objectTypeId: "0-1", // Contact object type
+				name: "firstname",
+				value: contactData.firstName || "",
+			},
+			{
+				objectTypeId: "0-1",
+				name: "lastname",
+				value: contactData.lastName || "",
+			},
+			{
+				objectTypeId: "0-1",
+				name: "email",
+				value: contactData.email || "",
+			},
+		],
+		context: {
+			pageUri: "https://app.dokploy.com/register",
+			pageName: "Sign Up",
+		},
+	};
+
+	// Add HubSpot UTK if available
+	if (hutk) {
+		formData.context.hutk = hutk;
+	}
+
+	return formData;
+}
+
+/**
+ * Submit form data to HubSpot Forms API
+ */
+export async function submitToHubSpot(
+	contactData: SignUpFormData,
+	hutk?: string | null,
+): Promise<boolean> {
+	try {
+		const portalId = process.env.HUBSPOT_PORTAL_ID;
+		const formGuid = process.env.HUBSPOT_FORM_GUID;
+
+		if (!portalId || !formGuid) {
+			console.error(
+				"HubSpot configuration missing: HUBSPOT_PORTAL_ID or HUBSPOT_FORM_GUID not set",
+			);
+			return false;
+		}
+
+		const formData = formatContactDataForHubSpot(contactData, hutk);
+		const response = await fetch(
+			`https://api.hsforms.com/submissions/v3/integration/submit/${portalId}/${formGuid}`,
+			{
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(formData),
+			},
+		);
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			console.error("HubSpot API error:", response.status, errorText);
+			return false;
+		}
+
+		const result = await response.json();
+		console.log("HubSpot submission successful:", result);
+		return true;
+	} catch (error) {
+		console.error("Error submitting to HubSpot:", error);
+		return false;
+	}
+}

packages/server/src/utils/traefik/application.ts

@@ -162,6 +162,7 @@ export const readMonitoringConfig = async (readAll = false) => {
 						trimmed.endsWith("}")
 					) {
 						const log = JSON.parse(trimmed);
+						// Exclude Dokploy service app and Dashboard requests
 						if (log.ServiceName !== "dokploy-service-app@file") {
 							content += `${line}\n`;
 							validCount++;

packages/server/src/utils/traefik/domain.ts

@@ -104,6 +104,20 @@ export const removeDomain = async (
 	}
 };
 
+/**
+ * Converts an internationalized domain name (IDN) to ASCII punycode format.
+ * Traefik requires domain names in ASCII format, so non-ASCII characters
+ * must be converted (e.g., "тест.рф" → "xn--e1aybc.xn--p1ai").
+ */
+const toPunycode = (host: string): string => {
+	try {
+		return new URL(`http://${host}`).hostname;
+	} catch {
+		// If URL parsing fails, return the original host
+		return host;
+	}
+};
+
 export const createRouterConfig = async (
 	app: ApplicationNested,
 	domain: Domain,
@@ -114,8 +128,9 @@ export const createRouterConfig = async (
 
 	const { host, path, https, uniqueConfigKey, internalPath, stripPath } =
 		domain;
+	const punycodeHost = toPunycode(host);
 	const routerConfig: HttpRouter = {
-		rule: `Host(\`${host}\`)${path !== null && path !== "/" ? ` && PathPrefix(\`${path}\`)` : ""}`,
+		rule: `Host(\`${punycodeHost}\`)${path !== null && path !== "/" ? ` && PathPrefix(\`${path}\`)` : ""}`,
 		service: `${appName}-service-${uniqueConfigKey}`,
 		middlewares: [],
 		entryPoints: [entryPoint],
@@ -137,16 +152,13 @@ export const createRouterConfig = async (
 	}
 
 	if ((entryPoint === "websecure" && https) || !https) {
-		// redirects
-		for (const redirect of redirects) {
-			let middlewareName = `redirect-${appName}-${redirect.uniqueConfigKey}`;
-			if (domain.domainType === "preview") {
-				middlewareName = `redirect-${appName.replace(
-					/^preview-(.+)-[^-]+$/,
-					"$1",
-				)}-${redirect.uniqueConfigKey}`;
+		// redirects - skip for preview deployments as wildcard subdomains
+		// should not inherit parent redirect rules (e.g., www-redirect)
+		if (domain.domainType !== "preview") {
+			for (const redirect of redirects) {
+				const middlewareName = `redirect-${appName}-${redirect.uniqueConfigKey}`;
+				routerConfig.middlewares?.push(middlewareName);
 			}
-			routerConfig.middlewares?.push(middlewareName);
 		}
 
 		// security

packages/server/src/utils/traefik/middleware.ts

@@ -46,8 +46,14 @@ export const deleteMiddleware = (
 };
 
 export const deleteAllMiddlewares = async (application: ApplicationNested) => {
-	const config = loadMiddlewares<FileConfig>();
-	const { security, appName, redirects } = application;
+	const { security, appName, redirects, serverId } = application;
+	let config: FileConfig;
+
+	if (serverId) {
+		config = await loadRemoteMiddlewares(serverId);
+	} else {
+		config = loadMiddlewares<FileConfig>();
+	}
 
 	if (config.http?.middlewares) {
 		if (security.length > 0) {
@@ -62,8 +68,8 @@ export const deleteAllMiddlewares = async (application: ApplicationNested) => {
 		}
 	}
 
-	if (application.serverId) {
-		await writeTraefikConfigRemote(config, "middlewares", application.serverId);
+	if (serverId) {
+		await writeTraefikConfigRemote(config, "middlewares", serverId);
 	} else {
 		writeMiddleware(config);
 	}

packages/server/src/utils/traefik/web-server.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { User } from "@dokploy/server/services/user";
+import type { webServerSettings } from "@dokploy/server/db/schema/web-server-settings";
 import { parse, stringify } from "yaml";
 import {
 	loadOrCreateConfig,
@@ -12,10 +12,10 @@ import type { FileConfig } from "./file-types";
 import type { MainTraefikConfig } from "./types";
 
 export const updateServerTraefik = (
-	user: User | null,
+	settings: typeof webServerSettings.$inferSelect | null,
 	newHost: string | null,
 ) => {
-	const { https, certificateType } = user || {};
+	const { https, certificateType } = settings || {};
 	const appName = "dokploy";
 	const config: FileConfig = loadOrCreateConfig(appName);
 
@@ -23,11 +23,18 @@ export const updateServerTraefik = (
 	config.http.routers = config.http.routers || {};
 	config.http.services = config.http.services || {};
 
+	// Get or create router config, but always update the rule with newHost
 	const currentRouterConfig = config.http.routers[`${appName}-router-app`] || {
-		rule: `Host(\`${newHost}\`)`,
 		service: `${appName}-service-app`,
 		entryPoints: ["web"],
+		rule: `Host(\`${newHost}\`)`,
 	};
+
+	// Always update the rule with the new host
+	if (newHost) {
+		currentRouterConfig.rule = `Host(\`${newHost}\`)`;
+	}
+
 	config.http.routers[`${appName}-router-app`] = currentRouterConfig;
 
 	config.http.services = {

packages/server/src/utils/volume-backups/backup.ts

@@ -4,23 +4,43 @@ import { findComposeById } from "@dokploy/server/services/compose";
 import type { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
 import { getS3Credentials, normalizeS3Path } from "../backups/utils";
 
+export const getVolumeServiceAppName = (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+): string => {
+	if (volumeBackup.compose?.appName) {
+		return volumeBackup.serviceName
+			? `${volumeBackup.compose.appName}_${volumeBackup.serviceName}`
+			: volumeBackup.compose.appName;
+	}
+	const serviceAppName =
+		volumeBackup.application?.appName ||
+		volumeBackup.postgres?.appName ||
+		volumeBackup.mysql?.appName ||
+		volumeBackup.mariadb?.appName ||
+		volumeBackup.mongo?.appName ||
+		volumeBackup.redis?.appName ||
+		volumeBackup.libsql?.appName;
+	return serviceAppName || volumeBackup.appName;
+};
+
 export const backupVolume = async (
 	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
 ) => {
 	const { serviceType, volumeName, turnOff, prefix } = volumeBackup;
 	const serverId =
 		volumeBackup.application?.serverId || volumeBackup.compose?.serverId;
-	const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
+	const { VOLUME_BACKUPS_PATH, VOLUME_BACKUP_LOCK_PATH } = paths(!!serverId);
 	const destination = volumeBackup.destination;
+	const s3AppName = getVolumeServiceAppName(volumeBackup);
 	const backupFileName = `${volumeName}-${new Date().toISOString()}.tar`;
-	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const bucketDestination = `${s3AppName}/${normalizeS3Path(prefix || "")}${backupFileName}`;
 	const rcloneFlags = getS3Credentials(volumeBackup.destination);
 	const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
 	const volumeBackupPath = path.join(VOLUME_BACKUPS_PATH, volumeBackup.appName);
 
 	const rcloneCommand = `rclone copyto ${rcloneFlags.join(" ")} "${volumeBackupPath}/${backupFileName}" "${rcloneDestination}"`;
 
-	const baseCommand = `
+	const backupCommand = `
 	set -e
 	echo "Volume name: ${volumeName}"
 	echo "Backup file name: ${backupFileName}"
@@ -33,6 +53,9 @@ export const backupVolume = async (
   ubuntu \
   bash -c "cd /volume_data && tar cvf /backup/${backupFileName} ."
   echo "Volume backup done ✅"
+  `;
+
+	const uploadCommand = `
   echo "Starting upload to S3..."
   ${rcloneCommand}
   echo "Upload to S3 done ✅"
@@ -42,19 +65,63 @@ export const backupVolume = async (
   `;
 
 	if (!turnOff) {
-		return baseCommand;
+		return `
+		${backupCommand}
+		${uploadCommand}
+		`;
 	}
 
+	const serviceLockId =
+		serviceType === "application"
+			? volumeBackup.application?.appName
+			: `${volumeBackup.compose?.appName}_${volumeBackup.serviceName}`;
+
+	const lockPath = `${VOLUME_BACKUP_LOCK_PATH}-${serviceLockId}`;
+
+	const lockWrapper = (body: string) => `
+		set -e
+
+		LOCK_PATH="${lockPath}"
+
+		echo "Waiting for volume backup lock: $LOCK_PATH"
+
+		if command -v flock >/dev/null 2>&1; then
+			exec 9>"$LOCK_PATH"
+			flock 9
+		else
+			LOCK_DIR="$LOCK_PATH.dir"
+			while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+				echo "Waiting for volume backup lock: $LOCK_PATH"
+				sleep 5
+			done
+			trap 'rm -rf "$LOCK_DIR"' EXIT
+		fi
+
+		echo "Volume backup lock acquired"
+
+		${body}
+
+		echo "Volume backup lock released"
+	`;
+
+	console.log(
+		lockWrapper(`
+		echo "Volume backup lock acquired"
+		echo "Volume backup lock released"
+	`),
+	);
+
 	if (serviceType === "application") {
-		return `
+		return lockWrapper(`
 		echo "Stopping application to 0 replicas"
 		ACTUAL_REPLICAS=$(docker service inspect ${volumeBackup.application?.appName} --format "{{.Spec.Mode.Replicated.Replicas}}")
 		echo "Actual replicas: $ACTUAL_REPLICAS"
-		docker service scale ${volumeBackup.application?.appName}=0
-        ${baseCommand}
+		docker service update --replicas=0 ${volumeBackup.application?.appName}
+        ${backupCommand}
 		echo "Starting application to $ACTUAL_REPLICAS replicas"
-        docker service scale ${volumeBackup.application?.appName}=$ACTUAL_REPLICAS
-  `;
+        docker service update --replicas=$ACTUAL_REPLICAS --with-registry-auth ${volumeBackup.application?.appName}
+		${uploadCommand}
+  `);
 	}
 	if (serviceType === "compose") {
 		const compose = await findComposeById(
@@ -69,25 +136,28 @@ export const backupVolume = async (
 			echo "Service name: ${compose.appName}_${volumeBackup.serviceName}"
             ACTUAL_REPLICAS=$(docker service inspect ${compose.appName}_${volumeBackup.serviceName} --format "{{.Spec.Mode.Replicated.Replicas}}")
             echo "Actual replicas: $ACTUAL_REPLICAS"
-            docker service scale ${compose.appName}_${volumeBackup.serviceName}=0`;
+            docker service update --replicas=0 ${compose.appName}_${volumeBackup.serviceName}`;
+
 			startCommand = `
 			echo "Starting compose to $ACTUAL_REPLICAS replicas"
-			docker service scale ${compose.appName}_${volumeBackup.serviceName}=$ACTUAL_REPLICAS`;
+			docker service update --replicas=$ACTUAL_REPLICAS --with-registry-auth ${compose.appName}_${volumeBackup.serviceName}`;
 		} else {
 			stopCommand = `
 			echo "Stopping compose container"
             ID=$(docker ps -q --filter "label=com.docker.compose.project=${compose.appName}" --filter "label=com.docker.compose.service=${volumeBackup.serviceName}")
             docker stop $ID`;
+
 			startCommand = `
             echo "Starting compose container"
             docker start $ID
 			echo "Compose container started"
 			`;
 		}
-		return `
+		return lockWrapper(`
         ${stopCommand}
-        ${baseCommand}
+        ${backupCommand}
         ${startCommand}
-  `;
+		${uploadCommand}
+  `);
 	}
 };

packages/server/src/utils/volume-backups/utils.ts

@@ -11,7 +11,55 @@ import {
 } from "@dokploy/server/utils/process/execAsync";
 import { scheduledJobs, scheduleJob } from "node-schedule";
 import { getS3Credentials, normalizeS3Path } from "../backups/utils";
-import { backupVolume } from "./backup";
+import { sendVolumeBackupNotifications } from "../notifications/volume-backup";
+import { backupVolume, getVolumeServiceAppName } from "./backup";
+
+// Helper functions to extract project info from volume backup
+const getProjectName = (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+): string => {
+	const services = [
+		volumeBackup.application,
+		volumeBackup.compose,
+		volumeBackup.postgres,
+		volumeBackup.mysql,
+		volumeBackup.mariadb,
+		volumeBackup.mongo,
+		volumeBackup.redis,
+		volumeBackup.libsql,
+	];
+
+	for (const service of services) {
+		if (service?.environment?.project?.name) {
+			return service.environment.project.name;
+		}
+	}
+
+	return "Unknown Project";
+};
+
+const getOrganizationId = (
+	volumeBackup: Awaited<ReturnType<typeof findVolumeBackupById>>,
+): string => {
+	const services = [
+		volumeBackup.application,
+		volumeBackup.compose,
+		volumeBackup.postgres,
+		volumeBackup.mysql,
+		volumeBackup.mariadb,
+		volumeBackup.mongo,
+		volumeBackup.redis,
+		volumeBackup.libsql,
+	];
+
+	for (const service of services) {
+		if (service?.environment?.project?.organizationId) {
+			return service.environment.project.organizationId;
+		}
+	}
+
+	return "";
+};
 
 export const scheduleVolumeBackup = async (volumeBackupId: string) => {
 	const volumeBackup = await findVolumeBackupById(volumeBackupId);
@@ -35,9 +83,9 @@ const cleanupOldVolumeBackups = async (
 
 	try {
 		const rcloneFlags = getS3Credentials(destination);
-		const normalizedPrefix = normalizeS3Path(prefix);
-		const backupFilesPath = `:s3:${destination.bucket}/${normalizedPrefix}`;
-		const listCommand = `rclone lsf ${rcloneFlags.join(" ")} --include \"${volumeName}-*.tar\" :s3:${destination.bucket}/${normalizedPrefix}`;
+		const s3AppName = getVolumeServiceAppName(volumeBackup);
+		const backupFilesPath = `:s3:${destination.bucket}/${s3AppName}/${normalizeS3Path(prefix || "")}`;
+		const listCommand = `rclone lsf ${rcloneFlags.join(" ")} --include \"${volumeName}-*.tar\" ${backupFilesPath}`;
 		const sortAndPick = `sort -r | tail -n +$((${keepLatestCount}+1)) | xargs -I{}`;
 		const deleteCommand = `rclone delete ${rcloneFlags.join(" ")} ${backupFilesPath}{}`;
 		const fullCommand = `${listCommand} | ${sortAndPick} ${deleteCommand}`;
@@ -61,7 +109,8 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		title: "Volume Backup",
 		description: "Volume Backup",
 	});
-
+	const projectName = getProjectName(volumeBackup);
+	const organizationId = getOrganizationId(volumeBackup);
 	try {
 		const command = await backupVolume(volumeBackup);
 
@@ -77,6 +126,28 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		}
 
 		await updateDeploymentStatus(deployment.deploymentId, "done");
+
+		// Map service type to match notification function expectations
+		const mappedServiceType =
+			volumeBackup.serviceType === "mongo"
+				? "mongodb"
+				: volumeBackup.serviceType;
+
+		try {
+			await sendVolumeBackupNotifications({
+				projectName,
+				applicationName: volumeBackup.name,
+				volumeName: volumeBackup.volumeName,
+				serviceType: mappedServiceType,
+				type: "success",
+				organizationId,
+			});
+		} catch (notificationError) {
+			console.error(
+				"Failed to send volume backup success notification",
+				notificationError,
+			);
+		}
 	} catch (error) {
 		const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
 		const volumeBackupPath = path.join(
@@ -92,6 +163,27 @@ export const runVolumeBackup = async (volumeBackupId: string) => {
 		}
 		await updateDeploymentStatus(deployment.deploymentId, "error");
 
-		console.error(error);
+		// Send error notification
+		const mappedServiceType =
+			volumeBackup.serviceType === "mongo"
+				? "mongodb"
+				: volumeBackup.serviceType;
+
+		try {
+			await sendVolumeBackupNotifications({
+				projectName,
+				applicationName: volumeBackup.name,
+				volumeName: volumeBackup.volumeName,
+				serviceType: mappedServiceType,
+				type: "error",
+				organizationId,
+				errorMessage: error instanceof Error ? error.message : String(error),
+			});
+		} catch (notificationError) {
+			console.error(
+				"Failed to send volume backup error notification",
+				notificationError,
+			);
+		}
 	}
 };