Merge branch 'canary' into copilot/fix-azure-openai-endpoint

Co-authored-by: Siumauricio <47042324+Siumauricio@users.noreply.github.com>

LICENSE.MD

@@ -1,13 +1,8 @@
-Copyright 2026-present Dokploy Technology, Inc.
+# License
 
-Portions of this software are licensed as follows:
+## Core License (Apache License 2.0)
 
-* All content that resides under a "/proprietary" directory of this repository, if that directory exists, is licensed under the license defined in "LICENSE_PROPRIETARY".
-* Content outside of the above mentioned directories or restrictions above is available under the "Apache License 2.0" license as defined below.
-
-## Apache License 2.0
-
-Copyright 2026-present Dokploy Technology, Inc.
+Copyright 2025 Mauricio Siu.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -20,4 +15,12 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and limitations under the License.
 
+## Additional Terms for Specific Features
 
+The following additional terms apply to the multi-node support, Docker Compose file, Preview Deployments and Multi Server features of Dokploy. In the event of a conflict, these provisions shall take precedence over those in the Apache License:
+
+- **Self-Hosted Version Free**: All features of Dokploy, including multi-node support, Docker Compose file support, Schedules, Preview Deployments and Multi Server, will always be free to use in the self-hosted version.
+- **Restriction on Resale**: The multi-node support, Docker Compose file support, Schedules, Preview Deployments and Multi Server features cannot be sold or offered as a service by any party other than the copyright holder without prior written consent.
+- **Modification Distribution**: Any modifications to the multi-node support, Docker Compose file support, Schedules, Preview Deployments and Multi Server features must be distributed freely and cannot be sold or offered as a service.
+
+For further inquiries or permissions, please contact us directly.

LICENSE_PROPRIETARY.md

@@ -1,11 +0,0 @@
-The Dokploy Source Available license (DSAL) version 1.0
-
-Copyright (c) 2026-present Dokploy Technology, Inc.
-
-With regard to the Dokploy Software:This software and associated documentation files (the "Software") may only beused in production, if you (and any entity that you represent) have agreed to, and are in compliance with, a valid commercial agreement from Dokploy.Subject to the foregoing sentence, you are free to modify this Software and publish patches to the Software. You agree that Dokploy and/or its licensors (as applicable) retain all right, title and interest in and to all such modifications and/or patches, and all such modifications and/or patches may only be used, copied, modified, displayed, distributed, or otherwise exploited with a valid Dokploy Source Available License.  Notwithstanding the foregoing, you may copy and modify the Software for development and testing purposes, without requiring a subscription.  You agree that Dokploy and/or its licensors (as applicable) retain all right, title and interest in and to all such modifications.  You are not granted any other rights beyond what is expressly stated herein.  Subject to theforegoing, it is forbidden to copy, merge, publish, distribute, sublicense,and/or sell the Software.
-
-This Dokploy Source Available license applies only to the part of this Software that is in a /proprietary folder. The full text of this License shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THESOFTWARE.
-
-For all third party components incorporated into the Dokploy Software, thosecomponents are licensed under the original license provided by the owner of the applicable component.

apps/dokploy/.env.production.example

@@ -1,2 +1,3 @@
+DATABASE_URL="postgres://dokploy:amukds4wi9001583845717ad2@dokploy-postgres:5432/dokploy"
 PORT=3000
 NODE_ENV=production

apps/dokploy/__test__/env/environment-access-fallback.test.ts

@@ -1,294 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-// Type definitions matching the project structure
-type Environment = {
-	environmentId: string;
-	name: string;
-	isDefault: boolean;
-};
-
-type Project = {
-	projectId: string;
-	name: string;
-	environments: Environment[];
-};
-
-/**
- * Helper function that selects the appropriate environment for a user
- * This matches the logic used in search-command.tsx and show.tsx
- */
-function selectAccessibleEnvironment(
-	project: Project | null | undefined,
-): Environment | null {
-	if (!project || !project.environments || project.environments.length === 0) {
-		return null;
-	}
-
-	// Find default environment from accessible environments, or fall back to first accessible environment
-	const defaultEnvironment =
-		project.environments.find((environment) => environment.isDefault) ||
-		project.environments[0];
-
-	return defaultEnvironment || null;
-}
-
-describe("Environment Access Fallback", () => {
-	describe("selectAccessibleEnvironment", () => {
-		it("should return default environment when user has access to it", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-prod",
-						name: "production",
-						isDefault: true,
-					},
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-prod");
-			expect(result?.isDefault).toBe(true);
-		});
-
-		it("should return first accessible environment when user doesn't have access to default", () => {
-			// Simulating filtered environments (user only has access to development)
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					// Note: production is not in the list because user doesn't have access
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-					{
-						environmentId: "env-staging",
-						name: "staging",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-dev");
-			expect(result?.name).toBe("development");
-		});
-
-		it("should return first environment when no default is marked but environments exist", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-					{
-						environmentId: "env-staging",
-						name: "staging",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-dev");
-		});
-
-		it("should return null when project has no accessible environments", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).toBeNull();
-		});
-
-		it("should return null when project is null", () => {
-			const result = selectAccessibleEnvironment(null);
-
-			expect(result).toBeNull();
-		});
-
-		it("should return null when project is undefined", () => {
-			const result = selectAccessibleEnvironment(undefined);
-
-			expect(result).toBeNull();
-		});
-
-		it("should handle project with single accessible environment", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-dev");
-		});
-
-		it("should prioritize default environment even when it's not first in the array", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-					{
-						environmentId: "env-staging",
-						name: "staging",
-						isDefault: false,
-					},
-					{
-						environmentId: "env-prod",
-						name: "production",
-						isDefault: true,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-prod");
-			expect(result?.isDefault).toBe(true);
-		});
-
-		it("should handle multiple default environments by returning the first one found", () => {
-			// Edge case: multiple environments marked as default (shouldn't happen, but test it)
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-prod-1",
-						name: "production-1",
-						isDefault: true,
-					},
-					{
-						environmentId: "env-prod-2",
-						name: "production-2",
-						isDefault: true,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.isDefault).toBe(true);
-			// Should return the first default found
-			expect(result?.environmentId).toBe("env-prod-1");
-		});
-
-		it("should work correctly when user has access to multiple environments including default", () => {
-			const project: Project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: [
-					{
-						environmentId: "env-prod",
-						name: "production",
-						isDefault: true,
-					},
-					{
-						environmentId: "env-dev",
-						name: "development",
-						isDefault: false,
-					},
-					{
-						environmentId: "env-staging",
-						name: "staging",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-prod");
-			expect(result?.isDefault).toBe(true);
-		});
-
-		it("should handle real-world scenario: user with only development access", () => {
-			// This simulates the exact bug we're fixing:
-			// User has access to development but not production (default)
-			// The filtered environments array only contains development
-			const project: Project = {
-				projectId: "proj-1",
-				name: "My Project",
-				environments: [
-					// Only development is accessible (production was filtered out)
-					{
-						environmentId: "env-dev-123",
-						name: "development",
-						isDefault: false,
-					},
-				],
-			};
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).not.toBeNull();
-			expect(result?.environmentId).toBe("env-dev-123");
-			expect(result?.name).toBe("development");
-			// Should not be null even though it's not the default
-		});
-	});
-
-	describe("Environment selection edge cases", () => {
-		it("should handle project with environments property as undefined", () => {
-			const project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: undefined,
-			} as unknown as Project;
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).toBeNull();
-		});
-
-		it("should handle project with null environments array", () => {
-			const project = {
-				projectId: "proj-1",
-				name: "Test Project",
-				environments: null,
-			} as unknown as Project;
-
-			const result = selectAccessibleEnvironment(project);
-
-			expect(result).toBeNull();
-		});
-	});
-});

apps/dokploy/__test__/utils/azure-ai-provider.test.ts

@@ -0,0 +1,81 @@
+import { normalizeAzureUrl } from "@dokploy/server/utils/ai/select-ai-provider";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Test for Azure OpenAI endpoint URL normalization
+ * These tests verify that Azure OpenAI URLs are properly cleaned up
+ * to remove duplicate /v1 paths that would cause API errors
+ */
+describe("Azure OpenAI URL Normalization", () => {
+	it("should strip /openai/v1 from Azure URL", () => {
+		const input = "https://workspacename.openai.azure.com/openai/v1";
+		const result = normalizeAzureUrl(input);
+
+		expect(result).toBe("https://workspacename.openai.azure.com");
+	});
+
+	it("should strip /v1 from Azure URL", () => {
+		const input = "https://workspacename.openai.azure.com/v1";
+		const result = normalizeAzureUrl(input);
+
+		expect(result).toBe("https://workspacename.openai.azure.com");
+	});
+
+	it("should strip trailing slash from Azure URL", () => {
+		const input = "https://workspacename.openai.azure.com/";
+		const result = normalizeAzureUrl(input);
+
+		expect(result).toBe("https://workspacename.openai.azure.com");
+	});
+
+	it("should handle clean Azure URL without modification", () => {
+		const input = "https://workspacename.openai.azure.com";
+		const result = normalizeAzureUrl(input);
+
+		expect(result).toBe("https://workspacename.openai.azure.com");
+	});
+
+	it("should strip /openai/v1/ with trailing slash", () => {
+		const input = "https://workspacename.openai.azure.com/openai/v1/";
+		const result = normalizeAzureUrl(input);
+
+		expect(result).toBe("https://workspacename.openai.azure.com");
+	});
+
+	it("should build correct deployments endpoint for Azure", () => {
+		const input = "https://workspacename.openai.azure.com/openai/v1";
+		const apiUrl = normalizeAzureUrl(input);
+
+		const deploymentsUrl = `${apiUrl}/openai/deployments?api-version=2023-05-15`;
+
+		expect(deploymentsUrl).toBe(
+			"https://workspacename.openai.azure.com/openai/deployments?api-version=2023-05-15",
+		);
+	});
+
+	it("should not strip /v1 from middle of path", () => {
+		const input = "https://workspacename.openai.azure.com/v1/something";
+		const result = normalizeAzureUrl(input);
+
+		// Should only strip trailing /v1, not /v1 in the middle
+		expect(result).toBe("https://workspacename.openai.azure.com/v1/something");
+	});
+
+	it("should handle edge case with multiple trailing /v1", () => {
+		const input = "https://workspacename.openai.azure.com/openai/v1/v1";
+		const result = normalizeAzureUrl(input);
+
+		// Should only strip the last /v1
+		expect(result).toBe("https://workspacename.openai.azure.com/openai/v1");
+	});
+
+	it("should not strip partial matches in path segments", () => {
+		const input = "https://workspacename.openai.azure.com/myopenai/v1service";
+		const result = normalizeAzureUrl(input);
+
+		// Should not modify paths that don't end with /openai/v1 or /v1
+		expect(result).toBe(
+			"https://workspacename.openai.azure.com/myopenai/v1service",
+		);
+	});
+});

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/endpoint-spec-form.tsx

@@ -1,154 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-
-export const endpointSpecFormSchema = z.object({
-	Mode: z.string().optional(),
-});
-
-interface EndpointSpecFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const EndpointSpecForm = ({ id, type }: EndpointSpecFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(endpointSpecFormSchema),
-		defaultValues: {
-			Mode: undefined,
-		},
-	});
-
-	useEffect(() => {
-		if (data?.endpointSpecSwarm) {
-			const es = data.endpointSpecSwarm;
-			form.reset({
-				Mode: es.Mode,
-			});
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: z.infer<typeof endpointSpecFormSchema>) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue =
-				formData.Mode !== undefined &&
-				formData.Mode !== null &&
-				formData.Mode !== "";
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				endpointSpecSwarm: hasAnyValue ? formData : null,
-			});
-
-			toast.success("Endpoint spec updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating endpoint spec");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="Mode"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Mode</FormLabel>
-							<FormDescription>Endpoint mode (vip or dnsrr)</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select endpoint mode" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="vip">VIP (Virtual IP)</SelectItem>
-									<SelectItem value="dnsrr">DNS Round Robin</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Mode: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Endpoint Spec
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/health-check-form.tsx

@@ -1,267 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-export const healthCheckFormSchema = z.object({
-	Test: z.array(z.string()).optional(),
-	Interval: z.coerce.number().optional(),
-	Timeout: z.coerce.number().optional(),
-	StartPeriod: z.coerce.number().optional(),
-	Retries: z.coerce.number().optional(),
-});
-
-interface HealthCheckFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const HealthCheckForm = ({ id, type }: HealthCheckFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-	const [testCommands, setTestCommands] = useState<string[]>([]);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(healthCheckFormSchema),
-		defaultValues: {
-			Test: [],
-			Interval: undefined,
-			Timeout: undefined,
-			StartPeriod: undefined,
-			Retries: undefined,
-		},
-	});
-
-	useEffect(() => {
-		if (data?.healthCheckSwarm) {
-			const hc = data.healthCheckSwarm;
-			form.reset({
-				Test: hc.Test || [],
-				Interval: hc.Interval,
-				Timeout: hc.Timeout,
-				StartPeriod: hc.StartPeriod,
-				Retries: hc.Retries,
-			});
-			setTestCommands(hc.Test || []);
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: z.infer<typeof healthCheckFormSchema>) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue =
-				(formData.Test && formData.Test.length > 0) ||
-				formData.Interval !== undefined ||
-				formData.Timeout !== undefined ||
-				formData.StartPeriod !== undefined ||
-				formData.Retries !== undefined;
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				healthCheckSwarm: hasAnyValue ? formData : null,
-			});
-
-			toast.success("Health check updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating health check");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	const addTestCommand = () => {
-		setTestCommands([...testCommands, ""]);
-	};
-
-	const updateTestCommand = (index: number, value: string) => {
-		const newCommands = [...testCommands];
-		newCommands[index] = value;
-		setTestCommands(newCommands);
-	};
-
-	const removeTestCommand = (index: number) => {
-		setTestCommands(testCommands.filter((_, i) => i !== index));
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<div>
-					<FormLabel>Test Commands</FormLabel>
-					<FormDescription>
-						Command to run for health check (e.g., ["CMD-SHELL", "curl -f
-						http://localhost:3000/health"])
-					</FormDescription>
-					<div className="space-y-2 mt-2">
-						{testCommands.map((cmd, index) => (
-							<div key={index} className="flex gap-2">
-								<Input
-									value={cmd}
-									onChange={(e) => updateTestCommand(index, e.target.value)}
-									placeholder={
-										index === 0
-											? "CMD-SHELL"
-											: "curl -f http://localhost:3000/health"
-									}
-								/>
-								<Button
-									type="button"
-									variant="destructive"
-									size="sm"
-									onClick={() => removeTestCommand(index)}
-								>
-									Remove
-								</Button>
-							</div>
-						))}
-						<Button
-							type="button"
-							variant="outline"
-							size="sm"
-							onClick={addTestCommand}
-						>
-							Add Command
-						</Button>
-					</div>
-				</div>
-
-				<FormField
-					control={form.control}
-					name="Interval"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Interval (nanoseconds)</FormLabel>
-							<FormDescription>
-								Time between health checks (e.g., 10000000000 for 10 seconds)
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Timeout"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Timeout (nanoseconds)</FormLabel>
-							<FormDescription>
-								Maximum time to wait for health check response
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="StartPeriod"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Start Period (nanoseconds)</FormLabel>
-							<FormDescription>
-								Initial grace period before health checks begin
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Retries"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Retries</FormLabel>
-							<FormDescription>
-								Number of consecutive failures needed to consider container
-								unhealthy
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="3" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Test: [],
-								Interval: undefined,
-								Timeout: undefined,
-								StartPeriod: undefined,
-								Retries: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Health Check
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/index.ts

@@ -1,10 +0,0 @@
-export { HealthCheckForm } from "./health-check-form";
-export { RestartPolicyForm } from "./restart-policy-form";
-export { PlacementForm } from "./placement-form";
-export { UpdateConfigForm } from "./update-config-form";
-export { RollbackConfigForm } from "./rollback-config-form";
-export { ModeForm } from "./mode-form";
-export { LabelsForm } from "./labels-form";
-export { StopGracePeriodForm } from "./stop-grace-period-form";
-export { EndpointSpecForm } from "./endpoint-spec-form";
-export { filterEmptyValues, hasValues } from "./utils";

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/labels-form.tsx

@@ -1,200 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useFieldArray, useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-export const labelsFormSchema = z.object({
-	labels: z
-		.array(
-			z.object({
-				key: z.string(),
-				value: z.string(),
-			}),
-		)
-		.optional(),
-});
-
-interface LabelsFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const LabelsForm = ({ id, type }: LabelsFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(labelsFormSchema),
-		defaultValues: {
-			labels: [],
-		},
-	});
-
-	const { fields, append, remove } = useFieldArray({
-		control: form.control,
-		name: "labels",
-	});
-
-	useEffect(() => {
-		if (data?.labelsSwarm && typeof data.labelsSwarm === "object") {
-			const labelEntries = Object.entries(data.labelsSwarm).map(
-				([key, value]) => ({
-					key,
-					value: value as string,
-				}),
-			);
-			form.reset({ labels: labelEntries });
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: z.infer<typeof labelsFormSchema>) => {
-		setIsLoading(true);
-		try {
-			const labelsObject =
-				formData.labels?.reduce(
-					(acc, { key, value }) => {
-						if (key && value) {
-							acc[key] = value;
-						}
-						return acc;
-					},
-					{} as Record<string, string>,
-				) || {};
-
-			// If no labels, send null to clear the database
-			const labelsToSend =
-				Object.keys(labelsObject).length > 0 ? labelsObject : null;
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				labelsSwarm: labelsToSend,
-			});
-
-			toast.success("Labels updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating labels");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<div>
-					<FormLabel>Labels</FormLabel>
-					<FormDescription>
-						Add key-value labels to your service
-					</FormDescription>
-					<div className="space-y-2 mt-2">
-						{fields.map((field, index) => (
-							<div key={field.id} className="flex gap-2">
-								<FormField
-									control={form.control}
-									name={`labels.${index}.key`}
-									render={({ field }) => (
-										<FormItem className="flex-1">
-											<FormControl>
-												<Input {...field} placeholder="com.example.app.name" />
-											</FormControl>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name={`labels.${index}.value`}
-									render={({ field }) => (
-										<FormItem className="flex-1">
-											<FormControl>
-												<Input {...field} placeholder="my-app" />
-											</FormControl>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<Button
-									type="button"
-									variant="destructive"
-									size="sm"
-									onClick={() => remove(index)}
-								>
-									Remove
-								</Button>
-							</div>
-						))}
-						<Button
-							type="button"
-							variant="outline"
-							size="sm"
-							onClick={() => append({ key: "", value: "" })}
-						>
-							Add Label
-						</Button>
-					</div>
-				</div>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({ labels: [] });
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Labels
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/mode-form.tsx

@@ -1,195 +0,0 @@
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-
-interface ModeFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const ModeForm = ({ id, type }: ModeFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		defaultValues: {
-			type: undefined,
-			Replicas: undefined,
-		},
-	});
-
-	const modeType = form.watch("type");
-
-	useEffect(() => {
-		if (data?.modeSwarm) {
-			const mode = data.modeSwarm;
-			if (mode.Replicated) {
-				form.reset({
-					type: "Replicated",
-					Replicas: mode.Replicated.Replicas,
-				});
-			} else if (mode.Global) {
-				form.reset({
-					type: "Global",
-					Replicas: undefined,
-				});
-			}
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: any) => {
-		setIsLoading(true);
-		try {
-			// If no type is selected, send null to clear the database
-			if (!formData.type) {
-				await mutateAsync({
-					applicationId: id || "",
-					postgresId: id || "",
-					redisId: id || "",
-					mysqlId: id || "",
-					mariadbId: id || "",
-					mongoId: id || "",
-					modeSwarm: null,
-				});
-				toast.success("Mode updated successfully");
-				refetch();
-				setIsLoading(false);
-				return;
-			}
-
-			const modeData =
-				formData.type === "Replicated"
-					? { Replicated: { Replicas: formData.Replicas } }
-					: { Global: {} };
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				modeSwarm: modeData,
-			});
-
-			toast.success("Mode updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating mode");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="type"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Mode Type</FormLabel>
-							<FormDescription>
-								Choose between replicated or global service mode
-							</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select mode type" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="Replicated">Replicated</SelectItem>
-									<SelectItem value="Global">Global</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				{modeType === "Replicated" && (
-					<FormField
-						control={form.control}
-						name="Replicas"
-						render={({ field }) => (
-							<FormItem>
-								<FormLabel>Replicas</FormLabel>
-								<FormDescription>Number of replicas to run</FormDescription>
-								<FormControl>
-									<Input type="number" placeholder="1" {...field} />
-								</FormControl>
-								<FormMessage />
-							</FormItem>
-						)}
-					/>
-				)}
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								type: undefined,
-								Replicas: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Mode
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/placement-form.tsx

@@ -1,342 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-const PreferenceSchema = z.object({
-	Spread: z.object({
-		SpreadDescriptor: z.string(),
-	}),
-});
-
-const PlatformSchema = z.object({
-	Architecture: z.string(),
-	OS: z.string(),
-});
-
-export const placementFormSchema = z.object({
-	Constraints: z.array(z.string()).optional(),
-	Preferences: z.array(PreferenceSchema).optional(),
-	MaxReplicas: z.coerce.number().optional(),
-	Platforms: z.array(PlatformSchema).optional(),
-});
-
-interface PlacementFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const PlacementForm = ({ id, type }: PlacementFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(placementFormSchema),
-		defaultValues: {
-			Constraints: [],
-			Preferences: [],
-			MaxReplicas: undefined,
-			Platforms: [],
-		},
-	});
-
-	const constraints = form.watch("Constraints") || [];
-	const preferences = form.watch("Preferences") || [];
-	const platforms = form.watch("Platforms") || [];
-
-	useEffect(() => {
-		if (data?.placementSwarm) {
-			const placement = data.placementSwarm;
-			form.reset({
-				Constraints: placement.Constraints || [],
-				Preferences:
-					placement.Preferences?.map((p: any) => ({
-						SpreadDescriptor: p.Spread?.SpreadDescriptor || "",
-					})) || [],
-				MaxReplicas: placement.MaxReplicas,
-				Platforms: placement.Platforms || [],
-			});
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: z.infer<typeof placementFormSchema>) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue =
-				(formData.Constraints && formData.Constraints.length > 0) ||
-				(formData.Preferences && formData.Preferences.length > 0) ||
-				(formData.Platforms && formData.Platforms.length > 0) ||
-				formData.MaxReplicas !== undefined;
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				placementSwarm: hasAnyValue ? formData : null,
-			});
-
-			toast.success("Placement updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating placement");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	const addConstraint = () => {
-		form.setValue("Constraints", [...constraints, ""]);
-	};
-
-	const updateConstraint = (index: number, value: string) => {
-		const newConstraints = [...constraints];
-		newConstraints[index] = value;
-		form.setValue("Constraints", newConstraints);
-	};
-
-	const removeConstraint = (index: number) => {
-		form.setValue(
-			"Constraints",
-			constraints.filter((_: string, i: number) => i !== index),
-		);
-	};
-
-	const addPreference = () => {
-		form.setValue("Preferences", [...preferences, { SpreadDescriptor: "" }]);
-	};
-
-	const updatePreference = (index: number, value: string) => {
-		const newPreferences = [...preferences];
-		if (newPreferences[index]) {
-			newPreferences[index].SpreadDescriptor = value;
-			form.setValue("Preferences", newPreferences);
-		}
-	};
-
-	const removePreference = (index: number) => {
-		form.setValue(
-			"Preferences",
-			preferences.filter((_: any, i: number) => i !== index),
-		);
-	};
-
-	const addPlatform = () => {
-		form.setValue("Platforms", [...platforms, { Architecture: "", OS: "" }]);
-	};
-
-	const updatePlatform = (
-		index: number,
-		field: "Architecture" | "OS",
-		value: string,
-	) => {
-		const newPlatforms = [...platforms];
-		if (newPlatforms[index]) {
-			newPlatforms[index][field] = value;
-			form.setValue("Platforms", newPlatforms);
-		}
-	};
-
-	const removePlatform = (index: number) => {
-		form.setValue(
-			"Platforms",
-			platforms.filter((_: any, i: number) => i !== index),
-		);
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<div>
-					<FormLabel>Constraints</FormLabel>
-					<FormDescription>
-						Placement constraints (e.g., "node.role==manager")
-					</FormDescription>
-					<div className="space-y-2 mt-2">
-						{constraints.map((constraint: string, index: number) => (
-							<div key={index} className="flex gap-2">
-								<Input
-									value={constraint}
-									onChange={(e) => updateConstraint(index, e.target.value)}
-									placeholder="node.role==manager"
-								/>
-								<Button
-									type="button"
-									variant="destructive"
-									size="sm"
-									onClick={() => removeConstraint(index)}
-								>
-									Remove
-								</Button>
-							</div>
-						))}
-						<Button
-							type="button"
-							variant="outline"
-							size="sm"
-							onClick={addConstraint}
-						>
-							Add Constraint
-						</Button>
-					</div>
-				</div>
-
-				<div>
-					<FormLabel>Preferences</FormLabel>
-					<FormDescription>
-						Spread preferences for task distribution (e.g.,
-						"node.labels.region")
-					</FormDescription>
-					<div className="space-y-2 mt-2">
-						{preferences.map((pref: any, index: number) => (
-							<div key={index} className="flex gap-2">
-								<Input
-									value={pref.SpreadDescriptor}
-									onChange={(e) => updatePreference(index, e.target.value)}
-									placeholder="node.labels.region"
-								/>
-								<Button
-									type="button"
-									variant="destructive"
-									size="sm"
-									onClick={() => removePreference(index)}
-								>
-									Remove
-								</Button>
-							</div>
-						))}
-						<Button
-							type="button"
-							variant="outline"
-							size="sm"
-							onClick={addPreference}
-						>
-							Add Preference
-						</Button>
-					</div>
-				</div>
-
-				<FormField
-					control={form.control}
-					name="MaxReplicas"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Max Replicas</FormLabel>
-							<FormDescription>
-								Maximum number of replicas per node
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div>
-					<FormLabel>Platforms</FormLabel>
-					<FormDescription>
-						Target platforms for task scheduling
-					</FormDescription>
-					<div className="space-y-2 mt-2">
-						{platforms.map((platform: any, index: number) => (
-							<div key={index} className="flex gap-2">
-								<Input
-									value={platform.Architecture}
-									onChange={(e) =>
-										updatePlatform(index, "Architecture", e.target.value)
-									}
-									placeholder="amd64"
-								/>
-								<Input
-									value={platform.OS}
-									onChange={(e) => updatePlatform(index, "OS", e.target.value)}
-									placeholder="linux"
-								/>
-								<Button
-									type="button"
-									variant="destructive"
-									size="sm"
-									onClick={() => removePlatform(index)}
-								>
-									Remove
-								</Button>
-							</div>
-						))}
-						<Button
-							type="button"
-							variant="outline"
-							size="sm"
-							onClick={addPlatform}
-						>
-							Add Platform
-						</Button>
-					</div>
-				</div>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Constraints: [],
-								Preferences: [],
-								MaxReplicas: undefined,
-								Platforms: [],
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Placement
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/restart-policy-form.tsx

@@ -1,219 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-
-export const restartPolicyFormSchema = z.object({
-	Condition: z.string().optional(),
-	Delay: z.coerce.number().optional(),
-	MaxAttempts: z.coerce.number().optional(),
-	Window: z.coerce.number().optional(),
-});
-
-interface RestartPolicyFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const RestartPolicyForm = ({ id, type }: RestartPolicyFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(restartPolicyFormSchema),
-		defaultValues: {
-			Condition: undefined,
-			Delay: undefined,
-			MaxAttempts: undefined,
-			Window: undefined,
-		},
-	});
-
-	useEffect(() => {
-		if (data?.restartPolicySwarm) {
-			form.reset({
-				Condition: data.restartPolicySwarm.Condition,
-				Delay: data.restartPolicySwarm.Delay,
-				MaxAttempts: data.restartPolicySwarm.MaxAttempts,
-				Window: data.restartPolicySwarm.Window,
-			});
-		}
-	}, [data, form]);
-
-	const onSubmit = async (
-		formData: z.infer<typeof restartPolicyFormSchema>,
-	) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue = Object.values(formData).some(
-				(value) => value !== undefined && value !== null && value !== "",
-			);
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				restartPolicySwarm: hasAnyValue ? formData : null,
-			});
-
-			toast.success("Restart policy updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating restart policy");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="Condition"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Condition</FormLabel>
-							<FormDescription>When to restart the container</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select restart condition" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="none">None</SelectItem>
-									<SelectItem value="on-failure">On Failure</SelectItem>
-									<SelectItem value="any">Any</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Delay"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Delay (nanoseconds)</FormLabel>
-							<FormDescription>
-								Wait time between restart attempts
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="MaxAttempts"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Max Attempts</FormLabel>
-							<FormDescription>
-								Maximum number of restart attempts
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="3" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Window"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Window (nanoseconds)</FormLabel>
-							<FormDescription>
-								Time window to evaluate restart policy
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Condition: undefined,
-								Delay: undefined,
-								MaxAttempts: undefined,
-								Window: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Restart Policy
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/rollback-config-form.tsx

@@ -1,257 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-
-export const rollbackConfigFormSchema = z.object({
-	Parallelism: z.coerce.number().optional(),
-	Delay: z.coerce.number().optional(),
-	FailureAction: z.string().optional(),
-	Monitor: z.coerce.number().optional(),
-	MaxFailureRatio: z.coerce.number().optional(),
-	Order: z.string().optional(),
-});
-
-interface RollbackConfigFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const RollbackConfigForm = ({ id, type }: RollbackConfigFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(rollbackConfigFormSchema),
-		defaultValues: {
-			Parallelism: undefined,
-			Delay: undefined,
-			FailureAction: undefined,
-			Monitor: undefined,
-			MaxFailureRatio: undefined,
-			Order: undefined,
-		},
-	});
-
-	useEffect(() => {
-		if (data?.rollbackConfigSwarm) {
-			form.reset(data.rollbackConfigSwarm);
-		}
-	}, [data, form]);
-
-	const onSubmit = async (
-		formData: z.infer<typeof rollbackConfigFormSchema>,
-	) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue = Object.values(formData).some(
-				(value) => value !== undefined && value !== null && value !== "",
-			);
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				rollbackConfigSwarm: (hasAnyValue ? formData : null) as any,
-			});
-
-			toast.success("Rollback config updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating rollback config");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="Parallelism"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Parallelism</FormLabel>
-							<FormDescription>
-								Number of tasks to rollback simultaneously
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="1" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Delay"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Delay (nanoseconds)</FormLabel>
-							<FormDescription>Delay between task rollbacks</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="FailureAction"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Failure Action</FormLabel>
-							<FormDescription>Action on rollback failure</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select failure action" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="pause">Pause</SelectItem>
-									<SelectItem value="continue">Continue</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Monitor"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Monitor (nanoseconds)</FormLabel>
-							<FormDescription>
-								Duration to monitor for failure after rollback
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="MaxFailureRatio"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Max Failure Ratio</FormLabel>
-							<FormDescription>
-								Maximum failure ratio tolerated (0-1)
-							</FormDescription>
-							<FormControl>
-								<Input type="number" step="0.01" placeholder="0.1" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Order"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Order</FormLabel>
-							<FormDescription>Rollback order strategy</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select order" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="stop-first">Stop First</SelectItem>
-									<SelectItem value="start-first">Start First</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Parallelism: undefined,
-								Delay: undefined,
-								FailureAction: undefined,
-								Monitor: undefined,
-								MaxFailureRatio: undefined,
-								Order: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Rollback Config
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/stop-grace-period-form.tsx

@@ -1,158 +0,0 @@
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-const hasStopGracePeriodSwarm = (
-	value: unknown,
-): value is { stopGracePeriodSwarm: bigint | number | string | null } =>
-	typeof value === "object" &&
-	value !== null &&
-	"stopGracePeriodSwarm" in value;
-
-interface StopGracePeriodFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const StopGracePeriodForm = ({ id, type }: StopGracePeriodFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		defaultValues: {
-			value: null as bigint | null,
-		},
-	});
-
-	useEffect(() => {
-		if (hasStopGracePeriodSwarm(data)) {
-			const value = data.stopGracePeriodSwarm;
-			const normalizedValue =
-				value === null || value === undefined
-					? null
-					: typeof value === "bigint"
-						? value
-						: BigInt(value);
-			form.reset({
-				value: normalizedValue,
-			});
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: any) => {
-		setIsLoading(true);
-		try {
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				stopGracePeriodSwarm: formData.value,
-			});
-
-			toast.success("Stop grace period updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating stop grace period");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="value"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Stop Grace Period (nanoseconds)</FormLabel>
-							<FormDescription>
-								Time to wait before forcefully killing the container
-								<br />
-								Examples: 30000000000 (30s), 120000000000 (2m)
-							</FormDescription>
-							<FormControl>
-								<Input
-									type="number"
-									placeholder="30000000000"
-									{...field}
-									value={
-										field?.value !== null && field?.value !== undefined
-											? field.value.toString()
-											: ""
-									}
-									onChange={(e) =>
-										field.onChange(
-											e.target.value ? BigInt(e.target.value) : null,
-										)
-									}
-								/>
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								value: null,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Stop Grace Period
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/update-config-form.tsx

@@ -1,264 +0,0 @@
-import { zodResolver } from "@hookform/resolvers/zod";
-import { useEffect, useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Form,
-	FormControl,
-	FormDescription,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-
-export const updateConfigFormSchema = z.object({
-	Parallelism: z.coerce.number().optional(),
-	Delay: z.coerce.number().optional(),
-	FailureAction: z.string().optional(),
-	Monitor: z.coerce.number().optional(),
-	MaxFailureRatio: z.coerce.number().optional(),
-	Order: z.string().optional(),
-});
-
-interface UpdateConfigFormProps {
-	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
-}
-
-export const UpdateConfigForm = ({ id, type }: UpdateConfigFormProps) => {
-	const [isLoading, setIsLoading] = useState(false);
-
-	const queryMap = {
-		postgres: () =>
-			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
-		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-	};
-	const { data, refetch } = queryMap[type]
-		? queryMap[type]()
-		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
-
-	const mutationMap = {
-		postgres: () => api.postgres.update.useMutation(),
-		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
-	};
-
-	const { mutateAsync } = mutationMap[type]
-		? mutationMap[type]()
-		: api.mongo.update.useMutation();
-
-	const form = useForm<any>({
-		resolver: zodResolver(updateConfigFormSchema),
-		defaultValues: {
-			Parallelism: undefined,
-			Delay: undefined,
-			FailureAction: undefined,
-			Monitor: undefined,
-			MaxFailureRatio: undefined,
-			Order: undefined,
-		},
-	});
-
-	useEffect(() => {
-		if (data?.updateConfigSwarm) {
-			const config = data.updateConfigSwarm;
-			form.reset({
-				Parallelism: config.Parallelism,
-				Delay: config.Delay,
-				FailureAction: config.FailureAction,
-				Monitor: config.Monitor,
-				MaxFailureRatio: config.MaxFailureRatio,
-				Order: config.Order,
-			});
-		}
-	}, [data, form]);
-
-	const onSubmit = async (formData: z.infer<typeof updateConfigFormSchema>) => {
-		setIsLoading(true);
-		try {
-			// Check if all values are empty, if so, send null to clear the database
-			const hasAnyValue = Object.values(formData).some(
-				(value) => value !== undefined && value !== null && value !== "",
-			);
-
-			await mutateAsync({
-				applicationId: id || "",
-				postgresId: id || "",
-				redisId: id || "",
-				mysqlId: id || "",
-				mariadbId: id || "",
-				mongoId: id || "",
-				updateConfigSwarm: (hasAnyValue ? formData : null) as any,
-			});
-
-			toast.success("Update config updated successfully");
-			refetch();
-		} catch {
-			toast.error("Error updating update config");
-		} finally {
-			setIsLoading(false);
-		}
-	};
-
-	return (
-		<Form {...form}>
-			<form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
-				<FormField
-					control={form.control}
-					name="Parallelism"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Parallelism</FormLabel>
-							<FormDescription>
-								Number of tasks to update simultaneously
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="1" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Delay"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Delay (nanoseconds)</FormLabel>
-							<FormDescription>Delay between task updates</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="FailureAction"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Failure Action</FormLabel>
-							<FormDescription>Action on update failure</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select failure action" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="pause">Pause</SelectItem>
-									<SelectItem value="continue">Continue</SelectItem>
-									<SelectItem value="rollback">Rollback</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Monitor"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Monitor (nanoseconds)</FormLabel>
-							<FormDescription>
-								Duration to monitor for failure after update
-							</FormDescription>
-							<FormControl>
-								<Input type="number" placeholder="10000000000" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="MaxFailureRatio"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Max Failure Ratio</FormLabel>
-							<FormDescription>
-								Maximum failure ratio tolerated (0-1)
-							</FormDescription>
-							<FormControl>
-								<Input type="number" step="0.01" placeholder="0.1" {...field} />
-							</FormControl>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<FormField
-					control={form.control}
-					name="Order"
-					render={({ field }) => (
-						<FormItem>
-							<FormLabel>Order</FormLabel>
-							<FormDescription>Update order strategy</FormDescription>
-							<Select onValueChange={field.onChange} value={field.value}>
-								<FormControl>
-									<SelectTrigger>
-										<SelectValue placeholder="Select order" />
-									</SelectTrigger>
-								</FormControl>
-								<SelectContent>
-									<SelectItem value="stop-first">Stop First</SelectItem>
-									<SelectItem value="start-first">Start First</SelectItem>
-								</SelectContent>
-							</Select>
-							<FormMessage />
-						</FormItem>
-					)}
-				/>
-
-				<div className="flex justify-end gap-2">
-					<Button
-						type="button"
-						variant="outline"
-						onClick={() => {
-							form.reset({
-								Parallelism: undefined,
-								Delay: undefined,
-								FailureAction: undefined,
-								Monitor: undefined,
-								MaxFailureRatio: undefined,
-								Order: undefined,
-							});
-						}}
-					>
-						Clear
-					</Button>
-					<Button type="submit" isLoading={isLoading}>
-						Save Update Config
-					</Button>
-				</div>
-			</form>
-		</Form>
-	);
-};

apps/dokploy/components/dashboard/application/advanced/cluster/swarm-forms/utils.ts

@@ -1,31 +0,0 @@
-/**
- * Filters out undefined, null, and empty string values from form data
- * Only returns fields that have actual values
- */
-export const filterEmptyValues = (
-	formData: Record<string, any>,
-): Record<string, any> => {
-	return Object.entries(formData).reduce(
-		(acc, [key, value]) => {
-			// Keep arrays even if empty (they might be intentionally cleared)
-			if (Array.isArray(value)) {
-				if (value.length > 0) {
-					acc[key] = value;
-				}
-			}
-			// For other values, filter out undefined, null, and empty strings
-			else if (value !== undefined && value !== null && value !== "") {
-				acc[key] = value;
-			}
-			return acc;
-		},
-		{} as Record<string, any>,
-	);
-};
-
-/**
- * Checks if filtered data has any values to save
- */
-export const hasValues = (data: Record<string, any>): boolean => {
-	return Object.keys(data).length > 0;
-};

apps/dokploy/components/dashboard/application/build/show.tsx

@@ -207,11 +207,6 @@ export const ShowBuildChooseForm = ({ applicationId }: Props) => {
 		}
 	}, [data, form]);
 
-	// Hide builder section when Docker provider is selected
-	if (data?.sourceType === "docker") {
-		return null;
-	}
-
 	const onSubmit = async (data: AddTemplate) => {
 		await mutateAsync({
 			applicationId,

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

@@ -288,12 +288,9 @@ export const ShowProjects = () => {
 												)
 												.some(Boolean);
 
-											// Find default environment from accessible environments, or fall back to first accessible environment
-											const accessibleEnvironment =
-												project?.environments.find((env) => env.isDefault) ||
-												project?.environments?.[0];
-
-											const hasNoEnvironments = !accessibleEnvironment;
+											const productionEnvironment = project?.environments.find(
+												(env) => env.isDefault,
+											);
 
 											return (
 												<div
@@ -301,16 +298,7 @@ export const ShowProjects = () => {
 													className="w-full lg:max-w-md"
 												>
 													<Link
-														href={
-															hasNoEnvironments
-																? "#"
-																: `/dashboard/project/${project.projectId}/environment/${accessibleEnvironment?.environmentId}`
-														}
-														onClick={(e) => {
-															if (hasNoEnvironments) {
-																e.preventDefault();
-															}
-														}}
+														href={`/dashboard/project/${project.projectId}/environment/${productionEnvironment?.environmentId}`}
 													>
 														<Card className="group relative w-full h-full bg-transparent transition-colors hover:bg-border">
 															{haveServicesWithDomains ? (
@@ -431,7 +419,7 @@ export const ShowProjects = () => {
 															) : null}
 															<CardHeader>
 																<CardTitle className="flex items-center justify-between gap-2">
-																	<span className="flex flex-col gap-1.5 ">
+																	<span className="flex flex-col gap-1.5">
 																		<div className="flex items-center gap-2">
 																			<BookIcon className="size-4 text-muted-foreground" />
 																			<span className="text-base font-medium leading-none">
@@ -439,19 +427,9 @@ export const ShowProjects = () => {
 																			</span>
 																		</div>
 
-																		<span className="text-sm font-medium text-muted-foreground break-all">
+																		<span className="text-sm font-medium text-muted-foreground">
 																			{project.description}
 																		</span>
-
-																		{hasNoEnvironments && (
-																			<div className="flex flex-row gap-2 items-center rounded-lg bg-yellow-50 p-2 mt-2 dark:bg-yellow-950">
-																				<AlertTriangle className="size-4 text-yellow-600 dark:text-yellow-400 shrink-0" />
-																				<span className="text-xs text-yellow-600 dark:text-yellow-400">
-																					You have access to this project but no
-																					environments are available
-																				</span>
-																			</div>
-																		)}
 																	</span>
 																	<div className="flex self-start space-x-1">
 																		<DropdownMenu>

apps/dokploy/components/dashboard/search-command.tsx

@@ -89,7 +89,7 @@ export const SearchCommand = () => {
 					<CommandGroup heading={"Projects"}>
 						<CommandList>
 							{data?.map((project) => {
-								// Find default environment from accessible environments, or fall back to first accessible environment
+								// Find default environment, or fall back to first environment
 								const defaultEnvironment =
 									project.environments.find(
 										(environment) => environment.isDefault,

apps/dokploy/components/dashboard/settings/profile/profile-form.tsx

@@ -41,7 +41,7 @@ const profileSchema = z.object({
 	password: z.string().nullable(),
 	currentPassword: z.string().nullable(),
 	image: z.string().optional(),
-	firstName: z.string().optional(),
+	name: z.string().optional(),
 	lastName: z.string().optional(),
 	allowImpersonation: z.boolean().optional().default(false),
 });
@@ -91,7 +91,7 @@ export const ProfileForm = () => {
 			image: data?.user?.image || "",
 			currentPassword: "",
 			allowImpersonation: data?.user?.allowImpersonation || false,
-			firstName: data?.user?.firstName || "",
+			name: data?.user?.firstName || "",
 			lastName: data?.user?.lastName || "",
 		},
 		resolver: zodResolver(profileSchema),
@@ -106,7 +106,7 @@ export const ProfileForm = () => {
 					image: data?.user?.image || "",
 					currentPassword: form.getValues("currentPassword") || "",
 					allowImpersonation: data?.user?.allowImpersonation,
-					firstName: data?.user?.firstName || "",
+					name: data?.user?.firstName || "",
 					lastName: data?.user?.lastName || "",
 				},
 				{
@@ -131,7 +131,7 @@ export const ProfileForm = () => {
 				image: values.image,
 				currentPassword: values.currentPassword || undefined,
 				allowImpersonation: values.allowImpersonation,
-				firstName: values.firstName || undefined,
+				name: values.name || undefined,
 				lastName: values.lastName || undefined,
 			});
 			await refetch();
@@ -141,7 +141,7 @@ export const ProfileForm = () => {
 				password: "",
 				image: values.image,
 				currentPassword: "",
-				firstName: values.firstName || "",
+				name: values.name || "",
 				lastName: values.lastName || "",
 			});
 		} catch (error) {
@@ -184,7 +184,7 @@ export const ProfileForm = () => {
 										<div className="space-y-4">
 											<FormField
 												control={form.control}
-												name="firstName"
+												name="name"
 												render={({ field }) => (
 													<FormItem>
 														<FormLabel>First Name</FormLabel>

apps/dokploy/components/layouts/side.tsx

@@ -18,6 +18,7 @@ import {
 	Forward,
 	GalleryVerticalEnd,
 	GitBranch,
+	HeartIcon,
 	KeyRound,
 	Loader2,
 	type LucideIcon,
@@ -409,6 +410,18 @@ const MENU: Menu = {
 			url: "https://discord.gg/2tBnJ3jDJc",
 			icon: CircleHelp,
 		},
+		{
+			name: "Sponsor",
+			url: "https://opencollective.com/dokploy",
+			icon: ({ className }) => (
+				<HeartIcon
+					className={cn(
+						"text-red-500 fill-red-600 animate-heartbeat",
+						className,
+					)}
+				/>
+			),
+		},
 	],
 } as const;
 

apps/dokploy/drizzle/0057_damp_prism.sql

@@ -0,0 +1,16 @@
+CREATE TABLE IF NOT EXISTS "ai" (
+	"aiId" text PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"apiUrl" text NOT NULL,
+	"apiKey" text NOT NULL,
+	"model" text NOT NULL,
+	"isEnabled" boolean DEFAULT true NOT NULL,
+	"adminId" text NOT NULL,
+	"createdAt" text NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "ai" ADD CONSTRAINT "ai_adminId_admin_adminId_fk" FOREIGN KEY ("adminId") REFERENCES "public"."admin"("adminId") ON DELETE cascade ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;

apps/dokploy/migration.ts

@@ -1,9 +1,10 @@
-import { dbUrl } from "@dokploy/server/db";
 import { drizzle } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
 
-const sql = postgres(dbUrl, { max: 1 });
+const connectionString = process.env.DATABASE_URL!;
+
+const sql = postgres(connectionString, { max: 1 });
 const db = drizzle(sql);
 
 await migrate(db, { migrationsFolder: "drizzle" })

apps/dokploy/next.config.mjs

@@ -19,32 +19,6 @@ const nextConfig = {
 		locales: ["en"],
 		defaultLocale: "en",
 	},
-	async headers() {
-		return [
-			{
-				// Apply security headers to all routes
-				source: "/:path*",
-				headers: [
-					{
-						key: "X-Frame-Options",
-						value: "DENY",
-					},
-					{
-						key: "Content-Security-Policy",
-						value: "frame-ancestors 'none'",
-					},
-					{
-						key: "X-Content-Type-Options",
-						value: "nosniff",
-					},
-					{
-						key: "Referrer-Policy",
-						value: "strict-origin-when-cross-origin",
-					},
-				],
-			},
-		];
-	},
 };
 
 export default nextConfig;

apps/dokploy/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dokploy",
-	"version": "v0.26.6",
+	"version": "v0.26.5",
 	"private": true,
 	"license": "Apache-2.0",
 	"type": "module",
@@ -196,5 +196,10 @@
 		"*": [
 			"biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
 		]
+	},
+	"commitlint": {
+		"extends": [
+			"@commitlint/config-conventional"
+		]
 	}
 }

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

@@ -1624,39 +1624,9 @@ export async function getServerSideProps(
 				projectId: params.projectId,
 			});
 
-			// Try to fetch the requested environment
-			try {
-				await helpers.environment.one.fetch({
-					environmentId: params.environmentId,
-				});
-			} catch (error) {
-				// If user doesn't have access to requested environment, redirect to accessible one
-				const accessibleEnvironments =
-					await helpers.environment.byProjectId.fetch({
-						projectId: params.projectId,
-					});
-
-				if (accessibleEnvironments.length > 0) {
-					// Try to find default, otherwise use first accessible
-					const targetEnv =
-						accessibleEnvironments.find((env) => env.isDefault) ||
-						accessibleEnvironments[0];
-
-					return {
-						redirect: {
-							permanent: false,
-							destination: `/dashboard/project/${params.projectId}/environment/${targetEnv.environmentId}`,
-						},
-					};
-				}
-				// No accessible environments, redirect to home
-				return {
-					redirect: {
-						permanent: false,
-						destination: "/",
-					},
-				};
-			}
+			await helpers.environment.one.fetch({
+				environmentId: params.environmentId,
+			});
 
 			await helpers.environment.byProjectId.fetch({
 				projectId: params.projectId,

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/application/[applicationId].tsx

@@ -108,7 +108,6 @@ const Service = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/compose/[composeId].tsx

@@ -97,7 +97,6 @@ const Service = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/mariadb/[mariadbId].tsx

@@ -79,7 +79,6 @@ const Mariadb = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/mongo/[mongoId].tsx

@@ -78,7 +78,6 @@ const Mongo = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/mysql/[mysqlId].tsx

@@ -77,7 +77,6 @@ const MySql = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/postgres/[postgresId].tsx

@@ -77,7 +77,6 @@ const Postgresql = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/pages/dashboard/project/[projectId]/environment/[environmentId]/services/redis/[redisId].tsx

@@ -77,7 +77,6 @@ const Redis = (
 					{ name: "Projects", href: "/dashboard/projects" },
 					{
 						name: data?.environment?.project?.name || "",
-						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
 					},
 					{
 						name: data?.environment?.name || "",

apps/dokploy/proprietary/README.md

@@ -1,18 +0,0 @@
-# Proprietary Features
-
-This directory contains all proprietary functionality of Dokploy.
-
-## Purpose
-
-This folder will house all **paid features** and premium functionality that are not part of the open source code.
-
-## License
-
-The code in this directory is under Dokploy's proprietary license. See [LICENSE_PROPRIETARY.md](../../../LICENSE_PROPRIETARY.md) for more details.
-
-## Contact
-
-If you want to learn more about our paid features or have any questions, please contact us at:
-
-- Email: [sales@dokploy.com](mailto:sales@dokploy.com)
-- Contact Form: [https://dokploy.com/contact](https://dokploy.com/contact)

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

@@ -26,6 +26,7 @@ import {
 	getProviderHeaders,
 	getProviderName,
 	type Model,
+	normalizeAzureUrl,
 } from "@dokploy/server/utils/ai/select-ai-provider";
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
@@ -58,16 +59,41 @@ export const aiRouter = createTRPCRouter({
 				const providerName = getProviderName(input.apiUrl);
 				const headers = getProviderHeaders(input.apiUrl, input.apiKey);
 				let response = null;
+				let apiUrl = input.apiUrl;
+
+				// Validate API key for providers that require it
+				if (
+					providerName !== "ollama" &&
+					providerName !== "gemini" &&
+					!input.apiKey
+				) {
+					throw new TRPCError({
+						code: "BAD_REQUEST",
+						message: "API key must contain at least 1 character(s)",
+					});
+				}
+
 				switch (providerName) {
 					case "ollama":
-						response = await fetch(`${input.apiUrl}/api/tags`, { headers });
+						response = await fetch(`${apiUrl}/api/tags`, { headers });
 						break;
 					case "gemini":
 						response = await fetch(
-							`${input.apiUrl}/models?key=${encodeURIComponent(input.apiKey)}`,
+							`${apiUrl}/models?key=${encodeURIComponent(input.apiKey)}`,
 							{ headers: {} },
 						);
 						break;
+					case "azure":
+						// Azure OpenAI uses deployments endpoint
+						// Normalize the URL to remove trailing /openai/v1 or /v1
+						apiUrl = normalizeAzureUrl(apiUrl);
+
+						// Azure uses deployments endpoint to list models
+						response = await fetch(
+							`${apiUrl}/openai/deployments?api-version=2023-05-15`,
+							{ headers },
+						);
+						break;
 					case "perplexity":
 						// Perplexity doesn't have a /models endpoint, return hardcoded list
 						return [
@@ -103,12 +129,7 @@ export const aiRouter = createTRPCRouter({
 							},
 						] as Model[];
 					default:
-						if (!input.apiKey)
-							throw new TRPCError({
-								code: "BAD_REQUEST",
-								message: "API key must contain at least 1 character(s)",
-							});
-						response = await fetch(`${input.apiUrl}/models`, { headers });
+						response = await fetch(`${apiUrl}/models`, { headers });
 				}
 
 				if (!response.ok) {

apps/dokploy/server/db/drizzle.config.ts

@@ -1,11 +1,10 @@
-import { dbUrl } from "@dokploy/server/db";
 import { defineConfig } from "drizzle-kit";
 
 export default defineConfig({
 	schema: "./server/db/schema/index.ts",
 	dialect: "postgresql",
 	dbCredentials: {
-		url: dbUrl,
+		url: process.env.DATABASE_URL!,
 	},
 	out: "drizzle",
 	migrations: {

apps/dokploy/server/db/index.ts

@@ -1,4 +1,3 @@
-import { dbUrl } from "@dokploy/server/db/constants";
 import { drizzle, type PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import * as schema from "./schema";
@@ -7,6 +6,10 @@ declare global {
 	var db: PostgresJsDatabase<typeof schema> | undefined;
 }
 
+const dbUrl =
+	process.env.DATABASE_URL ||
+	"postgres://dokploy:amukds4wi9001583845717ad2@dokploy-postgres:5432/dokploy";
+
 export let db: PostgresJsDatabase<typeof schema>;
 if (process.env.NODE_ENV === "production") {
 	db = drizzle(postgres(dbUrl!), {

apps/dokploy/server/db/migration.ts

@@ -1,9 +1,10 @@
-import { dbUrl } from "@dokploy/server/db";
 import { drizzle } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
 
-const sql = postgres(dbUrl, { max: 1 });
+const connectionString = process.env.DATABASE_URL!;
+
+const sql = postgres(connectionString, { max: 1 });
 const db = drizzle(sql);
 
 export const migration = async () =>

apps/dokploy/server/db/reset.ts

@@ -1,10 +1,11 @@
-import { dbUrl } from "@dokploy/server/db";
 import { sql } from "drizzle-orm";
 // Credits to Louistiti from Drizzle Discord: https://discord.com/channels/1043890932593987624/1130802621750448160/1143083373535973406
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 
-const pg = postgres(dbUrl, { max: 1 });
+const connectionString = process.env.DATABASE_URL!;
+
+const pg = postgres(connectionString, { max: 1 });
 const db = drizzle(pg);
 
 const clearDb = async (): Promise<void> => {

apps/dokploy/server/wss/docker-container-logs.ts

@@ -1,9 +1,9 @@
 import type http from "node:http";
-import { findServerById, IS_CLOUD, validateRequest } from "@dokploy/server";
+import { findServerById, validateRequest } from "@dokploy/server";
 import { spawn } from "node-pty";
 import { Client } from "ssh2";
 import { WebSocketServer } from "ws";
-import { getShell, isValidContainerId } from "./utils";
+import { getShell } from "./utils";
 
 export const setupDockerContainerLogsWebSocketServer = (
 	server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,
@@ -42,12 +42,6 @@ export const setupDockerContainerLogsWebSocketServer = (
 			return;
 		}
 
-		// Security: Validate containerId to prevent command injection
-		if (!isValidContainerId(containerId)) {
-			ws.close(4000, "Invalid container ID format");
-			return;
-		}
-
 		if (!user || !session) {
 			ws.close();
 			return;
@@ -117,11 +111,6 @@ export const setupDockerContainerLogsWebSocketServer = (
 					client.end();
 				});
 			} else {
-				if (IS_CLOUD) {
-					ws.send("This feature is not available in the cloud version.");
-					ws.close();
-					return;
-				}
 				const shell = getShell();
 				const baseCommand = `docker ${runType === "swarm" ? "service" : "container"} logs --timestamps ${
 					runType === "swarm" ? "--raw" : ""

apps/dokploy/server/wss/docker-container-terminal.ts

@@ -1,9 +1,9 @@
 import type http from "node:http";
-import { findServerById, IS_CLOUD, validateRequest } from "@dokploy/server";
+import { findServerById, validateRequest } from "@dokploy/server";
 import { spawn } from "node-pty";
 import { Client } from "ssh2";
 import { WebSocketServer } from "ws";
-import { isValidContainerId, isValidShell } from "./utils";
+import { getShell } from "./utils";
 
 export const setupDockerContainerTerminalWebSocketServer = (
 	server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,
@@ -35,25 +35,10 @@ export const setupDockerContainerTerminalWebSocketServer = (
 		const { user, session } = await validateRequest(req);
 
 		if (!containerId) {
-			ws.close(4000, "containerId not provided");
+			ws.close(4000, "containerId no provided");
 			return;
 		}
 
-		// Security: Validate containerId to prevent command injection
-		if (!isValidContainerId(containerId)) {
-			ws.close(4000, "Invalid container ID format");
-			return;
-		}
-
-		// Security: Validate shell to prevent command injection
-		if (activeWay && !isValidShell(activeWay)) {
-			ws.close(4000, "Invalid shell specified");
-			return;
-		}
-
-		// Default to 'sh' if no shell specified
-		const shell = activeWay || "sh";
-
 		if (!user || !session) {
 			ws.close();
 			return;
@@ -69,61 +54,55 @@ export const setupDockerContainerTerminalWebSocketServer = (
 				let _stderr = "";
 				conn
 					.once("ready", () => {
-						// Use array-style arguments to prevent shell injection
-						const dockerCommand = [
-							"docker",
-							"exec",
-							"-it",
-							"-w",
-							"/",
-							containerId,
-							shell,
-						].join(" ");
-						conn.exec(dockerCommand, { pty: true }, (err, stream) => {
-							if (err) {
-								console.error("SSH exec error:", err);
-								ws.close();
-								conn.end();
-								return;
-							}
-
-							stream
-								.on("close", (code: number, _signal: string) => {
-									ws.send(`\nContainer closed with code: ${code}\n`);
+						conn.exec(
+							`docker exec -it -w / ${containerId} ${activeWay}`,
+							{ pty: true },
+							(err, stream) => {
+								if (err) {
+									console.error("SSH exec error:", err);
+									ws.close();
 									conn.end();
-								})
-								.on("data", (data: string) => {
-									_stdout += data.toString();
-									ws.send(data.toString());
-								})
-								.stderr.on("data", (data) => {
-									_stderr += data.toString();
-									ws.send(data.toString());
-									console.error("Error: ", data.toString());
+									return;
+								}
+
+								stream
+									.on("close", (code: number, _signal: string) => {
+										ws.send(`\nContainer closed with code: ${code}\n`);
+										conn.end();
+									})
+									.on("data", (data: string) => {
+										_stdout += data.toString();
+										ws.send(data.toString());
+									})
+									.stderr.on("data", (data) => {
+										_stderr += data.toString();
+										ws.send(data.toString());
+										console.error("Error: ", data.toString());
+									});
+
+								ws.on("message", (message) => {
+									try {
+										let command: string | Buffer[] | Buffer | ArrayBuffer;
+										if (Buffer.isBuffer(message)) {
+											command = message.toString("utf8");
+										} else {
+											command = message;
+										}
+										stream.write(command.toString());
+									} catch (error) {
+										// @ts-ignore
+										const errorMessage = error?.message as unknown as string;
+										ws.send(errorMessage);
+									}
 								});
 
-							ws.on("message", (message) => {
-								try {
-									let command: string | Buffer[] | Buffer | ArrayBuffer;
-									if (Buffer.isBuffer(message)) {
-										command = message.toString("utf8");
-									} else {
-										command = message;
-									}
-									stream.write(command.toString());
-								} catch (error) {
-									// @ts-ignore
-									const errorMessage = error?.message as unknown as string;
-									ws.send(errorMessage);
-								}
-							});
-
-							ws.on("close", () => {
-								stream.end();
-								// Ensure SSH connection is closed when WebSocket closes
-								conn.end();
-							});
-						});
+								ws.on("close", () => {
+									stream.end();
+									// Ensure SSH connection is closed when WebSocket closes
+									conn.end();
+								});
+							},
+						);
 					})
 					.on("error", (err) => {
 						console.error("SSH connection error:", err);
@@ -140,14 +119,10 @@ export const setupDockerContainerTerminalWebSocketServer = (
 						privateKey: server.sshKey?.privateKey,
 					});
 			} else {
-				if (IS_CLOUD) {
-					ws.send("This feature is not available in the cloud version.");
-					ws.close();
-					return;
-				}
+				const shell = getShell();
 				const ptyProcess = spawn(
-					"docker",
-					["exec", "-it", "-w", "/", containerId, shell],
+					shell,
+					["-c", `docker exec -it -w / ${containerId} ${activeWay}`],
 					{},
 				);
 

apps/dokploy/server/wss/docker-stats.ts

@@ -4,7 +4,6 @@ import {
 	execAsync,
 	getHostSystemStats,
 	getLastAdvancedStatsFile,
-	IS_CLOUD,
 	recordAdvancedStats,
 	validateRequest,
 } from "@dokploy/server";
@@ -33,12 +32,6 @@ export const setupDockerStatsMonitoringSocketServer = (
 
 	wssTerm.on("connection", async (ws, req) => {
 		const url = new URL(req.url || "", `http://${req.headers.host}`);
-
-		if (IS_CLOUD) {
-			ws.send("This feature is not available in the cloud version.");
-			ws.close();
-			return;
-		}
 		const appName = url.searchParams.get("appName");
 		const appType = (url.searchParams.get("appType") || "application") as
 			| "application"

apps/dokploy/server/wss/listen-deployment.ts

@@ -1,9 +1,8 @@
 import { spawn } from "node:child_process";
 import type http from "node:http";
-import { findServerById, IS_CLOUD, validateRequest } from "@dokploy/server";
+import { findServerById, validateRequest } from "@dokploy/server";
 import { Client } from "ssh2";
 import { WebSocketServer } from "ws";
-import { readValidDirectory } from "./utils";
 
 export const setupDeploymentLogsWebSocketServer = (
 	server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,
@@ -41,11 +40,6 @@ export const setupDeploymentLogsWebSocketServer = (
 			return;
 		}
 
-		if (!readValidDirectory(logPath)) {
-			ws.close(4000, "Invalid log path");
-			return;
-		}
-
 		if (!user || !session) {
 			ws.close();
 			return;
@@ -114,11 +108,6 @@ export const setupDeploymentLogsWebSocketServer = (
 					}
 				});
 			} else {
-				if (IS_CLOUD) {
-					ws.send("This feature is not available in the cloud version.");
-					ws.close();
-					return;
-				}
 				tailProcess = spawn("tail", ["-n", "+1", "-f", logPath]);
 
 				const stdout = tailProcess.stdout;

apps/dokploy/server/wss/terminal.ts

@@ -97,12 +97,7 @@ export const setupTerminalWebSocketServer = (
 
 		const isLocalServer = serverId === "local";
 
-		if (isLocalServer) {
-			if (IS_CLOUD) {
-				ws.send("This feature is not available in the cloud version.");
-				ws.close();
-				return;
-			}
+		if (isLocalServer && !IS_CLOUD) {
 			const port = Number(url.searchParams.get("port"));
 			const username = url.searchParams.get("username");
 

apps/dokploy/server/wss/utils.ts

@@ -1,52 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execAsync, IS_CLOUD, paths } from "@dokploy/server";
+import { execAsync, paths } from "@dokploy/server";
 
-/**
- * Validates that the container ID matches Docker's expected format.
- * Docker container IDs are 64-character hex strings (or 12-char short form).
- * Also allows container names: alphanumeric, underscores, hyphens, and dots.
- */
-export const isValidContainerId = (id: string): boolean => {
-	// Match full ID (64 hex chars), short ID (12 hex chars), or container name
-	const hexPattern = /^[a-f0-9]{12,64}$/i;
-	const namePattern = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
-	return hexPattern.test(id) || (namePattern.test(id) && id.length <= 128);
-};
-
-/**
- * Validates that the shell is one of the allowed shells.
- */
-export const isValidShell = (shell: string): boolean => {
-	const allowedShells = [
-		"sh",
-		"bash",
-		"zsh",
-		"ash",
-		"/bin/sh",
-		"/bin/bash",
-		"/bin/zsh",
-		"/bin/ash",
-	];
-	return allowedShells.includes(shell);
-};
-
-export const readValidDirectory = (directory: string) => {
-	const { BASE_PATH } = paths();
-
-	const resolvedBase = path.resolve(BASE_PATH);
-	const resolvedDir = path.resolve(directory);
-
-	return (
-		resolvedDir === resolvedBase ||
-		resolvedDir.startsWith(resolvedBase + path.sep)
-	);
-};
 export const getShell = () => {
-	if (IS_CLOUD) {
-		return "NO_AVAILABLE";
-	}
 	switch (os.platform()) {
 		case "win32":
 			return "powershell.exe";

lefthook.yml

@@ -0,0 +1,45 @@
+# EXAMPLE USAGE:
+#
+#   Refer for explanation to following link:
+#   https://github.com/evilmartians/lefthook/blob/master/docs/configuration.md
+#
+# pre-push:
+#   commands:
+#     packages-audit:
+#       tags: frontend security
+#       run: yarn audit
+#     gems-audit:
+#       tags: backend security
+#       run: bundle audit
+#
+# pre-commit:
+#   parallel: true
+#   commands:
+#     eslint:
+#       glob: "*.{js,ts,jsx,tsx}"
+#       run: yarn eslint {staged_files}
+#     rubocop:
+#       tags: backend style
+#       glob: "*.rb"
+#       exclude: '(^|/)(application|routes)\.rb$'
+#       run: bundle exec rubocop --force-exclusion {all_files}
+#     govet:
+#       tags: backend style
+#       files: git ls-files -m
+#       glob: "*.go"
+#       run: go vet {files}
+#   scripts:
+#     "hello.js":
+#       runner: node
+#     "any.go":
+#       runner: go run
+
+commit-msg:
+  commands:
+    commitlint:
+      # run: "npx commitlint --edit $1"
+
+pre-commit:
+  commands:
+    check:
+      # run: "pnpm check"

package.json

@@ -24,9 +24,12 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.1.1",
+		"@commitlint/cli": "^19.8.1",
+		"@commitlint/config-conventional": "^19.8.1",
 		"@types/node": "^18.19.104",
 		"dotenv": "16.4.5",
 		"esbuild": "0.20.2",
+		"lefthook": "1.8.4",
 		"lint-staged": "^15.5.2",
 		"tsx": "4.16.2"
 	},
@@ -40,6 +43,11 @@
 			"biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
 		]
 	},
+	"commitlint": {
+		"extends": [
+			"@commitlint/config-conventional"
+		]
+	},
 	"resolutions": {
 		"@types/react": "18.3.5",
 		"@types/react-dom": "18.3.0"

packages/server/src/db/constants.ts

@@ -1,39 +0,0 @@
-import fs from "node:fs";
-
-export const {
-	DATABASE_URL,
-	POSTGRES_PASSWORD_FILE,
-	POSTGRES_USER = "dokploy",
-	POSTGRES_DB = "dokploy",
-	POSTGRES_HOST = "dokploy-postgres",
-	POSTGRES_PORT = "5432",
-} = process.env;
-
-function readSecret(path: string): string {
-	try {
-		return fs.readFileSync(path, "utf8").trim();
-	} catch {
-		throw new Error(`Cannot read secret at ${path}`);
-	}
-}
-export let dbUrl: string;
-if (DATABASE_URL) {
-	// Compatibilidad legacy / overrides
-	dbUrl = DATABASE_URL;
-} else if (POSTGRES_PASSWORD_FILE) {
-	const password = readSecret(POSTGRES_PASSWORD_FILE);
-	dbUrl = `postgres://${POSTGRES_USER}:${encodeURIComponent(
-		password,
-	)}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}`;
-} else {
-	console.warn(`
-		⚠️  [DEPRECATED DATABASE CONFIG]
-		You are using the legacy hardcoded database credentials.
-		This mode WILL BE REMOVED in a future release.
-		
-		Please migrate to Docker Secrets using POSTGRES_PASSWORD_FILE.
-		Please execute this command in your server: curl -sSL https://dokploy.com/security/0.26.6.sh | bash
-		`);
-	dbUrl =
-		"postgres://dokploy:amukds4wi9001583845717ad2@dokploy-postgres:5432/dokploy";
-}

packages/server/src/db/index.ts

@@ -1,6 +1,5 @@
 import { drizzle, type PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
-import { dbUrl } from "./constants";
 import * as schema from "./schema";
 
 declare global {
@@ -9,16 +8,14 @@ declare global {
 
 export let db: PostgresJsDatabase<typeof schema>;
 if (process.env.NODE_ENV === "production") {
-	db = drizzle(postgres(dbUrl), {
+	db = drizzle(postgres(process.env.DATABASE_URL!), {
 		schema,
 	});
 } else {
 	if (!global.db)
-		global.db = drizzle(postgres(dbUrl), {
+		global.db = drizzle(postgres(process.env.DATABASE_URL!), {
 			schema,
 		});
 
 	db = global.db;
 }
-
-export { dbUrl };

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

@@ -214,6 +214,6 @@ export const apiUpdateUser = createSchema.partial().extend({
 		.optional(),
 	password: z.string().optional(),
 	currentPassword: z.string().optional(),
-	firstName: z.string().optional(),
+	name: z.string().optional(),
 	lastName: z.string().optional(),
 });

packages/server/src/db/schema/web-server-settings.ts

@@ -131,10 +131,7 @@ export const apiAssignDomain = z
 	.object({
 		host: z.string(),
 		certificateType: z.enum(["letsencrypt", "none", "custom"]),
-		letsEncryptEmail: z
-			.union([z.string().email(), z.literal("")])
-			.optional()
-			.nullable(),
+		letsEncryptEmail: z.string().email().optional().nullable(),
 		https: z.boolean().optional(),
 	})
 	.required()

packages/server/src/index.ts

@@ -1,6 +1,5 @@
 export * from "./auth/random-password";
 export * from "./constants/index";
-export * from "./db/constants";
 export * from "./db/validations/domain";
 export * from "./db/validations/index";
 export * from "./lib/auth";

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

@@ -7,17 +7,44 @@ import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createOllama } from "ai-sdk-ollama";
 
+/**
+ * Normalize Azure OpenAI base URL by removing trailing /openai/v1 or /v1 paths
+ * Azure OpenAI SDK handles path construction internally, so these need to be stripped
+ * to avoid duplicate paths in the final URL (e.g., /v1/v1/chat/completions)
+ */
+export function normalizeAzureUrl(url: string): string {
+	// Use a single regex to handle all variations in one pass
+	// This matches: /openai/v1 or /v1 at the end, with optional trailing slash
+	const normalized = url.replace(/\/(?:openai\/v1|v1)\/?$/, "");
+	// Remove any remaining trailing slash
+	return normalized.replace(/\/$/, "");
+}
+
 export 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(":11434") || apiUrl.includes("ollama")) return "ollama";
-	if (apiUrl.includes("api.deepinfra.com")) return "deepinfra";
-	if (apiUrl.includes("generativelanguage.googleapis.com")) return "gemini";
-	return "custom";
+	try {
+		const url = new URL(apiUrl);
+		const hostname = url.hostname.toLowerCase();
+
+		if (hostname === "api.openai.com") return "openai";
+		// Azure OpenAI uses *.openai.azure.com subdomain
+		if (
+			hostname.endsWith(".openai.azure.com") ||
+			hostname === "openai.azure.com"
+		)
+			return "azure";
+		if (hostname === "api.anthropic.com") return "anthropic";
+		if (hostname === "api.cohere.ai") return "cohere";
+		if (hostname === "api.perplexity.ai") return "perplexity";
+		if (hostname === "api.mistral.ai") return "mistral";
+		if (url.port === "11434" || hostname.includes("ollama")) return "ollama";
+		if (hostname === "api.deepinfra.com") return "deepinfra";
+		if (hostname === "generativelanguage.googleapis.com") return "gemini";
+		return "custom";
+	} catch {
+		// If URL parsing fails, treat as custom provider
+		// This is safe because custom providers still require valid authentication
+		return "custom";
+	}
 }
 
 export function selectAIProvider(config: { apiUrl: string; apiKey: string }) {
@@ -29,11 +56,16 @@ export function selectAIProvider(config: { apiUrl: string; apiKey: string }) {
 				apiKey: config.apiKey,
 				baseURL: config.apiUrl,
 			});
-		case "azure":
+		case "azure": {
+			// Azure OpenAI endpoints should not include /openai/v1 or /v1 at the end
+			// The SDK handles the path construction internally
+			const azureBaseUrl = normalizeAzureUrl(config.apiUrl);
+
 			return createAzure({
 				apiKey: config.apiKey,
-				baseURL: config.apiUrl,
+				baseURL: azureBaseUrl,
 			});
+		}
 		case "anthropic":
 			return createAnthropic({
 				apiKey: config.apiKey,
@@ -92,25 +124,45 @@ export const getProviderHeaders = (
 	apiUrl: string,
 	apiKey: string,
 ): Record<string, string> => {
-	// Anthropic
-	if (apiUrl.includes("anthropic")) {
+	try {
+		const url = new URL(apiUrl);
+		const hostname = url.hostname.toLowerCase();
+
+		// Azure OpenAI uses *.openai.azure.com subdomain
+		if (
+			hostname.endsWith(".openai.azure.com") ||
+			hostname === "openai.azure.com"
+		) {
+			return {
+				"api-key": apiKey,
+			};
+		}
+
+		// Anthropic
+		if (hostname === "api.anthropic.com") {
+			return {
+				"x-api-key": apiKey,
+				"anthropic-version": "2023-06-01",
+			};
+		}
+
+		// Mistral
+		if (hostname === "api.mistral.ai") {
+			return {
+				Authorization: apiKey,
+			};
+		}
+
+		// Default (OpenAI style)
 		return {
-			"x-api-key": apiKey,
-			"anthropic-version": "2023-06-01",
+			Authorization: `Bearer ${apiKey}`,
+		};
+	} catch {
+		// Fallback to OpenAI-style headers if URL parsing fails
+		return {
+			Authorization: `Bearer ${apiKey}`,
 		};
 	}
-
-	// Mistral
-	if (apiUrl.includes("mistral")) {
-		return {
-			Authorization: apiKey,
-		};
-	}
-
-	// Default (OpenAI style)
-	return {
-		Authorization: `Bearer ${apiKey}`,
-	};
 };
 export interface Model {
 	id: string;

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

@@ -1,6 +1,6 @@
 import { createWriteStream } from "node:fs";
 import path from "node:path";
-import { IS_CLOUD, paths } from "@dokploy/server/constants";
+import { paths } from "@dokploy/server/constants";
 import type { Schedule } from "@dokploy/server/db/schema/schedule";
 import {
 	createDeploymentSchedule,
@@ -93,13 +93,6 @@ export const runCommand = async (scheduleId: string) => {
 			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
 
 			try {
-				if (IS_CLOUD) {
-					writeStream.write(
-						"This feature is not available in the cloud version.",
-					);
-					writeStream.end();
-					return;
-				}
 				writeStream.write(
 					`docker exec ${containerId} ${shellType} -c ${command}\n`,
 				);