Update src/lightweight-client.js

src/lightweight-client.js

@@ -1,398 +1,54 @@
-import express from 'express';
-import dotenv from 'dotenv';
-import { randomUUID } from 'crypto';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import chalk from 'chalk';
-import {
-  ChatMessage, ChatCompletionRequest, Choice, ChoiceDelta, ChatCompletionChunk
-} from './models.js';
-import {
-  initialize,
-  streamNotionResponse,
-  buildNotionRequest,
-  INITIALIZED_SUCCESSFULLY
-} from './lightweight-client.js';
-import { cookieManager } from './CookieManager.js';
-
-// 获取当前文件的目录路径
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// 加载环境变量
-dotenv.config({ path: join(dirname(__dirname), '.env') });
-
-// 活跃流管理器 - 用于跟踪和管理当前活跃的请求流
-const activeStreams = new Map();
-
-// 日志配置
-const logger = {
-  info: (message) => console.log(chalk.blue(`[info] ${message}`)),
-  error: (message) => console.error(chalk.red(`[error] ${message}`)),
-  warning: (message) => console.warn(chalk.yellow(`[warn] ${message}`)),
-  success: (message) => console.log(chalk.green(`[success] ${message}`)),
-  request: (method, path, status, time) => {
-    const statusColor = status >= 500 ? chalk.red : 
-                        status >= 400 ? chalk.yellow : 
-                        status >= 300 ? chalk.cyan : 
-                        status >= 200 ? chalk.green : chalk.white;
-    console.log(`${chalk.magenta(`[${method}]`)} - ${path} ${statusColor(status)} ${chalk.gray(`${time}ms`)}`);
-  }
-};
-
-// 认证配置
-const EXPECTED_TOKEN = process.env.PROXY_AUTH_TOKEN || "default_token";
-
-// 代理配置
-const PROXY_URL = process.env.PROXY_URL;
-
-// 代理验证函数
-async function validateProxy() {
-  if (!PROXY_URL) {
-    logger.info('未配置代理，将使用直连访问');
-    return true;
-  }
-  
-  try {
-    const { default: fetch } = await import('node-fetch');
-    const { HttpsProxyAgent } = await import('https-proxy-agent');
-    
-    const testResponse = await fetch('https://httpbin.org/ip', {
-      method: 'GET',
-      agent: new HttpsProxyAgent(PROXY_URL),
-      timeout: 15000
-    });
-    
-    if (testResponse.ok) {
-      const ipInfo = await testResponse.json();
-      // 隐藏密码的安全日志输出
-      const safeProxyUrl = PROXY_URL.replace(/:([^:@]+)@/, ':****@');
-      logger.success(`✅ 代理验证成功 - IP: ${ipInfo.origin} - 代理: ${safeProxyUrl}`);
-      return true;
-    } else {
-      logger.error(`❌ 代理验证失败 - 状态码: ${testResponse.status}`);
-      return false;
-    }
-  } catch (error) {
-    logger.error(`❌ 代理验证异常: ${error.message}`);
-    return false;
-  }
-}
-
-// 创建Express应用
-const app = express();
-app.use(express.json({ limit: '50mb' }));
-app.use(express.urlencoded({ extended: true, limit: '50mb' }));
+// 启动服务器
+const PORT = process.env.PORT || 7860;
 
-// 请求日志中间件
-app.use((req, res, next) => {
-  const start = Date.now();
-  
-  // 保存原始的 end 方法
-  const originalEnd = res.end;
-  
-  // 重写 end 方法以记录请求完成时间
-  res.end = function(...args) {
-    const duration = Date.now() - start;
-    logger.request(req.method, req.path, res.statusCode, duration);
-    return originalEnd.apply(this, args);
-  };
-  
-  next();
-});
+// 简化的启动流程
+console.log('🚀 开始启动服务器...');
 
-// 认证中间件
-function authenticate(req, res, next) {
-  const authHeader = req.headers.authorization;
+// 先启动服务器，再异步初始化
+app.listen(PORT, '0.0.0.0', () => {
+  logger.success(`🚀 服务器已在 0.0.0.0:${PORT} 启动成功`);
+  logger.info(`📡 访问地址: http://0.0.0.0:${PORT}`);
   
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    return res.status(401).json({
-      error: {
-        message: "Authentication required. Please provide a valid Bearer token.",
-        type: "authentication_error"
-      }
-    });
+  // 显示代理配置
+  if (PROXY_URL) {
+    const safeProxyUrl = PROXY_URL.replace(/:([^:@]+)@/, ':****@');
+    logger.info(`🌐 代理配置: ${safeProxyUrl}`);
+  } else {
+    logger.info(`🌐 代理配置: 直连模式`);
   }
   
-  const token = authHeader.split(' ')[1];
-  
-  if (token !== EXPECTED_TOKEN) {
-    return res.status(401).json({
-      error: {
-        message: "Invalid authentication credentials",
-        type: "authentication_error"
-      }
-    });
-  }
-  
-  next();
-}
-
-// 流管理函数
-function manageStream(clientId, stream) {
-  // 如果该客户端已有活跃流，先关闭它
-  if (activeStreams.has(clientId)) {
+  // 异步初始化，避免阻塞启动
+  setTimeout(async () => {
     try {
-      const oldStream = activeStreams.get(clientId);
-      logger.info(`关闭客户端 ${clientId} 的旧流`);
-      oldStream.end();
-    } catch (error) {
-      logger.error(`关闭旧流时出错: ${error.message}`);
-    }
-  }
-  
-  // 注册新流
-  activeStreams.set(clientId, stream);
-  
-  // 当���结束时从管理器中移除
-  stream.on('end', () => {
-    if (activeStreams.get(clientId) === stream) {
-      activeStreams.delete(clientId);
-      //logger.info(`客户端 ${clientId} 的流已结束并移除`);
-    }
-  });
-  
-  stream.on('error', (error) => {
-    logger.error(`流错误: ${error.message}`);
-    if (activeStreams.get(clientId) === stream) {
-      activeStreams.delete(clientId);
-    }
-  });
-  
-  return stream;
-}
-
-// API路由
-
-// 获取模型列表
-app.get('/v1/models', authenticate, (req, res) => {
-  // 返回可用模型列表
-  const modelList = {
-    data: [
-      { id: "openai-gpt-4.1" },
-      { id: "anthropic-opus-4" },
-      { id: "anthropic-sonnet-4" },
-      { id: "anthropic-sonnet-3.x-stable" },
-      { id: "google-gemini-2.5-pro"}, //vertex-gemini-2.5-pro
-      { id: "google-gemini-2.5-flash"}, //vertex-gemini-2.5-flash
-    ]
-  };
-  
-  res.json(modelList);
-});
-
-// 聊天完成端点
-app.post('/v1/chat/completions', authenticate, async (req, res) => {
-  try {
-    // 生成或获取客户端ID
-    const clientId = req.headers['x-client-id'] || randomUUID();
-    
-    // 检查是否成功初始化
-    if (!INITIALIZED_SUCCESSFULLY) {
-      return res.status(500).json({
-        error: {
-          message: "系统未成功初始化。请检查您的NOTION_COOKIE是否有效。",
-          type: "server_error"
-        }
-      });
-    }
-    
-    // 检查是否有可用的cookie
-    if (cookieManager.getValidCount() === 0) {
-      return res.status(500).json({
-        error: {
-          message: "没有可用的有效cookie。请检查您的NOTION_COOKIE配置。",
-          type: "server_error"
-        }
-      });
-    }
-    
-    // 验证请求数据
-    const requestData = req.body;
-    
-    if (!requestData.messages || !Array.isArray(requestData.messages) || requestData.messages.length === 0) {
-      return res.status(400).json({
-        error: {
-          message: "Invalid request: 'messages' field must be a non-empty array.",
-          type: "invalid_request_error"
-        }
-      });
-    }
-    
-    // 构建Notion请求
-    const notionRequestBody = buildNotionRequest(requestData);
-    
-    // 处理流式响应
-    if (requestData.stream) {
-      res.setHeader('Content-Type', 'text/event-stream');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Connection', 'keep-alive');
-      
-      logger.info(`开始流式响应`);
-      const stream = await streamNotionResponse(notionRequestBody);
-      
-      // 管理流
-      manageStream(clientId, stream);
+      logger.info('🔧 开始系统初始化...');
       
-      stream.pipe(res);
+      // 初始化系统
+      const initResult = await initialize();
+      INITIALIZED_SUCCESSFULLY = initResult !== false;
       
-      // 处理客户端断开连接
-      req.on('close', () => {
-        logger.info(`客户端 ${clientId} 断开连接`);
-        if (activeStreams.has(clientId)) {
-          try {
-            activeStreams.get(clientId).end();
-            activeStreams.delete(clientId);
-          } catch (error) {
-            logger.error(`关闭流时出错: ${error.message}`);
-          }
+      // 验证代理（如果配置了）
+      if (PROXY_URL) {
+        try {
+          await validateProxy();
+        } catch (error) {
+          logger.warning(`代理验证失败: ${error.message}`);
         }
-      });
-    } else {
-      // 非流式响应
-      // 创建一个内部流来收集完整响应
-      logger.info(`开始非流式响应`);
-      const chunks = [];
-      const stream = await streamNotionResponse(notionRequestBody);
-      
-      // 管理流
-      manageStream(clientId, stream);
+      }
       
-      return new Promise((resolve, reject) => {
-        stream.on('data', (chunk) => {
-          const chunkStr = chunk.toString();
-          if (chunkStr.startsWith('data: ') && !chunkStr.includes('[DONE]')) {
-            try {
-              const dataJson = chunkStr.substring(6).trim();
-              if (dataJson) {
-                const chunkData = JSON.parse(dataJson);
-                if (chunkData.choices && chunkData.choices[0].delta && chunkData.choices[0].delta.content) {
-                  chunks.push(chunkData.choices[0].delta.content);
-                }
-              }
-            } catch (error) {
-              logger.error(`解析非流式响应块时出错: ${error}`);
-            }
-          }
-        });
-        
-        stream.on('end', () => {
-          const fullResponse = {
-            id: `chatcmpl-${randomUUID()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1000),
-            model: requestData.model,
-            choices: [
-              {
-                index: 0,
-                message: {
-                  role: "assistant",
-                  content: chunks.join('')
-                },
-                finish_reason: "stop"
-              }
-            ],
-            usage: {
-              prompt_tokens: null,
-              completion_tokens: null,
-              total_tokens: null
-            }
-          };
-          
-          res.json(fullResponse);
-          resolve();
-        });
-        
-        stream.on('error', (error) => {
-          logger.error(`非流式响应出错: ${error}`);
-          reject(error);
-        });
-        
-        // 处理客户端断开连接
-        req.on('close', () => {
-          logger.info(`客户端 ${clientId} 断开连接（非流式）`);
-          if (activeStreams.has(clientId)) {
-            try {
-              activeStreams.get(clientId).end();
-              activeStreams.delete(clientId);
-            } catch (error) {
-              logger.error(`关闭流时出错: ${error.message}`);
-            }
-          }
-        });
-      });
-    }
-  } catch (error) {
-    logger.error(`聊天完成端点错误: ${error}`);
-    res.status(500).json({
-      error: {
-        message: `Internal server error: ${error.message}`,
-        type: "server_error"
+      // 显示最终状态
+      if (INITIALIZED_SUCCESSFULLY) {
+        logger.success(`✅ 系统初始化完成`);
+        logger.success(`🍪 可用Cookie数量: ${cookieManager.getValidCount()}`);
+      } else {
+        logger.warning(`❌ 系统初始化失败`);
+        logger.warning(`⚠️  请检查NOTION_COOKIE配置`);
       }
-    });
-  }
-});
-
-// 健康检查端点
-app.get('/health', (req, res) => {
-  res.json({
-    status: 'ok',
-    timestamp: new Date().toISOString(),
-    initialized: INITIALIZED_SUCCESSFULLY,
-    valid_cookies: cookieManager.getValidCount(),
-    active_streams: activeStreams.size,
-    proxy_configured: !!PROXY_URL
-  });
-});
-
-// Cookie状态查询端点
-app.get('/cookies/status', authenticate, (req, res) => {
-  res.json({
-    total_cookies: cookieManager.getValidCount(),
-    cookies: cookieManager.getStatus()
-  });
-});
-
-// 代理状态查询端点
-app.get('/proxy/status', authenticate, (req, res) => {
-  const safeProxyUrl = PROXY_URL ? PROXY_URL.replace(/:([^:@]+)@/, ':****@') : null;
-  res.json({
-    proxy_configured: !!PROXY_URL,
-    proxy_url: safeProxyUrl,
-    proxy_type: PROXY_URL ? 'fixed' : 'none'
-  });
-});
-
-// 启动服务器
-const PORT = process.env.PORT || 7860;
-
-// 初始化并启动服务器
-initialize().then(async () => {
-  // 验证代理配置
-  await validateProxy();
-  
-  // 将监听地址改为 '0.0.0.0'
-  app.listen(PORT, '0.0.0.0', () => {
-    logger.info(`服务已在 0.0.0.0:${PORT} 上启动`);
-    logger.info(`访问地址: http://0.0.0.0:${PORT}`);
-    
-    // 显示代理状态
-    if (PROXY_URL) {
-      const safeProxyUrl = PROXY_URL.replace(/:([^:@]+)@/, ':****@');
-      logger.info(`代理配置: ${safeProxyUrl}`);
-    } else {
-      logger.info(`代理配置: 未配置代理，使用直连`);
-    }
-    
-    if (INITIALIZED_SUCCESSFULLY) {
-      logger.success(`系统初始化状态: ✅`);
-      logger.success(`可用cookie数量: ${cookieManager.getValidCount()}`);
-    } else {
-      logger.warning(`系统初始化状态: ❌`);
-      logger.warning(`警告: 系统未成功初始化，API调用将无法正常工作`);
-      logger.warning(`请检查NOTION_COOKIE配置是否有效`);
+      
+      logger.success(`🎯 所有服务已就绪！`);
+      
+    } catch (error) {
+      logger.error(`❌ 初始化过程出错: ${error.message}`);
+      INITIALIZED_SUCCESSFULLY = false;
     }
-  });
-}).catch((error) => {
-  logger.error(`初始化失败: ${error}`);
+  }, 1000); // 1秒后开始初始化
 });