Update server.js

server.js

@@ -2,24 +2,25 @@ import express from 'express';
 import fs from 'fs/promises';
 import fssync from 'fs';
 import path from 'path';
-import { spawn } from 'child_process';
 import fetch from 'node-fetch';
 import { glob } from 'glob';
+import { createProxyMiddleware } from 'http-proxy-middleware';
 
 // --- Конфигурация ---
-const EXPRESS_PORT = parseInt(process.env.EXPRESS_PORT || '3001', 10);
+const APP_PORT = parseInt(process.env.PORT || '7860', 10); // HF устанавливает PORT
+const INTERNAL_TELEGRAM_API_PORT = parseInt(process.env.INTERNAL_TELEGRAM_API_PORT || '8081', 10);
 const TELEGRAM_DATA_DIR = process.env.TELEGRAM_DATA_DIR || '/var/lib/telegram-bot-api';
 const FILES_TTL_HOURS = parseInt(process.env.FILES_TTL || '-1', 10);
+const PROXY_TELEGRAM_PATH_PREFIX = process.env.PROXY_TELEGRAM_PATH_PREFIX || '/telegram';
+
 
 const GITHUB_USERNAME = process.env.GITHUB_USERNAME || '';
 const GITHUB_TOKEN = process.env.GITHUB_TOKEN || '';
 const ENV_GIST_ID = process.env.ENV_GIST_ID || '';
 
-let currentTunnelUrl = ''; // Будет обновляться при запуске туннеля
-
 const app = express();
 
-// ... (остальные вспомогательные функции без изменений) ...
+// --- Вспомогательные функции (formatBytes, getDirectoryStats, cleanupOldFiles) ---
 function formatBytes(bytes, decimals = 2) {
   if (bytes === 0) return '0 Bytes';
   const k = 1024;
@@ -37,9 +38,7 @@ async function getDirectoryStats(dirPath) {
       try {
         const stats = await fs.stat(file);
         totalSize += stats.size;
-      } catch (e) {
-        // Игнорируем ошибки для отдельных файлов (например, если файл удален во время сканирования)
-      }
+      } catch (e) { /* Игнор */ }
     }
     return {
       fileCount: files.length,
@@ -59,211 +58,142 @@ async function cleanupOldFiles(dirPath, ttlHours) {
   console.log(`[TTL] Starting cleanup for files older than ${ttlHours} hours in ${dirPath}`);
   const now = Date.now();
   const ttlMs = ttlHours * 60 * 60 * 1000;
-  let processed = 0;
-  let deleted = 0;
-  let errors = 0;
-
+  let processed = 0, deleted = 0, errors = 0;
   try {
     const files = await glob(`${dirPath}/**/*`, { nodir: true, dot: true, stat: true, withFileTypes: false });
-
     for (const file of files) {
       processed++;
       try {
-        const stats = await fs.stat(file); 
+        const stats = await fs.stat(file);
         if (stats.isFile()) {
-          const fileAge = now - stats.mtimeMs;
-          if (fileAge > ttlMs) {
+          if ((now - stats.mtimeMs) > ttlMs) {
             await fs.unlink(file);
             deleted++;
-            if (deleted % 100 === 0) console.log(`[TTL] Deleted ${deleted} old files so far...`);
           }
         }
-      } catch (e) {
-        console.error(`[TTL] Error processing file ${file}:`, e.message);
-        errors++;
-      }
+      } catch (e) { errors++; console.error(`[TTL] Error processing file ${file}:`, e.message); }
     }
   } catch (globError) {
      console.error(`[TTL] Error during glob search:`, globError);
      return { processed, deleted, errors: errors + 1, message: `Glob error: ${globError.message}` };
   }
-
   const result = { processed, deleted, errors, message: `Cleanup completed. Processed: ${processed}, Deleted: ${deleted}, Errors: ${errors}` };
   console.log(`[TTL] ${result.message}`);
   return result;
 }
 
-
 // --- Обновление Gist ---
-async function updateEnvGistInGithub(tunnelUrlToSave) {
+async function updateEnvGistInGithub() {
   if (!GITHUB_USERNAME || !GITHUB_TOKEN || !ENV_GIST_ID) {
     console.warn('Gist update skipped: GITHUB_USERNAME, GITHUB_TOKEN, or ENV_GIST_ID is not set.');
     return;
   }
   try {
     const spaceId = process.env.SPACE_ID || 'N/A';
-    const spaceHost = process.env.SPACE_HOST || 'N/A';
-    
-    // Используем более простое и статичное имя файла для Gist
-    const gistFilename = `hf_space_info.json`; 
+    const spaceHost = process.env.SPACE_HOST || 'N/A'; // e.g., your-user-your-space.hf.space
+    const publicSpaceUrl = spaceHost ? `https://${spaceHost}` : 'N/A';
 
+    const gistFilename = `hf_space_info.json`;
     const content = {
       last_updated: new Date().toISOString(),
       space_id: spaceId,
-      space_host: spaceHost,
-      tools_tunnel_url: tunnelUrlToSave || 'pending...',
-      telegram_api_main_port: 7860,
-      tools_app_internal_port: EXPRESS_PORT,
+      public_space_url: publicSpaceUrl,
+      tools_path_stats: `${publicSpaceUrl}/tools/stats`,
+      tools_path_file_base: `${publicSpaceUrl}/tools/file/`,
+      telegram_api_proxy_path: `${publicSpaceUrl}${PROXY_TELEGRAM_PATH_PREFIX}/bot<YOUR_BOT_TOKEN>/<METHOD>`,
+      app_main_port: APP_PORT,
+      internal_telegram_api_port: INTERNAL_TELEGRAM_API_PORT,
       files_ttl_hours: FILES_TTL_HOURS > 0 ? FILES_TTL_HOURS : 'disabled',
     };
-
     const gistData = {
-      description: `Hugging Face Space Info - ${spaceId}`, // Описание можно оставить динамическим
-      files: {
-        [gistFilename]: { // Используем новое имя файла
-          content: JSON.stringify(content, null, 2),
-        },
-      },
+      description: `Hugging Face Space Info - ${spaceId}`,
+      files: { [gistFilename]: { content: JSON.stringify(content, null, 2) } },
     };
-
-    console.log(`Attempting to update Gist ${ENV_GIST_ID} with filename ${gistFilename}`);
     const response = await fetch(`https://api.github.com/gists/${ENV_GIST_ID}`, {
       method: 'PATCH',
       headers: {
-        'Authorization': `token ${GITHUB_TOKEN}`,
-        'Accept': 'application/vnd.github.v3+json',
-        'User-Agent': 'HFSpaceTgAPITools',
-        'Content-Type': 'application/json',
+        'Authorization': `token ${GITHUB_TOKEN}`, 'Accept': 'application/vnd.github.v3+json',
+        'User-Agent': 'HFSpaceTgAPIProxyTools', 'Content-Type': 'application/json',
       },
       body: JSON.stringify(gistData),
     });
-
-    if (!response.ok) {
-      const errorBody = await response.text();
-      console.error(`GitHub API Response Status: ${response.status}`);
-      console.error(`GitHub API Response Body: ${errorBody}`);
-      throw new Error(`GitHub API error: ${response.status} - ${errorBody}`);
-    }
-    console.log(`Gist ${ENV_GIST_ID} updated successfully with tunnel URL: ${tunnelUrlToSave}`);
-  } catch (error) {
-    console.error('Error updating Gist:', error.message); // Выводим только сообщение об ошибке для краткости
-  }
+    if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${await response.text()}`);
+    console.log(`Gist ${ENV_GIST_ID} updated successfully.`);
+  } catch (error) { console.error('Error updating Gist:', error.message); }
 }
 
-
-// --- Маршруты Express ---
-// ... (маршруты без изменений) ...
-app.get('/', (req, res) => {
-  res.send(`Telegram API Tools. Tunnel: ${currentTunnelUrl || 'pending...'}. Stats: ${currentTunnelUrl}/stats. File base: ${currentTunnelUrl}/file/`);
+// --- Маршруты для инструментов ---
+const toolsRouter = express.Router();
+toolsRouter.get('/', (req, res) => {
+  const spaceHost = process.env.SPACE_HOST || 'your-space.hf.space';
+  res.send(`Telegram API Proxy & Tools. Stats: /tools/stats. File base: /tools/file/. Telegram API via: ${PROXY_TELEGRAM_PATH_PREFIX}/bot<TOKEN>/...`);
 });
-
-app.get('/stats', async (req, res) => {
+toolsRouter.get('/stats', async (req, res) => {
   const stats = await getDirectoryStats(TELEGRAM_DATA_DIR);
-  let ttlCleanupResult = { message: "TTL cleanup not run or disabled." };
+  let ttlResult = { message: "TTL cleanup not run or disabled." };
   if (req.query.run_ttl_now === 'true' && FILES_TTL_HOURS > 0) {
-      ttlCleanupResult = await cleanupOldFiles(TELEGRAM_DATA_DIR, FILES_TTL_HOURS);
+      ttlResult = await cleanupOldFiles(TELEGRAM_DATA_DIR, FILES_TTL_HOURS);
   }
-  res.json({
-    directory: TELEGRAM_DATA_DIR,
-    ...stats,
-    files_ttl_hours: FILES_TTL_HOURS > 0 ? FILES_TTL_HOURS : 'disabled',
-    ttl_cleanup_on_this_request: ttlCleanupResult
-  });
+  res.json({ directory: TELEGRAM_DATA_DIR, ...stats, files_ttl_hours: FILES_TTL_HOURS > 0 ? FILES_TTL_HOURS : 'disabled', ttl_cleanup_on_this_request: ttlResult });
 });
-
-app.get('/file/:filepath(*)', (req, res) => {
+toolsRouter.get('/file/:filepath(*)', (req, res) => {
   const relativePath = req.params.filepath;
-  if (!relativePath || relativePath.includes('..')) { 
-    return res.status(400).send('Invalid file path.');
-  }
-
+  if (!relativePath || relativePath.includes('..')) return res.status(400).send('Invalid file path.');
   const absoluteRequestedPath = path.normalize(path.join(TELEGRAM_DATA_DIR, relativePath));
-
-  if (!absoluteRequestedPath.startsWith(path.resolve(TELEGRAM_DATA_DIR))) {
-    return res.status(403).send('Forbidden: Access outside designated directory is not allowed.');
-  }
-
-  if (fssync.existsSync(absoluteRequestedPath)) {
-    const stats = fssync.statSync(absoluteRequestedPath);
-    if (stats.isFile()) {
-      res.sendFile(absoluteRequestedPath, (err) => {
-        if (err) {
-          console.error(`Error sending file ${absoluteRequestedPath}:`, err);
-          if (!res.headersSent) {
-            res.status(500).send('Error sending file.');
-          }
-        }
-      });
-    } else {
-      res.status(404).send('Path is not a file.');
-    }
-  } else {
-    res.status(404).send('File not found.');
-  }
+  if (!absoluteRequestedPath.startsWith(path.resolve(TELEGRAM_DATA_DIR))) return res.status(403).send('Forbidden.');
+  if (fssync.existsSync(absoluteRequestedPath) && fssync.statSync(absoluteRequestedPath).isFile()) {
+    res.sendFile(absoluteRequestedPath, err => {
+      if (err && !res.headersSent) res.status(500).send('Error sending file.');
+    });
+  } else res.status(404).send('File not found.');
 });
-
-// --- Запуск сервера и тунн��ля ---
-// ... (логика запуска сервера и туннеля без изменений) ...
-app.listen(EXPRESS_PORT, () => {
-  console.log(`Express server (for tools) listening on port ${EXPRESS_PORT}`);
-  console.log(`Attempting to start localhost.run tunnel for port ${EXPRESS_PORT}...`);
-
-  const tunnelProcess = spawn('ssh', [
-    '-R', `80:localhost:${EXPRESS_PORT}`,
-    '-o', 'StrictHostKeyChecking=no',
-    '-o', 'UserKnownHostsFile=/dev/null',
-    '-o', 'ServerAliveInterval=60',
-    '-o', 'ExitOnForwardFailure=yes',
-    '-o', 'LogLevel=ERROR', 
-    'nokey@localhost.run'
-  ]);
-
-  tunnelProcess.stdout.on('data', (data) => {
-    const output = data.toString();
-    const urlMatch = output.match(/https?:\/\/[a-zA-Z0-9-]+\.(lhr\.life|lhr\.run)/);
-    if (urlMatch && urlMatch[0] !== currentTunnelUrl) {
-      currentTunnelUrl = urlMatch[0];
-      console.log(`>>> Tools Tunnel active: ${currentTunnelUrl}`);
-      updateEnvGistInGithub(currentTunnelUrl).catch(console.error);
+app.use('/tools', toolsRouter);
+
+// --- Обратный прокси для Telegram Bot API ---
+app.use(PROXY_TELEGRAM_PATH_PREFIX, createProxyMiddleware({
+  target: `http://localhost:${INTERNAL_TELEGRAM_API_PORT}`,
+  changeOrigin: true,
+  pathRewrite: (path, req) => {
+    // Убираем префикс PROXY_TELEGRAM_PATH_PREFIX из пути перед отправкой на Telegram API
+    // Например, /telegram/bot<TOKEN>/getMe -> /bot<TOKEN>/getMe
+    return path.startsWith(PROXY_TELEGRAM_PATH_PREFIX) ? path.substring(PROXY_TELEGRAM_PATH_PREFIX.length) : path;
+  },
+  onProxyReq: (proxyReq, req, res) => {
+    console.log(`[Proxy] Request to Telegram API: ${req.method} ${proxyReq.path}`);
+  },
+  onError: (err, req, res) => {
+    console.error('[Proxy] Error:', err);
+    if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
     }
-    if (!urlMatch) {
-        console.log(`localhost.run stdout: ${output}`);
-    }
-  });
-
-  tunnelProcess.stderr.on('data', (data) => {
-    console.error(`localhost.run stderr: ${data.toString()}`);
-  });
+    res.end(JSON.stringify({ error: 'Proxy Error', message: err.message }));
+  }
+}));
 
-  tunnelProcess.on('close', (code) => {
-    console.log(`localhost.run tunnel process exited with code ${code}`);
-    currentTunnelUrl = ''; 
-    updateEnvGistInGithub('Tunnel closed or failed.').catch(console.error);
-  });
+// --- Корневой маршрут ---
+app.get('/', (req, res) => {
+  res.redirect('/tools');
+});
 
-  tunnelProcess.on('error', (err) => {
-    console.error('Failed to start localhost.run tunnel process:', err);
-    currentTunnelUrl = '';
-    updateEnvGistInGithub('Tunnel failed to start.').catch(console.error);
-  });
+// --- Запуск сервера ---
+app.listen(APP_PORT, () => {
+  console.log(`Main app (Reverse Proxy & Tools) listening on port ${APP_PORT}`);
+  console.log(`Telegram Bot API (internal) should be on port ${INTERNAL_TELEGRAM_API_PORT}`);
+  console.log(`Tools available at /tools`);
+  console.log(`Telegram API proxied from ${PROXY_TELEGRAM_PATH_PREFIX}/`);
 
-  updateEnvGistInGithub('Tunnel URL pending...').catch(console.error);
+  updateEnvGistInGithub().catch(console.error);
 
   if (FILES_TTL_HOURS > 0) {
     const ttlIntervalMs = FILES_TTL_HOURS * 60 * 60 * 1000;
     console.log(`[TTL] Scheduling cleanup every ${FILES_TTL_HOURS} hours.`);
     setTimeout(() => {
         cleanupOldFiles(TELEGRAM_DATA_DIR, FILES_TTL_HOURS).catch(console.error);
-        setInterval(() => {
-            cleanupOldFiles(TELEGRAM_DATA_DIR, FILES_TTL_HOURS).catch(console.error);
-        }, ttlIntervalMs);
-    }, 5 * 60 * 1000); 
+        setInterval(() => cleanupOldFiles(TELEGRAM_DATA_DIR, FILES_TTL_HOURS).catch(console.error), ttlIntervalMs);
+    }, 5 * 60 * 1000);
   }
 });
 
-function gracefulShutdown() {
-  console.log('Received shutdown signal. Closing server...');
-  process.exit(0);
-}
+function gracefulShutdown() { console.log('Received shutdown signal. Exiting...'); process.exit(0); }
 process.on('SIGINT', gracefulShutdown);
 process.on('SIGTERM', gracefulShutdown);