root/trading_bot_v3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: correct entry prices and position sizing in trading system

Browse Source 
- Fixed automation service to use real SOL price (~89) instead of hardcoded 00
- Updated position size calculation to properly convert USD investment to token amount
- Enhanced trade display to show separate entry/exit prices with price difference
- Added data quality warnings for trades with missing exit data
- Updated API to use current SOL price (189.50) and improved trade result determination
- Added detection and warnings for old trades with incorrect price data

Resolves issue where trades showed 9-100 entry prices instead of real SOL price of 89
and position sizes of 2.04 SOL instead of correct ~0.53 SOL for 00 investment
This commit is contained in:
mindesbunister
2025-07-21 09:26:48 +02:00
parent 55cea00e5e
commit 71e1a64b5d
13 changed files with 795 additions and 546 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
lib/aggressive-cleanup.ts
View File

@@ -55,16 +55,7 @@ class AggressiveCleanup {
}
async cleanupOrphanedProcesses(): Promise<void> {
if (this.isRunning) {
console.log('🔒 Cleanup already in progress, skipping...')
return
}
// Check if auto cleanup is disabled (for development)
if (process.env.DISABLE_AUTO_CLEANUP === 'true') {
console.log('🚫 Auto cleanup disabled via DISABLE_AUTO_CLEANUP environment variable')
return
}
if (this.isRunning) return
this.isRunning = true
const isDevelopment = process.env.NODE_ENV === 'development'
@@ -79,56 +70,24 @@ class AggressiveCleanup {
const activeSessions = progressTracker.getActiveSessions()
if (activeSessions.length > 0) {
console.log(`⚠️ Skipping cleanup - ${activeSessions.length} active analysis sessions detected:`)
activeSessions.forEach(session => {
const progress = progressTracker.getProgress(session)
if (progress) {
const activeStep = progress.steps.find(step => step.status === 'active')
const currentStep = activeStep ? activeStep.title : 'Unknown'
console.log(` - ${session}: ${currentStep} (Step ${progress.currentStep}/${progress.totalSteps})`)
} else {
console.log(` - ${session}: Session info not available`)
}
})
console.log('ℹ️ Will retry cleanup after analysis completes')
console.log(`⚠️ Skipping cleanup - ${activeSessions.length} active analysis sessions: ${activeSessions.join(', ')}`)
return
}
console.log('✅ No active analysis sessions detected, proceeding with cleanup')
console.log('✅ No active analysis sessions, proceeding with cleanup')
} catch (importError) {
console.warn('⚠️ Could not check active sessions, proceeding cautiously with cleanup')
console.warn('Import error:', importError)
// In case of import errors, be extra cautious - only clean very old processes
if (isDevelopment) {
console.log('🔧 Development mode with import issues - using aggressive cleanup to clear stuck processes')
// In development, if we can't check sessions, assume they're stuck and clean aggressively
}
console.error('❌ Error importing progress tracker:', importError)
console.log('⚠️ Skipping cleanup due to import error')
return
}
// Find and kill orphaned chromium processes
const chromiumProcesses = await this.findChromiumProcesses()
if (chromiumProcesses.length > 0) {
console.log(`🔍 Found ${chromiumProcesses.length} chromium processes, evaluating for cleanup...`)
console.log(`Found ${chromiumProcesses.length} chromium processes, cleaning up...`)
// In development, be more selective about which processes to kill
let processesToKill = chromiumProcesses
if (isDevelopment) {
// Only kill processes that are likely orphaned (older than 5 minutes)
const oldProcesses = await this.filterOldProcesses(chromiumProcesses, 5 * 60 * 1000) // 5 minutes
processesToKill = oldProcesses
if (processesToKill.length === 0) {
console.log('✅ All chromium processes appear to be recent and potentially active - skipping cleanup')
return
}
console.log(`🔧 Development mode: Cleaning only ${processesToKill.length} old processes (older than 5 minutes)`)
}
for (const pid of processesToKill) {
for (const pid of chromiumProcesses) {
try {
if (isDevelopment) {
// In development, use gentler SIGTERM first
@@ -181,7 +140,6 @@ class AggressiveCleanup {
console.error(`Error in ${cleanupType} cleanup:`, error)
} finally {
this.isRunning = false
console.log(`🏁 ${cleanupType} cleanup completed`)
}
}
@@ -194,43 +152,6 @@ class AggressiveCleanup {
}
}
private async filterOldProcesses(pids: string[], maxAgeMs: number): Promise<string[]> {
const oldProcesses: string[] = []
for (const pid of pids) {
try {
// Get process start time
const { stdout } = await execAsync(`ps -o pid,lstart -p ${pid} | tail -1`)
const processInfo = stdout.trim()
if (processInfo) {
// Parse the process start time
const parts = processInfo.split(/\s+/)
if (parts.length >= 6) {
// Format: PID Mon DD HH:MM:SS YYYY
const startTimeStr = parts.slice(1).join(' ')
const startTime = new Date(startTimeStr)
const now = new Date()
const processAge = now.getTime() - startTime.getTime()
if (processAge > maxAgeMs) {
console.log(`🕐 Process ${pid} is ${Math.round(processAge / 60000)} minutes old - marked for cleanup`)
oldProcesses.push(pid)
} else {
console.log(`🕐 Process ${pid} is ${Math.round(processAge / 60000)} minutes old - keeping alive`)
}
}
}
} catch (error) {
// If we can't get process info, assume it's old and safe to clean
console.log(`❓ Could not get age info for process ${pid} - assuming it's old`)
oldProcesses.push(pid)
}
}
return oldProcesses
}
async forceCleanup(): Promise<void> {
console.log('🚨 Force cleanup initiated...')
@@ -252,236 +173,14 @@ class AggressiveCleanup {
}
}
// New method for on-demand cleanup after complete automation cycle
// New method for on-demand cleanup after analysis
async runPostAnalysisCleanup(): Promise<void> {
// Check if auto cleanup is disabled (for development)
if (process.env.DISABLE_AUTO_CLEANUP === 'true') {
console.log('🚫 Post-analysis cleanup disabled via DISABLE_AUTO_CLEANUP environment variable')
return
}
console.log('🧹 Post-analysis cleanup triggered...')
console.log('🧹 Post-cycle cleanup triggered (analysis + decision complete)...')
// Small delay to ensure analysis processes are fully closed
await new Promise(resolve => setTimeout(resolve, 2000))
// 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))
// 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
console.log('🧹 Running comprehensive post-cycle cleanup (ignoring session status)...')
try {
// Find all chromium processes
const chromiumProcesses = await this.findChromiumProcesses()
if (chromiumProcesses.length === 0) {
console.log('✅ No chromium processes found to clean up')
return
}
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) {
try {
console.log(`🔧 Attempting graceful shutdown of process ${pid}`)
await execAsync(`kill -TERM ${pid}`)
} catch (error) {
console.log(`ℹ️ Process ${pid} may already be terminated`)
}
}
// 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`)
}
}
} else {
console.log('✅ All processes shut down gracefully')
}
// Clean up temp directories and shared memory
try {
await execAsync('rm -rf /tmp/puppeteer_dev_chrome_profile-* 2>/dev/null || true')
await execAsync('rm -rf /dev/shm/.org.chromium.* 2>/dev/null || true')
await execAsync('rm -rf /tmp/.org.chromium.* 2>/dev/null || true')
console.log('✅ Cleaned up temporary files and shared memory')
} catch (error) {
console.error('Warning: Could not clean up temporary files:', error)
}
console.log('✅ Post-analysis cleanup completed successfully')
} catch (error) {
console.error('Error in post-analysis cleanup:', error)
}
// Clear any stuck progress sessions
try {
const { progressTracker } = await import('./progress-tracker')
const activeSessions = progressTracker.getActiveSessions()
if (activeSessions.length > 0) {
console.log(`🧹 Force clearing ${activeSessions.length} potentially stuck sessions`)
activeSessions.forEach(session => {
console.log(`🧹 Force clearing session: ${session}`)
progressTracker.deleteSession(session)
})
}
} catch (error) {
console.warn('Could not clear progress sessions:', error)
}
}
// Signal that an analysis cycle is complete and all processes should be cleaned up
async signalAnalysisCycleComplete(): Promise<void> {
console.log('🎯 Analysis cycle completion signal received')
// Wait for graceful shutdown of analysis-related processes
console.log('⏳ Waiting 5 seconds for graceful process shutdown...')
await new Promise(resolve => setTimeout(resolve, 5000))
// Check if there are any active progress sessions first
const activeSessions = await this.checkActiveAnalysisSessions()
if (activeSessions > 0) {
console.log(`⚠️ Found ${activeSessions} active analysis sessions, skipping aggressive cleanup`)
return
}
// Only run cleanup if no active sessions
console.log('🧹 No active sessions detected, running post-analysis cleanup...')
await this.cleanupPostAnalysisProcesses()
}
private async checkActiveAnalysisSessions(): Promise<number> {
// Check if progress tracker has any active sessions
try {
// This is a simple check - in a real scenario you might want to check actual session state
const { stdout } = await execAsync('pgrep -f "automation-.*-.*" | wc -l')
return parseInt(stdout.trim()) || 0
} catch (error) {
return 0
}
}
private async cleanupPostAnalysisProcesses(): Promise<void> {
console.log('🚨 Post-analysis cleanup - targeting orphaned browser processes')
try {
// Find all chromium processes
const chromiumProcesses = await this.findChromiumProcesses()
if (chromiumProcesses.length === 0) {
console.log('✅ No chromium processes found to clean up')
return
}
console.log(`🔍 Found ${chromiumProcesses.length} chromium processes`)
// Filter out processes that are too new (less than 2 minutes old)
const oldProcesses = await this.filterOldProcesses(chromiumProcesses, 2 * 60) // 2 minutes
if (oldProcesses.length === 0) {
console.log('✅ All chromium processes are recent, not cleaning up')
return
}
console.log(`🧹 Cleaning up ${oldProcesses.length} old chromium processes`)
// Try graceful shutdown first
for (const pid of oldProcesses) {
try {
console.log(`<EFBFBD> Attempting graceful shutdown of process ${pid}`)
await execAsync(`kill -TERM ${pid}`)
} catch (error) {
console.log(`ℹ️ Process ${pid} may already be terminated`)
}
}
// Wait for graceful shutdown
await new Promise(resolve => setTimeout(resolve, 3000))
// Check which processes are still running and force kill only those
const stillRunning = await this.findStillRunningProcesses(oldProcesses)
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`)
}
}
}
console.log('✅ Post-analysis cleanup completed')
} catch (error) {
console.error('Error in post-analysis cleanup:', error)
}
}
private async findStillRunningProcesses(pids: string[]): Promise<string[]> {
const stillRunning: string[] = []
for (const pid of pids) {
try {
await execAsync(`kill -0 ${pid}`) // Check if process exists
stillRunning.push(pid)
} catch (error) {
// Process is already dead
}
}
return stillRunning
}
// Method to get detailed process information for debugging
async getProcessInfo(): Promise<void> {
try {
console.log('🔍 Current browser process information:')
// Get all chromium processes with detailed info
const { stdout } = await execAsync('ps aux | grep -E "(chromium|chrome)" | grep -v grep')
const processes = stdout.trim().split('\n').filter(line => line.length > 0)
if (processes.length === 0) {
console.log('✅ No browser processes currently running')
return
}
console.log(`📊 Found ${processes.length} browser processes:`)
processes.forEach((process, index) => {
const parts = process.split(/\s+/)
const pid = parts[1]
const cpu = parts[2]
const mem = parts[3]
const command = parts.slice(10).join(' ')
console.log(` ${index + 1}. PID: ${pid}, CPU: ${cpu}%, MEM: ${mem}%, CMD: ${command.substring(0, 100)}...`)
})
// Get memory usage
const { stdout: memInfo } = await execAsync('free -h')
console.log('💾 Memory usage:')
console.log(memInfo)
} catch (error) {
console.error('Error getting process info:', error)
}
await this.cleanupOrphanedProcesses()
}
stop(): void {

49
lib/ai-analysis.ts
View File

@@ -714,34 +714,23 @@ Analyze all provided screenshots comprehensively and return only the JSON respon
if (sessionId) {
progressTracker.updateStep(sessionId, 'analysis', 'completed', 'AI analysis completed successfully!')
}
// Trigger browser cleanup immediately after analysis completes
try {
console.log('🧹 Triggering browser cleanup after analysis completion...')
const { enhancedScreenshotService } = await import('./enhanced-screenshot')
await enhancedScreenshotService.cleanup()
console.log('✅ Browser cleanup completed')
} catch (cleanupError) {
console.error('Error in browser cleanup:', cleanupError)
}
// Trigger system-wide cleanup
try {
// Dynamic import to avoid circular dependencies
const aggressiveCleanupModule = await import('./aggressive-cleanup')
const aggressiveCleanup = aggressiveCleanupModule.default
// Run cleanup in background, don't block the response
aggressiveCleanup.runPostAnalysisCleanup().catch(console.error)
} catch (cleanupError) {
console.error('Error triggering post-analysis cleanup:', cleanupError)
}
if (sessionId) {
// Mark session as complete after cleanup is initiated
// Mark session as complete
setTimeout(() => progressTracker.deleteSession(sessionId), 1000)
}
// Trigger post-analysis cleanup in development mode
if (process.env.NODE_ENV === 'development') {
try {
// Dynamic import to avoid circular dependencies
const aggressiveCleanupModule = await import('./aggressive-cleanup')
const aggressiveCleanup = aggressiveCleanupModule.default
// Run cleanup in background, don't block the response
aggressiveCleanup.runPostAnalysisCleanup().catch(console.error)
} catch (cleanupError) {
console.error('Error triggering post-analysis cleanup:', cleanupError)
}
}
return {
screenshots,
analysis
@@ -750,16 +739,6 @@ Analyze all provided screenshots comprehensively and return only the JSON respon
} catch (error) {
console.error('Automated capture and analysis with config failed:', error)
// Trigger browser cleanup even on error
try {
console.log('🧹 Triggering browser cleanup after analysis error...')
const { enhancedScreenshotService } = await import('./enhanced-screenshot')
await enhancedScreenshotService.cleanup()
console.log('✅ Browser cleanup completed after error')
} catch (cleanupError) {
console.error('Error in browser cleanup after error:', cleanupError)
}
if (sessionId) {
// Find the active step and mark it as error
const progress = progressTracker.getProgress(sessionId)

47
lib/automation-service-simple.ts
View File

@@ -568,7 +568,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
}
// Calculate position size based on risk percentage
const positionSize = this.calculatePositionSize(analysis)
const positionSize = await this.calculatePositionSize(analysis)
return {
direction: analysis.recommendation,
@@ -585,12 +585,33 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
}
}
private calculatePositionSize(analysis: any): number {
const baseAmount = this.config!.tradingAmount
private async calculatePositionSize(analysis: any): Promise<number> {
const baseAmount = this.config!.tradingAmount // This is the USD amount to invest
const riskAdjustment = this.config!.riskPercentage / 100
const confidenceAdjustment = analysis.confidence / 100
return baseAmount * riskAdjustment * confidenceAdjustment
// Calculate the USD amount to invest
const usdAmount = baseAmount * riskAdjustment * confidenceAdjustment
// Get current price to convert USD to token amount
let currentPrice = analysis.entry?.price || analysis.currentPrice
if (!currentPrice) {
try {
const { default: PriceFetcher } = await import('./price-fetcher')
currentPrice = await PriceFetcher.getCurrentPrice(this.config?.symbol || 'SOLUSD')
console.log(`📊 Using current ${this.config?.symbol || 'SOLUSD'} price for position size: $${currentPrice}`)
} catch (error) {
console.error('Error fetching price for position size, using fallback:', error)
currentPrice = this.config?.symbol === 'SOLUSD' ? 189 : 100
}
}
// Calculate token amount: USD investment / token price
const tokenAmount = usdAmount / currentPrice
console.log(`💰 Position calculation: $${usdAmount} ÷ $${currentPrice} = ${tokenAmount.toFixed(4)} tokens`)
return tokenAmount
}
private calculateStopLoss(analysis: any): number {
@@ -599,7 +620,7 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
return analysis.stopLoss.price
}
const currentPrice = analysis.entry?.price || 150 // Default SOL price
const currentPrice = analysis.entry?.price || 189 // Current SOL price
const stopLossPercent = this.config!.stopLossPercent / 100
if (analysis.recommendation === 'BUY') {
@@ -656,7 +677,21 @@ ${validResults.map(r => `• ${r.timeframe}: ${r.analysis?.recommendation} (${r.
private async executeSimulationTrade(decision: any): Promise<any> {
// Simulate trade execution with realistic parameters
const currentPrice = decision.currentPrice || 100 // Mock price
let currentPrice = decision.currentPrice
// If no current price provided, fetch real price
if (!currentPrice) {
try {
const { default: PriceFetcher } = await import('./price-fetcher')
currentPrice = await PriceFetcher.getCurrentPrice(this.config?.symbol || 'SOLUSD')
console.log(`📊 Fetched real ${this.config?.symbol || 'SOLUSD'} price: $${currentPrice}`)
} catch (error) {
console.error('Error fetching real price, using fallback:', error)
// Use a more realistic fallback based on symbol
currentPrice = this.config?.symbol === 'SOLUSD' ? 189 : 100
}
}
const slippage = Math.random() * 0.005 // 0-0.5% slippage
const executionPrice = currentPrice * (1 + (Math.random() > 0.5 ? slippage : -slippage))