windsor-bot 0.1.12 → 0.1.13

package/assets/poker/README.txt

@@ -0,0 +1,6 @@
+These suit SVGs are CC0 assets from Wikimedia Commons:
+
+- https://commons.wikimedia.org/wiki/File:Playing_Card_Suit_-_Swiss-French_Club.svg
+- https://commons.wikimedia.org/wiki/File:Playing_Card_Suit_-_Swiss-French_Diamond.svg
+- https://commons.wikimedia.org/wiki/File:Playing_Card_Suit_-_Swiss-French_Heart.svg
+- https://commons.wikimedia.org/wiki/File:Playing_Card_Suit_-_Swiss-French_Spade.svg

package/assets/poker/club.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="72px" height="72px" viewBox="0 0 72 72" enable-background="new 0 0 72 72" xml:space="preserve">
+<path fill="#0A0B0B" d="M19.21,28.22c-12.744,0-12.976,16.22,0,16.22c7.647,0,11.818-7.491,14.367-4.865
+	c2.395,2.472-1.391,15.911-1.699,18.073c-0.464,2.936,2.008,5.253,4.712,5.253c2.857,0,4.865-2.317,4.325-5.253
+	c-0.387-2.162-3.785-15.524-1.313-18.073c2.395-2.472,7.029,4.942,15.217,4.865c11.662-0.076,11.662-16.22,0-16.22
+	c-8.033,0-12.745,7.415-15.217,4.943c-2.317-2.317,4.943-5.021,4.943-12.899c0-11.432-16.065-11.432-16.065-0.077
+	c0,7.956,7.492,10.736,5.098,12.976C30.951,35.635,26.857,28.22,19.21,28.22z"/>
+</svg>

package/assets/poker/diamond.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="72px" height="72px" viewBox="0 0 72 72" enable-background="new 0 0 72 72" xml:space="preserve">
+<path fill="#ED2224" d="M36.143,9.601c-5.631,9.257-16.662,20.982-25.688,27.154c9.026,5.708,20.057,17.896,25.688,26.846
+	c5.632-8.949,17.28-21.138,25.998-27.077C53.423,30.583,41.774,18.857,36.143,9.601z"/>
+</svg>

package/assets/poker/heart.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="72px" height="72px" viewBox="0 0 72 72" enable-background="new 0 0 72 72" xml:space="preserve">
+<path fill="#ED2224" d="M35.84,21.358c-11.368-11.92-27-6-27,9c0,14.684,14.842,18.631,21.158,24.947
+	c0.947,0.947,3.711,3.474,5.921,7.895c2.289-4.421,4.974-6.947,5.921-7.895c6-6.316,21-10.264,21-24.632
+	C62.84,15.358,47.051,9.438,35.84,21.358z"/>
+</svg>

package/assets/poker/spade.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="72px" height="72px" viewBox="0 0 72 72" enable-background="new 0 0 72 72" xml:space="preserve">
+<path fill="#010101" d="M36.067,10.646C29.462,25.327,11.332,27.309,9.35,39.199C7.441,51.017,22.636,58.356,33.572,49.988
+	c1.468,3.084-0.367,8.001-3.377,12.111c1.541-0.513,4.624-0.733,5.872-0.733s4.33,0.221,5.872,0.733
+	c-3.01-4.11-4.771-9.027-3.377-12.111c12.772,7.928,26.352,0.882,24.443-10.789C60.95,26.648,42.674,25.327,36.067,10.646z"/>
+</svg>

package/dist/bot.js

@@ -3,11 +3,12 @@ import { formatScheduleDate, generateIcon, getNextOccurrence, parseRecurringSche
 import { Commands } from './commands/index.js';
 import { getCurrentConfig, reconcileChannels } from './config.js';
 import { formatTimestamp } from './printer.js';
-import { printJob } from './printing/index.js';
+import { printJob, PrinterUnavailableError } from './printing/index.js';
 import { logEvent, status } from './server.js';
 import { Reaction } from './reactions.js';
 const MAX_MESSAGE_CHARS = 800;
 const MAX_URLS = 5;
+const PRINTER_POLL_INTERVAL_MS = 3_000;
 const URL_REGEX = /https:\/\/[^\s<>"']+/g;
 const TRAILING_PUNCT = /[.,;:!?)\]}>'"]+$/;
 export function extractUrls(text) {
@@ -90,6 +91,10 @@ async function reactSafe(message, emoji) {
         }
         if (emoji === Reaction.ok) {
             await removeReactionSafe(message, Reaction.fail);
+            await removeReactionSafe(message, Reaction.waiting);
+        }
+        if (emoji === Reaction.waiting) {
+            await removeReactionSafe(message, Reaction.fail);
         }
     }
     catch {
@@ -111,6 +116,15 @@ function isCommandMessage(content) {
     const trimmed = content.trim();
     return trimmed.startsWith('!') || trimmed.startsWith('/');
 }
+export function parseCommand(content) {
+    const match = content.trim().match(/^[!/]\s*(\S+)(?:\s+(.*))?$/);
+    if (!match?.[1])
+        return null;
+    return {
+        name: match[1].toLowerCase(),
+        args: match[2]?.trim() ?? '',
+    };
+}
 export function createWindsorBot() {
     const client = new Client({
         intents: [
@@ -120,6 +134,9 @@ export function createWindsorBot() {
             GatewayIntentBits.GuildMessageReactions,
         ],
     });
+    const pendingPrints = new Map();
+    const processingPending = new Set();
+    let pendingPoller = null;
     client.on('clientReady', () => void onReady());
     client.on('messageCreate', (msg) => void onMessage(msg));
     const bot = {
@@ -137,6 +154,10 @@ export function createWindsorBot() {
         await client.login(token);
     }
     function destroy() {
+        if (pendingPoller) {
+            clearInterval(pendingPoller);
+            pendingPoller = null;
+        }
         client.destroy();
     }
     function getClient() {
@@ -149,6 +170,37 @@ export function createWindsorBot() {
             && ch.type !== ChannelType.GuildForum
             && ch.type !== ChannelType.GuildMedia;
     }
+    function enqueuePendingPrint(message, retry) {
+        pendingPrints.set(message.id, { message, retry });
+        if (pendingPoller)
+            return;
+        pendingPoller = setInterval(() => void pollPendingPrints(), PRINTER_POLL_INTERVAL_MS);
+        logEvent('info', `Printer unavailable; polling for ${pendingPrints.size} pending print(s)`);
+    }
+    async function pollPendingPrints() {
+        for (const [messageId, pending] of pendingPrints) {
+            if (processingPending.has(messageId))
+                continue;
+            processingPending.add(messageId);
+            try {
+                await pending.retry();
+                await refreshMessage(pending.message);
+                if (!pending.message.reactions.cache.get(Reaction.waiting)?.me) {
+                    pendingPrints.delete(messageId);
+                }
+            }
+            catch (err) {
+                logEvent('error', `Pending print retry failed: ${err}`);
+            }
+            finally {
+                processingPending.delete(messageId);
+            }
+        }
+        if (pendingPrints.size === 0 && pendingPoller) {
+            clearInterval(pendingPoller);
+            pendingPoller = null;
+        }
+    }
     async function onReady() {
         const botUser = client.user;
         status.connected = true;
@@ -224,7 +276,11 @@ export function createWindsorBot() {
                     if (msg.author.id === botId)
                         continue;
                     if (isCommandMessage(msg.content)) {
-                        await handleOnDemand(msg);
+                        await handleOnDemand(msg, await hasReaction(msg, Reaction.waiting));
+                        continue;
+                    }
+                    if (await hasReaction(msg, Reaction.waiting)) {
+                        await handleImmediatePrint(msg, config, false, true);
                         continue;
                     }
                     if (await hasAnyReaction(msg))
@@ -243,6 +299,10 @@ export function createWindsorBot() {
                         continue;
                     if (!isPrintTrigger(msg.content))
                         continue;
+                    if (await hasReaction(msg, Reaction.waiting)) {
+                        await handleAccumulatingPrint(msg, config, messages, true);
+                        continue;
+                    }
                     if (await hasAnyReaction(msg))
                         continue;
                     await handleAccumulatingPrint(msg, config, messages);
@@ -261,6 +321,10 @@ export function createWindsorBot() {
                         continue;
                     if (msg.author.id === botId)
                         continue;
+                    if (await hasReaction(msg, Reaction.waiting)) {
+                        await handleOnDemand(msg, true);
+                        continue;
+                    }
                     if (await hasAnyReaction(msg))
                         continue;
                     await handleOnDemand(msg);
@@ -338,7 +402,7 @@ export function createWindsorBot() {
                 break;
         }
     }
-    async function handleImmediatePrint(message, config, retryFailed = false) {
+    async function handleImmediatePrint(message, config, retryFailed = false, retryPending = false) {
         const rawContent = message.content;
         const urls = extractUrls(rawContent);
         const textWithLinkLabels = replaceUrlsInText(rawContent, urls);
@@ -369,24 +433,34 @@ export function createWindsorBot() {
         }
         await refreshMessage(message);
         if (await hasAnyReaction(message)) {
-            if (!retryFailed || !message.reactions.cache.get(Reaction.fail)?.me) {
+            const waiting = message.reactions.cache.get(Reaction.waiting)?.me;
+            if (!retryPending && (!retryFailed || !message.reactions.cache.get(Reaction.fail)?.me)) {
                 await removeReactionSafe(message, Reaction.thinking);
                 return;
             }
+            if (retryPending && !waiting)
+                return;
         }
         try {
             await printJob(job);
+            pendingPrints.delete(message.id);
             await reactSafe(message, Reaction.ok);
             logEvent('print', `Printed immediate message from ${message.author.username}`);
         }
         catch (err) {
+            if (err instanceof PrinterUnavailableError) {
+                await reactSafe(message, Reaction.waiting);
+                enqueuePendingPrint(message, () => handleImmediatePrint(message, config, false, true));
+                logEvent('info', `Printer unavailable for immediate message from ${message.author.username}`);
+                return;
+            }
             await reactSafe(message, Reaction.fail);
             await replySafe(message, `⏸️ Print failed: ${err instanceof Error ? err.message : String(err)}`);
             logEvent('error', `Print failed: ${err}`);
         }
         await removeReactionSafe(message, Reaction.thinking);
     }
-    async function handleAccumulatingPrint(triggerMessage, config, allMessages) {
+    async function handleAccumulatingPrint(triggerMessage, config, allMessages, retryPending = false) {
         const botId = client.user?.id;
         const triggerIdx = allMessages.findIndex(m => m.id === triggerMessage.id);
         const prior = allMessages.slice(0, triggerIdx).reverse();
@@ -433,14 +507,23 @@ export function createWindsorBot() {
             job.metadataLines = [`Printed at ${formatTimestamp(new Date())}`];
         }
         await refreshMessage(triggerMessage);
-        if (await hasAnyReaction(triggerMessage))
-            return;
+        if (await hasAnyReaction(triggerMessage)) {
+            if (!retryPending || !triggerMessage.reactions.cache.get(Reaction.waiting)?.me)
+                return;
+        }
         try {
             await printJob(job);
+            pendingPrints.delete(triggerMessage.id);
             await reactSafe(triggerMessage, Reaction.ok);
             logEvent('print', `Printed accumulating list (${lines.length} items)`);
         }
         catch (err) {
+            if (err instanceof PrinterUnavailableError) {
+                await reactSafe(triggerMessage, Reaction.waiting);
+                enqueuePendingPrint(triggerMessage, () => handleAccumulatingPrint(triggerMessage, config, allMessages, true));
+                logEvent('info', `Printer unavailable for accumulating list in #${triggerMessage.channelId}`);
+                return;
+            }
             await reactSafe(triggerMessage, Reaction.fail);
             await replySafe(triggerMessage, `⏸️ Print failed: ${err instanceof Error ? err.message : String(err)}`);
             logEvent('error', `Accumulating print failed: ${err}`);
@@ -556,28 +639,38 @@ export function createWindsorBot() {
         }
         return failed.length;
     }
-    async function handleOnDemand(message) {
-        const content = message.content.trim();
-        if (!content.startsWith('!') && !content.startsWith('/'))
+    async function handleOnDemand(message, retryPending = false) {
+        const parsed = parseCommand(message.content);
+        if (!parsed)
             return;
-        const afterPrefix = content.slice(1).trim();
-        const spaceIdx = afterPrefix.indexOf(' ');
-        const commandName = (spaceIdx === -1 ? afterPrefix : afterPrefix.slice(0, spaceIdx)).toLowerCase();
-        const args = spaceIdx === -1 ? '' : afterPrefix.slice(spaceIdx + 1).trim();
+        const { name: commandName, args } = parsed;
         let foundCommand = false;
         for (const cmd of Commands) {
             if (cmd.aliases.some(a => commandName.localeCompare(a, undefined, { sensitivity: "base" }) == 0)) {
                 foundCommand = true;
                 logEvent('command', `Command '${commandName}' invoked by ${message.author.username}`);
                 await refreshMessage(message);
-                if (await hasAnyReaction(message))
+                if (await hasAnyReaction(message) && !retryPending)
                     return;
                 const ctx = {
                     printJob,
                     retryFailedMessages: () => retryFailedMessages(message),
                 };
-                const result = await cmd.invoke(args, ctx);
+                let result;
+                try {
+                    result = await cmd.invoke(args, ctx);
+                }
+                catch (err) {
+                    if (err instanceof PrinterUnavailableError) {
+                        await reactSafe(message, Reaction.waiting);
+                        enqueuePendingPrint(message, () => handleOnDemand(message, true));
+                        logEvent('info', `Printer unavailable for command '${commandName}'`);
+                        return;
+                    }
+                    throw err;
+                }
                 if (result.kind === 'pass') {
+                    pendingPrints.delete(message.id);
                     await reactSafe(message, "✅");
                     if (result.reply) {
                         await replySafe(message, result.reply);

package/dist/commands/index.js

@@ -1,6 +1,7 @@
 import { debugFail } from "./debug-fail.js";
 import { helloWorld } from "./hello-world.js";
 import { printPokemon } from "./pokemon.js";
+import { printPoker } from "./poker.js";
 import { retry } from "./retry.js";
 import { printSudoku } from "./sudoku.js";
 import { printWordsearch } from "./wordsearch.js";
@@ -9,6 +10,7 @@ export const Commands = [
     printSudoku,
     printWordsearch,
     printPokemon,
+    printPoker,
     retry,
     debugFail
 ];

package/dist/commands/poker.js

@@ -0,0 +1,139 @@
+import { readFile, unlink, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { Jimp, JimpMime, loadFont, measureText, ResizeStrategy } from 'jimp';
+import { Resvg } from '@resvg/resvg-js';
+import { tryExecCommandFunction } from './util.js';
+const FONT_DIR = new URL('../../node_modules/@jimp/plugin-print/dist/fonts/open-sans/', import.meta.url).pathname;
+const FONT_64 = `${FONT_DIR}open-sans-64-black/open-sans-64-black.fnt`;
+const FONT_128 = `${FONT_DIR}open-sans-128-black/open-sans-128-black.fnt`;
+const IMAGE_WIDTH = 560;
+const MARGIN = 24;
+const CARD_WIDTH = 88;
+const CARD_HEIGHT = 118;
+const CARD_GAP = 8;
+const HAND_GAP = 12;
+const TITLE_HEIGHT = 48;
+const SUIT_MARGIN = 8;
+const RENDER_SCALE = 3;
+const RANKS = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
+const SUITS = ['clubs', 'diamonds', 'hearts', 'spades'];
+const SUIT_FILES = {
+    clubs: new URL('../../assets/poker/club.svg', import.meta.url),
+    diamonds: new URL('../../assets/poker/diamond.svg', import.meta.url),
+    hearts: new URL('../../assets/poker/heart.svg', import.meta.url),
+    spades: new URL('../../assets/poker/spade.svg', import.meta.url),
+};
+export function dealPokerHand(random = Math.random) {
+    const deck = SUITS.flatMap(suit => RANKS.map(rank => ({ rank, suit })));
+    for (let i = deck.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1));
+        [deck[i], deck[j]] = [deck[j], deck[i]];
+    }
+    const board = deck.slice(0, 5);
+    const hands = Array.from({ length: 4 }, (_, index) => {
+        const offset = 5 + index * 2;
+        return [deck[offset], deck[offset + 1]];
+    });
+    return { board, hands };
+}
+function drawBox(image, left, top) {
+    left *= RENDER_SCALE;
+    top *= RENDER_SCALE;
+    const right = left + CARD_WIDTH * RENDER_SCALE;
+    const bottom = top + CARD_HEIGHT * RENDER_SCALE;
+    for (let x = left; x <= right; x++) {
+        image.setPixelColor(0x000000ff, x, top);
+        image.setPixelColor(0x000000ff, x, bottom);
+    }
+    for (let y = top; y <= bottom; y++) {
+        image.setPixelColor(0x000000ff, left, y);
+        image.setPixelColor(0x000000ff, right, y);
+    }
+}
+async function loadSuitImages() {
+    const entries = await Promise.all(Object.entries(SUIT_FILES).map(async ([suit, path]) => {
+        const svg = await readFile(path, 'utf8');
+        const png = new Resvg(svg, {
+            fitTo: { mode: 'width', value: 48 * RENDER_SCALE },
+        }).render().asPng();
+        return [suit, await Jimp.fromBuffer(png)];
+    }));
+    return Object.fromEntries(entries);
+}
+function drawCard(image, card, left, top, rankFont, suitImages) {
+    drawBox(image, left, top);
+    image.print({
+        font: rankFont,
+        x: (left + 8) * RENDER_SCALE,
+        y: (top + 7) * RENDER_SCALE,
+        text: card.rank,
+    });
+    const suit = suitImages[card.suit];
+    image.composite(suit, (left + CARD_WIDTH - SUIT_MARGIN) * RENDER_SCALE - suit.width, (top + 58) * RENDER_SCALE);
+}
+async function renderPokerImage(deal) {
+    const rankFont = await loadFont(FONT_128);
+    const titleFont = await loadFont(FONT_64);
+    const suitImages = await loadSuitImages();
+    const boardWidth = CARD_WIDTH * 5 + CARD_GAP * 4;
+    const handsTop = MARGIN + TITLE_HEIGHT + CARD_HEIGHT + 24;
+    const imageHeight = handsTop + CARD_HEIGHT * 4 + HAND_GAP * 3 + MARGIN;
+    const image = new Jimp({
+        width: IMAGE_WIDTH * RENDER_SCALE,
+        height: imageHeight * RENDER_SCALE,
+        color: 0xffffffff,
+    });
+    const title = "Texas Hold 'Em";
+    image.print({
+        font: titleFont,
+        x: (IMAGE_WIDTH * RENDER_SCALE - measureText(titleFont, title)) / 2,
+        y: MARGIN * RENDER_SCALE,
+        text: title,
+    });
+    const boardLeft = (IMAGE_WIDTH - boardWidth) / 2;
+    for (const [index, card] of deal.board.entries()) {
+        drawCard(image, card, boardLeft + index * (CARD_WIDTH + CARD_GAP), MARGIN + TITLE_HEIGHT, rankFont, suitImages);
+    }
+    const handCardsWidth = CARD_WIDTH * 2 + CARD_GAP;
+    const lineLeft = MARGIN + handCardsWidth + 28;
+    const lineRight = IMAGE_WIDTH - MARGIN;
+    for (const [index, hand] of deal.hands.entries()) {
+        const top = handsTop + index * (CARD_HEIGHT + HAND_GAP);
+        drawCard(image, hand[0], MARGIN, top, rankFont, suitImages);
+        drawCard(image, hand[1], MARGIN + CARD_WIDTH + CARD_GAP, top, rankFont, suitImages);
+        const lineY = top + CARD_HEIGHT;
+        for (let x = lineLeft * RENDER_SCALE; x <= lineRight * RENDER_SCALE; x++) {
+            for (let offset = 0; offset < RENDER_SCALE; offset++) {
+                image.setPixelColor(0x000000ff, x, lineY * RENDER_SCALE + offset);
+            }
+        }
+    }
+    image.resize({
+        w: IMAGE_WIDTH,
+        h: imageHeight,
+        mode: ResizeStrategy.BICUBIC,
+    });
+    const imagePath = join(tmpdir(), `windsor-poker-${process.pid}-${Date.now()}.png`);
+    await writeFile(imagePath, await image.getBuffer(JimpMime.png));
+    return imagePath;
+}
+async function pokerWorker(_args, ctx) {
+    const imagePath = await renderPokerImage(dealPokerHand());
+    try {
+        const job = {
+            lines: [],
+            urls: [],
+            iconPath: imagePath,
+        };
+        await ctx.printJob(job);
+    }
+    finally {
+        await unlink(imagePath);
+    }
+    return { kind: 'pass' };
+}
+export const printPoker = {
+    aliases: ['poker'],
+    invoke: tryExecCommandFunction(pokerWorker),
+};

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { loadConfig } from './config.js';
+import { getCurrentConfig, loadConfig } from './config.js';
 import { logEvent, startDiagnosticsServer, setDiscordChannels, setRestartHandler, setRefreshChannelsHandler } from './server.js';
 import { createWindsorBot, checkScheduledTasks } from './bot.js';
 import { ChannelType } from 'discord.js';
@@ -19,21 +19,7 @@ async function startBot(cfg) {
     try {
         await nextBot.start(cfg.discordToken);
         bot = nextBot;
-        // Register discord channels in server for the web UI
-        const guilds = [...nextBot.getClient().guilds.cache.values()];
-        const channels = [];
-        for (const guild of guilds) {
-            const fetched = await guild.channels.fetch();
-            for (const ch of fetched.values()) {
-                if (ch?.isTextBased() &&
-                    'name' in ch &&
-                    ch.type !== ChannelType.GuildVoice &&
-                    ch.type !== ChannelType.GuildStageVoice) {
-                    channels.push({ id: ch.id, name: ch.name });
-                }
-            }
-        }
-        setDiscordChannels(channels);
+        await refreshChannels();
         logEvent('startup', 'Bot started successfully');
     }
     catch (err) {
@@ -64,7 +50,13 @@ async function refreshChannels() {
         return;
     }
     logEvent('info', 'Refreshing Discord channels…');
-    const guilds = [...bot.getClient().guilds.cache.values()];
+    const serverId = getCurrentConfig().serverId;
+    const guilds = serverId
+        ? [bot.getClient().guilds.cache.get(serverId)].filter((guild) => guild !== undefined)
+        : [...bot.getClient().guilds.cache.values()];
+    if (serverId && guilds.length === 0) {
+        throw new Error(`Configured serverId ${serverId} not found`);
+    }
     const channels = [];
     for (const guild of guilds) {
         const fetched = await guild.channels.fetch();

package/dist/printing/index.js

@@ -2,26 +2,52 @@ import { getCurrentConfig } from '../config.js';
 import { printJobEscp } from './escp.js';
 import { printJobCups } from './cups.js';
 import { printJobImageFeed, printTestJobImageFeed } from './imagefeed.js';
+export class PrinterUnavailableError extends Error {
+    constructor(message = 'Printer is unavailable') {
+        super(message);
+        this.name = 'PrinterUnavailableError';
+    }
+}
+function isUnavailableError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const code = 'code' in error ? error.code : undefined;
+    const message = error.message.toLowerCase();
+    return code === 'ENOENT' ||
+        code === 'ENODEV' ||
+        code === 'ENXIO' ||
+        message.includes('printer or class does not exist') ||
+        message.includes('no printer') ||
+        message.includes('device or resource busy');
+}
 export async function printJob(job) {
     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 = printConfig;
-            throw new Error(`Unknown print mode: ${never.mode}`);
+    try {
+        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 = printConfig;
+                throw new Error(`Unknown print mode: ${never.mode}`);
+            }
+        }
+    }
+    catch (error) {
+        if (isUnavailableError(error)) {
+            throw new PrinterUnavailableError(error instanceof Error ? error.message : String(error));
         }
+        throw error;
     }
 }
 export async function printTestPage() {

package/dist/reactions.js

@@ -2,5 +2,6 @@ export const Reaction = {
     ok: "✅",
     what: "❓",
     fail: "❌",
-    thinking: "🧠"
+    thinking: "🧠",
+    waiting: "⏳"
 };

package/dist/server.js

@@ -1,12 +1,16 @@
 import { createServer } from 'http';
+import { execFile } from 'child_process';
 import { build } from 'esbuild';
 import { readFile, stat } from 'fs/promises';
+import { promisify } from 'util';
+import { spawn } from 'child_process';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { getCurrentConfig, updateConfig, checkPassword, hashPassword, getConfigFilePath, } from './config.js';
 import { printTestPage, getImageFeed, clearImageFeed, renderFeedHtml } from './printing/index.js';
 const MAX_EVENTS = 200;
 const events = [];
+const execFileAsync = promisify(execFile);
 export const status = {
     connected: false,
     tag: null,
@@ -53,6 +57,38 @@ function sendJson(res, statusCode, payload) {
     });
     res.end(body);
 }
+async function readPackageVersion() {
+    const runtimeDir = dirname(fileURLToPath(import.meta.url));
+    const packageJson = JSON.parse(await readFile(join(runtimeDir, '..', 'package.json'), 'utf8'));
+    if (typeof packageJson.version !== 'string')
+        throw new Error('package.json does not contain a valid version');
+    return packageJson.version;
+}
+async function updateGlobalBot() {
+    await execFileAsync('npm', ['install', '-g', 'windsor-bot@latest']);
+    const { stdout } = await execFileAsync('npm', ['root', '-g']);
+    const packageJsonPath = join(stdout.trim(), 'windsor-bot', 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    if (typeof packageJson.version !== 'string')
+        throw new Error('Updated package does not contain a valid version');
+    return packageJson.version;
+}
+function hardRestart() {
+    const child = spawn('/bin/sh', [
+        '-c',
+        'sleep 1; exec "$@"',
+        'windsor-hard-restart',
+        process.execPath,
+        ...process.argv.slice(1),
+    ], {
+        detached: true,
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    child.unref();
+    setTimeout(() => process.kill(process.pid, 'SIGTERM'), 250);
+}
 async function readJsonBody(req) {
     const chunks = [];
     let total = 0;
@@ -185,6 +221,10 @@ export function startDiagnosticsServer(port) {
                 sendJson(res, 200, status);
                 return;
             }
+            if (method === 'GET' && urlPath === '/api/version') {
+                sendJson(res, 200, { version: await readPackageVersion() });
+                return;
+            }
             if (method === 'GET' && urlPath === '/api/config') {
                 const cfg = getCurrentConfig();
                 sendJson(res, 200, {
@@ -300,6 +340,18 @@ export function startDiagnosticsServer(port) {
                 }
                 return;
             }
+            if (method === 'POST' && urlPath === '/api/update') {
+                const version = await updateGlobalBot();
+                logEvent('info', `Updated windsor-bot to version ${version}`);
+                sendJson(res, 200, { version });
+                return;
+            }
+            if (method === 'POST' && urlPath === '/api/hard-restart') {
+                logEvent('info', 'Hard restart requested via API');
+                sendJson(res, 200, { ok: true });
+                hardRestart();
+                return;
+            }
             if (method === 'POST' && urlPath === '/api/channels/refresh') {
                 if (_refreshChannelsHandler) {
                     await _refreshChannelsHandler();