libre-webui 0.24.1 → 0.26.0

package/backend/dist/persistence/sqliteResourceRepositories.js

@@ -172,101 +172,1481 @@ class SQLiteKnowledgeCollectionRepository {
             .prepare('SELECT * FROM knowledge_collections WHERE user_id = ? ORDER BY name COLLATE NOCASE ASC')
             .all(userId);
     }
+    async findById(collectionId) {
+        return (this.database
+            .prepare('SELECT * FROM knowledge_collections WHERE id = ?')
+            .get(collectionId) ?? null);
+    }
     async replace(collection) {
         ensureSameOwner(this.database, 'knowledge_collections', collection.id, collection.user_id);
         this.database
-            .prepare(`INSERT INTO knowledge_collections
-           (id, user_id, name, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET
-           name = excluded.name,
-           updated_at = excluded.updated_at
-         WHERE knowledge_collections.user_id = excluded.user_id`)
-            .run(collection.id, collection.user_id, collection.name, collection.created_at, collection.updated_at);
+            .prepare(`INSERT INTO knowledge_collections
+           (id, user_id, name, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           updated_at = excluded.updated_at
+         WHERE knowledge_collections.user_id = excluded.user_id`)
+            .run(collection.id, collection.user_id, collection.name, collection.created_at, collection.updated_at);
+    }
+    async deleteAndDetach(collectionId, userId) {
+        const remove = this.database.transaction(() => {
+            this.database
+                .prepare('UPDATE documents SET collection_id = NULL WHERE collection_id = ? AND user_id = ?')
+                .run(collectionId, userId);
+            return this.database
+                .prepare('DELETE FROM knowledge_collections WHERE id = ? AND user_id = ?')
+                .run(collectionId, userId).changes;
+        });
+        return remove() > 0;
+    }
+}
+class SQLiteNoteRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM notes
+         WHERE user_id = ?
+         ORDER BY pinned DESC, updated_at DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async findByOwner(noteId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM notes WHERE id = ? AND user_id = ?')
+            .get(noteId, userId) ?? null);
+    }
+    async replaceWithLimit(note, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'notes', note.id, note.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM notes WHERE user_id = ?')
+                    .get(note.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('note', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO notes
+             (id, user_id, title, content, pinned, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             title = excluded.title,
+             content = excluded.content,
+             pinned = excluded.pinned,
+             updated_at = excluded.updated_at
+           WHERE notes.user_id = excluded.user_id`)
+                .run(note.id, note.user_id, note.title, note.content, note.pinned, note.created_at, note.updated_at);
+        });
+        replace();
+    }
+    async patchByOwner(noteId, userId, patch) {
+        const update = this.database.transaction(() => {
+            const assignments = [];
+            const values = [];
+            if (patch.title !== undefined) {
+                assignments.push('title = ?');
+                values.push(patch.title);
+            }
+            if (patch.content !== undefined) {
+                assignments.push('content = ?');
+                values.push(patch.content);
+            }
+            if (patch.pinned !== undefined) {
+                assignments.push('pinned = ?');
+                values.push(patch.pinned);
+            }
+            assignments.push('updated_at = ?');
+            values.push(patch.updated_at);
+            const result = this.database
+                .prepare(`UPDATE notes SET ${assignments.join(', ')}
+            WHERE id = ? AND user_id = ?`)
+                .run(...values, noteId, userId);
+            if (result.changes !== 1)
+                return null;
+            return this.database
+                .prepare('SELECT * FROM notes WHERE id = ? AND user_id = ?')
+                .get(noteId, userId);
+        });
+        return update.immediate();
+    }
+    async deleteByOwner(noteId, userId) {
+        return (this.database
+            .prepare('DELETE FROM notes WHERE id = ? AND user_id = ?')
+            .run(noteId, userId).changes > 0);
+    }
+    async findById(noteId) {
+        return (this.database.prepare('SELECT * FROM notes WHERE id = ?').get(noteId) ?? null);
+    }
+    async patchById(noteId, patch) {
+        const update = this.database.transaction(() => {
+            const assignments = [];
+            const values = [];
+            if (patch.title !== undefined) {
+                assignments.push('title = ?');
+                values.push(patch.title);
+            }
+            if (patch.content !== undefined) {
+                assignments.push('content = ?');
+                values.push(patch.content);
+            }
+            if (patch.pinned !== undefined) {
+                assignments.push('pinned = ?');
+                values.push(patch.pinned);
+            }
+            assignments.push('updated_at = ?');
+            values.push(patch.updated_at);
+            const result = this.database
+                .prepare(`UPDATE notes SET ${assignments.join(', ')} WHERE id = ?`)
+                .run(...values, noteId);
+            if (result.changes !== 1)
+                return null;
+            return this.database
+                .prepare('SELECT * FROM notes WHERE id = ?')
+                .get(noteId);
+        });
+        return update.immediate();
+    }
+    async listRevisions(noteId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM note_revisions
+         WHERE note_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(noteId, maximum);
+    }
+    async findRevision(revisionId) {
+        return (this.database
+            .prepare('SELECT * FROM note_revisions WHERE id = ?')
+            .get(revisionId) ?? null);
+    }
+    async insertRevision(revision, maximum) {
+        const insert = this.database.transaction(() => {
+            // Strictly increasing per note so same-millisecond snapshots keep a
+            // deterministic order for listing, restore, and pruning.
+            const latest = this.database
+                .prepare('SELECT COALESCE(MAX(created_at), 0) AS latest FROM note_revisions WHERE note_id = ?')
+                .get(revision.note_id);
+            const createdAt = Math.max(revision.created_at, latest.latest + 1);
+            this.database
+                .prepare(`INSERT INTO note_revisions
+             (id, note_id, title, content, created_at)
+           VALUES (?, ?, ?, ?, ?)`)
+                .run(revision.id, revision.note_id, revision.title, revision.content, createdAt);
+            this.database
+                .prepare(`DELETE FROM note_revisions
+            WHERE note_id = ?
+              AND id NOT IN (
+                SELECT id FROM note_revisions
+                 WHERE note_id = ?
+                 ORDER BY created_at DESC, id DESC
+                 LIMIT ?
+              )`)
+                .run(revision.note_id, revision.note_id, maximum);
+        });
+        insert();
+    }
+    async listAttachments(noteId) {
+        return this.database
+            .prepare(`SELECT * FROM note_attachments
+         WHERE note_id = ?
+         ORDER BY created_at ASC, id ASC`)
+            .all(noteId);
+    }
+    async findAttachment(attachmentId) {
+        return (this.database
+            .prepare('SELECT * FROM note_attachments WHERE id = ?')
+            .get(attachmentId) ?? null);
+    }
+    async insertAttachmentWithLimit(attachment, maximum) {
+        const insert = this.database.transaction(() => {
+            const row = this.database
+                .prepare('SELECT COUNT(*) AS count FROM note_attachments WHERE note_id = ?')
+                .get(attachment.note_id);
+            if (row.count >= maximum) {
+                throw new PersistenceResourceLimitError('note-attachment', maximum);
+            }
+            this.database
+                .prepare(`INSERT INTO note_attachments
+             (id, note_id, blob_id, filename, content_type, size, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .run(attachment.id, attachment.note_id, attachment.blob_id, attachment.filename, attachment.content_type, attachment.size, attachment.created_at);
+        });
+        insert();
+    }
+    async deleteAttachment(attachmentId) {
+        return (this.database
+            .prepare('DELETE FROM note_attachments WHERE id = ?')
+            .run(attachmentId).changes > 0);
+    }
+}
+class SQLiteCalendarEventRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwnerBetween(userId, from, to, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM calendar_events
+         WHERE user_id = ? AND start_at >= ? AND start_at < ?
+         ORDER BY start_at ASC
+         LIMIT ?`)
+            .all(userId, from, to, maximum);
+    }
+    async listRecurringByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM calendar_events
+         WHERE user_id = ? AND recurrence IS NOT NULL
+         ORDER BY start_at ASC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async listByCalendarsBetween(calendarIds, from, to, maximum) {
+        if (calendarIds.length === 0)
+            return [];
+        const placeholders = calendarIds.map(() => '?').join(', ');
+        return this.database
+            .prepare(`SELECT * FROM calendar_events
+         WHERE calendar_id IN (${placeholders})
+           AND start_at >= ? AND start_at < ?
+         ORDER BY start_at ASC
+         LIMIT ?`)
+            .all(...calendarIds, from, to, maximum);
+    }
+    async listRecurringByCalendars(calendarIds, maximum) {
+        if (calendarIds.length === 0)
+            return [];
+        const placeholders = calendarIds.map(() => '?').join(', ');
+        return this.database
+            .prepare(`SELECT * FROM calendar_events
+         WHERE calendar_id IN (${placeholders})
+           AND recurrence IS NOT NULL
+         ORDER BY start_at ASC
+         LIMIT ?`)
+            .all(...calendarIds, maximum);
+    }
+    async findByOwner(eventId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM calendar_events WHERE id = ? AND user_id = ?')
+            .get(eventId, userId) ?? null);
+    }
+    async findById(eventId) {
+        return (this.database
+            .prepare('SELECT * FROM calendar_events WHERE id = ?')
+            .get(eventId) ?? null);
+    }
+    async listWithReminders(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM calendar_events
+         WHERE reminder_minutes IS NOT NULL
+         ORDER BY start_at ASC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async markReminded(eventId, occurrenceStart) {
+        return (this.database
+            .prepare(`UPDATE calendar_events
+           SET last_reminded_occurrence = ?
+           WHERE id = ?
+             AND (last_reminded_occurrence IS NULL
+               OR last_reminded_occurrence < ?)`)
+            .run(occurrenceStart, eventId, occurrenceStart).changes > 0);
+    }
+    async replaceWithLimit(event, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'calendar_events', event.id, event.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM calendar_events WHERE user_id = ?')
+                    .get(event.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('calendar-event', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO calendar_events
+             (id, user_id, title, notes, start_at, end_at, all_day,
+              recurrence, calendar_id, reminder_minutes,
+              last_reminded_occurrence, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             title = excluded.title,
+             notes = excluded.notes,
+             start_at = excluded.start_at,
+             end_at = excluded.end_at,
+             all_day = excluded.all_day,
+             recurrence = excluded.recurrence,
+             calendar_id = excluded.calendar_id,
+             reminder_minutes = excluded.reminder_minutes,
+             last_reminded_occurrence = excluded.last_reminded_occurrence,
+             updated_at = excluded.updated_at
+           WHERE calendar_events.user_id = excluded.user_id`)
+                .run(event.id, event.user_id, event.title, event.notes, event.start_at, event.end_at, event.all_day, event.recurrence, event.calendar_id, event.reminder_minutes, event.last_reminded_occurrence, event.created_at, event.updated_at);
+        });
+        replace();
+    }
+    async deleteByOwner(eventId, userId) {
+        return (this.database
+            .prepare('DELETE FROM calendar_events WHERE id = ? AND user_id = ?')
+            .run(eventId, userId).changes > 0);
+    }
+}
+class SQLiteCalendarRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM calendars
+         WHERE user_id = ?
+         ORDER BY created_at ASC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async findByOwner(calendarId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM calendars WHERE id = ? AND user_id = ?')
+            .get(calendarId, userId) ?? null);
+    }
+    async findById(calendarId) {
+        return (this.database
+            .prepare('SELECT * FROM calendars WHERE id = ?')
+            .get(calendarId) ?? null);
+    }
+    async replaceWithLimit(calendar, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'calendars', calendar.id, calendar.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM calendars WHERE user_id = ?')
+                    .get(calendar.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('calendar', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO calendars
+             (id, user_id, name, color, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             color = excluded.color,
+             updated_at = excluded.updated_at
+           WHERE calendars.user_id = excluded.user_id`)
+                .run(calendar.id, calendar.user_id, calendar.name, calendar.color, calendar.created_at, calendar.updated_at);
+        });
+        replace();
+    }
+    async deleteAndDetach(calendarId, userId) {
+        const remove = this.database.transaction(() => {
+            const deleted = this.database
+                .prepare('DELETE FROM calendars WHERE id = ? AND user_id = ?')
+                .run(calendarId, userId).changes > 0;
+            if (deleted) {
+                this.database
+                    .prepare(`UPDATE calendar_events
+             SET calendar_id = NULL
+             WHERE calendar_id = ? AND user_id = ?`)
+                    .run(calendarId, userId);
+            }
+            return deleted;
+        });
+        return remove();
+    }
+}
+class SQLiteChannelRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertWithOwner(channel, owner, maximumPerUser) {
+        const insert = this.database.transaction(() => {
+            const count = this.database
+                .prepare(`SELECT COUNT(*) AS count
+           FROM channels
+           WHERE created_by = ?`)
+                .get(owner.user_id);
+            if (count.count >= maximumPerUser) {
+                throw new PersistenceResourceLimitError('channel', maximumPerUser);
+            }
+            this.database
+                .prepare(`INSERT INTO channels
+             (id, type, name, description, dm_key, created_by,
+              created_at, updated_at, archived_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(channel.id, channel.type, channel.name, channel.description, channel.dm_key, channel.created_by, channel.created_at, channel.updated_at, channel.archived_at);
+            this.database
+                .prepare(`INSERT INTO channel_members
+             (channel_id, user_id, role, joined_at, last_read_at)
+           VALUES (?, ?, ?, ?, ?)`)
+                .run(owner.channel_id, owner.user_id, owner.role, owner.joined_at, owner.last_read_at);
+        });
+        insert();
+    }
+    async findById(channelId) {
+        return (this.database
+            .prepare('SELECT * FROM channels WHERE id = ?')
+            .get(channelId) ?? null);
+    }
+    async findByDmKey(dmKey) {
+        return (this.database
+            .prepare('SELECT * FROM channels WHERE dm_key = ?')
+            .get(dmKey) ?? null);
+    }
+    async listForUser(userId, maximum) {
+        const rows = this.database
+            .prepare(`SELECT
+           c.id, c.type, c.name, c.description, c.dm_key, c.created_by,
+           c.created_at, c.updated_at, c.archived_at,
+           m.channel_id AS member_channel_id, m.user_id AS member_user_id,
+           m.role AS member_role, m.joined_at AS member_joined_at,
+           m.last_read_at AS member_last_read_at
+         FROM channel_members m
+         JOIN channels c ON c.id = m.channel_id
+         WHERE m.user_id = ?
+         ORDER BY c.updated_at DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+        return rows.map(row => ({
+            channel: {
+                id: row.id,
+                type: row.type,
+                name: row.name,
+                description: row.description,
+                dm_key: row.dm_key,
+                created_by: row.created_by,
+                created_at: row.created_at,
+                updated_at: row.updated_at,
+                archived_at: row.archived_at,
+            },
+            member: {
+                channel_id: row.member_channel_id,
+                user_id: row.member_user_id,
+                role: row.member_role,
+                joined_at: row.member_joined_at,
+                last_read_at: row.member_last_read_at,
+            },
+        }));
+    }
+    async listPublic(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM channels
+         WHERE type = 'public' AND archived_at IS NULL
+         ORDER BY updated_at DESC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async update(channel) {
+        this.database
+            .prepare(`UPDATE channels SET
+           name = ?,
+           description = ?,
+           updated_at = ?,
+           archived_at = ?
+         WHERE id = ?`)
+            .run(channel.name, channel.description, channel.updated_at, channel.archived_at, channel.id);
+    }
+    async delete(channelId) {
+        return (this.database.prepare('DELETE FROM channels WHERE id = ?').run(channelId)
+            .changes > 0);
+    }
+    async upsertMember(member, maximumMembers) {
+        const upsert = this.database.transaction(() => {
+            const existing = this.database
+                .prepare('SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?')
+                .get(member.channel_id, member.user_id);
+            if (!existing) {
+                const count = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM channel_members WHERE channel_id = ?')
+                    .get(member.channel_id);
+                if (count.count >= maximumMembers) {
+                    throw new PersistenceResourceLimitError('channel-member', maximumMembers);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO channel_members
+             (channel_id, user_id, role, joined_at, last_read_at)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(channel_id, user_id) DO UPDATE SET
+             role = excluded.role`)
+                .run(member.channel_id, member.user_id, member.role, member.joined_at, member.last_read_at);
+        });
+        upsert();
+    }
+    async findMember(channelId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?')
+            .get(channelId, userId) ??
+            null);
+    }
+    async listMembers(channelId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM channel_members
+         WHERE channel_id = ?
+         ORDER BY joined_at ASC
+         LIMIT ?`)
+            .all(channelId, maximum);
+    }
+    async removeMember(channelId, userId) {
+        return (this.database
+            .prepare('DELETE FROM channel_members WHERE channel_id = ? AND user_id = ?')
+            .run(channelId, userId).changes > 0);
+    }
+    async advanceLastRead(channelId, userId, lastReadAt) {
+        return (this.database
+            .prepare(`UPDATE channel_members
+           SET last_read_at = ?
+           WHERE channel_id = ? AND user_id = ? AND last_read_at < ?`)
+            .run(lastReadAt, channelId, userId, lastReadAt).changes > 0);
+    }
+    async unreadSummaryForUser(userId) {
+        return this.database
+            .prepare(`SELECT
+           m.channel_id,
+           COUNT(msg.id) AS unread_count,
+           MAX(msg.created_at) AS latest_message_at
+         FROM channel_members m
+         LEFT JOIN channel_messages msg
+           ON msg.channel_id = m.channel_id
+          AND msg.created_at > m.last_read_at
+          AND msg.deleted_at IS NULL
+          AND (msg.user_id IS NULL OR msg.user_id != m.user_id
+               OR msg.author_kind != 'user')
+         WHERE m.user_id = ?
+         GROUP BY m.channel_id`)
+            .all(userId);
+    }
+}
+class SQLiteChannelMessageRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    insertMessageRow(message) {
+        this.database
+            .prepare(`INSERT INTO channel_messages
+           (id, channel_id, user_id, parent_id, author_kind, model, content,
+            metadata, created_at, updated_at, edited_at, deleted_at,
+            pinned_at, pinned_by)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(message.id, message.channel_id, message.user_id, message.parent_id, message.author_kind, message.model, message.content, message.metadata, message.created_at, message.updated_at, message.edited_at, message.deleted_at, message.pinned_at, message.pinned_by);
+    }
+    async insertIfAbsent(message, attachments, maximumPerChannel) {
+        const insert = this.database.transaction(() => {
+            const existing = this.database
+                .prepare('SELECT * FROM channel_messages WHERE id = ?')
+                .get(message.id);
+            if (existing) {
+                return { stored: existing, inserted: false };
+            }
+            const count = this.database
+                .prepare('SELECT COUNT(*) AS count FROM channel_messages WHERE channel_id = ?')
+                .get(message.channel_id);
+            if (count.count >= maximumPerChannel) {
+                throw new PersistenceResourceLimitError('channel-message', maximumPerChannel);
+            }
+            this.insertMessageRow(message);
+            const insertAttachment = this.database.prepare(`INSERT INTO channel_attachments
+           (id, message_id, channel_id, blob_id, filename, content_type,
+            size, created_by, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            for (const attachment of attachments) {
+                if (attachment.message_id !== message.id) {
+                    throw new Error('A channel attachment does not belong to its message');
+                }
+                insertAttachment.run(attachment.id, attachment.message_id, attachment.channel_id, attachment.blob_id, attachment.filename, attachment.content_type, attachment.size, attachment.created_by, attachment.created_at);
+            }
+            this.database
+                .prepare('UPDATE channels SET updated_at = ? WHERE id = ?')
+                .run(message.created_at, message.channel_id);
+            return { stored: message, inserted: true };
+        });
+        return insert();
+    }
+    async findById(messageId) {
+        return (this.database
+            .prepare('SELECT * FROM channel_messages WHERE id = ?')
+            .get(messageId) ?? null);
+    }
+    async listPage(channelId, options) {
+        const clauses = ['channel_id = ?'];
+        const parameters = [channelId];
+        if (options.parentId === null) {
+            clauses.push('parent_id IS NULL');
+        }
+        else if (options.parentId !== undefined) {
+            clauses.push('parent_id = ?');
+            parameters.push(options.parentId);
+        }
+        if (options.before) {
+            clauses.push('(created_at < ? OR (created_at = ? AND id < ?))');
+            parameters.push(options.before.created_at, options.before.created_at, options.before.id);
+        }
+        if (options.after) {
+            clauses.push('(created_at > ? OR (created_at = ? AND id > ?))');
+            parameters.push(options.after.created_at, options.after.created_at, options.after.id);
+        }
+        const direction = options.after ? 'ASC' : 'DESC';
+        parameters.push(options.limit);
+        return this.database
+            .prepare(`SELECT * FROM channel_messages
+         WHERE ${clauses.join(' AND ')}
+         ORDER BY created_at ${direction}, id ${direction}
+         LIMIT ?`)
+            .all(...parameters);
+    }
+    async listThread(parentId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM channel_messages
+         WHERE parent_id = ?
+         ORDER BY created_at ASC, id ASC
+         LIMIT ?`)
+            .all(parentId, maximum);
+    }
+    async countThreadReplies(parentIds) {
+        if (parentIds.length === 0)
+            return {};
+        const placeholders = parentIds.map(() => '?').join(', ');
+        const rows = this.database
+            .prepare(`SELECT parent_id, COUNT(*) AS count
+         FROM channel_messages
+         WHERE parent_id IN (${placeholders}) AND deleted_at IS NULL
+         GROUP BY parent_id`)
+            .all(...parentIds);
+        const counts = {};
+        for (const row of rows)
+            counts[row.parent_id] = row.count;
+        return counts;
+    }
+    async update(message) {
+        this.database
+            .prepare(`UPDATE channel_messages SET
+           content = ?,
+           metadata = ?,
+           updated_at = ?,
+           edited_at = ?,
+           deleted_at = ?,
+           pinned_at = ?,
+           pinned_by = ?
+         WHERE id = ?`)
+            .run(message.content, message.metadata, message.updated_at, message.edited_at, message.deleted_at, message.pinned_at, message.pinned_by, message.id);
+    }
+    async listPinned(channelId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM channel_messages
+         WHERE channel_id = ? AND pinned_at IS NOT NULL AND deleted_at IS NULL
+         ORDER BY pinned_at DESC
+         LIMIT ?`)
+            .all(channelId, maximum);
+    }
+    async listRecentForChannels(channelIds, maximum) {
+        if (channelIds.length === 0)
+            return [];
+        const placeholders = channelIds.map(() => '?').join(', ');
+        return this.database
+            .prepare(`SELECT * FROM channel_messages
+         WHERE channel_id IN (${placeholders}) AND deleted_at IS NULL
+         ORDER BY created_at DESC
+         LIMIT ?`)
+            .all(...channelIds, maximum);
+    }
+    async addReaction(reaction, maximumPerMessage) {
+        const add = this.database.transaction(() => {
+            const existing = this.database
+                .prepare(`SELECT 1 FROM channel_reactions
+           WHERE message_id = ? AND user_id = ? AND emoji = ?`)
+                .get(reaction.message_id, reaction.user_id, reaction.emoji);
+            if (existing)
+                return false;
+            const count = this.database
+                .prepare('SELECT COUNT(*) AS count FROM channel_reactions WHERE message_id = ?')
+                .get(reaction.message_id);
+            if (count.count >= maximumPerMessage) {
+                throw new PersistenceResourceLimitError('channel-reaction', maximumPerMessage);
+            }
+            this.database
+                .prepare(`INSERT INTO channel_reactions
+             (id, message_id, user_id, emoji, created_at)
+           VALUES (?, ?, ?, ?, ?)`)
+                .run(reaction.id, reaction.message_id, reaction.user_id, reaction.emoji, reaction.created_at);
+            return true;
+        });
+        return add();
+    }
+    async removeReaction(messageId, userId, emoji) {
+        return (this.database
+            .prepare(`DELETE FROM channel_reactions
+           WHERE message_id = ? AND user_id = ? AND emoji = ?`)
+            .run(messageId, userId, emoji).changes > 0);
+    }
+    async listReactionsForMessages(messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const placeholders = messageIds.map(() => '?').join(', ');
+        return this.database
+            .prepare(`SELECT * FROM channel_reactions
+         WHERE message_id IN (${placeholders})
+         ORDER BY created_at ASC`)
+            .all(...messageIds);
+    }
+    async findAttachment(attachmentId) {
+        return (this.database
+            .prepare('SELECT * FROM channel_attachments WHERE id = ?')
+            .get(attachmentId) ?? null);
+    }
+    async listAttachmentsForMessages(messageIds) {
+        if (messageIds.length === 0)
+            return [];
+        const placeholders = messageIds.map(() => '?').join(', ');
+        return this.database
+            .prepare(`SELECT * FROM channel_attachments
+         WHERE message_id IN (${placeholders})
+         ORDER BY created_at ASC`)
+            .all(...messageIds);
+    }
+    async listAttachmentBlobIds(channelId) {
+        return this.database
+            .prepare('SELECT blob_id, created_by FROM channel_attachments WHERE channel_id = ?')
+            .all(channelId);
+    }
+}
+class SQLiteNotificationRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertWithLimit(notification, maximumPerUser) {
+        const insert = this.database.transaction(() => {
+            const result = this.database
+                .prepare(`INSERT INTO notifications
+             (id, user_id, type, title, body, href, source_key,
+              created_at, read_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(user_id, source_key)
+             WHERE source_key IS NOT NULL
+             DO NOTHING`)
+                .run(notification.id, notification.user_id, notification.type, notification.title, notification.body, notification.href, notification.source_key, notification.created_at, notification.read_at);
+            if (result.changes === 0)
+                return false;
+            this.database
+                .prepare(`DELETE FROM notifications
+           WHERE user_id = ?
+             AND id NOT IN (
+               SELECT id FROM notifications
+               WHERE user_id = ?
+               ORDER BY created_at DESC, id DESC
+               LIMIT ?
+             )`)
+                .run(notification.user_id, notification.user_id, maximumPerUser);
+            return true;
+        });
+        return insert();
+    }
+    async listByOwner(userId, options) {
+        const clauses = ['user_id = ?'];
+        const parameters = [userId];
+        if (options.before !== undefined) {
+            clauses.push('created_at < ?');
+            parameters.push(options.before);
+        }
+        if (options.unreadOnly) {
+            clauses.push('read_at IS NULL');
+        }
+        parameters.push(options.limit);
+        return this.database
+            .prepare(`SELECT * FROM notifications
+         WHERE ${clauses.join(' AND ')}
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(...parameters);
+    }
+    async countUnread(userId) {
+        const row = this.database
+            .prepare(`SELECT COUNT(*) AS count FROM notifications
+         WHERE user_id = ? AND read_at IS NULL`)
+            .get(userId);
+        return row.count;
+    }
+    async markRead(notificationId, userId, readAt) {
+        return (this.database
+            .prepare(`UPDATE notifications SET read_at = ?
+           WHERE id = ? AND user_id = ? AND read_at IS NULL`)
+            .run(readAt, notificationId, userId).changes > 0);
+    }
+    async markAllRead(userId, readAt) {
+        return this.database
+            .prepare(`UPDATE notifications SET read_at = ?
+         WHERE user_id = ? AND read_at IS NULL`)
+            .run(readAt, userId).changes;
+    }
+    async deleteByOwner(notificationId, userId) {
+        return (this.database
+            .prepare('DELETE FROM notifications WHERE id = ? AND user_id = ?')
+            .run(notificationId, userId).changes > 0);
+    }
+}
+class SQLiteWebhookTargetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async list(maximum) {
+        return this.database
+            .prepare('SELECT * FROM webhook_targets ORDER BY created_at ASC LIMIT ?')
+            .all(maximum);
+    }
+    async findById(targetId) {
+        return (this.database
+            .prepare('SELECT * FROM webhook_targets WHERE id = ?')
+            .get(targetId) ?? null);
+    }
+    async replaceWithLimit(target, maximum) {
+        const replace = this.database.transaction(() => {
+            const existing = this.database
+                .prepare('SELECT 1 FROM webhook_targets WHERE id = ?')
+                .get(target.id);
+            if (!existing) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM webhook_targets')
+                    .get();
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('webhook-target', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO webhook_targets
+             (id, name, url, secret, events, enabled, created_by,
+              created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             url = excluded.url,
+             secret = excluded.secret,
+             events = excluded.events,
+             enabled = excluded.enabled,
+             updated_at = excluded.updated_at`)
+                .run(target.id, target.name, target.url, target.secret, target.events, target.enabled, target.created_by, target.created_at, target.updated_at);
+        });
+        replace();
+    }
+    async delete(targetId) {
+        return (this.database
+            .prepare('DELETE FROM webhook_targets WHERE id = ?')
+            .run(targetId).changes > 0);
+    }
+}
+class SQLiteAutomationRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM automations
+         WHERE user_id = ?
+         ORDER BY updated_at DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async findByOwner(automationId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM automations WHERE id = ? AND user_id = ?')
+            .get(automationId, userId) ??
+            null);
+    }
+    async findById(automationId) {
+        return (this.database
+            .prepare('SELECT * FROM automations WHERE id = ?')
+            .get(automationId) ?? null);
+    }
+    async replaceWithLimit(automation, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'automations', automation.id, automation.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM automations WHERE user_id = ?')
+                    .get(automation.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('automation', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO automations
+             (id, user_id, name, instructions, triggers, provider, model,
+              notify, status, next_run_at, last_run_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             instructions = excluded.instructions,
+             triggers = excluded.triggers,
+             provider = excluded.provider,
+             model = excluded.model,
+             notify = excluded.notify,
+             status = excluded.status,
+             next_run_at = excluded.next_run_at,
+             last_run_at = excluded.last_run_at,
+             updated_at = excluded.updated_at
+           WHERE automations.user_id = excluded.user_id`)
+                .run(automation.id, automation.user_id, automation.name, automation.instructions, automation.triggers, automation.provider, automation.model, automation.notify, automation.status, automation.next_run_at, automation.last_run_at, automation.created_at, automation.updated_at);
+        });
+        replace();
+    }
+    async listDue(now, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM automations
+         WHERE status = 'active'
+           AND next_run_at IS NOT NULL
+           AND next_run_at <= ?
+         ORDER BY next_run_at ASC
+         LIMIT ?`)
+            .all(now, maximum);
+    }
+    async advanceNextRun(automationId, observedNextRunAt, nextRunAt, lastRunAt) {
+        return (this.database
+            .prepare(`UPDATE automations
+           SET next_run_at = ?, last_run_at = ?
+           WHERE id = ? AND next_run_at = ?`)
+            .run(nextRunAt, lastRunAt, automationId, observedNextRunAt).changes > 0);
+    }
+    async setStatus(automationId, userId, status, nextRunAt, updatedAt) {
+        return (this.database
+            .prepare(`UPDATE automations
+           SET status = ?, next_run_at = ?, updated_at = ?
+           WHERE id = ? AND user_id = ?`)
+            .run(status, nextRunAt, updatedAt, automationId, userId).changes > 0);
+    }
+    async deleteByOwner(automationId, userId) {
+        return (this.database
+            .prepare('DELETE FROM automations WHERE id = ? AND user_id = ?')
+            .run(automationId, userId).changes > 0);
+    }
+}
+class SQLiteAutomationRunRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insert(run) {
+        this.database
+            .prepare(`INSERT INTO automation_runs
+           (id, automation_id, user_id, scheduled_for, started_at,
+            finished_at, status, session_id, assistant_message_id, error,
+            seen_at, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(run.id, run.automation_id, run.user_id, run.scheduled_for, run.started_at, run.finished_at, run.status, run.session_id, run.assistant_message_id, run.error, run.seen_at, run.created_at);
+    }
+    async findByOwner(runId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM automation_runs WHERE id = ? AND user_id = ?')
+            .get(runId, userId) ?? null);
+    }
+    async listByOwner(userId, options) {
+        const clauses = ['user_id = ?'];
+        const values = [userId];
+        if (options.automationId !== undefined) {
+            clauses.push('automation_id = ?');
+            values.push(options.automationId);
+        }
+        if (options.from !== undefined) {
+            clauses.push('scheduled_for >= ?');
+            values.push(options.from);
+        }
+        if (options.to !== undefined) {
+            clauses.push('scheduled_for < ?');
+            values.push(options.to);
+        }
+        values.push(options.maximum);
+        return this.database
+            .prepare(`SELECT * FROM automation_runs
+         WHERE ${clauses.join(' AND ')}
+         ORDER BY scheduled_for DESC
+         LIMIT ?`)
+            .all(...values);
+    }
+    async listUnfinished(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM automation_runs
+         WHERE status IN ('queued', 'running')
+         ORDER BY scheduled_for ASC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async markStarted(runId, sessionId, assistantMessageId, startedAt) {
+        return (this.database
+            .prepare(`UPDATE automation_runs
+           SET session_id = ?, assistant_message_id = ?, started_at = ?,
+               status = 'running'
+           WHERE id = ? AND status = 'queued'`)
+            .run(sessionId, assistantMessageId, startedAt, runId).changes > 0);
+    }
+    async finalize(runId, status, finishedAt, error) {
+        return (this.database
+            .prepare(`UPDATE automation_runs
+           SET status = ?, finished_at = ?, error = ?
+           WHERE id = ? AND status IN ('queued', 'running')`)
+            .run(status, finishedAt, error, runId).changes > 0);
+    }
+    async countUnseenFinished(userId) {
+        const row = this.database
+            .prepare(`SELECT COUNT(*) AS count FROM automation_runs
+         WHERE user_id = ?
+           AND status IN ('succeeded', 'failed')
+           AND seen_at IS NULL`)
+            .get(userId);
+        return row.count;
+    }
+    async markSeenBefore(userId, seenAt) {
+        return this.database
+            .prepare(`UPDATE automation_runs
+         SET seen_at = ?
+         WHERE user_id = ?
+           AND status IN ('succeeded', 'failed')
+           AND seen_at IS NULL
+           AND finished_at IS NOT NULL
+           AND finished_at <= ?`)
+            .run(seenAt, userId, seenAt).changes;
+    }
+}
+class SQLiteToolServerRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async list(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM tool_servers
+         ORDER BY updated_at DESC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async findById(serverId) {
+        return (this.database
+            .prepare('SELECT * FROM tool_servers WHERE id = ?')
+            .get(serverId) ?? null);
+    }
+    async replaceWithLimit(server, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = this.database
+                .prepare('SELECT id FROM tool_servers WHERE id = ?')
+                .get(server.id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM tool_servers')
+                    .get();
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('tool-server', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO tool_servers
+             (id, user_id, name, description, kind, base_url, spec,
+              spec_digest, spec_revision, auth_mode, auth_header, access_mode,
+              enabled, timeout_ms, max_response_bytes, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             description = excluded.description,
+             base_url = excluded.base_url,
+             spec = excluded.spec,
+             spec_digest = excluded.spec_digest,
+             spec_revision = excluded.spec_revision,
+             auth_mode = excluded.auth_mode,
+             auth_header = excluded.auth_header,
+             access_mode = excluded.access_mode,
+             enabled = excluded.enabled,
+             timeout_ms = excluded.timeout_ms,
+             max_response_bytes = excluded.max_response_bytes,
+             updated_at = excluded.updated_at`)
+                .run(server.id, server.user_id, server.name, server.description, server.kind, server.base_url, server.spec, server.spec_digest, server.spec_revision, server.auth_mode, server.auth_header, server.access_mode, server.enabled, server.timeout_ms, server.max_response_bytes, server.created_at, server.updated_at);
+        });
+        replace();
+    }
+    async delete(serverId) {
+        return (this.database
+            .prepare('DELETE FROM tool_servers WHERE id = ?')
+            .run(serverId).changes > 0);
+    }
+}
+class SQLiteToolServerToolRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByServer(serverId) {
+        return this.database
+            .prepare(`SELECT * FROM tool_server_tools
+         WHERE server_id = ?
+         ORDER BY name ASC`)
+            .all(serverId);
+    }
+    async replaceAllForServer(serverId, tools) {
+        const replace = this.database.transaction(() => {
+            const previous = new Map(this.database
+                .prepare('SELECT name, enabled, side_effect FROM tool_server_tools WHERE server_id = ?')
+                .all(serverId).map(row => [row.name, row]));
+            this.database
+                .prepare('DELETE FROM tool_server_tools WHERE server_id = ?')
+                .run(serverId);
+            const insert = this.database.prepare(`INSERT INTO tool_server_tools
+           (id, server_id, name, description, params_schema, detail,
+            side_effect, enabled, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+            for (const tool of tools) {
+                if (tool.server_id !== serverId) {
+                    throw new Error('A tool row does not belong to its server');
+                }
+                const kept = previous.get(tool.name);
+                insert.run(tool.id, tool.server_id, tool.name, tool.description, tool.params_schema, tool.detail, kept ? kept.side_effect : tool.side_effect, kept ? kept.enabled : tool.enabled, tool.created_at, tool.updated_at);
+            }
+        });
+        replace();
+    }
+    async updateOverrides(serverId, toolName, overrides, updatedAt) {
+        const assignments = ['updated_at = ?'];
+        const values = [updatedAt];
+        if (overrides.enabled !== undefined) {
+            assignments.push('enabled = ?');
+            values.push(overrides.enabled);
+        }
+        if (overrides.side_effect !== undefined) {
+            assignments.push('side_effect = ?');
+            values.push(overrides.side_effect);
+        }
+        const changed = this.database
+            .prepare(`UPDATE tool_server_tools
+         SET ${assignments.join(', ')}
+         WHERE server_id = ? AND name = ?`)
+            .run(...values, serverId, toolName).changes;
+        if (changed === 0)
+            return null;
+        return (this.database
+            .prepare('SELECT * FROM tool_server_tools WHERE server_id = ? AND name = ?')
+            .get(serverId, toolName) ??
+            null);
+    }
+}
+class SQLiteToolServerCredentialRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async find(serverId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM tool_server_credentials WHERE server_id = ? AND user_id = ?')
+            .get(serverId, userId) ?? null);
+    }
+    async upsert(credential) {
+        this.database
+            .prepare(`INSERT INTO tool_server_credentials
+           (id, server_id, user_id, secret, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(server_id, user_id) DO UPDATE SET
+           secret = excluded.secret,
+           updated_at = excluded.updated_at`)
+            .run(credential.id, credential.server_id, credential.user_id, credential.secret, credential.created_at, credential.updated_at);
     }
-    async deleteAndDetach(collectionId, userId) {
-        const remove = this.database.transaction(() => {
-            this.database
-                .prepare('UPDATE documents SET collection_id = NULL WHERE collection_id = ? AND user_id = ?')
-                .run(collectionId, userId);
-            return this.database
-                .prepare('DELETE FROM knowledge_collections WHERE id = ? AND user_id = ?')
-                .run(collectionId, userId).changes;
-        });
-        return remove() > 0;
+    async delete(serverId, userId) {
+        return (this.database
+            .prepare('DELETE FROM tool_server_credentials WHERE server_id = ? AND user_id = ?')
+            .run(serverId, userId).changes > 0);
     }
 }
-class SQLiteNoteRepository {
+class SQLiteToolApprovalRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insert(approval) {
+        this.database
+            .prepare(`INSERT INTO tool_approvals
+           (id, user_id, session_id, server_id, tool_name, call_id,
+            arguments_digest, scope, status, created_at, resolved_at,
+            expires_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(approval.id, approval.user_id, approval.session_id, approval.server_id, approval.tool_name, approval.call_id, approval.arguments_digest, approval.scope, approval.status, approval.created_at, approval.resolved_at, approval.expires_at);
+    }
+    async findByOwner(approvalId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM tool_approvals WHERE id = ? AND user_id = ?')
+            .get(approvalId, userId) ??
+            null);
+    }
+    async findStanding(userId, serverId, toolName, sessionId) {
+        return (this.database
+            .prepare(`SELECT * FROM tool_approvals
+           WHERE user_id = ?
+             AND status = 'approved'
+             AND tool_name = ?
+             AND ((server_id IS NULL AND ? IS NULL) OR server_id = ?)
+             AND (scope = 'always'
+                  OR (scope = 'session' AND session_id IS NOT NULL AND session_id = ?))
+           ORDER BY resolved_at DESC
+           LIMIT 1`)
+            .get(userId, toolName, serverId, serverId, sessionId) ?? null);
+    }
+    async resolvePending(approvalId, userId, status, scope, resolvedAt) {
+        const changed = this.database
+            .prepare(`UPDATE tool_approvals
+         SET status = ?, scope = ?, resolved_at = ?
+         WHERE id = ? AND user_id = ? AND status = 'pending'
+           AND (expires_at IS NULL OR expires_at > ?)`)
+            .run(status, scope, resolvedAt, approvalId, userId, resolvedAt).changes;
+        if (changed === 0)
+            return null;
+        return this.findByOwner(approvalId, userId);
+    }
+    async listPendingByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM tool_approvals
+         WHERE user_id = ? AND status = 'pending'
+         ORDER BY created_at ASC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async listStandingByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM tool_approvals
+         WHERE user_id = ? AND status = 'approved'
+           AND scope IN ('session', 'always')
+         ORDER BY resolved_at DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async expirePending(now) {
+        return this.database
+            .prepare(`UPDATE tool_approvals
+         SET status = 'expired', resolved_at = ?
+         WHERE status = 'pending' AND expires_at IS NOT NULL AND expires_at <= ?`)
+            .run(now, now).changes;
+    }
+    async deleteByOwner(approvalId, userId) {
+        return (this.database
+            .prepare('DELETE FROM tool_approvals WHERE id = ? AND user_id = ?')
+            .run(approvalId, userId).changes > 0);
+    }
+}
+class SQLitePromptRepository {
     constructor(database) {
         this.database = database;
     }
     async listByOwner(userId, maximum) {
         return this.database
-            .prepare(`SELECT * FROM notes
+            .prepare(`SELECT * FROM prompts
          WHERE user_id = ?
          ORDER BY updated_at DESC
          LIMIT ?`)
             .all(userId, maximum);
     }
-    async findByOwner(noteId, userId) {
+    async findByOwner(promptId, userId) {
         return (this.database
-            .prepare('SELECT * FROM notes WHERE id = ? AND user_id = ?')
-            .get(noteId, userId) ?? null);
+            .prepare('SELECT * FROM prompts WHERE id = ? AND user_id = ?')
+            .get(promptId, userId) ?? null);
     }
-    async replaceWithLimit(note, maximum) {
+    async findById(promptId) {
+        return (this.database
+            .prepare('SELECT * FROM prompts WHERE id = ?')
+            .get(promptId) ?? null);
+    }
+    async findBySlug(userId, slug) {
+        return (this.database
+            .prepare('SELECT * FROM prompts WHERE user_id = ? AND slug = ?')
+            .get(userId, slug) ?? null);
+    }
+    async replaceWithLimit(prompt, maximum, archivedVersion) {
         const replace = this.database.transaction(() => {
-            const exists = ensureSameOwner(this.database, 'notes', note.id, note.user_id);
+            const exists = ensureSameOwner(this.database, 'prompts', prompt.id, prompt.user_id);
             if (!exists) {
                 const row = this.database
-                    .prepare('SELECT COUNT(*) AS count FROM notes WHERE user_id = ?')
-                    .get(note.user_id);
+                    .prepare('SELECT COUNT(*) AS count FROM prompts WHERE user_id = ?')
+                    .get(prompt.user_id);
                 if (row.count >= maximum) {
-                    throw new PersistenceResourceLimitError('note', maximum);
+                    throw new PersistenceResourceLimitError('prompt', maximum);
                 }
             }
             this.database
-                .prepare(`INSERT INTO notes
-             (id, user_id, title, content, created_at, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?)
+                .prepare(`INSERT INTO prompts
+             (id, user_id, slug, title, description, content, variables,
+              tags, version, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT(id) DO UPDATE SET
+             slug = excluded.slug,
              title = excluded.title,
+             description = excluded.description,
              content = excluded.content,
+             variables = excluded.variables,
+             tags = excluded.tags,
+             version = excluded.version,
              updated_at = excluded.updated_at
-           WHERE notes.user_id = excluded.user_id`)
-                .run(note.id, note.user_id, note.title, note.content, note.created_at, note.updated_at);
+           WHERE prompts.user_id = excluded.user_id`)
+                .run(prompt.id, prompt.user_id, prompt.slug, prompt.title, prompt.description, prompt.content, prompt.variables, prompt.tags, prompt.version, prompt.created_at, prompt.updated_at);
+            if (archivedVersion) {
+                this.database
+                    .prepare(`INSERT INTO prompt_versions
+               (id, prompt_id, version, content, variables, created_at)
+             VALUES (?, ?, ?, ?, ?, ?)
+             ON CONFLICT(prompt_id, version) DO NOTHING`)
+                    .run(archivedVersion.id, archivedVersion.prompt_id, archivedVersion.version, archivedVersion.content, archivedVersion.variables, archivedVersion.created_at);
+            }
         });
         replace();
     }
-    async patchByOwner(noteId, userId, patch) {
-        const update = this.database.transaction(() => {
-            const assignments = [];
-            const values = [];
-            if (patch.title !== undefined) {
-                assignments.push('title = ?');
-                values.push(patch.title);
+    async listVersions(promptId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM prompt_versions
+         WHERE prompt_id = ?
+         ORDER BY version DESC
+         LIMIT ?`)
+            .all(promptId, maximum);
+    }
+    async findVersion(promptId, version) {
+        return (this.database
+            .prepare('SELECT * FROM prompt_versions WHERE prompt_id = ? AND version = ?')
+            .get(promptId, version) ??
+            null);
+    }
+    async deleteByOwner(promptId, userId) {
+        return (this.database
+            .prepare('DELETE FROM prompts WHERE id = ? AND user_id = ?')
+            .run(promptId, userId).changes > 0);
+    }
+}
+class SQLiteSkillRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM skills
+         WHERE user_id = ?
+         ORDER BY updated_at DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async findByOwner(skillId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM skills WHERE id = ? AND user_id = ?')
+            .get(skillId, userId) ?? null);
+    }
+    async findById(skillId) {
+        return (this.database
+            .prepare('SELECT * FROM skills WHERE id = ?')
+            .get(skillId) ?? null);
+    }
+    async findBySlug(userId, slug) {
+        return (this.database
+            .prepare('SELECT * FROM skills WHERE user_id = ? AND slug = ?')
+            .get(userId, slug) ?? null);
+    }
+    async replaceWithLimit(skill, maximum, archivedVersion) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'skills', skill.id, skill.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM skills WHERE user_id = ?')
+                    .get(skill.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('skill', maximum);
+                }
             }
-            if (patch.content !== undefined) {
-                assignments.push('content = ?');
-                values.push(patch.content);
+            this.database
+                .prepare(`INSERT INTO skills
+             (id, user_id, slug, name, description, instructions, enabled,
+              version, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             slug = excluded.slug,
+             name = excluded.name,
+             description = excluded.description,
+             instructions = excluded.instructions,
+             enabled = excluded.enabled,
+             version = excluded.version,
+             updated_at = excluded.updated_at
+           WHERE skills.user_id = excluded.user_id`)
+                .run(skill.id, skill.user_id, skill.slug, skill.name, skill.description, skill.instructions, skill.enabled, skill.version, skill.created_at, skill.updated_at);
+            if (archivedVersion) {
+                this.database
+                    .prepare(`INSERT INTO skill_versions
+               (id, skill_id, version, instructions, created_at)
+             VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(skill_id, version) DO NOTHING`)
+                    .run(archivedVersion.id, archivedVersion.skill_id, archivedVersion.version, archivedVersion.instructions, archivedVersion.created_at);
             }
-            assignments.push('updated_at = ?');
-            values.push(patch.updated_at);
-            const result = this.database
-                .prepare(`UPDATE notes SET ${assignments.join(', ')}
-            WHERE id = ? AND user_id = ?`)
-                .run(...values, noteId, userId);
-            if (result.changes !== 1)
-                return null;
-            return this.database
-                .prepare('SELECT * FROM notes WHERE id = ? AND user_id = ?')
-                .get(noteId, userId);
         });
-        return update.immediate();
+        replace();
     }
-    async deleteByOwner(noteId, userId) {
+    async listVersions(skillId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM skill_versions
+         WHERE skill_id = ?
+         ORDER BY version DESC
+         LIMIT ?`)
+            .all(skillId, maximum);
+    }
+    async findVersion(skillId, version) {
         return (this.database
-            .prepare('DELETE FROM notes WHERE id = ? AND user_id = ?')
-            .run(noteId, userId).changes > 0);
+            .prepare('SELECT * FROM skill_versions WHERE skill_id = ? AND version = ?')
+            .get(skillId, version) ?? null);
+    }
+    async deleteByOwner(skillId, userId) {
+        return (this.database
+            .prepare('DELETE FROM skills WHERE id = ? AND user_id = ?')
+            .run(skillId, userId).changes > 0);
+    }
+}
+class SQLiteSkillFileRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listBySkill(skillId) {
+        return this.database
+            .prepare(`SELECT * FROM skill_files
+         WHERE skill_id = ?
+         ORDER BY path ASC`)
+            .all(skillId);
+    }
+    async find(skillId, path) {
+        return (this.database
+            .prepare('SELECT * FROM skill_files WHERE skill_id = ? AND path = ?')
+            .get(skillId, path) ?? null);
+    }
+    async upsert(file, maximumPerSkill) {
+        const upsert = this.database.transaction(() => {
+            const exists = this.database
+                .prepare('SELECT id FROM skill_files WHERE skill_id = ? AND path = ?')
+                .get(file.skill_id, file.path);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM skill_files WHERE skill_id = ?')
+                    .get(file.skill_id);
+                if (row.count >= maximumPerSkill) {
+                    throw new PersistenceResourceLimitError('skill-file', maximumPerSkill);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO skill_files
+             (id, skill_id, path, content, size, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(skill_id, path) DO UPDATE SET
+             content = excluded.content,
+             size = excluded.size,
+             updated_at = excluded.updated_at`)
+                .run(file.id, file.skill_id, file.path, file.content, file.size, file.created_at, file.updated_at);
+        });
+        upsert();
+    }
+    async replaceAllForSkill(skillId, files) {
+        const replace = this.database.transaction(() => {
+            this.database
+                .prepare('DELETE FROM skill_files WHERE skill_id = ?')
+                .run(skillId);
+            const insert = this.database.prepare(`INSERT INTO skill_files
+           (id, skill_id, path, content, size, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`);
+            for (const file of files) {
+                if (file.skill_id !== skillId) {
+                    throw new Error('A skill file does not belong to its skill');
+                }
+                insert.run(file.id, file.skill_id, file.path, file.content, file.size, file.created_at, file.updated_at);
+            }
+        });
+        replace();
+    }
+    async delete(skillId, path) {
+        return (this.database
+            .prepare('DELETE FROM skill_files WHERE skill_id = ? AND path = ?')
+            .run(skillId, path).changes > 0);
     }
 }
 class SQLiteSessionFolderRepository {
@@ -440,6 +1820,10 @@ const ARCHIVE_TABLES = {
     'knowledge-collection': 'knowledge_collections',
     document: 'documents',
     persona: 'personas',
+    prompt: 'prompts',
+    skill: 'skills',
+    'tool-server': 'tool_servers',
+    calendar: 'calendars',
 };
 class SQLiteDataArchiveRepository {
     constructor(database) {
@@ -651,13 +2035,251 @@ class SQLiteDataArchiveRepository {
         apply.immediate();
     }
 }
+class SQLiteModelTariffRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listAll(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM model_tariffs
+         ORDER BY plugin_id ASC, model ASC, effective_from DESC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async insert(tariff) {
+        this.database
+            .prepare(`INSERT INTO model_tariffs
+           (id, plugin_id, model, input_per_million, output_per_million,
+            unit_price, currency, effective_from, created_by, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(tariff.id, tariff.plugin_id, tariff.model, tariff.input_per_million, tariff.output_per_million, tariff.unit_price, tariff.currency, tariff.effective_from, tariff.created_by, tariff.created_at);
+    }
+    async deleteById(tariffId) {
+        return (this.database
+            .prepare('DELETE FROM model_tariffs WHERE id = ?')
+            .run(tariffId).changes > 0);
+    }
+}
+class SQLiteUsageBudgetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listAll(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM usage_budgets
+         ORDER BY created_at ASC, id ASC
+         LIMIT ?`)
+            .all(maximum);
+    }
+    async findById(budgetId) {
+        return (this.database
+            .prepare('SELECT * FROM usage_budgets WHERE id = ?')
+            .get(budgetId) ?? null);
+    }
+    async replace(budget) {
+        this.database
+            .prepare(`INSERT INTO usage_budgets
+           (id, name, principal_type, principal_id, period, amount_usd,
+            mode, created_by, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           principal_type = excluded.principal_type,
+           principal_id = excluded.principal_id,
+           period = excluded.period,
+           amount_usd = excluded.amount_usd,
+           mode = excluded.mode,
+           updated_at = excluded.updated_at`)
+            .run(budget.id, budget.name, budget.principal_type, budget.principal_id, budget.period, budget.amount_usd, budget.mode, budget.created_by, budget.created_at, budget.updated_at);
+    }
+    async deleteById(budgetId) {
+        return (this.database
+            .prepare('DELETE FROM usage_budgets WHERE id = ?')
+            .run(budgetId).changes > 0);
+    }
+}
+class SQLiteMessageFeedbackRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async upsertByMessage(feedback) {
+        this.database
+            .prepare(`INSERT INTO message_feedback
+           (id, user_id, session_id, message_id, rating, tags, comment,
+            model, plugin_id, snapshot, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(user_id, message_id) DO UPDATE SET
+           rating = excluded.rating,
+           tags = excluded.tags,
+           comment = excluded.comment,
+           model = excluded.model,
+           plugin_id = excluded.plugin_id,
+           snapshot = excluded.snapshot,
+           updated_at = excluded.updated_at`)
+            .run(feedback.id, feedback.user_id, feedback.session_id, feedback.message_id, feedback.rating, feedback.tags, feedback.comment, feedback.model, feedback.plugin_id, feedback.snapshot, feedback.created_at, feedback.updated_at);
+    }
+    async deleteByMessage(userId, messageId) {
+        return (this.database
+            .prepare('DELETE FROM message_feedback WHERE user_id = ? AND message_id = ?')
+            .run(userId, messageId).changes > 0);
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM message_feedback
+         WHERE user_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async listAll(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM message_feedback
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(maximum);
+    }
+}
+class SQLiteArenaVoteRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async insertOnce(vote) {
+        return (this.database
+            .prepare(`INSERT INTO arena_votes
+             (id, user_id, compare_group, model_a, model_b, winner, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(user_id, compare_group) DO NOTHING`)
+            .run(vote.id, vote.user_id, vote.compare_group, vote.model_a, vote.model_b, vote.winner, vote.created_at).changes > 0);
+    }
+    async listAllOrdered(maximum) {
+        return this.database
+            .prepare(`SELECT * FROM arena_votes
+         ORDER BY created_at ASC, id ASC
+         LIMIT ?`)
+            .all(maximum);
+    }
+}
+class SQLiteEvalSetRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM eval_sets
+         WHERE user_id = ?
+         ORDER BY updated_at DESC, id DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async findByOwner(setId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM eval_sets WHERE id = ? AND user_id = ?')
+            .get(setId, userId) ?? null);
+    }
+    async replaceWithLimit(set, maximum) {
+        const replace = this.database.transaction(() => {
+            const exists = ensureSameOwner(this.database, 'eval_sets', set.id, set.user_id);
+            if (!exists) {
+                const row = this.database
+                    .prepare('SELECT COUNT(*) AS count FROM eval_sets WHERE user_id = ?')
+                    .get(set.user_id);
+                if (row.count >= maximum) {
+                    throw new PersistenceResourceLimitError('eval-set', maximum);
+                }
+            }
+            this.database
+                .prepare(`INSERT INTO eval_sets
+             (id, user_id, name, description, items, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             name = excluded.name,
+             description = excluded.description,
+             items = excluded.items,
+             updated_at = excluded.updated_at
+           WHERE eval_sets.user_id = excluded.user_id`)
+                .run(set.id, set.user_id, set.name, set.description, set.items, set.created_at, set.updated_at);
+        });
+        replace();
+    }
+    async deleteByOwner(setId, userId) {
+        return (this.database
+            .prepare('DELETE FROM eval_sets WHERE id = ? AND user_id = ?')
+            .run(setId, userId).changes > 0);
+    }
+}
+class SQLiteEvalRunRepository {
+    constructor(database) {
+        this.database = database;
+    }
+    async listByOwner(userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM eval_runs
+         WHERE user_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(userId, maximum);
+    }
+    async listBySet(setId, userId, maximum) {
+        return this.database
+            .prepare(`SELECT * FROM eval_runs
+         WHERE set_id = ? AND user_id = ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`)
+            .all(setId, userId, maximum);
+    }
+    async findByOwner(runId, userId) {
+        return (this.database
+            .prepare('SELECT * FROM eval_runs WHERE id = ? AND user_id = ?')
+            .get(runId, userId) ?? null);
+    }
+    async insert(run) {
+        this.database
+            .prepare(`INSERT INTO eval_runs
+           (id, set_id, user_id, label, plugin_id, model, status, results,
+            error, created_at, updated_at, completed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(run.id, run.set_id, run.user_id, run.label, run.plugin_id, run.model, run.status, run.results, run.error, run.created_at, run.updated_at, run.completed_at);
+    }
+    async update(runId, userId, changes) {
+        return (this.database
+            .prepare(`UPDATE eval_runs SET
+             status = ?,
+             results = COALESCE(?, results),
+             error = ?,
+             updated_at = ?,
+             completed_at = COALESCE(?, completed_at)
+           WHERE id = ? AND user_id = ?`)
+            .run(changes.status, changes.results ?? null, changes.error ?? null, changes.updated_at, changes.completed_at ?? null, runId, userId).changes > 0);
+    }
+}
 export const createSQLiteResourceRepositories = (database) => ({
     chatSessions: new SQLiteChatSessionRepository(database),
     knowledgeCollections: new SQLiteKnowledgeCollectionRepository(database),
     notes: new SQLiteNoteRepository(database),
+    calendars: new SQLiteCalendarRepository(database),
+    calendarEvents: new SQLiteCalendarEventRepository(database),
+    channels: new SQLiteChannelRepository(database),
+    channelMessages: new SQLiteChannelMessageRepository(database),
+    notifications: new SQLiteNotificationRepository(database),
+    webhookTargets: new SQLiteWebhookTargetRepository(database),
+    automations: new SQLiteAutomationRepository(database),
+    automationRuns: new SQLiteAutomationRunRepository(database),
+    toolServers: new SQLiteToolServerRepository(database),
+    toolServerTools: new SQLiteToolServerToolRepository(database),
+    toolServerCredentials: new SQLiteToolServerCredentialRepository(database),
+    toolApprovals: new SQLiteToolApprovalRepository(database),
+    prompts: new SQLitePromptRepository(database),
+    skills: new SQLiteSkillRepository(database),
+    skillFiles: new SQLiteSkillFileRepository(database),
     sessionFolders: new SQLiteSessionFolderRepository(database),
     preferences: new SQLitePreferenceRepository(database),
     systemSettings: new SQLiteSystemSettingRepository(database),
     archive: new SQLiteDataArchiveRepository(database),
+    modelTariffs: new SQLiteModelTariffRepository(database),
+    usageBudgets: new SQLiteUsageBudgetRepository(database),
+    messageFeedback: new SQLiteMessageFeedbackRepository(database),
+    arenaVotes: new SQLiteArenaVoteRepository(database),
+    evalSets: new SQLiteEvalSetRepository(database),
+    evalRuns: new SQLiteEvalRunRepository(database),
 });
 //# sourceMappingURL=sqliteResourceRepositories.js.map