Refactor compose and deployment services: streamline cloning and execution commands, remove redundant remote functions, and enhance error handling. Update database schema to include application build server ID for better tracking of deployments.

packages/server/src/utils/providers/bitbucket.ts

@@ -1,4 +1,3 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type {
@@ -9,12 +8,8 @@ import {
 	type Bitbucket,
 	findBitbucketById,
 } from "@dokploy/server/services/bitbucket";
-import type { Compose } from "@dokploy/server/services/compose";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export type ApplicationWithBitbucket = InferResultType<
 	"applications",
@@ -81,13 +76,16 @@ export const getBitbucketHeaders = (bitbucketProvider: Bitbucket) => {
 	};
 };
 
-export const cloneBitbucketRepository = async (
-	entity: ApplicationWithBitbucket | ComposeWithBitbucket,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths();
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+type BitbucketClone = (ApplicationWithBitbucket | ComposeWithBitbucket) & {
+	serverId: string | null;
+	type?: "application" | "compose";
+};
+
+export const cloneBitbucketRepository = async ({
+	type = "application",
+	...entity
+}: BitbucketClone) => {
+	let command = "set -e;";
 	const {
 		appName,
 		bitbucketRepository,
@@ -96,187 +94,24 @@ export const cloneBitbucketRepository = async (
 		bitbucketId,
 		bitbucket,
 		enableSubmodules,
+		serverId,
 	} = entity;
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
+		command += `echo "Error: ❌ Bitbucket Provider not found"; exit 1;`;
+		return command;
 	}
 
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
 	const cloneUrl = getBitbucketCloneUrl(bitbucket, repoclone);
-	try {
-		writeStream.write(`\nCloning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			bitbucketBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoclone} to ${outputPath}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const cloneRawBitbucketRepository = async (entity: Compose) => {
-	const { COMPOSE_PATH } = paths();
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		enableSubmodules,
-	} = entity;
-
-	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			bitbucketBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawBitbucketRepositoryRemote = async (compose: Compose) => {
-	const { COMPOSE_PATH } = paths(true);
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!bitbucketId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	try {
-		const cloneCommand = `
-			rm -rf ${outputPath};
-			git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, cloneCommand);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const getBitbucketCloneCommand = async (
-	entity: ApplicationWithBitbucket | ComposeWithBitbucket,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const {
-		appName,
-		bitbucketRepository,
-		bitbucketOwner,
-		bitbucketBranch,
-		bitbucketId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!bitbucketId) {
-		const command = `
-			echo  "Error: ❌ Bitbucket Provider not found" >> ${logPath};
-			exit 1;
-		`;
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Bitbucket Provider not found",
-		});
-	}
-
-	const bitbucketProvider = await findBitbucketById(bitbucketId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoclone = `bitbucket.org/${bitbucketOwner}/${bitbucketRepository}.git`;
-	const cloneUrl = getBitbucketCloneUrl(bitbucketProvider, repoclone);
-
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone the repository ${repoclone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
+	command += `echo "Cloning Repo ${repoclone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${bitbucketBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const getBitbucketRepositories = async (bitbucketId?: string) => {

packages/server/src/utils/providers/git.ts

@@ -1,159 +1,64 @@
-import { createWriteStream } from "node:fs";
 import path, { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { Compose } from "@dokploy/server/services/compose";
 import {
 	findSSHKeyById,
 	updateSSHKeyById,
 } from "@dokploy/server/services/ssh-key";
-import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsync, execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
-export const cloneGitRepository = async (
-	entity: {
-		appName: string;
-		customGitUrl?: string | null;
-		customGitBranch?: string | null;
-		customGitSSHKeyId?: string | null;
-		enableSubmodules?: boolean;
-	},
-	logPath: string,
-	isCompose = false,
-) => {
-	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths();
+interface CloneGitRepository {
+	appName: string;
+	customGitUrl?: string | null;
+	customGitBranch?: string | null;
+	customGitSSHKeyId?: string | null;
+	enableSubmodules?: boolean;
+	serverId: string | null;
+	type?: "application" | "compose";
+}
+
+export const cloneGitRepository = async ({
+	type = "application",
+	...entity
+}: CloneGitRepository) => {
+	let command = "set -e;";
 	const {
 		appName,
 		customGitUrl,
 		customGitBranch,
 		customGitSSHKeyId,
 		enableSubmodules,
+		serverId,
 	} = entity;
+	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!customGitUrl || !customGitBranch) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
+		command += `echo "Error: ❌ Repository not found"; exit 1;`;
+		return command;
 	}
 
-	const writeStream = createWriteStream(logPath, { flags: "a" });
 	const temporalKeyPath = path.join("/tmp", "id_rsa");
 
 	if (customGitSSHKeyId) {
 		const sshKey = await findSSHKeyById(customGitSSHKeyId);
 
-		await execAsync(`
+		command += `
 			echo "${sshKey.privateKey}" > ${temporalKeyPath}
-			chmod 600 ${temporalKeyPath}
-			`);
+			chmod 600 ${temporalKeyPath};
+			`;
 	}
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
 
-	try {
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				throw new TRPCError({
-					code: "BAD_REQUEST",
-					message:
-						"Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key",
-				});
-			}
-			await addHostToKnownHosts(customGitUrl);
+	if (!isHttpOrHttps(customGitUrl)) {
+		if (!customGitSSHKeyId) {
+			command += `echo "Error: ❌ You are trying to clone a ssh repository without a ssh key, please set a ssh key"; exit 1;`;
+			return command;
 		}
-		await recreateDirectory(outputPath);
-		writeStream.write(
-			`\nCloning Repo Custom ${customGitUrl} to ${outputPath}: ✅\n`,
-		);
-
-		if (customGitSSHKeyId) {
-			await updateSSHKeyById({
-				sshKeyId: customGitSSHKeyId,
-				lastUsedAt: new Date().toISOString(),
-			});
-		}
-
-		const { port } = sanitizeRepoPathSSH(customGitUrl);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			customGitBranch,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			customGitUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync(
-			"git",
-			cloneArgs,
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-			{
-				env: {
-					...process.env,
-					...(customGitSSHKeyId && {
-						GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath}${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`,
-					}),
-				},
-			},
-		);
-
-		writeStream.write(`\nCloned Custom Git ${customGitUrl}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`\nERROR Cloning Custom Git: ${error}: ❌\n`);
-		throw error;
-	} finally {
-		writeStream.end();
+		command += addHostToKnownHostsCommand(customGitUrl);
 	}
-};
-
-export const getCustomGitCloneCommand = async (
-	entity: {
-		appName: string;
-		customGitUrl?: string | null;
-		customGitBranch?: string | null;
-		customGitSSHKeyId?: string | null;
-		serverId: string | null;
-		enableSubmodules: boolean;
-	},
-	logPath: string,
-	isCompose = false,
-) => {
-	const { SSH_PATH, COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const {
-		appName,
-		customGitUrl,
-		customGitBranch,
-		customGitSSHKeyId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!customGitUrl || !customGitBranch) {
-		const command = `
-			echo  "Error: ❌ Repository not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
-	}
-
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
+	command += `echo "Cloning Repo Custom ${customGitUrl} to ${outputPath}: ✅";`;
 
 	if (customGitSSHKeyId) {
 		await updateSSHKeyById({
@@ -161,48 +66,22 @@ export const getCustomGitCloneCommand = async (
 			lastUsedAt: new Date().toISOString(),
 		});
 	}
-	try {
-		const command = [];
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				command.push(
-					`echo "Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key ❌" >> ${logPath};
-					 exit 1;
-					`,
-				);
-			}
-			command.push(addHostToKnownHostsCommand(customGitUrl));
-		}
-		command.push(`rm -rf ${outputPath};`);
-		command.push(`mkdir -p ${outputPath};`);
-		command.push(
-			`echo "Cloning Custom Git ${customGitUrl}" to ${outputPath}: ✅ >> ${logPath};`,
-		);
-		if (customGitSSHKeyId) {
-			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const { port } = sanitizeRepoPathSSH(customGitUrl);
-			const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
-			command.push(
-				`
-				echo "${sshKey.privateKey}" > /tmp/id_rsa
-				chmod 600 /tmp/id_rsa
-				export GIT_SSH_COMMAND="${gitSshCommand}"
-				`,
-			);
-		}
 
-		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath} >> ${logPath} 2>&1; then
-				echo "❌ [ERROR] Fail to clone the repository ${customGitUrl}" >> ${logPath};
+	if (customGitSSHKeyId) {
+		const sshKey = await findSSHKeyById(customGitSSHKeyId);
+		const { port } = sanitizeRepoPathSSH(customGitUrl);
+		const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
+		command += `echo "${sshKey.privateKey}" > /tmp/id_rsa;`;
+		command += "chmod 600 /tmp/id_rsa;";
+		command += `export GIT_SSH_COMMAND="${gitSshCommand}";`;
+	}
+	command += `if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath}; then
+				echo "❌ [ERROR] Fail to clone the repository ${customGitUrl}";
 				exit 1;
 			fi
-			`,
-		);
-		command.push(`echo "Cloned Custom Git ${customGitUrl}: ✅" >> ${logPath};`);
-		return command.join("\n");
-	} catch (error) {
-		throw error;
-	}
+			`;
+
+	return command;
 };
 
 const isHttpOrHttps = (url: string): boolean => {
@@ -210,19 +89,19 @@ const isHttpOrHttps = (url: string): boolean => {
 	return regex.test(url);
 };
 
-const addHostToKnownHosts = async (repositoryURL: string) => {
-	const { SSH_PATH } = paths();
-	const { domain, port } = sanitizeRepoPathSSH(repositoryURL);
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
+// const addHostToKnownHosts = async (repositoryURL: string) => {
+// 	const { SSH_PATH } = paths();
+// 	const { domain, port } = sanitizeRepoPathSSH(repositoryURL);
+// 	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
 
-	const command = `ssh-keyscan -p ${port} ${domain} >> ${knownHostsPath}`;
-	try {
-		await execAsync(command);
-	} catch (error) {
-		console.error(`Error adding host to known_hosts: ${error}`);
-		throw error;
-	}
-};
+// 	const command = `ssh-keyscan -p ${port} ${domain} >> ${knownHostsPath}`;
+// 	try {
+// 		await execAsync(command);
+// 	} catch (error) {
+// 		console.error(`Error adding host to known_hosts: ${error}`);
+// 		throw error;
+// 	}
+// };
 
 const addHostToKnownHostsCommand = (repositoryURL: string) => {
 	const { SSH_PATH } = paths(true);
@@ -266,161 +145,3 @@ const sanitizeRepoPathSSH = (input: string) => {
 		},
 	};
 };
-
-export const cloneGitRawRepository = async (entity: {
-	appName: string;
-	customGitUrl?: string | null;
-	customGitBranch?: string | null;
-	customGitSSHKeyId?: string | null;
-	enableSubmodules?: boolean;
-}) => {
-	const {
-		appName,
-		customGitUrl,
-		customGitBranch,
-		customGitSSHKeyId,
-		enableSubmodules,
-	} = entity;
-
-	if (!customGitUrl || !customGitBranch) {
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: Repository not found",
-		});
-	}
-
-	const { SSH_PATH, COMPOSE_PATH } = paths();
-	const temporalKeyPath = path.join("/tmp", "id_rsa");
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
-
-	if (customGitSSHKeyId) {
-		const sshKey = await findSSHKeyById(customGitSSHKeyId);
-
-		await execAsync(`
-			echo "${sshKey.privateKey}" > ${temporalKeyPath}
-			chmod 600 ${temporalKeyPath}
-			`);
-	}
-
-	try {
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				throw new TRPCError({
-					code: "BAD_REQUEST",
-					message:
-						"Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key",
-				});
-			}
-			await addHostToKnownHosts(customGitUrl);
-		}
-		await recreateDirectory(outputPath);
-
-		if (customGitSSHKeyId) {
-			await updateSSHKeyById({
-				sshKeyId: customGitSSHKeyId,
-				lastUsedAt: new Date().toISOString(),
-			});
-		}
-
-		const { port } = sanitizeRepoPathSSH(customGitUrl);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			customGitBranch,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			customGitUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (_data) => {}, {
-			env: {
-				...process.env,
-				...(customGitSSHKeyId && {
-					GIT_SSH_COMMAND: `ssh -i ${temporalKeyPath}${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`,
-				}),
-			},
-		});
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGitRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		customGitBranch,
-		customGitUrl,
-		customGitSSHKeyId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!customGitUrl) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Git Provider not found",
-		});
-	}
-
-	const { SSH_PATH, COMPOSE_PATH } = paths(true);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
-
-	if (customGitSSHKeyId) {
-		await updateSSHKeyById({
-			sshKeyId: customGitSSHKeyId,
-			lastUsedAt: new Date().toISOString(),
-		});
-	}
-	try {
-		const command = [];
-		if (!isHttpOrHttps(customGitUrl)) {
-			if (!customGitSSHKeyId) {
-				command.push(
-					`echo "Error: you are trying to clone a ssh repository without a ssh key, please set a ssh key ❌" ;
-					 exit 1;
-					`,
-				);
-			}
-			command.push(addHostToKnownHostsCommand(customGitUrl));
-		}
-		command.push(`rm -rf ${outputPath};`);
-		command.push(`mkdir -p ${outputPath};`);
-		if (customGitSSHKeyId) {
-			const sshKey = await findSSHKeyById(customGitSSHKeyId);
-			const { port } = sanitizeRepoPathSSH(customGitUrl);
-			const gitSshCommand = `ssh -i /tmp/id_rsa${port ? ` -p ${port}` : ""} -o UserKnownHostsFile=${knownHostsPath}`;
-			command.push(
-				`
-				echo "${sshKey.privateKey}" > /tmp/id_rsa
-				chmod 600 /tmp/id_rsa
-				export GIT_SSH_COMMAND="${gitSshCommand}"
-				`,
-			);
-		}
-
-		command.push(
-			`if ! git clone --branch ${customGitBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${customGitUrl} ${outputPath} ; then
-				echo "[ERROR] Fail to clone the repository ";
-				exit 1;
-			fi
-			`,
-		);
-
-		await execAsyncRemote(serverId, command.join("\n"));
-	} catch (error) {
-		throw error;
-	}
-};

packages/server/src/utils/providers/gitea.ts

@@ -1,7 +1,5 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
-import type { Compose } from "@dokploy/server/services/compose";
 import {
 	findGiteaById,
 	type Gitea,
@@ -9,9 +7,6 @@ import {
 } from "@dokploy/server/services/gitea";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const getErrorCloneRequirements = (entity: {
 	giteaRepository?: string | null;
@@ -119,79 +114,16 @@ export type ApplicationWithGitea = InferResultType<
 
 export type ComposeWithGitea = InferResultType<"compose", { gitea: true }>;
 
-export const getGiteaCloneCommand = async (
-	entity: ApplicationWithGitea | ComposeWithGitea,
-	logPath: string,
-	isCompose = false,
-) => {
-	const {
-		appName,
-		giteaBranch,
-		giteaId,
-		giteaOwner,
-		giteaRepository,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!giteaId) {
-		const command = `
-		echo  "Error: ❌ Gitlab Provider not found" >> ${logPath};
-		exit 1;
-	`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-
-	// Use paths(true) for remote operations
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	await refreshGiteaToken(giteaId);
-	const gitea = await findGiteaById(giteaId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-
-	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
-	const cloneUrl = buildGiteaCloneUrl(
-		gitea?.giteaUrl!,
-		gitea?.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	const cloneCommand = `
-    rm -rf ${outputPath};
-    mkdir -p ${outputPath};
-
-    if ! git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-      echo "❌ [ERROR] Failed to clone the repository ${repoClone}" >> ${logPath};
-      exit 1;
-    fi
-
-    echo "Cloned ${repoClone} to ${outputPath}: ✅" >> ${logPath};
-  `;
-
-	return cloneCommand;
+type GiteaClone = (ApplicationWithGitea | ComposeWithGitea) & {
+	serverId: string | null;
+	type?: "application" | "compose";
 };
 
-export const cloneGiteaRepository = async (
-	entity: ApplicationWithGitea | ComposeWithGitea,
-	logPath: string,
-	isCompose = false,
-) => {
-	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
-
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+export const cloneGiteaRepository = async ({
+	type = "application",
+	...entity
+}: GiteaClone) => {
+	let command = "set -e;";
 	const {
 		appName,
 		giteaBranch,
@@ -199,27 +131,27 @@ export const cloneGiteaRepository = async (
 		giteaOwner,
 		giteaRepository,
 		enableSubmodules,
+		serverId,
 	} = entity;
+	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);
 
 	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
+		command += `echo "Error: ❌ Gitea Provider not found"; exit 1;`;
+		return command;
 	}
 
 	await refreshGiteaToken(giteaId);
 	const giteaProvider = await findGiteaById(giteaId);
+
 	if (!giteaProvider) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea provider not found in the database",
-		});
+		command += `echo "❌ [ERROR] Gitea provider not found in the database"; exit 1;`;
+		return command;
 	}
 
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 
 	const repoClone = `${giteaOwner}/${giteaRepository}.git`;
 	const cloneUrl = buildGiteaCloneUrl(
@@ -229,134 +161,9 @@ export const cloneGiteaRepository = async (
 		giteaRepository!,
 	);
 
-	writeStream.write(`\nCloning Repo ${repoClone} to ${outputPath}...\n`);
-
-	try {
-		await spawnAsync(
-			"git",
-			[
-				"clone",
-				"--branch",
-				giteaBranch!,
-				"--depth",
-				"1",
-				...(enableSubmodules ? ["--recurse-submodules"] : []),
-				cloneUrl,
-				outputPath,
-				"--progress",
-			],
-			(data) => {
-				if (writeStream.writable) {
-					writeStream.write(data);
-				}
-			},
-		);
-		writeStream.write(`\nCloned ${repoClone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const cloneRawGiteaRepository = async (entity: Compose) => {
-	const {
-		appName,
-		giteaRepository,
-		giteaOwner,
-		giteaBranch,
-		giteaId,
-		enableSubmodules,
-	} = entity;
-	const { COMPOSE_PATH } = paths();
-
-	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-	await refreshGiteaToken(giteaId);
-	const giteaProvider = await findGiteaById(giteaId);
-	if (!giteaProvider) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea provider not found in the database",
-		});
-	}
-
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-
-	const cloneUrl = buildGiteaCloneUrl(
-		giteaProvider.giteaUrl,
-		giteaProvider.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	try {
-		await spawnAsync("git", [
-			"clone",
-			"--branch",
-			giteaBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		]);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGiteaRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		giteaRepository,
-		giteaOwner,
-		giteaBranch,
-		giteaId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!giteaId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitea Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths(true);
-	const giteaProvider = await findGiteaById(giteaId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const cloneUrl = buildGiteaCloneUrl(
-		giteaProvider.giteaUrl,
-		giteaProvider.accessToken!,
-		giteaOwner!,
-		giteaRepository!,
-	);
-
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
+	command += `echo "Cloning Repo ${repoClone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${giteaBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const haveGiteaRequirements = (giteaProvider: Gitea) => {

packages/server/src/utils/providers/github.ts

@@ -1,16 +1,11 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { apiFindGithubBranches } from "@dokploy/server/db/schema";
-import type { Compose } from "@dokploy/server/services/compose";
 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 { Octokit } from "octokit";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const authGithub = (githubProvider: Github): Octokit => {
 	if (!haveGithubRequirements(githubProvider)) {
@@ -123,42 +118,39 @@ interface CloneGithubRepository {
 	branch: string | null;
 	githubId: string | null;
 	repository: string | null;
-	logPath: string;
 	type?: "application" | "compose";
 	enableSubmodules: boolean;
+	serverId: string | null;
 }
 export const cloneGithubRepository = async ({
-	logPath,
 	type = "application",
 	...entity
 }: CloneGithubRepository) => {
+	let command = "set -e;";
 	const isCompose = type === "compose";
-	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths();
-	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const { appName, repository, owner, branch, githubId, enableSubmodules } =
-		entity;
+	const {
+		appName,
+		repository,
+		owner,
+		branch,
+		githubId,
+		enableSubmodules,
+		serverId,
+	} = entity;
+	const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(!!serverId);
 
 	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
+		command += `echo "Error: ❌ Github Provider not found"; exit 1;`;
+
+		return command;
 	}
 
 	const requirements = getErrorCloneRequirements(entity);
 
 	// Check if requirements are met
 	if (requirements.length > 0) {
-		writeStream.write(
-			`\nGitHub Repository configuration failed for application: ${appName}\n`,
-		);
-		writeStream.write("Reasons:\n");
-		writeStream.write(requirements.join("\n"));
-		writeStream.end();
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: GitHub repository information is incomplete.",
-		});
+		command += `echo "GitHub Repository configuration failed for application: ${appName}"; echo "Reasons:"; echo "${requirements.join("\n")}"; exit 1;`;
+		return command;
 	}
 
 	const githubProvider = await findGithubById(githubId);
@@ -167,193 +159,15 @@ export const cloneGithubRepository = async ({
 	const octokit = authGithub(githubProvider);
 	const token = await getGithubToken(octokit);
 	const repoclone = `github.com/${owner}/${repository}.git`;
-	await recreateDirectory(outputPath);
+	// await recreateDirectory(outputPath);
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
 
-	try {
-		writeStream.write(`\nCloning Repo ${repoclone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			branch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
+	command += `echo "Cloning Repo ${repoclone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
 
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoclone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getGithubCloneCommand = async ({
-	logPath,
-	type = "application",
-	...entity
-}: CloneGithubRepository & { serverId: string }) => {
-	const {
-		appName,
-		repository,
-		owner,
-		branch,
-		githubId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-	const isCompose = type === "compose";
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!githubId) {
-		const command = `
-			echo  "Error: ❌ Github Provider not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-
-	const requirements = getErrorCloneRequirements(entity);
-
-	// Build log messages
-	let logMessages = "";
-	if (requirements.length > 0) {
-		logMessages += `\nGitHub Repository configuration failed for application: ${appName}\n`;
-		logMessages += "Reasons:\n";
-		logMessages += requirements.join("\n");
-		const escapedLogMessages = logMessages
-			.replace(/\\/g, "\\\\")
-			.replace(/"/g, '\\"')
-			.replace(/\n/g, "\\n");
-
-		const bashCommand = `
-            echo "${escapedLogMessages}" >> ${logPath};
-            exit 1;  # Exit with error code
-        `;
-
-		await execAsyncRemote(serverId, bashCommand);
-		return;
-	}
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	const githubProvider = await findGithubById(githubId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone repository ${repoclone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoclone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
-};
-
-export const cloneRawGithubRepository = async (entity: Compose) => {
-	const { appName, repository, owner, branch, githubId, enableSubmodules } =
-		entity;
-
-	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths();
-	const githubProvider = await findGithubById(githubId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	await recreateDirectory(outputPath);
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			branch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGithubRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		repository,
-		owner,
-		branch,
-		githubId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!githubId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "GitHub Provider not found",
-		});
-	}
-
-	const { COMPOSE_PATH } = paths(true);
-	const githubProvider = await findGithubById(githubId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const octokit = authGithub(githubProvider);
-	const token = await getGithubToken(octokit);
-	const repoclone = `github.com/${owner}/${repository}.git`;
-	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${branch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
+	return command;
 };
 
 export const getGithubRepositories = async (githubId?: string) => {

packages/server/src/utils/providers/gitlab.ts

@@ -1,8 +1,6 @@
-import { createWriteStream } from "node:fs";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
 import type { apiGitlabTestConnection } from "@dokploy/server/db/schema";
-import type { Compose } from "@dokploy/server/services/compose";
 import {
 	findGitlabById,
 	type Gitlab,
@@ -10,9 +8,6 @@ import {
 } from "@dokploy/server/services/gitlab";
 import type { InferResultType } from "@dokploy/server/types/with";
 import { TRPCError } from "@trpc/server";
-import { recreateDirectory } from "../filesystem/directory";
-import { execAsyncRemote } from "../process/execAsync";
-import { spawnAsync } from "../process/spawnAsync";
 
 export const refreshGitlabToken = async (gitlabProviderId: string) => {
 	const gitlabProvider = await findGitlabById(gitlabProviderId);
@@ -102,25 +97,29 @@ const getGitlabCloneUrl = (gitlab: GitlabInfo, repoClone: string) => {
 	return cloneUrl;
 };
 
-export const cloneGitlabRepository = async (
-	entity: ApplicationWithGitlab | ComposeWithGitlab,
-	logPath: string,
-	isCompose = false,
-) => {
-	const writeStream = createWriteStream(logPath, { flags: "a" });
+type GitlabClone = (ApplicationWithGitlab | ComposeWithGitlab) & {
+	serverId: string | null;
+	type?: "application" | "compose";
+};
+
+export const cloneGitlabRepository = async ({
+	type = "application",
+	...entity
+}: GitlabClone) => {
+	let command = "set -e;";
 	const {
 		appName,
 		gitlabBranch,
 		gitlabId,
 		gitlabPathNamespace,
 		enableSubmodules,
+		serverId,
 	} = entity;
+	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(!!serverId);
 
 	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
+		command += `echo "Error: ❌ Gitlab Provider not found"; exit 1;`;
+		return command;
 	}
 
 	await refreshGitlabToken(gitlabId);
@@ -130,127 +129,19 @@ export const cloneGitlabRepository = async (
 
 	// Check if requirements are met
 	if (requirements.length > 0) {
-		writeStream.write(
-			`\nGitLab Repository configuration failed for application: ${appName}\n`,
-		);
-		writeStream.write("Reasons:\n");
-		writeStream.write(requirements.join("\n"));
-		writeStream.end();
-		throw new TRPCError({
-			code: "BAD_REQUEST",
-			message: "Error: GitLab repository information is incomplete.",
-		});
+		command += `echo "❌ [ERROR] GitLab Repository configuration failed for application: ${appName}"; echo "Reasons:"; echo "${requirements.join("\n")}"; exit 1;`;
+		return command;
 	}
 
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths();
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
+	const basePath = type === "compose" ? COMPOSE_PATH : APPLICATIONS_PATH;
 	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
+	command += `rm -rf ${outputPath};`;
+	command += `mkdir -p ${outputPath};`;
 	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
 	const cloneUrl = getGitlabCloneUrl(gitlab, repoClone);
-	try {
-		writeStream.write(`\nCloning Repo ${repoClone} to ${outputPath}: ✅\n`);
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			gitlabBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-
-		await spawnAsync("git", cloneArgs, (data) => {
-			if (writeStream.writable) {
-				writeStream.write(data);
-			}
-		});
-		writeStream.write(`\nCloned ${repoClone}: ✅\n`);
-	} catch (error) {
-		writeStream.write(`ERROR Cloning: ${error}: ❌`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getGitlabCloneCommand = async (
-	entity: ApplicationWithGitlab | ComposeWithGitlab,
-	logPath: string,
-	isCompose = false,
-) => {
-	const {
-		appName,
-		gitlabPathNamespace,
-		gitlabBranch,
-		gitlabId,
-		serverId,
-		enableSubmodules,
-	} = entity;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-
-	if (!gitlabId) {
-		const command = `
-			echo  "Error: ❌ Gitlab Provider not found" >> ${logPath};
-			exit 1;
-		`;
-
-		await execAsyncRemote(serverId, command);
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-
-	const requirements = getErrorCloneRequirements(entity);
-
-	// Build log messages
-	let logMessages = "";
-	if (requirements.length > 0) {
-		logMessages += `\nGitLab Repository configuration failed for application: ${appName}\n`;
-		logMessages += "Reasons:\n";
-		logMessages += requirements.join("\n");
-		const escapedLogMessages = logMessages
-			.replace(/\\/g, "\\\\")
-			.replace(/"/g, '\\"')
-			.replace(/\n/g, "\\n");
-
-		const bashCommand = `
-            echo "${escapedLogMessages}" >> ${logPath};
-            exit 1;  # Exit with error code
-        `;
-
-		await execAsyncRemote(serverId, bashCommand);
-		return;
-	}
-
-	const { COMPOSE_PATH, APPLICATIONS_PATH } = paths(true);
-	await refreshGitlabToken(gitlabId);
-	const gitlab = await findGitlabById(gitlabId);
-	const basePath = isCompose ? COMPOSE_PATH : APPLICATIONS_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoClone = getGitlabRepoClone(gitlab, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlab, repoClone);
-	const cloneCommand = `
-rm -rf ${outputPath};
-mkdir -p ${outputPath};
-if ! git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} --progress ${cloneUrl} ${outputPath} >> ${logPath} 2>&1; then
-	echo "❌ [ERROR] Fail to clone the repository ${repoClone}" >> ${logPath};
-	exit 1;
-fi
-echo "Cloned ${repoClone} to ${outputPath}: ✅" >> ${logPath};
-	`;
-
-	return cloneCommand;
+	command += `echo "Cloning Repo ${repoClone} to ${outputPath}: ✅";`;
+	command += `git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath} --progress;`;
+	return command;
 };
 
 export const getGitlabRepositories = async (gitlabId?: string) => {
@@ -355,88 +246,6 @@ export const getGitlabBranches = async (input: {
 	}[];
 };
 
-export const cloneRawGitlabRepository = async (entity: Compose) => {
-	const {
-		appName,
-		gitlabBranch,
-		gitlabId,
-		gitlabPathNamespace,
-		enableSubmodules,
-	} = entity;
-
-	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-
-	const { COMPOSE_PATH } = paths();
-	await refreshGitlabToken(gitlabId);
-	const gitlabProvider = await findGitlabById(gitlabId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	await recreateDirectory(outputPath);
-	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
-	try {
-		const cloneArgs = [
-			"clone",
-			"--branch",
-			gitlabBranch!,
-			"--depth",
-			"1",
-			...(enableSubmodules ? ["--recurse-submodules"] : []),
-			cloneUrl,
-			outputPath,
-			"--progress",
-		];
-		await spawnAsync("git", cloneArgs);
-	} catch (error) {
-		throw error;
-	}
-};
-
-export const cloneRawGitlabRepositoryRemote = async (compose: Compose) => {
-	const {
-		appName,
-		gitlabPathNamespace,
-		gitlabBranch,
-		gitlabId,
-		serverId,
-		enableSubmodules,
-	} = compose;
-
-	if (!serverId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Server not found",
-		});
-	}
-	if (!gitlabId) {
-		throw new TRPCError({
-			code: "NOT_FOUND",
-			message: "Gitlab Provider not found",
-		});
-	}
-	const { COMPOSE_PATH } = paths(true);
-	await refreshGitlabToken(gitlabId);
-	const gitlabProvider = await findGitlabById(gitlabId);
-	const basePath = COMPOSE_PATH;
-	const outputPath = join(basePath, appName, "code");
-	const repoClone = getGitlabRepoClone(gitlabProvider, gitlabPathNamespace);
-	const cloneUrl = getGitlabCloneUrl(gitlabProvider, repoClone);
-	try {
-		const command = `
-			rm -rf ${outputPath};
-			git clone --branch ${gitlabBranch} --depth 1 ${enableSubmodules ? "--recurse-submodules" : ""} ${cloneUrl} ${outputPath}
-		`;
-		await execAsyncRemote(serverId, command);
-	} catch (error) {
-		throw error;
-	}
-};
-
 export const testGitlabConnection = async (
 	input: typeof apiGitlabTestConnection._type,
 ) => {

packages/server/src/utils/providers/raw.ts

@@ -1,4 +1,3 @@
-import { createWriteStream } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { paths } from "@dokploy/server/constants";
@@ -7,33 +6,7 @@ import { encodeBase64 } from "../docker/utils";
 import { recreateDirectory } from "../filesystem/directory";
 import { execAsyncRemote } from "../process/execAsync";
 
-export const createComposeFile = async (compose: Compose, logPath: string) => {
-	const { COMPOSE_PATH } = paths();
-	const { appName, composeFile } = compose;
-	const writeStream = createWriteStream(logPath, { flags: "a" });
-	const outputPath = join(COMPOSE_PATH, appName, "code");
-
-	try {
-		await recreateDirectory(outputPath);
-		writeStream.write(
-			`\nCreating File 'docker-compose.yml' to ${outputPath}: ✅\n`,
-		);
-
-		await writeFile(join(outputPath, "docker-compose.yml"), composeFile);
-
-		writeStream.write(`\nFile 'docker-compose.yml' created: ✅\n`);
-	} catch (error) {
-		writeStream.write(`\nERROR Creating Compose File: ${error}: ❌\n`);
-		throw error;
-	} finally {
-		writeStream.end();
-	}
-};
-
-export const getCreateComposeFileCommand = (
-	compose: Compose,
-	logPath: string,
-) => {
+export const getCreateComposeFileCommand = (compose: Compose) => {
 	const { COMPOSE_PATH } = paths(true);
 	const { appName, composeFile } = compose;
 	const outputPath = join(COMPOSE_PATH, appName, "code");
@@ -43,7 +16,7 @@ export const getCreateComposeFileCommand = (
 		rm -rf ${outputPath};
 		mkdir -p ${outputPath};
 		echo "${encodedContent}" | base64 -d > "${filePath}";
-		echo "File 'docker-compose.yml' created: ✅" >> ${logPath};
+		echo "File 'docker-compose.yml' created: ✅";
 	`;
 	return bashCommand;
 };