@bramato/openrouter-mock-generator/dist/services/image-mock-generator.js

AI-powered mock data generator using OpenRouter API with JSON mode support

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImageMockGenerator = void 0;
const image_generator_1 = require("./image-generator");
const aws_s3_storage_1 = require("./aws-s3-storage");
const digitalocean_spaces_1 = require("./digitalocean-spaces");
const fs_1 = require("fs");
const path_1 = require("path");
class ImageMockGenerator {
    constructor(huggingfaceApiKey) {
        this.loadConfiguration();
        // Use Hugging Face API key from parameter or config
        const hfApiKey = huggingfaceApiKey || this.config.HUGGINGFACE_API_KEY;
        this.imageGenerator = new image_generator_1.ImageGenerator(hfApiKey);
        // Initialize storage based on provider
        if (this.config.STORAGE_PROVIDER === 'aws' && this.hasS3Config()) {
            this.s3Storage = new aws_s3_storage_1.AWSS3Storage({
                accessKeyId: this.config.AWS_ACCESS_KEY_ID,
                secretAccessKey: this.config.AWS_SECRET_ACCESS_KEY,
                region: this.config.AWS_REGION,
                bucketName: this.config.AWS_S3_BUCKET_NAME,
                endpoint: this.config.AWS_S3_ENDPOINT,
            });
        }
        else if (this.config.STORAGE_PROVIDER === 'digitalocean' && this.hasDOConfig()) {
            this.doStorage = new digitalocean_spaces_1.DigitalOceanSpaces({
                accessKeyId: this.config.DO_SPACES_ACCESS_KEY,
                secretAccessKey: this.config.DO_SPACES_SECRET_KEY,
                region: this.config.DO_SPACES_REGION,
                spaceName: this.config.DO_SPACES_NAME,
                apiToken: this.config.DO_API_TOKEN,
            });
        }
    }
    loadConfiguration() {
        try {
            const envPath = (0, path_1.join)(process.cwd(), '.env');
            const envContent = (0, fs_1.readFileSync)(envPath, 'utf8');
            this.config = {};
            // Parse .env content properly, handling escape sequences
            envContent.split('\n').forEach(line => {
                line = line.trim();
                // Skip empty lines and comments
                if (!line || line.startsWith('#')) {
                    return;
                }
                const equalIndex = line.indexOf('=');
                if (equalIndex === -1) {
                    return;
                }
                const key = line.substring(0, equalIndex).trim();
                let value = line.substring(equalIndex + 1).trim();
                // Handle quoted values
                if ((value.startsWith('"') && value.endsWith('"')) ||
                    (value.startsWith("'") && value.endsWith("'"))) {
                    value = value.slice(1, -1);
                }
                // Replace escape sequences
                value = value.replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t');
                if (key) {
                    this.config[key] = value;
                }
            });
            console.log('📋 Loaded configuration:', {
                STORAGE_PROVIDER: this.config.STORAGE_PROVIDER,
                DO_SPACES_REGION: this.config.DO_SPACES_REGION,
                DO_SPACES_NAME: this.config.DO_SPACES_NAME,
                HAS_DO_ACCESS_KEY: !!this.config.DO_SPACES_ACCESS_KEY,
            });
        }
        catch (error) {
            console.warn('Could not load .env file. Some features may not work.');
            this.config = {};
        }
    }
    hasS3Config() {
        return !!(this.config.AWS_ACCESS_KEY_ID &&
            this.config.AWS_SECRET_ACCESS_KEY &&
            this.config.AWS_REGION &&
            this.config.AWS_S3_BUCKET_NAME);
    }
    hasDOConfig() {
        return !!(this.config.DO_SPACES_ACCESS_KEY &&
            this.config.DO_SPACES_SECRET_KEY &&
            this.config.DO_SPACES_REGION &&
            this.config.DO_SPACES_NAME);
    }
    async generateImageMock(options) {
        const { prompt, uploadToCloud = false, filename = `generated-${Date.now()}`, ...imageOptions } = options;
        try {
            // Generate image using OpenRouter
            console.log(`🎨 Generating image: "${prompt}"`);
            const imageResponse = await this.imageGenerator.generateImage({
                prompt,
                ...imageOptions,
            });
            if (!imageResponse.data || imageResponse.data.length === 0) {
                throw new Error('No image data received from OpenRouter');
            }
            const imageData = imageResponse.data[0];
            let finalImageUrl = imageData.url;
            let cloudUpload;
            let cdnUrl;
            // Upload to cloud storage if requested and configured
            if (uploadToCloud) {
                // Get image data as base64
                const base64Images = await this.imageGenerator.generateImageFromBase64({
                    prompt,
                    n: 1,
                    ...imageOptions,
                });
                if (base64Images.length > 0) {
                    if (this.s3Storage) {
                        console.log('☁️  Uploading to AWS S3...');
                        cloudUpload = await this.s3Storage.uploadImage(base64Images[0], `${filename}.png`, 'image/png');
                        finalImageUrl = cloudUpload.url;
                        console.log(`✅ Image uploaded to S3: ${finalImageUrl}`);
                    }
                    else if (this.doStorage) {
                        console.log('☁️  Uploading to DigitalOcean Spaces...');
                        cloudUpload = await this.doStorage.uploadImage(base64Images[0], `${filename}.png`, 'image/png');
                        finalImageUrl = cloudUpload.url;
                        cdnUrl = cloudUpload.cdnUrl;
                        console.log(`✅ Image uploaded to Spaces: ${finalImageUrl}`);
                        if (cdnUrl) {
                            console.log(`📡 CDN URL: ${cdnUrl}`);
                        }
                    }
                    else {
                        console.warn('⚠️  Cloud upload requested but no storage provider is configured. Using original URL.');
                    }
                }
            }
            return {
                prompt,
                imageUrl: finalImageUrl,
                cloudUpload,
                cdnUrl,
                localPath: undefined, // Could implement local saving if needed
            };
        }
        catch (error) {
            console.error(`❌ Failed to generate image for prompt: "${prompt}"`, error);
            throw error;
        }
    }
    async generateMultipleImageMocks(prompts, options = {}) {
        const results = [];
        console.log(`🎨 Generating ${prompts.length} images...`);
        for (let i = 0; i < prompts.length; i++) {
            const prompt = prompts[i];
            try {
                console.log(`\n[${i + 1}/${prompts.length}] Processing: "${prompt}"`);
                const result = await this.generateImageMock({
                    prompt,
                    filename: `batch-${i + 1}-${Date.now()}`,
                    ...options,
                });
                results.push(result);
                // Add delay to avoid rate limiting
                if (i < prompts.length - 1) {
                    console.log('⏳ Waiting to avoid rate limits...');
                    await new Promise(resolve => setTimeout(resolve, 2000));
                }
            }
            catch (error) {
                console.error(`❌ Failed to process prompt ${i + 1}: "${prompt}"`);
                results.push({
                    prompt,
                    imageUrl: '',
                    cloudUpload: undefined,
                    cdnUrl: undefined,
                    localPath: undefined,
                });
            }
        }
        console.log(`\n✅ Completed batch generation: ${results.filter(r => r.imageUrl).length}/${prompts.length} successful`);
        return results;
    }
    async getAvailableModels() {
        return this.imageGenerator.getAvailableModels();
    }
    async testCloudConnection() {
        if (this.s3Storage) {
            return this.s3Storage.testConnection();
        }
        else if (this.doStorage) {
            return this.doStorage.testConnection();
        }
        return false;
    }
    formatResultsAsJSON(results) {
        return JSON.stringify(results.map(result => ({
            prompt: result.prompt,
            imageUrl: result.imageUrl,
            cdnUrl: result.cdnUrl,
            cloudKey: result.cloudUpload?.key,
            uploadStatus: result.cloudUpload ? 'uploaded' : 'not_uploaded',
            storageProvider: this.config.STORAGE_PROVIDER || 'none',
        })), null, 2);
    }
    formatResultsAsMarkdown(results) {
        let markdown = '# Generated Images\n\n';
        results.forEach((result, index) => {
            markdown += `## Image ${index + 1}\n\n`;
            markdown += `**Prompt:** ${result.prompt}\n\n`;
            if (result.imageUrl) {
                markdown += `![Generated Image](${result.imageUrl})\n\n`;
                markdown += `**URL:** [${result.imageUrl}](${result.imageUrl})\n\n`;
                if (result.cdnUrl) {
                    markdown += `**CDN URL:** [${result.cdnUrl}](${result.cdnUrl})\n\n`;
                }
                if (result.cloudUpload) {
                    markdown += `**Storage Key:** ${result.cloudUpload.key}\n\n`;
                    markdown += `**Provider:** ${this.config.STORAGE_PROVIDER || 'unknown'}\n\n`;
                }
            }
            else {
                markdown += `❌ *Image generation failed*\n\n`;
            }
            markdown += '---\n\n';
        });
        return markdown;
    }
}
exports.ImageMockGenerator = ImageMockGenerator;
//# sourceMappingURL=image-mock-generator.js.map