windsor-bot 0.1.0

package/dist/printer.js

@@ -0,0 +1,245 @@
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import { readFile } from 'fs/promises';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const ESC = '\x1B';
+const GS = '\x1D';
+const INIT = `${ESC}@`;
+const BOLD_ON = `${ESC}E\x01`;
+const BOLD_OFF = `${ESC}E\x00`;
+// Double width + double height
+const FONT_2X = `${GS}!\x11`;
+// Double height only
+const FONT_H2 = `${GS}!\x10`;
+// Normal
+const FONT_NORMAL = `${GS}!\x00`;
+// Partial cut with 3mm feed
+const CUT = `${GS}V\x41\x03`;
+// Center align
+const ALIGN_CENTER = `${ESC}a\x01`;
+// Left align
+const ALIGN_LEFT = `${ESC}a\x00`;
+// Line feed
+const LF = '\n';
+// Characters per line at normal font on 80mm paper
+const CHARS_NORMAL = 48;
+const CHARS_DOUBLE = 24;
+function wrapText(text, width) {
+    const words = text.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+        }
+        else if (current.length + 1 + word.length <= width) {
+            current += ' ' + word;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.length > 0 ? lines : [''];
+}
+function chooseFontForLines(totalLines) {
+    if (totalLines <= 4) {
+        return { fontSize: FONT_2X, charsPerLine: CHARS_DOUBLE };
+    }
+    else if (totalLines <= 8) {
+        return { fontSize: FONT_H2, charsPerLine: CHARS_DOUBLE };
+    }
+    else {
+        return { fontSize: FONT_NORMAL, charsPerLine: CHARS_NORMAL };
+    }
+}
+export async function getConnectedPrinter() {
+    // Try CUPS first
+    try {
+        const { stdout } = await execAsync('lpstat -p 2>/dev/null');
+        const lines = stdout.split('\n');
+        for (const line of lines) {
+            const match = /^printer\s+(\S+)/.exec(line);
+            if (match?.[1])
+                return match[1];
+        }
+    }
+    catch {
+        // CUPS not available or no printers
+    }
+    // Try USB device files
+    try {
+        const { stdout } = await execAsync('ls /dev/usb/lp* 2>/dev/null || ls /dev/lp* 2>/dev/null || true');
+        const devices = stdout.trim().split('\n').filter(Boolean);
+        if (devices.length > 0)
+            return devices[0] ?? null;
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/** Decode a simple PNG into raw RGBA pixels using Node built-in. Returns null if can't decode. */
+async function loadImageForPrinting(path) {
+    // Node doesn't have a built-in PNG decoder; we'd need a library.
+    // For now, skip image printing and return null.
+    // This is structured so QR/image printing can be added later.
+    void path;
+    return null;
+}
+export async function formatPrintJob(job) {
+    const parts = [];
+    parts.push(INIT);
+    // Determine content lines count for font sizing
+    const rawLines = job.lines;
+    const previewFontLines = rawLines.length <= 2 ? 2 : rawLines.length;
+    const { fontSize, charsPerLine } = chooseFontForLines(previewFontLines);
+    // Header
+    if (job.header) {
+        parts.push(ALIGN_CENTER);
+        parts.push(FONT_2X);
+        parts.push(BOLD_ON);
+        const headerLines = wrapText(job.header, CHARS_DOUBLE);
+        parts.push(headerLines.join(LF));
+        parts.push(BOLD_OFF);
+        parts.push(FONT_NORMAL);
+        parts.push(ALIGN_LEFT);
+        parts.push(LF);
+    }
+    // Primary text
+    if (rawLines.length > 0) {
+        parts.push(fontSize);
+        const wrapped = [];
+        for (const line of rawLines) {
+            wrapped.push(...wrapText(line, charsPerLine));
+        }
+        parts.push(wrapped.join(LF));
+        parts.push(FONT_NORMAL);
+        parts.push(LF);
+    }
+    // Icon
+    if (job.iconPath) {
+        const img = await loadImageForPrinting(job.iconPath);
+        if (img) {
+            // Future: raster print via ESC/P
+            parts.push(`[icon: ${job.iconPath}]${LF}`);
+        }
+        // else silently skip
+    }
+    // URLs / QR codes
+    if (job.urls.length > 0) {
+        parts.push(LF);
+        for (let i = 0; i < job.urls.length; i++) {
+            const url = job.urls[i];
+            if (!url)
+                continue;
+            const label = job.urls.length === 1 ? '[link]' : `[link ${i + 1}]`;
+            // Print URL in a box since we don't have a QR library
+            const boxWidth = Math.min(CHARS_NORMAL, url.length + 4);
+            const top = '┌' + '─'.repeat(boxWidth - 2) + '┐';
+            const bottom = '└' + '─'.repeat(boxWidth - 2) + '┘';
+            const urlLines = wrapText(url, boxWidth - 4);
+            parts.push(`${label}${LF}`);
+            parts.push(`${top}${LF}`);
+            for (const l of urlLines) {
+                parts.push(`│ ${l.padEnd(boxWidth - 4)} │${LF}`);
+            }
+            parts.push(`${bottom}${LF}`);
+        }
+    }
+    // Footer
+    if (job.footer) {
+        parts.push(LF);
+        parts.push(BOLD_ON);
+        const footerLines = wrapText(job.footer, CHARS_NORMAL);
+        parts.push(footerLines.join(LF));
+        parts.push(BOLD_OFF);
+        parts.push(LF);
+    }
+    // Metadata footer
+    if (job.metadataLines && job.metadataLines.length > 0) {
+        parts.push(LF);
+        for (const line of job.metadataLines) {
+            parts.push(`${line}${LF}`);
+        }
+    }
+    // Feed and cut
+    parts.push('\n\n\n');
+    parts.push(CUT);
+    return Buffer.from(parts.join(''), 'utf8');
+}
+export async function printJob(job, printerName) {
+    const printer = printerName ?? await getConnectedPrinter();
+    if (!printer) {
+        throw new Error('No printer available');
+    }
+    const data = await formatPrintJob(job);
+    if (printer.startsWith('/dev/')) {
+        // Direct USB - write via dd or direct file write
+        const { writeFile } = await import('fs/promises');
+        await writeFile(printer, data);
+    }
+    else {
+        // CUPS printer — use `lp`
+        await new Promise((resolve, reject) => {
+            const child = execFile('lp', ['-d', printer, '-o', 'raw', '-'], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            child.stdin?.write(data);
+            child.stdin?.end();
+        });
+    }
+}
+export async function printTestPage(printerName) {
+    const testJob = {
+        header: 'Windsor Test Page',
+        lines: [
+            'Normal size text - The quick brown fox jumps over the lazy dog.',
+            '',
+            '--- Font Demo ---',
+        ],
+        urls: ['https://github.com/SeaRyanC/d2p'],
+        footer: 'Footer text here',
+        metadataLines: [
+            `Printed at: ${formatTimestamp(new Date())}`,
+            `Printer: ${printerName}`,
+        ],
+    };
+    const data = await formatPrintJob(testJob);
+    if (printerName.startsWith('/dev/')) {
+        const { writeFile } = await import('fs/promises');
+        await writeFile(printerName, data);
+    }
+    else {
+        await new Promise((resolve, reject) => {
+            const child = execFile('lp', ['-d', printerName, '-o', 'raw', '-'], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+            child.stdin?.write(data);
+            child.stdin?.end();
+        });
+    }
+}
+export function formatTimestamp(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    let hours = date.getHours();
+    const minutes = date.getMinutes();
+    const ampm = hours >= 12 ? 'PM' : 'AM';
+    hours = hours % 12 || 12;
+    const mm = String(minutes).padStart(2, '0');
+    return `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')} ${hours}:${mm} ${ampm}`;
+}
+// suppress unused import warning
+void readFile;
+void execFileAsync;

package/dist/printing/cups.js

@@ -0,0 +1,89 @@
+import { execFile } from 'child_process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { writeFile, unlink } from 'fs/promises';
+import PDFDocument from 'pdfkit';
+const MARGIN = 36; // 0.5 inch
+const FONT_HEADER = 18;
+const FONT_BODY_LARGE = 14;
+const FONT_BODY_NORMAL = 10;
+const FONT_FOOTER = 9;
+const LINE_GAP = 4;
+function chooseFontSize(totalLines) {
+    if (totalLines <= 4)
+        return FONT_BODY_LARGE;
+    return FONT_BODY_NORMAL;
+}
+export async function buildPdfBuffer(job, paperSize) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const doc = new PDFDocument({
+            size: paperSize,
+            margins: { top: MARGIN, bottom: MARGIN, left: MARGIN, right: MARGIN },
+            autoFirstPage: true,
+            bufferPages: false,
+        });
+        doc.on('data', (chunk) => chunks.push(chunk));
+        doc.on('end', () => resolve(Buffer.concat(chunks)));
+        doc.on('error', reject);
+        const bodyFontSize = chooseFontSize(job.lines.length <= 2 ? 2 : job.lines.length);
+        // Header
+        if (job.header) {
+            doc.fontSize(FONT_HEADER).font('Helvetica-Bold').text(job.header, { align: 'center', lineGap: LINE_GAP });
+            doc.moveDown(0.5);
+        }
+        // Primary text
+        if (job.lines.length > 0) {
+            doc.fontSize(bodyFontSize).font('Helvetica');
+            for (const line of job.lines) {
+                doc.text(line || ' ', { lineGap: LINE_GAP });
+            }
+            doc.moveDown(0.5);
+        }
+        // URLs
+        if (job.urls.length > 0) {
+            doc.moveDown(0.25);
+            for (let i = 0; i < job.urls.length; i++) {
+                const url = job.urls[i];
+                if (!url)
+                    continue;
+                const label = job.urls.length === 1 ? 'Link:' : `Link ${i + 1}:`;
+                doc.fontSize(FONT_FOOTER).font('Helvetica-Bold').text(label, { continued: true });
+                doc.font('Helvetica').text(` ${url}`, { link: url, underline: true, lineGap: LINE_GAP });
+            }
+            doc.moveDown(0.25);
+        }
+        // Footer
+        if (job.footer) {
+            doc.moveDown(0.25);
+            doc.fontSize(FONT_FOOTER).font('Helvetica-Bold').text(job.footer, { lineGap: LINE_GAP });
+        }
+        // Metadata footer
+        if (job.metadataLines && job.metadataLines.length > 0) {
+            doc.moveDown(0.25);
+            doc.fontSize(FONT_FOOTER).font('Helvetica');
+            for (const line of job.metadataLines) {
+                doc.text(line, { lineGap: 2 });
+            }
+        }
+        doc.end();
+    });
+}
+export async function printJobCups(job, config) {
+    const pdfBuf = await buildPdfBuffer(job, config.paperSize);
+    const tmpPath = join(tmpdir(), `windsor-${Date.now()}.pdf`);
+    await writeFile(tmpPath, pdfBuf);
+    try {
+        await new Promise((resolve, reject) => {
+            execFile('lp', ['-d', config.printerName, '-o', `media=${config.paperSize}`, tmpPath], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    finally {
+        await unlink(tmpPath).catch(() => { });
+    }
+}

package/dist/printing/escp.js

@@ -0,0 +1,147 @@
+import { Printer, InMemory, Style, Align, Cut, Image } from 'escpos-buffer';
+import { SerialPort } from 'serialport';
+import { Jimp, ResizeStrategy } from 'jimp';
+const COLS_NORMAL = 48;
+const COLS_DOUBLE = 24;
+function wrapText(text, width) {
+    const words = text.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+        }
+        else if (current.length + 1 + word.length <= width) {
+            current += ' ' + word;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.length > 0 ? lines : [''];
+}
+function chooseFontForLines(totalLines) {
+    if (totalLines <= 4) {
+        return { fontSize: 'double', cols: COLS_DOUBLE };
+    }
+    else if (totalLines <= 8) {
+        return { fontSize: 'tall', cols: COLS_DOUBLE };
+    }
+    else {
+        return { fontSize: 'normal', cols: COLS_NORMAL };
+    }
+}
+export async function buildEscpBuffer(job) {
+    const conn = new InMemory();
+    const printer = await Printer.CONNECT('TM-T20', conn);
+    const { fontSize, cols } = chooseFontForLines(job.lines.length <= 2 ? 2 : job.lines.length);
+    // Header
+    if (job.header) {
+        const headerLines = wrapText(job.header, COLS_DOUBLE);
+        for (const line of headerLines) {
+            await printer.writeln(line, Style.Bold | Style.DoubleWidth | Style.DoubleHeight, Align.Center);
+        }
+        await printer.feed(1);
+    }
+    // Icon / sprite image
+    if (job.iconPath) {
+        try {
+            const img = await Jimp.read(job.iconPath);
+            const PRINT_WIDTH = 576; // ~80mm at 180dpi
+            const scale = img.width <= PRINT_WIDTH
+                ? Math.floor(PRINT_WIDTH / img.width)
+                : PRINT_WIDTH / img.width;
+            img.resize({ w: Math.round(img.width * scale), h: Math.round(img.height * scale), mode: ResizeStrategy.NEAREST_NEIGHBOR });
+            const escImage = new Image(img.bitmap);
+            await printer.draw(escImage);
+            await printer.feed(1);
+        }
+        catch {
+            // silently skip if image can't be loaded/printed
+        }
+    }
+    // Primary text
+    if (job.lines.length > 0) {
+        const widthStyle = fontSize === 'double'
+            ? Style.DoubleWidth | Style.DoubleHeight
+            : fontSize === 'tall'
+                ? Style.DoubleHeight
+                : 0;
+        for (const line of job.lines) {
+            const wrapped = wrapText(line, cols);
+            for (const l of wrapped) {
+                await printer.writeln(l, widthStyle);
+            }
+        }
+        await printer.feed(1);
+    }
+    // URLs (printed as labelled text; QR code can be added later)
+    if (job.urls.length > 0) {
+        await printer.feed(1);
+        for (let i = 0; i < job.urls.length; i++) {
+            const url = job.urls[i];
+            if (!url)
+                continue;
+            const label = job.urls.length === 1 ? '[link]' : `[link ${i + 1}]`;
+            await printer.writeln(label, Style.Bold);
+            const urlLines = wrapText(url, COLS_NORMAL);
+            for (const l of urlLines) {
+                await printer.writeln(l);
+            }
+        }
+    }
+    // Footer
+    if (job.footer) {
+        await printer.feed(1);
+        const footerLines = wrapText(job.footer, COLS_NORMAL);
+        for (const line of footerLines) {
+            await printer.writeln(line, Style.Bold);
+        }
+    }
+    // Metadata footer
+    if (job.metadataLines && job.metadataLines.length > 0) {
+        await printer.feed(1);
+        for (const line of job.metadataLines) {
+            await printer.writeln(line);
+        }
+    }
+    await printer.feed(3);
+    await printer.cutter(Cut.Partial);
+    await printer.close();
+    return conn.buffer();
+}
+export async function printJobEscp(job, portPath) {
+    const data = await buildEscpBuffer(job);
+    // USB printer devices (e.g. /dev/usb/lp0) don't support serial ioctl;
+    // write directly to the device file instead.
+    if (/\/lp\d+$/.test(portPath)) {
+        const { writeFile } = await import('fs/promises');
+        await writeFile(portPath, data);
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const port = new SerialPort({ path: portPath, baudRate: 115200 });
+        port.on('error', reject);
+        port.on('open', () => {
+            port.write(data, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                port.drain((drainErr) => {
+                    port.close((closeErr) => {
+                        if (drainErr)
+                            reject(drainErr);
+                        else if (closeErr)
+                            reject(closeErr);
+                        else
+                            resolve();
+                    });
+                });
+            });
+        });
+    });
+}

package/dist/printing/imagefeed.js

@@ -0,0 +1,212 @@
+import { Jimp, loadFont, measureText, JimpMime, ResizeStrategy } from 'jimp';
+import QRCode from 'qrcode';
+const FONT_DIR = new URL('../../node_modules/@jimp/plugin-print/dist/fonts/open-sans/', import.meta.url).pathname;
+const FONT_16 = `${FONT_DIR}open-sans-16-black/open-sans-16-black.fnt`;
+const FONT_32 = `${FONT_DIR}open-sans-32-black/open-sans-32-black.fnt`;
+const MAX_FEED_ENTRIES = 50;
+const feed = [];
+export function getImageFeed() {
+    return feed;
+}
+export function clearImageFeed() {
+    feed.length = 0;
+}
+const PAGE_WIDTH = 560; // ~80mm at 180dpi
+const MARGIN = 20;
+const LINE_HEIGHT_NORMAL = 20;
+const LINE_HEIGHT_LARGE = 36;
+const TEXT_WIDTH = PAGE_WIDTH - MARGIN * 2;
+function chooseLineHeight(totalLines) {
+    if (totalLines <= 4)
+        return { lineHeight: LINE_HEIGHT_LARGE, fontPath: FONT_32 };
+    return { lineHeight: LINE_HEIGHT_NORMAL, fontPath: FONT_16 };
+}
+function wrapText(text, font, maxWidth) {
+    if (!text)
+        return [''];
+    const words = text.split(' ');
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        const candidate = current ? `${current} ${word}` : word;
+        if (measureText(font, candidate) <= maxWidth) {
+            current = candidate;
+        }
+        else {
+            if (current)
+                lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.length > 0 ? lines : [''];
+}
+const QR_SIZE = 120; // pixels per QR code
+async function renderQrCode(url) {
+    const pngBuf = await QRCode.toBuffer(url, { type: 'png', width: QR_SIZE, margin: 1 });
+    return Jimp.fromBuffer(pngBuf);
+}
+export async function renderJobToPng(job) {
+    const totalLines = job.lines.length <= 2 ? 2 : job.lines.length;
+    const { lineHeight, fontPath } = chooseLineHeight(totalLines);
+    const fontNormal = await loadFont(FONT_16);
+    const fontLarge = await loadFont(FONT_32);
+    const bodyFont = lineHeight === LINE_HEIGHT_LARGE ? fontLarge : fontNormal;
+    // Pre-load and scale the icon so we know its exact dimensions before sizing the canvas
+    let scaledSprite = null;
+    if (job.iconPath) {
+        try {
+            const sprite = await Jimp.read(job.iconPath);
+            // For small pixel-art sprites: scale up by integer factor for crisp pixels.
+            // For large icons: scale down to fit within TEXT_WIDTH.
+            const scale = sprite.width <= TEXT_WIDTH
+                ? Math.floor(TEXT_WIDTH / sprite.width)
+                : TEXT_WIDTH / sprite.width;
+            sprite.resize({ w: Math.round(sprite.width * scale), h: Math.round(sprite.height * scale), mode: ResizeStrategy.NEAREST_NEIGHBOR });
+            scaledSprite = sprite;
+        }
+        catch {
+            // silently skip
+        }
+    }
+    // Measure total height now that icon dimensions are known
+    let estimatedHeight = MARGIN * 2;
+    if (job.header)
+        estimatedHeight += LINE_HEIGHT_LARGE * 2 + 12;
+    if (scaledSprite)
+        estimatedHeight += scaledSprite.height + 8;
+    for (const line of job.lines) {
+        const wrapped = wrapText(line || ' ', bodyFont, TEXT_WIDTH);
+        estimatedHeight += wrapped.length * lineHeight;
+    }
+    if (job.urls.length > 0)
+        estimatedHeight += job.urls.length * (QR_SIZE + LINE_HEIGHT_NORMAL + 8) + 8;
+    if (job.footer)
+        estimatedHeight += LINE_HEIGHT_NORMAL * 2 + 8;
+    if (job.metadataLines)
+        estimatedHeight += job.metadataLines.length * LINE_HEIGHT_NORMAL + 8;
+    estimatedHeight += 20; // bottom padding
+    const img = new Jimp({ width: PAGE_WIDTH, height: Math.max(estimatedHeight, 100), color: 0xffffffff });
+    let y = MARGIN;
+    const printLine = (text, font, lh) => {
+        img.print({ font, x: MARGIN, y, text, maxWidth: TEXT_WIDTH });
+        y += lh;
+    };
+    // Header
+    if (job.header) {
+        const headerLines = wrapText(job.header, fontLarge, TEXT_WIDTH);
+        for (const line of headerLines) {
+            img.print({ font: fontLarge, x: MARGIN, y, text: line, maxWidth: TEXT_WIDTH });
+            y += LINE_HEIGHT_LARGE;
+        }
+        y += 12;
+    }
+    // Icon / sprite image
+    if (scaledSprite) {
+        img.composite(scaledSprite, MARGIN, y);
+        y += scaledSprite.height + 8;
+    }
+    // Primary text
+    for (const line of job.lines) {
+        const wrapped = wrapText(line || ' ', bodyFont, TEXT_WIDTH);
+        for (const l of wrapped) {
+            printLine(l, bodyFont, lineHeight);
+        }
+    }
+    y += 8;
+    // URLs — render each as a QR code with a label beneath it
+    if (job.urls.length > 0) {
+        y += 8;
+        for (let i = 0; i < job.urls.length; i++) {
+            const url = job.urls[i];
+            if (!url)
+                continue;
+            const label = job.urls.length === 1 ? '🔗 Scan to open link' : `🔗 Link ${i + 1}`;
+            printLine(label, fontNormal, LINE_HEIGHT_NORMAL);
+            const qrImg = await renderQrCode(url);
+            img.composite(qrImg, MARGIN, y);
+            y += QR_SIZE + 4;
+            // Print the URL text in small font next to/below the QR
+            const urlLines = wrapText(url, fontNormal, TEXT_WIDTH);
+            for (const l of urlLines) {
+                printLine(l, fontNormal, LINE_HEIGHT_NORMAL);
+            }
+            y += 4;
+        }
+    }
+    // Footer
+    if (job.footer) {
+        y += 8;
+        const footerLines = wrapText(job.footer, fontNormal, TEXT_WIDTH);
+        for (const line of footerLines) {
+            printLine(line, fontNormal, LINE_HEIGHT_NORMAL);
+        }
+    }
+    // Metadata
+    if (job.metadataLines && job.metadataLines.length > 0) {
+        y += 8;
+        for (const line of job.metadataLines) {
+            printLine(line, fontNormal, LINE_HEIGHT_NORMAL);
+        }
+    }
+    // Draw a dashed separator line at the bottom to simulate a receipt cut
+    const cutY = y + 10;
+    if (cutY < img.height) {
+        for (let x = MARGIN; x < PAGE_WIDTH - MARGIN; x += 8) {
+            img.setPixelColor(0x888888ff, x, cutY);
+            img.setPixelColor(0x888888ff, x + 1, cutY);
+        }
+    }
+    return img.getBuffer(JimpMime.png);
+}
+export async function printJobImageFeed(job) {
+    const png = await renderJobToPng(job);
+    const label = job.header ?? job.lines[0] ?? 'print';
+    feed.unshift({ timestamp: new Date(), label, png });
+    if (feed.length > MAX_FEED_ENTRIES)
+        feed.length = MAX_FEED_ENTRIES;
+}
+export async function printTestJobImageFeed(job) {
+    return printJobImageFeed(job);
+}
+export function renderFeedHtml() {
+    const items = feed.map((entry, i) => {
+        const b64 = entry.png.toString('base64');
+        const ts = entry.timestamp.toLocaleString();
+        return `
+        <div style="margin-bottom:32px; border-bottom: 1px solid #333; padding-bottom:24px;">
+            <p style="color:#888; margin:0 0 8px;">#${i + 1} — ${ts} — <em>${escHtml(entry.label)}</em></p>
+            <img src="data:image/png;base64,${b64}" style="max-width:100%; border:1px solid #444;" alt="print job ${i + 1}"/>
+        </div>`;
+    }).join('\n');
+    const emptyMsg = feed.length === 0
+        ? '<p style="color:#888">No print jobs yet. Switch to "Image Feed" mode and trigger a print.</p>'
+        : '';
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Windsor Image Feed</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { margin: 0; padding: 24px; font-family: ui-sans-serif, system-ui, -apple-system, sans-serif; background: #0f1115; color: #f5f7fa; max-width: 700px; }
+    h1 { margin-top: 0; }
+    button { background: #2e7dff; color: #fff; border: none; border-radius: 6px; padding: 8px 14px; cursor: pointer; margin-bottom: 24px; }
+  </style>
+</head>
+<body>
+  <h1>🖨️ Image Feed</h1>
+  <form method="POST" action="/feed/clear" style="display:inline">
+    <button type="submit">Clear Feed</button>
+  </form>
+  <p style="color:#888; margin-top:0;">Newest first. Refresh the page to see new jobs. ${feed.length} job(s).</p>
+  ${emptyMsg}
+  ${items}
+</body>
+</html>`;
+}
+function escHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}