@zereight/mcp-gitlab 2.1.70 → 2.2.0

package/build/test/oauth-startup.test.js

@@ -1,204 +0,0 @@
-/**
- * OAuth startup tests.
- *
- * - isAuthInvalidTokenResponse: pure classifier — refresh failures that mean
- *   "re-login would fix it" vs transient/config errors that must not open a browser.
- * - ensureOAuthToken: lazy first-use delivery — the caller must receive the
- *   token even when the on-disk token is still valid (regression: returning
- *   early on hasValidToken() alone leaves requests unauthenticated).
- *
- * Temp token files + a loopback mock for /oauth/token only; no MCP server.
- * The missing-token and invalid_grant paths start the interactive browser
- * flow and are deliberately not covered here.
- */
-import { describe, test, afterEach } from "node:test";
-import assert from "node:assert";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as http from "node:http";
-import { GitLabOAuth, ensureOAuthToken, isAuthInvalidTokenResponse } from "../oauth.js";
-const validTokenFile = {
-    access_token: "cached-access-token",
-    refresh_token: "cached-refresh-token",
-    expires_in: 7200,
-    created_at: Date.now(),
-    token_type: "Bearer",
-};
-const expiredTokenFile = {
-    ...validTokenFile,
-    created_at: Date.now() - 10 * 3600 * 1000,
-};
-const tmpDirs = [];
-const servers = [];
-afterEach(async () => {
-    for (const server of servers.splice(0)) {
-        await new Promise(resolve => server.close(() => resolve()));
-    }
-    for (const dir of tmpDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-function makeTokenFile(data) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oauth-startup-"));
-    tmpDirs.push(dir);
-    const file = path.join(dir, "token.json");
-    fs.writeFileSync(file, JSON.stringify(data));
-    return file;
-}
-function makeClient(tokenStoragePath, gitlabUrl, extra) {
-    return new GitLabOAuth({
-        clientId: "test-client",
-        redirectUri: "http://127.0.0.1:8888/callback",
-        gitlabUrl,
-        scopes: ["api"],
-        tokenStoragePath,
-        ...extra,
-    });
-}
-async function startTokenServer(handler) {
-    const bodies = [];
-    const server = http.createServer((req, res) => {
-        let body = "";
-        req.on("data", (chunk) => {
-            body += chunk.toString();
-        });
-        req.on("end", () => {
-            bodies.push(body);
-            const { status, json } = handler();
-            res.writeHead(status, { "Content-Type": "application/json" });
-            res.end(JSON.stringify(json));
-        });
-    });
-    servers.push(server);
-    await new Promise(resolve => server.listen(0, "127.0.0.1", () => resolve()));
-    const addr = server.address();
-    assert(addr && typeof addr !== "string");
-    return { url: `http://127.0.0.1:${addr.port}`, bodies };
-}
-describe("isAuthInvalidTokenResponse", () => {
-    test("400 invalid_grant is auth-invalid", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_grant"}'), true);
-    });
-    test("400 invalid_token is auth-invalid", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_token"}'), true);
-    });
-    test("401 invalid_grant is auth-invalid", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(401, '{"error":"invalid_grant"}'), true);
-    });
-    test("400 invalid_client is not auth-invalid (config error)", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_client"}'), false);
-    });
-    test("400 invalid_request is not auth-invalid (config error)", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(400, '{"error":"invalid_request"}'), false);
-    });
-    test("500 server_error is not auth-invalid (transient)", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(500, '{"error":"server_error"}'), false);
-    });
-    test("429 is not auth-invalid (rate limited)", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(429, '{"error":"invalid_grant"}'), false);
-    });
-    test("non-JSON body is not auth-invalid", () => {
-        assert.strictEqual(isAuthInvalidTokenResponse(400, "gateway timeout"), false);
-    });
-});
-describe("ensureOAuthToken", () => {
-    test("null client is a no-op", async () => {
-        const delivered = [];
-        await ensureOAuthToken(null, null, t => {
-            delivered.push(t);
-        });
-        await ensureOAuthToken(undefined, undefined, t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, []);
-    });
-    test("first call with valid cached token delivers it without network", async () => {
-        // Closed port: any fetch attempt fails, proving the cached path is network-free.
-        const client = makeClient(makeTokenFile(validTokenFile), "http://127.0.0.1:9");
-        const delivered = [];
-        await ensureOAuthToken(client, null, t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, ["cached-access-token"]);
-    });
-    test("already-held valid token is not re-delivered", async () => {
-        const client = makeClient(makeTokenFile(validTokenFile), "http://127.0.0.1:9");
-        const delivered = [];
-        await ensureOAuthToken(client, "cached-access-token", t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, []);
-    });
-    test("expired token refreshes via /oauth/token and persists", async () => {
-        const { url, bodies } = await startTokenServer(() => ({
-            status: 200,
-            json: {
-                access_token: "fresh-token",
-                refresh_token: "fresh-refresh",
-                expires_in: 7200,
-                token_type: "Bearer",
-            },
-        }));
-        const file = makeTokenFile(expiredTokenFile);
-        const client = makeClient(file, url);
-        const delivered = [];
-        await ensureOAuthToken(client, null, t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, ["fresh-token"]);
-        assert.strictEqual(bodies.length, 1);
-        assert.match(bodies[0], /grant_type=refresh_token/);
-        assert.match(bodies[0], /refresh_token=cached-refresh-token/);
-        const saved = JSON.parse(fs.readFileSync(file, "utf8"));
-        assert.strictEqual(saved.access_token, "fresh-token");
-    });
-    test("transient refresh failure propagates without opening a browser", async () => {
-        const { url } = await startTokenServer(() => ({ status: 500, json: { error: "server_error" } }));
-        const client = makeClient(makeTokenFile(expiredTokenFile), url);
-        const delivered = [];
-        // Rejection (not a browser popup) proves the no-browser path.
-        await assert.rejects(() => ensureOAuthToken(client, null, t => {
-            delivered.push(t);
-        }), /Token refresh failed: 500/);
-        assert.deepStrictEqual(delivered, []);
-    });
-    test("token script resolves once, then fast path holds", async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oauth-startup-"));
-        tmpDirs.push(dir);
-        const client = makeClient(path.join(dir, "token.json"), "http://127.0.0.1:9", {
-            tokenScript: "echo script-token-1",
-        });
-        const delivered = [];
-        await ensureOAuthToken(client, null, t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, ["script-token-1"]);
-        await ensureOAuthToken(client, delivered[0], t => {
-            delivered.push(t);
-        });
-        assert.deepStrictEqual(delivered, ["script-token-1"]);
-    });
-    test("concurrent calls coalesce into a single refresh request", async () => {
-        const { url, bodies } = await startTokenServer(() => ({
-            status: 200,
-            json: {
-                access_token: "coalesced-token",
-                refresh_token: "new-refresh",
-                expires_in: 7200,
-                token_type: "Bearer",
-            },
-        }));
-        const file = makeTokenFile(expiredTokenFile);
-        const client = makeClient(file, url);
-        const deliveredA = [];
-        const deliveredB = [];
-        await Promise.all([
-            ensureOAuthToken(client, null, t => deliveredA.push(t)),
-            ensureOAuthToken(client, null, t => deliveredB.push(t)),
-        ]);
-        assert.deepStrictEqual(deliveredA, ["coalesced-token"]);
-        assert.deepStrictEqual(deliveredB, ["coalesced-token"]);
-        assert.strictEqual(bodies.length, 1);
-    });
-});

package/build/test/oauth-tests.js

@@ -1,428 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * OAuth Authentication Tests
- * Tests for GitLab OAuth2 authentication flow
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as http from 'http';
-import * as net from 'net';
-import { GitLabOAuth } from '../oauth.js';
-// Test configuration
-const TEST_CLIENT_ID = process.env.GITLAB_OAUTH_CLIENT_ID || 'test-client-id';
-const TEST_REDIRECT_URI = process.env.GITLAB_OAUTH_REDIRECT_URI || 'http://127.0.0.1:8888/callback';
-const TEST_GITLAB_URL = process.env.GITLAB_API_URL?.replace('/api/v4', '') || 'https://gitlab.com';
-const TEST_TOKEN_PATH = path.join(process.cwd(), '.test-gitlab-token.json');
-const testResults = [];
-// Helper function to run a single test
-async function runTest(name, testFn, skip = false) {
-    if (skip) {
-        console.log(`⏭️  SKIPPED: ${name}`);
-        testResults.push({ name, status: 'skipped', duration: 0 });
-        return;
-    }
-    const startTime = Date.now();
-    try {
-        console.log(`🧪 Testing: ${name}`);
-        await testFn();
-        const duration = Date.now() - startTime;
-        console.log(`✅ PASSED: ${name} (${duration}ms)`);
-        testResults.push({ name, status: 'passed', duration });
-    }
-    catch (error) {
-        const duration = Date.now() - startTime;
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        console.log(`❌ FAILED: ${name} (${duration}ms)`);
-        console.log(`   Error: ${errorMsg}`);
-        testResults.push({ name, status: 'failed', duration, error: errorMsg });
-    }
-}
-// Helper function to assert conditions
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failed: ${message}`);
-    }
-}
-// Helper function to check if port is available
-async function isPortAvailable(port) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(true);
-            }
-        });
-        server.once('listening', () => {
-            server.close();
-            resolve(true);
-        });
-        server.listen(port, '127.0.0.1');
-    });
-}
-// Clean up test token file
-function cleanupTestToken() {
-    if (fs.existsSync(TEST_TOKEN_PATH)) {
-        fs.unlinkSync(TEST_TOKEN_PATH);
-    }
-}
-// Test 1: GitLabOAuth class instantiation
-async function testOAuthInstantiation() {
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    assert(oauth !== null, 'OAuth instance should be created');
-    assert(typeof oauth.getAccessToken === 'function', 'Should have getAccessToken method');
-    assert(typeof oauth.clearToken === 'function', 'Should have clearToken method');
-    assert(typeof oauth.hasValidToken === 'function', 'Should have hasValidToken method');
-}
-// Test 2: Token storage path configuration
-async function testTokenStoragePath() {
-    const customPath = path.join(process.cwd(), '.custom-test-token.json');
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: customPath,
-    });
-    assert(oauth !== null, 'OAuth instance with custom path should be created');
-    // Clean up
-    if (fs.existsSync(customPath)) {
-        fs.unlinkSync(customPath);
-    }
-}
-// Test 3: Scope configuration
-async function testScopeConfiguration() {
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    assert(oauth !== null, 'OAuth instance with api scope should be created');
-}
-// Test 4: Multiple scopes (should still work but is redundant)
-async function testMultipleScopesRedundant() {
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api', 'read_user', 'read_api', 'write_repository'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    assert(oauth !== null, 'OAuth instance with multiple scopes should be created');
-}
-// Test 5: hasValidToken returns false when no token exists
-async function testHasValidTokenNoToken() {
-    cleanupTestToken();
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    const hasToken = oauth.hasValidToken();
-    assert(hasToken === false, 'Should return false when no token exists');
-}
-// Test 6: hasValidToken returns true with valid token
-async function testHasValidTokenWithToken() {
-    const tokenData = {
-        access_token: 'test-token',
-        token_type: 'Bearer',
-        created_at: Date.now(),
-        expires_in: 7200, // 2 hours
-    };
-    fs.writeFileSync(TEST_TOKEN_PATH, JSON.stringify(tokenData), { mode: 0o600 });
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    const hasToken = oauth.hasValidToken();
-    assert(hasToken === true, 'Should return true with valid token');
-    cleanupTestToken();
-}
-// Test 7: hasValidToken returns false with expired token
-async function testHasValidTokenExpired() {
-    const tokenData = {
-        access_token: 'test-token',
-        token_type: 'Bearer',
-        created_at: Date.now() - 10000000, // 2.7+ hours ago
-        expires_in: 7200, // 2 hours
-    };
-    fs.writeFileSync(TEST_TOKEN_PATH, JSON.stringify(tokenData), { mode: 0o600 });
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    const hasToken = oauth.hasValidToken();
-    assert(hasToken === false, 'Should return false with expired token');
-    cleanupTestToken();
-}
-// Test 8: clearToken removes token file
-async function testClearToken() {
-    const tokenData = {
-        access_token: 'test-token',
-        token_type: 'Bearer',
-        created_at: Date.now(),
-    };
-    fs.writeFileSync(TEST_TOKEN_PATH, JSON.stringify(tokenData), { mode: 0o600 });
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    oauth.clearToken();
-    assert(!fs.existsSync(TEST_TOKEN_PATH), 'Token file should be deleted');
-}
-// Test 9: Token file has correct permissions (Unix only)
-async function testTokenFilePermissions() {
-    if (process.platform === 'win32') {
-        throw new Error('Skipping permission test on Windows');
-    }
-    const tokenData = {
-        access_token: 'test-token',
-        token_type: 'Bearer',
-        created_at: Date.now(),
-    };
-    fs.writeFileSync(TEST_TOKEN_PATH, JSON.stringify(tokenData), { mode: 0o600 });
-    const stats = fs.statSync(TEST_TOKEN_PATH);
-    const mode = stats.mode & 0o777;
-    assert(mode === 0o600, `Token file should have 0600 permissions, got ${mode.toString(8)}`);
-    cleanupTestToken();
-}
-// Test 10: Port availability check
-async function testPortAvailability() {
-    const port = 8888;
-    const available = await isPortAvailable(port);
-    // We just check that the function works, not the actual availability
-    assert(typeof available === 'boolean', 'Port availability check should return boolean');
-}
-// Test: External OAuth token script
-async function testOAuthTokenScript() {
-    const scriptPath = path.join(process.cwd(), '.test-oauth-token-script.sh');
-    const writeScript = (output) => {
-        fs.writeFileSync(scriptPath, `#!/bin/sh\nprintf '%s\\n' '${output}'\n`, { mode: 0o700 });
-    };
-    const oauth = () => new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-        tokenScript: scriptPath,
-    });
-    try {
-        writeScript('script-token-123');
-        const plainToken = await oauth().getAccessToken();
-        assert(plainToken === 'script-token-123', 'Should return plain token from external script');
-        assert(oauth().hasValidToken(), 'Token script should count as a valid token source');
-        writeScript(JSON.stringify({ access_token: 'json-token-123' }));
-        const jsonToken = await oauth().getAccessToken();
-        assert(jsonToken === 'json-token-123', 'Should extract access_token from JSON output');
-        writeScript(JSON.stringify({ expires_in: 3600 }));
-        try {
-            await oauth().getAccessToken();
-            assert(false, 'Should reject JSON output without a token field');
-        }
-        catch (error) {
-            assert(error instanceof Error &&
-                error.message.includes('OAuth token script JSON must include a string access_token or token field'), 'Should explain missing token field in JSON output');
-        }
-    }
-    finally {
-        if (fs.existsSync(scriptPath)) {
-            fs.unlinkSync(scriptPath);
-        }
-    }
-}
-// Test 11: OAuth redirect URI parsing
-async function testRedirectUriParsing() {
-    const redirectUri = 'http://127.0.0.1:8888/callback';
-    const url = new URL(redirectUri);
-    assert(url.port === '8888', 'Should correctly parse port from redirect URI');
-    assert(url.pathname === '/callback', 'Should correctly parse path from redirect URI');
-    assert(url.hostname === '127.0.0.1', 'Should correctly parse hostname from redirect URI');
-}
-// Test 12: Token expiration calculation
-async function testTokenExpirationCalculation() {
-    const now = Date.now();
-    const expiresIn = 7200; // 2 hours in seconds
-    const buffer = 5 * 60 * 1000; // 5 minutes in milliseconds
-    const expiryTime = now + (expiresIn * 1000);
-    const shouldRefreshAt = expiryTime - buffer;
-    assert(shouldRefreshAt < expiryTime, 'Refresh time should be before expiry');
-    assert(shouldRefreshAt > now, 'Refresh time should be in the future for new token');
-}
-// Test 13: Concurrent OAuth server handling (shared server concept)
-async function testSharedServerConcept() {
-    // Test that multiple instances can theoretically share a port
-    const port = 9999;
-    // First instance: start server
-    const server = http.createServer((req, res) => {
-        res.writeHead(200);
-        res.end('OK');
-    });
-    await new Promise((resolve) => {
-        server.listen(port, '127.0.0.1', () => resolve());
-    });
-    // Check port is now in use
-    const inUse = !(await isPortAvailable(port));
-    assert(inUse === true, 'Port should be in use after server starts');
-    // Clean up
-    await new Promise((resolve) => {
-        server.close(() => resolve());
-    });
-    // Check port is available again
-    const available = await isPortAvailable(port);
-    assert(available === true, 'Port should be available after server closes');
-}
-// Test 14: Environment variable configuration
-async function testEnvironmentVariableConfig() {
-    const clientId = process.env.GITLAB_OAUTH_CLIENT_ID;
-    const redirectUri = process.env.GITLAB_OAUTH_REDIRECT_URI || 'http://127.0.0.1:8888/callback';
-    assert(typeof clientId === 'string' || clientId === undefined, 'Client ID should be string or undefined');
-    assert(typeof redirectUri === 'string', 'Redirect URI should be string');
-    const url = new URL(redirectUri);
-    assert(url.protocol === 'http:', 'Redirect URI should use http protocol for localhost');
-}
-// Test 15: Token data structure validation
-async function testTokenDataStructure() {
-    const tokenData = {
-        access_token: 'glpat-test123456789',
-        refresh_token: 'refresh-test123456789',
-        token_type: 'Bearer',
-        expires_in: 7200,
-        created_at: Date.now(),
-    };
-    assert(typeof tokenData.access_token === 'string', 'access_token should be string');
-    assert(typeof tokenData.token_type === 'string', 'token_type should be string');
-    assert(typeof tokenData.created_at === 'number', 'created_at should be number');
-    assert(tokenData.expires_in === undefined || typeof tokenData.expires_in === 'number', 'expires_in should be number or undefined');
-}
-// Test 16: Invalid token storage path handling
-async function testInvalidTokenStoragePath() {
-    const invalidPath = '/root/nonexistent/directory/.token.json';
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: invalidPath,
-    });
-    // Should create instance even with invalid path (error occurs during save)
-    assert(oauth !== null, 'Should create instance with invalid path');
-}
-// Test 17: Self-hosted GitLab URL configuration
-async function testSelfHostedGitLabUrl() {
-    const selfHostedUrl = 'https://gitlab.example.com';
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: TEST_REDIRECT_URI,
-        gitlabUrl: selfHostedUrl,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    assert(oauth !== null, 'Should create instance with self-hosted URL');
-}
-// Test 18: Custom port in redirect URI
-async function testCustomPortInRedirectUri() {
-    const customRedirectUri = 'http://127.0.0.1:9999/callback';
-    const oauth = new GitLabOAuth({
-        clientId: TEST_CLIENT_ID,
-        redirectUri: customRedirectUri,
-        gitlabUrl: TEST_GITLAB_URL,
-        scopes: ['api'],
-        tokenStoragePath: TEST_TOKEN_PATH,
-    });
-    assert(oauth !== null, 'Should create instance with custom port');
-    const url = new URL(customRedirectUri);
-    assert(url.port === '9999', 'Should correctly parse custom port');
-}
-// Main test runner
-async function runOAuthTests() {
-    console.log('🚀 GitLab OAuth Authentication Tests\n');
-    console.log('='.repeat(50));
-    // Core functionality tests
-    await runTest('OAuth class instantiation', testOAuthInstantiation);
-    await runTest('Token storage path configuration', testTokenStoragePath);
-    await runTest('Scope configuration with api only', testScopeConfiguration);
-    await runTest('Multiple scopes configuration (redundant)', testMultipleScopesRedundant);
-    // Token management tests
-    await runTest('hasValidToken returns false without token', testHasValidTokenNoToken);
-    await runTest('hasValidToken returns true with valid token', testHasValidTokenWithToken);
-    await runTest('hasValidToken returns false with expired token', testHasValidTokenExpired);
-    await runTest('clearToken removes token file', testClearToken);
-    await runTest('Token file has correct permissions', testTokenFilePermissions, process.platform === 'win32');
-    await runTest('External OAuth token script', testOAuthTokenScript, process.platform === 'win32');
-    // Network and configuration tests
-    await runTest('Port availability check', testPortAvailability);
-    await runTest('OAuth redirect URI parsing', testRedirectUriParsing);
-    await runTest('Token expiration calculation', testTokenExpirationCalculation);
-    await runTest('Shared server concept', testSharedServerConcept);
-    // Configuration tests
-    await runTest('Environment variable configuration', testEnvironmentVariableConfig);
-    await runTest('Token data structure validation', testTokenDataStructure);
-    await runTest('Invalid token storage path handling', testInvalidTokenStoragePath);
-    await runTest('Self-hosted GitLab URL configuration', testSelfHostedGitLabUrl);
-    await runTest('Custom port in redirect URI', testCustomPortInRedirectUri);
-    // Cleanup
-    cleanupTestToken();
-    // Print summary
-    console.log('\n' + '='.repeat(50));
-    console.log('📊 Test Results Summary\n');
-    const passed = testResults.filter(r => r.status === 'passed').length;
-    const failed = testResults.filter(r => r.status === 'failed').length;
-    const skipped = testResults.filter(r => r.status === 'skipped').length;
-    const total = testResults.length;
-    console.log(`Total tests: ${total}`);
-    console.log(`✅ Passed: ${passed}`);
-    console.log(`❌ Failed: ${failed}`);
-    console.log(`⏭️  Skipped: ${skipped}`);
-    if (total > 0) {
-        const successRate = ((passed / (total - skipped)) * 100).toFixed(1);
-        console.log(`Success rate: ${successRate}%`);
-    }
-    // Show failed tests
-    const failedTests = testResults.filter(r => r.status === 'failed');
-    if (failedTests.length > 0) {
-        console.log('\n❌ Failed Tests:');
-        failedTests.forEach(test => {
-            console.log(`  - ${test.name}`);
-            console.log(`    ${test.error}`);
-        });
-    }
-    // Save results to file
-    const reportPath = 'test-results-oauth.json';
-    fs.writeFileSync(reportPath, JSON.stringify(testResults, null, 2));
-    console.log(`\n📄 Detailed results saved to ${reportPath}`);
-    return failed === 0;
-}
-// Run tests if this is the main module
-if (import.meta.url === `file://${process.argv[1]}`) {
-    runOAuthTests()
-        .then(success => {
-        process.exit(success ? 0 : 1);
-    })
-        .catch(error => {
-        console.error('Error running tests:', error);
-        process.exit(1);
-    });
-}
-export { runOAuthTests, testResults };