fix(backups): remove repeatable job using pre-update cron when disabling in cloud

.claude/skills/fix-issue/SKILL.md

@@ -16,7 +16,7 @@ No instance is running yet — start your own, isolated to this worktree:
    until it answers (usually ~10-15s).
 3. Use `http://localhost:$PORT` as the base URL for Playwright navigation.
 
-Note: `mcp__dokploy__*` resolves its URL from
+Note: `mcp__dokploy__*` (this repo's `.mcp.json`) resolves its URL from
 `$DOKPLOY_BASE_URL` once, at session startup — it cannot pick up a port
 discovered mid-session. If those tools are unavailable or point at the wrong
 instance, fall back to `curl`/`gh api` for API-level checks, or ask the user

CONTRIBUTING.md

@@ -123,13 +123,13 @@ pnpm run docker:push
 In the case you lost your password, you can reset the owner's password using the following command
 
 ```bash
-pnpm --filter=dokploy run reset-password
+pnpm run reset-password
 ```
 
 To reset the password of a specific user instead, pass their email as an argument
 
 ```bash
-pnpm --filter=dokploy run reset-password user@example.com
+pnpm run reset-password -- user@example.com
 ```
 
 Both commands print the new randomly generated password to the console.

apps/dokploy/__test__/backups/cloud-disable-uses-old-cron.test.ts

@@ -0,0 +1,287 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Regression coverage for the cloud (`IS_CLOUD`) `update` mutation in
+ * `apps/dokploy/server/api/routers/backup.ts`.
+ *
+ * BullMQ repeatable jobs are keyed by `name + pattern (+ tz)`. When a backup
+ * that was originally scheduled with cron `A` is updated to cron `B` AND
+ * disabled in the same request, the disable branch must ask `apps/schedules`
+ * to remove the repeatable job using the *stored* (pre-update) cron `A` — not
+ * the post-update cron `B` — otherwise `removeRepeatable` misses and the old
+ * schedule keeps firing forever.
+ *
+ * The router fetches the row twice around `updateBackupById`: `existing`
+ * (pre-update) and `backup` (post-update). The disable branch must source the
+ * removal cron from `existing.schedule`.
+ */
+
+const mocks = vi.hoisted(() => ({
+	// @dokploy/server barrel — backup CRUD + helpers used by the router.
+	findBackupById: vi.fn(),
+	updateBackupById: vi.fn(),
+	// Cloud fetch wrappers in @/server/utils/backup (the things we assert on).
+	removeJob: vi.fn().mockResolvedValue(true),
+	updateJob: vi.fn().mockResolvedValue(true),
+	schedule: vi.fn().mockResolvedValue(true),
+	// Permission + audit side effects.
+	checkServicePermissionAndAccess: vi.fn().mockResolvedValue(undefined),
+	audit: vi.fn().mockResolvedValue(undefined),
+	assertDatabaseBackupLimit: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Cloud fetch wrappers (capture the cron handed to apps/schedules).
+vi.mock("@/server/utils/backup", () => ({
+	removeJob: mocks.removeJob,
+	updateJob: mocks.updateJob,
+	schedule: mocks.schedule,
+}));
+
+vi.mock("@/server/api/utils/audit", () => ({ audit: mocks.audit }));
+
+vi.mock("@/server/api/utils/plan-limits", () => ({
+	assertDatabaseBackupLimit: mocks.assertDatabaseBackupLimit,
+	assertScheduledJobLimit: vi.fn().mockResolvedValue(undefined),
+	assertVolumeBackupLimit: vi.fn().mockResolvedValue(undefined),
+	assertOrganizationLimit: vi.fn().mockResolvedValue(undefined),
+	assertMemberLimit: vi.fn().mockResolvedValue(undefined),
+	assertEnvironmentLimit: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@dokploy/server/services/permission", () => ({
+	checkPermission: vi.fn().mockResolvedValue(undefined),
+	checkServicePermissionAndAccess: mocks.checkServicePermissionAndAccess,
+	findMemberByUserId: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@dokploy/server/services/destination", () => ({
+	findDestinationById: vi.fn(),
+}));
+
+vi.mock("@dokploy/server/utils/backups/compose", () => ({
+	runComposeBackup: vi.fn(),
+}));
+
+vi.mock("@dokploy/server/utils/backups/utils", () => ({
+	getS3Credentials: vi.fn(),
+	normalizeS3Path: vi.fn(),
+}));
+
+vi.mock("@dokploy/server/utils/process/execAsync", () => ({
+	execAsync: vi.fn(),
+	execAsyncRemote: vi.fn(),
+	execAsyncStream: vi.fn(),
+}));
+
+vi.mock("@dokploy/server/utils/restore", () => ({
+	restoreComposeBackup: vi.fn(),
+	restoreLibsqlBackup: vi.fn(),
+	restoreMariadbBackup: vi.fn(),
+	restoreMongoBackup: vi.fn(),
+	restoreMySqlBackup: vi.fn(),
+	restorePostgresBackup: vi.fn(),
+	restoreWebServerBackup: vi.fn(),
+}));
+
+// trpc.ts imports validateRequest at module load.
+vi.mock("@dokploy/server/lib/auth", () => ({ validateRequest: vi.fn() }));
+
+// The @dokploy/server barrel is imported by the router AND by trpc.ts (as
+// @dokploy/server/index for `hasValidLicense`). Provide every named export the
+// router references so module load is side-effect free. `IS_CLOUD` pins the
+// cloud branch under test.
+vi.mock("@dokploy/server", () => ({
+	IS_CLOUD: true,
+	hasValidLicense: vi.fn().mockResolvedValue(true),
+	// CRUD / lookups used by the router.
+	findBackupById: mocks.findBackupById,
+	updateBackupById: mocks.updateBackupById,
+	createBackup: vi.fn(),
+	findBackupsByDbId: vi.fn().mockResolvedValue([]),
+	findComposeByBackupId: vi.fn(),
+	findComposeById: vi.fn(),
+	findLibsqlByBackupId: vi.fn(),
+	findLibsqlById: vi.fn(),
+	findMariadbByBackupId: vi.fn(),
+	findMariadbById: vi.fn(),
+	findMongoByBackupId: vi.fn(),
+	findMongoById: vi.fn(),
+	findMySqlByBackupId: vi.fn(),
+	findMySqlById: vi.fn(),
+	findPostgresByBackupId: vi.fn(),
+	findPostgresById: vi.fn(),
+	findServerById: vi.fn(),
+	keepLatestNBackups: vi.fn(),
+	removeBackupById: vi.fn(),
+	removeScheduleBackup: vi.fn(),
+	runLibsqlBackup: vi.fn(),
+	runMariadbBackup: vi.fn(),
+	runMongoBackup: vi.fn(),
+	runMySqlBackup: vi.fn(),
+	runPostgresBackup: vi.fn(),
+	runWebServerBackup: vi.fn(),
+	scheduleBackup: vi.fn(),
+}));
+
+// @/server/db/schema re-exports @dokploy/server/db/schema. Provide permissive
+// Zod input schemas so createCaller parses any input shape we pass.
+vi.mock("@dokploy/server/db/schema", async () => {
+	const { z } = await import("zod");
+	const any = z.any();
+	return {
+		apiCreateBackup: any,
+		apiFindOneBackup: any,
+		apiRemoveBackup: any,
+		apiRestoreBackup: any,
+		apiUpdateBackup: any,
+		createScheduleSchema: any,
+		updateScheduleSchema: any,
+		createVolumeBackupSchema: any,
+		updateVolumeBackupSchema: any,
+		VOLUME_NAME_MESSAGE: "invalid",
+		VOLUME_NAME_REGEX: /.*/,
+		backups: {},
+		schedules: {},
+		volumeBackups: {},
+		deployments: {},
+		environments: {},
+		member: {},
+		organization: {},
+	};
+});
+
+// Distinct subpath modules imported by the sibling routers / plan-limits; mock
+// them so the barrel re-export above is the single source of schema exports.
+vi.mock("@dokploy/server/db/schema/schedule", async () => {
+	const { z } = await import("zod");
+	return {
+		createScheduleSchema: z.any(),
+		updateScheduleSchema: z.any(),
+		schedules: {},
+	};
+});
+
+vi.mock("@dokploy/server/db/schema/deployment", () => ({ deployments: {} }));
+
+import { backupRouter } from "@/server/api/routers/backup";
+
+const buildBackup = (over: Partial<Record<string, unknown>> = {}) => ({
+	backupId: "backup-1",
+	schedule: "*/2 * * * *",
+	enabled: true,
+	postgresId: "pg-1",
+	databaseType: "postgres",
+	backupType: "database",
+	destinationId: "dest-1",
+	prefix: "pg",
+	database: "db",
+	serviceName: "pg",
+	keepLatestCount: 5,
+	metadata: {},
+	...over,
+});
+
+const ctx = () =>
+	({
+		session: { activeOrganizationId: "org-1" },
+		user: {
+			id: "u1",
+			email: "u@example.com",
+			role: "owner",
+			ownerId: "u1",
+			enableEnterpriseFeatures: false,
+			isValidEnterpriseLicense: false,
+		},
+		db: {},
+	}) as any;
+
+describe("backupRouter.update — cloud disable branch", () => {
+	const OLD_CRON = "*/2 * * * *";
+	const NEW_CRON = "0 0 * * *";
+
+	beforeEach(() => {
+		mocks.findBackupById.mockReset();
+		mocks.updateBackupById.mockReset();
+		mocks.removeJob.mockClear();
+		mocks.updateJob.mockClear();
+		mocks.schedule.mockClear();
+		mocks.checkServicePermissionAndAccess.mockClear();
+		mocks.audit.mockClear();
+	});
+
+	it("removes the repeatable job using the PRE-update cron when cron changes and enabled is flipped off", async () => {
+		// 1st read: pre-update row (scheduled with OLD_CRON, enabled).
+		// 2nd read: post-update row (NEW_CRON, disabled).
+		mocks.findBackupById
+			.mockResolvedValueOnce(buildBackup({ schedule: OLD_CRON, enabled: true }))
+			.mockResolvedValueOnce(
+				buildBackup({ schedule: NEW_CRON, enabled: false }),
+			);
+
+		const caller = backupRouter.createCaller(ctx());
+		await caller.update({
+			backupId: "backup-1",
+			schedule: NEW_CRON,
+			enabled: false,
+		} as any);
+
+		// The disable branch must remove using the stored (old) cron, not the
+		// post-update cron — otherwise the BullMQ repeatable member keyed by
+		// OLD_CRON is left in Redis and keeps firing.
+		expect(mocks.removeJob).toHaveBeenCalledTimes(1);
+		expect(mocks.removeJob).toHaveBeenCalledWith({
+			cronSchedule: OLD_CRON,
+			backupId: "backup-1",
+			type: "backup",
+		});
+		expect(mocks.updateJob).not.toHaveBeenCalled();
+	});
+
+	it("still removes correctly when only disabling (cron unchanged)", async () => {
+		mocks.findBackupById
+			.mockResolvedValueOnce(buildBackup({ schedule: OLD_CRON, enabled: true }))
+			.mockResolvedValueOnce(
+				buildBackup({ schedule: OLD_CRON, enabled: false }),
+			);
+
+		const caller = backupRouter.createCaller(ctx());
+		await caller.update({
+			backupId: "backup-1",
+			schedule: OLD_CRON,
+			enabled: false,
+		} as any);
+
+		expect(mocks.removeJob).toHaveBeenCalledTimes(1);
+		expect(mocks.removeJob).toHaveBeenCalledWith({
+			cronSchedule: OLD_CRON,
+			backupId: "backup-1",
+			type: "backup",
+		});
+		expect(mocks.updateJob).not.toHaveBeenCalled();
+	});
+
+	it("does not regress the enabled path: updateJob receives the post-update cron", async () => {
+		mocks.findBackupById
+			.mockResolvedValueOnce(buildBackup({ schedule: OLD_CRON, enabled: true }))
+			.mockResolvedValueOnce(
+				buildBackup({ schedule: NEW_CRON, enabled: true }),
+			);
+
+		const caller = backupRouter.createCaller(ctx());
+		await caller.update({
+			backupId: "backup-1",
+			schedule: NEW_CRON,
+			enabled: true,
+		} as any);
+
+		// The enabled branch delegates to /update-backup (which does its own
+		// getJobRepeatable lookup), so it receives the NEW cron to reschedule.
+		expect(mocks.updateJob).toHaveBeenCalledTimes(1);
+		expect(mocks.updateJob).toHaveBeenCalledWith({
+			cronSchedule: NEW_CRON,
+			backupId: "backup-1",
+			type: "backup",
+		});
+		expect(mocks.removeJob).not.toHaveBeenCalled();
+	});
+});

apps/dokploy/__test__/backups/schedules-runJobs-gate.test.ts

@@ -0,0 +1,269 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Defense-in-depth gate test for `apps/schedules/src/utils.ts` `runJobs`
+ * `backup` branch (G6, G7).
+ *
+ * `runJobs` is imported directly from the schedules service source (via
+ * relative path) so this exercises the real module. `bullmq` is mocked so the
+ * module-load-time `new Queue("backupQueue", { connection: ... })` in `queue.ts`
+ * does not open a Redis connection. The `@dokploy/server` barrel and the
+ * schedules `logger` are mocked so we can assert dispatch behaviour.
+ */
+
+const mocks = vi.hoisted(() => ({
+	findBackupById: vi.fn(),
+	findServerById: vi.fn(),
+	findScheduleById: vi.fn(),
+	findVolumeBackupById: vi.fn(),
+	runPostgresBackup: vi.fn().mockResolvedValue(undefined),
+	runMySqlBackup: vi.fn().mockResolvedValue(undefined),
+	runMongoBackup: vi.fn().mockResolvedValue(undefined),
+	runMariadbBackup: vi.fn().mockResolvedValue(undefined),
+	runLibsqlBackup: vi.fn().mockResolvedValue(undefined),
+	runComposeBackup: vi.fn().mockResolvedValue(undefined),
+	runVolumeBackup: vi.fn().mockResolvedValue(undefined),
+	keepLatestNBackups: vi.fn().mockResolvedValue(undefined),
+	runCommand: vi.fn().mockResolvedValue(undefined),
+	cleanupAll: vi.fn().mockResolvedValue(undefined),
+	loggerInfo: vi.fn(),
+	loggerError: vi.fn(),
+}));
+
+// Mock the schedules queue module (imported by utils.ts as ./queue.js) so the
+// real `queue.ts` — which instantiates `new Queue("backupQueue", { connection })`
+// and would connect to Redis — is never loaded. Mocking by the path utils.ts
+// resolves (`./queue.js` -> apps/schedules/src/queue.ts) ensures the stub is
+// used; a bare `vi.mock("bullmq")` would NOT match because pnpm's nested
+// node_modules resolves the schedules package's `bullmq` to a different
+// physical path than this test file's.
+vi.mock("../../../schedules/src/queue", () => ({
+	jobQueue: {
+		add: vi.fn(),
+		removeRepeatable: vi.fn(),
+		getRepeatableJobs: vi.fn().mockResolvedValue([]),
+		obliterate: vi.fn(),
+	},
+	scheduleJob: vi.fn().mockResolvedValue(undefined),
+	removeJob: vi.fn().mockResolvedValue(true),
+	getJobRepeatable: vi.fn().mockResolvedValue(null),
+	cleanQueue: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Mock the schedules logger (imported by utils.ts as ./logger.js).
+vi.mock("../../../schedules/src/logger", () => ({
+	logger: { info: mocks.loggerInfo, error: mocks.loggerError, warn: vi.fn() },
+}));
+
+vi.mock("@dokploy/server", () => ({
+	findBackupById: mocks.findBackupById,
+	findScheduleById: mocks.findScheduleById,
+	findServerById: mocks.findServerById,
+	findVolumeBackupById: mocks.findVolumeBackupById,
+	keepLatestNBackups: mocks.keepLatestNBackups,
+	runCommand: mocks.runCommand,
+	runComposeBackup: mocks.runComposeBackup,
+	runLibsqlBackup: mocks.runLibsqlBackup,
+	runMariadbBackup: mocks.runMariadbBackup,
+	runMongoBackup: mocks.runMongoBackup,
+	runMySqlBackup: mocks.runMySqlBackup,
+	runPostgresBackup: mocks.runPostgresBackup,
+	runVolumeBackup: mocks.runVolumeBackup,
+	cleanupAll: mocks.cleanupAll,
+	CLEANUP_CRON_JOB: "0 0 * * *",
+}));
+
+// Relative import to the real schedules source (resolved by vite).
+import { runJobs } from "../../../schedules/src/utils";
+
+const activeServer = { serverStatus: "active" } as const;
+
+describe("runJobs — backup enabled gate (G6)", () => {
+	beforeEach(() => {
+		mocks.findBackupById.mockReset();
+		mocks.findServerById.mockReset();
+		mocks.findScheduleById.mockReset();
+		mocks.findVolumeBackupById.mockReset();
+		for (const fn of [
+			mocks.runPostgresBackup,
+			mocks.runMySqlBackup,
+			mocks.runMongoBackup,
+			mocks.runMariadbBackup,
+			mocks.runLibsqlBackup,
+			mocks.runComposeBackup,
+			mocks.runVolumeBackup,
+			mocks.keepLatestNBackups,
+			mocks.runCommand,
+			mocks.cleanupAll,
+			mocks.loggerInfo,
+			mocks.loggerError,
+		]) {
+			fn.mockClear();
+		}
+		mocks.findServerById.mockResolvedValue(activeServer);
+	});
+
+	it("skips a disabled (enabled=false) postgres backup without dispatching", async () => {
+		mocks.findBackupById.mockResolvedValue({
+			enabled: false,
+			databaseType: "postgres",
+			backupType: "database",
+			postgres: { serverId: "s1" },
+		});
+
+		await runJobs({
+			type: "backup",
+			backupId: "b1",
+			cronSchedule: "*/2 * * * *",
+		});
+
+		expect(mocks.runPostgresBackup).not.toHaveBeenCalled();
+		expect(mocks.keepLatestNBackups).not.toHaveBeenCalled();
+		expect(mocks.loggerInfo).toHaveBeenCalledWith(
+			"Backup b1 is disabled; skipping",
+		);
+	});
+
+	it("skips a backup whose enabled is null (treats as falsy)", async () => {
+		mocks.findBackupById.mockResolvedValue({
+			enabled: null,
+			databaseType: "mysql",
+			backupType: "database",
+			mysql: { serverId: "s1" },
+		});
+
+		await runJobs({
+			type: "backup",
+			backupId: "b2",
+			cronSchedule: "*/2 * * * *",
+		});
+
+		expect(mocks.runMySqlBackup).not.toHaveBeenCalled();
+		expect(mocks.keepLatestNBackups).not.toHaveBeenCalled();
+	});
+
+	it("skips a disabled compose backup without dispatching", async () => {
+		mocks.findBackupById.mockResolvedValue({
+			enabled: false,
+			backupType: "compose",
+			compose: { serverId: "s1" },
+		});
+
+		await runJobs({
+			type: "backup",
+			backupId: "b3",
+			cronSchedule: "0 0 * * *",
+		});
+
+		expect(mocks.runComposeBackup).not.toHaveBeenCalled();
+		expect(mocks.keepLatestNBackups).not.toHaveBeenCalled();
+	});
+
+	it("does not gate schedule jobs (already gated on schedule.enabled, unchanged behaviour)", async () => {
+		// schedule disabled → runCommand NOT called; schedule enabled → runCommand called.
+		mocks.findScheduleById.mockResolvedValue({ enabled: false });
+		await runJobs({
+			type: "schedule",
+			scheduleId: "s1",
+			cronSchedule: "*/2 * * * *",
+		});
+		expect(mocks.runCommand).not.toHaveBeenCalled();
+
+		mocks.findScheduleById.mockResolvedValue({ enabled: true });
+		await runJobs({
+			type: "schedule",
+			scheduleId: "s2",
+			cronSchedule: "*/2 * * * *",
+		});
+		expect(mocks.runCommand).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not gate volume-backup jobs (already gated on volumeBackup.enabled)", async () => {
+		mocks.findVolumeBackupById.mockResolvedValue({ enabled: false });
+		await runJobs({
+			type: "volume-backup",
+			volumeBackupId: "v1",
+			cronSchedule: "*/2 * * * *",
+		});
+		expect(mocks.runVolumeBackup).not.toHaveBeenCalled();
+	});
+});
+
+describe("runJobs — backup enabled dispatch still runs (G7)", () => {
+	beforeEach(() => {
+		mocks.findBackupById.mockReset();
+		mocks.findServerById.mockReset();
+		for (const fn of [
+			mocks.runPostgresBackup,
+			mocks.runMySqlBackup,
+			mocks.runMongoBackup,
+			mocks.runMariadbBackup,
+			mocks.runLibsqlBackup,
+			mocks.runComposeBackup,
+			mocks.keepLatestNBackups,
+			mocks.loggerInfo,
+		]) {
+			fn.mockClear();
+		}
+		mocks.findServerById.mockResolvedValue(activeServer);
+	});
+
+	const cases: Array<
+		[string, Record<string, unknown>, ReturnType<typeof vi.fn>]
+	> = [
+		[
+			"postgres",
+			{ databaseType: "postgres", backupType: "database" },
+			mocks.runPostgresBackup,
+		],
+		[
+			"mysql",
+			{ databaseType: "mysql", backupType: "database" },
+			mocks.runMySqlBackup,
+		],
+		[
+			"mongo",
+			{ databaseType: "mongo", backupType: "database" },
+			mocks.runMongoBackup,
+		],
+		[
+			"mariadb",
+			{ databaseType: "mariadb", backupType: "database" },
+			mocks.runMariadbBackup,
+		],
+		[
+			"libsql",
+			{ databaseType: "libsql", backupType: "database" },
+			mocks.runLibsqlBackup,
+		],
+		[
+			"compose",
+			{ backupType: "compose" } as Record<string, unknown>,
+			mocks.runComposeBackup,
+		],
+	];
+
+	for (const [label, over, runFn] of cases) {
+		it(`enabled=true ${label} backup dispatches to run*Backup + keepLatestNBackups`, async () => {
+			mocks.findBackupById.mockResolvedValue({
+				enabled: true,
+				postgres: { serverId: "s1" },
+				mysql: { serverId: "s1" },
+				mongo: { serverId: "s1" },
+				mariadb: { serverId: "s1" },
+				libsql: { serverId: "s1" },
+				compose: { serverId: "s1" },
+				...over,
+			} as any);
+
+			await runJobs({
+				type: "backup",
+				backupId: "b1",
+				cronSchedule: "*/2 * * * *",
+			});
+
+			expect(runFn).toHaveBeenCalledTimes(1);
+			expect(mocks.keepLatestNBackups).toHaveBeenCalledTimes(1);
+		});
+	}
+});

apps/dokploy/__test__/compose/compose-pull-images.test.ts

@@ -1,44 +0,0 @@
-import { createCommand } from "@dokploy/server/utils/builders/compose";
-import { describe, expect, it } from "vitest";
-
-const base = {
-	composeType: "docker-compose" as const,
-	appName: "compose-app",
-	sourceType: "github" as const,
-	composePath: "./docker-compose.yml",
-	command: "",
-};
-
-describe("compose createCommand --pull always", () => {
-	it("adds --pull always when pullImages is enabled", () => {
-		const cmd = createCommand({ ...base, pullImages: true } as any);
-
-		expect(cmd).toContain("up -d --build --remove-orphans --pull always");
-	});
-
-	it("omits --pull when pullImages is disabled", () => {
-		const cmd = createCommand({ ...base, pullImages: false } as any);
-
-		expect(cmd).not.toContain("--pull");
-	});
-
-	it("does not add --pull to stack deploy", () => {
-		const cmd = createCommand({
-			...base,
-			composeType: "stack",
-			pullImages: true,
-		} as any);
-
-		expect(cmd).not.toContain("--pull");
-	});
-
-	it("leaves a custom command untouched", () => {
-		const cmd = createCommand({
-			...base,
-			command: "compose -p compose-app up -d",
-			pullImages: true,
-		} as any);
-
-		expect(cmd).toBe("compose -p compose-app up -d");
-	});
-});

apps/dokploy/__test__/dns/cloudflare.test.ts

@@ -323,11 +323,9 @@ describe("cloudflareClient.upsertRecord", () => {
 		expect(createInit.method).toBe("POST");
 	});
 
-	it("updates the existing record when content matches", async () => {
+	it("updates the existing record instead of creating a duplicate", async () => {
 		mockFetch
-			.mockResolvedValueOnce(
-				cfSuccess([{ id: "existing-1", type: "A", content: "5.6.7.8" }]),
-			)
+			.mockResolvedValueOnce(cfSuccess([{ id: "existing-1" }]))
 			.mockResolvedValueOnce(cfSuccess({ id: "existing-1" }));
 
 		const result = await cloudflareClient.upsertRecord(config, {
@@ -346,25 +344,6 @@ describe("cloudflareClient.upsertRecord", () => {
 		expect(updateInit.method).toBe("PUT");
 	});
 
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				cfSuccess([{ id: "existing-1", type: "A", content: "1.1.1.1" }]),
-			)
-			.mockResolvedValueOnce(cfSuccess({ id: "new-2" }));
-
-		const result = await cloudflareClient.upsertRecord(config, {
-			zoneId: "zone-1",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "new-2" });
-		const [, createInit] = mockFetch.mock.calls[1] as [string, RequestInit];
-		expect(createInit.method).toBe("POST");
-	});
-
 	it("defaults ttl to 1 (automatic) when not provided", async () => {
 		mockFetch
 			.mockResolvedValueOnce(cfSuccess([]))

apps/dokploy/__test__/dns/infomaniak.test.ts

@@ -1,486 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { infomaniakClient } from "@dokploy/server/utils/dns/infomaniak";
-
-const jsonResponse = (body: unknown, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		json: async () => body,
-	}) as Response;
-
-const ikSuccess = (data: unknown) => jsonResponse({ result: "success", data });
-
-const ikPage = (data: unknown, page: number, pages: number) =>
-	jsonResponse({ result: "success", data, page, pages });
-
-const ikError = (description: string, status = 400) =>
-	jsonResponse(
-		{ result: "error", error: { code: "not_authorized", description } },
-		false,
-		status,
-	);
-
-const config = {
-	providerType: "infomaniak" as const,
-	apiToken: "ik_test_token",
-};
-
-const lastCall = () =>
-	mockFetch.mock.calls.at(-1) as [string, RequestInit & { method?: string }];
-
-const lastBody = () => JSON.parse(lastCall()[1].body as string);
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("infomaniakClient.listZones", () => {
-	it("exposes each domain product as a zone keyed by its name", async () => {
-		mockFetch.mockResolvedValue(
-			ikPage(
-				[
-					{ id: 1, customer_name: "example.com" },
-					{ id: 2, customer_name: "example.ch" },
-				],
-				1,
-				1,
-			),
-		);
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones).toEqual([
-			{ id: "example.com", name: "example.com" },
-			{ id: "example.ch", name: "example.ch" },
-		]);
-		const [url, init] = lastCall();
-		// The documented endpoint is the plural one; the singular is legacy and
-		// returns no pagination metadata at all.
-		expect(url).toContain("/1/products?service_name=domain");
-		expect(url).toContain("page=1");
-		expect(init.headers).toMatchObject({
-			Authorization: "Bearer ik_test_token",
-		});
-	});
-
-	it("walks every page so accounts with many domains keep all their zones", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikPage([{ id: 1, customer_name: "a.com" }], 1, 3))
-			.mockResolvedValueOnce(ikPage([{ id: 2, customer_name: "b.com" }], 2, 3))
-			.mockResolvedValueOnce(ikPage([{ id: 3, customer_name: "c.com" }], 3, 3));
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones.map((zone) => zone.name)).toEqual(["a.com", "b.com", "c.com"]);
-		expect(mockFetch).toHaveBeenCalledTimes(3);
-		expect((mockFetch.mock.calls[2] as [string])[0]).toContain("page=3");
-	});
-
-	it("stops after a single page when the response has no pagination", async () => {
-		mockFetch.mockResolvedValue(ikSuccess([{ id: 1, customer_name: "a.com" }]));
-
-		const zones = await infomaniakClient.listZones(config);
-
-		expect(zones).toEqual([{ id: "a.com", name: "a.com" }]);
-		expect(mockFetch).toHaveBeenCalledTimes(1);
-	});
-
-	it("propagates the API error description", async () => {
-		mockFetch.mockResolvedValue(ikError("Authorization required", 401));
-
-		await expect(infomaniakClient.listZones(config)).rejects.toThrow(
-			"Authorization required",
-		);
-	});
-});
-
-describe("infomaniakClient.listRecords", () => {
-	it("rebuilds the fqdn from the relative source", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{ id: 10, type: "A", source: "app", target: "1.2.3.4", ttl: 300 },
-				{ id: 11, type: "A", source: "", target: "5.6.7.8", ttl: 600 },
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records).toEqual([
-			{
-				id: "10",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 300,
-			},
-			{
-				id: "11",
-				type: "A",
-				name: "example.com",
-				content: "5.6.7.8",
-				ttl: 600,
-			},
-		]);
-		expect(lastCall()[0]).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records?with=records_description",
-		);
-	});
-
-	it.each([".", "", "@"])("treats a %s source as the apex", async (source) => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([{ id: 12, type: "A", source, target: "1.2.3.4", ttl: 300 }]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.name).toBe("example.com");
-	});
-
-	it("unquotes TXT targets", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{
-					id: 13,
-					type: "TXT",
-					source: "_acme-challenge",
-					target: '"token-value"',
-					ttl: 300,
-				},
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.content).toBe("token-value");
-	});
-
-	it("leaves a CAA target untouched", async () => {
-		mockFetch.mockResolvedValue(
-			ikSuccess([
-				{
-					id: 14,
-					type: "CAA",
-					source: "",
-					target: '0 issue "letsencrypt.org"',
-					ttl: 300,
-				},
-			]),
-		);
-
-		const records = await infomaniakClient.listRecords(config, "example.com");
-
-		expect(records[0]?.content).toBe('0 issue "letsencrypt.org"');
-	});
-});
-
-describe("infomaniakClient.upsertRecord", () => {
-	it("creates the record when no matching source and type exists", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 42 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 600,
-		});
-
-		expect(result).toEqual({ id: "42" });
-		const [url, init] = lastCall();
-		expect(url).toBe("https://api.infomaniak.com/2/zones/example.com/records");
-		expect(init.method).toBe("POST");
-		expect(lastBody()).toEqual({
-			type: "A",
-			source: "app",
-			target: "1.2.3.4",
-			ttl: 600,
-		});
-	});
-
-	it("updates the existing record when content matches", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{ id: 7, type: "A", source: "app", target: "1.2.3.4", ttl: 300 },
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 7 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "7" });
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("PUT");
-		expect(lastBody().ttl).toBe(300);
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{ id: 7, type: "A", source: "app", target: "1.1.1.1", ttl: 300 },
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 50 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "50" });
-		const [url, init] = lastCall();
-		expect(url).toBe("https://api.infomaniak.com/2/zones/example.com/records");
-		expect(init.method).toBe("POST");
-	});
-
-	it("writes a root dot as the source for an apex record and strips the trailing dot", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 43 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "example.com.",
-			content: "1.2.3.4",
-		});
-
-		expect(lastBody().source).toBe(".");
-	});
-
-	it.each([".", "", "@"])(
-		"matches an existing apex record stored with a %s source",
-		async (source) => {
-			mockFetch
-				.mockResolvedValueOnce(
-					ikSuccess([
-						{ id: 8, type: "A", source, target: "1.2.3.4", ttl: 3600 },
-					]),
-				)
-				.mockResolvedValueOnce(ikSuccess({ id: 8 }));
-
-			const result = await infomaniakClient.upsertRecord(config, {
-				zoneId: "example.com",
-				type: "A",
-				name: "example.com",
-				content: "1.2.3.4",
-			});
-
-			expect(result).toEqual({ id: "8" });
-			expect(lastCall()[1].method).toBe("PUT");
-		},
-	);
-
-	it("matches the existing apex record instead of creating a duplicate", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{
-						id: 8,
-						type: "TXT",
-						source: ".",
-						target: '"v=spf1 -all"',
-						ttl: 3600,
-					},
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 8 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "example.com",
-			content: "v=spf1 -all",
-		});
-
-		expect(result).toEqual({ id: "8" });
-		const [url, init] = lastCall();
-		expect(init.method).toBe("PUT");
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/8",
-		);
-		expect(lastBody().target).toBe('"v=spf1 -all"');
-	});
-
-	it("quotes a TXT target on write", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 44 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "_acme-challenge.example.com",
-			content: "token-value",
-		});
-
-		expect(lastBody().target).toBe('"token-value"');
-	});
-
-	it("does not double-quote a TXT target that is already quoted", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 45 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "TXT",
-			name: "_acme-challenge.example.com",
-			content: '"token-value"',
-		});
-
-		expect(lastBody().target).toBe('"token-value"');
-	});
-
-	it("queries the API with a source and type filter instead of the whole zone", async () => {
-		mockFetch
-			.mockResolvedValueOnce(ikSuccess([]))
-			.mockResolvedValueOnce(ikSuccess({ id: 50 }));
-
-		await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		const [url] = mockFetch.mock.calls[0] as [string];
-		expect(url).toContain("filter%5Bsource%5D=app");
-		expect(url).toContain("filter%5Btypes%5D%5B%5D=A");
-	});
-
-	it("ignores a partial filter hit rather than overwriting a different record", async () => {
-		// filter[source] matches substrings: asking for "auto" also returns
-		// "autoconfig" and "autodiscover". Trusting it would overwrite one of them.
-		mockFetch
-			.mockResolvedValueOnce(
-				ikSuccess([
-					{
-						id: 61,
-						type: "CNAME",
-						source: "autoconfig",
-						target: "a.example.net",
-						ttl: 300,
-					},
-					{
-						id: 62,
-						type: "CNAME",
-						source: "autodiscover",
-						target: "b.example.net",
-						ttl: 300,
-					},
-				]),
-			)
-			.mockResolvedValueOnce(ikSuccess({ id: 63 }));
-
-		const result = await infomaniakClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "CNAME",
-			name: "auto.example.com",
-			content: "c.example.net",
-		});
-
-		expect(result).toEqual({ id: "63" });
-		expect(lastCall()[1].method).toBe("POST");
-	});
-});
-
-describe("infomaniakClient.updateRecord", () => {
-	it("updates the record and keeps its id", async () => {
-		mockFetch.mockResolvedValue(ikSuccess({ id: 7 }));
-
-		const result = await infomaniakClient.updateRecord(
-			config,
-			"example.com",
-			"7",
-			{
-				type: "CNAME",
-				name: "www.example.com",
-				content: "example.com",
-				ttl: 900,
-			},
-		);
-
-		expect(result).toEqual({ id: "7" });
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("PUT");
-		expect(lastBody()).toEqual({
-			type: "CNAME",
-			source: "www",
-			target: "example.com",
-			ttl: 900,
-		});
-	});
-
-	it("falls back to the default ttl when none is provided", async () => {
-		mockFetch.mockResolvedValue(ikSuccess({ id: 7 }));
-
-		await infomaniakClient.updateRecord(config, "example.com", "7", {
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(lastBody().ttl).toBe(300);
-	});
-});
-
-describe("infomaniakClient.deleteRecord", () => {
-	it("deletes the record", async () => {
-		mockFetch.mockResolvedValue(ikSuccess(null));
-
-		await infomaniakClient.deleteRecord(config, "example.com", "7");
-
-		const [url, init] = lastCall();
-		expect(url).toBe(
-			"https://api.infomaniak.com/2/zones/example.com/records/7",
-		);
-		expect(init.method).toBe("DELETE");
-	});
-
-	it("propagates a delete failure", async () => {
-		mockFetch.mockResolvedValue(ikError("Record not found", 404));
-
-		await expect(
-			infomaniakClient.deleteRecord(config, "example.com", "7"),
-		).rejects.toThrow("Record not found");
-	});
-});
-
-describe("infomaniakClient.testConnection", () => {
-	it("resolves when the domain listing succeeds", async () => {
-		mockFetch.mockResolvedValue(ikSuccess([]));
-
-		await expect(
-			infomaniakClient.testConnection(config),
-		).resolves.toBeUndefined();
-	});
-
-	it("rejects on an invalid token", async () => {
-		mockFetch.mockResolvedValue(ikError("Authorization required", 401));
-
-		await expect(infomaniakClient.testConnection(config)).rejects.toThrow(
-			"Infomaniak: request to /1/products?service_name=domain&per_page=1 failed: Authorization required",
-		);
-	});
-});

apps/dokploy/__test__/dns/ovh.test.ts

@@ -1,581 +0,0 @@
-import { createHash } from "node:crypto";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockFetch = vi.fn();
-global.fetch = mockFetch as typeof fetch;
-
-import { ovhClient } from "@dokploy/server/utils/dns/ovh";
-
-const textResponse = (body: string, ok = true, status = 200) =>
-	({
-		ok,
-		status,
-		text: async () => body,
-	}) as Response;
-
-const ovhSuccess = (data: unknown) =>
-	textResponse(data === undefined ? "" : JSON.stringify(data));
-
-const ovhError = (message: string, status = 403) =>
-	textResponse(JSON.stringify({ message }), false, status);
-
-const SERVER_TIME = 1788268225;
-
-const config = {
-	providerType: "ovh" as const,
-	endpoint: "ovh-eu" as const,
-	applicationKey: "app-key",
-	applicationSecret: "app-secret",
-	consumerKey: "consumer-key",
-};
-
-// Each test uses a distinct endpoint so the module-level clock-skew cache, which
-// is keyed by base url, never leaks a measurement between them.
-let endpointCursor = 0;
-const endpoints = [
-	"ovh-eu",
-	"ovh-ca",
-	"ovh-us",
-	"kimsufi-eu",
-	"kimsufi-ca",
-	"soyoustart-eu",
-	"soyoustart-ca",
-] as const;
-const baseUrls: Record<(typeof endpoints)[number], string> = {
-	"ovh-eu": "https://eu.api.ovh.com/1.0",
-	"ovh-ca": "https://ca.api.ovh.com/1.0",
-	"ovh-us": "https://api.us.ovhcloud.com/1.0",
-	"kimsufi-eu": "https://eu.api.kimsufi.com/1.0",
-	"kimsufi-ca": "https://ca.api.kimsufi.com/1.0",
-	"soyoustart-eu": "https://eu.api.soyoustart.com/1.0",
-	"soyoustart-ca": "https://ca.api.soyoustart.com/1.0",
-};
-
-/** A config on a not-yet-used endpoint, so the first call always fetches /auth/time. */
-const freshConfig = () => {
-	const endpoint = endpoints[
-		endpointCursor % endpoints.length
-	] as (typeof endpoints)[number];
-	endpointCursor += 1;
-	return { ...config, endpoint, baseUrl: baseUrls[endpoint] };
-};
-
-/** Replies to /auth/time, then to each queued API response in order. */
-const mockApi = (...responses: Response[]) => {
-	let call = 0;
-	mockFetch.mockImplementation((url: string) => {
-		if (url.endsWith("/auth/time")) {
-			return Promise.resolve(textResponse(String(SERVER_TIME)));
-		}
-		const response = responses[call];
-		call += 1;
-		return Promise.resolve(response ?? ovhSuccess(null));
-	});
-};
-
-const apiCalls = () =>
-	mockFetch.mock.calls.filter(
-		([url]) => !(url as string).endsWith("/auth/time"),
-	) as [string, RequestInit][];
-
-beforeEach(() => {
-	mockFetch.mockReset();
-});
-
-describe("ovhClient request signing", () => {
-	it("signs the request with the API server clock, not the local one", async () => {
-		const { baseUrl, ...cfg } = freshConfig();
-		mockApi(ovhSuccess(["example.com"]));
-		vi.spyOn(Date, "now").mockReturnValue((SERVER_TIME - 120) * 1000);
-
-		await ovhClient.listZones(cfg);
-
-		const [url, init] = apiCalls()[0] as [string, RequestInit];
-		const headers = init.headers as Record<string, string>;
-		expect(url).toBe(`${baseUrl}/domain/zone`);
-		expect(headers["X-Ovh-Timestamp"]).toBe(String(SERVER_TIME));
-		expect(headers["X-Ovh-Application"]).toBe("app-key");
-		expect(headers["X-Ovh-Consumer"]).toBe("consumer-key");
-
-		const expected = createHash("sha1")
-			.update(
-				["app-secret", "consumer-key", "GET", url, "", SERVER_TIME].join("+"),
-			)
-			.digest("hex");
-		expect(headers["X-Ovh-Signature"]).toBe(`$1$${expected}`);
-
-		vi.restoreAllMocks();
-	});
-
-	it("signs a request body when one is sent", async () => {
-		const { baseUrl, ...cfg } = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 5 }), ovhSuccess(null));
-		vi.spyOn(Date, "now").mockReturnValue(SERVER_TIME * 1000);
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		const [url, init] = apiCalls()[1] as [string, RequestInit];
-		const headers = init.headers as Record<string, string>;
-		const body = init.body as string;
-		expect(body).not.toBe("");
-		const expected = createHash("sha1")
-			.update(
-				["app-secret", "consumer-key", "POST", url, body, SERVER_TIME].join(
-					"+",
-				),
-			)
-			.digest("hex");
-		expect(headers["X-Ovh-Signature"]).toBe(`$1$${expected}`);
-
-		vi.restoreAllMocks();
-	});
-});
-
-describe("ovhClient.listZones", () => {
-	it("maps each zone name to a zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess(["example.com", "example.fr"]));
-
-		const zones = await ovhClient.listZones(cfg);
-
-		expect(zones).toEqual([
-			{ id: "example.com", name: "example.com" },
-			{ id: "example.fr", name: "example.fr" },
-		]);
-	});
-
-	it("names the missing root right when OVH refuses the zone listing", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("This call has not been granted", 403));
-
-		// A `GET /domain/zone/*` rule does not cover the bare `GET /domain/zone`,
-		// so the raw OVH message would send users looking in the wrong place.
-		await expect(ovhClient.listZones(cfg)).rejects.toThrow(
-			/missing the `GET \/domain\/zone` right/,
-		);
-	});
-
-	it("propagates the API error message", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("Invalid signature", 403));
-
-		await expect(ovhClient.listZones(cfg)).rejects.toThrow("Invalid signature");
-	});
-});
-
-describe("ovhClient.listRecords", () => {
-	it("resolves each id into a full record", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([1, 2]),
-			ovhSuccess({
-				id: 1,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.2.3.4",
-				ttl: 600,
-			}),
-			ovhSuccess({
-				id: 2,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: null,
-				target: "5.6.7.8",
-				ttl: null,
-			}),
-		);
-
-		const records = await ovhClient.listRecords(cfg, "example.com");
-
-		expect(records).toEqual([
-			{
-				id: "1",
-				type: "A",
-				name: "app.example.com",
-				content: "1.2.3.4",
-				ttl: 600,
-			},
-			{
-				id: "2",
-				type: "A",
-				name: "example.com",
-				content: "5.6.7.8",
-				ttl: 0,
-			},
-		]);
-	});
-
-	it("keeps the records in the order of the returned ids", async () => {
-		const cfg = freshConfig();
-		const record = (id: number, subDomain: string) => ({
-			id,
-			zone: "example.com",
-			fieldType: "A",
-			subDomain,
-			target: `10.0.0.${id}`,
-			ttl: 60,
-		});
-		mockApi(
-			ovhSuccess([1, 2, 3, 4, 5]),
-			...[1, 2, 3, 4, 5].map((id) => ovhSuccess(record(id, `host${id}`))),
-		);
-
-		const records = await ovhClient.listRecords(cfg, "example.com");
-
-		expect(records.map((r) => r.id)).toEqual(["1", "2", "3", "4", "5"]);
-	});
-});
-
-describe("ovhClient.upsertRecord", () => {
-	it("creates the record then refreshes the zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 600,
-		});
-
-		expect(result).toEqual({ id: "9" });
-		const calls = apiCalls();
-		expect(calls[0]?.[0]).toContain(
-			"/domain/zone/example.com/record?fieldType=A&subDomain=app",
-		);
-		expect(calls[1]?.[1].method).toBe("POST");
-		expect(JSON.parse(calls[1]?.[1].body as string)).toEqual({
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.2.3.4",
-			ttl: 600,
-		});
-		expect(calls[2]?.[0]).toContain("/domain/zone/example.com/refresh");
-		expect(calls[2]?.[1].method).toBe("POST");
-	});
-
-	it("updates the existing record when content matches", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([4]),
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.2.3.4",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(result).toEqual({ id: "4" });
-		const calls = apiCalls();
-		expect(calls[2]?.[0]).toContain("/domain/zone/example.com/record/4");
-		expect(calls[2]?.[1].method).toBe("PUT");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("creates a new record when content differs from existing", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess([4]),
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess({ id: 10 }),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "10" });
-		const calls = apiCalls();
-		expect(calls[2]?.[1].method).toBe("POST");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("omits the ttl so OVH applies the zone default", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-		});
-
-		expect(JSON.parse(apiCalls()[1]?.[1].body as string)).not.toHaveProperty(
-			"ttl",
-		);
-	});
-
-	it("writes an empty subDomain for the apex and strips the trailing dot", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]), ovhSuccess({ id: 9 }), ovhSuccess(null));
-
-		await ovhClient.upsertRecord(cfg, {
-			zoneId: "example.com",
-			type: "A",
-			name: "example.com.",
-			content: "1.2.3.4",
-		});
-
-		expect(apiCalls()[0]?.[0]).toContain("subDomain=");
-		expect(JSON.parse(apiCalls()[1]?.[1].body as string).subDomain).toBe("");
-	});
-});
-
-describe("ovhClient.updateRecord", () => {
-	it("updates in place when the type is unchanged", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "A",
-			name: "app.example.com",
-			content: "1.2.3.4",
-			ttl: 300,
-		});
-
-		expect(result).toEqual({ id: "4" });
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("PUT");
-		expect(JSON.parse(calls[1]?.[1].body as string)).toEqual({
-			subDomain: "app",
-			target: "1.2.3.4",
-			ttl: 300,
-		});
-		expect(calls[2]?.[0]).toContain("/refresh");
-	});
-
-	it("replaces the record when the type changes, since PUT carries no fieldType", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess({ id: 11 }),
-			ovhSuccess(null),
-		);
-
-		const result = await ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "CNAME",
-			name: "app.example.com",
-			content: "example.com",
-		});
-
-		expect(result).toEqual({ id: "11" });
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("DELETE");
-		expect(calls[2]?.[1].method).toBe("POST");
-		expect(JSON.parse(calls[2]?.[1].body as string).fieldType).toBe("CNAME");
-		expect(calls[3]?.[0]).toContain("/refresh");
-	});
-
-	it("restores the original record when the replacement fails", async () => {
-		const cfg = freshConfig();
-		const original = {
-			id: 4,
-			zone: "example.com",
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.1.1.1",
-			ttl: 60,
-		};
-		mockApi(
-			ovhSuccess(original),
-			ovhSuccess(null),
-			ovhError("Invalid target", 400),
-			ovhSuccess({ id: 12 }),
-			ovhSuccess(null),
-		);
-
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "not a valid target",
-			}),
-		).rejects.toThrow("Invalid target");
-
-		const calls = apiCalls();
-		expect(calls[1]?.[1].method).toBe("DELETE");
-		expect(calls[2]?.[1].method).toBe("POST");
-		// The original record is put back with its own type, target and ttl.
-		expect(JSON.parse(calls[3]?.[1].body as string)).toEqual({
-			fieldType: "A",
-			subDomain: "app",
-			target: "1.1.1.1",
-			ttl: 60,
-		});
-		expect(calls[4]?.[0]).toContain("/refresh");
-	});
-
-	it("reports the lost record when the restore also fails", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhError("Invalid target", 400),
-			ovhError("Service unavailable", 503),
-		);
-
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "not a valid target",
-			}),
-		).rejects.toThrow(
-			/Recreate it manually: A app\.example\.com -> 1\.1\.1\.1/,
-		);
-	});
-
-	it("says the change was applied when only the zone refresh fails", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null),
-			ovhSuccess({ id: 11 }),
-			ovhError("Service unavailable", 503),
-		);
-
-		// The replacement succeeded, so the record exists at the provider — only
-		// publishing failed. Rolling back would destroy correct state.
-		await expect(
-			ovhClient.updateRecord(cfg, "example.com", "4", {
-				type: "CNAME",
-				name: "app.example.com",
-				content: "example.com",
-			}),
-		).rejects.toThrow(/was applied, but refreshing zone "example\.com" failed/);
-	});
-
-	it("does not tell the user to recreate a record that was restored but not published", async () => {
-		const cfg = freshConfig();
-		mockApi(
-			ovhSuccess({
-				id: 4,
-				zone: "example.com",
-				fieldType: "A",
-				subDomain: "app",
-				target: "1.1.1.1",
-				ttl: 60,
-			}),
-			ovhSuccess(null), // DELETE de l'ancien
-			ovhError("Invalid target", 400), // POST de remplacement -> échec
-			ovhSuccess({ id: 12 }), // POST de restauration -> succès
-			ovhError("Service unavailable", 503), // refresh -> échec
-		);
-
-		const attempt = ovhClient.updateRecord(cfg, "example.com", "4", {
-			type: "CNAME",
-			name: "app.example.com",
-			content: "not a valid target",
-		});
-
-		// L'enregistrement existe de nouveau chez OVH : le recréer le dupliquerait.
-		await expect(attempt).rejects.toThrow(/was restored, but refreshing zone/);
-		await expect(attempt).rejects.not.toThrow(/Recreate it manually/);
-	});
-});
-
-describe("ovhClient.deleteRecord", () => {
-	it("deletes the record then refreshes the zone", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess(null), ovhSuccess(null));
-
-		await ovhClient.deleteRecord(cfg, "example.com", "4");
-
-		const calls = apiCalls();
-		expect(calls[0]?.[0]).toContain("/domain/zone/example.com/record/4");
-		expect(calls[0]?.[1].method).toBe("DELETE");
-		expect(calls[1]?.[0]).toContain("/domain/zone/example.com/refresh");
-	});
-
-	it("does not refresh the zone when the delete fails", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("This object does not exist", 404));
-
-		await expect(
-			ovhClient.deleteRecord(cfg, "example.com", "4"),
-		).rejects.toThrow("This object does not exist");
-		expect(apiCalls()).toHaveLength(1);
-	});
-});
-
-describe("ovhClient.testConnection", () => {
-	it("resolves when the zone listing succeeds", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhSuccess([]));
-
-		await expect(ovhClient.testConnection(cfg)).resolves.toBeUndefined();
-	});
-
-	it("rejects on invalid credentials", async () => {
-		const cfg = freshConfig();
-		mockApi(ovhError("Invalid signature", 403));
-
-		await expect(ovhClient.testConnection(cfg)).rejects.toThrow(
-			"Invalid signature",
-		);
-	});
-});

apps/dokploy/__test__/dns/porkbun.test.ts

@@ -121,11 +121,9 @@ describe("porkbunClient.upsertRecord", () => {
 		expect(lookupUrl).toContain("/dns/retrieveByNameType/example.com/A/");
 	});
 
-	it("edits the existing record when content matches", async () => {
+	it("edits the existing record instead of creating a duplicate", async () => {
 		mockFetch
-			.mockResolvedValueOnce(
-				pbSuccess({ records: [{ id: "existing-1", content: "5.6.7.8" }] }),
-			)
+			.mockResolvedValueOnce(pbSuccess({ records: [{ id: "existing-1" }] }))
 			.mockResolvedValueOnce(pbSuccess({}));
 
 		const result = await porkbunClient.upsertRecord(config, {
@@ -140,30 +138,6 @@ describe("porkbunClient.upsertRecord", () => {
 		expect(editUrl).toContain("/dns/edit/example.com/existing-1");
 	});
 
-	it("creates a new record when content differs from existing", async () => {
-		mockFetch
-			.mockResolvedValueOnce(
-				pbSuccess({ records: [{ id: "existing-1", content: "1.1.1.1" }] }),
-			)
-			.mockResolvedValueOnce(pbSuccess({ id: "new-2" }));
-
-		const result = await porkbunClient.upsertRecord(config, {
-			zoneId: "example.com",
-			type: "A",
-			name: "app.example.com",
-			content: "5.6.7.8",
-		});
-
-		expect(result).toEqual({ id: "new-2" });
-		const [createUrl, createInit] = mockFetch.mock.calls[1] as [
-			string,
-			RequestInit,
-		];
-		expect(createUrl).toContain("/dns/create/example.com");
-		const body = JSON.parse(createInit.body as string);
-		expect(body).toMatchObject({ name: "app", type: "A", content: "5.6.7.8" });
-	});
-
 	it("defaults ttl to 600 when not provided", async () => {
 		mockFetch
 			.mockResolvedValueOnce(pbSuccess({ records: [] }))

apps/dokploy/__test__/domains/domain-validation.test.ts

@@ -1,149 +0,0 @@
-import os from "node:os";
-import {
-	getServerIpCandidates,
-	validateDomain,
-} from "@dokploy/server/services/domain";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-	execAsyncRemote: vi.fn(),
-	findServerById: vi.fn(),
-	getPublicIpWithFallback: vi.fn(),
-	getWebServerSettings: vi.fn(),
-	resolve4: vi.fn(),
-	resolve6: vi.fn(),
-}));
-
-vi.mock("node:dns", () => ({
-	default: {
-		resolve4: mocks.resolve4,
-		resolve6: mocks.resolve6,
-	},
-}));
-
-vi.mock("@dokploy/server/utils/process/execAsync", () => ({
-	execAsyncRemote: mocks.execAsyncRemote,
-}));
-
-vi.mock("@dokploy/server/services/server", () => ({
-	findServerById: mocks.findServerById,
-}));
-
-vi.mock("@dokploy/server/services/web-server-settings", () => ({
-	getWebServerSettings: mocks.getWebServerSettings,
-}));
-
-vi.mock("@dokploy/server/wss/utils", () => ({
-	getPublicIpWithFallback: mocks.getPublicIpWithFallback,
-}));
-
-describe("getServerIpCandidates", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-		vi.useRealTimers();
-	});
-
-	it("includes every address reported by a multi-homed remote server", async () => {
-		mocks.findServerById.mockResolvedValue({
-			ipAddress: "10.0.0.10",
-		});
-		mocks.execAsyncRemote.mockResolvedValue({
-			stdout: ["10.0.0.10", "192.0.2.10", "2001:db8::10"].join("\n"),
-			stderr: "",
-		});
-
-		await expect(getServerIpCandidates("server-id")).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-			"2001:db8::10",
-		]);
-		expect(mocks.execAsyncRemote).toHaveBeenCalledWith(
-			"server-id",
-			expect.stringContaining("ip -o addr show scope global"),
-		);
-	});
-
-	it("includes every address assigned to the local Dokploy host", async () => {
-		mocks.getWebServerSettings.mockResolvedValue({
-			serverIp: "10.0.0.10",
-		});
-		mocks.getPublicIpWithFallback.mockResolvedValue("2001:db8::10");
-		vi.spyOn(os, "networkInterfaces").mockReturnValue({
-			eth0: [
-				{
-					address: "192.0.2.10",
-					netmask: "255.255.255.0",
-					family: "IPv4",
-					mac: "00:00:00:00:00:00",
-					internal: false,
-					cidr: "192.0.2.10/24",
-				},
-			],
-		});
-
-		await expect(getServerIpCandidates()).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-			"2001:db8::10",
-		]);
-	});
-
-	it("retains remote interface addresses when public IP detection times out", async () => {
-		vi.useFakeTimers();
-		mocks.findServerById.mockResolvedValue({
-			ipAddress: "10.0.0.10",
-		});
-		mocks.execAsyncRemote.mockImplementation(
-			(_serverId: string, command: string) => {
-				if (command.includes("curl")) {
-					return new Promise(() => undefined);
-				}
-				return Promise.resolve({
-					stdout: "192.0.2.10\n",
-					stderr: "",
-				});
-			},
-		);
-
-		const candidatesPromise = getServerIpCandidates("server-id");
-		await vi.advanceTimersByTimeAsync(7000);
-
-		await expect(candidatesPromise).resolves.toEqual([
-			"10.0.0.10",
-			"192.0.2.10",
-		]);
-	});
-});
-
-describe("validateDomain", () => {
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("validates an IPv6-only domain against an IPv6 server address", async () => {
-		const noIpv4 = Object.assign(new Error("queryA ENODATA example.com"), {
-			code: "ENODATA",
-		});
-		mocks.resolve4.mockImplementation(
-			(_domain: string, callback: (error: Error | null) => void) =>
-				callback(noIpv4),
-		);
-		mocks.resolve6.mockImplementation(
-			(
-				_domain: string,
-				callback: (error: Error | null, addresses?: string[]) => void,
-			) => callback(null, ["2001:db8::10"]),
-		);
-
-		await expect(
-			validateDomain("example.com", ["2001:db8::10"]),
-		).resolves.toMatchObject({
-			isValid: true,
-			resolvedIp: "2001:db8::10",
-		});
-	});
-});

apps/dokploy/__test__/env/aws-parameter-store.test.ts

@@ -1,195 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-type HasInput = { input: Record<string, unknown> };
-
-const findMany = vi.hoisted(() => vi.fn());
-
-const {
-	send,
-	paginate,
-	SSMClient,
-	GetParametersCommand,
-	DescribeParametersCommand,
-} = vi.hoisted(() => {
-	class FakeCommand {
-		input: Record<string, unknown>;
-		constructor(input: Record<string, unknown>) {
-			this.input = input;
-		}
-	}
-	const send = vi.fn();
-	const paginate = vi.fn();
-	class SSMClient {
-		send(command: unknown) {
-			return send(command);
-		}
-	}
-	return {
-		send,
-		paginate,
-		SSMClient,
-		GetParametersCommand: class extends FakeCommand {},
-		DescribeParametersCommand: class extends FakeCommand {},
-	};
-});
-
-vi.mock("@aws-sdk/client-ssm", () => ({
-	SSMClient,
-	GetParametersCommand,
-	DescribeParametersCommand,
-	paginateDescribeParameters: paginate,
-}));
-
-vi.mock("@dokploy/server/db", () => ({
-	db: {
-		query: {
-			vaultProvider: {
-				findMany: (...args: unknown[]) => findMany(...args),
-			},
-		},
-	},
-}));
-
-import { resolveVaultReferences } from "@dokploy/server/utils/vault";
-import { awsParameterStoreClient } from "@dokploy/server/utils/vault/aws-parameter-store";
-
-const config = {
-	providerType: "aws-parameter-store" as const,
-	region: "eu-central-1",
-	accessKeyId: "AKIA_TEST",
-	secretAccessKey: "secret",
-};
-
-beforeEach(() => {
-	send.mockReset();
-	paginate.mockReset();
-	findMany.mockReset();
-});
-
-describe("awsParameterStoreClient", () => {
-	it("decrypts parameters in batches of ten and preserves selectors", async () => {
-		const refs = [
-			"/prod/database:CURRENT",
-			...Array.from({ length: 10 }, (_, index) => `/prod/secret-${index}`),
-		];
-		send.mockImplementation(async (command: HasInput) => ({
-			Parameters: (command.input.Names as string[]).map((ref) => {
-				if (ref === "/prod/database:CURRENT") {
-					return {
-						Name: "/prod/database",
-						Selector: ":CURRENT",
-						Value: "selected-value",
-					};
-				}
-				return { Name: ref, Value: `value-for-${ref}` };
-			}),
-		}));
-
-		const result = await awsParameterStoreClient.getSecrets(config, refs);
-
-		expect(send).toHaveBeenCalledTimes(2);
-		expect((send.mock.calls[0]?.[0] as HasInput).input).toMatchObject({
-			WithDecryption: true,
-		});
-		expect(
-			((send.mock.calls[0]?.[0] as HasInput).input.Names as string[]).length,
-		).toBe(10);
-		expect(
-			((send.mock.calls[1]?.[0] as HasInput).input.Names as string[]).length,
-		).toBe(1);
-		expect(result["/prod/database:CURRENT"]).toBe("selected-value");
-		expect(result["/prod/secret-9"]).toBe("value-for-/prod/secret-9");
-	});
-
-	it("reports a missing parameter without exposing other values", async () => {
-		send.mockResolvedValue({ Parameters: [], InvalidParameters: ["/missing"] });
-
-		await expect(
-			awsParameterStoreClient.getSecrets(config, ["/missing"]),
-		).rejects.toThrow('AWS Parameter Store: parameter "/missing" not found');
-	});
-
-	it("tests the connection within the configured hierarchy", async () => {
-		send.mockResolvedValue({ Parameters: [] });
-
-		await awsParameterStoreClient.testConnection({
-			...config,
-			parameterPath: "/production/my-app/",
-		});
-
-		expect(send).toHaveBeenCalledTimes(1);
-		expect((send.mock.calls[0]?.[0] as HasInput).input).toEqual({
-			ParameterFilters: [
-				{
-					Key: "Path",
-					Option: "Recursive",
-					Values: ["/production/my-app"],
-				},
-			],
-			MaxResults: 1,
-		});
-	});
-
-	it("explains the discovery permission when connection testing is denied", async () => {
-		const error = new Error("not authorized");
-		error.name = "AccessDeniedException";
-		send.mockRejectedValue(error);
-
-		await expect(
-			awsParameterStoreClient.testConnection(config),
-		).rejects.toThrow("ssm:DescribeParameters");
-	});
-
-	it("lists parameter names across pages within the configured hierarchy", async () => {
-		paginate.mockReturnValue(
-			(async function* () {
-				yield { Parameters: [{ Name: "/prod/db" }] };
-				yield { Parameters: [{ Name: "/prod/api" }] };
-			})(),
-		);
-
-		const names = await awsParameterStoreClient.listSecretNames?.({
-			...config,
-			parameterPath: " /production/my-app/ ",
-		});
-
-		expect(names).toEqual(["/prod/db", "/prod/api"]);
-		expect(paginate).toHaveBeenCalledWith(
-			expect.objectContaining({ pageSize: 50 }),
-			{
-				ParameterFilters: [
-					{
-						Key: "Path",
-						Option: "Recursive",
-						Values: ["/production/my-app"],
-					},
-				],
-			},
-		);
-	});
-
-	it("resolves a vault reference through the registered provider", async () => {
-		findMany.mockResolvedValue([
-			{
-				name: "ssm-prod",
-				providerType: "aws-parameter-store",
-				config,
-				assignments: [{ projectId: "project-1", environmentIds: [] }],
-			},
-		]);
-		send.mockResolvedValue({
-			Parameters: [{ Name: "/prod/database-password", Value: "resolved" }],
-		});
-
-		const result = await resolveVaultReferences(
-			"DB_PASSWORD=${{vault.ssm-prod./prod/database-password}}",
-			{
-				organizationId: "organization-1",
-				projectId: "project-1",
-				environmentId: "environment-1",
-			},
-		);
-
-		expect(result).toBe("DB_PASSWORD=resolved");
-	});
-});

apps/dokploy/__test__/env/vault.test.ts

@@ -20,7 +20,6 @@ import {
 import { azureClient } from "@dokploy/server/utils/vault/azure";
 import { dopplerClient } from "@dokploy/server/utils/vault/doppler";
 import { hashicorpClient } from "@dokploy/server/utils/vault/hashicorp";
-import { infisicalClient } from "@dokploy/server/utils/vault/infisical";
 import { phaseClient } from "@dokploy/server/utils/vault/phase";
 import { scalewayClient } from "@dokploy/server/utils/vault/scaleway";
 
@@ -432,152 +431,6 @@ describe("azure client", () => {
 	});
 });
 
-describe("infisical client", () => {
-	const config = {
-		providerType: "infisical" as const,
-		siteUrl: "https://app.infisical.com",
-		clientId: "client-1",
-		clientSecret: "client-secret",
-		projectId: "workspace-1",
-		environmentSlug: "prod",
-		secretPath: "/frontend",
-	};
-
-	const loginResponse = () => jsonResponse({ accessToken: "token-1" });
-	const list = (secrets: Record<string, string>) =>
-		jsonResponse({
-			secrets: Object.entries(secrets).map(([secretKey, secretValue]) => ({
-				secretKey,
-				secretValue,
-			})),
-		});
-	const listPathOf = (callIndex: number) => {
-		const [url] = mockFetch.mock.calls[callIndex] as [string];
-		return new URL(url).searchParams.get("secretPath");
-	};
-
-	it("asks the list endpoint to expand secret references", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ DB_URL: "postgres://real" }));
-
-		const result = await infisicalClient.getSecrets(config, ["DB_URL"]);
-
-		expect(result).toEqual({ DB_URL: "postgres://real" });
-		const [listUrl] = mockFetch.mock.calls[1] as [string];
-		const params = new URL(listUrl).searchParams;
-		expect(params.get("expandSecretReferences")).toBe("true");
-		expect(params.get("workspaceId")).toBe("workspace-1");
-		expect(params.get("environment")).toBe("prod");
-		expect(params.get("secretPath")).toBe("/frontend");
-	});
-
-	it("throws a clear error for a missing secret", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(jsonResponse({ secrets: [] }));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["ABSENT"]),
-		).rejects.toThrow('secret "ABSENT" not found in environment "prod"');
-	});
-
-	it("propagates authentication failures with the status code", async () => {
-		mockFetch.mockResolvedValueOnce(jsonResponse({}, false, 401));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["DB_URL"]),
-		).rejects.toThrow("authentication failed (status 401)");
-	});
-
-	it("resolves a relative <path>:<KEY> ref against the provider path", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ SENTRY_DSN: "https://key@sentry.io/1" }));
-
-		const result = await infisicalClient.getSecrets(config, [
-			"shared/sentry:SENTRY_DSN",
-		]);
-
-		expect(result).toEqual({
-			"shared/sentry:SENTRY_DSN": "https://key@sentry.io/1",
-		});
-		expect(listPathOf(1)).toBe("/frontend/shared/sentry");
-	});
-
-	it("treats a leading slash as an absolute path", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ SENTRY_DSN: "https://key@sentry.io/1" }));
-
-		await infisicalClient.getSecrets(config, ["/external/sentry:SENTRY_DSN"]);
-
-		expect(listPathOf(1)).toBe("/external/sentry");
-	});
-
-	it("keeps the root path clean when the provider sits at /", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({ KEY: "value" }));
-
-		await infisicalClient.getSecrets({ ...config, secretPath: "/" }, [
-			"external/sentry:KEY",
-		]);
-
-		expect(listPathOf(1)).toBe("/external/sentry");
-	});
-
-	it("logs in once and fetches each path once", async () => {
-		const byPath: Record<string, Record<string, string>> = {
-			"/frontend": { A: "a", B: "b" },
-			"/frontend/other": { C: "c" },
-		};
-		mockFetch.mockImplementation(async (url: string) => {
-			if (url.includes("/auth/universal-auth/login")) return loginResponse();
-			const path = new URL(url).searchParams.get("secretPath") as string;
-			return list(byPath[path] ?? {});
-		});
-
-		const result = await infisicalClient.getSecrets(config, [
-			"A",
-			"B",
-			"other:C",
-		]);
-
-		expect(result).toEqual({ A: "a", B: "b", "other:C": "c" });
-
-		const urls = mockFetch.mock.calls.map(([url]) => url as string);
-		expect(urls.filter((u) => u.includes("/login"))).toHaveLength(1);
-		expect(
-			urls
-				.filter((u) => u.includes("/secrets/raw?"))
-				.map((u) => new URL(u).searchParams.get("secretPath"))
-				.sort(),
-		).toEqual(["/frontend", "/frontend/other"]);
-	});
-
-	it("names the path when a secret is missing from an explicit one", async () => {
-		mockFetch
-			.mockResolvedValueOnce(loginResponse())
-			.mockResolvedValueOnce(list({}));
-
-		await expect(
-			infisicalClient.getSecrets(config, ["external/sentry:ABSENT"]),
-		).rejects.toThrow(
-			'secret "ABSENT" not found at "/frontend/external/sentry"',
-		);
-	});
-
-	it("rejects a ref with an empty path or key", async () => {
-		await expect(infisicalClient.getSecrets(config, [":KEY"])).rejects.toThrow(
-			"expected format <path>:<KEY>",
-		);
-		await expect(
-			infisicalClient.getSecrets(config, ["external/sentry:"]),
-		).rejects.toThrow("expected format <path>:<KEY>");
-	});
-});
-
 describe("doppler client", () => {
 	it("propagates auth errors with the status code", async () => {
 		mockFetch.mockResolvedValue(jsonResponse({}, false, 401));

apps/dokploy/__test__/sandbox/container.test.ts

@@ -1,102 +0,0 @@
-import {
-	buildSandboxContainerOptions,
-	getSandboxNetworkName,
-	parseSandboxEnvVars,
-	parseSandboxUser,
-	SANDBOX_INTERNET_NETWORK,
-	SANDBOX_ISOLATED_NETWORK,
-} from "@dokploy/server/utils/sandbox/container";
-import { describe, expect, it } from "vitest";
-
-const spec = {
-	sandboxId: "sb_1",
-	projectId: "proj_1",
-	environmentId: "env_1",
-	image: "python:3.12-slim",
-	cpu: 1.5,
-	memoryMb: 512,
-	pidsLimit: 256,
-	networkMode: "isolated" as const,
-	envVars: "FOO=bar\n# comment\n\nBAZ=qux=1\ninvalid",
-	workdir: "/home/user",
-	user: "1000:1000",
-};
-
-describe("buildSandboxContainerOptions", () => {
-	it("applies cpu, memory and pids limits", () => {
-		const options = buildSandboxContainerOptions(spec);
-		expect(options.HostConfig?.NanoCpus).toBe(1_500_000_000);
-		expect(options.HostConfig?.Memory).toBe(512 * 1024 * 1024);
-		expect(options.HostConfig?.MemorySwap).toBe(512 * 1024 * 1024);
-		expect(options.HostConfig?.PidsLimit).toBe(256);
-	});
-
-	it("hardens the container", () => {
-		const options = buildSandboxContainerOptions(spec);
-		expect(options.HostConfig?.CapDrop).toEqual(["ALL"]);
-		expect(options.HostConfig?.SecurityOpt).toEqual(["no-new-privileges"]);
-		expect(options.HostConfig?.RestartPolicy).toEqual({ Name: "no" });
-		expect(options.HostConfig?.LogConfig?.Config?.["max-size"]).toBe("10m");
-		expect(options.User).toBe("1000:1000");
-	});
-
-	it("keeps the container alive with a portable command under an init", () => {
-		const options = buildSandboxContainerOptions(spec);
-		expect(options.Entrypoint).toEqual([""]);
-		expect(options.Cmd).toEqual(["tail", "-f", "/dev/null"]);
-		expect(options.HostConfig?.Init).toBe(true);
-		expect(options.WorkingDir).toBe("/home/user");
-	});
-
-	it("sets the labels used by the reaper and reconcile", () => {
-		const options = buildSandboxContainerOptions(spec);
-		expect(options.name).toBe("dokploy-sandbox-sb_1");
-		expect(options.Labels).toEqual({
-			"dokploy.sandbox": "true",
-			"dokploy.sandboxId": "sb_1",
-			"dokploy.projectId": "proj_1",
-			"dokploy.environmentId": "env_1",
-		});
-	});
-
-	it("selects the isolated or internet network and never dokploy-network", () => {
-		expect(buildSandboxContainerOptions(spec).HostConfig?.NetworkMode).toBe(
-			SANDBOX_ISOLATED_NETWORK,
-		);
-		expect(
-			buildSandboxContainerOptions({ ...spec, networkMode: "internet" })
-				.HostConfig?.NetworkMode,
-		).toBe(SANDBOX_INTERNET_NETWORK);
-		expect(getSandboxNetworkName("isolated")).not.toBe("dokploy-network");
-		expect(getSandboxNetworkName("internet")).not.toBe("dokploy-network");
-	});
-
-	it("passes env vars and HOME, skipping comments and malformed lines", () => {
-		const options = buildSandboxContainerOptions(spec);
-		expect(options.Env).toEqual(["HOME=/home/user", "FOO=bar", "BAZ=qux=1"]);
-	});
-
-	it("omits User when the image default should be used", () => {
-		const options = buildSandboxContainerOptions({ ...spec, user: null });
-		expect(options).not.toHaveProperty("User");
-	});
-});
-
-describe("parseSandboxEnvVars", () => {
-	it("returns an empty list for empty input", () => {
-		expect(parseSandboxEnvVars(null)).toEqual([]);
-		expect(parseSandboxEnvVars("")).toEqual([]);
-	});
-});
-
-describe("parseSandboxUser", () => {
-	it("parses uid:gid", () => {
-		expect(parseSandboxUser("1000:1000")).toEqual({ uid: 1000, gid: 1000 });
-		expect(parseSandboxUser("1001")).toEqual({ uid: 1001, gid: 1001 });
-	});
-
-	it("rejects named users", () => {
-		expect(parseSandboxUser("node")).toBeNull();
-		expect(parseSandboxUser(null)).toBeNull();
-	});
-});

apps/dokploy/__test__/sandbox/exec.test.ts

@@ -1,236 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import {
-	buildSandboxKillCommand,
-	runSandboxExec,
-	SANDBOX_EXEC_MARKER_ENV,
-	SANDBOX_EXEC_TIMEOUT_EXIT_CODE,
-	toSandboxEnvArray,
-} from "@dokploy/server/utils/sandbox/exec";
-import { parse, quote } from "shell-quote";
-import { describe, expect, it, vi } from "vitest";
-
-// Docker multiplexes stdout/stderr on a non-tty exec as 8-byte frames:
-// [stream type, 0, 0, 0, size (BE uint32)] followed by the payload.
-const frame = (type: 1 | 2, text: string) => {
-	const payload = Buffer.from(text);
-	const header = Buffer.alloc(8);
-	header[0] = type;
-	header.writeUInt32BE(payload.length, 4);
-	return Buffer.concat([header, payload]);
-};
-
-// Mirrors docker-modem's demuxStream so the runner is exercised end to end.
-const demuxStream = (
-	stream: NodeJS.ReadableStream,
-	stdout: NodeJS.WritableStream,
-	stderr: NodeJS.WritableStream,
-) => {
-	let buffer = Buffer.alloc(0);
-	stream.on("data", (chunk: Buffer) => {
-		buffer = Buffer.concat([buffer, chunk]);
-		while (buffer.length >= 8) {
-			const size = buffer.readUInt32BE(4);
-			if (buffer.length < 8 + size) break;
-			const payload = buffer.subarray(8, 8 + size);
-			(buffer[0] === 2 ? stderr : stdout).write(payload);
-			buffer = buffer.subarray(8 + size);
-		}
-	});
-};
-
-const createDocker = (opts: {
-	frames: Buffer[];
-	exitCode: number | null;
-	endAfterMs?: number;
-	dieOnKill?: boolean;
-}) => {
-	const stream = new PassThrough();
-	const execCreate = vi.fn();
-	const execStart = vi.fn();
-	const kill = vi.fn(async () => {
-		stream.end();
-	});
-	const start = vi.fn(async () => undefined);
-	const killExecStart = vi.fn(async () => {
-		if (opts.dieOnKill) stream.end();
-	});
-	const inspect = vi.fn(async () => ({ ExitCode: opts.exitCode }));
-
-	const exec = vi.fn(async (options: { Cmd: string[] }) => {
-		execCreate(options);
-		if (options.Cmd[2]?.startsWith("if grep -qzF x /dev/null")) {
-			return { start: killExecStart, inspect };
-		}
-		return {
-			start: vi.fn(async (startOptions: unknown) => {
-				execStart(startOptions);
-				setTimeout(() => {
-					for (const chunk of opts.frames) stream.write(chunk);
-					if (opts.endAfterMs === undefined) stream.end();
-					else if (opts.endAfterMs > 0)
-						setTimeout(() => stream.end(), opts.endAfterMs);
-				}, 5);
-				return stream;
-			}),
-			inspect,
-		};
-	});
-
-	const docker = {
-		getContainer: vi.fn(() => ({ exec, kill, start })),
-		modem: { demuxStream },
-	};
-	return { docker, execCreate, execStart, kill, start, killExecStart, inspect };
-};
-
-describe("runSandboxExec", () => {
-	it("demuxes stdout/stderr and reports the exit code", async () => {
-		const { docker, execCreate, execStart } = createDocker({
-			frames: [frame(1, "hello "), frame(1, "world\n"), frame(2, "oops\n")],
-			exitCode: 3,
-		});
-		const stdoutChunks: string[] = [];
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "echo hello world; echo oops >&2; exit 3",
-			cwd: "/home/user",
-			env: { FOO: "bar" },
-			timeoutMs: 5000,
-			onStdout: (chunk) => stdoutChunks.push(chunk),
-		});
-
-		expect(result).toMatchObject({
-			stdout: "hello world\n",
-			stderr: "oops\n",
-			exitCode: 3,
-			timedOut: false,
-			truncated: false,
-			containerKilled: false,
-		});
-		expect(stdoutChunks.join("")).toBe("hello world\n");
-
-		const options = execCreate.mock.calls[0]?.[0];
-		expect(options.Cmd).toEqual([
-			"sh",
-			"-c",
-			"echo hello world; echo oops >&2; exit 3",
-		]);
-		expect(options.WorkingDir).toBe("/home/user");
-		expect(options.Tty).toBe(false);
-		expect(options.Env).toContain("FOO=bar");
-		expect(
-			options.Env.some((e: string) =>
-				e.startsWith(`${SANDBOX_EXEC_MARKER_ENV}=`),
-			),
-		).toBe(true);
-		expect(execStart).toHaveBeenCalledWith({ hijack: true, stdin: false });
-	});
-
-	it("treats a null exit code as failure", async () => {
-		const { docker } = createDocker({ frames: [], exitCode: null });
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "true",
-			timeoutMs: 5000,
-		});
-		expect(result.exitCode).toBe(1);
-	});
-
-	it("truncates output beyond maxOutputBytes but keeps streaming", async () => {
-		const { docker } = createDocker({
-			frames: [frame(1, "a".repeat(100)), frame(1, "b".repeat(100))],
-			exitCode: 0,
-		});
-		const streamed: string[] = [];
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "yes",
-			timeoutMs: 5000,
-			maxOutputBytes: 150,
-			onStdout: (chunk) => streamed.push(chunk),
-		});
-		expect(result.stdout).toHaveLength(150);
-		expect(result.truncated).toBe(true);
-		expect(streamed.join("")).toHaveLength(200);
-	});
-
-	it("kills the process on timeout and returns exit code 124", async () => {
-		const { docker, killExecStart, kill } = createDocker({
-			frames: [frame(1, "partial")],
-			exitCode: 0,
-			endAfterMs: 0,
-			dieOnKill: true,
-		});
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "sleep 100",
-			timeoutMs: 50,
-		});
-		expect(result.timedOut).toBe(true);
-		expect(result.exitCode).toBe(SANDBOX_EXEC_TIMEOUT_EXIT_CODE);
-		expect(result.stdout).toBe("partial");
-		expect(killExecStart).toHaveBeenCalledWith({ Detach: true });
-		expect(kill).not.toHaveBeenCalled();
-		expect(result.containerKilled).toBe(false);
-		expect(result.containerRestarted).toBe(false);
-	});
-
-	it("kills and restarts the container when the process survives the marker kill", async () => {
-		const { docker, kill, start } = createDocker({
-			frames: [],
-			exitCode: 0,
-			endAfterMs: 0,
-			dieOnKill: false,
-		});
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "sleep 100",
-			timeoutMs: 50,
-		});
-		expect(result.timedOut).toBe(true);
-		expect(result.exitCode).toBe(SANDBOX_EXEC_TIMEOUT_EXIT_CODE);
-		expect(kill).toHaveBeenCalledWith({ signal: "SIGKILL" });
-		expect(start).toHaveBeenCalledTimes(1);
-		expect(result.containerKilled).toBe(true);
-		expect(result.containerRestarted).toBe(true);
-	}, 10_000);
-
-	it("reports a failed restart so the sandbox can be marked as error", async () => {
-		const { docker, start } = createDocker({
-			frames: [],
-			exitCode: 0,
-			endAfterMs: 0,
-			dieOnKill: false,
-		});
-		start.mockRejectedValueOnce(new Error("no such container"));
-		const result = await runSandboxExec(docker as never, "ctr", {
-			cmd: "sleep 100",
-			timeoutMs: 50,
-		});
-		expect(result.containerKilled).toBe(true);
-		expect(result.containerRestarted).toBe(false);
-	}, 10_000);
-});
-
-describe("buildSandboxKillCommand", () => {
-	it("matches the marker as a fixed string and never fails the shell", () => {
-		const cmd = buildSandboxKillCommand("abc-123");
-		expect(cmd).toContain(`grep -qzxF ${quote(["DOKPLOY_EXEC_ID=abc-123"])}`);
-		expect(cmd).toContain(
-			`tr '\\0' '\\n' < "$f" 2>/dev/null | grep -qxF ${quote(["DOKPLOY_EXEC_ID=abc-123"])}`,
-		);
-		expect(parse(cmd)).toContain("DOKPLOY_EXEC_ID=abc-123");
-		expect(cmd).toContain("kill -9");
-		expect(cmd.endsWith("; true")).toBe(true);
-	});
-});
-
-describe("toSandboxEnvArray", () => {
-	it("converts records and passes arrays through", () => {
-		expect(toSandboxEnvArray({ A: "1", B: "x=y" })).toEqual(["A=1", "B=x=y"]);
-		expect(toSandboxEnvArray(["C=3"])).toEqual(["C=3"]);
-		expect(toSandboxEnvArray(undefined)).toEqual([]);
-	});
-});
-
-describe("EventEmitter sanity", () => {
-	it("keeps the fake stream API compatible with what the runner uses", () => {
-		expect(new PassThrough()).toBeInstanceOf(EventEmitter);
-	});
-});

apps/dokploy/__test__/sandbox/files.test.ts

@@ -1,80 +0,0 @@
-import {
-	buildSandboxFindCommand,
-	buildSandboxLsCommand,
-	parseSandboxFindOutput,
-	parseSandboxLsOutput,
-} from "@dokploy/server/utils/sandbox/files";
-import { parse } from "shell-quote";
-import { describe, expect, it } from "vitest";
-
-describe("list files commands", () => {
-	it("quotes the path against shell injection", () => {
-		expect(buildSandboxFindCommand("/tmp/a b; rm -rf /")).toContain(
-			"'/tmp/a b; rm -rf /'",
-		);
-		expect(parse(buildSandboxLsCommand("/tmp/$(id)"))).toEqual([
-			"ls",
-			"-1Ap",
-			"/tmp/$(id)",
-		]);
-	});
-});
-
-describe("parseSandboxFindOutput", () => {
-	it("parses type, size, mtime, mode and name, directories first", () => {
-		const out = [
-			"f\t12\t1700000000.5000\t644\tmain.py",
-			"d\t4096\t1700000100.0000\t755\tsrc",
-			"l\t7\t1700000200.0000\t777\tlink",
-			"f\t0\t1700000300.0000\t600\tname with\tspaces",
-		].join("\n");
-		const entries = parseSandboxFindOutput(out);
-		expect(entries.map((e) => e.name)).toEqual([
-			"src",
-			"link",
-			"main.py",
-			"name with\tspaces",
-		]);
-		expect(entries[0]).toEqual({
-			name: "src",
-			type: "directory",
-			size: 4096,
-			mode: "755",
-			modifiedAt: new Date(1700000100 * 1000).toISOString(),
-		});
-		expect(entries[2]).toMatchObject({
-			type: "file",
-			size: 12,
-			modifiedAt: new Date(1700000000500).toISOString(),
-		});
-		expect(entries[1]?.type).toBe("symlink");
-	});
-
-	it("returns an empty list for an empty directory", () => {
-		expect(parseSandboxFindOutput("")).toEqual([]);
-		expect(parseSandboxFindOutput("\n")).toEqual([]);
-	});
-});
-
-describe("parseSandboxLsOutput", () => {
-	it("marks trailing-slash entries as directories", () => {
-		const entries = parseSandboxLsOutput("b.txt\na/\n.hidden\n");
-		expect(entries).toEqual([
-			{
-				name: "a",
-				type: "directory",
-				size: null,
-				mode: null,
-				modifiedAt: null,
-			},
-			{
-				name: ".hidden",
-				type: "file",
-				size: null,
-				mode: null,
-				modifiedAt: null,
-			},
-			{ name: "b.txt", type: "file", size: null, mode: null, modifiedAt: null },
-		]);
-	});
-});

apps/dokploy/__test__/sandbox/network.test.ts

@@ -1,107 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("@dokploy/server/utils/servers/remote-docker", () => ({
-	getRemoteDocker: vi.fn(),
-}));
-
-import {
-	ensureSandboxNetwork,
-	SANDBOX_NETWORK_OPTIONS,
-} from "@dokploy/server/services/sandbox";
-
-const notFound = () =>
-	Object.assign(new Error("no such network"), { statusCode: 404 });
-
-const createDocker = (inspect: () => Promise<unknown>) => {
-	const remove = vi.fn(async () => undefined);
-	const createNetwork = vi.fn(async () => undefined);
-	const getNetwork = vi.fn(() => ({ inspect, remove }));
-	return {
-		docker: { getNetwork, createNetwork },
-		remove,
-		createNetwork,
-		getNetwork,
-	};
-};
-
-beforeEach(() => {
-	vi.spyOn(console, "warn").mockImplementation(() => {});
-});
-
-describe("ensureSandboxNetwork", () => {
-	it("creates an internal bridge without inter-container traffic for isolated mode", async () => {
-		const { docker, createNetwork } = createDocker(async () => {
-			throw notFound();
-		});
-		const name = await ensureSandboxNetwork(docker as never, "isolated");
-		expect(name).toBe("dokploy-sandboxes-isolated");
-		expect(createNetwork).toHaveBeenCalledWith(
-			expect.objectContaining({
-				Name: "dokploy-sandboxes-isolated",
-				Driver: "bridge",
-				Internal: true,
-				Options: SANDBOX_NETWORK_OPTIONS,
-			}),
-		);
-		expect(
-			SANDBOX_NETWORK_OPTIONS["com.docker.network.bridge.enable_icc"],
-		).toBe("false");
-	});
-
-	it("creates a non-internal bridge for internet mode", async () => {
-		const { docker, createNetwork } = createDocker(async () => {
-			throw notFound();
-		});
-		await ensureSandboxNetwork(docker as never, "internet");
-		expect(createNetwork).toHaveBeenCalledWith(
-			expect.objectContaining({
-				Name: "dokploy-sandboxes",
-				Internal: false,
-				Options: SANDBOX_NETWORK_OPTIONS,
-			}),
-		);
-	});
-
-	it("reuses a network that already blocks inter-container traffic", async () => {
-		const { docker, createNetwork, remove } = createDocker(async () => ({
-			Options: SANDBOX_NETWORK_OPTIONS,
-			Containers: {},
-		}));
-		await ensureSandboxNetwork(docker as never, "isolated");
-		expect(createNetwork).not.toHaveBeenCalled();
-		expect(remove).not.toHaveBeenCalled();
-	});
-
-	it("recreates an unused legacy network that allows inter-container traffic", async () => {
-		const { docker, createNetwork, remove } = createDocker(async () => ({
-			Options: {},
-			Containers: {},
-		}));
-		await ensureSandboxNetwork(docker as never, "isolated");
-		expect(remove).toHaveBeenCalledTimes(1);
-		expect(createNetwork).toHaveBeenCalledTimes(1);
-	});
-
-	it("keeps a legacy network that still has containers attached and warns", async () => {
-		const { docker, createNetwork, remove } = createDocker(async () => ({
-			Options: {},
-			Containers: { abc: { Name: "dokploy-sandbox-x" } },
-		}));
-		await ensureSandboxNetwork(docker as never, "isolated");
-		expect(remove).not.toHaveBeenCalled();
-		expect(createNetwork).not.toHaveBeenCalled();
-		expect(console.warn).toHaveBeenCalled();
-	});
-
-	it("tolerates a concurrent create of the same network", async () => {
-		const { docker, createNetwork } = createDocker(async () => {
-			throw notFound();
-		});
-		createNetwork.mockRejectedValueOnce(
-			Object.assign(new Error("exists"), { statusCode: 409 }),
-		);
-		await expect(
-			ensureSandboxNetwork(docker as never, "isolated"),
-		).resolves.toBe("dokploy-sandboxes-isolated");
-	});
-});

apps/dokploy/__test__/sandbox/reaper.test.ts

@@ -1,117 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const findMany = vi.hoisted(() => vi.fn());
-vi.mock("@dokploy/server/db", () => ({
-	db: { query: { sandboxes: { findMany } } },
-}));
-vi.mock("@dokploy/server/services/sandbox", () => ({
-	killSandbox: vi.fn(),
-}));
-
-import {
-	findExpiredSandboxes,
-	planSandboxReconcile,
-	reapExpiredSandboxes,
-} from "@dokploy/server/utils/sandbox/reaper";
-
-const now = new Date("2026-09-10T12:00:00Z");
-const past = new Date(now.getTime() - 1000);
-const future = new Date(now.getTime() + 60_000);
-
-beforeEach(() => {
-	findMany.mockReset();
-});
-
-describe("findExpiredSandboxes", () => {
-	it("returns only running sandboxes whose expiresAt has passed", () => {
-		const list = [
-			{ sandboxId: "expired", status: "running", expiresAt: past },
-			{ sandboxId: "alive", status: "running", expiresAt: future },
-			{ sandboxId: "no-expiry", status: "running", expiresAt: null },
-			{ sandboxId: "killed", status: "killed", expiresAt: past },
-			{ sandboxId: "error", status: "error", expiresAt: past },
-		];
-		expect(findExpiredSandboxes(list, now).map((s) => s.sandboxId)).toEqual([
-			"expired",
-		]);
-	});
-});
-
-describe("reapExpiredSandboxes", () => {
-	it("kills expired sandboxes and leaves the rest untouched", async () => {
-		findMany.mockResolvedValue([
-			{ sandboxId: "expired", status: "running", expiresAt: past },
-			{ sandboxId: "alive", status: "running", expiresAt: future },
-		]);
-		const kill = vi.fn(async () => undefined);
-		const killed = await reapExpiredSandboxes(now, kill);
-		expect(killed).toEqual(["expired"]);
-		expect(kill).toHaveBeenCalledTimes(1);
-		expect(kill).toHaveBeenCalledWith("expired");
-	});
-
-	it("continues when one kill fails", async () => {
-		findMany.mockResolvedValue([
-			{ sandboxId: "a", status: "running", expiresAt: past },
-			{ sandboxId: "b", status: "running", expiresAt: past },
-		]);
-		const kill = vi.fn(async (id: string) => {
-			if (id === "a") throw new Error("docker down");
-		});
-		const spy = vi.spyOn(console, "error").mockImplementation(() => {});
-		const killed = await reapExpiredSandboxes(now, kill);
-		spy.mockRestore();
-		expect(killed).toEqual(["b"]);
-		expect(kill).toHaveBeenCalledTimes(2);
-	});
-});
-
-describe("planSandboxReconcile", () => {
-	const container = (id: string, sandboxId: string, state = "running") => ({
-		Id: id,
-		State: state,
-		Labels: { "dokploy.sandbox": "true", "dokploy.sandboxId": sandboxId },
-	});
-
-	it("removes containers without a running row and errors rows without a container", () => {
-		const plan = planSandboxReconcile(
-			[
-				{ sandboxId: "ok", containerId: "c-ok", status: "running" },
-				{ sandboxId: "gone", containerId: "c-gone", status: "running" },
-				{ sandboxId: "never-started", containerId: null, status: "running" },
-			],
-			[
-				container("c-ok", "ok"),
-				container("c-orphan", "orphan"),
-				container("c-exited", "ok-old", "exited"),
-			],
-		);
-		expect(plan.removeContainers).toEqual(["c-orphan", "c-exited"]);
-		expect(plan.markError).toEqual(["gone", "never-started"]);
-	});
-
-	it("removes a stopped container even when its row is running, and errors the row", () => {
-		const plan = planSandboxReconcile(
-			[{ sandboxId: "sb", containerId: "c1", status: "running" }],
-			[container("c1", "sb", "exited")],
-		);
-		expect(plan.removeContainers).toEqual(["c1"]);
-		expect(plan.markError).toEqual(["sb"]);
-	});
-
-	it("leaves containers of sandboxes that are still being created alone", () => {
-		const plan = planSandboxReconcile(
-			[{ sandboxId: "new", containerId: null, status: "creating" }],
-			[container("c-new", "new")],
-		);
-		expect(plan).toEqual({ removeContainers: [], markError: [] });
-	});
-
-	it("does nothing when everything matches", () => {
-		const plan = planSandboxReconcile(
-			[{ sandboxId: "sb", containerId: "c1", status: "running" }],
-			[container("c1", "sb")],
-		);
-		expect(plan).toEqual({ removeContainers: [], markError: [] });
-	});
-});

apps/dokploy/__test__/sandbox/tar.test.ts

@@ -1,145 +0,0 @@
-import { Readable } from "node:stream";
-import {
-	buildSandboxDirectoryTar,
-	buildSandboxFileTar,
-	extractSandboxFile,
-	SandboxFileTooLargeError,
-	SandboxNotRegularFileError,
-} from "@dokploy/server/utils/sandbox/tar";
-import { describe, expect, it } from "vitest";
-
-type Entry = {
-	name: string;
-	type: string;
-	mode: number;
-	uid: number;
-	gid: number;
-	size: number;
-	content: string;
-};
-
-const TYPES: Record<string, string> = {
-	"0": "file",
-	"\0": "file",
-	"5": "directory",
-};
-
-// Minimal ustar reader: 512-byte header blocks with octal numeric fields.
-const readTar = (buffer: Buffer): Entry[] => {
-	const entries: Entry[] = [];
-	let offset = 0;
-	const field = (start: number, length: number) =>
-		buffer
-			.subarray(offset + start, offset + start + length)
-			.toString("utf8")
-			.replace(/\0.*$/s, "");
-	const octal = (start: number, length: number) =>
-		Number.parseInt(field(start, length).trim() || "0", 8);
-	while (offset + 512 <= buffer.length) {
-		const name = field(0, 100);
-		if (!name) break;
-		const size = octal(124, 12);
-		const typeflag = buffer[offset + 156] ?? 0;
-		entries.push({
-			name,
-			type: TYPES[String.fromCharCode(typeflag)] ?? "other",
-			mode: octal(100, 8),
-			uid: octal(108, 8),
-			gid: octal(116, 8),
-			size,
-			content: buffer
-				.subarray(offset + 512, offset + 512 + size)
-				.toString("utf8"),
-		});
-		offset += 512 + Math.ceil(size / 512) * 512;
-	}
-	return entries;
-};
-
-describe("buildSandboxFileTar", () => {
-	it("packs a single file with the requested ownership and mode", async () => {
-		const tar = await buildSandboxFileTar({
-			name: "main.py",
-			content: Buffer.from("print('hi')\n"),
-			uid: 1000,
-			gid: 1000,
-			mode: 0o600,
-		});
-		const entries = await readTar(tar);
-		expect(entries).toHaveLength(1);
-		expect(entries[0]).toMatchObject({
-			name: "main.py",
-			type: "file",
-			mode: 0o600,
-			uid: 1000,
-			gid: 1000,
-			size: 12,
-			content: "print('hi')\n",
-		});
-	});
-
-	it("defaults to root ownership and 0644", async () => {
-		const entries = await readTar(
-			await buildSandboxFileTar({ name: "a.txt", content: Buffer.alloc(0) }),
-		);
-		expect(entries[0]).toMatchObject({ mode: 0o644, uid: 0, gid: 0, size: 0 });
-	});
-});
-
-describe("buildSandboxDirectoryTar", () => {
-	it("packs a directory entry with a trailing slash", async () => {
-		const entries = await readTar(
-			await buildSandboxDirectoryTar({ name: "user", uid: 1000, gid: 1000 }),
-		);
-		expect(entries[0]).toMatchObject({
-			name: "user/",
-			type: "directory",
-			mode: 0o755,
-			uid: 1000,
-			gid: 1000,
-		});
-	});
-});
-
-describe("extractSandboxFile", () => {
-	it("extracts the first regular file", async () => {
-		const tar = await buildSandboxFileTar({
-			name: "out.txt",
-			content: Buffer.from("hello"),
-		});
-		const file = await extractSandboxFile(Readable.from(tar), 1024);
-		expect(file.name).toBe("out.txt");
-		expect(file.content.toString()).toBe("hello");
-	});
-
-	it("rejects files over the limit", async () => {
-		const tar = await buildSandboxFileTar({
-			name: "big.bin",
-			content: Buffer.alloc(2048, 1),
-		});
-		await expect(
-			extractSandboxFile(Readable.from(tar), 1024),
-		).rejects.toBeInstanceOf(SandboxFileTooLargeError);
-	});
-
-	it("rejects a directory archive even when it contains files", async () => {
-		const dir = await buildSandboxDirectoryTar({ name: "proj" });
-		const file = await buildSandboxFileTar({
-			name: "proj/main.py",
-			content: Buffer.from("print(1)"),
-		});
-		// tar-stream pads each archive with two zero blocks; strip the first
-		// archive's end-of-archive marker so the entries are read as one tar.
-		const combined = Buffer.concat([dir.subarray(0, dir.length - 1024), file]);
-		await expect(
-			extractSandboxFile(Readable.from(combined), 1024),
-		).rejects.toBeInstanceOf(SandboxNotRegularFileError);
-	});
-
-	it("rejects archives without a regular file", async () => {
-		const tar = await buildSandboxDirectoryTar({ name: "dir" });
-		await expect(
-			extractSandboxFile(Readable.from(tar), 1024),
-		).rejects.toBeInstanceOf(SandboxNotRegularFileError);
-	});
-});

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

@@ -60,7 +60,7 @@ const baseSettings: WebServerSettings = {
 		docsUrl: null,
 		errorPageTitle: null,
 		errorPageDescription: null,
-		ogImageUrl: null,
+		metaTitle: null,
 		footerText: null,
 	},
 	cleanupCacheApplications: false,

apps/dokploy/__test__/utils/remote-stream.test.ts

@@ -1,60 +0,0 @@
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@dokploy/server/services/server", () => ({
-	findServerById: vi.fn(),
-}));
-
-import { pipeBetweenServers } from "@dokploy/server/utils/process/remoteStream";
-
-describe("pipeBetweenServers", () => {
-	it("delivers a short source stream that ends before the target is ready", async () => {
-		const bytes = await pipeBetweenServers({
-			source: { serverId: null, command: "printf 'hello world'" },
-			target: { serverId: null, command: "sleep 0.3; cat > /dev/null" },
-		});
-		expect(bytes).toBe(11);
-	});
-
-	it("pipes data larger than the pipe buffer unchanged", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "pipe-"));
-		const source = path.join(dir, "src.bin");
-		const target = path.join(dir, "dst.bin");
-		const size = 1024 * 1024;
-		const progress: number[] = [];
-
-		const bytes = await pipeBetweenServers({
-			source: {
-				serverId: null,
-				command: `head -c ${size} /dev/urandom | tee '${source}'`,
-			},
-			target: { serverId: null, command: `cat > '${target}'` },
-			onProgress: (transferred) => progress.push(transferred),
-		});
-
-		expect(bytes).toBe(size);
-		expect(progress.at(-1)).toBe(size);
-		expect(await fs.readFile(target)).toEqual(await fs.readFile(source));
-		await fs.rm(dir, { recursive: true, force: true });
-	}, 30_000);
-
-	it("reports a target failure with its stderr", async () => {
-		await expect(
-			pipeBetweenServers({
-				source: { serverId: null, command: "printf x" },
-				target: { serverId: null, command: "echo boom >&2; exit 3" },
-			}),
-		).rejects.toThrow("target exited with code 3: boom");
-	});
-
-	it("reports a source failure", async () => {
-		await expect(
-			pipeBetweenServers({
-				source: { serverId: null, command: "exit 2" },
-				target: { serverId: null, command: "cat > /dev/null" },
-			}),
-		).rejects.toThrow("source exited with code 2");
-	});
-});

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

@@ -8,3 +8,4 @@ export { RestartPolicyForm } from "./restart-policy-form";
 export { RollbackConfigForm } from "./rollback-config-form";
 export { StopGracePeriodForm } from "./stop-grace-period-form";
 export { UpdateConfigForm } from "./update-config-form";
+export { filterEmptyValues, hasValues } from "./utils";

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

@@ -0,0 +1,31 @@
+/**
+ * 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/domains/handle-domain.tsx

@@ -156,7 +156,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 			domainId,
 		},
 		{
-			enabled: isOpen && !!domainId,
+			enabled: !!domainId,
 		},
 	);
 
@@ -167,7 +167,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 						applicationId: id,
 					},
 					{
-						enabled: isOpen && !!id,
+						enabled: !!id,
 					},
 				)
 			: api.compose.one.useQuery(
@@ -175,7 +175,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 						composeId: id,
 					},
 					{
-						enabled: isOpen && !!id,
+						enabled: !!id,
 					},
 				);
 
@@ -187,14 +187,9 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 		api.domain.generateDomain.useMutation();
 
 	const { data: canGenerateTraefikMeDomains } =
-		api.domain.canGenerateTraefikMeDomains.useQuery(
-			{
-				serverId: application?.serverId || "",
-			},
-			{
-				enabled: isOpen,
-			},
-		);
+		api.domain.canGenerateTraefikMeDomains.useQuery({
+			serverId: application?.serverId || "",
+		});
 
 	const {
 		data: services,
@@ -209,7 +204,7 @@ export const AddDomain = ({ id, type, domainId = "", children }: Props) => {
 		{
 			retry: false,
 			refetchOnWindowFocus: false,
-			enabled: isOpen && type === "compose" && !!id,
+			enabled: type === "compose" && !!id,
 		},
 	);
 

apps/dokploy/components/dashboard/billing/trial-banner.tsx

@@ -1,34 +0,0 @@
-import { Rocket } from "lucide-react";
-import { useRouter } from "next/router";
-import { Button } from "@/components/ui/button";
-import { api } from "@/utils/api";
-
-export const TrialBanner = () => {
-	const router = useRouter();
-	const { data: billingStatus } = api.stripe.getBillingStatus.useQuery();
-
-	if (!billingStatus?.isOnTrial) {
-		return null;
-	}
-
-	const daysRemaining = billingStatus.trialDaysRemaining ?? 0;
-
-	return (
-		<div className="sticky top-0 z-20 mx-4 mt-4 flex flex-wrap items-center justify-center gap-x-3 gap-y-2 rounded-lg border border-primary/20 bg-primary/10 px-4 py-2 text-sm">
-			<span className="flex items-center gap-2">
-				<Rocket className="h-4 w-4 text-primary shrink-0" />
-				{daysRemaining > 0
-					? `You have ${daysRemaining} day${daysRemaining === 1 ? "" : "s"} left in your free trial.`
-					: "Your free trial ends today."}
-			</span>
-			<Button
-				size="sm"
-				variant="default"
-				className="h-7"
-				onClick={() => router.push("/dashboard/settings/billing")}
-			>
-				Upgrade now
-			</Button>
-		</div>
-	);
-};

apps/dokploy/components/dashboard/compose/advanced/add-command.tsx

@@ -22,7 +22,6 @@ import {
 	FormMessage,
 } from "@/components/ui/form";
 import { Input } from "@/components/ui/input";
-import { Switch } from "@/components/ui/switch";
 import { api } from "@/utils/api";
 
 interface Props {
@@ -31,7 +30,6 @@ interface Props {
 
 const AddRedirectSchema = z.object({
 	command: z.string(),
-	pullImages: z.boolean(),
 });
 
 type AddCommand = z.infer<typeof AddRedirectSchema>;
@@ -59,25 +57,22 @@ export const AddCommandCompose = ({ composeId }: Props) => {
 	const form = useForm<AddCommand>({
 		defaultValues: {
 			command: "",
-			pullImages: false,
 		},
 		resolver: zodResolver(AddRedirectSchema),
 	});
 
 	useEffect(() => {
-		if (data) {
+		if (data?.command) {
 			form.reset({
-				command: data.command || "",
-				pullImages: data.pullImages ?? false,
+				command: data?.command || "",
 			});
 		}
-	}, [form, form.reset, form.formState.isSubmitSuccessful, data]);
+	}, [form, form.reset, form.formState.isSubmitSuccessful, data?.command]);
 
-	const onSubmit = async (formData: AddCommand) => {
+	const onSubmit = async (data: AddCommand) => {
 		await mutateAsync({
 			composeId,
-			command: formData.command,
-			pullImages: formData.pullImages,
+			command: data?.command,
 		})
 			.then(async () => {
 				toast.success("Command Updated");
@@ -114,30 +109,6 @@ export const AddCommandCompose = ({ composeId }: Props) => {
 							<strong>docker</strong>.
 						</AlertBlock>
 						<div className="flex flex-col gap-4">
-							{data?.composeType === "docker-compose" && (
-								<FormField
-									control={form.control}
-									name="pullImages"
-									render={({ field }) => (
-										<FormItem className="flex flex-row items-center justify-between rounded-lg border p-3 shadow-xs">
-											<div className="space-y-0.5">
-												<FormLabel>Pull latest images on deploy</FormLabel>
-												<FormDescription>
-													Adds <strong>--pull always</strong> to the default
-													command so every deploy fetches the newest image for
-													each tag. Has no effect when a custom command is set.
-												</FormDescription>
-											</div>
-											<FormControl>
-												<Switch
-													checked={field.value}
-													onCheckedChange={field.onChange}
-												/>
-											</FormControl>
-										</FormItem>
-									)}
-								/>
-							)}
 							<FormField
 								control={form.control}
 								name="command"

apps/dokploy/components/dashboard/compose/advanced/fresh-volumes.tsx

@@ -1,216 +0,0 @@
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import copy from "copy-to-clipboard";
-import { AlertTriangle, Copy, HardDriveDownload } from "lucide-react";
-import { useRouter } from "next/router";
-import { useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-	DialogTrigger,
-} from "@/components/ui/dialog";
-import {
-	Form,
-	FormControl,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-const freshVolumesSchema = z.object({
-	confirmName: z.string().min(1, {
-		message: "Compose name is required",
-	}),
-});
-
-type FreshVolumesForm = z.infer<typeof freshVolumesSchema>;
-
-interface Props {
-	composeId: string;
-}
-
-export const FreshVolumes = ({ composeId }: Props) => {
-	const router = useRouter();
-	const [isOpen, setIsOpen] = useState(false);
-	const { data: permissions } = api.user.getPermissions.useQuery();
-	const canDeploy = permissions?.deployment.create ?? false;
-	const { data, refetch } = api.compose.one.useQuery(
-		{ composeId },
-		{ enabled: !!composeId },
-	);
-	const { mutateAsync: deploy, isPending } = api.compose.deploy.useMutation();
-
-	const form = useForm<FreshVolumesForm>({
-		defaultValues: { confirmName: "" },
-		resolver: zodResolver(freshVolumesSchema),
-	});
-
-	const expectedName = `${data?.name}/${data?.appName}`;
-	const isRunning = data?.composeStatus === "running";
-
-	const onSubmit = async (formData: FreshVolumesForm) => {
-		if (formData.confirmName !== expectedName) {
-			form.setError("confirmName", {
-				message: `Compose name must match "${expectedName}"`,
-			});
-			return;
-		}
-		await deploy({ composeId, freshVolumes: true })
-			.then(() => {
-				toast.success("Compose deployed with fresh volumes");
-				setIsOpen(false);
-				form.reset();
-				refetch();
-				router.push(
-					`/dashboard/project/${data?.environment.projectId}/environment/${data?.environmentId}/services/compose/${composeId}?tab=deployments`,
-				);
-			})
-			.catch(() => {
-				toast.error("Error deploying compose");
-			});
-	};
-
-	if (!canDeploy || data?.composeType !== "docker-compose") return null;
-
-	return (
-		<Card className="bg-background border-destructive/50">
-			<CardHeader>
-				<CardTitle className="text-xl flex items-center gap-2">
-					<AlertTriangle className="h-5 w-5 text-destructive" />
-					Danger Zone
-				</CardTitle>
-			</CardHeader>
-			<CardContent>
-				<div className="flex flex-col gap-4">
-					<div className="flex flex-col gap-2">
-						<h3 className="text-base font-semibold">
-							Deploy with Fresh Volumes
-						</h3>
-						<p className="text-sm text-muted-foreground">
-							Permanently wipes every volume of this compose and redeploys it
-							from a clean state. All persistent data (databases, uploads,
-							caches) will be lost.
-						</p>
-					</div>
-					<Dialog
-						open={isOpen}
-						onOpenChange={(open) => {
-							setIsOpen(open);
-							if (!open) form.reset();
-						}}
-					>
-						<DialogTrigger asChild>
-							<Button
-								isLoading={isPending}
-								variant="outline"
-								className="w-full border-destructive/50 hover:bg-destructive/10 hover:text-destructive text-destructive"
-							>
-								<HardDriveDownload className="mr-2 h-4 w-4" />
-								Deploy with Fresh Volumes
-							</Button>
-						</DialogTrigger>
-						<DialogContent className="sm:max-w-lg">
-							<DialogHeader>
-								<DialogTitle className="flex items-center gap-2">
-									<AlertTriangle className="h-5 w-5 text-destructive" />
-									Are you absolutely sure?
-								</DialogTitle>
-								<DialogDescription asChild>
-									<div className="space-y-2">
-										<p>This action will:</p>
-										<ul className="list-disc list-inside space-y-1">
-											<li>Stop the current compose</li>
-											<li>Delete all volumes and their data</li>
-											<li>Redeploy the compose with empty volumes</li>
-										</ul>
-										<p className="font-medium text-destructive mt-4">
-											This action cannot be undone.
-										</p>
-									</div>
-								</DialogDescription>
-							</DialogHeader>
-							<Form {...form}>
-								<form
-									onSubmit={form.handleSubmit(onSubmit)}
-									id="hook-form-fresh-volumes"
-									className="grid w-full gap-4"
-								>
-									<FormField
-										control={form.control}
-										name="confirmName"
-										render={({ field }) => (
-											<FormItem>
-												<FormLabel className="flex items-center gap-2">
-													<span>
-														To confirm, type{" "}
-														<Badge
-															className="p-2 rounded-md ml-1 mr-1 hover:border-primary hover:text-primary-foreground hover:bg-primary hover:cursor-pointer"
-															variant="outline"
-															onClick={() => {
-																if (data?.name && data?.appName) {
-																	copy(expectedName);
-																	toast.success(
-																		"Copied to clipboard. Be careful!",
-																	);
-																}
-															}}
-														>
-															{expectedName}&nbsp;
-															<Copy className="h-4 w-4 ml-1 text-muted-foreground" />
-														</Badge>{" "}
-														in the box below:
-													</span>
-												</FormLabel>
-												<FormControl>
-													<Input
-														placeholder="Enter compose name to confirm"
-														autoComplete="off"
-														{...field}
-													/>
-												</FormControl>
-												<FormMessage />
-											</FormItem>
-										)}
-									/>
-								</form>
-							</Form>
-							{isRunning && (
-								<AlertBlock type="warning" className="w-full">
-									Cannot deploy with fresh volumes while a deployment is
-									running. Please wait for it to finish and then try again.
-								</AlertBlock>
-							)}
-							<DialogFooter>
-								<Button variant="secondary" onClick={() => setIsOpen(false)}>
-									Cancel
-								</Button>
-								<Button
-									isLoading={isPending}
-									disabled={isRunning}
-									form="hook-form-fresh-volumes"
-									type="submit"
-									variant="destructive"
-								>
-									Wipe volumes and deploy
-								</Button>
-							</DialogFooter>
-						</DialogContent>
-					</Dialog>
-				</div>
-			</CardContent>
-		</Card>
-	);
-};

apps/dokploy/components/dashboard/compose/general/actions.tsx

@@ -1,4 +1,11 @@
-import { Ban, CheckCircle2, RefreshCcw, Rocket, Terminal } from "lucide-react";
+import {
+	Ban,
+	CheckCircle2,
+	HardDriveDownload,
+	RefreshCcw,
+	Rocket,
+	Terminal,
+} from "lucide-react";
 import { useRouter } from "next/router";
 import { Tooltip as TooltipPrimitive } from "radix-ui";
 import { toast } from "sonner";
@@ -82,6 +89,51 @@ export const ComposeActions = ({ composeId }: Props) => {
 						</Button>
 					</DialogAction>
 				)}
+				{canDeploy && data?.composeType === "docker-compose" && (
+					<DialogAction
+						title="Deploy with Fresh Volumes"
+						description="This will remove all volumes and redeploy with a clean state. All persistent data will be permanently deleted."
+						type="destructive"
+						onClick={async () => {
+							await deploy({
+								composeId: composeId,
+								freshVolumes: true,
+							})
+								.then(() => {
+									toast.success("Compose deployed with fresh volumes");
+									refetch();
+									router.push(
+										`/dashboard/project/${data?.environment.projectId}/environment/${data?.environmentId}/services/compose/${composeId}?tab=deployments`,
+									);
+								})
+								.catch(() => {
+									toast.error("Error deploying compose");
+								});
+						}}
+					>
+						<Button
+							variant="outline"
+							isLoading={data?.composeStatus === "running"}
+							className="flex items-center gap-1.5 group focus-visible:ring-2 focus-visible:ring-offset-2"
+						>
+							<Tooltip>
+								<TooltipTrigger asChild>
+									<div className="flex items-center">
+										<HardDriveDownload className="size-4 mr-1" />
+										Fresh Volumes
+									</div>
+								</TooltipTrigger>
+								<TooltipPrimitive.Portal>
+									<TooltipContent sideOffset={5} className="z-[60]">
+										<p>
+											Deploy with fresh volumes (removes all persistent data)
+										</p>
+									</TooltipContent>
+								</TooltipPrimitive.Portal>
+							</Tooltip>
+						</Button>
+					</DialogAction>
+				)}
 				{canDeploy && (
 					<DialogAction
 						title="Rebuild Compose"

apps/dokploy/components/dashboard/docker/show/show-containers.tsx

@@ -114,7 +114,7 @@ export const ShowContainers = ({ serverId }: Props) => {
 					</CardHeader>
 					<CardContent className="space-y-2 py-8 border-t">
 						<div className="gap-4 pb-20 w-full">
-							<div className="flex flex-col gap-4 w-full overflow-auto">
+							<div className="flex flex-col gap-4  w-full overflow-auto">
 								<div className="flex items-center gap-2 max-sm:flex-wrap">
 									<Input
 										placeholder="Filter by name..."

apps/dokploy/components/dashboard/onboarding/steps/plan-step.tsx

@@ -56,7 +56,7 @@ export const PlanStep = ({ onNext }: Props) => {
 		try {
 			await startFreeTrial();
 			await utils.project.onboardingStatus.invalidate();
-			toast.success("Your 7-day trial has started");
+			toast.success("Your 14-day trial has started");
 			onNext();
 		} catch (error) {
 			toast.error(
@@ -90,14 +90,14 @@ export const PlanStep = ({ onNext }: Props) => {
 							Recommended
 						</span>
 						<p className={`${displayFont.className} text-2xl mt-3`}>
-							7-day free trial
+							14-day free trial
 						</p>
 						<p className="text-sm text-zinc-400 dark:text-zinc-600 mt-1 max-w-xs">
 							No card required — cancel anytime.
 						</p>
 						<ul className="flex flex-col gap-1.5 mt-4">
 							{[
-								"Setup 1 server",
+								"1 server included",
 								"Unlimited apps & databases",
 								"Community support",
 							].map((f) => (
@@ -140,7 +140,7 @@ export const PlanStep = ({ onNext }: Props) => {
 						</p>
 						<ul className="flex flex-col gap-1.5 mt-4">
 							{[
-								"Setup 1 server",
+								"1 server included",
 								"Unlimited apps & databases",
 								"2 environments",
 								"Community support",
@@ -183,7 +183,7 @@ export const PlanStep = ({ onNext }: Props) => {
 						</p>
 						<ul className="flex flex-col gap-1.5 mt-4">
 							{[
-								`Setup up to ${STARTUP_SERVERS_INCLUDED} servers`,
+								`${STARTUP_SERVERS_INCLUDED} servers included`,
 								"Unlimited users & environments",
 								"Basic RBAC + 2FA",
 								"Email & chat support",

apps/dokploy/components/dashboard/organization/handle-organization.tsx

@@ -1,11 +1,10 @@
 import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
 
-import { PenBoxIcon, Plus, X } from "lucide-react";
+import { GlobeIcon, PenBoxIcon, Plus, X } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
 import { useForm } from "react-hook-form";
 import { toast } from "sonner";
 import { z } from "zod";
-import { Logo } from "@/components/shared/logo";
 import { Button } from "@/components/ui/button";
 import {
 	Dialog,
@@ -256,10 +255,8 @@ export function AddOrganization({
 							control={form.control}
 							name="name"
 							render={({ field }) => (
-								<FormItem className="items-center gap-4">
-									<div className="flex items-center justify-between">
-										<FormLabel className="text-right">Name</FormLabel>
-									</div>
+								<FormItem className="tems-center gap-4">
+									<FormLabel className="text-right">Name</FormLabel>
 									<FormControl>
 										<Input
 											placeholder="Organization name"
@@ -288,16 +285,16 @@ export function AddOrganization({
 										<FormControl>
 											<div className="col-span-3 flex flex-col gap-3">
 												<div className="flex items-center gap-3">
-													<div className="flex size-10 shrink-0 items-center justify-center rounded-md border bg-muted/50 overflow-hidden">
+													<div className="flex size-10 shrink-0 items-center justify-center rounded-md border bg-muted/50 p-1">
 														{field.value ? (
 															// biome-ignore lint/performance/noImgElement: user uploaded logo preview
 															<img
 																src={field.value}
 																alt="Logo preview"
-																className="size-full object-cover"
+																className="size-full object-contain"
 															/>
 														) : (
-															<Logo className="size-7" />
+															<GlobeIcon className="size-5 text-muted-foreground" />
 														)}
 													</div>
 													<div className="relative flex-1">

apps/dokploy/components/dashboard/requests/requests-table.tsx

@@ -189,7 +189,7 @@ export const RequestsTable = ({ dateRange }: RequestsTableProps) => {
 		<>
 			<div className="flex flex-col gap-6 w-full ">
 				<div className="mt-6 grid gap-4 pb-20 w-full">
-					<div className="flex flex-col gap-4 w-full overflow-auto">
+					<div className="flex flex-col gap-4  w-full overflow-auto">
 						<div className="flex items-center gap-2 max-sm:flex-wrap">
 							<Input
 								placeholder="Filter by hostname..."

apps/dokploy/components/dashboard/sandbox/add-sandbox.tsx

@@ -1,383 +0,0 @@
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import { Box, PlusIcon } from "lucide-react";
-import { useRouter } from "next/router";
-import { useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { Button } from "@/components/ui/button";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-	DialogTrigger,
-} from "@/components/ui/dialog";
-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 { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
-import { Textarea } from "@/components/ui/textarea";
-import { api } from "@/utils/api";
-
-const schema = z
-	.object({
-		name: z.string().max(64).optional(),
-		source: z.enum(["template", "image"]),
-		template: z.enum(["base", "python", "node"]),
-		image: z.string().max(255).optional(),
-		serverId: z.string().nullable(),
-		cpu: z.number().min(0.1).max(64),
-		memoryMb: z.number().int().min(64).max(262_144),
-		timeoutMinutes: z.number().min(1).max(1440),
-		networkMode: z.enum(["isolated", "internet"]),
-		envVars: z.string().optional(),
-	})
-	.refine((value) => value.source === "template" || !!value.image?.trim(), {
-		message: "Image is required",
-		path: ["image"],
-	});
-
-type FormValues = z.infer<typeof schema>;
-
-interface Props {
-	environmentId: string;
-	projectId: string;
-}
-
-export const AddSandbox = ({ environmentId, projectId }: Props) => {
-	const router = useRouter();
-	const utils = api.useUtils();
-	const [open, setOpen] = useState(false);
-	const { data: isCloud } = api.settings.isCloud.useQuery();
-	const { data: webServerSettings } =
-		api.settings.getWebServerSettings.useQuery();
-	const { data: servers } = api.server.withSSHKey.useQuery();
-	const { data: templates } = api.sandbox.templates.useQuery();
-	const { mutateAsync, isPending, error } = api.sandbox.create.useMutation();
-
-	const showLocalOption = !isCloud && !webServerSettings?.remoteServersOnly;
-
-	const form = useForm<FormValues>({
-		defaultValues: {
-			name: "",
-			source: "template",
-			template: "python",
-			image: "",
-			serverId: null,
-			cpu: 1,
-			memoryMb: 512,
-			timeoutMinutes: 5,
-			networkMode: "isolated",
-			envVars: "",
-		},
-		resolver: zodResolver(schema),
-	});
-	const source = form.watch("source");
-
-	const onSubmit = async (values: FormValues) => {
-		try {
-			const sandbox = await mutateAsync({
-				environmentId,
-				name: values.name?.trim() || undefined,
-				template: values.source === "template" ? values.template : undefined,
-				image: values.source === "image" ? values.image?.trim() : undefined,
-				serverId: values.serverId,
-				cpu: values.cpu,
-				memoryMb: values.memoryMb,
-				timeoutMs: Math.round(values.timeoutMinutes * 60_000),
-				networkMode: values.networkMode,
-				envVars: values.envVars?.trim() || undefined,
-			});
-			toast.success("Sandbox created");
-			await utils.sandbox.list.invalidate({ environmentId });
-			setOpen(false);
-			form.reset();
-			router.push(
-				`/dashboard/project/${projectId}/environment/${environmentId}/sandboxes/${sandbox.sandboxId}`,
-			);
-		} catch {
-			toast.error("Error creating the sandbox");
-		}
-	};
-
-	return (
-		<Dialog open={open} onOpenChange={setOpen}>
-			<DialogTrigger asChild>
-				<Button>
-					<PlusIcon className="size-4" />
-					Create Sandbox
-				</Button>
-			</DialogTrigger>
-			<DialogContent className="sm:max-w-2xl md:max-h-[90vh] overflow-y-auto">
-				<DialogHeader>
-					<DialogTitle className="flex items-center gap-2">
-						<Box className="size-5 text-muted-foreground" />
-						New Sandbox
-					</DialogTitle>
-					<DialogDescription>
-						An ephemeral, resource-limited container you can drive through the
-						API. It is removed automatically when its timeout expires.
-					</DialogDescription>
-				</DialogHeader>
-				{error && <AlertBlock type="error">{error.message}</AlertBlock>}
-				<Form {...form}>
-					<form
-						id="add-sandbox-form"
-						onSubmit={form.handleSubmit(onSubmit)}
-						className="grid gap-4"
-					>
-						<FormField
-							control={form.control}
-							name="name"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Name</FormLabel>
-									<FormControl>
-										<Input placeholder="my-sandbox" {...field} />
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-
-						<FormField
-							control={form.control}
-							name="source"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Image</FormLabel>
-									<Tabs value={field.value} onValueChange={field.onChange}>
-										<TabsList>
-											<TabsTrigger value="template">Template</TabsTrigger>
-											<TabsTrigger value="image">Custom image</TabsTrigger>
-										</TabsList>
-									</Tabs>
-								</FormItem>
-							)}
-						/>
-
-						{source === "template" ? (
-							<FormField
-								control={form.control}
-								name="template"
-								render={({ field }) => (
-									<FormItem>
-										<Select value={field.value} onValueChange={field.onChange}>
-											<SelectTrigger>
-												<SelectValue placeholder="Select a template" />
-											</SelectTrigger>
-											<SelectContent>
-												{(templates ?? []).map((template) => (
-													<SelectItem key={template.name} value={template.name}>
-														<span className="capitalize">{template.name}</span>
-														<span className="text-muted-foreground">
-															{" "}
-															· {template.image}
-														</span>
-													</SelectItem>
-												))}
-											</SelectContent>
-										</Select>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-						) : (
-							<FormField
-								control={form.control}
-								name="image"
-								render={({ field }) => (
-									<FormItem>
-										<FormControl>
-											<Input placeholder="alpine:3.20" {...field} />
-										</FormControl>
-										<FormDescription>
-											The image must contain a POSIX shell (sh) and tail.
-										</FormDescription>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-						)}
-
-						{(servers?.length ?? 0) > 0 && (
-							<FormField
-								control={form.control}
-								name="serverId"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>Server</FormLabel>
-										<Select
-											value={field.value ?? "dokploy"}
-											onValueChange={(value) =>
-												field.onChange(value === "dokploy" ? null : value)
-											}
-										>
-											<SelectTrigger>
-												<SelectValue placeholder="Select a server" />
-											</SelectTrigger>
-											<SelectContent>
-												{showLocalOption && (
-													<SelectItem value="dokploy">
-														Dokploy Server
-													</SelectItem>
-												)}
-												{servers?.map((server) => (
-													<SelectItem
-														key={server.serverId}
-														value={server.serverId}
-													>
-														{server.name}
-													</SelectItem>
-												))}
-											</SelectContent>
-										</Select>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-						)}
-
-						<div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
-							<FormField
-								control={form.control}
-								name="cpu"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>CPU cores</FormLabel>
-										<FormControl>
-											<Input
-												type="number"
-												step="0.1"
-												min={0.1}
-												{...field}
-												onChange={(event) =>
-													field.onChange(event.target.valueAsNumber)
-												}
-											/>
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-							<FormField
-								control={form.control}
-								name="memoryMb"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>Memory (MB)</FormLabel>
-										<FormControl>
-											<Input
-												type="number"
-												step="64"
-												min={64}
-												{...field}
-												onChange={(event) =>
-													field.onChange(event.target.valueAsNumber)
-												}
-											/>
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-							<FormField
-								control={form.control}
-								name="timeoutMinutes"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>Timeout (minutes)</FormLabel>
-										<FormControl>
-											<Input
-												type="number"
-												step="1"
-												min={1}
-												{...field}
-												onChange={(event) =>
-													field.onChange(event.target.valueAsNumber)
-												}
-											/>
-										</FormControl>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-						</div>
-
-						<FormField
-							control={form.control}
-							name="networkMode"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Network</FormLabel>
-									<Select value={field.value} onValueChange={field.onChange}>
-										<SelectTrigger>
-											<SelectValue />
-										</SelectTrigger>
-										<SelectContent>
-											<SelectItem value="isolated">
-												Isolated (no network access)
-											</SelectItem>
-											<SelectItem value="internet">Internet access</SelectItem>
-										</SelectContent>
-									</Select>
-									<FormDescription>
-										Sandboxes are never attached to dokploy-network or any
-										application network.
-									</FormDescription>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-
-						<FormField
-							control={form.control}
-							name="envVars"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Environment variables</FormLabel>
-									<FormControl>
-										<Textarea
-											placeholder={"KEY=value\nOTHER=value"}
-											className="font-mono min-h-[80px]"
-											{...field}
-										/>
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-					</form>
-				</Form>
-				<DialogFooter>
-					<Button
-						type="submit"
-						form="add-sandbox-form"
-						isLoading={isPending}
-						disabled={isPending}
-					>
-						Create
-					</Button>
-				</DialogFooter>
-			</DialogContent>
-		</Dialog>
-	);
-};

apps/dokploy/components/dashboard/sandbox/extend-sandbox-timeout.tsx

@@ -1,120 +0,0 @@
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import { Clock } from "lucide-react";
-import { useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { Button } from "@/components/ui/button";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-	DialogTrigger,
-} from "@/components/ui/dialog";
-import {
-	Form,
-	FormControl,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import { Input } from "@/components/ui/input";
-import { api } from "@/utils/api";
-
-const schema = z.object({
-	minutes: z.number().min(1).max(1440),
-});
-
-interface Props {
-	sandboxId: string;
-	currentTimeoutMs: number;
-}
-
-export const ExtendSandboxTimeout = ({
-	sandboxId,
-	currentTimeoutMs,
-}: Props) => {
-	const utils = api.useUtils();
-	const [open, setOpen] = useState(false);
-	const { mutateAsync, isPending } = api.sandbox.setTimeout.useMutation();
-	const form = useForm<z.infer<typeof schema>>({
-		defaultValues: {
-			minutes: Math.max(1, Math.round(currentTimeoutMs / 60_000)),
-		},
-		resolver: zodResolver(schema),
-	});
-
-	return (
-		<Dialog open={open} onOpenChange={setOpen}>
-			<DialogTrigger asChild>
-				<Button variant="outline">
-					<Clock className="size-4" />
-					Extend timeout
-				</Button>
-			</DialogTrigger>
-			<DialogContent className="sm:max-w-md">
-				<DialogHeader>
-					<DialogTitle>Extend timeout</DialogTitle>
-					<DialogDescription>
-						The sandbox will be killed this many minutes after its last
-						activity.
-					</DialogDescription>
-				</DialogHeader>
-				<Form {...form}>
-					<form
-						id="extend-sandbox-form"
-						className="grid gap-4"
-						onSubmit={form.handleSubmit(async (values) => {
-							await mutateAsync({
-								sandboxId,
-								timeoutMs: Math.round(values.minutes * 60_000),
-							})
-								.then(async () => {
-									toast.success("Timeout updated");
-									await utils.sandbox.one.invalidate({ sandboxId });
-									setOpen(false);
-								})
-								.catch(() => toast.error("Error updating the timeout"));
-						})}
-					>
-						<FormField
-							control={form.control}
-							name="minutes"
-							render={({ field }) => (
-								<FormItem>
-									<FormLabel>Timeout (minutes)</FormLabel>
-									<FormControl>
-										<Input
-											type="number"
-											min={1}
-											step={1}
-											{...field}
-											onChange={(event) =>
-												field.onChange(event.target.valueAsNumber)
-											}
-										/>
-									</FormControl>
-									<FormMessage />
-								</FormItem>
-							)}
-						/>
-					</form>
-				</Form>
-				<DialogFooter>
-					<Button
-						type="submit"
-						form="extend-sandbox-form"
-						isLoading={isPending}
-						disabled={isPending}
-					>
-						Save
-					</Button>
-				</DialogFooter>
-			</DialogContent>
-		</Dialog>
-	);
-};

apps/dokploy/components/dashboard/sandbox/sandbox-console.tsx

@@ -1,185 +0,0 @@
-import { Eraser, Loader2, Play, Terminal } from "lucide-react";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Input } from "@/components/ui/input";
-import { cn } from "@/lib/utils";
-
-type Line = {
-	kind: "cmd" | "stdout" | "stderr" | "exit" | "error" | "info";
-	text: string;
-};
-
-type ServerMessage =
-	| { type: "ready"; sandboxId: string }
-	| { type: "stdout"; data: string }
-	| { type: "stderr"; data: string }
-	| { type: "exit"; exitCode: number; timedOut: boolean }
-	| { type: "error"; message: string };
-
-interface Props {
-	sandboxId: string;
-	enabled: boolean;
-	workdir: string;
-}
-
-const lineClass: Record<Line["kind"], string> = {
-	cmd: "text-primary font-semibold",
-	stdout: "text-foreground",
-	stderr: "text-orange-500",
-	exit: "text-muted-foreground italic",
-	error: "text-destructive",
-	info: "text-muted-foreground",
-};
-
-export const SandboxConsole = ({ sandboxId, enabled, workdir }: Props) => {
-	const [lines, setLines] = useState<Line[]>([]);
-	const [command, setCommand] = useState("");
-	const [running, setRunning] = useState(false);
-	const [connected, setConnected] = useState(false);
-	const wsRef = useRef<WebSocket | null>(null);
-	const outputRef = useRef<HTMLDivElement | null>(null);
-
-	const append = useCallback((line: Line) => {
-		setLines((prev) => {
-			const last = prev[prev.length - 1];
-			if (
-				last &&
-				(line.kind === "stdout" || line.kind === "stderr") &&
-				last.kind === line.kind &&
-				!last.text.endsWith("\n")
-			) {
-				return [...prev.slice(0, -1), { ...last, text: last.text + line.text }];
-			}
-			return [...prev, line];
-		});
-	}, []);
-
-	useEffect(() => {
-		if (!enabled) return;
-		const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-		const ws = new WebSocket(
-			`${protocol}//${window.location.host}/sandbox-exec?sandboxId=${sandboxId}`,
-		);
-		wsRef.current = ws;
-		ws.onopen = () => setConnected(true);
-		ws.onclose = (event) => {
-			setConnected(false);
-			setRunning(false);
-			if (event.code >= 4000) {
-				append({ kind: "error", text: event.reason || "Connection closed" });
-			}
-		};
-		ws.onmessage = (event) => {
-			let message: ServerMessage;
-			try {
-				message = JSON.parse(event.data);
-			} catch {
-				return;
-			}
-			if (message.type === "stdout")
-				append({ kind: "stdout", text: message.data });
-			else if (message.type === "stderr")
-				append({ kind: "stderr", text: message.data });
-			else if (message.type === "exit") {
-				append({
-					kind: "exit",
-					text: message.timedOut
-						? `[timed out, exit code ${message.exitCode}]`
-						: `[exit code ${message.exitCode}]`,
-				});
-				setRunning(false);
-			} else if (message.type === "error") {
-				append({ kind: "error", text: message.message });
-				setRunning(false);
-			}
-		};
-		return () => {
-			ws.close();
-			wsRef.current = null;
-		};
-	}, [sandboxId, enabled, append]);
-
-	useEffect(() => {
-		outputRef.current?.scrollTo({ top: outputRef.current.scrollHeight });
-	}, [lines]);
-
-	const run = () => {
-		const cmd = command.trim();
-		const ws = wsRef.current;
-		if (!cmd || !ws || ws.readyState !== WebSocket.OPEN || running) return;
-		append({ kind: "cmd", text: `$ ${cmd}` });
-		setRunning(true);
-		setCommand("");
-		ws.send(JSON.stringify({ type: "exec", cmd }));
-	};
-
-	return (
-		<Card className="bg-background">
-			<CardHeader className="flex flex-row items-center justify-between">
-				<CardTitle className="text-xl flex items-center gap-2">
-					<Terminal className="size-5 text-muted-foreground" />
-					Console
-					<span className="text-xs font-normal text-muted-foreground">
-						{enabled
-							? connected
-								? "connected"
-								: "connecting..."
-							: "sandbox is not running"}
-					</span>
-				</CardTitle>
-				<Button
-					variant="ghost"
-					size="sm"
-					onClick={() => setLines([])}
-					disabled={lines.length === 0}
-				>
-					<Eraser className="size-4" />
-					Clear
-				</Button>
-			</CardHeader>
-			<CardContent className="flex flex-col gap-3">
-				<div
-					ref={outputRef}
-					className="h-[360px] overflow-auto rounded-lg border bg-muted/30 p-3 font-mono text-xs whitespace-pre-wrap break-words"
-				>
-					{lines.length === 0 ? (
-						<span className="text-muted-foreground">
-							Commands run with `sh -c` inside {workdir}. Output streams here.
-						</span>
-					) : (
-						lines.map((line, index) => (
-							<div key={index} className={cn(lineClass[line.kind])}>
-								{line.text}
-							</div>
-						))
-					)}
-				</div>
-				<form
-					className="flex gap-2"
-					onSubmit={(event) => {
-						event.preventDefault();
-						run();
-					}}
-				>
-					<Input
-						value={command}
-						onChange={(event) => setCommand(event.target.value)}
-						placeholder="echo hello"
-						className="font-mono"
-						disabled={!enabled || !connected || running}
-						autoComplete="off"
-					/>
-					<Button type="submit" disabled={!enabled || !connected || running}>
-						{running ? (
-							<Loader2 className="size-4 animate-spin" />
-						) : (
-							<Play className="size-4" />
-						)}
-						Run
-					</Button>
-				</form>
-			</CardContent>
-		</Card>
-	);
-};

apps/dokploy/components/dashboard/sandbox/sandbox-status-badge.tsx

@@ -1,16 +0,0 @@
-import { Badge } from "@/components/ui/badge";
-
-type SandboxStatus = "creating" | "running" | "killed" | "error";
-
-const variants: Record<SandboxStatus, "green" | "yellow" | "blank" | "red"> = {
-	running: "green",
-	creating: "yellow",
-	killed: "blank",
-	error: "red",
-};
-
-export const SandboxStatusBadge = ({ status }: { status: SandboxStatus }) => (
-	<Badge variant={variants[status]} className="capitalize">
-		{status}
-	</Badge>
-);

apps/dokploy/components/dashboard/sandbox/show-sandboxes.tsx

@@ -1,134 +0,0 @@
-import { formatDistanceToNow } from "date-fns";
-import { Box, ServerIcon, Trash2 } from "lucide-react";
-import Link from "next/link";
-import { toast } from "sonner";
-import { DateTooltip } from "@/components/shared/date-tooltip";
-import { DialogAction } from "@/components/shared/dialog-action";
-import { Button } from "@/components/ui/button";
-import {
-	Table,
-	TableBody,
-	TableCell,
-	TableHead,
-	TableHeader,
-	TableRow,
-} from "@/components/ui/table";
-import { api } from "@/utils/api";
-import { SandboxStatusBadge } from "./sandbox-status-badge";
-
-interface Props {
-	projectId: string;
-	environmentId: string;
-}
-
-export const formatExpiresIn = (expiresAt: Date | null, status: string) => {
-	if (status !== "running" || !expiresAt) return "—";
-	if (expiresAt.getTime() <= Date.now()) return "expired";
-	return formatDistanceToNow(expiresAt, { addSuffix: true });
-};
-
-export const ShowSandboxes = ({ projectId, environmentId }: Props) => {
-	const utils = api.useUtils();
-	const { data: permissions } = api.user.getPermissions.useQuery();
-	const { data: sandboxes, isLoading } = api.sandbox.list.useQuery(
-		{ environmentId },
-		{ refetchInterval: 10_000 },
-	);
-	const { mutateAsync: kill } = api.sandbox.kill.useMutation();
-
-	if (isLoading) {
-		return (
-			<div className="flex min-h-[40vh] items-center justify-center text-sm text-muted-foreground">
-				Loading...
-			</div>
-		);
-	}
-
-	if (!sandboxes || sandboxes.length === 0) {
-		return (
-			<div className="flex min-h-[40vh] w-full flex-col items-center justify-center gap-2">
-				<Box className="size-8 text-muted-foreground" />
-				<span className="font-medium text-muted-foreground">
-					No sandboxes yet. Create one from the UI or through the API.
-				</span>
-			</div>
-		);
-	}
-
-	return (
-		<div className="rounded-lg border overflow-x-auto">
-			<Table>
-				<TableHeader>
-					<TableRow>
-						<TableHead>Name</TableHead>
-						<TableHead>Image</TableHead>
-						<TableHead>Status</TableHead>
-						<TableHead>Server</TableHead>
-						<TableHead>CPU / RAM</TableHead>
-						<TableHead>Expires</TableHead>
-						<TableHead>Created</TableHead>
-						<TableHead className="text-right">Actions</TableHead>
-					</TableRow>
-				</TableHeader>
-				<TableBody>
-					{sandboxes.map((sandbox) => (
-						<TableRow key={sandbox.sandboxId}>
-							<TableCell className="font-medium">
-								<Link
-									href={`/dashboard/project/${projectId}/environment/${environmentId}/sandboxes/${sandbox.sandboxId}`}
-									className="hover:underline"
-								>
-									{sandbox.name}
-								</Link>
-							</TableCell>
-							<TableCell className="font-mono text-xs">
-								{sandbox.image}
-							</TableCell>
-							<TableCell>
-								<SandboxStatusBadge status={sandbox.status} />
-							</TableCell>
-							<TableCell>
-								<span className="flex items-center gap-1.5 text-sm">
-									<ServerIcon className="size-3.5 text-muted-foreground" />
-									{sandbox.server?.name ?? "Dokploy Server"}
-								</span>
-							</TableCell>
-							<TableCell className="text-sm">
-								{sandbox.cpu} vCPU / {sandbox.memoryMb} MB
-							</TableCell>
-							<TableCell className="text-sm text-muted-foreground">
-								{formatExpiresIn(sandbox.expiresAt, sandbox.status)}
-							</TableCell>
-							<TableCell className="text-sm">
-								<DateTooltip date={sandbox.createdAt} />
-							</TableCell>
-							<TableCell className="text-right">
-								{sandbox.status === "running" &&
-									permissions?.deployment.create && (
-										<DialogAction
-											title="Kill sandbox"
-											description={`The container for "${sandbox.name}" will be stopped and removed.`}
-											onClick={async () => {
-												await kill({ sandboxId: sandbox.sandboxId })
-													.then(() => {
-														toast.success("Sandbox killed");
-														utils.sandbox.list.invalidate({ environmentId });
-													})
-													.catch(() =>
-														toast.error("Error killing the sandbox"),
-													);
-											}}
-										>
-											<Button variant="ghost" size="icon">
-												<Trash2 className="size-4 text-destructive" />
-											</Button>
-										</DialogAction>
-									)}
-							</TableCell>
-						</TableRow>
-					))}
-				</TableBody>
-			</Table>
-		</div>
-	);
-};

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

@@ -24,7 +24,7 @@ export const AiForm = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="flex flex-row gap-2 justify-between">
 						<div>
@@ -62,7 +62,7 @@ export const AiForm = () => {
 												key={config.aiId}
 												className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 											>
-												<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+												<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 													<div>
 														<span className="text-sm font-medium">
 															{config.name}

apps/dokploy/components/dashboard/settings/api/show-api-keys.tsx

@@ -22,7 +22,7 @@ export const ShowApiKeys = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md">
 					<CardHeader className="flex flex-row gap-2 flex-wrap justify-between items-center">
 						<div>

apps/dokploy/components/dashboard/settings/billing/show-billing-invoices.tsx

@@ -29,7 +29,7 @@ export const ShowBillingInvoices = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="bg-sidebar p-2.5 rounded-xl w-full">
+			<Card className="bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md">
 					<CardHeader>
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/billing/show-billing.tsx

@@ -117,7 +117,7 @@ export const ShowBilling = () => {
 				utils.stripe.getProducts.invalidate(),
 				utils.user.get.invalidate(),
 			]);
-			toast.success("Your 7-day trial has started");
+			toast.success("Your 14-day trial has started");
 		} catch (error) {
 			toast.error(
 				error instanceof Error ? error.message : "Error starting trial",
@@ -326,14 +326,14 @@ export const ShowBilling = () => {
 											<Clock className="h-5 w-5 text-primary shrink-0" />
 											<div className="flex flex-col gap-1.5">
 												<span className="text-sm font-medium">
-													7-day free trial
+													14-day free trial
 												</span>
 												<span className="text-sm text-muted-foreground">
 													No credit card required — cancel anytime.
 												</span>
 												<ul className="flex flex-col gap-1 mt-1">
 													{[
-														"Setup 1 server",
+														"1 server included",
 														"Unlimited apps & databases",
 														"Community support",
 													].map((feature) => (
@@ -917,7 +917,7 @@ export const ShowBilling = () => {
 													"Unlimited Deployments",
 													"Unlimited Databases",
 													"Unlimited Applications",
-													"Setup 1 Server",
+													"1 Server Included",
 													"1 Organization",
 													"1 User",
 													"2 Environments",
@@ -1049,7 +1049,7 @@ export const ShowBilling = () => {
 													All the features of Hobby, plus…
 												</li>
 												{[
-													"Setup up to 3 Servers",
+													"3 Servers Included",
 													"3 Organizations",
 													"Unlimited Users",
 													"Unlimited Environments",

apps/dokploy/components/dashboard/settings/certificates/show-certificates.tsx

@@ -38,7 +38,7 @@ export const ShowCertificates = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
@@ -111,7 +111,7 @@ export const ShowCertificates = () => {
 														key={certificate.certificateId}
 														className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 													>
-														<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+														<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 															<div className="flex items-center justify-between">
 																<div className="flex gap-2 flex-col">
 																	<span className="text-sm font-medium">

apps/dokploy/components/dashboard/settings/cluster/registry/show-registry.tsx

@@ -20,7 +20,7 @@ export const ShowRegistry = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
@@ -55,7 +55,7 @@ export const ShowRegistry = () => {
 													key={registry.registryId}
 													className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 												>
-													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 														<div className="flex items-center justify-between">
 															<div className="flex gap-2 flex-col">
 																<span className="text-sm font-medium">

apps/dokploy/components/dashboard/settings/destination/show-destinations.tsx

@@ -19,7 +19,7 @@ export const ShowDestinations = () => {
 	const { data: permissions } = api.user.getPermissions.useQuery();
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
@@ -56,7 +56,7 @@ export const ShowDestinations = () => {
 													key={destination.destinationId}
 													className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 												>
-													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 														<div className="flex flex-col gap-1">
 															<span className="text-sm">
 																{index + 1}. {destination.name}

apps/dokploy/components/dashboard/settings/dns/handle-dns-provider.tsx

@@ -44,18 +44,6 @@ const providerLabels = {
 	cloudflare: "Cloudflare",
 	route53: "AWS Route53",
 	porkbun: "Porkbun",
-	infomaniak: "Infomaniak",
-	ovh: "OVHcloud",
-} as const;
-
-const ovhEndpointLabels = {
-	"ovh-eu": "OVHcloud Europe",
-	"ovh-ca": "OVHcloud Canada",
-	"ovh-us": "OVHcloud US",
-	"kimsufi-eu": "Kimsufi Europe",
-	"kimsufi-ca": "Kimsufi Canada",
-	"soyoustart-eu": "So you Start Europe",
-	"soyoustart-ca": "So you Start Canada",
 } as const;
 
 type ProviderType = keyof typeof providerLabels;
@@ -67,27 +55,12 @@ const DnsProviderSchema = z.object({
 		.regex(/^[a-zA-Z0-9_-]+$/, {
 			message: "Only letters, numbers, dashes and underscores",
 		}),
-	providerType: z.enum([
-		"cloudflare",
-		"route53",
-		"porkbun",
-		"infomaniak",
-		"ovh",
-	]),
+	providerType: z.enum(["cloudflare", "route53", "porkbun"]),
 	apiToken: z.string(),
 	accessKeyId: z.string(),
 	secretAccessKey: z.string(),
 	apiKey: z.string(),
 	secretApiKey: z.string(),
-	endpoint: z.enum(
-		Object.keys(ovhEndpointLabels) as [
-			keyof typeof ovhEndpointLabels,
-			...(keyof typeof ovhEndpointLabels)[],
-		],
-	),
-	applicationKey: z.string(),
-	applicationSecret: z.string(),
-	consumerKey: z.string(),
 });
 
 type DnsProviderForm = z.infer<typeof DnsProviderSchema>;
@@ -100,10 +73,6 @@ const defaultValues: DnsProviderForm = {
 	secretAccessKey: "",
 	apiKey: "",
 	secretApiKey: "",
-	endpoint: "ovh-eu",
-	applicationKey: "",
-	applicationSecret: "",
-	consumerKey: "",
 };
 
 const buildConfig = (data: DnsProviderForm) => {
@@ -125,19 +94,6 @@ const buildConfig = (data: DnsProviderForm) => {
 				apiKey: data.apiKey,
 				secretApiKey: data.secretApiKey,
 			};
-		case "infomaniak":
-			return {
-				providerType: "infomaniak" as const,
-				apiToken: data.apiToken,
-			};
-		case "ovh":
-			return {
-				providerType: "ovh" as const,
-				endpoint: data.endpoint,
-				applicationKey: data.applicationKey,
-				applicationSecret: data.applicationSecret,
-				consumerKey: data.consumerKey,
-			};
 	}
 };
 
@@ -199,15 +155,6 @@ export const HandleDnsProvider = ({ dnsProviderId }: Props) => {
 					apiKey: provider.config.apiKey,
 					secretApiKey: provider.config.secretApiKey,
 				}),
-				...(provider.config.providerType === "infomaniak" && {
-					apiToken: provider.config.apiToken,
-				}),
-				...(provider.config.providerType === "ovh" && {
-					endpoint: provider.config.endpoint,
-					applicationKey: provider.config.applicationKey,
-					applicationSecret: provider.config.applicationSecret,
-					consumerKey: provider.config.consumerKey,
-				}),
 			});
 		} else if (!dnsProviderId) {
 			form.reset(defaultValues);
@@ -436,118 +383,6 @@ export const HandleDnsProvider = ({ dnsProviderId }: Props) => {
 							</>
 						)}
 
-						{providerType === "infomaniak" && (
-							<FormField
-								control={form.control}
-								name="apiToken"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>API Token</FormLabel>
-										<FormControl>
-											<Input type="password" {...field} />
-										</FormControl>
-										<FormDescription>
-											Create a token at manager.infomaniak.com with the{" "}
-											<code>domain:read</code>, <code>dns:read</code> and{" "}
-											<code>dns:write</code> scopes.
-										</FormDescription>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
-						)}
-
-						{providerType === "ovh" && (
-							<>
-								<FormField
-									control={form.control}
-									name="endpoint"
-									render={({ field }) => (
-										<FormItem>
-											<FormLabel>API Endpoint</FormLabel>
-											<Select
-												onValueChange={field.onChange}
-												value={field.value}
-											>
-												<FormControl>
-													<SelectTrigger>
-														<SelectValue placeholder="Select an endpoint" />
-													</SelectTrigger>
-												</FormControl>
-												<SelectContent>
-													{Object.entries(ovhEndpointLabels).map(
-														([value, label]) => (
-															<SelectItem key={value} value={value}>
-																{label}
-															</SelectItem>
-														),
-													)}
-												</SelectContent>
-											</Select>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="applicationKey"
-									render={({ field }) => (
-										<FormItem>
-											<FormLabel>Application Key</FormLabel>
-											<FormControl>
-												<Input {...field} />
-											</FormControl>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="applicationSecret"
-									render={({ field }) => (
-										<FormItem>
-											<FormLabel>Application Secret</FormLabel>
-											<FormControl>
-												<Input type="password" {...field} />
-											</FormControl>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="consumerKey"
-									render={({ field }) => (
-										<FormItem>
-											<FormLabel>Consumer Key</FormLabel>
-											<FormControl>
-												<Input type="password" {...field} />
-											</FormControl>
-											<FormDescription>
-												Create the three keys at once on
-												api.ovh.com/createToken, with exactly these five rights:
-												<br />
-												<code>GET /domain/zone</code>
-												<br />
-												<code>GET /domain/zone/*</code>
-												<br />
-												<code>POST /domain/zone/*</code>
-												<br />
-												<code>PUT /domain/zone/*</code>
-												<br />
-												<code>DELETE /domain/zone/*</code>
-												<br />
-												The first one lists your zones and has to be granted on
-												its own: OVH matches rights per exact path, so{" "}
-												<code>/domain/zone/*</code> does not cover it.
-											</FormDescription>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-							</>
-						)}
-
 						<DialogFooter className="flex w-full flex-row justify-between gap-2 sm:justify-between">
 							<Button
 								type="button"

apps/dokploy/components/dashboard/settings/dns/show-dns-providers.tsx

@@ -23,9 +23,6 @@ import { HandleDnsProvider } from "./handle-dns-provider";
 const providerLabels: Record<string, string> = {
 	cloudflare: "Cloudflare",
 	route53: "AWS Route53",
-	porkbun: "Porkbun",
-	infomaniak: "Infomaniak",
-	ovh: "OVHcloud",
 };
 
 export const ShowDnsProviders = () => {
@@ -35,7 +32,7 @@ export const ShowDnsProviders = () => {
 	const { data: permissions } = api.user.getPermissions.useQuery();
 
 	return (
-		<div className="w-full">
+		<div className="w-full max-w-5xl mx-auto">
 			<Card className="h-full bg-sidebar p-2.5 rounded-xl">
 				<div className="rounded-xl bg-background shadow-md">
 					<div className="flex flex-wrap items-center justify-between gap-4 p-6">

apps/dokploy/components/dashboard/settings/dns/show-dns-zones.tsx

@@ -52,7 +52,7 @@ export const ShowDnsZones = ({ dnsProviderId }: Props) => {
 		api.dnsProvider.listZones.useQuery({ dnsProviderId });
 
 	return (
-		<div className="w-full">
+		<div className="w-full max-w-5xl mx-auto">
 			<Card className="h-full bg-sidebar p-2.5 rounded-xl">
 				<div className="rounded-xl bg-background shadow-md">
 					<div className="flex flex-wrap items-center justify-between gap-4 p-6">

apps/dokploy/components/dashboard/settings/git/show-git-providers.tsx

@@ -69,7 +69,7 @@ export const ShowGitProviders = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/notifications/show-notifications.tsx

@@ -31,7 +31,7 @@ export const ShowNotifications = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
@@ -70,7 +70,7 @@ export const ShowNotifications = () => {
 													key={notification.notificationId}
 													className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 												>
-													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 														<span className="text-sm flex flex-row items-center gap-4">
 															{notification.notificationType === "slack" && (
 																<div className="flex  items-center justify-center rounded-lg">

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

@@ -150,7 +150,7 @@ export const ProfileForm = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="flex flex-row gap-2 flex-wrap justify-between items-center">
 						<div>

apps/dokploy/components/dashboard/settings/servers/show-servers.tsx

@@ -49,7 +49,7 @@ export const ShowServers = () => {
 	return (
 		<div className="w-full">
 			{query?.success && isCloud && <WelcomeSubscription />}
-			<Card className="h-full  p-2.5 rounded-xl w-full">
+			<Card className="h-full  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/ssh-keys/show-ssh-keys.tsx

@@ -21,7 +21,7 @@ export const ShowDestinations = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">
@@ -57,7 +57,7 @@ export const ShowDestinations = () => {
 													key={sshKey.sshKeyId}
 													className="flex items-center justify-between bg-sidebar p-1 w-full rounded-lg"
 												>
-													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border w-full">
+													<div className="flex items-center justify-between p-3.5 rounded-lg bg-background border  w-full">
 														<div className="flex items-center justify-between">
 															<div className="flex flex-col">
 																<span className="text-sm font-medium">

apps/dokploy/components/dashboard/settings/tags/tag-manager.tsx

@@ -22,7 +22,7 @@ export const TagManager = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md">
 					<CardHeader>
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/users/add-permissions.tsx

@@ -320,7 +320,7 @@ export const AddUserPermissions = ({ userId, role }: Props) => {
 					<form
 						id="hook-form-add-permissions"
 						onSubmit={form.handleSubmit(onSubmit)}
-						className="grid  grid-cols-1 md:grid-cols-2 w-full gap-4"
+						className="grid  grid-cols-1 md:grid-cols-2  w-full gap-4"
 					>
 						{isCustomRole && (
 							<div className="md:col-span-2 rounded-lg border p-3 bg-muted/50 text-sm text-muted-foreground">

apps/dokploy/components/dashboard/settings/users/show-invitations.tsx

@@ -40,7 +40,7 @@ export const ShowInvitations = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/users/show-users.tsx

@@ -52,7 +52,7 @@ export const ShowUsers = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/vault/handle-vault-provider.tsx

@@ -40,7 +40,6 @@ const providerLabels = {
 	hashicorp: "HashiCorp Vault / OpenBao",
 	infisical: "Infisical",
 	aws: "AWS Secrets Manager",
-	"aws-parameter-store": "AWS Parameter Store",
 	doppler: "Doppler",
 	azure: "Azure Key Vault",
 	scaleway: "Scaleway Secret Manager",
@@ -62,7 +61,6 @@ const VaultProviderSchema = z
 			"hashicorp",
 			"infisical",
 			"aws",
-			"aws-parameter-store",
 			"doppler",
 			"azure",
 			"scaleway",
@@ -81,7 +79,6 @@ const VaultProviderSchema = z
 		region: z.string(),
 		accessKeyId: z.string(),
 		secretAccessKey: z.string(),
-		parameterPath: z.string(),
 		serviceToken: z.string(),
 		awsEndpoint: z.string(),
 		vaultUri: z.string(),
@@ -139,8 +136,7 @@ const VaultProviderSchema = z
 			});
 		}
 		if (
-			(data.providerType === "aws" ||
-				data.providerType === "aws-parameter-store") &&
+			data.providerType === "aws" &&
 			data.awsEndpoint &&
 			!isValidUrl(data.awsEndpoint)
 		) {
@@ -150,17 +146,6 @@ const VaultProviderSchema = z
 				path: ["awsEndpoint"],
 			});
 		}
-		if (
-			data.providerType === "aws-parameter-store" &&
-			data.parameterPath &&
-			!data.parameterPath.trim().startsWith("/")
-		) {
-			ctx.addIssue({
-				code: z.ZodIssueCode.custom,
-				message: "Parameter discovery path must start with /",
-				path: ["parameterPath"],
-			});
-		}
 		if (
 			data.providerType === "scaleway" &&
 			data.scalewayApiUrl &&
@@ -215,11 +200,6 @@ const VaultProviderSchema = z
 				["accessKeyId", "Access Key ID is required"],
 				["secretAccessKey", "Secret Access Key is required"],
 			],
-			"aws-parameter-store": [
-				["region", "Region is required"],
-				["accessKeyId", "Access Key ID is required"],
-				["secretAccessKey", "Secret Access Key is required"],
-			],
 			doppler: [["serviceToken", "Service Token is required"]],
 			azure: [
 				["vaultUri", "Vault URI is required"],
@@ -285,7 +265,6 @@ const defaultValues: VaultProviderForm = {
 	region: "",
 	accessKeyId: "",
 	secretAccessKey: "",
-	parameterPath: "",
 	serviceToken: "",
 	awsEndpoint: "",
 	vaultUri: "",
@@ -334,15 +313,6 @@ const buildConfig = (data: VaultProviderForm) => {
 				secretAccessKey: data.secretAccessKey,
 				endpoint: data.awsEndpoint || undefined,
 			};
-		case "aws-parameter-store":
-			return {
-				providerType: "aws-parameter-store" as const,
-				region: data.region,
-				accessKeyId: data.accessKeyId,
-				secretAccessKey: data.secretAccessKey,
-				endpoint: data.awsEndpoint || undefined,
-				parameterPath: data.parameterPath.trim() || undefined,
-			};
 		case "doppler":
 			return {
 				providerType: "doppler" as const,
@@ -473,16 +443,12 @@ export const HandleVaultProvider = ({ vaultProviderId }: Props) => {
 					environmentSlug: provider.config.environmentSlug,
 					secretPath: provider.config.secretPath,
 				}),
-				...((provider.config.providerType === "aws" ||
-					provider.config.providerType === "aws-parameter-store") && {
+				...(provider.config.providerType === "aws" && {
 					region: provider.config.region,
 					accessKeyId: provider.config.accessKeyId,
 					secretAccessKey: provider.config.secretAccessKey,
 					awsEndpoint: provider.config.endpoint ?? "",
 				}),
-				...(provider.config.providerType === "aws-parameter-store" && {
-					parameterPath: provider.config.parameterPath ?? "",
-				}),
 				...(provider.config.providerType === "doppler" && {
 					serviceToken: provider.config.serviceToken,
 					dopplerProject: provider.config.project ?? "",
@@ -791,8 +757,7 @@ export const HandleVaultProvider = ({ vaultProviderId }: Props) => {
 							</>
 						)}
 
-						{(providerType === "aws" ||
-							providerType === "aws-parameter-store") && (
+						{providerType === "aws" && (
 							<>
 								<FormField
 									control={form.control}
@@ -850,44 +815,12 @@ export const HandleVaultProvider = ({ vaultProviderId }: Props) => {
 										</FormItem>
 									)}
 								/>
-								{providerType === "aws-parameter-store" && (
-									<FormField
-										control={form.control}
-										name="parameterPath"
-										render={({ field }) => (
-											<FormItem>
-												<FormLabel>Discovery path (optional)</FormLabel>
-												<FormControl>
-													<Input placeholder="/production/my-app" {...field} />
-												</FormControl>
-												<FormDescription>
-													Limits parameter browsing and autocomplete to this
-													hierarchy. IAM permissions remain the security
-													boundary.
-												</FormDescription>
-												<FormMessage />
-											</FormItem>
-										)}
-									/>
-								)}
-								{providerType === "aws" ? (
-									<FormDescription>
-										Reference format:{" "}
-										<code>{"${{vault.<name>.secret-name}}"}</code> or{" "}
-										<code>{"${{vault.<name>.secret-name:field}}"}</code> for
-										JSON secrets
-									</FormDescription>
-								) : (
-									<FormDescription>
-										Reference format:{" "}
-										<code>{"${{vault.<name>./path/to/parameter}}"}</code>.
-										SecureString parameters are decrypted automatically.
-										Resolution requires <code>ssm:GetParameters</code>.
-										Discovery requires <code>ssm:DescribeParameters</code>.
-										Customer-managed KMS keys also require{" "}
-										<code>kms:Decrypt</code>.
-									</FormDescription>
-								)}
+								<FormDescription>
+									Reference format:{" "}
+									<code>{"${{vault.<name>.secret-name}}"}</code> or{" "}
+									<code>{"${{vault.<name>.secret-name:field}}"}</code> for JSON
+									secrets
+								</FormDescription>
 							</>
 						)}
 

apps/dokploy/components/dashboard/settings/vault/show-vault-providers.tsx

@@ -18,7 +18,6 @@ const providerLabels: Record<string, string> = {
 	hashicorp: "HashiCorp Vault",
 	infisical: "Infisical",
 	aws: "AWS Secrets Manager",
-	"aws-parameter-store": "AWS Parameter Store",
 	doppler: "Doppler",
 	azure: "Azure Key Vault",
 	scaleway: "Scaleway Secret Manager",
@@ -33,7 +32,7 @@ export const ShowVaultProviders = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md">
 					<CardHeader>
 						<CardTitle className="text-xl flex flex-row gap-2">

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

@@ -123,7 +123,7 @@ export const WebDomain = () => {
 
 	return (
 		<div className="w-full">
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="flex flex-row gap-2 flex-wrap justify-between items-center">
 						<div className="flex flex-col gap-1">

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

@@ -24,7 +24,7 @@ export const WebServer = () => {
 	return (
 		<div className="w-full">
 			{/* <Card className={cn("rounded-lg w-full bg-transparent p-0", className)}></Card> */}
-			<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+			<Card className="h-full bg-sidebar  p-2.5 rounded-xl  max-w-5xl mx-auto">
 				<div className="rounded-xl bg-background shadow-md ">
 					<CardHeader className="">
 						<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/dashboard/settings/web-server/update-server.tsx

@@ -7,7 +7,6 @@ import {
 	Server,
 	Sparkles,
 	Stars,
-	X,
 } from "lucide-react";
 import Link from "next/link";
 import { useState } from "react";
@@ -15,7 +14,6 @@ import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import {
 	Dialog,
-	DialogClose,
 	DialogContent,
 	DialogTitle,
 	DialogTrigger,
@@ -128,13 +126,13 @@ export const UpdateServer = ({
 					</TooltipProvider>
 				)}
 			</DialogTrigger>
-			<DialogContent className="max-w-lg" showCloseButton={false}>
-				<div className="flex items-center gap-2 mb-8">
-					<DialogTitle className="text-2xl font-semibold mr-auto">
+			<DialogContent className="max-w-lg">
+				<div className="flex items-center justify-between mb-8">
+					<DialogTitle className="text-2xl font-semibold">
 						Web Server Update
 					</DialogTitle>
 					{dokployVersion && (
-						<div className="flex items-center gap-1.5 rounded-full px-3 py-1 bg-muted">
+						<div className="flex items-center gap-1.5 rounded-full px-3 py-1 mr-2 bg-muted">
 							<Server className="h-4 w-4 text-muted-foreground" />
 							<span className="text-sm text-muted-foreground">
 								{dokployVersion}{" "}
@@ -143,12 +141,6 @@ export const UpdateServer = ({
 							</span>
 						</div>
 					)}
-					<DialogClose asChild>
-						<Button variant="ghost" size="icon-sm" className="shrink-0">
-							<X />
-							<span className="sr-only">Close</span>
-						</Button>
-					</DialogClose>
 				</div>
 
 				{/* Initial state */}

apps/dokploy/components/dashboard/shared/transfer-service.tsx

@@ -1,245 +0,0 @@
-import type { ServiceType } from "@dokploy/server/db/schema";
-import { standardSchemaResolver as zodResolver } from "@hookform/resolvers/standard-schema";
-import { ArrowRightLeft } from "lucide-react";
-import { useState } from "react";
-import { useForm } from "react-hook-form";
-import { toast } from "sonner";
-import { z } from "zod";
-import { AlertBlock } from "@/components/shared/alert-block";
-import { DrawerLogs } from "@/components/shared/drawer-logs";
-import { Button } from "@/components/ui/button";
-import { Checkbox } from "@/components/ui/checkbox";
-import {
-	Dialog,
-	DialogContent,
-	DialogDescription,
-	DialogFooter,
-	DialogHeader,
-	DialogTitle,
-	DialogTrigger,
-} from "@/components/ui/dialog";
-import {
-	Form,
-	FormControl,
-	FormField,
-	FormItem,
-	FormLabel,
-	FormMessage,
-} from "@/components/ui/form";
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select";
-import { api } from "@/utils/api";
-import { type LogLine, parseLogs } from "../docker/logs/utils";
-
-const LOCAL_SERVER = "dokploy";
-
-const transferSchema = z.object({
-	targetServerId: z.string().min(1, { message: "Select a target server" }),
-	removeSourceData: z.boolean(),
-});
-
-type TransferForm = z.infer<typeof transferSchema>;
-
-interface Props {
-	id: string;
-	type: ServiceType;
-	serverId?: string | null;
-}
-
-export const TransferService = ({ id, type, serverId }: Props) => {
-	const utils = api.useUtils();
-	const { data: isCloud } = api.settings.isCloud.useQuery();
-	const { data: servers } = api.server.withSSHKey.useQuery();
-	const [isOpen, setIsOpen] = useState(false);
-	const [isDrawerOpen, setIsDrawerOpen] = useState(false);
-	const [isTransferring, setIsTransferring] = useState(false);
-	const [logs, setLogs] = useState<LogLine[]>([]);
-	const [request, setRequest] = useState<{
-		targetServerId: string | null;
-		removeSourceData: boolean;
-	} | null>(null);
-
-	const targets = [
-		...(!isCloud && serverId
-			? [{ serverId: LOCAL_SERVER, name: "Dokploy Server" }]
-			: []),
-		...(servers ?? []).filter((server) => server.serverId !== serverId),
-	];
-
-	const form = useForm<TransferForm>({
-		defaultValues: { targetServerId: "", removeSourceData: false },
-		resolver: zodResolver(transferSchema),
-	});
-
-	api.transfer.start.useSubscription(
-		{
-			serviceType: type,
-			serviceId: id,
-			targetServerId: request?.targetServerId ?? null,
-			removeSourceData: request?.removeSourceData ?? false,
-		},
-		{
-			enabled: isTransferring && request !== null,
-			onData(line) {
-				setLogs((prev) => [...prev, ...parseLogs(line)]);
-				if (line.startsWith("Transfer completed")) {
-					setIsTransferring(false);
-					toast.success("Service transferred successfully");
-					utils.invalidate();
-				} else if (line.startsWith("Transfer failed")) {
-					setIsTransferring(false);
-					toast.error("Transfer failed, check the logs");
-					utils.invalidate();
-				}
-			},
-			onError(error) {
-				setIsTransferring(false);
-				toast.error(error.message);
-			},
-		},
-	);
-
-	const onSubmit = (values: TransferForm) => {
-		setRequest({
-			targetServerId:
-				values.targetServerId === LOCAL_SERVER ? null : values.targetServerId,
-			removeSourceData: values.removeSourceData,
-		});
-		setLogs([]);
-		setIsDrawerOpen(true);
-		setIsTransferring(true);
-		setIsOpen(false);
-	};
-
-	return (
-		<>
-			<Dialog open={isOpen} onOpenChange={setIsOpen}>
-				<DialogTrigger asChild>
-					<Button
-						variant="ghost"
-						size="icon"
-						className="group hover:bg-blue-500/10"
-						isLoading={isTransferring}
-					>
-						<ArrowRightLeft className="size-4 text-primary group-hover:text-blue-500" />
-					</Button>
-				</DialogTrigger>
-				<DialogContent className="sm:max-w-lg">
-					<DialogHeader>
-						<DialogTitle>Transfer to another server</DialogTitle>
-						<DialogDescription>
-							Moves this service with its volumes, bind mounts, file mounts and
-							configuration to the selected server, then deploys it there.
-						</DialogDescription>
-					</DialogHeader>
-					{targets.length === 0 ? (
-						<AlertBlock type="info">
-							There are no other servers available to transfer this service to.
-						</AlertBlock>
-					) : (
-						<Form {...form}>
-							<form
-								onSubmit={form.handleSubmit(onSubmit)}
-								id="hook-form-transfer-service"
-								className="grid w-full gap-4"
-							>
-								<FormField
-									control={form.control}
-									name="targetServerId"
-									render={({ field }) => (
-										<FormItem>
-											<FormLabel>Target server</FormLabel>
-											<Select
-												onValueChange={field.onChange}
-												defaultValue={field.value}
-											>
-												<FormControl>
-													<SelectTrigger>
-														<SelectValue placeholder="Select a server" />
-													</SelectTrigger>
-												</FormControl>
-												<SelectContent>
-													{targets.map((server) => (
-														<SelectItem
-															key={server.serverId}
-															value={server.serverId}
-														>
-															{server.name}
-														</SelectItem>
-													))}
-												</SelectContent>
-											</Select>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<FormField
-									control={form.control}
-									name="removeSourceData"
-									render={({ field }) => (
-										<FormItem>
-											<div className="flex items-center">
-												<FormControl>
-													<Checkbox
-														checked={field.value}
-														onCheckedChange={field.onChange}
-													/>
-												</FormControl>
-												<FormLabel className="ml-2">
-													Remove volumes from the source server after the
-													transfer
-												</FormLabel>
-											</div>
-											<FormMessage />
-										</FormItem>
-									)}
-								/>
-								<AlertBlock type="warning">
-									<ul className="list-disc pl-4 space-y-1">
-										<li>The service is stopped while its data is copied.</li>
-										<li>
-											Point your DNS records to the new server, certificates are
-											issued again there.
-										</li>
-										<li>
-											Networks that only exist on the current server are
-											detached.
-										</li>
-										<li>
-											Bind mount host paths are copied but never deleted from
-											the source server.
-										</li>
-									</ul>
-								</AlertBlock>
-							</form>
-						</Form>
-					)}
-					<DialogFooter>
-						<Button variant="secondary" onClick={() => setIsOpen(false)}>
-							Cancel
-						</Button>
-						{targets.length > 0 && (
-							<Button
-								isLoading={isTransferring}
-								form="hook-form-transfer-service"
-								type="submit"
-							>
-								Transfer
-							</Button>
-						)}
-					</DialogFooter>
-				</DialogContent>
-			</Dialog>
-			<DrawerLogs
-				isOpen={isDrawerOpen}
-				onClose={() => setIsDrawerOpen(false)}
-				filteredLogs={logs}
-			/>
-		</>
-	);
-};

apps/dokploy/components/icons/dns-provider-icons.tsx

@@ -91,32 +91,8 @@ export const PorkbunIcon = ({ className }: Props) => (
 	</svg>
 );
 
-export const InfomaniakIcon = ({ className }: Props) => (
-	<svg
-		viewBox="0 0 24 24"
-		fill="currentColor"
-		xmlns="http://www.w3.org/2000/svg"
-		className={className}
-	>
-		<path d="M2.4 0A2.395 2.395 0 0 0 0 2.4v19.2C0 22.9296 1.0704 24 2.4 24h19.2c1.3296 0 2.4-1.0704 2.4-2.4V2.4C24 1.0704 22.9296 0 21.6 0H10.112v11.7119l3.648-4.128h6l-4.58 4.3506 4.868 8.1296h-5.52l-2.5938-5.0211L10.112 16.8v3.264H5.12V0Z" />
-	</svg>
-);
-
-export const OvhIcon = ({ className }: Props) => (
-	<svg
-		viewBox="0 0 24 24"
-		fill="currentColor"
-		xmlns="http://www.w3.org/2000/svg"
-		className={className}
-	>
-		<path d="M19.881 10.095l2.563-4.45C23.434 7.389 24 9.404 24 11.555c0 2.88-1.017 5.523-2.71 7.594h-6.62l2.04-3.541h-2.696l3.176-5.513h2.691zm-2.32-5.243L9.333 19.14l.003.009H2.709C1.014 17.077 0 14.435 0 11.555c0-2.152.57-4.17 1.561-5.918L5.855 13.1 10.6 4.852h6.961z" />
-	</svg>
-);
-
 export const dnsProviderIcons = {
 	cloudflare: CloudflareIcon,
 	route53: Route53Icon,
 	porkbun: PorkbunIcon,
-	infomaniak: InfomaniakIcon,
-	ovh: OvhIcon,
 } as const;

apps/dokploy/components/icons/vault-provider-icons.tsx

@@ -608,7 +608,6 @@ export const vaultProviderIcons = {
 	hashicorp: HashicorpVaultIcon,
 	infisical: InfisicalIcon,
 	aws: AwsIcon,
-	"aws-parameter-store": AwsIcon,
 	doppler: DopplerIcon,
 	azure: AzureIcon,
 	scaleway: ScalewayIcon,

apps/dokploy/components/layouts/side.tsx

@@ -43,7 +43,6 @@ import Link from "next/link";
 import { usePathname } from "next/navigation";
 import { useEffect, useState } from "react";
 import { toast } from "sonner";
-import { TruncateTooltip } from "@/components/shared/truncate-tooltip";
 import { Badge } from "@/components/ui/badge";
 import {
 	Breadcrumb,
@@ -101,7 +100,6 @@ import { authClient } from "@/lib/auth-client";
 import { cn } from "@/lib/utils";
 import type { AppRouter } from "@/server/api/root";
 import { api } from "@/utils/api";
-import { TrialBanner } from "../dashboard/billing/trial-banner";
 import { AddOrganization } from "../dashboard/organization/handle-organization";
 import { DialogAction } from "../shared/dialog-action";
 import { Logo } from "../shared/logo";
@@ -658,12 +656,9 @@ function SidebarLogo() {
 											)}
 										>
 											<div className="flex items-center gap-1.5 min-w-0 w-full">
-												<TruncateTooltip
-													text={
-														activeOrganization?.name ?? "Select Organization"
-													}
-													className="text-sm font-medium"
-												/>
+												<p className="text-sm font-medium truncate">
+													{activeOrganization?.name ?? "Select Organization"}
+												</p>
 												{haveValidLicense && (
 													<Badge variant="blue" className="shrink-0">
 														Enterprise
@@ -1230,7 +1225,6 @@ export default function Page({ children }: Props) {
 				<SidebarRail />
 			</Sidebar>
 			<SidebarInset>
-				{isCloud === true && <TrialBanner />}
 				{!includesProjects && (
 					<header className="flex h-16 shrink-0 items-center gap-2 transition-[width,height] ease-linear group-has-data-[collapsible=icon]/sidebar-wrapper:h-12">
 						<div className="flex items-center justify-between w-full px-4">

apps/dokploy/components/proprietary/roles/manage-custom-roles.tsx

@@ -605,7 +605,7 @@ type CreateRoleSchema = z.infer<typeof createRoleSchema>;
 
 export const ManageCustomRoles = () => {
 	return (
-		<Card className="h-full bg-sidebar p-2.5 rounded-xl w-full">
+		<Card className="h-full bg-sidebar p-2.5 rounded-xl max-w-5xl mx-auto w-full">
 			<div className="rounded-xl bg-background shadow-md">
 				<CardHeader>
 					<CardTitle className="text-xl flex flex-row gap-2">

apps/dokploy/components/proprietary/sso/register-oidc-dialog.tsx

@@ -83,11 +83,6 @@ const azureMapping: ClaimMapping = {
 	image: "",
 };
 
-// id: "sub",
-// email: "preferred_username",
-// emailVerified: "email_verified",
-// name: "name",
-
 const genericMapping: ClaimMapping = {
 	id: "sub",
 	email: "email",
@@ -233,9 +228,10 @@ export function RegisterOidcDialog({
 			mapping: {
 				id: oidc?.mapping?.id ?? baseMapping.id,
 				email: oidc?.mapping?.email ?? baseMapping.email,
-				emailVerified: oidc?.mapping?.emailVerified ?? "",
+				emailVerified:
+					oidc?.mapping?.emailVerified ?? baseMapping.emailVerified,
 				name: oidc?.mapping?.name ?? baseMapping.name,
-				image: oidc?.mapping?.image ?? "",
+				image: oidc?.mapping?.image ?? baseMapping.image,
 			},
 		});
 	}, [data, open, form]);

apps/dokploy/components/proprietary/whitelabeling/whitelabeling-settings.tsx

@@ -47,8 +47,8 @@ const formSchema = z.object({
 	docsUrl: safeUrlField,
 	errorPageTitle: z.string(),
 	errorPageDescription: z.string(),
+	metaTitle: z.string(),
 	footerText: z.string(),
-	ogImageUrl: safeUrlField,
 });
 
 type FormSchema = z.infer<typeof formSchema>;
@@ -193,8 +193,8 @@ export function WhitelabelingSettings() {
 			docsUrl: "",
 			errorPageTitle: "",
 			errorPageDescription: "",
+			metaTitle: "",
 			footerText: "",
-			ogImageUrl: "",
 		},
 		resolver: zodResolver(formSchema),
 	});
@@ -212,8 +212,8 @@ export function WhitelabelingSettings() {
 				docsUrl: data.docsUrl ?? "",
 				errorPageTitle: data.errorPageTitle ?? "",
 				errorPageDescription: data.errorPageDescription ?? "",
+				metaTitle: data.metaTitle ?? "",
 				footerText: data.footerText ?? "",
-				ogImageUrl: data.ogImageUrl ?? "",
 			});
 		}
 	}, [data, form]);
@@ -242,8 +242,8 @@ export function WhitelabelingSettings() {
 				docsUrl: values.docsUrl || null,
 				errorPageTitle: values.errorPageTitle || null,
 				errorPageDescription: values.errorPageDescription || null,
+				metaTitle: values.metaTitle || null,
 				footerText: values.footerText || null,
-				ogImageUrl: values.ogImageUrl || null,
 			},
 		})
 			.then(async () => {
@@ -388,27 +388,6 @@ export function WhitelabelingSettings() {
 									</FormItem>
 								)}
 							/>
-
-							<FormField
-								control={form.control}
-								name="ogImageUrl"
-								render={({ field }) => (
-									<FormItem>
-										<FormLabel>OG Image URL</FormLabel>
-										<FormControl>
-											<Input
-												placeholder="https://example.com/og.png"
-												{...field}
-											/>
-										</FormControl>
-										<FormDescription>
-											Open Graph image used for link previews on social media
-											and messaging platforms. Recommended size: 1200x630px.
-										</FormDescription>
-										<FormMessage />
-									</FormItem>
-								)}
-							/>
 						</CardContent>
 					</Card>
 
@@ -462,15 +441,32 @@ export function WhitelabelingSettings() {
 						</CardContent>
 					</Card>
 
-					{/* Links Section */}
+					{/* Metadata & Links Section */}
 					<Card className="bg-transparent">
 						<CardHeader>
-							<CardTitle>Links</CardTitle>
+							<CardTitle>Metadata & Links</CardTitle>
 							<CardDescription>
-								Customize the footer text and sidebar links.
+								Customize the page title, footer text, and sidebar links.
 							</CardDescription>
 						</CardHeader>
 						<CardContent className="flex flex-col gap-4">
+							<FormField
+								control={form.control}
+								name="metaTitle"
+								render={({ field }) => (
+									<FormItem>
+										<FormLabel>Page Title</FormLabel>
+										<FormControl>
+											<Input placeholder="Dokploy" {...field} />
+										</FormControl>
+										<FormDescription>
+											Browser tab title. Defaults to "Dokploy" if empty.
+										</FormDescription>
+										<FormMessage />
+									</FormItem>
+								)}
+							/>
+
 							<FormField
 								control={form.control}
 								name="footerText"

apps/dokploy/components/shared/truncate-tooltip.tsx

@@ -1,78 +0,0 @@
-import { Tooltip as TooltipPrimitive } from "radix-ui";
-import type React from "react";
-import { useEffect, useRef, useState } from "react";
-import {
-	Tooltip,
-	TooltipProvider,
-	TooltipTrigger,
-} from "@/components/ui/tooltip";
-import { cn } from "@/lib/utils";
-
-interface Props extends React.HTMLAttributes<HTMLParagraphElement> {
-	text: string;
-}
-
-export const TruncateTooltip = ({ text, className, ...props }: Props) => {
-	const textRef = useRef<HTMLParagraphElement>(null);
-	const [isTruncated, setIsTruncated] = useState(false);
-	const [isOpen, setIsOpen] = useState(false);
-
-	useEffect(() => {
-		const element = textRef.current;
-		if (!element) return;
-
-		const checkTruncation = () => {
-			const truncated = element.scrollWidth > element.clientWidth;
-			setIsTruncated(truncated);
-			if (!truncated) {
-				setIsOpen(false);
-			}
-		};
-
-		checkTruncation();
-
-		const resizeObserver = new ResizeObserver(() => {
-			checkTruncation();
-		});
-
-		resizeObserver.observe(element);
-
-		return () => {
-			resizeObserver.disconnect();
-		};
-	}, [text]);
-
-	const content = (
-		<p ref={textRef} className={cn("truncate", className)} {...props}>
-			{text}
-		</p>
-	);
-
-	return (
-		<TooltipProvider>
-			<Tooltip
-				delayDuration={0}
-				open={isOpen}
-				onOpenChange={(open) => {
-					// Only allow opening if it's actually truncated
-					if (isTruncated) {
-						setIsOpen(open);
-					} else {
-						setIsOpen(false);
-					}
-				}}
-			>
-				<TooltipTrigger asChild>{content}</TooltipTrigger>
-				<TooltipPrimitive.Portal>
-					<TooltipPrimitive.Content
-						side="bottom"
-						align="start"
-						className="z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md max-w-[280px] break-words animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2"
-					>
-						<p>{text}</p>
-					</TooltipPrimitive.Content>
-				</TooltipPrimitive.Portal>
-			</Tooltip>
-		</TooltipProvider>
-	);
-};

apps/dokploy/drizzle/0191_cool_christian_walker.sql

@@ -1 +0,0 @@
-ALTER TYPE "public"."DnsProviderType" ADD VALUE 'infomaniak';

apps/dokploy/drizzle/0192_light_lake.sql

@@ -1 +0,0 @@
-ALTER TYPE "public"."DnsProviderType" ADD VALUE 'ovh';

apps/dokploy/drizzle/0193_chemical_the_liberteens.sql

@@ -1 +0,0 @@
-ALTER TYPE "public"."VaultProviderType" ADD VALUE 'aws-parameter-store' BEFORE 'doppler';

apps/dokploy/drizzle/0194_acoustic_prima.sql

@@ -1 +0,0 @@
-ALTER TABLE "sso_provider" ADD COLUMN "domain_verified" boolean DEFAULT true NOT NULL;

apps/dokploy/drizzle/0195_classy_whirlwind.sql

@@ -1 +0,0 @@
-ALTER TABLE "webServerSettings" ALTER COLUMN "whitelabelingConfig" SET DEFAULT '{"appName":null,"appDescription":null,"logoUrl":null,"faviconUrl":null,"customCss":null,"loginLogoUrl":null,"supportUrl":null,"docsUrl":null,"errorPageTitle":null,"errorPageDescription":null,"footerText":null,"ogImageUrl":null}'::jsonb;

apps/dokploy/drizzle/0196_worthless_ravenous.sql

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

apps/dokploy/drizzle/0197_demonic_the_initiative.sql

@@ -1,28 +0,0 @@
-CREATE TYPE "public"."sandboxNetworkMode" AS ENUM('isolated', 'internet');--> statement-breakpoint
-CREATE TYPE "public"."sandboxStatus" AS ENUM('creating', 'running', 'killed', 'error');--> statement-breakpoint
-CREATE TABLE "sandbox" (
-	"sandboxId" text PRIMARY KEY NOT NULL,
-	"name" text NOT NULL,
-	"environmentId" text NOT NULL,
-	"serverId" text,
-	"image" text NOT NULL,
-	"template" text,
-	"containerId" text,
-	"status" "sandboxStatus" DEFAULT 'creating' NOT NULL,
-	"cpu" real DEFAULT 1 NOT NULL,
-	"memoryMb" integer DEFAULT 512 NOT NULL,
-	"pidsLimit" integer DEFAULT 256 NOT NULL,
-	"timeoutMs" integer DEFAULT 300000 NOT NULL,
-	"expiresAt" timestamp with time zone,
-	"lastActivityAt" timestamp with time zone,
-	"networkMode" "sandboxNetworkMode" DEFAULT 'isolated' NOT NULL,
-	"envVars" text,
-	"workdir" text DEFAULT '/home/user' NOT NULL,
-	"user" text,
-	"runtime" text,
-	"createdAt" text NOT NULL,
-	"killedAt" timestamp with time zone
-);
---> statement-breakpoint
-ALTER TABLE "sandbox" ADD CONSTRAINT "sandbox_environmentId_environment_environmentId_fk" FOREIGN KEY ("environmentId") REFERENCES "public"."environment"("environmentId") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "sandbox" ADD CONSTRAINT "sandbox_serverId_server_serverId_fk" FOREIGN KEY ("serverId") REFERENCES "public"."server"("serverId") ON DELETE cascade ON UPDATE no action;

apps/dokploy/drizzle/meta/_journal.json

@@ -1338,55 +1338,6 @@
       "when": 1788300390648,
       "tag": "0190_nappy_anita_blake",
       "breakpoints": true
-    },
-    {
-      "idx": 191,
-      "version": "7",
-      "when": 1788332224024,
-      "tag": "0191_cool_christian_walker",
-      "breakpoints": true
-    },
-    {
-      "idx": 192,
-      "version": "7",
-      "when": 1788600069255,
-      "tag": "0192_light_lake",
-      "breakpoints": true
-    },
-    {
-      "idx": 193,
-      "version": "7",
-      "when": 1788802431830,
-      "tag": "0193_chemical_the_liberteens",
-      "breakpoints": true
-    },
-    {
-      "idx": 194,
-      "version": "7",
-      "when": 1788858506799,
-      "tag": "0194_acoustic_prima",
-      "breakpoints": true
-    },
-    {
-      "idx": 195,
-      "version": "7",
-      "when": 1788867370653,
-      "tag": "0195_classy_whirlwind",
-      "breakpoints": true
-    },
-    {
-      "idx": 196,
-      "version": "7",
-      "when": 1788995453103,
-      "tag": "0196_worthless_ravenous",
-      "breakpoints": true
-    },
-    {
-      "idx": 197,
-      "version": "7",
-      "when": 1789022852219,
-      "tag": "0197_demonic_the_initiative",
-      "breakpoints": true
     }
   ]
 }

apps/dokploy/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dokploy",
-	"version": "v0.30.6",
+	"version": "v0.30.5",
 	"private": true,
 	"license": "Apache-2.0",
 	"type": "module",
@@ -50,7 +50,6 @@
 		"@ai-sdk/openai-compatible": "^2.0.30",
 		"@aws-sdk/client-route-53": "^3.1108.0",
 		"@aws-sdk/client-secrets-manager": "^3.1108.0",
-		"@aws-sdk/client-ssm": "3.1108.0",
 		"@better-auth/api-key": "1.6.23",
 		"@better-auth/passkey": "1.6.23",
 		"@better-auth/scim": "1.6.23",
@@ -133,7 +132,7 @@
 		"resend": "^6.0.2",
 		"semver": "7.7.3",
 		"shadcn": "^4.11.0",
-		"shell-quote": "^1.8.4",
+		"shell-quote": "^1.8.1",
 		"slugify": "^1.6.6",
 		"sonner": "^1.7.4",
 		"ssh2": "~1.16.0",
@@ -180,7 +179,7 @@
 		"tsx": "^4.22.4",
 		"typescript": "^7.0.2",
 		"vite-tsconfig-paths": "4.3.2",
-		"vitest": "^4.1.0"
+		"vitest": "^4.0.18"
 	},
 	"ct3aMetadata": {
 		"initVersion": "7.25.2"

apps/dokploy/pages/_document.tsx

@@ -9,31 +9,17 @@ import NextDocument, {
 } from "next/document";
 
 interface WhitelabelingDocumentProps {
-	appName: string | null;
-	appDescription: string | null;
-	ogImageUrl: string | null;
+	metaTitle: string | null;
 	faviconHref: string | null;
 	customCss: string | null;
-	baseUrl: string;
 }
 
 export default function Document({
-	appName,
-	appDescription,
-	ogImageUrl,
+	metaTitle,
 	faviconHref,
 	customCss,
-	baseUrl,
 }: WhitelabelingDocumentProps) {
-	const title = appName || "Dokploy";
-	const description =
-		appDescription || "The Open Source alternative to Netlify, Vercel, Heroku.";
-
-	let ogImage = ogImageUrl || "/og.png";
-	if (ogImage.startsWith("/")) {
-		ogImage = `${baseUrl}${ogImage}`;
-	}
-
+	const title = metaTitle || "Dokploy";
 	return (
 		<Html lang="en" className="font-sans">
 			<Head>
@@ -41,9 +27,6 @@ export default function Document({
 				    paint (and for social scrapers), avoiding a flash of / fallback to
 				    the default Dokploy branding. */}
 				<title>{title}</title>
-				<meta property="og:title" content={title} />
-				<meta property="og:description" content={description} />
-				<meta property="og:image" content={ogImage} />
 				<link rel="icon" href={faviconHref || "/icon.svg"} />
 				{customCss && (
 					<style
@@ -65,9 +48,7 @@ const SETTINGS_CACHE_TTL = 60 * 1000; // 1 minute
 declare global {
 	var __SETTINGS_CACHE: {
 		data: {
-			appName: string | null;
-			appDescription: string | null;
-			ogImageUrl: string | null;
+			metaTitle: string | null;
 			faviconHref: string | null;
 			customCss: string | null;
 		};
@@ -80,16 +61,10 @@ Document.getInitialProps = async (
 ): Promise<DocumentInitialProps & WhitelabelingDocumentProps> => {
 	const initialProps = await NextDocument.getInitialProps(ctx);
 
-	let appName: string | null = null;
-	let appDescription: string | null = null;
-	let ogImageUrl: string | null = null;
+	let metaTitle: string | null = null;
 	let faviconHref: string | null = null;
 	let customCss: string | null = null;
 
-	const host = ctx.req?.headers?.host || "localhost:3000";
-	const protocol = ctx.req?.headers?.["x-forwarded-proto"] || "http";
-	const baseUrl = `${protocol}://${host}`;
-
 	if (
 		globalThis.__SETTINGS_CACHE &&
 		globalThis.__SETTINGS_CACHE.expiresAt > Date.now() &&
@@ -98,16 +73,13 @@ Document.getInitialProps = async (
 		return {
 			...initialProps,
 			...globalThis.__SETTINGS_CACHE.data,
-			baseUrl,
 		};
 	}
 
 	try {
 		const config = await getPublicWhitelabelingConfig();
 		if (config) {
-			appName = config.appName;
-			appDescription = config.appDescription;
-			ogImageUrl = config.ogImageUrl;
+			metaTitle = config.metaTitle;
 			// Remove any </style> tags to prevent XSS breakout
 			customCss = config.customCss
 				? config.customCss.replace(/<\/\s*style[^>]*>/gi, "")
@@ -120,9 +92,7 @@ Document.getInitialProps = async (
 
 	globalThis.__SETTINGS_CACHE = {
 		data: {
-			appName,
-			appDescription,
-			ogImageUrl,
+			metaTitle,
 			faviconHref,
 			customCss,
 		},
@@ -131,11 +101,8 @@ Document.getInitialProps = async (
 
 	return {
 		...initialProps,
-		appName,
-		appDescription,
-		ogImageUrl,
+		metaTitle,
 		faviconHref,
 		customCss,
-		baseUrl,
 	};
 };

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

@@ -3,7 +3,6 @@ import { validateRequest } from "@dokploy/server/lib/auth";
 import { createServerSideHelpers } from "@trpc/react-query/server";
 import {
 	Ban,
-	Box,
 	Check,
 	CheckCircle2,
 	ChevronsUpDown,
@@ -1063,14 +1062,6 @@ const EnvironmentPage = (
 									<ProjectEnvironment projectId={projectId}>
 										<Button variant="outline">Project Environment</Button>
 									</ProjectEnvironment>
-									<Link
-										href={`/dashboard/project/${projectId}/environment/${environmentId}/sandboxes`}
-									>
-										<Button variant="outline">
-											<Box className="size-4" />
-											Sandboxes
-										</Button>
-									</Link>
 									{permissions?.service.create && (
 										<DropdownMenu>
 											<DropdownMenuTrigger asChild>

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

@@ -1,230 +0,0 @@
-import { validateRequest } from "@dokploy/server/lib/auth";
-import { createServerSideHelpers } from "@trpc/react-query/server";
-import { ArrowLeft, Box, Skull, Trash2 } from "lucide-react";
-import type {
-	GetServerSidePropsContext,
-	InferGetServerSidePropsType,
-} from "next";
-import Head from "next/head";
-import Link from "next/link";
-import { useRouter } from "next/router";
-import type { ReactElement } from "react";
-import { toast } from "sonner";
-import superjson from "superjson";
-import { ExtendSandboxTimeout } from "@/components/dashboard/sandbox/extend-sandbox-timeout";
-import { SandboxConsole } from "@/components/dashboard/sandbox/sandbox-console";
-import { SandboxStatusBadge } from "@/components/dashboard/sandbox/sandbox-status-badge";
-import { formatExpiresIn } from "@/components/dashboard/sandbox/show-sandboxes";
-import { DashboardLayout } from "@/components/layouts/dashboard-layout";
-import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
-import { DateTooltip } from "@/components/shared/date-tooltip";
-import { DialogAction } from "@/components/shared/dialog-action";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { appRouter } from "@/server/api/root";
-import { api } from "@/utils/api";
-import { useWhitelabeling } from "@/utils/hooks/use-whitelabeling";
-
-const Field = ({ label, value }: { label: string; value: React.ReactNode }) => (
-	<div className="flex flex-col gap-1">
-		<span className="text-xs uppercase tracking-wide text-muted-foreground">
-			{label}
-		</span>
-		<span className="text-sm font-medium break-all">{value}</span>
-	</div>
-);
-
-const SandboxPage = (
-	props: InferGetServerSidePropsType<typeof getServerSideProps>,
-) => {
-	const { sandboxId } = props;
-	const router = useRouter();
-	const utils = api.useUtils();
-	const { projectId, environmentId } = router.query as {
-		projectId: string;
-		environmentId: string;
-	};
-	const { data, refetch } = api.sandbox.one.useQuery(
-		{ sandboxId },
-		{ refetchInterval: 10_000 },
-	);
-	const { data: permissions } = api.user.getPermissions.useQuery();
-	const { mutateAsync: kill, isPending: isKilling } =
-		api.sandbox.kill.useMutation();
-	const { mutateAsync: remove } = api.sandbox.remove.useMutation();
-	const { config: whitelabeling } = useWhitelabeling();
-	const appName = whitelabeling?.appName || "Dokploy";
-	const listHref = `/dashboard/project/${projectId}/environment/${environmentId}/sandboxes`;
-	const isRunning = data?.status === "running";
-
-	return (
-		<div className="pb-10">
-			<AdvanceBreadcrumb />
-			<Head>
-				<title>
-					Sandbox: {data?.name} - {data?.environment?.project?.name} | {appName}
-				</title>
-			</Head>
-			<Card className="bg-sidebar p-2.5 rounded-xl w-full">
-				<div className="rounded-xl bg-background shadow-md">
-					<CardHeader className="flex flex-row flex-wrap justify-between items-start gap-4">
-						<div className="flex flex-col gap-2">
-							<CardTitle className="text-xl flex items-center gap-2">
-								<Box className="size-6 text-muted-foreground" />
-								{data?.name}
-								{data && <SandboxStatusBadge status={data.status} />}
-							</CardTitle>
-							<span className="text-sm text-muted-foreground font-mono">
-								{data?.sandboxId}
-							</span>
-						</div>
-						<div className="flex flex-col items-end gap-2">
-							<Badge>{data?.server?.name || "Dokploy Server"}</Badge>
-							<div className="flex flex-wrap gap-2 justify-end">
-								<Link href={listHref}>
-									<Button variant="outline">
-										<ArrowLeft className="size-4" />
-										Sandboxes
-									</Button>
-								</Link>
-								{isRunning && permissions?.deployment.create && (
-									<ExtendSandboxTimeout
-										sandboxId={sandboxId}
-										currentTimeoutMs={data?.timeoutMs ?? 300_000}
-									/>
-								)}
-								{isRunning && permissions?.deployment.create && (
-									<DialogAction
-										title="Kill sandbox"
-										description="The container will be stopped and removed. Files inside it are lost."
-										onClick={async () => {
-											await kill({ sandboxId })
-												.then(async () => {
-													toast.success("Sandbox killed");
-													await refetch();
-												})
-												.catch(() => toast.error("Error killing the sandbox"));
-										}}
-									>
-										<Button variant="destructive" isLoading={isKilling}>
-											<Skull className="size-4" />
-											Kill
-										</Button>
-									</DialogAction>
-								)}
-								{permissions?.service.delete && (
-									<DialogAction
-										title="Delete sandbox"
-										description="Removes the sandbox record (and its container if still running)."
-										onClick={async () => {
-											await remove({ sandboxId })
-												.then(async () => {
-													toast.success("Sandbox deleted");
-													await utils.sandbox.list.invalidate({
-														environmentId,
-													});
-													router.push(listHref);
-												})
-												.catch(() => toast.error("Error deleting the sandbox"));
-										}}
-									>
-										<Button variant="ghost" size="icon">
-											<Trash2 className="size-4 text-destructive" />
-										</Button>
-									</DialogAction>
-								)}
-							</div>
-						</div>
-					</CardHeader>
-					<CardContent className="flex flex-col gap-6 py-8 border-t">
-						<Card className="bg-background">
-							<CardHeader>
-								<CardTitle className="text-xl">Details</CardTitle>
-							</CardHeader>
-							<CardContent className="grid grid-cols-2 md:grid-cols-4 gap-6">
-								<Field label="Image" value={data?.image} />
-								<Field label="Template" value={data?.template ?? "custom"} />
-								<Field label="CPU" value={`${data?.cpu} vCPU`} />
-								<Field label="Memory" value={`${data?.memoryMb} MB`} />
-								<Field label="PIDs limit" value={data?.pidsLimit} />
-								<Field label="Network" value={data?.networkMode} />
-								<Field label="Workdir" value={data?.workdir} />
-								<Field label="User" value={data?.user ?? "image default"} />
-								<Field
-									label="Timeout"
-									value={`${Math.round((data?.timeoutMs ?? 0) / 60_000)} min`}
-								/>
-								<Field
-									label="Expires"
-									value={
-										data ? formatExpiresIn(data.expiresAt, data.status) : "—"
-									}
-								/>
-								<Field
-									label="Created"
-									value={data ? <DateTooltip date={data.createdAt} /> : "—"}
-								/>
-								<Field
-									label="Container"
-									value={
-										<span className="font-mono text-xs">
-											{data?.containerId?.slice(0, 12) ?? "—"}
-										</span>
-									}
-								/>
-							</CardContent>
-						</Card>
-						{permissions?.deployment.create && (
-							<SandboxConsole
-								sandboxId={sandboxId}
-								enabled={isRunning}
-								workdir={data?.workdir ?? "/"}
-							/>
-						)}
-					</CardContent>
-				</div>
-			</Card>
-		</div>
-	);
-};
-
-export default SandboxPage;
-SandboxPage.getLayout = (page: ReactElement) => {
-	return <DashboardLayout>{page}</DashboardLayout>;
-};
-
-export async function getServerSideProps(
-	ctx: GetServerSidePropsContext<{ sandboxId: string }>,
-) {
-	const { params, req, res } = ctx;
-	const { user, session } = await validateRequest(req);
-	if (!user) {
-		return { redirect: { permanent: false, destination: "/" } };
-	}
-	const helpers = createServerSideHelpers({
-		router: appRouter,
-		ctx: {
-			req: req as any,
-			res: res as any,
-			db: null as any,
-			session: session as any,
-			user: user as any,
-		},
-		transformer: superjson,
-	});
-	if (typeof params?.sandboxId === "string") {
-		try {
-			await helpers.sandbox.one.fetch({ sandboxId: params.sandboxId });
-			return {
-				props: {
-					trpcState: helpers.dehydrate(),
-					sandboxId: params.sandboxId,
-				},
-			};
-		} catch {
-			return { redirect: { permanent: false, destination: "/" } };
-		}
-	}
-	return { redirect: { permanent: false, destination: "/" } };
-}

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

@@ -1,135 +0,0 @@
-import { validateRequest } from "@dokploy/server/lib/auth";
-import { createServerSideHelpers } from "@trpc/react-query/server";
-import { ArrowLeft, Box } from "lucide-react";
-import type {
-	GetServerSidePropsContext,
-	InferGetServerSidePropsType,
-} from "next";
-import Head from "next/head";
-import Link from "next/link";
-import type { ReactElement } from "react";
-import superjson from "superjson";
-import { AddSandbox } from "@/components/dashboard/sandbox/add-sandbox";
-import { ShowSandboxes } from "@/components/dashboard/sandbox/show-sandboxes";
-import { DashboardLayout } from "@/components/layouts/dashboard-layout";
-import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
-import { Button } from "@/components/ui/button";
-import {
-	Card,
-	CardContent,
-	CardDescription,
-	CardHeader,
-	CardTitle,
-} from "@/components/ui/card";
-import { appRouter } from "@/server/api/root";
-import { api } from "@/utils/api";
-import { useWhitelabeling } from "@/utils/hooks/use-whitelabeling";
-
-const SandboxesPage = (
-	props: InferGetServerSidePropsType<typeof getServerSideProps>,
-) => {
-	const { projectId, environmentId } = props;
-	const { data: environment } = api.environment.one.useQuery({ environmentId });
-	const { data: permissions } = api.user.getPermissions.useQuery();
-	const { config: whitelabeling } = useWhitelabeling();
-	const appName = whitelabeling?.appName || "Dokploy";
-
-	return (
-		<div className="pb-10">
-			<AdvanceBreadcrumb />
-			<Head>
-				<title>
-					Sandboxes: {environment?.name} | {environment?.project?.name} |{" "}
-					{appName}
-				</title>
-			</Head>
-			<Card className="bg-sidebar p-2.5 rounded-xl w-full">
-				<div className="rounded-xl bg-background shadow-md">
-					<CardHeader className="flex flex-row flex-wrap justify-between items-center gap-4">
-						<div className="flex flex-col gap-1">
-							<CardTitle className="text-xl flex items-center gap-2">
-								<Box className="size-6 text-muted-foreground" />
-								Sandboxes
-							</CardTitle>
-							<CardDescription>
-								Ephemeral containers for agents and automations in{" "}
-								{environment?.project?.name} / {environment?.name}.
-							</CardDescription>
-						</div>
-						<div className="flex gap-2">
-							<Link
-								href={`/dashboard/project/${projectId}/environment/${environmentId}`}
-							>
-								<Button variant="outline">
-									<ArrowLeft className="size-4" />
-									Services
-								</Button>
-							</Link>
-							{permissions?.service.create && (
-								<AddSandbox
-									projectId={projectId}
-									environmentId={environmentId}
-								/>
-							)}
-						</div>
-					</CardHeader>
-					<CardContent className="py-8 border-t">
-						<ShowSandboxes
-							projectId={projectId}
-							environmentId={environmentId}
-						/>
-					</CardContent>
-				</div>
-			</Card>
-		</div>
-	);
-};
-
-export default SandboxesPage;
-SandboxesPage.getLayout = (page: ReactElement) => {
-	return <DashboardLayout>{page}</DashboardLayout>;
-};
-
-export async function getServerSideProps(
-	ctx: GetServerSidePropsContext<{ projectId: string; environmentId: string }>,
-) {
-	const { params, req, res } = ctx;
-	const { user, session } = await validateRequest(req);
-	if (!user) {
-		return { redirect: { permanent: false, destination: "/" } };
-	}
-	const helpers = createServerSideHelpers({
-		router: appRouter,
-		ctx: {
-			req: req as any,
-			res: res as any,
-			db: null as any,
-			session: session as any,
-			user: user as any,
-		},
-		transformer: superjson,
-	});
-	if (
-		typeof params?.projectId === "string" &&
-		typeof params?.environmentId === "string"
-	) {
-		try {
-			await helpers.environment.one.fetch({
-				environmentId: params.environmentId,
-			});
-			await helpers.sandbox.list.prefetch({
-				environmentId: params.environmentId,
-			});
-			return {
-				props: {
-					trpcState: helpers.dehydrate(),
-					projectId: params.projectId,
-					environmentId: params.environmentId,
-				},
-			};
-		} catch {
-			return { redirect: { permanent: false, destination: "/" } };
-		}
-	}
-	return { redirect: { permanent: false, destination: "/" } };
-}

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

@@ -36,7 +36,6 @@ import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
 import { AssignNetworks } from "@/components/dashboard/networks/assign-networks";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
@@ -195,13 +194,6 @@ const Service = (
 									{permissions?.service.create && (
 										<UpdateApplication applicationId={applicationId} />
 									)}
-									{permissions?.service.create && (
-										<TransferService
-											id={applicationId}
-											type="application"
-											serverId={data?.serverId}
-										/>
-									)}
 									{permissions?.service.delete && (
 										<DeleteService id={applicationId} type="application" />
 									)}

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

@@ -23,7 +23,6 @@ import { ShowSchedules } from "@/components/dashboard/application/schedules/show
 import { ShowVolumeBackups } from "@/components/dashboard/application/volume-backups/show-volume-backups";
 import { AddCommandCompose } from "@/components/dashboard/compose/advanced/add-command";
 import { IsolatedDeploymentTab } from "@/components/dashboard/compose/advanced/add-isolation";
-import { FreshVolumes } from "@/components/dashboard/compose/advanced/fresh-volumes";
 import { ShowComposeContainers } from "@/components/dashboard/compose/containers/show-compose-containers";
 import { DeleteService } from "@/components/dashboard/compose/delete-service";
 import { ShowGeneralCompose } from "@/components/dashboard/compose/general/show";
@@ -34,7 +33,6 @@ import { ShowBackups } from "@/components/dashboard/database/backups/show-backup
 import { ComposeFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-compose-monitoring";
 import { ComposePaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-compose-monitoring";
 import { AssignComposeNetworks } from "@/components/dashboard/networks/assign-compose-networks";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
@@ -186,13 +184,6 @@ const Service = (
 											<UpdateCompose composeId={composeId} />
 										)}
 
-										{permissions?.service.create && (
-											<TransferService
-												id={composeId}
-												type="compose"
-												serverId={data?.serverId}
-											/>
-										)}
 										{permissions?.service.delete && (
 											<DeleteService id={composeId} type="compose" />
 										)}
@@ -443,7 +434,6 @@ const Service = (
 												<ShowImport composeId={composeId} />
 												<AssignComposeNetworks composeId={composeId} />
 												<IsolatedDeploymentTab composeId={composeId} />
-												<FreshVolumes composeId={composeId} />
 											</div>
 										</TabsContent>
 									)}

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

@@ -23,7 +23,6 @@ import { UpdateLibsql } from "@/components/dashboard/libsql/update-libsql";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { LibsqlIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -146,13 +145,6 @@ const Libsql = (
 								</div>
 								<div className="flex flex-row gap-2 justify-end">
 									<UpdateLibsql libsqlId={libsqlId} />
-									{(auth?.role === "owner" || auth?.canCreateServices) && (
-										<TransferService
-											id={libsqlId}
-											type="libsql"
-											serverId={data?.serverId}
-										/>
-									)}
 									{(auth?.role === "owner" || auth?.canDeleteServices) && (
 										<DeleteService id={libsqlId} type="libsql" />
 									)}

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

@@ -23,7 +23,6 @@ import { UpdateMariadb } from "@/components/dashboard/mariadb/update-mariadb";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { MariadbIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -160,13 +159,6 @@ const Mariadb = (
 									{permissions?.service.create && (
 										<UpdateMariadb mariadbId={mariadbId} />
 									)}
-									{permissions?.service.create && (
-										<TransferService
-											id={mariadbId}
-											type="mariadb"
-											serverId={data?.serverId}
-										/>
-									)}
 									{permissions?.service.delete && (
 										<DeleteService id={mariadbId} type="mariadb" />
 									)}

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

@@ -23,7 +23,6 @@ import { UpdateMongo } from "@/components/dashboard/mongo/update-mongo";
 import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
 import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { MongodbIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -160,13 +159,6 @@ const Mongo = (
 									{permissions?.service.create && (
 										<UpdateMongo mongoId={mongoId} />
 									)}
-									{permissions?.service.create && (
-										<TransferService
-											id={mongoId}
-											type="mongo"
-											serverId={data?.serverId}
-										/>
-									)}
 									{permissions?.service.delete && (
 										<DeleteService id={mongoId} type="mongo" />
 									)}

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

@@ -23,7 +23,6 @@ import { ShowGeneralMysql } from "@/components/dashboard/mysql/general/show-gene
 import { ShowInternalMysqlCredentials } from "@/components/dashboard/mysql/general/show-internal-mysql-credentials";
 import { UpdateMysql } from "@/components/dashboard/mysql/update-mysql";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { MysqlIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -160,13 +159,6 @@ const MySql = (
 										{permissions?.service.create && (
 											<UpdateMysql mysqlId={mysqlId} />
 										)}
-										{permissions?.service.create && (
-											<TransferService
-												id={mysqlId}
-												type="mysql"
-												serverId={data?.serverId}
-											/>
-										)}
 										{permissions?.service.delete && (
 											<DeleteService id={mysqlId} type="mysql" />
 										)}

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

@@ -23,7 +23,6 @@ import { ShowGeneralPostgres } from "@/components/dashboard/postgres/general/sho
 import { ShowInternalPostgresCredentials } from "@/components/dashboard/postgres/general/show-internal-postgres-credentials";
 import { UpdatePostgres } from "@/components/dashboard/postgres/update-postgres";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { PostgresqlIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -159,13 +158,6 @@ const Postgresql = (
 									{permissions?.service.create && (
 										<UpdatePostgres postgresId={postgresId} />
 									)}
-									{permissions?.service.create && (
-										<TransferService
-											id={postgresId}
-											type="postgres"
-											serverId={data?.serverId}
-										/>
-									)}
 									{permissions?.service.delete && (
 										<DeleteService id={postgresId} type="postgres" />
 									)}

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

@@ -22,7 +22,6 @@ import { ShowGeneralRedis } from "@/components/dashboard/redis/general/show-gene
 import { ShowInternalRedisCredentials } from "@/components/dashboard/redis/general/show-internal-redis-credentials";
 import { UpdateRedis } from "@/components/dashboard/redis/update-redis";
 import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
-import { TransferService } from "@/components/dashboard/shared/transfer-service";
 import { RedisIcon } from "@/components/icons/data-tools-icons";
 import { DashboardLayout } from "@/components/layouts/dashboard-layout";
 import { AdvanceBreadcrumb } from "@/components/shared/advance-breadcrumb";
@@ -159,13 +158,6 @@ const Redis = (
 									{permissions?.service.create && (
 										<UpdateRedis redisId={redisId} />
 									)}
-									{permissions?.service.create && (
-										<TransferService
-											id={redisId}
-											type="redis"
-											serverId={data?.serverId}
-										/>
-									)}
 									{permissions?.service.delete && (
 										<DeleteService id={redisId} type="redis" />
 									)}

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

@@ -21,7 +21,7 @@ const Page = () => {
 
 	return (
 		<div className="w-full">
-			<div className="h-full rounded-xl w-full flex flex-col gap-4">
+			<div className="h-full rounded-xl max-w-5xl mx-auto flex flex-col gap-4">
 				<Card className="h-full bg-sidebar p-2.5 rounded-xl mx-auto w-full">
 					<div className="rounded-xl bg-background shadow-md">
 						<CardHeader>

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

@@ -11,7 +11,7 @@ import { appRouter } from "@/server/api/root";
 const Page = () => {
 	return (
 		<div className="w-full">
-			<div className="h-full rounded-xl w-full flex flex-col gap-4">
+			<div className="h-full rounded-xl max-w-5xl mx-auto flex flex-col gap-4">
 				<Card className="h-full bg-sidebar p-2.5 rounded-xl mx-auto w-full">
 					<div className="rounded-xl bg-background shadow-md">
 						<div className="p-6">

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

@@ -16,7 +16,7 @@ const Page = () => {
 
 	return (
 		<div className="w-full">
-			<div className="h-full rounded-xl w-full flex flex-col gap-4">
+			<div className="h-full rounded-xl max-w-5xl mx-auto flex flex-col gap-4">
 				<ProfileForm />
 				{isCloud && <LinkingAccount />}
 				{permissions?.api.read && <ShowApiKeys />}

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

@@ -15,7 +15,7 @@ const Page = () => {
 	const { data: user } = api.user.get.useQuery();
 	return (
 		<div className="w-full">
-			<div className="h-full rounded-xl w-full flex flex-col gap-4">
+			<div className="h-full rounded-xl  max-w-5xl mx-auto flex flex-col gap-4">
 				<WebDomain />
 				<WebServer />
 				<div className="w-full flex flex-col gap-4">