archicore 0.1.0

package/dist/server/routes/github.js

@@ -0,0 +1,495 @@
+/**
+ * GitHub Integration Routes for ArchiCore
+ *
+ * OAuth flow, repository management, webhooks
+ */
+import { Router } from 'express';
+import { randomBytes } from 'crypto';
+import { GitHubService } from '../../github/github-service.js';
+import { ProjectService } from '../services/project-service.js';
+import { authMiddleware } from './auth.js';
+import { Logger } from '../../utils/logger.js';
+export const githubRouter = Router();
+// Services
+const githubService = new GitHubService();
+const projectService = new ProjectService();
+// Store OAuth states (in production, use Redis)
+const oauthStates = new Map();
+// ===== OAUTH FLOW =====
+/**
+ * GET /api/github/auth
+ * Start OAuth flow - redirect to GitHub
+ */
+githubRouter.get('/auth', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        if (!githubService.isConfigured()) {
+            res.status(503).json({
+                error: 'GitHub integration not configured',
+                message: 'Set GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET environment variables'
+            });
+            return;
+        }
+        // Generate state token
+        const state = randomBytes(32).toString('hex');
+        oauthStates.set(state, {
+            userId: req.user.id,
+            expiresAt: new Date(Date.now() + 10 * 60 * 1000) // 10 minutes
+        });
+        // Get authorization URL
+        const authUrl = githubService.getAuthorizationUrl(state);
+        res.json({ url: authUrl });
+    }
+    catch (error) {
+        Logger.error('GitHub auth error:', error);
+        res.status(500).json({ error: 'Failed to start GitHub authorization' });
+    }
+});
+/**
+ * GET /api/github/callback
+ * OAuth callback from GitHub
+ */
+githubRouter.get('/callback', async (req, res) => {
+    try {
+        const { code, state, error } = req.query;
+        if (error) {
+            res.redirect(`/?github_error=${encodeURIComponent(error)}`);
+            return;
+        }
+        if (!code || !state) {
+            res.redirect('/?github_error=missing_params');
+            return;
+        }
+        // Validate state
+        const stateData = oauthStates.get(state);
+        if (!stateData || stateData.expiresAt < new Date()) {
+            oauthStates.delete(state);
+            res.redirect('/?github_error=invalid_state');
+            return;
+        }
+        oauthStates.delete(state);
+        // Exchange code for token
+        const tokenResponse = await githubService.exchangeCodeForToken(code);
+        // Get GitHub user info
+        const githubUser = await githubService.getGitHubUser(tokenResponse.access_token);
+        // Save connection
+        await githubService.saveConnection(stateData.userId, tokenResponse, githubUser);
+        // Redirect to app with success
+        res.redirect('/?github_connected=true');
+    }
+    catch (error) {
+        Logger.error('GitHub callback error:', error);
+        res.redirect('/?github_error=auth_failed');
+    }
+});
+/**
+ * GET /api/github/status
+ * Check GitHub connection status
+ */
+githubRouter.get('/status', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const connection = await githubService.getConnection(req.user.id);
+        if (!connection) {
+            res.json({
+                connected: false,
+                configured: githubService.isConfigured()
+            });
+            return;
+        }
+        // Get connected repositories count
+        const repos = await githubService.getConnectedRepositories(req.user.id);
+        res.json({
+            connected: true,
+            username: connection.githubUsername,
+            connectedAt: connection.createdAt,
+            repositories: repos.length
+        });
+    }
+    catch (error) {
+        Logger.error('GitHub status error:', error);
+        res.status(500).json({ error: 'Failed to get GitHub status' });
+    }
+});
+/**
+ * POST /api/github/disconnect
+ * Disconnect GitHub account
+ */
+githubRouter.post('/disconnect', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        await githubService.disconnect(req.user.id);
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('GitHub disconnect error:', error);
+        res.status(500).json({ error: 'Failed to disconnect GitHub' });
+    }
+});
+// ===== REPOSITORIES =====
+/**
+ * GET /api/github/repositories
+ * List available GitHub repositories
+ */
+githubRouter.get('/repositories', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const connection = await githubService.getConnection(req.user.id);
+        if (!connection) {
+            res.status(400).json({ error: 'GitHub not connected' });
+            return;
+        }
+        // Get all user repos from GitHub
+        const githubRepos = await githubService.listUserRepositories(req.user.id);
+        // Get connected repos
+        const connectedRepos = await githubService.getConnectedRepositories(req.user.id);
+        const connectedIds = new Set(connectedRepos.map(r => r.githubRepoId));
+        // Format response
+        const repositories = githubRepos.map(repo => ({
+            id: repo.id,
+            name: repo.name,
+            fullName: repo.full_name,
+            description: repo.description,
+            private: repo.private,
+            language: repo.language,
+            stars: repo.stargazers_count,
+            forks: repo.forks_count,
+            size: repo.size,
+            defaultBranch: repo.default_branch,
+            updatedAt: repo.updated_at,
+            connected: connectedIds.has(repo.id),
+            projectId: connectedRepos.find(r => r.githubRepoId === repo.id)?.projectId
+        }));
+        res.json({ repositories });
+    }
+    catch (error) {
+        Logger.error('List repositories error:', error);
+        res.status(500).json({ error: 'Failed to list repositories' });
+    }
+});
+/**
+ * GET /api/github/repositories/connected
+ * List connected repositories
+ */
+githubRouter.get('/repositories/connected', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const repositories = await githubService.getConnectedRepositories(req.user.id);
+        res.json({
+            repositories: repositories.map(repo => ({
+                id: repo.id,
+                fullName: repo.fullName,
+                name: repo.name,
+                owner: repo.owner,
+                private: repo.private,
+                projectId: repo.projectId,
+                autoAnalyze: repo.autoAnalyze,
+                analyzePRs: repo.analyzePRs,
+                status: repo.status,
+                lastAnalyzedAt: repo.lastAnalyzedAt,
+                createdAt: repo.createdAt
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List connected repositories error:', error);
+        res.status(500).json({ error: 'Failed to list connected repositories' });
+    }
+});
+/**
+ * POST /api/github/repositories/connect
+ * Connect a repository to ArchiCore
+ */
+githubRouter.post('/repositories/connect', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const { repositoryId, autoAnalyze, analyzePRs, createProject, projectName } = req.body;
+        if (!repositoryId) {
+            res.status(400).json({ error: 'repositoryId is required' });
+            return;
+        }
+        // Connect repository
+        const connectedRepo = await githubService.connectRepository(req.user.id, repositoryId, {
+            autoAnalyze: autoAnalyze ?? true,
+            analyzePRs: analyzePRs ?? true
+        });
+        // Optionally create ArchiCore project
+        let projectId;
+        if (createProject !== false) {
+            try {
+                const project = await projectService.createProject(projectName || connectedRepo.name, connectedRepo.cloneUrl);
+                projectId = project.id;
+                // Update connected repo with project ID
+                connectedRepo.projectId = projectId;
+            }
+            catch (e) {
+                Logger.warn(`Failed to create project for ${connectedRepo.fullName}: ${e}`);
+            }
+        }
+        res.json({
+            success: true,
+            repository: {
+                id: connectedRepo.id,
+                fullName: connectedRepo.fullName,
+                projectId,
+                webhookActive: !!connectedRepo.webhookId
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('Connect repository error:', error);
+        res.status(500).json({ error: 'Failed to connect repository' });
+    }
+});
+/**
+ * DELETE /api/github/repositories/:id
+ * Disconnect a repository
+ */
+githubRouter.delete('/repositories/:id', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const success = await githubService.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 repository error:', error);
+        res.status(500).json({ error: 'Failed to disconnect repository' });
+    }
+});
+/**
+ * POST /api/github/repositories/:id/analyze
+ * Trigger analysis for a repository
+ */
+githubRouter.post('/repositories/:id/analyze', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const repo = await githubService.getConnectedRepository(req.params.id);
+        if (!repo || repo.userId !== req.user.id) {
+            res.status(404).json({ error: 'Repository not found' });
+            return;
+        }
+        if (!repo.projectId) {
+            res.status(400).json({ error: 'Repository not linked to a project' });
+            return;
+        }
+        // Update status
+        await githubService.updateRepositoryStatus(repo.id, 'syncing');
+        // Trigger project analysis
+        try {
+            const result = await projectService.runFullAnalysis(repo.projectId);
+            await githubService.updateLastAnalyzed(repo.id);
+            await githubService.updateRepositoryStatus(repo.id, 'active');
+            res.json({ success: true, result });
+        }
+        catch (e) {
+            await githubService.updateRepositoryStatus(repo.id, 'error', String(e));
+            throw e;
+        }
+    }
+    catch (error) {
+        Logger.error('Analyze repository error:', error);
+        res.status(500).json({ error: 'Failed to analyze repository' });
+    }
+});
+// ===== WEBHOOKS =====
+/**
+ * POST /api/github/webhook
+ * Receive GitHub webhooks
+ */
+githubRouter.post('/webhook', async (req, res) => {
+    try {
+        const event = req.headers['x-github-event'];
+        // signature available at req.headers['x-hub-signature-256'] for verification
+        const payload = req.body;
+        if (!event || !payload) {
+            res.status(400).json({ error: 'Invalid webhook' });
+            return;
+        }
+        // Get repository from payload
+        const fullName = payload.repository?.full_name;
+        if (!fullName) {
+            res.status(200).json({ message: 'No repository in payload' });
+            return;
+        }
+        // Find connected repository
+        const repo = await githubService.findRepositoryByWebhook(fullName);
+        if (!repo) {
+            res.status(200).json({ message: 'Repository not connected' });
+            return;
+        }
+        // Verify signature (if webhook secret is set)
+        // Note: In production, you'd verify the signature properly using:
+        // githubService.verifyWebhookSignature(JSON.stringify(req.body), signature, secret)
+        Logger.info(`Webhook received: ${event} for ${fullName}`);
+        // Handle different events
+        switch (event) {
+            case 'push':
+                await handlePushEvent(repo, payload);
+                break;
+            case 'pull_request':
+                await handlePullRequestEvent(repo, payload);
+                break;
+            default:
+                Logger.debug(`Unhandled webhook event: ${event}`);
+        }
+        res.status(200).json({ received: true });
+    }
+    catch (error) {
+        Logger.error('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.fullName} after push`);
+    try {
+        await githubService.updateRepositoryStatus(repo.id, 'syncing');
+        await projectService.runFullAnalysis(repo.projectId);
+        await githubService.updateLastAnalyzed(repo.id);
+        await githubService.updateRepositoryStatus(repo.id, 'active');
+    }
+    catch (e) {
+        Logger.error(`Analysis failed for ${repo.fullName}: ${e}`);
+        await githubService.updateRepositoryStatus(repo.id, 'error', String(e));
+    }
+}
+/**
+ * Handle pull request event
+ */
+async function handlePullRequestEvent(repo, payload) {
+    if (!repo || !repo.analyzePRs || !repo.projectId)
+        return;
+    const action = payload.action;
+    const pr = payload.pull_request;
+    if (!['opened', 'synchronize', 'reopened'].includes(action)) {
+        return;
+    }
+    Logger.info(`Analyzing PR #${pr.number} for ${repo.fullName}`);
+    try {
+        // Get PR files
+        const connection = await githubService.getConnection(repo.userId);
+        if (!connection)
+            return;
+        const files = await githubService.getPullRequestFiles(repo.userId, repo.fullName, pr.number);
+        // Analyze impact
+        const impact = await projectService.analyzeImpact(repo.projectId, {
+            description: pr.title,
+            files: files.map(f => f.filename),
+            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:** ${files.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 githubService.postPRComment(repo.userId, repo.fullName, pr.number, comment);
+    }
+    catch (e) {
+        Logger.error(`PR analysis failed for ${repo.fullName}#${pr.number}: ${e}`);
+    }
+}
+// ===== BRANCHES =====
+/**
+ * GET /api/github/repositories/:id/branches
+ * List branches for a repository
+ */
+githubRouter.get('/repositories/:id/branches', authMiddleware, async (req, res) => {
+    try {
+        if (!req.user) {
+            res.status(401).json({ error: 'Not authenticated' });
+            return;
+        }
+        const repo = await githubService.getConnectedRepository(req.params.id);
+        if (!repo || repo.userId !== req.user.id) {
+            res.status(404).json({ error: 'Repository not found' });
+            return;
+        }
+        const branches = await githubService.listBranches(req.user.id, repo.fullName);
+        res.json({
+            branches: branches.map(b => ({
+                name: b.name,
+                protected: b.protected,
+                isDefault: b.name === repo.defaultBranch
+            }))
+        });
+    }
+    catch (error) {
+        Logger.error('List branches error:', error);
+        res.status(500).json({ error: 'Failed to list branches' });
+    }
+});
+// Cleanup expired OAuth states periodically
+setInterval(() => {
+    const now = new Date();
+    for (const [state, data] of oauthStates.entries()) {
+        if (data.expiresAt < now) {
+            oauthStates.delete(state);
+        }
+    }
+}, 60000); // Every minute
+//# sourceMappingURL=github.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Upload Routes
+ *
+ * API для загрузки проектов через ZIP архивы.
+ */
+export declare const uploadRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=upload.d.ts.map

package/dist/server/routes/upload.js

@@ -0,0 +1,196 @@
+/**
+ * Upload Routes
+ *
+ * API для загрузки проектов через ZIP архивы.
+ */
+import { Router } from 'express';
+import multer from 'multer';
+import path from 'path';
+import { UploadService } from '../services/upload-service.js';
+import { ProjectService } from '../services/project-service.js';
+import { Logger } from '../../utils/logger.js';
+export const uploadRouter = Router();
+// Singleton сервисов
+const uploadService = new UploadService({
+    maxFileSize: parseInt(process.env.MAX_UPLOAD_SIZE || '104857600', 10), // 100MB
+    maxExtractedSize: parseInt(process.env.MAX_EXTRACTED_SIZE || '524288000', 10), // 500MB
+    uploadsDir: process.env.UPLOADS_DIR || '.archicore/uploads',
+    extractDir: process.env.PROJECTS_DIR || '.archicore/projects'
+});
+const projectService = new ProjectService();
+// Multer config для загрузки в память
+const upload = multer({
+    storage: multer.memoryStorage(),
+    limits: {
+        fileSize: parseInt(process.env.MAX_UPLOAD_SIZE || '104857600', 10) // 100MB
+    },
+    fileFilter: (_req, file, cb) => {
+        const ext = path.extname(file.originalname).toLowerCase();
+        // Разрешаем только ZIP
+        if (ext === '.zip') {
+            cb(null, true);
+        }
+        else {
+            cb(new Error(`Unsupported file type: ${ext}. Only .zip files are allowed.`));
+        }
+    }
+});
+/**
+ * POST /api/upload
+ * Загрузить и распаковать ZIP архив с проектом
+ *
+ * Body: multipart/form-data
+ * - file: ZIP файл
+ * - name: (опционально) Имя проекта
+ *
+ * Response:
+ * - uploadId: ID загрузки
+ * - projectId: ID созданного проекта
+ * - projectPath: Путь к распакованному проекту
+ * - stats: Статистика загрузки
+ */
+uploadRouter.post('/', upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            res.status(400).json({ error: 'No file uploaded' });
+            return;
+        }
+        Logger.progress(`Processing upload: ${req.file.originalname} (${formatBytes(req.file.size)})`);
+        // Обрабатываем загрузку
+        const uploadResult = await uploadService.processUpload(req.file.buffer, req.file.originalname);
+        if (!uploadResult.success) {
+            res.status(400).json({
+                error: uploadResult.error,
+                warnings: uploadResult.warnings,
+                stats: uploadResult.stats
+            });
+            return;
+        }
+        // Создаём проект в системе
+        const projectName = req.body.name ||
+            path.basename(req.file.originalname, '.zip');
+        const project = await projectService.createProject(projectName, uploadResult.projectPath);
+        Logger.success(`Upload complete: ${projectName} (${uploadResult.stats.fileCount} files)`);
+        res.json({
+            success: true,
+            uploadId: uploadResult.uploadId,
+            projectId: project.id,
+            projectName: project.name,
+            projectPath: uploadResult.projectPath,
+            warnings: uploadResult.warnings,
+            stats: uploadResult.stats
+        });
+    }
+    catch (error) {
+        Logger.error('Upload failed:', error);
+        if (error instanceof multer.MulterError) {
+            if (error.code === 'LIMIT_FILE_SIZE') {
+                res.status(413).json({
+                    error: 'File too large',
+                    maxSize: process.env.MAX_UPLOAD_SIZE || '100MB'
+                });
+                return;
+            }
+        }
+        res.status(500).json({
+            error: error instanceof Error ? error.message : 'Upload failed'
+        });
+    }
+});
+/**
+ * POST /api/upload/scan
+ * Сканировать архив на угрозы без распаковки
+ *
+ * Body: multipart/form-data
+ * - file: ZIP файл
+ *
+ * Response:
+ * - safe: boolean
+ * - threats: SecurityThreat[]
+ * - warnings: string[]
+ */
+uploadRouter.post('/scan', upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            res.status(400).json({ error: 'No file uploaded' });
+            return;
+        }
+        // Сохраняем временно для сканирования
+        const fs = await import('fs/promises');
+        const tempPath = `.archicore/temp_scan_${Date.now()}.zip`;
+        await fs.mkdir('.archicore', { recursive: true });
+        await fs.writeFile(tempPath, req.file.buffer);
+        try {
+            const scanResult = await uploadService.scanArchive(tempPath);
+            res.json({
+                safe: scanResult.safe,
+                threats: scanResult.threats,
+                warnings: scanResult.warnings,
+                fileInfo: {
+                    name: req.file.originalname,
+                    size: req.file.size
+                }
+            });
+        }
+        finally {
+            // Удаляем временный файл
+            await fs.rm(tempPath, { force: true });
+        }
+    }
+    catch (error) {
+        Logger.error('Scan failed:', error);
+        res.status(500).json({
+            error: error instanceof Error ? error.message : 'Scan failed'
+        });
+    }
+});
+/**
+ * GET /api/upload/projects
+ * Получить список загруженных проектов
+ */
+uploadRouter.get('/projects', async (_req, res) => {
+    try {
+        const projects = await uploadService.listUploadedProjects();
+        res.json({ projects });
+    }
+    catch (error) {
+        Logger.error('Failed to list uploaded projects:', error);
+        res.status(500).json({ error: 'Failed to list projects' });
+    }
+});
+/**
+ * DELETE /api/upload/:uploadId
+ * Удалить загруженный проект
+ */
+uploadRouter.delete('/:uploadId', async (req, res) => {
+    try {
+        const { uploadId } = req.params;
+        await uploadService.deleteProject(uploadId);
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Failed to delete upload:', error);
+        res.status(500).json({ error: 'Failed to delete upload' });
+    }
+});
+/**
+ * GET /api/upload/limits
+ * Получить лимиты загрузки
+ */
+uploadRouter.get('/limits', (_req, res) => {
+    res.json({
+        maxFileSize: parseInt(process.env.MAX_UPLOAD_SIZE || '104857600', 10),
+        maxExtractedSize: parseInt(process.env.MAX_EXTRACTED_SIZE || '524288000', 10),
+        allowedFormats: ['.zip'],
+        maxCompressionRatio: 100
+    });
+});
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+//# sourceMappingURL=upload.js.map