windsor-bot 0.1.0

package/src/printing/imagefeed.ts

@@ -0,0 +1,246 @@
+import { Jimp, loadFont, measureText, JimpMime, ResizeStrategy } from 'jimp';
+import QRCode from 'qrcode';
+import type { PrintJob } from '../types.ts';
+
+
+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`;
+
+
+interface FeedEntry {
+    timestamp: Date;
+    label: string;
+    png: Buffer;
+}
+
+const MAX_FEED_ENTRIES = 50;
+const feed: FeedEntry[] = [];
+
+export function getImageFeed(): FeedEntry[] {
+    return feed;
+}
+
+export function clearImageFeed(): void {
+    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: number): { lineHeight: number; fontPath: string } {
+    if (totalLines <= 4) return { lineHeight: LINE_HEIGHT_LARGE, fontPath: FONT_32 };
+    return { lineHeight: LINE_HEIGHT_NORMAL, fontPath: FONT_16 };
+}
+
+function wrapText(text: string, font: Awaited<ReturnType<typeof loadFont>>, maxWidth: number): string[] {
+    if (!text) return [''];
+    const words = text.split(' ');
+    const lines: string[] = [];
+    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: string) {
+    const pngBuf = await QRCode.toBuffer(url, { type: 'png', width: QR_SIZE, margin: 1 });
+    return Jimp.fromBuffer(pngBuf);
+}
+
+
+export async function renderJobToPng(job: PrintJob): Promise<Buffer> {
+    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: Awaited<ReturnType<typeof Jimp.read>> | null = 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: string, font: Awaited<ReturnType<typeof loadFont>>, lh: number): void => {
+        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: PrintJob): Promise<void> {
+    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: PrintJob): Promise<void> {
+    return printJobImageFeed(job);
+}
+
+
+export function renderFeedHtml(): string {
+    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: string): string {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}

package/src/printing/index.ts

@@ -0,0 +1,63 @@
+import type { PrintJob } from '../types.ts';
+import { getCurrentConfig } from '../config.ts';
+import { printJobEscp } from './escp.ts';
+import { printJobCups } from './cups.ts';
+import { printJobImageFeed, printTestJobImageFeed } from './imagefeed.ts';
+
+export async function printJob(job: PrintJob): Promise<void> {
+    const cfg = getCurrentConfig();
+    const printConfig = cfg.printConfig;
+
+    if (!printConfig) {
+        throw new Error('No print mode configured. Set a print mode in the Control Panel.');
+    }
+
+    switch (printConfig.mode) {
+        case 'escp':
+            await printJobEscp(job, printConfig.serialPort);
+            break;
+        case 'cups':
+            await printJobCups(job, printConfig);
+            break;
+        case 'imagefeed':
+            await printJobImageFeed(job);
+            break;
+        default: {
+            const never: never = printConfig;
+            throw new Error(`Unknown print mode: ${(never as { mode: string }).mode}`);
+        }
+    }
+}
+
+export async function printTestPage(): Promise<void> {
+    const cfg = getCurrentConfig();
+    const printConfig = cfg.printConfig;
+
+    if (!printConfig) {
+        throw new Error('No print mode configured.');
+    }
+
+    const testJob: PrintJob = {
+        header: 'Windsor Test Page',
+        lines: [
+            'Normal text — The quick brown fox jumps over the lazy dog.',
+        ],
+        urls: ['https://github.com/SeaRyanC/d2p'],
+        footer: 'Footer text here',
+        metadataLines: [`Printed at: ${new Date().toLocaleString()}`, `Mode: ${printConfig.mode}`],
+    };
+
+    switch (printConfig.mode) {
+        case 'escp':
+            await printJobEscp(testJob, printConfig.serialPort);
+            break;
+        case 'cups':
+            await printJobCups(testJob, printConfig);
+            break;
+        case 'imagefeed':
+            await printTestJobImageFeed(testJob);
+            break;
+    }
+}
+
+export { getImageFeed, clearImageFeed, renderFeedHtml } from './imagefeed.ts';

package/src/reactions.ts

@@ -0,0 +1,6 @@
+export const Reaction = {
+    ok: "✅",
+    what: "❓",
+    fail: "❌"
+} as const;
+export type Reaction = (typeof Reaction)[keyof typeof Reaction];

package/src/server.ts

@@ -0,0 +1,355 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'http';
+import { build } from 'esbuild';
+import { stat } from 'fs/promises';
+import { join } from 'path';
+import {
+    getCurrentConfig,
+    updateConfig,
+    checkPassword,
+    hashPassword,
+    getConfigFilePath,
+} from './config.ts';
+import { printTestPage, getImageFeed, clearImageFeed, renderFeedHtml } from './printing/index.ts';
+import type { DiagnosticEvent, BotStatus, PrintConfig } from './types.ts';
+
+const MAX_EVENTS = 200;
+const events: DiagnosticEvent[] = [];
+
+export const status: BotStatus = {
+    connected: false,
+    tag: null,
+    startedAt: null,
+    guilds: [],
+    configuredServerId: null,
+};
+
+export function logEvent(type: DiagnosticEvent['type'], message: string): void {
+    const event: DiagnosticEvent = { timestamp: new Date().toISOString(), type, message };
+    events.push(event);
+    if (events.length > MAX_EVENTS) events.shift();
+    console.log(`[${event.timestamp}] [${type.toUpperCase()}] ${message}`);
+}
+
+
+function checkAuth(req: IncomingMessage): boolean {
+    const config = getCurrentConfig();
+    if (!config.passwordHash) return true;
+
+    const authHeader = req.headers['authorization'];
+    if (!authHeader || !authHeader.startsWith('Basic ')) return false;
+
+    const base64 = authHeader.slice(6);
+    const decoded = Buffer.from(base64, 'base64').toString('utf8');
+    const colonIdx = decoded.indexOf(':');
+    const password = colonIdx === -1 ? decoded : decoded.slice(colonIdx + 1);
+
+    return checkPassword(password);
+}
+
+function requireAuth(req: IncomingMessage, res: ServerResponse): boolean {
+    if (!checkAuth(req)) {
+        res.writeHead(401, {
+            'WWW-Authenticate': 'Basic realm="Windsor"',
+            'Content-Type': 'application/json',
+        });
+        res.end(JSON.stringify({ error: 'Unauthorized' }));
+        return false;
+    }
+    return true;
+}
+
+
+function sendJson(res: ServerResponse, statusCode: number, payload: unknown): void {
+    const body = JSON.stringify(payload, null, 2);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(body),
+    });
+    res.end(body);
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {
+    const chunks: Buffer[] = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Buffer);
+        total += buf.byteLength;
+        if (total > 1_000_000) throw new Error('Request body too large');
+        chunks.push(buf);
+    }
+    if (chunks.length === 0) return {};
+    const raw = Buffer.concat(chunks).toString('utf8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('JSON body must be an object');
+    }
+    return parsed as Record<string, unknown>;
+}
+
+
+let appBundleCache: { script: string; mtimeMs: number } | null = null;
+
+async function loadAppScript(): Promise<string> {
+    const entryPoint = join(process.cwd(), 'src', 'web', 'app.tsx');
+    const sourceStat = await stat(entryPoint);
+    if (appBundleCache && appBundleCache.mtimeMs === sourceStat.mtimeMs) {
+        return appBundleCache.script;
+    }
+
+    const result = await build({
+        entryPoints: [entryPoint],
+        bundle: true,
+        write: false,
+        platform: 'browser',
+        format: 'esm',
+        target: ['es2022'],
+        jsx: 'automatic',
+        jsxImportSource: 'preact',
+        sourcemap: 'inline',
+    });
+
+    const firstFile = result.outputFiles[0];
+    if (!firstFile) throw new Error('Failed to generate app bundle');
+    appBundleCache = { script: firstFile.text, mtimeMs: sourceStat.mtimeMs };
+    return firstFile.text;
+}
+
+function renderHtmlShell(): string {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Windsor Control Panel</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, sans-serif; background: #0f1115; color: #f5f7fa; }
+    a { color: #8ab4ff; }
+  </style>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/app.js"></script>
+</body>
+</html>`;
+}
+
+
+/** Registered Discord channels (set by bot on startup) */
+let discordChannels: Array<{ id: string; name: string }> = [];
+
+export function setDiscordChannels(channels: Array<{ id: string; name: string }>): void {
+    discordChannels = channels;
+}
+
+let _restartHandler: (() => Promise<void>) | null = null;
+
+export function setRestartHandler(fn: () => Promise<void>): void {
+    _restartHandler = fn;
+}
+
+let _refreshChannelsHandler: (() => Promise<void>) | null = null;
+
+export function setRefreshChannelsHandler(fn: () => Promise<void>): void {
+    _refreshChannelsHandler = fn;
+}
+
+export function startDiagnosticsServer(port: number): void {
+    const server = createServer(async (req, res) => {
+        try {
+            const method = req.method ?? 'GET';
+            const rawUrl = req.url ?? '/';
+            const urlPath = rawUrl.split('?')[0] ?? '/';
+
+            // Static assets (no auth required)
+            if (method === 'GET' && urlPath === '/app.js') {
+                const script = await loadAppScript();
+                res.writeHead(200, { 'Content-Type': 'application/javascript; charset=utf-8' });
+                res.end(script);
+                return;
+            }
+
+            if (method === 'GET' && urlPath === '/') {
+                const html = renderHtmlShell();
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+                return;
+            }
+            if (method === 'GET' && urlPath === '/feed') {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(renderFeedHtml());
+                return;
+            }
+
+            if (method === 'POST' && urlPath === '/feed/clear') {
+                clearImageFeed();
+                res.writeHead(303, { 'Location': '/feed' });
+                res.end();
+                return;
+            }
+
+            // All API routes require auth
+            if (!requireAuth(req, res)) return;
+            if (method === 'GET' && urlPath === '/api/events') {
+                sendJson(res, 200, { status, events: [...events].reverse() });
+                return;
+            }
+
+            if (method === 'GET' && urlPath === '/api/status') {
+                sendJson(res, 200, status);
+                return;
+            }
+            if (method === 'GET' && urlPath === '/api/config') {
+                const cfg = getCurrentConfig();
+                sendJson(res, 200, {
+                    discordToken: cfg.discordToken ?? '',
+                    openaiKey: cfg.openaiKey ?? '',
+                    serverId: cfg.serverId ?? null,
+                    diagnosticsPort: cfg.diagnosticsPort,
+                    channels: cfg.channels,
+                    configPath: getConfigFilePath(),
+                });
+                return;
+            }
+
+            if ((method === 'POST' || method === 'PUT') && urlPath === '/api/config') {
+                const body = await readJsonBody(req);
+                const patch: Record<string, unknown> = {};
+
+                if (Object.hasOwn(body, 'discordToken') && typeof body['discordToken'] === 'string') {
+                    patch['discordToken'] = body['discordToken'].trim() || undefined;
+                }
+                if (Object.hasOwn(body, 'serverId')) {
+                    const v = body['serverId'];
+                    patch['serverId'] = typeof v === 'string' && v.trim() ? v.trim() : undefined;
+                }
+                if (Object.hasOwn(body, 'openaiKey') && typeof body['openaiKey'] === 'string') {
+                    patch['openaiKey'] = body['openaiKey'].trim() || undefined;
+                }
+                if (Object.hasOwn(body, 'diagnosticsPort') && typeof body['diagnosticsPort'] === 'number') {
+                    patch['diagnosticsPort'] = body['diagnosticsPort'];
+                }
+                if (Object.hasOwn(body, 'password') && typeof body['password'] === 'string') {
+                    const pw = body['password'].trim();
+                    if (pw) {
+                        patch['passwordHash'] = hashPassword(pw);
+                    } else {
+                        patch['passwordHash'] = undefined;
+                    }
+                }
+
+                await updateConfig(patch as Parameters<typeof updateConfig>[0]);
+                const updated = getCurrentConfig();
+                sendJson(res, 200, {
+                    discordToken: updated.discordToken ?? '',
+                    openaiKey: updated.openaiKey ?? '',
+                    serverId: updated.serverId ?? null,
+                    diagnosticsPort: updated.diagnosticsPort,
+                    channels: updated.channels,
+                    configPath: getConfigFilePath(),
+                });
+                return;
+            }
+            if (method === 'GET' && urlPath === '/api/channels') {
+                const config = getCurrentConfig();
+                sendJson(res, 200, {
+                    channels: config.channels,
+                    discordChannels,
+                    unmapped: discordChannels.filter(dc =>
+                        !config.channels.find(m => m.channelId === dc.id)
+                    ),
+                });
+                return;
+            }
+
+            if (method === 'POST' && urlPath === '/api/channels') {
+                const body = await readJsonBody(req);
+                const config = getCurrentConfig();
+                const newMapping = body as unknown as import('./types.ts').ChannelMapping;
+                const channels = [...config.channels, newMapping];
+                await updateConfig({ channels });
+                sendJson(res, 200, { channels: getCurrentConfig().channels });
+                return;
+            }
+
+            const channelDeleteMatch = /^\/api\/channels\/([^/]+)$/.exec(urlPath);
+            if (channelDeleteMatch) {
+                const channelId = channelDeleteMatch[1]!;
+                if (method === 'DELETE') {
+                    const config = getCurrentConfig();
+                    const channels = config.channels.filter(m => m.channelId !== channelId);
+                    await updateConfig({ channels });
+                    sendJson(res, 200, { channels: getCurrentConfig().channels });
+                    return;
+                }
+                if (method === 'PUT') {
+                    const body = await readJsonBody(req);
+                    const config = getCurrentConfig();
+                    const channels = config.channels.map(m =>
+                        m.channelId === channelId ? { ...m, ...body } : m
+                    ) as typeof config.channels;
+                    await updateConfig({ channels });
+                    sendJson(res, 200, { channels: getCurrentConfig().channels });
+                    return;
+                }
+            }
+            if (method === 'GET' && urlPath === '/api/print-config') {
+                const cfg = getCurrentConfig();
+                sendJson(res, 200, { printConfig: cfg.printConfig ?? null });
+                return;
+            }
+
+            if ((method === 'POST' || method === 'PUT') && urlPath === '/api/print-config') {
+                const body = await readJsonBody(req);
+                const printConfig = body['printConfig'] as PrintConfig | null;
+                const patch: Partial<import('./types.ts').WindsorConfig> = {};
+                if (printConfig != null) patch.printConfig = printConfig;
+                await updateConfig(patch);
+                sendJson(res, 200, { printConfig: getCurrentConfig().printConfig ?? null });
+                return;
+            }
+
+            if (method === 'POST' && urlPath === '/api/printer/test') {
+                await printTestPage();
+                logEvent('print', 'Test page printed');
+                sendJson(res, 200, { ok: true });
+                return;
+            }
+            if (method === 'POST' && urlPath === '/api/restart') {
+                logEvent('info', 'Restart requested via API');
+                sendJson(res, 200, { ok: true });
+                if (_restartHandler) {
+                    void _restartHandler();
+                }
+                return;
+            }
+
+            if (method === 'POST' && urlPath === '/api/channels/refresh') {
+                if (_refreshChannelsHandler) {
+                    await _refreshChannelsHandler();
+                    const config = getCurrentConfig();
+                    sendJson(res, 200, {
+                        channels: config.channels,
+                        discordChannels,
+                        unmapped: discordChannels.filter(dc =>
+                            !config.channels.find(m => m.channelId === dc.id)
+                        ),
+                    });
+                } else {
+                    sendJson(res, 503, { error: 'Bot not connected' });
+                }
+                return;
+            }
+
+            sendJson(res, 404, { error: 'Not found' });
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            sendJson(res, 400, { error: message });
+            logEvent('error', `API error: ${message}`);
+        }
+    });
+
+    server.listen(port, '0.0.0.0', () => {
+        logEvent('startup', `Diagnostics server listening on http://0.0.0.0:${port}`);
+    });
+}