Merge branch 'canary' into feat/quick-service-switcher

2026-06-15 20:25:23 +02:00 · 2026-02-26 22:28:34 -06:00
parent 355d46948b 98d09f187e
commit b1b1dbc1ce
382 changed files with 40007 additions and 5684 deletions
--- a/packages/server/package.json
+++ b/packages/server/package.json
@@ -19,45 +19,45 @@
    }
  },
  "scripts": {
-    "build": "npm run switch:prod && rm -rf ./dist && tsc --project tsconfig.server.json && tsc-alias -p tsconfig.server.json",
+    "build": "npm run switch:prod && rimraf dist && tsc --project tsconfig.server.json && tsc-alias -p tsconfig.server.json",
    "build:types": "tsc --emitDeclarationOnly --experimenta-dts",
    "switch:dev": "node scripts/switchToSrc.js",
    "switch:prod": "node scripts/switchToDist.js",
-    "dev": "rm -rf ./dist && pnpm esbuild && tsc --emitDeclarationOnly --outDir dist -p tsconfig.server.json",
+    "dev": "rimraf dist && pnpm esbuild && tsc --emitDeclarationOnly --outDir dist -p tsconfig.server.json",
    "esbuild": "tsx ./esbuild.config.ts && tsc --project tsconfig.server.json --emitDeclarationOnly ",
    "typecheck": "tsc --noEmit",
    "dbml:generate": "npx tsx src/db/schema/dbml.ts",
    "generate:drizzle": "pnpm dlx  @better-auth/cli generate --output auth-schema2.ts --config src/lib/auth.ts"
  },
  "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.5",
-    "@ai-sdk/azure": "^2.0.16",
-    "@ai-sdk/cohere": "^2.0.4",
-    "@ai-sdk/deepinfra": "^1.0.10",
-    "@ai-sdk/mistral": "^2.0.7",
-    "@ai-sdk/openai": "^2.0.16",
-    "@ai-sdk/openai-compatible": "^1.0.10",
-    "@better-auth/utils": "0.3.0",
+    "@ai-sdk/anthropic": "^3.0.44",
+    "@ai-sdk/azure": "^3.0.30",
+    "@ai-sdk/cohere": "^3.0.21",
+    "@ai-sdk/deepinfra": "^2.0.34",
+    "@ai-sdk/mistral": "^3.0.20",
+    "@ai-sdk/openai": "^3.0.29",
+    "@ai-sdk/openai-compatible": "^2.0.30",
+    "@better-auth/utils": "0.3.1",
    "@faker-js/faker": "^8.4.1",
    "@octokit/auth-app": "^6.1.3",
    "@octokit/rest": "^20.1.2",
    "@oslojs/crypto": "1.0.1",
    "@oslojs/encoding": "1.1.0",
    "@react-email/components": "^0.0.21",
-    "@better-auth/sso": "1.4.18",
-    "@trpc/server": "^10.45.2",
+    "@better-auth/sso": "1.5.0-beta.16",
+    "@trpc/server": "11.10.0",
    "adm-zip": "^0.5.16",
-    "ai": "^5.0.17",
-    "ai-sdk-ollama": "^0.5.1",
+    "ai": "^6.0.86",
+    "ai-sdk-ollama": "^3.7.0",
    "bcrypt": "5.1.1",
-    "better-auth": "1.4.18",
+    "better-auth": "1.5.0-beta.16",
    "bl": "6.0.11",
    "boxen": "^7.1.1",
    "date-fns": "3.6.0",
    "dockerode": "4.0.2",
    "dotenv": "16.4.5",
    "drizzle-dbml-generator": "0.10.0",
-    "drizzle-orm": "^0.41.0",
+    "drizzle-orm": "0.45.1",
    "drizzle-zod": "0.5.1",
    "yaml": "2.8.1",
    "lodash": "4.17.21",
@@ -81,18 +81,20 @@
    "ssh2": "1.15.0",
    "toml": "3.0.0",
    "ws": "8.16.0",
-    "zod": "^3.25.32",
-    "semver": "7.7.3"
+    "zod": "^4.3.6",
+    "semver": "7.7.3",
+    "better-call": "1.3.2"
  },
  "devDependencies": {
-    "@better-auth/cli": "1.4.18",
+    "rimraf": "6.1.3",
+    "@better-auth/cli": "1.5.0-beta.13",
    "@types/semver": "7.7.1",
    "@types/adm-zip": "^0.5.7",
    "@types/bcrypt": "5.0.2",
    "@types/dockerode": "3.3.23",
    "@types/lodash": "4.17.4",
    "@types/micromatch": "4.0.9",
-    "@types/node": "^20.16.0",
+    "@types/node": "^24.4.0",
    "@types/node-schedule": "2.1.6",
    "@types/nodemailer": "^6.4.17",
    "@types/qrcode": "^1.5.5",
@@ -110,9 +112,9 @@
    "tsx": "^4.16.2",
    "typescript": "^5.8.3"
  },
-  "packageManager": "pnpm@9.12.0",
+  "packageManager": "pnpm@10.22.0",
  "engines": {
-    "node": "^20.16.0",
-    "pnpm": ">=9.12.0"
+    "node": "^24.4.0",
+    "pnpm": ">=10.22.0"
  }
 }
--- a/packages/server/src/constants/index.ts
+++ b/packages/server/src/constants/index.ts
@@ -32,5 +32,6 @@ export const paths = (isServer = false) => {
 		SCHEDULES_PATH: `${BASE_PATH}/schedules`,
 		VOLUME_BACKUPS_PATH: `${BASE_PATH}/volume-backups`,
 		VOLUME_BACKUP_LOCK_PATH: `${BASE_PATH}/volume-backup-lock`,
+		PATCH_REPOS_PATH: `${BASE_PATH}/patch-repos`,
 	};
 };
--- a/packages/server/src/db/index.ts
+++ b/packages/server/src/db/index.ts
@@ -1,24 +1,40 @@
+import { and, eq } from "drizzle-orm";
 import { drizzle, type PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import { dbUrl } from "./constants";
 import * as schema from "./schema";

-declare global {
-	var db: PostgresJsDatabase<typeof schema> | undefined;
-}
+export { and, eq };
+export * from "./schema";
+
+type Database = PostgresJsDatabase<typeof schema>;
+
+/**
+ * Evita problemas de redeclaración global en monorepos.
+ * No usamos `declare global`.
+ */
+const globalForDb = globalThis as unknown as {
+	db?: Database;
+};
+
+let dbConnection: Database;

-export let db: PostgresJsDatabase<typeof schema>;
 if (process.env.NODE_ENV === "production") {
-	db = drizzle(postgres(dbUrl), {
+	// En producción no usamos global cache
+	dbConnection = drizzle(postgres(dbUrl), {
 		schema,
 	});
 } else {
-	if (!global.db)
-		global.db = drizzle(postgres(dbUrl), {
+	// En desarrollo reutilizamos conexión para evitar múltiples conexiones
+	if (!globalForDb.db) {
+		globalForDb.db = drizzle(postgres(dbUrl), {
 			schema,
 		});
+	}

-	db = global.db;
+	dbConnection = globalForDb.db;
 }

+export const db: Database = dbConnection;
+
 export { dbUrl };
--- a/packages/server/src/db/schema/application.ts
+++ b/packages/server/src/db/schema/application.ts
@@ -19,6 +19,7 @@ import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
+import { patch } from "./patch";
 import { ports } from "./port";
 import { previewDeployments } from "./preview-deployments";
 import { redirects } from "./redirects";
@@ -158,7 +159,7 @@ export const applications = pgTable("application", {
 		},
 	),
 	enableSubmodules: boolean("enableSubmodules").notNull().default(false),
-	dockerfile: text("dockerfile"),
+	dockerfile: text("dockerfile").default("Dockerfile"),
 	dockerContextPath: text("dockerContextPath"),
 	dockerBuildStage: text("dockerBuildStage"),
 	// Drop
@@ -286,6 +287,7 @@ export const applicationsRelations = relations(
 			references: [registry.registryId],
 			relationName: "applicationRollbackRegistry",
 		}),
+		patches: many(patch),
 	}),
 );

@@ -329,6 +331,7 @@ const createSchema = createInsertSchema(applications, {
 	sourceType: z
 		.enum(["github", "docker", "git", "gitlab", "bitbucket", "gitea", "drop"])
 		.optional(),
+	triggerType: z.enum(["push", "tag"]).optional(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	buildType: z.enum([
 		"dockerfile",
@@ -378,11 +381,9 @@ export const apiCreateApplication = createSchema.pick({
 	serverId: true,
 });

-export const apiFindOneApplication = createSchema
-	.pick({
-		applicationId: true,
-	})
-	.required();
+export const apiFindOneApplication = z.object({
+	applicationId: z.string().min(1),
+});

 export const apiDeployApplication = createSchema
 	.pick({
@@ -518,11 +519,9 @@ export const apiSaveEnvironmentVariables = createSchema
 	})
 	.required();

-export const apiFindMonitoringStats = createSchema
-	.pick({
-		appName: true,
-	})
-	.required();
+export const apiFindMonitoringStats = z.object({
+	appName: z.string().min(1),
+});

 export const apiUpdateApplication = createSchema
 	.partial()
--- a/packages/server/src/db/schema/backups.ts
+++ b/packages/server/src/db/schema/backups.ts
@@ -165,11 +165,9 @@ export const apiCreateBackup = createSchema.pick({
 	metadata: true,
 });

-export const apiFindOneBackup = createSchema
-	.pick({
-		backupId: true,
-	})
-	.required();
+export const apiFindOneBackup = z.object({
+	backupId: z.string().min(1),
+});

 export const apiRemoveBackup = createSchema
 	.pick({
--- a/packages/server/src/db/schema/compose.ts
+++ b/packages/server/src/db/schema/compose.ts
@@ -12,6 +12,7 @@ import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
+import { patch } from "./patch";
 import { schedules } from "./schedule";
 import { server } from "./server";
 import { applicationStatus, triggerType } from "./shared";
@@ -143,6 +144,7 @@ export const composeRelations = relations(compose, ({ one, many }) => ({
 	}),
 	backups: many(backups),
 	schedules: many(schedules),
+	patches: many(patch),
 }));

 const createSchema = createInsertSchema(compose, {
@@ -162,6 +164,11 @@ const createSchema = createInsertSchema(compose, {
 	composePath: z.string().min(1),
 	composeType: z.enum(["docker-compose", "stack"]).optional(),
 	watchPaths: z.array(z.string()).optional(),
+	sourceType: z
+		.enum(["git", "github", "gitlab", "bitbucket", "gitea", "raw"])
+		.optional(),
+	triggerType: z.enum(["push", "tag"]).optional(),
+	composeStatus: z.enum(["idle", "running", "done", "error"]).optional(),
 });

 export const apiCreateCompose = createSchema.pick({
--- a/packages/server/src/db/schema/deployment.ts
+++ b/packages/server/src/db/schema/deployment.ts
@@ -126,7 +126,6 @@ const schema = createInsertSchema(deployments, {
 	previewDeploymentId: z.string(),
 	buildServerId: z.string(),
 });
-
 export const apiCreateDeployment = schema
 	.pick({
 		title: true,
@@ -210,44 +209,27 @@ export const apiCreateDeploymentVolumeBackup = schema
 		volumeBackupId: z.string().min(1),
 	});

-export const apiFindAllByApplication = schema
-	.pick({
-		applicationId: true,
-	})
-	.extend({
-		applicationId: z.string().min(1),
-	})
-	.required();
+export const apiFindAllByApplication = z.object({
+	applicationId: z.string().min(1),
+});

-export const apiFindAllByCompose = schema
-	.pick({
-		composeId: true,
-	})
-	.extend({
-		composeId: z.string().min(1),
-	})
-	.required();
+export const apiFindAllByCompose = z.object({
+	composeId: z.string().min(1),
+});

-export const apiFindAllByServer = schema
-	.pick({
-		serverId: true,
-	})
-	.extend({
-		serverId: z.string().min(1),
-	})
-	.required();
+export const apiFindAllByServer = z.object({
+	serverId: z.string().min(1),
+});

-export const apiFindAllByType = z
-	.object({
-		id: z.string().min(1),
-		type: z.enum([
-			"application",
-			"compose",
-			"server",
-			"schedule",
-			"previewDeployment",
-			"backup",
-			"volumeBackup",
-		]),
-	})
-	.required();
+export const apiFindAllByType = z.object({
+	id: z.string().min(1),
+	type: z.enum([
+		"application",
+		"compose",
+		"server",
+		"schedule",
+		"previewDeployment",
+		"backup",
+		"volumeBackup",
+	]),
+});
--- a/packages/server/src/db/schema/destination.ts
+++ b/packages/server/src/db/schema/destination.ts
@@ -61,11 +61,9 @@ export const apiCreateDestination = createSchema
 		serverId: z.string().optional(),
 	});

-export const apiFindOneDestination = createSchema
-	.pick({
-		destinationId: true,
-	})
-	.required();
+export const apiFindOneDestination = z.object({
+	destinationId: z.string().min(1),
+});

 export const apiRemoveDestination = createSchema
 	.pick({
--- a/packages/server/src/db/schema/domain.ts
+++ b/packages/server/src/db/schema/domain.ts
@@ -70,7 +70,11 @@ export const domainsRelations = relations(domains, ({ one }) => ({
 	}),
 }));

-const createSchema = createInsertSchema(domains, domain._def.schema.shape);
+const createSchema = createInsertSchema(domains, {
+	...domain.shape,
+	// Override pgEnum so Zod 4 infers only string literals, not numeric enum index
+	domainType: z.enum(["compose", "application", "preview"]).optional(),
+});

 export const apiCreateDomain = createSchema.pick({
 	host: true,
@@ -88,11 +92,9 @@ export const apiCreateDomain = createSchema.pick({
 	stripPath: true,
 });

-export const apiFindDomain = createSchema
-	.pick({
-		domainId: true,
-	})
-	.required();
+export const apiFindDomain = z.object({
+	domainId: z.string().min(1),
+});

 export const apiFindDomainByApplication = createSchema.pick({
 	applicationId: true,
--- a/packages/server/src/db/schema/environment.ts
+++ b/packages/server/src/db/schema/environment.ts
@@ -1,6 +1,5 @@
 import { relations } from "drizzle-orm";
 import { boolean, pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { applications } from "./application";
@@ -46,46 +45,30 @@ export const environmentRelations = relations(
 	}),
 );

-const createSchema = createInsertSchema(environments, {
+export const apiCreateEnvironment = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	projectId: z.string().min(1),
+});
+
+export const apiFindOneEnvironment = z.object({
+	environmentId: z.string().min(1),
+});
+
+export const apiRemoveEnvironment = z.object({
+	environmentId: z.string().min(1),
+});
+
+export const apiUpdateEnvironment = z.object({
+	environmentId: z.string().min(1),
+	name: z.string().min(1).optional(),
+	description: z.string().optional(),
+	projectId: z.string().optional(),
+	env: z.string().optional(),
+});
+
+export const apiDuplicateEnvironment = z.object({
 	environmentId: z.string().min(1),
 	name: z.string().min(1),
 	description: z.string().optional(),
 });
-
-export const apiCreateEnvironment = createSchema.pick({
-	name: true,
-	description: true,
-	projectId: true,
-});
-
-export const apiFindOneEnvironment = createSchema
-	.pick({
-		environmentId: true,
-	})
-	.required();
-
-export const apiRemoveEnvironment = createSchema
-	.pick({
-		environmentId: true,
-	})
-	.required();
-
-export const apiUpdateEnvironment = createSchema
-	.partial()
-	.extend({
-		environmentId: z.string().min(1),
-	})
-	.omit({
-		isDefault: true,
-	});
-
-export const apiDuplicateEnvironment = createSchema
-	.pick({
-		environmentId: true,
-		name: true,
-		description: true,
-	})
-	.required({
-		environmentId: true,
-		name: true,
-	});
--- a/packages/server/src/db/schema/git-provider.ts
+++ b/packages/server/src/db/schema/git-provider.ts
@@ -1,6 +1,5 @@
 import { relations } from "drizzle-orm";
 import { pgEnum, pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
@@ -62,10 +61,6 @@ export const gitProviderRelations = relations(gitProvider, ({ one }) => ({
 	}),
 }));

-const createSchema = createInsertSchema(gitProvider);
-
-export const apiRemoveGitProvider = createSchema
-	.extend({
-		gitProviderId: z.string().min(1),
-	})
-	.pick({ gitProviderId: true });
+export const apiRemoveGitProvider = z.object({
+	gitProviderId: z.string().min(1),
+});
--- a/packages/server/src/db/schema/github.ts
+++ b/packages/server/src/db/schema/github.ts
@@ -1,6 +1,5 @@
 import { relations } from "drizzle-orm";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { gitProvider } from "./git-provider";
@@ -29,8 +28,7 @@ export const githubProviderRelations = relations(github, ({ one }) => ({
 	}),
 }));

-const createSchema = createInsertSchema(github);
-export const apiCreateGithub = createSchema.extend({
+export const apiCreateGithub = z.object({
 	githubAppName: z.string().optional(),
 	githubAppId: z.number().optional(),
 	githubClientId: z.string().optional(),
@@ -48,13 +46,11 @@ export const apiFindGithubBranches = z.object({
 	githubId: z.string().optional(),
 });

-export const apiFindOneGithub = createSchema
-	.extend({
-		githubId: z.string().min(1),
-	})
-	.pick({ githubId: true });
+export const apiFindOneGithub = z.object({
+	githubId: z.string().min(1),
+});

-export const apiUpdateGithub = createSchema.extend({
+export const apiUpdateGithub = z.object({
 	githubId: z.string().min(1),
 	name: z.string().min(1),
 	gitProviderId: z.string().min(1),
--- a/packages/server/src/db/schema/gitlab.ts
+++ b/packages/server/src/db/schema/gitlab.ts
@@ -1,6 +1,5 @@
 import { relations } from "drizzle-orm";
 import { integer, pgTable, text } from "drizzle-orm/pg-core";
-import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import { gitProvider } from "./git-provider";
@@ -31,9 +30,7 @@ export const gitlabProviderRelations = relations(gitlab, ({ one }) => ({
 	}),
 }));

-const createSchema = createInsertSchema(gitlab);
-
-export const apiCreateGitlab = createSchema.extend({
+export const apiCreateGitlab = z.object({
 	applicationId: z.string().optional(),
 	secret: z.string().optional(),
 	groupName: z.string().optional(),
@@ -45,17 +42,14 @@ export const apiCreateGitlab = createSchema.extend({
 	gitlabInternalUrl: z.string().optional().nullable(),
 });

-export const apiFindOneGitlab = createSchema
-	.extend({
-		gitlabId: z.string().min(1),
-	})
-	.pick({ gitlabId: true });
+export const apiFindOneGitlab = z.object({
+	gitlabId: z.string().min(1),
+});

-export const apiGitlabTestConnection = createSchema
-	.extend({
-		groupName: z.string().optional(),
-	})
-	.pick({ gitlabId: true, groupName: true });
+export const apiGitlabTestConnection = z.object({
+	gitlabId: z.string().min(1),
+	groupName: z.string().optional(),
+});

 export const apiFindGitlabBranches = z.object({
 	id: z.number().optional(),
@@ -64,7 +58,7 @@ export const apiFindGitlabBranches = z.object({
 	gitlabId: z.string().optional(),
 });

-export const apiUpdateGitlab = createSchema.extend({
+export const apiUpdateGitlab = z.object({
 	applicationId: z.string().optional(),
 	secret: z.string().optional(),
 	groupName: z.string().optional(),
@@ -72,5 +66,6 @@ export const apiUpdateGitlab = createSchema.extend({
 	name: z.string().min(1),
 	gitlabId: z.string().min(1),
 	gitlabUrl: z.string().min(1),
+	gitProviderId: z.string().min(1),
 	gitlabInternalUrl: z.string().optional().nullable(),
 });
--- a/packages/server/src/db/schema/index.ts
+++ b/packages/server/src/db/schema/index.ts
@@ -18,6 +18,7 @@ export * from "./mongo";
 export * from "./mount";
 export * from "./mysql";
 export * from "./notification";
+export * from "./patch";
 export * from "./port";
 export * from "./postgres";
 export * from "./preview-deployments";
--- a/packages/server/src/db/schema/mariadb.ts
+++ b/packages/server/src/db/schema/mariadb.ts
@@ -160,11 +160,9 @@ export const apiCreateMariaDB = createSchema.pick({
 	serverId: true,
 });

-export const apiFindOneMariaDB = createSchema
-	.pick({
-		mariadbId: true,
-	})
-	.required();
+export const apiFindOneMariaDB = z.object({
+	mariadbId: z.string().min(1),
+});

 export const apiChangeMariaDBStatus = createSchema
 	.pick({
--- a/packages/server/src/db/schema/mongo.ts
+++ b/packages/server/src/db/schema/mongo.ts
@@ -156,11 +156,9 @@ export const apiCreateMongo = createSchema.pick({
 	replicaSets: true,
 });

-export const apiFindOneMongo = createSchema
-	.pick({
-		mongoId: true,
-	})
-	.required();
+export const apiFindOneMongo = z.object({
+	mongoId: z.string().min(1),
+});

 export const apiChangeMongoStatus = createSchema
 	.pick({
--- a/packages/server/src/db/schema/mount.ts
+++ b/packages/server/src/db/schema/mount.ts
@@ -130,11 +130,9 @@ export const apiCreateMount = createSchema
 		serviceId: z.string().min(1),
 	});

-export const apiFindOneMount = createSchema
-	.pick({
-		mountId: true,
-	})
-	.required();
+export const apiFindOneMount = z.object({
+	mountId: z.string().min(1),
+});

 export const apiRemoveMount = createSchema
 	.pick({
@@ -148,12 +146,20 @@ export const apiRemoveMount = createSchema
 export const apiFindMountByApplicationId = createSchema
 	.extend({
 		serviceId: z.string().min(1),
+		serviceType: z.enum([
+			"application",
+			"postgres",
+			"mysql",
+			"mariadb",
+			"mongo",
+			"redis",
+			"compose",
+		]),
 	})
 	.pick({
 		serviceId: true,
 		serviceType: true,
-	})
-	.required();
+	});

 export const apiUpdateMount = createSchema.partial().extend({
 	mountId: z.string().min(1),
--- a/packages/server/src/db/schema/mysql.ts
+++ b/packages/server/src/db/schema/mysql.ts
@@ -157,11 +157,9 @@ export const apiCreateMySql = createSchema.pick({
 	serverId: true,
 });

-export const apiFindOneMySql = createSchema
-	.pick({
-		mysqlId: true,
-	})
-	.required();
+export const apiFindOneMySql = z.object({
+	mysqlId: z.string().min(1),
+});

 export const apiChangeMySqlStatus = createSchema
 	.pick({
--- a/packages/server/src/db/schema/notification.ts
+++ b/packages/server/src/db/schema/notification.ts
@@ -23,6 +23,7 @@ export const notificationType = pgEnum("notificationType", [
 	"pushover",
 	"custom",
 	"lark",
+	"teams",
 ]);

 export const notifications = pgTable("notification", {
@@ -72,6 +73,9 @@ export const notifications = pgTable("notification", {
 	pushoverId: text("pushoverId").references(() => pushover.pushoverId, {
 		onDelete: "cascade",
 	}),
+	teamsId: text("teamsId").references(() => teams.teamsId, {
+		onDelete: "cascade",
+	}),
 	organizationId: text("organizationId")
 		.notNull()
 		.references(() => organization.id, { onDelete: "cascade" }),
@@ -179,6 +183,14 @@ export const pushover = pgTable("pushover", {
 	expire: integer("expire"),
 });

+export const teams = pgTable("teams", {
+	teamsId: text("teamsId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	webhookUrl: text("webhookUrl").notNull(),
+});
+
 export const notificationsRelations = relations(notifications, ({ one }) => ({
 	slack: one(slack, {
 		fields: [notifications.slackId],
@@ -220,6 +232,10 @@ export const notificationsRelations = relations(notifications, ({ one }) => ({
 		fields: [notifications.pushoverId],
 		references: [pushover.pushoverId],
 	}),
+	teams: one(teams, {
+		fields: [notifications.teamsId],
+		references: [teams.teamsId],
+	}),
 	organization: one(organization, {
 		fields: [notifications.organizationId],
 		references: [organization.id],
@@ -448,11 +464,9 @@ export const apiTestNtfyConnection = apiCreateNtfy.pick({
 	priority: true,
 });

-export const apiFindOneNotification = notificationsSchema
-	.pick({
-		notificationId: true,
-	})
-	.required();
+export const apiFindOneNotification = z.object({
+	notificationId: z.string().min(1),
+});

 export const apiCreateCustom = notificationsSchema
 	.pick({
@@ -467,7 +481,7 @@ export const apiCreateCustom = notificationsSchema
 	})
 	.extend({
 		endpoint: z.string().min(1),
-		headers: z.record(z.string()).optional(),
+		headers: z.record(z.string(), z.string()).optional(),
 	});

 export const apiUpdateCustom = apiCreateCustom.partial().extend({
@@ -478,7 +492,7 @@ export const apiUpdateCustom = apiCreateCustom.partial().extend({

 export const apiTestCustomConnection = z.object({
 	endpoint: z.string().min(1),
-	headers: z.record(z.string()).optional(),
+	headers: z.record(z.string(), z.string()).optional(),
 });

 export const apiCreateLark = notificationsSchema
@@ -507,6 +521,32 @@ export const apiTestLarkConnection = apiCreateLark.pick({
 	webhookUrl: true,
 });

+export const apiCreateTeams = notificationsSchema
+	.pick({
+		appBuildError: true,
+		databaseBackup: true,
+		volumeBackup: true,
+		dokployRestart: true,
+		name: true,
+		appDeploy: true,
+		dockerCleanup: true,
+		serverThreshold: true,
+	})
+	.extend({
+		webhookUrl: z.string().min(1),
+	})
+	.required();
+
+export const apiUpdateTeams = apiCreateTeams.partial().extend({
+	notificationId: z.string().min(1),
+	teamsId: z.string().min(1),
+	organizationId: z.string().optional(),
+});
+
+export const apiTestTeamsConnection = apiCreateTeams.pick({
+	webhookUrl: true,
+});
+
 export const apiCreatePushover = notificationsSchema
 	.pick({
 		appBuildError: true,
--- a/packages/server/src/db/schema/patch.ts
+++ b/packages/server/src/db/schema/patch.ts
@@ -0,0 +1,100 @@
+import { relations } from "drizzle-orm";
+import { boolean, pgEnum, pgTable, text, unique } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { applications } from "./application";
+import { compose } from "./compose";
+
+export const patchType = pgEnum("patchType", ["create", "update", "delete"]);
+
+export const patch = pgTable(
+	"patch",
+	{
+		patchId: text("patchId")
+			.notNull()
+			.primaryKey()
+			.$defaultFn(() => nanoid()),
+		type: patchType("type").notNull().default("update"),
+		filePath: text("filePath").notNull(),
+		enabled: boolean("enabled").notNull().default(true),
+		content: text("content").notNull(),
+		createdAt: text("createdAt")
+			.notNull()
+			.$defaultFn(() => new Date().toISOString()),
+		updatedAt: text("updatedAt").$defaultFn(() => new Date().toISOString()),
+		// Relations - one of these must be set
+		applicationId: text("applicationId").references(
+			() => applications.applicationId,
+			{ onDelete: "cascade" },
+		),
+		composeId: text("composeId").references(() => compose.composeId, {
+			onDelete: "cascade",
+		}),
+	},
+	(table) => [
+		// Unique constraint: one patch per file per application/compose
+		unique("patch_filepath_application_unique").on(
+			table.filePath,
+			table.applicationId,
+		),
+		unique("patch_filepath_compose_unique").on(table.filePath, table.composeId),
+	],
+);
+
+export const patchRelations = relations(patch, ({ one }) => ({
+	application: one(applications, {
+		fields: [patch.applicationId],
+		references: [applications.applicationId],
+	}),
+	compose: one(compose, {
+		fields: [patch.composeId],
+		references: [compose.composeId],
+	}),
+}));
+
+const createSchema = createInsertSchema(patch, {
+	filePath: z.string().min(1),
+	content: z.string(),
+	type: z.enum(["create", "update", "delete"]).optional(),
+	enabled: z.boolean().optional(),
+	applicationId: z.string().optional(),
+	composeId: z.string().optional(),
+});
+
+export const apiCreatePatch = createSchema.pick({
+	filePath: true,
+	content: true,
+	type: true,
+	enabled: true,
+	applicationId: true,
+	composeId: true,
+});
+
+export const apiFindPatch = z.object({
+	patchId: z.string().min(1),
+});
+
+export const apiFindPatchesByApplicationId = z.object({
+	applicationId: z.string().min(1),
+});
+
+export const apiFindPatchesByComposeId = z.object({
+	composeId: z.string().min(1),
+});
+
+export const apiUpdatePatch = createSchema
+	.partial()
+	.extend({
+		patchId: z.string().min(1),
+	})
+	.omit({ applicationId: true, composeId: true });
+
+export const apiDeletePatch = z.object({
+	patchId: z.string().min(1),
+});
+
+export const apiTogglePatchEnabled = z.object({
+	patchId: z.string().min(1),
+	enabled: z.boolean(),
+});
--- a/packages/server/src/db/schema/port.ts
+++ b/packages/server/src/db/schema/port.ts
@@ -49,11 +49,9 @@ export const apiCreatePort = createSchema
 	})
 	.required();

-export const apiFindOnePort = createSchema
-	.pick({
-		portId: true,
-	})
-	.required();
+export const apiFindOnePort = z.object({
+	portId: z.string().min(1),
+});

 export const apiUpdatePort = createSchema
 	.pick({
--- a/packages/server/src/db/schema/postgres.ts
+++ b/packages/server/src/db/schema/postgres.ts
@@ -150,11 +150,9 @@ export const apiCreatePostgres = createSchema.pick({
 	serverId: true,
 });

-export const apiFindOnePostgres = createSchema
-	.pick({
-		postgresId: true,
-	})
-	.required();
+export const apiFindOnePostgres = z.object({
+	postgresId: z.string().min(1),
+});

 export const apiChangePostgresStatus = createSchema
 	.pick({
--- a/packages/server/src/db/schema/preview-deployments.ts
+++ b/packages/server/src/db/schema/preview-deployments.ts
@@ -58,17 +58,12 @@ export const createSchema = createInsertSchema(previewDeployments, {
 	applicationId: z.string(),
 });

-export const apiCreatePreviewDeployment = createSchema
-	.pick({
-		applicationId: true,
-		domainId: true,
-		branch: true,
-		pullRequestId: true,
-		pullRequestNumber: true,
-		pullRequestURL: true,
-		pullRequestTitle: true,
-	})
-	.extend({
-		applicationId: z.string().min(1),
-		// deploymentId: z.string().min(1),
-	});
+export const apiCreatePreviewDeployment = z.object({
+	applicationId: z.string().min(1),
+	domainId: z.string().optional(),
+	branch: z.string().min(1),
+	pullRequestId: z.string().min(1),
+	pullRequestNumber: z.string().min(1),
+	pullRequestURL: z.string().min(1),
+	pullRequestTitle: z.string().min(1),
+});
--- a/packages/server/src/db/schema/project.ts
+++ b/packages/server/src/db/schema/project.ts
@@ -43,12 +43,9 @@ export const apiCreateProject = createSchema.pick({
 	env: true,
 });

-export const apiFindOneProject = createSchema
-	.pick({
-		projectId: true,
-	})
-	.required();
-
+export const apiFindOneProject = z.object({
+	projectId: z.string().min(1),
+});
 export const apiRemoveProject = createSchema
 	.pick({
 		projectId: true,
--- a/packages/server/src/db/schema/redirects.ts
+++ b/packages/server/src/db/schema/redirects.ts
@@ -35,11 +35,9 @@ const createSchema = createInsertSchema(redirects, {
 	permanent: z.boolean().optional(),
 });

-export const apiFindOneRedirect = createSchema
-	.pick({
-		redirectId: true,
-	})
-	.required();
+export const apiFindOneRedirect = z.object({
+	redirectId: z.string().min(1),
+});

 export const apiCreateRedirect = createSchema
 	.pick({
--- a/packages/server/src/db/schema/redis.ts
+++ b/packages/server/src/db/schema/redis.ts
@@ -136,11 +136,9 @@ export const apiCreateRedis = createSchema.pick({
 	serverId: true,
 });

-export const apiFindOneRedis = createSchema
-	.pick({
-		redisId: true,
-	})
-	.required();
+export const apiFindOneRedis = z.object({
+	redisId: z.string().min(1),
+});

 export const apiChangeRedisStatus = createSchema
 	.pick({
--- a/packages/server/src/db/schema/registry.ts
+++ b/packages/server/src/db/schema/registry.ts
@@ -94,11 +94,9 @@ export const apiRemoveRegistry = createSchema
 	})
 	.required();

-export const apiFindOneRegistry = createSchema
-	.pick({
-		registryId: true,
-	})
-	.required();
+export const apiFindOneRegistry = z.object({
+	registryId: z.string().min(1),
+});

 export const apiUpdateRegistry = createSchema.partial().extend({
 	registryId: z.string().min(1),
--- a/packages/server/src/db/schema/security.ts
+++ b/packages/server/src/db/schema/security.ts
@@ -38,11 +38,9 @@ const createSchema = createInsertSchema(security, {
 	password: z.string().min(1),
 });

-export const apiFindOneSecurity = createSchema
-	.pick({
-		securityId: true,
-	})
-	.required();
+export const apiFindOneSecurity = z.object({
+	securityId: z.string().min(1),
+});

 export const apiCreateSecurity = createSchema
 	.pick({
--- a/packages/server/src/db/schema/server.ts
+++ b/packages/server/src/db/schema/server.ts
@@ -133,6 +133,7 @@ const createSchema = createInsertSchema(server, {
 	serverId: z.string().min(1),
 	name: z.string().min(1),
 	description: z.string().optional(),
+	serverType: z.enum(["deploy", "build"]).optional(),
 });

 export const apiCreateServer = createSchema
@@ -147,11 +148,9 @@ export const apiCreateServer = createSchema
 	})
 	.required();

-export const apiFindOneServer = createSchema
-	.pick({
-		serverId: true,
-	})
-	.required();
+export const apiFindOneServer = z.object({
+	serverId: z.string().min(1),
+});

 export const apiRemoveServer = createSchema
 	.pick({
--- a/packages/server/src/db/schema/session.ts
+++ b/packages/server/src/db/schema/session.ts
@@ -2,7 +2,7 @@ import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
 import { user } from "./user";

 // OLD TABLE
-export const session = pgTable("session_temp", {
+export const session = pgTable("session", {
 	id: text("id").primaryKey(),
 	expiresAt: timestamp("expires_at").notNull(),
 	token: text("token").notNull().unique(),
--- a/packages/server/src/db/schema/shared.ts
+++ b/packages/server/src/db/schema/shared.ts
@@ -175,12 +175,12 @@ export const NetworkSwarmSchema = z.array(
 		.object({
 			Target: z.string().optional(),
 			Aliases: z.array(z.string()).optional(),
-			DriverOpts: z.record(z.string()).optional(),
+			DriverOpts: z.record(z.string(), z.string()).optional(),
 		})
 		.strict(),
 );

-export const LabelsSwarmSchema = z.record(z.string());
+export const LabelsSwarmSchema = z.record(z.string(), z.string());

 export const EndpointPortConfigSwarmSchema = z
 	.object({
--- a/packages/server/src/db/schema/ssh-key.ts
+++ b/packages/server/src/db/schema/ssh-key.ts
@@ -2,6 +2,7 @@ import { relations } from "drizzle-orm";
 import { pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
+import { z } from "zod";
 import { sshKeyCreate, sshKeyType } from "../validations";
 import { organization } from "./account";
 import { applications } from "./application";
@@ -52,11 +53,9 @@ export const apiCreateSshKey = createSchema
 	})
 	.merge(sshKeyCreate.pick({ privateKey: true }));

-export const apiFindOneSshKey = createSchema
-	.pick({
-		sshKeyId: true,
-	})
-	.required();
+export const apiFindOneSshKey = z.object({
+	sshKeyId: z.string().min(1),
+});

 export const apiGenerateSSHKey = sshKeyType;

--- a/packages/server/src/index.ts
+++ b/packages/server/src/index.ts
@@ -27,10 +27,13 @@ export * from "./services/mongo";
 export * from "./services/mount";
 export * from "./services/mysql";
 export * from "./services/notification";
+export * from "./services/patch";
+export * from "./services/patch-repo";
 export * from "./services/port";
 export * from "./services/postgres";
 export * from "./services/preview-deployment";
 export * from "./services/project";
+export * from "./services/proprietary/license-key";
 export * from "./services/proprietary/sso";
 export * from "./services/redirect";
 export * from "./services/redis";
--- a/packages/server/src/lib/auth.ts
+++ b/packages/server/src/lib/auth.ts
@@ -9,7 +9,11 @@ import { and, desc, eq } from "drizzle-orm";
 import { BETTER_AUTH_SECRET, IS_CLOUD } from "../constants";
 import { db } from "../db";
 import * as schema from "../db/schema";
-import { getTrustedOrigins, getUserByToken } from "../services/admin";
+import {
+	getTrustedOrigins,
+	getTrustedProviders,
+	getUserByToken,
+} from "../services/admin";
 import {
 	getWebServerSettings,
 	updateWebServerSettings,
@@ -18,8 +22,6 @@ import { getHubSpotUTK, submitToHubSpot } from "../utils/tracking/hubspot";
 import { sendEmail } from "../verification/send-verification-email";
 import { getPublicIpWithFallback } from "../wss/utils";

-const trustedProviders = process.env?.TRUSTED_PROVIDERS?.split(",") || [];
-
 const { handler, api } = betterAuth({
 	database: drizzleAdapter(db, {
 		provider: "pg",
@@ -49,7 +51,10 @@ const { handler, api } = betterAuth({
 	account: {
 		accountLinking: {
 			enabled: true,
-			trustedProviders: ["github", "google", ...(trustedProviders || [])],
+			async trustedProviders() {
+				const fromDb = await getTrustedProviders();
+				return ["github", "google", ...fromDb];
+			},
 			allowDifferentEmails: true,
 		},
 	},
@@ -343,13 +348,16 @@ const { handler, api } = betterAuth({
 	],
 });

-export const auth = {
+const _auth = {
 	handler,
 	createApiKey: api.createApiKey,
 	registerSSOProvider: api.registerSSOProvider,
 	updateSSOProvider: api.updateSSOProvider,
 };

+export type AuthType = typeof _auth;
+export const auth: AuthType = _auth;
+
 export const validateRequest = async (request: IncomingMessage) => {
 	const apiKey = request.headers["x-api-key"] as string;
 	if (apiKey) {
@@ -361,7 +369,7 @@ export const validateRequest = async (request: IncomingMessage) => {
 			});

 			if (error) {
-				throw new Error(error.message || "Error verifying API key");
+				throw new Error(error.message?.toString() || "Error verifying API key");
 			}
 			if (!valid || !key) {
 				return {
@@ -460,11 +468,16 @@ export const validateRequest = async (request: IncomingMessage) => {
 		const member = await db.query.member.findFirst({
 			where: and(
 				eq(schema.member.userId, session.user.id),
-				eq(
-					schema.member.organizationId,
-					session.session.activeOrganizationId || "",
-				),
+				...(session.session.activeOrganizationId
+					? [
+							eq(
+								schema.member.organizationId,
+								session.session.activeOrganizationId || "",
+							),
+						]
+					: []),
 			),
+			orderBy: [desc(schema.member.isDefault), desc(schema.member.createdAt)],
 			with: {
 				organization: true,
 				user: true,
@@ -476,6 +489,7 @@ export const validateRequest = async (request: IncomingMessage) => {
 			member?.user.enableEnterpriseFeatures || false;
 		session.user.isValidEnterpriseLicense =
 			member?.user.isValidEnterpriseLicense || false;
+		session.session.activeOrganizationId = member?.organization.id || "";
 		if (member) {
 			session.user.ownerId = member.organization.ownerId;
 		} else {
--- a/packages/server/src/services/admin.ts
+++ b/packages/server/src/services/admin.ts
@@ -135,3 +135,12 @@ export const getTrustedOrigins = async () => {

 	return Array.from(new Set(trustedOrigins));
 };
+
+export const getTrustedProviders = async () => {
+	try {
+		const providers = await db.query.ssoProvider.findMany();
+		return providers.map((provider) => provider.providerId);
+	} catch (error) {
+		return [];
+	}
+};
--- a/packages/server/src/services/ai.ts
+++ b/packages/server/src/services/ai.ts
@@ -2,13 +2,31 @@ import { db } from "@dokploy/server/db";
 import { ai } from "@dokploy/server/db/schema";
 import { selectAIProvider } from "@dokploy/server/utils/ai/select-ai-provider";
 import { TRPCError } from "@trpc/server";
-import { generateObject } from "ai";
+import { generateText, Output } from "ai";
 import { desc, eq } from "drizzle-orm";
 import { z } from "zod";
 import { IS_CLOUD } from "../constants";
 import { findServerById } from "./server";
 import { getWebServerSettings } from "./web-server-settings";

+interface SuggestionItem {
+	id: string;
+	name: string;
+	shortDescription: string;
+	description: string;
+}
+
+interface SuggestionsOutput {
+	suggestions: SuggestionItem[];
+}
+
+interface DockerOutput {
+	dockerCompose: string;
+	envVariables: Array<{ name: string; value: string }>;
+	domains: Array<{ host: string; port: number; serviceName: string }>;
+	configFiles?: Array<{ content: string; filePath: string }>;
+}
+
 export const getAiSettingsByOrganizationId = async (organizationId: string) => {
 	const aiSettings = await db.query.ai.findMany({
 		where: eq(ai.organizationId, organizationId),
@@ -60,7 +78,7 @@ interface Props {
 }

 export const suggestVariants = async ({
-	organizationId,
+	organizationId: _organizationId,
 	aiId,
 	input,
 	serverId,
@@ -90,173 +108,177 @@ export const suggestVariants = async ({
 			ip = "127.0.0.1";
 		}

-		const { object } = await generateObject({
-			model,
-			output: "object",
-			schema: z.object({
-				suggestions: z.array(
-					z.object({
-						id: z.string(),
-						name: z.string(),
-						shortDescription: z.string(),
-						description: z.string(),
-					}),
-				),
-			}),
-			prompt: `
-        Act as advanced DevOps engineer and analyze the user's request to determine the appropriate suggestions (up to 3 items).
-
-        CRITICAL - Read the user's request carefully and follow the appropriate strategy:
-
-        Strategy A - If the user specifies a PARTICULAR APPLICATION/SERVICE (e.g., "deploy Chatwoot", "install sendingtk/chatwoot:develop", "setup Bitwarden"):
-        - Generate different deployment VARIANTS of that SAME application
-        - Each variant should be a different configuration (minimal, full stack, with different databases, development vs production, etc.)
-        - Example: For "Chatwoot" → "Chatwoot with PostgreSQL", "Chatwoot Development", "Chatwoot Full Stack"
-        - The name MUST include the specific application name the user mentioned
-
-        Strategy B - If the user describes a GENERAL NEED or USE CASE (e.g., "personal blog", "project management tool", "chat application"):
-        - Suggest different open source projects that fulfill that need
-        - Each suggestion should be a different tool/platform that solves the same problem
-        - Example: For "personal blog" → "WordPress", "Ghost", "Hugo with Nginx"
-        - The name should be the actual project name
-
-        Return your response as a JSON object with the following structure:
-        {
-          "suggestions": [
-            {
-              "id": "project-or-variant-slug",
-              "name": "Project Name or Variant Name",
-              "shortDescription": "Brief one-line description",
-              "description": "Detailed description"
-            }
-          ]
-        }
-
-        Important rules for the response:
-        1. Use slug format for the id field (lowercase, hyphenated)
-        2. Determine which strategy to use based on whether the user specified a particular application or described a general need
-        3. For Strategy A (specific app): The name must include the app name and describe the variant configuration
-        4. For Strategy B (general need): The name should be the actual project/tool name that fulfills the need
-        5. The description field should ONLY contain a plain text description of the project or variant, its features, and use cases
-        6. Do NOT include any code snippets, configuration examples, or installation instructions in the description
-        7. The shortDescription should be a single-line summary focusing on key technologies or differentiators
-        8. All suggestions should be installable in docker and have docker compose support
-        9. Provide variety in your suggestions - different complexity levels, tech stacks, or approaches
-
-        User wants to create a new project with the following details:
-
-        ${input}
-      `,
+		const suggestionsSchema = z.object({
+			suggestions: z.array(
+				z.object({
+					id: z.string(),
+					name: z.string(),
+					shortDescription: z.string(),
+					description: z.string(),
+				}),
+			),
 		});
+		const suggestionsResult = await generateText({
+			model,
+			// @ts-ignore - Zod + AI SDK Output.object() causes excessively deep instantiation
+			output: Output.object({ schema: suggestionsSchema }),
+			prompt: `
+		    Act as advanced DevOps engineer and analyze the user's request to determine the appropriate suggestions (up to 3 items).
+
+		    CRITICAL - Read the user's request carefully and follow the appropriate strategy:
+
+		    Strategy A - If the user specifies a PARTICULAR APPLICATION/SERVICE (e.g., "deploy Chatwoot", "install sendingtk/chatwoot:develop", "setup Bitwarden"):
+		    - Generate different deployment VARIANTS of that SAME application
+		    - Each variant should be a different configuration (minimal, full stack, with different databases, development vs production, etc.)
+		    - Example: For "Chatwoot" → "Chatwoot with PostgreSQL", "Chatwoot Development", "Chatwoot Full Stack"
+		    - The name MUST include the specific application name the user mentioned
+
+		    Strategy B - If the user describes a GENERAL NEED or USE CASE (e.g., "personal blog", "project management tool", "chat application"):
+		    - Suggest different open source projects that fulfill that need
+		    - Each suggestion should be a different tool/platform that solves the same problem
+		    - Example: For "personal blog" → "WordPress", "Ghost", "Hugo with Nginx"
+		    - The name should be the actual project name
+
+		    Return your response as a JSON object with the following structure:
+		    {
+		      "suggestions": [
+		        {
+		          "id": "project-or-variant-slug",
+		          "name": "Project Name or Variant Name",
+		          "shortDescription": "Brief one-line description",
+		          "description": "Detailed description"
+		        }
+		      ]
+		    }
+
+		    Important rules for the response:
+		    1. Use slug format for the id field (lowercase, hyphenated)
+		    2. Determine which strategy to use based on whether the user specified a particular application or described a general need
+		    3. For Strategy A (specific app): The name must include the app name and describe the variant configuration
+		    4. For Strategy B (general need): The name should be the actual project/tool name that fulfills the need
+		    5. The description field should ONLY contain a plain text description of the project or variant, its features, and use cases
+		    6. Do NOT include any code snippets, configuration examples, or installation instructions in the description
+		    7. The shortDescription should be a single-line summary focusing on key technologies or differentiators
+		    8. All suggestions should be installable in docker and have docker compose support
+		    9. Provide variety in your suggestions - different complexity levels, tech stacks, or approaches
+
+		    User wants to create a new project with the following details:
+
+		    ${input}
+		  `,
+		});
+		const object = suggestionsResult.output as SuggestionsOutput | undefined;

 		if (object?.suggestions?.length) {
+			const dockerSchema = z.object({
+				dockerCompose: z.string(),
+				envVariables: z.array(
+					z.object({
+						name: z.string(),
+						value: z.string(),
+					}),
+				),
+				domains: z.array(
+					z.object({
+						host: z.string(),
+						port: z.number(),
+						serviceName: z.string(),
+					}),
+				),
+				configFiles: z
+					.array(
+						z.object({
+							content: z.string(),
+							filePath: z.string(),
+						}),
+					)
+					.optional(),
+			});
 			const result = [];
 			for (const suggestion of object.suggestions) {
 				try {
-					const { object: docker } = await generateObject({
+					const dockerResult = await generateText({
 						model,
-						output: "object",
-						schema: z.object({
-							dockerCompose: z.string(),
-							envVariables: z.array(
-								z.object({
-									name: z.string(),
-									value: z.string(),
-								}),
-							),
-							domains: z.array(
-								z.object({
-									host: z.string(),
-									port: z.number(),
-									serviceName: z.string(),
-								}),
-							),
-							configFiles: z
-								.array(
-									z.object({
-										content: z.string(),
-										filePath: z.string(),
-									}),
-								)
-								.optional(),
-						}),
+						// @ts-ignore - Zod + AI SDK Output.object() causes excessively deep instantiation
+						output: Output.object({ schema: dockerSchema }),
 						prompt: `
-              Act as advanced DevOps engineer and generate docker compose with environment variables and domain configurations needed to install the following project.
+		          Act as advanced DevOps engineer and generate docker compose with environment variables and domain configurations needed to install the following project.

-              Return your response as a JSON object with this structure:
-              {
-                "dockerCompose": "yaml string here",
-                "envVariables": [{"name": "VAR_NAME", "value": "example_value"}],
-                "domains": [{"host": "domain.com", "port": 3000, "serviceName": "service"}],
-                "configFiles": [{"content": "file content", "filePath": "path/to/file"}]
-              }
+		          Return your response as a JSON object with this structure:
+		          {
+		            "dockerCompose": "yaml string here",
+		            "envVariables": [{"name": "VAR_NAME", "value": "example_value"}],
+		            "domains": [{"host": "domain.com", "port": 3000, "serviceName": "service"}],
+		            "configFiles": [{"content": "file content", "filePath": "path/to/file"}]
+		          }

-              Note: configFiles is optional - only include it if configuration files are absolutely required.
+		          Note: configFiles is optional - only include it if configuration files are absolutely required.

-              Follow these rules:
+		          Follow these rules:

-              Docker Compose Rules:
-              1. Use placeholder like \${VARIABLE_NAME-default} for generated variables in the docker-compose.yml
-              2. Use complex values for passwords/secrets variables
-              3. Don't set container_name field in services
-              4. Don't set version field in the docker compose
-              5. Don't set ports like 'ports: 3000:3000', use 'ports: "3000"' instead
-              6. If a service depends on a database or other service, INCLUDE that service in the docker-compose
-              7. Make sure all required services are defined in the docker-compose
+		          Docker Compose Rules:
+		          1. Use placeholder like \${VARIABLE_NAME-default} for generated variables in the docker-compose.yml
+		          2. Use complex values for passwords/secrets variables
+		          3. Don't set container_name field in services
+		          4. Don't set version field in the docker compose
+		          5. Don't set ports like 'ports: 3000:3000', use 'ports: "3000"' instead
+		          6. If a service depends on a database or other service, INCLUDE that service in the docker-compose
+		          7. Make sure all required services are defined in the docker-compose

-              Docker Image Rules (CRITICAL):
-              1. ALWAYS use 'image:' field, NEVER use 'build:' field
-              2. NEVER use 'build: .' or any build directive - we don't have local Dockerfiles
-              3. Use images from Docker Hub or other public registries (e.g., docker.io, ghcr.io, quay.io)
-              4. For dependencies (databases, redis, etc.), use official images (e.g., postgres:16, redis:7, etc.)
-              5. Always specify image tags - avoid using 'latest' tag, use specific versions when possible
-              6. Examples of correct image usage:
-                 - image: sendingtk/chatwoot:develop
-                 - image: postgres:16-alpine
-                 - image: redis:7-alpine
-                 - image: chatwoot/chatwoot:latest
-              7. Examples of INCORRECT usage (DO NOT USE):
-                 - build: .
-                 - build: ./app
-                 - build:
-                     context: .
-                     dockerfile: Dockerfile
+		          Docker Image Rules (CRITICAL):
+		          1. ALWAYS use 'image:' field, NEVER use 'build:' field
+		          2. NEVER use 'build: .' or any build directive - we don't have local Dockerfiles
+		          3. Use images from Docker Hub or other public registries (e.g., docker.io, ghcr.io, quay.io)
+		          4. For dependencies (databases, redis, etc.), use official images (e.g., postgres:16, redis:7, etc.)
+		          5. Always specify image tags - avoid using 'latest' tag, use specific versions when possible
+		          6. Examples of correct image usage:
+		             - image: sendingtk/chatwoot:develop
+		             - image: postgres:16-alpine
+		             - image: redis:7-alpine
+		             - image: chatwoot/chatwoot:latest
+		          7. Examples of INCORRECT usage (DO NOT USE):
+		             - build: .
+		             - build: ./app
+		             - build:
+		                 context: .
+		                 dockerfile: Dockerfile

-			  Volume Mounting and Configuration Rules:
-              1. DO NOT create configuration files unless the service CANNOT work without them
-              2. Most services can work with just environment variables - USE THEM FIRST
-              3. Ask yourself: "Can this be configured with an environment variable instead?"
-              4. If and ONLY IF a config file is absolutely required:
-                 - Keep it minimal with only critical settings
-                 - Use "../files/" prefix for all mounts
-                 - Format: "../files/folder:/container/path"
-              5. DO NOT add configuration files for:
-                 - Default configurations that work out of the box
-                 - Settings that can be handled by environment variables
-                 - Proxy or routing configurations (these are handled elsewhere)
+				  Volume Mounting and Configuration Rules:
+		          1. DO NOT create configuration files unless the service CANNOT work without them
+		          2. Most services can work with just environment variables - USE THEM FIRST
+		          3. Ask yourself: "Can this be configured with an environment variable instead?"
+		          4. If and ONLY IF a config file is absolutely required:
+		             - Keep it minimal with only critical settings
+		             - Use "../files/" prefix for all mounts
+		             - Format: "../files/folder:/container/path"
+		          5. DO NOT add configuration files for:
+		             - Default configurations that work out of the box
+		             - Settings that can be handled by environment variables
+		             - Proxy or routing configurations (these are handled elsewhere)

-			  Environment Variables Rules:
-              1. For the envVariables array, provide ACTUAL example values, not placeholders
-              2. Use realistic example values (e.g., "admin@example.com" for emails, "mypassword123" for passwords)
-			  3. DO NOT use \${VARIABLE_NAME-default} syntax in the envVariables values
-              4. ONLY include environment variables that are actually used in the docker-compose
-              5. Every environment variable referenced in the docker-compose MUST have a corresponding entry in envVariables
-              6. Do not include environment variables for services that don't exist in the docker-compose
+				  Environment Variables Rules:
+		          1. For the envVariables array, provide ACTUAL example values, not placeholders
+		          2. Use realistic example values (e.g., "admin@example.com" for emails, "mypassword123" for passwords)
+				  3. DO NOT use \${VARIABLE_NAME-default} syntax in the envVariables values
+		          4. ONLY include environment variables that are actually used in the docker-compose
+		          5. Every environment variable referenced in the docker-compose MUST have a corresponding entry in envVariables
+		          6. Do not include environment variables for services that don't exist in the docker-compose

-              For each service that needs to be exposed to the internet:
-              1. Define a domain configuration with:
-                - host: the domain name for the service in format: {service-name}-{random-3-chars-hex}-${ip ? ip.replaceAll(".", "-") : ""}.traefik.me
-                - port: the internal port the service runs on
-                - serviceName: the name of the service in the docker-compose
-              2. Make sure the service is properly configured to work with the specified port
+		          For each service that needs to be exposed to the internet:
+		          1. Define a domain configuration with:
+		            - host: the domain name for the service in format: {service-name}-{random-3-chars-hex}-${ip ? ip.replaceAll(".", "-") : ""}.traefik.me
+		            - port: the internal port the service runs on
+		            - serviceName: the name of the service in the docker-compose
+		          2. Make sure the service is properly configured to work with the specified port

-              User's original request: ${input}
+		          User's original request: ${input}

-              Project details:
-              ${suggestion?.description}
-            `,
+		          Project details:
+		          ${suggestion?.description}
+		        `,
 					});
-					if (!!docker && !!docker.dockerCompose) {
+					const docker = dockerResult.output as DockerOutput | undefined;
+					if (docker?.dockerCompose) {
 						result.push({
 							...suggestion,
 							...docker,
--- a/packages/server/src/services/application.ts
+++ b/packages/server/src/services/application.ts
@@ -29,6 +29,7 @@ import { cloneGitlabRepository } from "@dokploy/server/utils/providers/gitlab";
 import { createTraefikConfig } from "@dokploy/server/utils/traefik/application";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { encodeBase64 } from "../utils/docker/utils";
 import { getDokployUrl } from "./admin";
 import {
@@ -44,6 +45,7 @@ import {
 	issueCommentExists,
 	updateIssueComment,
 } from "./github";
+import { generateApplyPatchesCommand } from "./patch";
 import {
 	findPreviewDeploymentById,
 	updatePreviewDeployment,
@@ -52,7 +54,7 @@ import { validUniqueServerAppName } from "./project";
 export type Application = typeof applications.$inferSelect;

 export const createApplication = async (
-	input: typeof apiCreateApplication._type,
+	input: z.infer<typeof apiCreateApplication>,
 ) => {
 	const appName = buildAppName("app", input.appName);

@@ -202,6 +204,14 @@ export const deployApplication = async ({
 			command += await buildRemoteDocker(application);
 		}

+		if (application.sourceType !== "docker") {
+			command += await generateApplyPatchesCommand({
+				id: application.applicationId,
+				type: "application",
+				serverId,
+			});
+		}
+
 		command += await getBuildCommand(application);

 		const commandWithLog = `(${command}) >> ${deployment.logPath} 2>&1`;
--- a/packages/server/src/services/backup.ts
+++ b/packages/server/src/services/backup.ts
@@ -2,17 +2,16 @@ import { db } from "@dokploy/server/db";
 import { type apiCreateBackup, backups } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Backup = typeof backups.$inferSelect;

 export type BackupSchedule = Awaited<ReturnType<typeof findBackupById>>;
 export type BackupScheduleList = Awaited<ReturnType<typeof findBackupsByDbId>>;
-export const createBackup = async (input: typeof apiCreateBackup._type) => {
+export const createBackup = async (input: z.infer<typeof apiCreateBackup>) => {
 	const newBackup = await db
 		.insert(backups)
-		.values({
-			...input,
-		})
+		.values({ ...input } as typeof backups.$inferInsert)
 		.returning()
 		.then((value) => value[0]);

--- a/packages/server/src/services/bitbucket.ts
+++ b/packages/server/src/services/bitbucket.ts
@@ -7,11 +7,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Bitbucket = typeof bitbucket.$inferSelect;

 export const createBitbucket = async (
-	input: typeof apiCreateBitbucket._type,
+	input: z.infer<typeof apiCreateBitbucket>,
 	organizationId: string,
 	userId: string,
 ) => {
@@ -65,7 +66,7 @@ export const findBitbucketById = async (bitbucketId: string) => {

 export const updateBitbucket = async (
 	bitbucketId: string,
-	input: typeof apiUpdateBitbucket._type,
+	input: z.infer<typeof apiUpdateBitbucket>,
 ) => {
 	return await db.transaction(async (tx) => {
 		// First get the current bitbucket provider to get gitProviderId
--- a/packages/server/src/services/compose.ts
+++ b/packages/server/src/services/compose.ts
@@ -33,6 +33,7 @@ import { cloneGitlabRepository } from "@dokploy/server/utils/providers/gitlab";
 import { getCreateComposeFileCommand } from "@dokploy/server/utils/providers/raw";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { encodeBase64 } from "../utils/docker/utils";
 import { getDokployUrl } from "./admin";
 import {
@@ -40,11 +41,14 @@ import {
 	updateDeployment,
 	updateDeploymentStatus,
 } from "./deployment";
+import { generateApplyPatchesCommand } from "./patch";
 import { validUniqueServerAppName } from "./project";

 export type Compose = typeof compose.$inferSelect;

-export const createCompose = async (input: typeof apiCreateCompose._type) => {
+export const createCompose = async (
+	input: z.infer<typeof apiCreateCompose>,
+) => {
 	const appName = buildAppName("compose", input.appName);

 	const valid = await validUniqueServerAppName(appName);
@@ -247,8 +251,15 @@ export const deployCompose = async ({
 		} else {
 			await execAsync(commandWithLog);
 		}
-
 		command = "set -e;";
+		if (compose.sourceType !== "raw") {
+			command += await generateApplyPatchesCommand({
+				id: compose.composeId,
+				type: "compose",
+				serverId: compose.serverId,
+			});
+		}
+
 		command += await getBuildComposeCommand(entity);
 		commandWithLog = `(${command}) >> ${deployment.logPath} 2>&1`;
 		if (compose.serverId) {
--- a/packages/server/src/services/deployment.ts
+++ b/packages/server/src/services/deployment.ts
@@ -13,10 +13,14 @@ import {
 	deployments,
 } from "@dokploy/server/db/schema";
 import { removeDirectoryIfExistsContent } from "@dokploy/server/utils/filesystem/directory";
-import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
+import {
+	execAsync,
+	execAsyncRemote,
+} from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { format } from "date-fns";
 import { desc, eq } from "drizzle-orm";
+import type { z } from "zod";
 import {
 	type Application,
 	findApplicationById,
@@ -69,7 +73,7 @@ export const findDeploymentByApplicationId = async (applicationId: string) => {

 export const createDeployment = async (
 	deployment: Omit<
-		typeof apiCreateDeployment._type,
+		z.infer<typeof apiCreateDeployment>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -150,7 +154,7 @@ export const createDeployment = async (

 export const createDeploymentPreview = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentPreview._type,
+		z.infer<typeof apiCreateDeploymentPreview>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -233,7 +237,7 @@ export const createDeploymentPreview = async (

 export const createDeploymentCompose = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentCompose._type,
+		z.infer<typeof apiCreateDeploymentCompose>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -310,7 +314,7 @@ echo "Initializing deployment\n" >> ${logFilePath};

 export const createDeploymentBackup = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentBackup._type,
+		z.infer<typeof apiCreateDeploymentBackup>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -390,7 +394,7 @@ echo "Initializing backup\n" >> ${logFilePath};

 export const createDeploymentSchedule = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentSchedule._type,
+		z.infer<typeof apiCreateDeploymentSchedule>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -466,7 +470,7 @@ export const createDeploymentSchedule = async (

 export const createDeploymentVolumeBackup = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentVolumeBackup._type,
+		z.infer<typeof apiCreateDeploymentVolumeBackup>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -554,8 +558,25 @@ export const removeDeployment = async (deploymentId: string) => {
 		const deployment = await db
 			.delete(deployments)
 			.where(eq(deployments.deploymentId, deploymentId))
-			.returning();
-		return deployment[0];
+			.returning()
+			.then((result) => result[0]);
+
+		if (!deployment) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Deployment not found",
+			});
+		}
+		const command = `
+			rm -f ${deployment.logPath};
+		`;
+		if (deployment.serverId) {
+			await execAsyncRemote(deployment.serverId, command);
+		} else {
+			await execAsync(command);
+		}
+
+		return deployment;
 	} catch (error) {
 		const message =
 			error instanceof Error ? error.message : "Error creating the deployment";
@@ -753,7 +774,7 @@ export const updateDeploymentStatus = async (

 export const createServerDeployment = async (
 	deployment: Omit<
-		typeof apiCreateDeploymentServer._type,
+		z.infer<typeof apiCreateDeploymentServer>,
 		"deploymentId" | "createdAt" | "status" | "logPath"
 	>,
 ) => {
@@ -831,3 +852,19 @@ export const findAllDeploymentsByServerId = async (serverId: string) => {
 	});
 	return deploymentsList;
 };
+
+export const clearOldDeployments = async (
+	appName: string,
+	serverId: string | null,
+) => {
+	const { LOGS_PATH } = paths(!!serverId);
+	const folder = path.join(LOGS_PATH, appName);
+	const command = `
+		rm -rf ${folder};
+	`;
+	if (serverId) {
+		await execAsyncRemote(serverId, command);
+	} else {
+		await execAsync(command);
+	}
+};
--- a/packages/server/src/services/destination.ts
+++ b/packages/server/src/services/destination.ts
@@ -5,11 +5,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { and, eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Destination = typeof destinations.$inferSelect;

 export const createDestintation = async (
-	input: typeof apiCreateDestination._type,
+	input: z.infer<typeof apiCreateDestination>,
 	organizationId: string,
 ) => {
 	const newDestination = await db
--- a/packages/server/src/services/domain.ts
+++ b/packages/server/src/services/domain.ts
@@ -6,6 +6,7 @@ import { generateRandomDomain } from "@dokploy/server/templates";
 import { manageDomain } from "@dokploy/server/utils/traefik/domain";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { type apiCreateDomain, domains } from "../db/schema";
 import { findApplicationById } from "./application";
 import { detectCDNProvider } from "./cdn";
@@ -13,14 +14,14 @@ import { findServerById } from "./server";

 export type Domain = typeof domains.$inferSelect;

-export const createDomain = async (input: typeof apiCreateDomain._type) => {
+export const createDomain = async (input: z.infer<typeof apiCreateDomain>) => {
 	const result = await db.transaction(async (tx) => {
 		const domain = await tx
 			.insert(domains)
 			.values({
 				...input,
 				host: input.host?.trim(),
-			})
+			} as typeof domains.$inferInsert)
 			.returning()
 			.then((response) => response[0]);

--- a/packages/server/src/services/environment.ts
+++ b/packages/server/src/services/environment.ts
@@ -6,11 +6,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { asc, eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Environment = typeof environments.$inferSelect;

 export const createEnvironment = async (
-	input: typeof apiCreateEnvironment._type,
+	input: z.infer<typeof apiCreateEnvironment>,
 ) => {
 	const newEnvironment = await db
 		.insert(environments)
@@ -101,6 +102,20 @@ export const findEnvironmentsByProjectId = async (projectId: string) => {
 	return projectEnvironments;
 };

+const environmentHasServices = (
+	env: Awaited<ReturnType<typeof findEnvironmentById>>,
+) => {
+	return (
+		(env.applications?.length ?? 0) > 0 ||
+		(env.compose?.length ?? 0) > 0 ||
+		(env.mariadb?.length ?? 0) > 0 ||
+		(env.mongo?.length ?? 0) > 0 ||
+		(env.mysql?.length ?? 0) > 0 ||
+		(env.postgres?.length ?? 0) > 0 ||
+		(env.redis?.length ?? 0) > 0
+	);
+};
+
 export const deleteEnvironment = async (environmentId: string) => {
 	const currentEnvironment = await findEnvironmentById(environmentId);
 	if (currentEnvironment.isDefault) {
@@ -109,6 +124,13 @@ export const deleteEnvironment = async (environmentId: string) => {
 			message: "You cannot delete the default environment",
 		});
 	}
+	if (environmentHasServices(currentEnvironment)) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message:
+				"Cannot delete environment: it has active services. Delete all services first.",
+		});
+	}
 	const deletedEnvironment = await db
 		.delete(environments)
 		.where(eq(environments.environmentId, environmentId))
@@ -135,7 +157,7 @@ export const updateEnvironmentById = async (
 };

 export const duplicateEnvironment = async (
-	input: typeof apiDuplicateEnvironment._type,
+	input: z.infer<typeof apiDuplicateEnvironment>,
 ) => {
 	// Find the original environment
 	const originalEnvironment = await findEnvironmentById(input.environmentId);
--- a/packages/server/src/services/gitea.ts
+++ b/packages/server/src/services/gitea.ts
@@ -6,11 +6,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Gitea = typeof gitea.$inferSelect;

 export const createGitea = async (
-	input: typeof apiCreateGitea._type,
+	input: z.infer<typeof apiCreateGitea>,
 	organizationId: string,
 	userId: string,
 ) => {
--- a/packages/server/src/services/github.ts
+++ b/packages/server/src/services/github.ts
@@ -6,12 +6,13 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { authGithub } from "../utils/providers/github";
 import { updatePreviewDeployment } from "./preview-deployment";

 export type Github = typeof github.$inferSelect;
 export const createGithub = async (
-	input: typeof apiCreateGithub._type,
+	input: z.infer<typeof apiCreateGithub>,
 	organizationId: string,
 	userId: string,
 ) => {
--- a/packages/server/src/services/gitlab.ts
+++ b/packages/server/src/services/gitlab.ts
@@ -6,11 +6,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Gitlab = typeof gitlab.$inferSelect;

 export const createGitlab = async (
-	input: typeof apiCreateGitlab._type,
+	input: z.infer<typeof apiCreateGitlab>,
 	organizationId: string,
 	userId: string,
 ) => {
--- a/packages/server/src/services/mariadb.ts
+++ b/packages/server/src/services/mariadb.ts
@@ -11,11 +11,14 @@ import { pullImage } from "@dokploy/server/utils/docker/utils";
 import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
+import type { z } from "zod";
 import { validUniqueServerAppName } from "./project";

 export type Mariadb = typeof mariadb.$inferSelect;

-export const createMariadb = async (input: typeof apiCreateMariaDB._type) => {
+export const createMariadb = async (
+	input: z.infer<typeof apiCreateMariaDB>,
+) => {
 	const appName = buildAppName("mariadb", input.appName);

 	const valid = await validUniqueServerAppName(appName);
--- a/packages/server/src/services/mongo.ts
+++ b/packages/server/src/services/mongo.ts
@@ -12,11 +12,12 @@ import { pullImage } from "@dokploy/server/utils/docker/utils";
 import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
+import type { z } from "zod";
 import { validUniqueServerAppName } from "./project";

 export type Mongo = typeof mongo.$inferSelect;

-export const createMongo = async (input: typeof apiCreateMongo._type) => {
+export const createMongo = async (input: z.infer<typeof apiCreateMongo>) => {
 	const appName = buildAppName("mongo", input.appName);

 	const valid = await validUniqueServerAppName(appName);
--- a/packages/server/src/services/mount.ts
+++ b/packages/server/src/services/mount.ts
@@ -18,10 +18,11 @@ import {
 } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq, type SQL, sql } from "drizzle-orm";
+import type { z } from "zod";

 export type Mount = typeof mounts.$inferSelect;

-export const createMount = async (input: typeof apiCreateMount._type) => {
+export const createMount = async (input: z.infer<typeof apiCreateMount>) => {
 	try {
 		const { serviceId, ...rest } = input;
 		const value = await db
@@ -262,6 +263,9 @@ export const findMountsByApplicationId = async (
 		case "redis":
 			sqlChunks.push(eq(mounts.redisId, serviceId));
 			break;
+		case "compose":
+			sqlChunks.push(eq(mounts.composeId, serviceId));
+			break;
 		default:
 			throw new Error(`Unknown service type: ${serviceType}`);
 	}
--- a/packages/server/src/services/mysql.ts
+++ b/packages/server/src/services/mysql.ts
@@ -11,11 +11,12 @@ import { pullImage } from "@dokploy/server/utils/docker/utils";
 import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
+import type { z } from "zod";
 import { validUniqueServerAppName } from "./project";

 export type MySql = typeof mysql.$inferSelect;

-export const createMysql = async (input: typeof apiCreateMySql._type) => {
+export const createMysql = async (input: z.infer<typeof apiCreateMySql>) => {
 	const appName = buildAppName("mysql", input.appName);

 	const valid = await validUniqueServerAppName(appName);
--- a/packages/server/src/services/notification.ts
+++ b/packages/server/src/services/notification.ts
@@ -9,6 +9,7 @@ import {
 	type apiCreatePushover,
 	type apiCreateResend,
 	type apiCreateSlack,
+	type apiCreateTeams,
 	type apiCreateTelegram,
 	type apiUpdateCustom,
 	type apiUpdateDiscord,
@@ -19,6 +20,7 @@ import {
 	type apiUpdatePushover,
 	type apiUpdateResend,
 	type apiUpdateSlack,
+	type apiUpdateTeams,
 	type apiUpdateTelegram,
 	custom,
 	discord,
@@ -30,15 +32,17 @@ import {
 	pushover,
 	resend,
 	slack,
+	teams,
 	telegram,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Notification = typeof notifications.$inferSelect;

 export const createSlackNotification = async (
-	input: typeof apiCreateSlack._type,
+	input: z.infer<typeof apiCreateSlack>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -88,7 +92,7 @@ export const createSlackNotification = async (
 };

 export const updateSlackNotification = async (
-	input: typeof apiUpdateSlack._type,
+	input: z.infer<typeof apiUpdateSlack>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -130,7 +134,7 @@ export const updateSlackNotification = async (
 };

 export const createTelegramNotification = async (
-	input: typeof apiCreateTelegram._type,
+	input: z.infer<typeof apiCreateTelegram>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -181,7 +185,7 @@ export const createTelegramNotification = async (
 };

 export const updateTelegramNotification = async (
-	input: typeof apiUpdateTelegram._type,
+	input: z.infer<typeof apiUpdateTelegram>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -224,7 +228,7 @@ export const updateTelegramNotification = async (
 };

 export const createDiscordNotification = async (
-	input: typeof apiCreateDiscord._type,
+	input: z.infer<typeof apiCreateDiscord>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -274,7 +278,7 @@ export const createDiscordNotification = async (
 };

 export const updateDiscordNotification = async (
-	input: typeof apiUpdateDiscord._type,
+	input: z.infer<typeof apiUpdateDiscord>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -316,7 +320,7 @@ export const updateDiscordNotification = async (
 };

 export const createEmailNotification = async (
-	input: typeof apiCreateEmail._type,
+	input: z.infer<typeof apiCreateEmail>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -370,7 +374,7 @@ export const createEmailNotification = async (
 };

 export const updateEmailNotification = async (
-	input: typeof apiUpdateEmail._type,
+	input: z.infer<typeof apiUpdateEmail>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -416,7 +420,7 @@ export const updateEmailNotification = async (
 };

 export const createResendNotification = async (
-	input: typeof apiCreateResend._type,
+	input: z.infer<typeof apiCreateResend>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -467,7 +471,7 @@ export const createResendNotification = async (
 };

 export const updateResendNotification = async (
-	input: typeof apiUpdateResend._type,
+	input: z.infer<typeof apiUpdateResend>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -510,7 +514,7 @@ export const updateResendNotification = async (
 };

 export const createGotifyNotification = async (
-	input: typeof apiCreateGotify._type,
+	input: z.infer<typeof apiCreateGotify>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -561,7 +565,7 @@ export const createGotifyNotification = async (
 };

 export const updateGotifyNotification = async (
-	input: typeof apiUpdateGotify._type,
+	input: z.infer<typeof apiUpdateGotify>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -602,7 +606,7 @@ export const updateGotifyNotification = async (
 };

 export const createNtfyNotification = async (
-	input: typeof apiCreateNtfy._type,
+	input: z.infer<typeof apiCreateNtfy>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -653,7 +657,7 @@ export const createNtfyNotification = async (
 };

 export const updateNtfyNotification = async (
-	input: typeof apiUpdateNtfy._type,
+	input: z.infer<typeof apiUpdateNtfy>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -694,7 +698,7 @@ export const updateNtfyNotification = async (
 };

 export const createCustomNotification = async (
-	input: typeof apiCreateCustom._type,
+	input: z.infer<typeof apiCreateCustom>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -743,7 +747,7 @@ export const createCustomNotification = async (
 };

 export const updateCustomNotification = async (
-	input: typeof apiUpdateCustom._type,
+	input: z.infer<typeof apiUpdateCustom>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -796,6 +800,7 @@ export const findNotificationById = async (notificationId: string) => {
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});
 	if (!notification) {
@@ -817,7 +822,7 @@ export const removeNotificationById = async (notificationId: string) => {
 };

 export const createLarkNotification = async (
-	input: typeof apiCreateLark._type,
+	input: z.infer<typeof apiCreateLark>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -865,7 +870,7 @@ export const createLarkNotification = async (
 };

 export const updateLarkNotification = async (
-	input: typeof apiUpdateLark._type,
+	input: z.infer<typeof apiUpdateLark>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
@@ -905,6 +910,96 @@ export const updateLarkNotification = async (
 	});
 };

+export const createTeamsNotification = async (
+	input: z.infer<typeof apiCreateTeams>,
+	organizationId: string,
+) => {
+	await db.transaction(async (tx) => {
+		const newTeams = await tx
+			.insert(teams)
+			.values({
+				webhookUrl: input.webhookUrl,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newTeams) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting teams",
+			});
+		}
+
+		const newDestination = await tx
+			.insert(notifications)
+			.values({
+				teamsId: newTeams.teamsId,
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				volumeBackup: input.volumeBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				notificationType: "teams",
+				organizationId: organizationId,
+				serverThreshold: input.serverThreshold,
+			})
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error input: Inserting notification",
+			});
+		}
+
+		return newDestination;
+	});
+};
+
+export const updateTeamsNotification = async (
+	input: z.infer<typeof apiUpdateTeams>,
+) => {
+	await db.transaction(async (tx) => {
+		const newDestination = await tx
+			.update(notifications)
+			.set({
+				name: input.name,
+				appDeploy: input.appDeploy,
+				appBuildError: input.appBuildError,
+				databaseBackup: input.databaseBackup,
+				volumeBackup: input.volumeBackup,
+				dokployRestart: input.dokployRestart,
+				dockerCleanup: input.dockerCleanup,
+				organizationId: input.organizationId,
+				serverThreshold: input.serverThreshold,
+			})
+			.where(eq(notifications.notificationId, input.notificationId))
+			.returning()
+			.then((value) => value[0]);
+
+		if (!newDestination) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error Updating notification",
+			});
+		}
+
+		await tx
+			.update(teams)
+			.set({
+				webhookUrl: input.webhookUrl,
+			})
+			.where(eq(teams.teamsId, input.teamsId))
+			.returning()
+			.then((value) => value[0]);
+
+		return newDestination;
+	});
+};
+
 export const updateNotificationById = async (
 	notificationId: string,
 	notificationData: Partial<Notification>,
@@ -921,7 +1016,7 @@ export const updateNotificationById = async (
 };

 export const createPushoverNotification = async (
-	input: typeof apiCreatePushover._type,
+	input: z.infer<typeof apiCreatePushover>,
 	organizationId: string,
 ) => {
 	await db.transaction(async (tx) => {
@@ -974,7 +1069,7 @@ export const createPushoverNotification = async (
 };

 export const updatePushoverNotification = async (
-	input: typeof apiUpdatePushover._type,
+	input: z.infer<typeof apiUpdatePushover>,
 ) => {
 	await db.transaction(async (tx) => {
 		const newDestination = await tx
--- a/packages/server/src/services/patch-repo.ts
+++ b/packages/server/src/services/patch-repo.ts
@@ -0,0 +1,197 @@
+import { join } from "node:path";
+import { paths } from "@dokploy/server/constants";
+import { TRPCError } from "@trpc/server";
+import { execAsync, execAsyncRemote } from "../utils/process/execAsync";
+import { cloneBitbucketRepository } from "../utils/providers/bitbucket";
+import { cloneGitRepository } from "../utils/providers/git";
+import { cloneGiteaRepository } from "../utils/providers/gitea";
+import { cloneGithubRepository } from "../utils/providers/github";
+import { cloneGitlabRepository } from "../utils/providers/gitlab";
+import { findApplicationById } from "./application";
+import { findComposeById } from "./compose";
+
+interface PatchRepoConfig {
+	type: "application" | "compose";
+	id: string;
+}
+
+/**
+ * Ensure patch repo exists and is up-to-date
+ * Returns path to the repo
+ */
+export const ensurePatchRepo = async ({
+	type,
+	id,
+}: PatchRepoConfig): Promise<string> => {
+	let serverId: string | null = null;
+
+	if (type === "application") {
+		const application = await findApplicationById(id);
+		serverId = application.buildServerId || application.serverId;
+	} else {
+		const compose = await findComposeById(id);
+		serverId = compose.serverId;
+	}
+
+	const application =
+		type === "application"
+			? await findApplicationById(id)
+			: await findComposeById(id);
+
+	const { PATCH_REPOS_PATH } = paths(!!serverId);
+	const repoPath = join(PATCH_REPOS_PATH, type, application.appName);
+
+	const applicationEntity = {
+		...application,
+		type,
+		serverId: serverId,
+		outputPathOverride: repoPath,
+	};
+
+	let command = "set -e;";
+	if (application.sourceType === "github") {
+		command += await cloneGithubRepository(applicationEntity);
+	} else if (application.sourceType === "gitlab") {
+		command += await cloneGitlabRepository(applicationEntity);
+	} else if (application.sourceType === "gitea") {
+		command += await cloneGiteaRepository(applicationEntity);
+	} else if (application.sourceType === "bitbucket") {
+		command += await cloneBitbucketRepository(applicationEntity);
+	} else if (application.sourceType === "git") {
+		command += await cloneGitRepository(applicationEntity);
+	}
+
+	if (serverId) {
+		await execAsyncRemote(serverId, command);
+	} else {
+		await execAsync(command);
+	}
+
+	return repoPath;
+};
+
+interface DirectoryEntry {
+	name: string;
+	path: string;
+	type: "file" | "directory";
+	children?: DirectoryEntry[];
+}
+
+/**
+ * Read directory tree of the patch repo
+ */
+export const readPatchRepoDirectory = async (
+	repoPath: string,
+	serverId?: string | null,
+): Promise<DirectoryEntry[]> => {
+	// Use git ls-tree to get tracked files only
+	const command = `cd "${repoPath}" && git ls-tree -r --name-only HEAD`;
+
+	let stdout: string;
+	try {
+		if (serverId) {
+			const result = await execAsyncRemote(serverId, command);
+			stdout = result.stdout;
+		} else {
+			const result = await execAsync(command);
+			stdout = result.stdout;
+		}
+	} catch (error) {
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Failed to read repository: ${error}`,
+		});
+	}
+
+	const files = stdout.trim().split("\n").filter(Boolean);
+
+	// Build tree structure
+	const root: DirectoryEntry[] = [];
+	const dirMap = new Map<string, DirectoryEntry>();
+
+	for (const filePath of files) {
+		const parts = filePath.split("/");
+		let currentPath = "";
+
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (!part) continue;
+
+			const isFile = i === parts.length - 1;
+			const parentPath = currentPath;
+			currentPath = currentPath ? `${currentPath}/${part}` : part;
+
+			if (!dirMap.has(currentPath)) {
+				const entry: DirectoryEntry = {
+					name: part,
+					path: currentPath,
+					type: isFile ? "file" : "directory",
+					children: isFile ? undefined : [],
+				};
+
+				dirMap.set(currentPath, entry);
+
+				if (parentPath) {
+					const parent = dirMap.get(parentPath);
+					parent?.children?.push(entry);
+				} else {
+					root.push(entry);
+				}
+			}
+		}
+	}
+
+	return root;
+};
+
+export const readPatchRepoFile = async (
+	id: string,
+	type: "application" | "compose",
+	filePath: string,
+) => {
+	let serverId: string | null = null;
+
+	if (type === "application") {
+		const application = await findApplicationById(id);
+		serverId = application.buildServerId || application.serverId;
+	} else {
+		const compose = await findComposeById(id);
+		serverId = compose.serverId;
+	}
+	const { PATCH_REPOS_PATH } = paths(!!serverId);
+
+	const application =
+		type === "application"
+			? await findApplicationById(id)
+			: await findComposeById(id);
+
+	const repoPath = join(PATCH_REPOS_PATH, type, application.appName);
+	const fullPath = join(repoPath, filePath);
+
+	const command = `cat "${fullPath}"`;
+
+	if (serverId) {
+		const result = await execAsyncRemote(serverId, command);
+		return result.stdout;
+	}
+
+	const result = await execAsync(command);
+	return result.stdout;
+};
+
+/**
+ * Clean all patch repos
+ */
+export const cleanPatchRepos = async (
+	serverId?: string | null,
+): Promise<void> => {
+	const { PATCH_REPOS_PATH } = paths(!!serverId);
+
+	const command = `rm -rf "${PATCH_REPOS_PATH}"/* 2>/dev/null || true`;
+
+	if (serverId) {
+		await execAsyncRemote(serverId, command);
+	} else {
+		await execAsync(command);
+	}
+};
--- a/packages/server/src/services/patch.ts
+++ b/packages/server/src/services/patch.ts
@@ -0,0 +1,176 @@
+import { join } from "node:path";
+import { paths } from "@dokploy/server/constants";
+import { db } from "@dokploy/server/db";
+import { type apiCreatePatch, patch } from "@dokploy/server/db/schema";
+import { TRPCError } from "@trpc/server";
+import { and, eq } from "drizzle-orm";
+import type { z } from "zod";
+import { encodeBase64 } from "../utils/docker/utils";
+import { findApplicationById } from "./application";
+import { findComposeById } from "./compose";
+
+export type Patch = typeof patch.$inferSelect;
+
+export const createPatch = async (input: z.infer<typeof apiCreatePatch>) => {
+	if (!input.applicationId && !input.composeId) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Either applicationId or composeId must be provided",
+		});
+	}
+
+	const newPatch = await db
+		.insert(patch)
+		.values({
+			...input,
+			content: input.content,
+			enabled: true,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newPatch) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error creating the patch",
+		});
+	}
+
+	return newPatch;
+};
+
+export const findPatchById = async (patchId: string) => {
+	const result = await db.query.patch.findFirst({
+		where: eq(patch.patchId, patchId),
+	});
+
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Patch not found",
+		});
+	}
+
+	return result;
+};
+
+export const findPatchesByEntityId = async (
+	id: string,
+	type: "application" | "compose",
+) => {
+	return await db.query.patch.findMany({
+		where: eq(
+			type === "application" ? patch.applicationId : patch.composeId,
+			id,
+		),
+		orderBy: (patch, { asc }) => [asc(patch.filePath)],
+	});
+};
+
+export const findPatchByFilePath = async (
+	filePath: string,
+	id: string,
+	type: "application" | "compose",
+) => {
+	return await db.query.patch.findFirst({
+		where: and(
+			eq(patch.filePath, filePath),
+			eq(type === "application" ? patch.applicationId : patch.composeId, id),
+		),
+	});
+};
+
+export const updatePatch = async (patchId: string, data: Partial<Patch>) => {
+	const result = await db
+		.update(patch)
+		.set({
+			...data,
+			...(data.content && {
+				content: data.content.endsWith("\n")
+					? data.content
+					: `${data.content}\n`,
+			}),
+			updatedAt: new Date().toISOString(),
+		})
+		.where(eq(patch.patchId, patchId))
+		.returning();
+
+	return result[0];
+};
+
+export const deletePatch = async (patchId: string) => {
+	const result = await db
+		.delete(patch)
+		.where(eq(patch.patchId, patchId))
+		.returning();
+
+	return result[0];
+};
+
+export const markPatchForDeletion = async (
+	filePath: string,
+	entityId: string,
+	entityType: "application" | "compose",
+) => {
+	const existing = await findPatchByFilePath(filePath, entityId, entityType);
+
+	if (existing) {
+		return await updatePatch(existing.patchId, { type: "delete", content: "" });
+	}
+
+	return await createPatch({
+		filePath,
+		content: "",
+		type: "delete",
+		applicationId: entityType === "application" ? entityId : undefined,
+		composeId: entityType === "compose" ? entityId : undefined,
+	});
+};
+
+interface ApplyPatchesOptions {
+	id: string;
+	type: "application" | "compose";
+	serverId: string | null;
+}
+
+export const generateApplyPatchesCommand = async ({
+	id,
+	type,
+	serverId,
+}: ApplyPatchesOptions) => {
+	const entity =
+		type === "application"
+			? await findApplicationById(id)
+			: await findComposeById(id);
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const codePath = join(basePath, entity.appName, "code");
+
+	const resultPatches = await findPatchesByEntityId(id, type);
+	const patches = resultPatches.filter((p) => p.enabled);
+
+	if (patches.length === 0) {
+		return "";
+	}
+
+	let command = `echo "Applying ${patches.length} patch(es)...";`;
+
+	for (const p of patches) {
+		const filePath = join(codePath, p.filePath);
+
+		if (p.type === "delete") {
+			command += `
+			rm -f "${filePath}";
+			`;
+		} else {
+			command += `
+file="${filePath}"
+dir="$(dirname "$file")"
+mkdir -p "$dir"
+echo "${encodeBase64(p.content)}" | base64 -d > "$file"
+`;
+		}
+	}
+
+	return command;
+};
--- a/packages/server/src/services/port.ts
+++ b/packages/server/src/services/port.ts
@@ -2,10 +2,11 @@ import { db } from "@dokploy/server/db";
 import { type apiCreatePort, ports } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Port = typeof ports.$inferSelect;

-export const createPort = async (input: typeof apiCreatePort._type) => {
+export const createPort = async (input: z.infer<typeof apiCreatePort>) => {
 	const newPort = await db
 		.insert(ports)
 		.values({
--- a/packages/server/src/services/postgres.ts
+++ b/packages/server/src/services/postgres.ts
@@ -11,6 +11,7 @@ import { pullImage } from "@dokploy/server/utils/docker/utils";
 import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq, getTableColumns } from "drizzle-orm";
+import type { z } from "zod";
 import { validUniqueServerAppName } from "./project";

 export function getMountPath(dockerImage: string): string {
@@ -28,7 +29,9 @@ export function getMountPath(dockerImage: string): string {

 export type Postgres = typeof postgres.$inferSelect;

-export const createPostgres = async (input: typeof apiCreatePostgres._type) => {
+export const createPostgres = async (
+	input: z.infer<typeof apiCreatePostgres>,
+) => {
 	const appName = buildAppName("postgres", input.appName);

 	const valid = await validUniqueServerAppName(appName);
--- a/packages/server/src/services/preview-deployment.ts
+++ b/packages/server/src/services/preview-deployment.ts
@@ -7,6 +7,7 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { and, desc, eq } from "drizzle-orm";
+import type { z } from "zod";
 import { generatePassword } from "../templates";
 import { removeService } from "../utils/docker/utils";
 import { removeDirectoryCode } from "../utils/filesystem/directory";
@@ -130,7 +131,7 @@ export const findPreviewDeploymentsByApplicationId = async (
 };

 export const createPreviewDeployment = async (
-	schema: typeof apiCreatePreviewDeployment._type,
+	schema: z.infer<typeof apiCreatePreviewDeployment>,
 ) => {
 	const application = await findApplicationById(schema.applicationId);
 	const appName = `preview-${application.appName}-${generatePassword(6)}`;
--- a/packages/server/src/services/project.ts
+++ b/packages/server/src/services/project.ts
@@ -11,12 +11,13 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { createProductionEnvironment } from "./environment";

 export type Project = typeof projects.$inferSelect;

 export const createProject = async (
-	input: typeof apiCreateProject._type,
+	input: z.infer<typeof apiCreateProject>,
 	organizationId: string,
 ) => {
 	const newProject = await db
--- a/packages/server/src/services/proprietary/license-key.ts
+++ b/packages/server/src/services/proprietary/license-key.ts
@@ -0,0 +1,24 @@
+import { db } from "@dokploy/server/db";
+import { user } from "@dokploy/server/db/schema";
+import { eq } from "drizzle-orm";
+import { getOrganizationOwnerId } from "./sso";
+
+export const hasValidLicense = async (organizationId: string) => {
+	const ownerId = await getOrganizationOwnerId(organizationId);
+
+	if (!ownerId) {
+		return false;
+	}
+
+	const currentUser = await db.query.user.findFirst({
+		where: eq(user.id, ownerId),
+		columns: {
+			enableEnterpriseFeatures: true,
+			isValidEnterpriseLicense: true,
+		},
+	});
+	return !!(
+		currentUser?.enableEnterpriseFeatures &&
+		currentUser?.isValidEnterpriseLicense
+	);
+};
--- a/packages/server/src/services/proprietary/sso.ts
+++ b/packages/server/src/services/proprietary/sso.ts
@@ -1,4 +1,6 @@
 import { db } from "@dokploy/server/db";
+import { organization } from "@dokploy/server/db/schema";
+import { eq } from "drizzle-orm";

 export const getSSOProviders = async () => {
 	const providers = await db.query.ssoProvider.findMany({
@@ -33,3 +35,12 @@ export const normalizeTrustedOrigin = (value: string): string => {
 	// e.g. "https://example.com/" -> "https://example.com"
 	return value.trim().replace(/\/+$/, "");
 };
+
+export const getOrganizationOwnerId = async (organizationId: string) => {
+	const org = await db.query.organization.findFirst({
+		where: eq(organization.id, organizationId),
+		columns: { ownerId: true },
+	});
+	if (!org) return null;
+	return org.ownerId;
+};
--- a/packages/server/src/services/redis.ts
+++ b/packages/server/src/services/redis.ts
@@ -10,12 +10,13 @@ import { pullImage } from "@dokploy/server/utils/docker/utils";
 import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { validUniqueServerAppName } from "./project";

 export type Redis = typeof redis.$inferSelect;

 // https://github.com/drizzle-team/drizzle-orm/discussions/1483#discussioncomment-7523881
-export const createRedis = async (input: typeof apiCreateRedis._type) => {
+export const createRedis = async (input: z.infer<typeof apiCreateRedis>) => {
 	const appName = buildAppName("redis", input.appName);

 	const valid = await validUniqueServerAppName(appName);
--- a/packages/server/src/services/registry.ts
+++ b/packages/server/src/services/registry.ts
@@ -6,6 +6,7 @@ import {
 } from "@dokploy/server/utils/process/execAsync";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";
 import { IS_CLOUD } from "../constants";

 export type Registry = typeof registry.$inferSelect;
@@ -27,7 +28,7 @@ function safeDockerLoginCommand(
 }

 export const createRegistry = async (
-	input: typeof apiCreateRegistry._type,
+	input: z.infer<typeof apiCreateRegistry>,
 	organizationId: string,
 ) => {
 	return await db.transaction(async (tx) => {
--- a/packages/server/src/services/schedule.ts
+++ b/packages/server/src/services/schedule.ts
@@ -18,7 +18,10 @@ export const createSchedule = async (
 	input: z.infer<typeof createScheduleSchema>,
 ) => {
 	const { scheduleId, ...rest } = input;
-	const [newSchedule] = await db.insert(schedules).values(rest).returning();
+	const [newSchedule] = await db
+		.insert(schedules)
+		.values(rest as typeof schedules.$inferInsert)
+		.returning();

 	if (
 		newSchedule &&
@@ -120,7 +123,7 @@ export const updateSchedule = async (
 	const { scheduleId, ...rest } = input;
 	const [updatedSchedule] = await db
 		.update(schedules)
-		.set(rest)
+		.set(rest as Partial<typeof schedules.$inferInsert>)
 		.where(eq(schedules.scheduleId, scheduleId))
 		.returning();

--- a/packages/server/src/services/security.ts
+++ b/packages/server/src/services/security.ts
@@ -50,7 +50,8 @@ export const createSecurity = async (
 	} catch (error) {
 		throw new TRPCError({
 			code: "BAD_REQUEST",
-			message: "Error creating this security",
+			message:
+				error instanceof Error ? error.message : "Error creating this security",
 			cause: error,
 		});
 	}
@@ -90,15 +91,35 @@ export const updateSecurityById = async (
 	data: Partial<Security>,
 ) => {
 	try {
-		const response = await db
-			.update(security)
-			.set({
-				...data,
-			})
-			.where(eq(security.securityId, securityId))
-			.returning();
+		await db.transaction(async (tx) => {
+			const securityResponse = await findSecurityById(securityId);

-		return response[0];
+			const application = await findApplicationById(
+				securityResponse.applicationId,
+			);
+
+			await removeSecurityMiddleware(application, securityResponse);
+
+			const response = await tx
+				.update(security)
+				.set({
+					...data,
+				})
+				.where(eq(security.securityId, securityId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!response) {
+				throw new TRPCError({
+					code: "NOT_FOUND",
+					message: "Security not found",
+				});
+			}
+
+			await createSecurityMiddleware(application, response);
+
+			return response;
+		});
 	} catch (error) {
 		const message =
 			error instanceof Error ? error.message : "Error updating this security";
--- a/packages/server/src/services/server.ts
+++ b/packages/server/src/services/server.ts
@@ -6,11 +6,12 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

 export type Server = typeof server.$inferSelect;

 export const createServer = async (
-	input: typeof apiCreateServer._type,
+	input: z.infer<typeof apiCreateServer>,
 	organizationId: string,
 ) => {
 	const newServer = await db
@@ -19,7 +20,7 @@ export const createServer = async (
 			...input,
 			organizationId: organizationId,
 			createdAt: new Date().toISOString(),
-		})
+		} as typeof server.$inferInsert)
 		.returning()
 		.then((value) => value[0]);

--- a/packages/server/src/services/ssh-key.ts
+++ b/packages/server/src/services/ssh-key.ts
@@ -8,8 +8,9 @@ import {
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
+import type { z } from "zod";

-export const createSshKey = async (input: typeof apiCreateSshKey._type) => {
+export const createSshKey = async (input: z.infer<typeof apiCreateSshKey>) => {
 	await db.transaction(async (tx) => {
 		const sshKey = await tx
 			.insert(sshKeys)
@@ -29,7 +30,7 @@ export const createSshKey = async (input: typeof apiCreateSshKey._type) => {
 };

 export const removeSSHKeyById = async (
-	sshKeyId: (typeof apiRemoveSshKey._type)["sshKeyId"],
+	sshKeyId: z.infer<typeof apiRemoveSshKey>["sshKeyId"],
 ) => {
 	const result = await db
 		.delete(sshKeys)
@@ -42,7 +43,7 @@ export const removeSSHKeyById = async (
 export const updateSSHKeyById = async ({
 	sshKeyId,
 	...input
-}: typeof apiUpdateSshKey._type) => {
+}: z.infer<typeof apiUpdateSshKey>) => {
 	const result = await db
 		.update(sshKeys)
 		.set(input)
@@ -53,7 +54,7 @@ export const updateSSHKeyById = async ({
 };

 export const findSSHKeyById = async (
-	sshKeyId: (typeof apiFindOneSshKey._type)["sshKeyId"],
+	sshKeyId: z.infer<typeof apiFindOneSshKey>["sshKeyId"],
 ) => {
 	const sshKey = await db.query.sshKeys.findFirst({
 		where: eq(sshKeys.sshKeyId, sshKeyId),
--- a/packages/server/src/services/volume-backups.ts
+++ b/packages/server/src/services/volume-backups.ts
@@ -94,7 +94,7 @@ export const createVolumeBackup = async (
 ) => {
 	const newVolumeBackup = await db
 		.insert(volumeBackups)
-		.values(volumeBackup)
+		.values(volumeBackup as typeof volumeBackups.$inferInsert)
 		.returning()
 		.then((e) => e[0]);

@@ -113,7 +113,7 @@ export const updateVolumeBackup = async (
 ) => {
 	return await db
 		.update(volumeBackups)
-		.set(volumeBackup)
+		.set(volumeBackup as Partial<typeof volumeBackups.$inferInsert>)
 		.where(eq(volumeBackups.volumeBackupId, volumeBackupId))
 		.returning()
 		.then((e) => e[0]);
--- a/packages/server/src/utils/access-log/handler.ts
+++ b/packages/server/src/utils/access-log/handler.ts
@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { paths } from "@dokploy/server/constants";
 import {
 	getWebServerSettings,
@@ -12,8 +14,6 @@ export const startLogCleanup = async (
 	cronExpression = "0 0 * * *",
 ): Promise<boolean> => {
 	try {
-		const { DYNAMIC_TRAEFIK_PATH } = paths();
-
 		const existingJob = scheduledJobs[LOG_CLEANUP_JOB_NAME];
 		if (existingJob) {
 			existingJob.cancel();
@@ -21,10 +21,17 @@ export const startLogCleanup = async (

 		scheduleJob(LOG_CLEANUP_JOB_NAME, cronExpression, async () => {
 			try {
-				await execAsync(
-					`tail -n 1000 ${DYNAMIC_TRAEFIK_PATH}/access.log > ${DYNAMIC_TRAEFIK_PATH}/access.log.tmp && mv ${DYNAMIC_TRAEFIK_PATH}/access.log.tmp ${DYNAMIC_TRAEFIK_PATH}/access.log`,
-				);
+				const { DYNAMIC_TRAEFIK_PATH } = paths();
+				const accessLogPath = path.join(DYNAMIC_TRAEFIK_PATH, "access.log");

+				if (!fs.existsSync(accessLogPath)) {
+					console.error("Access log file does not exist");
+					return;
+				}
+
+				await execAsync(
+					`tail -n 1000 ${accessLogPath} > ${accessLogPath}.tmp && mv ${accessLogPath}.tmp ${accessLogPath}`,
+				);
 				await execAsync("docker exec dokploy-traefik kill -USR1 1");
 			} catch (error) {
 				console.error("Error during log cleanup:", error);
--- a/packages/server/src/utils/backups/index.ts
+++ b/packages/server/src/utils/backups/index.ts
@@ -30,15 +30,19 @@ export const initCronJobs = async () => {
 	const webServerSettings = await getWebServerSettings();

 	if (webServerSettings?.enableDockerCleanup) {
-		scheduleJob("docker-cleanup", CLEANUP_CRON_JOB, async () => {
-			console.log(
-				`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
-			);
+		try {
+			scheduleJob("docker-cleanup", CLEANUP_CRON_JOB, async () => {
+				console.log(
+					`Docker Cleanup ${new Date().toLocaleString()}]  Running docker cleanup`,
+				);

-			await cleanupAll();
+				await cleanupAll();

-			await sendDockerCleanupNotifications(admin.user.id);
-		});
+				await sendDockerCleanupNotifications(admin.user.id);
+			});
+		} catch (error) {
+			console.error("[Backup] Docker Cleanup Error", error);
+		}
 	}

 	const servers = await getAllServers();
@@ -46,18 +50,22 @@ export const initCronJobs = async () => {
 	for (const server of servers) {
 		const { serverId, enableDockerCleanup, name } = server;
 		if (enableDockerCleanup) {
-			scheduleJob(serverId, CLEANUP_CRON_JOB, async () => {
-				console.log(
-					`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${name}`,
-				);
+			try {
+				scheduleJob(serverId, CLEANUP_CRON_JOB, async () => {
+					console.log(
+						`SERVER-BACKUP[${new Date().toLocaleString()}] Running Cleanup ${name}`,
+					);

-				await cleanupAll(serverId);
+					await cleanupAll(serverId);

-				await sendDockerCleanupNotifications(
-					admin.user.id,
-					`Docker cleanup for Server ${name} (${serverId})`,
-				);
-			});
+					await sendDockerCleanupNotifications(
+						admin.user.id,
+						`Docker cleanup for Server ${name} (${serverId})`,
+					);
+				});
+			} catch (error) {
+				console.error(`[Backup] ${error}`);
+			}
 		}
 	}

@@ -87,11 +95,15 @@ export const initCronJobs = async () => {
 	}

 	if (webServerSettings?.logCleanupCron) {
-		console.log(
-			"Starting log requests cleanup",
-			webServerSettings.logCleanupCron,
-		);
-		await startLogCleanup(webServerSettings.logCleanupCron);
+		try {
+			console.log(
+				"Starting log requests cleanup",
+				webServerSettings.logCleanupCron,
+			);
+			await startLogCleanup(webServerSettings.logCleanupCron);
+		} catch (error) {
+			console.error("[Backup] Log Cleanup Error", error);
+		}
 	}
 };

--- a/packages/server/src/utils/builders/drop.ts
+++ b/packages/server/src/utils/builders/drop.ts
@@ -3,6 +3,7 @@ import path, { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { Application } from "@dokploy/server/services/application";
 import { findServerById } from "@dokploy/server/services/server";
+import { readValidDirectory } from "@dokploy/server/wss/utils";
 import AdmZip from "adm-zip";
 import { Client, type SFTPWrapper } from "ssh2";
 import {
@@ -16,10 +17,13 @@ export const unzipDrop = async (zipFile: File, application: Application) => {

 	try {
 		const { appName } = application;
-		const { APPLICATIONS_PATH } = paths(!!application.serverId);
+		// Use buildServerId if set, otherwise fall back to serverId
+		// This ensures the code is extracted to the server where the build will run
+		const targetServerId = application.buildServerId || application.serverId;
+		const { APPLICATIONS_PATH } = paths(!!targetServerId);
 		const outputPath = join(APPLICATIONS_PATH, appName, "code");
-		if (application.serverId) {
-			await recreateDirectoryRemote(outputPath, application.serverId);
+		if (targetServerId) {
+			await recreateDirectoryRemote(outputPath, targetServerId);
 		} else {
 			await recreateDirectory(outputPath);
 		}
@@ -45,8 +49,8 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 			? rootEntries[0]?.entryName.split("/")[0]
 			: "";

-		if (application.serverId) {
-			sftp = await getSFTPConnection(application.serverId);
+		if (targetServerId) {
+			sftp = await getSFTPConnection(targetServerId);
 		}
 		for (const entry of zipEntries) {
 			let filePath = entry.entryName;
@@ -62,16 +66,24 @@ export const unzipDrop = async (zipFile: File, application: Application) => {
 			if (!filePath) continue;

 			const fullPath = path.join(outputPath, filePath).replace(/\\/g, "/");
+			if (!readValidDirectory(fullPath, application.serverId)) {
+				throw new Error(
+					`Path traversal detected: resolved path escapes output directory: ${filePath}`,
+				);
+			}

-			if (application.serverId) {
+			if (isDangerousNode(entry)) {
+				throw new Error(
+					`Dangerous node entries are not allowed: ${entry.entryName}`,
+				);
+			}
+
+			if (targetServerId) {
 				if (!entry.isDirectory) {
 					if (sftp === null) throw new Error("No SFTP connection available");
 					try {
 						const dirPath = path.dirname(fullPath);
-						await execAsyncRemote(
-							application.serverId,
-							`mkdir -p "${dirPath}"`,
-						);
+						await execAsyncRemote(targetServerId, `mkdir -p "${dirPath}"`);
 						await uploadFileToServer(sftp, entry.getData(), fullPath);
 					} catch (err) {
 						console.error(`Error uploading file ${fullPath}:`, err);
@@ -132,3 +144,14 @@ const uploadFileToServer = (
 		});
 	});
 };
+
+function isDangerousNode(entry: AdmZip.IZipEntry) {
+	const type = (entry.header.attr >> 16) & 0o170000;
+
+	return (
+		type === 0o120000 || // symlink
+		type === 0o060000 || // block device
+		type === 0o020000 || // char device
+		type === 0o010000 // fifo/pipe
+	);
+}
--- a/packages/server/src/utils/filesystem/directory.ts
+++ b/packages/server/src/utils/filesystem/directory.ts
@@ -127,7 +127,7 @@ export const getBuildAppDirectory = (application: Application) => {
 			appName,
 			"code",
 			buildPath ?? "",
-			dockerfile || "",
+			dockerfile || "Dockerfile",
 		);
 	}

--- a/packages/server/src/utils/notifications/build-error.ts
+++ b/packages/server/src/utils/notifications/build-error.ts
@@ -14,6 +14,7 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -52,6 +53,7 @@ export const sendBuildErrorNotifications = async ({
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});

@@ -67,6 +69,7 @@ export const sendBuildErrorNotifications = async ({
 			custom,
 			lark,
 			pushover,
+			teams,
 		} = notification;
 		try {
 			if (email || resend) {
@@ -382,6 +385,26 @@ export const sendBuildErrorNotifications = async ({
 					`Project: ${projectName}\nApplication: ${applicationName}\nType: ${applicationType}\nDate: ${date.toLocaleString()}\nError: ${errorMessage}`,
 				);
 			}
+
+			if (teams) {
+				const limitCharacter = 800;
+				const truncatedErrorMessage = errorMessage.substring(0, limitCharacter);
+				await sendTeamsNotification(teams, {
+					title: "⚠️ Build Failed",
+					facts: [
+						{ name: "Project", value: projectName },
+						{ name: "Application", value: applicationName },
+						{ name: "Type", value: applicationType },
+						{ name: "Date", value: format(date, "PP pp") },
+						{ name: "Error Message", value: truncatedErrorMessage },
+					],
+					potentialAction: {
+						type: "Action.OpenUrl",
+						title: "View Build Details",
+						url: buildLink,
+					},
+				});
+			}
 		} catch (error) {
 			console.log(error);
 		}
--- a/packages/server/src/utils/notifications/build-success.ts
+++ b/packages/server/src/utils/notifications/build-success.ts
@@ -15,6 +15,7 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -55,6 +56,7 @@ export const sendBuildSuccessNotifications = async ({
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});

@@ -70,6 +72,7 @@ export const sendBuildSuccessNotifications = async ({
 			custom,
 			lark,
 			pushover,
+			teams,
 		} = notification;
 		try {
 			if (email || resend) {
@@ -396,6 +399,24 @@ export const sendBuildSuccessNotifications = async ({
 					`Project: ${projectName}\nApplication: ${applicationName}\nEnvironment: ${environmentName}\nType: ${applicationType}\nDate: ${date.toLocaleString()}`,
 				);
 			}
+
+			if (teams) {
+				await sendTeamsNotification(teams, {
+					title: "✅ Build Success",
+					facts: [
+						{ name: "Project", value: projectName },
+						{ name: "Application", value: applicationName },
+						{ name: "Environment", value: environmentName },
+						{ name: "Type", value: applicationType },
+						{ name: "Date", value: format(date, "PP pp") },
+					],
+					potentialAction: {
+						type: "Action.OpenUrl",
+						title: "View Build Details",
+						url: buildLink,
+					},
+				});
+			}
 		} catch (error) {
 			console.log(error);
 		}
--- a/packages/server/src/utils/notifications/database-backup.ts
+++ b/packages/server/src/utils/notifications/database-backup.ts
@@ -14,6 +14,7 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -52,6 +53,7 @@ export const sendDatabaseBackupNotifications = async ({
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});

@@ -67,6 +69,7 @@ export const sendDatabaseBackupNotifications = async ({
 			custom,
 			lark,
 			pushover,
+			teams,
 		} = notification;
 		try {
 			if (email || resend) {
@@ -410,6 +413,30 @@ export const sendDatabaseBackupNotifications = async ({
 					`Project: ${projectName}\nApplication: ${applicationName}\nDatabase: ${databaseType}\nDatabase Name: ${databaseName}\nDate: ${date.toLocaleString()}${type === "error" && errorMessage ? `\nError: ${errorMessage}` : ""}`,
 				);
 			}
+
+			if (teams) {
+				const facts = [
+					{ name: "Project", value: projectName },
+					{ name: "Application", value: applicationName },
+					{ name: "Database Type", value: databaseType },
+					{ name: "Database Name", value: databaseName },
+					{ name: "Date", value: format(date, "PP pp") },
+					{
+						name: "Status",
+						value: type === "success" ? "Successful" : "Failed",
+					},
+				];
+				if (type === "error" && errorMessage) {
+					facts.push({ name: "Error", value: errorMessage.substring(0, 500) });
+				}
+				await sendTeamsNotification(teams, {
+					title:
+						type === "success"
+							? "✅ Database Backup Successful"
+							: "❌ Database Backup Failed",
+					facts,
+				});
+			}
 		} catch (error) {
 			console.log(error);
 		}
--- a/packages/server/src/utils/notifications/docker-cleanup.ts
+++ b/packages/server/src/utils/notifications/docker-cleanup.ts
@@ -14,6 +14,7 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -39,6 +40,7 @@ export const sendDockerCleanupNotifications = async (
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});

@@ -54,6 +56,7 @@ export const sendDockerCleanupNotifications = async (
 			custom,
 			lark,
 			pushover,
+			teams,
 		} = notification;
 		try {
 			if (email || resend) {
@@ -262,6 +265,16 @@ export const sendDockerCleanupNotifications = async (
 					`Date: ${date.toLocaleString()}\nMessage: ${message}`,
 				);
 			}
+
+			if (teams) {
+				await sendTeamsNotification(teams, {
+					title: "✅ Docker Cleanup",
+					facts: [
+						{ name: "Date", value: format(date, "PP pp") },
+						{ name: "Message", value: message },
+					],
+				});
+			}
 		} catch (error) {
 			console.log(error);
 		}
--- a/packages/server/src/utils/notifications/dokploy-restart.ts
+++ b/packages/server/src/utils/notifications/dokploy-restart.ts
@@ -14,245 +14,262 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

 export const sendDokployRestartNotifications = async () => {
-	const date = new Date();
-	const unixDate = ~~(Number(date) / 1000);
-	const notificationList = await db.query.notifications.findMany({
-		where: eq(notifications.dokployRestart, true),
-		with: {
-			email: true,
-			discord: true,
-			telegram: true,
-			slack: true,
-			resend: true,
-			gotify: true,
-			ntfy: true,
-			custom: true,
-			lark: true,
-			pushover: true,
-		},
-	});
+	try {
+		const date = new Date();
+		const unixDate = ~~(Number(date) / 1000);
+		const notificationList = await db.query.notifications.findMany({
+			where: eq(notifications.dokployRestart, true),
+			with: {
+				email: true,
+				discord: true,
+				telegram: true,
+				slack: true,
+				resend: true,
+				gotify: true,
+				ntfy: true,
+				custom: true,
+				lark: true,
+				pushover: true,
+				teams: true,
+			},
+		});

-	for (const notification of notificationList) {
-		const {
-			email,
-			resend,
-			discord,
-			telegram,
-			slack,
-			gotify,
-			ntfy,
-			custom,
-			lark,
-			pushover,
-		} = notification;
+		for (const notification of notificationList) {
+			const {
+				email,
+				resend,
+				discord,
+				telegram,
+				slack,
+				gotify,
+				ntfy,
+				custom,
+				lark,
+				pushover,
+				teams,
+			} = notification;

-		try {
-			if (email || resend) {
-				const template = await renderAsync(
-					DokployRestartEmail({ date: date.toLocaleString() }),
-				).catch();
+			try {
+				if (email || resend) {
+					const template = await renderAsync(
+						DokployRestartEmail({ date: date.toLocaleString() }),
+					).catch();

-				if (email) {
-					await sendEmailNotification(
-						email,
-						"Dokploy Server Restarted",
-						template,
-					);
+					if (email) {
+						await sendEmailNotification(
+							email,
+							"Dokploy Server Restarted",
+							template,
+						);
+					}
+
+					if (resend) {
+						await sendResendNotification(
+							resend,
+							"Dokploy Server Restarted",
+							template,
+						);
+					}
 				}

-				if (resend) {
-					await sendResendNotification(
-						resend,
-						"Dokploy Server Restarted",
-						template,
-					);
-				}
-			}
+				if (discord) {
+					const decorate = (decoration: string, text: string) =>
+						`${discord.decoration ? decoration : ""} ${text}`.trim();

-			if (discord) {
-				const decorate = (decoration: string, text: string) =>
-					`${discord.decoration ? decoration : ""} ${text}`.trim();
-
-				await sendDiscordNotification(discord, {
-					title: decorate(">", "`✅` Dokploy Server Restarted"),
-					color: 0x57f287,
-					fields: [
-						{
-							name: decorate("`📅`", "Date"),
-							value: `<t:${unixDate}:D>`,
-							inline: true,
-						},
-						{
-							name: decorate("`⌚`", "Time"),
-							value: `<t:${unixDate}:t>`,
-							inline: true,
-						},
-						{
-							name: decorate("`❓`", "Type"),
-							value: "Successful",
-							inline: true,
-						},
-					],
-					timestamp: date.toISOString(),
-					footer: {
-						text: "Dokploy Restart Notification",
-					},
-				});
-			}
-
-			if (gotify) {
-				const decorate = (decoration: string, text: string) =>
-					`${gotify.decoration ? decoration : ""} ${text}\n`;
-				await sendGotifyNotification(
-					gotify,
-					decorate("✅", "Dokploy Server Restarted"),
-					`${decorate("🕒", `Date: ${date.toLocaleString()}`)}`,
-				);
-			}
-
-			if (ntfy) {
-				await sendNtfyNotification(
-					ntfy,
-					"Dokploy Server Restarted",
-					"white_check_mark",
-					"",
-					`🕒Date: ${date.toLocaleString()}`,
-				);
-			}
-
-			if (telegram) {
-				await sendTelegramNotification(
-					telegram,
-					`<b>✅ Dokploy Server Restarted</b>\n\n<b>Date:</b> ${format(
-						date,
-						"PP",
-					)}\n<b>Time:</b> ${format(date, "pp")}`,
-				);
-			}
-
-			if (slack) {
-				const { channel } = slack;
-				await sendSlackNotification(slack, {
-					channel: channel,
-					attachments: [
-						{
-							color: "#00FF00",
-							pretext: ":white_check_mark: *Dokploy Server Restarted*",
-							fields: [
-								{
-									title: "Time",
-									value: date.toLocaleString(),
-									short: true,
-								},
-							],
-						},
-					],
-				});
-			}
-
-			if (custom) {
-				try {
-					await sendCustomNotification(custom, {
-						title: "Dokploy Server Restarted",
-						message: "Dokploy server has been restarted successfully",
+					await sendDiscordNotification(discord, {
+						title: decorate(">", "`✅` Dokploy Server Restarted"),
+						color: 0x57f287,
+						fields: [
+							{
+								name: decorate("`📅`", "Date"),
+								value: `<t:${unixDate}:D>`,
+								inline: true,
+							},
+							{
+								name: decorate("`⌚`", "Time"),
+								value: `<t:${unixDate}:t>`,
+								inline: true,
+							},
+							{
+								name: decorate("`❓`", "Type"),
+								value: "Successful",
+								inline: true,
+							},
+						],
 						timestamp: date.toISOString(),
-						date: date.toLocaleString(),
-						status: "success",
-						type: "dokploy-restart",
+						footer: {
+							text: "Dokploy Restart Notification",
+						},
 					});
-				} catch (error) {
-					console.log(error);
 				}
-			}

-			if (lark) {
-				await sendLarkNotification(lark, {
-					msg_type: "interactive",
-					card: {
-						schema: "2.0",
-						config: {
-							update_multi: true,
-							style: {
-								text_size: {
-									normal_v2: {
-										default: "normal",
-										pc: "normal",
-										mobile: "heading",
+				if (gotify) {
+					const decorate = (decoration: string, text: string) =>
+						`${gotify.decoration ? decoration : ""} ${text}\n`;
+					await sendGotifyNotification(
+						gotify,
+						decorate("✅", "Dokploy Server Restarted"),
+						`${decorate("🕒", `Date: ${date.toLocaleString()}`)}`,
+					);
+				}
+
+				if (ntfy) {
+					await sendNtfyNotification(
+						ntfy,
+						"Dokploy Server Restarted",
+						"white_check_mark",
+						"",
+						`🕒Date: ${date.toLocaleString()}`,
+					);
+				}
+
+				if (telegram) {
+					await sendTelegramNotification(
+						telegram,
+						`<b>✅ Dokploy Server Restarted</b>\n\n<b>Date:</b> ${format(
+							date,
+							"PP",
+						)}\n<b>Time:</b> ${format(date, "pp")}`,
+					);
+				}
+
+				if (slack) {
+					const { channel } = slack;
+					await sendSlackNotification(slack, {
+						channel: channel,
+						attachments: [
+							{
+								color: "#00FF00",
+								pretext: ":white_check_mark: *Dokploy Server Restarted*",
+								fields: [
+									{
+										title: "Time",
+										value: date.toLocaleString(),
+										short: true,
+									},
+								],
+							},
+						],
+					});
+				}
+
+				if (custom) {
+					try {
+						await sendCustomNotification(custom, {
+							title: "Dokploy Server Restarted",
+							message: "Dokploy server has been restarted successfully",
+							timestamp: date.toISOString(),
+							date: date.toLocaleString(),
+							status: "success",
+							type: "dokploy-restart",
+						});
+					} catch (error) {
+						console.log(error);
+					}
+				}
+
+				if (lark) {
+					await sendLarkNotification(lark, {
+						msg_type: "interactive",
+						card: {
+							schema: "2.0",
+							config: {
+								update_multi: true,
+								style: {
+									text_size: {
+										normal_v2: {
+											default: "normal",
+											pc: "normal",
+											mobile: "heading",
+										},
 									},
 								},
 							},
-						},
-						header: {
-							title: {
-								tag: "plain_text",
-								content: "✅ Dokploy Server Restarted",
-							},
-							subtitle: {
-								tag: "plain_text",
-								content: "",
-							},
-							template: "green",
-							padding: "12px 12px 12px 12px",
-						},
-						body: {
-							direction: "vertical",
-							padding: "12px 12px 12px 12px",
-							elements: [
-								{
-									tag: "column_set",
-									columns: [
-										{
-											tag: "column",
-											width: "weighted",
-											elements: [
-												{
-													tag: "markdown",
-													content: "**Status:**\nSuccessful",
-													text_align: "left",
-													text_size: "normal_v2",
-												},
-											],
-											vertical_align: "top",
-											weight: 1,
-										},
-										{
-											tag: "column",
-											width: "weighted",
-											elements: [
-												{
-													tag: "markdown",
-													content: `**Restart Time:**\n${format(
-														date,
-														"PP pp",
-													)}`,
-													text_align: "left",
-													text_size: "normal_v2",
-												},
-											],
-											vertical_align: "top",
-											weight: 1,
-										},
-									],
+							header: {
+								title: {
+									tag: "plain_text",
+									content: "✅ Dokploy Server Restarted",
 								},
-							],
+								subtitle: {
+									tag: "plain_text",
+									content: "",
+								},
+								template: "green",
+								padding: "12px 12px 12px 12px",
+							},
+							body: {
+								direction: "vertical",
+								padding: "12px 12px 12px 12px",
+								elements: [
+									{
+										tag: "column_set",
+										columns: [
+											{
+												tag: "column",
+												width: "weighted",
+												elements: [
+													{
+														tag: "markdown",
+														content: "**Status:**\nSuccessful",
+														text_align: "left",
+														text_size: "normal_v2",
+													},
+												],
+												vertical_align: "top",
+												weight: 1,
+											},
+											{
+												tag: "column",
+												width: "weighted",
+												elements: [
+													{
+														tag: "markdown",
+														content: `**Restart Time:**\n${format(
+															date,
+															"PP pp",
+														)}`,
+														text_align: "left",
+														text_size: "normal_v2",
+													},
+												],
+												vertical_align: "top",
+												weight: 1,
+											},
+										],
+									},
+								],
+							},
 						},
-					},
-				});
-			}
+					});
+				}

-			if (pushover) {
-				await sendPushoverNotification(
-					pushover,
-					"Dokploy Server Restarted",
-					`Date: ${date.toLocaleString()}`,
-				);
+				if (pushover) {
+					await sendPushoverNotification(
+						pushover,
+						"Dokploy Server Restarted",
+						`Date: ${date.toLocaleString()}`,
+					);
+				}
+
+				if (teams) {
+					await sendTeamsNotification(teams, {
+						title: "✅ Dokploy Server Restarted",
+						facts: [
+							{ name: "Status", value: "Successful" },
+							{ name: "Restart Time", value: format(date, "PP pp") },
+						],
+					});
+				}
+			} catch (error) {
+				console.log(error);
 			}
-		} catch (error) {
-			console.log(error);
 		}
+	} catch (error) {
+		console.error("[Dokploy] Restart notifications failed:", error);
 	}
 };
--- a/packages/server/src/utils/notifications/server-threshold.ts
+++ b/packages/server/src/utils/notifications/server-threshold.ts
@@ -7,6 +7,7 @@ import {
 	sendLarkNotification,
 	sendPushoverNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -40,6 +41,7 @@ export const sendServerThresholdNotifications = async (
 			custom: true,
 			lark: true,
 			pushover: true,
+			teams: true,
 		},
 	});

@@ -47,7 +49,8 @@ export const sendServerThresholdNotifications = async (
 	const typeColor = 0xff0000; // Rojo para indicar alerta

 	for (const notification of notificationList) {
-		const { discord, telegram, slack, custom, lark, pushover } = notification;
+		const { discord, telegram, slack, custom, lark, pushover, teams } =
+			notification;

 		if (discord) {
 			const decorate = (decoration: string, text: string) =>
@@ -276,5 +279,19 @@ export const sendServerThresholdNotifications = async (
 				`Server: ${payload.ServerName}\nType: ${payload.Type}\nCurrent: ${payload.Value.toFixed(2)}%\nThreshold: ${payload.Threshold.toFixed(2)}%\nMessage: ${payload.Message}\nTime: ${date.toLocaleString()}`,
 			);
 		}
+
+		if (teams) {
+			await sendTeamsNotification(teams, {
+				title: `⚠️ Server ${payload.Type} Alert`,
+				facts: [
+					{ name: "Server Name", value: payload.ServerName },
+					{ name: "Type", value: payload.Type },
+					{ name: "Current Value", value: `${payload.Value.toFixed(2)}%` },
+					{ name: "Threshold", value: `${payload.Threshold.toFixed(2)}%` },
+					{ name: "Time", value: date.toLocaleString() },
+					{ name: "Message", value: payload.Message },
+				],
+			});
+		}
 	}
 };
--- a/packages/server/src/utils/notifications/utils.ts
+++ b/packages/server/src/utils/notifications/utils.ts
@@ -8,6 +8,7 @@ import type {
 	pushover,
 	resend,
 	slack,
+	teams,
 	telegram,
 } from "@dokploy/server/db/schema";
 import nodemailer from "nodemailer";
@@ -253,6 +254,84 @@ export const sendLarkNotification = async (
 	}
 };

+export interface TeamsAdaptiveCardMessage {
+	title: string;
+	themeColor?: string;
+	facts?: { name: string; value: string }[];
+	potentialAction?: { type: "Action.OpenUrl"; title: string; url: string };
+}
+
+export const sendTeamsNotification = async (
+	connection: typeof teams.$inferInsert,
+	message: TeamsAdaptiveCardMessage,
+) => {
+	try {
+		const bodyElements: Record<string, unknown>[] = [
+			{
+				type: "TextBlock",
+				text: message.title,
+				size: "Medium",
+				weight: "Bolder",
+				wrap: true,
+			},
+		];
+
+		if (message.facts && message.facts.length > 0) {
+			bodyElements.push({
+				type: "FactSet",
+				facts: message.facts.map((f) => ({
+					title: f.name,
+					value: f.value,
+				})),
+			});
+		}
+
+		const cardContent: Record<string, unknown> = {
+			type: "AdaptiveCard",
+			$schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+			version: "1.4",
+			body: bodyElements,
+		};
+
+		if (message.potentialAction) {
+			cardContent.actions = [
+				{
+					type: "Action.OpenUrl",
+					title: message.potentialAction.title,
+					url: message.potentialAction.url,
+				},
+			];
+		}
+
+		const payload = {
+			type: "message",
+			attachments: [
+				{
+					contentType: "application/vnd.microsoft.card.adaptive",
+					content: cardContent,
+				},
+			],
+		};
+
+		const response = await fetch(connection.webhookUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+		});
+
+		if (!response.ok) {
+			throw new Error(
+				`Failed to send Teams notification: ${response.statusText}`,
+			);
+		}
+	} catch (err) {
+		console.log(err);
+		throw new Error(
+			`Failed to send Teams notification ${err instanceof Error ? err.message : "Unknown error"}`,
+		);
+	}
+};
+
 export const sendPushoverNotification = async (
 	connection: typeof pushover.$inferInsert,
 	title: string,
--- a/packages/server/src/utils/notifications/volume-backup.ts
+++ b/packages/server/src/utils/notifications/volume-backup.ts
@@ -5,6 +5,7 @@ import { renderAsync } from "@react-email/components";
 import { format } from "date-fns";
 import { and, eq } from "drizzle-orm";
 import {
+	sendCustomNotification,
 	sendDiscordNotification,
 	sendEmailNotification,
 	sendGotifyNotification,
@@ -12,6 +13,7 @@ import {
 	sendPushoverNotification,
 	sendResendNotification,
 	sendSlackNotification,
+	sendTeamsNotification,
 	sendTelegramNotification,
 } from "./utils";

@@ -57,12 +59,24 @@ export const sendVolumeBackupNotifications = async ({
 			gotify: true,
 			ntfy: true,
 			pushover: true,
+			teams: true,
+			custom: true,
 		},
 	});

 	for (const notification of notificationList) {
-		const { email, resend, discord, telegram, slack, gotify, ntfy, pushover } =
-			notification;
+		const {
+			email,
+			resend,
+			discord,
+			telegram,
+			slack,
+			gotify,
+			ntfy,
+			pushover,
+			teams,
+			custom,
+		} = notification;

 		if (email || resend) {
 			const subject = `Volume Backup ${type === "success" ? "Successful" : "Failed"} - ${applicationName}`;
@@ -288,5 +302,49 @@ export const sendVolumeBackupNotifications = async ({
 				`Project: ${projectName}\nApplication: ${applicationName}\nVolume: ${volumeName}\nService Type: ${serviceType}${backupSize ? `\nBackup Size: ${backupSize}` : ""}\nDate: ${date.toLocaleString()}${type === "error" && errorMessage ? `\nError: ${errorMessage}` : ""}`,
 			);
 		}
+
+		if (teams) {
+			const facts = [
+				{ name: "Project", value: projectName },
+				{ name: "Application", value: applicationName },
+				{ name: "Volume Name", value: volumeName },
+				{ name: "Service Type", value: serviceType },
+				{ name: "Date", value: format(date, "PP pp") },
+				{ name: "Status", value: type === "success" ? "Successful" : "Failed" },
+			];
+			if (backupSize) {
+				facts.push({ name: "Backup Size", value: backupSize });
+			}
+			if (type === "error" && errorMessage) {
+				facts.push({ name: "Error", value: errorMessage.substring(0, 500) });
+			}
+			await sendTeamsNotification(teams, {
+				title:
+					type === "success"
+						? "✅ Volume Backup Successful"
+						: "❌ Volume Backup Failed",
+				facts,
+			});
+		}
+
+		if (custom) {
+			await sendCustomNotification(custom, {
+				title: `Volume Backup ${type === "success" ? "Successful" : "Failed"}`,
+				message:
+					type === "success"
+						? "Volume backup completed successfully"
+						: "Volume backup failed",
+				projectName,
+				applicationName,
+				volumeName,
+				serviceType,
+				type,
+				errorMessage: errorMessage ?? "",
+				backupSize: backupSize ?? "",
+				timestamp: date.toISOString(),
+				date: date.toLocaleString(),
+				status: type,
+			});
+		}
 	}
 };
--- a/packages/server/src/utils/providers/bitbucket.ts
+++ b/packages/server/src/utils/providers/bitbucket.ts
@@ -10,6 +10,7 @@ import {
 } from "@dokploy/server/services/bitbucket";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
+import type { z } from "zod";

 export type ApplicationWithBitbucket = InferResultType<
 	"applications",
@@ -86,6 +87,7 @@ interface CloneBitbucketRepository {
 	enableSubmodules: boolean;
 	serverId: string | null;
 	type?: "application" | "compose";
+	outputPathOverride?: string;
 }

 export const cloneBitbucketRepository = async ({
@@ -101,6 +103,7 @@ export const cloneBitbucketRepository = async ({
 		bitbucketId,
 		enableSubmodules,
 		serverId,
+		outputPathOverride,
 	} = entity;
 	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);

@@ -115,7 +118,7 @@ export const cloneBitbucketRepository = async ({
 		return command;
 	}
 	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	command += `rm -rf ${outputPath};`;
 	command += `mkdir -p ${outputPath};`;
 	const repoToUse = entity.bitbucketRepositorySlug || bitbucketRepository;
@@ -177,7 +180,7 @@ export const getBitbucketRepositories = async (bitbucketId?: string) => {
 };

 export const getBitbucketBranches = async (
-	input: typeof apiFindBitbucketBranches._type,
+	input: z.infer<typeof apiFindBitbucketBranches>,
 ) => {
 	if (!input.bitbucketId) {
 		return [];
@@ -232,7 +235,7 @@ export const getBitbucketBranches = async (
 };

 export const testBitbucketConnection = async (
-	input: typeof apiBitbucketTestConnection._type,
+	input: z.infer<typeof apiBitbucketTestConnection>,
 ) => {
 	const bitbucketProvider = await findBitbucketById(input.bitbucketId);

--- a/packages/server/src/utils/providers/git.ts
+++ b/packages/server/src/utils/providers/git.ts
@@ -14,6 +14,7 @@ interface CloneGitRepository {
 	enableSubmodules?: boolean;
 	serverId: string | null;
 	type?: "application" | "compose";
+	outputPathOverride?: string;
 }

 export const cloneGitRepository = async ({
@@ -28,6 +29,7 @@ export const cloneGitRepository = async ({
 		customGitSSHKeyId,
 		enableSubmodules,
 		serverId,
+		outputPathOverride,
 	} = entity;
 	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);

@@ -47,7 +49,7 @@ export const cloneGitRepository = async ({
 			`;
 	}
 	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");

 	if (!isHttpOrHttps(customGitUrl)) {
--- a/packages/server/src/utils/providers/gitea.ts
+++ b/packages/server/src/utils/providers/gitea.ts
@@ -130,6 +130,7 @@ interface CloneGiteaRepository {
 	enableSubmodules: boolean;
 	serverId: string | null;
 	type?: "application" | "compose";
+	outputPathOverride?: string;
 }

 export const cloneGiteaRepository = async ({
@@ -145,6 +146,7 @@ export const cloneGiteaRepository = async ({
 		giteaRepository,
 		enableSubmodules,
 		serverId,
+		outputPathOverride,
 	} = entity;
 	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);

@@ -162,7 +164,7 @@ export const cloneGiteaRepository = async ({
 	}

 	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	command += `rm -rf ${outputPath};`;
 	command += `mkdir -p ${outputPath};`;

--- a/packages/server/src/utils/providers/github.ts
+++ b/packages/server/src/utils/providers/github.ts
@@ -5,6 +5,7 @@ import { findGithubById, type Github } from "@dokploy/server/services/github";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { createAppAuth } from "@octokit/auth-app";
 import { TRPCError } from "@trpc/server";
+import type { z } from "zod";
 import { Octokit } from "octokit";

 export const authGithub = (githubProvider: Github): Octokit => {
@@ -121,6 +122,7 @@ interface CloneGithubRepository {
 	type?: "application" | "compose";
 	enableSubmodules: boolean;
 	serverId: string | null;
+	outputPathOverride?: string;
 }
 export const cloneGithubRepository = async ({
 	type = "application",
@@ -136,6 +138,7 @@ export const cloneGithubRepository = async ({
 		githubId,
 		enableSubmodules,
 		serverId,
+		outputPathOverride,
 	} = entity;
 	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);

@@ -155,7 +158,7 @@ export const cloneGithubRepository = async ({

 	const githubProvider = await findGithubById(githubId);
 	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	const octokit = authGithub(githubProvider);
 	const token = await getGithubToken(octokit);
 	const repoclone = `github.com/${owner}/${repository}.git`;
@@ -195,7 +198,7 @@ export const getGithubRepositories = async (githubId?: string) => {
 };

 export const getGithubBranches = async (
-	input: typeof apiFindGithubBranches._type,
+	input: z.infer<typeof apiFindGithubBranches>,
 ) => {
 	if (!input.githubId) {
 		return [];
--- a/packages/server/src/utils/providers/gitlab.ts
+++ b/packages/server/src/utils/providers/gitlab.ts
@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { apiGitlabTestConnection } from "@dokploy/server/db/schema";
+import type { z } from "zod";
 import {
 	findGitlabById,
 	type Gitlab,
@@ -107,6 +108,7 @@ interface CloneGitlabRepository {
 	enableSubmodules: boolean;
 	serverId: string | null;
 	type?: "application" | "compose";
+	outputPathOverride?: string;
 }

 export const cloneGitlabRepository = async ({
@@ -121,6 +123,7 @@ export const cloneGitlabRepository = async ({
 		gitlabPathNamespace,
 		enableSubmodules,
 		serverId,
+		outputPathOverride,
 	} = entity;
 	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);

@@ -141,7 +144,7 @@ export const cloneGitlabRepository = async ({
 	}

 	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
+	const outputPath = outputPathOverride ?? join(basePath, appName, "code");
 	command += `rm -rf ${outputPath};`;
 	command += `mkdir -p ${outputPath};`;
 	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
@@ -169,7 +172,7 @@ export const getGitlabRepositories = async (gitlabId?: string) => {
 		if (groupName) {
 			return groupName
 				.split(",")
-				.some((name) =>
+				.some((name: string) =>
 					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
 				);
 		}
@@ -254,7 +257,7 @@ export const getGitlabBranches = async (input: {
 };

 export const testGitlabConnection = async (
-	input: typeof apiGitlabTestConnection._type,
+	input: z.infer<typeof apiGitlabTestConnection>,
 ) => {
 	const { gitlabId, groupName } = input;

@@ -274,7 +277,7 @@ export const testGitlabConnection = async (
 		if (groupName) {
 			return groupName
 				.split(",")
-				.some((name) =>
+				.some((name: string) =>
 					full_path.toLowerCase().startsWith(name.trim().toLowerCase()),
 				);
 		}
--- a/packages/server/src/wss/utils.ts
+++ b/packages/server/src/wss/utils.ts
@@ -1,4 +1,6 @@
 import os from "node:os";
+import path from "node:path";
+import { paths } from "@dokploy/server/constants";
 import { publicIpv4, publicIpv6 } from "public-ip";

 export const getShell = () => {
@@ -33,3 +35,18 @@ export const getPublicIpWithFallback = async () => {
 	}
 	return ip;
 };
+
+export const readValidDirectory = (
+	directory: string,
+	serverId?: string | null,
+) => {
+	const { BASE_PATH } = paths(!!serverId);
+
+	const resolvedBase = path.resolve(BASE_PATH);
+	const resolvedDir = path.resolve(directory);
+
+	return (
+		resolvedDir === resolvedBase ||
+		resolvedDir.startsWith(resolvedBase + path.sep)
+	);
+};
--- a/packages/server/tsconfig.json
+++ b/packages/server/tsconfig.json
@@ -34,6 +34,7 @@
 		"dokploy",
 		"config",
 		"dist",
+		".next",
 		"webpack.config.server.js",
 		"migration.ts",
 		"setup.ts"
--- a/packages/server/tsconfig.server.no-decl.json
+++ b/packages/server/tsconfig.server.no-decl.json
@@ -0,0 +1,7 @@
+{
+	"extends": "./tsconfig.server.json",
+	"compilerOptions": {
+		"declaration": false,
+		"declarationMap": false
+	}
+}