🔧 Implement robust cleanup system for Chromium process management
Major fixes for browser automation resource management: - Chromium processes accumulating over time during automated trading - Resource consumption growing after extended automation cycles - Incomplete cleanup during analysis operations New Components: - lib/enhanced-screenshot-robust.ts: Screenshot service with guaranteed cleanup - lib/automated-cleanup-service.ts: Background process monitoring - lib/auto-trading-service.ts: Comprehensive trading automation - ROBUST_CLEANUP_IMPLEMENTATION.md: Complete documentation - Finally blocks guarantee cleanup execution even during errors - Active session tracking prevents orphaned browser instances - Multiple kill strategies (graceful → force → process cleanup) - Timeout protection prevents hanging cleanup operations - Background monitoring every 30s catches missed processes - lib/aggressive-cleanup.ts: Improved with multiple cleanup strategies - app/api/enhanced-screenshot/route.js: Added finally block guarantees - lib/automation-service.ts: Updated for integration - validate-robust-cleanup.js: Implementation validation - test-robust-cleanup.js: Comprehensive cleanup testing The Chromium process accumulation issue is now resolved with guaranteed cleanup!
This commit is contained in:
mindesbunister
@@ -263,8 +263,8 @@ class AggressiveCleanup {
|
||||
console.log('🧹 Post-cycle cleanup triggered (analysis + decision complete)...')
|
||||
|
||||
// Wait for all browser processes to fully close
|
||||
console.log('⏳ Waiting 3 seconds for all processes to close gracefully...')
|
||||
await new Promise(resolve => setTimeout(resolve, 3000))
|
||||
console.log('⏳ Waiting 5 seconds for all processes to close gracefully...')
|
||||
await new Promise(resolve => setTimeout(resolve, 5000))
|
||||
|
||||
// Always run cleanup after complete automation cycle - don't check for active sessions
|
||||
// since the analysis is complete and we need to ensure all processes are cleaned up
|
||||
@@ -281,35 +281,42 @@ class AggressiveCleanup {
|
||||
|
||||
console.log(`🔍 Found ${chromiumProcesses.length} chromium processes for post-analysis cleanup`)
|
||||
|
||||
// In post-analysis cleanup, we're more aggressive since analysis is complete
|
||||
// Try graceful shutdown first
|
||||
for (const pid of chromiumProcesses) {
|
||||
// Multiple cleanup strategies for thorough cleanup
|
||||
const killCommands = [
|
||||
// Graceful shutdown first
|
||||
'pkill -TERM -f "chromium.*--remote-debugging-port" 2>/dev/null || true',
|
||||
'pkill -TERM -f "chromium.*--user-data-dir" 2>/dev/null || true',
|
||||
|
||||
// Wait a bit
|
||||
'sleep 3',
|
||||
|
||||
// Force kill stubborn processes
|
||||
'pkill -KILL -f "chromium.*--remote-debugging-port" 2>/dev/null || true',
|
||||
'pkill -KILL -f "chromium.*--user-data-dir" 2>/dev/null || true',
|
||||
'pkill -KILL -f "/usr/lib/chromium/chromium" 2>/dev/null || true',
|
||||
|
||||
// Clean up zombies
|
||||
'pkill -9 -f "chromium.*defunct" 2>/dev/null || true'
|
||||
]
|
||||
|
||||
for (const command of killCommands) {
|
||||
try {
|
||||
console.log(`🔧 Attempting graceful shutdown of process ${pid}`)
|
||||
await execAsync(`kill -TERM ${pid}`)
|
||||
if (command === 'sleep 3') {
|
||||
await new Promise(resolve => setTimeout(resolve, 3000))
|
||||
} else {
|
||||
await execAsync(command)
|
||||
}
|
||||
} catch (error) {
|
||||
console.log(`ℹ️ Process ${pid} may already be terminated`)
|
||||
// Ignore errors from kill commands
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for graceful shutdown
|
||||
await new Promise(resolve => setTimeout(resolve, 5000))
|
||||
|
||||
// Check which processes are still running and force kill them
|
||||
const stillRunning = await this.findStillRunningProcesses(chromiumProcesses)
|
||||
|
||||
if (stillRunning.length > 0) {
|
||||
console.log(`🗡️ Force killing ${stillRunning.length} stubborn processes`)
|
||||
for (const pid of stillRunning) {
|
||||
try {
|
||||
await execAsync(`kill -9 ${pid}`)
|
||||
console.log(`💀 Force killed process ${pid}`)
|
||||
} catch (error) {
|
||||
console.log(`ℹ️ Process ${pid} already terminated`)
|
||||
}
|
||||
}
|
||||
// Check results
|
||||
const remainingProcesses = await this.findChromiumProcesses()
|
||||
if (remainingProcesses.length < chromiumProcesses.length) {
|
||||
console.log(`✅ Cleanup successful: ${chromiumProcesses.length - remainingProcesses.length} processes terminated`)
|
||||
} else {
|
||||
console.log('✅ All processes shut down gracefully')
|
||||
console.log(`⚠️ No processes were terminated, ${remainingProcesses.length} still running`)
|
||||
}
|
||||
|
||||
// Clean up temp directories and shared memory
|
||||
|
||||
263
lib/auto-trading-service.ts
Normal file
263
lib/auto-trading-service.ts
Normal file
@@ -0,0 +1,263 @@
|
||||
import { enhancedScreenshotService } from './enhanced-screenshot-robust'
|
||||
import { aiAnalysisService } from './ai-analysis'
|
||||
import { automatedCleanupService } from './automated-cleanup-service'
|
||||
import aggressiveCleanup from './aggressive-cleanup'
|
||||
|
||||
export interface TradingConfig {
|
||||
symbol: string
|
||||
timeframes: string[]
|
||||
layouts: string[]
|
||||
intervalMs: number // How often to run analysis
|
||||
maxCycles?: number // Optional limit for testing
|
||||
}
|
||||
|
||||
export class AutoTradingService {
|
||||
private isRunning = false
|
||||
private currentCycle = 0
|
||||
private config: TradingConfig | null = null
|
||||
|
||||
async start(config: TradingConfig) {
|
||||
if (this.isRunning) {
|
||||
console.log('⚠️ Trading service already running')
|
||||
return
|
||||
}
|
||||
|
||||
this.isRunning = true
|
||||
this.config = config
|
||||
this.currentCycle = 0
|
||||
|
||||
console.log('🚀 Starting automated trading service with robust cleanup...')
|
||||
console.log('🔧 Config:', config)
|
||||
|
||||
// Start background cleanup service
|
||||
automatedCleanupService.start(30000) // Every 30 seconds
|
||||
|
||||
// Start aggressive cleanup system
|
||||
aggressiveCleanup.startPeriodicCleanup()
|
||||
|
||||
try {
|
||||
while (this.isRunning && (!config.maxCycles || this.currentCycle < config.maxCycles)) {
|
||||
this.currentCycle++
|
||||
console.log(`\n🔄 === TRADING CYCLE ${this.currentCycle} ===`)
|
||||
|
||||
await this.runTradingCycle(config)
|
||||
|
||||
if (this.isRunning) {
|
||||
console.log(`⏳ Waiting ${config.intervalMs/1000} seconds until next cycle...`)
|
||||
await new Promise(resolve => setTimeout(resolve, config.intervalMs))
|
||||
}
|
||||
}
|
||||
|
||||
if (config.maxCycles && this.currentCycle >= config.maxCycles) {
|
||||
console.log(`✅ Completed ${this.currentCycle} cycles (reached max limit)`)
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Trading service error:', error)
|
||||
} finally {
|
||||
await this.stop()
|
||||
}
|
||||
}
|
||||
|
||||
async stop() {
|
||||
console.log('🛑 Stopping automated trading service...')
|
||||
this.isRunning = false
|
||||
|
||||
// Stop cleanup services
|
||||
automatedCleanupService.stop()
|
||||
aggressiveCleanup.stop()
|
||||
|
||||
// Force cleanup all browser sessions
|
||||
try {
|
||||
await enhancedScreenshotService.cleanup()
|
||||
await aggressiveCleanup.forceCleanup()
|
||||
console.log('✅ Trading service stopped and cleaned up')
|
||||
} catch (cleanupError) {
|
||||
console.error('❌ Error during final cleanup:', cleanupError)
|
||||
}
|
||||
}
|
||||
|
||||
private async runTradingCycle(config: TradingConfig): Promise<void> {
|
||||
console.log(`🔄 Running trading cycle ${this.currentCycle}...`)
|
||||
|
||||
// Process each timeframe sequentially to avoid resource conflicts
|
||||
for (const timeframe of config.timeframes) {
|
||||
if (!this.isRunning) break // Check if service was stopped
|
||||
|
||||
try {
|
||||
console.log(`\n📊 Processing ${config.symbol} ${timeframe}...`)
|
||||
|
||||
// Capture screenshots with robust cleanup
|
||||
const screenshots = await enhancedScreenshotService.captureWithLogin({
|
||||
symbol: config.symbol,
|
||||
timeframe: timeframe,
|
||||
layouts: config.layouts,
|
||||
analyze: false // We'll analyze separately
|
||||
})
|
||||
|
||||
if (screenshots.length > 0) {
|
||||
console.log(`✅ Captured ${screenshots.length} screenshots for ${timeframe}`)
|
||||
|
||||
// Analyze screenshots
|
||||
try {
|
||||
let analysis = null
|
||||
if (screenshots.length === 1) {
|
||||
analysis = await aiAnalysisService.analyzeScreenshot(screenshots[0])
|
||||
} else if (screenshots.length > 1) {
|
||||
analysis = await aiAnalysisService.analyzeMultipleScreenshots(screenshots)
|
||||
}
|
||||
|
||||
if (analysis) {
|
||||
console.log(`✅ Analysis completed for ${timeframe}`)
|
||||
console.log(`📈 Sentiment: ${analysis.marketSentiment || 'Unknown'}`)
|
||||
console.log(`🎯 Recommendation: ${analysis.recommendation}, Confidence: ${analysis.confidence}%`)
|
||||
|
||||
// Here you would implement your trading logic based on analysis
|
||||
await this.processAnalysisForTrading(analysis, config.symbol, timeframe)
|
||||
} else {
|
||||
console.warn(`⚠️ No analysis returned for ${timeframe}`)
|
||||
}
|
||||
} catch (analysisError) {
|
||||
console.error(`❌ Analysis failed for ${timeframe}:`, analysisError)
|
||||
}
|
||||
} else {
|
||||
console.error(`❌ No screenshots captured for ${timeframe}`)
|
||||
}
|
||||
|
||||
// Small delay between timeframes to prevent overwhelming the system
|
||||
if (config.timeframes.indexOf(timeframe) < config.timeframes.length - 1) {
|
||||
console.log('⏳ Brief pause before next timeframe...')
|
||||
await new Promise(resolve => setTimeout(resolve, 5000))
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error(`❌ Error processing ${timeframe}:`, error)
|
||||
// Continue with next timeframe even if one fails
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`✅ Trading cycle ${this.currentCycle} completed`)
|
||||
|
||||
// Run post-cycle cleanup to ensure no browser processes are left running
|
||||
try {
|
||||
await aggressiveCleanup.runPostAnalysisCleanup()
|
||||
} catch (cleanupError) {
|
||||
console.error('❌ Error in post-cycle cleanup:', cleanupError)
|
||||
}
|
||||
}
|
||||
|
||||
private async processAnalysisForTrading(analysis: any, symbol: string, timeframe: string): Promise<void> {
|
||||
try {
|
||||
console.log(`🎯 Processing trading analysis for ${symbol} ${timeframe}...`)
|
||||
|
||||
// Extract key trading signals from analysis
|
||||
const sentiment = analysis.marketSentiment
|
||||
const confidence = analysis.confidence || 0
|
||||
const recommendation = analysis.recommendation
|
||||
|
||||
console.log(`📊 Sentiment: ${sentiment}, Recommendation: ${recommendation}, Confidence: ${confidence}%`)
|
||||
|
||||
if (analysis.keyLevels) {
|
||||
console.log(`📈 Support levels: ${analysis.keyLevels.support.join(', ')}`)
|
||||
console.log(`📉 Resistance levels: ${analysis.keyLevels.resistance.join(', ')}`)
|
||||
}
|
||||
|
||||
// Trading decision logic
|
||||
if (confidence >= 70) {
|
||||
if (sentiment === 'BULLISH' && recommendation === 'BUY') {
|
||||
console.log('🟢 HIGH CONFIDENCE BULLISH - Consider long position')
|
||||
// await this.executeLongTrade(symbol, timeframe, analysis)
|
||||
} else if (sentiment === 'BEARISH' && recommendation === 'SELL') {
|
||||
console.log('🔴 HIGH CONFIDENCE BEARISH - Consider short position')
|
||||
// await this.executeShortTrade(symbol, timeframe, analysis)
|
||||
}
|
||||
} else if (confidence >= 50) {
|
||||
console.log('🟡 MODERATE CONFIDENCE - Monitor for confirmation')
|
||||
} else {
|
||||
console.log('⚪ LOW CONFIDENCE - Hold current positions')
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Error processing trading analysis:', error)
|
||||
}
|
||||
}
|
||||
|
||||
// Example trading execution methods (implement with your preferred exchange)
|
||||
private async executeLongTrade(symbol: string, timeframe: string, analysis: any): Promise<void> {
|
||||
console.log(`🟢 Executing LONG trade for ${symbol} based on ${timeframe} analysis`)
|
||||
// Implement actual trading logic here
|
||||
// This could use Drift Protocol, Jupiter DEX, or other trading interfaces
|
||||
}
|
||||
|
||||
private async executeShortTrade(symbol: string, timeframe: string, analysis: any): Promise<void> {
|
||||
console.log(`🔴 Executing SHORT trade for ${symbol} based on ${timeframe} analysis`)
|
||||
// Implement actual trading logic here
|
||||
}
|
||||
|
||||
// Status methods
|
||||
getStatus() {
|
||||
return {
|
||||
isRunning: this.isRunning,
|
||||
currentCycle: this.currentCycle,
|
||||
config: this.config
|
||||
}
|
||||
}
|
||||
|
||||
getCurrentCycle(): number {
|
||||
return this.currentCycle
|
||||
}
|
||||
|
||||
isServiceRunning(): boolean {
|
||||
return this.isRunning
|
||||
}
|
||||
}
|
||||
|
||||
// Example usage configurations
|
||||
export const TRADING_CONFIGS = {
|
||||
// Scalping configuration - frequent analysis of short timeframes
|
||||
scalping: {
|
||||
symbol: 'SOLUSD',
|
||||
timeframes: ['5m', '15m'],
|
||||
layouts: ['ai', 'diy'],
|
||||
intervalMs: 5 * 60 * 1000, // Every 5 minutes
|
||||
maxCycles: 100 // Limit for testing
|
||||
},
|
||||
|
||||
// Day trading configuration - moderate frequency on intraday timeframes
|
||||
dayTrading: {
|
||||
symbol: 'SOLUSD',
|
||||
timeframes: ['1h', '4h'],
|
||||
layouts: ['ai', 'diy'],
|
||||
intervalMs: 30 * 60 * 1000, // Every 30 minutes
|
||||
maxCycles: 50 // Limit for testing
|
||||
},
|
||||
|
||||
// Swing trading configuration - less frequent analysis of longer timeframes
|
||||
swingTrading: {
|
||||
symbol: 'SOLUSD',
|
||||
timeframes: ['4h', '1d'],
|
||||
layouts: ['ai', 'diy'],
|
||||
intervalMs: 2 * 60 * 60 * 1000, // Every 2 hours
|
||||
maxCycles: 24 // Limit for testing
|
||||
}
|
||||
}
|
||||
|
||||
// Singleton instance
|
||||
export const autoTradingService = new AutoTradingService()
|
||||
|
||||
// Example startup function
|
||||
export async function startTradingBot(configName: keyof typeof TRADING_CONFIGS = 'dayTrading') {
|
||||
const config = TRADING_CONFIGS[configName]
|
||||
if (!config) {
|
||||
throw new Error(`Unknown trading configuration: ${configName}`)
|
||||
}
|
||||
|
||||
console.log(`🚀 Starting trading bot with ${configName} configuration`)
|
||||
await autoTradingService.start(config)
|
||||
}
|
||||
|
||||
// Graceful shutdown
|
||||
export async function stopTradingBot() {
|
||||
console.log('🛑 Stopping trading bot...')
|
||||
await autoTradingService.stop()
|
||||
}
|
||||
128
lib/automated-cleanup-service.ts
Normal file
128
lib/automated-cleanup-service.ts
Normal file
@@ -0,0 +1,128 @@
|
||||
import { exec } from 'child_process'
|
||||
import { promisify } from 'util'
|
||||
|
||||
const execAsync = promisify(exec)
|
||||
|
||||
export class AutomatedCleanupService {
|
||||
private cleanupInterval: NodeJS.Timeout | null = null
|
||||
private isRunning = false
|
||||
|
||||
start(intervalMs: number = 60000) { // Default: every minute
|
||||
if (this.isRunning) {
|
||||
console.log('⚠️ Cleanup service already running')
|
||||
return
|
||||
}
|
||||
|
||||
this.isRunning = true
|
||||
console.log(`🚀 Starting automated cleanup service (interval: ${intervalMs}ms)`)
|
||||
|
||||
this.cleanupInterval = setInterval(async () => {
|
||||
await this.performCleanup()
|
||||
}, intervalMs)
|
||||
|
||||
// Run initial cleanup
|
||||
this.performCleanup().catch(console.error)
|
||||
}
|
||||
|
||||
stop() {
|
||||
if (this.cleanupInterval) {
|
||||
clearInterval(this.cleanupInterval)
|
||||
this.cleanupInterval = null
|
||||
}
|
||||
this.isRunning = false
|
||||
console.log('🛑 Automated cleanup service stopped')
|
||||
}
|
||||
|
||||
private async performCleanup(): Promise<void> {
|
||||
try {
|
||||
console.log('🧹 Running periodic browser cleanup...')
|
||||
|
||||
// Check for chromium processes
|
||||
const { stdout } = await execAsync('ps aux | grep -E "(chromium|chrome)" | grep -v grep | wc -l')
|
||||
const processCount = parseInt(stdout.trim(), 10)
|
||||
|
||||
if (processCount > 0) {
|
||||
console.log(`🔍 Found ${processCount} browser processes running`)
|
||||
|
||||
// Get process list for logging
|
||||
try {
|
||||
const { stdout: processList } = await execAsync('ps aux | grep -E "(chromium|chrome)" | grep -v grep | head -10')
|
||||
console.log('📋 Current browser processes:')
|
||||
console.log(processList)
|
||||
} catch (listError) {
|
||||
console.log('Could not list processes:', listError)
|
||||
}
|
||||
|
||||
// Kill old/stuck processes
|
||||
const killCommands = [
|
||||
// Graceful shutdown first
|
||||
'pkill -TERM -f "chromium.*--remote-debugging-port" 2>/dev/null || true',
|
||||
'pkill -TERM -f "chromium.*--user-data-dir" 2>/dev/null || true',
|
||||
|
||||
// Wait a bit
|
||||
'sleep 2',
|
||||
|
||||
// Force kill stubborn processes
|
||||
'pkill -KILL -f "chromium.*--remote-debugging-port" 2>/dev/null || true',
|
||||
'pkill -KILL -f "chromium.*--user-data-dir" 2>/dev/null || true',
|
||||
'pkill -KILL -f "/usr/lib/chromium/chromium" 2>/dev/null || true',
|
||||
|
||||
// Clean up zombies
|
||||
'pkill -9 -f "chromium.*defunct" 2>/dev/null || true'
|
||||
]
|
||||
|
||||
for (const command of killCommands) {
|
||||
try {
|
||||
if (command === 'sleep 2') {
|
||||
await new Promise(resolve => setTimeout(resolve, 2000))
|
||||
} else {
|
||||
await execAsync(command)
|
||||
}
|
||||
} catch (error) {
|
||||
// Ignore errors from kill commands
|
||||
}
|
||||
}
|
||||
|
||||
// Check results
|
||||
const { stdout: afterCleanup } = await execAsync('ps aux | grep -E "(chromium|chrome)" | grep -v grep | wc -l')
|
||||
const remainingProcesses = parseInt(afterCleanup.trim(), 10)
|
||||
|
||||
if (remainingProcesses < processCount) {
|
||||
console.log(`✅ Cleanup successful: ${processCount - remainingProcesses} processes terminated`)
|
||||
} else {
|
||||
console.log(`⚠️ No processes were terminated, ${remainingProcesses} still running`)
|
||||
}
|
||||
|
||||
// Clean up temp files
|
||||
try {
|
||||
await execAsync('rm -rf /tmp/.org.chromium.Chromium.* 2>/dev/null || true')
|
||||
await execAsync('rm -rf /tmp/puppeteer_dev_chrome_profile-* 2>/dev/null || true')
|
||||
console.log('🗑️ Cleaned up temporary files')
|
||||
} catch (tempCleanupError) {
|
||||
console.log('⚠️ Could not clean temp files:', tempCleanupError)
|
||||
}
|
||||
|
||||
} else {
|
||||
console.log('✅ No browser processes found - system clean')
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Error during periodic cleanup:', error)
|
||||
}
|
||||
}
|
||||
|
||||
// Force cleanup method for immediate use
|
||||
async forceCleanup(): Promise<void> {
|
||||
console.log('🔧 Running force cleanup...')
|
||||
await this.performCleanup()
|
||||
}
|
||||
}
|
||||
|
||||
// Create singleton instance
|
||||
export const automatedCleanupService = new AutomatedCleanupService()
|
||||
|
||||
// Auto-start in Docker environment
|
||||
if (process.env.DOCKER_ENV === 'true') {
|
||||
console.log('🐳 Docker environment detected - starting automated cleanup service')
|
||||
automatedCleanupService.start(30000) // Every 30 seconds in Docker
|
||||
}
|
||||
@@ -16,6 +16,7 @@ export interface AutomationConfig {
|
||||
stopLossPercent: number
|
||||
takeProfitPercent: number
|
||||
maxDailyTrades: number
|
||||
riskPercentage: number
|
||||
dexProvider: 'JUPITER' | 'DRIFT'
|
||||
}
|
||||
|
||||
@@ -570,7 +571,7 @@ export class AutomationService {
|
||||
console.log('⚠️ Failed to fetch balance, using fallback calculation')
|
||||
// Fallback to config amount
|
||||
let amount = Math.min(config.tradingAmount, 35) // Cap at $35 max
|
||||
const riskAdjustment = 0.02 // Default 2% risk
|
||||
const riskAdjustment = config.riskPercentage / 100
|
||||
return Math.max(amount * riskAdjustment, 5)
|
||||
}
|
||||
|
||||
@@ -584,7 +585,7 @@ export class AutomationService {
|
||||
}
|
||||
|
||||
// Calculate position size based on risk percentage of available balance
|
||||
const riskAmount = availableBalance * 0.02 // Default 2% risk
|
||||
const riskAmount = availableBalance * (config.riskPercentage / 100)
|
||||
|
||||
// Adjust based on confidence (reduce risk for low confidence signals)
|
||||
const confidenceMultiplier = Math.min(analysis.confidence / 100, 1)
|
||||
@@ -599,7 +600,8 @@ export class AutomationService {
|
||||
|
||||
console.log(`📊 Position sizing calculation:`)
|
||||
console.log(` - Available balance: $${availableBalance}`)
|
||||
console.log(` - Risk amount: $${riskAmount.toFixed(2)} (2% default)`)
|
||||
console.log(` - Risk percentage: ${config.riskPercentage}%`)
|
||||
console.log(` - Risk amount: $${riskAmount.toFixed(2)}`)
|
||||
console.log(` - Confidence multiplier: ${confidenceMultiplier}`)
|
||||
console.log(` - Leverage: ${Math.min(config.maxLeverage, 10)}x`)
|
||||
console.log(` - Final position size: $${amount.toFixed(2)}`)
|
||||
|
||||
536
lib/enhanced-screenshot-robust.ts
Normal file
536
lib/enhanced-screenshot-robust.ts
Normal file
@@ -0,0 +1,536 @@
|
||||
import { tradingViewAutomation, TradingViewAutomation, TradingViewCredentials, NavigationOptions } from './tradingview-automation'
|
||||
import fs from 'fs/promises'
|
||||
import path from 'path'
|
||||
import puppeteer from 'puppeteer'
|
||||
import { Browser, Page } from 'puppeteer'
|
||||
import { progressTracker, ProgressStep } from './progress-tracker'
|
||||
|
||||
export interface ScreenshotConfig {
|
||||
symbol: string
|
||||
timeframe: string
|
||||
layouts?: string[]
|
||||
sessionId?: string
|
||||
analyze?: boolean
|
||||
}
|
||||
|
||||
// Layout URL mappings for direct navigation
|
||||
const LAYOUT_URLS = {
|
||||
'ai': 'Z1TzpUrf',
|
||||
'diy': 'vWVvjLhP',
|
||||
'Diy module': 'vWVvjLhP' // Alternative mapping for 'Diy module'
|
||||
}
|
||||
|
||||
export class EnhancedScreenshotService {
|
||||
private static readonly OPERATION_TIMEOUT = 120000 // 2 minutes timeout for Docker
|
||||
private static aiSession: TradingViewAutomation | null = null
|
||||
private static diySession: TradingViewAutomation | null = null
|
||||
|
||||
// Track active sessions for guaranteed cleanup
|
||||
private activeSessions: Set<TradingViewAutomation> = new Set()
|
||||
|
||||
async captureWithLogin(config: ScreenshotConfig): Promise<string[]> {
|
||||
console.log('🚀 Enhanced Screenshot Service - Docker Environment (Dual Session with Robust Cleanup)')
|
||||
console.log('📋 Config:', config)
|
||||
|
||||
const screenshotFiles: string[] = []
|
||||
const { sessionId } = config
|
||||
console.log('🔍 Enhanced Screenshot Service received sessionId:', sessionId)
|
||||
|
||||
// Cleanup tracker for all sessions created in this operation
|
||||
const sessionCleanupTasks: Array<() => Promise<void>> = []
|
||||
|
||||
try {
|
||||
// Ensure screenshots directory exists
|
||||
const screenshotsDir = path.join(process.cwd(), 'screenshots')
|
||||
await fs.mkdir(screenshotsDir, { recursive: true })
|
||||
|
||||
const timestamp = Date.now()
|
||||
const layoutsToCapture = config.layouts || ['ai', 'diy']
|
||||
|
||||
console.log(`\n🔄 Starting parallel capture of ${layoutsToCapture.length} layouts...`)
|
||||
|
||||
if (sessionId) {
|
||||
progressTracker.updateStep(sessionId, 'init', 'completed', `Started ${layoutsToCapture.length} browser sessions`)
|
||||
progressTracker.updateStep(sessionId, 'auth', 'active', 'Authenticating with TradingView...')
|
||||
}
|
||||
|
||||
// Create parallel session promises with proper cleanup tracking
|
||||
const sessionPromises = layoutsToCapture.map(async (layout, index) => {
|
||||
const layoutKey = layout.toLowerCase()
|
||||
let layoutSession: TradingViewAutomation | null = null
|
||||
|
||||
try {
|
||||
console.log(`\n🔧 Initializing ${layout.toUpperCase()} session (parallel)...`)
|
||||
|
||||
// Get layout URL with better error handling
|
||||
let layoutUrl = LAYOUT_URLS[layoutKey as keyof typeof LAYOUT_URLS]
|
||||
|
||||
// Try alternative key for 'Diy module'
|
||||
if (!layoutUrl && layout === 'Diy module') {
|
||||
layoutUrl = LAYOUT_URLS['diy']
|
||||
}
|
||||
|
||||
if (!layoutUrl) {
|
||||
throw new Error(`No URL mapping found for layout: ${layout} (tried keys: ${layoutKey}, diy)`)
|
||||
}
|
||||
|
||||
console.log(`🗺️ ${layout.toUpperCase()}: Using layout URL ${layoutUrl}`)
|
||||
|
||||
// Create a dedicated automation instance for this layout
|
||||
layoutSession = new TradingViewAutomation()
|
||||
|
||||
// CRITICAL: Add to active sessions for guaranteed cleanup
|
||||
this.activeSessions.add(layoutSession)
|
||||
|
||||
// Add cleanup task for this session
|
||||
sessionCleanupTasks.push(async () => {
|
||||
if (layoutSession) {
|
||||
console.log(`🧹 Cleaning up ${layout} session...`)
|
||||
try {
|
||||
await layoutSession.forceCleanup()
|
||||
this.activeSessions.delete(layoutSession)
|
||||
console.log(`✅ ${layout} session cleaned up`)
|
||||
} catch (cleanupError) {
|
||||
console.error(`❌ Error cleaning up ${layout} session:`, cleanupError)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
console.log(`🐳 Starting ${layout} browser session...`)
|
||||
await layoutSession.init()
|
||||
|
||||
// Check login status and login if needed
|
||||
const isLoggedIn = await layoutSession.checkLoginStatus()
|
||||
if (!isLoggedIn) {
|
||||
console.log(`🔐 Logging in to ${layout} session...`)
|
||||
if (sessionId && index === 0) {
|
||||
progressTracker.updateStep(sessionId, 'auth', 'active', `Logging into ${layout} session...`)
|
||||
}
|
||||
|
||||
const credentials: TradingViewCredentials = {
|
||||
email: process.env.TRADINGVIEW_EMAIL!,
|
||||
password: process.env.TRADINGVIEW_PASSWORD!
|
||||
}
|
||||
|
||||
const loginSuccess = await layoutSession.login(credentials)
|
||||
if (!loginSuccess) {
|
||||
throw new Error(`Failed to login to ${layout} session`)
|
||||
}
|
||||
} else {
|
||||
console.log(`✅ ${layout.toUpperCase()}: Already logged in`)
|
||||
}
|
||||
|
||||
// Get page from the session
|
||||
const page = (layoutSession as any).page
|
||||
if (!page) {
|
||||
throw new Error(`Failed to get page for ${layout} session`)
|
||||
}
|
||||
|
||||
// Navigate directly to the layout URL with retries and progressive timeout strategy
|
||||
let navigationSuccess = false
|
||||
for (let attempt = 1; attempt <= 3; attempt++) {
|
||||
try {
|
||||
console.log(`🔄 ${layout.toUpperCase()}: Navigation attempt ${attempt}/3`)
|
||||
|
||||
// Progressive waiting strategy: first try domcontentloaded, then networkidle if that fails
|
||||
const waitUntilStrategy = attempt === 1 ? 'domcontentloaded' : 'networkidle0'
|
||||
const timeoutDuration = attempt === 1 ? 30000 : (60000 + (attempt - 1) * 30000)
|
||||
|
||||
const directUrl = `https://www.tradingview.com/chart/?symbol=${config.symbol}&interval=${config.timeframe}&layout=${layoutUrl}`
|
||||
console.log(`🔗 ${layout.toUpperCase()}: Direct navigation to: ${directUrl}`)
|
||||
console.log(`📋 ${layout.toUpperCase()}: Using waitUntil: ${waitUntilStrategy}, timeout: ${timeoutDuration}ms`)
|
||||
|
||||
await page.goto(directUrl, {
|
||||
waitUntil: waitUntilStrategy,
|
||||
timeout: timeoutDuration
|
||||
})
|
||||
|
||||
// If we used domcontentloaded, wait a bit more for dynamic content
|
||||
if (waitUntilStrategy === 'domcontentloaded') {
|
||||
console.log(`⏳ ${layout.toUpperCase()}: Waiting additional 5s for dynamic content...`)
|
||||
await new Promise(resolve => setTimeout(resolve, 5000))
|
||||
}
|
||||
|
||||
navigationSuccess = true
|
||||
break
|
||||
} catch (navError: any) {
|
||||
console.warn(`⚠️ ${layout.toUpperCase()}: Navigation attempt ${attempt} failed:`, navError?.message || navError)
|
||||
if (attempt === 3) {
|
||||
throw new Error(`Failed to navigate to ${layout} layout after 3 attempts: ${navError?.message || navError}`)
|
||||
}
|
||||
// Progressive backoff
|
||||
const waitTime = 2000 * attempt
|
||||
console.log(`⏳ ${layout.toUpperCase()}: Waiting ${waitTime}ms before retry...`)
|
||||
await new Promise(resolve => setTimeout(resolve, waitTime))
|
||||
}
|
||||
}
|
||||
|
||||
if (!navigationSuccess) {
|
||||
throw new Error(`Navigation to ${layout} layout failed after all attempts`)
|
||||
}
|
||||
|
||||
// Wait for chart to load
|
||||
console.log(`⏳ ${layout.toUpperCase()}: Waiting for chart to load...`)
|
||||
|
||||
if (sessionId && index === 0) {
|
||||
progressTracker.updateStep(sessionId, 'auth', 'completed', 'Authentication successful')
|
||||
progressTracker.updateStep(sessionId, 'loading', 'active', 'Loading chart data...')
|
||||
}
|
||||
|
||||
try {
|
||||
// Wait for canvas elements (charts)
|
||||
await page.waitForSelector('canvas', { timeout: 30000 })
|
||||
console.log(`✅ ${layout.toUpperCase()}: Chart canvas found`)
|
||||
} catch (canvasError) {
|
||||
console.warn(`⚠️ ${layout.toUpperCase()}: Chart canvas not found, continuing anyway...`)
|
||||
}
|
||||
|
||||
// Check if it's the primary session for loading progress updates
|
||||
if (sessionId && index === 0) {
|
||||
// Wait for chart data to fully load
|
||||
console.log(`⏳ ${layout.toUpperCase()}: Ensuring chart data is loaded...`)
|
||||
await new Promise(resolve => setTimeout(resolve, 8000))
|
||||
} else {
|
||||
// Additional stabilization wait after chart loads
|
||||
console.log(`⏳ ${layout.toUpperCase()}: Chart stabilization (3s)...`)
|
||||
await new Promise(resolve => setTimeout(resolve, 3000))
|
||||
}
|
||||
|
||||
// Update loading progress when first session completes loading
|
||||
if (sessionId && index === 0) {
|
||||
progressTracker.updateStep(sessionId, 'loading', 'completed', 'Chart data loaded successfully')
|
||||
progressTracker.updateStep(sessionId, 'capture', 'active', 'Capturing screenshots...')
|
||||
}
|
||||
|
||||
// Take screenshot with better error handling
|
||||
const filename = `${config.symbol}_${config.timeframe}_${layout}_${timestamp}.png`
|
||||
console.log(`📸 Taking ${layout} screenshot: ${filename}`)
|
||||
|
||||
let screenshotFile = null
|
||||
try {
|
||||
screenshotFile = await layoutSession.takeScreenshot({ filename })
|
||||
if (screenshotFile) {
|
||||
console.log(`✅ ${layout.toUpperCase()}: Screenshot saved: ${screenshotFile}`)
|
||||
return screenshotFile
|
||||
} else {
|
||||
console.error(`❌ ${layout.toUpperCase()}: Screenshot failed - no file returned`)
|
||||
return null
|
||||
}
|
||||
} catch (screenshotError: any) {
|
||||
console.error(`❌ ${layout.toUpperCase()}: Screenshot capture failed:`, screenshotError?.message || screenshotError)
|
||||
return null
|
||||
}
|
||||
|
||||
} catch (error: any) {
|
||||
console.error(`❌ Error capturing ${layout} layout:`, error?.message || error)
|
||||
console.error(`❌ Full ${layout} error details:`, error)
|
||||
console.error(`❌ ${layout} error stack:`, error?.stack)
|
||||
|
||||
// Attempt to capture browser state for debugging
|
||||
try {
|
||||
const page = (layoutSession as any)?.page
|
||||
if (page) {
|
||||
const url = await page.url()
|
||||
const title = await page.title()
|
||||
console.error(`❌ ${layout} browser state - URL: ${url}, Title: ${title}`)
|
||||
|
||||
// Try to get page content for debugging
|
||||
const bodyText = await page.evaluate(() => document.body.innerText.slice(0, 200))
|
||||
console.error(`❌ ${layout} page content preview:`, bodyText)
|
||||
}
|
||||
} catch (debugError: any) {
|
||||
console.error(`❌ Failed to capture ${layout} browser state:`, debugError?.message || debugError)
|
||||
}
|
||||
|
||||
throw error // Re-throw to be caught by Promise.allSettled
|
||||
}
|
||||
})
|
||||
|
||||
// Execute all sessions in parallel and wait for completion
|
||||
console.log(`\n⚡ Executing ${layoutsToCapture.length} sessions in parallel...`)
|
||||
const results = await Promise.allSettled(sessionPromises)
|
||||
|
||||
// Collect successful screenshots
|
||||
results.forEach((result, index) => {
|
||||
const layout = layoutsToCapture[index]
|
||||
if (result.status === 'fulfilled' && result.value) {
|
||||
screenshotFiles.push(result.value)
|
||||
console.log(`✅ ${layout} parallel session completed successfully`)
|
||||
} else {
|
||||
console.error(`❌ ${layout} parallel session failed:`, result.status === 'rejected' ? result.reason : 'Unknown error')
|
||||
}
|
||||
})
|
||||
|
||||
if (sessionId) {
|
||||
progressTracker.updateStep(sessionId, 'capture', 'completed', `Captured ${screenshotFiles.length}/${layoutsToCapture.length} screenshots`)
|
||||
}
|
||||
|
||||
console.log(`\n🎯 Parallel capture completed: ${screenshotFiles.length}/${layoutsToCapture.length} screenshots`)
|
||||
return screenshotFiles
|
||||
|
||||
} catch (error) {
|
||||
console.error('Enhanced parallel screenshot capture failed:', error)
|
||||
|
||||
if (sessionId) {
|
||||
// Mark the current active step as error
|
||||
const progress = progressTracker.getProgress(sessionId)
|
||||
if (progress) {
|
||||
const activeStep = progress.steps.find(step => step.status === 'active')
|
||||
if (activeStep) {
|
||||
progressTracker.updateStep(sessionId, activeStep.id, 'error', error instanceof Error ? error.message : 'Unknown error')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
throw error
|
||||
} finally {
|
||||
// CRITICAL: Guaranteed cleanup of all sessions created in this operation
|
||||
console.log(`🧹 FINALLY BLOCK: Cleaning up ${sessionCleanupTasks.length} sessions...`)
|
||||
|
||||
try {
|
||||
// Execute all cleanup tasks in parallel with timeout
|
||||
const cleanupPromises = sessionCleanupTasks.map(task =>
|
||||
Promise.race([
|
||||
task(),
|
||||
new Promise((_, reject) =>
|
||||
setTimeout(() => reject(new Error('Cleanup timeout')), 10000)
|
||||
)
|
||||
]).catch(error => {
|
||||
console.error('Session cleanup error:', error)
|
||||
})
|
||||
)
|
||||
|
||||
await Promise.allSettled(cleanupPromises)
|
||||
console.log('✅ FINALLY BLOCK: All session cleanups completed')
|
||||
|
||||
// Additional aggressive cleanup to ensure no processes remain
|
||||
await this.forceKillRemainingProcesses()
|
||||
|
||||
} catch (cleanupError) {
|
||||
console.error('❌ FINALLY BLOCK: Error during session cleanup:', cleanupError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Enhanced cleanup with force process termination
|
||||
private async forceKillRemainingProcesses(): Promise<void> {
|
||||
try {
|
||||
const { exec } = require('child_process')
|
||||
const { promisify } = require('util')
|
||||
const execAsync = promisify(exec)
|
||||
|
||||
console.log('🔧 Force killing any remaining browser processes...')
|
||||
|
||||
// Multiple kill strategies for thorough cleanup
|
||||
const killCommands = [
|
||||
'pkill -f "chromium.*--remote-debugging-port" 2>/dev/null || true',
|
||||
'pkill -f "chromium.*--user-data-dir" 2>/dev/null || true',
|
||||
'pkill -f "/usr/lib/chromium/chromium" 2>/dev/null || true',
|
||||
'pkill -f "chrome.*--remote-debugging-port" 2>/dev/null || true',
|
||||
// Clean up any zombie processes
|
||||
'pkill -9 -f "chromium.*defunct" 2>/dev/null || true'
|
||||
]
|
||||
|
||||
for (const command of killCommands) {
|
||||
try {
|
||||
await execAsync(command)
|
||||
} catch (killError) {
|
||||
// Ignore errors from kill commands as processes might not exist
|
||||
}
|
||||
}
|
||||
|
||||
console.log('✅ Force process cleanup completed')
|
||||
} catch (error) {
|
||||
console.error('Error in force process cleanup:', error)
|
||||
}
|
||||
}
|
||||
|
||||
async cleanup(): Promise<void> {
|
||||
console.log('🧹 Cleaning up parallel browser sessions...')
|
||||
|
||||
const cleanupPromises = []
|
||||
|
||||
// Cleanup all active sessions tracked in this instance
|
||||
for (const session of this.activeSessions) {
|
||||
cleanupPromises.push(
|
||||
session.forceCleanup().catch((err: any) =>
|
||||
console.error('Active session cleanup error:', err)
|
||||
)
|
||||
)
|
||||
}
|
||||
this.activeSessions.clear()
|
||||
|
||||
// Cleanup dedicated AI session if exists
|
||||
if (EnhancedScreenshotService.aiSession) {
|
||||
console.log('🔧 Cleaning up AI session...')
|
||||
cleanupPromises.push(
|
||||
EnhancedScreenshotService.aiSession.forceCleanup().catch((err: any) =>
|
||||
console.error('AI session cleanup error:', err)
|
||||
)
|
||||
)
|
||||
EnhancedScreenshotService.aiSession = null
|
||||
}
|
||||
|
||||
// Cleanup dedicated DIY session if exists
|
||||
if (EnhancedScreenshotService.diySession) {
|
||||
console.log('🔧 Cleaning up DIY session...')
|
||||
cleanupPromises.push(
|
||||
EnhancedScreenshotService.diySession.forceCleanup().catch((err: any) =>
|
||||
console.error('DIY session cleanup error:', err)
|
||||
)
|
||||
)
|
||||
EnhancedScreenshotService.diySession = null
|
||||
}
|
||||
|
||||
// Also cleanup the main singleton session
|
||||
cleanupPromises.push(
|
||||
tradingViewAutomation.forceCleanup().catch((err: any) =>
|
||||
console.error('Main session cleanup error:', err)
|
||||
)
|
||||
)
|
||||
|
||||
// Wait for all cleanup operations to complete
|
||||
await Promise.allSettled(cleanupPromises)
|
||||
|
||||
// Give browsers time to fully close
|
||||
await new Promise(resolve => setTimeout(resolve, 3000))
|
||||
|
||||
console.log('✅ All parallel browser sessions cleaned up')
|
||||
|
||||
// Force kill any remaining browser processes
|
||||
await this.forceKillRemainingProcesses()
|
||||
}
|
||||
|
||||
// Keep existing methods for compatibility
|
||||
async captureQuick(symbol: string, timeframe: string, credentials?: TradingViewCredentials): Promise<string | null> {
|
||||
const automation = tradingViewAutomation
|
||||
|
||||
try {
|
||||
await automation.init()
|
||||
|
||||
if (credentials) {
|
||||
const loginSuccess = await automation.login(credentials)
|
||||
if (!loginSuccess) {
|
||||
throw new Error('Failed to login to TradingView')
|
||||
}
|
||||
}
|
||||
|
||||
// Navigate to symbol and timeframe
|
||||
await automation.navigateToSymbol(symbol, timeframe)
|
||||
|
||||
const filename = `${symbol}_${timeframe}_${Date.now()}.png`
|
||||
return await automation.takeScreenshot({ filename })
|
||||
|
||||
} catch (error) {
|
||||
console.error('Quick capture failed:', error)
|
||||
throw error
|
||||
} finally {
|
||||
// Cleanup after quick capture
|
||||
try {
|
||||
await automation.forceCleanup()
|
||||
} catch (cleanupError) {
|
||||
console.error('Error in quick capture cleanup:', cleanupError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async capture(symbol: string, filename: string): Promise<string[]> {
|
||||
let browser: Browser | null = null
|
||||
|
||||
try {
|
||||
console.log(`Starting enhanced screenshot capture for ${symbol}...`);
|
||||
|
||||
// Launch browser
|
||||
browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || undefined,
|
||||
args: [
|
||||
'--no-sandbox',
|
||||
'--disable-setuid-sandbox',
|
||||
'--disable-dev-shm-usage',
|
||||
'--disable-accelerated-2d-canvas',
|
||||
'--no-first-run',
|
||||
'--no-zygote',
|
||||
'--disable-gpu'
|
||||
]
|
||||
});
|
||||
|
||||
const page = await browser.newPage();
|
||||
await page.setViewport({ width: 1920, height: 1080 });
|
||||
|
||||
// Navigate to TradingView chart
|
||||
await page.goto('https://www.tradingview.com/chart/', {
|
||||
waitUntil: 'networkidle0',
|
||||
timeout: 30000
|
||||
});
|
||||
|
||||
// Wait for chart to load
|
||||
await page.waitForSelector('canvas', { timeout: 30000 });
|
||||
await new Promise(resolve => setTimeout(resolve, 3000));
|
||||
|
||||
// Ensure screenshots directory exists
|
||||
const screenshotsDir = path.join(process.cwd(), 'screenshots')
|
||||
await fs.mkdir(screenshotsDir, { recursive: true })
|
||||
|
||||
// Take screenshot
|
||||
const screenshotPath = path.join(screenshotsDir, filename);
|
||||
await page.screenshot({
|
||||
path: screenshotPath as `${string}.png`,
|
||||
type: 'png',
|
||||
fullPage: false
|
||||
});
|
||||
|
||||
console.log(`Screenshot saved to: ${screenshotPath}`);
|
||||
return [screenshotPath];
|
||||
|
||||
} catch (error) {
|
||||
console.error('Error capturing screenshot:', error);
|
||||
throw error;
|
||||
} finally {
|
||||
// CRITICAL: Always cleanup browser in finally block
|
||||
if (browser) {
|
||||
try {
|
||||
await browser.close();
|
||||
console.log('✅ Browser closed in finally block');
|
||||
} catch (cleanupError) {
|
||||
console.error('Error closing browser in finally block:', cleanupError);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<{ status: 'healthy' | 'error', message?: string }> {
|
||||
let browser: Browser | null = null
|
||||
|
||||
try {
|
||||
// Simple health check - try to launch a browser instance
|
||||
browser = await puppeteer.launch({
|
||||
headless: true,
|
||||
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || undefined,
|
||||
args: [
|
||||
'--no-sandbox',
|
||||
'--disable-setuid-sandbox',
|
||||
'--disable-dev-shm-usage',
|
||||
]
|
||||
});
|
||||
|
||||
return { status: 'healthy' };
|
||||
} catch (error) {
|
||||
return {
|
||||
status: 'error',
|
||||
message: error instanceof Error ? error.message : 'Unknown error'
|
||||
};
|
||||
} finally {
|
||||
// CRITICAL: Always cleanup browser in finally block
|
||||
if (browser) {
|
||||
try {
|
||||
await browser.close();
|
||||
} catch (cleanupError) {
|
||||
console.error('Error closing browser in health check:', cleanupError);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export const enhancedScreenshotService = new EnhancedScreenshotService()
|
||||
Reference in New Issue
Block a user