Update server.js

server.js

@@ -1,22 +1,32 @@
 import express from 'express';
-import http from 'http';
+import http from 'http'; // Нужен для второго сервера
 import { spawn } from 'child_process';
-import url from 'url';
+import url from 'url'; // Нужен для formatRequestInfo для второго сервера
+import fetch from 'node-fetch';
 
-const EXPRESS_PORT = 3000; // Внутренний порт для Express-приложения (для туннеля)
-const HF_PORT = 7860;      // Порт для Hugging Face
+const PROXY_PORT = 3000; // Порт для CORS-прокси (будет туннелироваться)
+const SECONDARY_SERVER_PORT = 7860; // Порт для второго сервера (Hugging Face / Hello World)
 
-// Функция для форматирования информации о запросе
-function formatRequestInfo(req, isExpress = true) {
+// Функция для форматирования информации о запросе (из оригинального server.js.txt)
+// Немного адаптирована, чтобы можно было использовать для обоих типов серверов
+function formatRequestInfo(req, serverType = 'express') {
   let info = 'ИНФОРМАЦИЯ О ЗАПРОСЕ:\n\n';
+  let reqUrl, queryParams, clientIp;
+
+  if (serverType === 'express') {
+    reqUrl = req.originalUrl;
+    queryParams = req.query;
+    clientIp = req.ip;
+  } else { // 'http'
+    reqUrl = req.url;
+    queryParams = url.parse(req.url, true).query;
+    clientIp = req.socket.remoteAddress;
+  }
 
-  // Основная информация
   info += `Метод запроса: ${req.method}\n`;
-  info += `URL: ${isExpress ? req.originalUrl : req.url}\n`;
-  info += `IP клиента: ${isExpress ? req.ip : req.socket.remoteAddress}\n\n`;
+  info += `URL: ${reqUrl}\n`;
+  info += `IP клиента: ${clientIp}\n\n`;
 
-  // Query параметры
-  const queryParams = isExpress ? req.query : url.parse(req.url, true).query;
   info += 'QUERY ПАРАМЕТРЫ:\n';
   if (Object.keys(queryParams).length === 0) {
     info += '(нет параметров)\n';
@@ -27,50 +37,181 @@ function formatRequestInfo(req, isExpress = true) {
   }
   info += '\n';
 
-  // Заголовки запроса
   info += 'ЗАГОЛОВКИ ЗАПРОСА:\n';
   const headers = req.headers;
   for (const [key, value] of Object.entries(headers)) {
     info += `${key}: ${value}\n`;
   }
 
-  // User-Agent (информация о браузере)
   info += '\nИНФОРМАЦИЯ О БРАУЗЕРЕ:\n';
   info += headers['user-agent'] || 'Информация недоступна';
 
   return info;
 }
 
-// --- Сервер 1: Express-приложение для localhost.run ---
-const app = express();
+// --- Сервер 1: CORS Proxy на порту PROXY_PORT (будет туннелироваться) ---
+const proxyApp = express();
+
+proxyApp.use(express.raw({
+  type: '*/*',
+  limit: '100mb'
+}));
+
+function addCorsHeaders(res, clientRequestOrigin) {
+  if (clientRequestOrigin) {
+    res.setHeader('Access-Control-Allow-Origin', clientRequestOrigin);
+    res.setHeader('Access-Control-Allow-Credentials', 'true');
+    res.setHeader('Vary', 'Origin');
+  } else {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+  }
+}
+
+proxyApp.options('*', (req, res) => {
+  const origin = req.headers.origin;
+  addCorsHeaders(res, origin);
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD');
+  const requestedHeaders = req.headers['access-control-request-headers'];
+  if (requestedHeaders) {
+    res.setHeader('Access-Control-Allow-Headers', requestedHeaders);
+  } else {
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With, X-CSRF-Token, Accept, Origin, User-Agent');
+  }
+  res.setHeader('Access-Control-Max-Age', '86400');
+  res.status(204).end();
+});
 
-app.get('*', (req, res) => {
-  const requestInfo = formatRequestInfo(req);
+proxyApp.get('/', (req, res) => {
+  const origin = req.headers.origin;
+  addCorsHeaders(res, origin);
   res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-  res.send(requestInfo);
+  res.send(`CORS Proxy is running on port ${PROXY_PORT}. Append target URL to proxy, e.g., /http://example.com. Tunnel will be established for this port.`);
 });
 
-app.listen(EXPRESS_PORT, () => {
-  console.log(`Express server (для туннеля) слушает порт ${EXPRESS_PORT}`);
+proxyApp.all('*', async (req, res) => {
+  if (req.path === '/') {
+    return; 
+  }
+
+  const clientRequestOrigin = req.headers.origin;
+
+  try {
+    let targetUrlString = req.url.substring(1);
+    try {
+      const decoded = decodeURIComponent(targetUrlString);
+      if (decoded.startsWith('http://') || decoded.startsWith('https://')) {
+        targetUrlString = decoded;
+      }
+    } catch (e) { /* Игнорируем ошибку декодирования, используем как есть */ }
+
+    if (!targetUrlString) {
+      addCorsHeaders(res, clientRequestOrigin);
+      res.status(400).send('Target URL is missing in the path.');
+      return;
+    }
+
+    if (!targetUrlString.match(/^https?:\/\//i)) {
+        if (!targetUrlString.startsWith('http://') && !targetUrlString.startsWith('https://')) {
+            targetUrlString = 'http://' + targetUrlString;
+        }
+    }
 
-  // Запускаем туннель localhost.run ПОСЛЕ того, как Express-сервер стартовал
-  console.log(`Попытка запустить туннель localhost.run для порта ${EXPRESS_PORT}...`);
+    let targetUrl;
+    try {
+        targetUrl = new URL(targetUrlString);
+    } catch (e) {
+        addCorsHeaders(res, clientRequestOrigin);
+        res.status(400).send(`Invalid target URL provided in path: ${targetUrlString}. Error: ${e.message}`);
+        return;
+    }
+    
+    const requestHeaders = {...req.headers};
+    delete requestHeaders['host'];
+    delete requestHeaders['content-length'];
+    delete requestHeaders['connection'];
+
+    const proxyResponse = await fetch(targetUrl.toString(), {
+      method: req.method,
+      headers: requestHeaders,
+      body: (req.method !== 'GET' && req.method !== 'HEAD' && req.body && req.body.length > 0) ? req.body : undefined,
+      redirect: 'manual',
+      compress: false
+    });
+
+    proxyResponse.headers.forEach((value, key) => {
+        const lowerKey = key.toLowerCase();
+        if (!lowerKey.startsWith('access-control-') && 
+            !['strict-transport-security', 'content-security-policy', 'public-key-pins', 
+             'transfer-encoding', 'connection', 'keep-alive', 'proxy-authenticate', 
+             'proxy-authorization', 'te', 'trailers', 'upgrade'].includes(lowerKey)
+        ) {
+            res.setHeader(key, value);
+        }
+    });
+    
+    addCorsHeaders(res, clientRequestOrigin);
+    const exposedHeaders = Array.from(proxyResponse.headers.keys()).filter(key => 
+        !key.toLowerCase().startsWith('access-control-') &&
+        key.toLowerCase() !== 'transfer-encoding' &&
+        key.toLowerCase() !== 'connection'
+    ).join(', ');
+
+    if (exposedHeaders) {
+        res.setHeader('Access-Control-Expose-Headers', exposedHeaders);
+    } else {
+        res.setHeader('Access-Control-Expose-Headers', '*');
+    }
+    
+    res.status(proxyResponse.status);
+
+    if (proxyResponse.body) {
+        proxyResponse.body.pipe(res);
+    } else {
+        res.end();
+    }
+
+  } catch (error) {
+    console.error('Proxy error:', error);
+    if (!res.headersSent) {
+      addCorsHeaders(res, clientRequestOrigin);
+      let statusCode = 500;
+      let message = 'Proxy error occurred.';
+      if (error.code === 'ENOTFOUND' || error.cause?.code === 'ENOTFOUND') {
+          statusCode = 404; message = `Target host not found: ${req.url.substring(1)}`;
+      } else if (error.message?.includes('Invalid URL') || (error.name === 'TypeError' && error.message?.includes('Invalid URL'))) {
+          statusCode = 400; message = `Invalid target URL in path: ${req.url.substring(1)}. Detail: ${error.message}`;
+      } else if (error.code === 'ECONNREFUSED' || error.cause?.code === 'ECONNREFUSED') {
+          statusCode = 502; message = `Bad Gateway: Could not connect to target server at ${req.url.substring(1)}`;
+      } else if (error.code === 'ERR_INVALID_URL') {
+          statusCode = 400; message = `Invalid target URL format in path: ${req.url.substring(1)}`;
+      }
+      res.status(statusCode).send(message);
+    } else {
+      res.end();
+    }
+  }
+});
+
+proxyApp.listen(PROXY_PORT, '0.0.0.0', () => {
+  console.log(`CORS Proxy server (для туннеля) слушает порт ${PROXY_PORT}`);
+
+  console.log(`Попытка запустить туннель localhost.run для порта ${PROXY_PORT}...`);
   const tunnel = spawn('ssh', [
-    '-R', `80:localhost:${EXPRESS_PORT}`, // Туннелируем порт 80 публичного URL на наш localhost:EXPRESS_PORT
-    '-o', 'StrictHostKeyChecking=no',    // Отключаем проверку ключа хоста для автоматизации
-    '-o', 'UserKnownHostsFile=/dev/null', // Не сохраняем ключи хостов
-    '-o', 'ServerAliveInterval=60',       // Поддерживать соединение активным
-    '-o', 'ExitOnForwardFailure=yes',     // Выйти, если форвардинг не удался
+    '-R', `80:localhost:${PROXY_PORT}`,
+    '-o', 'StrictHostKeyChecking=no',
+    '-o', 'UserKnownHostsFile=/dev/null',
+    '-o', 'ServerAliveInterval=60',
+    '-o', 'ExitOnForwardFailure=yes',
+    '-o', 'ConnectTimeout=10',
     'nokey@localhost.run'
   ]);
 
   tunnel.stdout.on('data', (data) => {
     const output = data.toString();
     console.log(`localhost.run stdout: ${output}`);
-    // Попытка извлечь URL из вывода
-    const urlMatch = output.match(/https?:\/\/[a-zA-Z0-9-]+\.lhr\.life/);
+    const urlMatch = output.match(/https?:\/\/[a-zA-Z0-9-]+\.(lhr\.life|lhr\.run|localhost\.run)/);
     if (urlMatch) {
-      console.log(`>>> Туннель активен: ${urlMatch[0]}`);
+      console.log(`>>> Туннель для PROXY (порт ${PROXY_PORT}) активен: ${urlMatch[0]}`);
     }
   });
 
@@ -87,17 +228,27 @@ app.listen(EXPRESS_PORT, () => {
   });
 });
 
-// --- Сервер 2: Простой HTTP-сервер для Hugging Face на порту 7860 ---
-const server2 = http.createServer((req, res) => {
-  const requestInfo = formatRequestInfo(req, false);
-  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
-  res.end(requestInfo);
+
+// --- Сервер 2: Простой HTTP-сервер на порту SECONDARY_SERVER_PORT (например, для Hugging Face / Hello World) ---
+// Ты просил оставить "Hello World" или оригинальный сервер. Я оставлю оригинальный, который показывает инфо о запросе.
+// Если нужен просто Hello World, замени тело обработчика.
+const secondaryServer = http.createServer((req, res) => {
+  if (req.url === '/' && req.method === 'GET') {
+    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end(`Hello World from secondary server on port ${SECONDARY_SERVER_PORT}!`);
+  } else {
+    // Показываем информацию о запросе для других путей, как в оригинале
+    const requestInfo = formatRequestInfo(req, 'http');
+    res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end(requestInfo);
+  }
 });
 
-server2.listen(HF_PORT, () => {
-  console.log(`Второй HTTP-сервер (для Hugging Face) слушает порт ${HF_PORT}`);
+secondaryServer.listen(SECONDARY_SERVER_PORT, '0.0.0.0', () => {
+  console.log(`Второй HTTP-сервер (для Hugging Face / Hello World) слушает порт ${SECONDARY_SERVER_PORT}`);
 });
 
+
 // Обработка сигналов для корректного завершения
 process.on('SIGINT', () => {
   console.log('Получен SIGINT. Завершение...');