408 lines
15 KiB
TypeScript
408 lines
15 KiB
TypeScript
import express, { Request, Response } from 'express';
|
|
import compression from 'compression';
|
|
import path from 'path';
|
|
import fs from 'fs';
|
|
import ffmpeg from 'fluent-ffmpeg';
|
|
|
|
// Configure ffmpeg paths
|
|
ffmpeg.setFfmpegPath('/usr/bin/ffmpeg');
|
|
ffmpeg.setFfprobePath('/usr/bin/ffprobe');
|
|
import { Database } from './database';
|
|
import { SoundCloudService } from './soundcloud';
|
|
import { QuixoticBot } from './bot';
|
|
import { logger } from './logger';
|
|
|
|
const app = express();
|
|
const port = process.env.PORT || 3000;
|
|
|
|
// Initialize services
|
|
const db = new Database();
|
|
const soundcloud = new SoundCloudService();
|
|
|
|
// Middleware
|
|
app.use(compression()); // Enable gzip compression
|
|
app.use(express.json());
|
|
app.use((req: Request, res: Response, next) => {
|
|
res.set('Content-Security-Policy',
|
|
'default-src \'self\'; ' +
|
|
'script-src \'self\' https://telegram.org \'unsafe-inline\'; ' +
|
|
'style-src \'self\' \'unsafe-inline\'; ' +
|
|
'img-src \'self\' data: https:; ' +
|
|
'font-src \'self\'; ' +
|
|
'connect-src \'self\' https://telegram.org; ' +
|
|
'frame-ancestors \'self\'; ' +
|
|
'base-uri \'self\'; ' +
|
|
'form-action \'self\''
|
|
);
|
|
res.set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
|
|
res.set('Cross-Origin-Opener-Policy', 'same-origin');
|
|
res.set('X-Frame-Options', 'SAMEORIGIN');
|
|
res.set('X-Content-Type-Options', 'nosniff');
|
|
res.set('Referrer-Policy', 'strict-origin-when-cross-origin');
|
|
next();
|
|
});
|
|
|
|
// Optimized caching strategy
|
|
app.use(express.static('public', {
|
|
maxAge: '365d', // Cache static assets for 1 year by default
|
|
etag: true,
|
|
lastModified: true,
|
|
setHeaders: (res: Response, filePath: string) => {
|
|
// Cache images, fonts, etc. with immutable flag
|
|
if (filePath.match(/\.(jpg|jpeg|png|gif|ico|woff|woff2|ttf|eot|svg)$/)) {
|
|
res.set('Cache-Control', 'public, max-age=31536000, immutable');
|
|
}
|
|
// Cache CSS and JS with version string for 1 year
|
|
else if (filePath.match(/\.(css|js)$/)) {
|
|
res.set('Cache-Control', 'public, max-age=31536000, immutable'); // 1 year
|
|
}
|
|
// HTML files - short cache with revalidation
|
|
else if (filePath.match(/\.html$/)) {
|
|
res.set('Cache-Control', 'public, max-age=0, must-revalidate');
|
|
}
|
|
}
|
|
}));
|
|
|
|
// Ensure downloads directory exists
|
|
const downloadsDir = path.join(__dirname, '../downloads');
|
|
if (!fs.existsSync(downloadsDir)) {
|
|
fs.mkdirSync(downloadsDir, { recursive: true });
|
|
}
|
|
|
|
// Load version for cache busting
|
|
let appVersion = Date.now().toString();
|
|
try {
|
|
const versionPath = path.join(__dirname, '../public/version.json');
|
|
if (fs.existsSync(versionPath)) {
|
|
const versionData = JSON.parse(fs.readFileSync(versionPath, 'utf8'));
|
|
appVersion = versionData.version || appVersion;
|
|
logger.info(`App version loaded: ${appVersion}`);
|
|
}
|
|
} catch (error) {
|
|
logger.warn('Could not load version file, using timestamp');
|
|
}
|
|
|
|
// Routes
|
|
app.get('/', (req: Request, res: Response) => {
|
|
// Use minified HTML in production
|
|
const isProduction = process.env.NODE_ENV === 'production';
|
|
const htmlFile = isProduction ? 'index.min.html' : 'index.html';
|
|
const indexPath = path.join(__dirname, '../public', htmlFile);
|
|
|
|
// Set cache headers for HTML (no cache for HTML itself)
|
|
res.set({
|
|
'Cache-Control': 'no-cache, no-store, must-revalidate',
|
|
'Pragma': 'no-cache',
|
|
'Expires': '0'
|
|
});
|
|
|
|
// Read HTML and inject version
|
|
try {
|
|
let html = fs.readFileSync(indexPath, 'utf8');
|
|
// Replace version placeholders with actual version
|
|
html = html.replace(/\?v=\d+/g, `?v=${appVersion}`);
|
|
res.send(html);
|
|
} catch (error) {
|
|
logger.error('Error serving HTML:', error);
|
|
res.sendFile(indexPath);
|
|
}
|
|
});
|
|
|
|
// Search videos
|
|
app.post('/api/search', async (req: Request, res: Response) => {
|
|
try {
|
|
const { query, userId, page }: { query?: string; userId?: string; page?: number } = req.body;
|
|
|
|
if (!query || query.trim().length === 0) {
|
|
return res.status(400).json({ error: 'Query is required' });
|
|
}
|
|
|
|
// Calculate offset based on page number (10 results per page)
|
|
const currentPage = page || 1;
|
|
const resultsPerPage = 10;
|
|
const offset = (currentPage - 1) * resultsPerPage;
|
|
|
|
// Save search history
|
|
if (userId && userId !== 'demo') {
|
|
try {
|
|
const user = await db.getUserByTelegramId(userId);
|
|
if (user) {
|
|
await db.addSearchHistory(user.id, query);
|
|
}
|
|
} catch (dbError) {
|
|
logger.error('Database error:', dbError);
|
|
}
|
|
}
|
|
|
|
const videos = await soundcloud.searchTracks(query.trim(), resultsPerPage, offset);
|
|
|
|
// Return hasMore flag based on results
|
|
const hasMore = videos.length === resultsPerPage;
|
|
|
|
res.json({ videos, hasMore });
|
|
|
|
} catch (error) {
|
|
logger.error('Search error:', error);
|
|
res.status(500).json({ error: 'Failed to search videos' });
|
|
}
|
|
});
|
|
|
|
// Convert video to MP3
|
|
app.post('/api/convert', async (req: Request, res: Response) => {
|
|
try {
|
|
const { videoId, title, userId, url }: { videoId?: string; title?: string; userId?: string; url?: string } = req.body;
|
|
logger.info(`Convert request received: ${title} (ID: ${videoId})`);
|
|
|
|
if (!videoId) {
|
|
return res.status(400).json({ error: 'Video ID is required' });
|
|
}
|
|
|
|
// Generate safe filename
|
|
const safeTitle = (title || '').replace(/[^\w\s-]/g, '').replace(/\s+/g, '_').substring(0, 50);
|
|
const filename = `${videoId}_${safeTitle}.mp3`;
|
|
const outputPath = path.join(downloadsDir, filename);
|
|
|
|
// Check if file already exists
|
|
if (fs.existsSync(outputPath)) {
|
|
logger.info('File already exists, serving cached version');
|
|
const audioUrl = `${req.protocol}://${req.get('host')}/downloads/${filename}`;
|
|
return res.json({ audioUrl, title });
|
|
}
|
|
|
|
logger.info(`Starting MP3 conversion: ${title}`);
|
|
|
|
try {
|
|
// Get audio stream from YouTube
|
|
logger.debug(`Attempting to get audio stream for: ${videoId}`);
|
|
const audioStream = await soundcloud.getAudioStream(videoId, url);
|
|
logger.info('Audio stream obtained, starting FFmpeg conversion...');
|
|
|
|
// Download to temporary file first, then convert
|
|
const tempInputPath = path.join(downloadsDir, `temp_${videoId}.tmp`);
|
|
|
|
// Save stream to temporary file
|
|
await new Promise<void>((resolve, reject) => {
|
|
const writeStream = fs.createWriteStream(tempInputPath);
|
|
audioStream.pipe(writeStream);
|
|
audioStream.on('end', resolve);
|
|
audioStream.on('error', reject);
|
|
writeStream.on('error', reject);
|
|
});
|
|
|
|
logger.info('Temporary file saved, starting FFmpeg conversion...');
|
|
|
|
// Debug: check temp file
|
|
const stats = fs.statSync(tempInputPath);
|
|
logger.debug(`Temp file size: ${stats.size} bytes`);
|
|
|
|
// Test ffmpeg with simple command first
|
|
try {
|
|
const { execSync } = require('child_process');
|
|
execSync(`ffmpeg -i "${tempInputPath}" -t 1 -f null -`, { encoding: 'utf8', stdio: 'pipe' });
|
|
logger.debug('FFmpeg file test passed');
|
|
} catch (e: any) {
|
|
logger.error('FFmpeg file test failed:', e.stderr || e.message);
|
|
}
|
|
|
|
// Convert temporary file to MP3 using ffmpeg
|
|
await new Promise<void>((resolve, reject) => {
|
|
const conversion = ffmpeg(tempInputPath)
|
|
.audioCodec('libmp3lame')
|
|
.audioBitrate('192k')
|
|
.audioChannels(2)
|
|
.audioFrequency(44100)
|
|
.format('mp3')
|
|
.output(outputPath)
|
|
.on('start', (command: string) => {
|
|
logger.ffmpeg('Started', command);
|
|
})
|
|
.on('progress', (progress: any) => {
|
|
if (progress.percent) {
|
|
logger.ffmpeg('Progress', `${Math.round(progress.percent)}%`);
|
|
}
|
|
})
|
|
.on('end', () => {
|
|
logger.success('MP3 conversion completed successfully');
|
|
// Clean up temporary file
|
|
fs.unlink(tempInputPath, (err) => {
|
|
if (err) logger.error('Failed to delete temp file:', err);
|
|
});
|
|
resolve();
|
|
})
|
|
.on('error', (err: Error) => {
|
|
logger.error('FFmpeg error:', err.message);
|
|
// Clean up temporary file on error
|
|
fs.unlink(tempInputPath, () => {});
|
|
reject(err);
|
|
});
|
|
|
|
conversion.run();
|
|
});
|
|
|
|
// Save download record
|
|
if (userId && userId !== 'demo') {
|
|
try {
|
|
const user = await db.getUserByTelegramId(userId);
|
|
if (user) {
|
|
await db.addDownload(user.id, videoId, title || '', outputPath);
|
|
}
|
|
} catch (dbError) {
|
|
logger.error('Database error:', dbError);
|
|
}
|
|
}
|
|
|
|
const audioUrl = `${req.protocol}://${req.get('host')}/downloads/${filename}`;
|
|
logger.success(`Conversion successful: ${audioUrl}`);
|
|
res.json({ audioUrl, title });
|
|
|
|
} catch (conversionError: any) {
|
|
logger.error(`Conversion failed for video: ${videoId}`);
|
|
logger.error('Error details:', conversionError.message);
|
|
logger.error('Full error:', conversionError);
|
|
|
|
// Return error - no fallbacks for Telegram bot
|
|
return res.status(503).json({
|
|
error: 'MP3 conversion failed. This video may be restricted or unavailable for download.',
|
|
details: conversionError.message,
|
|
videoId: videoId
|
|
});
|
|
}
|
|
|
|
} catch (error) {
|
|
logger.error('Server error:', error);
|
|
res.status(500).json({ error: 'Failed to process request' });
|
|
}
|
|
});
|
|
|
|
// Direct Telegram API for sending audio
|
|
app.post('/api/telegram-send', async (req: Request, res: Response) => {
|
|
logger.telegram('Send request received');
|
|
|
|
try {
|
|
const { userId, audioUrl, title, performer, thumbnail }: { userId?: string; audioUrl?: string; title?: string; performer?: string; thumbnail?: string } = req.body;
|
|
logger.telegram('Sending to user', `${userId}: ${title}`);
|
|
|
|
if (!userId || !audioUrl || !title) {
|
|
return res.status(400).json({ error: 'Missing required fields' });
|
|
}
|
|
|
|
const botInstance = (global as any).quixoticBot;
|
|
if (!botInstance) {
|
|
logger.error('Bot not available');
|
|
return res.status(500).json({ error: 'Bot not available' });
|
|
}
|
|
|
|
const chatId = parseInt(userId);
|
|
await botInstance.sendAudioFile(chatId, audioUrl, title, performer, thumbnail);
|
|
logger.success('Audio sent successfully');
|
|
|
|
res.json({ success: true, message: 'Audio sent successfully' });
|
|
|
|
} catch (error: any) {
|
|
logger.error('Send failed:', error.message);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Serve download files
|
|
app.use('/downloads', express.static(downloadsDir));
|
|
|
|
// Health check
|
|
app.get('/health', (req: Request, res: Response) => {
|
|
res.json({ status: 'ok', timestamp: new Date().toISOString() });
|
|
});
|
|
|
|
// Version endpoint for client-side cache busting
|
|
app.get('/api/version', (req: Request, res: Response) => {
|
|
res.set('Cache-Control', 'no-cache, no-store, must-revalidate');
|
|
try {
|
|
const versionPath = path.join(__dirname, '../public/version.json');
|
|
if (fs.existsSync(versionPath)) {
|
|
const versionData = fs.readFileSync(versionPath, 'utf8');
|
|
res.json(JSON.parse(versionData));
|
|
} else {
|
|
res.json({ version: appVersion, timestamp: Date.now() });
|
|
}
|
|
} catch (error) {
|
|
res.json({ version: appVersion, timestamp: Date.now() });
|
|
}
|
|
});
|
|
|
|
// Error handler
|
|
app.use((err: Error, _req: Request, res: Response, _next: any) => {
|
|
logger.error(err.stack || err.message);
|
|
res.status(500).json({ error: 'Something went wrong!' });
|
|
});
|
|
|
|
// Cleanup old files periodically (every hour)
|
|
setInterval(() => {
|
|
const maxAge = 24 * 60 * 60 * 1000; // 24 hours
|
|
const now = Date.now();
|
|
|
|
fs.readdir(downloadsDir, (err, files) => {
|
|
if (err) return;
|
|
|
|
files.forEach(file => {
|
|
const filePath = path.join(downloadsDir, file);
|
|
fs.stat(filePath, (err, stats) => {
|
|
if (err) return;
|
|
|
|
if (now - stats.mtime.getTime() > maxAge) {
|
|
fs.unlink(filePath, (err) => {
|
|
if (!err) {
|
|
logger.info('Deleted old file:', file);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}, 60 * 60 * 1000); // Run every hour
|
|
|
|
app.listen(port, () => {
|
|
logger.success(`Quixotic server running on port ${port}`);
|
|
logger.info(`Downloads directory: ${downloadsDir}`);
|
|
logger.info(`Open in browser: http://localhost:${port}`);
|
|
});
|
|
|
|
// Initialize Telegram bot
|
|
const botToken = process.env.TELEGRAM_BOT_TOKEN;
|
|
const webAppUrl = process.env.WEB_APP_URL || `http://localhost:${port}`;
|
|
|
|
if (botToken && botToken.length > 10 && botToken !== 'your_telegram_bot_token_here') {
|
|
try {
|
|
const botInstance = new QuixoticBot(botToken, webAppUrl);
|
|
// Store bot instance globally for API access
|
|
(global as any).quixoticBot = botInstance;
|
|
logger.telegram('Bot started and stored globally');
|
|
} catch (error: any) {
|
|
logger.error('Bot initialization failed:', error.message);
|
|
logger.warn('Bot disabled due to error');
|
|
logger.warn('Telegram integration will not be available');
|
|
// Don't crash the server, continue without bot
|
|
}
|
|
} else {
|
|
logger.warn('TELEGRAM_BOT_TOKEN not configured properly');
|
|
logger.warn('Bot will not start - only web interface will be available');
|
|
logger.info('To enable Telegram bot, set a valid TELEGRAM_BOT_TOKEN');
|
|
}
|
|
|
|
// Handle unhandled promise rejections
|
|
process.on('unhandledRejection', (reason: any, promise: Promise<any>) => {
|
|
logger.error('Unhandled Rejection at:', promise);
|
|
logger.error('Reason:', reason);
|
|
|
|
// Log but don't crash the server
|
|
if (reason?.code === 'ETELEGRAM') {
|
|
logger.warn('Telegram API error - continuing operation');
|
|
}
|
|
});
|
|
|
|
// Handle uncaught exceptions
|
|
process.on('uncaughtException', (error: Error) => {
|
|
logger.error('Uncaught Exception:', error);
|
|
// Log but try to continue
|
|
});
|
|
|
|
export default app;
|