github.ts

import { mkdtemp, writeFile } from "fs/promises";
import { join } from "path";
import { fetch } from "./fetch";
import { exec } from "./shell";

interface GitHubReleaseInfo {
    title: string;
    tag: string;
    target: string;
    notes:
        | {
              text: string;
          }
        | {
              file: string;
          };
    filesToRelease?: string;
    isDraft?: boolean;
    repo?: string;
}
interface GitHubPRInfo {
    title: string;
    body: string;
    head: string;
    base: string;
    repo?: string;
}

export class GitHub {
    authSet = false;
    tmpPrefix = "gh-";

    async ensureAuth(): Promise<void> {
        if (!this.authSet) {
            if (process.env.GITHUB_TOKEN) {
                // when using GITHUB_TOKEN, gh will automatically use it
            } else if (process.env.GH_PAT) {
                await exec(`echo "${process.env.GH_PAT}" | gh auth login --with-token`);
            } else {
                // No environment variables set, check if already authenticated
                if (!(await this.isAuthenticated())) {
                    throw new Error(
                        "GitHub CLI is not authenticated. Please set GITHUB_TOKEN or GH_PAT environment variable, or run 'gh auth login'."
                    );
                }
            }

            this.authSet = true;
        }
    }

    private async isAuthenticated(): Promise<boolean> {
        try {
            // Try to run 'gh auth status' to check if authenticated
            await exec("gh auth status", { stdio: "pipe" });
            return true;
        } catch (error) {
            // If the command fails, the user is not authenticated
            return false;
        }
    }

    async createTempFile(): Promise<string> {
        const dir = await mkdtemp(this.tmpPrefix);
        return join(dir, "release-notes.txt");
    }

    async createGithubPRFrom(pr: GitHubPRInfo): Promise<void> {
        await this.ensureAuth();

        const repoArgument = pr.repo ? `--repo '${pr.repo}'` : "";
        const command = [
            `gh pr create`,
            `--title '${pr.title}'`,
            `--body '${pr.body}'`,
            `--base '${pr.base}'`,
            `--head '${pr.head}'`,
            repoArgument
        ].join(" ");

        await exec(command);
    }

    async createGithubReleaseFrom(params: GitHubReleaseInfo): Promise<void> {
        const { notes, title, tag, filesToRelease = "", target, isDraft = false, repo } = params;
        await this.ensureAuth();

        const notesFilePath = "file" in notes ? notes.file : await this.createReleaseNotesFile(notes.text);

        const targetHash = (await exec(`git rev-parse --verify ${target}`, { stdio: "pipe" })).stdout.trim();
        const command = [
            `gh release create`,
            `--title '${title}'`,
            `--notes-file '${notesFilePath}'`,
            isDraft ? `--draft` : "",
            repo ? `-R '${repo}'` : "",
            `'${tag}'`,
            `--target '${targetHash}'`,
            filesToRelease ? `'${filesToRelease}'` : ""
        ]
            .filter(str => str !== "")
            .join(" ");

        await exec(command);
    }

    get ghAPIHeaders(): Record<string, string> {
        return {
            "X-GitHub-Api-Version": "2022-11-28",
            Authorization: `Bearer ${process.env.GH_PAT}`
        };
    }

    async getReleaseIdByReleaseTag(releaseTag: string): Promise<string | undefined> {
        console.log(`Searching for release from Github tag '${releaseTag}'`);
        try {
            const release =
                (await fetch<{ id: string }>(
                    "GET",
                    `https://api.github.com/repos/mendix/web-widgets/releases/tags/${releaseTag}`,
                    undefined,
                    { ...this.ghAPIHeaders }
                )) ?? [];

            if (!release) {
                return undefined;
            }

            return release.id;
        } catch (e) {
            if (e instanceof Error && e.message.includes("404")) {
                return undefined;
            }

            throw e;
        }
    }

    async getReleaseArtifacts(releaseTag: string): Promise<Array<{ name: string; browser_download_url: string }>> {
        const releaseId = await this.getReleaseIdByReleaseTag(releaseTag);

        if (!releaseId) {
            throw new Error(`Could not find release with tag '${releaseTag}' on GitHub`);
        }

        return fetch<
            Array<{
                name: string;
                browser_download_url: string;
            }>
        >("GET", `https://api.github.com/repos/mendix/web-widgets/releases/${releaseId}/assets`, undefined, {
            ...this.ghAPIHeaders
        });
    }

    async getMPKReleaseArtifactUrl(releaseTag: string): Promise<string> {
        const artifacts = await this.getReleaseArtifacts(releaseTag);

        const downloadUrl = artifacts.find(asset => asset.name.endsWith(".mpk"))?.browser_download_url;

        if (!downloadUrl) {
            throw new Error(`Could not retrieve MPK url from GitHub release with tag ${process.env.TAG}`);
        }

        return downloadUrl;
    }

    async createReleaseNotesFile(releaseNotesText: string): Promise<string> {
        const filePath = await this.createTempFile();
        await writeFile(filePath, releaseNotesText);

        return filePath;
    }

    private async triggerGithubWorkflow(params: {
        workflowId: string;
        ref: string;
        inputs: Record<string, string>;
        owner?: string;
        repo?: string;
    }): Promise<void> {
        await this.ensureAuth();

        const { workflowId, ref, inputs, owner = "mendix", repo = "web-widgets" } = params;

        // Convert inputs object to CLI parameters
        const inputParams = Object.entries(inputs)
            .map(([key, value]) => `-f ${key}=${value}`)
            .join(" ");

        const repoParam = `${owner}/${repo}`;

        const command = [`gh workflow run`, `"${workflowId}"`, `--ref "${ref}"`, inputParams, `-R "${repoParam}"`]
            .filter(Boolean)
            .join(" ");

        try {
            await exec(command);
            console.log(`Successfully triggered workflow '${workflowId}'`);
        } catch (error) {
            throw new Error(`Failed to trigger workflow '${workflowId}': ${error}`);
        }
    }

    async triggerCreateReleaseWorkflow(packageName: string, ref = "main"): Promise<void> {
        return this.triggerGithubWorkflow({
            workflowId: "CreateGitHubRelease.yml",
            ref,
            inputs: {
                package: packageName
            }
        });
    }
}

export const gh = new GitHub();