archicore 0.3.0 → 0.3.2

package/dist/gitlab/gitlab-service.js

@@ -0,0 +1,652 @@
+/**
+ * GitLab Integration Service
+ *
+ * Manages GitLab connections with support for:
+ * - Multiple GitLab instances (self-hosted + gitlab.com)
+ * - Personal Access Token (PAT) authentication
+ * - Private repositories access
+ * - Branch listing and selection
+ * - Webhooks for auto-analysis
+ * - Merge Request analysis
+ */
+import { randomBytes, createCipheriv, createDecipheriv, createHash } from 'crypto';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { Logger } from '../utils/logger.js';
+// Storage paths
+const DATA_DIR = process.env.ARCHICORE_DATA_DIR || '.archicore';
+const INSTANCES_FILE = 'gitlab-instances.json';
+const REPOSITORIES_FILE = 'gitlab-repositories.json';
+// Encryption key for tokens
+const ENCRYPTION_KEY = process.env.GITLAB_ENCRYPTION_KEY || process.env.ENCRYPTION_KEY || 'archicore-gitlab-key-32bytes!!';
+// Webhook base URL - construct from PUBLIC_URL or API_URL
+const getWebhookUrl = () => {
+    // Use explicit GitLab webhook URL if set
+    if (process.env.GITLAB_WEBHOOK_URL) {
+        return process.env.GITLAB_WEBHOOK_URL;
+    }
+    // Otherwise construct from API_URL or PUBLIC_URL
+    const baseUrl = process.env.API_URL || process.env.PUBLIC_URL || 'http://localhost:3000';
+    return `${baseUrl}/api/gitlab/webhook`;
+};
+const WEBHOOK_BASE_URL = getWebhookUrl();
+// Singleton instance
+let instance = null;
+export class GitLabService {
+    instances = [];
+    repositories = [];
+    initialized = false;
+    dataDir = DATA_DIR;
+    constructor(config) {
+        // Singleton pattern
+        if (instance) {
+            return instance;
+        }
+        instance = this;
+        this.dataDir = config?.dataDir || DATA_DIR;
+    }
+    // ===== INITIALIZATION =====
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        try {
+            await this.loadInstances();
+            await this.loadRepositories();
+            this.initialized = true;
+        }
+        catch (error) {
+            Logger.error('GitLab service initialization failed:', error);
+            throw error;
+        }
+    }
+    async loadInstances() {
+        const filePath = join(this.dataDir, INSTANCES_FILE);
+        if (existsSync(filePath)) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                this.instances = data.instances || [];
+                Logger.info(`Loaded ${this.instances.length} GitLab instances`);
+            }
+            catch (error) {
+                Logger.warn('Could not load GitLab instances:', error);
+                this.instances = [];
+            }
+        }
+    }
+    async saveInstances() {
+        try {
+            if (!existsSync(this.dataDir)) {
+                await mkdir(this.dataDir, { recursive: true });
+            }
+            const filePath = join(this.dataDir, INSTANCES_FILE);
+            await writeFile(filePath, JSON.stringify({ instances: this.instances }, null, 2));
+        }
+        catch (error) {
+            Logger.error('Could not save GitLab instances:', error);
+        }
+    }
+    async loadRepositories() {
+        const filePath = join(this.dataDir, REPOSITORIES_FILE);
+        if (existsSync(filePath)) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const data = JSON.parse(content);
+                this.repositories = data.repositories || [];
+                Logger.info(`Loaded ${this.repositories.length} connected GitLab repositories`);
+            }
+            catch (error) {
+                Logger.warn('Could not load GitLab repositories:', error);
+                this.repositories = [];
+            }
+        }
+    }
+    async saveRepositories() {
+        try {
+            if (!existsSync(this.dataDir)) {
+                await mkdir(this.dataDir, { recursive: true });
+            }
+            const filePath = join(this.dataDir, REPOSITORIES_FILE);
+            await writeFile(filePath, JSON.stringify({ repositories: this.repositories }, null, 2));
+        }
+        catch (error) {
+            Logger.error('Could not save GitLab repositories:', error);
+        }
+    }
+    // ===== ENCRYPTION =====
+    encrypt(text) {
+        const iv = randomBytes(16);
+        const key = createHash('sha256').update(ENCRYPTION_KEY).digest();
+        const cipher = createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return iv.toString('hex') + ':' + encrypted;
+    }
+    decrypt(encrypted) {
+        try {
+            const parts = encrypted.split(':');
+            if (parts.length !== 2)
+                return encrypted; // Not encrypted
+            const iv = Buffer.from(parts[0], 'hex');
+            const key = createHash('sha256').update(ENCRYPTION_KEY).digest();
+            const decipher = createDecipheriv('aes-256-cbc', key, iv);
+            let decrypted = decipher.update(parts[1], 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        }
+        catch {
+            return encrypted; // Return as-is if decryption fails
+        }
+    }
+    // ===== INSTANCE MANAGEMENT =====
+    /**
+     * Add a new GitLab instance connection
+     */
+    async addInstance(userId, instanceUrl, accessToken, options = {}) {
+        await this.ensureInitialized();
+        // Normalize URL (remove trailing slash)
+        const normalizedUrl = instanceUrl.replace(/\/+$/, '');
+        // Validate token by fetching user info
+        const user = await this.fetchGitLabUser(normalizedUrl, accessToken, options.rejectUnauthorizedSSL);
+        // Check if instance already exists for this user
+        const existingIndex = this.instances.findIndex(i => i.userId === userId && i.instanceUrl === normalizedUrl);
+        const instanceData = {
+            id: existingIndex >= 0 ? this.instances[existingIndex].id : uuidv4(),
+            name: options.name || this.getInstanceName(normalizedUrl),
+            instanceUrl: normalizedUrl,
+            userId,
+            gitlabUserId: user.id,
+            gitlabUsername: user.username,
+            accessToken: this.encrypt(accessToken),
+            tokenScopes: await this.getTokenScopes(normalizedUrl, accessToken, options.rejectUnauthorizedSSL),
+            rejectUnauthorizedSSL: options.rejectUnauthorizedSSL ?? true,
+            createdAt: existingIndex >= 0 ? this.instances[existingIndex].createdAt : new Date(),
+            lastUsedAt: new Date()
+        };
+        if (existingIndex >= 0) {
+            this.instances[existingIndex] = instanceData;
+            Logger.info(`Updated GitLab instance: ${instanceData.name} for user ${userId}`);
+        }
+        else {
+            this.instances.push(instanceData);
+            Logger.info(`Added GitLab instance: ${instanceData.name} for user ${userId}`);
+        }
+        await this.saveInstances();
+        return instanceData;
+    }
+    /**
+     * Get instance display name from URL
+     */
+    getInstanceName(url) {
+        try {
+            const hostname = new URL(url).hostname;
+            if (hostname === 'gitlab.com')
+                return 'GitLab.com';
+            return hostname;
+        }
+        catch {
+            return url;
+        }
+    }
+    /**
+     * Get all GitLab instances for a user
+     */
+    async getInstances(userId) {
+        await this.ensureInitialized();
+        return this.instances
+            .filter(i => i.userId === userId)
+            .map(i => ({ ...i, accessToken: '[ENCRYPTED]' })); // Don't expose tokens
+    }
+    /**
+     * Get a specific instance by ID
+     */
+    async getInstance(instanceId) {
+        await this.ensureInitialized();
+        return this.instances.find(i => i.id === instanceId) || null;
+    }
+    /**
+     * Remove a GitLab instance connection
+     */
+    async removeInstance(userId, instanceId) {
+        await this.ensureInitialized();
+        const index = this.instances.findIndex(i => i.id === instanceId && i.userId === userId);
+        if (index === -1)
+            return false;
+        // Also remove all connected repositories for this instance
+        this.repositories = this.repositories.filter(r => r.instanceId !== instanceId);
+        this.instances.splice(index, 1);
+        await this.saveInstances();
+        await this.saveRepositories();
+        Logger.info(`Removed GitLab instance: ${instanceId}`);
+        return true;
+    }
+    // ===== GITLAB API HELPERS =====
+    /**
+     * Make authenticated request to GitLab API
+     */
+    async gitlabFetch(instanceUrl, accessToken, endpoint, options = {}) {
+        const url = `${instanceUrl}/api/v4${endpoint}`;
+        const fetchOptions = {
+            method: options.method || 'GET',
+            headers: {
+                'PRIVATE-TOKEN': accessToken,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            }
+        };
+        if (options.body) {
+            fetchOptions.body = JSON.stringify(options.body);
+        }
+        // Note: For self-signed certificates, Node.js fetch doesn't support
+        // rejectUnauthorized directly. Users may need to set NODE_TLS_REJECT_UNAUTHORIZED=0
+        // or use a custom agent in production.
+        const response = await fetch(url, fetchOptions);
+        if (!response.ok) {
+            const errorText = await response.text();
+            let errorMessage = `GitLab API error: ${response.status}`;
+            try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage = errorJson.message || errorJson.error || errorMessage;
+            }
+            catch {
+                errorMessage = errorText || errorMessage;
+            }
+            throw new Error(errorMessage);
+        }
+        return response.json();
+    }
+    /**
+     * Fetch current GitLab user info
+     */
+    async fetchGitLabUser(instanceUrl, accessToken, rejectUnauthorizedSSL) {
+        return this.gitlabFetch(instanceUrl, accessToken, '/user', { rejectUnauthorizedSSL });
+    }
+    /**
+     * Get token scopes (by testing API endpoints)
+     */
+    async getTokenScopes(instanceUrl, accessToken, rejectUnauthorizedSSL) {
+        const scopes = [];
+        // Test read_user scope
+        try {
+            await this.gitlabFetch(instanceUrl, accessToken, '/user', { rejectUnauthorizedSSL });
+            scopes.push('read_user');
+        }
+        catch { /* no access */ }
+        // Test read_api/api scope (list projects)
+        try {
+            await this.gitlabFetch(instanceUrl, accessToken, '/projects?per_page=1', { rejectUnauthorizedSSL });
+            scopes.push('read_api');
+        }
+        catch { /* no access */ }
+        // Test read_repository scope
+        try {
+            const projects = await this.gitlabFetch(instanceUrl, accessToken, '/projects?per_page=1&membership=true', { rejectUnauthorizedSSL });
+            if (projects.length > 0) {
+                try {
+                    await this.gitlabFetch(instanceUrl, accessToken, `/projects/${projects[0].id}/repository/branches?per_page=1`, { rejectUnauthorizedSSL });
+                    scopes.push('read_repository');
+                }
+                catch { /* no access */ }
+            }
+        }
+        catch { /* no access */ }
+        // Test write_repository scope (we don't actually write, just assume if api scope)
+        if (scopes.includes('read_api')) {
+            scopes.push('api'); // Full API access likely
+        }
+        return scopes;
+    }
+    // ===== REPOSITORY MANAGEMENT =====
+    /**
+     * List all accessible projects from a GitLab instance
+     */
+    async listProjects(userId, instanceId, options = {}) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const params = new URLSearchParams();
+        if (options.search)
+            params.set('search', options.search);
+        if (options.membership !== false)
+            params.set('membership', 'true');
+        if (options.owned)
+            params.set('owned', 'true');
+        params.set('order_by', 'last_activity_at');
+        params.set('sort', 'desc');
+        params.set('per_page', String(options.perPage || 50));
+        params.set('page', String(options.page || 1));
+        const endpoint = `/projects?${params.toString()}`;
+        return this.gitlabFetch(instance.instanceUrl, accessToken, endpoint, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+    }
+    /**
+     * Get a specific project by ID
+     */
+    async getProject(userId, instanceId, projectId) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        return this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}`, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+    }
+    /**
+     * List branches for a project
+     */
+    async listBranches(userId, instanceId, projectId) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        return this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/repository/branches?per_page=100`, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+    }
+    /**
+     * Connect a GitLab repository to ArchiCore
+     */
+    async connectRepository(userId, instanceId, projectId, options = {}) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        // Check if already connected
+        const existing = this.repositories.find(r => r.instanceId === instanceId && r.gitlabProjectId === projectId);
+        if (existing && !options.forceReconnect) {
+            return existing;
+        }
+        // Fetch project info
+        const project = await this.getProject(userId, instanceId, projectId);
+        const repoData = {
+            id: existing?.id || uuidv4(),
+            instanceId,
+            gitlabProjectId: project.id,
+            fullPath: project.path_with_namespace,
+            name: project.name,
+            owner: project.namespace.path,
+            visibility: project.visibility,
+            defaultBranch: project.default_branch,
+            autoAnalyze: options.autoAnalyze ?? true,
+            analyzeMRs: options.analyzeMRs ?? true,
+            status: 'pending',
+            createdAt: existing?.createdAt || new Date(),
+            updatedAt: new Date()
+        };
+        // Remove existing if force reconnect
+        if (existing) {
+            const index = this.repositories.findIndex(r => r.id === existing.id);
+            if (index >= 0) {
+                this.repositories.splice(index, 1);
+            }
+        }
+        this.repositories.push(repoData);
+        await this.saveRepositories();
+        Logger.info(`Connected GitLab repository: ${project.path_with_namespace}`);
+        return repoData;
+    }
+    /**
+     * Get all connected repositories for a user
+     */
+    async getConnectedRepositories(userId) {
+        await this.ensureInitialized();
+        // Get user's instances
+        const userInstanceIds = this.instances
+            .filter(i => i.userId === userId)
+            .map(i => i.id);
+        return this.repositories.filter(r => userInstanceIds.includes(r.instanceId));
+    }
+    /**
+     * Get a specific connected repository
+     */
+    async getConnectedRepository(repoId) {
+        await this.ensureInitialized();
+        return this.repositories.find(r => r.id === repoId) || null;
+    }
+    /**
+     * Disconnect a repository
+     */
+    async disconnectRepository(userId, repoId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (!repo)
+            return false;
+        // Verify ownership
+        const instance = this.instances.find(i => i.id === repo.instanceId);
+        if (!instance || instance.userId !== userId)
+            return false;
+        // Remove webhook if exists
+        if (repo.webhookId) {
+            try {
+                await this.deleteWebhook(userId, repo.instanceId, repo.gitlabProjectId, repo.webhookId);
+            }
+            catch (error) {
+                Logger.warn(`Failed to delete webhook for ${repo.fullPath}:`, error);
+            }
+        }
+        const index = this.repositories.findIndex(r => r.id === repoId);
+        if (index >= 0) {
+            this.repositories.splice(index, 1);
+            await this.saveRepositories();
+            Logger.info(`Disconnected GitLab repository: ${repo.fullPath}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Update repository's ArchiCore project ID
+     */
+    async updateRepositoryProjectId(repoId, projectId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (repo) {
+            repo.projectId = projectId;
+            repo.updatedAt = new Date();
+            await this.saveRepositories();
+        }
+    }
+    /**
+     * Update repository status
+     */
+    async updateRepositoryStatus(repoId, status, error) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (repo) {
+            repo.status = status;
+            repo.lastError = error;
+            repo.updatedAt = new Date();
+            await this.saveRepositories();
+        }
+    }
+    /**
+     * Update last analyzed timestamp
+     */
+    async updateLastAnalyzed(repoId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.id === repoId);
+        if (repo) {
+            repo.lastAnalyzedAt = new Date();
+            repo.updatedAt = new Date();
+            await this.saveRepositories();
+        }
+    }
+    // ===== REPOSITORY CONTENT =====
+    /**
+     * Download repository archive
+     */
+    async downloadRepository(userId, instanceId, projectId, ref) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        const sha = ref || 'HEAD';
+        const url = `${instance.instanceUrl}/api/v4/projects/${encodedId}/repository/archive.zip?sha=${encodeURIComponent(sha)}`;
+        const response = await fetch(url, {
+            headers: {
+                'PRIVATE-TOKEN': accessToken
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download repository: ${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    /**
+     * Get file content from repository
+     */
+    async getFileContent(userId, instanceId, projectId, filePath, ref) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        const encodedPath = encodeURIComponent(filePath);
+        const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : '';
+        const file = await this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/repository/files/${encodedPath}${refParam}`, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+        if (file.encoding === 'base64') {
+            return Buffer.from(file.content, 'base64').toString('utf-8');
+        }
+        return file.content;
+    }
+    // ===== MERGE REQUESTS =====
+    /**
+     * Get merge request details
+     */
+    async getMergeRequest(userId, instanceId, projectId, mrIid) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        return this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/merge_requests/${mrIid}`, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+    }
+    /**
+     * Get merge request changes (diff)
+     */
+    async getMergeRequestChanges(userId, instanceId, projectId, mrIid) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        const response = await this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/merge_requests/${mrIid}/changes`, { rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL });
+        return response.changes;
+    }
+    /**
+     * Post a comment on merge request
+     */
+    async postMRComment(userId, instanceId, projectId, mrIid, body) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        return this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/merge_requests/${mrIid}/notes`, {
+            method: 'POST',
+            body: { body },
+            rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL
+        });
+    }
+    // ===== WEBHOOKS =====
+    /**
+     * Create webhook for repository
+     */
+    async createWebhook(userId, instanceId, projectId) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const secret = randomBytes(32).toString('hex');
+        const encodedId = encodeURIComponent(String(projectId));
+        const webhook = await this.gitlabFetch(instance.instanceUrl, accessToken, `/projects/${encodedId}/hooks`, {
+            method: 'POST',
+            body: {
+                url: WEBHOOK_BASE_URL,
+                token: secret,
+                push_events: true,
+                merge_requests_events: true,
+                enable_ssl_verification: instance.rejectUnauthorizedSSL
+            },
+            rejectUnauthorizedSSL: instance.rejectUnauthorizedSSL
+        });
+        return { id: webhook.id, secret };
+    }
+    /**
+     * Delete webhook
+     */
+    async deleteWebhook(userId, instanceId, projectId, hookId) {
+        await this.ensureInitialized();
+        const instance = this.instances.find(i => i.id === instanceId && i.userId === userId);
+        if (!instance) {
+            throw new Error('GitLab instance not found');
+        }
+        const accessToken = this.decrypt(instance.accessToken);
+        const encodedId = encodeURIComponent(String(projectId));
+        await fetch(`${instance.instanceUrl}/api/v4/projects/${encodedId}/hooks/${hookId}`, {
+            method: 'DELETE',
+            headers: { 'PRIVATE-TOKEN': accessToken }
+        });
+    }
+    /**
+     * Verify webhook token
+     */
+    verifyWebhookToken(token, expectedToken) {
+        return token === expectedToken;
+    }
+    /**
+     * Find repository by webhook (for incoming webhooks)
+     */
+    async findRepositoryByWebhook(fullPath) {
+        await this.ensureInitialized();
+        return this.repositories.find(r => r.fullPath === fullPath) || null;
+    }
+    /**
+     * Get instance for repository (used in webhook handling)
+     */
+    async getInstanceForRepository(repo) {
+        await this.ensureInitialized();
+        return this.instances.find(i => i.id === repo.instanceId) || null;
+    }
+    /**
+     * Get decrypted webhook secret
+     */
+    getWebhookSecret(encryptedSecret) {
+        return this.decrypt(encryptedSecret);
+    }
+    /**
+     * Disconnect repository by ArchiCore project ID
+     */
+    async disconnectRepositoryByProjectId(projectId) {
+        await this.ensureInitialized();
+        const repo = this.repositories.find(r => r.projectId === projectId);
+        if (!repo)
+            return false;
+        const instance = this.instances.find(i => i.id === repo.instanceId);
+        if (!instance)
+            return false;
+        return this.disconnectRepository(instance.userId, repo.id);
+    }
+}
+export default GitLabService;
+//# sourceMappingURL=gitlab-service.js.map

package/dist/gitlab/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitLab Integration Module
+ *
+ * Exports GitLab service and types for integration with ArchiCore
+ */
+export { GitLabService, default } from './gitlab-service.js';
+export * from '../types/gitlab.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gitlab/index.js

@@ -0,0 +1,8 @@
+/**
+ * GitLab Integration Module
+ *
+ * Exports GitLab service and types for integration with ArchiCore
+ */
+export { GitLabService, default } from './gitlab-service.js';
+export * from '../types/gitlab.js';
+//# sourceMappingURL=index.js.map

package/dist/server/config/passport.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Passport OAuth Configuration
+ * Google and GitHub authentication strategies
+ */
+import passport from 'passport';
+export interface OAuthProfile {
+    id: string;
+    email: string;
+    displayName: string;
+    avatar?: string;
+    provider: 'google' | 'github';
+}
+export default passport;
+//# sourceMappingURL=passport.d.ts.map