archicore 0.2.0 → 0.2.2

package/dist/semantic-memory/embedding-service.js

@@ -5,7 +5,9 @@ export class EmbeddingService {
     config;
     initialized = false;
     _isAvailable = false;
-    jinaApiKey;
+    jinaApiKeys = [];
+    currentKeyIndex = 0;
+    keyFailures = new Map();
     embeddingDimension = 1024; // Jina default, OpenAI small = 1536
     constructor(config) {
         this.config = config;
@@ -23,16 +25,21 @@ export class EmbeddingService {
         }
         try {
             if (this.config.provider === 'jina') {
-                // Jina AI - free embeddings
-                this.jinaApiKey = process.env.JINA_API_KEY;
-                if (!this.jinaApiKey) {
-                    Logger.warn('JINA_API_KEY not set - semantic search disabled');
+                // Jina AI - free embeddings with key rotation support
+                // Support multiple keys: JINA_API_KEYS (comma-separated) or JINA_API_KEY (single)
+                const keysEnv = process.env.JINA_API_KEYS || process.env.JINA_API_KEY || '';
+                this.jinaApiKeys = keysEnv
+                    .split(',')
+                    .map(k => k.trim())
+                    .filter(k => k.length > 0);
+                if (this.jinaApiKeys.length === 0) {
+                    Logger.warn('JINA_API_KEY(S) not set - semantic search disabled');
                     Logger.info('Get free API key at: https://jina.ai/embeddings/');
                     return;
                 }
                 this.embeddingDimension = 1024;
                 this._isAvailable = true;
-                Logger.success('Jina AI embeddings enabled');
+                Logger.success(`Jina AI embeddings enabled (${this.jinaApiKeys.length} key${this.jinaApiKeys.length > 1 ? 's' : ''} configured)`);
             }
             else {
                 // OpenAI embeddings
@@ -51,6 +58,45 @@ export class EmbeddingService {
             Logger.warn('Embedding init failed: ' + error);
         }
     }
+    getCurrentJinaKey() {
+        if (this.jinaApiKeys.length === 0)
+            return undefined;
+        return this.jinaApiKeys[this.currentKeyIndex];
+    }
+    rotateToNextKey() {
+        if (this.jinaApiKeys.length <= 1)
+            return false;
+        const oldIndex = this.currentKeyIndex;
+        this.currentKeyIndex = (this.currentKeyIndex + 1) % this.jinaApiKeys.length;
+        // Track failure for old key
+        const failure = this.keyFailures.get(oldIndex) || { count: 0, lastFail: new Date() };
+        failure.count++;
+        failure.lastFail = new Date();
+        this.keyFailures.set(oldIndex, failure);
+        Logger.warn(`Jina API key ${oldIndex + 1} exhausted/failed, rotating to key ${this.currentKeyIndex + 1}`);
+        return true;
+    }
+    shouldSkipKey(index) {
+        const failure = this.keyFailures.get(index);
+        if (!failure)
+            return false;
+        // Skip key if it failed recently (within 5 minutes) and has many failures
+        const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+        return failure.count >= 3 && failure.lastFail > fiveMinutesAgo;
+    }
+    findWorkingKeyIndex() {
+        const startIndex = this.currentKeyIndex;
+        for (let i = 0; i < this.jinaApiKeys.length; i++) {
+            const index = (startIndex + i) % this.jinaApiKeys.length;
+            if (!this.shouldSkipKey(index)) {
+                return index;
+            }
+        }
+        // All keys are marked as failed, reset failures and try first key
+        Logger.warn('All Jina API keys marked as failed, resetting failure counters');
+        this.keyFailures.clear();
+        return 0;
+    }
     isAvailable() {
         this.ensureInitialized();
         return this._isAvailable;
@@ -60,7 +106,7 @@ export class EmbeddingService {
         if (!this._isAvailable)
             return new Array(this.embeddingDimension).fill(0);
         try {
-            if (this.config.provider === 'jina' && this.jinaApiKey) {
+            if (this.config.provider === 'jina' && this.jinaApiKeys.length > 0) {
                 return await this.generateJinaEmbedding(text);
             }
             else if (this.openai) {
@@ -73,28 +119,51 @@ export class EmbeddingService {
             return new Array(this.embeddingDimension).fill(0);
         }
     }
-    async generateJinaEmbedding(text) {
-        if (!this.jinaApiKey)
+    async generateJinaEmbedding(text, retryCount = 0) {
+        const maxRetries = this.jinaApiKeys.length;
+        // Find a working key index before first attempt
+        if (retryCount === 0) {
+            this.currentKeyIndex = this.findWorkingKeyIndex();
+        }
+        const apiKey = this.getCurrentJinaKey();
+        if (!apiKey)
             throw new Error('Jina API key not set');
-        const response = await fetch('https://api.jina.ai/v1/embeddings', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.jinaApiKey}`
-            },
-            body: JSON.stringify({
-                model: this.config.model || 'jina-embeddings-v3',
-                task: 'text-matching',
-                dimensions: 1024,
-                input: [text.substring(0, 8000)]
-            })
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Jina API error: ${response.status} ${error}`);
+        try {
+            const response = await fetch('https://api.jina.ai/v1/embeddings', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.config.model || 'jina-embeddings-v3',
+                    task: 'text-matching',
+                    dimensions: 1024,
+                    input: [text.substring(0, 8000)]
+                })
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // Check for rate limit or auth errors - try next key
+                if (response.status === 429 || response.status === 401 || response.status === 403) {
+                    if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                        Logger.warn(`Jina API key error (${response.status}), trying next key...`);
+                        return this.generateJinaEmbedding(text, retryCount + 1);
+                    }
+                }
+                throw new Error(`Jina API error: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            return data.data[0].embedding;
+        }
+        catch (error) {
+            // Network error or other issue - try next key
+            if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                Logger.warn(`Jina API request failed, trying next key...`);
+                return this.generateJinaEmbedding(text, retryCount + 1);
+            }
+            throw error;
         }
-        const data = await response.json();
-        return data.data[0].embedding;
     }
     /**
      * Generate embeddings for multiple texts - uses true batch API when available
@@ -110,30 +179,13 @@ export class EmbeddingService {
         Logger.progress(`Generating embeddings for ${texts.length} texts...`);
         try {
             // Use true batch API for Jina (much faster!)
-            if (this.config.provider === 'jina' && this.jinaApiKey) {
+            if (this.config.provider === 'jina' && this.jinaApiKeys.length > 0) {
                 const BATCH_SIZE = 500;
                 const allEmbeddings = [];
                 for (let i = 0; i < texts.length; i += BATCH_SIZE) {
                     const batch = texts.slice(i, i + BATCH_SIZE).map(t => t.substring(0, 8000));
-                    const response = await fetch('https://api.jina.ai/v1/embeddings', {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${this.jinaApiKey}`
-                        },
-                        body: JSON.stringify({
-                            model: this.config.model || 'jina-embeddings-v3',
-                            task: 'text-matching',
-                            dimensions: 1024,
-                            input: batch
-                        })
-                    });
-                    if (!response.ok) {
-                        const error = await response.text();
-                        throw new Error(`Jina API error: ${response.status} ${error}`);
-                    }
-                    const data = await response.json();
-                    allEmbeddings.push(...data.data.map(d => d.embedding));
+                    const batchEmbeddings = await this.generateJinaBatchWithRetry(batch);
+                    allEmbeddings.push(...batchEmbeddings);
                     if (progressCallback) {
                         progressCallback(Math.min(i + BATCH_SIZE, texts.length), texts.length);
                     }
@@ -161,6 +213,48 @@ export class EmbeddingService {
             return texts.map(() => new Array(this.embeddingDimension).fill(0));
         }
     }
+    async generateJinaBatchWithRetry(batch, retryCount = 0) {
+        const maxRetries = this.jinaApiKeys.length;
+        const apiKey = this.getCurrentJinaKey();
+        if (!apiKey)
+            throw new Error('Jina API key not set');
+        try {
+            const response = await fetch('https://api.jina.ai/v1/embeddings', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.config.model || 'jina-embeddings-v3',
+                    task: 'text-matching',
+                    dimensions: 1024,
+                    input: batch
+                })
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // Check for rate limit or auth errors - try next key
+                if (response.status === 429 || response.status === 401 || response.status === 403) {
+                    if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                        Logger.warn(`Jina API batch error (${response.status}), trying next key...`);
+                        return this.generateJinaBatchWithRetry(batch, retryCount + 1);
+                    }
+                }
+                throw new Error(`Jina API error: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            return data.data.map(d => d.embedding);
+        }
+        catch (error) {
+            // Network error or other issue - try next key
+            if (retryCount < maxRetries - 1 && this.rotateToNextKey()) {
+                Logger.warn(`Jina API batch request failed, trying next key...`);
+                return this.generateJinaBatchWithRetry(batch, retryCount + 1);
+            }
+            throw error;
+        }
+    }
     async generateOpenAIEmbedding(text) {
         if (!this.openai)
             throw new Error('OpenAI client not initialized');

package/dist/server/index.js

@@ -16,6 +16,7 @@ import morgan from 'morgan';
 import rateLimit from 'express-rate-limit';
 import { createServer } from 'http';
 import path from 'path';
+import fs from 'fs';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
 import { apiRouter } from './routes/api.js';
@@ -25,6 +26,10 @@ import { adminRouter } from './routes/admin.js';
 import { developerRouter } from './routes/developer.js';
 import { githubRouter } from './routes/github.js';
 import deviceAuthRouter from './routes/device-auth.js';
+import { reportIssueRouter } from './routes/report-issue.js';
+import { cache } from './services/cache.js';
+import { db } from './services/database.js';
+import { AuthService } from './services/auth-service.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // CORS whitelist - настройте под свои домены
@@ -53,6 +58,89 @@ const createRateLimiter = (windowMs, max, message) => rateLimit({
         });
     },
 });
+// Settings file path
+const SETTINGS_FILE = path.join(process.cwd(), '.archicore', 'settings.json');
+// Load settings helper
+function loadMaintenanceSettings() {
+    try {
+        if (fs.existsSync(SETTINGS_FILE)) {
+            const data = fs.readFileSync(SETTINGS_FILE, 'utf-8');
+            const settings = JSON.parse(data);
+            return {
+                enabled: settings.maintenance?.enabled || false,
+                message: settings.maintenance?.message || 'ArchiCore is currently undergoing maintenance.'
+            };
+        }
+    }
+    catch (error) {
+        Logger.error('Failed to load maintenance settings:', error);
+    }
+    return { enabled: false, message: '' };
+}
+// Maintenance middleware
+const maintenanceMiddleware = async (req, res, next) => {
+    const maintenance = loadMaintenanceSettings();
+    // If maintenance is not enabled, continue
+    if (!maintenance.enabled) {
+        return next();
+    }
+    // Allow certain paths even in maintenance mode
+    const allowedPaths = [
+        '/api/auth',
+        '/api/admin',
+        '/auth',
+        '/login',
+        '/admin',
+        '/maintenance.html',
+        '/favicon.svg',
+        '/favicon.ico',
+        '/health',
+        '/api/admin/maintenance-status',
+        // Static assets
+        '/fonts/',
+        '/css/',
+        '/js/',
+        '/images/',
+        '/assets/'
+    ];
+    // Check if path is allowed
+    const isAllowed = allowedPaths.some(p => req.path.startsWith(p));
+    if (isAllowed) {
+        return next();
+    }
+    // Check if user is admin via token
+    const authHeader = req.headers.authorization;
+    const token = authHeader?.startsWith('Bearer ') ? authHeader.slice(7) : null;
+    // Also check for token in cookies (for browser requests)
+    const cookieToken = req.headers.cookie?.split(';')
+        .find(c => c.trim().startsWith('archicore_token='))
+        ?.split('=')[1];
+    const actualToken = token || cookieToken;
+    if (actualToken) {
+        try {
+            const authService = AuthService.getInstance();
+            const user = await authService.validateToken(actualToken);
+            if (user && user.tier === 'admin') {
+                return next(); // Admin can access
+            }
+        }
+        catch (error) {
+            // Token invalid, continue to maintenance page
+        }
+    }
+    // For API requests, return JSON
+    if (req.path.startsWith('/api/')) {
+        res.status(503).json({
+            error: 'Service Unavailable',
+            message: maintenance.message,
+            maintenance: true
+        });
+        return;
+    }
+    // For browser requests, serve maintenance page
+    const maintenancePath = path.join(__dirname, '../../public/maintenance.html');
+    res.status(503).sendFile(maintenancePath);
+};
 export class ArchiCoreServer {
     app;
     server = null;
@@ -151,11 +239,14 @@ export class ArchiCoreServer {
             res.setHeader('X-Request-ID', requestId);
             next();
         });
+        // Maintenance mode check
+        this.app.use(maintenanceMiddleware);
         // Статические файлы (фронтенд)
         const publicPath = path.join(__dirname, '../../public');
         this.app.use(express.static(publicPath, {
             maxAge: process.env.NODE_ENV === 'production' ? '1d' : 0,
             etag: true,
+            index: false, // Отключаем автоматический index.html - используем явные маршруты
         }));
     }
     setupRoutes() {
@@ -173,6 +264,8 @@ export class ArchiCoreServer {
         this.app.use('/api', apiRouter);
         // Upload маршруты
         this.app.use('/api/upload', uploadRouter);
+        // Report issue routes
+        this.app.use('/api/report-issue', reportIssueRouter);
         // Health check
         this.app.get('/health', (_req, res) => {
             res.json({
@@ -187,7 +280,62 @@ export class ArchiCoreServer {
             const deviceAuthPath = path.join(__dirname, '../../public/device-auth.html');
             res.sendFile(deviceAuthPath);
         });
-        // SPA fallback - все остальные маршруты отдают index.html
+        // Clean URL routing
+        // Landing page (главная)
+        this.app.get('/', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/landing.html'));
+        });
+        // Dashboard (после авторизации)
+        this.app.get('/dashboard', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/index.html'));
+        });
+        // Add new project page
+        this.app.get('/new', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/index.html'));
+        });
+        // Pricing page
+        this.app.get('/pricing', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/pricing.html'));
+        });
+        // API Dashboard page
+        this.app.get('/api-dashboard', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/api-dashboard.html'));
+        });
+        // Auth page
+        this.app.get('/auth', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/auth.html'));
+        });
+        // Login alias
+        this.app.get('/login', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/auth.html'));
+        });
+        // Register alias
+        this.app.get('/register', (_req, res) => {
+            res.redirect('/auth?mode=register');
+        });
+        // Admin page
+        this.app.get('/admin', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/admin.html'));
+        });
+        // Blog page
+        this.app.get('/blog', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/blog.html'));
+        });
+        // Report issue page (without .html extension)
+        this.app.get('/report-issue', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/report-issue.html'));
+        });
+        // Legal pages
+        this.app.get('/privacy', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/privacy.html'));
+        });
+        this.app.get('/terms', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/terms.html'));
+        });
+        this.app.get('/security', (_req, res) => {
+            res.sendFile(path.join(__dirname, '../../public/security.html'));
+        });
+        // SPA fallback - все остальные маршруты отдают index.html (dashboard)
         this.app.get('/*splat', (_req, res) => {
             const indexPath = path.join(__dirname, '../../public/index.html');
             res.sendFile(indexPath);
@@ -208,6 +356,17 @@ export class ArchiCoreServer {
         });
     }
     async start() {
+        // Initialize database
+        try {
+            await db.init();
+            const authService = AuthService.getInstance();
+            await authService.initDatabase();
+        }
+        catch (error) {
+            Logger.warn('Database initialization failed, using JSON fallback:', error);
+        }
+        // Initialize cache
+        await cache.connect();
         return new Promise((resolve) => {
             this.server = createServer(this.app);
             const host = this.config.host || '0.0.0.0';
@@ -221,6 +380,9 @@ export class ArchiCoreServer {
         });
     }
     async stop() {
+        // Disconnect cache and database
+        await cache.disconnect();
+        await db.close();
         return new Promise((resolve) => {
             if (this.server) {
                 this.server.close(() => {