windsor-bot 0.1.16 → 0.2.0

package/dist/bot.js

@@ -1,5 +1,5 @@
-import { ChannelType, Client, GatewayIntentBits, } from 'discord.js';
-import { formatScheduleDate, generateIcon, getNextOccurrence, parseRecurringSchedule } from './ai.js';
+import { ChannelType, Client, GatewayIntentBits, Partials, } from 'discord.js';
+import { generateIcon, isIconCached } from './ai.js';
 import { Commands } from './commands/index.js';
 import { getCurrentConfig, reconcileChannels } from './config.js';
 import { formatTimestamp } from './printer.js';
@@ -31,6 +31,15 @@ export function extractUrls(text) {
 export function stripUrls(text) {
     return text.replace(URL_REGEX, '').replace(/\s+/g, ' ').trim();
 }
+async function removeOwnReactionSafe(reaction) {
+    try {
+        if (reaction.me)
+            await reaction.users.remove();
+    }
+    catch {
+        // ignore
+    }
+}
 export function replaceUrlsInText(text, urls) {
     if (urls.length === 0)
         return text;
@@ -83,10 +92,10 @@ async function removeReactionSafe(message, emoji) {
         // ignore
     }
 }
-async function reactSafe(message, emoji) {
+async function reactSafe(message, emoji, clearThinking = true) {
     try {
         await message.react(emoji);
-        if (emoji !== Reaction.thinking) {
+        if (emoji !== Reaction.thinking && clearThinking) {
             await removeReactionSafe(message, Reaction.thinking);
         }
         if (emoji === Reaction.ok) {
@@ -127,6 +136,7 @@ export function parseCommand(content) {
 }
 export function createWindsorBot() {
     const client = new Client({
+        partials: [Partials.Message, Partials.Reaction, Partials.User],
         intents: [
             GatewayIntentBits.Guilds,
             GatewayIntentBits.GuildMessages,
@@ -136,18 +146,18 @@ export function createWindsorBot() {
     });
     const pendingPrints = new Map();
     const processingPending = new Set();
+    const reusableStates = new Map();
     let pendingPoller = null;
     client.on('clientReady', () => void onReady());
     client.on('messageCreate', (msg) => void onMessage(msg));
+    client.on('messageReactionAdd', (reaction, user) => void onReactionAdd(reaction, user));
+    client.on('messageReactionRemove', (reaction, user) => void onReactionRemove(reaction, user));
     const bot = {
         start,
         destroy,
         getClient,
         handleImmediatePrint,
         handleAccumulatingPrint,
-        handleRecurringSetup,
-        executeRecurringTask,
-        advanceRecurring,
         handleOnDemand,
     };
     async function start(token) {
@@ -163,6 +173,74 @@ export function createWindsorBot() {
     function getClient() {
         return client;
     }
+    function getReusableConfig(message) {
+        const config = getCurrentConfig();
+        const mapping = config.channels.find(m => m.channelId === message.channelId);
+        if (!mapping || mapping.config.type !== 'reusable-list')
+            return null;
+        if (config.serverId && message.guildId !== config.serverId)
+            return null;
+        if (message.author.bot || message.reference)
+            return null;
+        return mapping.config;
+    }
+    async function hydrateReaction(reaction) {
+        const fullReaction = reaction.partial ? await reaction.fetch() : reaction;
+        if (fullReaction.message.partial)
+            await fullReaction.message.fetch();
+        return { reaction: fullReaction, message: fullReaction.message };
+    }
+    async function findStartupReusableReaction(message) {
+        if ([...message.reactions.cache.values()].some(reaction => reaction.me))
+            return null;
+        for (const reaction of message.reactions.cache.values()) {
+            const users = await reaction.users.fetch();
+            if ([...users.values()].some(user => !user.bot))
+                return reaction;
+        }
+        return null;
+    }
+    async function onReactionAdd(reactionEvent, user) {
+        if (user.bot)
+            return;
+        try {
+            const { reaction, message } = await hydrateReaction(reactionEvent);
+            const config = getReusableConfig(message);
+            if (!config)
+                return;
+            if ([...message.reactions.cache.values()].some(candidate => candidate.me))
+                return;
+            if (reusableStates.has(message.id))
+                return;
+            const state = { reaction, cancelled: false, status: 'printing' };
+            reusableStates.set(message.id, state);
+            await handleReusablePrint(message, config, state);
+        }
+        catch (err) {
+            logEvent('error', `Reusable List reaction handling failed: ${err}`);
+        }
+    }
+    async function onReactionRemove(reactionEvent, user) {
+        if (user.bot)
+            return;
+        try {
+            const { reaction, message } = await hydrateReaction(reactionEvent);
+            if (!getReusableConfig(message))
+                return;
+            const state = reusableStates.get(message.id);
+            if (state) {
+                state.cancelled = true;
+                pendingPrints.delete(message.id);
+                await removeReactionSafe(message, Reaction.waiting);
+                if (state.status !== 'printing')
+                    reusableStates.delete(message.id);
+            }
+            await removeOwnReactionSafe(reaction);
+        }
+        catch (err) {
+            logEvent('error', `Reusable List reaction removal failed: ${err}`);
+        }
+    }
     function isTextOnlyChannel(ch) {
         return ch.isTextBased()
             && ch.type !== ChannelType.GuildVoice
@@ -244,16 +322,7 @@ export function createWindsorBot() {
                 if (!mapping)
                     continue;
                 try {
-                    let fetchedMessages;
-                    if (mapping.config.type === 'recurring-print') {
-                        const page1 = await textCh.messages.fetch({ limit: 100 });
-                        const oldest = [...page1.values()].reduce((a, b) => BigInt(a.id) < BigInt(b.id) ? a : b);
-                        const page2 = await textCh.messages.fetch({ limit: 100, before: oldest.id });
-                        fetchedMessages = new Map([...page1, ...page2]);
-                    }
-                    else {
-                        fetchedMessages = await textCh.messages.fetch({ limit: 100 });
-                    }
+                    const fetchedMessages = await textCh.messages.fetch({ limit: 100 });
                     const sorted = [...fetchedMessages.values()].sort((a, b) => Number(BigInt(a.id) - BigInt(b.id)));
                     await processBehaviorStartup(textCh, mapping.config, sorted);
                 }
@@ -309,8 +378,17 @@ export function createWindsorBot() {
                 }
                 break;
             }
-            case 'recurring-print': {
-                await startupRecurring(channel, config, messages);
+            case 'reusable-list': {
+                for (const msg of messages) {
+                    if (msg.author.bot || msg.reference || msg.author.id === botId)
+                        continue;
+                    const reaction = await findStartupReusableReaction(msg);
+                    if (!reaction || reusableStates.has(msg.id))
+                        continue;
+                    const state = { reaction, cancelled: false, status: 'printing' };
+                    reusableStates.set(msg.id, state);
+                    await handleReusablePrint(msg, config, state);
+                }
                 break;
             }
             case 'on-demand': {
@@ -333,35 +411,6 @@ export function createWindsorBot() {
             }
         }
     }
-    async function startupRecurring(channel, config, messages) {
-        const botId = client.user?.id;
-        const scheduleReplies = messages.filter(m => m.author.id === botId && m.content.startsWith('Got it. I will print ⟪'));
-        for (const scheduleReply of scheduleReplies) {
-            const parentId = scheduleReply.reference?.messageId;
-            if (!parentId)
-                continue;
-            const statusReplies = messages.filter(m => m.author.id === botId &&
-                m.reference?.messageId === scheduleReply.id &&
-                (m.content.startsWith('Printed at') || m.content.includes('has expired')));
-            const latestStatus = statusReplies[statusReplies.length - 1];
-            if (latestStatus?.content.includes('has expired')) {
-                continue;
-            }
-            if (latestStatus && latestStatus.content.startsWith('Printed at') && !await hasReaction(latestStatus, Reaction.ok)) {
-                await advanceRecurring(scheduleReply, latestStatus, config);
-                continue;
-            }
-            if (!latestStatus) {
-                const match = /at (.+)$/.exec(scheduleReply.content);
-                if (!match?.[1])
-                    continue;
-                const nextTime = new Date(match[1]);
-                if (isNaN(nextTime.getTime()))
-                    continue;
-                scheduleRecurringTask(scheduleReply, nextTime, config, bot);
-            }
-        }
-    }
     async function onMessage(message) {
         if (message.author.bot)
             return;
@@ -394,8 +443,7 @@ export function createWindsorBot() {
                 }
                 break;
             }
-            case 'recurring-print':
-                await handleRecurringSetup(message, mapping.config);
+            case 'reusable-list':
                 break;
             case 'on-demand':
                 await handleOnDemand(message);
@@ -424,9 +472,12 @@ export function createWindsorBot() {
                 `${message.author.username} · ${formatTimestamp(message.createdAt)}`,
             ];
         }
+        let thinkingReacted = false;
         if (config.includeIcon) {
-            await reactSafe(message, Reaction.thinking);
             const iconCacheDir = getCurrentConfig().iconCacheDir ?? './icon-cache';
+            thinkingReacted = !await isIconCached(strippedText, iconCacheDir);
+            if (thinkingReacted)
+                await reactSafe(message, Reaction.thinking);
             const iconPath = await generateIcon(strippedText, iconCacheDir);
             if (iconPath)
                 job.iconPath = iconPath;
@@ -435,7 +486,8 @@ export function createWindsorBot() {
         if (await hasAnyReaction(message)) {
             const waiting = message.reactions.cache.get(Reaction.waiting)?.me;
             if (!retryPending && (!retryFailed || !message.reactions.cache.get(Reaction.fail)?.me)) {
-                await removeReactionSafe(message, Reaction.thinking);
+                if (thinkingReacted)
+                    await removeReactionSafe(message, Reaction.thinking);
                 return;
             }
             if (retryPending && !waiting)
@@ -444,21 +496,22 @@ export function createWindsorBot() {
         try {
             await printJob(job);
             pendingPrints.delete(message.id);
-            await reactSafe(message, Reaction.ok);
+            await reactSafe(message, Reaction.ok, thinkingReacted);
             logEvent('print', `Printed immediate message from ${message.author.username}`);
         }
         catch (err) {
             if (isPrinterUnavailableError(err)) {
-                await reactSafe(message, Reaction.waiting);
+                await reactSafe(message, Reaction.waiting, thinkingReacted);
                 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 reactSafe(message, Reaction.fail, thinkingReacted);
             await replySafe(message, `⏸️ Print failed: ${err instanceof Error ? err.message : String(err)}`);
             logEvent('error', `Print failed: ${err}`);
         }
-        await removeReactionSafe(message, Reaction.thinking);
+        if (thinkingReacted)
+            await removeReactionSafe(message, Reaction.thinking);
     }
     async function handleAccumulatingPrint(triggerMessage, config, allMessages, retryPending = false) {
         const botId = client.user?.id;
@@ -529,99 +582,70 @@ export function createWindsorBot() {
             logEvent('error', `Accumulating print failed: ${err}`);
         }
     }
-    async function handleRecurringSetup(message, config) {
-        const rawContent = message.content;
+    async function handleReusablePrint(message, config, state) {
+        if (state.cancelled) {
+            reusableStates.delete(message.id);
+            return;
+        }
         try {
-            const parsed = await parseRecurringSchedule(rawContent, new Date());
-            if (!parsed) {
-                await reactSafe(message, Reaction.what);
-                await replySafe(message, '⁉️ Could not parse a schedule from your message. Please try again with a clearer schedule.');
-                return;
-            }
-            const nextStr = formatScheduleDate(parsed.nextOccurrence);
-            await reactSafe(message, Reaction.ok);
-            const reply = await replySafe(message, `Got it. I will print ⟪${parsed.message}⟫ at ${nextStr}`);
-            if (reply) {
-                scheduleRecurringTask(reply, parsed.nextOccurrence, config, bot);
-            }
+            await message.fetch();
         }
         catch (err) {
-            await reactSafe(message, Reaction.fail);
-            await replySafe(message, `⁉️ Failed to parse schedule: ${err instanceof Error ? err.message : String(err)}`);
+            reusableStates.delete(message.id);
+            pendingPrints.delete(message.id);
+            logEvent('info', `Cancelled reusable print for unavailable message ${message.id}: ${err}`);
+            return;
         }
-    }
-    async function executeRecurringTask(scheduleReply, config) {
-        const match = /⟪(.+?)⟫/.exec(scheduleReply.content);
-        if (!match?.[1])
+        const rawContent = message.content;
+        const urls = extractUrls(rawContent);
+        const text = replaceUrlsInText(rawContent, urls);
+        const strippedText = stripUrls(rawContent);
+        if (strippedText.length > MAX_MESSAGE_CHARS) {
+            reusableStates.delete(message.id);
+            await removeReactionSafe(message, Reaction.waiting);
+            await replySafe(message, '⁉️ This message is too long to print.');
             return;
-        const text = match[1];
-        const urls = extractUrls(text);
-        const textWithLinks = replaceUrlsInText(text, urls);
-        const strippedText = stripUrls(text);
-        const job = {
-            lines: [textWithLinks],
-            urls,
-        };
+        }
+        const job = { lines: [text], urls };
         if (config.header)
             job.header = config.header;
         if (config.footer)
             job.footer = config.footer;
         if (config.includeMetadata) {
-            job.metadataLines = [`Recurring · ${formatTimestamp(new Date())}`];
-        }
-        if (config.includeIcon) {
-            const iconCacheDir = getCurrentConfig().iconCacheDir ?? './icon-cache';
-            const iconPath = await generateIcon(strippedText, iconCacheDir);
-            if (iconPath)
-                job.iconPath = iconPath;
+            job.metadataLines = [
+                `${message.author.username} · ${formatTimestamp(message.createdAt)}`,
+            ];
         }
-        await refreshMessage(scheduleReply);
-        if (await hasAnyReaction(scheduleReply)) {
-            await removeReactionSafe(scheduleReply, Reaction.thinking);
+        if (state.cancelled) {
+            reusableStates.delete(message.id);
             return;
         }
-        const printedAt = formatTimestamp(new Date());
         try {
             await printJob(job);
         }
         catch (err) {
-            await removeReactionSafe(scheduleReply, Reaction.thinking);
-            logEvent('error', `Recurring print failed: ${err}`);
+            if (isPrinterUnavailableError(err)) {
+                state.status = 'pending';
+                await reactSafe(message, Reaction.waiting);
+                enqueuePendingPrint(message, () => handleReusablePrint(message, config, state));
+                logEvent('info', `Printer unavailable for reusable message in #${message.channelId}`);
+                return;
+            }
+            reusableStates.delete(message.id);
+            await removeReactionSafe(message, Reaction.waiting);
+            await replySafe(message, `⏸️ Print failed: ${err instanceof Error ? err.message : String(err)}`);
+            logEvent('error', `Reusable List print failed: ${err}`);
             return;
         }
-        logEvent('print', `Printed recurring task: ${text}`);
-        const originalUserMessage = scheduleReply.content.replace(/^Got it\. I will print ⟪.+?⟫ at /, '');
-        const nextOccurrence = await getNextOccurrence(originalUserMessage, new Date());
-        let statusReply;
-        if (!nextOccurrence) {
-            statusReply = await replySafe(scheduleReply, 'This occurrence has expired and no more prints are scheduled');
-        }
-        else {
-            const nextStr = formatScheduleDate(nextOccurrence);
-            statusReply = await replySafe(scheduleReply, `Printed at ${printedAt}. The next print will be at ${nextStr}.`);
-        }
-        if (statusReply) {
-            await reactSafe(statusReply, Reaction.ok);
-        }
-        await removeReactionSafe(scheduleReply, Reaction.thinking);
-        if (nextOccurrence && statusReply) {
-            scheduleRecurringTask(scheduleReply, nextOccurrence, config, bot);
-        }
-    }
-    async function advanceRecurring(scheduleReply, latestStatusReply, config) {
-        const match = /⟪(.+?)⟫/.exec(scheduleReply.content);
-        if (!match?.[1])
-            return;
-        const nextOccurrence = await getNextOccurrence(match[1], new Date());
-        if (!nextOccurrence) {
-            await replySafe(latestStatusReply, 'This occurrence has expired and no more prints are scheduled');
-            await removeReactionSafe(latestStatusReply, Reaction.thinking);
+        pendingPrints.delete(message.id);
+        await removeReactionSafe(message, Reaction.waiting);
+        if (state.cancelled) {
+            reusableStates.delete(message.id);
             return;
         }
-        const nextStr = formatScheduleDate(nextOccurrence);
-        await replySafe(latestStatusReply, `The next print will be at ${nextStr}.`);
-        await reactSafe(latestStatusReply, Reaction.ok);
-        scheduleRecurringTask(scheduleReply, nextOccurrence, config, bot);
+        await message.react(state.reaction.emoji);
+        state.status = 'printed';
+        logEvent('print', `Printed reusable message from ${message.author.username}`);
     }
     async function retryFailedMessages(message) {
         const mapping = getCurrentConfig().channels.find(m => m.channelId === message.channelId);
@@ -690,26 +714,3 @@ export function createWindsorBot() {
     }
     return bot;
 }
-const scheduledTasks = new Map();
-export function scheduleRecurringTask(scheduleReply, nextOccurrence, config, bot) {
-    const key = scheduleReply.id;
-    const existing = scheduledTasks.get(key);
-    if (existing)
-        clearTimeout(existing.timerId);
-    const delay = Math.max(0, nextOccurrence.getTime() - Date.now());
-    const timerId = setTimeout(() => {
-        scheduledTasks.delete(key);
-        void bot.executeRecurringTask(scheduleReply, config);
-    }, delay);
-    scheduledTasks.set(key, { scheduleReply, nextOccurrence, config, bot, timerId });
-}
-export function checkScheduledTasks() {
-    const now = new Date();
-    for (const [key, task] of scheduledTasks) {
-        if (task.nextOccurrence <= now) {
-            clearTimeout(task.timerId);
-            scheduledTasks.delete(key);
-            void task.bot.executeRecurringTask(task.scheduleReply, task.config);
-        }
-    }
-}

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { getCurrentConfig, loadConfig } from './config.js';
 import { logEvent, startDiagnosticsServer, setDiscordChannels, setRestartHandler, setRefreshChannelsHandler } from './server.js';
-import { createWindsorBot, checkScheduledTasks } from './bot.js';
+import { createWindsorBot } from './bot.js';
 import { ChannelType } from 'discord.js';
 const { config } = await loadConfig();
 startDiagnosticsServer(config.diagnosticsPort);
@@ -39,10 +39,6 @@ export async function restartBot() {
     const { config } = await loadConfig();
     await startBot(config);
 }
-// Recurring task checker
-setInterval(() => {
-    checkScheduledTasks();
-}, 30_000);
 setRestartHandler(restartBot);
 async function refreshChannels() {
     if (!bot) {

package/dist/server.js

@@ -1,7 +1,7 @@
 import { createServer } from 'http';
 import { execFile } from 'child_process';
 import { build } from 'esbuild';
-import { readFile, stat } from 'fs/promises';
+import { access, readFile, stat } from 'fs/promises';
 import { promisify } from 'util';
 import { spawn } from 'child_process';
 import { dirname, join } from 'path';
@@ -65,13 +65,29 @@ async function readPackageVersion() {
     return packageJson.version;
 }
 async function updateGlobalBot() {
-    // GUI-launched processes may not inherit the shell PATH where npm is installed.
-    const npmEnv = {
-        ...process.env,
-        PATH: [dirname(process.execPath), process.env.PATH].filter(Boolean).join(process.platform === 'win32' ? ';' : ':'),
-    };
-    await execFileAsync('npm', ['install', '-g', 'windsor-bot@latest'], { env: npmEnv });
-    const { stdout } = await execFileAsync('npm', ['root', '-g'], { env: npmEnv });
+    const npmCliCandidates = [
+        process.env['npm_execpath'],
+        join(dirname(process.execPath), '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        '/usr/local/lib/node_modules/npm/bin/npm-cli.js',
+        '/opt/homebrew/lib/node_modules/npm/bin/npm-cli.js',
+    ].filter((candidate) => Boolean(candidate));
+    let npmCliPath;
+    for (const candidate of npmCliCandidates) {
+        try {
+            await access(candidate);
+            npmCliPath = candidate;
+            break;
+        }
+        catch {
+            // Try the next known npm installation location.
+        }
+    }
+    if (!npmCliPath)
+        throw new Error('Unable to locate npm');
+    const npmCli = npmCliPath;
+    const runNpm = (args) => execFileAsync(process.execPath, [npmCli, ...args]);
+    await runNpm(['install', '-g', 'windsor-bot@latest']);
+    const { stdout } = await runNpm(['root', '-g']);
     const packageJsonPath = join(stdout.trim(), 'windsor-bot', 'package.json');
     const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
     if (typeof packageJson.version !== 'string')