archicore 0.1.0

package/dist/server/index.js

@@ -0,0 +1,141 @@
+/**
+ * ArchiCore Web Server
+ *
+ * HTTP API для Architecture Digital Twin:
+ * - Индексация проектов
+ * - Визуализация архитектуры
+ * - Анализ влияния изменений
+ * - Симуляция изменений
+ */
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Logger } from '../utils/logger.js';
+import { apiRouter } from './routes/api.js';
+import { uploadRouter } from './routes/upload.js';
+import { authRouter } from './routes/auth.js';
+import { adminRouter } from './routes/admin.js';
+import { developerRouter } from './routes/developer.js';
+import { githubRouter } from './routes/github.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class ArchiCoreServer {
+    app;
+    server = null;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.app = express();
+        this.setupMiddleware();
+        this.setupRoutes();
+        this.setupErrorHandling();
+    }
+    setupMiddleware() {
+        // CORS для фронтенда
+        this.app.use(cors({
+            origin: '*',
+            methods: ['GET', 'POST', 'PUT', 'DELETE'],
+            allowedHeaders: ['Content-Type', 'Authorization']
+        }));
+        // JSON парсинг
+        this.app.use(express.json({ limit: '50mb' }));
+        this.app.use(express.urlencoded({ extended: true }));
+        // Статические файлы (фронтенд)
+        const publicPath = path.join(__dirname, '../../public');
+        this.app.use(express.static(publicPath));
+        // Логирование запросов
+        this.app.use((req, _res, next) => {
+            Logger.debug(`${req.method} ${req.path}`);
+            next();
+        });
+    }
+    setupRoutes() {
+        // Auth routes
+        this.app.use('/api/auth', authRouter);
+        // Admin routes
+        this.app.use('/api/admin', adminRouter);
+        // Developer API routes (for API key management and public API)
+        this.app.use('/api/developer', developerRouter);
+        // GitHub integration routes
+        this.app.use('/api/github', githubRouter);
+        // API маршруты
+        this.app.use('/api', apiRouter);
+        // Upload маршруты
+        this.app.use('/api/upload', uploadRouter);
+        // Health check
+        this.app.get('/health', (_req, res) => {
+            res.json({
+                status: 'ok',
+                version: '0.1.0',
+                name: 'ArchiCore',
+                timestamp: new Date().toISOString()
+            });
+        });
+        // SPA fallback - все остальные маршруты отдают index.html
+        this.app.get('/*splat', (_req, res) => {
+            const indexPath = path.join(__dirname, '../../public/index.html');
+            res.sendFile(indexPath);
+        });
+    }
+    setupErrorHandling() {
+        // 404 handler
+        this.app.use((_req, res) => {
+            res.status(404).json({ error: 'Not found' });
+        });
+        // Error handler
+        this.app.use((err, _req, res, _next) => {
+            Logger.error('Server error:', err);
+            res.status(500).json({
+                error: 'Internal server error',
+                message: err.message
+            });
+        });
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = createServer(this.app);
+            this.server.listen(this.config.port, this.config.host || '0.0.0.0', () => {
+                Logger.success(`ArchiCore server running at http://localhost:${this.config.port}`);
+                Logger.info(`API available at http://localhost:${this.config.port}/api`);
+                Logger.info(`Dashboard at http://localhost:${this.config.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    Logger.info('Server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getApp() {
+        return this.app;
+    }
+}
+// Запуск сервера при прямом вызове
+const isMainModule = process.argv[1]?.includes('server');
+if (isMainModule) {
+    const port = parseInt(process.env.PORT || '3000', 10);
+    const server = new ArchiCoreServer({ port });
+    server.start().catch((err) => {
+        Logger.error('Failed to start server:', err);
+        process.exit(1);
+    });
+    // Graceful shutdown
+    process.on('SIGINT', async () => {
+        Logger.info('Shutting down...');
+        await server.stop();
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/server/middleware/api-auth.d.ts

@@ -0,0 +1,43 @@
+/**
+ * API Authentication Middleware for ArchiCore Developer API
+ *
+ * Аутентификация через API ключи, rate limiting, проверка permissions
+ */
+import { Request, Response, NextFunction } from 'express';
+import { ApiPermission, ApiRequestContext } from '../../types/api.js';
+declare global {
+    namespace Express {
+        interface Request {
+            apiContext?: ApiRequestContext;
+        }
+    }
+}
+/**
+ * Middleware для аутентификации через API ключ
+ * Поддерживает:
+ * - Header: Authorization: Bearer arc_xxxxx
+ * - Header: X-API-Key: arc_xxxxx
+ * - Query: ?api_key=arc_xxxxx
+ */
+export declare function apiKeyAuth(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * Middleware для проверки permission
+ */
+export declare function requirePermission(permission: ApiPermission): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Middleware для проверки баланса перед операцией
+ */
+export declare function checkBalance(estimatedTokens: number): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ * Wrapper для автоматического трекинга использования токенов
+ */
+export declare function trackUsage(operation: ApiPermission extends `${infer Op}:${string}` ? Op : never): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ * Error handler для API ошибок
+ */
+export declare function apiErrorHandler(err: Error, _req: Request, res: Response, _next: NextFunction): void;
+/**
+ * Optional API key auth (не требует ключ, но использует если есть)
+ */
+export declare function optionalApiKeyAuth(req: Request, _res: Response, next: NextFunction): Promise<void>;
+//# sourceMappingURL=api-auth.d.ts.map

package/dist/server/middleware/api-auth.js

@@ -0,0 +1,256 @@
+/**
+ * API Authentication Middleware for ArchiCore Developer API
+ *
+ * Аутентификация через API ключи, rate limiting, проверка permissions
+ */
+import { ApiKeyService } from '../services/api-key-service.js';
+import { TokenService } from '../services/token-service.js';
+import { Logger } from '../../utils/logger.js';
+// Singleton instances
+const apiKeyService = new ApiKeyService();
+const tokenService = new TokenService();
+/**
+ * Middleware для аутентификации через API ключ
+ * Поддерживает:
+ * - Header: Authorization: Bearer arc_xxxxx
+ * - Header: X-API-Key: arc_xxxxx
+ * - Query: ?api_key=arc_xxxxx
+ */
+export async function apiKeyAuth(req, res, next) {
+    try {
+        // Извлекаем API ключ из разных источников
+        let apiKey;
+        // 1. Authorization header (Bearer token)
+        const authHeader = req.headers.authorization;
+        if (authHeader?.startsWith('Bearer ')) {
+            apiKey = authHeader.substring(7);
+        }
+        // 2. X-API-Key header
+        if (!apiKey && req.headers['x-api-key']) {
+            apiKey = req.headers['x-api-key'];
+        }
+        // 3. Query parameter (не рекомендуется, но поддерживаем)
+        if (!apiKey && req.query.api_key) {
+            apiKey = req.query.api_key;
+        }
+        if (!apiKey) {
+            res.status(401).json({
+                error: {
+                    type: 'authentication_error',
+                    message: 'API key is required. Provide it via Authorization header, X-API-Key header, or api_key query parameter.'
+                }
+            });
+            return;
+        }
+        // Валидация ключа
+        const validatedKey = await apiKeyService.validateKey(apiKey);
+        if (!validatedKey) {
+            res.status(401).json({
+                error: {
+                    type: 'authentication_error',
+                    message: 'Invalid or expired API key.'
+                }
+            });
+            return;
+        }
+        // Проверка rate limit
+        const rateLimitResult = await tokenService.checkRateLimit(validatedKey.id, validatedKey.rateLimit);
+        if (!rateLimitResult.allowed) {
+            res.status(429).json({
+                error: {
+                    type: 'rate_limit_error',
+                    message: 'Rate limit exceeded. Please retry later.',
+                    retryAfter: rateLimitResult.retryAfter
+                },
+                limits: {
+                    remaining: rateLimitResult.remaining,
+                    resetAt: rateLimitResult.resetAt
+                }
+            });
+            return;
+        }
+        // Получаем billing account
+        const billingAccount = await tokenService.getBillingAccount(validatedKey.userId);
+        // Добавляем контекст в request
+        req.apiContext = {
+            apiKey: validatedKey,
+            userId: validatedKey.userId,
+            rateLimitState: (await tokenService.getRateLimitState(validatedKey.id)),
+            billingAccount
+        };
+        // Добавляем rate limit headers
+        res.setHeader('X-RateLimit-Limit-Requests', validatedKey.rateLimit.requestsPerMinute.toString());
+        res.setHeader('X-RateLimit-Remaining-Requests', rateLimitResult.remaining.requestsPerMinute.toString());
+        res.setHeader('X-RateLimit-Reset', rateLimitResult.resetAt.minute.toISOString());
+        next();
+    }
+    catch (error) {
+        Logger.error('API auth error:', error);
+        res.status(500).json({
+            error: {
+                type: 'server_error',
+                message: 'Authentication failed due to server error.'
+            }
+        });
+    }
+}
+/**
+ * Middleware для проверки permission
+ */
+export function requirePermission(permission) {
+    return (req, res, next) => {
+        if (!req.apiContext) {
+            res.status(401).json({
+                error: {
+                    type: 'authentication_error',
+                    message: 'Not authenticated.'
+                }
+            });
+            return;
+        }
+        if (!apiKeyService.hasPermission(req.apiContext.apiKey, permission)) {
+            res.status(403).json({
+                error: {
+                    type: 'permission_error',
+                    message: `Permission '${permission}' is required for this operation.`,
+                    required: permission,
+                    available: req.apiContext.apiKey.permissions
+                }
+            });
+            return;
+        }
+        next();
+    };
+}
+/**
+ * Middleware для проверки баланса перед операцией
+ */
+export function checkBalance(estimatedTokens) {
+    return async (req, res, next) => {
+        if (!req.apiContext) {
+            res.status(401).json({
+                error: {
+                    type: 'authentication_error',
+                    message: 'Not authenticated.'
+                }
+            });
+            return;
+        }
+        const balanceCheck = await tokenService.checkBalance(req.apiContext.userId, estimatedTokens);
+        if (!balanceCheck.allowed) {
+            res.status(402).json({
+                error: {
+                    type: 'insufficient_funds',
+                    message: 'Insufficient balance for this operation.',
+                    balance: balanceCheck.balance / 100, // в долларах
+                    estimatedCost: balanceCheck.estimatedCost / 100,
+                    tokensRemaining: balanceCheck.tokensRemaining
+                }
+            });
+            return;
+        }
+        next();
+    };
+}
+/**
+ * Wrapper для автоматического трекинга использования токенов
+ */
+export function trackUsage(operation) {
+    return async (req, res, next) => {
+        if (!req.apiContext) {
+            next();
+            return;
+        }
+        // Сохраняем оригинальный json метод
+        const originalJson = res.json.bind(res);
+        const startTime = Date.now();
+        // Перехватываем ответ
+        res.json = function (body) {
+            // Подсчитываем токены на основе размера ответа
+            const responseSize = JSON.stringify(body).length;
+            const inputSize = JSON.stringify(req.body || {}).length;
+            const tokens = tokenService.calculateTokens(operation, {
+                inputText: JSON.stringify(req.body || {}),
+                outputText: JSON.stringify(body),
+                contentSizeKb: Math.ceil((inputSize + responseSize) / 1024)
+            });
+            // Записываем использование асинхронно (не блокируем ответ)
+            tokenService.recordUsage(req.apiContext.apiKey.id, req.apiContext.userId, operation, tokens, req.params.id, // projectId if present
+            {
+                endpoint: req.path,
+                method: req.method,
+                duration: Date.now() - startTime
+            }).then(() => {
+                // Инкрементим rate limit
+                return tokenService.incrementRateLimit(req.apiContext.apiKey.id, tokens.totalTokens);
+            }).catch(err => {
+                Logger.error('Failed to record usage:', err);
+            });
+            // Добавляем usage info в ответ
+            if (body && typeof body === 'object' && !Array.isArray(body)) {
+                body.usage = {
+                    inputTokens: tokens.inputTokens,
+                    outputTokens: tokens.outputTokens,
+                    totalTokens: tokens.totalTokens
+                };
+            }
+            return originalJson(body);
+        };
+        next();
+    };
+}
+/**
+ * Error handler для API ошибок
+ */
+export function apiErrorHandler(err, _req, res, _next) {
+    Logger.error('API Error:', err);
+    // Определяем тип ошибки
+    let statusCode = 500;
+    let errorType = 'server_error';
+    if (err.message.includes('not found')) {
+        statusCode = 404;
+        errorType = 'not_found';
+    }
+    else if (err.message.includes('permission') || err.message.includes('forbidden')) {
+        statusCode = 403;
+        errorType = 'permission_error';
+    }
+    else if (err.message.includes('invalid') || err.message.includes('validation')) {
+        statusCode = 400;
+        errorType = 'validation_error';
+    }
+    res.status(statusCode).json({
+        error: {
+            type: errorType,
+            message: err.message
+        }
+    });
+}
+/**
+ * Optional API key auth (не требует ключ, но использует если есть)
+ */
+export async function optionalApiKeyAuth(req, _res, next) {
+    // Пытаемся аутентифицировать, но не отклоняем если нет ключа
+    let apiKey;
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith('Bearer ')) {
+        apiKey = authHeader.substring(7);
+    }
+    if (!apiKey && req.headers['x-api-key']) {
+        apiKey = req.headers['x-api-key'];
+    }
+    if (apiKey) {
+        const validatedKey = await apiKeyService.validateKey(apiKey);
+        if (validatedKey) {
+            const billingAccount = await tokenService.getBillingAccount(validatedKey.userId);
+            req.apiContext = {
+                apiKey: validatedKey,
+                userId: validatedKey.userId,
+                rateLimitState: (await tokenService.getRateLimitState(validatedKey.id)),
+                billingAccount
+            };
+        }
+    }
+    next();
+}
+//# sourceMappingURL=api-auth.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Admin API Routes for ArchiCore
+ */
+export declare const adminRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=admin.d.ts.map

package/dist/server/routes/admin.js

@@ -0,0 +1,123 @@
+/**
+ * Admin API Routes for ArchiCore
+ */
+import { Router } from 'express';
+import { AuthService } from '../services/auth-service.js';
+import { authMiddleware, adminMiddleware } from './auth.js';
+import { Logger } from '../../utils/logger.js';
+export const adminRouter = Router();
+const authService = new AuthService();
+// All admin routes require authentication and admin role
+adminRouter.use(authMiddleware);
+adminRouter.use(adminMiddleware);
+/**
+ * GET /api/admin/users
+ * Get all users
+ */
+adminRouter.get('/users', async (_req, res) => {
+    try {
+        const users = await authService.getAllUsers();
+        res.json({ users });
+    }
+    catch (error) {
+        Logger.error('Failed to get users:', error);
+        res.status(500).json({ error: 'Failed to get users' });
+    }
+});
+/**
+ * GET /api/admin/users/:id
+ * Get specific user
+ */
+adminRouter.get('/users/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const user = await authService.getUser(id);
+        if (!user) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        const { passwordHash, ...sanitized } = user;
+        res.json({ user: sanitized });
+    }
+    catch (error) {
+        Logger.error('Failed to get user:', error);
+        res.status(500).json({ error: 'Failed to get user' });
+    }
+});
+/**
+ * PUT /api/admin/users/:id/tier
+ * Update user's subscription tier
+ */
+adminRouter.put('/users/:id/tier', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { tier } = req.body;
+        const validTiers = ['free', 'mid', 'pro', 'admin'];
+        if (!tier || !validTiers.includes(tier)) {
+            res.status(400).json({ error: 'Invalid tier' });
+            return;
+        }
+        const updated = await authService.updateUserTier(id, tier);
+        if (!updated) {
+            res.status(404).json({ error: 'User not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Failed to update user tier:', error);
+        res.status(500).json({ error: 'Failed to update tier' });
+    }
+});
+/**
+ * DELETE /api/admin/users/:id
+ * Delete user
+ */
+adminRouter.delete('/users/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const deleted = await authService.deleteUser(id);
+        if (!deleted) {
+            res.status(400).json({ error: 'Cannot delete user (admin or not found)' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        Logger.error('Failed to delete user:', error);
+        res.status(500).json({ error: 'Failed to delete user' });
+    }
+});
+/**
+ * GET /api/admin/stats
+ * Get system statistics
+ */
+adminRouter.get('/stats', async (_req, res) => {
+    try {
+        const users = await authService.getAllUsers();
+        const stats = {
+            totalUsers: users.length,
+            byTier: {
+                free: users.filter(u => u.tier === 'free').length,
+                mid: users.filter(u => u.tier === 'mid').length,
+                pro: users.filter(u => u.tier === 'pro').length,
+                admin: users.filter(u => u.tier === 'admin').length
+            },
+            byProvider: {
+                email: users.filter(u => u.provider === 'email').length,
+                github: users.filter(u => u.provider === 'github').length,
+                google: users.filter(u => u.provider === 'google').length
+            },
+            recentUsers: users
+                .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+                .slice(0, 5)
+                .map(u => ({ id: u.id, username: u.username, tier: u.tier, createdAt: u.createdAt }))
+        };
+        res.json(stats);
+    }
+    catch (error) {
+        Logger.error('Failed to get stats:', error);
+        res.status(500).json({ error: 'Failed to get statistics' });
+    }
+});
+//# sourceMappingURL=admin.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * ArchiCore API Routes
+ *
+ * REST API для Architecture Digital Twin
+ */
+export declare const apiRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=api.d.ts.map