feat: initial commit

server/utils/providers/docker.ts

@@ -0,0 +1,49 @@
+import { createWriteStream } from "node:fs";
+import { type ApplicationNested, mechanizeDockerContainer } from "../builders";
+import { pullImage } from "../docker/utils";
+
+interface RegistryAuth {
+  username: string;
+  password: string;
+  serveraddress: string;
+}
+
+export const buildDocker = async (
+  application: ApplicationNested,
+  logPath: string,
+): Promise<void> => {
+  const { buildType, dockerImage, username, password } = application;
+  const authConfig: Partial<RegistryAuth> = {
+    username: username || "",
+    password: password || "",
+  };
+
+  const writeStream = createWriteStream(logPath, { flags: "a" });
+
+  writeStream.write(`\nBuild ${buildType}\n`);
+
+  writeStream.write(`Pulling ${dockerImage}: ✅\n`);
+
+  try {
+    if (!dockerImage) {
+      throw new Error("Docker image not found");
+    }
+
+    await pullImage(
+      dockerImage,
+      (data) => {
+        if (writeStream.writable) {
+          writeStream.write(`${data.status}\n`);
+        }
+      },
+      authConfig,
+    );
+    await mechanizeDockerContainer(application);
+    writeStream.write("\nDocker Deployed: ✅\n");
+  } catch (error) {
+    writeStream.write(`ERROR: ${error}: ❌`);
+    throw error;
+  } finally {
+    writeStream.end();
+  }
+};

server/utils/providers/git.ts

@@ -0,0 +1,120 @@
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import type { Application } from "@/server/api/services/application";
+import { APPLICATIONS_PATH, SSH_PATH } from "@/server/constants";
+import { TRPCError } from "@trpc/server";
+import { recreateDirectory } from "../filesystem/directory";
+import { execAsync } from "../process/execAsync";
+import { spawnAsync } from "../process/spawnAsync";
+
+export const cloneGitRepository = async (
+	application: Application,
+	logPath: string,
+) => {
+	const { appName, customGitUrl, customGitBranch, customGitSSHKey } =
+		application;
+
+	if (!customGitUrl || !customGitBranch) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error: Repository not found",
+		});
+	}
+
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const keyPath = path.join(SSH_PATH, `${appName}_rsa`);
+	const outputPath = path.join(APPLICATIONS_PATH, appName);
+	const knownHostsPath = path.join(SSH_PATH, "known_hosts");
+
+	try {
+		await addHostToKnownHosts(customGitUrl);
+		await recreateDirectory(outputPath);
+		// const command = `GIT_SSH_COMMAND="ssh -i ${keyPath} -o UserKnownHostsFile=${knownHostsPath}" git clone --branch ${customGitBranch} --depth 1 ${customGitUrl} ${gitCopyPath} --progress`;
+		// const { stdout, stderr } = await execAsync(command);
+		writeStream.write(
+			`\nCloning Repo Custom ${customGitUrl} to ${outputPath}: ✅\n`,
+		);
+
+		await spawnAsync(
+			"git",
+			[
+				"clone",
+				"--branch",
+				customGitBranch,
+				"--depth",
+				"1",
+				customGitUrl,
+				outputPath,
+				"--progress",
+			],
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data);
+				}
+			},
+			{
+				env: {
+					...process.env,
+					...(customGitSSHKey && {
+						GIT_SSH_COMMAND: `ssh -i ${keyPath} -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();
+	}
+};
+
+const addHostToKnownHosts = async (repositoryURL: string) => {
+	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 sanitizeRepoPathSSH = (input: string) => {
+	const SSH_PATH_RE = new RegExp(
+		[
+			/^\s*/,
+			/(?:(?<proto>[a-z]+):\/\/)?/,
+			/(?:(?<user>[a-z_][a-z0-9_-]+)@)?/,
+			/(?<domain>[^\s\/\?#:]+)/,
+			/(?::(?<port>[0-9]{1,5}))?/,
+			/(?:[\/:](?<owner>[^\s\/\?#:]+))?/,
+			/(?:[\/:](?<repo>(?:[^\s\?#:.]|\.(?!git\/?\s*$))+))/,
+			/(?:.git)?\/?\s*$/,
+		]
+			.map((r) => r.source)
+			.join(""),
+		"i",
+	);
+
+	const found = input.match(SSH_PATH_RE);
+	if (!found) {
+		throw new Error(`Malformatted SSH path: ${input}`);
+	}
+
+	return {
+		user: found.groups?.user ?? "git",
+		domain: found.groups?.domain,
+		port: Number(found.groups?.port ?? 22),
+		owner: found.groups?.owner ?? "",
+		repo: found.groups?.repo,
+		get repoPath() {
+			return `ssh://${this.user}@${this.domain}:${this.port}/${this.owner}${
+				this.owner && "/"
+			}${this.repo}.git`;
+		},
+	};
+};

server/utils/providers/github.ts

@@ -0,0 +1,119 @@
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import type { Application } from "@/server/api/services/application";
+import { APPLICATIONS_PATH } from "@/server/constants";
+import { createAppAuth } from "@octokit/auth-app";
+import { TRPCError } from "@trpc/server";
+import { Octokit } from "octokit";
+import { recreateDirectory } from "../filesystem/directory";
+import { spawnAsync } from "../process/spawnAsync";
+import type { Admin } from "@/server/api/services/admin";
+
+export const authGithub = (admin: Admin) => {
+	if (!haveGithubRequirements(admin)) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Github Account not configured correctly",
+		});
+	}
+
+	const octokit = new Octokit({
+		authStrategy: createAppAuth,
+		auth: {
+			appId: admin?.githubAppId || 0,
+			privateKey: admin?.githubPrivateKey || "",
+			installationId: admin?.githubInstallationId,
+		},
+	});
+
+	return octokit;
+};
+
+export const getGithubToken = async (
+	octokit: ReturnType<typeof authGithub>,
+) => {
+	const installation = (await octokit.auth({
+		type: "installation",
+	})) as {
+		token: string;
+	};
+
+	return installation.token;
+};
+
+export const haveGithubRequirements = (admin: Admin) => {
+	return !!(
+		admin?.githubAppId &&
+		admin?.githubPrivateKey &&
+		admin?.githubInstallationId
+	);
+};
+
+const getErrorCloneRequirements = (application: Application) => {
+	const reasons: string[] = [];
+	const { repository, owner, branch } = application;
+
+	if (!repository) reasons.push("1. Repository not assigned.");
+	if (!owner) reasons.push("2. Owner not specified .");
+	if (!branch) reasons.push("3. Branch not defined.");
+
+	return reasons;
+};
+export const cloneGithubRepository = async (
+	admin: Admin,
+	application: Application,
+	logPath: string,
+) => {
+	const writeStream = createWriteStream(logPath, { flags: "a" });
+	const { appName, repository, owner, branch } = application;
+
+	const requirements = getErrorCloneRequirements(application);
+
+	// 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.",
+		});
+	}
+	const outputPath = path.join(APPLICATIONS_PATH, appName);
+	const octokit = authGithub(admin);
+	const token = await getGithubToken(octokit);
+	const repoclone = `github.com/${owner}/${repository}.git`;
+	await recreateDirectory(outputPath);
+	const cloneUrl = `https://oauth2:${token}@${repoclone}`;
+
+	try {
+		writeStream.write(`\nClonning Repo ${repoclone} to ${outputPath}: ✅\n`);
+		await spawnAsync(
+			"git",
+			[
+				"clone",
+				"--branch",
+				branch!,
+				"--depth",
+				"1",
+				cloneUrl,
+				outputPath,
+				"--progress",
+			],
+			(data) => {
+				if (writeStream.writable) {
+					writeStream.write(data);
+				}
+			},
+		);
+		writeStream.write(`\nCloned ${repoclone}: ✅\n`);
+	} catch (error) {
+		writeStream.write(`ERROR Clonning: ${error}: ❌`);
+		throw error;
+	} finally {
+		writeStream.end();
+	}
+};