Spaces:

hello-yaaash25
/

DoclessAPIAgent

Runtime error

Remove favicon.ico 404 errors - add favicon handler and prevent browser requests

d0ea8bd about 1 year ago

18 kB

#!/usr/bin/env node

const express = require('express');
const path = require('path');
const cors = require('cors');
const fs = require('fs').promises;
const DemoStreamingService = require('./demo-streaming');
const SpacesStorageManager = require('./storage-manager');

const app = express();
const PORT = process.env.PORT || 3000;
const IS_SPACES = process.env.IS_SPACES === 'true';
const WORKSPACE_DIR = process.env.WORKSPACE_DIR || './demo-sessions';

// Initialize services
const streamingService = new DemoStreamingService();
const storageManager = new SpacesStorageManager(WORKSPACE_DIR);

// Hugging Face Spaces optimized middleware
if (IS_SPACES) {
    // Trust proxy for Spaces environment
    app.set('trust proxy', true);
    
    // Add Spaces-specific headers and force HTTPS
    app.use((req, res, next) => {
        // Force HTTPS redirect in Spaces
        if (req.header('x-forwarded-proto') !== 'https') {
            res.redirect(`https://${req.header('host')}${req.url}`);
            return;
        }
        
        res.setHeader('X-Frame-Options', 'SAMEORIGIN');
        res.setHeader('X-Content-Type-Options', 'nosniff');
        res.setHeader('X-Powered-By', 'Doc-less API Agent on Spaces');
        res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
        res.setHeader('X-XSS-Protection', '1; mode=block');
        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
        next();
    });
}

// Enhanced CORS configuration for Spaces
const corsOptions = {
    origin: IS_SPACES ? true : (process.env.CORS_ORIGIN || '*'),
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
    allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
    credentials: false
};
app.use(cors(corsOptions));

// Body parsing middleware
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// Serve static files with proper headers
app.use(express.static('.', {
    setHeaders: (res, path) => {
        if (path.endsWith('.html')) {
            res.setHeader('Content-Type', 'text/html; charset=utf-8');
        } else if (path.endsWith('.js')) {
            res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
        } else if (path.endsWith('.css')) {
            res.setHeader('Content-Type', 'text/css; charset=utf-8');
        } else if (path.endsWith('.json')) {
            res.setHeader('Content-Type', 'application/json; charset=utf-8');
        } else if (path.endsWith('.md')) {
            res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
        } else if (path.endsWith('.yaml') || path.endsWith('.yml')) {
            res.setHeader('Content-Type', 'text/yaml; charset=utf-8');
        }
        
        // Cache static assets appropriately
        if (path.includes('demo-output') || path.includes('deliverables')) {
            res.setHeader('Cache-Control', 'public, max-age=300'); // 5 minutes
        } else {
            res.setHeader('Cache-Control', 'no-cache');
        }
    }
}));

// Main route - serve the demo interface
app.get('/', (req, res) => {
    try {
        console.log(`📱 Serving demo interface to ${req.ip} - User Agent: ${req.get('User-Agent')?.substring(0, 50)}...`);
        
        // Add headers for better compatibility
        res.setHeader('Content-Type', 'text/html; charset=utf-8');
        res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
        res.setHeader('Pragma', 'no-cache');
        res.setHeader('Expires', '0');
        
        // Send the file with error handling
        res.sendFile(path.join(__dirname, 'demo-interface.html'), (err) => {
            if (err) {
                console.error('❌ Error serving demo interface:', err);
                res.status(500).send(`
                    <!DOCTYPE html>
                    <html>
                    <head><title>Doc-less API Agent</title></head>
                    <body style="font-family: Arial, sans-serif; padding: 20px;">
                        <h1>🤖 Doc-less API Agent</h1>
                        <p>Demo interface is loading...</p>
                        <p>Server Status: ✅ Running</p>
                        <p>Environment: ${IS_SPACES ? 'Hugging Face Spaces' : 'Local'}</p>
                        <p>Port: ${PORT}</p>
                        <p>Time: ${new Date().toISOString()}</p>
                        <a href="/health">Health Check</a> | 
                        <a href="/test">Test Endpoint</a> | 
                        <a href="/api/status">API Status</a>
                    </body>
                    </html>
                `);
            }
        });
    } catch (error) {
        console.error('❌ Fatal error in main route:', error);
        res.status(500).json({ 
            error: 'Internal Server Error',
            message: 'Unable to serve demo interface',
            timestamp: new Date().toISOString()
        });
    }
});

app.get('/favicon.ico', (req, res) => {
    res.status(204).end();
});

// Simple test route for debugging
app.get('/test', (req, res) => {
    console.log(`🧪 Test endpoint accessed from ${req.ip}`);
    res.json({
        status: 'success',
        message: 'Doc-less API Agent is working!',
        timestamp: new Date().toISOString(),
        environment: IS_SPACES ? 'Hugging Face Spaces' : 'Local',
        port: PORT,
        uptime: process.uptime()
    });
});

// Debug page for troubleshooting
app.get('/debug', (req, res) => {
    console.log(`🔧 Debug page accessed from ${req.ip}`);
    res.sendFile(path.join(__dirname, 'debug.html'));
});

// Health check endpoint with detailed information
app.get('/health', async (req, res) => {
    const health = {
        status: 'healthy',
        timestamp: new Date().toISOString(),
        uptime: process.uptime(),
        environment: IS_SPACES ? 'spaces' : 'local',
        port: PORT,
        version: process.env.npm_package_version || '1.0.0',
        memory: process.memoryUsage(),
        workspace: WORKSPACE_DIR,
        request_info: {
            ip: req.ip,
            user_agent: req.get('User-Agent'),
            headers: req.headers
        },
        services: {
            streaming: {
                active_sessions: streamingService.getActiveSessionsCount(),
                active_streams: streamingService.getActiveStreamsCount()
            },
            storage: await storageManager.getStorageStats()
        }
    };

    // Check workspace directory
    try {
        await fs.access(WORKSPACE_DIR);
        health.workspace_accessible = true;
    } catch (error) {
        health.workspace_accessible = false;
        health.workspace_error = error.message;
    }

    // Add CORS headers for health check
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'GET');
    res.setHeader('Cache-Control', 'no-cache');
    
    console.log(`🏥 Health check from ${req.ip} - Status: ${health.status}`);
    res.json(health);
});

// Spaces-specific metadata endpoint
app.get('/spaces/info', (req, res) => {
    res.json({
        title: '🤖 Doc-less API Agent',
        description: 'Interactive API documentation and SDK generator demo',
        version: '1.0.0',
        features: [
            'Live API Discovery',
            'OpenAPI Generation',
            'TypeScript SDK Creation',
            'Postman Collections',
            'Mock Lab Environment',
            'Evidence Reports',
            'Real-time Demo Streaming'
        ],
        demo_paths: [
            '/ - Interactive Demo Interface',
            '/api/status - Service Status',
            '/api/demo/stream - Live Demo Stream',
            '/deliverables - Generated Files',
            '/spaces/info - This Information'
        ],
        github: 'https://github.com/ysrastogi/apiWitness',
        is_spaces: IS_SPACES,
        uptime: process.uptime()
    });
});

// Server-Sent Events endpoint for real-time demo streaming
app.get('/api/demo/stream', streamingService.createSSEEndpoint());

// API endpoints for demo integration
app.get('/api/status', async (req, res) => {
    const status = {
        services: {
            main_server: `http://localhost:${PORT}`,
            demo_interface: `http://localhost:${PORT}/`,
            deliverables: `http://localhost:${PORT}/deliverables`,
            demo_stream: `http://localhost:${PORT}/api/demo/stream`
        },
        environment: {
            is_spaces: IS_SPACES,
            workspace: WORKSPACE_DIR,
            node_env: process.env.NODE_ENV || 'development'
        },
        demo: {
            interface_url: `http://localhost:${PORT}`,
            deliverables_url: `http://localhost:${PORT}/deliverables`,
            health_check: `http://localhost:${PORT}/health`,
            streaming_url: `http://localhost:${PORT}/api/demo/stream`
        },
        streaming: {
            active_sessions: streamingService.getActiveSessionsCount(),
            active_streams: streamingService.getActiveStreamsCount()
        },
        timestamp: new Date().toISOString()
    };

    // Check if demo assets exist
    try {
        const demoOutputs = await fs.readdir('.', { withFileTypes: true });
        const demoFolders = demoOutputs
            .filter(dirent => dirent.isDirectory() && dirent.name.startsWith('demo-output-'))
            .map(dirent => dirent.name);
        
        status.available_demos = demoFolders;
    } catch (error) {
        status.demo_scan_error = error.message;
    }

    res.json(status);
});

// Demo session management for Spaces
app.post('/api/demo/start', async (req, res) => {
    try {
        const { sessionId, config = {} } = req.body;
        const finalSessionId = sessionId || `demo-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
        
        // Create storage session
        const session = await storageManager.createSession(finalSessionId);
        
        // Start streaming demo
        const demoConfig = streamingService.startDemoSession(finalSessionId, {
            delays: config.delays !== false, // Default to true
            realExecution: config.realExecution || false,
            ...config
        });
        
        console.log(`🎬 Demo started: ${finalSessionId}`);
        res.json({
            sessionId: finalSessionId,
            session,
            demoConfig,
            streamUrl: `/api/demo/stream?sessionId=${finalSessionId}`
        });
        
    } catch (error) {
        console.error('❌ Error starting demo:', error);
        res.status(500).json({ error: error.message });
    }
});

// Get demo session status
app.get('/api/demo/:sessionId/status', (req, res) => {
    const { sessionId } = req.params;
    const status = streamingService.getSessionStatus(sessionId);
    
    if (status) {
        res.json(status);
    } else {
        res.status(404).json({ error: 'Session not found' });
    }
});

// Save demo result file
app.post('/api/demo/:sessionId/save', async (req, res) => {
    try {
        const { sessionId } = req.params;
        const { fileName, content, metadata } = req.body;
        
        if (!fileName || content === undefined) {
            return res.status(400).json({ error: 'fileName and content are required' });
        }
        
        const filePath = await storageManager.saveFile(sessionId, fileName, content, metadata);
        
        res.json({
            success: true,
            fileName,
            path: filePath,
            sessionId
        });
        
    } catch (error) {
        console.error('❌ Error saving file:', error);
        res.status(500).json({ error: error.message });
    }
});

// Get demo session files
app.get('/api/demo/:sessionId/files', async (req, res) => {
    try {
        const { sessionId } = req.params;
        const session = await storageManager.getSession(sessionId);
        
        if (!session) {
            return res.status(404).json({ error: 'Session not found' });
        }
        
        res.json({
            sessionId,
            files: session.files || []
        });
        
    } catch (error) {
        console.error('❌ Error getting session files:', error);
        res.status(500).json({ error: error.message });
    }
});

// Get specific file from session
app.get('/api/demo/:sessionId/files/:fileName', async (req, res) => {
    try {
        const { sessionId, fileName } = req.params;
        const content = await storageManager.getFile(sessionId, fileName);
        
        if (content === null) {
            return res.status(404).json({ error: 'File not found' });
        }
        
        // Set appropriate content type
        if (fileName.endsWith('.json')) {
            res.setHeader('Content-Type', 'application/json');
        } else if (fileName.endsWith('.md')) {
            res.setHeader('Content-Type', 'text/markdown');
        } else if (fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
            res.setHeader('Content-Type', 'text/yaml');
        } else if (fileName.endsWith('.ts')) {
            res.setHeader('Content-Type', 'text/typescript');
        }
        
        res.send(content);
        
    } catch (error) {
        console.error('❌ Error getting file:', error);
        res.status(500).json({ error: error.message });
    }
});

// Serve deliverables directory with better error handling
app.use('/deliverables', express.static('demo-output-*', {
    setHeaders: (res, path) => {
        res.setHeader('Access-Control-Allow-Origin', '*');
        if (path.endsWith('.json')) {
            res.setHeader('Content-Type', 'application/json');
        } else if (path.endsWith('.md')) {
            res.setHeader('Content-Type', 'text/markdown');
        } else if (path.endsWith('.yaml') || path.endsWith('.yml')) {
            res.setHeader('Content-Type', 'text/yaml');
        }
    }
}));

// Serve static demo outputs if available
app.get('/demo-assets/:asset', async (req, res) => {
    const asset = req.params.asset;
    
    try {
        // Look for the asset in any demo-output directory
        const dirs = await fs.readdir('.');
        const demoDir = dirs.find(dir => dir.startsWith('demo-output-'));
        
        if (demoDir) {
            const assetPath = path.join(demoDir, asset);
            await fs.access(assetPath);
            res.sendFile(path.resolve(assetPath));
        } else {
            res.status(404).json({ error: 'Demo assets not found' });
        }
    } catch (error) {
        console.error(`❌ Error serving asset ${asset}:`, error);
        res.status(404).json({ error: 'Asset not found' });
    }
});

// Analytics endpoint (privacy-compliant)
app.post('/api/analytics', (req, res) => {
    const { event, category, label, value } = req.body;
    
    // Log analytics data (can be enhanced to send to analytics service)
    console.log(`📊 Analytics: ${category}/${event}`, { 
        label, 
        value, 
        timestamp: new Date().toISOString(),
        ip: req.ip,
        userAgent: req.get('User-Agent')
    });
    
    res.json({ status: 'logged' });
});

// Storage management endpoints
app.get('/api/storage/stats', async (req, res) => {
    try {
        const stats = await storageManager.getStorageStats();
        res.json(stats);
    } catch (error) {
        console.error('❌ Error getting storage stats:', error);
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/storage/cleanup', async (req, res) => {
    try {
        const deletedCount = await storageManager.cleanup();
        res.json({ success: true, deleted: deletedCount });
    } catch (error) {
        console.error('❌ Error during cleanup:', error);
        res.status(500).json({ error: error.message });
    }
});

// 404 handler - redirect to demo interface for SPA behavior
app.use((req, res) => {
    console.log(`🔍 404 for ${req.path}, redirecting to demo interface`);
    res.status(404).sendFile(path.join(__dirname, 'demo-interface.html'));
});

// Enhanced error handler
app.use((error, req, res, next) => {
    console.error('❌ Server Error:', {
        message: error.message,
        stack: error.stack,
        url: req.url,
        method: req.method,
        timestamp: new Date().toISOString()
    });
    
    res.status(error.status || 500).json({
        error: IS_SPACES ? 'Internal Server Error' : error.message,
        timestamp: new Date().toISOString(),
        path: req.path
    });
});

// Graceful shutdown handling
process.on('SIGTERM', () => {
    console.log('🛑 SIGTERM received, shutting down gracefully');
    process.exit(0);
});

process.on('SIGINT', () => {
    console.log('🛑 SIGINT received, shutting down gracefully');
    process.exit(0);
});

// Start server
app.listen(PORT, '0.0.0.0', () => {
    console.log(`🌐 Doc-less API Agent ${IS_SPACES ? '(Spaces)' : '(Local)'} running on:`);
    console.log(`   Local:    http://localhost:${PORT}`);
    console.log(`   Network:  http://0.0.0.0:${PORT}`);
    console.log(`   Health:   http://localhost:${PORT}/health`);
    console.log(`   API:      http://localhost:${PORT}/api/status`);
    console.log(`   Stream:   http://localhost:${PORT}/api/demo/stream`);
    console.log(`   Info:     http://localhost:${PORT}/spaces/info`);
    console.log('');
    console.log('📁 Serving files from:', __dirname);
    console.log('💾 Workspace directory:', WORKSPACE_DIR);
    console.log('🎯 Environment:', IS_SPACES ? 'Hugging Face Spaces' : 'Local Development');
    console.log(`🎥 Streaming service: ${streamingService.getActiveSessionsCount()} active sessions`);
    
    // Initialize storage manager after server starts
    console.log('💾 Storage manager initialized:', WORKSPACE_DIR);
    console.log('⏰ Cleanup timer started (every 60 minutes)');
});

module.exports = app;

	#!/usr/bin/env node

	const express = require('express');
	const path = require('path');
	const cors = require('cors');
	const fs = require('fs').promises;
	const DemoStreamingService = require('./demo-streaming');
	const SpacesStorageManager = require('./storage-manager');

	const app = express();
	const PORT = process.env.PORT \|\| 3000;
	const IS_SPACES = process.env.IS_SPACES === 'true';
	const WORKSPACE_DIR = process.env.WORKSPACE_DIR \|\| './demo-sessions';

	// Initialize services
	const streamingService = new DemoStreamingService();
	const storageManager = new SpacesStorageManager(WORKSPACE_DIR);

	// Hugging Face Spaces optimized middleware
	if (IS_SPACES) {
	// Trust proxy for Spaces environment
	app.set('trust proxy', true);

	// Add Spaces-specific headers and force HTTPS
	app.use((req, res, next) => {
	// Force HTTPS redirect in Spaces
	if (req.header('x-forwarded-proto') !== 'https') {
	res.redirect(`https://${req.header('host')}${req.url}`);
	return;
	}

	res.setHeader('X-Frame-Options', 'SAMEORIGIN');
	res.setHeader('X-Content-Type-Options', 'nosniff');
	res.setHeader('X-Powered-By', 'Doc-less API Agent on Spaces');
	res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
	res.setHeader('X-XSS-Protection', '1; mode=block');
	res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
	next();
	});
	}

	// Enhanced CORS configuration for Spaces
	const corsOptions = {
	origin: IS_SPACES ? true : (process.env.CORS_ORIGIN \|\| '*'),
	methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
	allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
	credentials: false
	};
	app.use(cors(corsOptions));

	// Body parsing middleware
	app.use(express.json({ limit: '10mb' }));
	app.use(express.urlencoded({ extended: true, limit: '10mb' }));

	// Serve static files with proper headers
	app.use(express.static('.', {
	setHeaders: (res, path) => {
	if (path.endsWith('.html')) {
	res.setHeader('Content-Type', 'text/html; charset=utf-8');
	} else if (path.endsWith('.js')) {
	res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
	} else if (path.endsWith('.css')) {
	res.setHeader('Content-Type', 'text/css; charset=utf-8');
	} else if (path.endsWith('.json')) {
	res.setHeader('Content-Type', 'application/json; charset=utf-8');
	} else if (path.endsWith('.md')) {
	res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
	} else if (path.endsWith('.yaml') \|\| path.endsWith('.yml')) {
	res.setHeader('Content-Type', 'text/yaml; charset=utf-8');
	}

	// Cache static assets appropriately
	if (path.includes('demo-output') \|\| path.includes('deliverables')) {
	res.setHeader('Cache-Control', 'public, max-age=300'); // 5 minutes
	} else {
	res.setHeader('Cache-Control', 'no-cache');
	}
	}
	}));

	// Main route - serve the demo interface
	app.get('/', (req, res) => {
	try {
	console.log(`📱 Serving demo interface to ${req.ip} - User Agent: ${req.get('User-Agent')?.substring(0, 50)}...`);

	// Add headers for better compatibility
	res.setHeader('Content-Type', 'text/html; charset=utf-8');
	res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
	res.setHeader('Pragma', 'no-cache');
	res.setHeader('Expires', '0');

	// Send the file with error handling
	res.sendFile(path.join(__dirname, 'demo-interface.html'), (err) => {
	if (err) {
	console.error('❌ Error serving demo interface:', err);
	res.status(500).send(`
	<!DOCTYPE html>
	<html>
	<head><title>Doc-less API Agent</title></head>
	<body style="font-family: Arial, sans-serif; padding: 20px;">
	<h1>🤖 Doc-less API Agent</h1>
	<p>Demo interface is loading...</p>
	<p>Server Status: ✅ Running</p>
	<p>Environment: ${IS_SPACES ? 'Hugging Face Spaces' : 'Local'}</p>
	<p>Port: ${PORT}</p>
	<p>Time: ${new Date().toISOString()}</p>
	<a href="/health">Health Check</a> \|
	<a href="/test">Test Endpoint</a> \|
	<a href="/api/status">API Status</a>
	</body>
	</html>
	`);
	}
	});
	} catch (error) {
	console.error('❌ Fatal error in main route:', error);
	res.status(500).json({
	error: 'Internal Server Error',
	message: 'Unable to serve demo interface',
	timestamp: new Date().toISOString()
	});
	}
	});

	app.get('/favicon.ico', (req, res) => {
	res.status(204).end();
	});

	// Simple test route for debugging
	app.get('/test', (req, res) => {
	console.log(`🧪 Test endpoint accessed from ${req.ip}`);
	res.json({
	status: 'success',
	message: 'Doc-less API Agent is working!',
	timestamp: new Date().toISOString(),
	environment: IS_SPACES ? 'Hugging Face Spaces' : 'Local',
	port: PORT,
	uptime: process.uptime()
	});
	});

	// Debug page for troubleshooting
	app.get('/debug', (req, res) => {
	console.log(`🔧 Debug page accessed from ${req.ip}`);
	res.sendFile(path.join(__dirname, 'debug.html'));
	});

	// Health check endpoint with detailed information
	app.get('/health', async (req, res) => {
	const health = {
	status: 'healthy',
	timestamp: new Date().toISOString(),
	uptime: process.uptime(),
	environment: IS_SPACES ? 'spaces' : 'local',
	port: PORT,
	version: process.env.npm_package_version \|\| '1.0.0',
	memory: process.memoryUsage(),
	workspace: WORKSPACE_DIR,
	request_info: {
	ip: req.ip,
	user_agent: req.get('User-Agent'),
	headers: req.headers
	},
	services: {
	streaming: {
	active_sessions: streamingService.getActiveSessionsCount(),
	active_streams: streamingService.getActiveStreamsCount()
	},
	storage: await storageManager.getStorageStats()
	}
	};

	// Check workspace directory
	try {
	await fs.access(WORKSPACE_DIR);
	health.workspace_accessible = true;
	} catch (error) {
	health.workspace_accessible = false;
	health.workspace_error = error.message;
	}

	// Add CORS headers for health check
	res.setHeader('Access-Control-Allow-Origin', '*');
	res.setHeader('Access-Control-Allow-Methods', 'GET');
	res.setHeader('Cache-Control', 'no-cache');

	console.log(`🏥 Health check from ${req.ip} - Status: ${health.status}`);
	res.json(health);
	});

	// Spaces-specific metadata endpoint
	app.get('/spaces/info', (req, res) => {
	res.json({
	title: '🤖 Doc-less API Agent',
	description: 'Interactive API documentation and SDK generator demo',
	version: '1.0.0',
	features: [
	'Live API Discovery',
	'OpenAPI Generation',
	'TypeScript SDK Creation',
	'Postman Collections',
	'Mock Lab Environment',
	'Evidence Reports',
	'Real-time Demo Streaming'
	],
	demo_paths: [
	'/ - Interactive Demo Interface',
	'/api/status - Service Status',
	'/api/demo/stream - Live Demo Stream',
	'/deliverables - Generated Files',
	'/spaces/info - This Information'
	],
	github: 'https://github.com/ysrastogi/apiWitness',
	is_spaces: IS_SPACES,
	uptime: process.uptime()
	});
	});

	// Server-Sent Events endpoint for real-time demo streaming
	app.get('/api/demo/stream', streamingService.createSSEEndpoint());

	// API endpoints for demo integration
	app.get('/api/status', async (req, res) => {
	const status = {
	services: {
	main_server: `http://localhost:${PORT}`,
	demo_interface: `http://localhost:${PORT}/`,
	deliverables: `http://localhost:${PORT}/deliverables`,
	demo_stream: `http://localhost:${PORT}/api/demo/stream`
	},
	environment: {
	is_spaces: IS_SPACES,
	workspace: WORKSPACE_DIR,
	node_env: process.env.NODE_ENV \|\| 'development'
	},
	demo: {
	interface_url: `http://localhost:${PORT}`,
	deliverables_url: `http://localhost:${PORT}/deliverables`,
	health_check: `http://localhost:${PORT}/health`,
	streaming_url: `http://localhost:${PORT}/api/demo/stream`
	},
	streaming: {
	active_sessions: streamingService.getActiveSessionsCount(),
	active_streams: streamingService.getActiveStreamsCount()
	},
	timestamp: new Date().toISOString()
	};

	// Check if demo assets exist
	try {
	const demoOutputs = await fs.readdir('.', { withFileTypes: true });
	const demoFolders = demoOutputs
	.filter(dirent => dirent.isDirectory() && dirent.name.startsWith('demo-output-'))
	.map(dirent => dirent.name);

	status.available_demos = demoFolders;
	} catch (error) {
	status.demo_scan_error = error.message;
	}

	res.json(status);
	});

	// Demo session management for Spaces
	app.post('/api/demo/start', async (req, res) => {
	try {
	const { sessionId, config = {} } = req.body;
	const finalSessionId = sessionId \|\| `demo-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

	// Create storage session
	const session = await storageManager.createSession(finalSessionId);

	// Start streaming demo
	const demoConfig = streamingService.startDemoSession(finalSessionId, {
	delays: config.delays !== false, // Default to true
	realExecution: config.realExecution \|\| false,
	...config
	});

	console.log(`🎬 Demo started: ${finalSessionId}`);
	res.json({
	sessionId: finalSessionId,
	session,
	demoConfig,
	streamUrl: `/api/demo/stream?sessionId=${finalSessionId}`
	});

	} catch (error) {
	console.error('❌ Error starting demo:', error);
	res.status(500).json({ error: error.message });
	}
	});

	// Get demo session status
	app.get('/api/demo/:sessionId/status', (req, res) => {
	const { sessionId } = req.params;
	const status = streamingService.getSessionStatus(sessionId);

	if (status) {
	res.json(status);
	} else {
	res.status(404).json({ error: 'Session not found' });
	}
	});

	// Save demo result file
	app.post('/api/demo/:sessionId/save', async (req, res) => {
	try {
	const { sessionId } = req.params;
	const { fileName, content, metadata } = req.body;

	if (!fileName \|\| content === undefined) {
	return res.status(400).json({ error: 'fileName and content are required' });
	}

	const filePath = await storageManager.saveFile(sessionId, fileName, content, metadata);

	res.json({
	success: true,
	fileName,
	path: filePath,
	sessionId
	});

	} catch (error) {
	console.error('❌ Error saving file:', error);
	res.status(500).json({ error: error.message });
	}
	});

	// Get demo session files
	app.get('/api/demo/:sessionId/files', async (req, res) => {
	try {
	const { sessionId } = req.params;
	const session = await storageManager.getSession(sessionId);

	if (!session) {
	return res.status(404).json({ error: 'Session not found' });
	}

	res.json({
	sessionId,
	files: session.files \|\| []
	});

	} catch (error) {
	console.error('❌ Error getting session files:', error);
	res.status(500).json({ error: error.message });
	}
	});

	// Get specific file from session
	app.get('/api/demo/:sessionId/files/:fileName', async (req, res) => {
	try {
	const { sessionId, fileName } = req.params;
	const content = await storageManager.getFile(sessionId, fileName);

	if (content === null) {
	return res.status(404).json({ error: 'File not found' });
	}

	// Set appropriate content type
	if (fileName.endsWith('.json')) {
	res.setHeader('Content-Type', 'application/json');
	} else if (fileName.endsWith('.md')) {
	res.setHeader('Content-Type', 'text/markdown');
	} else if (fileName.endsWith('.yaml') \|\| fileName.endsWith('.yml')) {
	res.setHeader('Content-Type', 'text/yaml');
	} else if (fileName.endsWith('.ts')) {
	res.setHeader('Content-Type', 'text/typescript');
	}

	res.send(content);

	} catch (error) {
	console.error('❌ Error getting file:', error);
	res.status(500).json({ error: error.message });
	}
	});

	// Serve deliverables directory with better error handling
	app.use('/deliverables', express.static('demo-output-*', {
	setHeaders: (res, path) => {
	res.setHeader('Access-Control-Allow-Origin', '*');
	if (path.endsWith('.json')) {
	res.setHeader('Content-Type', 'application/json');
	} else if (path.endsWith('.md')) {
	res.setHeader('Content-Type', 'text/markdown');
	} else if (path.endsWith('.yaml') \|\| path.endsWith('.yml')) {
	res.setHeader('Content-Type', 'text/yaml');
	}
	}
	}));

	// Serve static demo outputs if available
	app.get('/demo-assets/:asset', async (req, res) => {
	const asset = req.params.asset;

	try {
	// Look for the asset in any demo-output directory
	const dirs = await fs.readdir('.');
	const demoDir = dirs.find(dir => dir.startsWith('demo-output-'));

	if (demoDir) {
	const assetPath = path.join(demoDir, asset);
	await fs.access(assetPath);
	res.sendFile(path.resolve(assetPath));
	} else {
	res.status(404).json({ error: 'Demo assets not found' });
	}
	} catch (error) {
	console.error(`❌ Error serving asset ${asset}:`, error);
	res.status(404).json({ error: 'Asset not found' });
	}
	});

	// Analytics endpoint (privacy-compliant)
	app.post('/api/analytics', (req, res) => {
	const { event, category, label, value } = req.body;

	// Log analytics data (can be enhanced to send to analytics service)
	console.log(`📊 Analytics: ${category}/${event}`, {
	label,
	value,
	timestamp: new Date().toISOString(),
	ip: req.ip,
	userAgent: req.get('User-Agent')
	});

	res.json({ status: 'logged' });
	});

	// Storage management endpoints
	app.get('/api/storage/stats', async (req, res) => {
	try {
	const stats = await storageManager.getStorageStats();
	res.json(stats);
	} catch (error) {
	console.error('❌ Error getting storage stats:', error);
	res.status(500).json({ error: error.message });
	}
	});

	app.post('/api/storage/cleanup', async (req, res) => {
	try {
	const deletedCount = await storageManager.cleanup();
	res.json({ success: true, deleted: deletedCount });
	} catch (error) {
	console.error('❌ Error during cleanup:', error);
	res.status(500).json({ error: error.message });
	}
	});

	// 404 handler - redirect to demo interface for SPA behavior
	app.use((req, res) => {
	console.log(`🔍 404 for ${req.path}, redirecting to demo interface`);
	res.status(404).sendFile(path.join(__dirname, 'demo-interface.html'));
	});

	// Enhanced error handler
	app.use((error, req, res, next) => {
	console.error('❌ Server Error:', {
	message: error.message,
	stack: error.stack,
	url: req.url,
	method: req.method,
	timestamp: new Date().toISOString()
	});

	res.status(error.status \|\| 500).json({
	error: IS_SPACES ? 'Internal Server Error' : error.message,
	timestamp: new Date().toISOString(),
	path: req.path
	});
	});

	// Graceful shutdown handling
	process.on('SIGTERM', () => {
	console.log('🛑 SIGTERM received, shutting down gracefully');
	process.exit(0);
	});

	process.on('SIGINT', () => {
	console.log('🛑 SIGINT received, shutting down gracefully');
	process.exit(0);
	});

	// Start server
	app.listen(PORT, '0.0.0.0', () => {
	console.log(`🌐 Doc-less API Agent ${IS_SPACES ? '(Spaces)' : '(Local)'} running on:`);
	console.log(` Local: http://localhost:${PORT}`);
	console.log(` Network: http://0.0.0.0:${PORT}`);
	console.log(` Health: http://localhost:${PORT}/health`);
	console.log(` API: http://localhost:${PORT}/api/status`);
	console.log(` Stream: http://localhost:${PORT}/api/demo/stream`);
	console.log(` Info: http://localhost:${PORT}/spaces/info`);
	console.log('');
	console.log('📁 Serving files from:', __dirname);
	console.log('💾 Workspace directory:', WORKSPACE_DIR);
	console.log('🎯 Environment:', IS_SPACES ? 'Hugging Face Spaces' : 'Local Development');
	console.log(`🎥 Streaming service: ${streamingService.getActiveSessionsCount()} active sessions`);

	// Initialize storage manager after server starts
	console.log('💾 Storage manager initialized:', WORKSPACE_DIR);
	console.log('⏰ Cleanup timer started (every 60 minutes)');
	});

	module.exports = app;