archicore 0.1.0

package/dist/server/services/upload-service.js

@@ -0,0 +1,464 @@
+/**
+ * Upload Service
+ *
+ * Безопасная загрузка и распаковка ZIP/RAR архивов.
+ *
+ * Защита от:
+ * - ZIP-бомб (проверка соотношения сжатия)
+ * - Path traversal атак (../../../etc/passwd)
+ * - Опасных файлов (исполняемые, скрипты и т.д.)
+ * - Слишком больших файлов
+ */
+import { v4 as uuidv4 } from 'uuid';
+import AdmZip from 'adm-zip';
+import path from 'path';
+import { mkdir, rm, stat, readdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { Logger } from '../../utils/logger.js';
+// Опасные расширения файлов
+const DANGEROUS_EXTENSIONS = new Set([
+    // Исполняемые
+    '.exe', '.dll', '.so', '.dylib', '.bin', '.com', '.bat', '.cmd', '.ps1', '.vbs',
+    '.msi', '.msp', '.scr', '.pif', '.gadget', '.hta', '.cpl', '.msc', '.jar',
+    // Скрипты с shell
+    '.sh', '.bash', '.zsh', '.fish', '.ksh',
+    // Архивы-матрёшки (могут содержать вредоносный код)
+    '.zip', '.rar', '.7z', '.tar', '.gz', '.bz2', '.xz',
+    // Потенциально опасные
+    '.reg', '.inf', '.lnk', '.url', '.scf'
+]);
+// Разрешённые расширения для кода
+const ALLOWED_CODE_EXTENSIONS = new Set([
+    // JavaScript/TypeScript
+    '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs',
+    // Vue/React/Angular
+    '.vue', '.svelte',
+    // Стили
+    '.css', '.scss', '.sass', '.less', '.styl',
+    // Разметка
+    '.html', '.htm', '.xml', '.svg',
+    // Python
+    '.py', '.pyw', '.pyx', '.pyd', '.pyi',
+    // Go
+    '.go',
+    // Rust
+    '.rs',
+    // Java/Kotlin/Scala
+    '.java', '.kt', '.kts', '.scala',
+    // C/C++
+    '.c', '.cpp', '.cc', '.cxx', '.h', '.hpp', '.hh',
+    // C#
+    '.cs',
+    // PHP
+    '.php', '.phtml',
+    // Ruby
+    '.rb', '.erb', '.rake',
+    // Swift
+    '.swift',
+    // Конфиги и данные
+    '.json', '.yaml', '.yml', '.toml', '.ini', '.env.example', '.env.sample',
+    '.lock', '.config', '.conf',
+    // Документация
+    '.md', '.mdx', '.txt', '.rst',
+    // GraphQL
+    '.graphql', '.gql',
+    // Другое
+    '.sql', '.prisma', '.proto'
+]);
+// Паттерны опасных путей
+const DANGEROUS_PATH_PATTERNS = [
+    /\.\./, // Path traversal
+    /^\/etc\//, // System files
+    /^\/var\//,
+    /^\/usr\//,
+    /^\/bin\//,
+    /^\/sbin\//,
+    /^C:\\Windows/i, // Windows system
+    /^C:\\Program Files/i,
+    /^C:\\Users\\.*\\AppData/i,
+    /\0/, // Null byte injection
+];
+export class UploadService {
+    config;
+    constructor(config) {
+        this.config = {
+            maxFileSize: config?.maxFileSize || 100 * 1024 * 1024, // 100MB default
+            maxExtractedSize: config?.maxExtractedSize || 500 * 1024 * 1024, // 500MB extracted
+            maxCompressionRatio: config?.maxCompressionRatio || 100, // Max 100x compression
+            uploadsDir: config?.uploadsDir || '.archicore/uploads',
+            extractDir: config?.extractDir || '.archicore/projects'
+        };
+    }
+    /**
+     * Проверка безопасности архива БЕЗ распаковки
+     */
+    async scanArchive(filePath) {
+        const threats = [];
+        const warnings = [];
+        try {
+            const fileStats = await stat(filePath);
+            // Проверка размера файла
+            if (fileStats.size > this.config.maxFileSize) {
+                threats.push({
+                    type: 'oversized',
+                    description: `File size ${this.formatBytes(fileStats.size)} exceeds limit ${this.formatBytes(this.config.maxFileSize)}`,
+                    severity: 'high'
+                });
+                return { safe: false, threats, warnings };
+            }
+            const zip = new AdmZip(filePath);
+            const entries = zip.getEntries();
+            let totalUncompressedSize = 0;
+            for (const entry of entries) {
+                const entryName = entry.entryName;
+                const ext = path.extname(entryName).toLowerCase();
+                // 1. Проверка на path traversal
+                if (this.isPathTraversal(entryName)) {
+                    threats.push({
+                        type: 'path_traversal',
+                        description: `Suspicious path detected: ${entryName}`,
+                        file: entryName,
+                        severity: 'critical'
+                    });
+                }
+                // 2. Проверка на опасные файлы
+                if (DANGEROUS_EXTENSIONS.has(ext)) {
+                    threats.push({
+                        type: 'dangerous_file',
+                        description: `Dangerous file type: ${ext}`,
+                        file: entryName,
+                        severity: 'high'
+                    });
+                }
+                // 3. Проверка на symlinks
+                if (entry.header.attr === 0xA1FF0000 || entry.isDirectory && entryName.includes('->')) {
+                    threats.push({
+                        type: 'symlink',
+                        description: 'Symbolic link detected',
+                        file: entryName,
+                        severity: 'medium'
+                    });
+                }
+                // 4. Предупреждение о неизвестных типах файлов
+                if (!entry.isDirectory && !ALLOWED_CODE_EXTENSIONS.has(ext) && !DANGEROUS_EXTENSIONS.has(ext)) {
+                    // Исключаем файлы без расширения (могут быть конфигами)
+                    if (ext && ext !== '') {
+                        warnings.push(`Unknown file type will be skipped: ${entryName}`);
+                    }
+                }
+                // 5. Накапливаем размер для проверки zip-бомбы
+                if (!entry.isDirectory) {
+                    totalUncompressedSize += entry.header.size;
+                }
+            }
+            // 6. Проверка на zip-бомбу (соотношение сжатия)
+            const compressionRatio = totalUncompressedSize / fileStats.size;
+            if (compressionRatio > this.config.maxCompressionRatio) {
+                threats.push({
+                    type: 'zip_bomb',
+                    description: `Suspicious compression ratio: ${compressionRatio.toFixed(1)}x (limit: ${this.config.maxCompressionRatio}x)`,
+                    severity: 'critical'
+                });
+            }
+            // 7. Проверка общего размера после распаковки
+            if (totalUncompressedSize > this.config.maxExtractedSize) {
+                threats.push({
+                    type: 'oversized',
+                    description: `Extracted size ${this.formatBytes(totalUncompressedSize)} exceeds limit ${this.formatBytes(this.config.maxExtractedSize)}`,
+                    severity: 'high'
+                });
+            }
+            const hasCriticalThreats = threats.some(t => t.severity === 'critical' || t.severity === 'high');
+            return {
+                safe: !hasCriticalThreats,
+                threats,
+                warnings
+            };
+        }
+        catch (error) {
+            Logger.error('Archive scan failed:', error);
+            threats.push({
+                type: 'dangerous_file',
+                description: `Failed to scan archive: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                severity: 'critical'
+            });
+            return { safe: false, threats, warnings };
+        }
+    }
+    /**
+     * Безопасная распаковка архива
+     */
+    async extractArchive(filePath, uploadId) {
+        const warnings = [];
+        const skippedFiles = [];
+        let extractedSize = 0;
+        let fileCount = 0;
+        const projectPath = path.join(this.config.extractDir, uploadId);
+        try {
+            // Сначала сканируем
+            const scanResult = await this.scanArchive(filePath);
+            if (!scanResult.safe) {
+                return {
+                    success: false,
+                    uploadId,
+                    projectPath: '',
+                    error: `Security scan failed: ${scanResult.threats.map(t => t.description).join('; ')}`,
+                    warnings: scanResult.warnings,
+                    stats: {
+                        originalSize: 0,
+                        extractedSize: 0,
+                        fileCount: 0,
+                        skippedFiles: []
+                    }
+                };
+            }
+            warnings.push(...scanResult.warnings);
+            // Создаём директорию проекта
+            await mkdir(projectPath, { recursive: true });
+            const fileStats = await stat(filePath);
+            const zip = new AdmZip(filePath);
+            const entries = zip.getEntries();
+            // Безопасная распаковка по одному файлу
+            for (const entry of entries) {
+                if (entry.isDirectory)
+                    continue;
+                const entryName = entry.entryName;
+                const ext = path.extname(entryName).toLowerCase();
+                // Пропускаем опасные и неизвестные файлы
+                if (DANGEROUS_EXTENSIONS.has(ext)) {
+                    skippedFiles.push(`${entryName} (dangerous extension)`);
+                    continue;
+                }
+                // Пропускаем symlinks
+                if (entry.header.attr === 0xA1FF0000) {
+                    skippedFiles.push(`${entryName} (symlink)`);
+                    continue;
+                }
+                // Проверка path traversal ещё раз
+                if (this.isPathTraversal(entryName)) {
+                    skippedFiles.push(`${entryName} (path traversal)`);
+                    continue;
+                }
+                // Нормализуем путь
+                const safePath = this.sanitizePath(entryName);
+                const fullPath = path.join(projectPath, safePath);
+                // Проверяем что путь всё ещё внутри projectPath
+                const resolvedPath = path.resolve(fullPath);
+                const resolvedProjectPath = path.resolve(projectPath);
+                if (!resolvedPath.startsWith(resolvedProjectPath)) {
+                    skippedFiles.push(`${entryName} (escaped project directory)`);
+                    continue;
+                }
+                // Создаём директорию
+                const dir = path.dirname(fullPath);
+                await mkdir(dir, { recursive: true });
+                // Извлекаем файл
+                const content = entry.getData();
+                extractedSize += content.length;
+                // Проверяем лимит размера на ходу
+                if (extractedSize > this.config.maxExtractedSize) {
+                    // Откатываем
+                    await rm(projectPath, { recursive: true, force: true });
+                    return {
+                        success: false,
+                        uploadId,
+                        projectPath: '',
+                        error: `Extracted size exceeds limit of ${this.formatBytes(this.config.maxExtractedSize)}`,
+                        warnings,
+                        stats: {
+                            originalSize: fileStats.size,
+                            extractedSize,
+                            fileCount,
+                            skippedFiles
+                        }
+                    };
+                }
+                await writeFile(fullPath, content);
+                fileCount++;
+            }
+            Logger.success(`Extracted ${fileCount} files to ${projectPath}`);
+            return {
+                success: true,
+                uploadId,
+                projectPath,
+                warnings,
+                stats: {
+                    originalSize: fileStats.size,
+                    extractedSize,
+                    fileCount,
+                    skippedFiles
+                }
+            };
+        }
+        catch (error) {
+            Logger.error('Extract failed:', error);
+            // Очищаем при ошибке
+            if (existsSync(projectPath)) {
+                await rm(projectPath, { recursive: true, force: true });
+            }
+            return {
+                success: false,
+                uploadId,
+                projectPath: '',
+                error: error instanceof Error ? error.message : 'Unknown error',
+                warnings,
+                stats: {
+                    originalSize: 0,
+                    extractedSize,
+                    fileCount,
+                    skippedFiles
+                }
+            };
+        }
+    }
+    /**
+     * Полный процесс загрузки: сохранение + сканирование + распаковка
+     */
+    async processUpload(buffer, originalName) {
+        const uploadId = uuidv4();
+        const ext = path.extname(originalName).toLowerCase();
+        // Проверяем формат
+        if (ext !== '.zip') {
+            return {
+                success: false,
+                uploadId,
+                projectPath: '',
+                error: 'Only ZIP files are supported',
+                warnings: [],
+                stats: {
+                    originalSize: buffer.length,
+                    extractedSize: 0,
+                    fileCount: 0,
+                    skippedFiles: []
+                }
+            };
+        }
+        // Создаём директорию для загрузок
+        await mkdir(this.config.uploadsDir, { recursive: true });
+        await mkdir(this.config.extractDir, { recursive: true });
+        // Сохраняем временный файл
+        const tempPath = path.join(this.config.uploadsDir, `${uploadId}${ext}`);
+        await writeFile(tempPath, buffer);
+        try {
+            // Распаковываем
+            const result = await this.extractArchive(tempPath, uploadId);
+            // Удаляем временный архив
+            await rm(tempPath, { force: true });
+            return result;
+        }
+        catch (error) {
+            // Очищаем при ошибке
+            await rm(tempPath, { force: true });
+            throw error;
+        }
+    }
+    /**
+     * Удаление проекта
+     */
+    async deleteProject(uploadId) {
+        const projectPath = path.join(this.config.extractDir, uploadId);
+        if (existsSync(projectPath)) {
+            await rm(projectPath, { recursive: true, force: true });
+            Logger.info(`Deleted project: ${uploadId}`);
+        }
+    }
+    /**
+     * Проверка на path traversal
+     */
+    isPathTraversal(filePath) {
+        // Нормализуем слеши
+        const normalized = filePath.replace(/\\/g, '/');
+        for (const pattern of DANGEROUS_PATH_PATTERNS) {
+            if (pattern.test(normalized)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Очистка пути от опасных элементов
+     */
+    sanitizePath(filePath) {
+        // Убираем ведущие слеши и path traversal
+        return filePath
+            .replace(/\\/g, '/')
+            .replace(/^\/+/, '')
+            .replace(/\.\.\//g, '')
+            .replace(/\/\.\.\//g, '/')
+            .split('/')
+            .filter(part => part !== '..' && part !== '')
+            .join('/');
+    }
+    /**
+     * Форматирование размера в читаемый вид
+     */
+    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];
+    }
+    /**
+     * Получить информацию о загруженных проектах
+     */
+    async listUploadedProjects() {
+        const projects = [];
+        if (!existsSync(this.config.extractDir)) {
+            return projects;
+        }
+        const dirs = await readdir(this.config.extractDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (dir.isDirectory()) {
+                const projectPath = path.join(this.config.extractDir, dir.name);
+                const stats = await stat(projectPath);
+                const files = await this.countFiles(projectPath);
+                projects.push({
+                    id: dir.name,
+                    path: projectPath,
+                    size: await this.getDirSize(projectPath),
+                    files,
+                    createdAt: stats.birthtime
+                });
+            }
+        }
+        return projects;
+    }
+    /**
+     * Подсчёт файлов в директории рекурсивно
+     */
+    async countFiles(dir) {
+        let count = 0;
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                count += await this.countFiles(fullPath);
+            }
+            else {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Размер директории рекурсивно
+     */
+    async getDirSize(dir) {
+        let size = 0;
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                size += await this.getDirSize(fullPath);
+            }
+            else {
+                const stats = await stat(fullPath);
+                size += stats.size;
+            }
+        }
+        return size;
+    }
+}
+//# sourceMappingURL=upload-service.js.map

package/dist/types/api.d.ts

@@ -0,0 +1,188 @@
+/**
+ * API Types for ArchiCore Developer API
+ *
+ * Система токенизированной тарификации как у OpenAI/Anthropic
+ */
+export interface ApiKey {
+    id: string;
+    userId: string;
+    name: string;
+    keyHash: string;
+    keyPrefix: string;
+    permissions: ApiPermission[];
+    rateLimit: RateLimitConfig;
+    createdAt: Date;
+    lastUsedAt: Date | null;
+    expiresAt: Date | null;
+    isActive: boolean;
+}
+export type ApiPermission = 'read:projects' | 'write:projects' | 'analyze:impact' | 'analyze:security' | 'analyze:full' | 'search:semantic' | 'ask:architect' | 'export:data' | 'admin:all';
+export interface RateLimitConfig {
+    requestsPerMinute: number;
+    requestsPerDay: number;
+    tokensPerMinute: number;
+    tokensPerDay: number;
+}
+export interface TokenUsage {
+    id: string;
+    apiKeyId: string;
+    userId: string;
+    operation: ApiOperation;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: number;
+    timestamp: Date;
+    projectId?: string;
+    metadata?: Record<string, unknown>;
+}
+export type ApiOperation = 'index' | 'analyze_impact' | 'analyze_security' | 'analyze_full' | 'search_semantic' | 'ask_architect' | 'export' | 'refactoring' | 'metrics' | 'rules_check' | 'dead_code' | 'duplication';
+export interface PricingTier {
+    name: string;
+    pricePerMillionTokens: number;
+    includedTokens: number;
+    monthlyPrice: number;
+}
+export declare const PRICING_TIERS: Record<string, PricingTier>;
+export declare const OPERATION_TOKEN_COSTS: Record<ApiOperation, {
+    base: number;
+    perFile: number;
+    perKb: number;
+}>;
+export interface BillingAccount {
+    id: string;
+    userId: string;
+    pricingTier: string;
+    balance: number;
+    tokensUsedThisMonth: number;
+    tokensIncludedThisMonth: number;
+    billingCycleStart: Date;
+    billingCycleEnd: Date;
+    autoRecharge: boolean;
+    autoRechargeThreshold: number;
+    autoRechargeAmount: number;
+    paymentMethods: PaymentMethod[];
+    invoices: Invoice[];
+}
+export interface PaymentMethod {
+    id: string;
+    type: 'card' | 'paypal' | 'bank';
+    last4?: string;
+    brand?: string;
+    isDefault: boolean;
+    expiresAt?: Date;
+}
+export interface Invoice {
+    id: string;
+    userId: string;
+    amount: number;
+    currency: string;
+    status: 'pending' | 'paid' | 'failed' | 'refunded';
+    createdAt: Date;
+    paidAt?: Date;
+    items: InvoiceItem[];
+    pdfUrl?: string;
+}
+export interface InvoiceItem {
+    description: string;
+    quantity: number;
+    unitPrice: number;
+    total: number;
+}
+export interface RateLimitState {
+    apiKeyId: string;
+    requestsThisMinute: number;
+    requestsToday: number;
+    tokensThisMinute: number;
+    tokensToday: number;
+    minuteResetAt: Date;
+    dayResetAt: Date;
+}
+export interface RateLimitResult {
+    allowed: boolean;
+    remaining: {
+        requestsPerMinute: number;
+        requestsPerDay: number;
+        tokensPerMinute: number;
+        tokensPerDay: number;
+    };
+    resetAt: {
+        minute: Date;
+        day: Date;
+    };
+    retryAfter?: number;
+}
+export interface UsageStats {
+    period: 'hour' | 'day' | 'week' | 'month';
+    startDate: Date;
+    endDate: Date;
+    totalRequests: number;
+    totalTokens: number;
+    totalCost: number;
+    byOperation: Record<ApiOperation, {
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+    byDay?: Array<{
+        date: string;
+        requests: number;
+        tokens: number;
+        cost: number;
+    }>;
+}
+export interface ApiKeyCreateRequest {
+    name: string;
+    permissions?: ApiPermission[];
+    expiresIn?: number;
+    rateLimit?: Partial<RateLimitConfig>;
+}
+export interface ApiKeyCreateResponse {
+    success: boolean;
+    apiKey?: {
+        id: string;
+        name: string;
+        key: string;
+        keyPrefix: string;
+        permissions: ApiPermission[];
+        expiresAt: Date | null;
+    };
+    error?: string;
+}
+export interface ApiKeyListResponse {
+    success: boolean;
+    keys?: Array<{
+        id: string;
+        name: string;
+        keyPrefix: string;
+        permissions: ApiPermission[];
+        createdAt: Date;
+        lastUsedAt: Date | null;
+        expiresAt: Date | null;
+        isActive: boolean;
+    }>;
+    error?: string;
+}
+export interface UsageResponse {
+    success: boolean;
+    usage?: {
+        currentPeriod: UsageStats;
+        billing: {
+            tier: string;
+            balance: number;
+            tokensUsed: number;
+            tokensIncluded: number;
+            tokensRemaining: number;
+            estimatedCost: number;
+        };
+    };
+    error?: string;
+}
+export interface ApiRequestContext {
+    apiKey: ApiKey;
+    userId: string;
+    rateLimitState: RateLimitState;
+    billingAccount: BillingAccount;
+}
+export declare const DEFAULT_RATE_LIMITS: Record<string, RateLimitConfig>;
+//# sourceMappingURL=api.d.ts.map