| import { createWriteStream } from "node:fs"; |
| import { join } from "node:path"; |
| import { paths } from "@dokploy/server/constants"; |
| 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 { spawnAsync } from "../process/spawnAsync"; |
|
|
| import type { apiFindGithubBranches } from "@dokploy/server/db/schema"; |
| import type { Compose } from "@dokploy/server/services/compose"; |
| import { type Github, findGithubById } from "@dokploy/server/services/github"; |
| import { execAsyncRemote } from "../process/execAsync"; |
|
|
| export const authGithub = (githubProvider: Github): Octokit => { |
| if (!haveGithubRequirements(githubProvider)) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "Github Account not configured correctly", |
| }); |
| } |
|
|
| const octokit: Octokit = new Octokit({ |
| authStrategy: createAppAuth, |
| auth: { |
| appId: githubProvider?.githubAppId || 0, |
| privateKey: githubProvider?.githubPrivateKey || "", |
| installationId: githubProvider?.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 = (githubProvider: Github) => { |
| return !!( |
| githubProvider?.githubAppId && |
| githubProvider?.githubPrivateKey && |
| githubProvider?.githubInstallationId |
| ); |
| }; |
|
|
| const getErrorCloneRequirements = (entity: { |
| repository?: string | null; |
| owner?: string | null; |
| branch?: string | null; |
| }) => { |
| const reasons: string[] = []; |
| const { repository, owner, branch } = entity; |
|
|
| 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 type ApplicationWithGithub = InferResultType< |
| "applications", |
| { github: true } |
| >; |
|
|
| export type ComposeWithGithub = InferResultType<"compose", { github: true }>; |
|
|
| interface CloneGithubRepository { |
| appName: string; |
| owner: string | null; |
| branch: string | null; |
| githubId: string | null; |
| repository: string | null; |
| logPath: string; |
| type?: "application" | "compose"; |
| enableSubmodules: boolean; |
| } |
| export const cloneGithubRepository = async ({ |
| logPath, |
| type = "application", |
| ...entity |
| }: CloneGithubRepository) => { |
| const isCompose = type === "compose"; |
| const { APPLICATIONS_PATH, COMPOSE_PATH } = paths(); |
| const writeStream = createWriteStream(logPath, { flags: "a" }); |
| const { appName, repository, owner, branch, githubId, enableSubmodules } = |
| entity; |
|
|
| if (!githubId) { |
| throw new TRPCError({ |
| code: "NOT_FOUND", |
| message: "GitHub Provider not found", |
| }); |
| } |
|
|
| const requirements = getErrorCloneRequirements(entity); |
|
|
| |
| 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 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`; |
| await recreateDirectory(outputPath); |
| const cloneUrl = `https://oauth2:${token}@${repoclone}`; |
|
|
| try { |
| writeStream.write(`\nClonning Repo ${repoclone} to ${outputPath}: ✅\n`); |
| const cloneArgs = [ |
| "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 Clonning: ${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); |
|
|
| |
| 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; |
| } |
| }; |
|
|
| export const getGithubRepositories = async (githubId?: string) => { |
| if (!githubId) { |
| return []; |
| } |
|
|
| const githubProvider = await findGithubById(githubId); |
|
|
| const octokit = new Octokit({ |
| authStrategy: createAppAuth, |
| auth: { |
| appId: githubProvider.githubAppId, |
| privateKey: githubProvider.githubPrivateKey, |
| installationId: githubProvider.githubInstallationId, |
| }, |
| }); |
|
|
| const repositories = (await octokit.paginate( |
| octokit.rest.apps.listReposAccessibleToInstallation, |
| )) as unknown as Awaited< |
| ReturnType<typeof octokit.rest.apps.listReposAccessibleToInstallation> |
| >["data"]["repositories"]; |
|
|
| return repositories; |
| }; |
|
|
| export const getGithubBranches = async ( |
| input: typeof apiFindGithubBranches._type, |
| ) => { |
| if (!input.githubId) { |
| return []; |
| } |
| const githubProvider = await findGithubById(input.githubId); |
|
|
| const octokit = new Octokit({ |
| authStrategy: createAppAuth, |
| auth: { |
| appId: githubProvider.githubAppId, |
| privateKey: githubProvider.githubPrivateKey, |
| installationId: githubProvider.githubInstallationId, |
| }, |
| }); |
|
|
| const branches = (await octokit.paginate(octokit.rest.repos.listBranches, { |
| owner: input.owner, |
| repo: input.repo, |
| })) as unknown as Awaited< |
| ReturnType<typeof octokit.rest.repos.listBranches> |
| >["data"]; |
|
|
| return branches; |
| }; |
|
|
