cli.ts

#!/usr/bin/env bun
import { readFileSync, writeFileSync, statSync, existsSync } from 'fs';
import { setDefaultResultOrder } from 'node:dns';
import { lookup } from 'node:dns/promises';
import { isIP } from 'node:net';
import { loadImage, createCanvas, Image } from 'canvas';
import { getConfig, Config } from './src/config';
import { adjustContrast, ditherImage, processImageData } from './src/image-processor';
import { generateQrCode, drawQrCodeOnCanvas } from './src/qr-generator';
import { applyScaling } from './src/scaling';
import { generateQrContent } from './src/qr-content-generator';

function errorMessage(error: unknown) {
    return error instanceof Error ? error.message : String(error);
}

function enableIpv4FirstDns() {
    try {
        setDefaultResultOrder('ipv4first');
    } catch (error) {
        console.warn('Unable to set IPv4-first DNS result ordering:', errorMessage(error));
    }
}

async function resolveHttpUrlIpv4First(url: string, headers?: HeadersInit) {
    const parsedUrl = new URL(url);
    if (parsedUrl.protocol !== 'http:' || isIP(parsedUrl.hostname)) {
        return null;
    }

    try {
        const address = await lookup(parsedUrl.hostname, { family: 4 });
        const hostHeader = parsedUrl.host;
        parsedUrl.hostname = address.address;

        const resolvedHeaders = new Headers(headers);
        if (!resolvedHeaders.has('Host')) {
            resolvedHeaders.set('Host', hostHeader);
        }

        return { url: parsedUrl.toString(), headers: resolvedHeaders };
    } catch (error) {
        console.warn(`Could not resolve ${parsedUrl.hostname} to an IPv4 address, using original URL:`, errorMessage(error));
        return null;
    }
}

async function fetchImageUrl(url: string, options: RequestInit, resolveUrlIpv4First: boolean) {
    if (!resolveUrlIpv4First) {
        return fetch(url, options);
    }

    const resolved = await resolveHttpUrlIpv4First(url, options.headers);
    if (!resolved) {
        return fetch(url, options);
    }

    try {
        return await fetch(resolved.url, { ...options, headers: resolved.headers });
    } catch (error) {
        console.warn(`IPv4 fetch failed for ${url}, retrying original URL:`, errorMessage(error));
        return fetch(url, options);
    }
}

async function waitForDevice(ip: string, timeout: number) {
    console.log(`Waiting for device at ${ip} to come online...`);
    const end = Date.now() + timeout * 1000;
    while (Date.now() < end) {
        try {
            const response = await fetch(`http://${ip}/`, { method: 'GET', signal: AbortSignal.timeout(1000) });
            if (response.status === 500) {
                console.log('Device is online.');
                return true;
            }
        } catch (error) {
            // Ignore errors until timeout
        }
        await new Promise(resolve => setTimeout(resolve, 1000));
    }
    console.error(`Device at ${ip} did not come online within ${timeout} seconds.`);
    return false;
}

async function main() {
    const args = process.argv.slice(2);
    const imagePathOrUrlIndex = args.findIndex(arg => !arg.startsWith('--'));
    const imagePathOrUrl = args[imagePathOrUrlIndex];
    const configStrOrPathIndex = args.findIndex(arg => arg.endsWith('.json') || arg.startsWith('{'));
    const configStrOrPath = args[configStrOrPathIndex];

    const waitForOnlineIndex = args.indexOf('--wait-for-online');
    let waitForOnlineTimeout = 0;
    if (waitForOnlineIndex !== -1 && args[waitForOnlineIndex + 1]) {
        waitForOnlineTimeout = parseInt(args[waitForOnlineIndex + 1], 10);
    }

    const ifModifiedSinceIndex = args.indexOf('--if-modified-since');
    let ifModifiedSince = 0;
    if (ifModifiedSinceIndex !== -1 && args[ifModifiedSinceIndex + 1]) {
        ifModifiedSince = parseInt(args[ifModifiedSinceIndex + 1], 10);
    }

    if (!imagePathOrUrl || !configStrOrPath) {
        console.error('Usage: ./dist/cli.js <path_to_image_or_url> <json_config_string_or_path_to_json> [--wait-for-online <seconds>] [--if-modified-since <timestamp>] [--resolve-url-ipv4-first]');
        process.exit(1);
    }

    let config: Partial<Config>;
    try {
        config = JSON.parse(configStrOrPath);
    } catch (e) {
        try {
            config = JSON.parse(readFileSync(configStrOrPath, 'utf-8'));
        } catch (fileError) {
            console.error('Error: Invalid configuration. Please provide a valid JSON string or a path to a valid JSON file.');
            process.exit(1);
        }
    }

    const settings = getConfig(config);
    const resolveUrlIpv4First = settings.resolveUrlIpv4First || args.includes('--resolve-url-ipv4-first');
    if (resolveUrlIpv4First) {
        enableIpv4FirstDns();
    }

    // Check for duplicate local image file
    let shouldUpdateLastFile = false;
    if (!imagePathOrUrl.startsWith('http')) {
        const fileStats = statSync(imagePathOrUrl);
        const currentSize = fileStats.size;
        const lastFilePath = '/tmp/neoframe.last';
        if (existsSync(lastFilePath)) {
            const lastSizeStr = readFileSync(lastFilePath, 'utf-8');
            const lastSize = parseInt(lastSizeStr, 10);
            if (lastSize === currentSize) {
                console.log(`Error: ${imagePathOrUrl} is the same size as the last image sent to the frame (remove /tmp/neoframe.last to resend or provide an image file with a different size)`);
                process.exit(100);
            }
        }
        shouldUpdateLastFile = true;
    }

    try {
        console.log('Loading image...');
        let image;
        if (imagePathOrUrl.startsWith('http')) {
            const fetchOptions: any = {};
            if (ifModifiedSince > 0) {
                const date = new Date(ifModifiedSince * 1000);
                fetchOptions.headers = {
                    'If-Modified-Since': date.toUTCString()
                };
            }
            const response = await fetchImageUrl(imagePathOrUrl, fetchOptions, resolveUrlIpv4First);
            if (response.status === 304) {
                const isoDate = new Date(ifModifiedSince * 1000).toISOString().replace('T', ' ').slice(0, 19);
                console.log(`Web server reports image as unchanged since ${ifModifiedSince} (${isoDate})`);
                process.exit(100);
            }
            if (!response.ok) {
                throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
            }
            const buffer = await response.arrayBuffer();
            image = await loadImage(Buffer.from(buffer));
        } else {
            image = await loadImage(imagePathOrUrl);
        }

        const frameWidth = 1200;
        const frameHeight = 1600;
        const canvas = createCanvas(frameWidth, frameHeight);
        const ctx = canvas.getContext('2d');

        console.log('Processing image...');

        const rotatedCanvas = createCanvas(image.width, image.height);
        const rotatedCtx = rotatedCanvas.getContext('2d');

        const rotation = parseInt(settings.rotation, 10);
        if (rotation === 90 || rotation === 270) {
            rotatedCanvas.width = image.height;
            rotatedCanvas.height = image.width;
        }

        rotatedCtx.translate(rotatedCanvas.width / 2, rotatedCanvas.height / 2);
        rotatedCtx.rotate(rotation * Math.PI / 180);
        rotatedCtx.drawImage(image, -image.width / 2, -image.height / 2);

        const sourceImage = rotatedCanvas;

        const scalingMode = settings.scaling;

        const offscreenCanvas = createCanvas(frameWidth, frameHeight);
        const offscreenCtx = offscreenCanvas.getContext('2d');

        offscreenCtx.fillStyle = 'white';
        offscreenCtx.fillRect(0, 0, frameWidth, frameHeight);

        const { imageBoundingBox } = applyScaling(sourceImage, offscreenCtx, settings, frameWidth, frameHeight);

        const imageData = offscreenCtx.getImageData(0, 0, frameWidth, frameHeight);
        adjustContrast(imageData, parseFloat(settings.contrast));
        ditherImage(imageData, settings);
        offscreenCtx.putImageData(imageData, 0, 0);

        ctx.drawImage(offscreenCanvas, 0, 0);

        if (settings.qrCodeEnabled) {
            console.log('Generating QR code...');
            const qrContent = await generateQrContent({
                qrContentType: settings.qrContentType,
                qrCustomText: settings.qrCustomText,
                qrExifLabels: settings.qrExifLabels,
                qrExifGps: settings.qrExifGps,
                qrExifMaps: settings.qrExifMaps,
                imagePathOrBuffer: imagePathOrUrl,
                isBrowser: false
            });
            if (qrContent && qrContent.trim()) {
                console.log('Generating QR code for content:', JSON.stringify(qrContent));
                const qrCanvas = await generateQrCode(qrContent, settings);
                console.log('QR canvas created, size:', qrCanvas.width, 'x', qrCanvas.height);
                drawQrCodeOnCanvas(ctx, qrCanvas, settings, rotation, imageBoundingBox);
                console.log('QR code drawn on image');
            } else {
                console.log('No QR content to generate');
            }
        }

        console.log('Image processing complete.');

        const finalImageData = processImageData(ctx.getImageData(0, 0, frameWidth, frameHeight), settings);

        if (waitForOnlineTimeout > 0) {
            const online = await waitForDevice(settings.esp32Ip, waitForOnlineTimeout);
            if (!online) {
                process.exit(1);
            }
        }

        try {
            console.log('Uploading to frame...');
            const esp32IP = settings.esp32Ip;
            const blob = new Blob([finalImageData], { type: 'application/octet-stream' });
            const formData = new FormData();
            formData.append('data', blob, 'image_data.bin');

            const response = await fetch(`http://${esp32IP}/upload`, {
                method: 'POST',
                body: formData as any,
            });

            if (!response.ok) {
                throw new Error(`Error uploading to frame: ${response.statusText}`);
            }

            const responseText = await response.text();
            console.log('Upload response:', responseText);
            console.log('Successfully uploaded image to the frame.');

            // Save dithered image
            const outPath = 'dithered_image.png';
            try {
                writeFileSync(outPath, canvas.toBuffer('image/png'));
                console.log(`Dithered image saved to ${outPath}`);
            } catch (saveError) {
                console.error('Error saving dithered image:', saveError.message);
            }

            // Update last file if needed
            if (shouldUpdateLastFile) {
                const fileStats = statSync(imagePathOrUrl);
                const currentSize = fileStats.size;
                const lastFilePath = '/tmp/neoframe.last';
                writeFileSync(lastFilePath, currentSize.toString());
            }
        } catch (uploadError) {
            console.error('An error occurred during upload:', uploadError.message);
            process.exit(1);
        }
    } catch (error) {
        console.error('An error occurred during image processing:', error.message);
        if (error.cause) {
            console.error('Cause:', error.cause);
        }
        process.exit(1);
    }
}

main();