CodeBuddy Craft智能体是架构师的“好帮手“

iVault-App/
├── src/
│   ├── assets/         # 图标、字体等静态资源
│   ├── components/     # 可复用UI组件
│   │   ├── common/     # 通用组件
│   │   ├── auth/       # 认证相关组件
│   │   ├── media/      # 媒体处理组件
│   ├── screens/        # 应用屏幕
│   │   ├── auth/       # 认证屏幕
│   │   ├── home/       # 主屏幕
│   │   ├── media/      # 媒体浏览屏幕
│   │   ├── settings/   # 设置屏幕
│   │   ├── transfer/   # 传输屏幕
│   ├── navigation/     # 导航配置
│   ├── services/       # API和本地服务
│   │   ├── api/        # 后端API交互
│   │   ├── storage/    # 本地存储服务
│   │   ├── encryption/ # 加密服务
│   │   ├── media/      # 媒体处理服务
│   ├── store/          # Redux状态管理
│   ├── utils/          # 工具函数
│   ├── constants/      # 常量定义
│   ├── App.js          # 应用入口
├── api/                # 后端服务
│   ├── src/
│   │   ├── controllers/# API控制器
│   │   ├── models/     # 数据模型
│   │   ├── routes/     # API路由
│   │   ├── services/   # 业务逻辑
│   │   ├── middleware/ # 中间件
│   │   ├── utils/      # 工具函数
│   │   ├── app.js      # 服务入口
├── scripts/            # 构建脚本
├── tests/              # 测试代码
├── docs/               # 项目文档

// src/services/auth/authService.js
import { encryptData, decryptData, hashPassword } from '../encryption/encryptionService';
import { secureStore } from '../storage/secureStorage';
import * as LocalAuthentication from 'expo-local-authentication';

export class AuthService {
  // 初始化设置
  async setupAuthentication(password, useGesture, useBiometric) {
    try {
      // 生成密码哈希
      const passwordHash = await hashPassword(password);
      
      // 保存认证设置
      await secureStore.setItem('auth_settings', encryptData(JSON.stringify({
        passwordHash,
        useGesture,
        useBiometric,
        setupComplete: true
      })));
      
      return { success: true };
    } catch (error) {
      console.error('Setup authentication failed:', error);
      return { success: false, error };
    }
  }
  
  // 验证密码
  async verifyPassword(password) {
    try {
      const authSettings = JSON.parse(
        decryptData(await secureStore.getItem('auth_settings'))
      );
      
      const inputHash = await hashPassword(password);
      return { 
        success: inputHash === authSettings.passwordHash 
      };
    } catch (error) {
      console.error('Password verification failed:', error);
      return { success: false, error };
    }
  }
  
  // 生物识别认证
  async authenticateWithBiometrics() {
    try {
      const authSettings = JSON.parse(
        decryptData(await secureStore.getItem('auth_settings'))
      );
      
      if (!authSettings.useBiometric) {
        return { success: false, error: 'Biometric authentication not enabled' };
      }
      
      const result = await LocalAuthentication.authenticateAsync({
        promptMessage: '使用生物识别解锁',
        fallbackLabel: '使用密码',
        disableDeviceFallback: false,
      });
      
      return { success: result.success };
    } catch (error) {
      console.error('Biometric authentication failed:', error);
      return { success: false, error };
    }
  }
  
  // 手势认证
  async verifyGesturePattern(pattern) {
    try {
      const authSettings = JSON.parse(
        decryptData(await secureStore.getItem('auth_settings'))
      );
      
      if (!authSettings.useGesture) {
        return { success: false, error: 'Gesture authentication not enabled' };
      }
      
      const savedPattern = JSON.parse(
        decryptData(await secureStore.getItem('gesture_pattern'))
      );
      
      // 比较手势模式
      const isMatch = pattern.length === savedPattern.length && 
        pattern.every((point, index) => 
          point.row === savedPattern[index].row && 
          point.col === savedPattern[index].col
        );
      
      return { success: isMatch };
    } catch (error) {
      console.error('Gesture verification failed:', error);
      return { success: false, error };
    }
  }
}

export default new AuthService();

// src/services/media/mediaEncryptionService.js
import { encryptFile, decryptFile } from '../encryption/encryptionService';
import { fileSystem } from '../storage/fileSystemService';
import { generateUUID } from '../../utils/idGenerator';

export class MediaEncryptionService {
  // 加密并保存媒体文件
  async encryptAndSaveMedia(fileUri, mediaType, password, metadata = {}) {
    try {
      // 生成唯一文件名
      const encryptedFileName = `${generateUUID()}.enc`;
      const metadataFileName = `${encryptedFileName}.meta`;
      
      // 确定保存路径
      const baseDir = await this.getMediaTypeDirectory(mediaType);
      const encryptedFilePath = `${baseDir}/${encryptedFileName}`;
      const metadataFilePath = `${baseDir}/${metadataFileName}`;
      
      // 加密文件
      await encryptFile(fileUri, encryptedFilePath, password);
      
      // 保存元数据
      const encryptedMetadata = encryptData(JSON.stringify({
        originalName: metadata.name || 'Unknown',
        size: metadata.size,
        mimeType: metadata.mimeType,
        createdAt: new Date().toISOString(),
        thumbnail: metadata.thumbnail,
        isEncrypted: true,
        mediaType
      }), password);
      
      await fileSystem.writeFile(metadataFilePath, encryptedMetadata, {
        encoding: 'utf8'
      });
      
      return {
        success: true,
        fileId: encryptedFileName
      };
    } catch (error) {
      console.error('Media encryption failed:', error);
      return { success: false, error };
    }
  }
  
  // 解密并访问媒体文件
  async decryptAndAccessMedia(fileId, password) {
    try {
      // 查找文件
      const mediaInfo = await this.getMediaInfo(fileId);
      if (!mediaInfo) {
        throw new Error('File not found');
      }
      
      // 解密文件到临时目录
      const tempDir = `${fileSystem.cacheDirectory}/temp`;
      await fileSystem.makeDirectory(tempDir, { intermediates: true });
      
      const tempFilePath = `${tempDir}/${mediaInfo.originalName}`;
      
      await decryptFile(
        `${mediaInfo.directory}/${fileId}`, 
        tempFilePath, 
        password
      );
      
      return {
        success: true,
        uri: tempFilePath,
        mediaInfo
      };
    } catch (error) {
      console.error('Media decryption failed:', error);
      return { success: false, error };
    }
  }
  
  // 获取媒体文件信息
  async getMediaInfo(fileId) {
    try {
      // 查找所有媒体目录
      const mediaTypes = ['photos', 'videos', 'audio', 'documents'];
      
      for (const mediaType of mediaTypes) {
        const baseDir = await this.getMediaTypeDirectory(mediaType);
        const metadataPath = `${baseDir}/${fileId}.meta`;
        
        if (await fileSystem.exists(metadataPath)) {
          const encryptedMetadata = await fileSystem.readFile(metadataPath, {
            encoding: 'utf8'
          });
          
          // 注意：这里不解密元数据，因为我们还不知道密码
          // 仅返回文件位置信息
          return {
            id: fileId,
            directory: baseDir,
            metadataPath,
            encryptedMetadata,
            mediaType
          };
        }
      }
      
      return null;
    } catch (error) {
      console.error('Get media info failed:', error);
      return null;
    }
  }
  
  // 获取媒体类型对应的目录
  async getMediaTypeDirectory(mediaType) {
    const baseDir = `${fileSystem.documentDirectory}media`;
    const typeDir = `${baseDir}/${mediaType}`;
    
    // 确保目录存在
    if (!(await fileSystem.exists(typeDir))) {
      await fileSystem.makeDirectory(typeDir, { intermediates: true });
    }
    
    return typeDir;
  }
}

export default new MediaEncryptionService();

// src/services/transfer/wifiTransferService.js
import { NetworkInfo } from 'react-native-network-info';
import { createServer } from 'react-native-http-server';
import QRCode from 'react-native-qrcode-svg';
import { fileSystem } from '../storage/fileSystemService';
import { checkFileAccess } from '../encryption/accessControlService';

export class WifiTransferService {
  constructor() {
    this.server = null;
    this.port = 8080;
    this.ipAddress = null;
    this.isRunning = false;
    this.allowUpload = true;
    this.allowDownload = true;
  }
  
  // 启动传输服务器
  async startServer() {
    try {
      if (this.isRunning) {
        return { 
          success: true, 
          serverUrl: `http://${this.ipAddress}:${this.port}`,
          isAlreadyRunning: true
        };
      }
      
      // 获取设备IP地址
      this.ipAddress = await NetworkInfo.getIPAddress();
      
      // 创建HTTP服务器
      this.server = createServer({
        port: this.port,
        middleware: [
          // 跨域支持
          (req, res, next) => {
            res.setHeader('Access-Control-Allow-Origin', '*');
            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
            next();
          }
        ]
      });
      
      // 配置路由
      this.setupRoutes();
      
      // 启动服务器
      await this.server.start();
      this.isRunning = true;
      
      return { 
        success: true, 
        serverUrl: `http://${this.ipAddress}:${this.port}` 
      };
    } catch (error) {
      console.error('Starting WiFi transfer server failed:', error);
      return { success: false, error };
    }
  }
  
  // 停止传输服务器
  async stopServer() {
    if (!this.isRunning) {
      return { success: true, isAlreadyStopped: true };
    }
    
    try {
      await this.server.stop();
      this.isRunning = false;
      return { success: true };
    } catch (error) {
      console.error('Stopping WiFi transfer server failed:', error);
      return { success: false, error };
    }
  }
  
  // 设置服务器配置
  setServerConfig({ allowUpload, allowDownload }) {
    this.allowUpload = allowUpload;
    this.allowDownload = allowDownload;
    
    return { success: true };
  }
  
  // 生成服务器访问二维码
  generateQRCode(callback) {
    if (!this.isRunning) {
      callback(null, new Error('Server not running'));
      return;
    }
    
    const url = `http://${this.ipAddress}:${this.port}`;
    QRCode.toString(url, { type: 'svg' }, callback);
  }
  
  // 配置服务器路由
  setupRoutes() {
    // 主页路由
    this.server.get('/', (req, res) => {
      res.send(`
        <!DOCTYPE html>
        <html>
          <head>
            <title>iVault WiFi Transfer</title>
            <meta name="viewport" content="width=device-width, initial-scale=1.0">
            <style>
              body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; padding: 20px; max-width: 800px; margin: 0 auto; }
              .header { text-align: center; margin-bottom: 40px; }
              .section { margin-bottom: 30px; }
              .file-list { border: 1px solid #eee; border-radius: 8px; overflow: hidden; }
              .file-item { padding: 15px; border-bottom: 1px solid #eee; display: flex; align-items: center; }
              .file-item:last-child { border-bottom: none; }
              .file-icon { margin-right: 15px; width: 40px; text-align: center; font-size: 24px; }
              .file-info { flex: 1; }
              .file-name { font-weight: 600; margin-bottom: 5px; }
              .file-meta { font-size: 12px; color: #666; }
              .upload-zone { border: 2px dashed #ccc; padding: 30px; text-align: center; border-radius: 8px; margin-bottom: 20px; }
              .button { background: #007AFF; color: white; padding: 10px 20px; border-radius: 8px; border: none; font-size: 16px; cursor: pointer; }
              .button:disabled { background: #ccc; }
            </style>
          </head>
          <body>
            <div class="header">
              <h1>iVault WiFi Transfer</h1>
              <p>通过WiFi在设备间传输文件</p>
            </div>
            
            ${this.allowUpload ? `
            <div class="section">
              <h2>上传文件</h2>
              <div class="upload-zone" id="dropZone">
                <p>拖放文件到此处，或</p>
                <input type="file" id="fileInput" multiple style="display: none;" />
                <button class="button" onclick="document.getElementById('fileInput').click()">选择文件</button>
              </div>
              <div id="uploadProgress"></div>
            </div>
            ` : ''}
            
            ${this.allowDownload ? `
            <div class="section">
              <h2>可下载文件</h2>
              <div class="file-list" id="fileList">
                <div class="file-item">
                  <div class="file-icon">📁</div>
                  <div class="file-info">
                    <div class="file-name">加载中...</div>
                  </div>
                </div>
              </div>
            </div>
            ` : ''}
            
            <script>
              // 此处添加前端JavaScript代码处理上传下载逻辑
              // ...
            </script>
          </body>
        </html>
      `);
    });
    
    // 文件列表API
    this.server.get('/api/files', async (req, res) => {
      if (!this.allowDownload) {
        res.status(403).json({ error: 'Download not allowed' });
        return;
      }
      
      try {
        const files = await this.getAccessibleFiles();
        res.json({ files });
      } catch (error) {
        res.status(500).json({ error: error.message });
      }
    });
    
    // 文件下载API
    this.server.get('/api/files/:fileId', async (req, res) => {
      if (!this.allowDownload) {
        res.status(403).json({ error: 'Download not allowed' });
        return;
      }
      
      try {
        const { fileId } = req.params;
        const fileAccess = await checkFileAccess(fileId);
        
        if (!fileAccess.canAccess) {
          res.status(403).json({ error: 'Access denied' });
          return;
        }
        
        // 设置响应头
        res.setHeader('Content-Type', fileAccess.mimeType);
        res.setHeader('Content-Disposition', `attachment; filename="${fileAccess.filename}"`);
        
        // 发送文件
        const fileStream = await fileSystem.createReadStream(fileAccess.path);
        fileStream.pipe(res);
      } catch (error) {
        res.status(500).json({ error: error.message });
      }
    });
    
    // 文件上传API
    this.server.post('/api/upload', async (req, res) => {
      if (!this.allowUpload) {
        res.status(403).json({ error: 'Upload not allowed' });
        return;
      }
      
      try {
        // 处理文件上传逻辑
        // ...
        
        res.json({ success: true });
      } catch (error) {
        res.status(500).json({ error: error.message });
      }
    });
  }
  
  // 获取可访问的文件
  async getAccessibleFiles() {
    // 实现获取可访问文件的逻辑
    // ...
    
    return [];
  }
}

export default new WifiTransferService();