windsor-bot 0.1.0

package/src/commands/index.ts

@@ -0,0 +1,35 @@
+import { debugFail } from "./debug-fail.ts";
+import { helloWorld } from "./hello-world.ts";
+import { printPokemon } from "./pokemon.ts";
+import { printSudoku } from "./sudoku.ts";
+import { printWordsearch } from "./wordsearch.ts";
+import type { PrintJob } from "../types.ts";
+
+export interface CommandRunContext {
+    printJob: (job: PrintJob) => Promise<void>;
+}
+
+export type Command = {
+    aliases: string[];
+    invoke: (msg: string, ctx: CommandRunContext) => Promise<CommandResult>;
+};
+
+export type CommandResultPass = {
+    kind: "pass";
+    reply?: string;
+};
+
+export type CommandResultFail = {
+    kind: "fail";
+    reason: string;
+};
+
+export type CommandResult = CommandResultPass | CommandResultFail;
+
+export const Commands = [
+    helloWorld,
+    printSudoku,
+    printWordsearch,
+    printPokemon,
+    debugFail
+] as const satisfies ReadonlyArray<Command>;

package/src/commands/pokemon.ts

@@ -0,0 +1,146 @@
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import type { Command, CommandResult, CommandRunContext } from './index.ts';
+import type { PrintJob } from '../types.ts';
+import { tryExecCommandFunction } from './util.ts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SPRITE_DIR = join(__dirname, '../assets/pokemon-sprites');
+
+// Kanto Pokédex — index 0 = Bulbasaur (#1)
+const KANTO: string[] = [
+    'Bulbasaur', 'Ivysaur', 'Venusaur',
+    'Charmander', 'Charmeleon', 'Charizard',
+    'Squirtle', 'Wartortle', 'Blastoise',
+    'Caterpie', 'Metapod', 'Butterfree',
+    'Weedle', 'Kakuna', 'Beedrill',
+    'Pidgey', 'Pidgeotto', 'Pidgeot',
+    'Rattata', 'Raticate',
+    'Spearow', 'Fearow',
+    'Ekans', 'Arbok',
+    'Pikachu', 'Raichu',
+    'Sandshrew', 'Sandslash',
+    'Nidoran♀', 'Nidorina', 'Nidoqueen',
+    'Nidoran♂', 'Nidorino', 'Nidoking',
+    'Clefairy', 'Clefable',
+    'Vulpix', 'Ninetales',
+    'Jigglypuff', 'Wigglytuff',
+    'Zubat', 'Golbat',
+    'Oddish', 'Gloom', 'Vileplume',
+    'Paras', 'Parasect',
+    'Venonat', 'Venomoth',
+    'Diglett', 'Dugtrio',
+    'Meowth', 'Persian',
+    'Psyduck', 'Golduck',
+    'Mankey', 'Primeape',
+    'Growlithe', 'Arcanine',
+    'Poliwag', 'Poliwhirl', 'Poliwrath',
+    'Abra', 'Kadabra', 'Alakazam',
+    'Machop', 'Machoke', 'Machamp',
+    'Bellsprout', 'Weepinbell', 'Victreebel',
+    'Tentacool', 'Tentacruel',
+    'Geodude', 'Graveler', 'Golem',
+    'Ponyta', 'Rapidash',
+    'Slowpoke', 'Slowbro',
+    'Magnemite', 'Magneton',
+    "Farfetch'd",
+    'Doduo', 'Dodrio',
+    'Seel', 'Dewgong',
+    'Grimer', 'Muk',
+    'Shellder', 'Cloyster',
+    'Gastly', 'Haunter', 'Gengar',
+    'Onix',
+    'Drowzee', 'Hypno',
+    'Krabby', 'Kingler',
+    'Voltorb', 'Electrode',
+    'Exeggcute', 'Exeggutor',
+    'Cubone', 'Marowak',
+    'Hitmonlee', 'Hitmonchan',
+    'Lickitung',
+    'Koffing', 'Weezing',
+    'Rhyhorn', 'Rhydon',
+    'Chansey',
+    'Tangela',
+    'Kangaskhan',
+    'Horsea', 'Seadra',
+    'Goldeen', 'Seaking',
+    'Staryu', 'Starmie',
+    'Mr. Mime',
+    'Scyther',
+    'Jynx',
+    'Electabuzz',
+    'Magmar',
+    'Pinsir',
+    'Tauros',
+    'Magikarp', 'Gyarados',
+    'Lapras',
+    'Ditto',
+    'Eevee', 'Vaporeon', 'Jolteon', 'Flareon',
+    'Porygon',
+    'Omanyte', 'Omastar',
+    'Kabuto', 'Kabutops',
+    'Aerodactyl',
+    'Snorlax',
+    'Articuno', 'Zapdos', 'Moltres',
+    'Dratini', 'Dragonair', 'Dragonite',
+    'Mewtwo',
+    'Mew',
+];
+
+function findPokemon(arg: string): { id: number; name: string } | null {
+    const trimmed = arg.trim();
+
+    // Try by number
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num) && num >= 1 && num <= 151) {
+        return { id: num, name: KANTO[num - 1]! };
+    }
+
+    // Try by name (case-insensitive)
+    const lower = trimmed.toLowerCase();
+    const idx = KANTO.findIndex(n => n.toLowerCase() === lower);
+    if (idx !== -1) {
+        return { id: idx + 1, name: KANTO[idx]! };
+    }
+
+    return null;
+}
+
+async function pokemonWorker(args: string, ctx: CommandRunContext): Promise<CommandResult> {
+    let id: number;
+    let name: string;
+
+    if (!args.trim()) {
+        // Random
+        id = Math.floor(Math.random() * KANTO.length) + 1;
+        name = KANTO[id - 1]!;
+    } else {
+        const found = findPokemon(args);
+        if (!found) {
+            return {
+                kind: 'fail',
+                reason: `Unknown Pokémon "${args.trim()}". Use a name or number 1-151.`,
+            };
+        }
+        ({ id, name } = found);
+    }
+
+    const spritePath = join(SPRITE_DIR, `${id}.png`);
+    const numStr = String(id).padStart(3, '0');
+
+    const job: PrintJob = {
+        header: `#${numStr} ${name}`,
+        lines: [],
+        urls: [],
+        iconPath: spritePath,
+    };
+
+    await ctx.printJob(job);
+
+    return { kind: 'pass', reply: `Printing #${numStr} ${name}!` };
+}
+
+export const printPokemon: Command = {
+    aliases: ['pokemon', 'kanto'],
+    invoke: tryExecCommandFunction(pokemonWorker),
+};

package/src/commands/sudoku.ts

@@ -0,0 +1,94 @@
+import type { PrintJob } from '../types.ts';
+import type { Command, CommandResult, CommandRunContext } from './index.ts';
+import { tryExecCommandFunction } from './util.ts';
+
+type Difficulty = 'kid' | 'easy' | 'medium' | 'hard' | '';
+
+type Grid = (number | 0)[][];
+
+function generateSudoku(difficulty: Difficulty): Grid {
+    // Start with a solved grid
+    const base: Grid = [
+        [5, 3, 4, 6, 7, 8, 9, 1, 2],
+        [6, 7, 2, 1, 9, 5, 3, 4, 8],
+        [1, 9, 8, 3, 4, 2, 5, 6, 7],
+        [8, 5, 9, 7, 6, 1, 4, 2, 3],
+        [4, 2, 6, 8, 5, 3, 7, 9, 1],
+        [7, 1, 3, 9, 2, 4, 8, 5, 6],
+        [9, 6, 1, 5, 3, 7, 2, 8, 4],
+        [2, 8, 7, 4, 1, 9, 6, 3, 5],
+        [3, 4, 5, 2, 8, 6, 1, 7, 9],
+    ];
+
+    // Number of cells to remove based on difficulty
+    const removes: Record<NonNullable<Difficulty>, number> = {
+        '': 35,
+        kid: 20,
+        easy: 35,
+        medium: 45,
+        hard: 55,
+    };
+    const toRemove = removes[difficulty] ?? 35;
+
+    // Shuffle positions and remove
+    const positions = Array.from({ length: 81 }, (_, i) => i);
+    for (let i = positions.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        const tmp = positions[i]!;
+        positions[i] = positions[j]!;
+        positions[j] = tmp;
+    }
+
+    const grid: Grid = base.map(row => [...row] as (number | 0)[]);
+    for (let i = 0; i < toRemove; i++) {
+        const pos = positions[i];
+        if (pos === undefined) break;
+        const row = Math.floor(pos / 9);
+        const col = pos % 9;
+        if (grid[row]) grid[row]![col] = 0;
+    }
+    return grid;
+}
+
+function renderSudokuGrid(grid: Grid): string[] {
+    const lines: string[] = [];
+    lines.push('┌───────┬───────┬───────┐');
+    for (let row = 0; row < 9; row++) {
+        const cells = grid[row] ?? [];
+        const r1 = cells.slice(0, 3).map(c => c === 0 ? '·' : String(c)).join(' ');
+        const r2 = cells.slice(3, 6).map(c => c === 0 ? '·' : String(c)).join(' ');
+        const r3 = cells.slice(6, 9).map(c => c === 0 ? '·' : String(c)).join(' ');
+        lines.push(`│ ${r1} │ ${r2} │ ${r3} │`);
+        if (row === 2 || row === 5) {
+            lines.push('├───────┼───────┼───────┤');
+        }
+    }
+    lines.push('└───────┴───────┴───────┘');
+    return lines;
+}
+
+async function printSudokuWorker(args: string, ctx: CommandRunContext): Promise<CommandResult> {
+    // !TODO: Implement good command parsing
+    const difficulty = args as Difficulty;
+
+    const diff = difficulty || 'easy';
+    const grid = generateSudoku(diff as Difficulty);
+    const gridLines = renderSudokuGrid(grid);
+
+    const job: PrintJob = {
+        urls: [],
+        header: `Sudoku (${diff})`,
+        lines: gridLines,
+    };
+
+    await ctx.printJob(job);
+
+    return {
+        kind: "pass"
+    };
+}
+
+export const printSudoku: Command = {
+    aliases: ["sudoku"],
+    invoke: tryExecCommandFunction(printSudokuWorker)
+};

package/src/commands/util.ts

@@ -0,0 +1,14 @@
+import type { CommandResult, CommandRunContext } from "./index.ts";
+
+export function tryExecCommandFunction(func: (cmd: string, ctx: CommandRunContext) => Promise<CommandResult>) {
+    return async function(cmd: string, ctx: CommandRunContext): Promise<CommandResult> {
+        try {
+            return await func(cmd, ctx);
+        } catch(err) {
+            return {
+                kind: "fail",
+                reason: `${err}`
+            };
+        }
+    }
+}

package/src/commands/wordsearch.ts

@@ -0,0 +1,118 @@
+import type { PrintJob } from '../types.ts';
+import type { Command, CommandResultPass, CommandRunContext } from './index.ts';
+import { tryExecCommandFunction } from './util.ts';
+
+const THEMES: Array<{ name: string; words: string[] }> = [
+    {
+        name: 'Animals',
+        words: ['CAT', 'DOG', 'BIRD', 'FISH', 'LION', 'BEAR', 'FROG', 'DUCK', 'WOLF', 'DEER'],
+    },
+    {
+        name: 'Fruits',
+        words: ['APPLE', 'MANGO', 'GRAPE', 'PEACH', 'PLUM', 'PEAR', 'LIME', 'KIWI', 'FIG', 'DATE'],
+    },
+    {
+        name: 'Colors',
+        words: ['RED', 'BLUE', 'GREEN', 'PINK', 'GOLD', 'TEAL', 'CORAL', 'TAN', 'IVORY', 'NAVY'],
+    },
+    {
+        name: 'Space',
+        words: ['STAR', 'MOON', 'SUN', 'MARS', 'EARTH', 'VENUS', 'COMET', 'ORBIT', 'NOVA', 'RING'],
+    },
+    {
+        name: 'Food',
+        words: ['PIZZA', 'TACO', 'SOUP', 'CAKE', 'RICE', 'BREAD', 'PASTA', 'SALAD', 'CHIP', 'PIE'],
+    },
+];
+
+const SIZE = 15;
+
+function makeGrid(): string[][] {
+    return Array.from({ length: SIZE }, () => Array(SIZE).fill('') as string[]);
+}
+
+type Direction = [number, number];
+
+const DIRECTIONS: Direction[] = [
+    [0, 1], [1, 0], [1, 1], [1, -1],
+    [0, -1], [-1, 0], [-1, -1], [-1, 1],
+];
+
+function placeWord(grid: string[][], word: string): boolean {
+    const shuffledDirs = [...DIRECTIONS].sort(() => Math.random() - 0.5);
+    for (const [dr, dc] of shuffledDirs) {
+        for (let attempt = 0; attempt < 30; attempt++) {
+            const row = Math.floor(Math.random() * SIZE);
+            const col = Math.floor(Math.random() * SIZE);
+            let fits = true;
+            for (let i = 0; i < word.length; i++) {
+                const r = row + dr * i;
+                const c = col + dc * i;
+                if (r < 0 || r >= SIZE || c < 0 || c >= SIZE) { fits = false; break; }
+                const cell = grid[r]?.[c];
+                if (cell && cell !== word[i]) { fits = false; break; }
+            }
+            if (fits) {
+                for (let i = 0; i < word.length; i++) {
+                    const r = row + dr * i;
+                    const c = col + dc * i;
+                    if (grid[r]) grid[r]![c] = word[i]!;
+                }
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function fillGrid(grid: string[][]): void {
+    for (let r = 0; r < SIZE; r++) {
+        for (let c = 0; c < SIZE; c++) {
+            if (!grid[r]?.[c]) {
+                if (grid[r]) grid[r]![c] = LETTERS[Math.floor(Math.random() * 26)] ?? 'A';
+            }
+        }
+    }
+}
+
+function renderGrid(grid: string[][]): string[] {
+    return grid.map(row => row.join(' '));
+}
+
+async function printWordsearchWorker(_args: string, ctx: CommandRunContext): Promise<CommandResultPass> {
+    const theme = THEMES[Math.floor(Math.random() * THEMES.length)];
+    if (!theme) throw new Error('No themes available');
+
+    const grid = makeGrid();
+    const placed: string[] = [];
+    for (const word of theme.words) {
+        if (placeWord(grid, word)) placed.push(word);
+    }
+    fillGrid(grid);
+
+    const lines: string[] = [
+        ...renderGrid(grid),
+        '',
+        'Find these words:',
+        placed.join('  '),
+    ];
+
+    const job: PrintJob = {
+        urls: [],
+        header: `Word Search: ${theme.name}`,
+        lines,
+    };
+
+    await ctx.printJob(job);
+
+    return {
+        kind: "pass"
+    };
+}
+
+export const printWordsearch: Command = {
+    aliases: ["wordsearch"],
+    invoke: tryExecCommandFunction(printWordsearchWorker)
+};

package/src/config.ts

@@ -0,0 +1,166 @@
+import { readFile, writeFile } from 'fs/promises';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import type { WindsorConfig, ChannelMapping, TokenUsageEntry } from './types.ts';
+
+export const DEFAULT_CONFIG_FILE = 'windsor.config.json';
+
+export function getConfigPath(): string {
+    if (process.env['WINDSOR_CONFIG_PATH']) return process.env['WINDSOR_CONFIG_PATH'];
+    return join(process.cwd(), DEFAULT_CONFIG_FILE);
+}
+
+
+let _config: WindsorConfig = {
+    diagnosticsPort: 8080,
+    channels: [],
+    tokenUsage: [],
+};
+let _configPath: string = getConfigPath();
+
+export function getCurrentConfig(): WindsorConfig {
+    return _config;
+}
+
+export function getConfigFilePath(): string {
+    return _configPath;
+}
+
+
+function defaultConfig(): WindsorConfig {
+    const envPort = Number.parseInt(process.env['DIAGNOSTICS_PORT'] ?? '8080', 10);
+    const diagnosticsPort = Number.isFinite(envPort) && envPort >= 1 && envPort <= 65535 ? envPort : 8080;
+    const result: WindsorConfig = {
+        diagnosticsPort,
+        channels: [],
+        tokenUsage: [],
+    };
+    const token = process.env['DISCORD_TOKEN']?.trim();
+    if (token) result.discordToken = token;
+    const serverId = process.env['SERVER_ID']?.trim();
+    if (serverId) result.serverId = serverId;
+    const openaiKey = process.env['OPENAI_API_KEY']?.trim();
+    if (openaiKey) result.openaiKey = openaiKey;
+    return result;
+}
+
+function parseConfig(raw: unknown): WindsorConfig {
+    if (typeof raw !== 'object' || raw === null) {
+        return defaultConfig();
+    }
+    const obj = raw as Record<string, unknown>;
+    const base = defaultConfig();
+    const result: WindsorConfig = {
+        diagnosticsPort: typeof obj['diagnosticsPort'] === 'number' ? obj['diagnosticsPort'] : base.diagnosticsPort,
+        channels: Array.isArray(obj['channels']) ? (obj['channels'] as unknown[]).flatMap(c => {
+            if (typeof c === 'object' && c !== null) return [c as ChannelMapping];
+            return [];
+        }) : [],
+        tokenUsage: Array.isArray(obj['tokenUsage']) ? (obj['tokenUsage'] as unknown[]).flatMap(e => {
+            if (typeof e === 'object' && e !== null) return [e as TokenUsageEntry];
+            return [];
+        }) : [],
+    };
+    if (typeof obj['discordToken'] === 'string' && obj['discordToken'].trim()) {
+        result.discordToken = obj['discordToken'].trim();
+    } else if (base.discordToken) {
+        result.discordToken = base.discordToken;
+    }
+    if (typeof obj['serverId'] === 'string' && obj['serverId'].trim()) {
+        result.serverId = obj['serverId'].trim();
+    } else if (base.serverId) {
+        result.serverId = base.serverId;
+    }
+    if (typeof obj['openaiKey'] === 'string' && obj['openaiKey'].trim()) {
+        result.openaiKey = obj['openaiKey'].trim();
+    } else if (base.openaiKey) {
+        result.openaiKey = base.openaiKey;
+    }
+    if (typeof obj['passwordHash'] === 'string') result.passwordHash = obj['passwordHash'];
+    if (typeof obj['iconCacheDir'] === 'string') result.iconCacheDir = obj['iconCacheDir'];
+    if (typeof obj['printConfig'] === 'object' && obj['printConfig'] !== null) {
+        result.printConfig = obj['printConfig'] as import('./types.ts').PrintConfig;
+    }
+    return result;
+}
+
+export async function loadConfig(): Promise<{ config: WindsorConfig; configPath: string }> {
+    _configPath = getConfigPath();
+
+    try {
+        const raw = await readFile(_configPath, 'utf8');
+        _config = parseConfig(JSON.parse(raw));
+        return { config: _config, configPath: _configPath };
+    } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+            throw err;
+        }
+    }
+
+    _config = defaultConfig();
+    return { config: _config, configPath: _configPath };
+}
+
+export async function saveCurrentConfig(): Promise<void> {
+    await writeFile(_configPath, `${JSON.stringify(_config, null, 2)}\n`, 'utf8');
+}
+
+export async function updateConfig(patch: Partial<WindsorConfig>): Promise<WindsorConfig> {
+    const updated: WindsorConfig = { ..._config, ...patch };
+    _config = updated;
+    await saveCurrentConfig();
+    return _config;
+}
+
+
+export function hashPassword(password: string): string {
+    return createHash('sha256').update(password).digest('hex');
+}
+
+export function checkPassword(password: string): boolean {
+    if (!_config.passwordHash) return true; // no password set
+    return hashPassword(password) === _config.passwordHash;
+}
+
+
+export interface DiscordChannelInfo {
+    id: string;
+    name: string;
+}
+
+/**
+ * Reconcile channel configs against the current set of Discord channels.
+ * Match by ID first, then by name. Delete unmatched UNLESS all channels are missing (server blip).
+ * Mutates config.channels in place and saves.
+ */
+export async function reconcileChannels(discordChannels: DiscordChannelInfo[]): Promise<void> {
+    if (discordChannels.length === 0) {
+        // Server blip - don't delete anything
+        return;
+    }
+
+    const channelById = new Map(discordChannels.map(c => [c.id, c]));
+    const channelByName = new Map(discordChannels.map(c => [c.name, c]));
+
+    const reconciled: ChannelMapping[] = [];
+    for (const mapping of _config.channels) {
+        const byId = channelById.get(mapping.channelId);
+        if (byId) {
+            // ID match — update name if changed
+            reconciled.push({ ...mapping, channelName: byId.name });
+            continue;
+        }
+        const byName = channelByName.get(mapping.channelName);
+        if (byName) {
+            // Name match — update ID
+            reconciled.push({ ...mapping, channelId: byName.id });
+            continue;
+        }
+        // No match — delete this mapping
+    }
+
+    _config.channels = reconciled;
+    await saveCurrentConfig();
+}
+
+

package/src/index.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { loadConfig, getCurrentConfig } from './config.ts';
+import { logEvent, startDiagnosticsServer, setDiscordChannels, setRestartHandler, setRefreshChannelsHandler } from './server.ts';
+import { createWindsorBot, checkScheduledTasks } from './bot.ts';
+import { ChannelType } from 'discord.js';
+
+const config = getCurrentConfig();
+
+startDiagnosticsServer(config.diagnosticsPort);
+
+let bot: ReturnType<typeof createWindsorBot> | null = null;
+let startInFlight = false;
+
+async function startBot(): Promise<void> {
+    if (startInFlight) return;
+    const cfg = getCurrentConfig();
+    if (!cfg.discordToken) {
+        logEvent('info', 'No Discord token configured. Visit the control panel to set up.');
+        return;
+    }
+
+    startInFlight = true;
+    const nextBot = createWindsorBot();
+    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: Array<{ id: string; name: string }> = [];
+        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 as { name: string }).name });
+                }
+            }
+        }
+        setDiscordChannels(channels);
+
+        logEvent('startup', 'Bot started successfully');
+    } catch (err) {
+        logEvent('error', `Failed to start bot: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+        startInFlight = false;
+    }
+}
+
+export async function restartBot(): Promise<void> {
+    logEvent('info', 'Restarting bot…');
+    if (bot) {
+        bot.destroy();
+        bot = null;
+    }
+    setDiscordChannels([]);
+    await loadConfig();
+    await startBot();
+}
+
+// Recurring task checker
+setInterval(() => {
+    checkScheduledTasks();
+}, 30_000);
+
+setRestartHandler(restartBot);
+
+async function refreshChannels(): Promise<void> {
+    if (!bot) {
+        logEvent('info', 'Cannot refresh channels: bot not connected');
+        return;
+    }
+    logEvent('info', 'Refreshing Discord channels…');
+    const guilds = [...bot.getClient().guilds.cache.values()];
+    const channels: Array<{ id: string; name: string }> = [];
+    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 as { name: string }).name });
+            }
+        }
+    }
+    setDiscordChannels(channels);
+    logEvent('info', `Refreshed ${channels.length} Discord channels`);
+}
+
+setRefreshChannelsHandler(refreshChannels);
+await startBot();