[Bug](solved?): Forgejo/Gitea failing due to bad API URL

[jiriks74]

Subject of the issue

Running this action on Forgejo/Gitea results in the following error:

::error::Not found.%0A

Debugging this lead me to the following URL definition:

https://github.com/peter-evans/create-pull-request/blob/16e0059bfd236716f0191bfcfa63d9ded4cf325f/dist/index.js#L1287

Changing this

From 9791a4f146d5369620ea3b934822e717d3d90034 Mon Sep 17 00:00:00 2001
From: jiriks74 <jiri@stefka.eu>
Date: Sun, 15 Dec 2024 02:37:18 +0100
Subject: [PATCH] fix: Use the `v1` api as `v3` is not available on Forgejo.

---
 dist/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dist/index.js b/dist/index.js
index b555e94..8cbfb72 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -1284,7 +1284,7 @@ class GitHubHelper {
             options.auth = `${token}`;
         }
         if (githubServerHostname !== 'github.com') {
-            options.baseUrl = `https://${githubServerHostname}/api/v3`;
+            options.baseUrl = `https://${githubServerHostname}/api/v1`;
         }
         else {
             options.baseUrl = 'https://api.github.com';

resolves the issue and results in a working Action:

Steps to reproduce

1. Use Forgejo/Gitea
2. Create a simple Action modifying some files
3. Use this Action for pushing the changes to the repository and creating a PR
4. Run the new Action
5. See the ::error::Not found.%0A error

[jiriks74]

We can possibly figure out the host by looking at the /api/swagger# path. I'll be asking devs if there's some better way to do this.

[jiriks74]

Ok a better way is to check /api/v1/version. It returns the version using the following format:

{"version":"1.23.0+dev-789-g18061af490"}

[jiriks74]

If we want to check specifically for Forgejo we can use api/forgejo/v1/version:

{"version":"9.0.2+gitea-1.22.0"}

[jiriks74]

I made a simple proof of concept. Keep in mind that I don't know JavaScript so it probably needs some revision:

Code

async function determineApiBaseUrl(hostname) {
    if ( hostname == 'github.com' ){
      console.log(`Valid API path detected: https://api.github.com`);
      return "https://api.github.com";
    }

    const baseUrl = `https://${hostname}`;
    const possiblePaths = ['/api/v4/version', '/api/forgejo/v1/version', '/api/v1/version' ];

    for (const path of possiblePaths) {
      try {
            const url = `${baseUrl}${path}`;
            const response = await fetch(url, { method: 'GET', redirect: 'manual' }); // GitLab redirects `/api/forgejo/v1/version to
                                                                                      // login prompt so we get response 200
                                                                                      // if we allow the redirect. Now we get 302.

            const contentType = response.headers.get('Content-Type') || '';
            if (
                (response.ok || [401, 403].includes(response.status)) && // Check for valid API status codes
                contentType.includes('application/json') // Ensure it's returning JSON
            ) {
                console.log(`Valid API path detected: ${path.includes('/version') ? url.replace('/version', '') : url}`);
                return path.includes('/version') ? url.replace('/version', '') : url;
            }
        } catch (error) {
        }
    }

    throw new Error(`Unable to determine API base URL for hostname: ${hostname}`);
}

(async () => {
    try {
        const hostname = "github.com";
        const apiBaseUrl = await determineApiBaseUrl(hostname);
    } catch (error) {
        console.error(error.message);
        process.exit(1); // Exit with an error code if no API path is found
    }
})();


(async () => {
    try {
        const hostname = "codeberg.org";
        const apiBaseUrl = await determineApiBaseUrl(hostname);
    } catch (error) {
        console.error(error.message);
        process.exit(1); // Exit with an error code if no API path is found
    }
})();

(async () => {
    try {
        const hostname = "demo.gitea.com";
        const apiBaseUrl = await determineApiBaseUrl(hostname);
    } catch (error) {
        console.error(error.message);
        process.exit(1); // Exit with an error code if no API path is found
    }
})();

(async () => {
    try {
        const hostname = "gitlab.com";
        const apiBaseUrl = await determineApiBaseUrl(hostname);
    } catch (error) {
        console.error(error.message);
        process.exit(1); // Exit with an error code if no API path is found
    }
})();

I get the following output when running this code:

Valid API path detected: https://api.github.com
Valid API path detected: https://codeberg.org/api/v1
Valid API path detected: https://gitlab.com/api/v4
Valid API path detected: https://demo.gitea.com/api/v1

and I get the following when the API URL isn't recognized:

Unable to determine API base URL for hostname: example.com

so the end user knows that the Action failed because of a bad API URL.

Maybe we could evern let the user define a custom API URL in the Action inputs if we aren't able to detect it.

[jiriks74]

With what I found online I was able to create a working patch. I'm happy to open a PR if you find it good enough.

Patch

diff --git a/src/create-pull-request.ts b/src/create-pull-request.ts
index 9076b7d..a8971a7 100644
--- a/src/create-pull-request.ts
+++ b/src/create-pull-request.ts
@@ -51,8 +51,10 @@ export async function createPullRequest(inputs: Inputs): Promise<void> {
     core.startGroup('Determining the base and head repositories')
     const baseRemote = gitConfigHelper.getGitRemote()
     // Init the GitHub clients
-    const ghBranch = new GitHubHelper(baseRemote.hostname, inputs.branchToken)
-    const ghPull = new GitHubHelper(baseRemote.hostname, inputs.token)
+    const apiUrl = await GitHubHelper.determineApiUrl(baseRemote.hostname);
+    core.info(`Using API base URL: ${apiUrl}`);
+    const ghBranch = new GitHubHelper(apiUrl, inputs.branchToken)
+    const ghPull = new GitHubHelper(apiUrl, inputs.token)
     // Determine the head repository; the target for the pull request branch
     const branchRemoteName = inputs.pushToFork ? 'fork' : 'origin'
     const branchRepository = inputs.pushToFork
diff --git a/src/github-helper.ts b/src/github-helper.ts
index 82a9296..15efc16 100644
--- a/src/github-helper.ts
+++ b/src/github-helper.ts
@@ -41,20 +41,49 @@ type TreeObject = {
 export class GitHubHelper {
   private octokit: InstanceType<typeof Octokit>
 
-  constructor(githubServerHostname: string, token: string) {
+  constructor(apiUrl: string, token: string) {
     const options: OctokitOptions = {}
     if (token) {
       options.auth = `${token}`
     }
-    if (githubServerHostname !== 'github.com') {
-      options.baseUrl = `https://${githubServerHostname}/api/v3`
-    } else {
-      options.baseUrl = 'https://api.github.com'
-    }
+    options.baseUrl = apiUrl;
     options.throttle = throttleOptions
     this.octokit = new Octokit(options)
   }
 
+  static async determineApiUrl(hostname: string): Promise<string> {
+    if (hostname === 'github.com') {
+      return "https://api.github.com";
+    }
+
+    const baseUrl = `https://${hostname}`;
+    const possiblePaths = ['/api/v4/version', '/api/forgejo/v1/version', '/api/v1/version'];
+
+    for (const path of possiblePaths) {
+      try {
+        const url = `${baseUrl}${path}`;
+        const response = await fetch(url, { method: 'GET', redirect: 'manual' }); // GitLab redirects
+                                                                                  // invalid API paths
+                                                                                  // to login prompt
+                                                                                  // which returns 200
+
+        const contentType = response.headers.get('Content-Type') || '';
+        if (
+          (response.ok || [401, 403].includes(response.status)) && // We might get 401, 403
+                                                                   // as we're unauthorised
+          contentType.includes('application/json')
+        ) {
+          return path.includes('/version') ? url.replace('/version', '') : url;
+        }
+
+      } catch (error) {
+          // Ignore errors and try the next path
+      }
+    }
+
+    throw new Error(`Unable to determine API base URL for hostname: ${hostname}`);
+  }
+
   private parseRepository(repository: string): Repository {
     const [owner, repo] = repository.split('/')
     return {

I've tested the function locally with the following code

determineApiUrl("github.com")
  .then(url => console.log(url))
  .catch(error => console.error(error));
determineApiUrl("gitlab.com")
  .then(url => console.log(url))
  .catch(error => console.error(error));
determineApiUrl("codeberg.org")
  .then(url => console.log(url))
  .catch(error => console.error(error));
determineApiUrl("demo.gitea.com")
  .then(url => console.log(url))
  .catch(error => console.error(error));

producing this output

https://api.github.com
https://codeberg.org/api/v1
https://gitlab.com/api/v4
https://demo.gitea.com/api/v1

[peter-evans]

Hi @jiriks74

Thank you for raising this and your effort to solve it! Very interesting.

This action supports many use cases, and I would be very surprised if they all work outside of GitHub's ecosystem. I'm not sure that I'm prepared to try and make this action work elsewhere and keep up with its maintenance.

You are welcome to fork this action and try and make a working version that covers the test cases. If you achieve it I would consider if it makes sense to merge it in.

[robbevp]

@peter-evans I just ran into this issue as well, while migrating some repositories from github to a private git server using forgejo. Would you be open for a input option like apiBaseUrl that would override the logic in: https://github.com/peter-evans/create-pull-request/blob/main/src/github-helper.ts#L49-L53
That could come with a clear warning that some use cases of the action depend on the git server supporting specific features - keeping the maintenance on your side low

[peter-evans]

I would prefer not to add additional inputs to the action. I try to keep the interface as clean and simple as possible.

Looking at @jiriks74's patch a little closer, I think I would be willing to accept logic like that with the addition of outputting a warning to the log for non-GitHub environments. The warning would state that some features may not work in those environments, and I don't (currently) have intention to provide further support.

@jiriks74 Possible paths would need to include v3 first, because that is the current version used for self-hosted GitHub enterprise. That's why v3 is currently used in the code.

-const possiblePaths = ['/api/v4/version', '/api/forgejo/v1/version', '/api/v1/version'];
+const possiblePaths = ['/api/v3/version', '/api/v4/version', '/api/forgejo/v1/version', '/api/v1/version'];

[jiriks74]

Hello,
thanks for looking into it! I didn't make much progress because I don't know TypeScript/JavaScript and I had trouble setting up your testing environment on Gitea/Forgejo (haven't had that much time to figure out all the repos and configs).

It's been working flawlessly for me (and someone else) for a while, at least the basics have.

I'll add the paths as you requested. The debug message is a great idea, do you have anything specific in mind?

Would you like something like

You're running create-pull-request in an unsupported environment. Feel free to report issues but a fix is not guaranteed.

or

You're running create-pull-request in an unsupported environment. Please don't send reports about broken functionality.

?