Create server.js

server.js

@@ -0,0 +1,268 @@
+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';
+
+// --- Конфигурация ---
+const EXPRESS_PORT = parseInt(process.env.EXPRESS_PORT || '3001', 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 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();
+
+// --- Вспомогательные функции ---
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+async function getDirectoryStats(dirPath) {
+  try {
+    const files = await glob(`${dirPath}/**/*`, { nodir: true, dot: true });
+    let totalSize = 0;
+    for (const file of files) {
+      try {
+        const stats = await fs.stat(file);
+        totalSize += stats.size;
+      } catch (e) {
+        // Игнорируем ошибки для отдельных файлов (например, если файл удален во время сканирования)
+      }
+    }
+    return {
+      fileCount: files.length,
+      totalSizeBytes: totalSize,
+      totalSizeHuman: formatBytes(totalSize),
+    };
+  } catch (error) {
+    console.error(`Error getting directory stats for ${dirPath}:`, error);
+    return { fileCount: 0, totalSizeBytes: 0, totalSizeHuman: '0 Bytes', error: error.message };
+  }
+}
+
+async function cleanupOldFiles(dirPath, ttlHours) {
+  if (ttlHours <= 0) {
+    return { processed: 0, deleted: 0, errors: 0, message: 'Cleanup disabled (FILES_TTL <= 0)' };
+  }
+  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;
+
+  try {
+    const files = await glob(`${dirPath}/**/*`, { nodir: true, dot: true, stat: true, withFileTypes: false }); // stat:true для mtime
+
+    for (const file of files) {
+      processed++;
+      try {
+        // glob с { stat: true } возвращает объекты с путем и fs.Stats, но mtime может быть не в том формате
+        // поэтому перепроверяем stat для каждого файла
+        const stats = await fs.stat(file); // file здесь это строка пути
+        if (stats.isFile()) {
+          const fileAge = now - stats.mtimeMs;
+          if (fileAge > 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 (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) {
+  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';
+    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,
+      files_ttl_hours: FILES_TTL_HOURS > 0 ? FILES_TTL_HOURS : 'disabled',
+    };
+    const gistData = {
+      description: `Hugging Face Space Info - ${spaceId}`,
+      files: {
+        [`hf_space_env_${spaceId}.json`]: {
+          content: JSON.stringify(content, null, 2),
+        },
+      },
+    };
+    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',
+      },
+      body: JSON.stringify(gistData),
+    });
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${await response.text()}`);
+    }
+    console.log(`Gist ${ENV_GIST_ID} updated successfully with tunnel URL: ${tunnelUrlToSave}`);
+  } catch (error) {
+    console.error('Error updating Gist:', error);
+  }
+}
+
+
+// --- Маршруты Express ---
+app.get('/', (req, res) => {
+  res.send(`Telegram API Tools. Tunnel: ${currentTunnelUrl || 'pending...'}. Stats: ${currentTunnelUrl}/stats. File base: ${currentTunnelUrl}/file/`);
+});
+
+app.get('/stats', async (req, res) => {
+  const stats = await getDirectoryStats(TELEGRAM_DATA_DIR);
+  let ttlCleanupResult = { 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);
+  }
+  res.json({
+    directory: TELEGRAM_DATA_DIR,
+    ...stats,
+    files_ttl_hours: FILES_TTL_HOURS > 0 ? FILES_TTL_HOURS : 'disabled',
+    ttl_cleanup_on_this_request: ttlCleanupResult
+  });
+});
+
+app.get('/file/:filepath(*)', (req, res) => {
+  const relativePath = req.params.filepath;
+  if (!relativePath || relativePath.includes('..')) { // Простая проверка на '..'
+    return res.status(400).send('Invalid file path.');
+  }
+
+  // Нормализуем путь и убеждаемся, что он внутри TELEGRAM_DATA_DIR
+  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.');
+  }
+});
+
+// --- Запуск сервера и туннеля ---
+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', // Меньше логов от ssh, если все ок
+    'nokey@localhost.run'
+  ]);
+
+  tunnelProcess.stdout.on('data', (data) => {
+    const output = data.toString();
+    // Ищем URL в формате https://*.lhr.life или https://*.lhr.run
+    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);
+    }
+    // Выводим весь stdout для отладки, если URL не найден сразу
+    if (!urlMatch) {
+        console.log(`localhost.run stdout: ${output}`);
+    }
+  });
+
+  tunnelProcess.stderr.on('data', (data) => {
+    console.error(`localhost.run stderr: ${data.toString()}`);
+  });
+
+  tunnelProcess.on('close', (code) => {
+    console.log(`localhost.run tunnel process exited with code ${code}`);
+    currentTunnelUrl = ''; // Сбрасываем URL, если туннель упал
+    updateEnvGistInGithub('Tunnel closed or failed.').catch(console.error);
+  });
+
+  tunnelProcess.on('error', (err) => {
+    console.error('Failed to start localhost.run tunnel process:', err);
+    currentTunnelUrl = '';
+    updateEnvGistInGithub('Tunnel failed to start.').catch(console.error);
+  });
+
+  // Первоначальное обновление Gist
+  updateEnvGistInGithub('Tunnel URL pending...').catch(console.error);
+
+  // Периодическая очистка файлов, если TTL настроен
+  if (FILES_TTL_HOURS > 0) {
+    const ttlIntervalMs = FILES_TTL_HOURS * 60 * 60 * 1000;
+    // const ttlIntervalMs = 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); // Первая очистка через 5 минут
+  }
+});
+
+// Обработка сигналов для корректного завершения
+function gracefulShutdown() {
+  console.log('Received shutdown signal. Closing server...');
+  // Здесь можно добавить закрытие сервера Express, если нужно дождаться завершения запросов
+  process.exit(0);
+}
+process.on('SIGINT', gracefulShutdown);
+process.on('SIGTERM', gracefulShutdown);