Merge pull request #1645 from Dokploy/canary

🚀 Release v0.21.4

apps/dokploy/__test__/traefik/server/update-server-config.test.ts

@@ -14,6 +14,7 @@ import {
 import { beforeEach, expect, test, vi } from "vitest";
 
 const baseAdmin: User = {
+	https: false,
 	enablePaidFeatures: false,
 	metricsConfig: {
 		containers: {
@@ -73,7 +74,6 @@ beforeEach(() => {
 
 test("Should read the configuration file", () => {
 	const config: FileConfig = loadOrCreateConfig("dokploy");
-
 	expect(config.http?.routers?.["dokploy-router-app"]?.service).toBe(
 		"dokploy-service-app",
 	);
@@ -83,6 +83,7 @@ test("Should apply redirect-to-https", () => {
 	updateServerTraefik(
 		{
 			...baseAdmin,
+			https: true,
 			certificateType: "letsencrypt",
 		},
 		"example.com",

apps/dokploy/__test__/utils/backups.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "vitest";
+import { normalizeS3Path } from "@dokploy/server/utils/backups/utils";
+
+describe("normalizeS3Path", () => {
+	test("should handle empty and whitespace-only prefix", () => {
+		expect(normalizeS3Path("")).toBe("");
+		expect(normalizeS3Path("/")).toBe("");
+		expect(normalizeS3Path("  ")).toBe("");
+		expect(normalizeS3Path("\t")).toBe("");
+		expect(normalizeS3Path("\n")).toBe("");
+		expect(normalizeS3Path(" \n \t ")).toBe("");
+	});
+
+	test("should trim whitespace from prefix", () => {
+		expect(normalizeS3Path(" prefix")).toBe("prefix/");
+		expect(normalizeS3Path("prefix ")).toBe("prefix/");
+		expect(normalizeS3Path(" prefix ")).toBe("prefix/");
+		expect(normalizeS3Path("\tprefix\t")).toBe("prefix/");
+		expect(normalizeS3Path(" prefix/nested ")).toBe("prefix/nested/");
+	});
+
+	test("should remove leading slashes", () => {
+		expect(normalizeS3Path("/prefix")).toBe("prefix/");
+		expect(normalizeS3Path("///prefix")).toBe("prefix/");
+	});
+
+	test("should remove trailing slashes", () => {
+		expect(normalizeS3Path("prefix/")).toBe("prefix/");
+		expect(normalizeS3Path("prefix///")).toBe("prefix/");
+	});
+
+	test("should remove both leading and trailing slashes", () => {
+		expect(normalizeS3Path("/prefix/")).toBe("prefix/");
+		expect(normalizeS3Path("///prefix///")).toBe("prefix/");
+	});
+
+	test("should handle nested paths", () => {
+		expect(normalizeS3Path("prefix/nested")).toBe("prefix/nested/");
+		expect(normalizeS3Path("/prefix/nested/")).toBe("prefix/nested/");
+		expect(normalizeS3Path("///prefix/nested///")).toBe("prefix/nested/");
+	});
+
+	test("should preserve middle slashes", () => {
+		expect(normalizeS3Path("prefix/nested/deep")).toBe("prefix/nested/deep/");
+		expect(normalizeS3Path("/prefix/nested/deep/")).toBe("prefix/nested/deep/");
+	});
+
+	test("should handle special characters", () => {
+		expect(normalizeS3Path("prefix-with-dashes")).toBe("prefix-with-dashes/");
+		expect(normalizeS3Path("prefix_with_underscores")).toBe(
+			"prefix_with_underscores/",
+		);
+		expect(normalizeS3Path("prefix.with.dots")).toBe("prefix.with.dots/");
+	});
+
+	test("should handle the cases from the bug report", () => {
+		expect(normalizeS3Path("instance-backups/")).toBe("instance-backups/");
+		expect(normalizeS3Path("/instance-backups/")).toBe("instance-backups/");
+		expect(normalizeS3Path("instance-backups")).toBe("instance-backups/");
+	});
+});

apps/dokploy/components/dashboard/projects/handle-project.tsx

@@ -31,9 +31,14 @@ import { toast } from "sonner";
 import { z } from "zod";
 
 const AddProjectSchema = z.object({
-	name: z.string().min(1, {
-		message: "Name is required",
-	}),
+	name: z
+		.string()
+		.min(1, {
+			message: "Name is required",
+		})
+		.regex(/^[a-zA-Z]/, {
+			message: "Project name cannot start with a number",
+		}),
 	description: z.string().optional(),
 });
 
@@ -97,18 +102,6 @@ export const HandleProject = ({ projectId }: Props) => {
 				);
 			});
 	};
-	// useEffect(() => {
-	// 	const getUsers = async () => {
-	// 		const users = await authClient.admin.listUsers({
-	// 			query: {
-	// 				limit: 100,
-	// 			},
-	// 		});
-	// 		console.log(users);
-	// 	};
-
-	// 	getUsers();
-	// });
 
 	return (
 		<Dialog open={isOpen} onOpenChange={setIsOpen}>

apps/dokploy/components/dashboard/projects/show.tsx

@@ -115,7 +115,7 @@ export const ShowProjects = () => {
 											</span>
 										</div>
 									)}
-									<div className="w-full grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-4 3xl:grid-cols-5 flex-wrap gap-5">
+									<div className="w-full grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4 3xl:grid-cols-5 flex-wrap gap-5">
 										{filteredProjects?.map((project) => {
 											const emptyServices =
 												project?.mariadb.length === 0 &&

apps/dokploy/components/dashboard/settings/web-domain.tsx

@@ -9,6 +9,7 @@ import {
 import {
 	Form,
 	FormControl,
+	FormDescription,
 	FormField,
 	FormItem,
 	FormLabel,
@@ -22,6 +23,7 @@ import {
 	SelectTrigger,
 	SelectValue,
 } from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
 import { api } from "@/utils/api";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { GlobeIcon } from "lucide-react";
@@ -33,11 +35,19 @@ import { z } from "zod";
 
 const addServerDomain = z
 	.object({
-		domain: z.string().min(1, { message: "URL is required" }),
+		domain: z.string(),
 		letsEncryptEmail: z.string(),
+		https: z.boolean().optional(),
 		certificateType: z.enum(["letsencrypt", "none", "custom"]),
 	})
 	.superRefine((data, ctx) => {
+		if (data.https && !data.certificateType) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["certificateType"],
+				message: "Required",
+			});
+		}
 		if (data.certificateType === "letsencrypt" && !data.letsEncryptEmail) {
 			ctx.addIssue({
 				code: z.ZodIssueCode.custom,
@@ -61,15 +71,18 @@ export const WebDomain = () => {
 			domain: "",
 			certificateType: "none",
 			letsEncryptEmail: "",
+			https: false,
 		},
 		resolver: zodResolver(addServerDomain),
 	});
+	const https = form.watch("https");
 	useEffect(() => {
 		if (data) {
 			form.reset({
 				domain: data?.user?.host || "",
 				certificateType: data?.user?.certificateType,
 				letsEncryptEmail: data?.user?.letsEncryptEmail || "",
+				https: data?.user?.https || false,
 			});
 		}
 	}, [form, form.reset, data]);
@@ -79,6 +92,7 @@ export const WebDomain = () => {
 			host: data.domain,
 			letsEncryptEmail: data.letsEncryptEmail,
 			certificateType: data.certificateType,
+			https: data.https,
 		})
 			.then(async () => {
 				await refetch();
@@ -155,44 +169,67 @@ export const WebDomain = () => {
 								/>
 								<FormField
 									control={form.control}
-									name="certificateType"
-									render={({ field }) => {
-										return (
-											<FormItem className="md:col-span-2">
-												<FormLabel>
-													{t("settings.server.domain.form.certificate.label")}
-												</FormLabel>
-												<Select
-													onValueChange={field.onChange}
-													value={field.value}
-												>
-													<FormControl>
-														<SelectTrigger>
-															<SelectValue
-																placeholder={t(
-																	"settings.server.domain.form.certificate.placeholder",
-																)}
-															/>
-														</SelectTrigger>
-													</FormControl>
-													<SelectContent>
-														<SelectItem value={"none"}>
-															{t(
-																"settings.server.domain.form.certificateOptions.none",
-															)}
-														</SelectItem>
-														<SelectItem value={"letsencrypt"}>
-															{t(
-																"settings.server.domain.form.certificateOptions.letsencrypt",
-															)}
-														</SelectItem>
-													</SelectContent>
-												</Select>
+									name="https"
+									render={({ field }) => (
+										<FormItem className="flex flex-row items-center justify-between p-3 mt-4 border rounded-lg shadow-sm w-full col-span-2">
+											<div className="space-y-0.5">
+												<FormLabel>HTTPS</FormLabel>
+												<FormDescription>
+													Automatically provision SSL Certificate.
+												</FormDescription>
 												<FormMessage />
-											</FormItem>
-										);
-									}}
+											</div>
+											<FormControl>
+												<Switch
+													checked={field.value}
+													onCheckedChange={field.onChange}
+												/>
+											</FormControl>
+										</FormItem>
+									)}
 								/>
+								{https && (
+									<FormField
+										control={form.control}
+										name="certificateType"
+										render={({ field }) => {
+											return (
+												<FormItem className="md:col-span-2">
+													<FormLabel>
+														{t("settings.server.domain.form.certificate.label")}
+													</FormLabel>
+													<Select
+														onValueChange={field.onChange}
+														value={field.value}
+													>
+														<FormControl>
+															<SelectTrigger>
+																<SelectValue
+																	placeholder={t(
+																		"settings.server.domain.form.certificate.placeholder",
+																	)}
+																/>
+															</SelectTrigger>
+														</FormControl>
+														<SelectContent>
+															<SelectItem value={"none"}>
+																{t(
+																	"settings.server.domain.form.certificateOptions.none",
+																)}
+															</SelectItem>
+															<SelectItem value={"letsencrypt"}>
+																{t(
+																	"settings.server.domain.form.certificateOptions.letsencrypt",
+																)}
+															</SelectItem>
+														</SelectContent>
+													</Select>
+													<FormMessage />
+												</FormItem>
+											);
+										}}
+									/>
+								)}
 
 								<div className="flex w-full justify-end col-span-2">
 									<Button isLoading={isLoading} type="submit">

apps/dokploy/components/layouts/user-nav.tsx

@@ -120,17 +120,6 @@ export const UserNav = () => {
 									Docker
 								</DropdownMenuItem>
 							)}
-
-							{data?.role === "owner" && (
-								<DropdownMenuItem
-									className="cursor-pointer"
-									onClick={() => {
-										router.push("/dashboard/settings");
-									}}
-								>
-									Settings
-								</DropdownMenuItem>
-							)}
 						</>
 					) : (
 						<>

apps/dokploy/drizzle/0084_thin_iron_lad.sql

@@ -0,0 +1 @@
+ALTER TABLE "user_temp" ADD COLUMN "https" boolean DEFAULT false NOT NULL;

apps/dokploy/drizzle/meta/_journal.json

@@ -589,6 +589,13 @@
       "when": 1743288371413,
       "tag": "0083_parallel_stranger",
       "breakpoints": true
+    },
+    {
+      "idx": 84,
+      "version": "7",
+      "when": 1743923992280,
+      "tag": "0084_thin_iron_lad",
+      "breakpoints": true
     }
   ]
 }

apps/dokploy/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dokploy",
-	"version": "v0.21.3",
+	"version": "v0.21.4",
 	"private": true,
 	"license": "Apache-2.0",
 	"type": "module",

apps/dokploy/pages/dashboard/project/[projectId].tsx

@@ -314,31 +314,43 @@ const Project = (
 	};
 
 	const applicationActions = {
+		start: api.application.start.useMutation(),
+		stop: api.application.stop.useMutation(),
 		move: api.application.move.useMutation(),
 		delete: api.application.delete.useMutation(),
 	};
 
 	const postgresActions = {
+		start: api.postgres.start.useMutation(),
+		stop: api.postgres.stop.useMutation(),
 		move: api.postgres.move.useMutation(),
 		delete: api.postgres.remove.useMutation(),
 	};
 
 	const mysqlActions = {
+		start: api.mysql.start.useMutation(),
+		stop: api.mysql.stop.useMutation(),
 		move: api.mysql.move.useMutation(),
 		delete: api.mysql.remove.useMutation(),
 	};
 
 	const mariadbActions = {
+		start: api.mariadb.start.useMutation(),
+		stop: api.mariadb.stop.useMutation(),
 		move: api.mariadb.move.useMutation(),
 		delete: api.mariadb.remove.useMutation(),
 	};
 
 	const redisActions = {
+		start: api.redis.start.useMutation(),
+		stop: api.redis.stop.useMutation(),
 		move: api.redis.move.useMutation(),
 		delete: api.redis.remove.useMutation(),
 	};
 
 	const mongoActions = {
+		start: api.mongo.start.useMutation(),
+		stop: api.mongo.stop.useMutation(),
 		move: api.mongo.move.useMutation(),
 		delete: api.mongo.remove.useMutation(),
 	};
@@ -348,7 +360,32 @@ const Project = (
 		setIsBulkActionLoading(true);
 		for (const serviceId of selectedServices) {
 			try {
-				await composeActions.start.mutateAsync({ composeId: serviceId });
+				const service = filteredServices.find((s) => s.id === serviceId);
+				if (!service) continue;
+
+				switch (service.type) {
+					case "application":
+						await applicationActions.start.mutateAsync({ applicationId: serviceId });
+						break;
+					case "compose":
+						await composeActions.start.mutateAsync({ composeId: serviceId });
+						break;
+					case "postgres":
+						await postgresActions.start.mutateAsync({ postgresId: serviceId });
+						break;
+					case "mysql":
+						await mysqlActions.start.mutateAsync({ mysqlId: serviceId });
+						break;
+					case "mariadb":
+						await mariadbActions.start.mutateAsync({ mariadbId: serviceId });
+						break;
+					case "redis":
+						await redisActions.start.mutateAsync({ redisId: serviceId });
+						break;
+					case "mongo":
+						await mongoActions.start.mutateAsync({ mongoId: serviceId });
+						break;
+				}
 				success++;
 			} catch (_error) {
 				toast.error(`Error starting service ${serviceId}`);
@@ -368,7 +405,32 @@ const Project = (
 		setIsBulkActionLoading(true);
 		for (const serviceId of selectedServices) {
 			try {
-				await composeActions.stop.mutateAsync({ composeId: serviceId });
+				const service = filteredServices.find((s) => s.id === serviceId);
+				if (!service) continue;
+
+				switch (service.type) {
+					case "application":
+						await applicationActions.stop.mutateAsync({ applicationId: serviceId });
+						break;
+					case "compose":
+						await composeActions.stop.mutateAsync({ composeId: serviceId });
+						break;
+					case "postgres":
+						await postgresActions.stop.mutateAsync({ postgresId: serviceId });
+						break;
+					case "mysql":
+						await mysqlActions.stop.mutateAsync({ mysqlId: serviceId });
+						break;
+					case "mariadb":
+						await mariadbActions.stop.mutateAsync({ mariadbId: serviceId });
+						break;
+					case "redis":
+						await redisActions.stop.mutateAsync({ redisId: serviceId });
+						break;
+					case "mongo":
+						await mongoActions.stop.mutateAsync({ mongoId: serviceId });
+						break;
+				}
 				success++;
 			} catch (_error) {
 				toast.error(`Error stopping service ${serviceId}`);

apps/dokploy/pages/dashboard/settings/index.tsx

@@ -1,219 +0,0 @@
-import { DashboardLayout } from "@/components/layouts/dashboard-layout";
-
-import { AlertBlock } from "@/components/shared/alert-block";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import { DialogFooter } from "@/components/ui/dialog";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-} from "@/components/ui/form";
-import { Switch } from "@/components/ui/switch";
-import { appRouter } from "@/server/api/root";
-import { api } from "@/utils/api";
-import { validateRequest } from "@dokploy/server";
-import { zodResolver } from "@hookform/resolvers/zod";
-import { createServerSideHelpers } from "@trpc/react-query/server";
-import { Settings } from "lucide-react";
-import type { GetServerSidePropsContext } from "next";
-import { type ReactElement, useEffect } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import superjson from "superjson";
-import { z } from "zod";
-
-const settings = z.object({
-	cleanCacheOnApplications: z.boolean(),
-	cleanCacheOnCompose: z.boolean(),
-	cleanCacheOnPreviews: z.boolean(),
-});
-
-type SettingsType = z.infer<typeof settings>;
-
-const Page = () => {
-	const { data, refetch } = api.user.get.useQuery();
-	const { mutateAsync, isLoading, isError, error } =
-		api.user.update.useMutation();
-	const form = useForm<SettingsType>({
-		defaultValues: {
-			cleanCacheOnApplications: false,
-			cleanCacheOnCompose: false,
-			cleanCacheOnPreviews: false,
-		},
-		resolver: zodResolver(settings),
-	});
-	useEffect(() => {
-		form.reset({
-			cleanCacheOnApplications: data?.user.cleanupCacheApplications || false,
-			cleanCacheOnCompose: data?.user.cleanupCacheOnCompose || false,
-			cleanCacheOnPreviews: data?.user.cleanupCacheOnPreviews || false,
-		});
-	}, [form, form.reset, form.formState.isSubmitSuccessful, data]);
-
-	const onSubmit = async (values: SettingsType) => {
-		await mutateAsync({
-			cleanupCacheApplications: values.cleanCacheOnApplications,
-			cleanupCacheOnCompose: values.cleanCacheOnCompose,
-			cleanupCacheOnPreviews: values.cleanCacheOnPreviews,
-		})
-			.then(() => {
-				toast.success("Settings updated");
-				refetch();
-			})
-			.catch(() => {
-				toast.error("Something went wrong");
-			});
-	};
-	return (
-		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
-				<div className="rounded-xl bg-background shadow-md ">
-					<CardHeader className="">
-						<CardTitle className="text-xl flex flex-row gap-2">
-							<Settings className="size-6 text-muted-foreground self-center" />
-							Settings
-						</CardTitle>
-						<CardDescription>Manage your Dokploy settings</CardDescription>
-						{isError && <AlertBlock type="error">{error?.message}</AlertBlock>}
-					</CardHeader>
-					<CardContent className="space-y-2 py-8 border-t">
-						<Form {...form}>
-							<form
-								id="hook-form-add-security"
-								onSubmit={form.handleSubmit(onSubmit)}
-								className="grid w-full gap-2"
-							>
-								<FormField
-									control={form.control}
-									name="cleanCacheOnApplications"
-									render={({ field }) => (
-										<FormItem className="flex flex-row items-center justify-between p-3 mt-4 border rounded-lg shadow-sm">
-											<div className="space-y-0.5">
-												<FormLabel>Clean Cache on Applications</FormLabel>
-												<FormDescription>
-													Clean the cache after every application deployment
-												</FormDescription>
-											</div>
-											<FormControl>
-												<Switch
-													checked={field.value}
-													onCheckedChange={field.onChange}
-												/>
-											</FormControl>
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="cleanCacheOnPreviews"
-									render={({ field }) => (
-										<FormItem className="flex flex-row items-center justify-between p-3 mt-4 border rounded-lg shadow-sm">
-											<div className="space-y-0.5">
-												<FormLabel>Clean Cache on Previews</FormLabel>
-												<FormDescription>
-													Clean the cache after every preview deployment
-												</FormDescription>
-											</div>
-											<FormControl>
-												<Switch
-													checked={field.value}
-													onCheckedChange={field.onChange}
-												/>
-											</FormControl>
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="cleanCacheOnCompose"
-									render={({ field }) => (
-										<FormItem className="flex flex-row items-center justify-between p-3 mt-4 border rounded-lg shadow-sm">
-											<div className="space-y-0.5">
-												<FormLabel>Clean Cache on Compose</FormLabel>
-												<FormDescription>
-													Clean the cache after every compose deployment
-												</FormDescription>
-											</div>
-											<FormControl>
-												<Switch
-													checked={field.value}
-													onCheckedChange={field.onChange}
-												/>
-											</FormControl>
-										</FormItem>
-									)}
-								/>
-								<DialogFooter>
-									<Button
-										isLoading={isLoading}
-										form="hook-form-add-security"
-										type="submit"
-									>
-										Update
-									</Button>
-								</DialogFooter>
-							</form>
-						</Form>
-					</CardContent>
-				</div>
-			</Card>
-		</div>
-	);
-};
-
-export default Page;
-
-Page.getLayout = (page: ReactElement) => {
-	return <DashboardLayout metaName="Server">{page}</DashboardLayout>;
-};
-export async function getServerSideProps(
-	ctx: GetServerSidePropsContext<{ serviceId: string }>,
-) {
-	const { req, res } = ctx;
-	const { user, session } = await validateRequest(ctx.req);
-	if (!user) {
-		return {
-			redirect: {
-				permanent: true,
-				destination: "/",
-			},
-		};
-	}
-	if (user.role === "member") {
-		return {
-			redirect: {
-				permanent: true,
-				destination: "/dashboard/settings/profile",
-			},
-		};
-	}
-
-	const helpers = createServerSideHelpers({
-		router: appRouter,
-		ctx: {
-			req: req as any,
-			res: res as any,
-			db: null as any,
-			session: session as any,
-			user: user as any,
-		},
-		transformer: superjson,
-	});
-	await helpers.user.get.prefetch();
-
-	return {
-		props: {
-			trpcState: helpers.dehydrate(),
-		},
-	};
-}

apps/dokploy/server/api/routers/application.ts

@@ -33,6 +33,7 @@ import {
 	findApplicationById,
 	findProjectById,
 	getApplicationStats,
+	mechanizeDockerContainer,
 	readConfig,
 	readRemoteConfig,
 	removeDeployments,
@@ -132,28 +133,36 @@ export const applicationRouter = createTRPCRouter({
 		.input(apiReloadApplication)
 		.mutation(async ({ input, ctx }) => {
 			const application = await findApplicationById(input.applicationId);
-			if (
-				application.project.organizationId !== ctx.session.activeOrganizationId
-			) {
+
+			try {
+				if (
+					application.project.organizationId !==
+					ctx.session.activeOrganizationId
+				) {
+					throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: "You are not authorized to reload this application",
+					});
+				}
+
+				if (application.serverId) {
+					await stopServiceRemote(application.serverId, input.appName);
+				} else {
+					await stopService(input.appName);
+				}
+
+				await updateApplicationStatus(input.applicationId, "idle");
+				await mechanizeDockerContainer(application);
+				await updateApplicationStatus(input.applicationId, "done");
+				return true;
+			} catch (error) {
+				await updateApplicationStatus(input.applicationId, "error");
 				throw new TRPCError({
-					code: "UNAUTHORIZED",
-					message: "You are not authorized to reload this application",
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Error reloading application",
+					cause: error,
 				});
 			}
-			if (application.serverId) {
-				await stopServiceRemote(application.serverId, input.appName);
-			} else {
-				await stopService(input.appName);
-			}
-			await updateApplicationStatus(input.applicationId, "idle");
-
-			if (application.serverId) {
-				await startServiceRemote(application.serverId, input.appName);
-			} else {
-				await startService(input.appName);
-			}
-			await updateApplicationStatus(input.applicationId, "done");
-			return true;
 		}),
 
 	delete: protectedProcedure

apps/dokploy/server/api/routers/backup.ts

@@ -31,7 +31,10 @@ import {
 } from "@dokploy/server";
 
 import { findDestinationById } from "@dokploy/server/services/destination";
-import { getS3Credentials } from "@dokploy/server/utils/backups/utils";
+import {
+	getS3Credentials,
+	normalizeS3Path,
+} from "@dokploy/server/utils/backups/utils";
 import {
 	execAsync,
 	execAsyncRemote,
@@ -257,7 +260,7 @@ export const backupRouter = createTRPCRouter({
 				const lastSlashIndex = input.search.lastIndexOf("/");
 				const baseDir =
 					lastSlashIndex !== -1
-						? input.search.slice(0, lastSlashIndex + 1)
+						? normalizeS3Path(input.search.slice(0, lastSlashIndex + 1))
 						: "";
 				const searchTerm =
 					lastSlashIndex !== -1
@@ -270,7 +273,7 @@ export const backupRouter = createTRPCRouter({
 				let stdout = "";
 
 				if (input.serverId) {
-					const result = await execAsyncRemote(listCommand, input.serverId);
+					const result = await execAsyncRemote(input.serverId, listCommand);
 					stdout = result.stdout;
 				} else {
 					const result = await execAsync(listCommand);

apps/dokploy/server/api/routers/registry.ts

@@ -10,8 +10,8 @@ import {
 import {
 	IS_CLOUD,
 	createRegistry,
-	execAsync,
 	execAsyncRemote,
+	execFileAsync,
 	findRegistryById,
 	removeRegistry,
 	updateRegistry,
@@ -83,7 +83,13 @@ export const registryRouter = createTRPCRouter({
 		.input(apiTestRegistry)
 		.mutation(async ({ input }) => {
 			try {
-				const loginCommand = `echo ${input.password} | docker login ${input.registryUrl} --username ${input.username} --password-stdin`;
+				const args = [
+					"login",
+					input.registryUrl,
+					"--username",
+					input.username,
+					"--password-stdin",
+				];
 
 				if (IS_CLOUD && !input.serverId) {
 					throw new TRPCError({
@@ -93,9 +99,14 @@ export const registryRouter = createTRPCRouter({
 				}
 
 				if (input.serverId && input.serverId !== "none") {
-					await execAsyncRemote(input.serverId, loginCommand);
+					await execAsyncRemote(
+						input.serverId,
+						`echo ${input.password} | docker ${args.join(" ")}`,
+					);
 				} else {
-					await execAsync(loginCommand);
+					await execFileAsync("docker", args, {
+						input: Buffer.from(input.password).toString(),
+					});
 				}
 
 				return true;

apps/dokploy/server/api/routers/settings.ts

@@ -184,6 +184,7 @@ export const settingsRouter = createTRPCRouter({
 					letsEncryptEmail: input.letsEncryptEmail,
 				}),
 				certificateType: input.certificateType,
+				https: input.https,
 			});
 
 			if (!user) {

apps/dokploy/server/wss/drawer-logs.ts

@@ -1,9 +1,9 @@
 import type http from "node:http";
-import { validateRequest } from "@dokploy/server/index";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
 import { WebSocketServer } from "ws";
 import { appRouter } from "../api/root";
 import { createTRPCContext } from "../api/trpc";
+import { validateRequest } from "@dokploy/server/lib/auth";
 
 export const setupDrawerLogsWebSocketServer = (
 	server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,
@@ -13,11 +13,13 @@ export const setupDrawerLogsWebSocketServer = (
 		path: "/drawer-logs",
 	});
 
+	// Set up tRPC WebSocket handler
 	applyWSSHandler({
 		wss: wssTerm,
 		router: appRouter,
 		createContext: createTRPCContext as any,
 	});
+
 	server.on("upgrade", (req, socket, head) => {
 		const { pathname } = new URL(req.url || "", `http://${req.headers.host}`);
 

packages/server/src/db/schema/user.ts

@@ -50,6 +50,7 @@ export const users_temp = pgTable("user_temp", {
 	// Admin
 	serverIp: text("serverIp"),
 	certificateType: certificateType("certificateType").notNull().default("none"),
+	https: boolean("https").notNull().default(false),
 	host: text("host"),
 	letsEncryptEmail: text("letsEncryptEmail"),
 	sshPrivateKey: text("sshPrivateKey"),
@@ -202,10 +203,12 @@ export const apiAssignDomain = createSchema
 		host: true,
 		certificateType: true,
 		letsEncryptEmail: true,
+		https: true,
 	})
 	.required()
 	.partial({
 		letsEncryptEmail: true,
+		https: true,
 	});
 
 export const apiUpdateDockerCleanup = createSchema

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

@@ -106,8 +106,8 @@ export const keepLatestNBackups = async (
 			backup.prefix,
 		);
 
-		// --include "*.sql.gz" ensures nothing else other than the db backup files are touched by rclone
-		const rcloneList = `rclone lsf ${rcloneFlags.join(" ")} --include "*.sql.gz" ${backupFilesPath}`;
+		// --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

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

@@ -1,4 +1,3 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
@@ -8,7 +7,7 @@ import {
 } from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMariadbBackup = async (
 	mariadb: Mariadb,
@@ -19,7 +18,7 @@ export const runMariadbBackup = async (
 	const { prefix, database } = 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);

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

@@ -1,4 +1,3 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
@@ -8,7 +7,7 @@ import {
 } from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getS3Credentials, normalizeS3Path } from "./utils";
 
 // mongodb://mongo:Bqh7AQl-PRbnBu@localhost:27017/?tls=false&directConnection=true
 export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
@@ -17,7 +16,7 @@ export const runMongoBackup = async (mongo: Mongo, backup: BackupSchedule) => {
 	const { prefix, database } = backup;
 	const destination = backup.destination;
 	const backupFileName = `${new Date().toISOString()}.dump.gz`;
-	const bucketDestination = path.join(prefix, backupFileName);
+	const bucketDestination = `${normalizeS3Path(prefix)}${backupFileName}`;
 
 	try {
 		const rcloneFlags = getS3Credentials(destination);

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

@@ -1,4 +1,3 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
@@ -8,7 +7,7 @@ import {
 } from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	const { appName, databaseRootPassword, projectId, name } = mysql;
@@ -16,7 +15,7 @@ export const runMySqlBackup = async (mysql: MySql, backup: BackupSchedule) => {
 	const { prefix, database } = 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);

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

@@ -1,4 +1,3 @@
-import path from "node:path";
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
@@ -8,7 +7,7 @@ import {
 } from "../docker/utils";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getS3Credentials, normalizeS3Path } from "./utils";
 
 export const runPostgresBackup = async (
 	postgres: Postgres,
@@ -20,7 +19,7 @@ export const runPostgresBackup = async (
 	const { prefix, database } = 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}`;

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

@@ -36,6 +36,13 @@ 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, region, endpoint, provider } =
 		destination;

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

@@ -1,6 +1,6 @@
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import { execAsync } from "../process/execAsync";
-import { getS3Credentials } from "./utils";
+import { getS3Credentials, normalizeS3Path } from "./utils";
 import { findDestinationById } from "@dokploy/server/services/destination";
 import { IS_CLOUD, paths } from "@dokploy/server/constants";
 import { mkdtemp } from "node:fs/promises";
@@ -18,7 +18,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 		const { BASE_PATH } = paths();
 		const tempDir = await mkdtemp(join(tmpdir(), "dokploy-backup-"));
 		const backupFileName = `webserver-backup-${timestamp}.zip`;
-		const s3Path = `:s3:${destination.bucket}/${backup.prefix}${backupFileName}`;
+		const s3Path = `:s3:${destination.bucket}/${normalizeS3Path(backup.prefix)}${backupFileName}`;
 
 		try {
 			await execAsync(`mkdir -p ${tempDir}/filesystem`);
@@ -29,7 +29,7 @@ export const runWebServerBackup = async (backup: BackupSchedule) => {
 			await execAsync(`cp -r ${BASE_PATH}/* ${tempDir}/filesystem/`);
 
 			await execAsync(
-				`cd ${tempDir} && zip -r ${backupFileName} database.sql filesystem/`,
+				`cd ${tempDir} && zip -r ${backupFileName} database.sql filesystem/ > /dev/null 2>&1`,
 			);
 
 			const uploadCommand = `rclone copyto ${rcloneFlags.join(" ")} "${tempDir}/${backupFileName}" "${s3Path}"`;

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

@@ -25,6 +25,12 @@ export const buildStatic = async (
 			].join("\n"),
 		);
 
+		createFile(
+			buildAppDirectory,
+			".dockerignore",
+			[".git", ".env", "Dockerfile", ".dockerignore"].join("\n"),
+		);
+
 		await buildCustomDocker(
 			{
 				...application,

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

@@ -1,9 +1,48 @@
-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);
 
+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,

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

@@ -45,7 +45,7 @@ export const restoreWebServerBackup = async (
 
 			// Extract backup
 			emit("Extracting backup...");
-			await execAsync(`cd ${tempDir} && unzip ${backupFile}`);
+			await execAsync(`cd ${tempDir} && unzip ${backupFile} > /dev/null 2>&1`);
 
 			// Restore filesystem first
 			emit("Restoring filesystem...");

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

@@ -3,7 +3,11 @@ import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 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";
 
@@ -11,32 +15,62 @@ export const updateServerTraefik = (
 	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 (user?.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) => {