feat(gitea): add Gitea repository support

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

@@ -13,9 +13,9 @@ import { z } from "zod";
 import { bitbucket } from "./bitbucket";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
+import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
-import { gitea } from "./gitea";
 import { mounts } from "./mount";
 import { ports } from "./port";
 import { previewDeployments } from "./preview-deployments";
@@ -395,7 +395,9 @@ const createSchema = createInsertSchema(applications, {
 	customGitUrl: z.string().optional(),
 	buildPath: z.string().optional(),
 	projectId: z.string(),
-	sourceType: z.enum(["github", "docker", "git", "gitlab", "bitbucket", "gitea", "drop"]).optional(),
+	sourceType: z
+		.enum(["github", "docker", "git", "gitlab", "bitbucket", "gitea", "drop"])
+		.optional(),
 	applicationStatus: z.enum(["idle", "running", "done", "error"]),
 	buildType: z.enum([
 		"dockerfile",
@@ -556,4 +558,4 @@ export const apiUpdateApplication = createSchema
 	.extend({
 		applicationId: z.string().min(1),
 	})
-	.omit({ serverId: true });
+	.omit({ serverId: true });

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

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { bitbucket } from "./bitbucket";
 import { deployments } from "./deployment";
 import { domains } from "./domain";
+import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
@@ -14,7 +15,6 @@ import { server } from "./server";
 import { applicationStatus } from "./shared";
 import { sshKeys } from "./ssh-key";
 import { generateAppName } from "./utils";
-import { gitea } from "./gitea";
 
 export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
 	"git",
@@ -58,9 +58,9 @@ export const compose = pgTable("compose", {
 	bitbucketOwner: text("bitbucketOwner"),
 	bitbucketBranch: text("bitbucketBranch"),
 	// Gitea
-    giteaRepository: text("giteaRepository"),
-    giteaOwner: text("giteaOwner"),
-    giteaBranch: text("giteaBranch"),
+	giteaRepository: text("giteaRepository"),
+	giteaOwner: text("giteaOwner"),
+	giteaBranch: text("giteaBranch"),
 	// Git
 	customGitUrl: text("customGitUrl"),
 	customGitBranch: text("customGitBranch"),
@@ -94,8 +94,8 @@ export const compose = pgTable("compose", {
 		onDelete: "set null",
 	}),
 	giteaId: text("giteaId").references(() => gitea.giteaId, {
-        onDelete: "set null",
-    }),
+		onDelete: "set null",
+	}),
 	serverId: text("serverId").references(() => server.serverId, {
 		onDelete: "cascade",
 	}),
@@ -126,9 +126,9 @@ export const composeRelations = relations(compose, ({ one, many }) => ({
 		references: [bitbucket.bitbucketId],
 	}),
 	gitea: one(gitea, {
-        fields: [compose.giteaId],
-        references: [gitea.giteaId],
-    }),
+		fields: [compose.giteaId],
+		references: [gitea.giteaId],
+	}),
 	server: one(server, {
 		fields: [compose.serverId],
 		references: [server.serverId],

packages/server/src/db/schema/git-provider.ts

@@ -5,9 +5,9 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 import { organization } from "./account";
 import { bitbucket } from "./bitbucket";
+import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
-import { gitea } from "./gitea";
 
 export const gitProviderType = pgEnum("gitProviderType", [
 	"github",

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

@@ -7,31 +7,31 @@ import { gitProvider } from "./git-provider";
 
 // Gitea table definition
 export const gitea = pgTable("gitea", {
-  giteaId: text("giteaId")
-    .notNull()
-    .primaryKey()
-    .$defaultFn(() => nanoid()), // Using nanoid for unique ID
-  giteaUrl: text("giteaUrl").default("https://gitea.com").notNull(), // Default URL for Gitea
-  redirectUri: text("redirect_uri"),
-  clientId: text("client_id"),
-  clientSecret: text("client_secret"),
-  gitProviderId: text("gitProviderId")
-    .notNull()
-    .references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
-  giteaUsername: text("gitea_username"),
-  accessToken: text("access_token"),
-  refreshToken: text("refresh_token"),
-  expiresAt: integer("expires_at"),
-  scopes: text("scopes").default('repo,repo:status,read:user,read:org'),
-  lastAuthenticatedAt: integer("last_authenticated_at"),
+	giteaId: text("giteaId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()), // Using nanoid for unique ID
+	giteaUrl: text("giteaUrl").default("https://gitea.com").notNull(), // Default URL for Gitea
+	redirectUri: text("redirect_uri"),
+	clientId: text("client_id"),
+	clientSecret: text("client_secret"),
+	gitProviderId: text("gitProviderId")
+		.notNull()
+		.references(() => gitProvider.gitProviderId, { onDelete: "cascade" }),
+	giteaUsername: text("gitea_username"),
+	accessToken: text("access_token"),
+	refreshToken: text("refresh_token"),
+	expiresAt: integer("expires_at"),
+	scopes: text("scopes").default("repo,repo:status,read:user,read:org"),
+	lastAuthenticatedAt: integer("last_authenticated_at"),
 });
 
 // Gitea relations with gitProvider
 export const giteaProviderRelations = relations(gitea, ({ one }) => ({
-  gitProvider: one(gitProvider, {
-    fields: [gitea.gitProviderId],
-    references: [gitProvider.gitProviderId],
-  }),
+	gitProvider: one(gitProvider, {
+		fields: [gitea.gitProviderId],
+		references: [gitProvider.gitProviderId],
+	}),
 }));
 
 // Create schema for Gitea
@@ -39,58 +39,58 @@ const createSchema = createInsertSchema(gitea);
 
 // API schema for creating a Gitea instance
 export const apiCreateGitea = createSchema.extend({
-  clientId: z.string().optional(),
-  clientSecret: z.string().optional(),
-  gitProviderId: z.string().optional(),
-  redirectUri: z.string().optional(),
-  name: z.string().min(1),
-  giteaUrl: z.string().min(1),
-  giteaUsername: z.string().optional(),
-  accessToken: z.string().optional(),
-  refreshToken: z.string().optional(),
-  expiresAt: z.number().optional(),
-  organizationName: z.string().optional(),
-  scopes: z.string().optional(),
-  lastAuthenticatedAt: z.number().optional(),
+	clientId: z.string().optional(),
+	clientSecret: z.string().optional(),
+	gitProviderId: z.string().optional(),
+	redirectUri: z.string().optional(),
+	name: z.string().min(1),
+	giteaUrl: z.string().min(1),
+	giteaUsername: z.string().optional(),
+	accessToken: z.string().optional(),
+	refreshToken: z.string().optional(),
+	expiresAt: z.number().optional(),
+	organizationName: z.string().optional(),
+	scopes: z.string().optional(),
+	lastAuthenticatedAt: z.number().optional(),
 });
 
 // API schema for finding one Gitea instance
 export const apiFindOneGitea = createSchema
-  .extend({
-    giteaId: z.string().min(1),
-  })
-  .pick({ giteaId: true });
+	.extend({
+		giteaId: z.string().min(1),
+	})
+	.pick({ giteaId: true });
 
 // API schema for testing Gitea connection
 export const apiGiteaTestConnection = createSchema
-  .extend({
-    organizationName: z.string().optional(),
-  })
-  .pick({ giteaId: true, organizationName: true });
+	.extend({
+		organizationName: z.string().optional(),
+	})
+	.pick({ giteaId: true, organizationName: true });
 
 export type ApiGiteaTestConnection = z.infer<typeof apiGiteaTestConnection>;
 
 // API schema for finding branches in Gitea
 export const apiFindGiteaBranches = z.object({
-  id: z.number().optional(),
-  owner: z.string().min(1),
-  repositoryName: z.string().min(1),
-  giteaId: z.string().optional(),
+	id: z.number().optional(),
+	owner: z.string().min(1),
+	repositoryName: z.string().min(1),
+	giteaId: z.string().optional(),
 });
 
 // API schema for updating Gitea instance
 export const apiUpdateGitea = createSchema.extend({
-  clientId: z.string().optional(),
-  clientSecret: z.string().optional(),
-  redirectUri: z.string().optional(),
-  name: z.string().min(1),
-  giteaId: z.string().min(1),
-  giteaUrl: z.string().min(1),
-  giteaUsername: z.string().optional(),
-  accessToken: z.string().optional(),
-  refreshToken: z.string().optional(),
-  expiresAt: z.number().optional(),
-  organizationName: z.string().optional(),
-  scopes: z.string().optional(),
-  lastAuthenticatedAt: z.number().optional(),
-});
+	clientId: z.string().optional(),
+	clientSecret: z.string().optional(),
+	redirectUri: z.string().optional(),
+	name: z.string().min(1),
+	giteaId: z.string().min(1),
+	giteaUrl: z.string().min(1),
+	giteaUsername: z.string().optional(),
+	accessToken: z.string().optional(),
+	refreshToken: z.string().optional(),
+	expiresAt: z.number().optional(),
+	organizationName: z.string().optional(),
+	scopes: z.string().optional(),
+	lastAuthenticatedAt: z.number().optional(),
+});

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

@@ -10,7 +10,7 @@ import {
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-import { account, organization, apikey } from "./account";
+import { account, apikey, organization } from "./account";
 import { projects } from "./project";
 import { certificateType } from "./shared";
 /**

packages/server/src/lib/auth.ts

@@ -2,12 +2,12 @@ import type { IncomingMessage } from "node:http";
 import * as bcrypt from "bcrypt";
 import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { organization, twoFactor, apiKey } from "better-auth/plugins";
+import { apiKey, organization, twoFactor } from "better-auth/plugins";
 import { and, desc, eq } from "drizzle-orm";
+import { IS_CLOUD } from "../constants";
 import { db } from "../db";
 import * as schema from "../db/schema";
 import { sendEmail } from "../verification/send-verification-email";
-import { IS_CLOUD } from "../constants";
 
 const { handler, api } = betterAuth({
 	database: drizzleAdapter(db, {

packages/server/src/services/ai.ts

@@ -6,8 +6,8 @@ import { generateObject } from "ai";
 import { desc, eq } from "drizzle-orm";
 import { z } from "zod";
 import { IS_CLOUD } from "../constants";
-import { findServerById } from "./server";
 import { findOrganizationById } from "./admin";
+import { findServerById } from "./server";
 
 export const getAiSettingsByOrganizationId = async (organizationId: string) => {
 	const aiSettings = await db.query.ai.findMany({

packages/server/src/services/application.ts

@@ -26,6 +26,10 @@ import {
 	cloneGitRepository,
 	getCustomGitCloneCommand,
 } from "@dokploy/server/utils/providers/git";
+import {
+	cloneGiteaRepository,
+	getGiteaCloneCommand,
+} from "@dokploy/server/utils/providers/gitea";
 import {
 	cloneGithubRepository,
 	getGithubCloneCommand,
@@ -34,10 +38,6 @@ import {
 	cloneGitlabRepository,
 	getGitlabCloneCommand,
 } from "@dokploy/server/utils/providers/gitlab";
-import {
-	cloneGiteaRepository,
-	getGiteaCloneCommand,
-} from "@dokploy/server/utils/providers/gitea";
 import { createTraefikConfig } from "@dokploy/server/utils/traefik/application";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
@@ -318,10 +318,7 @@ export const deployRemoteApplication = async ({
 					deployment.logPath,
 				);
 			} else if (application.sourceType === "gitea") {
-				command += await getGiteaCloneCommand(
-					application,
-					deployment.logPath,
-				);
+				command += await getGiteaCloneCommand(application, deployment.logPath);
 			} else if (application.sourceType === "git") {
 				command += await getCustomGitCloneCommand(
 					application,

packages/server/src/services/compose.ts

@@ -29,6 +29,10 @@ import {
 	cloneGitRepository,
 	getCustomGitCloneCommand,
 } from "@dokploy/server/utils/providers/git";
+import {
+	cloneGiteaRepository,
+	getGiteaCloneCommand,
+} from "@dokploy/server/utils/providers/gitea";
 import {
 	cloneGithubRepository,
 	getGithubCloneCommand,
@@ -37,10 +41,6 @@ import {
 	cloneGitlabRepository,
 	getGitlabCloneCommand,
 } from "@dokploy/server/utils/providers/gitlab";
-import {
-	cloneGiteaRepository,
-	getGiteaCloneCommand,
-} from "@dokploy/server/utils/providers/gitea";
 import {
 	createComposeFile,
 	getCreateComposeFileCommand,
@@ -237,7 +237,7 @@ export const deployCompose = async ({
 			await cloneGiteaRepository(compose, deployment.logPath, true);
 		} else if (compose.sourceType === "raw") {
 			await createComposeFile(compose, deployment.logPath);
-		} 
+		}
 		await buildCompose(compose, deployment.logPath);
 		await updateDeploymentStatus(deployment.deploymentId, "done");
 		await updateCompose(composeId, {
@@ -360,9 +360,9 @@ export const deployRemoteCompose = async ({
 				command += getCreateComposeFileCommand(compose, deployment.logPath);
 			} else if (compose.sourceType === "gitea") {
 				command += await getGiteaCloneCommand(
-				  compose,
-				  deployment.logPath,
-				  true
+					compose,
+					deployment.logPath,
+					true,
 				);
 			}
 

packages/server/src/services/gitea.ts

@@ -1,104 +1,100 @@
 import { db } from "@dokploy/server/db";
 import {
-  type apiCreateGitea,
-  gitProvider,
-  gitea,
+	type apiCreateGitea,
+	gitProvider,
+	gitea,
 } from "@dokploy/server/db/schema";
 import { TRPCError } from "@trpc/server";
 import { eq } from "drizzle-orm";
 export type Gitea = typeof gitea.$inferSelect;
 
 export const createGitea = async (
-  input: typeof apiCreateGitea._type,
-  organizationId: string,
+	input: typeof apiCreateGitea._type,
+	organizationId: string,
 ) => {
-  return await db.transaction(async (tx) => {
-    // Insert new Git provider (Gitea)
-    const newGitProvider = await tx
-      .insert(gitProvider)
-      .values({
-        providerType: "gitea", // Set providerType to 'gitea'
-        organizationId: organizationId,
-        name: input.name,
-      })
-      .returning()
-      .then((response) => response[0]);
+	return await db.transaction(async (tx) => {
+		// Insert new Git provider (Gitea)
+		const newGitProvider = await tx
+			.insert(gitProvider)
+			.values({
+				providerType: "gitea", // Set providerType to 'gitea'
+				organizationId: organizationId,
+				name: input.name,
+			})
+			.returning()
+			.then((response) => response[0]);
 
-    if (!newGitProvider) {
-      throw new TRPCError({
-        code: "BAD_REQUEST",
-        message: "Error creating the Git provider",
-      });
-    }
+		if (!newGitProvider) {
+			throw new TRPCError({
+				code: "BAD_REQUEST",
+				message: "Error creating the Git provider",
+			});
+		}
 
-    // Insert the Gitea data into the `gitea` table
-    await tx
-      .insert(gitea)
-      .values({
-        ...input,
-        gitProviderId: newGitProvider?.gitProviderId,
-      })
-      .returning()
-      .then((response) => response[0]);
-  });
+		// Insert the Gitea data into the `gitea` table
+		await tx
+			.insert(gitea)
+			.values({
+				...input,
+				gitProviderId: newGitProvider?.gitProviderId,
+			})
+			.returning()
+			.then((response) => response[0]);
+	});
 };
 
 export const findGiteaById = async (giteaId: string) => {
-  try {
-  
-    const giteaProviderResult = await db.query.gitea.findFirst({
-      where: eq(gitea.giteaId, giteaId),
-      with: {
-        gitProvider: true,
-      },
-    });
-  
-    if (!giteaProviderResult) {
-      console.error('No Gitea Provider found:', { giteaId });
-      throw new TRPCError({
-        code: "NOT_FOUND",
-        message: "Gitea Provider not found",
-      });
-    }
-  
-    return giteaProviderResult;
-  } catch (error) {
-    console.error('Error finding Gitea Provider:', error);
-    throw error;
-  }
+	try {
+		const giteaProviderResult = await db.query.gitea.findFirst({
+			where: eq(gitea.giteaId, giteaId),
+			with: {
+				gitProvider: true,
+			},
+		});
+
+		if (!giteaProviderResult) {
+			console.error("No Gitea Provider found:", { giteaId });
+			throw new TRPCError({
+				code: "NOT_FOUND",
+				message: "Gitea Provider not found",
+			});
+		}
+
+		return giteaProviderResult;
+	} catch (error) {
+		console.error("Error finding Gitea Provider:", error);
+		throw error;
+	}
 };
 
-export const updateGitea = async (
-    giteaId: string,
-    input: Partial<Gitea>,
-) => {
-    console.log('Updating Gitea Provider:', {
-        giteaId,
-        updateData: {
-            accessTokenPresent: !!input.accessToken,
-            refreshTokenPresent: !!input.refreshToken,
-            expiresAt: input.expiresAt,
-        }
-    });
+export const updateGitea = async (giteaId: string, input: Partial<Gitea>) => {
+	console.log("Updating Gitea Provider:", {
+		giteaId,
+		updateData: {
+			accessTokenPresent: !!input.accessToken,
+			refreshTokenPresent: !!input.refreshToken,
+			expiresAt: input.expiresAt,
+		},
+	});
 
-    try {
-        const updateResult = await db
-            .update(gitea)
-            .set(input)
-            .where(eq(gitea.giteaId, giteaId))
-            .returning();
+	try {
+		const updateResult = await db
+			.update(gitea)
+			.set(input)
+			.where(eq(gitea.giteaId, giteaId))
+			.returning();
 
-        // Explicitly type the result and handle potential undefined
-        const result = updateResult[0] as Gitea | undefined;
+		// Explicitly type the result and handle potential undefined
+		const result = updateResult[0] as Gitea | undefined;
 
-        if (!result) {
-            console.error('No rows were updated', { giteaId, input });
-            throw new Error(`Failed to update Gitea provider with ID ${giteaId}`);
-        }
+		if (!result) {
+			console.error("No rows were updated", { giteaId, input });
+			throw new Error(`Failed to update Gitea provider with ID ${giteaId}`);
+		}
 
-        return result;
-    } catch (error) {
-        console.error('Error updating Gitea provider:', error);
-        throw error;
-    }
-};
+		return result;
+	} catch (error) {
+		console.error("Error updating Gitea provider:", error);
+		throw error;
+	}
+};

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

@@ -6,10 +6,10 @@ import {
 } from "@dokploy/server/services/deployment";
 import { findServerById } from "@dokploy/server/services/server";
 import {
+	TRAEFIK_HTTP3_PORT,
 	TRAEFIK_PORT,
 	TRAEFIK_SSL_PORT,
 	TRAEFIK_VERSION,
-	TRAEFIK_HTTP3_PORT,
 	getDefaultMiddlewares,
 	getDefaultServerTraefikConfig,
 } from "@dokploy/server/setup/traefik-setup";

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

@@ -1,8 +1,8 @@
 import { paths } from "@dokploy/server/constants";
-import { execAsync } from "../process/execAsync";
 import { findAdmin } from "@dokploy/server/services/admin";
 import { updateUser } from "@dokploy/server/services/user";
 import { scheduleJob, scheduledJobs } from "node-schedule";
+import { execAsync } from "../process/execAsync";
 
 const LOG_CLEANUP_JOB_NAME = "access-log-cleanup";
 

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

@@ -2,19 +2,19 @@ import path from "node:path";
 import { getAllServers } from "@dokploy/server/services/server";
 import { scheduleJob } from "node-schedule";
 import { db } from "../../db/index";
+import { findAdmin } from "../../services/admin";
 import {
 	cleanUpDockerBuilder,
 	cleanUpSystemPrune,
 	cleanUpUnusedImages,
 } from "../docker/utils";
 import { sendDockerCleanupNotifications } from "../notifications/docker-cleanup";
+import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { runMariadbBackup } from "./mariadb";
 import { runMongoBackup } from "./mongo";
 import { runMySqlBackup } from "./mysql";
 import { runPostgresBackup } from "./postgres";
-import { findAdmin } from "../../services/admin";
 import { getS3Credentials } from "./utils";
-import { execAsync, execAsyncRemote } from "../process/execAsync";
 
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import { startLogCleanup } from "../access-log/handler";

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

@@ -1,11 +1,11 @@
 import type { BackupSchedule } from "@dokploy/server/services/backup";
 import type { Destination } from "@dokploy/server/services/destination";
 import { scheduleJob, scheduledJobs } from "node-schedule";
+import { keepLatestNBackups } from ".";
 import { runMariadbBackup } from "./mariadb";
 import { runMongoBackup } from "./mongo";
 import { runMySqlBackup } from "./mysql";
 import { runPostgresBackup } from "./postgres";
-import { keepLatestNBackups } from ".";
 
 export const scheduleBackup = (backup: BackupSchedule) => {
 	const { schedule, backupId, databaseType, postgres, mysql, mongo, mariadb } =

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

@@ -112,118 +112,120 @@ export const getBuildCommand = (
 
 export const mechanizeDockerContainer = async (
 	application: ApplicationNested,
-  ) => {
-	console.log(`Starting to mechanize Docker container for ${application.appName}`);
-	
+) => {
+	console.log(
+		`Starting to mechanize Docker container for ${application.appName}`,
+	);
+
 	const {
-	  appName,
-	  env,
-	  mounts,
-	  cpuLimit,
-	  memoryLimit,
-	  memoryReservation,
-	  cpuReservation,
-	  command,
-	  ports,
+		appName,
+		env,
+		mounts,
+		cpuLimit,
+		memoryLimit,
+		memoryReservation,
+		cpuReservation,
+		command,
+		ports,
 	} = application;
-  
+
 	const resources = calculateResources({
-	  memoryLimit,
-	  memoryReservation,
-	  cpuLimit,
-	  cpuReservation,
+		memoryLimit,
+		memoryReservation,
+		cpuLimit,
+		cpuReservation,
 	});
-  
+
 	const volumesMount = generateVolumeMounts(mounts);
-  
+
 	const {
-	  HealthCheck,
-	  RestartPolicy,
-	  Placement,
-	  Labels,
-	  Mode,
-	  RollbackConfig,
-	  UpdateConfig,
-	  Networks,
+		HealthCheck,
+		RestartPolicy,
+		Placement,
+		Labels,
+		Mode,
+		RollbackConfig,
+		UpdateConfig,
+		Networks,
 	} = generateConfigContainer(application);
-  
+
 	const bindsMount = generateBindMounts(mounts);
 	const filesMount = generateFileMounts(appName, application);
 	const envVariables = prepareEnvironmentVariables(
-	  env,
-	  application.project.env,
+		env,
+		application.project.env,
 	);
-  
+
 	const image = getImageName(application);
 	const authConfig = getAuthConfig(application);
 	const docker = await getRemoteDocker(application.serverId);
-  
+
 	const settings: CreateServiceOptions = {
-	  authconfig: authConfig,
-	  Name: appName,
-	  TaskTemplate: {
-		ContainerSpec: {
-		  HealthCheck,
-		  Image: image,
-		  Env: envVariables,
-		  Mounts: [...volumesMount, ...bindsMount, ...filesMount],
-		  ...(command
-			? {
-				Command: ["/bin/sh"],
-				Args: ["-c", command],
-			  }
-			: {}),
-		  Labels,
-		},
-		Networks,
-		RestartPolicy,
-		Placement,
-		Resources: {
-		  ...resources,
-		},
-	  },
-	  Mode,
-	  RollbackConfig,
-	  EndpointSpec: {
-		Ports: ports.map((port) => ({
-		  Protocol: port.protocol,
-		  TargetPort: port.targetPort,
-		  PublishedPort: port.publishedPort,
-		})),
-	  },
-	  UpdateConfig,
-	};
-  
-	try {
-	  console.log(`Attempting to find existing service: ${appName}`);
-	  const service = docker.getService(appName);
-	  const inspect = await service.inspect();
-	  console.log(`Found existing service, updating: ${appName}`);
-	  
-	  await service.update({
-		version: Number.parseInt(inspect.Version.Index),
-		...settings,
+		authconfig: authConfig,
+		Name: appName,
 		TaskTemplate: {
-		  ...settings.TaskTemplate,
-		  ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
+			ContainerSpec: {
+				HealthCheck,
+				Image: image,
+				Env: envVariables,
+				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
+				...(command
+					? {
+							Command: ["/bin/sh"],
+							Args: ["-c", command],
+						}
+					: {}),
+				Labels,
+			},
+			Networks,
+			RestartPolicy,
+			Placement,
+			Resources: {
+				...resources,
+			},
 		},
-	  });
-	  console.log(`Service updated successfully: ${appName}`);
+		Mode,
+		RollbackConfig,
+		EndpointSpec: {
+			Ports: ports.map((port) => ({
+				Protocol: port.protocol,
+				TargetPort: port.targetPort,
+				PublishedPort: port.publishedPort,
+			})),
+		},
+		UpdateConfig,
+	};
+
+	try {
+		console.log(`Attempting to find existing service: ${appName}`);
+		const service = docker.getService(appName);
+		const inspect = await service.inspect();
+		console.log(`Found existing service, updating: ${appName}`);
+
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+			TaskTemplate: {
+				...settings.TaskTemplate,
+				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
+			},
+		});
+		console.log(`Service updated successfully: ${appName}`);
 	} catch (error: unknown) {
-	  const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-	  console.log(`Service not found or error: ${errorMessage}`);
-	  console.log(`Creating new service: ${appName}`);
-	  
-	  try {
-		await docker.createService(settings);
-		console.log(`Service created successfully: ${appName}`);
-	  } catch (createError: unknown) {
-		const createErrorMessage = createError instanceof Error 
-		  ? createError.message 
-		  : 'Unknown error';
-		console.error(`Failed to create service: ${createErrorMessage}`);
-		throw createError;
-	  }
+		const errorMessage =
+			error instanceof Error ? error.message : "Unknown error";
+		console.log(`Service not found or error: ${errorMessage}`);
+		console.log(`Creating new service: ${appName}`);
+
+		try {
+			await docker.createService(settings);
+			console.log(`Service created successfully: ${appName}`);
+		} catch (createError: unknown) {
+			const createErrorMessage =
+				createError instanceof Error ? createError.message : "Unknown error";
+			console.error(`Failed to create service: ${createErrorMessage}`);
+			throw createError;
+		}
 	}
 };
 

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

@@ -39,7 +39,7 @@ export const buildNixpacks = async (
 		for (const env of envVariables) {
 			args.push("--env", env);
 		}
-		
+
 		if (publishDirectory) {
 			/* No need for any start command, since we'll use nginx later on */
 			args.push("--no-error-without-start");
@@ -90,10 +90,11 @@ export const buildNixpacks = async (
 			await spawnAsync("docker", ["rm", buildContainerId], writeToStream);
 		} catch (rmError) {
 			// Ignore errors from container removal
-			const errorMessage = rmError instanceof Error 
-			? rmError.message 
-			: 'Unknown container cleanup error';
-		  
+			const errorMessage =
+				rmError instanceof Error
+					? rmError.message
+					: "Unknown container cleanup error";
+
 			// Just log it but don't let it cause another error
 			writeToStream(`Container cleanup attempt: ${errorMessage}\n`);
 		}

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

@@ -1,11 +1,11 @@
+import { createHash } from "node:crypto";
 import type { WriteStream } from "node:fs";
+import { nanoid } from "nanoid";
 import type { ApplicationNested } from ".";
 import { prepareEnvironmentVariables } from "../docker/utils";
 import { getBuildAppDirectory } from "../filesystem/directory";
-import { spawnAsync } from "../process/spawnAsync";
 import { execAsync } from "../process/execAsync";
-import { nanoid } from "nanoid";
-import { createHash } from "node:crypto";
+import { spawnAsync } from "../process/spawnAsync";
 
 const calculateSecretsHash = (envVariables: string[]): string => {
 	const hash = createHash("sha256");

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

@@ -1,20 +1,20 @@
-import { deployPostgres } from "@dokploy/server/services/postgres";
-import { execAsyncRemote } from "../process/execAsync";
-import { execAsync } from "../process/execAsync";
-import { deployMySql } from "@dokploy/server/services/mysql";
-import { deployMariadb } from "@dokploy/server/services/mariadb";
-import { deployMongo } from "@dokploy/server/services/mongo";
-import { deployRedis } from "@dokploy/server/services/redis";
-import { removeService } from "../docker/utils";
 import { db } from "@dokploy/server/db";
 import {
-	postgres,
-	mysql,
 	mariadb,
 	mongo,
+	mysql,
+	postgres,
 	redis,
 } from "@dokploy/server/db/schema";
+import { deployMariadb } from "@dokploy/server/services/mariadb";
+import { deployMongo } from "@dokploy/server/services/mongo";
+import { deployMySql } from "@dokploy/server/services/mysql";
+import { deployPostgres } from "@dokploy/server/services/postgres";
+import { deployRedis } from "@dokploy/server/services/redis";
 import { eq } from "drizzle-orm";
+import { removeService } from "../docker/utils";
+import { execAsyncRemote } from "../process/execAsync";
+import { execAsync } from "../process/execAsync";
 
 type DatabaseType = "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
 

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

@@ -14,6 +14,7 @@ import {
 	cloneGitRawRepository,
 	cloneRawGitRepositoryRemote,
 } from "../providers/git";
+import { cloneRawGiteaRepository } from "../providers/gitea";
 import {
 	cloneRawGithubRepository,
 	cloneRawGithubRepositoryRemote,
@@ -22,10 +23,6 @@ import {
 	cloneRawGitlabRepository,
 	cloneRawGitlabRepositoryRemote,
 } from "../providers/gitlab";
-import {
-	cloneRawGiteaRepository,
-	cloneRawGiteaRepositoryRemote,
-} from "../providers/gitea";
 import {
 	createComposeFileRaw,
 	createComposeFileRawRemote,