test_image_processing.js

const net = require('net');
const fs = require('fs');
const path = require('path');

async function testImageProcessing() {
    console.log('🧪 IMAGE PROCESSING TEST');
    console.log('='.repeat(50));
    
    // Connect to server socket
    const client = net.createConnection('/tmp/rkllm.sock');
    await new Promise(resolve => client.on('connect', resolve));
    console.log('✅ Connected to server');
    
    let id = 1;
    
    function send(method, params, timeout = 5000) {
        return new Promise((resolve, reject) => {
            const req = {jsonrpc: '2.0', method, params, id: id++};
            console.log(`📤 ${method}`);
            
            const timer = setTimeout(() => {
                reject(new Error(`Timeout waiting for response to ${method}`));
            }, timeout);
            
            function handleData(data) {
                try {
                    const lines = data.toString().split('\\n').filter(l => l.trim());
                    for (const line of lines) {
                        try {
                            const resp = JSON.parse(line);
                            if (resp.id === req.id) {
                                clearTimeout(timer);
                                client.removeListener('data', handleData);
                                resolve(resp);
                                return;
                            }
                        } catch(e) {
                            console.log('Parse error:', e.message, 'Line:', line);
                        }
                    }
                } catch(e) {
                    console.log('Data handling error:', e.message);
                }
            }
            
            client.on('data', handleData);
            client.write(JSON.stringify(req) + '\\n');
        });
    }
    
    try {
        // Test 1: Initialize image processor (without actual model for now)
        console.log('\\n🔧 1. Testing image processor initialization...');
        const initResp = await send('image.init_processor', {
            model_path: './models/qwen2vl2b/Qwen2-VL-2B-Instruct.rknn',
            core_num: 1
        });
        
        if (initResp.error) {
            console.log('⚠️  Expected error (no model file):', initResp.error.message);
        } else {
            console.log('✅ Image processor initialized:', initResp.result);
        }
        
        // Test 2: Load and encode demo image to base64
        console.log('\\n🖼️  2. Loading demo.jpg...');
        const imagePath = path.join(__dirname, 'tests', 'images', 'demo.jpg');
        let imageBase64 = '';
        
        try {
            const imageBuffer = fs.readFileSync(imagePath);
            imageBase64 = imageBuffer.toString('base64');
            console.log(`📊 Image loaded: ${imageBuffer.length} bytes -> ${imageBase64.length} base64 chars`);
        } catch (err) {
            console.log('❌ Could not load demo.jpg:', err.message);
            return;
        }
        
        // Test 3: Process image (create small test data instead of actual JPEG)
        console.log('\\n🔍 3. Testing image processing API...');
        // Create fake RGB data (224x224x3 = 150528 bytes)
        const fakeRgbSize = 224 * 224 * 3;
        const fakeRgbData = Buffer.alloc(fakeRgbSize, 128); // Gray image
        const fakeBase64 = fakeRgbData.toString('base64');
        
        const processResp = await send('image.process', {
            image_data: fakeBase64
        }, 15000); // Increase timeout to 15 seconds
        
        if (processResp.error) {
            console.log('⚠️  Expected error (no model initialized):', processResp.error.message);
        } else {
            console.log('✅ Image processed:', {
                embedding_size: processResp.result.embedding_size,
                n_image_tokens: processResp.result.n_image_tokens,
                embed_dim: processResp.result.embed_dim
            });
        }
        
        // Test 4: Cleanup
        console.log('\\n🧹 4. Testing cleanup...');
        const cleanupResp = await send('image.cleanup_processor');
        
        if (cleanupResp.error) {
            console.log('❌ Cleanup error:', cleanupResp.error.message);
        } else {
            console.log('✅ Cleanup successful:', cleanupResp.result);
        }
        
        console.log('\\n🎉 Image processing API test completed!');
        console.log('\\n📝 Summary:');
        console.log('   • Image processing endpoints are available');
        console.log('   • JSON-RPC API is working correctly');
        console.log('   • Ready for real vision model integration');
        
    } catch (error) {
        console.error('❌ Test failed:', error);
    } finally {
        client.end();
    }
}

// Run the test
testImageProcessing().catch(console.error);