综合实战：构建完整Cloud IDE

// api-gateway/src/index.js - API网关核心入口
const express = require('express');
const http = require('http');
const { Server } = require('socket.io');
const jwt = require('jsonwebtoken');
const rateLimit = require('express-rate-limit');
const helmet = require('helmet');
const cors = require('cors');

const app = express();
const server = http.createServer(app);

// Socket.IO配置，支持WebSocket升级
const io = new Server(server, {
    cors: {
        origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
        methods: ['GET', 'POST'],
        credentials: true
    },
    pingTimeout: 60000,
    pingInterval: 25000
});

// 安全中间件
app.use(helmet({
    contentSecurityPolicy: {
        directives: {
            defaultSrc: ["'self'"],
            scriptSrc: ["'self'", "'unsafe-inline'", "'unsafe-eval'"],
            styleSrc: ["'self'", "'unsafe-inline'"],
            connectSrc: ["'self'", 'wss:', 'ws:'],
            workerSrc: ["'self'", 'blob:']
        }
    }
}));

app.use(cors({
    origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
    credentials: true
}));

// 请求体解析
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// 全局限流：防止DDoS攻击
const globalLimiter = rateLimit({
    windowMs: 60 * 1000, // 1分钟窗口
    max: 1000, // 最多1000请求
    message: { error: '请求过于频繁，请稍后再试' },
    standardHeaders: true,
    legacyHeaders: false
});
app.use('/api/', globalLimiter);

// 认证中间件
const authMiddleware = require('./middleware/auth');
app.use('/api/', authMiddleware.verifyToken);

// 请求日志中间件
const requestLogger = require('./middleware/logger');
app.use(requestLogger.logRequest);

// 路由配置
const apiRoutes = require('./routes');
app.use('/api/v1', apiRoutes);

// 错误处理
const errorHandler = require('./middleware/errorHandler');
app.use(errorHandler.handle);

// Socket.IO事件处理
const socketHandler = require('./socket');
socketHandler.initialize(io);

// 健康检查
app.get('/health', (req, res) => {
    res.json({ 
        status: 'healthy', 
        uptime: process.uptime(),
        timestamp: new Date().toISOString()
    });
});

const PORT = process.env.PORT || 8080;
server.listen(PORT, () => {
    console.log(`🚀 API Gateway running on port ${PORT}`);
    console.log(`📡 WebSocket server ready`);
    console.log(`🔒 Environment: ${process.env.NODE_ENV || 'development'}`);
});

module.exports = { app, server, io };

// api-gateway/src/services/auth.service.js - 认证服务核心实现
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const { v4: uuidv4 } = require('uuid');
const { pool } = require('../database/postgres');
const { redisClient } = require('../database/redis');
const emailService = require('./email.service');
const { AppError } = require('../utils/errors');

const SALT_ROUNDS = 12;
const ACCESS_TOKEN_EXPIRY = '15m';
const REFRESH_TOKEN_EXPIRY = '7d';
const VERIFICATION_EXPIRY = 24 * 60 * 60 * 1000;

class AuthService {
    /**
     * 用户注册
     */
    async register(userData) {
        const { email, password, username, invitationCode } = userData;
        
        if (!this.isValidEmail(email)) {
            throw new AppError('INVALID_EMAIL', '请输入有效的邮箱地址');
        }
        
        this.validatePasswordStrength(password);
        
        if (!this.isValidUsername(username)) {
            throw new AppError('INVALID_USERNAME', '用户名需包含3-20个字符');
        }
        
        const client = await pool.connect();
        
        try {
            await client.query('BEGIN');
            
            const existingEmail = await client.query(
                'SELECT id FROM users WHERE email = $1',
                [email.toLowerCase()]
            );
            if (existingEmail.rows.length > 0) {
                throw new AppError('EMAIL_EXISTS', '该邮箱已被注册');
            }
            
            const existingUsername = await client.query(
                'SELECT id FROM users WHERE username = $1',
                [username]
            );
            if (existingUsername.rows.length > 0) {
                throw new AppError('USERNAME_EXISTS', '该用户名已被使用');
            }
            
            let plan = 'free';
            if (invitationCode) {
                const inviteResult = await this.validateInvitationCode(client, invitationCode);
                plan = inviteResult.plan;
            }
            
            const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);
            const userId = uuidv4();
            const verificationToken = uuidv4();
            
            const result = await client.query(
                `INSERT INTO users (
                    id, email, username, password_hash, plan, 
                    verification_token, created_at, updated_at
                ) VALUES ($1, $2, $3, $4, $5, $6, NOW(), NOW())
                RETURNING id, email, username, plan, created_at`,
                [userId, email.toLowerCase(), username, passwordHash, plan, verificationToken]
            );
            
            const user = result.rows[0];
            await emailService.sendVerificationEmail(email, verificationToken);
            
            await client.query('COMMIT');
            const tokens = await this.generateTokens(user);
            
            return { user, ...tokens };
            
        } catch (error) {
            await client.query('ROLLBACK');
            throw error;
        } finally {
            client.release();
        }
    }
    
    /**
     * 用户登录
     */
    async login(email, password) {
        if (!email || !password) {
            throw new AppError('MISSING_CREDENTIALS', '邮箱和密码不能为空');
        }
        
        const result = await pool.query(
            'SELECT * FROM users WHERE email = $1',
            [email.toLowerCase()]
        );
        
        const user = result.rows[0];
        
        if (!user) {
            throw new AppError('INVALID_CREDENTIALS', '邮箱或密码错误');
        }
        
        if (!user.is_verified) {
            throw new AppError('EMAIL_NOT_VERIFIED', '请先验证您的邮箱');
        }
        
        if (user.is_locked) {
            throw new AppError('ACCOUNT_LOCKED', '账户已被锁定');
        }
        
        const isPasswordValid = await bcrypt.compare(password, user.password_hash);
        
        if (!isPasswordValid) {
            await this.recordFailedLogin(user.id);
            throw new AppError('INVALID_CREDENTIALS', '邮箱或密码错误');
        }
        
        await this.resetFailedLogins(user.id);
        await pool.query('UPDATE users SET last_login_at = NOW() WHERE id = $1', [user.id]);
        
        const tokens = await this.generateTokens(user);
        await this.createSession(user.id, tokens.refreshToken);
        
        return {
            user: {
                id: user.id,
                email: user.email,
                username: user.username,
                plan: user.plan,
                avatar_url: user.avatar_url
            },
            ...tokens
        };
    }
    
    /**
     * 生成令牌
     */
    async generateTokens(user) {
        const accessToken = jwt.sign(
            { sub: user.id, email: user.email, username: user.username, plan: user.plan, type: 'access' },
            process.env.JWT_SECRET,
            { expiresIn: ACCESS_TOKEN_EXPIRY }
        );
        
        const refreshToken = jwt.sign(
            { sub: user.id, type: 'refresh', jti: uuidv4() },
            process.env.JWT_REFRESH_SECRET,
            { expiresIn: REFRESH_TOKEN_EXPIRY }
        );
        
        return { accessToken, refreshToken };
    }
    
    /**
     * 刷新令牌
     */
    async refreshAccessToken(refreshToken) {
        try {
            const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
            const sessionKey = `session:${decoded.sub}:${decoded.jti}`;
            const session = await redisClient.get(sessionKey);
            
            if (!session) {
                throw new AppError('INVALID_REFRESH_TOKEN', '刷新令牌已失效');
            }
            
            const result = await pool.query('SELECT * FROM users WHERE id = $1', [decoded.sub]);
            const user = result.rows[0];
            
            if (!user || !user.is_verified) {
                throw new AppError('USER_NOT_FOUND', '用户不存在或未验证');
            }
            
            const tokens = await this.generateTokens(user);
            await redisClient.setex(sessionKey, 7 * 24 * 60 * 60, tokens.refreshToken);
            
            return tokens;
            
        } catch (error) {
            if (error.name === 'JsonWebTokenError') {
                throw new AppError('INVALID_REFRESH_TOKEN', '刷新令牌无效');
            }
            throw error;
        }
    }
    
    /**
     * 验证邮箱
     */
    async verifyEmail(token) {
        const result = await pool.query(
            'SELECT id, verification_token FROM users WHERE verification_token = $1',
            [token]
        );
        
        if (result.rows.length === 0) {
            throw new AppError('INVALID_TOKEN', '验证链接无效或已过期');
        }
        
        await pool.query(
            'UPDATE users SET is_verified = true, verification_token = NULL WHERE id = $1',
            [result.rows[0].id]
        );
        
        return true;
    }
    
    /**
     * 验证访问令牌
     */
    async verifyAccessToken(token) {
        try {
            const decoded = jwt.verify(token, process.env.JWT_SECRET);
            
            if (decoded.type !== 'access') {
                throw new AppError('INVALID_TOKEN_TYPE', '令牌类型无效');
            }
            
            const result = await pool.query(
                'SELECT id, is_active FROM users WHERE id = $1',
                [decoded.sub]
            );
            
            if (result.rows.length === 0 || !result.rows[0].is_active) {
                throw new AppError('USER_DISABLED', '用户已被禁用');
            }
            
            return decoded;
            
        } catch (error) {
            if (error.name === 'TokenExpiredError') {
                throw new AppError('TOKEN_EXPIRED', '访问令牌已过期');
            }
            if (error.name === 'JsonWebTokenError') {
                throw new AppError('INVALID_TOKEN', '访问令牌无效');
            }
            throw error;
        }
    }
    
    /**
     * 创建会话
     */
    async createSession(userId, refreshToken) {
        const decoded = jwt.decode(refreshToken);
        const sessionKey = `session:${userId}:${decoded.jti}`;
        await redisClient.setex(sessionKey, 7 * 24 * 60 * 60, JSON.stringify({
            createdAt: Date.now(),
            userAgent: process.headers?.['user-agent']
        }));
    }
    
    /**
     * 记录失败登录
     */
    async recordFailedLogin(userId) {
        const key = `login_failed:${userId}`;
        const attempts = await redisClient.incr(key);
        
        if (attempts === 1) {
            await redisClient.expire(key, 15 * 60);
        }
        
        if (attempts >= 5) {
            await pool.query('UPDATE users SET is_locked = true WHERE id = $1', [userId]);
            setTimeout(async () => {
                await pool.query('UPDATE users SET is_locked = false, login_attempts = 0 WHERE id = $1', [userId]);
            }, 30 * 60 * 1000);
        }
    }
    
    /**
     * 重置失败登录计数
     */
    async resetFailedLogins(userId) {
        await redisClient.del(`login_failed:${userId}`);
        await pool.query('UPDATE users SET login_attempts = 0 WHERE id = $1', [userId]);
    }
    
    /**
     * 验证邮箱格式
     */
    isValidEmail(email) {
        const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return re.test(email);
    }
    
    /**
     * 验证密码强度
     */
    validatePasswordStrength(password) {
        if (password.length < 8) {
            throw new AppError('WEAK_PASSWORD', '密码长度至少为8个字符');
        }
        
        const hasUpperCase = /[A-Z]/.test(password);
        const hasLowerCase = /[a-z]/.test(password);
        const hasNumber = /[0-9]/.test(password);
        const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);
        
        const strength = [hasUpperCase, hasLowerCase, hasNumber, hasSpecialChar].filter(Boolean).length;
        
        if (strength < 3) {
            throw new AppError('WEAK_PASSWORD', '密码需包含大小写字母、数字和特殊字符中的至少三种');
        }
    }
    
    /**
     * 验证用户名格式
     */
    isValidUsername(username) {
        const re = /^[a-zA-Z0-9_]{3,20}$/;
        return re.test(username);
    }
    
    /**
     * 登出
     */
    async logout(userId, refreshToken) {
        try {
            const decoded = jwt.decode(refreshToken);
            if (decoded?.jti) {
                await redisClient.del(`session:${userId}:${decoded.jti}`);
            }
        } catch (error) {
            console.error('Logout error:', error);
        }
    }
}

module.exports = new AuthService();

// api-gateway/src/database/models/project.model.js - 项目数据模型
const { pool } = require('../postgres');

class ProjectModel {
    /**
     * 创建新项目
     */
    async create(projectData) {
        const { name, description, owner_id, template_id, visibility, git_url, default_branch } = projectData;
        
        const id = require('uuid').v4();
        
        const result = await pool.query(
            `INSERT INTO projects (
                id, name, description, owner_id, template_id, visibility,
                git_url, default_branch, created_at, updated_at
            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW(), NOW())
            RETURNING *`,
            [id, name, description, owner_id, template_id || null, visibility || 'private',
             git_url || null, default_branch || 'main']
        );
        
        await this.createDefaultDevfile(id, template_id);
        return result.rows[0];
    }
    
    /**
     * 创建默认.devfile配置
     */
    async createDefaultDevfile(projectId, templateId) {
        let devfileContent;
        
        if (templateId) {
            const template = await pool.query(
                'SELECT devfile FROM project_templates WHERE id = $1',
                [templateId]
            );
            devfileContent = template.rows[0]?.devfile;
        }
        
        if (!devfileContent) {
            devfileContent = {
                schemaVersion: '2.2.0',
                metadata: { name: 'default', version: '1.0.0' },
                components: [{
                    name: 'dev-environment',
                    container: {
                        image: 'ubuntu:latest',
                        mountSources: true,
                        command: ['sleep', 'infinity']
                    }
                }]
            };
        }
        
        await pool.query(
            `INSERT INTO project_files (project_id, path, content, is_directory, created_at)
             VALUES ($1, $2, $3, $4, NOW())`,
            [projectId, '/.devfile.json', JSON.stringify(devfileContent), false]
        );
    }
    
    /**
     * 获取用户可访问的项目列表
     */
    async listByUser(userId, options = {}) {
        const { page = 1, limit = 20, search, sortBy = 'updated_at', sortOrder = 'DESC' } = options;
        const offset = (page - 1) * limit;
        
        let query = `
            SELECT p.*, u.username as owner_username,
                   (SELECT COUNT(*) FROM project_members pm WHERE pm.project_id = p.id) as member_count
            FROM projects p
            LEFT JOIN users u ON p.owner_id = u.id
            WHERE (p.owner_id = $1 OR p.visibility = 'public' 
                   OR EXISTS (SELECT 1 FROM project_members WHERE project_id = p.id AND user_id = $1))
        `;
        
        const params = [userId];
        let paramIndex = 2;
        
        if (search) {
            query += ` AND (p.name ILIKE $${paramIndex} OR p.description ILIKE $${paramIndex})`;
            params.push(`%${search}%`);
            paramIndex++;
        }
        
        const validSortColumns = ['created_at', 'updated_at', 'name'];
        const sortColumn = validSortColumns.includes(sortBy) ? sortBy : 'updated_at';
        const order = sortOrder.toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
        
        query += ` ORDER BY p.${sortColumn} ${order} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
        params.push(limit, offset);
        
        return await pool.query(query, params);
    }
    
    /**
     * 获取项目详情
     */
    async getById(projectId, userId = null) {
        let query = `
            SELECT p.*, u.username as owner_username, u.avatar_url as owner_avatar
            FROM projects p
            LEFT JOIN users u ON p.owner_id = u.id
            WHERE p.id = $1
        `;
        
        const params = [projectId];
        
        if (userId) {
            query += ` AND (p.owner_id = $2 OR p.visibility = 'public' 
                      OR EXISTS (SELECT 1 FROM project_members WHERE project_id = p.id AND user_id = $2))`;
            params.push(userId);
        }
        
        const result = await pool.query(query, params);
        
        if (result.rows.length === 0) {
            return null;
        }
        
        const project = result.rows[0];
        project.members = await this.getMembers(projectId);
        project.stats = await this.getStats(projectId);
        
        return project;
    }
    
    /**
     * 获取项目成员
     */
    async getMembers(projectId) {
        const result = await pool.query(
            `SELECT u.id, u.username, u.email, u.avatar_url, pm.role, pm.joined_at
             FROM project_members pm
             JOIN users u ON pm.user_id = u.id
             WHERE pm.project_id = $1 ORDER BY pm.joined_at`,
            [projectId]
        );
        return result.rows;
    }
    
    /**
     * 获取项目统计
     */
    async getStats(projectId) {
        const fileCount = await pool.query(
            'SELECT COUNT(*) FROM project_files WHERE project_id = $1',
            [projectId]
        );
        
        const executionCount = await pool.query(
            'SELECT COUNT(*) FROM code_executions WHERE project_id = $1',
            [projectId]
        );
        
        return {
            fileCount: parseInt(fileCount.rows[0].count),
            executionCount: parseInt(executionCount.rows[0].count)
        };
    }
    
    /**
     * 更新项目
     */
    async update(projectId, updateData) {
        const { name, description, visibility, devfile } = updateData;
        
        const updates = [];
        const params = [];
        let paramIndex = 1;
        
        if (name !== undefined) { updates.push(`name = $${paramIndex++}`); params.push(name); }
        if (description !== undefined) { updates.push(`description = $${paramIndex++}`); params.push(description); }
        if (visibility !== undefined) { updates.push(`visibility = $${paramIndex++}`); params.push(visibility); }
        if (devfile !== undefined) { updates.push(`devfile = $${paramIndex++}`); params.push(JSON.stringify(devfile)); }
        
        updates.push(`updated_at = NOW()`);
        params.push(projectId);
        
        const result = await pool.query(
            `UPDATE projects SET ${updates.join(', ')} WHERE id = $${paramIndex} RETURNING *`,
            params
        );
        
        return result.rows[0];
    }
    
    /**
     * 删除项目
     */
    async delete(projectId) {
        await pool.query('BEGIN');
        
        try {
            await pool.query('DELETE FROM project_files WHERE project_id = $1', [projectId]);
            await pool.query('DELETE FROM project_members WHERE project_id = $1', [projectId]);
            await pool.query('DELETE FROM code_executions WHERE project_id = $1', [projectId]);
            await pool.query('DELETE FROM project_invitations WHERE project_id = $1', [projectId]);
            await pool.query('DELETE FROM projects WHERE id = $1', [projectId]);
            
            await pool.query('COMMIT');
            return true;
        } catch (error) {
            await pool.query('ROLLBACK');
            throw error;
        }
    }
    
    /**
     * 添加项目成员
     */
    async addMember(projectId, userId, role = 'developer') {
        const result = await pool.query(
            `INSERT INTO project_members (project_id, user_id, role, joined_at)
             VALUES ($1, $2, $3, NOW())
             ON CONFLICT (project_id, user_id) DO UPDATE SET role = $3
             RETURNING *`,
            [projectId, userId, role]
        );
        return result.rows[0];
    }
    
    /**
     * 移除项目成员
     */
    async removeMember(projectId, userId) {
        await pool.query(
            'DELETE FROM project_members WHERE project_id = $1 AND user_id = $2',
            [projectId, userId]
        );
        return true;
    }
    
    /**
     * 检查用户权限
     */
    async checkPermission(projectId, userId, requiredRoles) {
        const project = await pool.query(
            'SELECT owner_id FROM projects WHERE id = $1',
            [projectId]
        );
        
        if (project.rows.length === 0) {
            return false;
        }
        
        if (project.rows[0].owner_id === userId) {
            return true;
        }
        
        if (requiredRoles.includes('member')) {
            const member = await pool.query(
                'SELECT role FROM project_members WHERE project_id = $1 AND user_id = $2',
                [projectId, userId]
            );
            
            if (member.rows.length === 0) {
                return false;
            }
            
            return requiredRoles.includes(member.rows[0].role);
        }
        
        return false;
    }
}

module.exports = new ProjectModel();

// api-gateway/src/services/filesystem.service.js - 文件系统服务
const { pool } = require('../database/postgres');
const { redisClient } = require('../database/redis');
const s3Service = require('./s3.service');
const path = require('path');
const { v4: uuidv4 } = require('uuid');
const { AppError } = require('../utils/errors');

class FilesystemService {
    /**
     * 获取项目文件树
     */
    async getFileTree(projectId) {
        const result = await pool.query(
            `SELECT id, path, name, is_directory, mime_type, size, created_at, updated_at
             FROM project_files 
             WHERE project_id = $1 
             ORDER BY is_directory DESC, name ASC`,
            [projectId]
        );
        
        return this.buildTree(result.rows);
    }
    
    /**
     * 构建文件树
     */
    buildTree(files) {
        const fileMap = new Map();
        const roots = [];
        
        files.forEach(file => {
            fileMap.set(file.path, {
                id: file.id,
                name: file.name,
                path: file.path,
                isDirectory: file.is_directory,
                mimeType: file.mime_type,
                size: file.size,
                children: [],
                createdAt: file.created_at,
                updatedAt: file.updated_at
            });
        });
        
        files.forEach(file => {
            const node = fileMap.get(file.path);
            const parentPath = path.dirname(file.path);
            
            if (parentPath === '/' || parentPath === '.') {
                roots.push(node);
            } else {
                const parent = fileMap.get(parentPath);
                if (parent) {
                    parent.children.push(node);
                } else {
                    roots.push(node);
                }
            }
        });
        
        return roots;
    }
    
    /**
     * 读取文件内容
     */
    async readFile(projectId, filePath) {
        const result = await pool.query(
            `SELECT * FROM project_files WHERE project_id = $1 AND path = $2`,
            [projectId, filePath]
        );
        
        if (result.rows.length === 0) {
            throw new AppError('FILE_NOT_FOUND', `文件不存在: ${filePath}`);
        }
        
        const file = result.rows[0];
        
        if (file.is_directory) {
            throw new AppError('IS_DIRECTORY', '该路径是目录，不是文件');
        }
        
        if (file.storage_path) {
            file.content = await s3Service.getFile(file.storage_path);
        }
        
        return file;
    }
    
    /**
     * 创建文件或目录
     */
    async createFile(projectId, filePath, options = {}) {
        const { content, isDirectory, mimeType } = options;
        
        const parentPath = path.dirname(filePath);
        if (parentPath !== '/' && parentPath !== '.') {
            const parentExists = await pool.query(
                'SELECT id FROM project_files WHERE project_id = $1 AND path = $2 AND is_directory = true',
                [projectId, parentPath]
            );
            
            if (parentExists.rows.length === 0) {
                throw new AppError('PARENT_NOT_FOUND', `父目录不存在: ${parentPath}`);
            }
        }
        
        const existing = await pool.query(
            'SELECT id FROM project_files WHERE project_id = $1 AND path = $2',
            [projectId, filePath]
        );
        
        if (existing.rows.length > 0) {
            throw new AppError('FILE_EXISTS', `文件已存在: ${filePath}`);
        }
        
        const id = uuidv4();
        const name = path.basename(filePath);
        let storagePath = null;
        let size = 0;
        
        if (!isDirectory && content && content.length > 1024 * 100) {
            storagePath = `projects/${projectId}/files/${id}`;
            await s3Service.uploadFile(storagePath, content);
            size = Buffer.byteLength(content, 'utf8');
            content = null;
        }
        
        const result = await pool.query(
            `INSERT INTO project_files (
                id, project_id, path, name, content, storage_path, 
                is_directory, mime_type, size, created_at, updated_at
            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
            RETURNING *`,
            [id, projectId, filePath, name, isDirectory ? null : content, 
             storagePath, isDirectory || false, mimeType || 'text/plain', size]
        );
        
        await redisClient.del(`file_tree:${projectId}`);
        return result.rows[0];
    }
    
    /**
     * 更新文件内容
     */
    async updateFile(projectId, filePath, content) {
        const file = await pool.query(
            'SELECT * FROM project_files WHERE project_id = $1 AND path = $2',
            [projectId, filePath]
        );
        
        if (file.rows.length === 0) {
            throw new AppError('FILE_NOT_FOUND', `文件不存在: ${filePath}`);
        }
        
        if (file.rows[0].is_directory) {
            throw new AppError('IS_DIRECTORY', '不能更新目录内容');
        }
        
        const fileRecord = file.rows[0];
        let storagePath = fileRecord.storage_path;
        let size = Buffer.byteLength(content, 'utf8');
        
        if (size > 1024 * 100) {
            storagePath = `projects/${projectId}/files/${fileRecord.id}`;
            await s3Service.uploadFile(storagePath, content);
            content = null;
        }
        
        const result = await pool.query(
            `UPDATE project_files SET content = $1, storage_path = $2, size = $3, updated_at = NOW()
             WHERE project_id = $4 AND path = $5 RETURNING *`,
            [content, storagePath, size, projectId, filePath]
        );
        
        await redisClient.del(`file_tree:${projectId}`);
        await redisClient.del(`file:${projectId}:${filePath}`);
        
        return result.rows[0];
    }
    
    /**
     * 删除文件或目录
     */
    async deleteFile(projectId, filePath) {
        const file = await pool.query(
            'SELECT * FROM project_files WHERE project_id = $1 AND path = $2',
            [projectId, filePath]
        );
        
        if (file.rows.length === 0) {
            throw new AppError('FILE_NOT_FOUND', `文件不存在: ${filePath}`);
        }
        
        const fileRecord = file.rows[0];
        
        if (fileRecord.is_directory) {
            await pool.query(
                'DELETE FROM project_files WHERE project_id = $1 AND path LIKE $2',
                [projectId, `${filePath}/%`]
            );
        }
        
        if (fileRecord.storage_path) {
            await s3Service.deleteFile(fileRecord.storage_path);
        }
        
        await pool.query(
            'DELETE FROM project_files WHERE project_id = $1 AND path = $2',
            [projectId, filePath]
        );
        
        await redisClient.del(`file_tree:${projectId}`);
        return true;
    }
    
    /**
     * 重命名文件
     */
    async renameFile(projectId, oldPath, newPath) {
        const file = await pool.query(
            'SELECT * FROM project_files WHERE project_id = $1 AND path = $2',
            [projectId, oldPath]
        );
        
        if (file.rows.length === 0) {
            throw new AppError('FILE_NOT_FOUND', `文件不存在: ${oldPath}`);
        }
        
        const fileRecord = file.rows[0];
        const newName = path.basename(newPath);
        
        if (fileRecord.is_directory) {
            const children = await pool.query(
                'SELECT path FROM project_files WHERE project_id = $1 AND path LIKE $2',
                [projectId, `${oldPath}/%`]
            );
            
            for (const child of children.rows) {
                const newChildPath = child.path.replace(oldPath, newPath);
                await pool.query(
                    'UPDATE project_files SET path = $1, name = $2 WHERE path = $3',
                    [newChildPath, path.basename(newChildPath), child.path]
                );
            }
        }
        
        const result = await pool.query(
            `UPDATE project_files SET path = $1, name = $2, updated_at = NOW()
             WHERE project_id = $3 AND path = $4 RETURNING *`,
            [newPath, newName, projectId, oldPath]
        );
        
        await redisClient.del(`file_tree:${projectId}`);
        return result.rows[0];
    }
    
    /**
     * 搜索文件内容
     */
    async searchFiles(projectId, query, options = {}) {
        const { fileTypes, caseSensitive } = options;
        
        let sqlQuery = `
            SELECT * FROM project_files 
            WHERE project_id = $1 AND is_directory = false AND content IS NOT NULL
        `;
        
        const params = [projectId];
        let paramIndex = 2;
        
        if (caseSensitive) {
            sqlQuery += ` AND content LIKE $${paramIndex++}`;
        } else {
            sqlQuery += ` AND content ILIKE $${paramIndex++}`;
        }
        params.push(`%${query}%`);
        
        if (fileTypes && fileTypes.length > 0) {
            sqlQuery += ` AND mime_type = ANY($${paramIndex}::text[])`;
            params.push(fileTypes);
            paramIndex++;
        }
        
        const result = await pool.query(sqlQuery, params);
        
        return result.rows.filter(file => {
            const content = file.content || '';
            const pattern = caseSensitive ? query : query.toLowerCase();
            const searchContent = caseSensitive ? content : content.toLowerCase();
            
            const index = searchContent.indexOf(pattern);
            if (index === -1) return false;
            
            const start = Math.max(0, index - 50);
            const end = Math.min(content.length, index + query.length + 50);
            
            file.matchContext = content.substring(start, end);
            file.matchIndex = index - start;
            
            return true;
        });
    }
}

module.exports = new FilesystemService();

// client/src/components/CloudIDE/Editor/CodeEditor.jsx - 代码编辑器主组件
import React, { useEffect, useRef, useState, useCallback } from 'react';
import * as monaco from 'monaco-editor';
import { editor as monacoEditor } from 'monaco-editor';
import editorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
import jsonWorker from 'monaco-editor/esm/vs/language/json/json.worker?worker';
import cssWorker from 'monaco-editor/esm/vs/language/css/css.worker?worker';
import htmlWorker from 'monaco-editor/esm/vs/language/html/html.worker?worker';
import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
import { useCollaboration } from '../../hooks/useCollaboration';
import { useFileSystem } from '../../hooks/useFileSystem';
import { useAIAssist } from '../../hooks/useAIAssist';
import EditorToolbar from './EditorToolbar';
import EditorTabs from './EditorTabs';
import Minimap from './Minimap';
import StatusBar from './StatusBar';
import './CodeEditor.css';

// 配置Monaco Workers
self.MonacoEnvironment = {
    getWorker(_, label) {
        if (label === 'json') return new jsonWorker();
        if (label === 'css' || label === 'scss' || label === 'less') return new cssWorker();
        if (label === 'html' || label === 'handlebars' || label === 'razor') return new htmlWorker();
        if (label === 'typescript' || label === 'javascript') return new tsWorker();
        return new editorWorker();
    }
};

const CodeEditor = ({ projectId, filePath, onFileChange }) => {
    const containerRef = useRef(null);
    const editorRef = useRef(null);
    const decorationsRef = useRef([]);
    const [isLoading, setIsLoading] = useState(true);
    const [currentFile, setCurrentFile] = useState(null);
    const [isDirty, setIsDirty] = useState(false);
    
    const {
        isConnected, remoteUsers, remoteSelections,
        onRemoteOperation, sendOperation, updateCursorPosition
    } = useCollaboration(projectId, filePath);
    
    const { readFile, writeFile, subscribeToFile } = useFileSystem(projectId);
    
    const {
        suggestions, isGenerating, generateCompletion,
        acceptSuggestion, rejectSuggestion
    } = useAIAssist();
    
    // 初始化编辑器
    useEffect(() => {
        if (!containerRef.current) return;
        
        monaco.editor.defineTheme('cloudIDE-dark', {
            base: 'vs-dark',
            inherit: true,
            rules: [
                { token: 'comment', foreground: '6A9955', fontStyle: 'italic' },
                { token: 'keyword', foreground: '569CD6', fontStyle: 'bold' },
                { token: 'string', foreground: 'CE9178' },
                { token: 'number', foreground: 'B5CEA8' },
                { token: 'type', foreground: '4EC9B0' },
                { token: 'function', foreground: 'DCDCAA' },
                { token: 'variable', foreground: '9CDCFE' }
            ],
            colors: {
                'editor.background': '#1E1E1E',
                'editor.foreground': '#D4D4D4',
                'editor.lineHighlightBackground': '#2D2D30',
                'editor.selectionBackground': '#264F78',
                'editorCursor.foreground': '#AEAFAD'
            }
        });
        
        editorRef.current = monaco.editor.create(containerRef.current, {
            value: '',
            language: 'javascript',
            theme: 'cloudIDE-dark',
            fontSize: 14,
            fontFamily: "'JetBrains Mono', 'Fira Code', Consolas, monospace",
            fontLigatures: true,
            lineNumbers: 'on',
            renderLineHighlight: 'all',
            minimap: { enabled: true, maxColumn: 80, renderCharacters: false },
            scrollBeyondLastLine: false,
            smoothScrolling: true,
            cursorBlinking: 'smooth',
            cursorSmoothCaretAnimation: 'on',
            bracketPairColorization: { enabled: true },
            automaticLayout: true,
            tabSize: 4,
            insertSpaces: true,
            wordWrap: 'off',
            formatOnPaste: true,
            formatOnType: true,
            suggestOnTriggerCharacters: true,
            acceptSuggestionOnEnter: 'on',
            quickSuggestions: { other: true, comments: false, strings: true },
            parameterHints: { enabled: true, cycle: true },
            folding: true,
            foldingStrategy: 'indentation',
            showFoldingControls: 'mouseover',
            matchBrackets: 'always',
            autoClosingBrackets: 'always',
            autoClosingQuotes: 'always',
            autoIndent: 'full',
            dragAndDrop: true,
            linkedEditing: true,
            multiCursorModifier: 'ctrlCmd',
            accessibilitySupport: 'on'
        });
        
        editorRef.current.addCommand(
            monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS,
            () => handleSave()
        );
        
        editorRef.current.addCommand(
            monaco.KeyMod.CtrlCmd | monaco.KeyCode.Shift | monaco.KeyCode.KeyP,
            () => editorRef.current.getAction('editor.action.quickCommand').run()
        );
        
        editorRef.current.onDidChangeModelContent((event) => {
            setIsDirty(true);
            event.changes.forEach(change => {
                const operation = {
                    type: change.text ? 'insert' : 'delete',
                    position: change.range.start,
                    endPosition: change.rangeEnd,
                    text: change.text,
                    timestamp: Date.now()
                };
                sendOperation(operation);
            });
            if (onFileChange) onFileChange(editorRef.current.getValue());
        });
        
        editorRef.current.onDidChangeCursorPosition((event) => {
            updateCursorPosition({
                lineNumber: event.position.lineNumber,
                column: event.position.column
            });
        });
        
        setIsLoading(false);
        
        return () => {
            if (editorRef.current) editorRef.current.dispose();
        };
    }, []);
    
    // 加载文件内容
    useEffect(() => {
        if (!filePath) return;
        
        const loadFile = async () => {
            setIsLoading(true);
            try {
                const file = await readFile(filePath);
                const language = getLanguageFromPath(filePath);
                monaco.editor.setModelLanguage(editorRef.current.getModel(), language);
                editorRef.current.setValue(file.content || '');
                setCurrentFile({ path: filePath, ...file });
                setIsDirty(false);
            } catch (error) {
                console.error('Failed to load file:', error);
            } finally {
                setIsLoading(false);
            }
        };
        
        loadFile();
        
        const unsubscribe = subscribeToFile(filePath, (newContent) => {
            if (!isDirty) editorRef.current.setValue(newContent);
        });
        
        return () => { if (unsubscribe) unsubscribe(); };
    }, [filePath]);
    
    // 保存文件
    const handleSave = useCallback(async () => {
        if (!currentFile || !isDirty) return;
        try {
            await writeFile(currentFile.path, editorRef.current.getValue());
            setIsDirty(false);
        } catch (error) {
            console.error('Failed to save file:', error);
        }
    }, [currentFile, isDirty, writeFile]);
    
    // 根据文件路径获取语言
    const getLanguageFromPath = (filePath) => {
        const ext = filePath.split('.').pop().toLowerCase();
        const languageMap = {
            'js': 'javascript', 'jsx': 'javascript',
            'ts': 'typescript', 'tsx': 'typescript',
            'json': 'json', 'html': 'html', 'css': 'css',
            'scss': 'scss', 'less': 'less', 'py': 'python',
            'java': 'java', 'go': 'go', 'rs': 'rust',
            'rb': 'ruby', 'php': 'php', 'sql': 'sql',
            'sh': 'shell', 'bash': 'shell', 'md': 'markdown',
            'yaml': 'yaml', 'yml': 'yaml', 'xml': 'xml',
            'vue': 'html', 'svelte': 'html'
        };
        return languageMap[ext] || 'plaintext';
    };
    
    return (
        <div className="code-editor">
            <EditorToolbar
                onSave={handleSave}
                onFormat={() => editorRef.current?.getAction('editor.action.formatDocument').run()}
                onFind={() => editorRef.current?.getAction('actions.find').run()}
                onReplace={() => editorRef.current?.getAction('editor.action.startFindReplaceAction').run()}
                isDirty={isDirty}
            />
            <EditorTabs
                files={[currentFile]}
                activeFile={currentFile?.path}
                onSelectFile={(path) => {}}
                onCloseFile={(path) => {}}
            />
            <div className="editor-container" ref={containerRef}>
                {isLoading && (
                    <div className="editor-loading">
                        <div className="spinner"></div>
                        <span>加载中...</span>
                    </div>
                )}
            </div>
            <StatusBar
                language={currentFile ? getLanguageFromPath(currentFile.path) : 'plaintext'}
                line={editorRef.current?.getPosition()?.lineNumber || 1}
                column={editorRef.current?.getPosition()?.column || 1}
                isConnected={isConnected}
                remoteUsers={remoteUsers}
            />
        </div>
    );
};

export default CodeEditor;

/* client/src/components/CloudIDE/Editor/CodeEditor.css - 编辑器样式 */
.code-editor {
    display: flex;
    flex-direction: column;
    height: 100%;
    background: #1E1E1E;
    color: #D4D4D4;
}

.editor-container {
    flex: 1;
    position: relative;
    overflow: hidden;
}

.editor-loading {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    background: rgba(30, 30, 30, 0.9);
    z-index: 100;
}

.spinner {
    width: 40px;
    height: 40px;
    border: 3px solid #404040;
    border-top-color: #569CD6;
    border-radius: 50%;
    animation: spin 1s linear infinite;
}

@keyframes spin { to { transform: rotate(360deg); } }

.remote-selection-1 { background: rgba(255, 107, 107, 0.2); }
.remote-selection-2 { background: rgba(78, 205, 196, 0.2); }
.remote-selection-3 { background: rgba(69, 183, 209, 0.2); }
.remote-selection-4 { background: rgba(150, 206, 180, 0.2); }
.remote-selection-5 { background: rgba(255, 234, 167, 0.2); }

.editor-toolbar {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: #252526;
    border-bottom: 1px solid #3C3C3C;
    gap: 8px;
}

.editor-toolbar button {
    display: flex;
    align-items: center;
    justify-content: center;
    padding: 6px 12px;
    background: #3C3C3C;
    border: none;
    border-radius: 4px;
    color: #CCCCCC;
    font-size: 12px;
    cursor: pointer;
    transition: all 0.15s ease;
}

.editor-toolbar button:hover { background: #505050; }
.editor-toolbar button:active { background: #606060; }

.editor-tabs {
    display: flex;
    background: #252526;
    border-bottom: 1px solid #3C3C3C;
    overflow-x: auto;
}

.editor-tab {
    display: flex;
    align-items: center;
    padding: 8px 16px;
    background: #2D2D2D;
    border-right: 1px solid #3C3C3C;
    color: #CCCCCC;
    font-size: 13px;
    cursor: pointer;
    transition: all 0.15s ease;
    white-space: nowrap;
}

.editor-tab:hover { background: #333333; }
.editor-tab.active { background: #1E1E1E; border-bottom: 2px solid #569CD6; }

.editor-statusbar {
    display: flex;
    align-items: center;
    justify-content: space-between;
    padding: 4px 12px;
    background: #007ACC;
    color: #FFFFFF;
    font-size: 12px;
}

.statusbar-left, .statusbar-right {
    display: flex;
    align-items: center;
    gap: 16px;
}

.remote-user-avatar {
    width: 20px;
    height: 20px;
    border-radius: 50%;
    background: #FF6B6B;
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 10px;
    color: white;
}

// api-gateway/src/socket/index.js - WebSocket服务器核心实现
const jwt = require('jsonwebtoken');
const { v4: uuidv4 } = require('uuid');
const { redisClient, redisSub } = require('../database/redis');
const { pool } = require('../database/postgres');
const OTEngine = require('./ot-engine');
const PresenceManager = require('./presence-manager');

class SocketHandler {
    constructor() {
        this.io = null;
        this.rooms = new Map();
        this.userSockets = new Map();
        this.socketUsers = new Map();
        this.otEngines = new Map();
        this.presenceManager = null;
    }
    
    initialize(io) {
        this.io = io;
        this.presenceManager = new PresenceManager(io);
        
        io.use(async (socket, next) => {
            try {
                await this.authenticateSocket(socket);
                next();
            } catch (error) {
                next(new Error('Authentication error'));
            }
        });
        
        io.on('connection', (socket) => {
            console.log(`Socket connected: ${socket.id}, User: ${socket.user.id}`);
            this.registerUserSocket(socket);
            this.setupHeartbeat(socket);
            
            socket.on('join-project', (data) => this.handleJoinProject(socket, data));
            socket.on('leave-project', (data) => this.handleLeaveProject(socket, data));
            socket.on('file-operation', (data) => this.handleFileOperation(socket, data));
            socket.on('cursor-update', (data) => this.handleCursorUpdate(socket, data));
            socket.on('selection-update', (data) => this.handleSelectionUpdate(socket, data));
            socket.on('terminal-output', (data) => this.handleTerminalOutput(socket, data));
            socket.on('chat-message', (data) => this.handleChatMessage(socket, data));
            socket.on('ai-request', (data) => this.handleAIRequest(socket, data));
            socket.on('disconnect', (reason) => this.handleDisconnect(socket, reason));
        });
        
        this.setupRedisSubscription();
    }
    
    async authenticateSocket(socket) {
        const token = socket.handshake.auth.token || socket.handshake.query.token;
        
        if (!token) throw new Error('No token provided');
        
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        const result = await pool.query(
            'SELECT id, username, email, avatar_url FROM users WHERE id = $1',
            [decoded.sub]
        );
        
        if (result.rows.length === 0) throw new Error('User not found');
        socket.user = result.rows[0];
    }
    
    registerUserSocket(socket) {
        const { id: userId } = socket.user;
        if (!this.userSockets.has(userId)) this.userSockets.set(userId, new Set());
        this.userSockets.get(userId).add(socket.id);
        this.socketUsers.set(socket.id, socket.user);
    }
    
    setupHeartbeat(socket) {
        socket.emit('heartbeat', { timestamp: Date.now() });
        
        socket.on('heartbeat-ack', () => { socket.lastHeartbeat = Date.now(); });
        
        const heartbeatInterval = setInterval(() => {
            if (socket.lastHeartbeat && Date.now() - socket.lastHeartbeat > 30000) {
                socket.disconnect(true);
            }
        }, 10000);
        
        socket.on('disconnect', () => clearInterval(heartbeatInterval));
    }
    
    async handleJoinProject(socket, { projectId, filePath }) {
        const roomId = `${projectId}:${filePath}`;
        
        await socket.join(roomId);
        
        if (!this.rooms.has(roomId)) this.rooms.set(roomId, new Set());
        this.rooms.get(roomId).add(socket.id);
        
        if (!this.otEngines.has(roomId)) this.otEngines.set(roomId, new OTEngine(roomId));
        
        const onlineUsers = this.presenceManager.getRoomPresence(roomId);
        const otEngine = this.otEngines.get(roomId);
        
        socket.emit('join-success', {
            roomId,
            documentState: otEngine.getDocumentState(),
            revision: otEngine.getRevision(),
            onlineUsers
        });
        
        socket.to(roomId).emit('user-joined', {
            user: socket.user,
            socketId: socket.id,
            timestamp: Date.now()
        });
        
        this.presenceManager.updatePresence(roomId, socket.user.id, {
            socketId: socket.id,
            username: socket.user.username,
            avatarUrl: socket.user.avatar_url,
            cursor: null,
            selection: null,
            lastActivity: Date.now()
        });
        
        socket.data.roomId = roomId;
        socket.data.projectId = projectId;
        socket.data.filePath = filePath;
    }
    
    async handleLeaveProject(socket, { projectId, filePath }) {
        const roomId = `${projectId}:${filePath}`;
        
        await socket.leave(roomId);
        
        if (this.rooms.has(roomId)) {
            this.rooms.get(roomId).delete(socket.id);
            if (this.rooms.get(roomId).size === 0) {
                this.rooms.delete(roomId);
                await this.saveDocumentState(roomId);
                this.otEngines.delete(roomId);
            }
        }
        
        socket.to(roomId).emit('user-left', {
            user: socket.user,
            socketId: socket.id,
            timestamp: Date.now()
        });
        
        this.presenceManager.removePresence(roomId, socket.user.id);
        socket.data.roomId = null;
        socket.data.projectId = null;
        socket.data.filePath = null;
    }
    
    handleFileOperation(socket, operation) {
        const { roomId } = socket.data;
        if (!roomId) return;
        
        const otEngine = this.otEngines.get(roomId);
        if (!otEngine) return;
        
        operation.serverTimestamp = Date.now();
        operation.clientId = socket.id;
        operation.userId = socket.user.id;
        
        try {
            const transformedOp = otEngine.applyOperation(operation);
            
            if (transformedOp) {
                socket.to(roomId).emit('remote-operation', {
                    ...transformedOp,
                    userId: socket.user.id,
                    username: socket.user.username
                });
                
                socket.emit('operation-ack', {
                    clientId: operation.clientId,
                    revision: otEngine.getRevision()
                });
            }
        } catch (error) {
            console.error('OT operation error:', error);
            socket.emit('operation-error', {
                clientId: operation.clientId,
                error: error.message
            });
        }
    }
    
    handleCursorUpdate(socket, { lineNumber, column }) {
        const { roomId } = socket.data;
        if (!roomId) return;
        
        socket.to(roomId).emit('remote-cursor', {
            userId: socket.user.id,
            username: socket.user.username,
            lineNumber,
            column,
            timestamp: Date.now()
        });
        
        this.presenceManager.updatePresence(roomId, socket.user.id, {
            cursor: { lineNumber, column }
        });
    }
    
    handleSelectionUpdate(socket, { startLineNumber, startColumn, endLineNumber, endColumn }) {
        const { roomId } = socket.data;
        if (!roomId) return;
        
        socket.to(roomId).emit('remote-selection', {
            userId: socket.user.id,
            username: socket.user.username,
            selection: { startLineNumber, startColumn, endLineNumber, endColumn },
            timestamp: Date.now()
        });
        
        this.presenceManager.updatePresence(roomId, socket.user.id, {
            selection: { startLineNumber, startColumn, endLineNumber, endColumn }
        });
    }
    
    handleTerminalOutput(socket, { terminalId, data, type }) {
        const { roomId } = socket.data;
        if (!roomId) return;
        
        socket.to(roomId).emit('remote-terminal', {
            terminalId, data, type,
            userId: socket.user.id,
            username: socket.user.username
        });
    }
    
    async handleChatMessage(socket, { projectId, message }) {
        const chatMessage = {
            id: uuidv4(),
            projectId,
            userId: socket.user.id,
            username: socket.user.username,
            avatarUrl: socket.user.avatar_url,
            content: message,
            timestamp: Date.now()
        };
        
        await pool.query(
            `INSERT INTO project_messages (id, project_id, user_id, content, created_at)
             VALUES ($1, $2, $3, $4, $5)`,
            [chatMessage.id, projectId, socket.user.id, message, new Date(chatMessage.timestamp)]
        );
        
        this.io.to(`project:${projectId}`).emit('chat-message', chatMessage);
    }
    
    async handleAIRequest(socket, { requestId, type, prompt, context }) {
        try {
            const aiService = require('../services/ai.service');
            const response = await aiService.generate({
                type, prompt, context,
                projectId: socket.data.projectId,
                userId: socket.user.id
            });
            
            socket.emit('ai-response', { requestId, success: true, data: response });
            
            if (response.stream) {
                for await (const chunk of response.stream) {
                    socket.emit('ai-stream', { requestId, chunk });
                }
                socket.emit('ai-stream-end', { requestId });
            }
        } catch (error) {
            socket.emit('ai-response', { requestId, success: false, error: error.message });
        }
    }
    
    async handleDisconnect(socket, reason) {
        const { roomId } = socket.data;
        
        if (roomId) {
            socket.to(roomId).emit('user-left', {
                user: socket.user,
                socketId: socket.id,
                timestamp: Date.now()
            });
            
            this.presenceManager.removePresence(roomId, socket.user.id);
            
            if (this.rooms.has(roomId)) {
                this.rooms.get(roomId).delete(socket.id);
                if (this.rooms.get(roomId).size === 0) await this.saveDocumentState(roomId);
            }
        }
        
        if (this.userSockets.has(socket.user.id)) {
            this.userSockets.get(socket.user.id).delete(socket.id);
            if (this.userSockets.get(socket.user.id).size === 0) {
                this.userSockets.delete(socket.user.id);
            }
        }
        this.socketUsers.delete(socket.id);
    }
    
    setupRedisSubscription() {
        redisSub.subscribe('cloud-ide:events', (err) => {
            if (err) console.error('Redis subscribe error:', err);
        });
        
        redisSub.on('message', (channel, message) => {
            if (channel === 'cloud-ide:events') {
                const event = JSON.parse(message);
                this.handleRedisEvent(event);
            }
        });
    }
    
    handleRedisEvent(event) {
        const { type, roomId, data } = event;
        
        switch (type) {
            case 'broadcast-operation':
                this.io.to(roomId).emit('remote-operation', data);
                break;
            case 'user-joined':
                this.io.to(roomId).emit('user-joined', data);
                break;
            case 'user-left':
                this.io.to(roomId).emit('user-left', data);
                break;
        }
    }
    
    async saveDocumentState(roomId) {
        const otEngine = this.otEngines.get(roomId);
        if (!otEngine) return;
        
        const state = otEngine.getDocumentState();
        const [projectId, filePath] = roomId.split(':');
        
        await pool.query(
            `UPDATE project_files SET content = $1, updated_at = NOW()
             WHERE project_id = $2 AND path = $3`,
            [state.content, projectId, filePath]
        );
        
        await redisClient.del(`file:${projectId}:${filePath}`);
    }
}

module.exports = new SocketHandler();

// api-gateway/src/socket/ot-engine.js - OT引擎实现

const OperationType = {
    INSERT: 'insert',
    DELETE: 'delete',
    RETAIN: 'retain'
};

class Operation {
    constructor(type, position, text, length = 0) {
        this.type = type;
        this.position = position;
        this.text = text;
        this.length = length;
        this.userId = null;
        this.clientId = null;
        this.timestamp = Date.now();
    }
    
    static fromJSON(json) {
        const op = new Operation(json.type, json.position, json.text, json.length);
        op.userId = json.userId;
        op.clientId = json.clientId;
        op.timestamp = json.timestamp;
        return op;
    }
    
    toJSON() {
        return {
            type: this.type, position: this.position, text: this.text,
            length: this.length, userId: this.userId, clientId: this.clientId,
            timestamp: this.timestamp
        };
    }
}

class OTEngine {
    constructor(roomId) {
        this.roomId = roomId;
        this.document = '';
        this.revision = 0;
        this.pendingOps = [];
        this.history = [];
        this.clients = new Map();
        this.MAX_HISTORY = 1000;
    }
    
    initialize(content = '') {
        this.document = content;
        this.revision = 0;
        this.history = [];
    }
    
    applyOperation(operation) {
        const op = operation instanceof Operation ? operation : Operation.fromJSON(operation);
        
        if (!this.validateOperation(op)) {
            throw new Error('Invalid operation');
        }
        
        const transformedOp = this.transform(op);
        this.applyToDocument(transformedOp);
        this.revision++;
        this.history.push(transformedOp);
        
        if (this.history.length > this.MAX_HISTORY) this.history.shift();
        
        return { ...transformedOp, revision: this.revision };
    }
    
    validateOperation(op) {
        if (op.type === OperationType.INSERT) {
            return op.position >= 0 && op.position <= this.document.length;
        }
        if (op.type === OperationType.DELETE) {
            return op.position >= 0 && 
                   op.position + op.length <= this.document.length && op.length > 0;
        }
        return false;
    }
    
    transform(op1, op2) {
        if (!this.operationsOverlap(op1, op2)) return op1;
        
        if (op1.type === OperationType.INSERT && op2.type === OperationType.INSERT) {
            return this.transformInsertInsert(op1, op2);
        }
        if (op1.type === OperationType.INSERT && op2.type === OperationType.DELETE) {
            return this.transformInsertDelete(op1, op2);
        }
        if (op1.type === OperationType.DELETE && op2.type === OperationType.INSERT) {
            return this.transformDeleteInsert(op1, op2);
        }
        if (op1.type === OperationType.DELETE && op2.type === OperationType.DELETE) {
            return this.transformDeleteDelete(op1, op2);
        }
        return op1;
    }
    
    transformInsertInsert(op1, op2) {
        const transformed = new Operation(op1.type, op1.position, op1.text, op1.length);
        
        if (op1.position > op2.position) {
            transformed.position += op2.text.length;
        } else if (op1.position === op2.position) {
            if (op1.userId > op2.userId) transformed.position += op2.text.length;
        }
        
        return transformed;
    }
    
    transformInsertDelete(op1, op2) {
        const transformed = new Operation(op1.type, op1.position, op1.text, op1.length);
        
        if (op1.position > op2.position) {
            if (op1.position >= op2.position + op2.length) {
                transformed.position -= op2.length;
            } else {
                transformed.position = op2.position;
            }
        }
        
        return transformed;
    }
    
    transformDeleteInsert(op1, op2) {
        const transformed = new Operation(op1.type, op1.position, op1.text, op1.length);
        
        if (op2.position >= op1.position + op1.length) {
            transformed.position += op2.text.length;
        } else if (op2.position >= op1.position) {
            transformed.length += op2.text.length;
        }
        
        return transformed;
    }
    
    transformDeleteDelete(op1, op2) {
        const transformed = new Operation(op1.type, op1.position, op1.text, op1.length);
        
        const op1End = op1.position + op1.length;
        const op2End = op2.position + op2.length;
        
        if (op1End <= op2.position) return transformed;
        if (op2End <= op1.position) {
            transformed.position -= op2.length;
            return transformed;
        }
        
        const overlapStart = Math.max(op1.position, op2.position);
        const overlapEnd = Math.min(op1End, op2End);
        const overlapLength = overlapEnd - overlapStart;
        
        if (op1.position < op2.position) {
            transformed.length -= overlapLength;
        } else if (op1.position > op2.position) {
            transformed.position = op2.position;
            transformed.length -= overlapLength;
        } else {
            transformed.length = Math.max(op1.length, op2.length) - overlapLength;
            if (transformed.length <= 0) return null;
        }
        
        return transformed;
    }
    
    operationsOverlap(op1, op2) {
        if (op1.type === OperationType.INSERT && op2.type === OperationType.INSERT) {
            return Math.abs(op1.position - op2.position) < 
                   Math.max(op1.text?.length || 0, op2.text?.length || 0);
        }
        if (op1.type === OperationType.DELETE && op2.type === OperationType.DELETE) {
            const op1End = op1.position + op1.length;
            const op2End = op2.position + op2.length;
            return !(op1End <= op2.position || op2End <= op1.position);
        }
        if (op1.type === OperationType.INSERT && op2.type === OperationType.DELETE) {
            return op1.position >= op2.position && op1.position <= op2.position + op2.length;
        }
        if (op1.type === OperationType.DELETE && op2.type === OperationType.INSERT) {
            return op2.position >= op1.position && op2.position <= op1.position + op1.length;
        }
        return false;
    }
    
    applyToDocument(op) {
        switch (op.type) {
            case OperationType.INSERT:
                this.document = this.document.slice(0, op.position) + 
                               op.text + this.document.slice(op.position);
                break;
            case OperationType.DELETE:
                this.document = this.document.slice(0, op.position) + 
                               this.document.slice(op.position + op.length);
                break;
        }
    }
    
    getDocumentState() { return { content: this.document, revision: this.revision }; }
    getRevision() { return this.revision; }
    registerClient(clientId, revision = 0) {
        this.clients.set(clientId, { revision, pendingOps: [] });
    }
    removeClient(clientId) { this.clients.delete(clientId); }
    getState() {
        return {
            roomId: this.roomId, revision: this.revision,
            documentLength: this.document.length,
            connectedClients: this.clients.size
        };
    }
}

module.exports = OTEngine;
module.exports.Operation = Operation;
module.exports.OperationType = OperationType;

// api-gateway/src/socket/presence-manager.js - 在线状态管理器

const { redisClient } = require('../database/redis');

class PresenceManager {
    constructor(io) {
        this.io = io;
        this.presence = new Map();
        this.heartbeatInterval = null;
        this.startHeartbeatCheck();
    }
    
    updatePresence(roomId, userId, data) {
        if (!this.presence.has(roomId)) this.presence.set(roomId, new Map());
        
        const roomPresence = this.presence.get(roomId);
        const existingData = roomPresence.get(userId) || {};
        
        const presenceData = {
            ...existingData, ...data, lastActivity: Date.now(), isOnline: true
        };
        
        roomPresence.set(userId, presenceData);
        this.syncToRedis(roomId, userId, presenceData);
    }
    
    removePresence(roomId, userId) {
        if (this.presence.has(roomId)) {
            this.presence.get(roomId).delete(userId);
            this.removeFromRedis(roomId, userId);
            this.broadcastPresenceUpdate(roomId);
        }
    }
    
    getRoomPresence(roomId) {
        if (!this.presence.has(roomId)) return [];
        return Array.from(this.presence.get(roomId).values());
    }
    
    getUserPresence(roomId, userId) {
        if (!this.presence.has(roomId)) return null;
        return this.presence.get(roomId).get(userId);
    }
    
    async syncToRedis(roomId, userId, data) {
        const key = `presence:${roomId}:${userId}`;
        await redisClient.setex(key, 300, JSON.stringify(data));
    }
    
    async removeFromRedis(roomId, userId) {
        const key = `presence:${roomId}:${userId}`;
        await redisClient.del(key);
    }
    
    async loadFromRedis(roomId) {
        const pattern = `presence:${roomId}:*`;
        const keys = await redisClient.keys(pattern);
        const presence = new Map();
        
        for (const key of keys) {
            const data = await redisClient.get(key);
            if (data) {
                const userId = key.split(':')[2];
                presence.set(userId, JSON.parse(data));
            }
        }
        
        return presence;
    }
    
    broadcastPresenceUpdate(roomId) {
        if (!this.presence.has(roomId)) {
            this.io.to(roomId).emit('presence-update', []);
            return;
        }
        const users = Array.from(this.presence.get(roomId).values());
        this.io.to(roomId).emit('presence-update', users);
    }
    
    startHeartbeatCheck() {
        this.heartbeatInterval = setInterval(() => {
            const now = Date.now();
            const timeout = 60000;
            
            this.presence.forEach((roomPresence, roomId) => {
                roomPresence.forEach((data, userId) => {
                    if (data.lastActivity && now - data.lastActivity > timeout) {
                        this.handleUserTimeout(roomId, userId);
                    }
                });
            });
        }, 30000);
    }
    
    handleUserTimeout(roomId, userId) {
        this.updatePresence(roomId, userId, { isOnline: false });
        this.io.to(roomId).emit('user-offline', { userId, timestamp: Date.now() });
    }
    
    cleanup() {
        if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
    }
}

module.exports = PresenceManager;

// api-gateway/src/services/ai.service.js - AI服务核心实现
const { pool } = require('../database/postgres');
const { redisClient } = require('../database/redis');
const OpenAI = require('openai');
const { v4: uuidv4 } = require('uuid');
const { AppError } = require('../utils/errors');

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const AICapabilityType = {
    CODE_COMPLETION: 'code_completion',
    CODE_EXPLANATION: 'code_explanation',
    ERROR_DIAGNOSIS: 'error_diagnosis',
    CODE_REFACTOR: 'code_refactor',
    UNIT_TEST: 'unit_test',
    CODE_TRANSLATION: 'code_translation',
    DOC_GENERATION: 'doc_generation',
    CHAT: 'chat'
};

const PROMPT_TEMPLATES = {
    [AICapabilityType.CODE_COMPLETION]: `请根据以下代码上下文，补全代码。直接输出补全的代码，不要包含解释。

文件路径: {{filePath}}
编程语言: {{language}}

代码上下文:
{{context}}

请补全:
{{incompleteCode}}`,
    
    [AICapabilityType.CODE_EXPLANATION]: `请解释以下代码的功能。提供简洁但全面的说明。

文件路径: {{filePath}}
编程语言: {{language}}

代码:
{{code}}`,
    
    [AICapabilityType.ERROR_DIAGNOSIS]: `请诊断以下代码中的错误。提供错误类型、位置和修复建议。

文件路径: {{filePath}}
编程语言: {{language}}
错误信息: {{errorMessage}}

代码:
{{code}}`
};

class AIService {
    constructor() { this.rateLimits = new Map(); }
    
    async generate(params) {
        const { type, prompt, context, projectId, userId } = params;
        await this.checkUserQuota(userId, type);
        
        const fullPrompt = this.buildPrompt(type, { ...context, customPrompt: prompt });
        const projectContext = await this.getProjectContext(projectId, context?.filePath);
        
        const response = await this.callOpenAI({ prompt: fullPrompt, context: projectContext, type });
        await this.recordUsage(userId, projectId, type);
        
        return response;
    }
    
    async *streamGenerate(params) {
        const { type, prompt, context, projectId, userId } = params;
        await this.checkUserQuota(userId, type);
        
        const fullPrompt = this.buildPrompt(type, { ...context, customPrompt: prompt });
        const projectContext = await this.getProjectContext(projectId, context?.filePath);
        
        const stream = await this.callOpenAIStream({ prompt: fullPrompt, context: projectContext, type });
        await this.recordUsage(userId, projectId, type);
        
        for await (const chunk of stream) yield chunk;
    }
    
    buildPrompt(type, context) {
        let template = PROMPT_TEMPLATES[type];
        if (!template) return context.customPrompt || '';
        
        Object.entries(context).forEach(([key, value]) => {
            template = template.replace(new RegExp(`{{${key}}}`, 'g'), value || '');
        });
        
        return template;
    }
    
    async getProjectContext(projectId, filePath) {
        if (!projectId) return '';
        
        const filesResult = await pool.query(
            `SELECT path, name, is_directory FROM project_files 
             WHERE project_id = $1 AND is_directory = false
             ORDER BY updated_at DESC LIMIT 20`,
            [projectId]
        );
        
        let currentFileContent = '';
        if (filePath) {
            const fileResult = await pool.query(
                'SELECT content FROM project_files WHERE project_id = $1 AND path = $2',
                [projectId, filePath]
            );
            if (fileResult.rows.length > 0) currentFileContent = fileResult.rows[0].content;
        }
        
        return { projectFiles: filesResult.rows.map(f => f.path).join('\n'), currentFileContent };
    }
    
    async callOpenAI({ prompt, context, type }) {
        const systemMessage = this.getSystemMessage(type);
        
        const messages = [{ role: 'system', content: systemMessage }];
        
        if (context?.projectFiles) {
            messages.push({ role: 'system', content: `项目文件列表:\n${context.projectFiles}` });
        }
        if (context?.currentFileContent) {
            messages.push({ role: 'system', content: `当前文件内容:\n${context.currentFileContent}` });
        }
        
        messages.push({ role: 'user', content: prompt });
        
        try {
            const completion = await openai.chat.completions.create({
                model: this.getModelForType(type),
                messages,
                temperature: this.getTemperatureForType(type),
                max_tokens: this.getMaxTokensForType(type)
            });
            
            return {
                content: completion.choices[0].message.content,
                usage: completion.usage,
                model: completion.model
            };
        } catch (error) {
            throw new AppError('AI_SERVICE_ERROR', 'AI服务暂时不可用');
        }
    }
    
    async callOpenAIStream({ prompt, context, type }) {
        const systemMessage = this.getSystemMessage(type);
        const messages = [{ role: 'system', content: systemMessage }];
        
        if (context?.projectFiles) messages.push({ role: 'system', content: `项目文件:\n${context.projectFiles}` });
        if (context?.currentFileContent) messages.push({ role: 'system', content: `当前文件:\n${context.currentFileContent}` });
        messages.push({ role: 'user', content: prompt });
        
        return await openai.chat.completions.create({
            model: this.getModelForType(type),
            messages,
            temperature: this.getTemperatureForType(type),
            max_tokens: this.getMaxTokensForType(type),
            stream: true
        });
    }
    
    getSystemMessage(type) {
        const messages = {
            [AICapabilityType.CODE_COMPLETION]: '你是一个专业的代码补全助手。直接输出代码，不要包含解释。',
            [AICapabilityType.CODE_EXPLANATION]: '你是一个耐心的代码解释助手。用简洁清晰的语言解释代码功能。',
            [AICapabilityType.ERROR_DIAGNOSIS]: '你是一个经验丰富的代码调试专家。准确诊断错误并提供修复建议。',
            [AICapabilityType.CHAT]: '你是一个友好的编程助手。'
        };
        return messages[type] || messages[AICapabilityType.CHAT];
    }
    
    getModelForType(type) {
        return type === AICapabilityType.CODE_COMPLETION ? 'gpt-4' : 'gpt-4o';
    }
    
    getTemperatureForType(type) {
        const temps = {
            [AICapabilityType.CODE_COMPLETION]: 0.3,
            [AICapabilityType.CODE_EXPLANATION]: 0.5,
            [AICapabilityType.ERROR_DIAGNOSIS]: 0.2,
            [AICapabilityType.CHAT]: 0.7
        };
        return temps[type] || 0.5;
    }
    
    getMaxTokensForType(type) {
        const tokens = {
            [AICapabilityType.CODE_COMPLETION]: 500,
            [AICapabilityType.CODE_EXPLANATION]: 1000,
            [AICapabilityType.ERROR_DIAGNOSIS]: 800,
            [AICapabilityType.CHAT]: 2000
        };
        return tokens[type] || 1000;
    }
    
    async checkUserQuota(userId, type) {
        const userResult = await pool.query('SELECT plan FROM users WHERE id = $1', [userId]);
        const plan = userResult.rows[0]?.plan || 'free';
        
        const quotas = {
            free: { requests: 100, interval: 3600 },
            pro: { requests: 1000, interval: 3600 },
            enterprise: { requests: Infinity, interval: 0 }
        };
        
        const quota = quotas[plan];
        const key = `ai_quota:${userId}:${type}`;
        const current = await redisClient.get(key);
        
        if (current && parseInt(current) >= quota.requests) {
            throw new AppError('QUOTA_EXCEEDED', `AI请求配额已用尽`);
        }
        
        if (current) await redisClient.incr(key);
        else await redisClient.setex(key, quota.interval, 1);
    }
    
    async recordUsage(userId, projectId, type) {
        const id = uuidv4();
        await pool.query(
            `INSERT INTO ai_usage_records (id, user_id, project_id, capability_type, created_at)
             VALUES ($1, $2, $3, $4, NOW())`,
            [id, userId, projectId, type]
        );
    }
}

module.exports = new AIService();
module.exports.AICapabilityType = AICapabilityType;

// api-gateway/src/services/execution.service.js - 代码执行服务
const { pool } = require('../database/postgres');
const { redisClient } = require('../database/redis');
const Docker = require('dockerode');
const { v4: uuidv4 } = require('uuid');
const { AppError } = require('../utils/errors');

const docker = new Docker({
    socketPath: process.env.DOCKER_SOCKET || '/var/run/docker.sock'
});

const LANGUAGE_IMAGES = {
    javascript: 'node:18-alpine',
    typescript: 'node:18-alpine',
    python: 'python:3.11-slim',
    java: 'openjdk:17-slim',
    go: 'golang:1.21-alpine',
    rust: 'rust:1.72-slim',
    ruby: 'ruby:3.2-slim',
    php: 'php:8.2-cli-alpine',
    cpp: 'gcc:13',
    c: 'gcc:13'
};

const RESOURCE_LIMITS = {
    free: { cpuPeriod: 100000, cpuQuota: 50000, memory: 256*1024*1024, pidsLimit: 64, timeout: 30000 },
    pro: { cpuPeriod: 100000, cpuQuota: 100000, memory: 512*1024*1024, pidsLimit: 128, timeout: 60000 },
    enterprise: { cpuPeriod: 100000, cpuQuota: 200000, memory: 1024*1024*1024, pidsLimit: 256, timeout: 120000 }
};

class ExecutionService {
    constructor() {
        this.containerPool = new Map();
        this.activeExecutions = new Map();
        this.poolSize = 3;
    }
    
    async execute({ projectId, userId, language, code, stdin, timeout }) {
        const executionId = uuidv4();
        const limits = await this.getUserLimits(userId);
        const effectiveTimeout = Math.min(timeout || Infinity, limits.timeout);
        
        const execution = {
            id: executionId, projectId, userId, language,
            status: 'pending', createdAt: Date.now(), timeout: effectiveTimeout
        };
        
        this.activeExecutions.set(executionId, execution);
        this.runExecution(execution, code, stdin).catch(error => {
            this.updateExecutionStatus(executionId, 'error', { error: error.message });
        });
        
        return { executionId, status: 'pending' };
    }
    
    async executeStream({ projectId, userId, language, code, stdin, timeout }) {
        const executionId = uuidv4();
        const limits = await this.getUserLimits(userId);
        const effectiveTimeout = Math.min(timeout || Infinity, limits.timeout);
        
        const execution = {
            id: executionId, projectId, userId, language,
            status: 'running', createdAt: Date.now(), timeout: effectiveTimeout
        };
        
        this.activeExecutions.set(executionId, execution);
        
        const outputStream = new PassThrough();
        this.runExecution(execution, code, stdin, outputStream).catch(error => {
            outputStream.write(`\nError: ${error.message}\n`);
        });
        
        return { executionId, outputStream };
    }
    
    async runExecution(execution, code, stdin, outputStream = null) {
        const { id: executionId, userId, language, timeout } = execution;
        
        const image = LANGUAGE_IMAGES[language];
        if (!image) throw new AppError('UNSUPPORTED_LANGUAGE', `不支持的语言: ${language}`);
        
        const container = await this.getContainer(userId, language, image);
        
        try {
            this.updateExecutionStatus(executionId, 'running');
            await this.writeCodeToContainer(container, language, code);
            
            const result = await this.runCodeInContainer(container, language, stdin, timeout, outputStream);
            
            this.updateExecutionStatus(executionId, 'completed', result);
            await this.releaseContainer(userId, container, language);
            
            return result;
        } catch (error) {
            await this.destroyContainer(container);
            this.updateExecutionStatus(executionId, 'error', { error: error.message });
            throw error;
        }
    }
    
    async getContainer(userId, language, image) {
        const poolKey = `${userId}:${language}`;
        
        if (this.containerPool.has(poolKey)) {
            const pool = this.containerPool.get(poolKey);
            if (pool.length > 0) {
                const container = pool.pop();
                try {
                    const info = await container.inspect();
                    if (info.State.Running) return container;
                } catch (e) {}
            }
        }
        
        return await this.createContainer(image, language);
    }
    
    async createContainer(image, language) {
        const limits = RESOURCE_LIMITS[process.env.USER_PLAN || 'free'];
        
        const container = await docker.createContainer({
            Image: image,
            Cmd: this.getLanguageCommand(language),
            Env: ['NODE_ENV=production'],
            HostConfig: {
                NetworkMode: 'cloudide-network',
                Memory: limits.memory,
                CpuPeriod: limits.cpuPeriod,
                CpuQuota: limits.cpuQuota,
                PidsLimit: limits.pidsLimit,
                ReadonlyRootfs: true,
                Tmpfs: { '/tmp': 'rw,noexec,nosuid,size=64m' },
                AutoRemove: false,
                MemorySwap: limits.memory,
                MemorySwappiness: 0
            },
            WorkingDir: '/workspace',
            Tty: true,
            AttachStdout: true,
            AttachStderr: true,
            AttachStdin: true,
            StdinOnce: false
        });
        
        await container.start();
        return container;
    }
    
    getLanguageCommand(language) {
        const commands = {
            javascript: ['node'], typescript: ['npx', 'ts-node'],
            python: ['python3'], java: ['java', '-Xmx256m'],
            go: ['go', 'run'], rust: ['rustc'], ruby: ['ruby'],
            php: ['php'], cpp: ['sh', '-c', 'g++ -o /tmp/main /tmp/main.cpp && /tmp/main'],
            c: ['sh', '-c', 'gcc -o /tmp/main /tmp/main.c && /tmp/main']
        };
        return commands[language] || ['sh'];
    }
    
    async writeCodeToContainer(container, language, code) {
        const extensions = {
            javascript: 'js', typescript: 'ts', python: 'py', java: 'java',
            go: 'go', rust: 'rs', ruby: 'rb', php: 'php', cpp: 'cpp', c: 'c'
        };
        
        const ext = extensions[language] || 'txt';
        const filename = `/tmp/main.${ext}`;
        const buffer = Buffer.from(code, 'utf8');
        await container.putArchive(buffer, { path: filename });
        return filename;
    }
    
    async runCodeInContainer(container, language, stdin, timeout, outputStream) {
        return new Promise(async (resolve, reject) => {
            const timeoutId = setTimeout(() => {
                reject(new AppError('EXECUTION_TIMEOUT', `执行超时（${timeout}ms）`));
            }, timeout);
            
            try {
                const stream = await container.attach({
                    stream: true, stdout: true, stderr: true, stdin: true
                });
                
                let stdout = '', stderr = '';
                
                stream.on('data', (chunk) => {
                    const output = chunk.toString();
                    stdout += output;
                    if (outputStream) outputStream.write(output);
                });
                
                stream.on('end', () => {
                    clearTimeout(timeoutId);
                    resolve({ stdout, stderr, exitCode: 0 });
                });
                
                stream.on('error', (error) => {
                    clearTimeout(timeoutId);
                    reject(error);
                });
                
                if (stdin && typeof stdin === 'string') {
                    container.modem.demuxStream(stdin, stream, stream);
                }
            } catch (error) {
                clearTimeout(timeoutId);
                reject(error);
            }
        });
    }
    
    async releaseContainer(userId, container, language) {
        const poolKey = `${userId}:${language}`;
        
        if (!this.containerPool.has(poolKey)) this.containerPool.set(poolKey, []);
        const pool = this.containerPool.get(poolKey);
        
        if (pool.length < this.poolSize) {
            try { await container.kill('SIGKILL'); await container.remove(); } catch (e) {}
            const newContainer = await this.createContainer(LANGUAGE_IMAGES[language], language);
            pool.push(newContainer);
        } else {
            await this.destroyContainer(container);
        }
    }
    
    async destroyContainer(container) {
        try { await container.kill('SIGKILL'); } catch (e) {}
        try { await container.remove({ force: true }); } catch (e) {}
    }
    
    async getUserLimits(userId) {
        const result = await pool.query('SELECT plan FROM users WHERE id = $1', [userId]);
        const plan = result.rows[0]?.plan || 'free';
        return RESOURCE_LIMITS[plan] || RESOURCE_LIMITS.free;
    }
    
    async updateExecutionStatus(executionId, status, result = {}) {
        const execution = this.activeExecutions.get(executionId);
        if (!execution) return;
        
        execution.status = status;
        execution.completedAt = Date.now();
        execution.result = result;
        
        await redisClient.setex(`execution:${executionId}`, 3600, JSON.stringify(execution));
        
        await pool.query(
            `INSERT INTO code_executions (id, project_id, user_id, language, status, result, created_at, completed_at)
             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
             ON CONFLICT (id) DO UPDATE SET status = $5, result = $6, completed_at = $8`,
            [executionId, execution.projectId, execution.userId, execution.language,
             status, JSON.stringify(result), new Date(execution.createdAt),
             status === 'completed' || status === 'error' ? new Date() : null]
        );
    }
    
    async getExecutionStatus(executionId) {
        const cached = await redisClient.get(`execution:${executionId}`);
        if (cached) return JSON.parse(cached);
        
        const result = await pool.query('SELECT * FROM code_executions WHERE id = $1', [executionId]);
        return result.rows[0] || null;
    }
}

module.exports = new ExecutionService();

// api-gateway/src/config/languages.config.js - 语言配置

const LANGUAGES = {
    javascript: {
        id: 'javascript', name: 'JavaScript',
        extensions: ['.js', '.mjs', '.cjs'],
        mimeTypes: ['text/javascript'],
        editorConfig: { tabSize: 4, insertSpaces: true, wordWrap: 'off' },
        linter: 'eslint', formatter: 'prettier',
        runtime: 'node', executionImage: 'node:18-alpine',
        defaultCode: `// JavaScript\nconsole.log("Hello, World!");`,
        languageServer: 'vscode-javascript'
    },
    python: {
        id: 'python', name: 'Python',
        extensions: ['.py', '.pyw', '.pyi'],
        mimeTypes: ['text/x-python'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'pylint', formatter: 'black',
        runtime: 'python', executionImage: 'python:3.11-slim',
        defaultCode: `# Python\nprint("Hello, World!")`,
        languageServer: 'pylance'
    },
    typescript: {
        id: 'typescript', name: 'TypeScript',
        extensions: ['.ts', '.tsx', '.mts', '.cts'],
        mimeTypes: ['text/typescript'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'eslint', formatter: 'prettier',
        runtime: 'node', executionImage: 'node:18-alpine',
        defaultCode: `// TypeScript\nconst greet = (name: string): string => \`Hello, \${name}!\`;\nconsole.log(greet("World"));`,
        languageServer: 'vscode-typescript'
    },
    java: {
        id: 'java', name: 'Java',
        extensions: ['.java'],
        mimeTypes: ['text/x-java'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        formatter: 'google-java-format',
        runtime: 'java', executionImage: 'openjdk:17-slim',
        defaultCode: `public class Main {\n    public static void main(String[] args) {\n        System.out.println("Hello, World!");\n    }\n}`,
        languageServer: 'eclipse.jdt.ls'
    },
    go: {
        id: 'go', name: 'Go',
        extensions: ['.go'],
        mimeTypes: ['text/x-go'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'golangci-lint', formatter: 'gofmt',
        runtime: 'go', executionImage: 'golang:1.21-alpine',
        defaultCode: `package main\nimport "fmt"\nfunc main() {\n    fmt.Println("Hello, World!")\n}`,
        languageServer: 'gopls'
    },
    rust: {
        id: 'rust', name: 'Rust',
        extensions: ['.rs'],
        mimeTypes: ['text/x-rust'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'clippy', formatter: 'rustfmt',
        executionImage: 'rust:1.72-slim',
        defaultCode: `fn main() {\n    println!("Hello, World!");\n}`,
        languageServer: 'rust-analyzer'
    },
    cpp: {
        id: 'cpp', name: 'C++',
        extensions: ['.cpp', '.cc', '.cxx', '.hpp'],
        mimeTypes: ['text/x-c++src'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'clang-tidy', formatter: 'clang-format',
        executionImage: 'gcc:13',
        defaultCode: `#include <iostream>\nint main() {\n    std::cout << "Hello, World!" << std::endl;\n    return 0;\n}`,
        languageServer: 'clangd'
    },
    html: {
        id: 'html', name: 'HTML',
        extensions: ['.html', '.htm'],
        mimeTypes: ['text/html'],
        editorConfig: { tabSize: 2, insertSpaces: true },
        formatter: 'prettier',
        executionImage: null,
        defaultCode: `<!DOCTYPE html>\n<html>\n<head><title>Hello</title></head>\n<body>\n    <h1>Hello, World!</h1>\n</body>\n</html>`,
        languageServer: 'vscode-html'
    },
    css: {
        id: 'css', name: 'CSS',
        extensions: ['.css'],
        mimeTypes: ['text/css'],
        editorConfig: { tabSize: 2, insertSpaces: true },
        linter: 'stylelint', formatter: 'prettier',
        executionImage: null,
        defaultCode: `body { font-family: Arial; margin: 0; }\nh1 { color: #333; }`,
        languageServer: 'vscode-css'
    },
    json: {
        id: 'json', name: 'JSON',
        extensions: ['.json', '.jsonc'],
        mimeTypes: ['application/json'],
        editorConfig: { tabSize: 2, insertSpaces: true },
        formatter: 'prettier',
        executionImage: null,
        defaultCode: `{\n    "name": "project",\n    "version": "1.0.0"\n}`,
        languageServer: 'vscode-json'
    },
    sql: {
        id: 'sql', name: 'SQL',
        extensions: ['.sql'],
        mimeTypes: ['text/x-sql'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        formatter: 'prettier',
        executionImage: null,
        defaultCode: `SELECT * FROM users WHERE active = true;`,
        languageServer: 'mssql'
    },
    shell: {
        id: 'shell', name: 'Shell',
        extensions: ['.sh', '.bash'],
        mimeTypes: ['text/x-shellscript'],
        editorConfig: { tabSize: 4, insertSpaces: true },
        linter: 'shellcheck',
        runtime: 'bash', executionImage: 'bash:5.2',
        defaultCode: `#!/bin/bash\necho "Hello, World!"`,
        languageServer: null
    }
};

function getLanguageByExtension(extension) {
    for (const [id, config] of Object.entries(LANGUAGES)) {
        if (config.extensions.includes(extension.toLowerCase())) {
            return { id, ...config };
        }
    }
    return null;
}

function getLanguageByFilename(filename) {
    const ext = '.' + filename.split('.').pop();
    return getLanguageByExtension(ext);
}

function getSupportedLanguages() {
    return Object.entries(LANGUAGES).map(([id, config]) => ({
        id, name: config.name, extensions: config.extensions,
        hasExecution: config.executionImage !== null
    }));
}

async function detectLanguageFromContent(content) {
    const patterns = [
        { pattern: /^<!DOCTYPE html>/i, language: 'html' },
        { pattern: /^<html/i, language: 'html' },
        { pattern: /^{\s*"[\w]+":/i, language: 'json' },
        { pattern: /^import\s+[\w]+\s+from\s+['"][^'"]+['"]/i, language: 'javascript' },
        { pattern: /^from\s+[\w]+\s+import\s+/i, language: 'python' },
        { pattern: /^package\s+[\w.]+;/i, language: 'java' },
        { pattern: /^package\s+main/i, language: 'go' },
        { pattern: /^fn\s+\w+\s*\(/i, language: 'rust' },
        { pattern: /^#include\s*</i, language: 'cpp' },
        { pattern: /^SELECT\s+/i, language: 'sql' }
    ];
    
    for (const { pattern, language } of patterns) {
        if (pattern.test(content)) return language;
    }
    return 'plaintext';
}

module.exports = {
    LANGUAGES, getLanguageByExtension, getLanguageByFilename,
    getSupportedLanguages, detectLanguageFromContent
};

-- 用户表
CREATE TABLE users (
    id UUID PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    username VARCHAR(50) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    plan VARCHAR(20) DEFAULT 'free',
    is_verified BOOLEAN DEFAULT false,
    is_locked BOOLEAN DEFAULT false,
    avatar_url TEXT,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW(),
    last_login_at TIMESTAMP
);

-- 项目表
CREATE TABLE projects (
    id UUID PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    description TEXT,
    owner_id UUID REFERENCES users(id),
    template_id UUID,
    visibility VARCHAR(20) DEFAULT 'private',
    git_url TEXT,
    default_branch VARCHAR(50) DEFAULT 'main',
    devfile JSONB,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

-- 项目文件表
CREATE TABLE project_files (
    id UUID PRIMARY KEY,
    project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
    path TEXT NOT NULL,
    name VARCHAR(255) NOT NULL,
    content TEXT,
    storage_path TEXT,
    is_directory BOOLEAN DEFAULT false,
    mime_type VARCHAR(100),
    size BIGINT DEFAULT 0,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW(),
    UNIQUE(project_id, path)
);

-- 项目成员表
CREATE TABLE project_members (
    project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    role VARCHAR(50) DEFAULT 'developer',
    joined_at TIMESTAMP DEFAULT NOW(),
    PRIMARY KEY (project_id, user_id)
);

-- 代码执行记录表
CREATE TABLE code_executions (
    id UUID PRIMARY KEY,
    project_id UUID REFERENCES projects(id),
    user_id UUID REFERENCES users(id),
    language VARCHAR(50) NOT NULL,
    status VARCHAR(20) NOT NULL,
    result JSONB,
    created_at TIMESTAMP DEFAULT NOW(),
    completed_at TIMESTAMP
);

-- AI使用记录表
CREATE TABLE ai_usage_records (
    id UUID PRIMARY KEY,
    user_id UUID REFERENCES users(id),
    project_id UUID REFERENCES projects(id),
    capability_type VARCHAR(50) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

-- 索引
CREATE INDEX idx_project_files_project_id ON project_files(project_id);
CREATE INDEX idx_project_files_path ON project_files(project_id, path);
CREATE INDEX idx_code_executions_user_id ON code_executions(user_id);
CREATE INDEX idx_ai_usage_user_id ON ai_usage_records(user_id);

# .env.example
NODE_ENV=production
PORT=8080

# 数据库
DATABASE_URL=postgresql://user:password@localhost:5432/cloudide

# Redis
REDIS_URL=redis://localhost:6379

# JWT
JWT_SECRET=your-super-secret-jwt-key
JWT_REFRESH_SECRET=your-refresh-secret-key

# Docker
DOCKER_SOCKET=/var/run/docker.sock

# OpenAI
OPENAI_API_KEY=sk-your-api-key

# 对象存储
S3_ENDPOINT=https://s3.amazonaws.com
S3_BUCKET=cloudide-files
AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key

# 允许的源
ALLOWED_ORIGINS=https://cloudide.example.com,http://localhost:3000

// package.json (frontend)
{
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.20.0",
    "monaco-editor": "^0.45.0",
    "socket.io-client": "^4.7.2",
    "@tanstack/react-query": "^5.8.0",
    "zustand": "^4.4.6",
    "axios": "^1.6.2",
    "prismjs": "^1.29.0",
    "katex": "^0.16.9"
  },
  "devDependencies": {
    "@types/react": "^18.2.0",
    "typescript": "^5.3.0",
    "vite": "^5.0.0",
    "@vitejs/plugin-react": "^4.2.0"
  }
}

// package.json (backend)
{
  "dependencies": {
    "express": "^4.18.2",
    "socket.io": "^4.7.2",
    "pg": "^8.11.3",
    "redis": "^4.6.10",
    "jsonwebtoken": "^9.0.2",
    "bcryptjs": "^2.4.3",
    "helmet": "^7.1.0",
    "cors": "^2.8.5",
    "express-rate-limit": "^7.1.5",
    "dockerode": "^4.0.0",
    "openai": "^4.20.0",
    "uuid": "^9.0.1",
    "multer": "^1.4.5-lts.1",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.2",
    "jest": "^29.7.0"
  }
}