windsor-bot 0.1.17 → 0.2.0

package/README.md

@@ -26,185 +26,17 @@ for the bot before starting it.
 
 ## Initial setup
 
-### 1. Create a Discord bot
-
-1. Open the [Discord Developer Portal](https://discord.com/developers/applications)
-   and select **New Application**.
-2. Give the application a name and open its **Bot** page.
-3. Click **Reset Token**, then copy the token. Treat it like a password: do
-   not commit it, paste it into public issues, or share it. Discord will not
-   show the token again without resetting it.
-4. On the **Bot** page, enable the **Message Content Intent**. Windsor reads
-   ordinary message text, so this privileged intent is required. Windsor also
-   uses guilds, guild messages, and guild message reactions.
-
-### 2. Invite the bot to your server
-
-From the application's **Installation** or **OAuth2 > URL Generator** page,
-create an installation URL with the `bot` scope. Grant these permissions:
-
-* View Channels
-* Send Messages
-* Read Message History
-* Add Reactions
-
-Open the generated URL, choose the target server, and authorize it. The person
-installing the bot must have permission to manage the server. The bot must be
-able to view and read history in every channel that Windsor monitors.
-
-### 3. Set up a Raspberry Pi (headless)
-
-These steps assume a Raspberry Pi 4 or 5, a blank microSD card, and a wired or
-wireless network. The [official Raspberry Pi OS documentation](https://www.raspberrypi.com/documentation/computers/getting-started.html)
-has screenshots and troubleshooting for each step.
-
-1. Use [Raspberry Pi Imager](https://www.raspberrypi.com/software/) to write
-   **Raspberry Pi OS Lite (64-bit)** to the microSD card. Before writing,
-   open the OS customization screen and set:
-   * a hostname such as `windsor-pi`
-   * a username such as `piuser` (the Linux account that will run Windsor)
-   * a strong password
-   * your Wi-Fi country, network name, and password (if using Wi-Fi)
-   * the correct time zone and keyboard layout
-   * **Enable SSH**, using password authentication for the first login
-2. Eject the card, insert it into the Pi, connect the printer, and power on the
-   Pi. Wait two to five minutes for the first boot.
-3. From another computer on the same network, connect using the hostname:
-
-   ```bash
-   ssh piuser@windsor-pi.local
-   ```
-
-   If that name does not resolve, find the Pi in the router's client list and
-   use its address instead:
-
-   ```bash
-   ssh piuser@192.168.1.50
-   ```
-
-   See the
-   [Raspberry Pi SSH guide](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh)
-   if hostname discovery does not work.
-4. Update Raspberry Pi OS and install Node.js, npm, and the optional CUPS
-   printing tools:
-
-   ```bash
-   sudo apt update && sudo apt upgrade -y
-   sudo apt install -y nodejs npm cups
-   node --version
-   npm --version
-   ```
-
-5. Install Windsor globally:
-
-   ```bash
-   sudo npm install --global windsor-bot
-   command -v windsor-bot
-   ```
-
-6. Create a dedicated working directory. Configuration and cached icons will
-   be stored here:
-
-   ```bash
-   mkdir -p ~/windsor
-   cd ~/windsor
-   ```
-
-7. Connect the USB printer. For a direct ESC/P printer, identify the device:
-
-   ```bash
-   ls -l /dev/ttyUSB* /dev/ttyACM* 2>/dev/null
-   ```
-
-   The usual result is `/dev/ttyUSB0` or `/dev/ttyACM0`. Add the login user to
-   the device-access group, then reconnect over SSH:
-
-   ```bash
-   sudo usermod -aG dialout "$USER"
-   exit
-   ssh piuser@windsor-pi.local
-   cd ~/windsor
-   ```
-
-   For a CUPS printer, enable the service and list configured printers:
-
-   ```bash
-   sudo systemctl enable --now cups
-   lpstat -p
-   ```
-
-   Add the printer in CUPS, then use the name returned by `lpstat -p` in the
-   Windsor control panel.
-
-### 4. Install Windsor as a boot-time service
+### 1. Set up Discord
 
-Windsor should run under `systemd`, so it starts automatically whenever the Pi
-boots and restarts if the process exits. `systemd` does not use your interactive
-shell's username or `nvm` settings, so use the actual account and absolute
-binary path. Record them while logged in as the account that should run
-Windsor:
+Follow the [Discord setup guide](docs/discord-setup.md) to create and invite
+the bot.
 
-```bash
-id -un
-echo "$HOME"
-command -v windsor-bot
-```
-
-The first command must print an existing Linux username, and the last command
-must print an executable path. In the example below the account is `piuser`,
-the home directory is `/home/piuser`, and the installed command is
-`/usr/bin/windsor-bot`. If your output is different, substitute your values
-everywhere in the service file. For example, a Pi account named `windsor`
-uses `User=windsor` and `/home/windsor/...`; do not leave `User=piuser` unless
-that account actually exists.
-
-Create `/etc/systemd/system/windsor.service`:
-
-```bash
-sudo nano /etc/systemd/system/windsor.service
-```
+### 2. Set up a Raspberry Pi (headless)
 
-Paste the following, replacing the three example values with the output from
-the commands above:
-
-```ini
-[Unit]
-Description=Windsor Bot
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=piuser
-WorkingDirectory=/home/piuser/windsor
-ExecStart=/usr/bin/windsor-bot
-Restart=on-failure
-RestartSec=10
-
-[Install]
-WantedBy=multi-user.target
-```
+Follow the [Raspberry Pi setup guide](docs/pi-setup.md) to install Windsor and
+configure it as a boot-time service.
 
-Enable and start the service:
-
-```bash
-sudo systemctl daemon-reload
-sudo systemctl enable windsor
-sudo systemctl start windsor
-sudo systemctl status windsor
-```
-
-The service starts Windsor on every boot. View its logs with:
-
-```bash
-journalctl -u windsor -f
-```
-
-If the unit was already started with the wrong username or path, edit the unit,
-then run `sudo systemctl daemon-reload`, `sudo systemctl reset-failed windsor`,
-and `sudo systemctl restart windsor`.
-
-### 5. Configure credentials
+### 3. Configure credentials
 
 Open [http://localhost:8080](http://localhost:8080) (or port 8080 on the Pi's
 hostname/IP) from a computer on the same network. The service starts with no
@@ -214,8 +46,7 @@ Discord token, but the control panel is available immediately. Enter:
 2. Optionally, the server ID to restrict Windsor to one server. To copy
    IDs in Discord, enable **Developer Mode**, then right-click the server and
    choose **Copy Server ID**.
-3. Optionally enter an OpenAI API key. It is required for AI-generated icons
-   and recurring schedules.
+3. Optionally enter an OpenAI API key. It is required for AI-generated icons.
 4. Set a control-panel password in the **Security** section.
 5. Save, then click **Restart Server**. This restarts the bot while leaving the
    boot service enabled.
@@ -277,21 +108,17 @@ print and marks the trigger with a reaction. This is useful for shopping lists.
 Available options are **Header**, **Footer**, **Include metadata footer**, and
 **Include checklist boxes**.
 
-### 🔄 Recurring Print
+### 🔁 Reusable List
 
-Each message becomes a scheduled print. This behavior requires an OpenAI key
-because Windsor uses it to interpret natural-language schedules. Examples:
-
-```text
-Take out the trash every other Tuesday at 7 PM
-Change out the batteries on the 3rd of the month at 2 PM
-Call Bob a week before his birthday (6/12)
-```
+React to a message to print it. Windsor adds the same reaction after a
+successful print, giving the message two matching reactions. Removing your
+reaction also removes Windsor's matching reaction. Each message is printed at
+most once, and existing unhandled reactions from the last 100 messages are
+processed when Windsor starts.
 
-Windsor replies with the interpreted schedule. If it is wrong, delete the
-original message and post a corrected version. If no time is specified, the
-default is 8:00 AM local time. Schedules are restored from recent channel
-history when the bot starts.
+If the printer is unavailable, Windsor adds ⏳ and retries. Removing your
+reaction while the print is waiting cancels the pending print. This behavior
+does not add ✅ or ❌ reactions.
 
 ### 💬 On-Demand
 

package/dist/ai.js

@@ -2,8 +2,6 @@ import { createHash } from 'crypto';
 import { mkdir, writeFile, readFile, access } from 'fs/promises';
 import { join } from 'path';
 import OpenAI from 'openai';
-import { zodResponseFormat } from 'openai/helpers/zod.js';
-import { z } from 'zod/v4';
 import { getCurrentConfig, updateConfig } from './config.js';
 import { logEvent } from './server.js';
 const MODEL = 'gpt-5.4-nano';
@@ -43,102 +41,23 @@ function getClient() {
         return null;
     return new OpenAI({ apiKey: key });
 }
-const ScheduleSchema = z.object({
-    'message without schedule': z.string(),
-    'next occurrence': z.string(),
-});
-function parseOccurrenceDate(str) {
+function getIconCachePath(text, cacheDir) {
+    const prompt = `Black-on-transparent line drawing icon for the TODO item: "${text}". Do not produce any text. Use big, thick lines. No fine detailing.`;
+    const hash = createHash('sha1').update(prompt).digest('hex').slice(0, 9);
+    return join(cacheDir, `${hash}.png`);
+}
+export async function isIconCached(text, cacheDir) {
     try {
-        const d = new Date(str);
-        if (!isNaN(d.getTime()))
-            return d;
+        await access(getIconCachePath(text, cacheDir));
+        return true;
     }
     catch {
-        // ignore
+        return false;
     }
-    return null;
-}
-export async function parseRecurringSchedule(userMessage, now) {
-    const client = getClient();
-    if (!client)
-        return null;
-    if (await isOverTokenLimit())
-        return null;
-    const nowStr = formatScheduleDate(now);
-    const prompt = `The user has asked for a recurring printout. It is currently ${nowStr}. Tell me the next time that I should do this, and what the non-schedule part of the message was (verbatim). If the user didn't specify a time of day, use 8:00 AM. Here's the user's message: ${userMessage}`;
-    const results = [];
-    const ATTEMPTS = 5;
-    for (let i = 0; i < ATTEMPTS; i++) {
-        try {
-            const completion = await client.chat.completions.create({
-                model: MODEL,
-                reasoning_effort: 'low',
-                messages: [{ role: 'user', content: prompt }],
-                response_format: zodResponseFormat(ScheduleSchema, 'schedule'),
-            });
-            const content = completion.choices[0]?.message?.content;
-            if (content) {
-                const parsed = ScheduleSchema.parse(JSON.parse(content));
-                results.push(parsed);
-                const tokens = completion.usage?.total_tokens ?? 0;
-                trackTokenUsage(tokens);
-            }
-        }
-        catch (err) {
-            logEvent('error', `Schedule parsing attempt ${i + 1} failed: ${err}`);
-        }
-    }
-    if (results.length < 3)
-        return null;
-    // Majority voting: need 60% consistency for each field
-    const messageCounts = new Map();
-    const occurrenceCounts = new Map();
-    for (const r of results) {
-        messageCounts.set(r['message without schedule'], (messageCounts.get(r['message without schedule']) ?? 0) + 1);
-        occurrenceCounts.set(r['next occurrence'], (occurrenceCounts.get(r['next occurrence']) ?? 0) + 1);
-    }
-    const threshold = ATTEMPTS * 0.6;
-    let bestMessage = null;
-    for (const [msg, count] of messageCounts) {
-        if (count >= threshold) {
-            bestMessage = msg;
-            break;
-        }
-    }
-    let bestOccurrence = null;
-    for (const [occ, count] of occurrenceCounts) {
-        if (count >= threshold) {
-            bestOccurrence = occ;
-            break;
-        }
-    }
-    if (!bestMessage || !bestOccurrence)
-        return null;
-    const occDate = parseOccurrenceDate(bestOccurrence);
-    if (!occDate)
-        return null;
-    return { message: bestMessage, nextOccurrence: occDate };
-}
-function formatScheduleDate(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    let hours = date.getHours();
-    const minutes = String(date.getMinutes()).padStart(2, '0');
-    const ampm = hours >= 12 ? 'PM' : 'AM';
-    hours = hours % 12 || 12;
-    return `${year}-${month}-${day} ${hours}:${minutes} ${ampm}`;
-}
-export { formatScheduleDate };
-export async function getNextOccurrence(originalMessage, now) {
-    const result = await parseRecurringSchedule(originalMessage, now);
-    return result ? result.nextOccurrence : null;
 }
 export async function generateIcon(text, cacheDir) {
     const prompt = `Black-on-transparent line drawing icon for the TODO item: "${text}". Do not produce any text. Use big, thick lines. No fine detailing.`;
-    const hash = createHash('sha1').update(prompt).digest('hex').slice(0, 9);
-    const filename = `${hash}.png`;
-    const cachePath = join(cacheDir, filename);
+    const cachePath = getIconCachePath(text, cacheDir);
     // Check cache first
     try {
         await access(cachePath);