Use user GitHub OAuth token for repochecker API calls

express/backend/src/api/repochecker-worker.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { handler } = require('@iobroker/repochecker');
+
+function send(message) {
+    if (process.send) {
+        process.send(message);
+    }
+}
+
+function serializeError(error) {
+    if (!error) {
+        return undefined;
+    }
+
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+
+    return error;
+}
+
+const request = JSON.parse(process.argv[2] || '{}');
+
+process.on('uncaughtException', error => {
+    send({ error: serializeError(error) });
+    process.exit(1);
+});
+
+process.on('unhandledRejection', error => {
+    send({ error: serializeError(error) });
+    process.exit(1);
+});
+
+handler(request, null, (error, result) => {
+    send({
+        error: serializeError(error),
+        result,
+    });
+    process.exit(error || !result ? 1 : 0);
+});

express/backend/src/api/repochecker.ts

@@ -1,25 +1,102 @@
-import { handler } from "@iobroker/repochecker";
+import { CheckRequest, CheckResult } from "@iobroker/repochecker";
+import { fork } from "child_process";
 import { Router } from "express";
+import path from "path";
 
 const router = Router();
 
+type RepocheckerWorkerResponse = {
+	error?: unknown;
+	result?: CheckResult;
+};
+
+function getGithubToken(authorization?: string | string[]) {
+	if (typeof authorization !== "string") {
+		return undefined;
+	}
+
+	const trimmed = authorization.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+
+	const separatorIndex = trimmed.indexOf(" ");
+	if (separatorIndex < 0) {
+		return trimmed;
+	}
+
+	const scheme = trimmed.slice(0, separatorIndex).toLowerCase();
+	if (scheme !== "bearer" && scheme !== "token") {
+		return trimmed;
+	}
+
+	const token = trimmed.slice(separatorIndex + 1).trim();
+	return token || undefined;
+}
+
+function runRepochecker(
+	request: CheckRequest,
+	githubToken?: string,
+): Promise<CheckResult> {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const child = fork(path.join(__dirname, "repochecker-worker.js"), [
+			JSON.stringify(request),
+		], {
+			env: githubToken
+				? { ...process.env, OWN_GITHUB_TOKEN: githubToken }
+				: process.env,
+		});
+
+		const finishWithError = (error: unknown) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			reject(error);
+		};
+
+		child.once("message", (message: RepocheckerWorkerResponse) => {
+			if (message.result) {
+				settled = true;
+				resolve(message.result);
+				return;
+			}
+			finishWithError(
+				message.error || new Error("Repochecker returned no result"),
+			);
+		});
+		child.once("error", finishWithError);
+		child.once("exit", (code, signal) => {
+			if (settled || code === 0) {
+				return;
+			}
+			settled = true;
+			reject(
+				new Error(
+					`Repochecker exited before responding (code=${code}, signal=${signal})`,
+				),
+			);
+		});
+	});
+}
+
 router.get("/api/repochecker/", async function (req, res) {
-	handler(
-		{
-			queryStringParameters: {
-				url: req.query.url as string,
-				branch: req.query.branch as string | undefined,
+	try {
+		const result = await runRepochecker(
+			{
+				queryStringParameters: {
+					url: req.query.url as string,
+					branch: req.query.branch as string | undefined,
+				},
 			},
-		},
-		null,
-		(error, result) => {
-			if (error || !result) {
-				res.status(500).send(error);
-			} else {
-				res.status(result.statusCode).send(result.body);
-			}
-		},
-	);
+			getGithubToken(req.headers.authorization),
+		);
+		res.status(result.statusCode).send(result.body);
+	} catch (error) {
+		console.error("Repochecker request failed", error);
+		res.status(500).send("Repochecker request failed");
+	}
 });
 
 export default router;

express/frontend/src/lib/ioBroker.ts

@@ -273,12 +273,20 @@ export interface CheckResults {
 	errors: CheckResult[];
 }
 
-export async function checkAdapter(repoName: string, branchName?: string) {
+export async function checkAdapter(
+	repoName: string,
+	ghToken: string,
+	branchName?: string,
+) {
 	const url = new URL(getApiUrl("repochecker/"), window.location.origin);
 	url.searchParams.set("url", `https://github.com/${repoName}`);
 	if (branchName) {
 		url.searchParams.set("branch", branchName);
 	}
-	const { data } = await axios.get<CheckResults>(url.toString());
+	const { data } = await axios.get<CheckResults>(url.toString(), {
+		headers: {
+			Authorization: ["Bearer", ghToken].join(" "),
+		},
+	});
 	return data;
 }

express/frontend/src/tools/AdapterCheck.tsx

@@ -163,7 +163,7 @@ export function AdapterCheck() {
 		setMessages([]);
 		setBusy(true);
 		try {
-			const results = await checkAdapter(repoName, branchName);
+			const results = await checkAdapter(repoName, token, branchName);
 			const messages = results.errors.map((c) => new Message("error", c));
 			messages.push(
 				...results.warnings.map((c) => new Message("warning", c)),

express/frontend/src/tools/adapter/releases/UpdateRepositoriesDialog.tsx

@@ -85,7 +85,7 @@ function AdapterCheckStep(props: {
 		};
 		const runAdapterCheck = async () => {
 			try {
-				const awaitCheckAdapter = checkAdapter(repo!.full_name);
+				const awaitCheckAdapter = checkAdapter(repo!.full_name, token);
 				const pr = await findPullRequest();
 				setPullRequestUrl(pr);
 				const results = await awaitCheckAdapter;