Merge branch 'canary' into fix/gitlab-branches-pagination

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

@@ -1,122 +1,78 @@
-import { IS_CLOUD, paths } from "@dokploy/server/constants";
-import { updateAdmin } from "@dokploy/server/services/admin";
-import { type RotatingFileStream, createStream } from "rotating-file-stream";
-import { db } from "../../db";
+import { paths } from "@dokploy/server/constants";
+import { findAdmin } from "@dokploy/server/services/admin";
+import { updateUser } from "@dokploy/server/services/user";
+import { scheduleJob, scheduledJobs } from "node-schedule";
 import { execAsync } from "../process/execAsync";
 
-class LogRotationManager {
-	private static instance: LogRotationManager;
-	private stream: RotatingFileStream | null = null;
+const LOG_CLEANUP_JOB_NAME = "access-log-cleanup";
 
-	private constructor() {
-		if (IS_CLOUD) {
-			return;
-		}
-		this.initialize().catch(console.error);
-	}
-
-	public static getInstance(): LogRotationManager {
-		if (!LogRotationManager.instance) {
-			LogRotationManager.instance = new LogRotationManager();
-		}
-		return LogRotationManager.instance;
-	}
-
-	private async initialize(): Promise<void> {
-		const isActive = await this.getStateFromDB();
-		if (isActive) {
-			await this.activateStream();
-		}
-	}
-
-	private async getStateFromDB(): Promise<boolean> {
-		const setting = await db.query.admins.findFirst({});
-		return setting?.enableLogRotation ?? false;
-	}
-
-	private async setStateInDB(active: boolean): Promise<void> {
-		const admin = await db.query.admins.findFirst({});
-
-		if (!admin) {
-			return;
-		}
-		await updateAdmin(admin?.authId, {
-			enableLogRotation: active,
-		});
-	}
-
-	private async activateStream(): Promise<void> {
+export const startLogCleanup = async (
+	cronExpression = "0 0 * * *",
+): Promise<boolean> => {
+	try {
 		const { DYNAMIC_TRAEFIK_PATH } = paths();
-		if (this.stream) {
-			await this.deactivateStream();
+
+		const existingJob = scheduledJobs[LOG_CLEANUP_JOB_NAME];
+		if (existingJob) {
+			existingJob.cancel();
 		}
 
-		this.stream = createStream("access.log", {
-			size: "100M",
-			interval: "1d",
-			path: DYNAMIC_TRAEFIK_PATH,
-			rotate: 6,
-			compress: "gzip",
-		});
+		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`,
+				);
 
-		this.stream.on("rotation", this.handleRotation.bind(this));
-	}
-
-	private async deactivateStream(): Promise<void> {
-		return new Promise<void>((resolve) => {
-			if (this.stream) {
-				this.stream.end(() => {
-					this.stream = null;
-					resolve();
-				});
-			} else {
-				resolve();
+				await execAsync("docker exec dokploy-traefik kill -USR1 1");
+			} catch (error) {
+				console.error("Error during log cleanup:", error);
 			}
 		});
-	}
 
-	public async activate(): Promise<boolean> {
-		const currentState = await this.getStateFromDB();
-		if (currentState) {
-			return true;
+		const admin = await findAdmin();
+		if (admin) {
+			await updateUser(admin.user.id, {
+				logCleanupCron: cronExpression,
+			});
 		}
 
-		await this.setStateInDB(true);
-		await this.activateStream();
 		return true;
+	} catch (error) {
+		console.error("Error starting log cleanup:", error);
+		return false;
 	}
+};
 
-	public async deactivate(): Promise<boolean> {
-		console.log("Deactivating log rotation...");
-		const currentState = await this.getStateFromDB();
-		if (!currentState) {
-			console.log("Log rotation is already inactive in DB");
-			return true;
+export const stopLogCleanup = async (): Promise<boolean> => {
+	try {
+		const existingJob = scheduledJobs[LOG_CLEANUP_JOB_NAME];
+		if (existingJob) {
+			existingJob.cancel();
+		}
+
+		// Update database
+		const admin = await findAdmin();
+		if (admin) {
+			await updateUser(admin.user.id, {
+				logCleanupCron: null,
+			});
 		}
 
-		await this.setStateInDB(false);
-		await this.deactivateStream();
-		console.log("Log rotation deactivated successfully");
 		return true;
+	} catch (error) {
+		console.error("Error stopping log cleanup:", error);
+		return false;
 	}
+};
 
-	private async handleRotation() {
-		try {
-			const status = await this.getStatus();
-			if (!status) {
-				await this.deactivateStream();
-			}
-			await execAsync(
-				"docker kill -s USR1 $(docker ps -q --filter name=dokploy-traefik)",
-			);
-			console.log("USR1 Signal send to Traefik");
-		} catch (error) {
-			console.error("Error to send USR1 Signal to Traefik:", error);
-		}
-	}
-	public async getStatus(): Promise<boolean> {
-		const dbState = await this.getStateFromDB();
-		return dbState;
-	}
-}
-export const logRotationManager = LogRotationManager.getInstance();
+export const getLogCleanupStatus = async (): Promise<{
+	enabled: boolean;
+	cronExpression: string | null;
+}> => {
+	const admin = await findAdmin();
+	const cronExpression = admin?.user.logCleanupCron ?? null;
+	return {
+		enabled: cronExpression !== null,
+		cronExpression,
+	};
+};

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

@@ -6,14 +6,21 @@ interface HourlyData {
 	count: number;
 }
 
-export function processLogs(logString: string): HourlyData[] {
+export function processLogs(
+	logString: string,
+	dateRange?: { start?: string; end?: string },
+): HourlyData[] {
 	if (_.isEmpty(logString)) {
 		return [];
 	}
 
 	const hourlyData = _(logString)
 		.split("\n")
-		.compact()
+		.filter((line) => {
+			const trimmed = line.trim();
+			// Check if the line starts with { and ends with } to ensure it's a potential JSON object
+			return trimmed !== "" && trimmed.startsWith("{") && trimmed.endsWith("}");
+		})
 		.map((entry) => {
 			try {
 				const log: LogEntry = JSON.parse(entry);
@@ -21,6 +28,20 @@ export function processLogs(logString: string): HourlyData[] {
 					return null;
 				}
 				const date = new Date(log.StartUTC);
+
+				if (dateRange?.start || dateRange?.end) {
+					const logDate = date.getTime();
+					const start = dateRange?.start
+						? new Date(dateRange.start).getTime()
+						: 0;
+					const end = dateRange?.end
+						? new Date(dateRange.end).getTime()
+						: Number.POSITIVE_INFINITY;
+					if (logDate < start || logDate > end) {
+						return null;
+					}
+				}
+
 				return `${date.toISOString().slice(0, 13)}:00:00Z`;
 			} catch (error) {
 				console.error("Error parsing log entry:", error);
@@ -51,21 +72,46 @@ export function parseRawConfig(
 	sort?: SortInfo,
 	search?: string,
 	status?: string[],
+	dateRange?: { start?: string; end?: string },
 ): { data: LogEntry[]; totalCount: number } {
 	try {
 		if (_.isEmpty(rawConfig)) {
 			return { data: [], totalCount: 0 };
 		}
 
+		// Split logs into chunks to avoid memory issues
 		let parsedLogs = _(rawConfig)
 			.split("\n")
+			.filter((line) => {
+				const trimmed = line.trim();
+				return (
+					trimmed !== "" && trimmed.startsWith("{") && trimmed.endsWith("}")
+				);
+			})
+			.map((line) => {
+				try {
+					return JSON.parse(line) as LogEntry;
+				} catch (error) {
+					console.error("Error parsing log line:", error);
+					return null;
+				}
+			})
 			.compact()
-			.map((line) => JSON.parse(line) as LogEntry)
 			.value();
 
-		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) => {
+				const logDate = new Date(log.StartUTC).getTime();
+				const start = dateRange?.start
+					? new Date(dateRange.start).getTime()
+					: 0;
+				const end = dateRange?.end
+					? new Date(dateRange.end).getTime()
+					: Number.POSITIVE_INFINITY;
+				return logDate >= start && logDate <= end;
+			});
+		}
 
 		if (search) {
 			parsedLogs = parsedLogs.filter((log) =>
@@ -78,6 +124,7 @@ export function parseRawConfig(
 				status.some((range) => isStatusInRange(log.DownstreamStatus, range)),
 			);
 		}
+
 		const totalCount = parsedLogs.length;
 
 		if (sort) {
@@ -101,6 +148,7 @@ export function parseRawConfig(
 		throw new Error("Failed to parse rawConfig");
 	}
 }
+
 const isStatusInRange = (status: number, range: string) => {
 	switch (range) {
 		case "info":

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

@@ -0,0 +1 @@
+export * from "./select-ai-provider";

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

@@ -0,0 +1,112 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createAzure } from "@ai-sdk/azure";
+import { createCohere } from "@ai-sdk/cohere";
+import { createDeepInfra } from "@ai-sdk/deepinfra";
+import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createOllama } from "ollama-ai-provider";
+
+function getProviderName(apiUrl: string) {
+	if (apiUrl.includes("api.openai.com")) return "openai";
+	if (apiUrl.includes("azure.com")) return "azure";
+	if (apiUrl.includes("api.anthropic.com")) return "anthropic";
+	if (apiUrl.includes("api.cohere.ai")) return "cohere";
+	if (apiUrl.includes("api.perplexity.ai")) return "perplexity";
+	if (apiUrl.includes("api.mistral.ai")) return "mistral";
+	if (apiUrl.includes("localhost:11434") || apiUrl.includes("ollama"))
+		return "ollama";
+	if (apiUrl.includes("api.deepinfra.com")) return "deepinfra";
+	return "custom";
+}
+
+export function selectAIProvider(config: { apiUrl: string; apiKey: string }) {
+	const providerName = getProviderName(config.apiUrl);
+
+	switch (providerName) {
+		case "openai":
+			return createOpenAI({
+				apiKey: config.apiKey,
+				baseURL: config.apiUrl,
+			});
+		case "azure":
+			return createAzure({
+				apiKey: config.apiKey,
+				baseURL: config.apiUrl,
+			});
+		case "anthropic":
+			return createAnthropic({
+				apiKey: config.apiKey,
+				baseURL: config.apiUrl,
+			});
+		case "cohere":
+			return createCohere({
+				baseURL: config.apiUrl,
+				apiKey: config.apiKey,
+			});
+		case "perplexity":
+			return createOpenAICompatible({
+				name: "perplexity",
+				baseURL: config.apiUrl,
+				headers: {
+					Authorization: `Bearer ${config.apiKey}`,
+				},
+			});
+		case "mistral":
+			return createMistral({
+				baseURL: config.apiUrl,
+				apiKey: config.apiKey,
+			});
+		case "ollama":
+			return createOllama({
+				// optional settings, e.g.
+				baseURL: config.apiUrl,
+			});
+		case "deepinfra":
+			return createDeepInfra({
+				baseURL: config.apiUrl,
+				apiKey: config.apiKey,
+			});
+		case "custom":
+			return createOpenAICompatible({
+				name: "custom",
+				baseURL: config.apiUrl,
+				headers: {
+					Authorization: `Bearer ${config.apiKey}`,
+				},
+			});
+		default:
+			throw new Error(`Unsupported AI provider: ${providerName}`);
+	}
+}
+
+export const getProviderHeaders = (
+	apiUrl: string,
+	apiKey: string,
+): Record<string, string> => {
+	// Anthropic
+	if (apiUrl.includes("anthropic")) {
+		return {
+			"x-api-key": apiKey,
+			"anthropic-version": "2023-06-01",
+		};
+	}
+
+	// Mistral
+	if (apiUrl.includes("mistral")) {
+		return {
+			Authorization: apiKey,
+		};
+	}
+
+	// Default (OpenAI style)
+	return {
+		Authorization: `Bearer ${apiKey}`,
+	};
+};
+export interface Model {
+	id: string;
+	object: string;
+	created: number;
+	owned_by: string;
+}

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

@@ -0,0 +1,88 @@
+import type { BackupSchedule } from "@dokploy/server/services/backup";
+import type { Compose } from "@dokploy/server/services/compose";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
+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 runComposeBackup = async (
+	compose: Compose,
+	backup: BackupSchedule,
+) => {
+	const { projectId, name } = compose;
+	const project = await findProjectById(projectId);
+	const { prefix, databaseType } = backup;
+	const destination = backup.destination;
+	const backupFileName = `${new Date().toISOString()}.dump.gz`;
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "Compose Backup",
+		description: "Compose Backup",
+	});
+
+	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 (compose.serverId) {
+			await execAsyncRemote(compose.serverId, backupCommand);
+		} else {
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
+		}
+
+		await sendDatabaseBackupNotifications({
+			applicationName: name,
+			projectName: project.name,
+			databaseType: getDatabaseType(databaseType),
+			type: "success",
+			organizationId: project.organizationId,
+			databaseName: backup.database,
+		});
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+	} catch (error) {
+		console.log(error);
+		await sendDatabaseBackupNotifications({
+			applicationName: name,
+			projectName: project.name,
+			databaseType: getDatabaseType(databaseType),
+			type: "error",
+			// @ts-ignore
+			errorMessage: error?.message || "Error message not provided",
+			organizationId: project.organizationId,
+			databaseName: backup.database,
+		});
+
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		throw error;
+	}
+};
+
+const getDatabaseType = (databaseType: BackupSchedule["databaseType"]) => {
+	if (databaseType === "mongo") {
+		return "mongodb";
+	}
+	if (databaseType === "postgres") {
+		return "postgres";
+	}
+	if (databaseType === "mariadb") {
+		return "mariadb";
+	}
+	if (databaseType === "mysql") {
+		return "mysql";
+	}
+	return "mongodb";
+};

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

@@ -1,4 +1,4 @@
-import { findAdmin } from "@dokploy/server/services/admin";
+import path from "node:path";
 import { getAllServers } from "@dokploy/server/services/server";
 import { scheduleJob } from "node-schedule";
 import { db } from "../../db/index";
@@ -7,17 +7,30 @@ import {
 	cleanUpSystemPrune,
 	cleanUpUnusedImages,
 } from "../docker/utils";
-import { runMariadbBackup } from "./mariadb";
-import { runMongoBackup } from "./mongo";
-import { runMySqlBackup } from "./mysql";
-import { runPostgresBackup } from "./postgres";
+import { sendDockerCleanupNotifications } from "../notifications/docker-cleanup";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getS3Credentials, scheduleBackup } from "./utils";
+
+import { member } from "@dokploy/server/db/schema";
+import type { BackupSchedule } from "@dokploy/server/services/backup";
+import { eq } from "drizzle-orm";
+import { startLogCleanup } from "../access-log/handler";
 
 export const initCronJobs = async () => {
 	console.log("Setting up cron jobs....");
 
-	const admin = await findAdmin();
+	const admin = await db.query.member.findFirst({
+		where: eq(member.role, "owner"),
+		with: {
+			user: true,
+		},
+	});
 
-	if (admin?.enableDockerCleanup) {
+	if (!admin) {
+		return;
+	}
+
+	if (admin.user.enableDockerCleanup) {
 		scheduleJob("docker-cleanup", "0 0 * * *", async () => {
 			console.log(
 				`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
@@ -25,133 +38,92 @@ export const initCronJobs = async () => {
 			await cleanUpUnusedImages();
 			await cleanUpDockerBuilder();
 			await cleanUpSystemPrune();
+			await sendDockerCleanupNotifications(admin.user.id);
 		});
 	}
 
 	const servers = await getAllServers();
 
 	for (const server of servers) {
-		const { appName, serverId } = server;
-		if (serverId) {
+		const { serverId, enableDockerCleanup, name } = server;
+		if (enableDockerCleanup) {
 			scheduleJob(serverId, "0 0 * * *", async () => {
 				console.log(
-					`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${appName}`,
+					`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})`,
+				);
 			});
 		}
 	}
 
-	const pgs = await db.query.postgres.findMany({
+	const backups = await db.query.backups.findMany({
 		with: {
-			backups: {
-				with: {
-					destination: true,
-					postgres: true,
-					mariadb: true,
-					mysql: true,
-					mongo: true,
-				},
-			},
+			destination: true,
+			postgres: true,
+			mariadb: true,
+			mysql: true,
+			mongo: true,
+			user: true,
+			compose: true,
 		},
 	});
-	for (const pg of pgs) {
-		for (const backup of pg.backups) {
-			const { schedule, backupId, enabled } = backup;
-			if (enabled) {
-				scheduleJob(backupId, schedule, async () => {
-					console.log(
-						`PG-SERVER[${new Date().toLocaleString()}] Running Backup ${backupId}`,
-					);
-					runPostgresBackup(pg, backup);
-				});
+
+	for (const backup of backups) {
+		try {
+			if (backup.enabled) {
+				scheduleBackup(backup);
+				console.log(
+					`[Backup] ${backup.databaseType} Enabled with cron: [${backup.schedule}]`,
+				);
 			}
+		} catch (error) {
+			console.error(`[Backup] ${backup.databaseType} Error`, error);
 		}
 	}
 
-	const mariadbs = await db.query.mariadb.findMany({
-		with: {
-			backups: {
-				with: {
-					destination: true,
-					postgres: true,
-					mariadb: true,
-					mysql: true,
-					mongo: true,
-				},
-			},
-		},
-	});
-
-	for (const maria of mariadbs) {
-		for (const backup of maria.backups) {
-			const { schedule, backupId, enabled } = backup;
-			if (enabled) {
-				scheduleJob(backupId, schedule, async () => {
-					console.log(
-						`MARIADB-SERVER[${new Date().toLocaleString()}] Running Backup ${backupId}`,
-					);
-					await runMariadbBackup(maria, backup);
-				});
-			}
-		}
-	}
-
-	const mongodbs = await db.query.mongo.findMany({
-		with: {
-			backups: {
-				with: {
-					destination: true,
-					postgres: true,
-					mariadb: true,
-					mysql: true,
-					mongo: true,
-				},
-			},
-		},
-	});
-
-	for (const mongo of mongodbs) {
-		for (const backup of mongo.backups) {
-			const { schedule, backupId, enabled } = backup;
-			if (enabled) {
-				scheduleJob(backupId, schedule, async () => {
-					console.log(
-						`MONGO-SERVER[${new Date().toLocaleString()}] Running Backup ${backupId}`,
-					);
-					await runMongoBackup(mongo, backup);
-				});
-			}
-		}
-	}
-
-	const mysqls = await db.query.mysql.findMany({
-		with: {
-			backups: {
-				with: {
-					destination: true,
-					postgres: true,
-					mariadb: true,
-					mysql: true,
-					mongo: true,
-				},
-			},
-		},
-	});
-
-	for (const mysql of mysqls) {
-		for (const backup of mysql.backups) {
-			const { schedule, backupId, enabled } = backup;
-			if (enabled) {
-				scheduleJob(backupId, schedule, async () => {
-					console.log(
-						`MYSQL-SERVER[${new Date().toLocaleString()}] Running Backup ${backupId}`,
-					);
-					await runMySqlBackup(mysql, backup);
-				});
-			}
-		}
+	if (admin?.user.logCleanupCron) {
+		console.log("Starting log requests cleanup", admin.user.logCleanupCron);
+		await startLogCleanup(admin.user.logCleanupCron);
+	}
+};
+
+export const keepLatestNBackups = async (
+	backup: BackupSchedule,
+	serverId?: string | null,
+) => {
+	// 0 also immediately returns which is good as the empty "keep latest" field in the UI
+	// is saved as 0 in the database
+	if (!backup.keepLatestCount) return;
+
+	try {
+		const rcloneFlags = getS3Credentials(backup.destination);
+		const backupFilesPath = path.join(
+			`:s3:${backup.destination.bucket}`,
+			backup.prefix,
+		);
+
+		// --include "*.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"}" ${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}/{}`;
+
+		const rcloneCommand = `${rcloneList} | ${sortAndPickUnwantedBackups} ${rcloneDelete}`;
+
+		if (serverId) {
+			await execAsyncRemote(serverId, rcloneCommand);
+		} else {
+			await execAsync(rcloneCommand);
+		}
+	} catch (error) {
+		console.error(error);
 	}
 };

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

@@ -1,47 +1,45 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
 import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
-import {
-	getRemoteServiceContainer,
-	getServiceContainer,
-} from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMariadbBackup = async (
 	mariadb: Mariadb,
 	backup: BackupSchedule,
 ) => {
-	const { appName, databasePassword, databaseUser, projectId, name } = mariadb;
+	const { projectId, name } = mariadb;
 	const project = await findProjectById(projectId);
-	const { prefix, database } = backup;
+	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = path.join(prefix, backupFileName);
-
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "MariaDB Backup",
+		description: "MariaDB Backup",
+	});
 	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 (mariadb.serverId) {
-			const { Id: containerId } = await getRemoteServiceContainer(
-				mariadb.serverId,
-				appName,
-			);
-			const mariadbDumpCommand = `docker exec ${containerId} sh -c "mariadb-dump --user='${databaseUser}' --password='${databasePassword}' --databases ${database} | gzip"`;
-
-			await execAsyncRemote(
-				mariadb.serverId,
-				`${mariadbDumpCommand} | ${rcloneCommand}`,
-			);
+			await execAsyncRemote(mariadb.serverId, backupCommand);
 		} else {
-			const { Id: containerId } = await getServiceContainer(appName);
-			const mariadbDumpCommand = `docker exec ${containerId} sh -c "mariadb-dump --user='${databaseUser}' --password='${databasePassword}' --databases ${database} | gzip"`;
-
-			await execAsync(`${mariadbDumpCommand} | ${rcloneCommand}`);
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
 		}
 
 		await sendDatabaseBackupNotifications({
@@ -49,8 +47,10 @@ export const runMariadbBackup = async (
 			projectName: project.name,
 			databaseType: "mariadb",
 			type: "success",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "done");
 	} catch (error) {
 		console.log(error);
 		await sendDatabaseBackupNotifications({
@@ -60,8 +60,10 @@ export const runMariadbBackup = async (
 			type: "error",
 			// @ts-ignore
 			errorMessage: error?.message || "Error message not provided",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "error");
 		throw error;
 	}
 };

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

@@ -1,44 +1,43 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
 import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
-import {
-	getRemoteServiceContainer,
-	getServiceContainer,
-} from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
-// mongodb://mongo:Bqh7AQl-PRbnBu@localhost:27017/?tls=false&directConnection=true
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
-	const { appName, databasePassword, databaseUser, projectId, name } = mongo;
+	const { projectId, name } = mongo;
 	const project = await findProjectById(projectId);
-	const { prefix, database } = backup;
+	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.dump.gz`;
-	const bucketDestination = path.join(prefix, backupFileName);
-
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "MongoDB Backup",
+		description: "MongoDB Backup",
+	});
 	try {
 		const rcloneFlags = getS3Credentials(destination);
 		const rcloneDestination = `:s3:${destination.bucket}/${bucketDestination}`;
-
 		const rcloneCommand = `rclone rcat ${rcloneFlags.join(" ")} "${rcloneDestination}"`;
-		if (mongo.serverId) {
-			const { Id: containerId } = await getRemoteServiceContainer(
-				mongo.serverId,
-				appName,
-			);
-			const mongoDumpCommand = `docker exec ${containerId} sh -c "mongodump -d '${database}' -u '${databaseUser}' -p '${databasePassword}' --archive --authenticationDatabase=admin --gzip"`;
 
-			await execAsyncRemote(
-				mongo.serverId,
-				`${mongoDumpCommand} | ${rcloneCommand}`,
-			);
+		const backupCommand = getBackupCommand(
+			backup,
+			rcloneCommand,
+			deployment.logPath,
+		);
+
+		if (mongo.serverId) {
+			await execAsyncRemote(mongo.serverId, backupCommand);
 		} else {
-			const { Id: containerId } = await getServiceContainer(appName);
-			const mongoDumpCommand = `docker exec ${containerId} sh -c "mongodump -d '${database}' -u '${databaseUser}' -p '${databasePassword}'  --archive --authenticationDatabase=admin --gzip"`;
-			await execAsync(`${mongoDumpCommand} | ${rcloneCommand}`);
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
 		}
 
 		await sendDatabaseBackupNotifications({
@@ -46,8 +45,10 @@ export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 			projectName: project.name,
 			databaseType: "mongodb",
 			type: "success",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "done");
 	} catch (error) {
 		console.log(error);
 		await sendDatabaseBackupNotifications({
@@ -57,9 +58,10 @@ export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 			type: "error",
 			// @ts-ignore
 			errorMessage: error?.message || "Error message not provided",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "error");
 		throw error;
 	}
 };
-// mongorestore -d monguito -u mongo -p Bqh7AQl-PRbnBu --authenticationDatabase admin --gzip --archive=2024-04-13T05:03:58.937Z.dump.gz

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

@@ -1,53 +1,55 @@
-import { unlink } from "node:fs/promises";
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
 import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
-import {
-	getRemoteServiceContainer,
-	getServiceContainer,
-} from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
-	const { appName, databaseRootPassword, projectId, name } = mysql;
+	const { projectId, name } = mysql;
 	const project = await findProjectById(projectId);
-	const { prefix, database } = backup;
+	const { prefix } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.sql.gz`;
-	const bucketDestination = path.join(prefix, backupFileName);
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "MySQL Backup",
+		description: "MySQL Backup",
+	});
 
 	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 (mysql.serverId) {
-			const { Id: containerId } = await getRemoteServiceContainer(
-				mysql.serverId,
-				appName,
-			);
-			const mysqlDumpCommand = `docker exec ${containerId} sh -c "mysqldump --default-character-set=utf8mb4 -u 'root' --password='${databaseRootPassword}' --single-transaction --no-tablespaces --quick '${database}' | gzip"`;
-
-			await execAsyncRemote(
-				mysql.serverId,
-				`${mysqlDumpCommand} | ${rcloneCommand}`,
-			);
+			await execAsyncRemote(mysql.serverId, backupCommand);
 		} else {
-			const { Id: containerId } = await getServiceContainer(appName);
-			const mysqlDumpCommand = `docker exec ${containerId} sh -c "mysqldump --default-character-set=utf8mb4 -u 'root' --password='${databaseRootPassword}' --single-transaction --no-tablespaces --quick '${database}' | gzip"`;
-
-			await execAsync(`${mysqlDumpCommand} | ${rcloneCommand}`);
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
 		}
 		await sendDatabaseBackupNotifications({
 			applicationName: name,
 			projectName: project.name,
 			databaseType: "mysql",
 			type: "success",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "done");
 	} catch (error) {
 		console.log(error);
 		await sendDatabaseBackupNotifications({
@@ -57,8 +59,10 @@ export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 			type: "error",
 			// @ts-ignore
 			errorMessage: error?.message || "Error message not provided",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+		await updateDeploymentStatus(deployment.deploymentId, "error");
 		throw error;
 	}
 };

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

@@ -1,47 +1,47 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
 import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
-import {
-	getRemoteServiceContainer,
-	getServiceContainer,
-} from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getBackupCommand, getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runPostgresBackup = async (
 	postgres: Postgres,
 	backup: BackupSchedule,
 ) => {
-	const { appName, databaseUser, name, projectId } = postgres;
+	const { name, projectId } = postgres;
 	const project = await findProjectById(projectId);
 
-	const { prefix, database } = backup;
+	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 = path.join(prefix, backupFileName);
+	const bucketDestination = `${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 (postgres.serverId) {
-			const { Id: containerId } = await getRemoteServiceContainer(
-				postgres.serverId,
-				appName,
-			);
-			const pgDumpCommand = `docker exec ${containerId} sh -c "pg_dump -Fc --no-acl --no-owner -h localhost -U ${databaseUser} --no-password '${database}' | gzip"`;
-
-			await execAsyncRemote(
-				postgres.serverId,
-				`${pgDumpCommand} | ${rcloneCommand}`,
-			);
+			await execAsyncRemote(postgres.serverId, backupCommand);
 		} else {
-			const { Id: containerId } = await getServiceContainer(appName);
-
-			const pgDumpCommand = `docker exec ${containerId} sh -c "pg_dump -Fc --no-acl --no-owner -h localhost -U ${databaseUser} --no-password '${database}' | gzip"`;
-			await execAsync(`${pgDumpCommand} | ${rcloneCommand}`);
+			await execAsync(backupCommand, {
+				shell: "/bin/bash",
+			});
 		}
 
 		await sendDatabaseBackupNotifications({
@@ -49,8 +49,11 @@ export const runPostgresBackup = async (
 			projectName: project.name,
 			databaseType: "postgres",
 			type: "success",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
 	} catch (error) {
 		await sendDatabaseBackupNotifications({
 			applicationName: name,
@@ -59,13 +62,13 @@ export const runPostgresBackup = async (
 			type: "error",
 			// @ts-ignore
 			errorMessage: error?.message || "Error message not provided",
-			adminId: project.adminId,
+			organizationId: project.organizationId,
+			databaseName: backup.database,
 		});
 
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+
 		throw error;
 	} finally {
 	}
 };
-
-// Restore
-// /Applications/pgAdmin 4.app/Contents/SharedSupport/pg_restore --host "localhost" --port "5432" --username "mauricio" --no-password --dbname "postgres" --verbose "/Users/mauricio/Downloads/_databases_2024-04-12T07_02_05.234Z.sql"

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

@@ -1,23 +1,47 @@
+import { logger } from "@dokploy/server/lib/logger";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { Destination } from "@dokploy/server/services/destination";
 import { scheduleJob, scheduledJobs } from "node-schedule";
+import { keepLatestNBackups } from ".";
+import { runComposeBackup } from "./compose";
 import { runMariadbBackup } from "./mariadb";
 import { runMongoBackup } from "./mongo";
 import { runMySqlBackup } from "./mysql";
 import { runPostgresBackup } from "./postgres";
+import { runWebServerBackup } from "./web-server";
 
 export const scheduleBackup = (backup: BackupSchedule) => {
-	const { schedule, backupId, databaseType, postgres, mysql, mongo, mariadb } =
-		backup;
+	const {
+		schedule,
+		backupId,
+		databaseType,
+		postgres,
+		mysql,
+		mongo,
+		mariadb,
+		compose,
+	} = backup;
 	scheduleJob(backupId, schedule, async () => {
-		if (databaseType === "postgres" && postgres) {
-			await runPostgresBackup(postgres, backup);
-		} else if (databaseType === "mysql" && mysql) {
-			await runMySqlBackup(mysql, backup);
-		} else if (databaseType === "mongo" && mongo) {
-			await runMongoBackup(mongo, backup);
-		} else if (databaseType === "mariadb" && mariadb) {
-			await runMariadbBackup(mariadb, backup);
+		if (backup.backupType === "database") {
+			if (databaseType === "postgres" && postgres) {
+				await runPostgresBackup(postgres, backup);
+				await keepLatestNBackups(backup, postgres.serverId);
+			} else if (databaseType === "mysql" && mysql) {
+				await runMySqlBackup(mysql, backup);
+				await keepLatestNBackups(backup, mysql.serverId);
+			} else if (databaseType === "mongo" && mongo) {
+				await runMongoBackup(mongo, backup);
+				await keepLatestNBackups(backup, mongo.serverId);
+			} else if (databaseType === "mariadb" && mariadb) {
+				await runMariadbBackup(mariadb, backup);
+				await keepLatestNBackups(backup, mariadb.serverId);
+			} else if (databaseType === "web-server") {
+				await runWebServerBackup(backup);
+				await keepLatestNBackups(backup);
+			}
+		} else if (backup.backupType === "compose" && compose) {
+			await runComposeBackup(compose, backup);
+			await keepLatestNBackups(backup, compose.serverId);
 		}
 	});
 };
@@ -27,8 +51,15 @@ export const removeScheduleBackup = (backupId: string) => {
 	currentJob?.cancel();
 };
 
+export const normalizeS3Path = (prefix: string) => {
+	// Trim whitespace and remove leading/trailing slashes
+	const normalizedPrefix = prefix.trim().replace(/^\/+|\/+$/g, "");
+	// Return empty string if prefix is empty, otherwise append trailing slash
+	return normalizedPrefix ? `${normalizedPrefix}/` : "";
+};
+
 export const getS3Credentials = (destination: Destination) => {
-	const { accessKey, secretAccessKey, bucket, region, endpoint, provider } =
+	const { accessKey, secretAccessKey, region, endpoint, provider } =
 		destination;
 	const rcloneFlags = [
 		`--s3-access-key-id=${accessKey}`,
@@ -45,3 +76,195 @@ export const getS3Credentials = (destination: Destination) => {
 
 	return rcloneFlags;
 };
+
+export const getPostgresBackupCommand = (
+	database: string,
+	databaseUser: string,
+) => {
+	return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; pg_dump -Fc --no-acl --no-owner -h localhost -U ${databaseUser} --no-password '${database}' | gzip"`;
+};
+
+export const getMariadbBackupCommand = (
+	database: string,
+	databaseUser: string,
+	databasePassword: string,
+) => {
+	return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mariadb-dump --user='${databaseUser}' --password='${databasePassword}' --databases ${database} | gzip"`;
+};
+
+export const getMysqlBackupCommand = (
+	database: string,
+	databasePassword: string,
+) => {
+	return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mysqldump --default-character-set=utf8mb4 -u 'root' --password='${databasePassword}' --single-transaction --no-tablespaces --quick '${database}' | gzip"`;
+};
+
+export const getMongoBackupCommand = (
+	database: string,
+	databaseUser: string,
+	databasePassword: string,
+) => {
+	return `docker exec -i $CONTAINER_ID bash -c "set -o pipefail; mongodump -d '${database}' -u '${databaseUser}' -p '${databasePassword}' --archive --authenticationDatabase admin --gzip"`;
+};
+
+export const getServiceContainerCommand = (appName: string) => {
+	return `docker ps -q --filter "status=running" --filter "label=com.docker.swarm.service.name=${appName}" | head -n 1`;
+};
+
+export const getComposeContainerCommand = (
+	appName: string,
+	serviceName: string,
+	composeType: "stack" | "docker-compose" | undefined,
+) => {
+	if (composeType === "stack") {
+		return `docker ps -q --filter "status=running" --filter "label=com.docker.stack.namespace=${appName}" --filter "label=com.docker.swarm.service.name=${appName}_${serviceName}" | head -n 1`;
+	}
+	return `docker ps -q --filter "status=running" --filter "label=com.docker.compose.project=${appName}" --filter "label=com.docker.compose.service=${serviceName}" | head -n 1`;
+};
+
+const getContainerSearchCommand = (backup: BackupSchedule) => {
+	const { backupType, postgres, mysql, mariadb, mongo, compose, serviceName } =
+		backup;
+
+	if (backupType === "database") {
+		const appName =
+			postgres?.appName || mysql?.appName || mariadb?.appName || mongo?.appName;
+		return getServiceContainerCommand(appName || "");
+	}
+	if (backupType === "compose") {
+		const { appName, composeType } = compose || {};
+		return getComposeContainerCommand(
+			appName || "",
+			serviceName || "",
+			composeType,
+		);
+	}
+};
+
+export const generateBackupCommand = (backup: BackupSchedule) => {
+	const { backupType, databaseType } = backup;
+	switch (databaseType) {
+		case "postgres": {
+			const postgres = backup.postgres;
+			if (backupType === "database" && postgres) {
+				return getPostgresBackupCommand(backup.database, postgres.databaseUser);
+			}
+			if (backupType === "compose" && backup.metadata?.postgres) {
+				return getPostgresBackupCommand(
+					backup.database,
+					backup.metadata.postgres.databaseUser,
+				);
+			}
+			break;
+		}
+		case "mysql": {
+			const mysql = backup.mysql;
+			if (backupType === "database" && mysql) {
+				return getMysqlBackupCommand(
+					backup.database,
+					mysql.databaseRootPassword,
+				);
+			}
+			if (backupType === "compose" && backup.metadata?.mysql) {
+				return getMysqlBackupCommand(
+					backup.database,
+					backup.metadata?.mysql?.databaseRootPassword || "",
+				);
+			}
+			break;
+		}
+		case "mariadb": {
+			const mariadb = backup.mariadb;
+			if (backupType === "database" && mariadb) {
+				return getMariadbBackupCommand(
+					backup.database,
+					mariadb.databaseUser,
+					mariadb.databasePassword,
+				);
+			}
+			if (backupType === "compose" && backup.metadata?.mariadb) {
+				return getMariadbBackupCommand(
+					backup.database,
+					backup.metadata.mariadb.databaseUser,
+					backup.metadata.mariadb.databasePassword,
+				);
+			}
+			break;
+		}
+		case "mongo": {
+			const mongo = backup.mongo;
+			if (backupType === "database" && mongo) {
+				return getMongoBackupCommand(
+					backup.database,
+					mongo.databaseUser,
+					mongo.databasePassword,
+				);
+			}
+			if (backupType === "compose" && backup.metadata?.mongo) {
+				return getMongoBackupCommand(
+					backup.database,
+					backup.metadata.mongo.databaseUser,
+					backup.metadata.mongo.databasePassword,
+				);
+			}
+			break;
+		}
+		default:
+			throw new Error(`Database type not supported: ${databaseType}`);
+	}
+
+	return null;
+};
+
+export const getBackupCommand = (
+	backup: BackupSchedule,
+	rcloneCommand: string,
+	logPath: string,
+) => {
+	const containerSearch = getContainerSearchCommand(backup);
+	const backupCommand = generateBackupCommand(backup);
+
+	logger.info(
+		{
+			containerSearch,
+			backupCommand,
+			rcloneCommand,
+			logPath,
+		},
+		`Executing backup command: ${backup.databaseType} ${backup.backupType}`,
+	);
+
+	return `
+	set -eo pipefail;
+	echo "[$(date)] Starting backup process..." >> ${logPath};
+	echo "[$(date)] Executing backup command..." >> ${logPath};
+	CONTAINER_ID=$(${containerSearch})
+
+	if [ -z "$CONTAINER_ID" ]; then
+		echo "[$(date)] ❌ Error: Container not found" >> ${logPath};
+		exit 1;
+	fi
+
+	echo "[$(date)] Container Up: $CONTAINER_ID" >> ${logPath};
+
+	# Run the backup command and capture the exit status
+	BACKUP_OUTPUT=$(${backupCommand} 2>&1 >/dev/null) || {
+		echo "[$(date)] ❌ Error: Backup failed" >> ${logPath};
+		echo "Error: $BACKUP_OUTPUT" >> ${logPath};
+		exit 1;
+	}
+
+	echo "[$(date)] ✅ backup completed successfully" >> ${logPath};
+	echo "[$(date)] Starting upload to S3..." >> ${logPath};
+
+	# Run the upload command and capture the exit status
+	UPLOAD_OUTPUT=$(${backupCommand} | ${rcloneCommand} 2>&1 >/dev/null) || {
+		echo "[$(date)] ❌ Error: Upload to S3 failed" >> ${logPath};
+		echo "Error: $UPLOAD_OUTPUT" >> ${logPath};
+		exit 1;
+	}
+
+	echo "[$(date)] ✅ Upload to S3 completed successfully" >> ${logPath};
+	echo "Backup done ✅" >> ${logPath};
+	`;
+};

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

@@ -0,0 +1,106 @@
+import { createWriteStream } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { IS_CLOUD, paths } from "@dokploy/server/constants";
+import type { BackupSchedule } from "@dokploy/server/services/backup";
+import {
+	createDeploymentBackup,
+	updateDeploymentStatus,
+} from "@dokploy/server/services/deployment";
+import { findDestinationById } from "@dokploy/server/services/destination";
+import { execAsync } from "../process/execAsync";
+import { getS3Credentials, normalizeS3Path } from "./utils";
+
+export const runWebServerBackup = async (backup: BackupSchedule) => {
+	if (IS_CLOUD) {
+		return;
+	}
+
+	const deployment = await createDeploymentBackup({
+		backupId: backup.backupId,
+		title: "Web Server Backup",
+		description: "Web Server Backup",
+	});
+	const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+
+	try {
+		const destination = await findDestinationById(backup.destinationId);
+		const rcloneFlags = getS3Credentials(destination);
+		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+		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}`;
+
+		try {
+			await execAsync(`mkdir -p ${tempDir}/filesystem`);
+
+			// First get the container ID
+			const { stdout: containerId } = await execAsync(
+				`docker ps --filter "name=dokploy-postgres" --filter "status=running" -q | head -n 1`,
+			);
+
+			if (!containerId) {
+				writeStream.write("Dokploy postgres container not found❌\n");
+				writeStream.end();
+				throw new Error("Dokploy postgres container not found");
+			}
+
+			writeStream.write(`Dokploy postgres container ID: ${containerId}\n`);
+
+			const postgresContainerId = containerId.trim();
+
+			// First dump the database inside the container
+			const dumpCommand = `docker exec ${postgresContainerId} pg_dump -v -Fc -U dokploy -d dokploy -f /tmp/database.sql`;
+			writeStream.write(`Running dump command: ${dumpCommand}\n`);
+			await execAsync(dumpCommand);
+
+			// Then copy the file from the container to host
+			const copyCommand = `docker cp ${postgresContainerId}:/tmp/database.sql ${tempDir}/database.sql`;
+			writeStream.write(`Copying database dump: ${copyCommand}\n`);
+			await execAsync(copyCommand);
+
+			// Clean up the temp file in the container
+			const cleanupCommand = `docker exec ${postgresContainerId} rm -f /tmp/database.sql`;
+			writeStream.write(`Cleaning up temp file: ${cleanupCommand}\n`);
+			await execAsync(cleanupCommand);
+
+			await execAsync(
+				`rsync -a --ignore-errors ${BASE_PATH}/ ${tempDir}/filesystem/`,
+			);
+
+			writeStream.write("Copied filesystem to temp directory\n");
+
+			await execAsync(
+				// Zip all .sql files since we created more than one
+				`cd ${tempDir} && zip -r ${backupFileName} *.sql filesystem/ > /dev/null 2>&1`,
+			);
+
+			writeStream.write("Zipped database and filesystem\n");
+
+			const uploadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${tempDir}/${backupFileName}" "${s3Path}"`;
+			writeStream.write(`Running command: ${uploadCommand}\n`);
+			await execAsync(uploadCommand);
+			writeStream.write("Uploaded backup to S3 ✅\n");
+			writeStream.end();
+			await updateDeploymentStatus(deployment.deploymentId, "done");
+			return true;
+		} finally {
+			try {
+				await rm(tempDir, { recursive: true, force: true });
+			} catch (cleanupError) {
+				console.error("Cleanup error:", cleanupError);
+			}
+		}
+	} catch (error) {
+		console.error("Backup error:", error);
+		writeStream.write("Backup error❌\n");
+		writeStream.write(
+			error instanceof Error ? error.message : "Unknown error\n",
+		);
+		writeStream.end();
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		throw error;
+	}
+};

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

@@ -12,8 +12,12 @@ import {
 	writeDomainsToCompose,
 	writeDomainsToComposeRemote,
 } from "../docker/domain";
-import { encodeBase64, prepareEnvironmentVariables } from "../docker/utils";
-import { execAsyncRemote } from "../process/execAsync";
+import {
+	encodeBase64,
+	getEnviromentVariablesObject,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { spawnAsync } from "../process/spawnAsync";
 
 export type ComposeNested = InferResultType<
@@ -29,13 +33,19 @@ export const buildCompose = async (compose: ComposeNested, logPath: string) => {
 		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} ✅`;
+    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,
@@ -46,8 +56,8 @@ Compose Type: ${composeType} ✅`;
 			borderStyle: "double",
 		});
 		writeStream.write(`\n${logBox}\n`);
-
 		const projectPath = join(COMPOSE_PATH, compose.appName, "code");
+
 		await spawnAsync(
 			"docker",
 			[...command.split(" ")],
@@ -61,13 +71,22 @@ Compose Type: ${composeType} ✅`;
 				env: {
 					NODE_ENV: process.env.NODE_ENV,
 					PATH: process.env.PATH,
+					...(composeType === "stack" && {
+						...getEnviromentVariablesObject(compose.env, compose.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 ❌");
+		writeStream.write(`Error ❌ ${(error as Error).message}`);
 		throw error;
 	} finally {
 		writeStream.end();
@@ -79,11 +98,11 @@ export const getBuildComposeCommand = async (
 	logPath: string,
 ) => {
 	const { COMPOSE_PATH } = paths(true);
-	const { sourceType, appName, mounts, composeType, domains, composePath } =
-		compose;
+	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,
@@ -119,7 +138,10 @@ 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 connect ${compose.appName} $(docker ps --filter "name=dokploy-traefik" -q) >/dev/null 2>&1` : ""}
 	
 		echo "Docker Compose Deployed: ✅" >> "${logPath}"
 	} || {
@@ -143,6 +165,9 @@ const sanitizeCommand = (command: string) => {
 
 export const createCommand = (compose: ComposeNested) => {
 	const { composeType, appName, sourceType } = compose;
+	if (compose.command) {
+		return `${sanitizeCommand(compose.command)}`;
+	}
 
 	const path =
 		sourceType === "raw" ? "docker-compose.yml" : compose.composePath;
@@ -154,12 +179,6 @@ export const createCommand = (compose: ComposeNested) => {
 		command = `stack deploy -c ${path} ${appName} --prune`;
 	}
 
-	const customCommand = sanitizeCommand(compose.command);
-
-	if (customCommand) {
-		command = `${command} ${customCommand}`;
-	}
-
 	return command;
 };
 
@@ -171,9 +190,10 @@ const createEnvFile = (compose: ComposeNested) => {
 		join(COMPOSE_PATH, appName, "code", "docker-compose.yml");
 
 	const envFilePath = join(dirname(composeFilePath), ".env");
-	let envContent = env || "";
+	let envContent = `APP_NAME=${appName}\n`;
+	envContent += env || "";
 	if (!envContent.includes("DOCKER_CONFIG")) {
-		envContent += "\nDOCKER_CONFIG=/root/.docker/config.json";
+		envContent += "\nDOCKER_CONFIG=/root/.docker";
 	}
 
 	if (compose.randomize) {
@@ -200,9 +220,10 @@ export const getCreateEnvFileCommand = (compose: ComposeNested) => {
 
 	const envFilePath = join(dirname(composeFilePath), ".env");
 
-	let envContent = env || "";
+	let envContent = `APP_NAME=${appName}\n`;
+	envContent += env || "";
 	if (!envContent.includes("DOCKER_CONFIG")) {
-		envContent += "\nDOCKER_CONFIG=/root/.docker/config.json";
+		envContent += "\nDOCKER_CONFIG=/root/.docker";
 	}
 
 	if (compose.randomize) {
@@ -220,3 +241,17 @@ touch ${envFilePath};
 echo "${encodedContent}" | base64 -d > "${envFilePath}";
 	`;
 };
+
+const getExportEnvCommand = (compose: ComposeNested) => {
+	if (compose.composeType !== "stack") return "";
+
+	const envVars = getEnviromentVariablesObject(
+		compose.env,
+		compose.project.env,
+	);
+	const exports = Object.entries(envVars)
+		.map(([key, value]) => `export ${key}=${JSON.stringify(value)}`)
+		.join("\n");
+
+	return exports ? `\n# Export environment variables\n${exports}\n` : "";
+};

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

@@ -12,8 +12,14 @@ export const buildCustomDocker = async (
 	application: ApplicationNested,
 	writeStream: WriteStream,
 ) => {
-	const { appName, env, publishDirectory, buildArgs, dockerBuildStage } =
-		application;
+	const {
+		appName,
+		env,
+		publishDirectory,
+		buildArgs,
+		dockerBuildStage,
+		cleanCache,
+	} = application;
 	const dockerFilePath = getBuildAppDirectory(application);
 	try {
 		const image = `${appName}`;
@@ -29,6 +35,10 @@ export const buildCustomDocker = async (
 
 		const commandArgs = ["build", "-t", image, "-f", dockerFilePath, "."];
 
+		if (cleanCache) {
+			commandArgs.push("--no-cache");
+		}
+
 		if (dockerBuildStage) {
 			commandArgs.push("--target", dockerBuildStage);
 		}
@@ -65,8 +75,14 @@ export const getDockerCommand = (
 	application: ApplicationNested,
 	logPath: string,
 ) => {
-	const { appName, env, publishDirectory, buildArgs, dockerBuildStage } =
-		application;
+	const {
+		appName,
+		env,
+		publishDirectory,
+		buildArgs,
+		dockerBuildStage,
+		cleanCache,
+	} = application;
 	const dockerFilePath = getBuildAppDirectory(application);
 
 	try {
@@ -88,8 +104,12 @@ export const getDockerCommand = (
 			commandArgs.push("--target", dockerBuildStage);
 		}
 
+		if (cleanCache) {
+			commandArgs.push("--no-cache");
+		}
+
 		for (const arg of args) {
-			commandArgs.push("--build-arg", arg);
+			commandArgs.push("--build-arg", `'${arg}'`);
 		}
 
 		/*

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

@@ -27,7 +27,9 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 		const buffer = Buffer.from(arrayBuffer);
 
 		const zip = new AdmZip(buffer);
-		const zipEntries = zip.getEntries();
+		const zipEntries = zip
+			.getEntries()
+			.filter((entry) => !entry.entryName.startsWith("__MACOSX"));
 
 		const rootEntries = zipEntries.filter(
 			(entry) =>
@@ -59,14 +61,22 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 
 			if (!filePath) continue;
 
-			const fullPath = path.join(outputPath, filePath);
+			const fullPath = path.join(outputPath, filePath).replace(/\\/g, "/");
 
 			if (application.serverId) {
-				if (entry.isDirectory) {
-					await execAsyncRemote(application.serverId, `mkdir -p ${fullPath}`);
-				} else {
+				if (!entry.isDirectory) {
 					if (sftp === null) throw new Error("No SFTP connection available");
-					await uploadFileToServer(sftp, entry.getData(), fullPath);
+					try {
+						const dirPath = path.dirname(fullPath);
+						await execAsyncRemote(
+							application.serverId,
+							`mkdir -p "${dirPath}"`,
+						);
+						await uploadFileToServer(sftp, entry.getData(), fullPath);
+					} catch (err) {
+						console.error(`Error uploading file ${fullPath}:`, err);
+						throw err;
+					}
 				}
 			} else {
 				if (entry.isDirectory) {
@@ -103,7 +113,6 @@ const getSFTPConnection = async (serverId: string): Promise<SFTPWrapper> => {
 				port: server.port,
 				username: server.username,
 				privateKey: server.sshKey?.privateKey,
-				timeout: 99999,
 			});
 	});
 };
@@ -115,7 +124,10 @@ const uploadFileToServer = (
 ): Promise<void> => {
 	return new Promise((resolve, reject) => {
 		sftp.writeFile(remotePath, data, (err) => {
-			if (err) return reject(err);
+			if (err) {
+				console.error(`SFTP write error for ${remotePath}:`, err);
+				return reject(err);
+			}
 			resolve();
 		});
 	});

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

@@ -9,7 +9,7 @@ export const buildHeroku = async (
 	application: ApplicationNested,
 	writeStream: WriteStream,
 ) => {
-	const { env, appName } = application;
+	const { env, appName, cleanCache } = application;
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const envVariables = prepareEnvironmentVariables(
 		env,
@@ -29,6 +29,10 @@ export const buildHeroku = async (
 			args.push("--env", env);
 		}
 
+		if (cleanCache) {
+			args.push("--clear-cache");
+		}
+
 		await spawnAsync("pack", args, (data) => {
 			if (writeStream.writable) {
 				writeStream.write(data);
@@ -44,7 +48,7 @@ export const getHerokuCommand = (
 	application: ApplicationNested,
 	logPath: string,
 ) => {
-	const { env, appName } = application;
+	const { env, appName, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const envVariables = prepareEnvironmentVariables(
@@ -61,6 +65,10 @@ export const getHerokuCommand = (
 		`heroku/builder:${application.herokuVersion || "24"}`,
 	];
 
+	if (cleanCache) {
+		args.push("--clear-cache");
+	}
+
 	for (const env of envVariables) {
 		args.push("--env", `'${env}'`);
 	}

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

@@ -1,5 +1,4 @@
 import { createWriteStream } from "node:fs";
-import { join } from "node:path";
 import type { InferResultType } from "@dokploy/server/types/with";
 import type { CreateServiceOptions } from "dockerode";
 import { uploadImage, uploadImageRemoteCommand } from "../cluster/upload";
@@ -16,8 +15,8 @@ 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 { nanoid } from "nanoid";
 
 // NIXPACKS codeDirectory = where is the path of the code directory
 // HEROKU codeDirectory = where is the path of the code directory
@@ -56,6 +55,8 @@ export const buildApplication = async (
 			await buildCustomDocker(application, writeStream);
 		} else if (buildType === "static") {
 			await buildStatic(application, writeStream);
+		} else if (buildType === "railpack") {
+			await buildRailpack(application, writeStream);
 		}
 
 		if (application.registryId) {
@@ -97,6 +98,9 @@ export const getBuildCommand = (
 		case "dockerfile":
 			command = getDockerCommand(application, logPath);
 			break;
+		case "railpack":
+			command = getRailpackCommand(application, logPath);
+			break;
 	}
 	if (registry) {
 		command += uploadImageRemoteCommand(application, logPath);
@@ -179,6 +183,7 @@ export const mechanizeDockerContainer = async (
 		RollbackConfig,
 		EndpointSpec: {
 			Ports: ports.map((port) => ({
+				PublishMode: port.publishMode,
 				Protocol: port.protocol,
 				TargetPort: port.targetPort,
 				PublishedPort: port.publishedPort,
@@ -190,6 +195,7 @@ export const mechanizeDockerContainer = async (
 	try {
 		const service = docker.getService(appName);
 		const inspect = await service.inspect();
+
 		await service.update({
 			version: Number.parseInt(inspect.Version.Index),
 			...settings,
@@ -198,34 +204,38 @@ export const mechanizeDockerContainer = async (
 				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
 			},
 		});
-	} catch (error) {
+	} catch {
 		await docker.createService(settings);
 	}
 };
 
 const getImageName = (application: ApplicationNested) => {
 	const { appName, sourceType, dockerImage, registry } = application;
-
+	const imageName = `${appName}:latest`;
 	if (sourceType === "docker") {
 		return dockerImage || "ERROR-NO-IMAGE-PROVIDED";
 	}
 
 	if (registry) {
-		return join(registry.imagePrefix || "", appName);
+		const { registryUrl, imagePrefix, username } = registry;
+		const registryTag = imagePrefix
+			? `${registryUrl}/${imagePrefix}/${imageName}`
+			: `${registryUrl}/${username}/${imageName}`;
+		return registryTag;
 	}
 
-	return `${appName}:latest`;
+	return imageName;
 };
 
-const getAuthConfig = (application: ApplicationNested) => {
-	const { registry, username, password, sourceType } = application;
+export const getAuthConfig = (application: ApplicationNested) => {
+	const { registry, username, password, sourceType, registryUrl } = application;
 
 	if (sourceType === "docker") {
 		if (username && password) {
 			return {
 				password,
 				username,
-				serveraddress: "https://index.docker.io/v1/",
+				serveraddress: registryUrl || "",
 			};
 		}
 	} else if (registry) {

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

@@ -14,7 +14,7 @@ export const buildNixpacks = async (
 	application: ApplicationNested,
 	writeStream: WriteStream,
 ) => {
-	const { env, appName, publishDirectory } = application;
+	const { env, appName, publishDirectory, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const buildContainerId = `${appName}-${nanoid(10)}`;
@@ -32,6 +32,10 @@ export const buildNixpacks = async (
 	try {
 		const args = ["build", buildAppDirectory, "--name", appName];
 
+		if (cleanCache) {
+			args.push("--no-cache");
+		}
+
 		for (const env of envVariables) {
 			args.push("--env", env);
 		}
@@ -91,7 +95,7 @@ export const getNixpacksCommand = (
 	application: ApplicationNested,
 	logPath: string,
 ) => {
-	const { env, appName, publishDirectory, serverId } = application;
+	const { env, appName, publishDirectory, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const buildContainerId = `${appName}-${nanoid(10)}`;
@@ -102,6 +106,10 @@ export const getNixpacksCommand = (
 
 	const args = ["build", buildAppDirectory, "--name", appName];
 
+	if (cleanCache) {
+		args.push("--no-cache");
+	}
+
 	for (const env of envVariables) {
 		args.push("--env", `'${env}'`);
 	}

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

@@ -8,7 +8,7 @@ export const buildPaketo = async (
 	application: ApplicationNested,
 	writeStream: WriteStream,
 ) => {
-	const { env, appName } = application;
+	const { env, appName, cleanCache } = application;
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const envVariables = prepareEnvironmentVariables(
 		env,
@@ -24,6 +24,10 @@ export const buildPaketo = async (
 			"paketobuildpacks/builder-jammy-full",
 		];
 
+		if (cleanCache) {
+			args.push("--clear-cache");
+		}
+
 		for (const env of envVariables) {
 			args.push("--env", env);
 		}
@@ -43,7 +47,7 @@ export const getPaketoCommand = (
 	application: ApplicationNested,
 	logPath: string,
 ) => {
-	const { env, appName } = application;
+	const { env, appName, cleanCache } = application;
 
 	const buildAppDirectory = getBuildAppDirectory(application);
 	const envVariables = prepareEnvironmentVariables(
@@ -60,6 +64,10 @@ export const getPaketoCommand = (
 		"paketobuildpacks/builder-jammy-full",
 	];
 
+	if (cleanCache) {
+		args.push("--clear-cache");
+	}
+
 	for (const env of envVariables) {
 		args.push("--env", `'${env}'`);
 	}

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

@@ -0,0 +1,200 @@
+import { createHash } from "node:crypto";
+import type { WriteStream } from "node:fs";
+import { nanoid } from "nanoid";
+import type { ApplicationNested } from ".";
+import {
+	parseEnvironmentKeyValuePair,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import { getBuildAppDirectory } from "../filesystem/directory";
+import { execAsync } from "../process/execAsync";
+import { spawnAsync } from "../process/spawnAsync";
+
+const calculateSecretsHash = (envVariables: string[]): string => {
+	const hash = createHash("sha256");
+	for (const env of envVariables.sort()) {
+		hash.update(env);
+	}
+	return hash.digest("hex");
+};
+
+export const buildRailpack = async (
+	application: ApplicationNested,
+	writeStream: WriteStream,
+) => {
+	const { env, appName, cleanCache } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(
+		env,
+		application.project.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:v0.0.64",
+			"-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;
+	}
+};
+
+export const getRailpackCommand = (
+	application: ApplicationNested,
+	logPath: string,
+) => {
+	const { env, appName, cleanCache } = application;
+	const buildAppDirectory = getBuildAppDirectory(application);
+	const envVariables = prepareEnvironmentVariables(
+		env,
+		application.project.env,
+	);
+
+	// Prepare command
+	const prepareArgs = [
+		"prepare",
+		buildAppDirectory,
+		"--plan-out",
+		`${buildAppDirectory}/railpack-plan.json`,
+		"--info-out",
+		`${buildAppDirectory}/railpack-info.json`,
+	];
+
+	for (const env of envVariables) {
+		prepareArgs.push("--env", `'${env}'`);
+	}
+
+	// Calculate secrets hash for layer invalidation
+	const secretsHash = calculateSecretsHash(envVariables);
+
+	const cacheKey = cleanCache ? nanoid(10) : undefined;
+	// Build command
+	const buildArgs = [
+		"buildx",
+		"build",
+		...(cacheKey
+			? [
+					"--build-arg",
+					`secrets-hash=${secretsHash}`,
+					"--build-arg",
+					`cache-key=${cacheKey}`,
+				]
+			: []),
+		"--build-arg",
+		"BUILDKIT_SYNTAX=ghcr.io/railwayapp/railpack-frontend:v0.0.64",
+		"-f",
+		`${buildAppDirectory}/railpack-plan.json`,
+		"--output",
+		`type=docker,name=${appName}`,
+	];
+
+	// Add secrets properly formatted
+	const exportEnvs = [];
+	for (const pair of envVariables) {
+		const [key, value] = parseEnvironmentKeyValuePair(pair);
+		if (key && value) {
+			buildArgs.push("--secret", `id=${key},env=${key}`);
+			exportEnvs.push(`export ${key}='${value}'`);
+		}
+	}
+
+	buildArgs.push(buildAppDirectory);
+
+	const bashCommand = `
+# Ensure we have a builder with containerd
+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};
+	exit 1;
+}
+echo "✅ Railpack prepare completed." >> ${logPath};
+
+echo "Building with Railpack frontend..." >> "${logPath}";
+# Export environment variables for secrets
+${exportEnvs.join("\n")}
+docker ${buildArgs.join(" ")} >> ${logPath} 2>> ${logPath} || { 
+	echo "❌ Railpack build failed" >> ${logPath};
+	exit 1;
+}
+echo "✅ Railpack build completed." >> ${logPath};
+`;
+
+	return bashCommand;
+};

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

@@ -7,24 +7,67 @@ import type { ApplicationNested } from ".";
 import { createFile, getCreateFileCommand } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
 
+const nginxSpaConfig = `
+worker_processes 1;
+
+events {
+  worker_connections 1024;
+}
+
+http {
+  include mime.types;
+  default_type  application/octet-stream;
+
+  access_log /dev/stdout;
+  error_log /dev/stderr;
+
+  server {
+    listen 80;
+    location / {
+      root   /usr/share/nginx/html;
+      index  index.html index.htm;
+      try_files $uri $uri/ /index.html;
+    }
+  }
+}
+`;
+
 export const buildStatic = async (
 	application: ApplicationNested,
 	writeStream: WriteStream,
 ) => {
-	const { publishDirectory } = application;
+	const { publishDirectory, isStaticSpa } = application;
 	const buildAppDirectory = getBuildAppDirectory(application);
 
 	try {
+		if (isStaticSpa) {
+			createFile(buildAppDirectory, "nginx.conf", nginxSpaConfig);
+		}
+
+		createFile(
+			buildAppDirectory,
+			".dockerignore",
+			[".git", ".env", "Dockerfile", ".dockerignore"].join("\n"),
+		);
+
 		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,

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

@@ -1,5 +1,4 @@
 import type { WriteStream } from "node:fs";
-import { join } from "node:path";
 import type { ApplicationNested } from "../builders";
 import { spawnAsync } from "../process/spawnAsync";
 
@@ -13,27 +12,35 @@ export const uploadImage = async (
 		throw new Error("Registry not found");
 	}
 
-	const { registryUrl, imagePrefix, registryType } = registry;
+	const { registryUrl, imagePrefix, username } = registry;
 	const { appName } = application;
 	const imageName = `${appName}:latest`;
 
 	const finalURL = registryUrl;
 
-	const registryTag = join(imagePrefix || "", imageName);
+	// 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}/${imagePrefix}/${imageName}`
+		: `${registryUrl}/${username}/${imageName}`;
 
 	try {
 		writeStream.write(
-			`📦 [Enabled Registry] Uploading image to ${registry.registryType} | ${registryTag} | ${finalURL}\n`,
+			`📦 [Enabled Registry] Uploading image to ${registry.registryType} | ${imageName} | ${finalURL} | ${registryTag}\n`,
 		);
-		await spawnAsync(
+		const loginCommand = spawnAsync(
 			"docker",
-			["login", finalURL, "-u", registry.username, "-p", registry.password],
+			["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) {
@@ -62,28 +69,30 @@ export const uploadImageRemoteCommand = (
 		throw new Error("Registry not found");
 	}
 
-	const { registryUrl, imagePrefix } = registry;
+	const { registryUrl, imagePrefix, username } = registry;
 	const { appName } = application;
 	const imageName = `${appName}:latest`;
 
 	const finalURL = registryUrl;
 
-	const registryTag = join(imagePrefix || "", imageName);
+	// 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};
-		docker login ${finalURL} -u ${registry.username} -p ${registry.password} >> ${logPath} 2>> ${logPath} || { 
+		echo "${registry.password}" | docker login ${finalURL} -u ${registry.username} --password-stdin >> ${logPath} 2>> ${logPath} || { 
 			echo "❌ DockerHub Failed" >> ${logPath};
 			exit 1;
 		}
-		echo "✅ DockerHub Login Success" >> ${logPath};
+		echo "✅ Registry Login Success" >> ${logPath};
 		docker tag ${imageName} ${registryTag} >> ${logPath} 2>> ${logPath} || { 
 			echo "❌ Error tagging image" >> ${logPath};
 			exit 1;
 		}
-			echo "✅ Image Tagged" >> ${logPath};
-
+		echo "✅ Image Tagged" >> ${logPath};
 		docker push ${registryTag} 2>> ${logPath} || { 
 			echo "❌ Error pushing image" >> ${logPath};
 			exit 1;
@@ -92,7 +101,6 @@ export const uploadImageRemoteCommand = (
 		`;
 		return command;
 	} catch (error) {
-		console.log(error);
 		throw error;
 	}
 };

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

@@ -31,7 +31,7 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 		mounts,
 	} = mariadb;
 
-	const defaultMariadbEnv = `MARIADB_DATABASE=${databaseName}\nMARIADB_USER=${databaseUser}\nMARIADB_PASSWORD=${databasePassword}\nMARIADB_ROOT_PASSWORD=${databaseRootPassword}${
+	const defaultMariadbEnv = `MARIADB_DATABASE="${databaseName}"\nMARIADB_USER="${databaseUser}"\nMARIADB_PASSWORD="${databasePassword}"\nMARIADB_ROOT_PASSWORD="${databaseRootPassword}"${
 		env ? `\n${env}` : ""
 	}`;
 	const resources = calculateResources({
@@ -98,7 +98,7 @@ export const buildMariadb = async (mariadb: MariadbNested) => {
 			version: Number.parseInt(inspect.Version.Index),
 			...settings,
 		});
-	} catch (error) {
+	} catch {
 		await docker.createService(settings);
 	}
 };

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

@@ -28,17 +28,66 @@ export const buildMongo = async (mongo: MongoNested) => {
 		databasePassword,
 		command,
 		mounts,
+		replicaSets,
 	} = mongo;
 
-	const defaultMongoEnv = `MONGO_INITDB_ROOT_USERNAME=${databaseUser}\nMONGO_INITDB_ROOT_PASSWORD=${databasePassword}${
+	const startupScript = `
+#!/bin/bash
+${
+	replicaSets
+		? `
+mongod --port 27017 --replSet rs0 --bind_ip_all &
+MONGOD_PID=$!
+
+# Wait for MongoDB to be ready
+while ! mongosh --eval "db.adminCommand('ping')" > /dev/null 2>&1; do
+	sleep 2
+done
+
+# Check if replica set is already initialized
+REPLICA_STATUS=$(mongosh --quiet --eval "rs.status().ok || 0")
+
+if [ "$REPLICA_STATUS" != "1" ]; then
+	echo "Initializing replica set..."
+	mongosh --eval '
+	rs.initiate({
+		_id: "rs0",
+		members: [{ _id: 0, host: "localhost:27017", priority: 1 }]
+	});
+
+    // Wait for the replica set to initialize
+	while (!rs.isMaster().ismaster) {
+		sleep(1000);
+	}
+
+    // Create root user after replica set is initialized and we are primary
+	db.getSiblingDB("admin").createUser({
+		user: "${databaseUser}",
+		pwd: "${databasePassword}",
+		roles: ["root"]
+	});
+	'
+
+else
+	echo "Replica set already initialized."
+fi
+`
+		: ""
+}
+
+${command ?? "wait $MONGOD_PID"}`;
+
+	const defaultMongoEnv = `MONGO_INITDB_ROOT_USERNAME="${databaseUser}"\nMONGO_INITDB_ROOT_PASSWORD="${databasePassword}"${replicaSets ? "\nMONGO_INITDB_DATABASE=admin" : ""}${
 		env ? `\n${env}` : ""
 	}`;
+
 	const resources = calculateResources({
 		memoryLimit,
 		memoryReservation,
 		cpuLimit,
 		cpuReservation,
 	});
+
 	const envVariables = prepareEnvironmentVariables(
 		defaultMongoEnv,
 		mongo.project.env,
@@ -56,12 +105,17 @@ export const buildMongo = async (mongo: MongoNested) => {
 				Image: dockerImage,
 				Env: envVariables,
 				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-				...(command
+				...(replicaSets
 					? {
-							Command: ["/bin/sh"],
-							Args: ["-c", command],
+							Command: ["/bin/bash"],
+							Args: ["-c", startupScript],
 						}
-					: {}),
+					: {
+							...(command && {
+								Command: ["/bin/bash"],
+								Args: ["-c", command],
+							}),
+						}),
 			},
 			Networks: [{ Target: "dokploy-network" }],
 			Resources: {
@@ -90,6 +144,7 @@ export const buildMongo = async (mongo: MongoNested) => {
 				: [],
 		},
 	};
+
 	try {
 		const service = docker.getService(appName);
 		const inspect = await service.inspect();
@@ -97,7 +152,7 @@ export const buildMongo = async (mongo: MongoNested) => {
 			version: Number.parseInt(inspect.Version.Index),
 			...settings,
 		});
-	} catch (error) {
+	} catch {
 		await docker.createService(settings);
 	}
 };

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

@@ -34,10 +34,10 @@ export const buildMysql = async (mysql: MysqlNested) => {
 
 	const defaultMysqlEnv =
 		databaseUser !== "root"
-			? `MYSQL_USER=${databaseUser}\nMYSQL_DATABASE=${databaseName}\nMYSQL_PASSWORD=${databasePassword}\nMYSQL_ROOT_PASSWORD=${databaseRootPassword}${
+			? `MYSQL_USER="${databaseUser}"\nMYSQL_DATABASE="${databaseName}"\nMYSQL_PASSWORD="${databasePassword}"\nMYSQL_ROOT_PASSWORD="${databaseRootPassword}"${
 					env ? `\n${env}` : ""
 				}`
-			: `MYSQL_DATABASE=${databaseName}\nMYSQL_ROOT_PASSWORD=${databaseRootPassword}${
+			: `MYSQL_DATABASE="${databaseName}"\nMYSQL_ROOT_PASSWORD="${databaseRootPassword}"${
 					env ? `\n${env}` : ""
 				}`;
 	const resources = calculateResources({
@@ -104,7 +104,7 @@ export const buildMysql = async (mysql: MysqlNested) => {
 			version: Number.parseInt(inspect.Version.Index),
 			...settings,
 		});
-	} catch (error) {
+	} catch {
 		await docker.createService(settings);
 	}
 };

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

@@ -30,7 +30,7 @@ export const buildPostgres = async (postgres: PostgresNested) => {
 		mounts,
 	} = postgres;
 
-	const defaultPostgresEnv = `POSTGRES_DB=${databaseName}\nPOSTGRES_USER=${databaseUser}\nPOSTGRES_PASSWORD=${databasePassword}${
+	const defaultPostgresEnv = `POSTGRES_DB="${databaseName}"\nPOSTGRES_USER="${databaseUser}"\nPOSTGRES_PASSWORD="${databasePassword}"${
 		env ? `\n${env}` : ""
 	}`;
 	const resources = calculateResources({

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

@@ -0,0 +1,99 @@
+import { db } from "@dokploy/server/db";
+import {
+	mariadb,
+	mongo,
+	mysql,
+	postgres,
+	redis,
+} from "@dokploy/server/db/schema";
+import { deployMariadb } from "@dokploy/server/services/mariadb";
+import { deployMongo } from "@dokploy/server/services/mongo";
+import { deployMySql } from "@dokploy/server/services/mysql";
+import { deployPostgres } from "@dokploy/server/services/postgres";
+import { deployRedis } from "@dokploy/server/services/redis";
+import { eq } from "drizzle-orm";
+import { removeService } from "../docker/utils";
+import { execAsyncRemote } from "../process/execAsync";
+import { execAsync } from "../process/execAsync";
+
+type DatabaseType = "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
+
+export const rebuildDatabase = async (
+	databaseId: string,
+	type: DatabaseType,
+) => {
+	const database = await findDatabaseById(databaseId, type);
+
+	if (!database) {
+		throw new Error("Database not found");
+	}
+
+	await removeService(database.appName, database.serverId);
+	await new Promise((resolve) => setTimeout(resolve, 6000));
+
+	for (const mount of database.mounts) {
+		if (mount.type === "volume") {
+			const command = `docker volume rm ${mount?.volumeName} --force`;
+			if (database.serverId) {
+				await execAsyncRemote(database.serverId, command);
+			} else {
+				await execAsync(command);
+			}
+		}
+	}
+
+	if (type === "postgres") {
+		await deployPostgres(databaseId);
+	} else if (type === "mysql") {
+		await deployMySql(databaseId);
+	} else if (type === "mariadb") {
+		await deployMariadb(databaseId);
+	} else if (type === "mongo") {
+		await deployMongo(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),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+	if (type === "mariadb") {
+		return await db.query.mariadb.findFirst({
+			where: eq(mariadb.mariadbId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+	if (type === "mongo") {
+		return await db.query.mongo.findFirst({
+			where: eq(mongo.mongoId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+	if (type === "redis") {
+		return await db.query.redis.findFirst({
+			where: eq(redis.redisId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+};

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

@@ -28,7 +28,7 @@ export const buildRedis = async (redis: RedisNested) => {
 		mounts,
 	} = redis;
 
-	const defaultRedisEnv = `REDIS_PASSWORD=${databasePassword}${
+	const defaultRedisEnv = `REDIS_PASSWORD="${databasePassword}"${
 		env ? `\n${env}` : ""
 	}`;
 	const resources = calculateResources({
@@ -95,7 +95,7 @@ export const buildRedis = async (redis: RedisNested) => {
 			version: Number.parseInt(inspect.Version.Index),
 			...settings,
 		});
-	} catch (error) {
+	} catch {
 		await docker.createService(settings);
 	}
 };

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

@@ -0,0 +1,55 @@
+import { findComposeById } from "@dokploy/server/services/compose";
+import { dump, load } from "js-yaml";
+import { addAppNameToAllServiceNames } from "./collision/root-network";
+import { generateRandomHash } from "./compose";
+import { addSuffixToAllVolumes } from "./compose/volume";
+import type { ComposeSpecification } from "./types";
+
+export const addAppNameToPreventCollision = (
+	composeData: ComposeSpecification,
+	appName: string,
+	isolatedDeploymentsVolume: boolean,
+): ComposeSpecification => {
+	let updatedComposeData = { ...composeData };
+
+	updatedComposeData = addAppNameToAllServiceNames(updatedComposeData, appName);
+	if (isolatedDeploymentsVolume) {
+		updatedComposeData = addSuffixToAllVolumes(updatedComposeData, appName);
+	}
+	return updatedComposeData;
+};
+
+export const randomizeIsolatedDeploymentComposeFile = async (
+	composeId: string,
+	suffix?: string,
+) => {
+	const compose = await findComposeById(composeId);
+	const composeFile = compose.composeFile;
+	const composeData = load(composeFile) as ComposeSpecification;
+
+	const randomSuffix = suffix || compose.appName || generateRandomHash();
+
+	const newComposeFile = addAppNameToPreventCollision(
+		composeData,
+		randomSuffix,
+		compose.isolatedDeploymentsVolume,
+	);
+
+	return dump(newComposeFile);
+};
+
+export const randomizeDeployableSpecificationFile = (
+	composeSpec: ComposeSpecification,
+	isolatedDeploymentsVolume: boolean,
+	suffix?: string,
+) => {
+	if (!suffix) {
+		return composeSpec;
+	}
+	const newComposeFile = addAppNameToPreventCollision(
+		composeSpec,
+		suffix,
+		isolatedDeploymentsVolume,
+	);
+	return newComposeFile;
+};

packages/server/src/utils/docker/collision/root-network.ts

@@ -0,0 +1,62 @@
+import _ from "lodash";
+import type { ComposeSpecification, DefinitionsService } from "../types";
+
+export const addAppNameToRootNetwork = (
+	composeData: ComposeSpecification,
+	appName: string,
+): ComposeSpecification => {
+	const updatedComposeData = { ...composeData };
+
+	// Initialize networks if it doesn't exist
+	if (!updatedComposeData.networks) {
+		updatedComposeData.networks = {};
+	}
+
+	// Add the new network with the app name
+	updatedComposeData.networks[appName] = {
+		name: appName,
+		external: true,
+	};
+
+	return updatedComposeData;
+};
+
+export const addAppNameToServiceNetworks = (
+	services: { [key: string]: DefinitionsService },
+	appName: string,
+): { [key: string]: DefinitionsService } => {
+	return _.mapValues(services, (service) => {
+		if (!service.networks) {
+			service.networks = [appName];
+			return service;
+		}
+
+		if (Array.isArray(service.networks)) {
+			if (!service.networks.includes(appName)) {
+				service.networks.push(appName);
+			}
+		} else {
+			service.networks[appName] = {};
+		}
+
+		return service;
+	});
+};
+
+export const addAppNameToAllServiceNames = (
+	composeData: ComposeSpecification,
+	appName: string,
+): ComposeSpecification => {
+	let updatedComposeData = { ...composeData };
+
+	updatedComposeData = addAppNameToRootNetwork(updatedComposeData, appName);
+
+	if (updatedComposeData.services) {
+		updatedComposeData.services = addAppNameToServiceNetworks(
+			updatedComposeData.services,
+			appName,
+		);
+	}
+
+	return updatedComposeData;
+};

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

@@ -30,12 +30,22 @@ export const addSuffixToVolumesInServices = (
 
 					// skip bind mounts and variables (e.g. $PWD)
 					if (
-						volumeName?.startsWith(".") ||
-						volumeName?.startsWith("/") ||
-						volumeName?.startsWith("$")
+						!volumeName ||
+						volumeName.startsWith(".") ||
+						volumeName.startsWith("/") ||
+						volumeName.startsWith("$")
 					) {
 						return volume;
 					}
+
+					// Handle volume paths with subdirectories
+					const parts = volumeName.split("/");
+					if (parts.length > 1) {
+						const baseName = parts[0];
+						const rest = parts.slice(1).join("/");
+						return `${baseName}-${suffix}/${rest}:${path}`;
+					}
+
 					return `${volumeName}-${suffix}:${path}`;
 				}
 				if (_.isObject(volume) && volume.type === "volume" && volume.source) {

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

@@ -14,6 +14,10 @@ import {
 	cloneGitRawRepository,
 	cloneRawGitRepositoryRemote,
 } from "../providers/git";
+import {
+	cloneRawGiteaRepository,
+	cloneRawGiteaRepositoryRemote,
+} from "../providers/gitea";
 import {
 	cloneRawGithubRepository,
 	cloneRawGithubRepositoryRemote,
@@ -26,6 +30,7 @@ import {
 	createComposeFileRaw,
 	createComposeFileRawRemote,
 } from "../providers/raw";
+import { randomizeDeployableSpecificationFile } from "./collision";
 import { randomizeSpecificationFile } from "./compose";
 import type {
 	ComposeSpecification,
@@ -43,6 +48,8 @@ export const cloneCompose = async (compose: Compose) => {
 		await cloneRawBitbucketRepository(compose);
 	} else if (compose.sourceType === "git") {
 		await cloneGitRawRepository(compose);
+	} else if (compose.sourceType === "gitea") {
+		await cloneRawGiteaRepository(compose);
 	} else if (compose.sourceType === "raw") {
 		await createComposeFileRaw(compose);
 	}
@@ -57,6 +64,8 @@ export const cloneComposeRemote = async (compose: Compose) => {
 		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);
 	}
@@ -108,7 +117,7 @@ export const loadDockerComposeRemote = async (
 		if (!stdout) return null;
 		const parsedConfig = load(stdout) as ComposeSpecification;
 		return parsedConfig;
-	} catch (err) {
+	} catch {
 		return null;
 	}
 };
@@ -190,7 +199,14 @@ export const addDomainToCompose = async (
 		return null;
 	}
 
-	if (compose.randomize) {
+	if (compose.isolatedDeployment) {
+		const randomized = randomizeDeployableSpecificationFile(
+			result,
+			compose.isolatedDeploymentsVolume,
+			compose.suffix || compose.appName,
+		);
+		result = randomized;
+	} else if (compose.randomize) {
 		const randomized = randomizeSpecificationFile(result, compose.suffix);
 		result = randomized;
 	}
@@ -203,37 +219,56 @@ export const addDomainToCompose = async (
 		if (!result?.services?.[serviceName]) {
 			throw new Error(`The service ${serviceName} not found in the compose`);
 		}
-		if (!result.services[serviceName].labels) {
-			result.services[serviceName].labels = [];
-		}
 
-		const httpLabels = await createDomainLabels(appName, domain, "web");
+		const httpLabels = createDomainLabels(appName, domain, "web");
 		if (https) {
-			const httpsLabels = await createDomainLabels(
-				appName,
-				domain,
-				"websecure",
-			);
+			const httpsLabels = createDomainLabels(appName, domain, "websecure");
 			httpLabels.push(...httpsLabels);
 		}
 
-		const labels = result.services[serviceName].labels;
+		let labels: DefinitionsService["labels"] = [];
+		if (compose.composeType === "docker-compose") {
+			if (!result.services[serviceName].labels) {
+				result.services[serviceName].labels = [];
+			}
+
+			labels = result.services[serviceName].labels;
+		} else {
+			// Stack Case
+			if (!result.services[serviceName].deploy) {
+				result.services[serviceName].deploy = {};
+			}
+			if (!result.services[serviceName].deploy.labels) {
+				result.services[serviceName].deploy.labels = [];
+			}
+
+			labels = result.services[serviceName].deploy.labels;
+		}
 
 		if (Array.isArray(labels)) {
 			if (!labels.includes("traefik.enable=true")) {
-				labels.push("traefik.enable=true");
+				labels.unshift("traefik.enable=true");
+			}
+			labels.unshift(...httpLabels);
+			if (!compose.isolatedDeployment) {
+				if (!labels.includes("traefik.docker.network=dokploy-network")) {
+					labels.unshift("traefik.docker.network=dokploy-network");
+				}
 			}
-			labels.push(...httpLabels);
 		}
 
-		// Add the dokploy-network to the service
-		result.services[serviceName].networks = addDokployNetworkToService(
-			result.services[serviceName].networks,
-		);
+		if (!compose.isolatedDeployment) {
+			// Add the dokploy-network to the service
+			result.services[serviceName].networks = addDokployNetworkToService(
+				result.services[serviceName].networks,
+			);
+		}
 	}
 
 	// Add dokploy-network to the root of the compose file
-	result.networks = addDokployNetworkToRoot(result.networks);
+	if (!compose.isolatedDeployment) {
+		result.networks = addDokployNetworkToRoot(result.networks);
+	}
 
 	return result;
 };
@@ -254,12 +289,22 @@ export const writeComposeFile = async (
 	}
 };
 
-export const createDomainLabels = async (
+export const createDomainLabels = (
 	appName: string,
 	domain: Domain,
 	entrypoint: "web" | "websecure",
 ) => {
-	const { host, port, https, uniqueConfigKey, certificateType, path } = domain;
+	const {
+		host,
+		port,
+		https,
+		uniqueConfigKey,
+		certificateType,
+		path,
+		customCertResolver,
+		stripPath,
+		internalPath,
+	} = domain;
 	const routerName = `${appName}-${uniqueConfigKey}-${entrypoint}`;
 	const labels = [
 		`traefik.http.routers.${routerName}.rule=Host(\`${host}\`)${path && path !== "/" ? ` && PathPrefix(\`${path}\`)` : ""}`,
@@ -268,6 +313,34 @@ export const createDomainLabels = async (
 		`traefik.http.routers.${routerName}.service=${routerName}`,
 	];
 
+	// Validate stripPath - it should only be used when path is defined and not "/"
+	if (stripPath) {
+		if (!path || path === "/") {
+			console.warn(
+				`stripPath is enabled but path is not defined or is "/" for domain ${host}`,
+			);
+		} else {
+			const middlewareName = `stripprefix-${appName}-${uniqueConfigKey}`;
+			labels.push(
+				`traefik.http.middlewares.${middlewareName}.stripprefix.prefixes=${path}`,
+			);
+		}
+	}
+
+	// Validate internalPath - ensure it's a valid path format
+	if (internalPath && internalPath !== "/") {
+		if (!internalPath.startsWith("/")) {
+			console.warn(
+				`internalPath "${internalPath}" should start with "/" and not be empty for domain ${host}`,
+			);
+		} else {
+			const middlewareName = `addprefix-${appName}-${uniqueConfigKey}`;
+			labels.push(
+				`traefik.http.middlewares.${middlewareName}.addprefix.prefix=${internalPath}`,
+			);
+		}
+	}
+
 	if (entrypoint === "web" && https) {
 		labels.push(
 			`traefik.http.routers.${routerName}.middlewares=redirect-to-https@file`,
@@ -279,6 +352,10 @@ export const createDomainLabels = async (
 			labels.push(
 				`traefik.http.routers.${routerName}.tls.certresolver=letsencrypt`,
 			);
+		} else if (certificateType === "custom" && customCertResolver) {
+			labels.push(
+				`traefik.http.routers.${routerName}.tls.certresolver=${customCertResolver}`,
+			);
 		}
 	}
 

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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import type { Readable } from "node:stream";
 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 type { ApplicationNested } from "../builders";
@@ -100,7 +101,7 @@ export const containerExists = async (containerName: string) => {
 	try {
 		await container.inspect();
 		return true;
-	} catch (error) {
+	} catch {
 		return false;
 	}
 };
@@ -144,10 +145,11 @@ export const getContainerByName = (name: string): Promise<ContainerInfo> => {
 };
 export const cleanUpUnusedImages = async (serverId?: string) => {
 	try {
+		const command = "docker image prune --force";
 		if (serverId) {
-			await execAsyncRemote(serverId, "docker image prune --all --force");
+			await execAsyncRemote(serverId, command);
 		} else {
-			await execAsync("docker image prune --all --force");
+			await execAsync(command);
 		}
 	} catch (error) {
 		console.error(error);
@@ -157,10 +159,11 @@ export const cleanUpUnusedImages = async (serverId?: string) => {
 
 export const cleanStoppedContainers = async (serverId?: string) => {
 	try {
+		const command = "docker container prune --force";
 		if (serverId) {
-			await execAsyncRemote(serverId, "docker container prune --force");
+			await execAsyncRemote(serverId, command);
 		} else {
-			await execAsync("docker container prune --force");
+			await execAsync(command);
 		}
 	} catch (error) {
 		console.error(error);
@@ -170,10 +173,11 @@ export const cleanStoppedContainers = async (serverId?: string) => {
 
 export const cleanUpUnusedVolumes = async (serverId?: string) => {
 	try {
+		const command = "docker volume prune --force";
 		if (serverId) {
-			await execAsyncRemote(serverId, "docker volume prune --all --force");
+			await execAsyncRemote(serverId, command);
 		} else {
-			await execAsync("docker volume prune --all --force");
+			await execAsync(command);
 		}
 	} catch (error) {
 		console.error(error);
@@ -199,21 +203,20 @@ export const cleanUpInactiveContainers = async () => {
 };
 
 export const cleanUpDockerBuilder = async (serverId?: string) => {
+	const command = "docker builder prune --all --force";
 	if (serverId) {
-		await execAsyncRemote(serverId, "docker builder prune --all --force");
+		await execAsyncRemote(serverId, command);
 	} else {
-		await execAsync("docker builder prune --all --force");
+		await execAsync(command);
 	}
 };
 
 export const cleanUpSystemPrune = async (serverId?: string) => {
+	const command = "docker system prune --force --volumes";
 	if (serverId) {
-		await execAsyncRemote(
-			serverId,
-			"docker system prune --all --force --volumes",
-		);
+		await execAsyncRemote(serverId, command);
 	} else {
-		await execAsync("docker system prune --all --force --volumes");
+		await execAsync(command);
 	}
 };
 
@@ -238,9 +241,11 @@ export const startServiceRemote = async (serverId: string, appName: string) => {
 export const removeService = async (
 	appName: string,
 	serverId?: string | null,
+	_deleteVolumes = false,
 ) => {
 	try {
 		const command = `docker service rm ${appName}`;
+
 		if (serverId) {
 			await execAsyncRemote(serverId, command);
 		} else {
@@ -274,13 +279,27 @@ export const prepareEnvironmentVariables = (
 	return resolvedVars;
 };
 
-export const prepareBuildArgs = (input: string | null) => {
-	const pairs = (input ?? "").split("\n");
+export const parseEnvironmentKeyValuePair = (
+	pair: string,
+): [string, string] => {
+	const [key, ...valueParts] = pair.split("=");
+	if (!key || !valueParts.length) {
+		throw new Error(`Invalid environment variable pair: ${pair}`);
+	}
+
+	return [key, valueParts.join("=")];
+};
+
+export const getEnviromentVariablesObject = (
+	input: string | null,
+	projectEnv?: string | null,
+) => {
+	const envs = prepareEnvironmentVariables(input, projectEnv);
 
 	const jsonObject: Record<string, string> = {};
 
-	for (const pair of pairs) {
-		const [key, value] = pair.split("=");
+	for (const pair of envs) {
+		const [key, value] = parseEnvironmentKeyValuePair(pair);
 		if (key && value) {
 			jsonObject[key] = value;
 		}
@@ -304,10 +323,10 @@ export const generateVolumeMounts = (mounts: ApplicationNested["mounts"]) => {
 };
 
 type Resources = {
-	memoryLimit: number | null;
-	memoryReservation: number | null;
-	cpuLimit: number | null;
-	cpuReservation: number | null;
+	memoryLimit: string | null;
+	memoryReservation: string | null;
+	cpuLimit: string | null;
+	cpuReservation: string | null;
 };
 export const calculateResources = ({
 	memoryLimit,
@@ -317,16 +336,14 @@ export const calculateResources = ({
 }: Resources): ResourceRequirements => {
 	return {
 		Limits: {
-			MemoryBytes: memoryLimit ? memoryLimit * 1024 * 1024 : undefined,
-			NanoCPUs: memoryLimit ? (cpuLimit || 1) * 1000 * 1000 * 1000 : undefined,
+			MemoryBytes: memoryLimit ? Number.parseInt(memoryLimit) : undefined,
+			NanoCPUs: cpuLimit ? Number.parseInt(cpuLimit) : undefined,
 		},
 		Reservations: {
-			MemoryBytes: memoryLimit
-				? (memoryReservation || 1) * 1024 * 1024
-				: undefined,
-			NanoCPUs: memoryLimit
-				? (cpuReservation || 1) * 1000 * 1000 * 1000
+			MemoryBytes: memoryReservation
+				? Number.parseInt(memoryReservation)
 				: undefined,
+			NanoCPUs: cpuReservation ? Number.parseInt(cpuReservation) : undefined,
 		},
 	};
 };
@@ -488,32 +505,9 @@ export const getCreateFileCommand = (
 	`;
 };
 
-export const getServiceContainer = async (appName: string) => {
-	try {
-		const filter = {
-			status: ["running"],
-			label: [`com.docker.swarm.service.name=${appName}`],
-		};
-
-		const containers = await docker.listContainers({
-			filters: JSON.stringify(filter),
-		});
-
-		if (containers.length === 0 || !containers[0]) {
-			throw new Error(`No container found with name: ${appName}`);
-		}
-
-		const container = containers[0];
-
-		return container;
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const getRemoteServiceContainer = async (
-	serverId: string,
+export const getServiceContainer = async (
 	appName: string,
+	serverId?: string | null,
 ) => {
 	try {
 		const filter = {
@@ -526,7 +520,7 @@ export const getRemoteServiceContainer = async (
 		});
 
 		if (containers.length === 0 || !containers[0]) {
-			throw new Error(`No container found with name: ${appName}`);
+			return null;
 		}
 
 		const container = containers[0];
@@ -536,3 +530,42 @@ export const getRemoteServiceContainer = async (
 		throw error;
 	}
 };
+
+export const getComposeContainer = async (
+	compose: Compose,
+	serviceName: string,
+) => {
+	try {
+		const { appName, composeType, serverId } = compose;
+		// 1. Determine the correct labels based on composeType
+		const labels: string[] = [];
+		if (composeType === "stack") {
+			// Labels for Docker Swarm stack services
+			labels.push(`com.docker.stack.namespace=${appName}`);
+			labels.push(`com.docker.swarm.service.name=${appName}_${serviceName}`);
+		} else {
+			// Labels for Docker Compose projects (default)
+			labels.push(`com.docker.compose.project=${appName}`);
+			labels.push(`com.docker.compose.service=${serviceName}`);
+		}
+		const filter = {
+			status: ["running"],
+			label: labels,
+		};
+
+		const remoteDocker = await getRemoteDocker(serverId);
+		const containers = await remoteDocker.listContainers({
+			filters: JSON.stringify(filter),
+			limit: 1,
+		});
+
+		if (containers.length === 0 || !containers[0]) {
+			return null;
+		}
+
+		const container = containers[0];
+		return container;
+	} catch (error) {
+		throw error;
+	}
+};

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

@@ -39,7 +39,7 @@ export const removeFileOrDirectory = async (path: string) => {
 	try {
 		await execAsync(`rm -rf ${path}`);
 	} catch (error) {
-		console.error(`Error to remove ${path}: ${error}`);
+		console.error(`Error removing ${path}: ${error}`);
 		throw error;
 	}
 };
@@ -58,7 +58,7 @@ export const removeDirectoryCode = async (
 			await execAsync(command);
 		}
 	} catch (error) {
-		console.error(`Error to remove ${directoryPath}: ${error}`);
+		console.error(`Error removing ${directoryPath}: ${error}`);
 		throw error;
 	}
 };
@@ -77,7 +77,7 @@ export const removeComposeDirectory = async (
 			await execAsync(command);
 		}
 	} catch (error) {
-		console.error(`Error to remove ${directoryPath}: ${error}`);
+		console.error(`Error removing ${directoryPath}: ${error}`);
 		throw error;
 	}
 };
@@ -96,7 +96,7 @@ export const removeMonitoringDirectory = async (
 			await execAsync(command);
 		}
 	} catch (error) {
-		console.error(`Error to remove ${directoryPath}: ${error}`);
+		console.error(`Error removing ${directoryPath}: ${error}`);
 		throw error;
 	}
 };
@@ -113,6 +113,8 @@ export const getBuildAppDirectory = (application: Application) => {
 		buildPath = application?.gitlabBuildPath || "";
 	} else if (sourceType === "bitbucket") {
 		buildPath = application?.bitbucketBuildPath || "";
+	} else if (sourceType === "gitea") {
+		buildPath = application?.giteaBuildPath || "";
 	} else if (sourceType === "drop") {
 		buildPath = application?.dropBuildPath || "";
 	} else if (sourceType === "git") {

packages/server/src/utils/gpu-setup.ts

@@ -34,8 +34,7 @@ export async function checkGPUStatus(serverId?: string): Promise<GPUInfo> {
 			...gpuInfo,
 			...cudaInfo,
 		};
-	} catch (error) {
-		console.error("Error in checkGPUStatus:", error);
+	} catch {
 		return {
 			driverInstalled: false,
 			driverVersion: undefined,
@@ -316,8 +315,7 @@ const setupLocalServer = async (daemonConfig: any) => {
 
 	try {
 		await execAsync(setupCommands);
-	} catch (error) {
-		console.error("Setup failed:", error);
+	} catch {
 		throw new Error(
 			"Failed to configure GPU support. Please ensure you have sudo privileges and try again.",
 		);
@@ -344,11 +342,10 @@ const verifySetup = async (nodeId: string, serverId?: string) => {
 			"cat /etc/nvidia-container-runtime/config.toml",
 		].join(" && ");
 
-		const { stdout: diagnostics } = serverId
-			? await execAsyncRemote(serverId, diagnosticCommands)
-			: await execAsync(diagnosticCommands);
+		await (serverId
+			? execAsyncRemote(serverId, diagnosticCommands)
+			: execAsync(diagnosticCommands));
 
-		console.error("Diagnostic Information:", diagnostics);
 		throw new Error("GPU support not detected in swarm after setup");
 	}
 

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

@@ -2,10 +2,12 @@ import { db } from "@dokploy/server/db";
 import { notifications } from "@dokploy/server/db/schema";
 import BuildFailedEmail from "@dokploy/server/emails/emails/build-failed";
 import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
 	sendDiscordNotification,
 	sendEmailNotification,
+	sendGotifyNotification,
 	sendSlackNotification,
 	sendTelegramNotification,
 } from "./utils";
@@ -16,7 +18,7 @@ interface Props {
 	applicationType: string;
 	errorMessage: string;
 	buildLink: string;
-	adminId: string;
+	organizationId: string;
 }
 
 export const sendBuildErrorNotifications = async ({
@@ -25,24 +27,26 @@ export const sendBuildErrorNotifications = async ({
 	applicationType,
 	errorMessage,
 	buildLink,
-	adminId,
+	organizationId,
 }: Props) => {
 	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
 	const notificationList = await db.query.notifications.findMany({
 		where: and(
 			eq(notifications.appBuildError, true),
-			eq(notifications.adminId, adminId),
+			eq(notifications.organizationId, organizationId),
 		),
 		with: {
 			email: true,
 			discord: true,
 			telegram: true,
 			slack: true,
+			gotify: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack } = notification;
+		const { email, discord, telegram, slack, gotify } = notification;
 		if (email) {
 			const template = await renderAsync(
 				BuildFailedEmail({
@@ -58,46 +62,51 @@ export const sendBuildErrorNotifications = async ({
 		}
 
 		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: "> `⚠️` - Build Failed",
+				title: decorate(">", "`⚠️` Build Failed"),
 				color: 0xed4245,
 				fields: [
 					{
-						name: "`🛠️`・Project",
+						name: decorate("`🛠️`", "Project"),
 						value: projectName,
 						inline: true,
 					},
 					{
-						name: "`⚙️`・Application",
+						name: decorate("`⚙️`", "Application"),
 						value: applicationName,
 						inline: true,
 					},
 					{
-						name: "`❔`・Type",
+						name: decorate("`❔`", "Type"),
 						value: applicationType,
 						inline: true,
 					},
 					{
-						name: "`📅`・Date",
-						value: date.toLocaleDateString(),
+						name: decorate("`📅`", "Date"),
+						value: `<t:${unixDate}:D>`,
 						inline: true,
 					},
 					{
-						name: "`⌚`・Time",
-						value: date.toLocaleTimeString(),
+						name: decorate("`⌚`", "Time"),
+						value: `<t:${unixDate}:t>`,
 						inline: true,
 					},
 					{
-						name: "`❓`・Type",
+						name: decorate("`❓`", "Type"),
 						value: "Failed",
 						inline: true,
 					},
 					{
-						name: "`⚠️`・Error Message",
-						value: `\`\`\`${errorMessage}\`\`\``,
+						name: decorate("`⚠️`", "Error Message"),
+						value: `\`\`\`${truncatedErrorMessage}\`\`\``,
 					},
 					{
-						name: "`🧷`・Build Link",
+						name: decorate("`🧷`", "Build Link"),
 						value: `[Click here to access build link](${buildLink})`,
 					},
 				],
@@ -108,22 +117,35 @@ export const sendBuildErrorNotifications = async ({
 			});
 		}
 
+		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 (telegram) {
+			const inlineButton = [
+				[
+					{
+						text: "Deployment Logs",
+						url: buildLink,
+					},
+				],
+			];
+
 			await sendTelegramNotification(
 				telegram,
-				`
-				<b>⚠️ Build Failed</b>
-				
-				<b>Project:</b> ${projectName}
-				<b>Application:</b> ${applicationName}
-				<b>Type:</b> ${applicationType}
-				<b>Time:</b> ${date.toLocaleString()}
-				
-				<b>Error:</b>
-				<pre>${errorMessage}</pre>
-				
-				<b>Build Details:</b> ${buildLink}
-				`,
+				`<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,
 			);
 		}
 

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

@@ -1,11 +1,14 @@
 import { db } from "@dokploy/server/db";
 import { notifications } from "@dokploy/server/db/schema";
 import BuildSuccessEmail from "@dokploy/server/emails/emails/build-success";
+import type { Domain } from "@dokploy/server/services/domain";
 import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
 	sendDiscordNotification,
 	sendEmailNotification,
+	sendGotifyNotification,
 	sendSlackNotification,
 	sendTelegramNotification,
 } from "./utils";
@@ -15,7 +18,8 @@ interface Props {
 	applicationName: string;
 	applicationType: string;
 	buildLink: string;
-	adminId: string;
+	organizationId: string;
+	domains: Domain[];
 }
 
 export const sendBuildSuccessNotifications = async ({
@@ -23,24 +27,27 @@ export const sendBuildSuccessNotifications = async ({
 	applicationName,
 	applicationType,
 	buildLink,
-	adminId,
+	organizationId,
+	domains,
 }: Props) => {
 	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
 	const notificationList = await db.query.notifications.findMany({
 		where: and(
 			eq(notifications.appDeploy, true),
-			eq(notifications.adminId, adminId),
+			eq(notifications.organizationId, organizationId),
 		),
 		with: {
 			email: true,
 			discord: true,
 			telegram: true,
 			slack: true,
+			gotify: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack } = notification;
+		const { email, discord, telegram, slack, gotify } = notification;
 
 		if (email) {
 			const template = await renderAsync(
@@ -56,42 +63,45 @@ export const sendBuildSuccessNotifications = async ({
 		}
 
 		if (discord) {
+			const decorate = (decoration: string, text: string) =>
+				`${discord.decoration ? decoration : ""} ${text}`.trim();
+
 			await sendDiscordNotification(discord, {
-				title: "> `✅` - Build Success",
+				title: decorate(">", "`✅` Build Success"),
 				color: 0x57f287,
 				fields: [
 					{
-						name: "`🛠️`・Project",
+						name: decorate("`🛠️`", "Project"),
 						value: projectName,
 						inline: true,
 					},
 					{
-						name: "`⚙️`・Application",
+						name: decorate("`⚙️`", "Application"),
 						value: applicationName,
 						inline: true,
 					},
 					{
-						name: "`❔`・Application Type",
+						name: decorate("`❔`", "Type"),
 						value: applicationType,
 						inline: true,
 					},
 					{
-						name: "`📅`・Date",
-						value: date.toLocaleDateString(),
+						name: decorate("`📅`", "Date"),
+						value: `<t:${unixDate}:D>`,
 						inline: true,
 					},
 					{
-						name: "`⌚`・Time",
-						value: date.toLocaleTimeString(),
+						name: decorate("`⌚`", "Time"),
+						value: `<t:${unixDate}:t>`,
 						inline: true,
 					},
 					{
-						name: "`❓`・Type",
+						name: decorate("`❓`", "Type"),
 						value: "Successful",
 						inline: true,
 					},
 					{
-						name: "`🧷`・Build Link",
+						name: decorate("`🧷`", "Build Link"),
 						value: `[Click here to access build link](${buildLink})`,
 					},
 				],
@@ -102,19 +112,45 @@ export const sendBuildSuccessNotifications = async ({
 			});
 		}
 
+		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 (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>
-				
-				<b>Project:</b> ${projectName}
-				<b>Application:</b> ${applicationName}
-				<b>Type:</b> ${applicationType}
-				<b>Time:</b> ${date.toLocaleString()}
-				
-				<b>Build Details:</b> ${buildLink}
-				`,
+				`<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,
 			);
 		}
 

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

@@ -2,10 +2,12 @@ import { db } from "@dokploy/server/db";
 import { notifications } from "@dokploy/server/db/schema";
 import DatabaseBackupEmail from "@dokploy/server/emails/emails/database-backup";
 import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
 	sendDiscordNotification,
 	sendEmailNotification,
+	sendGotifyNotification,
 	sendSlackNotification,
 	sendTelegramNotification,
 } from "./utils";
@@ -16,31 +18,35 @@ export const sendDatabaseBackupNotifications = async ({
 	databaseType,
 	type,
 	errorMessage,
-	adminId,
+	organizationId,
+	databaseName,
 }: {
 	projectName: string;
 	applicationName: string;
 	databaseType: "postgres" | "mysql" | "mongodb" | "mariadb";
 	type: "error" | "success";
-	adminId: string;
+	organizationId: string;
 	errorMessage?: string;
+	databaseName: string;
 }) => {
 	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
 	const notificationList = await db.query.notifications.findMany({
 		where: and(
 			eq(notifications.databaseBackup, true),
-			eq(notifications.adminId, adminId),
+			eq(notifications.organizationId, organizationId),
 		),
 		with: {
 			email: true,
 			discord: true,
 			telegram: true,
 			slack: true,
+			gotify: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack } = notification;
+		const { email, discord, telegram, slack, gotify } = notification;
 
 		if (email) {
 			const template = await renderAsync(
@@ -61,40 +67,48 @@ export const sendDatabaseBackupNotifications = async ({
 		}
 
 		if (discord) {
+			const decorate = (decoration: string, text: string) =>
+				`${discord.decoration ? decoration : ""} ${text}`.trim();
+
 			await sendDiscordNotification(discord, {
 				title:
 					type === "success"
-						? "> `✅` - Database Backup Successful"
-						: "> `❌` - Database Backup Failed",
+						? decorate(">", "`✅` Database Backup Successful")
+						: decorate(">", "`❌` Database Backup Failed"),
 				color: type === "success" ? 0x57f287 : 0xed4245,
 				fields: [
 					{
-						name: "`🛠️`・Project",
+						name: decorate("`🛠️`", "Project"),
 						value: projectName,
 						inline: true,
 					},
 					{
-						name: "`⚙️`・Application",
+						name: decorate("`⚙️`", "Application"),
 						value: applicationName,
 						inline: true,
 					},
 					{
-						name: "`❔`・Database",
+						name: decorate("`❔`", "Database"),
 						value: databaseType,
 						inline: true,
 					},
 					{
-						name: "`📅`・Date",
-						value: date.toLocaleDateString(),
+						name: decorate("`📂`", "Database Name"),
+						value: databaseName,
 						inline: true,
 					},
 					{
-						name: "`⌚`・Time",
-						value: date.toLocaleTimeString(),
+						name: decorate("`📅`", "Date"),
+						value: `<t:${unixDate}:D>`,
 						inline: true,
 					},
 					{
-						name: "`❓`・Type",
+						name: decorate("`⌚`", "Time"),
+						value: `<t:${unixDate}:t>`,
+						inline: true,
+					},
+					{
+						name: decorate("`❓`", "Type"),
 						value: type
 							.replace("error", "Failed")
 							.replace("success", "Successful"),
@@ -103,7 +117,7 @@ export const sendDatabaseBackupNotifications = async ({
 					...(type === "error" && errorMessage
 						? [
 								{
-									name: "`⚠️`・Error Message",
+									name: decorate("`⚠️`", "Error Message"),
 									value: `\`\`\`${errorMessage}\`\`\``,
 								},
 							]
@@ -116,19 +130,36 @@ export const sendDatabaseBackupNotifications = async ({
 			});
 		}
 
+		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 (telegram) {
+			const isError = type === "error" && errorMessage;
+
 			const statusEmoji = type === "success" ? "✅" : "❌";
-			const messageText = `
-				<b>${statusEmoji} Database Backup ${type === "success" ? "Successful" : "Failed"}</b>
-			
-			<b>Project:</b> ${projectName}
-			<b>Application:</b> ${applicationName}
-			<b>Type:</b> ${databaseType}
-			<b>Time:</b> ${date.toLocaleString()}
-			
-			<b>Status:</b> ${type === "success" ? "Successful" : "Failed"}
-			${type === "error" && errorMessage ? `<b>Error:</b> ${errorMessage}` : ""}
-			`;
+			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);
 		}
 
@@ -168,6 +199,10 @@ export const sendDatabaseBackupNotifications = async ({
 								value: databaseType,
 								short: true,
 							},
+							{
+								title: "Database Name",
+								value: databaseName,
+							},
 							{
 								title: "Time",
 								value: date.toLocaleString(),

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

@@ -2,34 +2,38 @@ import { db } from "@dokploy/server/db";
 import { notifications } from "@dokploy/server/db/schema";
 import DockerCleanupEmail from "@dokploy/server/emails/emails/docker-cleanup";
 import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
 	sendDiscordNotification,
 	sendEmailNotification,
+	sendGotifyNotification,
 	sendSlackNotification,
 	sendTelegramNotification,
 } from "./utils";
 
 export const sendDockerCleanupNotifications = async (
-	adminId: string,
+	organizationId: string,
 	message = "Docker cleanup for dokploy",
 ) => {
 	const date = new Date();
+	const unixDate = ~~(Number(date) / 1000);
 	const notificationList = await db.query.notifications.findMany({
 		where: and(
 			eq(notifications.dockerCleanup, true),
-			eq(notifications.adminId, adminId),
+			eq(notifications.organizationId, organizationId),
 		),
 		with: {
 			email: true,
 			discord: true,
 			telegram: true,
 			slack: true,
+			gotify: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack } = notification;
+		const { email, discord, telegram, slack, gotify } = notification;
 
 		if (email) {
 			const template = await renderAsync(
@@ -44,27 +48,30 @@ export const sendDockerCleanupNotifications = async (
 		}
 
 		if (discord) {
+			const decorate = (decoration: string, text: string) =>
+				`${discord.decoration ? decoration : ""} ${text}`.trim();
+
 			await sendDiscordNotification(discord, {
-				title: "> `✅` - Docker Cleanup",
+				title: decorate(">", "`✅` Docker Cleanup"),
 				color: 0x57f287,
 				fields: [
 					{
-						name: "`📅`・Date",
-						value: date.toLocaleDateString(),
+						name: decorate("`📅`", "Date"),
+						value: `<t:${unixDate}:D>`,
 						inline: true,
 					},
 					{
-						name: "`⌚`・Time",
-						value: date.toLocaleTimeString(),
+						name: decorate("`⌚`", "Time"),
+						value: `<t:${unixDate}:t>`,
 						inline: true,
 					},
 					{
-						name: "`❓`・Type",
+						name: decorate("`❓`", "Type"),
 						value: "Successful",
 						inline: true,
 					},
 					{
-						name: "`📜`・Message",
+						name: decorate("`📜`", "Message"),
 						value: `\`\`\`${message}\`\`\``,
 					},
 				],
@@ -75,14 +82,21 @@ export const sendDockerCleanupNotifications = async (
 			});
 		}
 
+		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 (telegram) {
 			await sendTelegramNotification(
 				telegram,
-				`
-				<b>✅ Docker Cleanup</b>
-				<b>Message:</b> ${message}
-				<b>Time:</b> ${date.toLocaleString()}
-			`,
+				`<b>✅ Docker Cleanup</b>\n\n<b>Message:</b> ${message}\n<b>Date:</b> ${format(date, "PP")}\n<b>Time:</b> ${format(date, "pp")}`,
 			);
 		}
 

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

@@ -2,16 +2,19 @@ import { db } from "@dokploy/server/db";
 import { notifications } from "@dokploy/server/db/schema";
 import DokployRestartEmail from "@dokploy/server/emails/emails/dokploy-restart";
 import { renderAsync } from "@react-email/components";
+import { format } from "date-fns";
 import { eq } from "drizzle-orm";
 import {
 	sendDiscordNotification,
 	sendEmailNotification,
+	sendGotifyNotification,
 	sendSlackNotification,
 	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: {
@@ -19,11 +22,12 @@ export const sendDokployRestartNotifications = async () => {
 			discord: true,
 			telegram: true,
 			slack: true,
+			gotify: true,
 		},
 	});
 
 	for (const notification of notificationList) {
-		const { email, discord, telegram, slack } = notification;
+		const { email, discord, telegram, slack, gotify } = notification;
 
 		if (email) {
 			const template = await renderAsync(
@@ -33,61 +37,87 @@ export const sendDokployRestartNotifications = async () => {
 		}
 
 		if (discord) {
-			await sendDiscordNotification(discord, {
-				title: "> `✅` - Dokploy Server Restarted",
-				color: 0x57f287,
-				fields: [
-					{
-						name: "`📅`・Date",
-						value: date.toLocaleDateString(),
-						inline: true,
+			const decorate = (decoration: string, text: string) =>
+				`${discord.decoration ? decoration : ""} ${text}`.trim();
+
+			try {
+				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: "`⌚`・Time",
-						value: date.toLocaleTimeString(),
-						inline: true,
-					},
-					{
-						name: "`❓`・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 (telegram) {
-			await sendTelegramNotification(
-				telegram,
-				`
-				<b>✅ Dokploy Serverd Restarted</b>
-				<b>Time:</b> ${date.toLocaleString()}
-			`,
-			);
+			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 (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,
-							},
-						],
-					},
-				],
-			});
+			try {
+				await sendSlackNotification(slack, {
+					channel: channel,
+					attachments: [
+						{
+							color: "#00FF00",
+							pretext: ":white_check_mark: *Dokploy Server Restarted*",
+							fields: [
+								{
+									title: "Time",
+									value: date.toLocaleString(),
+									short: true,
+								},
+							],
+						},
+					],
+				});
+			} catch (error) {
+				console.log(error);
+			}
 		}
 	}
 };

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

@@ -0,0 +1,155 @@
+import { and, eq } from "drizzle-orm";
+import { db } from "../../db";
+import { notifications } from "../../db/schema";
+import {
+	sendDiscordNotification,
+	sendSlackNotification,
+	sendTelegramNotification,
+} from "./utils";
+
+interface ServerThresholdPayload {
+	Type: "CPU" | "Memory";
+	Value: number;
+	Threshold: number;
+	Message: string;
+	Timestamp: string;
+	Token: string;
+	ServerName: string;
+}
+
+export const sendServerThresholdNotifications = async (
+	organizationId: string,
+	payload: ServerThresholdPayload,
+) => {
+	const date = new Date(payload.Timestamp);
+	const unixDate = ~~(Number(date) / 1000);
+
+	const notificationList = await db.query.notifications.findMany({
+		where: and(
+			eq(notifications.serverThreshold, true),
+			eq(notifications.organizationId, organizationId),
+		),
+		with: {
+			email: true,
+			discord: true,
+			telegram: true,
+			slack: true,
+		},
+	});
+
+	const typeEmoji = payload.Type === "CPU" ? "🔲" : "💾";
+	const typeColor = 0xff0000; // Rojo para indicar alerta
+
+	for (const notification of notificationList) {
+		const { discord, telegram, slack } = notification;
+
+		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,
+					},
+					{
+						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,
+				`
+				<b>⚠️ Server ${payload.Type} Alert</b>
+                <b>Server Name:</b> ${payload.ServerName}
+				<b>Type:</b> ${payload.Type}
+				<b>Current Value:</b> ${payload.Value.toFixed(2)}%
+				<b>Threshold:</b> ${payload.Threshold.toFixed(2)}%
+				<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,
+							},
+						],
+					},
+				],
+			});
+		}
+	}
+};

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

@@ -1,6 +1,7 @@
 import type {
 	discord,
 	email,
+	gotify,
 	slack,
 	telegram,
 } from "@dokploy/server/db/schema";
@@ -41,20 +42,24 @@ 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 {
+	await fetch(connection.webhookUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ embeds: [embed] }),
+	});
+	// } catch (err) {
+	// 	console.log(err);
+	// }
 };
 
 export const sendTelegramNotification = async (
 	connection: typeof telegram.$inferInsert,
 	messageText: string,
+	inlineButton?: {
+		text: string;
+		url: string;
+	}[][],
 ) => {
 	try {
 		const url = `https://api.telegram.org/bot${connection.botToken}/sendMessage`;
@@ -63,9 +68,13 @@ export const sendTelegramNotification = async (
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
 				chat_id: connection.chatId,
+				message_thread_id: connection.messageThreadId,
 				text: messageText,
 				parse_mode: "HTML",
 				disable_web_page_preview: true,
+				reply_markup: {
+					inline_keyboard: inlineButton,
+				},
 			}),
 		});
 	} catch (err) {
@@ -87,3 +96,33 @@ export const sendSlackNotification = async (
 		console.log(err);
 	}
 };
+
+export const sendGotifyNotification = async (
+	connection: typeof gotify.$inferInsert,
+	title: string,
+	message: string,
+) => {
+	const response = await fetch(`${connection.serverUrl}/message`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"X-Gotify-Key": connection.appToken,
+		},
+		body: JSON.stringify({
+			title: title,
+			message: message,
+			priority: connection.priority,
+			extras: {
+				"client::display": {
+					contentType: "text/plain",
+				},
+			},
+		}),
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`Failed to send Gotify notification: ${response.statusText}`,
+		);
+	}
+};

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

@@ -1,12 +1,97 @@
-import { exec } from "node:child_process";
+import { exec, execFile } from "node:child_process";
 import util from "node:util";
 import { findServerById } from "@dokploy/server/services/server";
 import { Client } from "ssh2";
+
 export const execAsync = util.promisify(exec);
 
+interface ExecOptions {
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+}
+
+export const execAsyncStream = (
+	command: string,
+	onData?: (data: string) => void,
+	options: ExecOptions = {},
+): Promise<{ stdout: string; stderr: string }> => {
+	return new Promise((resolve, reject) => {
+		let stdoutComplete = "";
+		let stderrComplete = "";
+
+		const childProcess = exec(command, options, (error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve({ stdout: stdoutComplete, stderr: stderrComplete });
+		});
+
+		childProcess.stdout?.on("data", (data: Buffer | string) => {
+			const stringData = data.toString();
+			stdoutComplete += stringData;
+			if (onData) {
+				onData(stringData);
+			}
+		});
+
+		childProcess.stderr?.on("data", (data: Buffer | string) => {
+			const stringData = data.toString();
+			stderrComplete += stringData;
+			if (onData) {
+				onData(stringData);
+			}
+		});
+
+		childProcess.on("error", (error) => {
+			console.log(error);
+			reject(error);
+		});
+	});
+};
+
+export const execFileAsync = async (
+	command: string,
+	args: string[],
+	options: { input?: string } = {},
+): Promise<{ stdout: string; stderr: string }> => {
+	const child = execFile(command, args);
+
+	if (options.input && child.stdin) {
+		child.stdin.write(options.input);
+		child.stdin.end();
+	}
+
+	return new Promise((resolve, reject) => {
+		let stdout = "";
+		let stderr = "";
+
+		child.stdout?.on("data", (data) => {
+			stdout += data.toString();
+		});
+
+		child.stderr?.on("data", (data) => {
+			stderr += data.toString();
+		});
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve({ stdout, stderr });
+			} else {
+				reject(
+					new Error(`Command failed with code ${code}. Stderr: ${stderr}`),
+				);
+			}
+		});
+
+		child.on("error", reject);
+	});
+};
+
 export const execAsyncRemote = async (
 	serverId: string | null,
 	command: string,
+	onData?: (data: string) => void,
 ): Promise<{ stdout: string; stderr: string }> => {
 	if (!serverId) return { stdout: "", stderr: "" };
 	const server = await findServerById(serverId);
@@ -21,9 +106,12 @@ export const execAsyncRemote = async (
 		conn
 			.once("ready", () => {
 				conn.exec(command, (err, stream) => {
-					if (err) throw err;
+					if (err) {
+						onData?.(err.message);
+						throw err;
+					}
 					stream
-						.on("close", (code: number, signal: string) => {
+						.on("close", (code: number, _signal: string) => {
 							conn.end();
 							if (code === 0) {
 								resolve({ stdout, stderr });
@@ -37,21 +125,27 @@ export const execAsyncRemote = async (
 						})
 						.on("data", (data: string) => {
 							stdout += data.toString();
+							onData?.(data.toString());
 						})
 						.stderr.on("data", (data) => {
 							stderr += data.toString();
+							onData?.(data.toString());
 						});
 				});
 			})
 			.on("error", (err) => {
 				conn.end();
 				if (err.level === "client-authentication") {
+					onData?.(
+						`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
+					);
 					reject(
 						new Error(
 							`Authentication failed: Invalid SSH private key. ❌ Error: ${err.message} ${err.level}`,
 						),
 					);
 				} else {
+					onData?.(`SSH connection error: ${err.message}`);
 					reject(new Error(`SSH connection error: ${err.message}`));
 				}
 			})

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

@@ -37,6 +37,7 @@ export const cloneBitbucketRepository = async (
 		bitbucketBranch,
 		bitbucketId,
 		bitbucket,
+		enableSubmodules,
 	} = entity;
 
 	if (!bitbucketId) {
@@ -53,28 +54,26 @@ export const cloneBitbucketRepository = async (
 	const cloneUrl = `https://${bitbucket?.bitbucketUsername}:${bitbucket?.appPassword}@${repoclone}`;
 	try {
 		writeStream.write(`\nCloning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				bitbucketBranch!,
-				"--depth",
-				"1",
-				"--recurse-submodules",
-				cloneUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
+		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 Clonning: ${error}: ❌`);
+		writeStream.write(`ERROR Cloning: ${error}: ❌`);
 		throw error;
 	} finally {
 		writeStream.end();
@@ -89,6 +88,7 @@ export const cloneRawBitbucketRepository = async (entity: Compose) => {
 		bitbucketOwner,
 		bitbucketBranch,
 		bitbucketId,
+		enableSubmodules,
 	} = entity;
 
 	if (!bitbucketId) {
@@ -106,17 +106,19 @@ export const cloneRawBitbucketRepository = async (entity: Compose) => {
 	const cloneUrl = `https://${bitbucketProvider?.bitbucketUsername}:${bitbucketProvider?.appPassword}@${repoclone}`;
 
 	try {
-		await spawnAsync("git", [
+		const cloneArgs = [
 			"clone",
 			"--branch",
 			bitbucketBranch!,
 			"--depth",
 			"1",
-			"--recurse-submodules",
+			...(enableSubmodules ? ["--recurse-submodules"] : []),
 			cloneUrl,
 			outputPath,
 			"--progress",
-		]);
+		];
+
+		await spawnAsync("git", cloneArgs);
 	} catch (error) {
 		throw error;
 	}
@@ -131,6 +133,7 @@ export const cloneRawBitbucketRepositoryRemote = async (compose: Compose) => {
 		bitbucketBranch,
 		bitbucketId,
 		serverId,
+		enableSubmodules,
 	} = compose;
 
 	if (!serverId) {
@@ -153,11 +156,11 @@ export const cloneRawBitbucketRepositoryRemote = async (compose: Compose) => {
 	const cloneUrl = `https://${bitbucketProvider?.bitbucketUsername}:${bitbucketProvider?.appPassword}@${repoclone}`;
 
 	try {
-		const command = `
+		const cloneCommand = `
 			rm -rf ${outputPath};
-			git clone --branch ${bitbucketBranch} --depth 1 --recurse-submodules ${cloneUrl} ${outputPath}
+			git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
 		`;
-		await execAsyncRemote(serverId, command);
+		await execAsyncRemote(serverId, cloneCommand);
 	} catch (error) {
 		throw error;
 	}
@@ -176,7 +179,7 @@ export const getBitbucketCloneCommand = async (
 		bitbucketBranch,
 		bitbucketId,
 		serverId,
-		bitbucket,
+		enableSubmodules,
 	} = entity;
 
 	if (!serverId) {
@@ -208,7 +211,7 @@ export const getBitbucketCloneCommand = async (
 	const cloneCommand = `
 rm -rf ${outputPath};
 mkdir -p ${outputPath};
-if ! git clone --branch ${bitbucketBranch} --depth 1 --recurse-submodules --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
+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
@@ -276,7 +279,7 @@ export const getBitbucketBranches = async (
 	}
 	const bitbucketProvider = await findBitbucketById(input.bitbucketId);
 	const { owner, repo } = input;
-	const url = `https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/refs/branches`;
+	const url = `https://api.bitbucket.org/2.0/repositories/${owner}/${repo}/refs/branches?pagelen=100`;
 
 	try {
 		const response = await fetch(url, {

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

@@ -53,7 +53,7 @@ export const buildRemoteDocker = async (
 	application: ApplicationNested,
 	logPath: string,
 ) => {
-	const { sourceType, dockerImage, username, password } = application;
+	const { registryUrl, dockerImage, username, password } = application;
 
 	try {
 		if (!dockerImage) {
@@ -65,7 +65,7 @@ echo "Pulling ${dockerImage}" >> ${logPath};
 
 		if (username && password) {
 			command += `
-if ! docker login --username ${username} --password ${password} https://index.docker.io/v1/ >> ${logPath} 2>&1; then
+if ! echo "${password}" | docker login --username "${username}" --password-stdin "${registryUrl || ""}" >> ${logPath} 2>&1; then
 	echo "❌ Login failed" >> ${logPath};
 	exit 1;
 fi

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

@@ -17,12 +17,19 @@ export const cloneGitRepository = async (
 		customGitUrl?: string | null;
 		customGitBranch?: string | null;
 		customGitSSHKeyId?: string | null;
+		enableSubmodules?: boolean;
 	},
 	logPath: string,
 	isCompose = false,
 ) => {
 	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths();
-	const { appName, customGitUrl, customGitBranch, customGitSSHKeyId } = entity;
+	const {
+		appName,
+		customGitUrl,
+		customGitBranch,
+		customGitSSHKeyId,
+		enableSubmodules,
+	} = entity;
 
 	if (!customGitUrl || !customGitBranch) {
 		throw new TRPCError({
@@ -69,19 +76,22 @@ export const cloneGitRepository = async (
 			});
 		}
 
+		const { port } = sanitizeRepoPathSSH(customGitUrl);
+		const cloneArgs = [
+			"clone",
+			"--branch",
+			customGitBranch,
+			"--depth",
+			"1",
+			...(enableSubmodules ? ["--recurse-submodules"] : []),
+			customGitUrl,
+			outputPath,
+			"--progress",
+		];
+
 		await spawnAsync(
 			"git",
-			[
-				"clone",
-				"--branch",
-				customGitBranch,
-				"--depth",
-				"1",
-				"--recurse-submodules",
-				customGitUrl,
-				outputPath,
-				"--progress",
-			],
+			cloneArgs,
 			(data) => {
 				if (writeStream.writable) {
 					writeStream.write(data);
@@ -91,7 +101,7 @@ export const cloneGitRepository = async (
 				env: {
 					...process.env,
 					...(customGitSSHKeyId && {
-						GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath} -o UserKnownHostsFile=${knownHostsPath}`,
+						GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath}${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`,
 					}),
 				},
 			},
@@ -113,6 +123,7 @@ export const getCustomGitCloneCommand = async (
 		customGitBranch?: string | null;
 		customGitSSHKeyId?: string | null;
 		serverId: string | null;
+		enableSubmodules: boolean;
 	},
 	logPath: string,
 	isCompose = false,
@@ -124,6 +135,7 @@ export const getCustomGitCloneCommand = async (
 		customGitBranch,
 		customGitSSHKeyId,
 		serverId,
+		enableSubmodules,
 	} = entity;
 
 	if (!customGitUrl || !customGitBranch) {
@@ -168,7 +180,8 @@ export const getCustomGitCloneCommand = async (
 		);
 		if (customGitSSHKeyId) {
 			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const gitSshCommand = `ssh -i /tmp/id_rsa -o UserKnownHostsFile=${knownHostsPath}`;
+			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
@@ -179,7 +192,7 @@ export const getCustomGitCloneCommand = async (
 		}
 
 		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 --recurse-submodules --progress ${customGitUrl} ${outputPath} >> ${logPath} 2>&1; then
+			`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};
 				exit 1;
 			fi
@@ -259,8 +272,15 @@ export const cloneGitRawRepository = async (entity: {
 	customGitUrl?: string | null;
 	customGitBranch?: string | null;
 	customGitSSHKeyId?: string | null;
+	enableSubmodules?: boolean;
 }) => {
-	const { appName, customGitUrl, customGitBranch, customGitSSHKeyId } = entity;
+	const {
+		appName,
+		customGitUrl,
+		customGitBranch,
+		customGitSSHKeyId,
+		enableSubmodules,
+	} = entity;
 
 	if (!customGitUrl || !customGitBranch) {
 		throw new TRPCError({
@@ -304,29 +324,27 @@ export const cloneGitRawRepository = async (entity: {
 			});
 		}
 
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				customGitBranch,
-				"--depth",
-				"1",
-				"--recurse-submodules",
-				customGitUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {},
-			{
-				env: {
-					...process.env,
-					...(customGitSSHKeyId && {
-						GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath} -o UserKnownHostsFile=${knownHostsPath}`,
-					}),
-				},
+		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}`,
+				}),
 			},
-		);
+		});
 	} catch (error) {
 		throw error;
 	}
@@ -339,6 +357,7 @@ export const cloneRawGitRepositoryRemote = async (compose: Compose) => {
 		customGitUrl,
 		customGitSSHKeyId,
 		serverId,
+		enableSubmodules,
 	} = compose;
 
 	if (!serverId) {
@@ -381,7 +400,8 @@ export const cloneRawGitRepositoryRemote = async (compose: Compose) => {
 		command.push(`mkdir -p ${outputPath};`);
 		if (customGitSSHKeyId) {
 			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const gitSshCommand = `ssh -i /tmp/id_rsa -o UserKnownHostsFile=${knownHostsPath}`;
+			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
@@ -392,7 +412,7 @@ export const cloneRawGitRepositoryRemote = async (compose: Compose) => {
 		}
 
 		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 --recurse-submodules --progress ${customGitUrl} ${outputPath} ; then
+			`if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath} ; then
 				echo "[ERROR] Fail to clone the repository ";
 				exit 1;
 			fi

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

@@ -0,0 +1,516 @@
+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 {
+	type Gitea,
+	findGiteaById,
+	updateGitea,
+} 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;
+	giteaOwner?: string | null;
+	giteaBranch?: string | null;
+}) => {
+	const reasons: string[] = [];
+	const { giteaBranch, giteaOwner, giteaRepository } = entity;
+
+	if (!giteaRepository) reasons.push("1. Repository not assigned.");
+	if (!giteaOwner) reasons.push("2. Owner not specified.");
+	if (!giteaBranch) reasons.push("3. Branch not defined.");
+
+	return reasons;
+};
+
+export const refreshGiteaToken = async (giteaProviderId: string) => {
+	try {
+		const giteaProvider = await findGiteaById(giteaProviderId);
+
+		if (
+			!giteaProvider?.clientId ||
+			!giteaProvider?.clientSecret ||
+			!giteaProvider?.refreshToken
+		) {
+			return giteaProvider?.accessToken || null;
+		}
+
+		// Check if token is still valid (add some buffer time, e.g., 5 minutes)
+		const currentTimeSeconds = Math.floor(Date.now() / 1000);
+		const bufferTimeSeconds = 300; // 5 minutes
+
+		if (
+			giteaProvider.expiresAt &&
+			giteaProvider.expiresAt > currentTimeSeconds + bufferTimeSeconds &&
+			giteaProvider.accessToken
+		) {
+			// Token is still valid, no need to refresh
+			return giteaProvider.accessToken;
+		}
+
+		// Token is expired or about to expire, refresh it
+		const tokenEndpoint = `${giteaProvider.giteaUrl}/login/oauth/access_token`;
+		const params = new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: giteaProvider.refreshToken,
+			client_id: giteaProvider.clientId,
+			client_secret: giteaProvider.clientSecret,
+		});
+
+		const response = await fetch(tokenEndpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				Accept: "application/json",
+			},
+			body: params.toString(),
+		});
+
+		if (!response.ok) {
+			return giteaProvider?.accessToken || null;
+		}
+
+		const data = await response.json();
+		const { access_token, refresh_token, expires_in } = data;
+
+		if (!access_token) {
+			return giteaProvider?.accessToken || null;
+		}
+
+		const expiresAt = Date.now() + (expires_in || 3600) * 1000;
+		const expiresAtSeconds = Math.floor(expiresAt / 1000);
+
+		await updateGitea(giteaProviderId, {
+			accessToken: access_token,
+			refreshToken: refresh_token || giteaProvider.refreshToken,
+			expiresAt: expiresAtSeconds,
+		});
+
+		return access_token;
+	} catch (error) {
+		console.error("Error refreshing Gitea token:", error);
+		const giteaProvider = await findGiteaById(giteaProviderId);
+		return giteaProvider?.accessToken || null;
+	}
+};
+
+export type ApplicationWithGitea = InferResultType<
+	"applications",
+	{ gitea: true }
+>;
+
+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,
+		gitea,
+		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 basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = join(basePath, appName, "code");
+
+	const baseUrl = gitea?.giteaUrl.replace(/^https?:\/\//, "");
+	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
+	const cloneUrl = `https://oauth2:${gitea?.accessToken}@${baseUrl}/${repoClone}`;
+
+	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;
+};
+
+export const cloneGiteaRepository = async (
+	entity: ApplicationWithGitea | ComposeWithGitea,
+	logPath: string,
+	isCompose = false,
+) => {
+	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
+
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const {
+		appName,
+		giteaBranch,
+		giteaId,
+		giteaOwner,
+		giteaRepository,
+		enableSubmodules,
+	} = entity;
+
+	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 = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const outputPath = join(basePath, appName, "code");
+	await recreateDirectory(outputPath);
+
+	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
+	const baseUrl = giteaProvider.giteaUrl.replace(/^https?:\/\//, "");
+	const cloneUrl = `https://oauth2:${giteaProvider.accessToken}@${baseUrl}/${repoClone}`;
+
+	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 repoClone = `${giteaOwner}/${giteaRepository}.git`;
+	const baseUrl = giteaProvider.giteaUrl.replace(/^https?:\/\//, "");
+	const cloneUrl = `https://oauth2:${giteaProvider.accessToken}@${baseUrl}/${repoClone}`;
+
+	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 repoClone = `${giteaOwner}/${giteaRepository}.git`;
+	const baseUrl = giteaProvider.giteaUrl.replace(/^https?:\/\//, "");
+	const cloneUrl = `https://oauth2:${giteaProvider.accessToken}@${baseUrl}/${repoClone}`;
+	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;
+	}
+};
+
+export const haveGiteaRequirements = (giteaProvider: Gitea) => {
+	return !!(giteaProvider?.clientId && giteaProvider?.clientSecret);
+};
+
+export const testGiteaConnection = async (input: { giteaId: string }) => {
+	try {
+		const { giteaId } = input;
+
+		if (!giteaId) {
+			throw new Error("Gitea provider not found");
+		}
+
+		const giteaProvider = await findGiteaById(giteaId);
+		if (!giteaProvider) {
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Gitea provider not found in the database",
+			});
+		}
+
+		await refreshGiteaToken(giteaId);
+
+		const provider = await findGiteaById(giteaId);
+		if (!provider || !provider.accessToken) {
+			throw new TRPCError({
+				code: "UNAUTHORIZED",
+				message: "No access token available. Please authorize with Gitea.",
+			});
+		}
+
+		const baseUrl = provider.giteaUrl.replace(/\/+$/, "");
+		const limit = 30;
+		let allRepos = 0;
+		let nextUrl = `${baseUrl}/api/v1/repos/search?limit=${limit}`;
+
+		while (nextUrl) {
+			const response = await fetch(nextUrl, {
+				headers: {
+					Accept: "application/json",
+					Authorization: `token ${provider.accessToken}`,
+				},
+			});
+
+			if (!response.ok) {
+				throw new Error(
+					`Failed to connect to Gitea API: ${response.status} ${response.statusText}`,
+				);
+			}
+
+			const repos = await response.json();
+			allRepos += repos.data.length;
+
+			const linkHeader = response.headers.get("link");
+			nextUrl = "";
+
+			if (linkHeader) {
+				const nextLink = linkHeader
+					.split(",")
+					.find((link) => link.includes('rel="next"'));
+				if (nextLink) {
+					const matches = nextLink.match(/<([^>]+)>/);
+					if (matches?.[1]) {
+						nextUrl = matches[1];
+					}
+				}
+			}
+		}
+
+		await updateGitea(giteaId, {
+			lastAuthenticatedAt: Math.floor(Date.now() / 1000),
+		});
+
+		return allRepos;
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const getGiteaRepositories = async (giteaId?: string) => {
+	if (!giteaId) {
+		return [];
+	}
+
+	await refreshGiteaToken(giteaId);
+	const giteaProvider = await findGiteaById(giteaId);
+
+	const baseUrl = giteaProvider.giteaUrl.replace(/\/+$/, "");
+	const limit = 30;
+	let allRepositories: any[] = [];
+	let nextUrl = `${baseUrl}/api/v1/repos/search?limit=${limit}`;
+
+	while (nextUrl) {
+		const response = await fetch(nextUrl, {
+			headers: {
+				Accept: "application/json",
+				Authorization: `token ${giteaProvider.accessToken}`,
+			},
+		});
+
+		if (!response.ok) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: `Failed to fetch repositories: ${response.statusText}`,
+			});
+		}
+
+		const result = await response.json();
+		allRepositories = [...allRepositories, ...result.data];
+
+		const linkHeader = response.headers.get("link");
+		nextUrl = "";
+
+		if (linkHeader) {
+			const nextLink = linkHeader
+				.split(",")
+				.find((link) => link.includes('rel="next"'));
+			if (nextLink) {
+				const matches = nextLink.match(/<([^>]+)>/);
+				if (matches?.[1]) {
+					nextUrl = matches[1];
+				}
+			}
+		}
+	}
+
+	return (
+		allRepositories?.map((repo: any) => ({
+			id: repo.id,
+			name: repo.name,
+			url: repo.full_name,
+			owner: {
+				username: repo.owner.login,
+			},
+		})) || []
+	);
+};
+
+export const getGiteaBranches = async (input: {
+	giteaId?: string;
+	owner: string;
+	repo: string;
+}) => {
+	if (!input.giteaId) {
+		return [];
+	}
+
+	await refreshGiteaToken(input.giteaId);
+
+	const giteaProvider = await findGiteaById(input.giteaId);
+
+	const baseUrl = giteaProvider.giteaUrl.replace(/\/+$/, "");
+	const url = `${baseUrl}/api/v1/repos/${input.owner}/${input.repo}/branches`;
+
+	const response = await fetch(url, {
+		headers: {
+			Accept: "application/json",
+			Authorization: `token ${giteaProvider.accessToken}`,
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch branches: ${response.statusText}`);
+	}
+
+	const branches = await response.json();
+
+	if (!branches) {
+		return [];
+	}
+	return branches?.map((branch: any) => ({
+		id: branch.name,
+		name: branch.name,
+		commit: {
+			id: branch.commit.id,
+		},
+	})) as {
+		id: string;
+		name: string;
+		commit: {
+			id: string;
+		};
+	}[];
+};

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

@@ -45,6 +45,49 @@ export const getGithubToken = async (
 	return installation.token;
 };
 
+/**
+ * Check if a GitHub user has write/admin permissions on a repository
+ * This is used to validate PR authors before allowing preview deployments
+ */
+export const checkUserRepositoryPermissions = async (
+	githubProvider: Github,
+	owner: string,
+	repo: string,
+	username: string,
+): Promise<{ hasWriteAccess: boolean; permission: string | null }> => {
+	try {
+		const octokit = authGithub(githubProvider);
+
+		// Check if user is a collaborator with write permissions
+		const { data: permission } =
+			await octokit.rest.repos.getCollaboratorPermissionLevel({
+				owner,
+				repo,
+				username,
+			});
+
+		// Allow only users with 'write', 'admin', or 'maintain' permissions
+		// Currently exists Read, Triage, Write, Maintain, Admin
+		const allowedPermissions = ["write", "admin", "maintain"];
+		const hasWriteAccess = allowedPermissions.includes(permission.permission);
+
+		return {
+			hasWriteAccess,
+			permission: permission.permission,
+		};
+	} catch (error) {
+		// If user is not a collaborator, GitHub API returns 404
+		console.warn(
+			`User ${username} is not a collaborator of ${owner}/${repo}:`,
+			error,
+		);
+		return {
+			hasWriteAccess: false,
+			permission: null,
+		};
+	}
+};
+
 export const haveGithubRequirements = (githubProvider: Github) => {
 	return !!(
 		githubProvider?.githubAppId &&
@@ -83,6 +126,7 @@ interface CloneGithubRepository {
 	repository: string | null;
 	logPath: string;
 	type?: "application" | "compose";
+	enableSubmodules: boolean;
 }
 export const cloneGithubRepository = async ({
 	logPath,
@@ -92,7 +136,8 @@ export const cloneGithubRepository = async ({
 	const isCompose = type === "compose";
 	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
 	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const { appName, repository, owner, branch, githubId } = entity;
+	const { appName, repository, owner, branch, githubId, enableSubmodules } =
+		entity;
 
 	if (!githubId) {
 		throw new TRPCError({
@@ -128,28 +173,26 @@ export const cloneGithubRepository = async ({
 
 	try {
 		writeStream.write(`\nClonning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				branch!,
-				"--depth",
-				"1",
-				"--recurse-submodules",
-				cloneUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
+		const cloneArgs = [
+			"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 Clonning: ${error}: ❌`);
+		writeStream.write(`ERROR Cloning: ${error}: ❌`);
 		throw error;
 	} finally {
 		writeStream.end();
@@ -161,7 +204,15 @@ export const getGithubCloneCommand = async ({
 	type = "application",
 	...entity
 }: CloneGithubRepository & { serverId: string }) => {
-	const { appName, repository, owner, branch, githubId, serverId } = entity;
+	const {
+		appName,
+		repository,
+		owner,
+		branch,
+		githubId,
+		serverId,
+		enableSubmodules,
+	} = entity;
 	const isCompose = type === "compose";
 	if (!serverId) {
 		throw new TRPCError({
@@ -216,7 +267,7 @@ export const getGithubCloneCommand = async ({
 	const cloneCommand = `
 rm -rf ${outputPath};
 mkdir -p ${outputPath};
-if ! git clone --branch ${branch} --depth 1 --recurse-submodules --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
+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
@@ -227,7 +278,8 @@ echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath};
 };
 
 export const cloneRawGithubRepository = async (entity: Compose) => {
-	const { appName, repository, owner, branch, githubId } = entity;
+	const { appName, repository, owner, branch, githubId, enableSubmodules } =
+		entity;
 
 	if (!githubId) {
 		throw new TRPCError({
@@ -245,24 +297,33 @@ export const cloneRawGithubRepository = async (entity: Compose) => {
 	await recreateDirectory(outputPath);
 	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
 	try {
-		await spawnAsync("git", [
+		const cloneArgs = [
 			"clone",
 			"--branch",
 			branch!,
 			"--depth",
 			"1",
-			"--recurse-submodules",
+			...(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 } = compose;
+	const {
+		appName,
+		repository,
+		owner,
+		branch,
+		githubId,
+		serverId,
+		enableSubmodules,
+	} = compose;
 
 	if (!serverId) {
 		throw new TRPCError({
@@ -288,7 +349,7 @@ export const cloneRawGithubRepositoryRemote = async (compose: Compose) => {
 	try {
 		const command = `
 			rm -rf ${outputPath};
-			git clone --branch ${branch} --depth 1 ${cloneUrl} ${outputPath}
+			git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
 		`;
 		await execAsyncRemote(serverId, command);
 	} catch (error) {

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

@@ -4,8 +4,8 @@ import { paths } from "@dokploy/server/constants";
 import type { apiGitlabTestConnection } from "@dokploy/server/db/schema";
 import type { Compose } from "@dokploy/server/services/compose";
 import {
-	type Gitlab,
 	findGitlabById,
+	type Gitlab,
 	updateGitlab,
 } from "@dokploy/server/services/gitlab";
 import type { InferResultType } from "@dokploy/server/types/with";
@@ -26,7 +26,7 @@ export const refreshGitlabToken = async (gitlabProviderId: string) => {
 		return;
 	}
 
-	const response = await fetch("https://gitlab.com/oauth/token", {
+	const response = await fetch(`${gitlabProvider.gitlabUrl}/oauth/token`, {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/x-www-form-urlencoded",
@@ -84,14 +84,38 @@ export type ApplicationWithGitlab = InferResultType<
 
 export type ComposeWithGitlab = InferResultType<"compose", { gitlab: true }>;
 
+export type GitlabInfo =
+	| ApplicationWithGitlab["gitlab"]
+	| ComposeWithGitlab["gitlab"];
+
+const getGitlabRepoClone = (
+	gitlab: GitlabInfo,
+	gitlabPathNamespace: string | null,
+) => {
+	const repoClone = `${gitlab?.gitlabUrl.replace(/^https?:\/\//, "")}/${gitlabPathNamespace}.git`;
+	return repoClone;
+};
+
+const getGitlabCloneUrl = (gitlab: GitlabInfo, repoClone: string) => {
+	const isSecure = gitlab?.gitlabUrl.startsWith("https://");
+	const cloneUrl = `http${isSecure ? "s" : ""}://oauth2:${gitlab?.accessToken}@${repoClone}`;
+	return cloneUrl;
+};
+
 export const cloneGitlabRepository = async (
 	entity: ApplicationWithGitlab | ComposeWithGitlab,
 	logPath: string,
 	isCompose = false,
 ) => {
 	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const { appName, gitlabBranch, gitlabId, gitlab, gitlabPathNamespace } =
-		entity;
+	const {
+		appName,
+		gitlabBranch,
+		gitlabId,
+		gitlab,
+		gitlabPathNamespace,
+		enableSubmodules,
+	} = entity;
 
 	if (!gitlabId) {
 		throw new TRPCError({
@@ -122,33 +146,30 @@ export const cloneGitlabRepository = async (
 	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
 	await recreateDirectory(outputPath);
-	const repoclone = `gitlab.com/${gitlabPathNamespace}.git`;
-	const cloneUrl = `https://oauth2:${gitlab?.accessToken}@${repoclone}`;
-
+	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
+	const cloneUrl = getGitlabCloneUrl(gitlab, repoClone);
 	try {
-		writeStream.write(`\nClonning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				gitlabBranch!,
-				"--depth",
-				"1",
-				"--recurse-submodules",
-				cloneUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
-		writeStream.write(`\nCloned ${repoclone}: ✅\n`);
+		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 Clonning: ${error}: ❌`);
+		writeStream.write(`ERROR Cloning: ${error}: ❌`);
 		throw error;
 	} finally {
 		writeStream.end();
@@ -162,13 +183,12 @@ export const getGitlabCloneCommand = async (
 ) => {
 	const {
 		appName,
-		gitlabRepository,
-		gitlabOwner,
 		gitlabPathNamespace,
 		gitlabBranch,
 		gitlabId,
 		serverId,
 		gitlab,
+		enableSubmodules,
 	} = entity;
 
 	if (!serverId) {
@@ -218,17 +238,16 @@ export const getGitlabCloneCommand = async (
 	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
 	await recreateDirectory(outputPath);
-	const repoclone = `gitlab.com/${gitlabPathNamespace}.git`;
-	const cloneUrl = `https://oauth2:${gitlab?.accessToken}@${repoclone}`;
-
+	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 --recurse-submodules --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone the repository ${repoclone}" >> ${logPath};
+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};
+echo "Cloned ${repoClone} to ${outputPath}: ✅" >> ${logPath};
 	`;
 
 	return cloneCommand;
@@ -243,30 +262,18 @@ export const getGitlabRepositories = async (gitlabId?: string) => {
 
 	const gitlabProvider = await findGitlabById(gitlabId);
 
-	const response = await fetch(
-		`https://gitlab.com/api/v4/projects?membership=true&owned=true&page=${0}&per_page=${100}`,
-		{
-			headers: {
-				Authorization: `Bearer ${gitlabProvider.accessToken}`,
-			},
-		},
-	);
+	const allProjects = await validateGitlabProvider(gitlabProvider);
 
-	if (!response.ok) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: `Failed to fetch repositories: ${response.statusText}`,
-		});
-	}
-
-	const repositories = await response.json();
-
-	const filteredRepos = repositories.filter((repo: any) => {
+	const filteredRepos = allProjects.filter((repo: any) => {
 		const { full_path, kind } = repo.namespace;
 		const groupName = gitlabProvider.groupName?.toLowerCase();
 
 		if (groupName) {
-			return full_path.toLowerCase().includes(groupName) && kind === "group";
+			return groupName
+				.split(",")
+				.some((name) =>
+					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
+				);
 		}
 		return kind === "user";
 	});
@@ -318,7 +325,9 @@ export const getGitlabBranches = async (input: {
 		);
 
 		if (!branchesResponse.ok) {
-			throw new Error(`Failed to fetch branches: ${branchesResponse.statusText}`);
+			throw new Error(
+				`Failed to fetch branches: ${branchesResponse.statusText}`,
+			);
 		}
 
 		const branches = await branchesResponse.json();
@@ -349,11 +358,10 @@ export const getGitlabBranches = async (input: {
 export const cloneRawGitlabRepository = async (entity: Compose) => {
 	const {
 		appName,
-		gitlabRepository,
-		gitlabOwner,
 		gitlabBranch,
 		gitlabId,
 		gitlabPathNamespace,
+		enableSubmodules,
 	} = entity;
 
 	if (!gitlabId) {
@@ -369,28 +377,35 @@ export const cloneRawGitlabRepository = async (entity: Compose) => {
 	const basePath = COMPOSE_PATH;
 	const outputPath = join(basePath, appName, "code");
 	await recreateDirectory(outputPath);
-	const repoclone = `gitlab.com/${gitlabPathNamespace}.git`;
-	const cloneUrl = `https://oauth2:${gitlabProvider?.accessToken}@${repoclone}`;
-
+	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
+	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
 	try {
-		await spawnAsync("git", [
+		const cloneArgs = [
 			"clone",
 			"--branch",
 			gitlabBranch!,
 			"--depth",
 			"1",
-			"--recurse-submodules",
+			...(enableSubmodules ? ["--recurse-submodules"] : []),
 			cloneUrl,
 			outputPath,
 			"--progress",
-		]);
+		];
+		await spawnAsync("git", cloneArgs);
 	} catch (error) {
 		throw error;
 	}
 };
 
 export const cloneRawGitlabRepositoryRemote = async (compose: Compose) => {
-	const { appName, gitlabPathNamespace, branch, gitlabId, serverId } = compose;
+	const {
+		appName,
+		gitlabPathNamespace,
+		branch,
+		gitlabId,
+		serverId,
+		enableSubmodules,
+	} = compose;
 
 	if (!serverId) {
 		throw new TRPCError({
@@ -409,12 +424,12 @@ export const cloneRawGitlabRepositoryRemote = async (compose: Compose) => {
 	await refreshGitlabToken(gitlabId);
 	const basePath = COMPOSE_PATH;
 	const outputPath = join(basePath, appName, "code");
-	const repoclone = `gitlab.com/${gitlabPathNamespace}.git`;
-	const cloneUrl = `https://oauth2:${gitlabProvider?.accessToken}@${repoclone}`;
+	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
+	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
 	try {
 		const command = `
 			rm -rf ${outputPath};
-			git clone --branch ${branch} --depth 1 --recurse-submodules ${cloneUrl} ${outputPath}
+			git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
 		`;
 		await execAsyncRemote(serverId, command);
 	} catch (error) {
@@ -435,32 +450,64 @@ export const testGitlabConnection = async (
 
 	const gitlabProvider = await findGitlabById(gitlabId);
 
-	const response = await fetch(
-		`https://gitlab.com/api/v4/projects?membership=true&owned=true&page=${0}&per_page=${100}`,
-		{
-			headers: {
-				Authorization: `Bearer ${gitlabProvider.accessToken}`,
-			},
-		},
-	);
-
-	if (!response.ok) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: `Failed to fetch repositories: ${response.statusText}`,
-		});
-	}
-
-	const repositories = await response.json();
+	const repositories = await validateGitlabProvider(gitlabProvider);
 
 	const filteredRepos = repositories.filter((repo: any) => {
 		const { full_path, kind } = repo.namespace;
 
 		if (groupName) {
-			return full_path.toLowerCase().includes(groupName) && kind === "group";
+			return groupName
+				.split(",")
+				.some((name) =>
+					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
+				);
 		}
 		return kind === "user";
 	});
 
 	return filteredRepos.length;
 };
+
+export const validateGitlabProvider = async (gitlabProvider: Gitlab) => {
+	try {
+		const allProjects = [];
+		let page = 1;
+		const perPage = 100; // GitLab's max per page is 100
+
+		while (true) {
+			const response = await fetch(
+				`${gitlabProvider.gitlabUrl}/api/v4/projects?membership=true&owned=true&page=${page}&per_page=${perPage}`,
+				{
+					headers: {
+						Authorization: `Bearer ${gitlabProvider.accessToken}`,
+					},
+				},
+			);
+
+			if (!response.ok) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: `Failed to fetch repositories: ${response.statusText}`,
+				});
+			}
+
+			const projects = await response.json();
+
+			if (projects.length === 0) {
+				break;
+			}
+
+			allProjects.push(...projects);
+			page++;
+
+			const total = response.headers.get("x-total");
+			if (total && allProjects.length >= Number.parseInt(total)) {
+				break;
+			}
+		}
+
+		return allProjects;
+	} catch (error) {
+		throw error;
+	}
+};

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

@@ -0,0 +1,97 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Compose } from "@dokploy/server/services/compose";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { z } from "zod";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRestoreCommand } from "./utils";
+
+interface DatabaseCredentials {
+	databaseUser?: string;
+	databasePassword?: string;
+}
+
+export const restoreComposeBackup = async (
+	compose: Compose,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		if (backupInput.databaseType === "web-server") {
+			return;
+		}
+		const { serverId, appName, composeType } = compose;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+		let rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+
+		if (backupInput.metadata?.mongo) {
+			rcloneCommand = `rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
+		}
+
+		let credentials: DatabaseCredentials;
+
+		switch (backupInput.databaseType) {
+			case "postgres":
+				credentials = {
+					databaseUser: backupInput.metadata?.postgres?.databaseUser,
+				};
+				break;
+			case "mariadb":
+				credentials = {
+					databaseUser: backupInput.metadata?.mariadb?.databaseUser,
+					databasePassword: backupInput.metadata?.mariadb?.databasePassword,
+				};
+				break;
+			case "mysql":
+				credentials = {
+					databasePassword: backupInput.metadata?.mysql?.databaseRootPassword,
+				};
+				break;
+			case "mongo":
+				credentials = {
+					databaseUser: backupInput.metadata?.mongo?.databaseUser,
+					databasePassword: backupInput.metadata?.mongo?.databasePassword,
+				};
+				break;
+		}
+
+		const restoreCommand = getRestoreCommand({
+			appName: appName,
+			serviceName: backupInput.metadata?.serviceName,
+			type: backupInput.databaseType,
+			credentials: {
+				database: backupInput.databaseName,
+				...credentials,
+			},
+			restoreType: composeType,
+			rcloneCommand,
+		});
+
+		emit("Starting restore...");
+		emit(`Backup path: ${backupPath}`);
+
+		emit(`Executing command: ${restoreCommand}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, restoreCommand);
+		} else {
+			await execAsync(restoreCommand);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring mongo backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mongo backup",
+		);
+	}
+};

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

@@ -0,0 +1,6 @@
+export { restorePostgresBackup } from "./postgres";
+export { restoreMySqlBackup } from "./mysql";
+export { restoreMariadbBackup } from "./mariadb";
+export { restoreMongoBackup } from "./mongo";
+export { restoreWebServerBackup } from "./web-server";
+export { restoreComposeBackup } from "./compose";

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

@@ -0,0 +1,60 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Mariadb } from "@dokploy/server/services/mariadb";
+import type { z } from "zod";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRestoreCommand } from "./utils";
+
+export const restoreMariadbBackup = async (
+	mariadb: Mariadb,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, serverId, databaseUser, databasePassword } = mariadb;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+
+		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+
+		const command = getRestoreCommand({
+			appName,
+			credentials: {
+				database: backupInput.databaseName,
+				databaseUser,
+				databasePassword,
+			},
+			type: "mariadb",
+			rcloneCommand,
+			restoreType: "database",
+		});
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${command}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error
+					? error.message
+					: "Error restoring mariadb backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mariadb backup",
+		);
+	}
+};

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

@@ -0,0 +1,58 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Mongo } from "@dokploy/server/services/mongo";
+import type { z } from "zod";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRestoreCommand } from "./utils";
+
+export const restoreMongoBackup = async (
+	mongo: Mongo,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databasePassword, databaseUser, serverId } = mongo;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+		const rcloneCommand = `rclone copy ${rcloneFlags.join(" ")} "${backupPath}"`;
+
+		const command = getRestoreCommand({
+			appName,
+			type: "mongo",
+			credentials: {
+				database: backupInput.databaseName,
+				databaseUser,
+				databasePassword,
+			},
+			restoreType: "database",
+			rcloneCommand,
+			backupFile: backupInput.backupFile,
+		});
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${command}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring mongo backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mongo backup",
+		);
+	}
+};

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

@@ -0,0 +1,57 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { MySql } from "@dokploy/server/services/mysql";
+import type { z } from "zod";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRestoreCommand } from "./utils";
+
+export const restoreMySqlBackup = async (
+	mysql: MySql,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databaseRootPassword, serverId } = mysql;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+
+		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+
+		const command = getRestoreCommand({
+			appName,
+			type: "mysql",
+			credentials: {
+				database: backupInput.databaseName,
+				databasePassword: databaseRootPassword,
+			},
+			restoreType: "database",
+			rcloneCommand,
+		});
+
+		emit("Starting restore...");
+
+		emit(`Executing command: ${command}`);
+
+		if (serverId) {
+			await execAsyncRemote(serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		emit("Restore completed successfully!");
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error ? error.message : "Error restoring mysql backup"
+			}`,
+		);
+		throw new Error(
+			error instanceof Error ? error.message : "Error restoring mysql backup",
+		);
+	}
+};

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

@@ -0,0 +1,58 @@
+import type { apiRestoreBackup } from "@dokploy/server/db/schema";
+import type { Destination } from "@dokploy/server/services/destination";
+import type { Postgres } from "@dokploy/server/services/postgres";
+import type { z } from "zod";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
+import { getRestoreCommand } from "./utils";
+
+export const restorePostgresBackup = async (
+	postgres: Postgres,
+	destination: Destination,
+	backupInput: z.infer<typeof apiRestoreBackup>,
+	emit: (log: string) => void,
+) => {
+	try {
+		const { appName, databaseUser, serverId } = postgres;
+
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+
+		const backupPath = `${bucketPath}/${backupInput.backupFile}`;
+
+		const rcloneCommand = `rclone cat ${rcloneFlags.join(" ")} "${backupPath}" | gunzip`;
+
+		emit("Starting restore...");
+		emit(`Backup path: ${backupPath}`);
+
+		const command = getRestoreCommand({
+			appName,
+			credentials: {
+				database: backupInput.databaseName,
+				databaseUser,
+			},
+			type: "postgres",
+			rcloneCommand,
+			restoreType: "database",
+		});
+
+		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 postgres backup"
+			}`,
+		);
+		throw error;
+	}
+};

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

@@ -0,0 +1,131 @@
+import {
+	getComposeContainerCommand,
+	getServiceContainerCommand,
+} from "../backups/utils";
+
+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"`;
+};
+
+export const getMariadbRestoreCommand = (
+	database: string,
+	databaseUser: string,
+	databasePassword: string,
+) => {
+	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}"`;
+};
+
+export const getMongoRestoreCommand = (
+	database: string,
+	databaseUser: string,
+	databasePassword: string,
+) => {
+	return `docker exec -i $CONTAINER_ID sh -c "mongorestore --username ${databaseUser} --password ${databasePassword} --authenticationDatabase admin --db ${database} --archive"`;
+};
+
+export const getComposeSearchCommand = (
+	appName: string,
+	type: "stack" | "docker-compose" | "database",
+	serviceName?: string,
+) => {
+	if (type === "database") {
+		return getServiceContainerCommand(appName || "");
+	}
+	return getComposeContainerCommand(appName || "", serviceName || "", type);
+};
+
+interface DatabaseCredentials {
+	database: string;
+	databaseUser?: string;
+	databasePassword?: string;
+}
+
+const generateRestoreCommand = (
+	type: "postgres" | "mariadb" | "mysql" | "mongo",
+	credentials: DatabaseCredentials,
+) => {
+	const { database, databaseUser, databasePassword } = credentials;
+	switch (type) {
+		case "postgres":
+			return getPostgresRestoreCommand(database, databaseUser || "");
+		case "mariadb":
+			return getMariadbRestoreCommand(
+				database,
+				databaseUser || "",
+				databasePassword || "",
+			);
+		case "mysql":
+			return getMysqlRestoreCommand(database, databasePassword || "");
+		case "mongo":
+			return getMongoRestoreCommand(
+				database,
+				databaseUser || "",
+				databasePassword || "",
+			);
+	}
+};
+
+const getMongoSpecificCommand = (
+	rcloneCommand: string,
+	restoreCommand: string,
+	backupFile: string,
+): string => {
+	const tempDir = "/tmp/dokploy-restore";
+	const fileName = backupFile.split("/").pop() || "backup.dump.gz";
+	const decompressedName = fileName.replace(".gz", "");
+	return `
+rm -rf ${tempDir} && \
+mkdir -p ${tempDir} && \
+${rcloneCommand} ${tempDir} && \
+cd ${tempDir} && \
+gunzip -f "${fileName}" && \
+${restoreCommand} < "${decompressedName}" && \
+rm -rf ${tempDir}
+	`;
+};
+
+interface RestoreOptions {
+	appName: string;
+	type: "postgres" | "mariadb" | "mysql" | "mongo";
+	restoreType: "stack" | "docker-compose" | "database";
+	credentials: DatabaseCredentials;
+	serviceName?: string;
+	rcloneCommand: string;
+	backupFile?: string;
+}
+
+export const getRestoreCommand = ({
+	appName,
+	type,
+	restoreType,
+	credentials,
+	serviceName,
+	rcloneCommand,
+	backupFile,
+}: RestoreOptions) => {
+	const containerSearch = getComposeSearchCommand(
+		appName,
+		restoreType,
+		serviceName,
+	);
+	const restoreCommand = generateRestoreCommand(type, credentials);
+	let cmd = `CONTAINER_ID=$(${containerSearch})`;
+
+	if (type !== "mongo") {
+		cmd += ` && ${rcloneCommand} | ${restoreCommand}`;
+	} else {
+		cmd += ` && ${getMongoSpecificCommand(rcloneCommand, restoreCommand, backupFile || "")}`;
+	}
+
+	return cmd;
+};

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

@@ -0,0 +1,153 @@
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { IS_CLOUD, paths } from "@dokploy/server/constants";
+import type { Destination } from "@dokploy/server/services/destination";
+import { getS3Credentials } from "../backups/utils";
+import { execAsync } from "../process/execAsync";
+
+export const restoreWebServerBackup = async (
+	destination: Destination,
+	backupFile: string,
+	emit: (log: string) => void,
+) => {
+	if (IS_CLOUD) {
+		return;
+	}
+	try {
+		const rcloneFlags = getS3Credentials(destination);
+		const bucketPath = `:s3:${destination.bucket}`;
+		const backupPath = `${bucketPath}/${backupFile}`;
+		const { BASE_PATH } = paths();
+
+		// Create a temporary directory outside of BASE_PATH
+		const tempDir = await mkdtemp(join(tmpdir(), "dokploy-restore-"));
+
+		try {
+			emit("Starting restore...");
+			emit(`Backup path: ${backupPath}`);
+			emit(`Temp directory: ${tempDir}`);
+
+			// Create temp directory
+			emit("Creating temporary directory...");
+			await execAsync(`mkdir -p ${tempDir}`);
+
+			// Download backup from S3
+			emit("Downloading backup from S3...");
+			await execAsync(
+				`rclone copyto ${rcloneFlags.join(" ")} "${backupPath}" "${tempDir}/${backupFile}"`,
+			);
+
+			// List files before extraction
+			emit("Listing files before extraction...");
+			const { stdout: beforeFiles } = await execAsync(`ls -la ${tempDir}`);
+			emit(`Files before extraction: ${beforeFiles}`);
+
+			// Extract backup
+			emit("Extracting backup...");
+			await execAsync(`cd ${tempDir} && unzip ${backupFile} > /dev/null 2>&1`);
+
+			// Restore filesystem first
+			emit("Restoring filesystem...");
+			emit(`Copying from ${tempDir}/filesystem/* to ${BASE_PATH}/`);
+
+			// First clean the target directory
+			emit("Cleaning target directory...");
+			await execAsync(`rm -rf "${BASE_PATH}/"*`);
+
+			// Ensure the target directory exists
+			emit("Setting up target directory...");
+			await execAsync(`mkdir -p "${BASE_PATH}"`);
+
+			// Copy files preserving permissions
+			emit("Copying files...");
+			await execAsync(`cp -rp "${tempDir}/filesystem/"* "${BASE_PATH}/"`);
+
+			// Now handle database restore
+			emit("Starting database restore...");
+
+			// Check if database.sql.gz exists and decompress it
+			const { stdout: hasGzFile } = await execAsync(
+				`ls ${tempDir}/database.sql.gz || true`,
+			);
+			if (hasGzFile.includes("database.sql.gz")) {
+				emit("Found compressed database file, decompressing...");
+				await execAsync(`cd ${tempDir} && gunzip database.sql.gz`);
+			}
+
+			// Verify database file exists
+			const { stdout: hasSqlFile } = await execAsync(
+				`ls ${tempDir}/database.sql || true`,
+			);
+			if (!hasSqlFile.includes("database.sql")) {
+				throw new Error("Database file not found after extraction");
+			}
+
+			const { stdout: postgresContainer } = await execAsync(
+				`docker ps --filter "name=dokploy-postgres" --filter "status=running" -q | head -n 1`,
+			);
+
+			if (!postgresContainer) {
+				throw new Error("Dokploy Postgres container not found");
+			}
+
+			const postgresContainerId = postgresContainer.trim();
+
+			// Drop and recreate database
+			emit("Disconnecting all users from database...");
+			await execAsync(
+				`docker exec ${postgresContainerId} psql -U dokploy postgres -c "SELECT pg_terminate_backend(pg_stat_activity.pid) FROM pg_stat_activity WHERE pg_stat_activity.datname = 'dokploy' AND pid <> pg_backend_pid();"`,
+			);
+
+			emit("Dropping existing database...");
+			await execAsync(
+				`docker exec ${postgresContainerId} psql -U dokploy postgres -c "DROP DATABASE IF EXISTS dokploy;"`,
+			);
+
+			emit("Creating fresh database...");
+			await execAsync(
+				`docker exec ${postgresContainerId} psql -U dokploy postgres -c "CREATE DATABASE dokploy;"`,
+			);
+
+			// Copy the backup file into the container
+			emit("Copying backup file into container...");
+			await execAsync(
+				`docker cp ${tempDir}/database.sql ${postgresContainerId}:/tmp/database.sql`,
+			);
+
+			// Verify file in container
+			emit("Verifying file in container...");
+			await execAsync(
+				`docker exec ${postgresContainerId} ls -l /tmp/database.sql`,
+			);
+
+			// Restore from the copied file
+			emit("Running database restore...");
+			await execAsync(
+				`docker exec ${postgresContainerId} pg_restore -v -U dokploy -d dokploy /tmp/database.sql`,
+			);
+
+			// Cleanup the temporary file in the container
+			emit("Cleaning up container temp file...");
+			await execAsync(
+				`docker exec ${postgresContainerId} rm /tmp/database.sql`,
+			);
+
+			emit("Restore completed successfully!");
+		} finally {
+			// Cleanup
+			emit("Cleaning up temporary files...");
+			await execAsync(`rm -rf ${tempDir}`);
+		}
+	} catch (error) {
+		console.error(error);
+		emit(
+			`Error: ${
+				error instanceof Error
+					? error.message
+					: "Error restoring web server backup"
+			}`,
+		);
+		throw error;
+	}
+};

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

@@ -0,0 +1,28 @@
+import { schedules } from "@dokploy/server/db/schema";
+import { eq } from "drizzle-orm";
+import { db } from "../../db/index";
+import { scheduleJob } from "./utils";
+
+export const initSchedules = async () => {
+	try {
+		const schedulesResult = await db.query.schedules.findMany({
+			where: eq(schedules.enabled, true),
+			with: {
+				server: true,
+				application: true,
+				compose: true,
+				user: true,
+			},
+		});
+
+		console.log(`Initializing ${schedulesResult.length} schedules`);
+		for (const schedule of schedulesResult) {
+			scheduleJob(schedule);
+			console.log(
+				`Initialized schedule: ${schedule.name} ${schedule.scheduleType} ✅`,
+			);
+		}
+	} catch (error) {
+		console.log(`Error initializing schedules: ${error}`);
+	}
+};

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

@@ -0,0 +1,168 @@
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { paths } from "@dokploy/server/constants";
+import type { Schedule } from "@dokploy/server/db/schema/schedule";
+import {
+	createDeploymentSchedule,
+	updateDeployment,
+} from "@dokploy/server/services/deployment";
+import { updateDeploymentStatus } from "@dokploy/server/services/deployment";
+import { findScheduleById } from "@dokploy/server/services/schedule";
+import { scheduleJob as scheduleJobNode, scheduledJobs } from "node-schedule";
+import { getComposeContainer, getServiceContainer } from "../docker/utils";
+import { execAsyncRemote } from "../process/execAsync";
+import { spawnAsync } from "../process/spawnAsync";
+
+export const scheduleJob = (schedule: Schedule) => {
+	const { cronExpression, scheduleId } = schedule;
+
+	scheduleJobNode(scheduleId, cronExpression, async () => {
+		await runCommand(scheduleId);
+	});
+};
+
+export const removeScheduleJob = (scheduleId: string) => {
+	const currentJob = scheduledJobs[scheduleId];
+	currentJob?.cancel();
+};
+
+export const runCommand = async (scheduleId: string) => {
+	const {
+		application,
+		command,
+		shellType,
+		scheduleType,
+		compose,
+		serviceName,
+		appName,
+		serverId,
+	} = await findScheduleById(scheduleId);
+
+	const deployment = await createDeploymentSchedule({
+		scheduleId,
+		title: "Schedule",
+		description: "Schedule",
+	});
+
+	if (scheduleType === "application" || scheduleType === "compose") {
+		let containerId = "";
+		let serverId = "";
+		if (scheduleType === "application" && application) {
+			const container = await getServiceContainer(
+				application.appName,
+				application.serverId,
+			);
+			containerId = container?.Id || "";
+			serverId = application.serverId || "";
+		}
+		if (scheduleType === "compose" && compose) {
+			const container = await getComposeContainer(compose, serviceName || "");
+			containerId = container?.Id || "";
+			serverId = compose.serverId || "";
+		}
+
+		if (serverId) {
+			try {
+				await execAsyncRemote(
+					serverId,
+					`
+					set -e
+					echo "Running command: docker exec ${containerId} ${shellType} -c '${command}'" >> ${deployment.logPath};
+					docker exec ${containerId} ${shellType} -c '${command}' >> ${deployment.logPath} 2>> ${deployment.logPath} || { 
+						echo "❌ Command failed" >> ${deployment.logPath};
+						exit 1;
+					}
+					echo "✅ Command executed successfully" >> ${deployment.logPath};
+					`,
+				);
+			} catch (error) {
+				await updateDeploymentStatus(deployment.deploymentId, "error");
+				throw error;
+			}
+		} else {
+			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+
+			try {
+				writeStream.write(
+					`docker exec ${containerId} ${shellType} -c ${command}\n`,
+				);
+				await spawnAsync(
+					"docker",
+					["exec", containerId, shellType, "-c", command],
+					(data) => {
+						if (writeStream.writable) {
+							writeStream.write(data);
+						}
+					},
+				);
+
+				writeStream.write("✅ Command executed successfully\n");
+			} catch (error) {
+				writeStream.write("❌ Command failed\n");
+				writeStream.write(
+					error instanceof Error ? error.message : "Unknown error",
+				);
+				writeStream.end();
+				await updateDeploymentStatus(deployment.deploymentId, "error");
+				throw error;
+			}
+		}
+	} else if (scheduleType === "dokploy-server") {
+		try {
+			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+			const { SCHEDULES_PATH } = paths();
+			const fullPath = path.join(SCHEDULES_PATH, appName || "");
+
+			await spawnAsync(
+				"bash",
+				["-c", "./script.sh"],
+				async (data) => {
+					if (writeStream.writable) {
+						// we need to extract the PID and Schedule ID from the data
+						const pid = data?.match(/PID: (\d+)/)?.[1];
+
+						if (pid) {
+							await updateDeployment(deployment.deploymentId, {
+								pid,
+							});
+						}
+						writeStream.write(data);
+					}
+				},
+				{
+					cwd: fullPath,
+				},
+			);
+		} catch (error) {
+			await updateDeploymentStatus(deployment.deploymentId, "error");
+			throw error;
+		}
+	} else if (scheduleType === "server") {
+		try {
+			const { SCHEDULES_PATH } = paths(true);
+			const fullPath = path.join(SCHEDULES_PATH, appName || "");
+			const command = `
+				set -e
+				echo "Running script" >> ${deployment.logPath};
+				bash -c ${fullPath}/script.sh 2>&1 | tee -a ${deployment.logPath} || { 
+					echo "❌ Command failed" >> ${deployment.logPath};
+					exit 1;
+				  }
+				echo "✅ Command executed successfully" >> ${deployment.logPath};
+			`;
+			await execAsyncRemote(serverId, command, async (data) => {
+				// we need to extract the PID and Schedule ID from the data
+				const pid = data?.match(/PID: (\d+)/)?.[1];
+				if (pid) {
+					await updateDeployment(deployment.deploymentId, {
+						pid,
+					});
+				}
+			});
+		} catch (error) {
+			await updateDeploymentStatus(deployment.deploymentId, "error");
+			throw error;
+		}
+	}
+	await updateDeploymentStatus(deployment.deploymentId, "done");
+};

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

@@ -1,5 +1,7 @@
 import fs, { writeFileSync } from "node:fs";
+import { createReadStream } from "node:fs";
 import path from "node:path";
+import { createInterface } from "node:readline";
 import { paths } from "@dokploy/server/constants";
 import type { Domain } from "@dokploy/server/services/domain";
 import { dump, load } from "js-yaml";
@@ -67,7 +69,7 @@ export const removeTraefikConfig = async (
 		if (fs.existsSync(configPath)) {
 			await fs.promises.unlink(configPath);
 		}
-	} catch (error) {}
+	} catch {}
 };
 
 export const removeTraefikConfigRemote = async (
@@ -78,7 +80,7 @@ export const removeTraefikConfigRemote = async (
 		const { DYNAMIC_TRAEFIK_PATH } = paths(true);
 		const configPath = path.join(DYNAMIC_TRAEFIK_PATH, `${appName}.yml`);
 		await execAsyncRemote(serverId, `rm ${configPath}`);
-	} catch (error) {}
+	} catch {}
 };
 
 export const loadOrCreateConfig = (appName: string): FileConfig => {
@@ -110,7 +112,7 @@ export const loadOrCreateConfigRemote = async (
 			http: { routers: {}, services: {} },
 		};
 		return parsedConfig;
-	} catch (err) {
+	} catch {
 		return fileConfig;
 	}
 };
@@ -132,17 +134,50 @@ export const readRemoteConfig = async (serverId: string, appName: string) => {
 		const { stdout } = await execAsyncRemote(serverId, `cat ${configPath}`);
 		if (!stdout) return null;
 		return stdout;
-	} catch (err) {
+	} catch {
 		return null;
 	}
 };
 
-export const readMonitoringConfig = () => {
+export const readMonitoringConfig = async (readAll = false) => {
 	const { DYNAMIC_TRAEFIK_PATH } = paths();
 	const configPath = path.join(DYNAMIC_TRAEFIK_PATH, "access.log");
 	if (fs.existsSync(configPath)) {
-		const yamlStr = fs.readFileSync(configPath, "utf8");
-		return yamlStr;
+		if (!readAll) {
+			// Read first 500 lines using streams
+			let content = "";
+			let validCount = 0;
+
+			const fileStream = createReadStream(configPath, { encoding: "utf8" });
+			const readline = createInterface({
+				input: fileStream,
+				crlfDelay: Number.POSITIVE_INFINITY,
+			});
+
+			for await (const line of readline) {
+				try {
+					const trimmed = line.trim();
+					if (
+						trimmed !== "" &&
+						trimmed.startsWith("{") &&
+						trimmed.endsWith("}")
+					) {
+						const log = JSON.parse(trimmed);
+						if (log.ServiceName !== "dokploy-service-app@file") {
+							content += `${line}\n`;
+							validCount++;
+							if (validCount >= 500) {
+								break;
+							}
+						}
+					}
+				} catch {
+					// Ignore invalid JSON
+				}
+			}
+			return content;
+		}
+		return fs.readFileSync(configPath, "utf8");
 	}
 	return null;
 };
@@ -202,7 +237,6 @@ export const writeTraefikConfigInPath = async (
 		} else {
 			fs.writeFileSync(configPath, traefikConfig, "utf8");
 		}
-		fs.writeFileSync(configPath, traefikConfig, "utf8");
 	} catch (e) {
 		console.error("Error saving the YAML config file:", e);
 	}

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

@@ -10,6 +10,7 @@ import {
 	writeTraefikConfigRemote,
 } from "./application";
 import type { FileConfig, HttpRouter } from "./file-types";
+import { createPathMiddlewares, removePathMiddlewares } from "./middleware";
 
 export const manageDomain = async (app: ApplicationNested, domain: Domain) => {
 	const { appName } = app;
@@ -46,6 +47,8 @@ export const manageDomain = async (app: ApplicationNested, domain: Domain) => {
 
 	config.http.services[serviceName] = createServiceConfig(appName, domain);
 
+	await createPathMiddlewares(app, domain);
+
 	if (app.serverId) {
 		await writeTraefikConfigRemote(config, appName, app.serverId);
 	} else {
@@ -80,6 +83,8 @@ export const removeDomain = async (
 		delete config.http.services[serviceKey];
 	}
 
+	await removePathMiddlewares(application, uniqueKey);
+
 	// verify if is the last router if so we delete the router
 	if (
 		config?.http?.routers &&
@@ -107,7 +112,8 @@ export const createRouterConfig = async (
 	const { appName, redirects, security } = app;
 	const { certificateType } = domain;
 
-	const { host, path, https, uniqueConfigKey } = domain;
+	const { host, path, https, uniqueConfigKey, internalPath, stripPath } =
+		domain;
 	const routerConfig: HttpRouter = {
 		rule: `Host(\`${host}\`)${path !== null && path !== "/" ? ` && PathPrefix(\`${path}\`)` : ""}`,
 		service: `${appName}-service-${uniqueConfigKey}`,
@@ -115,6 +121,17 @@ export const createRouterConfig = async (
 		entryPoints: [entryPoint],
 	};
 
+	// Add path rewriting middleware if needed
+	if (internalPath && internalPath !== "/" && internalPath !== path) {
+		const pathMiddleware = `addprefix-${appName}-${uniqueConfigKey}`;
+		routerConfig.middlewares?.push(pathMiddleware);
+	}
+
+	if (stripPath && path && path !== "/") {
+		const stripMiddleware = `stripprefix-${appName}-${uniqueConfigKey}`;
+		routerConfig.middlewares?.push(stripMiddleware);
+	}
+
 	if (entryPoint === "web" && https) {
 		routerConfig.middlewares = ["redirect-to-https"];
 	}
@@ -122,13 +139,25 @@ export const createRouterConfig = async (
 	if ((entryPoint === "websecure" && https) || !https) {
 		// redirects
 		for (const redirect of redirects) {
-			const middlewareName = `redirect-${appName}-${redirect.uniqueConfigKey}`;
+			let middlewareName = `redirect-${appName}-${redirect.uniqueConfigKey}`;
+			if (domain.domainType === "preview") {
+				middlewareName = `redirect-${appName.replace(
+					/^preview-(.+)-[^-]+$/,
+					"$1",
+				)}-${redirect.uniqueConfigKey}`;
+			}
 			routerConfig.middlewares?.push(middlewareName);
 		}
 
 		// security
 		if (security.length > 0) {
-			const middlewareName = `auth-${appName}`;
+			let middlewareName = `auth-${appName}`;
+			if (domain.domainType === "preview") {
+				middlewareName = `auth-${appName.replace(
+					/^preview-(.+)-[^-]+$/,
+					"$1",
+				)}`;
+			}
 			routerConfig.middlewares?.push(middlewareName);
 		}
 	}
@@ -136,6 +165,8 @@ export const createRouterConfig = async (
 	if (entryPoint === "websecure") {
 		if (certificateType === "letsencrypt") {
 			routerConfig.tls = { certResolver: "letsencrypt" };
+		} else if (certificateType === "custom" && domain.customCertResolver) {
+			routerConfig.tls = { certResolver: domain.customCertResolver };
 		} else if (certificateType === "none") {
 			routerConfig.tls = undefined;
 		}

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
+import type { Domain } from "@dokploy/server/services/domain";
 import { dump, load } from "js-yaml";
 import type { ApplicationNested } from "../builders";
 import { execAsyncRemote } from "../process/execAsync";
@@ -95,7 +96,7 @@ export const loadRemoteMiddlewares = async (serverId: string) => {
 		}
 		const config = load(stdout) as FileConfig;
 		return config;
-	} catch (error) {
+	} catch (_) {
 		throw new Error(`File not found: ${configPath}`);
 	}
 };
@@ -105,3 +106,97 @@ export const writeMiddleware = <T>(config: T) => {
 	const newYamlContent = dump(config);
 	writeFileSync(configPath, newYamlContent, "utf8");
 };
+
+export const createPathMiddlewares = async (
+	app: ApplicationNested,
+	domain: Domain,
+) => {
+	let config: FileConfig;
+
+	if (app.serverId) {
+		try {
+			config = await loadRemoteMiddlewares(app.serverId);
+		} catch {
+			config = { http: { middlewares: {} } };
+		}
+	} else {
+		try {
+			config = loadMiddlewares<FileConfig>();
+		} catch {
+			config = { http: { middlewares: {} } };
+		}
+	}
+
+	const { appName } = app;
+	const { uniqueConfigKey, internalPath, stripPath, path } = domain;
+
+	if (!config.http) {
+		config.http = { middlewares: {} };
+	}
+	if (!config.http.middlewares) {
+		config.http.middlewares = {};
+	}
+
+	// Add internal path prefix middleware
+	if (internalPath && internalPath !== "/" && internalPath !== path) {
+		const middlewareName = `addprefix-${appName}-${uniqueConfigKey}`;
+		config.http.middlewares[middlewareName] = {
+			addPrefix: {
+				prefix: internalPath,
+			},
+		};
+	}
+
+	// Strip external path middleware if needed
+	if (stripPath && path && path !== "/") {
+		const middlewareName = `stripprefix-${appName}-${uniqueConfigKey}`;
+		config.http.middlewares[middlewareName] = {
+			stripPrefix: {
+				prefixes: [path],
+			},
+		};
+	}
+
+	if (app.serverId) {
+		await writeTraefikConfigRemote(config, "middlewares", app.serverId);
+	} else {
+		writeMiddleware(config);
+	}
+};
+
+export const removePathMiddlewares = async (
+	app: ApplicationNested,
+	uniqueConfigKey: number,
+) => {
+	let config: FileConfig;
+
+	if (app.serverId) {
+		try {
+			config = await loadRemoteMiddlewares(app.serverId);
+		} catch {
+			return;
+		}
+	} else {
+		try {
+			config = loadMiddlewares<FileConfig>();
+		} catch {
+			return;
+		}
+	}
+
+	const { appName } = app;
+
+	if (config.http?.middlewares) {
+		const addPrefixMiddleware = `addprefix-${appName}-${uniqueConfigKey}`;
+		const stripPrefixMiddleware = `stripprefix-${appName}-${uniqueConfigKey}`;
+
+		delete config.http.middlewares[addPrefixMiddleware];
+		delete config.http.middlewares[stripPrefixMiddleware];
+	}
+
+	if (app.serverId) {
+		await writeTraefikConfigRemote(config, "middlewares", app.serverId);
+	} else {
+		writeMiddleware(config);
+	}
+};

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

@@ -1,42 +1,76 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { Admin } from "@dokploy/server/services/admin";
+import type { User } from "@dokploy/server/services/user";
 import { dump, load } from "js-yaml";
-import { loadOrCreateConfig, writeTraefikConfig } from "./application";
+import {
+	loadOrCreateConfig,
+	removeTraefikConfig,
+	writeTraefikConfig,
+} from "./application";
 import type { FileConfig } from "./file-types";
 import type { MainTraefikConfig } from "./types";
 
 export const updateServerTraefik = (
-	admin: Admin | null,
+	user: User | null,
 	newHost: string | null,
 ) => {
+	const { https, certificateType } = user || {};
 	const appName = "dokploy";
 	const config: FileConfig = loadOrCreateConfig(appName);
 
 	config.http = config.http || { routers: {}, services: {} };
 	config.http.routers = config.http.routers || {};
+	config.http.services = config.http.services || {};
 
-	const currentRouterConfig = config.http.routers[`${appName}-router-app`];
+	const currentRouterConfig = config.http.routers[`${appName}-router-app`] || {
+		rule: `Host(\`${newHost}\`)`,
+		service: `${appName}-service-app`,
+		entryPoints: ["web"],
+	};
+	config.http.routers[`${appName}-router-app`] = currentRouterConfig;
 
-	if (currentRouterConfig && newHost) {
-		currentRouterConfig.rule = `Host(\`${newHost}\`)`;
+	config.http.services = {
+		...config.http.services,
+		[`${appName}-service-app`]: {
+			loadBalancer: {
+				servers: [
+					{
+						url: `http://dokploy:${process.env.PORT || 3000}`,
+					},
+				],
+				passHostHeader: true,
+			},
+		},
+	};
 
-		if (admin?.certificateType === "letsencrypt") {
+	if (https) {
+		currentRouterConfig.middlewares = ["redirect-to-https"];
+
+		if (certificateType === "letsencrypt") {
 			config.http.routers[`${appName}-router-app-secure`] = {
-				...currentRouterConfig,
+				rule: `Host(\`${newHost}\`)`,
+				service: `${appName}-service-app`,
 				entryPoints: ["websecure"],
 				tls: { certResolver: "letsencrypt" },
 			};
-
-			currentRouterConfig.middlewares = ["redirect-to-https"];
 		} else {
-			delete config.http.routers[`${appName}-router-app-secure`];
-			currentRouterConfig.middlewares = [];
+			config.http.routers[`${appName}-router-app-secure`] = {
+				rule: `Host(\`${newHost}\`)`,
+				service: `${appName}-service-app`,
+				entryPoints: ["websecure"],
+			};
 		}
+	} else {
+		delete config.http.routers[`${appName}-router-app-secure`];
+		currentRouterConfig.middlewares = [];
 	}
 
-	writeTraefikConfig(config, appName);
+	if (newHost) {
+		writeTraefikConfig(config, appName);
+	} else {
+		removeTraefikConfig(appName);
+	}
 };
 
 export const updateLetsEncryptEmail = (newEmail: string | null) => {

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

@@ -0,0 +1,93 @@
+import path from "node:path";
+import { paths } from "@dokploy/server/constants";
+import { findComposeById } from "@dokploy/server/services/compose";
+import type { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
+import { getS3Credentials, normalizeS3Path } from "../backups/utils";
+
+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 destination = volumeBackup.destination;
+	const backupFileName = `${volumeName}-${new Date().toISOString()}.tar`;
+	const bucketDestination = `${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 = `
+	set -e
+	echo "Volume name: ${volumeName}"
+	echo "Backup file name: ${backupFileName}"
+	echo "Turning off volume backup: ${turnOff ? "Yes" : "No"}"
+	echo "Starting volume backup" 
+	echo "Dir: ${volumeBackupPath}"
+    docker run --rm \
+  -v ${volumeName}:/volume_data \
+  -v ${volumeBackupPath}:/backup \
+  ubuntu \
+  bash -c "cd /volume_data && tar cvf /backup/${backupFileName} ."
+  echo "Volume backup done ✅"
+  echo "Starting upload to S3..."
+  ${rcloneCommand}
+  echo "Upload to S3 done ✅"
+  echo "Cleaning up local backup file..."
+  rm "${volumeBackupPath}/${backupFileName}"
+  echo "Local backup file cleaned up ✅"
+  `;
+
+	if (!turnOff) {
+		return baseCommand;
+	}
+
+	if (serviceType === "application") {
+		return `
+		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}
+		echo "Starting application to $ACTUAL_REPLICAS replicas"
+        docker service scale ${volumeBackup.application?.appName}=$ACTUAL_REPLICAS
+  `;
+	}
+	if (serviceType === "compose") {
+		const compose = await findComposeById(
+			volumeBackup.compose?.composeId || "",
+		);
+		let stopCommand = "";
+		let startCommand = "";
+
+		if (compose.composeType === "stack") {
+			stopCommand = `
+			echo "Stopping compose to 0 replicas"
+			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`;
+			startCommand = `
+			echo "Starting compose to $ACTUAL_REPLICAS replicas"
+			docker service scale ${compose.appName}_${volumeBackup.serviceName}=$ACTUAL_REPLICAS`;
+		} 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 `
+        ${stopCommand}
+        ${baseCommand}
+        ${startCommand}
+  `;
+	}
+};

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

@@ -0,0 +1,30 @@
+export * from "./backup";
+export * from "./restore";
+export * from "./utils";
+import { volumeBackups } from "@dokploy/server/db/schema";
+import { eq } from "drizzle-orm";
+import { db } from "../../db/index";
+import { scheduleVolumeBackup } from "./utils";
+
+export const initVolumeBackupsCronJobs = async () => {
+	console.log("Setting up volume backups cron jobs....");
+	try {
+		const volumeBackupsResult = await db.query.volumeBackups.findMany({
+			where: eq(volumeBackups.enabled, true),
+			with: {
+				application: true,
+				compose: true,
+			},
+		});
+
+		console.log(`Initializing ${volumeBackupsResult.length} volume backups`);
+		for (const volumeBackup of volumeBackupsResult) {
+			scheduleVolumeBackup(volumeBackup.volumeBackupId);
+			console.log(
+				`Initialized volume backup: ${volumeBackup.name} ${volumeBackup.serviceType} ✅`,
+			);
+		}
+	} catch (error) {
+		console.log(`Error initializing volume backups: ${error}`);
+	}
+};

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

@@ -0,0 +1,126 @@
+import path from "node:path";
+import {
+	findApplicationById,
+	findComposeById,
+	findDestinationById,
+	getS3Credentials,
+	paths,
+} from "../..";
+
+export const restoreVolume = async (
+	id: string,
+	destinationId: string,
+	volumeName: string,
+	backupFileName: string,
+	serverId: string,
+	serviceType: "application" | "compose",
+) => {
+	const destination = await findDestinationById(destinationId);
+	const { VOLUME_BACKUPS_PATH } = paths(!!serverId);
+	const volumeBackupPath = path.join(VOLUME_BACKUPS_PATH, volumeName);
+	const rcloneFlags = getS3Credentials(destination);
+	const bucketPath = `:s3:${destination.bucket}`;
+	const backupPath = `${bucketPath}/${backupFileName}`;
+
+	// Command to download backup file from S3
+	const downloadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${backupPath}" "${volumeBackupPath}/${backupFileName}"`;
+
+	// Base restore command that creates the volume and restores data
+	const baseRestoreCommand = `
+	set -e
+	echo "Volume name: ${volumeName}"
+	echo "Backup file name: ${backupFileName}"
+	echo "Volume backup path: ${volumeBackupPath}"
+	echo "Downloading backup from S3..."
+	mkdir -p ${volumeBackupPath}
+	${downloadCommand}
+	echo "Download completed ✅"
+	echo "Creating new volume and restoring data..."
+	docker run --rm \
+		-v ${volumeName}:/volume_data \
+		-v ${volumeBackupPath}:/backup \
+		ubuntu \
+		bash -c "cd /volume_data && tar xvf /backup/${backupFileName} ."
+	echo "Volume restore completed ✅"
+	`;
+
+	// Function to check if volume exists and get containers using it
+	const checkVolumeCommand = `
+	# Check if volume exists
+	VOLUME_EXISTS=$(docker volume ls -q --filter name="^${volumeName}$" | wc -l)
+	echo "Volume exists: $VOLUME_EXISTS"
+	
+	if [ "$VOLUME_EXISTS" = "0" ]; then
+		echo "Volume doesn't exist, proceeding with direct restore"
+		${baseRestoreCommand}
+	else
+		echo "Volume exists, checking for containers using it (including stopped ones)..."
+		
+		# Get ALL containers (running and stopped) using this volume - much simpler with native filter!
+		CONTAINERS_USING_VOLUME=$(docker ps -a --filter "volume=${volumeName}" --format "{{.ID}}|{{.Names}}|{{.State}}|{{.Labels}}")
+		
+		if [ -z "$CONTAINERS_USING_VOLUME" ]; then
+			echo "Volume exists but no containers are using it"
+			echo "Removing existing volume and proceeding with restore"
+			docker volume rm ${volumeName} --force
+			${baseRestoreCommand}
+		else
+			echo ""
+			echo "⚠️  WARNING: Cannot restore volume as it is currently in use!"
+			echo ""
+			echo "📋 The following containers are using volume '${volumeName}':"
+			echo ""
+			
+			echo "$CONTAINERS_USING_VOLUME" | while IFS='|' read container_id container_name container_state labels; do
+				echo "   🐳 Container: $container_name ($container_id)"
+				echo "      Status: $container_state"
+				
+				# Determine container type
+				if echo "$labels" | grep -q "com.docker.swarm.service.name="; then
+					SERVICE_NAME=$(echo "$labels" | grep -o "com.docker.swarm.service.name=[^,]*" | cut -d'=' -f2)
+					echo "      Type: Docker Swarm Service ($SERVICE_NAME)"
+				elif echo "$labels" | grep -q "com.docker.compose.project="; then
+					PROJECT_NAME=$(echo "$labels" | grep -o "com.docker.compose.project=[^,]*" | cut -d'=' -f2)
+					echo "      Type: Docker Compose ($PROJECT_NAME)"
+				else
+					echo "      Type: Regular Container"
+				fi
+				echo ""
+			done
+			
+			echo ""
+			echo "🔧 To restore this volume, please:"
+			echo "   1. Stop all containers/services using this volume"
+			echo "   2. Remove the existing volume: docker volume rm ${volumeName}"
+			echo "   3. Run the restore operation again"
+			echo ""
+			echo "❌ Volume restore aborted - volume is in use"
+			
+			exit 1
+		fi
+	fi
+	`;
+
+	if (serviceType === "application") {
+		const application = await findApplicationById(id);
+		return `
+		echo "=== VOLUME RESTORE FOR APPLICATION ==="
+		echo "Application: ${application.appName}"
+		${checkVolumeCommand}
+		`;
+	}
+
+	if (serviceType === "compose") {
+		const compose = await findComposeById(id);
+
+		return `
+		echo "=== VOLUME RESTORE FOR COMPOSE ==="
+		echo "Compose: ${compose.appName}"
+		echo "Compose Type: ${compose.composeType}"
+		${checkVolumeCommand}
+		`;
+	}
+
+	// Fallback for unknown service types
+	return checkVolumeCommand;
+};

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

@@ -0,0 +1,48 @@
+import { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
+import { scheduleJob, scheduledJobs } from "node-schedule";
+import {
+	createDeploymentVolumeBackup,
+	execAsync,
+	execAsyncRemote,
+	updateDeploymentStatus,
+} from "../..";
+import { backupVolume } from "./backup";
+
+export const scheduleVolumeBackup = async (volumeBackupId: string) => {
+	const volumeBackup = await findVolumeBackupById(volumeBackupId);
+	scheduleJob(volumeBackupId, volumeBackup.cronExpression, async () => {
+		await runVolumeBackup(volumeBackupId);
+	});
+};
+
+export const removeVolumeBackupJob = async (volumeBackupId: string) => {
+	const currentJob = scheduledJobs[volumeBackupId];
+	currentJob?.cancel();
+};
+
+export const runVolumeBackup = async (volumeBackupId: string) => {
+	const volumeBackup = await findVolumeBackupById(volumeBackupId);
+	const serverId =
+		volumeBackup.application?.serverId || volumeBackup.compose?.serverId;
+	const deployment = await createDeploymentVolumeBackup({
+		volumeBackupId: volumeBackup.volumeBackupId,
+		title: "Volume Backup",
+		description: "Volume Backup",
+	});
+
+	try {
+		const command = await backupVolume(volumeBackup);
+
+		const commandWithLog = `(${command}) >> ${deployment.logPath} 2>&1`;
+		if (serverId) {
+			await execAsyncRemote(serverId, commandWithLog);
+		} else {
+			await execAsync(commandWithLog);
+		}
+
+		await updateDeploymentStatus(deployment.deploymentId, "done");
+	} catch (error) {
+		await updateDeploymentStatus(deployment.deploymentId, "error");
+		console.error(error);
+	}
+};

packages/server/src/utils/watch-paths/should-deploy.ts

@@ -0,0 +1,9 @@
+import micromatch from "micromatch";
+
+export const shouldDeploy = (
+	watchPaths: string[] | null,
+	modifiedFiles: string[],
+): boolean => {
+	if (!watchPaths || watchPaths?.length === 0) return true;
+	return micromatch.some(modifiedFiles, watchPaths);
+};