Upload 11 files

backend/package.json

@@ -20,7 +20,8 @@
     "dotenv": "^16.4.5",
     "express-rate-limit": "^7.4.1",
     "uuid": "^10.0.0",
-    "puppeteer": "^21.0.0"
+    "puppeteer": "^21.0.0",
+    "playwright": "^1.40.0"
   },
   "devDependencies": {
     "nodemon": "^3.1.7"

backend/src/app.js

@@ -5,18 +5,29 @@ import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import axios from 'axios';
+import fs from 'fs'; // 添加ES模块fs导入
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 首先加载环境变量 - 必须在导入服务之前
+dotenv.config({ path: path.join(__dirname, '../../.env') });
+
+// 验证环境变量是否正确加载
+console.log('=== Environment Variables Check ===');
+console.log('GITHUB_TOKEN configured:', !!process.env.GITHUB_TOKEN);
+console.log('GITHUB_TOKEN length:', process.env.GITHUB_TOKEN ? process.env.GITHUB_TOKEN.length : 0);
+console.log('GITHUB_REPOS configured:', !!process.env.GITHUB_REPOS);
+console.log('GITHUB_REPOS value:', process.env.GITHUB_REPOS);
+
+// 现在导入需要环境变量的模块
 import authRoutes from './routes/auth.js';
 import pptRoutes from './routes/ppt.js';
 import publicRoutes from './routes/public.js';
 import { authenticateToken } from './middleware/auth.js';
 import { errorHandler } from './middleware/errorHandler.js';
 
-dotenv.config();
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
 const app = express();
 const PORT = process.env.PORT || 7860; // 修改为7860端口
 
@@ -28,12 +39,17 @@ app.use(helmet({
   contentSecurityPolicy: false, // 为了兼容前端静态文件
 }));
 
-// 限流中间件
+// 修复限流配置 - 针对Huggingface Space环境
 const limiter = rateLimit({
   windowMs: 15 * 60 * 1000, // 15分钟
   max: 100, // 每个IP每15分钟最多100个请求
-  message: 'Too many requests from this IP, please try again later.'
+  message: 'Too many requests from this IP, please try again later.',
+  trustProxy: false, // 在本地测试环境设为false
+  standardHeaders: true,
+  legacyHeaders: false
 });
+
+// 应用限流中间件
 app.use('/api', limiter);
 
 // CORS配置
@@ -45,8 +61,10 @@ app.use(cors({
 app.use(express.json({ limit: '50mb' }));
 app.use(express.urlencoded({ extended: true, limit: '50mb' }));
 
-// 提供前端静态文件
-app.use(express.static(path.join(__dirname, '../../frontend/dist')));
+// 提供前端静态文件 - 修复路径配置
+const frontendDistPath = path.join(__dirname, '../../frontend/dist');
+console.log('Frontend dist path:', frontendDistPath);
+app.use(express.static(frontendDistPath));
 
 // 提供数据文件
 app.use('/data', express.static(path.join(__dirname, '../../frontend/public/mocks')));
@@ -465,6 +483,129 @@ app.get('/api/github/test', async (req, res) => {
   }
 });
 
+// 添加GitHub调试路由
+app.get('/api/debug/github', async (req, res) => {
+  try {
+    console.log('=== GitHub Debug Information ===');
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    
+    const debugInfo = {
+      timestamp: new Date().toISOString(),
+      environment: {
+        tokenConfigured: !!process.env.GITHUB_TOKEN,
+        tokenLength: process.env.GITHUB_TOKEN ? process.env.GITHUB_TOKEN.length : 0,
+        reposConfigured: !!process.env.GITHUB_REPOS,
+        reposList: process.env.GITHUB_REPOS ? process.env.GITHUB_REPOS.split(',') : [],
+        nodeEnv: process.env.NODE_ENV
+      },
+      service: {
+        hasToken: !!githubService.token,
+        repositoriesCount: githubService.repositories?.length || 0,
+        repositories: githubService.repositories || [],
+        apiUrl: githubService.apiUrl
+      }
+    };
+    
+    // 测试连接
+    try {
+      const connectionTest = await githubService.validateConnection();
+      debugInfo.connectionTest = connectionTest;
+    } catch (connError) {
+      debugInfo.connectionError = connError.message;
+    }
+    
+    console.log('Debug info:', debugInfo);
+    res.json(debugInfo);
+    
+  } catch (error) {
+    console.error('Debug route error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+    });
+  }
+});
+
+// 添加PPT调试路由
+app.get('/api/debug/ppt/:userId', async (req, res) => {
+  try {
+    const { userId } = req.params;
+    console.log(`=== PPT Debug for User: ${userId} ===`);
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    
+    const debugInfo = {
+      timestamp: new Date().toISOString(),
+      userId: userId,
+      repositories: []
+    };
+    
+    // 检查每个仓库中用户的文件
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      const repoInfo = {
+        index: i,
+        url: githubService.repositories[i],
+        accessible: false,
+        userDirectoryExists: false,
+        files: []
+      };
+      
+      try {
+        const { owner, repo } = githubService.parseRepoUrl(githubService.repositories[i]);
+        
+        // 检查仓库是否可访问
+        await axios.get(`https://api.github.com/repos/${owner}/${repo}`, {
+          headers: {
+            'Authorization': `token ${githubService.token}`,
+            'Accept': 'application/vnd.github.v3+json'
+          }
+        });
+        repoInfo.accessible = true;
+        
+        // 检查用户目录
+        try {
+          const userDirResponse = await axios.get(
+            `https://api.github.com/repos/${owner}/${repo}/contents/users/${userId}`,
+            {
+              headers: {
+                'Authorization': `token ${githubService.token}`,
+                'Accept': 'application/vnd.github.v3+json'
+              }
+            }
+          );
+          
+          repoInfo.userDirectoryExists = true;
+          repoInfo.files = userDirResponse.data
+            .filter(item => item.type === 'file' && item.name.endsWith('.json'))
+            .map(file => ({
+              name: file.name,
+              size: file.size,
+              sha: file.sha
+            }));
+        } catch (userDirError) {
+          repoInfo.userDirectoryError = userDirError.response?.status === 404 ? 'Directory not found' : userDirError.message;
+        }
+        
+      } catch (repoError) {
+        repoInfo.error = repoError.message;
+      }
+      
+      debugInfo.repositories.push(repoInfo);
+    }
+    
+    console.log('PPT Debug info:', debugInfo);
+    res.json(debugInfo);
+    
+  } catch (error) {
+    console.error('PPT Debug route error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+    });
+  }
+});
+
 // 添加仓库初始化端点
 app.post('/api/github/initialize', async (req, res) => {
   try {
@@ -508,6 +649,467 @@ app.post('/api/github/initialize', async (req, res) => {
   }
 });
 
+// 添加GitHub权限详细检查路由
+app.get('/api/debug/github-permissions', async (req, res) => {
+  try {
+    console.log('=== GitHub Token Permissions Check ===');
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    
+    if (!githubService.token) {
+      return res.status(400).json({ error: 'No GitHub token configured' });
+    }
+    
+    const debugInfo = {
+      timestamp: new Date().toISOString(),
+      tokenInfo: {},
+      repositoryTests: []
+    };
+    
+    // 1. 检查token基本信息和权限
+    try {
+      const userResponse = await axios.get('https://api.github.com/user', {
+        headers: {
+          'Authorization': `token ${githubService.token}`,
+          'Accept': 'application/vnd.github.v3+json'
+        }
+      });
+      
+      debugInfo.tokenInfo = {
+        login: userResponse.data.login,
+        id: userResponse.data.id,
+        type: userResponse.data.type,
+        company: userResponse.data.company,
+        publicRepos: userResponse.data.public_repos,
+        privateRepos: userResponse.data.total_private_repos,
+        tokenScopes: userResponse.headers['x-oauth-scopes'] || 'Unknown'
+      };
+      
+      console.log('Token info:', debugInfo.tokenInfo);
+      
+    } catch (tokenError) {
+      debugInfo.tokenError = {
+        status: tokenError.response?.status,
+        message: tokenError.message
+      };
+    }
+    
+    // 2. 检查每个仓库的详细状态
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      const repoUrl = githubService.repositories[i];
+      const repoTest = {
+        index: i,
+        url: repoUrl,
+        tests: {}
+      };
+      
+      try {
+        const { owner, repo } = githubService.parseRepoUrl(repoUrl);
+        repoTest.owner = owner;
+        repoTest.repo = repo;
+        
+        // 测试1: 基本仓库访问
+        try {
+          const repoResponse = await axios.get(`https://api.github.com/repos/${owner}/${repo}`, {
+            headers: {
+              'Authorization': `token ${githubService.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            }
+          });
+          
+          repoTest.tests.basicAccess = {
+            success: true,
+            repoExists: true,
+            private: repoResponse.data.private,
+            permissions: repoResponse.data.permissions,
+            defaultBranch: repoResponse.data.default_branch,
+            size: repoResponse.data.size
+          };
+          
+        } catch (repoError) {
+          repoTest.tests.basicAccess = {
+            success: false,
+            status: repoError.response?.status,
+            message: repoError.message,
+            details: repoError.response?.data
+          };
+          
+          // 如果是404，检查是否是权限问题还是仓库不存在
+          if (repoError.response?.status === 404) {
+            // 尝试不使用认证访问（如果是公开仓库应该能访问）
+            try {
+              await axios.get(`https://api.github.com/repos/${owner}/${repo}`);
+              repoTest.tests.basicAccess.possibleCause = 'Repository exists but token lacks permission';
+            } catch (publicError) {
+              if (publicError.response?.status === 404) {
+                repoTest.tests.basicAccess.possibleCause = 'Repository does not exist';
+              }
+            }
+          }
+        }
+        
+        // 测试2: 检查是否能列出用户的仓库
+        try {
+          const userReposResponse = await axios.get(`https://api.github.com/users/${owner}/repos?per_page=100`, {
+            headers: {
+              'Authorization': `token ${githubService.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            }
+          });
+          
+          const hasRepo = userReposResponse.data.some(r => r.name === repo);
+          repoTest.tests.userReposList = {
+            success: true,
+            totalRepos: userReposResponse.data.length,
+            targetRepoFound: hasRepo,
+            repoNames: userReposResponse.data.slice(0, 10).map(r => ({ name: r.name, private: r.private }))
+          };
+          
+        } catch (userReposError) {
+          repoTest.tests.userReposList = {
+            success: false,
+            status: userReposError.response?.status,
+            message: userReposError.message
+          };
+        }
+        
+      } catch (parseError) {
+        repoTest.parseError = parseError.message;
+      }
+      
+      debugInfo.repositoryTests.push(repoTest);
+    }
+    
+    // 3. 提供修复建议
+    const suggestions = [];
+    
+    if (debugInfo.tokenError) {
+      suggestions.push('Token authentication failed - check if GITHUB_TOKEN is valid');
+    }
+    
+    debugInfo.repositoryTests.forEach((repoTest, index) => {
+      if (!repoTest.tests.basicAccess?.success) {
+        if (repoTest.tests.basicAccess?.status === 404) {
+          if (repoTest.tests.basicAccess?.possibleCause === 'Repository does not exist') {
+            suggestions.push(`Repository ${repoTest.url} does not exist - please create it on GitHub`);
+          } else {
+            suggestions.push(`Repository ${repoTest.url} exists but token lacks permission - check token scopes`);
+          }
+        } else if (repoTest.tests.basicAccess?.status === 403) {
+          suggestions.push(`Permission denied for ${repoTest.url} - check if token has 'repo' scope`);
+        }
+      }
+    });
+    
+    debugInfo.suggestions = suggestions;
+    
+    console.log('GitHub permissions debug completed');
+    res.json(debugInfo);
+    
+  } catch (error) {
+    console.error('GitHub permissions check error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+    });
+  }
+});
+
+// 添加大文件处理调试端点
+app.get('/api/debug/large-files/:userId', async (req, res) => {
+  try {
+    const { userId } = req.params;
+    console.log(`=== Large Files Debug for User: ${userId} ===`);
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    
+    const debugInfo = {
+      timestamp: new Date().toISOString(),
+      userId: userId,
+      fileAnalysis: []
+    };
+    
+    // 检查用户的所有PPT文件
+    const pptList = await githubService.getUserPPTList(userId);
+    
+    for (const ppt of pptList) {
+      const fileInfo = {
+        pptId: ppt.name,
+        title: ppt.title,
+        fileName: `${ppt.name}.json`,
+        analysis: {}
+      };
+      
+      try {
+        // 获取文件内容
+        const result = await githubService.getFile(userId, `${ppt.name}.json`, ppt.repoIndex || 0);
+        
+        if (result && result.content) {
+          const content = result.content;
+          const jsonString = JSON.stringify(content);
+          const fileSize = Buffer.byteLength(jsonString, 'utf8');
+          
+          fileInfo.analysis = {
+            fileSize: fileSize,
+            fileSizeKB: (fileSize / 1024).toFixed(2),
+            slidesCount: content.slides?.length || 0,
+            isChunked: !!content.isChunked,
+            chunkedInfo: content.isChunked ? {
+              totalChunks: content.totalChunks,
+              totalSlides: content.totalSlides
+            } : null,
+            wasReassembled: !!result.isReassembled,
+            metadata: content.metadata || 'No metadata',
+            status: fileSize > 1024 * 1024 ? 'LARGE' : fileSize > 800 * 1024 ? 'MEDIUM' : 'NORMAL'
+          };
+          
+          // 分析每个slide的大小
+          if (content.slides && content.slides.length > 0) {
+            const slideSizes = content.slides.map((slide, index) => {
+              const slideJson = JSON.stringify(slide);
+              const slideSize = Buffer.byteLength(slideJson, 'utf8');
+              return {
+                index: index,
+                size: slideSize,
+                sizeKB: (slideSize / 1024).toFixed(2),
+                elementsCount: slide.elements?.length || 0
+              };
+            });
+            
+            // 找出最大的slides
+            const largestSlides = slideSizes
+              .sort((a, b) => b.size - a.size)
+              .slice(0, 3);
+            
+            fileInfo.analysis.slideSummary = {
+              averageSlideSize: (fileSize / content.slides.length).toFixed(0),
+              largestSlides: largestSlides
+            };
+          }
+        } else {
+          fileInfo.analysis = { error: 'Could not read file content' };
+        }
+        
+      } catch (error) {
+        fileInfo.analysis = { 
+          error: error.message,
+          errorType: error.name
+        };
+      }
+      
+      debugInfo.fileAnalysis.push(fileInfo);
+    }
+    
+    // 添加统计摘要
+    debugInfo.summary = {
+      totalFiles: debugInfo.fileAnalysis.length,
+      largeFiles: debugInfo.fileAnalysis.filter(f => f.analysis.status === 'LARGE').length,
+      chunkedFiles: debugInfo.fileAnalysis.filter(f => f.analysis.isChunked).length,
+      errors: debugInfo.fileAnalysis.filter(f => f.analysis.error).length
+    };
+    
+    console.log('Large files debug completed');
+    res.json(debugInfo);
+    
+  } catch (error) {
+    console.error('Large files debug error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+    });
+  }
+});
+
+// 添加分块文件修复端点
+app.post('/api/debug/fix-chunked-file/:userId/:pptId', async (req, res) => {
+  try {
+    const { userId, pptId } = req.params;
+    console.log(`=== Fixing Chunked File: ${userId}/${pptId} ===`);
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    const fileName = `${pptId}.json`;
+    
+    const result = {
+      timestamp: new Date().toISOString(),
+      userId,
+      pptId,
+      fileName,
+      status: 'unknown',
+      details: {},
+      actions: []
+    };
+    
+    // 1. 检查主文件是否存在
+    let mainFile = null;
+    let mainFileRepo = -1;
+    
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      try {
+        const fileResult = await githubService.getFile(userId, fileName, i);
+        if (fileResult) {
+          mainFile = fileResult;
+          mainFileRepo = i;
+          result.details.mainFileFound = true;
+          result.details.mainFileRepo = i;
+          result.actions.push(`Main file found in repository ${i}`);
+          break;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    
+    if (!mainFile) {
+      result.status = 'error';
+      result.details.error = 'Main file not found in any repository';
+      return res.json(result);
+    }
+    
+    const content = mainFile.content;
+    
+    // 2. 检查是否是分块文件
+    if (!content.isChunked) {
+      result.status = 'normal';
+      result.details.isChunked = false;
+      result.details.slideCount = content.slides?.length || 0;
+      result.actions.push('File is not chunked, no action needed');
+      return res.json(result);
+    }
+    
+    // 3. 分析分块文件状态
+    result.details.isChunked = true;
+    result.details.totalChunks = content.totalChunks;
+    result.details.totalSlides = content.totalSlides;
+    result.details.mainFileSlides = content.slides?.length || 0;
+    
+    // 4. 检查所有chunk文件
+    const chunkStatus = [];
+    let totalFoundSlides = content.slides?.length || 0;
+    
+    for (let i = 1; i < content.totalChunks; i++) {
+      const chunkFileName = fileName.replace('.json', `_chunk_${i}.json`);
+      const chunkInfo = {
+        index: i,
+        fileName: chunkFileName,
+        found: false,
+        slides: 0,
+        error: null
+      };
+      
+      try {
+        const repoUrl = githubService.repositories[mainFileRepo];
+        const { owner, repo } = githubService.parseRepoUrl(repoUrl);
+        const path = `users/${userId}/${chunkFileName}`;
+
+        const response = await axios.get(
+          `${githubService.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
+          {
+            headers: {
+              'Authorization': `token ${githubService.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
+          }
+        );
+
+        const chunkContent = Buffer.from(response.data.content, 'base64').toString('utf8');
+        const chunkData = JSON.parse(chunkContent);
+        
+        chunkInfo.found = true;
+        chunkInfo.slides = chunkData.slides?.length || 0;
+        totalFoundSlides += chunkInfo.slides;
+        
+        result.actions.push(`Chunk ${i} found: ${chunkInfo.slides} slides`);
+      } catch (error) {
+        chunkInfo.error = error.message;
+        result.actions.push(`Chunk ${i} missing or error: ${error.message}`);
+      }
+      
+      chunkStatus.push(chunkInfo);
+    }
+    
+    result.details.chunks = chunkStatus;
+    result.details.totalFoundSlides = totalFoundSlides;
+    result.details.missingSlides = content.totalSlides - totalFoundSlides;
+    
+    // 5. 判断状态和建议修复方案
+    const missingChunks = chunkStatus.filter(chunk => !chunk.found);
+    
+    if (missingChunks.length === 0 && totalFoundSlides === content.totalSlides) {
+      result.status = 'healthy';
+      result.actions.push('All chunks found, file should load correctly');
+    } else if (missingChunks.length > 0) {
+      result.status = 'incomplete';
+      result.details.missingChunks = missingChunks.map(c => c.index);
+      result.actions.push(`Missing chunks: ${missingChunks.map(c => c.index).join(', ')}`);
+      
+      // 提供修复建议
+      if (totalFoundSlides >= content.totalSlides * 0.8) {
+        result.actions.push('Recommendation: Reassemble available slides into single file');
+        result.details.recommendation = 'reassemble';
+      } else {
+        result.actions.push('Recommendation: File may be corrupted, consider restoration from backup');
+        result.details.recommendation = 'restore';
+      }
+    } else {
+      result.status = 'mismatch';
+      result.actions.push('Slide count mismatch detected');
+    }
+    
+    console.log('Chunked file analysis completed:', result);
+    res.json(result);
+    
+  } catch (error) {
+    console.error('Chunked file fix error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+    });
+  }
+});
+
+// 添加分块文件重组端点
+app.post('/api/debug/reassemble-chunked-file/:userId/:pptId', async (req, res) => {
+  try {
+    const { userId, pptId } = req.params;
+    console.log(`=== Reassembling Chunked File: ${userId}/${pptId} ===`);
+    
+    const { default: githubService } = await import('./services/githubService.js');
+    const fileName = `${pptId}.json`;
+    
+    // 强制重新组装文件
+    const result = await githubService.getFile(userId, fileName, 0);
+    
+    if (!result) {
+      return res.status(404).json({ error: 'File not found' });
+    }
+    
+    if (result.isReassembled) {
+      res.json({
+        success: true,
+        message: 'File reassembled successfully',
+        slideCount: result.content.slides?.length || 0,
+        wasChunked: !!result.content.reassembledInfo,
+        reassembledInfo: result.content.reassembledInfo
+      });
+    } else {
+      res.json({
+        success: true,
+        message: 'File was not chunked',
+        slideCount: result.content.slides?.length || 0,
+        wasChunked: false
+      });
+    }
+    
+  } catch (error) {
+    console.error('File reassembly error:', error);
+    res.status(500).json({ 
+      error: error.message,
+      details: error.stack
+    });
+  }
+});
+
 // 添加路由注册日志
 console.log('Importing route modules...');
 console.log('Auth routes imported:', !!authRoutes);
@@ -539,9 +1141,23 @@ app.use('/api/*', (req, res) => {
   res.status(404).json({ error: 'API route not found', path: req.path });
 });
 
-// 前端路由处理 - 必须在API路由之后
+// 前端路由处理 - 修复ES模块兼容性
 app.get('*', (req, res) => {
-  res.sendFile(path.join(__dirname, '../../frontend/dist/index.html'));
+  const indexPath = path.join(frontendDistPath, 'index.html');
+  console.log(`Serving frontend route: ${req.path}, index.html path: ${indexPath}`);
+  
+  // 使用ES模块的fs检查文件是否存在
+  if (fs.existsSync(indexPath)) {
+    res.sendFile(indexPath);
+  } else {
+    console.error('index.html not found at:', indexPath);
+    res.status(404).send(`
+      <h1>前端文件未找到</h1>
+      <p>index.html路径: ${indexPath}</p>
+      <p>请确保前端已正确构建</p>
+      <a href="/test">访问API测试页面</a>
+    `);
+  }
 });
 
 // 错误处理中间件

backend/src/middleware/errorHandler.js

@@ -16,20 +16,86 @@ export const errorHandler = (err, req, res, next) => {
     const message = err.response.data?.message || 'GitHub API error';
     
     if (status === 401) {
-      return res.status(500).json({ error: 'GitHub authentication failed' });
+      return res.status(500).json({ 
+        error: 'GitHub authentication failed',
+        details: 'GitHub token may be invalid or expired',
+        suggestion: 'Check GitHub token configuration'
+      });
+    }
+    
+    if (status === 403) {
+      return res.status(500).json({ 
+        error: 'GitHub access forbidden',
+        details: 'Insufficient permissions or rate limit exceeded',
+        suggestion: 'Check repository permissions or wait for rate limit reset'
+      });
     }
     
     if (status === 404) {
-      return res.status(404).json({ error: 'Resource not found in GitHub' });
+      return res.status(404).json({ 
+        error: 'Resource not found in GitHub',
+        details: message,
+        suggestion: 'Check if the repository or file exists'
+      });
+    }
+
+    if (status === 422) {
+      return res.status(413).json({ 
+        error: 'File too large for GitHub',
+        details: message,
+        suggestion: 'Try reducing file size or splitting into smaller files'
+      });
     }
     
-    return res.status(500).json({ error: `GitHub API error: ${message}` });
+    return res.status(500).json({ 
+      error: `GitHub API error: ${message}`,
+      details: `HTTP ${status}: ${message}`,
+      suggestion: 'Check GitHub service status or try again later'
+    });
+  }
+
+  // Axios 网络错误
+  if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+    return res.status(503).json({
+      error: 'Service unavailable',
+      details: 'Cannot connect to GitHub API',
+      suggestion: 'Check network connection or GitHub service status'
+    });
+  }
+
+  if (err.code === 'ETIMEDOUT') {
+    return res.status(504).json({
+      error: 'Request timeout',
+      details: 'GitHub API request timed out',
+      suggestion: 'Try again with smaller data or check network connection'
+    });
+  }
+
+  // 自定义应用错误
+  if (err.message.includes('Too many slides failed to save')) {
+    return res.status(500).json({
+      error: 'Partial save failure',
+      details: err.message,
+      suggestion: 'Some slides could not be saved. Check individual slide content and try again.',
+      partialFailure: true
+    });
+  }
+
+  if (err.message.includes('Failed to save PPT')) {
+    return res.status(500).json({
+      error: 'PPT save failed',
+      details: err.message,
+      suggestion: 'Check PPT content and try saving again. Consider reducing file size if needed.'
+    });
   }
 
   // 默认错误
+  const isDevelopment = process.env.NODE_ENV === 'development';
+  
   res.status(500).json({ 
-    error: process.env.NODE_ENV === 'production' 
-      ? 'Internal server error' 
-      : err.message 
+    error: isDevelopment ? err.message : 'Internal server error',
+    details: isDevelopment ? err.stack : 'An unexpected error occurred',
+    suggestion: 'If the problem persists, please contact support',
+    timestamp: new Date().toISOString()
   });
 };

backend/src/routes/ppt.js

@@ -1,7 +1,6 @@
 import express from 'express';
 import { v4 as uuidv4 } from 'uuid';
 import githubService from '../services/githubService.js';
-import memoryStorageService from '../services/memoryStorageService.js';
 
 const router = express.Router();
 
@@ -11,21 +10,11 @@ router.use((req, res, next) => {
   next();
 });
 
-// 选择存储服务
-const getStorageService = () => {
-  // 如果GitHub Token未配置，使用内存存储
-  if (!process.env.GITHUB_TOKEN) {
-    return memoryStorageService;
-  }
-  return githubService;
-};
-
 // 获取用户的PPT列表
 router.get('/list', async (req, res, next) => {
   try {
     const userId = req.user.userId;
-    const storageService = getStorageService();
-    const pptList = await storageService.getUserPPTList(userId);
+    const pptList = await githubService.getUserPPTList(userId);
     res.json(pptList);
   } catch (error) {
     next(error);
@@ -37,77 +26,409 @@ router.get('/:pptId', async (req, res, next) => {
   try {
     const userId = req.user.userId;
     const { pptId } = req.params;
-    const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
+
+    console.log(`🔍 Fetching PPT: ${pptId} for user: ${userId}`);
 
     let pptData = null;
+    let foundInRepo = -1;
     
-    // 如果是GitHub服务，尝试所有仓库
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
+    if (githubService.useMemoryStorage) {
+      // 内存存储模式
+      const result = await githubService.getPPTFromMemory(userId, pptId);
+      if (result && result.content) {
+        pptData = result.content;
+        foundInRepo = 0;
+        console.log(`✅ PPT found in memory storage`);
+      }
+    } else {
+      // GitHub存储模式 - 尝试所有仓库
+      console.log(`Available repositories: ${githubService.repositories.length}`);
+      
+      for (let i = 0; i < githubService.repositories.length; i++) {
         try {
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
+          console.log(`📂 Checking repository ${i}: ${githubService.repositories[i]}`);
+          const result = await githubService.getPPT(userId, pptId, i);
+          if (result && result.content) {
             pptData = result.content;
+            foundInRepo = i;
+            console.log(`✅ PPT found in repository ${i}${result.isReassembled ? ' (reassembled from chunks)' : ''}`);
             break;
           }
         } catch (error) {
+          console.log(`❌ PPT not found in repository ${i}: ${error.message}`);
           continue;
         }
       }
-    } else {
-      // 内存存储服务
-      const result = await storageService.getFile(userId, fileName);
-      if (result) {
-        pptData = result.content;
-      }
     }
 
     if (!pptData) {
-      return res.status(404).json({ error: 'PPT not found' });
+      console.log(`❌ PPT ${pptId} not found for user ${userId}`);
+      return res.status(404).json({ 
+        error: 'PPT not found',
+        pptId: pptId,
+        userId: userId,
+        storageMode: githubService.useMemoryStorage ? 'memory' : 'github'
+      });
+    }
+
+    // 🔧 修复：标准化PPT数据格式，确保前端兼容性
+    const standardizedPptData = {
+      // 确保基本字段存在
+      id: pptData.id || pptData.pptId || pptId,
+      pptId: pptData.pptId || pptData.id || pptId,
+      title: pptData.title || '未命名演示文稿',
+      
+      // 标准化slides数组
+      slides: Array.isArray(pptData.slides) ? pptData.slides.map((slide, index) => ({
+        id: slide.id || `slide-${index}`,
+        elements: Array.isArray(slide.elements) ? slide.elements : [],
+        background: slide.background || { type: 'solid', color: '#ffffff' },
+        ...slide
+      })) : [],
+      
+      // 标准化主题
+      theme: pptData.theme || {
+        backgroundColor: '#ffffff',
+        themeColor: '#d14424',
+        fontColor: '#333333',
+        fontName: 'Microsoft YaHei'
+      },
+      
+      // 🔧 关键修复：确保视口信息正确传递
+      viewportSize: pptData.viewportSize || 1000,
+      viewportRatio: pptData.viewportRatio || 0.5625,
+      
+      // 时间戳
+      createdAt: pptData.createdAt || new Date().toISOString(),
+      updatedAt: pptData.updatedAt || new Date().toISOString(),
+      
+      // 保留其他可能的属性
+      ...pptData
+    };
+
+    // 🔧 新增：数据验证和修复
+    if (standardizedPptData.slides.length === 0) {
+      console.log(`⚠️ PPT ${pptId} has no slides, creating default slide`);
+      standardizedPptData.slides = [{
+        id: 'default-slide',
+        elements: [],
+        background: { type: 'solid', color: '#ffffff' }
+      }];
+    }
+
+    // 验证视口比例的合理性
+    if (standardizedPptData.viewportRatio <= 0 || standardizedPptData.viewportRatio > 2) {
+      console.log(`⚠️ Invalid viewportRatio ${standardizedPptData.viewportRatio}, resetting to 0.5625`);
+      standardizedPptData.viewportRatio = 0.5625;
     }
 
-    res.json(pptData);
+    // 验证视口尺寸的合理性
+    if (standardizedPptData.viewportSize <= 0 || standardizedPptData.viewportSize > 2000) {
+      console.log(`⚠️ Invalid viewportSize ${standardizedPptData.viewportSize}, resetting to 1000`);
+      standardizedPptData.viewportSize = 1000;
+    }
+
+    console.log(`✅ Successfully found and standardized PPT ${pptId}:`, {
+      slidesCount: standardizedPptData.slides.length,
+      viewportSize: standardizedPptData.viewportSize,
+      viewportRatio: standardizedPptData.viewportRatio,
+      storageMode: githubService.useMemoryStorage ? 'memory' : `repository ${foundInRepo}`
+    });
+
+    res.json(standardizedPptData);
   } catch (error) {
+    console.error(`❌ Error fetching PPT ${req.params.pptId}:`, error);
     next(error);
   }
 });
 
-// 保存PPT数据
+// 保存PPT数据 - 新架构版本
 router.post('/save', async (req, res, next) => {
   try {
     const userId = req.user.userId;
     const { pptId, title, slides, theme, viewportSize, viewportRatio } = req.body;
 
+    console.log(`🔄 Starting PPT save for user ${userId}, PPT ID: ${pptId}`);
+    console.log(`📊 Request body analysis:`, {
+      pptId: !!pptId,
+      title: title?.length || 0,
+      slidesCount: Array.isArray(slides) ? slides.length : 'not array',
+      theme: !!theme,
+      requestSize: req.get('content-length'),
+      storageMode: githubService.useMemoryStorage ? 'memory' : 'github'
+    });
+
     if (!pptId || !slides) {
+      console.log(`❌ Missing required fields - pptId: ${!!pptId}, slides: ${!!slides}`);
       return res.status(400).json({ error: 'PPT ID and slides are required' });
     }
 
-    const fileName = `${pptId}.json`;
+    // 验证slides数组
+    if (!Array.isArray(slides) || slides.length === 0) {
+      console.log(`❌ Invalid slides array - isArray: ${Array.isArray(slides)}, length: ${slides?.length || 0}`);
+      return res.status(400).json({ error: 'Slides must be a non-empty array' });
+    }
+
+    // 构建标准化的PPT数据结构
     const pptData = {
       id: pptId,
       title: title || '未命名演示文稿',
-      slides: slides,
-      theme: theme || {},
-      // 保存关键的尺寸信息
-      viewportSize: viewportSize,
-      viewportRatio: viewportRatio,
+      slides: slides.map((slide, index) => ({
+        id: slide.id || `slide-${index}`,
+        elements: Array.isArray(slide.elements) ? slide.elements : [],
+        background: slide.background || { type: 'solid', color: '#ffffff' },
+        ...slide
+      })),
+      theme: theme || {
+        backgroundColor: '#ffffff',
+        themeColor: '#d14424',
+        fontColor: '#333333',
+        fontName: 'Microsoft YaHei'
+      },
+      viewportSize: viewportSize || 1000,
+      viewportRatio: viewportRatio || 0.5625,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     };
 
-    const storageService = getStorageService();
+    // 计算文件大小分析
+    const jsonData = JSON.stringify(pptData);
+    const totalDataSize = Buffer.byteLength(jsonData, 'utf8');
     
-    // 如果是GitHub服务，保存到第一个仓库
-    if (storageService === githubService) {
-      await storageService.saveFile(userId, fileName, pptData, 0);
-    } else {
-      // 内存存储服务
-      await storageService.saveFile(userId, fileName, pptData);
+    console.log(`📊 PPT data analysis:`);
+    console.log(`  - Total slides: ${slides.length}`);
+    console.log(`  - Total data size: ${totalDataSize} bytes (${(totalDataSize / 1024).toFixed(2)} KB)`);
+    console.log(`  - Average slide size: ${(totalDataSize / slides.length / 1024).toFixed(2)} KB`);
+    
+    // 分析每个slide的大小
+    const slideAnalysis = slides.map((slide, index) => {
+      const slideJson = JSON.stringify(slide);
+      const slideSize = Buffer.byteLength(slideJson, 'utf8');
+      return {
+        index,
+        size: slideSize,
+        sizeKB: (slideSize / 1024).toFixed(2),
+        elementsCount: slide.elements?.length || 0,
+        hasLargeContent: slideSize > 800 * 1024 // 800KB+
+      };
+    });
+    
+    const largeSlides = slideAnalysis.filter(s => s.hasLargeContent);
+    const maxSlideSize = Math.max(...slideAnalysis.map(s => s.size));
+    
+    console.log(`📋 Slide size analysis:`);
+    console.log(`  - Largest slide: ${(maxSlideSize / 1024).toFixed(2)} KB`);
+    console.log(`  - Large slides (>800KB): ${largeSlides.length}`);
+    if (largeSlides.length > 0) {
+      console.log(`  - Large slide indices: ${largeSlides.map(s => s.index).join(', ')}`);
     }
 
-    res.json({ message: 'PPT saved successfully', pptId });
+    try {
+      let result;
+      
+      console.log(`💾 Using storage mode: ${githubService.useMemoryStorage ? 'memory' : 'GitHub folder architecture'}`);
+      
+      if (githubService.useMemoryStorage) {
+        // 内存存储模式
+        result = await githubService.savePPTToMemory(userId, pptId, pptData);
+        console.log(`✅ PPT saved to memory storage:`, result);
+      } else {
+        // GitHub存储模式 - 使用新的文件夹架构
+        console.log(`🐙 Using GitHub folder storage for ${pptId}`);
+        console.log(`📂 Available repositories: ${githubService.repositories?.length || 0}`);
+        
+        if (!githubService.repositories || githubService.repositories.length === 0) {
+          throw new Error('No GitHub repositories configured');
+        }
+        
+        console.log(`🔍 Pre-save validation:`);
+        console.log(`  - Repository 0: ${githubService.repositories[0]}`);
+        console.log(`  - Token configured: ${!!githubService.token}`);
+        console.log(`  - API URL: ${githubService.apiUrl}`);
+        
+        result = await githubService.savePPT(userId, pptId, pptData, 0);
+        console.log(`✅ PPT saved to GitHub folder storage:`, result);
+      }
+      
+      console.log(`✅ PPT save completed successfully:`, {
+        pptId,
+        userId,
+        slideCount: slides.length,
+        totalDataSize,
+        storageType: result.storage || 'unknown',
+        compressionApplied: result.compressionSummary?.compressedSlides > 0,
+        storageMode: githubService.useMemoryStorage ? 'memory' : 'github'
+      });
+
+      const response = { 
+        message: 'PPT saved successfully', 
+        pptId,
+        slidesCount: slides.length,
+        savedAt: new Date().toISOString(),
+        totalFileSize: `${(totalDataSize / 1024).toFixed(2)} KB`,
+        storageType: result.storage || 'unknown',
+        storageMode: githubService.useMemoryStorage ? 'memory' : 'github',
+        architecture: 'folder-based',
+        slideAnalysis: {
+          totalSlides: slides.length,
+          largestSlideSize: `${(maxSlideSize / 1024).toFixed(2)} KB`,
+          largeSlides: largeSlides.length,
+          averageSlideSize: `${(totalDataSize / slides.length / 1024).toFixed(2)} KB`
+        }
+      };
+
+      // 添加压缩信息
+      if (result.compressionSummary) {
+        response.compression = {
+          applied: result.compressionSummary.compressedSlides > 0,
+          compressedSlides: result.compressionSummary.compressedSlides,
+          totalSlides: result.compressionSummary.totalSlides,
+          savedSlides: result.compressionSummary.savedSlides,
+          failedSlides: result.compressionSummary.failedSlides,
+          originalSize: `${(result.compressionSummary.totalOriginalSize / 1024).toFixed(2)} KB`,
+          finalSize: `${(result.compressionSummary.totalFinalSize / 1024).toFixed(2)} KB`,
+          savedSpace: `${((result.compressionSummary.totalOriginalSize - result.compressionSummary.totalFinalSize) / 1024).toFixed(2)} KB`,
+          compressionRatio: `${(result.compressionSummary.compressionRatio * 100).toFixed(1)}%`
+        };
+        
+        if (result.compressionSummary.compressedSlides > 0) {
+          response.message = `PPT saved successfully with ${result.compressionSummary.compressedSlides} slides optimized for storage`;
+          response.optimization = `Automatic compression applied to ${result.compressionSummary.compressedSlides} large slides, saving ${response.compression.savedSpace}`;
+        }
+
+        // 添加保存警告信息
+        if (result.compressionSummary.failedSlides > 0) {
+          response.warning = `${result.compressionSummary.failedSlides} slides failed to save`;
+          response.partialSave = true;
+          response.savedSlides = result.compressionSummary.savedSlides;
+          response.failedSlides = result.compressionSummary.failedSlides;
+          
+          if (result.compressionSummary.errors) {
+            response.slideErrors = result.compressionSummary.errors;
+          }
+        }
+      }
+
+      // 添加存储路径信息
+      if (result.folderPath) {
+        response.storagePath = result.folderPath;
+        response.architecture = 'folder-based (meta.json + individual slide files)';
+      }
+
+      // 添加警告信息
+      if (result.warnings) {
+        response.warnings = result.warnings;
+      }
+
+      res.json(response);
+      
+    } catch (saveError) {
+      console.error(`❌ Save operation failed:`, {
+        error: saveError.message,
+        stack: saveError.stack,
+        userId,
+        pptId,
+        slidesCount: slides.length,
+        totalDataSize,
+        errorName: saveError.name,
+        errorCode: saveError.code
+      });
+      
+      let errorResponse = {
+        error: 'PPT save failed',
+        details: saveError.message,
+        pptId: pptId,
+        slidesCount: slides.length,
+        totalFileSize: `${(totalDataSize / 1024).toFixed(2)} KB`,
+        timestamp: new Date().toISOString(),
+        slideAnalysis: {
+          largestSlideSize: `${(maxSlideSize / 1024).toFixed(2)} KB`,
+          largeSlides: largeSlides.length
+        }
+      };
+      
+      // 根据错误类型提供具体建议
+      if (saveError.message.includes('File too large') || saveError.message.includes('exceeds')) {
+        errorResponse.error = 'Slide file too large for storage';
+        errorResponse.suggestion = 'Some slides are too large even after compression. Try reducing image sizes or slide complexity.';
+        errorResponse.limits = {
+          maxSlideSize: '999 KB per slide',
+          largestSlideSize: `${(maxSlideSize / 1024).toFixed(2)} KB`,
+          oversizeSlides: largeSlides.length
+        };
+        return res.status(413).json(errorResponse);
+      }
+      
+      if (saveError.message.includes('Failed to compress slide')) {
+        errorResponse.error = 'Slide compression failed';
+        errorResponse.suggestion = 'Unable to compress slides to acceptable size. Try manually reducing content complexity.';
+        errorResponse.compressionError = true;
+        return res.status(500).json(errorResponse);
+      }
+      
+      if (saveError.message.includes('GitHub API') || saveError.message.includes('GitHub')) {
+        errorResponse.error = 'GitHub storage service error';
+        errorResponse.suggestion = 'Temporary GitHub service issue. Please try again in a few minutes.';
+        errorResponse.githubError = true;
+        return res.status(502).json(errorResponse);
+      }
+      
+      if (saveError.message.includes('No GitHub repositories')) {
+        errorResponse.error = 'Storage configuration error';
+        errorResponse.suggestion = 'GitHub repositories not properly configured. Please contact support.';
+        errorResponse.configError = true;
+        return res.status(500).json(errorResponse);
+      }
+      
+      // 网络相关错误
+      if (saveError.code === 'ETIMEDOUT' || saveError.message.includes('timeout')) {
+        errorResponse.error = 'Storage operation timeout';
+        errorResponse.suggestion = 'The save operation took too long. Try reducing file size or try again later.';
+        errorResponse.timeoutError = true;
+        return res.status(504).json(errorResponse);
+      }
+      
+      // 默认错误
+      errorResponse.suggestion = 'Unknown save error. Please try again or contact support if the problem persists.';
+      errorResponse.unknownError = true;
+      return res.status(500).json(errorResponse);
+    }
+    
   } catch (error) {
+    console.error(`❌ PPT save failed for user ${req.user?.userId}, PPT ID: ${req.body?.pptId}:`, {
+      error: error.message,
+      stack: error.stack,
+      userId: req.user?.userId,
+      pptId: req.body?.pptId,
+      requestSize: req.get('content-length'),
+      slidesCount: req.body?.slides?.length,
+      errorName: error.name,
+      errorCode: error.code
+    });
+
+    // 提供更详细的错误处理
+    let errorResponse = {
+      error: 'PPT save processing failed',
+      details: error.message,
+      timestamp: new Date().toISOString(),
+      userId: req.user?.userId,
+      pptId: req.body?.pptId,
+      architecture: 'folder-based'
+    };
+
+    if (error.message.includes('Invalid slide data')) {
+      errorResponse.error = 'Invalid slide data detected';
+      errorResponse.suggestion = 'One or more slides contain invalid or corrupted data';
+      return res.status(400).json(errorResponse);
+    }
+
+    if (error.message.includes('JSON')) {
+      errorResponse.error = 'Invalid data format';
+      errorResponse.suggestion = 'Check slide data structure and content';
+      return res.status(400).json(errorResponse);
+    }
+
+    errorResponse.suggestion = 'Unknown processing error. Please try again or contact support if the problem persists.';
     next(error);
   }
 });
@@ -125,6 +446,7 @@ router.post('/create', async (req, res, next) => {
     const pptId = uuidv4();
     const now = new Date().toISOString();
     
+    // 确保数据格式与前端store一致
     const pptData = {
       id: pptId,
       title,
@@ -159,42 +481,25 @@ router.post('/create', async (req, res, next) => {
           }
         }
       ],
+      // 确保视口信息与前端一致
+      viewportSize: 1000,
+      viewportRatio: 0.5625,
       createdAt: now,
       updatedAt: now
     };
 
-    const storageService = getStorageService();
     const fileName = `${pptId}.json`;
     
-    console.log(`Creating PPT for user ${userId}, using storage: ${storageService === githubService ? 'GitHub' : 'Memory'}`);
+    console.log(`Creating PPT for user ${userId}, using ${githubService.useMemoryStorage ? 'memory' : 'GitHub'} storage`);
     
-    try {
-      await storageService.saveFile(userId, fileName, pptData);
-      console.log(`PPT created successfully: ${pptId}`);
-      res.json({ success: true, pptId, pptData });
-    } catch (saveError) {
-      console.error('Error saving PPT:', saveError.message);
-      
-      // 如果GitHub保存失败，尝试使用内存存储作为fallback
-      if (storageService === githubService) {
-        console.log('GitHub save failed, falling back to memory storage');
-        try {
-          await memoryStorageService.saveFile(userId, fileName, pptData);
-          console.log(`PPT saved to memory storage: ${pptId}`);
-          res.json({ 
-            success: true, 
-            pptId, 
-            pptData,
-            warning: 'Saved to temporary storage due to GitHub connection issue'
-          });
-        } catch (memoryError) {
-          console.error('Memory storage also failed:', memoryError.message);
-          throw new Error('Failed to save PPT to any storage');
-        }
-      } else {
-        throw saveError;
-      }
+    if (githubService.useMemoryStorage) {
+      await githubService.saveToMemory(userId, fileName, pptData);
+    } else {
+      await githubService.saveFile(userId, fileName, pptData);
     }
+    
+    console.log(`PPT created successfully: ${pptId}`);
+    res.json({ success: true, pptId, pptData });
   } catch (error) {
     console.error('PPT creation error:', error);
     next(error);
@@ -207,21 +512,30 @@ router.delete('/:pptId', async (req, res, next) => {
     const userId = req.user.userId;
     const { pptId } = req.params;
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
 
-    // 如果是GitHub服务，从所有仓库中删除
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
+    if (githubService.useMemoryStorage) {
+      // 内存存储模式
+      const deleted = githubService.memoryStorage.delete(`users/${userId}/${fileName}`);
+      if (!deleted) {
+        return res.status(404).json({ error: 'PPT not found' });
+      }
+    } else {
+      // GitHub存储模式 - 从所有仓库中删除
+      let deleted = false;
+      for (let i = 0; i < githubService.repositories.length; i++) {
         try {
-          await storageService.deleteFile(userId, fileName, i);
+          await githubService.deleteFile(userId, fileName, i);
+          deleted = true;
+          break; // 只需要从一个仓库删除成功即可
         } catch (error) {
           // 继续尝试其他仓库
           continue;
         }
       }
-    } else {
-      // 内存存储服务
-      await storageService.deleteFile(userId, fileName);
+      
+      if (!deleted) {
+        return res.status(404).json({ error: 'PPT not found in any repository' });
+      }
     }
 
     res.json({ message: 'PPT deleted successfully' });
@@ -237,27 +551,26 @@ router.post('/:pptId/copy', async (req, res, next) => {
     const { pptId } = req.params;
     const { title } = req.body;
     const sourceFileName = `${pptId}.json`;
-    const storageService = getStorageService();
 
     // 获取源PPT数据
     let sourcePPT = null;
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
+    
+    if (githubService.useMemoryStorage) {
+      // 内存存储模式
+      sourcePPT = await githubService.getFromMemory(userId, sourceFileName);
+    } else {
+      // GitHub存储模式
+      for (let i = 0; i < githubService.repositories.length; i++) {
         try {
-          const result = await storageService.getFile(userId, sourceFileName, i);
+          const result = await githubService.getFile(userId, sourceFileName, i);
           if (result) {
-            sourcePPT = result.content;
+            sourcePPT = result;
             break;
           }
         } catch (error) {
           continue;
         }
       }
-    } else {
-      const result = await storageService.getFile(userId, sourceFileName);
-      if (result) {
-        sourcePPT = result.content;
-      }
     }
 
     if (!sourcePPT) {
@@ -276,10 +589,10 @@ router.post('/:pptId/copy', async (req, res, next) => {
     };
 
     // 保存复制的PPT
-    if (storageService === githubService) {
-      await storageService.saveFile(userId, newFileName, newPPTData, 0);
+    if (githubService.useMemoryStorage) {
+      await githubService.saveToMemory(userId, newFileName, newPPTData);
     } else {
-      await storageService.saveFile(userId, newFileName, newPPTData);
+      await githubService.saveFile(userId, newFileName, newPPTData, 0);
     }
 
     res.json({ 

backend/src/routes/public.js

@@ -1,566 +1,108 @@
 import express from 'express';
 import githubService from '../services/githubService.js';
-import memoryStorageService from '../services/memoryStorageService.js';
 import screenshotService from '../services/screenshotService.js';
+// 修正导入路径：从 backend/src 向上两级到 app，再进入 shared
+import { generateSlideHTML, generateExportPage } from '../../../shared/export-utils.js';
 
 const router = express.Router();
 
-// 选择存储服务
-const getStorageService = () => {
-  // 如果GitHub Token未配置，使用内存存储
-  if (!process.env.GITHUB_TOKEN) {
-    return memoryStorageService;
-  }
-  return githubService;
-};
-
-// 生成HTML页面来显示PPT幻灯片
-const generateSlideHTML = (pptData, slideIndex, title) => {
-  const slide = pptData.slides[slideIndex];
-  const theme = pptData.theme || {};
-  
-  // 精确计算PPT内容的真实尺寸 - 基于填满画布的图像元素推断
-  const calculatePptDimensions = (slide) => {
-    console.log('开始计算PPT尺寸，当前slide元素数量:', slide.elements?.length || 0);
-    
-    // 1. 优先使用PPT数据中的viewportSize和viewportRatio（编辑器的真实尺寸）
-    if (pptData.viewportSize && pptData.viewportRatio) {
-      const result = {
-        width: Math.ceil(pptData.viewportSize),
-        height: Math.ceil(pptData.viewportSize * pptData.viewportRatio)
-      };
-      console.log(`使用编辑器真实尺寸: ${result.width}x${result.height} (viewportSize: ${pptData.viewportSize}, viewportRatio: ${pptData.viewportRatio})`);
-      return result;
-    }
-    
-    // 2. 使用PPT数据中的预设尺寸
-    if (pptData.slideSize && pptData.slideSize.width && pptData.slideSize.height) {
-      const result = {
-        width: Math.ceil(pptData.slideSize.width),
-        height: Math.ceil(pptData.slideSize.height)
-      };
-      console.log(`使用PPT预设尺寸: ${result.width}x${result.height}`);
-      return result;
-    }
-    
-    // 3. 如果PPT数据中有width和height
-    if (pptData.width && pptData.height) {
-      const result = {
-        width: Math.ceil(pptData.width),
-        height: Math.ceil(pptData.height)
-      };
-      console.log(`使用PPT根级尺寸: ${result.width}x${result.height}`);
-      return result;
-    }
-    
-    // 4. 使用slide级别的尺寸设置
-    if (slide.width && slide.height) {
-      const result = {
-        width: Math.ceil(slide.width),
-        height: Math.ceil(slide.height)
-      };
-      console.log(`使用slide尺寸: ${result.width}x${result.height}`);
-      return result;
-    }
-    
-    // 5. 基于填满画布的图像元素精确推断PPT尺寸
-    if (slide.elements && slide.elements.length > 0) {
-      // 寻找可能填满画布的图像元素（left=0, top=0 或接近0，且尺寸较大）
-      const candidateImages = slide.elements.filter(element => 
-        element.type === 'image' && 
-        Math.abs(element.left || 0) <= 10 &&  // 允许小偏差
-        Math.abs(element.top || 0) <= 10 &&   // 允许小偏差
-        (element.width || 0) >= 800 &&        // 宽度至少800
-        (element.height || 0) >= 400          // 高度至少400
-      );
-      
-      if (candidateImages.length > 0) {
-        // 使用面积最大的图像作为画布尺寸参考
-        const referenceImage = candidateImages.reduce((max, current) => {
-          const maxArea = (max.width || 0) * (max.height || 0);
-          const currentArea = (current.width || 0) * (current.height || 0);
-          return currentArea > maxArea ? current : max;
-        });
-        
-        const result = {
-          width: Math.ceil(referenceImage.width || 1000),
-          height: Math.ceil(referenceImage.height || 562)
-        };
-        
-        console.log(`基于填满画布的图像推断PPT尺寸: ${result.width}x${result.height} (参考图像: ${referenceImage.id})`);
-        console.log(`参考图像信息: left=${referenceImage.left}, top=${referenceImage.top}, width=${referenceImage.width}, height=${referenceImage.height}`);
-        
-        return result;
-      }
-      
-      // 如果没有找到填满画布的图像，回退到边界计算
-      let maxRight = 0;
-      let maxBottom = 0;
-      let minLeft = Infinity;
-      let minTop = Infinity;
-      
-      // 计算所有元素的实际边界
-      slide.elements.forEach(element => {
-        const left = element.left || 0;
-        const top = element.top || 0;
-        const width = element.width || 0;
-        const height = element.height || 0;
-        
-        const elementRight = left + width;
-        const elementBottom = top + height;
-        
-        maxRight = Math.max(maxRight, elementRight);
-        maxBottom = Math.max(maxBottom, elementBottom);
-        minLeft = Math.min(minLeft, left);
-        minTop = Math.min(minTop, top);
-        
-        console.log(`元素 ${element.id}: type=${element.type}, left=${left}, top=${top}, width=${width}, height=${height}, right=${elementRight}, bottom=${elementBottom}`);
-      });
-      
-      // 重置无限值
-      if (minLeft === Infinity) minLeft = 0;
-      if (minTop === Infinity) minTop = 0;
-      
-      console.log(`元素边界: minLeft=${minLeft}, minTop=${minTop}, maxRight=${maxRight}, maxBottom=${maxBottom}`);
-      
-      // 根据实际元素分布确定画布尺寸
-      const canvasLeft = Math.min(0, minLeft);
-      const canvasTop = Math.min(0, minTop);
-      const canvasRight = Math.max(maxRight, 1000); // 最小宽度1000（基于GitHub数据）
-      const canvasBottom = Math.max(maxBottom, 562);  // 最小高度562（基于GitHub数据）
-      
-      // 计算最终的画布尺寸
-      let finalWidth = canvasRight - canvasLeft;
-      let finalHeight = canvasBottom - canvasTop;
-      
-      // 基于从GitHub仓库观察到的实际比例进行智能调整
-      const currentRatio = finalWidth / finalHeight;
-      console.log(`当前计算比例: ${currentRatio.toFixed(3)}`);
-      
-      // 从GitHub数据分析：1000x562.5 ≈ 1.78 (接近16:9的1.77)
-      const targetRatio = 1000 / 562.5; // ≈ 1.778
-      
-      // 如果比例接近观察到的标准比例，调整为精确比例
-      if (Math.abs(currentRatio - targetRatio) < 0.2) {
-        if (finalWidth > finalHeight * targetRatio) {
-          finalHeight = finalWidth / targetRatio;
-        } else {
-          finalWidth = finalHeight * targetRatio;
+// Generate error page for frontend display
+function generateErrorPage(title, message) {
+  return `
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title} - PPT导出</title>
+    <style>
+        body {
+            font-family: 'Microsoft YaHei', sans-serif;
+            margin: 0;
+            padding: 0;
+            background: linear-gradient(135deg, #ff6b6b 0%, #feca57 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
         }
-        console.log(`调整为GitHub观察到的标准比例: ${targetRatio.toFixed(3)}`);
-      }
-      // 如果比例接近16:9，调整为标准16:9
-      else if (Math.abs(currentRatio - 16/9) < 0.1) {
-        if (finalWidth > finalHeight * 16/9) {
-          finalHeight = finalWidth / (16/9);
-        } else {
-          finalWidth = finalHeight * (16/9);
+        .error-container {
+            background: white;
+            padding: 40px;
+            border-radius: 15px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            text-align: center;
+            max-width: 500px;
+            margin: 20px;
         }
-        console.log(`调整为16:9比例`);
-      }
-      // 如果比例接近4:3，调整为标准4:3
-      else if (Math.abs(currentRatio - 4/3) < 0.1) {
-        if (finalWidth > finalHeight * 4/3) {
-          finalHeight = finalWidth / (4/3);
-        } else {
-          finalWidth = finalHeight * (4/3);
+        .error-icon { font-size: 64px; margin-bottom: 20px; }
+        .error-title { font-size: 24px; font-weight: bold; color: #333; margin-bottom: 15px; }
+        .error-message { font-size: 16px; color: #666; line-height: 1.6; margin-bottom: 30px; }
+        .error-actions { display: flex; gap: 15px; justify-content: center; }
+        .btn {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 5px;
+            font-size: 16px;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: all 0.3s;
         }
-        console.log(`调整为4:3比例`);
-      }
-      
-      // 确保尺寸为偶数（避免半像素问题）
-      finalWidth = Math.ceil(finalWidth / 2) * 2;
-      finalHeight = Math.ceil(finalHeight / 2) * 2;
-      
-      const result = { width: finalWidth, height: finalHeight };
-      console.log(`根据元素边界计算最终尺寸: ${result.width}x${result.height}, 比例: ${(result.width/result.height).toFixed(3)}`);
-      
-      return result;
-    }
-    
-    // 6. 如果没有元素，使用从GitHub数据分析得出的标准尺寸
-    const result = { width: 1000, height: 562 }; // 基于GitHub仓库中观察到的实际数据
-    console.log(`使用GitHub数据分析的默认尺寸: ${result.width}x${result.height} (1000x562, 比例≈1.78)`);
-    return result;
-  };
-  
-  const pptDimensions = calculatePptDimensions(slide);
-  
-  // 渲染幻灯片元素 - 使用原始像素值，完全保真
-  const renderElements = (elements) => {
-    if (!elements || elements.length === 0) return '';
-    
-    return elements.map(element => {
-      const style = `
-        position: absolute;
-        left: ${element.left || 0}px;
-        top: ${element.top || 0}px;
-        width: ${element.width || 0}px;
-        height: ${element.height || 0}px;
-        transform: rotate(${element.rotate || 0}deg);
-        z-index: ${element.zIndex || 1};
-      `;
-      
-      switch (element.type) {
-        case 'text':
-          return `
-            <div style="${style} 
-              font-size: ${element.fontSize || 14}px;
-              font-family: ${element.fontName || 'Arial'};
-              color: ${element.defaultColor || '#000'};
-              font-weight: ${element.bold ? 'bold' : 'normal'};
-              font-style: ${element.italic ? 'italic' : 'normal'};
-              text-decoration: ${element.underline ? 'underline' : 'none'};
-              text-align: ${element.align || 'left'};
-              line-height: ${element.lineHeight || 1.2};
-              padding: 10px;
-              word-wrap: break-word;
-              overflow: hidden;
-              box-sizing: border-box;
-            ">
-              ${element.content || ''}
-            </div>
-          `;
-        case 'image':
-          return `
-            <div style="${style}">
-              <img src="${element.src}" alt="" style="width: 100%; height: 100%; object-fit: ${element.objectFit || 'cover'}; display: block;" />
-            </div>
-          `;
-        case 'shape':
-          const shapeStyle = element.fill ? `background-color: ${element.fill};` : '';
-          const borderStyle = element.outline ? `border: ${element.outline.width || 1}px ${element.outline.style || 'solid'} ${element.outline.color || '#000'};` : '';
-          return `
-            <div style="${style} ${shapeStyle} ${borderStyle} box-sizing: border-box;"></div>
-          `;
-        default:
-          return `<div style="${style}"></div>`;
-      }
-    }).join('');
-  };
-
-  return `
-    <!DOCTYPE html>
-    <html lang="zh-CN">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-        <title>${title} - 第${slideIndex + 1}页</title>
-        <style>
-            /* 完全重置所有默认样式 */
-            *, *::before, *::after {
-                margin: 0 !important;
-                padding: 0 !important;
-                border: 0 !important;
-                outline: 0 !important;
-                box-sizing: border-box !important;
-            }
-            
-            /* HTML - 填满整个窗口，黑色背景 */
-            html {
-                width: 100vw !important;
-                height: 100vh !important;
-                background: #000000 !important;
-                overflow: hidden !important;
-                position: fixed !important;
-                top: 0 !important;
-                left: 0 !important;
-            }
-            
-            /* Body - 填满整个窗口，黑色背景，居中显示PPT */
-            body {
-                width: 100vw !important;
-                height: 100vh !important;
-                background: #000000 !important;
-                overflow: hidden !important;
-                font-family: 'Microsoft YaHei', Arial, sans-serif !important;
-                position: fixed !important;
-                top: 0 !important;
-                left: 0 !important;
-                display: flex !important;
-                align-items: center !important;
-                justify-content: center !important;
-            }
-            
-            /* PPT容器 - 使用PPT原始尺寸 */
-            .slide-container {
-                width: ${pptDimensions.width}px !important;
-                height: ${pptDimensions.height}px !important;
-                background-color: ${slide.background?.color || theme.backgroundColor || '#ffffff'} !important;
-                position: relative !important;
-                overflow: hidden !important;
-                transform-origin: center center !important;
-                /* 缩放将通过JavaScript动态设置 */
-            }
-            
-            /* 背景图片处理 */
-            ${slide.background?.type === 'image' ? `
-            .slide-container::before {
-                content: '';
-                position: absolute !important;
-                top: 0 !important;
-                left: 0 !important;
-                width: 100% !important;
-                height: 100% !important;
-                background-image: url('${slide.background.image}') !important;
-                background-size: cover !important;
-                background-position: center !important;
-                background-repeat: no-repeat !important;
-                z-index: 0 !important;
-            }
-            ` : ''}
-            
-            /* 隐藏所有滚动条 */
-            ::-webkit-scrollbar {
-                display: none !important;
-            }
-            
-            html {
-                scrollbar-width: none !important;
-                -ms-overflow-style: none !important;
-            }
-            
-            /* 禁用用户交互 */
-            * {
-                -webkit-user-select: none !important;
-                -moz-user-select: none !important;
-                -ms-user-select: none !important;
-                user-select: none !important;
-                -webkit-user-drag: none !important;
-                -khtml-user-drag: none !important;
-                -moz-user-drag: none !important;
-                -o-user-drag: none !important;
-                user-drag: none !important;
-            }
-            
-            /* 禁用缩放 */
-            body {
-                zoom: 1 !important;
-                -webkit-text-size-adjust: 100% !important;
-                -ms-text-size-adjust: 100% !important;
-            }
-        </style>
-    </head>
-    <body>
-        <div class="slide-container" id="slideContainer">
-            ${renderElements(slide.elements)}
+        .btn-primary { background: #4CAF50; color: white; }
+        .btn-primary:hover { background: #45a049; }
+        .btn-secondary { background: #f8f9fa; color: #333; border: 1px solid #ddd; }
+        .btn-secondary:hover { background: #e9ecef; }
+    </style>
+</head>
+<body>
+    <div class="error-container">
+        <div class="error-icon">❌</div>
+        <div class="error-title">${title}</div>
+        <div class="error-message">${message}</div>
+        <div class="error-actions">
+            <button class="btn btn-secondary" onclick="history.back()">返回上页</button>
+            <a href="/" class="btn btn-primary">回到首页</a>
         </div>
-        
-        <script>
-            // PPT尺寸信息
-            window.PPT_DIMENSIONS = {
-                width: ${pptDimensions.width},
-                height: ${pptDimensions.height}
-            };
-            
-            console.log('PPT页面初始化 - 原始尺寸整体缩放模式:', window.PPT_DIMENSIONS);
-            
-            // 计算整体缩放比例，让PPT适应窗口大小
-            function calculateScale() {
-                const windowWidth = window.innerWidth;
-                const windowHeight = window.innerHeight;
-                const pptWidth = ${pptDimensions.width};
-                const pptHeight = ${pptDimensions.height};
-                
-                // 计算缩放比例，保持PPT长宽比
-                const scaleX = windowWidth / pptWidth;
-                const scaleY = windowHeight / pptHeight;
-                
-                // 使用较小的缩放比例，确保PPT完全可见（会有黑边）
-                const scale = Math.min(scaleX, scaleY);
-                
-                return Math.min(scale, 1); // 最大不超过1（不放大）
-            }
-            
-            // 应用缩放变换
-            function scalePPTToFitWindow() {
-                const container = document.getElementById('slideContainer');
-                if (!container) return;
-                
-                const scale = calculateScale();
-                
-                // 应用缩放变换
-                container.style.transform = \`scale(\${scale})\`;
-                
-                console.log(\`PPT整体缩放: \${scale.toFixed(3)}x (窗口: \${window.innerWidth}x\${window.innerHeight}, PPT: \${${pptDimensions.width}}x\${${pptDimensions.height}})\`);
-            }
-            
-            // 页面加载完成后初始化
-            window.addEventListener('load', function() {
-                const html = document.documentElement;
-                const body = document.body;
-                const container = document.getElementById('slideContainer');
-                
-                console.log('页面加载完成，开始整体缩放布局');
-                
-                // 确保页面元素填满窗口
-                html.style.width = '100vw';
-                html.style.height = '100vh';
-                html.style.background = '#000000';
-                html.style.overflow = 'hidden';
-                html.style.margin = '0';
-                html.style.padding = '0';
-                
-                body.style.width = '100vw';
-                body.style.height = '100vh';
-                body.style.background = '#000000';
-                body.style.overflow = 'hidden';
-                body.style.margin = '0';
-                body.style.padding = '0';
-                body.style.display = 'flex';
-                body.style.alignItems = 'center';
-                body.style.justifyContent = 'center';
-                
-                // 确保PPT容器使用原始尺寸
-                if (container) {
-                    container.style.width = '${pptDimensions.width}px';
-                    container.style.height = '${pptDimensions.height}px';
-                    container.style.transformOrigin = 'center center';
-                }
-                
-                // 执行整体缩放
-                scalePPTToFitWindow();
-                
-                // 禁用各种用户交互
-                document.addEventListener('wheel', function(e) {
-                    if (e.ctrlKey) e.preventDefault();
-                }, { passive: false });
-                
-                document.addEventListener('keydown', function(e) {
-                    if ((e.ctrlKey && (e.key === '+' || e.key === '-' || e.key === '0')) || e.key === 'F11') {
-                        e.preventDefault();
-                    }
-                }, false);
-                
-                document.addEventListener('contextmenu', function(e) {
-                    e.preventDefault();
-                }, false);
-                
-                // 禁用触摸缩放
-                let lastTouchEnd = 0;
-                document.addEventListener('touchend', function(e) {
-                    const now = new Date().getTime();
-                    if (now - lastTouchEnd <= 300) {
-                        e.preventDefault();
-                    }
-                    lastTouchEnd = now;
-                }, false);
-                
-                document.addEventListener('touchstart', function(e) {
-                    if (e.touches.length > 1) {
-                        e.preventDefault();
-                    }
-                }, { passive: false });
-                
-                console.log('原始尺寸PPT页面初始化完成');
-                
-                // 验证最终效果
-                setTimeout(() => {
-                    const actualScale = container.style.transform.match(/scale\\(([^)]+)\\)/);
-                    const scaleValue = actualScale ? parseFloat(actualScale[1]) : 1;
-                    
-                    console.log(\`✅ PPT以原始尺寸(\${${pptDimensions.width}}x\${${pptDimensions.height}})显示，整体缩放: \${scaleValue.toFixed(3)}x\`);
-                    console.log('🎯 显示效果与编辑器完全一致，周围黑边正常');
-                }, 200);
-            });
-            
-            // 监听窗口大小变化，实时调整缩放
-            window.addEventListener('resize', function() {
-                console.log('窗口大小变化，重新计算整体缩放');
-                scalePPTToFitWindow();
-            });
-            
-            // 监听屏幕方向变化（移动设备）
-            window.addEventListener('orientationchange', function() {
-                console.log('屏幕方向变化，重新计算整体缩放');
-                setTimeout(scalePPTToFitWindow, 100);
-            });
-        </script>
-    </body>
-    </html>
+    </div>
+</body>
+</html>
   `;
-};
+}
 
-// 公开访问PPT页面 - 返回HTML页面
+// Publicly access PPT page - return HTML page
 router.get('/view/:userId/:pptId/:slideIndex?', async (req, res, next) => {
   try {
     const { userId, pptId, slideIndex = 0 } = req.params;
     const querySlideIndex = req.query.slide ? parseInt(req.query.slide) : parseInt(slideIndex);
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
 
     let pptData = null;
     
-    // 如果是GitHub服务，尝试所有仓库
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
-        try {
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
-            pptData = result.content;
-            break;
-          }
-        } catch (error) {
-          continue;
+    // Try all GitHub repositories
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      try {
+        const result = await githubService.getFile(userId, fileName, i);
+        if (result) {
+          pptData = result.content;
+          break;
         }
-      }
-    } else {
-      // 内存存储服务
-      const result = await storageService.getFile(userId, fileName);
-      if (result) {
-        pptData = result.content;
+      } catch (error) {
+        continue;
       }
     }
 
     if (!pptData) {
-      return res.status(404).send(`
-        <!DOCTYPE html>
-        <html lang="zh-CN">
-        <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>PPT未找到</title>
-            <style>
-                body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
-                .error { color: #e74c3c; font-size: 18px; }
-            </style>
-        </head>
-        <body>
-            <div class="error">
-                <h2>PPT未找到</h2>
-                <p>请检查链接是否正确</p>
-            </div>
-        </body>
-        </html>
-      `);
+      return res.status(404).send(generateErrorPage('PPT Not Found', 'Please check if the link is correct'));
     }
 
     const slideIdx = querySlideIndex;
     if (slideIdx >= pptData.slides.length || slideIdx < 0) {
-      return res.status(404).send(`
-        <!DOCTYPE html>
-        <html lang="zh-CN">
-        <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-            <title>幻灯片未找到</title>
-            <style>
-                body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
-                .error { color: #e74c3c; font-size: 18px; }
-            </style>
-        </head>
-        <body>
-            <div class="error">
-                <h2>幻灯片未找到</h2>
-                <p>请检查幻灯片索引是否正确</p>
-            </div>
-        </body>
-        </html>
-      `);
+      return res.status(404).send(generateErrorPage('Slide Not Found', 'Please check if the slide index is correct'));
     }
 
-    // 返回HTML页面
-    const htmlContent = generateSlideHTML(pptData, slideIdx, pptData.title);
+    // 使用共享模块生成HTML
+    const htmlContent = generateSlideHTML(pptData, slideIdx, { format: 'view' });
     res.setHeader('Content-Type', 'text/html; charset=utf-8');
     res.send(htmlContent);
   } catch (error) {
@@ -568,33 +110,24 @@ router.get('/view/:userId/:pptId/:slideIndex?', async (req, res, next) => {
   }
 });
 
-// API接口：获取PPT数据和指定幻灯片（JSON格式）
+// API endpoint: Get PPT data and specified slide (JSON format)
 router.get('/api-view/:userId/:pptId/:slideIndex?', async (req, res, next) => {
   try {
     const { userId, pptId, slideIndex = 0 } = req.params;
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
 
     let pptData = null;
     
-    // 如果是GitHub服务，尝试所有仓库
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
-        try {
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
-            pptData = result.content;
-            break;
-          }
-        } catch (error) {
-          continue;
+    // Try all GitHub repositories
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      try {
+        const result = await githubService.getFile(userId, fileName, i);
+        if (result) {
+          pptData = result.content;
+          break;
         }
-      }
-    } else {
-      // 内存存储服务
-      const result = await storageService.getFile(userId, fileName);
-      if (result) {
-        pptData = result.content;
+      } catch (error) {
+        continue;
       }
     }
 
@@ -607,7 +140,7 @@ router.get('/api-view/:userId/:pptId/:slideIndex?', async (req, res, next) => {
       return res.status(404).json({ error: 'Slide not found' });
     }
 
-    // 返回PPT数据和指定幻灯片
+    // Return PPT data and specified slide
     res.json({
       id: pptData.id,
       title: pptData.title,
@@ -622,33 +155,24 @@ router.get('/api-view/:userId/:pptId/:slideIndex?', async (req, res, next) => {
   }
 });
 
-// 获取完整PPT数据（只读模式）
+// Get complete PPT data (read-only mode)
 router.get('/ppt/:userId/:pptId', async (req, res, next) => {
   try {
     const { userId, pptId } = req.params;
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
 
     let pptData = null;
     
-    // 如果是GitHub服务，尝试所有仓库
-    if (storageService === githubService && storageService.repositories) {
-      for (let i = 0; i < storageService.repositories.length; i++) {
-        try {
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
-            pptData = result.content;
-            break;
-          }
-        } catch (error) {
-          continue;
+    // Try all GitHub repositories
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      try {
+        const result = await githubService.getFile(userId, fileName, i);
+        if (result) {
+          pptData = result.content;
+          break;
         }
-      }
-    } else {
-      // 内存存储服务
-      const result = await storageService.getFile(userId, fileName);
-      if (result) {
-        pptData = result.content;
+      } catch (error) {
+        continue;
       }
     }
 
@@ -656,7 +180,7 @@ router.get('/ppt/:userId/:pptId', async (req, res, next) => {
       return res.status(404).json({ error: 'PPT not found' });
     }
 
-    // 返回只读版本的PPT数据
+    // Return read-only version of PPT data
     res.json({
       ...pptData,
       isPublicView: true,
@@ -667,7 +191,7 @@ router.get('/ppt/:userId/:pptId', async (req, res, next) => {
   }
 });
 
-// 生成PPT分享链接
+// Generate PPT share link
 router.post('/generate-share-link', async (req, res, next) => {
   try {
     const { userId, pptId, slideIndex = 0 } = req.body;
@@ -678,64 +202,26 @@ router.post('/generate-share-link', async (req, res, next) => {
 
     console.log(`Generating share link for PPT: ${pptId}, User: ${userId}`);
 
-    // 验证PPT是否存在
+    // Verify if PPT exists
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
     let pptExists = false;
     let pptData = null;
     
-    console.log(`Using storage service: ${storageService === githubService ? 'GitHub' : 'Memory'}`);
+    console.log(`Checking ${githubService.repositories.length} GitHub repositories...`);
     
-    // 如果是GitHub服务，尝试所有仓库
-    if (storageService === githubService && storageService.repositories) {
-      console.log(`Checking ${storageService.repositories.length} GitHub repositories...`);
-      
-      for (let i = 0; i < storageService.repositories.length; i++) {
-        try {
-          console.log(`Checking repository ${i}: ${storageService.repositories[i]}`);
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
-            pptExists = true;
-            pptData = result.content;
-            console.log(`PPT found in repository ${i}`);
-            break;
-          }
-        } catch (error) {
-          console.log(`PPT not found in repository ${i}: ${error.message}`);
-          continue;
-        }
-      }
-    } else {
-      // 内存存储服务
-      console.log('Checking memory storage...');
+    for (let i = 0; i < githubService.repositories.length; i++) {
       try {
-        const result = await storageService.getFile(userId, fileName);
+        console.log(`Checking repository ${i}: ${githubService.repositories[i]}`);
+        const result = await githubService.getFile(userId, fileName, i);
         if (result) {
           pptExists = true;
           pptData = result.content;
-          console.log('PPT found in memory storage');
+          console.log(`PPT found in repository ${i}`);
+          break;
         }
       } catch (error) {
-        console.log(`PPT not found in memory storage: ${error.message}`);
-      }
-    }
-
-    if (!pptExists) {
-      console.log('PPT not found in any storage location');
-      
-      // 额外尝试：如果GitHub失败，检查memory storage作为fallback
-      if (storageService === githubService) {
-        console.log('GitHub lookup failed, trying memory storage fallback...');
-        try {
-          const memoryResult = await memoryStorageService.getFile(userId, fileName);
-          if (memoryResult) {
-            pptExists = true;
-            pptData = memoryResult.content;
-            console.log('PPT found in memory storage fallback');
-          }
-        } catch (memoryError) {
-          console.log(`Memory storage fallback also failed: ${memoryError.message}`);
-        }
+        console.log(`PPT not found in repository ${i}: ${error.message}`);
+        continue;
       }
     }
 
@@ -743,7 +229,7 @@ router.post('/generate-share-link', async (req, res, next) => {
       return res.status(404).json({ 
         error: 'PPT not found',
         details: `PPT ${pptId} not found for user ${userId}`,
-        searchedLocations: storageService === githubService ? 'GitHub repositories and memory storage' : 'Memory storage only'
+        searchedLocations: 'GitHub repositories'
       });
     }
 
@@ -751,15 +237,15 @@ router.post('/generate-share-link', async (req, res, next) => {
     const protocol = process.env.NODE_ENV === 'production' ? 'https' : req.protocol;
     
     const shareLinks = {
-      // 单页分享链接
+      // Single page share link
       slideUrl: `${protocol}://${baseUrl}/api/public/view/${userId}/${pptId}/${slideIndex}`,
-      // 完整PPT分享链接
+      // Complete PPT share link
       pptUrl: `${protocol}://${baseUrl}/api/public/ppt/${userId}/${pptId}`,
-      // 前端查看链接
+      // Frontend view link
       viewUrl: `${protocol}://${baseUrl}/public/${userId}/${pptId}/${slideIndex}`,
-      // 新增：截图链接
+      // Screenshot link
       screenshotUrl: `${protocol}://${baseUrl}/api/public/screenshot/${userId}/${pptId}/${slideIndex}`,
-      // 添加PPT信息
+      // Add PPT information
       pptInfo: {
         id: pptId,
         title: pptData?.title || 'Unknown Title',
@@ -770,134 +256,253 @@ router.post('/generate-share-link', async (req, res, next) => {
     console.log('Share links generated successfully:', shareLinks);
     res.json(shareLinks);
   } catch (error) {
-    console.error('Share link generation error:', error);
     next(error);
   }
 });
 
-// 截图功能 - 返回JPEG图片
+// Screenshot endpoint - Frontend Export Strategy
 router.get('/screenshot/:userId/:pptId/:slideIndex?', async (req, res, next) => {
   try {
-    console.log('📸 Screenshot request received:', req.params);
-    
     const { userId, pptId, slideIndex = 0 } = req.params;
-    const slideIdx = parseInt(slideIndex);
+    const { format = 'jpeg', quality = 90, strategy = 'frontend-first', returnHtml = 'true' } = req.query;
+    
+    console.log(`Screenshot request: userId=${userId}, pptId=${pptId}, slideIndex=${slideIndex}, strategy=${strategy}, returnHtml=${returnHtml}`);
+    
+    // Get PPT data
     const fileName = `${pptId}.json`;
-    const storageService = getStorageService();
-
-    console.log(`🎯 Generating screenshot for: ${userId}/${pptId}/${slideIdx}`);
-
     let pptData = null;
     
-    // 获取PPT数据（复用现有逻辑）
-    if (storageService === githubService && storageService.repositories) {
-      console.log('📂 Checking GitHub repositories...');
-      for (let i = 0; i < storageService.repositories.length; i++) {
-        try {
-          const result = await storageService.getFile(userId, fileName, i);
-          if (result) {
-            pptData = result.content;
-            console.log(`✅ PPT data found in repository ${i}`);
-            break;
-          }
-        } catch (error) {
-          console.log(`❌ Repository ${i} check failed:`, error.message);
-          continue;
-        }
-      }
-    } else {
-      console.log('📂 Checking memory storage...');
+    // Try all GitHub repositories
+    for (let i = 0; i < githubService.repositories.length; i++) {
       try {
-        const result = await storageService.getFile(userId, fileName);
+        const result = await githubService.getFile(userId, fileName, i);
         if (result) {
           pptData = result.content;
-          console.log('✅ PPT data found in memory storage');
+          break;
         }
       } catch (error) {
-        console.log('❌ Memory storage check failed:', error.message);
+        continue;
       }
     }
 
-    // 如果GitHub失败，尝试内存存储fallback
-    if (!pptData && storageService === githubService) {
-      console.log('🔄 Trying memory storage fallback...');
+    if (!pptData) {
+      return res.status(404).json({ error: 'PPT not found' });
+    }
+
+    const slideIdx = parseInt(slideIndex);
+    if (slideIdx >= pptData.slides.length || slideIdx < 0) {
+      return res.status(404).json({ error: 'Invalid slide index' });
+    }
+
+    // Frontend Export Strategy - Return HTML page for client-side screenshot generation
+    if (strategy === 'frontend-first' && returnHtml !== 'false') {
+      console.log('Using frontend export strategy - returning HTML page');
+      
+      // 使用共享模块生成导出页面
+      const htmlPage = generateExportPage(pptData, slideIdx, {
+        format,
+        quality: parseInt(quality),
+        autoDownload: req.query.autoDownload === 'true'
+      });
+      
+      res.setHeader('Content-Type', 'text/html; charset=utf-8');
+      res.setHeader('X-Screenshot-Strategy', 'frontend-export');
+      res.setHeader('X-Generation-Time', '< 100ms');
+      return res.send(htmlPage);
+    }
+
+    // Fallback: Backend screenshot (if specifically requested)
+    console.log('Using backend screenshot for direct image return...');
+    
+    // 使用共享模块生成HTML用于后端截图
+    const htmlContent = generateSlideHTML(pptData, slideIdx, { format: 'screenshot' });
+    
+    try {
+      const screenshot = await screenshotService.generateScreenshot(htmlContent, {
+        format,
+        quality: parseInt(quality),
+        width: pptData.viewportSize || 1000,
+        height: Math.ceil((pptData.viewportSize || 1000) * (pptData.viewportRatio || 0.5625))
+      });
+      
+      res.setHeader('Content-Type', `image/${format}`);
+      res.setHeader('X-Screenshot-Type', 'backend-generated');
+      res.setHeader('X-Generation-Time', '2-5s');
+      res.send(screenshot);
+      
+    } catch (error) {
+      console.error('Backend screenshot failed:', error);
+      
+      // Generate fallback image
+      const fallbackImage = screenshotService.generateFallbackImage(
+        pptData.viewportSize || 1000, 
+        Math.ceil((pptData.viewportSize || 1000) * (pptData.viewportRatio || 0.5625))
+      );
+      
+      res.setHeader('Content-Type', `image/${format}`);
+      res.setHeader('X-Screenshot-Type', 'fallback-generated');
+      res.setHeader('X-Generation-Time', '< 50ms');
+      res.send(fallbackImage);
+    }
+    
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Image endpoint - Direct frontend export page
+router.get('/image/:userId/:pptId/:slideIndex?', async (req, res, next) => {
+  try {
+    const { userId, pptId, slideIndex = 0 } = req.params;
+    const { format = 'jpeg', quality = 90 } = req.query;
+    
+    console.log(`Image export request: userId=${userId}, pptId=${pptId}, slideIndex=${slideIndex}`);
+    
+    // Get PPT data
+    const fileName = `${pptId}.json`;
+    let pptData = null;
+    
+    for (let i = 0; i < githubService.repositories.length; i++) {
       try {
-        const memoryResult = await memoryStorageService.getFile(userId, fileName);
-        if (memoryResult) {
-          pptData = memoryResult.content;
-          console.log('✅ PPT data found in memory storage fallback');
+        const result = await githubService.getFile(userId, fileName, i);
+        if (result) {
+          pptData = result.content;
+          break;
         }
-      } catch (memoryError) {
-        console.log('❌ Memory storage fallback failed:', memoryError.message);
+      } catch (error) {
+        continue;
       }
     }
 
     if (!pptData) {
-      console.log('❌ PPT not found anywhere');
-      
-      // 生成"PPT未找到"的错误图片
-      const errorImage = screenshotService.generateFallbackImage(960, 720, 'PPT未找到');
-      res.setHeader('Content-Type', 'image/svg+xml');
-      res.setHeader('Cache-Control', 'no-cache');
-      return res.send(errorImage);
+      const errorPage = generateErrorPage('PPT Not Found', `PPT ${pptId} not found for user ${userId}`);
+      res.setHeader('Content-Type', 'text/html; charset=utf-8');
+      return res.status(404).send(errorPage);
     }
 
+    const slideIdx = parseInt(slideIndex);
     if (slideIdx >= pptData.slides.length || slideIdx < 0) {
-      console.log(`❌ Slide index out of bounds: ${slideIdx}/${pptData.slides.length}`);
-      
-      // 生成"幻灯片不存在"的错误图片
-      const errorImage = screenshotService.generateFallbackImage(960, 720, '幻灯片不存在');
-      res.setHeader('Content-Type', 'image/svg+xml');
-      res.setHeader('Cache-Control', 'no-cache');
-      return res.send(errorImage);
+      const errorPage = generateErrorPage('Invalid Slide', `Slide ${slideIndex} not found in PPT`);
+      res.setHeader('Content-Type', 'text/html; charset=utf-8');
+      return res.status(404).send(errorPage);
     }
 
-    console.log('📝 Generating HTML content...');
-    // 生成HTML内容（复用现有函数）
-    const htmlContent = generateSlideHTML(pptData, slideIdx, pptData.title);
-    
-    console.log('🎯 Calling screenshot service...');
-    // 生成截图
-    const screenshot = await screenshotService.generateScreenshot(htmlContent, {
-      format: 'jpeg',
-      quality: 90
+    // 使用共享模块生成导出页面
+    const htmlPage = generateExportPage(pptData, slideIdx, {
+      format,
+      quality: parseInt(quality),
+      autoDownload: true // Auto-generate and download
     });
     
-    console.log(`✅ Screenshot generated successfully, size: ${screenshot.length} bytes`);
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.setHeader('X-Screenshot-Strategy', 'frontend-export-page');
+    res.setHeader('X-Generation-Time', '< 50ms');
+    res.send(htmlPage);
     
-    // 检查是否是SVG fallback（通过内容检测）
-    const isSvgFallback = screenshot.toString().includes('<svg');
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Screenshot data endpoint - For frontend direct rendering
+router.get('/screenshot-data/:userId/:pptId/:slideIndex?', async (req, res, next) => {
+  try {
+    const { userId, pptId, slideIndex = 0 } = req.params;
+    const { format = 'jpeg', quality = 90 } = req.query;
+    
+    console.log(`Screenshot data request: userId=${userId}, pptId=${pptId}, slideIndex=${slideIndex}`);
     
-    if (isSvgFallback) {
-      console.log('📋 Returning SVG fallback image');
-      res.setHeader('Content-Type', 'image/svg+xml');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Content-Disposition', `inline; filename="${pptData.title}-${slideIdx + 1}-fallback.svg"`);
-    } else {
-      console.log('📸 Returning JPEG screenshot');
-      res.setHeader('Content-Type', 'image/jpeg');
-      res.setHeader('Cache-Control', 'public, max-age=300'); // 5分钟缓存
-      res.setHeader('Content-Disposition', `inline; filename="${pptData.title}-${slideIdx + 1}.jpg"`);
+    // Get PPT data
+    const fileName = `${pptId}.json`;
+    let pptData = null;
+    
+    for (let i = 0; i < githubService.repositories.length; i++) {
+      try {
+        const result = await githubService.getFile(userId, fileName, i);
+        if (result) {
+          pptData = result.content;
+          break;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+
+    if (!pptData) {
+      return res.status(404).json({ error: 'PPT not found' });
+    }
+
+    const slideIdx = parseInt(slideIndex);
+    if (slideIdx >= pptData.slides.length || slideIdx < 0) {
+      return res.status(404).json({ error: 'Invalid slide index' });
     }
+
+    // Return PPT data for frontend rendering
+    const responseData = {
+      pptData: {
+        id: pptData.id,
+        title: pptData.title,
+        theme: pptData.theme,
+        viewportSize: pptData.viewportSize,
+        viewportRatio: pptData.viewportRatio,
+        slide: pptData.slides[slideIdx]
+      },
+      slideIndex: slideIdx,
+      totalSlides: pptData.slides.length,
+      exportConfig: {
+        format,
+        quality: parseInt(quality),
+        width: pptData.viewportSize || 1000,
+        height: Math.ceil((pptData.viewportSize || 1000) * (pptData.viewportRatio || 0.5625))
+      },
+      strategy: 'frontend-direct-rendering',
+      timestamp: new Date().toISOString()
+    };
     
-    res.send(screenshot);
+    res.setHeader('X-Screenshot-Strategy', 'frontend-data-api');
+    res.json(responseData);
     
   } catch (error) {
-    console.error('❌ Screenshot route error:', error);
-    console.error('Stack trace:', error.stack);
-    
+    next(error);
+  }
+});
+
+// Screenshot health check
+router.get('/screenshot-health', async (req, res, next) => {
+  try {
+    const status = {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      environment: {
+        nodeEnv: process.env.NODE_ENV,
+        isHuggingFace: process.env.SPACE_ID ? true : false,
+        platform: process.platform
+      },
+      screenshotService: {
+        available: true,
+        strategy: 'frontend-first',
+        backendFallback: false, // Disable backend browsers
+        screenshotSize: 0
+      }
+    };
+
+    // Test fallback image generation
     try {
-      // 生成错误截图
-      const errorImage = screenshotService.generateFallbackImage(960, 720, '截图生成失败');
-      res.setHeader('Content-Type', 'image/svg+xml');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Content-Disposition', 'inline; filename="error.svg"');
-      res.send(errorImage);
-    } catch (responseError) {
-      console.error('❌ Error sending error response:', responseError);
-      // 如果连错误响应都发送失败，调用next
-      next(error);
+      const testImage = screenshotService.generateFallbackImage(100, 100);
+      status.screenshotService.screenshotSize = testImage.length;
+      status.screenshotService.fallbackAvailable = true;
+    } catch (error) {
+      status.screenshotService.fallbackAvailable = false;
+      status.screenshotService.fallbackError = error.message;
     }
+
+    res.json(status);
+  } catch (error) {
+    res.status(500).json({
+      status: 'error',
+      timestamp: new Date().toISOString(),
+      error: error.message
+    });
   }
 });
 

backend/src/services/githubService.js

@@ -1,39 +1,205 @@
 import axios from 'axios';
-import { GITHUB_CONFIG } from '../config/users.js';
-import memoryStorageService from './memoryStorageService.js';
 
 class GitHubService {
   constructor() {
-    this.apiUrl = GITHUB_CONFIG.apiUrl;
-    this.token = GITHUB_CONFIG.token;
-    this.repositories = GITHUB_CONFIG.repositories;
-    this.useMemoryStorage = !this.token; // 如果没有token，使用内存存储
+    // 延迟初始化，动态读取环境变量
+    this.initialized = false;
+    this.useMemoryStorage = false;
+    this.memoryStorage = new Map();
+    this.apiUrl = 'https://api.github.com';
     
+    // 首次使用时再初始化
+    this.initPromise = null;
+    
+    // 添加错误重试配置
+    this.retryConfig = {
+      maxRetries: 3,
+      retryDelay: 1000,
+      backoffMultiplier: 2
+    };
+    
+    // API限制处理
+    this.apiRateLimit = {
+      requestQueue: [],
+      processing: false,
+      minDelay: 100 // 最小请求间隔
+    };
+  }
+
+  // 动态初始化方法
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+
     console.log('=== GitHub Service Configuration ===');
-    console.log('Token configured:', !!this.token);
-    console.log('Token preview:', this.token ? `${this.token.substring(0, 8)}...` : 'Not set');
-    console.log('Repositories:', this.repositories);
-    console.log('Using memory storage:', this.useMemoryStorage);
     
-    if (!this.token) {
-      console.warn('GitHub token not configured, using memory storage for development');
+    try {
+      // 动态读取环境变量
+      this.token = process.env.GITHUB_TOKEN;
+      this.repositories = process.env.GITHUB_REPOS 
+        ? process.env.GITHUB_REPOS.split(',').map(repo => repo.trim())
+        : [];
+      
+      console.log('Token configured:', !!this.token);
+      console.log('Token preview:', this.token ? `${this.token.substring(0, 8)}...` : 'Not set');
+      console.log('Repositories:', this.repositories);
+      console.log('Repositories length:', this.repositories?.length || 0);
+      
+      // Check if token is a placeholder
+      if (!this.token || this.token === 'your_github_token_here') {
+        console.warn('❌ GitHub token is missing or using placeholder value!');
+        console.warn('⚠️ Switching to memory storage mode for development...');
+        this.useMemoryStorage = true;
+        console.log('✅ Memory storage mode activated');
+        this.initialized = true;
+        return;
+      }
+      
+      if (!this.repositories || this.repositories.length === 0) {
+        console.warn('❌ No GitHub repositories configured!');
+        console.warn('⚠️ Switching to memory storage mode...');
+        this.useMemoryStorage = true;
+        console.log('✅ Memory storage mode activated');
+        this.initialized = true;
+        return;
+      }
+
+      // Check for placeholder repository URLs
+      const validRepos = this.repositories.filter(repo => {
+        const isPlaceholder = repo.includes('your-username') || repo.includes('placeholder');
+        if (isPlaceholder) {
+          console.warn(`⚠️ Skipping placeholder repository: ${repo}`);
+          return false;
+        }
+        return this.isValidRepoUrl(repo);
+      });
+
+      if (validRepos.length === 0) {
+        console.warn('❌ No valid GitHub repositories found (all are placeholders)!');
+        console.warn('⚠️ Switching to memory storage mode...');
+        this.useMemoryStorage = true;
+        console.log('✅ Memory storage mode activated');
+        this.initialized = true;
+        return;
+      }
+
+      this.repositories = validRepos;
+
+      // 验证每个仓库URL的格式
+      this.repositories.forEach((repo, index) => {
+        if (!this.isValidRepoUrl(repo)) {
+          console.error(`❌ Invalid repository URL at index ${index}: ${repo}`);
+          throw new Error(`Invalid repository URL: ${repo}. Expected format: https://github.com/owner/repo`);
+        }
+      });
+      
+      console.log('✅ GitHub Service initialized successfully');
+      this.initialized = true;
+    } catch (error) {
+      console.error('❌ GitHub Service initialization failed:', error);
+      console.warn('⚠️ Falling back to memory storage mode...');
+      this.useMemoryStorage = true;
+      this.initialized = true;
+    }
+  }
+
+  // 确保在所有方法中先初始化
+  async ensureInitialized() {
+    if (!this.initPromise) {
+      this.initPromise = this.initialize();
+    }
+    await this.initPromise;
+  }
+
+  // 验证仓库URL格式
+  isValidRepoUrl(repoUrl) {
+    const githubUrlPattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/?$/;
+    return githubUrlPattern.test(repoUrl.trim());
+  }
+
+  // 带重试的API请求方法
+  async makeGitHubRequest(requestFn, operation = 'GitHub API request', maxRetries = null) {
+    const retries = maxRetries || this.retryConfig.maxRetries;
+    let lastError = null;
+    
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.retryConfig.retryDelay * Math.pow(this.retryConfig.backoffMultiplier, attempt - 1);
+          console.log(`🔄 Retrying ${operation} (attempt ${attempt + 1}/${retries + 1}) after ${delay}ms...`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        
+        const result = await requestFn();
+        
+        if (attempt > 0) {
+          console.log(`✅ ${operation} succeeded on retry attempt ${attempt + 1}`);
+        }
+        
+        return result;
+      } catch (error) {
+        lastError = error;
+        
+        // 判断是否应该重试
+        if (!this.shouldRetry(error) || attempt === retries) {
+          break;
+        }
+        
+        console.warn(`⚠️ ${operation} failed (attempt ${attempt + 1}):`, error.message);
+      }
+    }
+    
+    console.error(`❌ ${operation} failed after ${retries + 1} attempts:`, lastError.message);
+    throw lastError;
+  }
+
+  // 判断错误是否应该重试
+  shouldRetry(error) {
+    if (!error.response) {
+      return true; // 网络错误，重试
+    }
+    
+    const status = error.response.status;
+    
+    // 这些状态码不应该重试
+    if ([400, 401, 403, 404, 422].includes(status)) {
+      return false;
     }
+    
+    // 5xx错误和429限制错误应该重试
+    if (status >= 500 || status === 429) {
+      return true;
+    }
+    
+    return false;
   }
 
   // 验证GitHub连接
   async validateConnection() {
+    await this.ensureInitialized();
+    
     if (this.useMemoryStorage) {
-      return { valid: false, reason: 'No GitHub token configured' };
+      console.log('📝 Memory storage mode active');
+      return { 
+        valid: true, 
+        useMemoryStorage: true,
+        repositories: [],
+        message: 'Using memory storage mode for development'
+      };
     }
 
     try {
       // 测试GitHub API连接
-      const response = await axios.get(`${this.apiUrl}/user`, {
-        headers: {
-          'Authorization': `token ${this.token}`,
-          'Accept': 'application/vnd.github.v3+json'
-        }
-      });
+      const response = await this.makeGitHubRequest(async () => {
+        return await axios.get(`${this.apiUrl}/user`, {
+          headers: {
+            'Authorization': `token ${this.token}`,
+            'Accept': 'application/vnd.github.v3+json'
+          },
+          timeout: 30000
+        });
+      }, 'GitHub user authentication');
       
       console.log('GitHub API connection successful:', response.data.login);
       
@@ -44,12 +210,15 @@ class GitHubService {
           const { owner, repo } = this.parseRepoUrl(repoUrl);
           
           // 检查仓库基本信息
-          const repoResponse = await axios.get(`${this.apiUrl}/repos/${owner}/${repo}`, {
-            headers: {
-              'Authorization': `token ${this.token}`,
-              'Accept': 'application/vnd.github.v3+json'
-            }
-          });
+          const repoResponse = await this.makeGitHubRequest(async () => {
+            return await axios.get(`${this.apiUrl}/repos/${owner}/${repo}`, {
+              headers: {
+                'Authorization': `token ${this.token}`,
+                'Accept': 'application/vnd.github.v3+json'
+              },
+              timeout: 30000
+            });
+          }, `Repository access check for ${owner}/${repo}`);
           
           // 检查权限
           const permissions = repoResponse.data.permissions;
@@ -63,7 +232,8 @@ class GitHubService {
               headers: {
                 'Authorization': `token ${this.token}`,
                 'Accept': 'application/vnd.github.v3+json'
-              }
+              },
+              timeout: 15000
             });
             canAccessContents = true;
           } catch (contentsError) {
@@ -108,403 +278,1140 @@ class GitHubService {
 
   // 初始化空仓库
   async initializeRepository(repoIndex = 0) {
+    await this.ensureInitialized();
+    
     if (this.useMemoryStorage) {
-      return { success: false, reason: 'Using memory storage' };
+      console.log('📝 Memory storage mode - no repository initialization needed');
+      return { success: true, message: 'Memory storage initialized' };
     }
 
+    const repoUrl = this.repositories[repoIndex];
+    const { owner, repo } = this.parseRepoUrl(repoUrl);
+    
     try {
-      const repoUrl = this.repositories[repoIndex];
-      const { owner, repo } = this.parseRepoUrl(repoUrl);
-      
-      console.log(`Initializing empty repository: ${owner}/${repo}`);
+      console.log(`🚀 Initializing repository: ${owner}/${repo}`);
       
       // 创建初始README文件
-      const readmeContent = Buffer.from(`# PPTist Data Repository
+      const readmeContent = `# PPT Storage Repository\n\nThis repository is used to store PPT data files.\n\nCreated: ${new Date().toISOString()}`;
+      const content = Buffer.from(readmeContent).toString('base64');
+      
+      await this.makeGitHubRequest(async () => {
+        return await axios.put(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/README.md`,
+          {
+            message: 'Initialize PPT storage repository',
+            content: content
+          },
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
+          }
+        );
+      }, `Repository initialization for ${owner}/${repo}`);
+      
+      console.log(`✅ Repository ${owner}/${repo} initialized successfully`);
+      return { success: true, message: 'Repository initialized' };
+    } catch (error) {
+      console.error(`❌ Repository initialization failed:`, error);
+      throw new Error(`Failed to initialize repository: ${error.message}`);
+    }
+  }
+
+  // 兼容性方法：旧的getFile方法重定向到新的getPPT
+  async getFile(userId, fileName, repoIndex = 0) {
+    await this.ensureInitialized();
+    
+    const pptId = fileName.replace('.json', '');
+    return await this.getPPT(userId, pptId, repoIndex);
+  }
 
-This repository stores PPT data for the PPTist application.
+  // 兼容性方法：旧的saveFile方法重定向到新的savePPT
+  async saveFile(userId, fileName, data, repoIndex = 0) {
+    await this.ensureInitialized();
+    
+    const pptId = fileName.replace('.json', '');
+    return await this.savePPT(userId, pptId, data, repoIndex);
+  }
 
-## Structure
+  // 数据格式标准化
+  normalizeDataFormat(data) {
+    if (!data || typeof data !== 'object') {
+      throw new Error('Invalid data format provided');
+    }
 
-\`\`\`
-users/
-├── PS01/
-│   ├── README.md
-│   └── *.json (PPT files)
-├── PS02/
-│   ├── README.md
-│   └── *.json (PPT files)
-└── ...
-\`\`\`
+    const normalized = {
+      id: data.id || data.pptId || `ppt-${Date.now()}`,
+      title: data.title || '未命名演示文稿',
+      slides: Array.isArray(data.slides) ? data.slides : [],
+      theme: data.theme || {
+        backgroundColor: '#ffffff',
+        themeColor: '#d14424',
+        fontColor: '#333333',
+        fontName: 'Microsoft YaHei'
+      },
+      viewportSize: data.viewportSize || 1000,
+      viewportRatio: data.viewportRatio || 0.5625,
+      createdAt: data.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
 
-## Auto-generated
+    // 标准化slides数据
+    normalized.slides = normalized.slides.map((slide, index) => {
+      if (!slide || typeof slide !== 'object') {
+        return {
+          id: `slide-${index}`,
+          elements: [],
+          background: { type: 'solid', color: '#ffffff' }
+        };
+      }
 
-This repository is automatically managed by PPTist Huggingface Space.
-Do not manually edit files unless you know what you're doing.
-`).toString('base64');
+      return {
+        id: slide.id || `slide-${index}`,
+        elements: Array.isArray(slide.elements) ? slide.elements : [],
+        background: slide.background || { type: 'solid', color: '#ffffff' },
+        ...slide
+      };
+    });
 
-      const response = await axios.put(
-        `${this.apiUrl}/repos/${owner}/${repo}/contents/README.md`,
-        {
-          message: 'Initialize repository for PPTist data storage',
-          content: readmeContent,
-          branch: 'main'
-        },
-        {
-          headers: {
-            'Authorization': `token ${this.token}`,
-            'Accept': 'application/vnd.github.v3+json'
+    // 保留原始数据的其他字段
+    Object.keys(data).forEach(key => {
+      if (!normalized.hasOwnProperty(key) && key !== 'slides') {
+        normalized[key] = data[key];
+      }
+    });
+
+    return normalized;
+  }
+
+  // 兼容性：旧的deleteFile方法
+  async deleteFile(userId, fileName, repoIndex = 0) {
+    await this.ensureInitialized();
+    
+    if (this.useMemoryStorage) {
+      const key = `users/${userId}/${fileName}`;
+      return this.memoryStorage.delete(key);
+    }
+
+    const repoUrl = this.repositories[repoIndex];
+    const { owner, repo } = this.parseRepoUrl(repoUrl);
+    const path = `users/${userId}/${fileName}`;
+
+    try {
+      // 获取文件信息
+      const response = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
           }
-        }
-      );
+        );
+      }, `Get file info for deletion: ${fileName}`);
+
+      // 删除主文件
+      await this.makeGitHubRequest(async () => {
+        return await axios.delete(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
+          {
+            data: {
+              message: `Delete legacy PPT: ${fileName}`,
+              sha: response.data.sha
+            },
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
+          }
+        );
+      }, `Delete legacy file: ${fileName}`);
 
-      console.log(`Repository initialized successfully: ${response.data.commit.sha}`);
-      return { success: true, commit: response.data.commit.sha };
+      console.log(`✅ Legacy file deleted: ${fileName}`);
+      return true;
     } catch (error) {
-      console.error('Repository initialization failed:', error.response?.data || error.message);
-      return { success: false, error: error.message };
+      if (error.response?.status === 404) {
+        console.log(`📄 File not found: ${fileName}`);
+        return false;
+      }
+      console.error(`❌ Delete failed for ${fileName}:`, error);
+      throw new Error(`Failed to delete file: ${error.message}`);
     }
   }
 
-  // 获取文件内容
-  async getFile(userId, fileName, repoIndex = 0) {
-    // 如果使用内存存储
+  // Memory storage methods - 兼容性方法
+  async saveToMemory(userId, fileName, data) {
+    const pptId = fileName.replace('.json', '');
+    return await this.savePPTToMemory(userId, pptId, data);
+  }
+
+  async getFromMemory(userId, fileName) {
+    const pptId = fileName.replace('.json', '');
+    const result = await this.getPPTFromMemory(userId, pptId);
+    return result ? result.content : null;
+  }
+
+  // 新架构：获取PPT（文件夹模式） - 简化版本
+  async getPPT(userId, pptId, repoIndex = 0) {
+    await this.ensureInitialized();
+    
     if (this.useMemoryStorage) {
-      return await memoryStorageService.getFile(userId, fileName);
+      return await this.getPPTFromMemory(userId, pptId);
     }
 
-    // 原有的GitHub逻辑
     try {
+      console.log(`📂 Getting PPT folder: ${pptId} for user: ${userId}`);
+      
       const repoUrl = this.repositories[repoIndex];
       const { owner, repo } = this.parseRepoUrl(repoUrl);
-      const path = `users/${userId}/${fileName}`;
+      const pptFolderPath = `users/${userId}/${pptId}`;
 
-      const response = await axios.get(
-        `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
-        {
-          headers: {
-            'Authorization': `token ${this.token}`,
-            'Accept': 'application/vnd.github.v3+json'
+      // 1. 获取PPT文件夹内容 - 带重试
+      const folderResponse = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${pptFolderPath}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
           }
-        }
+        );
+      }, `Get PPT folder contents for ${pptId}`);
+
+      // 2. 读取元数据文件
+      const metaFile = folderResponse.data.find(file => file.name === 'meta.json');
+      if (!metaFile) {
+        throw new Error('PPT metadata file not found');
+      }
+
+      const metaResponse = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${metaFile.path}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 15000
+          }
+        );
+      }, `Get PPT metadata for ${pptId}`);
+
+      let metadata;
+      try {
+        const metaContent = Buffer.from(metaResponse.data.content, 'base64').toString('utf8');
+        metadata = JSON.parse(metaContent);
+      } catch (parseError) {
+        console.error('❌ Failed to parse metadata:', parseError);
+        throw new Error('Invalid PPT metadata format');
+      }
+
+      // 3. 加载所有slide文件
+      const allFiles = folderResponse.data;
+      const slides = [];
+      const failedSlides = [];
+      
+      // 查找slide文件（只处理普通文件，忽略拆分文件）
+      const slideFiles = allFiles.filter(file => 
+        file.name.startsWith('slide_') && 
+        file.name.endsWith('.json') && 
+        !file.name.includes('_main') && 
+        !file.name.includes('_part_')
       );
 
-      const content = Buffer.from(response.data.content, 'base64').toString('utf8');
-      return {
-        content: JSON.parse(content),
-        sha: response.data.sha
+      // 按序号排序
+      const sortedSlideFiles = slideFiles.sort((a, b) => {
+        const aIndex = parseInt(a.name.match(/slide_(\d+)\.json/)?.[1] || '0');
+        const bIndex = parseInt(b.name.match(/slide_(\d+)\.json/)?.[1] || '0');
+        return aIndex - bIndex;
+      });
+
+      for (const slideFile of sortedSlideFiles) {
+        try {
+          const slide = await this.loadSlideFile(slideFile, repoIndex);
+          const slideIndex = parseInt(slideFile.name.match(/slide_(\d+)\.json/)?.[1] || '0');
+          slides[slideIndex] = slide;
+        } catch (slideError) {
+          console.warn(`⚠️ Failed to load slide ${slideFile.name}:`, slideError.message);
+          failedSlides.push(slideFile.name);
+        }
+      }
+
+      // 4. 组装完整PPT数据
+      const finalSlides = slides.filter(slide => slide !== undefined);
+      const pptData = {
+        ...metadata,
+        slides: finalSlides,
+        storage: {
+          type: 'folder',
+          slidesCount: finalSlides.length,
+          folderPath: pptFolderPath,
+          loadedAt: new Date().toISOString(),
+          failedSlides: failedSlides.length > 0 ? failedSlides : undefined
+        }
       };
+
+      if (failedSlides.length > 0) {
+        console.warn(`⚠️ PPT loaded with ${failedSlides.length} failed slides`);
+      } else {
+        console.log(`✅ PPT loaded successfully: ${finalSlides.length} slides`);
+      }
+      
+      return { content: pptData };
+
     } catch (error) {
       if (error.response?.status === 404) {
+        console.log(`📄 PPT folder not found: ${pptId}`);
         return null;
       }
-      throw error;
+      console.error(`❌ Get PPT failed:`, error);
+      throw new Error(`Failed to get PPT: ${error.message}`);
     }
   }
 
-  // 保存文件
-  async saveFile(userId, fileName, data, repoIndex = 0) {
-    // 如果使用内存存储
-    if (this.useMemoryStorage) {
-      return await memoryStorageService.saveFile(userId, fileName, data);
-    }
-
-    // 原有的GitHub逻辑
+  // 新增：检查文件大小
+  async checkFileSize(filePath, repoIndex) {
     const repoUrl = this.repositories[repoIndex];
     const { owner, repo } = this.parseRepoUrl(repoUrl);
-    const path = `users/${userId}/${fileName}`;
-
-    console.log(`Attempting to save file: ${path} to repo: ${owner}/${repo}`);
-
-    // 先尝试获取现有文件的SHA
-    let sha = null;
+    
     try {
-      const existing = await this.getFile(userId, fileName, repoIndex);
-      if (existing) {
-        sha = existing.sha;
-        console.log(`Found existing file with SHA: ${sha}`);
-      }
+      const response = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${filePath}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 15000
+          }
+        );
+      }, `Check file size for ${filePath}`);
+      
+      return {
+        size: response.data.size,
+        sha: response.data.sha
+      };
     } catch (error) {
-      console.log(`No existing file found: ${error.message}`);
+      if (error.response?.status === 404) {
+        return null;
+      }
+      throw error;
     }
+  }
 
-    const content = Buffer.from(JSON.stringify(data, null, 2)).toString('base64');
-
-    const payload = {
-      message: `${sha ? 'Update' : 'Create'} ${fileName} for user ${userId}`,
-      content: content,
-      branch: 'main'
-    };
-
-    if (sha) {
-      payload.sha = sha;
+  // 新增：智能读取文件内容（根据大小选择策略）
+  async readFileContent(filePath, repoIndex, maxDirectSize = 1024 * 1024) { // 1MB限制
+    const fileInfo = await this.checkFileSize(filePath, repoIndex);
+    
+    if (!fileInfo) {
+      return null;
+    }
+    
+    // 如果文件小于限制，直接读取
+    if (fileInfo.size <= maxDirectSize) {
+      return await this.readFileContentDirect(filePath, repoIndex);
     }
+    
+    // 大文件：使用Git Blob API读取
+    console.log(`📊 Large file detected (${(fileInfo.size / 1024 / 1024).toFixed(2)} MB), using blob API`);
+    return await this.readFileContentViaBlob(filePath, fileInfo.sha, repoIndex);
+  }
 
-    try {
-      console.log(`Saving to GitHub: ${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`);
-      
-      const response = await axios.put(
-        `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
-        payload,
+  // 直接读取文件（小文件）
+  async readFileContentDirect(filePath, repoIndex) {
+    const repoUrl = this.repositories[repoIndex];
+    const { owner, repo } = this.parseRepoUrl(repoUrl);
+    
+    const response = await this.makeGitHubRequest(async () => {
+      return await axios.get(
+        `${this.apiUrl}/repos/${owner}/${repo}/contents/${filePath}`,
         {
           headers: {
             'Authorization': `token ${this.token}`,
             'Accept': 'application/vnd.github.v3+json'
-          }
+          },
+          timeout: 30000
         }
       );
+    }, `Read file content directly: ${filePath}`);
+    
+    const content = Buffer.from(response.data.content, 'base64').toString('utf8');
+    return JSON.parse(content);
+  }
 
-      console.log(`Successfully saved to GitHub: ${response.data.commit.sha}`);
-      return response.data;
-    } catch (error) {
-      console.error(`GitHub save failed:`, error.response?.data || error.message);
+  // 通过Git Blob API读取大文件
+  async readFileContentViaBlob(filePath, sha, repoIndex) {
+    const repoUrl = this.repositories[repoIndex];
+    const { owner, repo } = this.parseRepoUrl(repoUrl);
+    
+    try {
+      console.log(`🔍 Reading large file via blob API: ${filePath}`);
       
-      // 特殊处理空仓库的情况
-      if (error.response?.status === 409 && error.response?.data?.message?.includes('empty')) {
-        console.log('Repository is empty, initializing...');
-        const initResult = await this.initializeRepository(repoIndex);
-        
-        if (initResult.success) {
-          console.log('Repository initialized, retrying save...');
-          // 等待一会儿让GitHub同步
-          await new Promise(resolve => setTimeout(resolve, 2000));
-          
-          // 继续执行原来的目录创建逻辑
-          return this.saveFileWithDirectoryCreation(userId, fileName, data, repoIndex, payload);
-        }
-      }
+      const response = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/git/blobs/${sha}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 120000 // 2分钟超时
+          }
+        );
+      }, `Read blob for large file: ${filePath}`);
       
-      // 详细的错误处理
-      if (error.response?.status === 404) {
-        return this.saveFileWithDirectoryCreation(userId, fileName, data, repoIndex, payload);
-      } else if (error.response?.status === 403) {
-        throw new Error(`GitHub permission denied. Check if the token has 'repo' permissions: ${error.response.data.message}`);
+      if (response.data.encoding === 'base64') {
+        const content = Buffer.from(response.data.content, 'base64').toString('utf8');
+        return JSON.parse(content);
       } else {
-        throw new Error(`GitHub API error (${error.response?.status}): ${error.response?.data?.message || error.message}`);
+        // 如果不是base64编码，直接解析
+        return JSON.parse(response.data.content);
       }
+    } catch (error) {
+      console.error(`❌ Blob API read failed for ${filePath}:`, error.message);
+      
+      // 回退到分批读取策略
+      console.log(`🔄 Falling back to chunked reading...`);
+      return await this.readLargeFileInChunks(filePath, repoIndex);
     }
   }
 
-  // 带目录创建的保存文件方法
-  async saveFileWithDirectoryCreation(userId, fileName, data, repoIndex, payload) {
-    const repoUrl = this.repositories[repoIndex];
-    const { owner, repo } = this.parseRepoUrl(repoUrl);
-    const path = `users/${userId}/${fileName}`;
+  // 分批读取大文件（最后的回退策略）
+  async readLargeFileInChunks(filePath, repoIndex) {
+    console.log(`📦 Attempting chunked read for: ${filePath}`);
     
-    console.log('404 error - attempting to create directory structure...');
+    // 检查是否存在分块文件（PPT文件夹结构）
+    const folderPath = filePath.replace(/\/[^\/]+$/, '');
     
     try {
-      // 方法1: 先检查仓库是否存在和可访问
-      const repoCheckResponse = await axios.get(`${this.apiUrl}/repos/${owner}/${repo}`, {
-        headers: {
-          'Authorization': `token ${this.token}`,
-          'Accept': 'application/vnd.github.v3+json'
-        }
-      });
-      console.log(`Repository exists: ${repoCheckResponse.data.full_name}`);
+      const repoUrl = this.repositories[repoIndex];
+      const { owner, repo } = this.parseRepoUrl(repoUrl);
       
-      // 方法2: 检查users目录是否存在
-      try {
-        await axios.get(`${this.apiUrl}/repos/${owner}/${repo}/contents/users`, {
-          headers: {
-            'Authorization': `token ${this.token}`,
-            'Accept': 'application/vnd.github.v3+json'
-          }
-        });
-        console.log('Users directory exists');
-      } catch (usersDirError) {
-        console.log('Users directory does not exist, creating...');
-        
-        // 创建users目录的README
-        const usersReadmePath = 'users/README.md';
-        const usersReadmeContent = Buffer.from('# Users Directory\n\nThis directory contains user-specific PPT files.\n').toString('base64');
-        
-        await axios.put(
-          `${this.apiUrl}/repos/${owner}/${repo}/contents/${usersReadmePath}`,
-          {
-            message: 'Create users directory',
-            content: usersReadmeContent,
-            branch: 'main'
-          },
+      // 尝试读取文件夹内容
+      const folderResponse = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${folderPath}`,
           {
             headers: {
               'Authorization': `token ${this.token}`,
               'Accept': 'application/vnd.github.v3+json'
-            }
+            },
+            timeout: 30000
           }
         );
-        console.log('Users directory created');
+      }, `Read folder for chunked file: ${folderPath}`);
+      
+      // 查找相关的分块文件
+      const chunkFiles = folderResponse.data.filter(file => 
+        file.name.includes('_part_') || file.name.includes('_chunk_')
+      );
+      
+      if (chunkFiles.length > 0) {
+        console.log(`📊 Found ${chunkFiles.length} chunk files, reassembling...`);
+        return await this.reassembleChunkedFiles(chunkFiles, repoIndex);
       }
       
-      // 方法3: 检查用户目录是否存在
+      throw new Error('No chunked files found, cannot read large file');
+    } catch (error) {
+      console.error(`❌ Chunked read failed:`, error.message);
+      throw new Error(`Unable to read large file: ${filePath}. File may be too large for current GitHub API limits.`);
+    }
+  }
+
+  // 重组分块文件
+  async reassembleChunkedFiles(chunkFiles, repoIndex) {
+    const chunks = [];
+    
+    // 按顺序读取所有分块
+    const sortedChunks = chunkFiles.sort((a, b) => {
+      const aIndex = parseInt(a.name.match(/_(\d+)(?:_|\.)/)?.[1] || '0');
+      const bIndex = parseInt(b.name.match(/_(\d+)(?:_|\.)/)?.[1] || '0');
+      return aIndex - bIndex;
+    });
+    
+    for (const chunkFile of sortedChunks) {
       try {
-        await axios.get(`${this.apiUrl}/repos/${owner}/${repo}/contents/users/${userId}`, {
-          headers: {
-            'Authorization': `token ${this.token}`,
-            'Accept': 'application/vnd.github.v3+json'
-          }
-        });
-        console.log(`User directory exists: users/${userId}`);
-      } catch (userDirError) {
-        console.log(`User directory does not exist, creating: users/${userId}`);
+        const chunkContent = await this.readFileContentDirect(chunkFile.path, repoIndex);
+        chunks.push(chunkContent);
+      } catch (error) {
+        console.error(`⚠️ Failed to read chunk ${chunkFile.name}:`, error.message);
+      }
+    }
+    
+    // 重组数据
+    if (chunks.length === 0) {
+      throw new Error('No valid chunks found');
+    }
+    
+    // 假设第一个chunk包含基础结构
+    const baseData = chunks[0];
+    const allSlides = [];
+    
+    chunks.forEach(chunk => {
+      if (chunk.slides && Array.isArray(chunk.slides)) {
+        allSlides.push(...chunk.slides);
+      }
+    });
+    
+    return {
+      ...baseData,
+      slides: allSlides,
+      storage: {
+        type: 'reassembled',
+        chunksCount: chunks.length,
+        reassembledAt: new Date().toISOString()
+      }
+    };
+  }
+
+  // 修改现有的loadSlideFile方法，使用新的智能读取
+  async loadSlideFile(slideFile, repoIndex) {
+    try {
+      // 使用智能读取策略
+      const slideContent = await this.readFileContent(slideFile.path, repoIndex);
+      return slideContent;
+    } catch (error) {
+      console.error(`❌ Failed to load slide file ${slideFile.name}:`, error.message);
+      throw error;
+    }
+  }
+
+  // slide压缩算法 - 保留轻量压缩
+  async compressSlide(slide) {
+    let compressedSlide = JSON.parse(JSON.stringify(slide)); // 深拷贝
+    
+    // 压缩策略1：移除不必要的属性
+    if (compressedSlide.elements) {
+      compressedSlide.elements = compressedSlide.elements.map(element => {
+        // 移除编辑状态属性
+        element = this.removeUnnecessaryProps(element);
         
-        // 创建用户目录的README
-        const userReadmePath = `users/${userId}/README.md`;
-        const userReadmeContent = Buffer.from(`# PPT Files for User ${userId}\n\nThis directory contains PPT files for user ${userId}.\n`).toString('base64');
+        // 压缩文本内容（移除多余空白）
+        if (element.type === 'text' && element.content && typeof element.content === 'string') {
+          element.content = element.content.replace(/\s+/g, ' ').trim();
+        }
         
-        await axios.put(
-          `${this.apiUrl}/repos/${owner}/${repo}/contents/${userReadmePath}`,
-          {
-            message: `Create user directory for ${userId}`,
-            content: userReadmeContent,
-            branch: 'main'
-          },
+        return element;
+      });
+    }
+
+    // 压缩策略2：精简数值���度
+    compressedSlide = this.roundNumericValues(compressedSlide);
+
+    const compressedSize = Buffer.byteLength(JSON.stringify(compressedSlide), 'utf8');
+    console.log(`🗜️ Light compression applied: ${(compressedSize / 1024).toFixed(2)} KB`);
+
+    return compressedSlide;
+  }
+
+  // 移除不必要的属性
+  removeUnnecessaryProps(element) {
+    const unnecessaryProps = [
+      'selected', 'editing', 'dragData', 'resizeData', 
+      'tempData', 'cache', 'debug'
+    ];
+    
+    unnecessaryProps.forEach(prop => {
+      if (element[prop] !== undefined) {
+        delete element[prop];
+      }
+    });
+
+    return element;
+  }
+
+  // 精简数值精度 - 保持高精度的关键属性
+  roundNumericValues(obj, precision = 2) {
+    if (typeof obj !== 'object' || obj === null) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.roundNumericValues(item, precision));
+    }
+
+    const rounded = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'number') {
+        // 🎯 关键布局属性保持高精度
+        if (['left', 'top', 'width', 'height', 'x', 'y', 'viewportRatio', 'viewportSize'].includes(key)) {
+          rounded[key] = Math.round(value * 1000000000) / 1000000000; // 9位精度
+        } 
+        // 🎯 变换和旋转属性保持高精度
+        else if (key.includes('transform') || key.includes('rotate') || key === 'rotate') {
+          rounded[key] = Math.round(value * 1000000000) / 1000000000;
+        }
+        // 📐 其他数值属性适度精简
+        else {
+          rounded[key] = typeof value === 'number' && !isNaN(value) && isFinite(value)
+            ? Math.round(value * 1000000) / 1000000 // 6位精度
+            : value;
+        }
+      } else if (typeof value === 'object') {
+        rounded[key] = this.roundNumericValues(value, precision);
+      } else {
+        rounded[key] = value;
+      }
+    }
+
+    return rounded;
+  }
+
+  // 通用文件保存到仓库 - 简化版本
+  async saveFileToRepo(filePath, data, commitMessage, repoIndex) {
+    const repoUrl = this.repositories[repoIndex];
+    const { owner, repo } = this.parseRepoUrl(repoUrl);
+    
+    try {
+      // 验证数据
+      if (!data || typeof data !== 'object') {
+        throw new Error('Invalid data provided for file save');
+      }
+
+      const content = Buffer.from(JSON.stringify(data)).toString('base64');
+      const fileSize = Buffer.byteLength(JSON.stringify(data), 'utf8');
+      
+      // 检查文件大小（GitHub限制100MB）
+      if (fileSize > 100 * 1024 * 1024) {
+        throw new Error(`File too large: ${(fileSize / 1024 / 1024).toFixed(2)} MB exceeds GitHub's 100MB limit`);
+      }
+      
+      console.log(`💾 Saving file: ${filePath} (${(fileSize / 1024).toFixed(2)} KB)`);
+      
+      // 检查文件是否已存在
+      let sha = null;
+      try {
+        const existingResponse = await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${filePath}`,
           {
             headers: {
               'Authorization': `token ${this.token}`,
               'Accept': 'application/vnd.github.v3+json'
-            }
+            },
+            timeout: 30000
           }
         );
-        console.log(`User directory created: users/${userId}`);
+        sha = existingResponse.data.sha;
+      } catch (error) {
+        // 文件不存在，将创建新文件
       }
-      
-      // 等待一小会儿让GitHub同步
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      
-      // 重试保存PPT文件
-      console.log('Retrying PPT file save...');
-      const retryResponse = await axios.put(
-        `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
-        payload,
+
+      // 保存文件
+      const response = await axios.put(
+        `${this.apiUrl}/repos/${owner}/${repo}/contents/${filePath}`,
+        {
+          message: commitMessage,
+          content: content,
+          ...(sha && { sha })
+        },
         {
           headers: {
             'Authorization': `token ${this.token}`,
             'Accept': 'application/vnd.github.v3+json'
-          }
+          },
+          timeout: 60000
         }
       );
+
+      console.log(`✅ File saved successfully: ${filePath}`);
+      return response.data;
+    } catch (error) {
+      console.error(`❌ File save failed for ${filePath}:`, error.message);
       
-      console.log(`Successfully saved to GitHub after retry: ${retryResponse.data.commit.sha}`);
-      return retryResponse.data;
+      if (error.response?.status === 422) {
+        if (error.response?.data?.message?.includes('file is too large')) {
+          throw new Error(`File too large: ${filePath} exceeds GitHub size limits`);
+        }
+        if (error.response?.data?.message?.includes('Invalid request')) {
+          throw new Error(`Invalid file format for: ${filePath}`);
+        }
+      }
       
-    } catch (retryError) {
-      console.error(`Comprehensive retry also failed:`, retryError.response?.data || retryError.message);
+      if (error.response?.status === 409) {
+        throw new Error(`File conflict for: ${filePath}. File may have been modified by another process.`);
+      }
       
-      // 如果GitHub彻底失败，fallback到内存存储
-      console.log('GitHub save completely failed, falling back to memory storage...');
-      try {
-        const memoryResult = await memoryStorageService.saveFile(userId, fileName, data);
-        console.log('Successfully saved to memory storage as fallback');
-        return {
-          ...memoryResult,
-          warning: 'Saved to temporary memory storage due to GitHub issues'
-        };
-      } catch (memoryError) {
-        console.error('Memory storage fallback also failed:', memoryError.message);
-        throw new Error(`All storage methods failed. GitHub: ${retryError.message}, Memory: ${memoryError.message}`);
+      throw new Error(`Failed to save file ${filePath}: ${error.message}`);
+    }
+  }
+
+  // 单个slide保存 - 简化版本
+  async saveSlideWithCompression(filePath, slide, slideIndex, repoIndex) {
+    try {
+      // 应用轻量压缩
+      const compressedSlide = await this.compressSlide(slide);
+      
+      await this.makeGitHubRequest(async () => {
+        return await this.saveFileToRepo(
+          filePath,
+          compressedSlide,
+          `Save slide ${slideIndex}`,
+          repoIndex
+        );
+      }, `Save slide ${slideIndex}`);
+
+      const finalSize = Buffer.byteLength(JSON.stringify(compressedSlide), 'utf8');
+      
+      return {
+        slideIndex,
+        finalSize,
+        compressed: true
+      };
+    } catch (error) {
+      console.error(`❌ Failed to save slide ${slideIndex}:`, error);
+      throw error;
+    }
+  }
+
+  // 新架构：保存PPT（文件夹模式） - 简化版本
+  async savePPT(userId, pptId, pptData, repoIndex = 0) {
+    await this.ensureInitialized();
+    
+    if (this.useMemoryStorage) {
+      return await this.savePPTToMemory(userId, pptId, pptData);
+    }
+
+    try {
+      console.log(`📂 Saving PPT to folder: ${pptId} for user: ${userId}`);
+      
+      const repoUrl = this.repositories[repoIndex];
+      const { owner, repo } = this.parseRepoUrl(repoUrl);
+      const pptFolderPath = `users/${userId}/${pptId}`;
+
+      // 验证输入数据
+      if (!pptData || typeof pptData !== 'object') {
+        throw new Error('Invalid PPT data provided');
+      }
+
+      // 1. 准备元数据（不包含slides）
+      const metadata = {
+        id: pptData.id || pptId,
+        title: pptData.title || '未命名演示文稿',
+        theme: pptData.theme || {
+          backgroundColor: '#ffffff',
+          themeColor: '#d14424',
+          fontColor: '#333333',
+          fontName: 'Microsoft YaHei'
+        },
+        viewportSize: pptData.viewportSize || 1000,
+        viewportRatio: pptData.viewportRatio || 0.5625,
+        createdAt: pptData.createdAt || new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        storage: {
+          type: 'folder',
+          version: '2.0',
+          slidesCount: pptData.slides?.length || 0
+        }
+      };
+
+      // 2. 保存元数据文件
+      await this.makeGitHubRequest(async () => {
+        return await this.saveFileToRepo(
+          `${pptFolderPath}/meta.json`,
+          metadata,
+          `Update PPT metadata: ${metadata.title}`,
+          repoIndex
+        );
+      }, `Save metadata for PPT ${pptId}`);
+
+      console.log(`✅ Metadata saved for PPT: ${pptId}`);
+
+      // 3. 串行化保存每个slide文件
+      const slides = Array.isArray(pptData.slides) ? pptData.slides : [];
+      const saveResults = [];
+
+      console.log(`📊 Starting to save ${slides.length} slides...`);
+
+      for (let i = 0; i < slides.length; i++) {
+        const slide = slides[i];
+        const slideFileName = `slide_${String(i).padStart(3, '0')}.json`;
+        
+        console.log(`💾 Saving slide ${i + 1}/${slides.length}: ${slideFileName}`);
+        
+        try {
+          // 验证slide数据
+          if (!slide || typeof slide !== 'object') {
+            throw new Error(`Invalid slide data at index ${i}`);
+          }
+
+          const result = await this.saveSlideWithCompression(
+            `${pptFolderPath}/${slideFileName}`,
+            slide,
+            i,
+            repoIndex
+          );
+          
+          saveResults.push(result);
+          console.log(`✅ Slide ${i} saved: ${(result.finalSize / 1024).toFixed(2)} KB`);
+          
+          // 添加延迟避免GitHub API速率限制
+          if (i < slides.length - 1) {
+            await new Promise(resolve => setTimeout(resolve, this.apiRateLimit.minDelay));
+          }
+        } catch (slideError) {
+          console.error(`❌ Failed to save slide ${i}: ${slideError.message}`);
+          throw slideError; // 任何slide保存失败都应该停止整个过程
+        }
+      }
+
+      // 4. 计算保存统计
+      const totalSize = saveResults.reduce((sum, r) => sum + r.finalSize, 0);
+
+      console.log(`🎉 PPT saved successfully: ${slides.length} slides, total size: ${(totalSize / 1024).toFixed(2)} KB`);
+
+      return {
+        success: true,
+        pptId: pptId,
+        storage: 'folder',
+        slidesCount: slides.length,
+        folderPath: pptFolderPath,
+        size: totalSize
+      };
+
+    } catch (error) {
+      console.error(`❌ PPT save failed for ${pptId}: ${error.message}`);
+      throw new Error(`Failed to save PPT: ${error.message}`);
+    }
+  }
+
+  // Memory storage methods - 简化版本
+  async getPPTFromMemory(userId, pptId) {
+    const metaKey = `users/${userId}/${pptId}/meta`;
+    const metadata = this.memoryStorage.get(metaKey);
+    
+    if (!metadata) {
+      console.log(`📄 PPT not found in memory: ${pptId}`);
+      return null;
+    }
+
+    // 重组slides
+    const slides = [];
+    const slidesCount = metadata.storage?.slidesCount || 0;
+    
+    for (let i = 0; i < slidesCount; i++) {
+      const slideKey = `users/${userId}/${pptId}/slide_${String(i).padStart(3, '0')}`;
+      const slide = this.memoryStorage.get(slideKey);
+      if (slide) {
+        slides.push(slide);
+      }
+    }
+
+    const pptData = {
+      ...metadata,
+      slides: slides,
+      storage: {
+        ...metadata.storage,
+        loadedAt: new Date().toISOString()
+      }
+    };
+
+    console.log(`📖 Read PPT from memory: ${pptId} (${slides.length} slides)`);
+    return { content: pptData };
+  }
+
+  // 简化内存存储
+  async savePPTToMemory(userId, pptId, pptData) {
+    // 保存元数据
+    const metadata = {
+      id: pptData.id || pptId,
+      title: pptData.title || '未命名演示文稿',
+      theme: pptData.theme,
+      viewportSize: pptData.viewportSize || 1000,
+      viewportRatio: pptData.viewportRatio || 0.5625,
+      createdAt: pptData.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      storage: {
+        type: 'folder',
+        version: '2.0',
+        slidesCount: pptData.slides?.length || 0
+      }
+    };
+
+    const metaKey = `users/${userId}/${pptId}/meta`;
+    this.memoryStorage.set(metaKey, metadata);
+
+    // 保存slides
+    const slides = pptData.slides || [];
+    let totalSize = 0;
+
+    for (let i = 0; i < slides.length; i++) {
+      const slide = slides[i];
+      const compressedSlide = await this.compressSlide(slide);
+      const slideKey = `users/${userId}/${pptId}/slide_${String(i).padStart(3, '0')}`;
+      this.memoryStorage.set(slideKey, compressedSlide);
+      
+      totalSize += Buffer.byteLength(JSON.stringify(compressedSlide), 'utf8');
+    }
+
+    console.log(`💾 Saved PPT to memory: ${pptId} (${slides.length} slides, ${(totalSize / 1024).toFixed(2)} KB)`);
+
+    return {
+      success: true,
+      storage: 'folder',
+      slidesCount: slides.length,
+      size: totalSize
+    };
+  }
+
+  // 删除PPT时清理所有文件
+  async deletePPTFromMemory(userId, pptId) {
+    let deleted = 0;
+    const prefix = `users/${userId}/${pptId}/`;
+    
+    // 删除所有相关键
+    for (const key of this.memoryStorage.keys()) {
+      if (key.startsWith(prefix)) {
+        this.memoryStorage.delete(key);
+        deleted++;
       }
     }
+    
+    console.log(`📝 Memory storage: Deleted ${deleted} files for PPT ${pptId}`);
+    return deleted > 0;
   }
 
-  // 获取用户的所有PPT列表
+  // 更新用户PPT列表
+  async getUserPPTListFromMemory(userId) {
+    const results = [];
+    const userPrefix = `users/${userId}/`;
+    const pptIds = new Set();
+    
+    // 收集所有PPT ID
+    for (const key of this.memoryStorage.keys()) {
+      if (key.startsWith(userPrefix) && key.includes('/meta')) {
+        const pptId = key.replace(userPrefix, '').replace('/meta', '');
+        pptIds.add(pptId);
+      }
+    }
+    
+    // 获取每个PPT的元数据
+    for (const pptId of pptIds) {
+      const metaKey = `${userPrefix}${pptId}/meta`;
+      const metadata = this.memoryStorage.get(metaKey);
+      
+      if (metadata) {
+        results.push({
+          name: pptId,
+          title: metadata.title || '未命名演示文稿',
+          updatedAt: metadata.updatedAt || new Date().toISOString(),
+          slidesCount: metadata.storage?.slidesCount || 0,
+          isChunked: false,
+          storageType: 'folder',
+          size: JSON.stringify(metadata).length,
+          repoIndex: 0
+        });
+      }
+    }
+    
+    console.log(`📋 Found ${results.length} PPTs in memory for user ${userId}`);
+    return results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  }
+
+  // 获取用户PPT列表（新架构） - 简化版本
   async getUserPPTList(userId) {
-    // 如果使用内存存储
+    await this.ensureInitialized();
+    
     if (this.useMemoryStorage) {
-      return await memoryStorageService.getUserPPTList(userId);
+      return await this.getUserPPTListFromMemory(userId);
     }
 
-    // 原有的GitHub逻辑
-    const results = [];
+    const pptList = [];
     
-    for (let i = 0; i < this.repositories.length; i++) {
+    // 检查所有仓库
+    for (let repoIndex = 0; repoIndex < this.repositories.length; repoIndex++) {
       try {
-        const repoUrl = this.repositories[i];
+        const repoUrl = this.repositories[repoIndex];
         const { owner, repo } = this.parseRepoUrl(repoUrl);
-        const path = `users/${userId}`;
+        const userDirPath = `users/${userId}`;
 
-        const response = await axios.get(
-          `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
-          {
-            headers: {
-              'Authorization': `token ${this.token}`,
-              'Accept': 'application/vnd.github.v3+json'
+        const response = await this.makeGitHubRequest(async () => {
+          return await axios.get(
+            `${this.apiUrl}/repos/${owner}/${repo}/contents/${userDirPath}`,
+            {
+              headers: {
+                'Authorization': `token ${this.token}`,
+                'Accept': 'application/vnd.github.v3+json'
+              },
+              timeout: 30000
             }
-          }
+          );
+        }, `Get user directory for ${userId} in repo ${repoIndex}`);
+
+        // 查找PPT文件夹
+        const pptFolders = response.data.filter(item => 
+          item.type === 'dir' // PPT存储为文件夹
         );
 
-        const files = response.data
-          .filter(item => item.type === 'file' && item.name.endsWith('.json'));
+        for (const folder of pptFolders) {
+          try {
+            const pptId = folder.name;
+            
+            // 获取PPT元数据
+            const metaResponse = await this.makeGitHubRequest(async () => {
+              return await axios.get(
+                `${this.apiUrl}/repos/${owner}/${repo}/contents/${userDirPath}/${pptId}/meta.json`,
+                {
+                  headers: {
+                    'Authorization': `token ${this.token}`,
+                    'Accept': 'application/vnd.github.v3+json'
+                  },
+                  timeout: 15000
+                }
+              );
+            }, `Get metadata for PPT ${pptId}`);
+
+            const metaContent = Buffer.from(metaResponse.data.content, 'base64').toString('utf8');
+            const metadata = JSON.parse(metaContent);
 
-        // 获取每个PPT文件的实际内容以读取标题
-        for (const file of files) {
+            pptList.push({
+              name: pptId,
+              title: metadata.title || '未命名演示文稿',
+              updatedAt: metadata.updatedAt || new Date().toISOString(),
+              slidesCount: metadata.storage?.slidesCount || 0,
+              isChunked: false,
+              storageType: 'folder',
+              size: metaResponse.data.size || 0,
+              repoIndex: repoIndex
+            });
+          } catch (error) {
+            console.warn(`跳过无效PPT文件夹 ${folder.name}:`, error.message);
+          }
+        }
+
+        // 兼容性：同时检查旧的单文件格式
+        const jsonFiles = response.data.filter(file => 
+          file.type === 'file' && 
+          file.name.endsWith('.json') && 
+          !file.name.includes('_chunk_')
+        );
+
+        for (const file of jsonFiles) {
           try {
             const pptId = file.name.replace('.json', '');
-            const fileContent = await this.getFile(userId, file.name, i);
             
-            if (fileContent && fileContent.content) {
-              results.push({
-                name: pptId,
-                title: fileContent.content.title || '未命名演示文稿',
-                lastModified: fileContent.content.updatedAt || fileContent.content.createdAt,
-                repoIndex: i,
-                repoUrl: repoUrl
-              });
+            // 避免重复添加（如果已经有文件夹版本）
+            if (pptList.some(p => p.name === pptId)) {
+              continue;
             }
-          } catch (error) {
-            // 如果读取单个文件失败，使用文件名作为标题
-            console.warn(`Failed to read PPT content for ${file.name}:`, error.message);
-            results.push({
-              name: file.name.replace('.json', ''),
-              title: file.name.replace('.json', ''),
-              lastModified: new Date().toISOString(),
-              repoIndex: i,
-              repoUrl: repoUrl
+            
+            const fileResponse = await this.makeGitHubRequest(async () => {
+              return await axios.get(
+                `${this.apiUrl}/repos/${owner}/${repo}/contents/${userDirPath}/${file.name}`,
+                {
+                  headers: {
+                    'Authorization': `token ${this.token}`,
+                    'Accept': 'application/vnd.github.v3+json'
+                  },
+                  timeout: 15000
+                }
+              );
+            }, `Get legacy PPT file ${file.name}`);
+
+            const content = Buffer.from(fileResponse.data.content, 'base64').toString('utf8');
+            const pptData = JSON.parse(content);
+
+            pptList.push({
+              name: pptId,
+              title: pptData.title || '未命名演示文稿',
+              updatedAt: pptData.updatedAt || new Date().toISOString(),
+              slidesCount: pptData.isChunked ? pptData.totalSlides : (pptData.slides?.length || 0),
+              isChunked: pptData.isChunked || false,
+              storageType: 'legacy',
+              size: file.size,
+              repoIndex: repoIndex
             });
+          } catch (error) {
+            console.warn(`跳过无效文件 ${file.name}:`, error.message);
           }
         }
       } catch (error) {
-        if (error.response?.status !== 404) {
-          console.error(`Error fetching files from repo ${i}:`, error.message);
-        }
+        console.warn(`仓库 ${repoIndex} 中没有找到用户目录或访问失败:`, error.message);
+        continue;
       }
     }
 
-    return results;
+    // 按更新时间排序
+    return pptList.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
   }
 
-  // 删除文件
-  async deleteFile(userId, fileName, repoIndex = 0) {
-    // 如果使用内存存储
+  // 删除PPT（新架构） - 简化版本
+  async deletePPT(userId, pptId, repoIndex = 0) {
+    await this.ensureInitialized();
+    
     if (this.useMemoryStorage) {
-      return await memoryStorageService.deleteFile(userId, fileName);
-    }
-
-    // 原有的GitHub逻辑
-    const existing = await this.getFile(userId, fileName, repoIndex);
-    if (!existing) {
-      throw new Error('File not found');
+      return await this.deletePPTFromMemory(userId, pptId);
     }
 
     const repoUrl = this.repositories[repoIndex];
     const { owner, repo } = this.parseRepoUrl(repoUrl);
-    const path = `users/${userId}/${fileName}`;
+    const pptFolderPath = `users/${userId}/${pptId}`;
 
-    const response = await axios.delete(
-      `${this.apiUrl}/repos/${owner}/${repo}/contents/${path}`,
-      {
-        data: {
-          message: `Delete ${fileName} for user ${userId}`,
-          sha: existing.sha,
-          branch: 'main'
-        },
-        headers: {
-          'Authorization': `token ${this.token}`,
-          'Accept': 'application/vnd.github.v3+json'
+    try {
+      console.log(`🗑️ Deleting PPT folder: ${pptFolderPath}`);
+      
+      // 1. 获取文件夹内容
+      const folderResponse = await this.makeGitHubRequest(async () => {
+        return await axios.get(
+          `${this.apiUrl}/repos/${owner}/${repo}/contents/${pptFolderPath}`,
+          {
+            headers: {
+              'Authorization': `token ${this.token}`,
+              'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 30000
+          }
+        );
+      }, `Get PPT folder contents for deletion: ${pptId}`);
+
+      // 2. 串行删除所有文件
+      for (const file of folderResponse.data) {
+        try {
+          await this.makeGitHubRequest(async () => {
+            return await axios.delete(
+              `${this.apiUrl}/repos/${owner}/${repo}/contents/${file.path}`,
+              {
+                data: {
+                  message: `Delete PPT file: ${file.name}`,
+                  sha: file.sha
+                },
+                headers: {
+                  'Authorization': `token ${this.token}`,
+                  'Accept': 'application/vnd.github.v3+json'
+                },
+                timeout: 30000
+              }
+            );
+          }, `Delete file ${file.name}`);
+          
+          console.log(`✅ Deleted file: ${file.name}`);
+          
+          // 添加延迟避免API限制
+          await new Promise(resolve => setTimeout(resolve, this.apiRateLimit.minDelay));
+        } catch (error) {
+          console.warn(`⚠️ Failed to delete file ${file.name}:`, error.message);
         }
       }
-    );
 
-    return response.data;
+      console.log(`✅ PPT folder deleted successfully: ${pptId}`);
+      return true;
+
+    } catch (error) {
+      if (error.response?.status === 404) {
+        console.log(`📄 PPT folder not found, trying legacy format: ${pptId}`);
+        return await this.deleteFile(userId, `${pptId}.json`, repoIndex);
+      }
+      
+      console.error(`❌ Delete PPT failed for ${pptId}:`, error);
+      throw new Error(`Failed to delete PPT: ${error.message}`);
+    }
   }
 }
 

backend/src/services/screenshotService.js

@@ -1,663 +1,341 @@
 import puppeteer from 'puppeteer';
+import playwright from 'playwright';
 
 class ScreenshotService {
   constructor() {
-    this.browser = null;
-    this.playwrightBrowser = null; // 添加Playwright浏览器实例
-    this.isInitialized = false;
-    this.maxRetries = 2;
-    this.browserLaunchRetries = 0;
-    this.maxBrowserLaunchRetries = 2;
-    this.isClosing = false;
-    this.isHuggingFaceSpace = process.env.SPACE_ID || process.env.HF_SPACE_ID;
-    this.preferredEngine = 'puppeteer'; // 优先使用的截图引擎
-    this.isPlaywrightAvailable = false; // 初始为false，运行时检查
-    this.chromium = null; // Playwright chromium实例
-  }
-
-  // 动态检查和加载Playwright
-  async initPlaywright() {
-    if (this.chromium) return this.chromium; // 已经加载过
+    this.puppeteerBrowser = null;
+    this.playwrightBrowser = null;
+    this.isInitializing = false;
+    this.puppeteerReady = false;
+    this.playwrightReady = false;
     
-    try {
-      console.log('🎭 尝试动态加载Playwright...');
-      const playwrightModule = await import('playwright');
-      this.chromium = playwrightModule.chromium;
-      this.isPlaywrightAvailable = true;
-      console.log('✅ Playwright动态加载成功，可作为截图备用方案');
-      return this.chromium;
-    } catch (error) {
-      console.warn('⚠️ Playwright动态加载失败，将仅使用Puppeteer进行截图:', error.message);
-      this.isPlaywrightAvailable = false;
-      this.chromium = null;
-      return null;
-    }
+    console.log('Screenshot service initialized');
   }
 
-  async initBrowser() {
-    if (this.isClosing) {
-      console.log('浏览器正在关闭中，等待重新初始化...');
-      this.browser = null;
-      this.isClosing = false;
-    }
-
-    if (!this.browser) {
-      try {
-        console.log('初始化Puppeteer浏览器...');
-        
-        const launchOptions = {
-          headless: 'new',
-          timeout: 60000,
-          protocolTimeout: 60000,
-          args: [
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-dev-shm-usage',
-            '--disable-accelerated-2d-canvas',
-            '--no-first-run',
-            '--disable-gpu',
-            '--disable-background-timer-throttling',
-            '--disable-backgrounding-occluded-windows',
-            '--disable-renderer-backgrounding',
-            '--disable-features=TranslateUI',
-            '--disable-extensions',
-            '--hide-scrollbars',
-            '--mute-audio',
-            '--no-default-browser-check',
-            '--disable-default-apps',
-            '--disable-background-networking',
-            '--disable-sync',
-            '--metrics-recording-only',
-            '--disable-domain-reliability',
-            '--force-device-scale-factor=1',
-            '--disable-features=VizDisplayCompositor',
-            '--run-all-compositor-stages-before-draw',
-            '--disable-new-content-rendering-timeout',
-            '--disable-ipc-flooding-protection',
-            '--disable-hang-monitor',
-            '--disable-prompt-on-repost',
-            '--memory-pressure-off',
-            '--max_old_space_size=1024',
-            '--disable-background-media-suspend',
-            '--disable-backgrounding-occluded-windows',
-            '--disable-renderer-backgrounding',
-            '--disable-field-trial-config',
-            '--disable-component-extensions-with-background-pages',
-            '--disable-permissions-api',
-            '--disable-client-side-phishing-detection',
-            '--no-zygote',
-            '--disable-web-security',
-            '--allow-running-insecure-content',
-            '--disable-features=VizDisplayCompositor,AudioServiceOutOfProcess',
-            '--disable-software-rasterizer',
-            '--disable-canvas-aa',
-            '--disable-2d-canvas-clip-aa',
-            '--disable-gl-drawing-for-tests',
-            '--use-gl=swiftshader'
-          ]
-        };
-
-        if (this.isHuggingFaceSpace) {
-          console.log('检测到Hugging Face Space环境，使用单进程模式');
-          launchOptions.args.push(
-            '--single-process',
-            '--disable-features=site-per-process',
-            '--disable-site-isolation-trials',
-            '--disable-features=BlockInsecurePrivateNetworkRequests'
-          );
-        }
-
-        try {
-          const chromePath = process.env.CHROME_BIN || 
-                           process.env.GOOGLE_CHROME_BIN || 
-                           '/usr/bin/google-chrome-stable' ||
-                           '/usr/bin/chromium-browser';
-          
-          if (chromePath && require('fs').existsSync(chromePath)) {
-            launchOptions.executablePath = chromePath;
-            console.log(`使用Chrome路径: ${chromePath}`);
-          }
-        } catch (pathError) {
-          console.log('未找到自定义Chrome路径，使用默认配置');
-        }
-
-        this.browser = await puppeteer.launch(launchOptions);
-        console.log('✅ Puppeteer浏览器初始化成功');
-
-        this.browser.on('disconnected', () => {
-          console.log('Puppeteer浏览器连接断开');
-          this.browser = null;
-          this.isClosing = false;
-        });
-
-        this.browserLaunchRetries = 0;
-      } catch (error) {
-        console.error('❌ Puppeteer浏览器初始化失败:', error.message);
-        this.browserLaunchRetries++;
-        
-        if (this.browserLaunchRetries <= this.maxBrowserLaunchRetries) {
-          console.log(`尝试重新初始化浏览器 (${this.browserLaunchRetries}/${this.maxBrowserLaunchRetries})`);
-          await this.delay(3000);
-          return this.initBrowser();
-        } else {
-          console.warn('⚠️ Puppeteer初始化完全失败，将使用fallback方法');
-          return null;
-        }
-      }
-    }
-
-    if (this.browser) {
-      try {
-        await this.browser.version();
-        console.log('✅ 浏览器连接正常');
-      } catch (error) {
-        console.warn('浏览器连接已断开，重新初始化:', error.message);
-        this.browser = null;
-        return this.initBrowser();
-      }
-    }
-
-    return this.browser;
-  }
-
-  async initPlaywrightBrowser() {
-    // 先尝试加载Playwright
-    const chromium = await this.initPlaywright();
-    if (!chromium) {
-      console.warn('Playwright不可用，跳过初始化');
-      return null;
-    }
-
-    if (this.playwrightBrowser) {
-      try {
-        const context = await this.playwrightBrowser.newContext();
-        await context.close();
-        return this.playwrightBrowser;
-      } catch (error) {
-        console.warn('Playwright浏览器连接已断开，重新初始化');
-        this.playwrightBrowser = null;
-      }
-    }
-
+  // Initialize Puppeteer browser
+  async initPuppeteer() {
+    if (this.puppeteerBrowser || this.isInitializing) return;
+    
+    this.isInitializing = true;
+    
     try {
-      console.log('初始化Playwright浏览器...');
+      console.log('🚀 Starting Puppeteer browser...');
       
       const launchOptions = {
-        headless: true,
-        timeout: 30000,
+        headless: 'new',
         args: [
           '--no-sandbox',
           '--disable-setuid-sandbox',
           '--disable-dev-shm-usage',
           '--disable-gpu',
           '--disable-extensions',
-          '--no-first-run',
           '--disable-background-timer-throttling',
+          '--disable-backgrounding-occluded-windows',
           '--disable-renderer-backgrounding',
-          '--disable-backgrounding-occluded-windows'
-        ]
+          '--no-first-run',
+          '--no-default-browser-check',
+          '--disable-default-apps',
+          '--disable-features=TranslateUI',
+          '--disable-ipc-flooding-protection',
+          '--memory-pressure-off',
+          '--max_old_space_size=4096'
+        ],
+        timeout: 30000
       };
 
-      if (this.isHuggingFaceSpace) {
-        console.log('检测到Hugging Face Space环境，使用Playwright优化配置');
+      // Hugging Face Spaces optimizations
+      if (process.env.SPACE_ID) {
         launchOptions.args.push(
           '--single-process',
-          '--no-zygote',
-          '--disable-web-security'
+          '--disable-background-networking',
+          '--disable-background-mode'
         );
       }
 
-      this.playwrightBrowser = await chromium.launch(launchOptions);
-      console.log('✅ Playwright浏览器初始化成功');
+      this.puppeteerBrowser = await puppeteer.launch(launchOptions);
+      this.puppeteerReady = true;
+      console.log('✅ Puppeteer browser started successfully');
+      
+      // Cleanup when process exits
+      process.on('exit', () => this.cleanup());
+      process.on('SIGINT', () => this.cleanup());
+      process.on('SIGTERM', () => this.cleanup());
       
-      return this.playwrightBrowser;
     } catch (error) {
-      console.error('❌ Playwright浏览器初始化失败:', error.message);
-      return null;
+      console.error('❌ Puppeteer initialization failed:', error.message);
+      this.puppeteerReady = false;
+    } finally {
+      this.isInitializing = false;
     }
   }
 
-  async closeBrowser() {
-    if (this.browser && !this.isClosing) {
-      try {
-        this.isClosing = true;
-        console.log('正在关闭Puppeteer浏览器...');
-        await this.browser.close();
-        console.log('Puppeteer浏览器已关闭');
-      } catch (error) {
-        console.warn('关闭浏览器时出错:', error.message);
-      } finally {
-        this.browser = null;
-        this.isClosing = false;
-      }
+  // Initialize Playwright browser (fallback)
+  async initPlaywright() {
+    if (this.playwrightBrowser) return;
+    
+    try {
+      console.log('🎭 Starting Playwright browser...');
+      
+      this.playwrightBrowser = await playwright.chromium.launch({
+        headless: true,
+        args: [
+          '--no-sandbox',
+          '--disable-setuid-sandbox',
+          '--disable-dev-shm-usage'
+        ]
+      });
+      
+      this.playwrightReady = true;
+      console.log('✅ Playwright browser started successfully');
+      
+    } catch (error) {
+      console.error('❌ Playwright initialization failed:', error.message);
+      this.playwrightReady = false;
     }
   }
 
-  async closePlaywrightBrowser() {
-    if (this.playwrightBrowser) {
+  // Generate screenshot
+  async generateScreenshot(htmlContent, options = {}) {
+    const {
+      format = 'jpeg',
+      quality = 90,
+      width = 1000,
+      height = 562,
+      timeout = 15000
+    } = options;
+
+    console.log(`📸 Generating screenshot: ${width}x${height}, ${format}@${quality}%`);
+
+    // Try Puppeteer first
+    if (!this.puppeteerReady) {
+      await this.initPuppeteer();
+    }
+
+    if (this.puppeteerReady) {
       try {
-        console.log('正在关闭Playwright浏览器...');
-        await this.playwrightBrowser.close();
-        console.log('Playwright浏览器已关闭');
+        return await this.generateWithPuppeteer(htmlContent, { format, quality, width, height, timeout });
       } catch (error) {
-        console.warn('关闭Playwright浏览器时出错:', error.message);
-      } finally {
-        this.playwrightBrowser = null;
+        console.warn('Puppeteer screenshot failed, trying Playwright:', error.message);
       }
     }
-  }
-
-  delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
 
-  extractPPTDimensions(htmlContent) {
-    try {
-      const dimensionMatch = htmlContent.match(/window\.PPT_DIMENSIONS\s*=\s*{\s*width:\s*(\d+),\s*height:\s*(\d+)\s*}/);
-      if (dimensionMatch) {
-        return {
-          width: parseInt(dimensionMatch[1]),
-          height: parseInt(dimensionMatch[2])
-        };
-      }
+    // Fallback to Playwright
+    if (!this.playwrightReady) {
+      await this.initPlaywright();
+    }
 
-      const viewportMatch = htmlContent.match(/width=(\d+),\s*height=(\d+)/);
-      if (viewportMatch) {
-        return {
-          width: parseInt(viewportMatch[1]),
-          height: parseInt(viewportMatch[2])
-        };
+    if (this.playwrightReady) {
+      try {
+        return await this.generateWithPlaywright(htmlContent, { format, quality, width, height, timeout });
+      } catch (error) {
+        console.warn('Playwright screenshot failed:', error.message);
       }
-
-      return { width: 960, height: 720 };
-    } catch (error) {
-      console.warn('提取PPT尺寸失败，使用默认尺寸:', error.message);
-      return { width: 960, height: 720 };
     }
-  }
 
-  generateFallbackImage(width, height, message = 'Screenshot not available') {
-    console.log(`🔄 生成fallback图片: ${width}x${height}`);
-    
-    const svg = `
-      <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
-        <rect width="100%" height="100%" fill="#f8f9fa"/>
-        <rect x="10" y="10" width="${width-20}" height="${height-20}" 
-              fill="none" stroke="#dee2e6" stroke-width="2" stroke-dasharray="10,5"/>
-        <text x="50%" y="40%" text-anchor="middle" dominant-baseline="middle" 
-              font-family="Arial, sans-serif" font-size="28" fill="#495057" font-weight="bold">
-          PPT 预览图
-        </text>
-        <text x="50%" y="50%" text-anchor="middle" dominant-baseline="middle" 
-              font-family="Arial, sans-serif" font-size="16" fill="#6c757d">
-          ${message}
-        </text>
-        <text x="50%" y="60%" text-anchor="middle" dominant-baseline="middle" 
-              font-family="Arial, sans-serif" font-size="14" fill="#adb5bd">
-          尺寸: ${width} × ${height}
-        </text>
-        <circle cx="50%" cy="70%" r="20" fill="none" stroke="#28a745" stroke-width="3">
-          <animate attributeName="stroke-dasharray" values="0,126;126,126" dur="2s" repeatCount="indefinite"/>
-        </circle>
-      </svg>
-    `;
-    
-    return Buffer.from(svg, 'utf8');
+    // Final fallback: generate SVG
+    console.warn('All screenshot methods failed, generating fallback SVG');
+    return this.generateFallbackImage(width, height, 'Screenshot Service', 'Browser unavailable');
   }
 
-  optimizeHtmlForScreenshot(htmlContent, targetWidth, targetHeight) {
-    console.log(`优化HTML for精确截图, 目标尺寸: ${targetWidth}x${targetHeight}`);
-
-    const optimizedHtml = htmlContent.replace(
-      /(<head[^>]*>)/i,
-      `$1
-        <meta name="screenshot-mode" content="true">
-        <style id="screenshot-precise-control">
-          *, *::before, *::after {
-            margin: 0 !important;
-            padding: 0 !important;
-            box-sizing: border-box !important;
-            border: none !important;
-            outline: none !important;
-          }
-          
-          html {
-            width: ${targetWidth}px !important;
-            height: ${targetHeight}px !important;
-            min-width: ${targetWidth}px !important;
-            min-height: ${targetHeight}px !important;
-            max-width: ${targetWidth}px !important;
-            max-height: ${targetHeight}px !important;
-            overflow: hidden !important;
-            position: fixed !important;
-            top: 0 !important;
-            left: 0 !important;
-            margin: 0 !important;
-            padding: 0 !important;
-            transform: none !important;
-            transform-origin: top left !important;
-          }
-          
-          body {
-            width: ${targetWidth}px !important;
-            height: ${targetHeight}px !important;
-            min-width: ${targetWidth}px !important;
-            min-height: ${targetHeight}px !important;
-            max-width: ${targetWidth}px !important;
-            max-height: ${targetHeight}px !important;
-            overflow: hidden !important;
-            position: fixed !important;
-            top: 0 !important;
-            left: 0 !important;
-            margin: 0 !important;
-            padding: 0 !important;
-            transform: none !important;
-            transform-origin: top left !important;
-          }
-          
-          .slide-container {
-            width: ${targetWidth}px !important;
-            height: ${targetHeight}px !important;
-            min-width: ${targetWidth}px !important;
-            min-height: ${targetHeight}px !important;
-            max-width: ${targetWidth}px !important;
-            max-height: ${targetHeight}px !important;
-            position: fixed !important;
-            top: 0 !important;
-            left: 0 !important;
-            overflow: hidden !important;
-            transform: none !important;
-            transform-origin: top left !important;
-            margin: 0 !important;
-            padding: 0 !important;
-            box-shadow: none !important;
-            z-index: 1 !important;
-          }
-          
-          html::-webkit-scrollbar,
-          body::-webkit-scrollbar,
-          *::-webkit-scrollbar {
-            display: none !important;
-            width: 0 !important;
-            height: 0 !important;
-          }
-          
-          html { scrollbar-width: none !important; }
-          
-          * {
-            -webkit-user-select: none !important;
-            -moz-user-select: none !important;
-            -ms-user-select: none !important;
-            user-select: none !important;
-            pointer-events: none !important;
-          }
-        </style>`
-    );
+  // Generate screenshot using Puppeteer
+  async generateWithPuppeteer(htmlContent, options) {
+    const { format, quality, width, height, timeout } = options;
+    let page = null;
 
-    return optimizedHtml;
-  }
-
-  async generateScreenshotWithPuppeteer(htmlContent, options = {}, retryCount = 0) {
     try {
-      console.log(`🎯 开始Puppeteer截图生成... (尝试 ${retryCount + 1}/${this.maxRetries + 1})`);
-      
-      const browser = await this.initBrowser();
-      if (!browser) {
-        throw new Error('浏览器初始化失败');
-      }
-      
-      const dimensions = this.extractPPTDimensions(htmlContent);
-      console.log(`📐 检测到PPT尺寸: ${dimensions.width}x${dimensions.height}`);
+      page = await this.puppeteerBrowser.newPage();
       
-      const optimizedHtml = this.optimizeHtmlForScreenshot(htmlContent, dimensions.width, dimensions.height);
+      // Set viewport
+      await page.setViewport({ width, height });
       
-      let page = null;
-      try {
-        page = await browser.newPage();
-        console.log('📄 创建新页面成功');
-        
-        page.setDefaultTimeout(20000);
-        page.setDefaultNavigationTimeout(20000);
-        
-        await page.setViewport({
-          width: dimensions.width,
-          height: dimensions.height,
-          deviceScaleFactor: 1,
-        });
-        console.log(`🖥️ 设置viewport: ${dimensions.width}x${dimensions.height}`);
-        
-        await page.setContent(optimizedHtml, {
-          waitUntil: ['load', 'domcontentloaded'],
-          timeout: 20000
-        });
-        console.log('📝 页面内容设置完成');
-        
-        await page.waitForTimeout(1000);
-        console.log('⏱️ 等待渲染完成');
-        
-        console.log('📸 开始执行截图...');
-        const screenshot = await page.screenshot({
-          type: 'jpeg',
-          quality: 85,
-          clip: {
-            x: 0,
-            y: 0,
-            width: dimensions.width,
-            height: dimensions.height
-          },
-          omitBackground: false,
-          captureBeyondViewport: false,
-        });
-        
-        console.log(`✅ Puppeteer截图成功生成，尺寸: ${dimensions.width}x${dimensions.height}, 数据大小: ${screenshot.length} 字节`);
-        return screenshot;
-        
-      } finally {
-        if (page) {
-          try {
-            await page.close();
-            console.log('📄 页面已关闭');
-          } catch (error) {
-            console.warn('关闭页面时出错:', error.message);
-          }
-        }
-      }
-      
-    } catch (error) {
-      console.error(`❌ Puppeteer截图生成失败 (尝试 ${retryCount + 1}):`, error.message);
-      
-      if (error.message.includes('Target closed') || 
-          error.message.includes('Connection closed') ||
-          error.message.includes('Protocol error')) {
-        console.log('🔄 检测到浏览器连接问题，重置浏览器实例');
-        this.browser = null;
-        this.isClosing = false;
-      }
+      // Set content
+      await page.setContent(htmlContent, { 
+        waitUntil: 'networkidle0',
+        timeout: timeout
+      });
+
+      // Wait for fonts
+      await page.evaluate(() => {
+        return document.fonts ? document.fonts.ready : Promise.resolve();
+      });
+
+      // Additional wait for rendering
+      await page.waitForTimeout(300);
+
+      // Take screenshot
+      const screenshotOptions = {
+        type: format,
+        quality: format === 'jpeg' ? quality : undefined,
+        fullPage: false,
+        clip: { x: 0, y: 0, width, height }
+      };
+
+      const screenshot = await page.screenshot(screenshotOptions);
       
-      if (retryCount < this.maxRetries) {
-        const waitTime = (retryCount + 1) * 2;
-        console.log(`⏳ 等待 ${waitTime} 秒后重试...`);
-        await this.delay(waitTime * 1000);
-        return this.generateScreenshotWithPuppeteer(htmlContent, options, retryCount + 1);
+      console.log(`✅ Puppeteer screenshot generated: ${screenshot.length} bytes`);
+      return screenshot;
+
+    } finally {
+      if (page) {
+        await page.close().catch(console.error);
       }
-      
-      throw error;
     }
   }
 
-  async generateScreenshotWithPlaywright(htmlContent, options = {}) {
-    // 先尝试加载Playwright
-    const chromium = await this.initPlaywright();
-    if (!chromium) {
-      throw new Error('Playwright不可用');
-    }
+  // Generate screenshot using Playwright
+  async generateWithPlaywright(htmlContent, options) {
+    const { format, quality, width, height, timeout } = options;
+    let page = null;
 
     try {
-      console.log('🎭 开始Playwright截图生成...');
+      page = await this.playwrightBrowser.newPage();
       
-      const browser = await this.initPlaywrightBrowser();
-      if (!browser) {
-        throw new Error('Playwright浏览器初始化失败');
-      }
-
-      const dimensions = this.extractPPTDimensions(htmlContent);
-      console.log(`📐 Playwright检测到PPT尺寸: ${dimensions.width}x${dimensions.height}`);
-
-      const context = await browser.newContext({
-        viewport: {
-          width: dimensions.width,
-          height: dimensions.height
-        },
-        deviceScaleFactor: 1,
-        hasTouch: false,
-        isMobile: false
-      });
-
-      const page = await context.newPage();
+      // Set viewport
+      await page.setViewportSize({ width, height });
       
-      await page.setContent(htmlContent, {
-        waitUntil: 'domcontentloaded',
-        timeout: 15000
+      // Set content
+      await page.setContent(htmlContent, { 
+        waitUntil: 'networkidle',
+        timeout: timeout
       });
 
-      await page.waitForTimeout(800);
-
-      const screenshot = await page.screenshot({
-        type: 'jpeg',
-        quality: 90,
-        clip: {
-          x: 0,
-          y: 0,
-          width: dimensions.width,
-          height: dimensions.height
-        },
-        animations: 'disabled'
+      // Wait for fonts
+      await page.evaluate(() => {
+        return document.fonts ? document.fonts.ready : Promise.resolve();
       });
 
-      await context.close();
+      // Take screenshot
+      const screenshotOptions = {
+        type: format,
+        quality: format === 'jpeg' ? quality : undefined,
+        fullPage: false,
+        clip: { x: 0, y: 0, width, height }
+      };
+
+      const screenshot = await page.screenshot(screenshotOptions);
       
-      console.log(`✅ Playwright截图成功生成，尺寸: ${dimensions.width}x${dimensions.height}, 数据大小: ${screenshot.length} 字节`);
+      console.log(`✅ Playwright screenshot generated: ${screenshot.length} bytes`);
       return screenshot;
-      
-    } catch (error) {
-      console.error('❌ Playwright截图生成失败:', error.message);
-      throw error;
-    }
-  }
 
-  async generateScreenshot(htmlContent, options = {}) {
-    console.log('🎯 开始生成截图...');
-    
-    if (this.preferredEngine === 'puppeteer') {
-      try {
-        console.log('🚀 尝试使用Puppeteer生成截图');
-        const screenshot = await this.generateScreenshotWithPuppeteer(htmlContent, options);
-        console.log('✅ Puppeteer截图生成成功');
-        return screenshot;
-      } catch (puppeteerError) {
-        console.warn('⚠️ Puppeteer截图失败:', puppeteerError.message);
-        
-        // 动态检查Playwright是否可用
-        if (await this.initPlaywright()) {
-          console.log('🎭 尝试使用Playwright作为备用方案...');
-          try {
-            const screenshot = await this.generateScreenshotWithPlaywright(htmlContent, options);
-            console.log('✅ Playwright截图生成成功');
-            this.preferredEngine = 'playwright';
-            return screenshot;
-          } catch (playwrightError) {
-            console.warn('⚠️ Playwright截图也失败，使用fallback方法:', playwrightError.message);
-          }
-        } else {
-          console.warn('⚠️ Playwright不可用，直接使用fallback方法');
-        }
-      }
-    } else {
-      // 如果偏好Playwright，先动态检查是否可用
-      if (await this.initPlaywright()) {
-        try {
-          console.log('🎭 尝试使用Playwright生成截图');
-          const screenshot = await this.generateScreenshotWithPlaywright(htmlContent, options);
-          console.log('✅ Playwright截图生成成功');
-          return screenshot;
-        } catch (playwrightError) {
-          console.warn('⚠️ Playwright截图失败，尝试Puppeteer:', playwrightError.message);
-          
-          try {
-            const screenshot = await this.generateScreenshotWithPuppeteer(htmlContent, options);
-            console.log('✅ Puppeteer截图生成成功');
-            return screenshot;
-          } catch (puppeteerError) {
-            console.warn('⚠️ Puppeteer截图也失败，使用fallback方法:', puppeteerError.message);
-          }
-        }
-      } else {
-        console.warn('⚠️ Playwright不可用，直接使用Puppeteer');
-        try {
-          const screenshot = await this.generateScreenshotWithPuppeteer(htmlContent, options);
-          console.log('✅ Puppeteer截图生成成功');
-          return screenshot;
-        } catch (puppeteerError) {
-          console.warn('⚠️ Puppeteer截图也失败，使用fallback方法:', puppeteerError.message);
-        }
+    } finally {
+      if (page) {
+        await page.close().catch(console.error);
       }
     }
-    
-    // 如果所有截图引擎都失败，生成fallback图片
-    const dimensions = this.extractPPTDimensions(htmlContent);
-    const fallbackImage = this.generateFallbackImage(
-      dimensions.width, 
-      dimensions.height, 
-      '截图引擎不可用，显示占位图'
-    );
-    
-    console.log(`📋 生成fallback图片，尺寸: ${dimensions.width}x${dimensions.height}`);
-    return fallbackImage;
   }
 
-  async setPreferredEngine(engine) {
-    if (['puppeteer', 'playwright'].includes(engine)) {
-      // 检查所选引擎是否可用
-      if (engine === 'playwright') {
-        const chromium = await this.initPlaywright();
-        if (!chromium) {
-          console.warn('Playwright不可用，保持使用Puppeteer');
-          return;
-        }
-      }
-      
-      this.preferredEngine = engine;
-      console.log(`截图引擎偏好设置为: ${engine}`);
-    }
+  // Generate fallback SVG image
+  generateFallbackImage(width = 1000, height = 562, title = 'PPT Screenshot', subtitle = '', message = '') {
+    const svg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#f8f9fa;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#e9ecef;stop-opacity:1" />
+    </linearGradient>
+    <pattern id="dots" patternUnits="userSpaceOnUse" width="20" height="20">
+      <circle cx="2" cy="2" r="1" fill="#dee2e6" opacity="0.5"/>
+    </pattern>
+  </defs>
+  
+  <!-- Background -->
+  <rect width="100%" height="100%" fill="url(#bg)"/>
+  <rect width="100%" height="100%" fill="url(#dots)"/>
+  
+  <!-- Border -->
+  <rect x="20" y="20" width="${width-40}" height="${height-40}" 
+        fill="none" stroke="#dee2e6" stroke-width="3" 
+        stroke-dasharray="15,10" rx="10"/>
+  
+  <!-- Icon -->
+  <g transform="translate(${width/2}, ${height*0.25})">
+    <circle cx="0" cy="0" r="30" fill="#6c757d" opacity="0.3"/>
+    <rect x="-15" y="-10" width="30" height="20" rx="3" fill="#6c757d"/>
+    <rect x="-12" y="-7" width="24" height="3" fill="white"/>
+    <rect x="-12" y="-2" width="24" height="3" fill="white"/>
+    <rect x="-12" y="3" width="16" height="3" fill="white"/>
+  </g>
+  
+  <!-- Title -->
+  <text x="${width/2}" y="${height*0.45}" 
+        text-anchor="middle" 
+        font-family="Microsoft YaHei, PingFang SC, Hiragino Sans GB, Source Han Sans SC, Noto Sans SC, WenQuanYi Micro Hei, SimHei, SimSun, Arial, sans-serif"
+        font-size="28" 
+        font-weight="bold" 
+        fill="#495057">${title}</text>
+  
+  ${subtitle ? `
+  <!-- Subtitle -->
+  <text x="${width/2}" y="${height*0.55}" 
+        text-anchor="middle" 
+        font-family="Microsoft YaHei, PingFang SC, Hiragino Sans GB, Source Han Sans SC, Noto Sans SC, WenQuanYi Micro Hei, SimHei, SimSun, Arial, sans-serif"
+        font-size="18" 
+        fill="#6c757d">${subtitle}</text>
+  ` : ''}
+  
+  ${message ? `
+  <!-- Message -->
+  <text x="${width/2}" y="${height*0.65}" 
+        text-anchor="middle" 
+        font-family="Microsoft YaHei, PingFang SC, Hiragino Sans GB, Source Han Sans SC, Noto Sans SC, WenQuanYi Micro Hei, SimHei, SimSun, Arial, sans-serif"
+        font-size="14" 
+        fill="#adb5bd">${message}</text>
+  ` : ''}
+  
+  <!-- Footer -->
+  <text x="${width/2}" y="${height*0.85}" 
+        text-anchor="middle" 
+        font-family="Microsoft YaHei, PingFang SC, Hiragino Sans GB, Source Han Sans SC, Noto Sans SC, WenQuanYi Micro Hei, SimHei, SimSun, Arial, sans-serif"
+        font-size="12" 
+        fill="#ced4da">PPT Screenshot Service • ${new Date().toLocaleString('zh-CN')}</text>
+        
+  <!-- Dimensions info -->
+  <text x="${width/2}" y="${height*0.92}" 
+        text-anchor="middle" 
+        font-family="Microsoft YaHei, PingFang SC, Hiragino Sans GB, Source Han Sans SC, Noto Sans SC, WenQuanYi Micro Hei, SimHei, SimSun, Arial, sans-serif"
+        font-size="10" 
+        fill="#ced4da">Size: ${width} × ${height}</text>
+</svg>`;
+
+    return Buffer.from(svg, 'utf-8');
   }
 
-  async captureScreenshot(htmlContent, width, height, options = {}) {
-    console.log('使用兼容方法captureScreenshot，建议使用generateScreenshot');
-    return this.generateScreenshot(htmlContent, options);
+  // Get service status
+  getStatus() {
+    return {
+      puppeteerReady: this.puppeteerReady,
+      playwrightReady: this.playwrightReady,
+      environment: process.env.NODE_ENV || 'development',
+      isHuggingFace: !!process.env.SPACE_ID
+    };
   }
 
+  // Cleanup resources
   async cleanup() {
-    await Promise.all([
-      this.closeBrowser(),
-      this.closePlaywrightBrowser()
-    ]);
+    console.log('🧹 Cleaning up screenshot service...');
+    
+    if (this.puppeteerBrowser) {
+      try {
+        await this.puppeteerBrowser.close();
+        this.puppeteerBrowser = null;
+        this.puppeteerReady = false;
+        console.log('✅ Puppeteer browser closed');
+      } catch (error) {
+        console.error('Error closing Puppeteer browser:', error);
+      }
+    }
+    
+    if (this.playwrightBrowser) {
+      try {
+        await this.playwrightBrowser.close();
+        this.playwrightBrowser = null;
+        this.playwrightReady = false;
+        console.log('✅ Playwright browser closed');
+      } catch (error) {
+        console.error('Error closing Playwright browser:', error);
+      }
+    }
   }
 }
 
-const screenshotService = new ScreenshotService();
-
-process.on('exit', async () => {
-  await screenshotService.cleanup();
-});
-
-process.on('SIGINT', async () => {
-  await screenshotService.cleanup();
-  process.exit(0);
-});
-
-process.on('SIGTERM', async () => {
-  await screenshotService.cleanup();
-  process.exit(0);
-});
-
-export default screenshotService;
+export default new ScreenshotService();