reflectt-node 0.1.0

package/dist/chat.js

@@ -0,0 +1,666 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) Reflectt AI
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { eventBus } from './events.js';
+import { DATA_DIR, LEGACY_DATA_DIR } from './config.js';
+import { CHANNEL_DEFINITIONS, DEFAULT_CHAT_CHANNELS } from './channels.js';
+import { getDb, importJsonlIfNeeded, safeJsonParse, safeJsonStringify } from './db.js';
+import { suppressionLedger } from './suppression-ledger.js';
+// OpenClaw integration pending — chat works standalone for now
+const MESSAGES_FILE = join(DATA_DIR, 'messages.jsonl');
+const LEGACY_MESSAGES_FILE = join(LEGACY_DATA_DIR, 'messages.jsonl');
+// All reads go directly to SQLite — no in-memory message cache.
+// JSONL file is kept as an append-only audit trail.
+function importMessages(db, records) {
+    const byId = new Map();
+    for (const record of records) {
+        if (!record || typeof record !== 'object')
+            continue;
+        const message = record;
+        if (typeof message.id !== 'string' || message.id.length === 0)
+            continue;
+        const deleteUpdate = Boolean(message.metadata?.deleteUpdate);
+        if (deleteUpdate) {
+            byId.delete(message.id);
+            continue;
+        }
+        if (typeof message.from !== 'string' || typeof message.content !== 'string')
+            continue;
+        byId.set(message.id, {
+            id: message.id,
+            from: message.from,
+            to: message.to,
+            content: message.content,
+            timestamp: Number(message.timestamp) || Date.now(),
+            channel: message.channel || 'general',
+            reactions: message.reactions || {},
+            threadId: message.threadId,
+            metadata: message.metadata,
+        });
+    }
+    if (byId.size === 0)
+        return 0;
+    const upsert = db.prepare(`
+    INSERT OR REPLACE INTO chat_messages (
+      id, "from", "to", content, timestamp, channel, reactions, thread_id, metadata, attachments
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertMany = db.transaction((messages) => {
+        for (const msg of messages) {
+            upsert.run(msg.id, msg.from, msg.to ?? null, msg.content, msg.timestamp, msg.channel || 'general', safeJsonStringify(msg.reactions), msg.threadId ?? null, safeJsonStringify(msg.metadata), msg.attachments?.length ? safeJsonStringify(msg.attachments) : null);
+        }
+    });
+    const messages = Array.from(byId.values());
+    insertMany(messages);
+    return messages.length;
+}
+/** Convert a SQLite row to an AgentMessage */
+function rowToMessage(row) {
+    return {
+        id: row.id,
+        from: row.from,
+        to: row.to ?? undefined,
+        content: row.content,
+        timestamp: row.timestamp,
+        channel: row.channel || 'general',
+        reactions: safeJsonParse(row.reactions) || {},
+        threadId: row.thread_id ?? undefined,
+        metadata: safeJsonParse(row.metadata),
+        ...(row.attachments ? { attachments: safeJsonParse(row.attachments) ?? undefined } : {}),
+    };
+}
+class ChatManager {
+    rooms = new Map();
+    subscribers = new Set();
+    initialized = false;
+    constructor() {
+        // OpenClaw listener disabled for now — chat works standalone
+        // TODO: re-enable when OpenClaw connection is configured
+        // openclawClient.on('message', ...)
+        // Create default rooms/channels
+        for (const channel of CHANNEL_DEFINITIONS) {
+            this.createRoom(channel.id, channel.name);
+        }
+        // Run one-time JSONL → SQLite migration
+        this.migrateJsonl().catch(err => {
+            console.error('[Chat] Failed to migrate JSONL:', err);
+        });
+    }
+    async migrateJsonl() {
+        try {
+            await fs.mkdir(DATA_DIR, { recursive: true });
+            const db = getDb();
+            importJsonlIfNeeded(db, MESSAGES_FILE, 'chat_messages', importMessages);
+            importJsonlIfNeeded(db, LEGACY_MESSAGES_FILE, 'chat_messages', importMessages);
+            // All queries now go directly to SQLite — no in-memory array.
+            const countRow = db.prepare('SELECT COUNT(*) as count FROM chat_messages').get();
+            console.log(`[Chat] SQLite has ${countRow.count} messages (all queries go to DB, no in-memory cache)`);
+        }
+        finally {
+            this.initialized = true;
+        }
+    }
+    writeMessageToDb(message) {
+        const db = getDb();
+        const meta = (message.metadata || {});
+        const dedupKey = typeof meta.dedup_key === 'string' ? meta.dedup_key : null;
+        const upsert = db.prepare(`
+      INSERT OR REPLACE INTO chat_messages (
+        id, "from", "to", content, timestamp, channel, reactions, thread_id, metadata, dedup_key, attachments
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        upsert.run(message.id, message.from, message.to ?? null, message.content, message.timestamp, message.channel || 'general', safeJsonStringify(message.reactions), message.threadId ?? null, safeJsonStringify(message.metadata), dedupKey, message.attachments?.length ? safeJsonStringify(message.attachments) : null);
+    }
+    deleteMessageFromDb(messageId) {
+        const db = getDb();
+        db.prepare('DELETE FROM chat_messages WHERE id = ?').run(messageId);
+    }
+    async appendAuditRecord(record) {
+        try {
+            await fs.mkdir(DATA_DIR, { recursive: true });
+            await fs.appendFile(MESSAGES_FILE, JSON.stringify(record) + '\n', 'utf-8');
+        }
+        catch (err) {
+            console.error('[Chat] Failed to append audit record:', err);
+        }
+    }
+    async persistMessage(message) {
+        try {
+            this.writeMessageToDb(message);
+            await this.appendAuditRecord(message);
+        }
+        catch (err) {
+            console.error('[Chat] Failed to persist message:', err);
+        }
+    }
+    createRoom(id, name) {
+        const room = {
+            id,
+            name,
+            participants: [],
+            createdAt: Date.now(),
+        };
+        this.rooms.set(id, room);
+        return room;
+    }
+    getRoom(id) {
+        return this.rooms.get(id);
+    }
+    listRooms() {
+        return Array.from(this.rooms.values());
+    }
+    // ── Noise Budget State ──
+    // Per-channel message counts in rolling windows
+    channelBudgetCounters = new Map();
+    // Duplicate suppression: hash → timestamp of last send
+    recentMessageHashes = new Map();
+    // Suppression stats tracking
+    suppressionStats = { total: 0, byCategory: new Map(), since: Date.now() };
+    // Digest batching: queued system reminders per channel
+    digestQueue = new Map();
+    digestTimers = new Map();
+    // Configurable limits
+    static CHANNEL_BUDGET_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+    static CHANNEL_BUDGET_MAX = {
+        general: 30, // max 30 messages per hour in #general
+        shipping: 20,
+        reviews: 20,
+        blockers: 15,
+        _default: 40,
+    };
+    static DEDUP_WINDOW_MS = 5 * 60 * 1000; // 5 minute dedup window (non-system)
+    static SYSTEM_DEDUP_WINDOW_MS = 30 * 60 * 1000; // 30 minute dedup window (system messages)
+    static DIGEST_BATCH_DELAY_MS = 30 * 1000; // 30s digest batching window
+    static SYSTEM_REMINDER_PATTERNS = [
+        /^⚠️ Working contract warning/,
+        /^⚠️ \[Product Enforcement\]/,
+        /^🔄.*Auto-requeued/,
+        /^⚠️ SLA breach/,
+        /^⚠️ Ready-queue floor/,
+        /^🪞 Reflection nudge/,
+        /^\[SHIP\]/,
+        /^🚨 CRITICAL/,
+        /^✅ Auto-closed/,
+    ];
+    /**
+     * Check if message is within per-channel budget
+     */
+    checkChannelBudget(channel) {
+        const now = Date.now();
+        const counter = this.channelBudgetCounters.get(channel);
+        const maxBudget = ChatManager.CHANNEL_BUDGET_MAX[channel] ?? ChatManager.CHANNEL_BUDGET_MAX._default;
+        if (!counter || now - counter.windowStart > ChatManager.CHANNEL_BUDGET_WINDOW_MS) {
+            // New window
+            this.channelBudgetCounters.set(channel, { count: 1, windowStart: now });
+            return { allowed: true };
+        }
+        if (counter.count >= maxBudget) {
+            return { allowed: false, reason: `Channel #${channel} budget exceeded (${counter.count}/${maxBudget} per hour)` };
+        }
+        counter.count++;
+        return { allowed: true };
+    }
+    /**
+     * Check for duplicate messages within suppression window.
+     * System messages use a 30-minute window; others use 5 minutes.
+     * Callers can pass an explicit dedup_key in metadata to control dedup grouping.
+     */
+    checkDuplicate(from, channel, content, dedupKey) {
+        const now = Date.now();
+        const isSystem = from === 'system';
+        const windowMs = isSystem ? ChatManager.SYSTEM_DEDUP_WINDOW_MS : ChatManager.DEDUP_WINDOW_MS;
+        // Clean expired entries (use the longer window to avoid premature cleanup)
+        const maxWindow = ChatManager.SYSTEM_DEDUP_WINDOW_MS;
+        for (const [key, ts] of this.recentMessageHashes) {
+            if (now - ts > maxWindow)
+                this.recentMessageHashes.delete(key);
+        }
+        // Hash: explicit dedup_key if provided, otherwise from + channel + normalized content
+        let hash;
+        if (dedupKey) {
+            hash = `dedup:${channel}:${dedupKey}`;
+        }
+        else {
+            // Normalize: strip timestamps, task IDs, agent-specific names, counts
+            const normalized = content
+                .replace(/\d{10,}/g, '') // strip epoch timestamps
+                .replace(/task-\S+/g, 'TASK') // normalize task IDs
+                .replace(/@\w+/g, '@AGENT') // normalize @mentions
+                .replace(/\d+\/\d+/g, 'N/M') // normalize counts like "0/2"
+                .replace(/\(need \d+ more\)/g, '') // normalize "need N more"
+                .trim().slice(0, 200);
+            hash = `${from}:${channel}:${normalized}`;
+        }
+        const lastSent = this.recentMessageHashes.get(hash);
+        if (lastSent && (now - lastSent) < windowMs) {
+            // Track suppression stats
+            this.suppressionStats.total++;
+            const category = isSystem ? 'system' : from;
+            this.suppressionStats.byCategory.set(category, (this.suppressionStats.byCategory.get(category) || 0) + 1);
+            return true; // duplicate
+        }
+        this.recentMessageHashes.set(hash, now);
+        return false;
+    }
+    /**
+     * Get suppression statistics
+     */
+    getSuppressionStats() {
+        return {
+            total: this.suppressionStats.total,
+            byCategory: Object.fromEntries(this.suppressionStats.byCategory),
+            since: this.suppressionStats.since,
+            activeHashes: this.recentMessageHashes.size,
+        };
+    }
+    /**
+     * Check if message is a system reminder eligible for digest batching
+     */
+    isSystemReminder(content) {
+        return ChatManager.SYSTEM_REMINDER_PATTERNS.some(p => p.test(content));
+    }
+    /**
+     * Queue a system reminder for digest batching
+     * Returns true if queued (caller should skip sending), false if digest should flush now
+     */
+    queueForDigest(channel, from, content) {
+        const queue = this.digestQueue.get(channel) || [];
+        queue.push({ content, from, queuedAt: Date.now() });
+        this.digestQueue.set(channel, queue);
+        // If timer already running, just add to queue
+        if (this.digestTimers.has(channel))
+            return true;
+        // Start digest timer
+        const timer = setTimeout(() => {
+            this.flushDigest(channel);
+            this.digestTimers.delete(channel);
+        }, ChatManager.DIGEST_BATCH_DELAY_MS);
+        timer.unref();
+        this.digestTimers.set(channel, timer);
+        return true;
+    }
+    /**
+     * Flush queued digest messages into a single batched message
+     */
+    flushDigest(channel) {
+        const queue = this.digestQueue.get(channel);
+        if (!queue || queue.length === 0)
+            return;
+        this.digestQueue.delete(channel);
+        if (queue.length === 1) {
+            // Single message — send as-is
+            void this.sendMessage({ from: queue[0].from, channel, content: queue[0].content });
+            return;
+        }
+        // Batch multiple reminders into a single digest
+        const summary = `📋 **System digest** (${queue.length} reminders):\n` +
+            queue.map((q, i) => `${i + 1}. ${q.content.split('\n')[0].slice(0, 120)}`).join('\n');
+        void this.sendMessage({
+            from: 'system',
+            channel,
+            content: summary,
+            metadata: { digest: true, batchedCount: queue.length },
+        });
+    }
+    async sendMessage(message) {
+        const channel = message.channel || 'general';
+        // ── Noise Budget Checks ──
+        // Skip budget checks for direct messages (has `to` field) and metadata.bypass_budget
+        const bypassBudget = message.metadata?.bypass_budget === true || message.to;
+        if (!bypassBudget) {
+            // 1. Duplicate suppression (supports explicit dedup_key from metadata)
+            const dedupKey = message.metadata?.dedup_key;
+            if (this.checkDuplicate(message.from, channel, message.content, dedupKey)) {
+                console.log(`[Chat/NoiseBudget] Suppressed duplicate from ${message.from} in #${channel}`);
+                // Return a synthetic message so callers don't break
+                return {
+                    ...message,
+                    id: `msg-${Date.now()}-suppressed`,
+                    timestamp: Date.now(),
+                    channel,
+                    reactions: {},
+                };
+            }
+            // 2. System reminder digest batching
+            if (this.isSystemReminder(message.content)) {
+                if (this.queueForDigest(channel, message.from, message.content)) {
+                    console.log(`[Chat/NoiseBudget] Queued system reminder for digest in #${channel}`);
+                    return {
+                        ...message,
+                        id: `msg-${Date.now()}-queued`,
+                        timestamp: Date.now(),
+                        channel,
+                        reactions: {},
+                    };
+                }
+            }
+            // 3. Per-channel budget — DISABLED
+            // Was silently dropping messages after 30/hr with a fake success response.
+            // Dedup + watchdog are sufficient noise controls.
+            // const budget = this.checkChannelBudget(channel)
+            // if (!budget.allowed) { ... }
+        }
+        // ── Persistent suppression ledger (dedup_key) ──
+        // For system/automated messages, compute a dedup_key and check the persistent ledger
+        const msgMeta = (message.metadata || {});
+        const category = typeof msgMeta.category === 'string' ? msgMeta.category : 'general';
+        const isSystemSource = message.from === 'system'
+            || typeof msgMeta.category === 'string'
+            || msgMeta.digest === true;
+        let dedupKey;
+        if (isSystemSource && !bypassBudget) {
+            const check = suppressionLedger.check({
+                category,
+                channel,
+                from: message.from,
+                content: message.content,
+            });
+            dedupKey = check.dedup_key;
+            if (check.isDuplicate) {
+                console.log(`[Chat/SuppressionLedger] Suppressed duplicate (key=${dedupKey}) from ${message.from} in #${channel}`);
+                return {
+                    ...message,
+                    id: `msg-${Date.now()}-ledger-suppressed`,
+                    timestamp: Date.now(),
+                    channel,
+                    reactions: {},
+                    metadata: { ...msgMeta, dedup_key: dedupKey, suppressed: true },
+                };
+            }
+        }
+        const fullMessage = {
+            ...message,
+            id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            channel,
+            reactions: message.reactions || {},
+            threadId: message.threadId,
+            metadata: dedupKey ? { ...msgMeta, dedup_key: dedupKey } : message.metadata,
+        };
+        // Persist to SQLite + JSONL audit
+        await this.persistMessage(fullMessage);
+        // Notify local subscribers
+        this.notifySubscribers(fullMessage);
+        // Emit event to event bus
+        eventBus.emitMessagePosted(fullMessage);
+        // Route to agent inboxes (auto-routing)
+        this.routeToInboxes(fullMessage);
+        // TODO: Send via OpenClaw when connected
+        return fullMessage;
+    }
+    /**
+     * Route message to agent inboxes
+     * This is called automatically when a message is posted
+     */
+    routeToInboxes(message) {
+        // Import here to avoid circular dependency at module level
+        import('./inbox.js')
+            .then(({ inboxManager }) => {
+            const agents = this.getKnownAgents();
+            inboxManager.routeMessage(message, agents);
+        })
+            .catch(err => {
+            console.error('[Chat] Failed to route message to inboxes:', err);
+        });
+    }
+    /**
+     * Get list of all known agents from SQLite.
+     */
+    getKnownAgents() {
+        const db = getDb();
+        const rows = db.prepare(`
+      SELECT DISTINCT "from" as agent FROM chat_messages
+      UNION
+      SELECT DISTINCT "to" as agent FROM chat_messages WHERE "to" IS NOT NULL
+    `).all();
+        return rows.map(r => r.agent).filter((v) => Boolean(v));
+    }
+    handleIncomingMessage(message) {
+        // Persist to DB (INSERT OR REPLACE handles dedup)
+        this.writeMessageToDb(message);
+        this.notifySubscribers(message);
+    }
+    hydrateRows(rows) {
+        return rows.map((row) => ({
+            id: row.id,
+            from: row.from,
+            to: row.to ?? undefined,
+            content: row.content,
+            timestamp: row.timestamp,
+            channel: row.channel || 'general',
+            reactions: safeJsonParse(row.reactions) || {},
+            threadId: row.thread_id ?? undefined,
+            metadata: safeJsonParse(row.metadata),
+        }));
+    }
+    getMessages(options) {
+        const db = getDb();
+        const conditions = [];
+        const params = [];
+        if (options?.from) {
+            conditions.push('"from" = ?');
+            params.push(options.from);
+        }
+        if (options?.excludeFrom) {
+            conditions.push('"from" != ?');
+            params.push(options.excludeFrom);
+        }
+        if (options?.to) {
+            conditions.push('"to" = ?');
+            params.push(options.to);
+        }
+        if (options?.channel) {
+            conditions.push('channel = ?');
+            params.push(options.channel);
+        }
+        if (options?.since) {
+            conditions.push('timestamp >= ?');
+            params.push(options.since);
+        }
+        if (options?.before) {
+            conditions.push('timestamp < ?');
+            params.push(options.before);
+        }
+        if (options?.after) {
+            conditions.push('timestamp > ?');
+            params.push(options.after);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = options?.limit !== undefined ? options.limit : 20;
+        // Fetch newest-first for efficiency, then return ascending.
+        const sql = limit > 0
+            ? `SELECT * FROM (SELECT * FROM chat_messages ${where} ORDER BY timestamp DESC LIMIT ?) ORDER BY timestamp ASC`
+            : `SELECT * FROM chat_messages ${where} ORDER BY timestamp ASC`;
+        if (limit > 0)
+            params.push(limit);
+        const rows = db.prepare(sql).all(...params);
+        const messages = rows.map(rowToMessage);
+        return this.addReplyCounts(messages);
+    }
+    addReplyCounts(messages) {
+        if (messages.length === 0)
+            return messages;
+        const db = getDb();
+        const ids = messages.map(m => m.id);
+        // Build `IN (?, ?, ...)` safely.
+        const placeholders = ids.map(() => '?').join(',');
+        const rows = db.prepare(`
+      SELECT thread_id as id, COUNT(*) as c
+      FROM chat_messages
+      WHERE thread_id IN (${placeholders})
+      GROUP BY thread_id
+    `).all(...ids);
+        const map = new Map(rows.map(r => [r.id, r.c]));
+        return messages.map(m => ({ ...m, replyCount: map.get(m.id) ?? 0 }));
+    }
+    getThread(messageId) {
+        const db = getDb();
+        const parentRow = db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(messageId);
+        if (!parentRow)
+            return null;
+        const parent = rowToMessage(parentRow);
+        const replyRows = db.prepare('SELECT * FROM chat_messages WHERE thread_id = ? ORDER BY timestamp ASC').all(messageId);
+        const replies = replyRows.map(rowToMessage);
+        return this.addReplyCounts([parent, ...replies]);
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+    }
+    notifySubscribers(message) {
+        this.subscribers.forEach(callback => {
+            try {
+                callback(message);
+            }
+            catch (err) {
+                console.error('[Chat] Subscriber error:', err);
+            }
+        });
+    }
+    getChannels() {
+        const db = getDb();
+        const rows = db.prepare(`
+      SELECT COALESCE(channel, 'general') as channel, COUNT(*) as count, MAX(timestamp) as lastActivity
+      FROM chat_messages
+      GROUP BY COALESCE(channel, 'general')
+      ORDER BY lastActivity DESC
+    `).all();
+        // Include default channels even if empty
+        const channelMap = new Map();
+        DEFAULT_CHAT_CHANNELS.forEach(ch => channelMap.set(ch, { count: 0, lastActivity: 0 }));
+        for (const row of rows) {
+            channelMap.set(row.channel, { count: row.count, lastActivity: row.lastActivity });
+        }
+        return Array.from(channelMap.entries())
+            .map(([channel, data]) => ({ channel, ...data }))
+            .sort((a, b) => b.lastActivity - a.lastActivity);
+    }
+    async addReaction(messageId, emoji, from) {
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(messageId);
+        if (!row)
+            return null;
+        const message = rowToMessage(row);
+        // Initialize reactions if needed
+        if (!message.reactions)
+            message.reactions = {};
+        if (!message.reactions[emoji])
+            message.reactions[emoji] = [];
+        const agents = message.reactions[emoji];
+        const index = agents.indexOf(from);
+        if (index >= 0) {
+            agents.splice(index, 1);
+            if (agents.length === 0)
+                delete message.reactions[emoji];
+        }
+        else {
+            agents.push(from);
+        }
+        this.writeMessageToDb(message);
+        await this.appendAuditRecord(message);
+        this.notifySubscribers(message);
+        eventBus.emit({
+            id: `evt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            type: 'message_posted',
+            timestamp: Date.now(),
+            data: { ...message, reactionUpdate: true },
+        });
+        return message;
+    }
+    getReactions(messageId) {
+        const db = getDb();
+        const row = db.prepare('SELECT reactions FROM chat_messages WHERE id = ?').get(messageId);
+        if (!row)
+            return null;
+        return safeJsonParse(row.reactions) || {};
+    }
+    async editMessage(messageId, editor, content) {
+        const trimmed = content.trim();
+        if (!trimmed)
+            return { ok: false, error: 'invalid_content' };
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(messageId);
+        if (!row) {
+            return { ok: false, error: 'not_found' };
+        }
+        const message = rowToMessage(row);
+        if (message.from !== editor) {
+            return { ok: false, error: 'forbidden' };
+        }
+        message.content = trimmed;
+        message.metadata = {
+            ...(message.metadata || {}),
+            editedAt: Date.now(),
+            editedBy: editor,
+        };
+        this.writeMessageToDb(message);
+        await this.appendAuditRecord(message);
+        // No in-memory cache to update.
+        this.notifySubscribers(message);
+        eventBus.emit({
+            id: `evt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            type: 'message_posted',
+            timestamp: Date.now(),
+            data: { ...message, editUpdate: true },
+        });
+        return { ok: true, message };
+    }
+    async deleteMessage(messageId, actor) {
+        const db = getDb();
+        const row = db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(messageId);
+        if (!row) {
+            return { ok: false, error: 'not_found' };
+        }
+        const message = rowToMessage(row);
+        if (message.from !== actor) {
+            return { ok: false, error: 'forbidden' };
+        }
+        this.deleteMessageFromDb(messageId);
+        await this.appendAuditRecord({
+            id: messageId,
+            from: actor,
+            content: '',
+            timestamp: Date.now(),
+            channel: message.channel || 'general',
+            metadata: {
+                deleteUpdate: true,
+                deletedBy: actor,
+            },
+        });
+        eventBus.emit({
+            id: `evt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            type: 'message_posted',
+            timestamp: Date.now(),
+            data: { id: messageId, deleteUpdate: true },
+        });
+        return { ok: true };
+    }
+    search(query, options) {
+        const db = getDb();
+        const likePattern = `%${query}%`;
+        const limit = options?.limit ?? 50;
+        const rows = db.prepare(`
+      SELECT * FROM chat_messages
+      WHERE content LIKE ? COLLATE NOCASE
+         OR "from" LIKE ? COLLATE NOCASE
+         OR channel LIKE ? COLLATE NOCASE
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(likePattern, likePattern, likePattern, limit);
+        // Return in chronological order
+        return rows.map(rowToMessage).reverse();
+    }
+    getStats() {
+        const db = getDb();
+        const totalRow = db.prepare('SELECT COUNT(*) as count FROM chat_messages').get();
+        return {
+            totalMessages: totalRow?.count ?? 0,
+            rooms: this.rooms.size,
+            subscribers: this.subscribers.size,
+            initialized: this.initialized,
+        };
+    }
+}
+export const chatManager = new ChatManager();
+//# sourceMappingURL=chat.js.map