notify_user.yml

name: Comment when commit references issue

on:
  workflow_call:
  workflow_run:
    workflows:
      - Build APKs
    types:
      - completed
    branches:
      - main

jobs:
  notify-issue:
    if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
    runs-on: ubuntu-latest

    permissions:
      issues: write
      pull-requests: write
      contents: read

    steps:
      - name: Notify referenced issues
        uses: actions/github-script@v9
        env:
          ISSUE_LABEL: CONFIRMED
          ISSUE_LABEL_COLOR: 8DF148
          ISSUE_LABEL_DESCRIPTION: Issue was referenced and confirmed by a commit and should be closed.
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          script: |
            const nightlyLinks = [
              {
                label: "GMS",
                url: "https://nightly.link/SolsticeIO/Solstice/workflows/build/dev/app-gms-mobile-universal-release"
              },
              {
                label: "FOSS",
                url: "https://nightly.link/SolsticeIO/Solstice/workflows/build/dev/app-foss-mobile-universal-release"
              }
            ];
            const nightlyUrls = nightlyLinks.map((link) => link.url);
            const labelName = process.env.ISSUE_LABEL;
            const labelColor = process.env.ISSUE_LABEL_COLOR;
            const labelDescription = process.env.ISSUE_LABEL_DESCRIPTION;
            const commentMarker = "<!-- solstice-notify-user:nightly-reference -->";
            const referencedIssuePattern = /#([1-9]\d*)\b/g;
            const issueClosedReason = "completed";
            const workflowRun = context.payload.workflow_run;
            const commits = Array.isArray(context.payload.commits)
              ? context.payload.commits
              : [];
            const headCommit = workflowRun?.head_commit ?? context.payload.head_commit;
            const commitMessages = commits.length > 0
              ? commits.map((commit) => commit.message)
              : headCommit?.message
                ? [headCommit.message]
                : [];

            const issueNumbers = [
              ...new Set(
                commitMessages.flatMap((message) =>
                  [...message.matchAll(referencedIssuePattern)].map((match) => Number(match[1]))
                )
              )
            ];

            if (issueNumbers.length === 0) {
              core.info("No referenced issues found in the completed build commit message.");
              return;
            }

            const ensureLabelExists = async () => {
              try {
                await github.rest.issues.getLabel({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  name: labelName
                });
              } catch (error) {
                if (error.status !== 404) {
                  throw error;
                }

                await github.rest.issues.createLabel({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  name: labelName,
                  color: labelColor,
                  description: labelDescription
                });
              }
            };

            const tryEnsureLabelExists = async () => {
              try {
                await ensureLabelExists();
                return true;
              } catch (error) {
                core.warning(`Skipping label creation check because GitHub rejected the request: ${error.message}`);
                return false;
              }
            };

            const canApplyLabel = await tryEnsureLabelExists();

            const failures = [];

            for (const issueNumber of issueNumbers) {
              try {
                const issue = await github.rest.issues.get({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  issue_number: issueNumber
                });

                if (issue.data.pull_request) {
                  core.info(`Skipped notifying #${issueNumber} because it is a pull request.`);
                  continue;
                }

                if (canApplyLabel) {
                  try {
                    await github.rest.issues.addLabels({
                      owner: context.repo.owner,
                      repo: context.repo.repo,
                      issue_number: issueNumber,
                      labels: [labelName]
                    });
                  } catch (error) {
                    core.warning(`Skipping label update for issue #${issueNumber}: ${error.message}`);
                  }
                }

                const comments = await github.paginate(github.rest.issues.listComments, {
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  issue_number: issueNumber,
                  per_page: 100
                });

                const hasExistingNotification = comments.some((comment) => {
                  const body = comment.body ?? "";
                  return body.includes(commentMarker) ||
                    (
                      comment.user?.type === "Bot" &&
                      body.includes("This issue was referenced on commit") &&
                      nightlyUrls.some((nightlyUrl) => body.includes(nightlyUrl))
                    );
                });

                if (hasExistingNotification) {
                  core.info(`Issue #${issueNumber} already has a nightly reference notification comment.`);
                  if (!issue.data.pull_request && issue.data.state !== "closed") {
                    await github.rest.issues.update({
                      owner: context.repo.owner,
                      repo: context.repo.repo,
                      issue_number: issueNumber,
                      state: "closed",
                      state_reason: issueClosedReason
                    });
                    core.info(`Closed issue #${issueNumber} after existing notification comment.`);
                  }
                  continue;
                }

                const author = issue.data.user.login;
                const headSha = workflowRun?.head_sha ?? headCommit?.id ?? context.sha;
                const commitUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/commit/${headSha}`;
                const commitSha = headSha.substring(0, 7);
                const body = [
                  commentMarker,
                  `Hey @${author}, This issue was referenced on commit [\`${commitSha}\`](${commitUrl}).`,
                  "",
                  "Make sure to try the latest nightly version:",
                  "",
                  ...nightlyLinks.map((link) => `${link.label}: ${link.url}`),
                  "",
                  "This issue is being closed automatically after the referenced fix commit."
                ].join("\n");

                await github.rest.issues.createComment({
                  owner: context.repo.owner,
                  repo: context.repo.repo,
                  issue_number: issueNumber,
                  body
                });

                if (!issue.data.pull_request && issue.data.state !== "closed") {
                  await github.rest.issues.update({
                    owner: context.repo.owner,
                    repo: context.repo.repo,
                    issue_number: issueNumber,
                    state: "closed",
                    state_reason: issueClosedReason
                  });
                  core.info(`Closed issue #${issueNumber} after notification comment.`);
                }
              } catch (error) {
                failures.push(`#${issueNumber}: ${error.message}`);
                core.warning(`Failed to notify issue #${issueNumber}: ${error.message}`);
              }
            }

            if (failures.length > 0) {
              throw new Error(`Failed to notify referenced issues: ${failures.join("; ")}`);
            }