@zereight/mcp-gitlab 2.2.6 → 2.3.1

package/build/oauth.js

@@ -44,6 +44,117 @@ export function isAuthInvalidTokenResponse(status, bodyText) {
         return false;
     }
 }
+// Shared OAuth callback servers started by this process
+const sharedOAuthServers = new Set();
+/**
+ * Stop the shared OAuth callback servers started by this process.
+ */
+export async function closeSharedOAuthServersAsync() {
+    const servers = [...sharedOAuthServers];
+    sharedOAuthServers.clear();
+    await Promise.all(servers.map(server => new Promise(resolve => {
+        server.close(() => resolve());
+        server.closeAllConnections();
+    })));
+}
+const SHARED_OAUTH_KEY_HEADER = "x-gitlab-mcp-oauth-key";
+/**
+ * Key file for the shared OAuth callback server on `port`. Sibling processes
+ * compute the same path, so they need the same OS user and home directory.
+ */
+function sharedOAuthKeyPath(port) {
+    return path.join(os.homedir(), `.gitlab-mcp-oauth-${port}.key`);
+}
+/**
+ * Write the key to an owner-only file without following symlinks. The caller
+ * holds the port, so an existing regular file of ours is left from an earlier run.
+ */
+function writeSharedOAuthKey(keyPath, key) {
+    const flags = fs.constants.O_WRONLY |
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        (fs.constants.O_NOFOLLOW ?? 0);
+    let fd;
+    try {
+        fd = fs.openSync(keyPath, flags, 0o600);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+        const stat = fs.lstatSync(keyPath);
+        const uid = process.getuid?.();
+        if (!stat.isFile() || (uid !== undefined && stat.uid !== uid)) {
+            throw new Error(`Refusing to replace ${keyPath}: not a regular file owned by the current user`);
+        }
+        fs.unlinkSync(keyPath);
+        fd = fs.openSync(keyPath, flags, 0o600);
+    }
+    try {
+        fs.writeSync(fd, key);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function removeSharedOAuthKey(keyPath, key) {
+    try {
+        if (fs.readFileSync(keyPath, "utf8").trim() === key) {
+            fs.unlinkSync(keyPath);
+        }
+    }
+    catch {
+        // Best effort
+    }
+}
+async function readSharedOAuthKeyAsync(port) {
+    const keyPath = sharedOAuthKeyPath(port);
+    let problem = "ENOENT";
+    // The other process writes its key right after it binds the port.
+    for (let attempt = 0; attempt < 5; attempt++) {
+        if (attempt > 0) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        try {
+            const key = fs.readFileSync(keyPath, "utf8").trim();
+            if (/^[0-9a-f]{64}$/.test(key)) {
+                return key;
+            }
+            problem = "unexpected content";
+        }
+        catch (error) {
+            problem = error.code ?? String(error);
+            if (problem !== "ENOENT") {
+                break;
+            }
+        }
+    }
+    throw new Error(`cannot read OAuth server key ${keyPath} (${problem}); the process holding port ${port} ` +
+        "must run as the same OS user with the same home directory");
+}
+/**
+ * Host headers the shared OAuth callback server answers: loopback names with
+ * its port, plus the configured redirect URI host. The listener is bound to
+ * 127.0.0.1, so any other Host comes from a name that merely resolves there
+ * (DNS rebinding).
+ */
+function sharedOAuthAllowedHosts(port, redirectUri) {
+    const hosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+    try {
+        hosts.add(new URL(redirectUri).host.toLowerCase());
+    }
+    catch {
+        // Malformed redirectUri: loopback names only
+    }
+    return hosts;
+}
+function sharedOAuthKeyMatches(provided, expected) {
+    if (typeof provided !== "string") {
+        return false;
+    }
+    const digest = (value) => crypto.createHash("sha256").update(value).digest();
+    return crypto.timingSafeEqual(digest(provided), digest(expected));
+}
 /**
  * Check if a port is already in use
  */
@@ -69,12 +180,14 @@ async function isPortInUse(port) {
  * Request authentication from an existing OAuth server
  */
 async function requestAuthFromExistingServer(port, requestId) {
+    const key = await readSharedOAuthKeyAsync(port);
     return new Promise((resolve, reject) => {
         const options = {
             hostname: "127.0.0.1",
             port: port,
             path: `/auth-request?requestId=${requestId}`,
             method: "GET",
+            headers: { [SHARED_OAUTH_KEY_HEADER]: key },
         };
         const req = http.request(options, res => {
             let data = "";
@@ -91,6 +204,9 @@ async function requestAuthFromExistingServer(port, requestId) {
                         reject(new Error(`Failed to parse token data: ${error}`));
                     }
                 }
+                else if (res.statusCode === 403) {
+                    reject(new Error(`OAuth server on port ${port} rejected the request key; it may run as a different OS user or an older version`));
+                }
                 else {
                     reject(new Error(`Auth request failed with status ${res.statusCode}: ${data}`));
                 }
@@ -288,7 +404,8 @@ export class GitLabOAuth {
             }
             catch (error) {
                 logger.error({ err: error }, "Failed to connect to existing OAuth server");
-                throw new Error(`Port ${callbackPort} is in use but cannot connect to existing OAuth server. Please close other instances or use a different port.`);
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new Error(`Port ${callbackPort} is in use but cannot connect to existing OAuth server: ${reason}. Please close other instances or use a different port.`);
             }
         }
         // Port is free, start the shared OAuth server
@@ -300,6 +417,9 @@ export class GitLabOAuth {
     async startSharedOAuthServer(callbackPort, initialRequestId) {
         const stateToRequestId = new Map();
         const requestIdToOAuthInstance = new Map();
+        const allowedHosts = sharedOAuthAllowedHosts(callbackPort, this.config.redirectUri);
+        const keyPath = sharedOAuthKeyPath(callbackPort);
+        const key = crypto.randomBytes(32).toString("hex");
         return new Promise((resolve, reject) => {
             // Create initial request
             const state = crypto.randomUUID();
@@ -312,9 +432,20 @@ export class GitLabOAuth {
             pendingAuthRequests.set(initialRequestId, { resolve, reject, timeout });
             const server = http.createServer(async (req, res) => {
                 try {
+                    // Only answer requests addressed to this listener by an expected name
+                    if (!allowedHosts.has((req.headers.host || "").toLowerCase())) {
+                        res.writeHead(403, { "Content-Type": "text/plain" });
+                        res.end("Forbidden");
+                        return;
+                    }
                     const parsedUrl = url.parse(req.url || "", true);
                     // Handle auth requests from other MCP instances
                     if (parsedUrl.pathname === "/auth-request") {
+                        if (!sharedOAuthKeyMatches(req.headers[SHARED_OAUTH_KEY_HEADER], key)) {
+                            res.writeHead(403, { "Content-Type": "text/plain" });
+                            res.end("Forbidden");
+                            return;
+                        }
                         const newRequestId = parsedUrl.query.requestId;
                         if (!newRequestId) {
                             res.writeHead(400, { "Content-Type": "text/plain" });
@@ -331,7 +462,7 @@ export class GitLabOAuth {
                         const authUrl = await this.getAuthorizationUrl(newState);
                         logger.info("Opening browser for new authentication request...");
                         logger.info(`If browser doesn't open, visit: ${redactUrlSecretsInText(authUrl)}`);
-                        open(authUrl).catch(err => {
+                        (this.config.openBrowser ?? open)(authUrl).catch(err => {
                             logger.error({ err }, "Failed to open browser");
                             logger.info(`Please manually open: ${redactUrlSecretsInText(authUrl)}`);
                         });
@@ -483,11 +614,24 @@ export class GitLabOAuth {
                 }
             });
             server.listen(callbackPort, "127.0.0.1", async () => {
+                sharedOAuthServers.add(server);
+                try {
+                    writeSharedOAuthKey(keyPath, key);
+                    const removeKey = () => removeSharedOAuthKey(keyPath, key);
+                    process.once("exit", removeKey);
+                    server.once("close", () => {
+                        process.removeListener("exit", removeKey);
+                        removeKey();
+                    });
+                }
+                catch (error) {
+                    logger.warn({ err: error }, `Failed to write ${keyPath}; other MCP instances cannot use this OAuth callback server`);
+                }
                 logger.info(`Shared OAuth callback server listening on port ${callbackPort}`);
                 const authUrl = await this.getAuthorizationUrl(state);
                 logger.info("Opening browser for authentication...");
                 logger.info(`If browser doesn't open, visit: ${redactUrlSecretsInText(authUrl)}`);
-                open(authUrl).catch(err => {
+                (this.config.openBrowser ?? open)(authUrl).catch(err => {
                     logger.error({ err }, "Failed to open browser");
                     logger.info(`Please manually open: ${redactUrlSecretsInText(authUrl)}`);
                 });