windsor-bot 0.1.0

package/src/tests/config.test.ts

@@ -0,0 +1,88 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { reconcileChannels, getCurrentConfig, updateConfig, hashPassword } from '../config.ts';
+import type { ChannelMapping } from '../types.ts';
+
+// Setup: initialize config with some channel mappings
+async function withChannels(mappings: ChannelMapping[], fn: () => Promise<void>): Promise<void> {
+    const original = getCurrentConfig().channels;
+    await updateConfig({ channels: mappings });
+    try {
+        await fn();
+    } finally {
+        await updateConfig({ channels: original });
+    }
+}
+
+test('reconcileChannels: matches by ID and updates name', async () => {
+    await withChannels([
+        { channelId: '111', channelName: 'old-name', config: { type: 'on-demand' } },
+    ], async () => {
+        await reconcileChannels([{ id: '111', name: 'new-name' }]);
+        const channels = getCurrentConfig().channels;
+        assert.equal(channels.length, 1);
+        assert.equal(channels[0]?.channelName, 'new-name');
+        assert.equal(channels[0]?.channelId, '111');
+    });
+});
+
+test('reconcileChannels: matches by name and updates ID', async () => {
+    await withChannels([
+        { channelId: '111', channelName: 'my-channel', config: { type: 'on-demand' } },
+    ], async () => {
+        await reconcileChannels([{ id: '222', name: 'my-channel' }]);
+        const channels = getCurrentConfig().channels;
+        assert.equal(channels.length, 1);
+        assert.equal(channels[0]?.channelId, '222');
+        assert.equal(channels[0]?.channelName, 'my-channel');
+    });
+});
+
+test('reconcileChannels: deletes unmatched channels', async () => {
+    await withChannels([
+        { channelId: '111', channelName: 'gone-channel', config: { type: 'on-demand' } },
+    ], async () => {
+        await reconcileChannels([{ id: '999', name: 'different-channel' }]);
+        const channels = getCurrentConfig().channels;
+        assert.equal(channels.length, 0);
+    });
+});
+
+test('reconcileChannels: does NOT delete if all discord channels missing (server blip)', async () => {
+    await withChannels([
+        { channelId: '111', channelName: 'my-channel', config: { type: 'on-demand' } },
+    ], async () => {
+        await reconcileChannels([]);
+        const channels = getCurrentConfig().channels;
+        assert.equal(channels.length, 1);
+    });
+});
+
+test('hashPassword produces consistent hash', () => {
+    const hash1 = hashPassword('secret');
+    const hash2 = hashPassword('secret');
+    assert.equal(hash1, hash2);
+});
+
+test('hashPassword produces different hashes for different passwords', () => {
+    assert.notEqual(hashPassword('abc'), hashPassword('xyz'));
+});
+
+test('token usage 24h tracking', async () => {
+    // Setup with stale and recent entries
+    const now = new Date();
+    const twoHoursAgo = new Date(now.getTime() - 2 * 60 * 60 * 1000).toISOString();
+    const twoDaysAgo = new Date(now.getTime() - 48 * 60 * 60 * 1000).toISOString();
+
+    await updateConfig({
+        tokenUsage: [
+            { timestamp: twoDaysAgo, tokens: 10000 },
+            { timestamp: twoHoursAgo, tokens: 5000 },
+        ],
+    });
+
+    const { getTokenUsage24h } = await import('../ai.ts');
+    const used = getTokenUsage24h();
+    // Should only count the 2-hours-ago entry (5000), not the 2-days-ago one
+    assert.equal(used, 5000);
+});

package/src/tests/urls.test.ts

@@ -0,0 +1,64 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { extractUrls, stripUrls, replaceUrlsInText } from '../bot.ts';
+
+test('extracts a single URL', () => {
+    const urls = extractUrls('Check this out https://example.com for more info');
+    assert.deepEqual(urls, ['https://example.com']);
+});
+
+test('strips trailing punctuation from URLs', () => {
+    const urls = extractUrls('See https://example.com. For details.');
+    assert.deepEqual(urls, ['https://example.com']);
+});
+
+test('extracts multiple URLs', () => {
+    const urls = extractUrls('https://foo.com and https://bar.com are cool');
+    assert.deepEqual(urls, ['https://foo.com', 'https://bar.com']);
+});
+
+test('caps at 5 URLs', () => {
+    const text = 'https://a.com https://b.com https://c.com https://d.com https://e.com https://f.com';
+    const urls = extractUrls(text);
+    assert.equal(urls.length, 5);
+});
+
+test('ignores non-https URLs', () => {
+    const urls = extractUrls('Visit http://example.com or ftp://files.com');
+    assert.deepEqual(urls, []);
+});
+
+test('replaces single URL with [link]', () => {
+    const text = 'See https://example.com for info';
+    const urls = extractUrls(text);
+    const result = replaceUrlsInText(text, urls);
+    assert.equal(result, 'See [link] for info');
+});
+
+test('replaces multiple URLs with [link N]', () => {
+    const text = 'See https://foo.com and https://bar.com';
+    const urls = extractUrls(text);
+    const result = replaceUrlsInText(text, urls);
+    assert.ok(result.includes('[link 1]'));
+    assert.ok(result.includes('[link 2]'));
+});
+
+test('strips all URLs from text', () => {
+    const text = 'Buy this https://shop.com today!';
+    const result = stripUrls(text);
+    assert.ok(!result.includes('https://'));
+    assert.ok(result.includes('Buy this'));
+});
+
+test('message over 800 chars after URL strip is too long', () => {
+    const longText = 'A'.repeat(801);
+    const stripped = stripUrls(longText);
+    assert.ok(stripped.length > 800);
+});
+
+test('message exactly 800 chars is not too long', () => {
+    const text = 'A'.repeat(800);
+    const stripped = stripUrls(text);
+    assert.equal(stripped.length, 800);
+    assert.ok(stripped.length <= 800);
+});

package/src/types.ts

@@ -0,0 +1,120 @@
+
+export type ChannelBehaviorType = 'immediate-print' | 'accumulating-list' | 'recurring-print' | 'on-demand';
+
+export interface ImmediatePrintConfig {
+    type: 'immediate-print';
+    header?: string;
+    footer?: string;
+    includeIcon: boolean;
+    includeMetadata: boolean;
+}
+
+export interface AccumulatingListConfig {
+    type: 'accumulating-list';
+    header?: string;
+    footer?: string;
+    includeChecklist: boolean;
+    includeMetadata: boolean;
+}
+
+export interface RecurringPrintConfig {
+    type: 'recurring-print';
+    header?: string;
+    footer?: string;
+    includeIcon: boolean;
+    includeMetadata: boolean;
+}
+
+export interface OnDemandConfig {
+    type: 'on-demand';
+}
+
+export type ChannelBehaviorConfig =
+    | ImmediatePrintConfig
+    | AccumulatingListConfig
+    | RecurringPrintConfig
+    | OnDemandConfig;
+
+export interface ChannelMapping {
+    channelId: string;
+    channelName: string;
+    config: ChannelBehaviorConfig;
+}
+
+
+export interface TokenUsageEntry {
+    timestamp: string; // ISO string
+    tokens: number;
+}
+
+
+export type PrintMode = 'escp' | 'cups' | 'imagefeed';
+
+export interface EscpPrintConfig {
+    mode: 'escp';
+    serialPort: string; // e.g. /dev/ttyUSB0 or COM3
+}
+
+export interface CupsPrintConfig {
+    mode: 'cups';
+    printerName: string;
+    paperSize: string;  // e.g. "Letter", "A4"
+    paperName: string;  // human label shown on printout
+}
+
+export interface ImageFeedConfig {
+    mode: 'imagefeed';
+}
+
+export type PrintConfig = EscpPrintConfig | CupsPrintConfig | ImageFeedConfig;
+
+
+export interface WindsorConfig {
+    discordToken?: string;
+    serverId?: string;
+    openaiKey?: string;
+    diagnosticsPort: number;
+    passwordHash?: string;
+    channels: ChannelMapping[];
+    iconCacheDir?: string;
+    tokenUsage: TokenUsageEntry[];
+    printConfig?: PrintConfig;
+}
+
+
+export type DiagnosticEventType = 'startup' | 'command' | 'success' | 'error' | 'info' | 'print';
+
+export interface DiagnosticEvent {
+    timestamp: string; // ISO string
+    type: DiagnosticEventType;
+    message: string;
+}
+
+export interface BotStatus {
+    connected: boolean;
+    tag: string | null;
+    startedAt: string | null;
+    guilds: string[];
+    configuredServerId: string | null;
+}
+
+
+export interface PrintJob {
+    header?: string;
+    lines: string[];
+    iconPath?: string;
+    urls: string[];
+    footer?: string;
+    metadataLines?: string[];
+}
+
+
+export interface CommandContext {
+    channelName: string;
+    args: string;
+    rawMessage: string;
+    messageId: string;
+    channelId: string;
+    guildId: string;
+}
+