archicore 0.3.0 → 0.3.2

package/dist/server/routes/gitlab.js

@@ -0,0 +1,528 @@
+/**
+ * GitLab Integration Routes for ArchiCore
+ *
+ * Provides API endpoints for:
+ * - Managing GitLab instances (add, remove, list)
+ * - Listing and connecting repositories
+ * - Branch selection
+ * - Webhooks for auto-analysis
+ */
+import { Router } from 'express';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+import AdmZip from 'adm-zip';
+import { GitLabService } from '../../gitlab/gitlab-service.js';
+import { ProjectService } from '../services/project-service.js';
+import { AuthService } from '../services/auth-service.js';
+import { authMiddleware } from './auth.js';
+import { Logger } from '../../utils/logger.js';
+export const gitlabRouter = Router();
+// Services
+const gitlabService = new GitLabService();
+const projectService = new ProjectService();
+const authService = AuthService.getInstance();
+// ===== INSTANCE MANAGEMENT =====
+/**
+ * POST /api/gitlab/instances
+ * Add a new GitLab instance connection
+ */
+gitlabRouter.post('/instances', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const { instanceUrl, accessToken, name, rejectUnauthorizedSSL } = req.body;
+        if (!instanceUrl || !accessToken) {
+            res.status(400).json({ error: 'instanceUrl and accessToken are required' });
+            return;
+        }
+        const instance = await gitlabService.addInstance(req.user.id, instanceUrl, accessToken, { name, rejectUnauthorizedSSL });
+        res.json({
+            success: true,
+            instance: {
+                id: instance.id,
+                name: instance.name,
+                instanceUrl: instance.instanceUrl,
+                gitlabUsername: instance.gitlabUsername,
+                tokenScopes: instance.tokenScopes,
+                createdAt: instance.createdAt
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Add GitLab instance error:', error);
+        const message = error instanceof Error ? error.message : 'Failed to add GitLab instance';
+        res.status(500).json({ error: message });
+    }
+});
+/**
+ * GET /api/gitlab/instances
+ * List all GitLab instances for current user
+ */
+gitlabRouter.get('/instances', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const instances = await gitlabService.getInstances(req.user.id);
+        res.json({
+            instances: instances.map(i => ({
+                id: i.id,
+                name: i.name,
+                instanceUrl: i.instanceUrl,
+                gitlabUsername: i.gitlabUsername,
+                tokenScopes: i.tokenScopes,
+                createdAt: i.createdAt,
+                lastUsedAt: i.lastUsedAt
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List GitLab instances error:', error);
+        res.status(500).json({ error: 'Failed to list GitLab instances' });
+    }
+});
+/**
+ * DELETE /api/gitlab/instances/:id
+ * Remove a GitLab instance connection
+ */
+gitlabRouter.delete('/instances/:id', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const success = await gitlabService.removeInstance(req.user.id, req.params.id);
+        if (!success) {
+            res.status(404).json({ error: 'GitLab instance not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Remove GitLab instance error:', error);
+        res.status(500).json({ error: 'Failed to remove GitLab instance' });
+    }
+});
+// ===== PROJECTS/REPOSITORIES =====
+/**
+ * GET /api/gitlab/instances/:instanceId/projects
+ * List available projects from a GitLab instance
+ */
+gitlabRouter.get('/instances/:instanceId/projects', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const { search, owned, page, per_page } = req.query;
+        const projects = await gitlabService.listProjects(req.user.id, req.params.instanceId, {
+            search: search,
+            owned: owned === 'true',
+            page: page ? parseInt(page, 10) : undefined,
+            perPage: per_page ? parseInt(per_page, 10) : undefined
+        });
+        // Get connected repositories to mark them
+        const connectedRepos = await gitlabService.getConnectedRepositories(req.user.id);
+        const connectedProjectIds = new Set(connectedRepos.map(r => r.gitlabProjectId));
+        res.json({
+            projects: projects.map(p => ({
+                id: p.id,
+                name: p.name,
+                fullPath: p.path_with_namespace,
+                description: p.description,
+                visibility: p.visibility,
+                defaultBranch: p.default_branch,
+                webUrl: p.web_url,
+                stars: p.star_count,
+                forks: p.forks_count,
+                lastActivity: p.last_activity_at,
+                namespace: p.namespace.name,
+                archived: p.archived,
+                connected: connectedProjectIds.has(p.id),
+                projectId: connectedRepos.find(r => r.gitlabProjectId === p.id)?.projectId
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List GitLab projects error:', error);
+        const message = error instanceof Error ? error.message : 'Failed to list projects';
+        res.status(500).json({ error: message });
+    }
+});
+/**
+ * GET /api/gitlab/instances/:instanceId/projects/:projectId/branches
+ * List branches for a GitLab project
+ */
+gitlabRouter.get('/instances/:instanceId/projects/:projectId/branches', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const projectId = parseInt(req.params.projectId, 10) || req.params.projectId;
+        // Get project info for default branch
+        const project = await gitlabService.getProject(req.user.id, req.params.instanceId, projectId);
+        const branches = await gitlabService.listBranches(req.user.id, req.params.instanceId, projectId);
+        res.json({
+            branches: branches.map(b => ({
+                name: b.name,
+                protected: b.protected,
+                isDefault: b.name === project.default_branch,
+                lastCommit: {
+                    id: b.commit.short_id,
+                    title: b.commit.title,
+                    date: b.commit.created_at
+                }
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List branches error:', error);
+        const message = error instanceof Error ? error.message : 'Failed to list branches';
+        res.status(500).json({ error: message });
+    }
+});
+// ===== CONNECTED REPOSITORIES =====
+/**
+ * GET /api/gitlab/repositories
+ * List all connected GitLab repositories
+ */
+gitlabRouter.get('/repositories', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const repositories = await gitlabService.getConnectedRepositories(req.user.id);
+        res.json({
+            repositories: repositories.map(r => ({
+                id: r.id,
+                instanceId: r.instanceId,
+                fullPath: r.fullPath,
+                name: r.name,
+                owner: r.owner,
+                visibility: r.visibility,
+                projectId: r.projectId,
+                autoAnalyze: r.autoAnalyze,
+                analyzeMRs: r.analyzeMRs,
+                status: r.status,
+                lastAnalyzedAt: r.lastAnalyzedAt,
+                createdAt: r.createdAt
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List connected repositories error:', error);
+        res.status(500).json({ error: 'Failed to list repositories' });
+    }
+});
+/**
+ * POST /api/gitlab/repositories/connect
+ * Connect a GitLab repository to ArchiCore
+ */
+gitlabRouter.post('/repositories/connect', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const { instanceId, projectId, autoAnalyze, analyzeMRs, createProject, projectName, branch, forceReconnect } = req.body;
+        if (!instanceId || !projectId) {
+            res.status(400).json({ error: 'instanceId and projectId are required' });
+            return;
+        }
+        // Connect repository
+        const connectedRepo = await gitlabService.connectRepository(req.user.id, instanceId, projectId, { autoAnalyze, analyzeMRs, forceReconnect });
+        // Optionally create ArchiCore project
+        let archiProjectId;
+        if (createProject !== false) {
+            try {
+                // Download repository
+                const project = await gitlabService.getProject(req.user.id, instanceId, projectId);
+                const targetBranch = branch || project.default_branch || 'main';
+                Logger.progress(`Downloading GitLab repository: ${project.path_with_namespace} (branch: ${targetBranch})`);
+                const zipBuffer = await gitlabService.downloadRepository(req.user.id, instanceId, projectId, targetBranch);
+                Logger.info(`Downloaded ZIP: ${zipBuffer.length} bytes`);
+                // Create projects directory
+                const projectsDir = process.env.PROJECTS_DIR || join('.archicore', 'projects');
+                await mkdir(projectsDir, { recursive: true });
+                // Extract to project directory
+                const projectPath = join(projectsDir, project.name);
+                await mkdir(projectPath, { recursive: true });
+                const zip = new AdmZip(zipBuffer);
+                const zipEntries = zip.getEntries();
+                Logger.info(`ZIP contains ${zipEntries.length} entries`);
+                // Extract files
+                let extractedCount = 0;
+                for (const entry of zipEntries) {
+                    if (entry.isDirectory) {
+                        const dirPath = join(projectPath, entry.entryName);
+                        await mkdir(dirPath, { recursive: true });
+                    }
+                    else {
+                        const filePath = join(projectPath, entry.entryName);
+                        const fileDir = join(projectPath, entry.entryName.split('/').slice(0, -1).join('/'));
+                        await mkdir(fileDir, { recursive: true });
+                        const content = entry.getData();
+                        const { writeFile } = await import('fs/promises');
+                        await writeFile(filePath, content);
+                        extractedCount++;
+                    }
+                }
+                Logger.info(`Extraction complete: ${extractedCount} files extracted`);
+                // GitLab creates a folder like "project-branch" inside, find it
+                const { readdir, stat } = await import('fs/promises');
+                const contents = await readdir(projectPath);
+                let actualPath = projectPath;
+                if (contents.length === 1) {
+                    const innerPath = join(projectPath, contents[0]);
+                    const stats = await stat(innerPath);
+                    if (stats.isDirectory()) {
+                        actualPath = innerPath;
+                        Logger.info(`Using inner path: ${actualPath}`);
+                    }
+                }
+                Logger.success(`Downloaded and extracted to: ${actualPath}`);
+                // Check project creation limit
+                const usageResult = await authService.checkAndUpdateUsage(req.user.id, 'project');
+                if (!usageResult.allowed) {
+                    res.status(429).json({
+                        error: 'Project limit reached',
+                        message: `You have reached your daily project limit (${usageResult.limit})`,
+                        usage: { used: usageResult.limit, limit: usageResult.limit, remaining: 0 }
+                    });
+                    return;
+                }
+                // Create ArchiCore project
+                const archiProject = await projectService.createProject(projectName || project.name, actualPath, req.user.id);
+                archiProjectId = archiProject.id;
+                // Update connected repo with project ID
+                await gitlabService.updateRepositoryProjectId(connectedRepo.id, archiProjectId);
+                await gitlabService.updateRepositoryStatus(connectedRepo.id, 'active');
+                Logger.info(`Linked ArchiCore project ${archiProjectId} to GitLab repository ${project.path_with_namespace}`);
+            }
+            catch (e) {
+                Logger.warn(`Failed to create ArchiCore project for ${connectedRepo.fullPath}: ${e}`);
+                await gitlabService.updateRepositoryStatus(connectedRepo.id, 'error', String(e));
+            }
+        }
+        res.json({
+            success: true,
+            repository: {
+                id: connectedRepo.id,
+                fullPath: connectedRepo.fullPath,
+                projectId: archiProjectId,
+                status: connectedRepo.status
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Connect GitLab repository error:', error);
+        const message = error instanceof Error ? error.message : 'Failed to connect repository';
+        res.status(500).json({ error: message });
+    }
+});
+/**
+ * DELETE /api/gitlab/repositories/:id
+ * Disconnect a GitLab repository
+ */
+gitlabRouter.delete('/repositories/:id', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const success = await gitlabService.disconnectRepository(req.user.id, req.params.id);
+        if (!success) {
+            res.status(404).json({ error: 'Repository not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Disconnect GitLab repository error:', error);
+        res.status(500).json({ error: 'Failed to disconnect repository' });
+    }
+});
+/**
+ * POST /api/gitlab/repositories/:id/analyze
+ * Trigger analysis for a connected repository
+ */
+gitlabRouter.post('/repositories/:id/analyze', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const repo = await gitlabService.getConnectedRepository(req.params.id);
+        if (!repo) {
+            res.status(404).json({ error: 'Repository not found' });
+            return;
+        }
+        if (!repo.projectId) {
+            res.status(400).json({ error: 'Repository not linked to an ArchiCore project' });
+            return;
+        }
+        // Update status
+        await gitlabService.updateRepositoryStatus(repo.id, 'syncing');
+        try {
+            const result = await projectService.runFullAnalysis(repo.projectId);
+            await gitlabService.updateLastAnalyzed(repo.id);
+            await gitlabService.updateRepositoryStatus(repo.id, 'active');
+            res.json({ success: true, result });
+        }
+        catch (e) {
+            await gitlabService.updateRepositoryStatus(repo.id, 'error', String(e));
+            throw e;
+        }
+    }
+    catch (error) {
+        Logger.error('Analyze GitLab repository error:', error);
+        res.status(500).json({ error: 'Failed to analyze repository' });
+    }
+});
+// ===== WEBHOOKS =====
+/**
+ * POST /api/gitlab/webhook
+ * Receive GitLab webhooks
+ */
+gitlabRouter.post('/webhook', async (req, res) => {
+    try {
+        const event = req.headers['x-gitlab-event'];
+        const token = req.headers['x-gitlab-token'];
+        const payload = req.body;
+        if (!event || !payload) {
+            res.status(400).json({ error: 'Invalid webhook' });
+            return;
+        }
+        // Get repository from payload
+        const fullPath = payload.project?.path_with_namespace;
+        if (!fullPath) {
+            res.status(200).json({ message: 'No project in payload' });
+            return;
+        }
+        // Find connected repository
+        const repo = await gitlabService.findRepositoryByWebhook(fullPath);
+        if (!repo) {
+            res.status(200).json({ message: 'Repository not connected' });
+            return;
+        }
+        // Verify webhook token
+        if (repo.webhookSecret) {
+            const secret = gitlabService.getWebhookSecret(repo.webhookSecret);
+            if (!token || !gitlabService.verifyWebhookToken(token, secret)) {
+                Logger.warn(`Invalid webhook token for ${fullPath}`);
+                res.status(401).json({ error: 'Invalid token' });
+                return;
+            }
+        }
+        Logger.info(`GitLab webhook received: ${event} for ${fullPath}`);
+        // Handle different events
+        switch (payload.object_kind) {
+            case 'push':
+                await handlePushEvent(repo, payload);
+                break;
+            case 'merge_request':
+                await handleMergeRequestEvent(repo, payload);
+                break;
+            default:
+                Logger.debug(`Unhandled GitLab webhook event: ${payload.object_kind}`);
+        }
+        res.status(200).json({ received: true });
+    }
+    catch (error) {
+        Logger.error('GitLab webhook error:', error);
+        res.status(500).json({ error: 'Webhook processing failed' });
+    }
+});
+/**
+ * Handle push event
+ */
+async function handlePushEvent(repo, payload) {
+    if (!repo || !repo.autoAnalyze || !repo.projectId)
+        return;
+    const branch = payload.ref?.replace('refs/heads/', '');
+    if (branch !== repo.defaultBranch) {
+        Logger.debug(`Push to non-default branch ${branch}, skipping analysis`);
+        return;
+    }
+    Logger.info(`Auto-analyzing ${repo.fullPath} after push`);
+    try {
+        await gitlabService.updateRepositoryStatus(repo.id, 'syncing');
+        await projectService.runFullAnalysis(repo.projectId);
+        await gitlabService.updateLastAnalyzed(repo.id);
+        await gitlabService.updateRepositoryStatus(repo.id, 'active');
+    }
+    catch (e) {
+        Logger.error(`Analysis failed for ${repo.fullPath}: ${e}`);
+        await gitlabService.updateRepositoryStatus(repo.id, 'error', String(e));
+    }
+}
+/**
+ * Handle merge request event
+ */
+async function handleMergeRequestEvent(repo, payload) {
+    if (!repo || !repo.analyzeMRs || !repo.projectId)
+        return;
+    const action = payload.object_attributes?.action;
+    const mrIid = payload.object_attributes?.iid;
+    if (!mrIid || !['open', 'reopen', 'update'].includes(action || '')) {
+        return;
+    }
+    Logger.info(`Analyzing MR !${mrIid} for ${repo.fullPath}`);
+    try {
+        const instance = await gitlabService.getInstanceForRepository(repo);
+        if (!instance)
+            return;
+        // Get MR changes
+        const changes = await gitlabService.getMergeRequestChanges(instance.userId, instance.id, repo.gitlabProjectId, mrIid);
+        // Analyze impact
+        const impact = await projectService.analyzeImpact(repo.projectId, {
+            description: payload.object_attributes?.title || 'Merge Request',
+            files: changes.map(c => c.new_path),
+            symbols: [],
+            type: 'modify'
+        });
+        // Generate comment
+        const riskEmoji = {
+            low: '✅',
+            medium: '⚠️',
+            high: '🔶',
+            critical: '🚨'
+        };
+        const riskLevel = impact.risks.length > 0
+            ? impact.risks.reduce((max, r) => ['critical', 'high', 'medium', 'low'].indexOf(r.severity) <
+                ['critical', 'high', 'medium', 'low'].indexOf(max) ? r.severity : max, 'low')
+            : 'low';
+        const comment = `## ArchiCore Analysis ${riskEmoji[riskLevel]}
+
+**Risk Level:** ${riskLevel.toUpperCase()}
+**Affected Components:** ${impact.affectedNodes.length}
+**Files Changed:** ${changes.length}
+
+### Impact Summary
+
+${impact.affectedNodes.slice(0, 5).map(n => `- **${n.name}** (${n.type}) - ${n.reason}`).join('\n') || 'No significant impact detected.'}
+
+${impact.risks.length > 0 ? `### Risks
+
+${impact.risks.slice(0, 3).map(r => `- ${riskEmoji[r.severity]} **${r.category}**: ${r.description}`).join('\n')}` : ''}
+
+${impact.recommendations.length > 0 ? `### Recommendations
+
+${impact.recommendations.slice(0, 3).map(r => `- ${r.description}`).join('\n')}` : ''}
+
+---
+*Analyzed by [ArchiCore](https://archicore.io)*`;
+        // Post comment
+        await gitlabService.postMRComment(instance.userId, instance.id, repo.gitlabProjectId, mrIid, comment);
+    }
+    catch (e) {
+        Logger.error(`MR analysis failed for ${repo.fullPath}!${mrIid}: ${e}`);
+    }
+}
+export default gitlabRouter;
+//# sourceMappingURL=gitlab.js.map

package/dist/server/routes/oauth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * OAuth Authentication Routes
+ * Google and GitHub OAuth login flows
+ */
+export declare const oauthRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=oauth.d.ts.map