@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/apps/server/src/db/channelSessions/repo.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelSessionsRepo = createChannelSessionsRepo;
+function createChannelSessionsRepo(db) {
+    const get = (channelType, sessionType, channelId) => {
+        const stmt = db.prepare(`
+      SELECT channelType, sessionType, channelId, channelKey, replyReceiveId, replyReceiveIdType, sessionId, createdAt, updatedAt
+      FROM channel_sessions
+      WHERE channelType = ? AND sessionType = ? AND channelId = ?
+    `);
+        return stmt.get(channelType, sessionType, channelId);
+    };
+    const getBySessionId = (sessionId) => {
+        const stmt = db.prepare(`
+      SELECT channelType, sessionType, channelId, channelKey, replyReceiveId, replyReceiveIdType, sessionId, createdAt, updatedAt
+      FROM channel_sessions
+      WHERE sessionId = ?
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `);
+        return stmt.get(sessionId);
+    };
+    const upsert = (row) => {
+        const now = Date.now();
+        const stmt = db.prepare(`
+      INSERT INTO channel_sessions (channelType, sessionType, channelId, channelKey, replyReceiveId, replyReceiveIdType, sessionId, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(channelType, sessionType, channelId) DO UPDATE SET
+        channelKey = excluded.channelKey,
+        replyReceiveId = excluded.replyReceiveId,
+        replyReceiveIdType = excluded.replyReceiveIdType,
+        sessionId = excluded.sessionId,
+        updatedAt = excluded.updatedAt
+    `);
+        stmt.run(row.channelType, row.sessionType, row.channelId, row.channelKey, row.replyReceiveId ?? null, row.replyReceiveIdType ?? null, row.sessionId, now, now);
+    };
+    const removeBySessionId = (sessionId) => {
+        const stmt = db.prepare(`
+      DELETE FROM channel_sessions
+      WHERE sessionId = ?
+    `);
+        return stmt.run(sessionId).changes;
+    };
+    const getPreference = (channelType, sessionType, channelId) => {
+        const stmt = db.prepare(`
+      SELECT channelType, sessionType, channelId, channelKey, adapter, permissionMode, createdAt, updatedAt
+      FROM channel_preferences
+      WHERE channelType = ? AND sessionType = ? AND channelId = ?
+    `);
+        return stmt.get(channelType, sessionType, channelId);
+    };
+    const upsertPreference = (row) => {
+        const now = Date.now();
+        const stmt = db.prepare(`
+      INSERT INTO channel_preferences (
+        channelType, sessionType, channelId, channelKey, adapter, permissionMode, createdAt, updatedAt
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(channelType, sessionType, channelId) DO UPDATE SET
+        channelKey = excluded.channelKey,
+        adapter = excluded.adapter,
+        permissionMode = excluded.permissionMode,
+        updatedAt = excluded.updatedAt
+    `);
+        stmt.run(row.channelType, row.sessionType, row.channelId, row.channelKey, row.adapter ?? null, row.permissionMode ?? null, now, now);
+    };
+    return {
+        get,
+        getPreference,
+        getBySessionId,
+        removeBySessionId,
+        upsert,
+        upsertPreference
+    };
+}

package/dist/apps/server/src/db/channelSessions/schema.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaModule } from '../schema';
+export declare const channelSessionsSchemaModule: SchemaModule;

package/dist/apps/server/src/db/channelSessions/schema.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelSessionsSchemaModule = void 0;
+exports.channelSessionsSchemaModule = {
+    name: 'channel-sessions',
+    apply({ exec, ensureColumn, getColumns }) {
+        exec(`
+      CREATE TABLE IF NOT EXISTS channel_sessions (
+        channelType TEXT NOT NULL,
+        sessionType TEXT NOT NULL,
+        channelId TEXT NOT NULL,
+        channelKey TEXT NOT NULL,
+        replyReceiveId TEXT,
+        replyReceiveIdType TEXT,
+        sessionId TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        updatedAt INTEGER NOT NULL,
+        PRIMARY KEY (channelType, sessionType, channelId),
+        FOREIGN KEY(sessionId) REFERENCES sessions(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_channel_sessions_sessionId ON channel_sessions(sessionId);
+
+      CREATE TABLE IF NOT EXISTS channel_preferences (
+        channelType TEXT NOT NULL,
+        sessionType TEXT NOT NULL,
+        channelId TEXT NOT NULL,
+        channelKey TEXT NOT NULL,
+        adapter TEXT,
+        permissionMode TEXT,
+        createdAt INTEGER NOT NULL,
+        updatedAt INTEGER NOT NULL,
+        PRIMARY KEY (channelType, sessionType, channelId)
+      );
+    `);
+        if (getColumns('channel_sessions').length > 0) {
+            ensureColumn('channel_sessions', 'replyReceiveId', 'TEXT');
+            ensureColumn('channel_sessions', 'replyReceiveIdType', 'TEXT');
+        }
+        if (getColumns('channel_preferences').length > 0) {
+            ensureColumn('channel_preferences', 'adapter', 'TEXT');
+            ensureColumn('channel_preferences', 'permissionMode', 'TEXT');
+        }
+    }
+};

package/dist/apps/server/src/db/connection.d.ts

@@ -0,0 +1,6 @@
+import type { SqliteDatabase } from './sqlite';
+export interface DbConnection {
+    db: SqliteDatabase;
+    dbPath: string;
+}
+export declare function createConnection(): DbConnection;

package/dist/apps/server/src/db/connection.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = createConnection;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = require("node:process");
+const sqlite_1 = require("./sqlite");
+function createConnection() {
+    let dbPath = node_process_1.env.DB_PATH;
+    if (dbPath == null || dbPath === '') {
+        const homeDir = node_os_1.default.homedir();
+        const vfDir = node_path_1.default.join(homeDir, '.vf');
+        if (!node_fs_1.default.existsSync(vfDir)) {
+            node_fs_1.default.mkdirSync(vfDir, { recursive: true });
+        }
+        dbPath = node_path_1.default.join(vfDir, 'db.sqlite');
+    }
+    else {
+        const dir = node_path_1.default.dirname(dbPath);
+        if (!node_fs_1.default.existsSync(dir)) {
+            node_fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        if (node_fs_1.default.existsSync(dbPath) && node_fs_1.default.statSync(dbPath).isDirectory()) {
+            dbPath = node_path_1.default.join(dbPath, 'db.sqlite');
+        }
+    }
+    return {
+        dbPath,
+        db: (0, sqlite_1.createSqliteDatabase)(dbPath)
+    };
+}

package/dist/apps/server/src/db/index.d.ts

@@ -0,0 +1,55 @@
+import type { AutomationRule, AutomationRuleDetail, AutomationRun, AutomationTask, AutomationTrigger } from './automation/repo';
+import type { SqliteDatabase } from './sqlite';
+export interface SqliteDbOptions {
+    db?: SqliteDatabase;
+}
+export declare class SqliteDb {
+    private db;
+    private sessions;
+    private messages;
+    private channelSessions;
+    private tags;
+    private automation;
+    constructor(options?: SqliteDbOptions);
+    getSessions(filter?: 'active' | 'archived' | 'all'): import("@vibe-forge/types").Session[];
+    getSession(id: string): import("@vibe-forge/types").Session | undefined;
+    updateSession(id: string, updates: Parameters<typeof this.sessions.update>[1]): void;
+    updateSessionStarred(id: string, isStarred: boolean): void;
+    updateSessionArchived(id: string, isArchived: boolean): void;
+    updateSessionArchivedWithChildren(id: string, isArchived: boolean): string[];
+    updateSessionTags(sessionId: string, tags: string[]): void;
+    saveMessage(sessionId: string, data: unknown): void;
+    getMessages(sessionId: string): unknown[];
+    getChannelSession(channelType: string, sessionType: string, channelId: string): import("./channelSessions/repo").ChannelSessionRow | undefined;
+    getChannelPreference(channelType: string, sessionType: string, channelId: string): import("./channelSessions/repo").ChannelPreferenceRow | undefined;
+    getChannelSessionBySessionId(sessionId: string): import("./channelSessions/repo").ChannelSessionRow | undefined;
+    upsertChannelSession(row: Parameters<typeof this.channelSessions.upsert>[0]): void;
+    upsertChannelPreference(row: Parameters<typeof this.channelSessions.upsertPreference>[0]): void;
+    deleteChannelSessionBySessionId(sessionId: string): number;
+    copyMessages(fromSessionId: string, toSessionId: string): void;
+    createSession(title?: string, id?: string, status?: string, parentSessionId?: string): import("@vibe-forge/types").Session;
+    updateSessionTitle(id: string, title: string): void;
+    updateSessionLastMessages(id: string, lastMessage?: string, lastUserMessage?: string): void;
+    deleteSession(id: string): boolean;
+    close(): void;
+    listAutomationRules(): AutomationRule[];
+    listAutomationRuleDetails(): AutomationRuleDetail[];
+    getAutomationRuleDetail(id: string): AutomationRuleDetail | undefined;
+    getAutomationRule(id: string): AutomationRule | undefined;
+    createAutomationRule(rule: AutomationRule): void;
+    updateAutomationRule(id: string, updates: Partial<Omit<AutomationRule, 'id' | 'createdAt'>>): void;
+    deleteAutomationRule(id: string): boolean;
+    listAutomationTriggers(ruleId: string): AutomationTrigger[];
+    getAutomationTrigger(id: string): AutomationTrigger | undefined;
+    replaceAutomationTriggers(ruleId: string, triggers: Array<Omit<AutomationTrigger, 'id' | 'ruleId' | 'createdAt'> & {
+        id?: string;
+    }>): void;
+    listAutomationTasks(ruleId: string): AutomationTask[];
+    replaceAutomationTasks(ruleId: string, tasks: Array<Omit<AutomationTask, 'id' | 'ruleId' | 'createdAt'> & {
+        id?: string;
+    }>): void;
+    createAutomationRun(ruleId: string, sessionId: string, taskId?: string | null, taskTitle?: string | null): void;
+    listAutomationRuns(ruleId: string, limit?: number): AutomationRun[];
+}
+export declare function getDb(): SqliteDb;
+export type { AutomationRule, AutomationRuleDetail, AutomationRun, AutomationTask, AutomationTrigger };

package/dist/apps/server/src/db/index.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteDb = void 0;
+exports.getDb = getDb;
+const repo_1 = require("./automation/repo");
+const schema_1 = require("./automation/schema");
+const schema_2 = require("./channelSessions/schema");
+const repo_2 = require("./channelSessions/repo");
+const connection_1 = require("./connection");
+const schema_3 = require("./schema");
+const messages_repo_1 = require("./sessions/messages.repo");
+const repo_3 = require("./sessions/repo");
+const schema_4 = require("./sessions/schema");
+const tags_repo_1 = require("./sessions/tags.repo");
+const dbSchemaModules = [schema_4.sessionsSchemaModule, schema_2.channelSessionsSchemaModule, schema_1.automationSchemaModule];
+class SqliteDb {
+    db;
+    sessions;
+    messages;
+    channelSessions;
+    tags;
+    automation;
+    constructor(options = {}) {
+        this.db = options.db ?? (0, connection_1.createConnection)().db;
+        (0, schema_3.initSchema)(this.db, dbSchemaModules);
+        this.sessions = (0, repo_3.createSessionsRepo)(this.db);
+        this.messages = (0, messages_repo_1.createMessagesRepo)(this.db);
+        this.channelSessions = (0, repo_2.createChannelSessionsRepo)(this.db);
+        this.tags = (0, tags_repo_1.createTagsRepo)(this.db);
+        this.automation = (0, repo_1.createAutomationRepo)(this.db);
+    }
+    getSessions(filter = 'active') {
+        return this.sessions.list(filter);
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    updateSession(id, updates) {
+        return this.sessions.update(id, updates);
+    }
+    updateSessionStarred(id, isStarred) {
+        return this.sessions.setStarred(id, isStarred);
+    }
+    updateSessionArchived(id, isArchived) {
+        return this.sessions.setArchived(id, isArchived);
+    }
+    updateSessionArchivedWithChildren(id, isArchived) {
+        return this.sessions.archiveTree(id, isArchived);
+    }
+    updateSessionTags(sessionId, tags) {
+        return this.tags.replace(sessionId, tags);
+    }
+    saveMessage(sessionId, data) {
+        return this.messages.save(sessionId, data);
+    }
+    getMessages(sessionId) {
+        return this.messages.list(sessionId);
+    }
+    getChannelSession(channelType, sessionType, channelId) {
+        return this.channelSessions.get(channelType, sessionType, channelId);
+    }
+    getChannelPreference(channelType, sessionType, channelId) {
+        return this.channelSessions.getPreference(channelType, sessionType, channelId);
+    }
+    getChannelSessionBySessionId(sessionId) {
+        return this.channelSessions.getBySessionId(sessionId);
+    }
+    upsertChannelSession(row) {
+        return this.channelSessions.upsert(row);
+    }
+    upsertChannelPreference(row) {
+        return this.channelSessions.upsertPreference(row);
+    }
+    deleteChannelSessionBySessionId(sessionId) {
+        return this.channelSessions.removeBySessionId(sessionId);
+    }
+    copyMessages(fromSessionId, toSessionId) {
+        return this.messages.copy(fromSessionId, toSessionId);
+    }
+    createSession(title, id, status, parentSessionId) {
+        return this.sessions.create(title, id, status, parentSessionId);
+    }
+    updateSessionTitle(id, title) {
+        return this.sessions.setTitle(id, title);
+    }
+    updateSessionLastMessages(id, lastMessage, lastUserMessage) {
+        return this.sessions.setLastMessages(id, lastMessage, lastUserMessage);
+    }
+    deleteSession(id) {
+        return this.sessions.remove(id);
+    }
+    close() {
+        this.db.close();
+    }
+    listAutomationRules() {
+        return this.automation.listRules();
+    }
+    listAutomationRuleDetails() {
+        return this.automation.listRuleDetails();
+    }
+    getAutomationRuleDetail(id) {
+        return this.automation.getRuleDetail(id);
+    }
+    getAutomationRule(id) {
+        return this.automation.getRule(id);
+    }
+    createAutomationRule(rule) {
+        return this.automation.createRule(rule);
+    }
+    updateAutomationRule(id, updates) {
+        return this.automation.updateRule(id, updates);
+    }
+    deleteAutomationRule(id) {
+        return this.automation.removeRule(id);
+    }
+    listAutomationTriggers(ruleId) {
+        return this.automation.listTriggers(ruleId);
+    }
+    getAutomationTrigger(id) {
+        return this.automation.getTrigger(id);
+    }
+    replaceAutomationTriggers(ruleId, triggers) {
+        return this.automation.replaceTriggers(ruleId, triggers);
+    }
+    listAutomationTasks(ruleId) {
+        return this.automation.listTasks(ruleId);
+    }
+    replaceAutomationTasks(ruleId, tasks) {
+        return this.automation.replaceTasks(ruleId, tasks);
+    }
+    createAutomationRun(ruleId, sessionId, taskId, taskTitle) {
+        return this.automation.createRun(ruleId, sessionId, taskId, taskTitle);
+    }
+    listAutomationRuns(ruleId, limit = 50) {
+        return this.automation.listRuns(ruleId, limit);
+    }
+}
+exports.SqliteDb = SqliteDb;
+let dbInstance = null;
+function getDb() {
+    if (!dbInstance) {
+        dbInstance = new SqliteDb();
+    }
+    return dbInstance;
+}

package/dist/apps/server/src/db/repo.utils.d.ts

@@ -0,0 +1,11 @@
+export type SqlParam = string | number | null;
+export interface UpdateFieldDefinition<T extends Record<string, any>> {
+    key: keyof T;
+    column?: string;
+    toParam?: (value: T[keyof T]) => SqlParam;
+}
+export interface UpdateStatement {
+    sql: string;
+    params: SqlParam[];
+}
+export declare function buildUpdateStatement<T extends Record<string, any>>(tableName: string, idColumn: string, idValue: SqlParam, updates: T, definitions: readonly UpdateFieldDefinition<T>[]): UpdateStatement | undefined;

package/dist/apps/server/src/db/repo.utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpdateStatement = buildUpdateStatement;
+function buildUpdateStatement(tableName, idColumn, idValue, updates, definitions) {
+    const sets = [];
+    const params = [];
+    for (const definition of definitions) {
+        const value = updates[definition.key];
+        if (value === undefined) {
+            continue;
+        }
+        sets.push(`${definition.column ?? String(definition.key)} = ?`);
+        params.push(definition.toParam ? definition.toParam(value) : value);
+    }
+    if (sets.length === 0) {
+        return undefined;
+    }
+    params.push(idValue);
+    return {
+        sql: `UPDATE ${tableName} SET ${sets.join(', ')} WHERE ${idColumn} = ?`,
+        params
+    };
+}

package/dist/apps/server/src/db/schema.d.ts

@@ -0,0 +1,12 @@
+import type { SqliteDatabase } from './sqlite';
+export interface SchemaContext {
+    db: SqliteDatabase;
+    exec: (sql: string) => void;
+    getColumns: (tableName: string) => string[];
+    ensureColumn: (tableName: string, columnName: string, definition: string) => void;
+}
+export interface SchemaModule {
+    name: string;
+    apply: (context: SchemaContext) => void;
+}
+export declare function initSchema(db: SqliteDatabase, modules: readonly SchemaModule[]): void;

package/dist/apps/server/src/db/schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSchema = initSchema;
+function createSchemaContext(db) {
+    const getColumns = (tableName) => {
+        const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+        return rows.map(row => row.name);
+    };
+    return {
+        db,
+        exec: (sql) => {
+            db.exec(sql);
+        },
+        getColumns,
+        ensureColumn: (tableName, columnName, definition) => {
+            const columns = getColumns(tableName);
+            if (!columns.includes(columnName)) {
+                db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+            }
+        }
+    };
+}
+function initSchema(db, modules) {
+    const context = createSchemaContext(db);
+    for (const module of modules) {
+        module.apply(context);
+    }
+}

package/dist/apps/server/src/db/sessions/messages.repo.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDatabase } from '../sqlite';
+export declare function createMessagesRepo(db: SqliteDatabase): {
+    copy: (fromSessionId: string, toSessionId: string) => void;
+    list: (sessionId: string) => unknown[];
+    save: (sessionId: string, data: unknown) => void;
+};
+export type MessagesRepo = ReturnType<typeof createMessagesRepo>;

package/dist/apps/server/src/db/sessions/messages.repo.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagesRepo = createMessagesRepo;
+const json_js_1 = require("#~/utils/json.js");
+function createMessagesRepo(db) {
+    const save = (sessionId, data) => {
+        const stmt = db.prepare('INSERT INTO messages (sessionId, data, createdAt) VALUES (?, ?, ?)');
+        stmt.run(sessionId, (0, json_js_1.safeJsonStringify)(data), Date.now());
+    };
+    const list = (sessionId) => {
+        const stmt = db.prepare('SELECT data FROM messages WHERE sessionId = ? ORDER BY id ASC');
+        const rows = stmt.all(sessionId);
+        return rows.map(r => JSON.parse(r.data));
+    };
+    const copy = (fromSessionId, toSessionId) => {
+        const messages = list(fromSessionId);
+        for (const msg of messages) {
+            save(toSessionId, msg);
+        }
+    };
+    return {
+        copy,
+        list,
+        save
+    };
+}

package/dist/apps/server/src/db/sessions/repo.d.ts

@@ -0,0 +1,17 @@
+import type { Session } from '@vibe-forge/core';
+import type { SqliteDatabase } from '../sqlite';
+type SessionUpdate = Partial<Omit<Session, 'id' | 'createdAt' | 'messageCount'>>;
+export declare function createSessionsRepo(db: SqliteDatabase): {
+    archiveTree: (id: string, isArchived: boolean) => string[];
+    create: (title?: string, id?: string, status?: string, parentSessionId?: string) => Session;
+    get: (id: string) => Session | undefined;
+    list: (filter?: "active" | "archived" | "all") => Session[];
+    remove: (id: string) => boolean;
+    setArchived: (id: string, isArchived: boolean) => void;
+    setLastMessages: (id: string, lastMessage?: string, lastUserMessage?: string) => void;
+    setStarred: (id: string, isStarred: boolean) => void;
+    setTitle: (id: string, title: string) => void;
+    update: (id: string, updates: SessionUpdate) => void;
+};
+export type SessionsRepo = ReturnType<typeof createSessionsRepo>;
+export {};

package/dist/apps/server/src/db/sessions/repo.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionsRepo = createSessionsRepo;
+const uuid_1 = require("uuid");
+const repo_utils_1 = require("../repo.utils");
+const SESSION_SELECT = `
+  SELECT s.*,
+         (SELECT COUNT(*) FROM messages WHERE sessionId = s.id) as messageCount,
+         (SELECT GROUP_CONCAT(t.name) FROM tags t JOIN session_tags st ON t.id = st.tagId WHERE st.sessionId = s.id) as tags
+  FROM sessions s
+`;
+const sessionUpdateFields = [
+    { key: 'title' },
+    { key: 'lastMessage' },
+    { key: 'lastUserMessage' },
+    { key: 'isStarred', toParam: value => value ? 1 : 0 },
+    { key: 'isArchived', toParam: value => value ? 1 : 0 },
+    { key: 'status' },
+    { key: 'model' },
+    { key: 'adapter' },
+    { key: 'permissionMode' }
+];
+function mapSessionRow(row) {
+    return {
+        id: row.id,
+        parentSessionId: row.parentSessionId ?? undefined,
+        title: row.title ?? undefined,
+        createdAt: row.createdAt,
+        messageCount: row.messageCount,
+        lastMessage: row.lastMessage ?? undefined,
+        lastUserMessage: row.lastUserMessage ?? undefined,
+        isStarred: row.isStarred === 1,
+        isArchived: row.isArchived === 1,
+        tags: (row.tags != null && row.tags !== '') ? row.tags.split(',') : [],
+        status: row.status ?? undefined,
+        model: row.model ?? undefined,
+        adapter: row.adapter ?? undefined,
+        permissionMode: row.permissionMode ?? undefined
+    };
+}
+function createSessionsRepo(db) {
+    const list = (filter = 'active') => {
+        let whereClause = '';
+        if (filter === 'active') {
+            whereClause = 'WHERE isArchived = 0';
+        }
+        else if (filter === 'archived') {
+            whereClause = 'WHERE isArchived = 1';
+        }
+        const stmt = db.prepare(`
+      ${SESSION_SELECT}
+      ${whereClause}
+      ORDER BY isStarred DESC, createdAt DESC
+    `);
+        const rows = stmt.all();
+        return rows.map(mapSessionRow);
+    };
+    const get = (id) => {
+        const stmt = db.prepare(`
+      ${SESSION_SELECT}
+      WHERE s.id = ?
+    `);
+        const row = stmt.get(id);
+        if (row == null)
+            return undefined;
+        return mapSessionRow(row);
+    };
+    const update = (id, updates) => {
+        const statement = (0, repo_utils_1.buildUpdateStatement)('sessions', 'id', id, updates, sessionUpdateFields);
+        if (!statement)
+            return;
+        const stmt = db.prepare(statement.sql);
+        stmt.run(...statement.params);
+    };
+    const setStarred = (id, isStarred) => {
+        update(id, { isStarred });
+    };
+    const setArchived = (id, isArchived) => {
+        update(id, { isArchived });
+    };
+    const archiveTree = (id, isArchived) => {
+        const stmt = db.prepare('SELECT id FROM sessions WHERE parentSessionId = ?');
+        const updateStmt = db.prepare('UPDATE sessions SET isArchived = ? WHERE id = ?');
+        const updatedIds = [];
+        const stack = [id];
+        while (stack.length > 0) {
+            const currentId = stack.pop();
+            if (!currentId)
+                continue;
+            updateStmt.run(isArchived ? 1 : 0, currentId);
+            updatedIds.push(currentId);
+            const rows = stmt.all(currentId);
+            for (const row of rows) {
+                stack.push(row.id);
+            }
+        }
+        return updatedIds;
+    };
+    const create = (title, id, status, parentSessionId) => {
+        const session = {
+            id: id ?? (0, uuid_1.v4)(),
+            parentSessionId: parentSessionId ?? undefined,
+            title,
+            createdAt: Date.now(),
+            status: status ?? undefined
+        };
+        const stmt = db.prepare('INSERT INTO sessions (id, parentSessionId, title, createdAt, status) VALUES (?, ?, ?, ?, ?)');
+        stmt.run(session.id, session.parentSessionId ?? null, session.title ?? null, session.createdAt, session.status ?? null);
+        return session;
+    };
+    const setTitle = (id, title) => {
+        update(id, { title });
+    };
+    const setLastMessages = (id, lastMessage, lastUserMessage) => {
+        update(id, { lastMessage, lastUserMessage });
+    };
+    const remove = (id) => {
+        const stmt = db.prepare('DELETE FROM sessions WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    };
+    return {
+        archiveTree,
+        create,
+        get,
+        list,
+        remove,
+        setArchived,
+        setLastMessages,
+        setStarred,
+        setTitle,
+        update
+    };
+}

package/dist/apps/server/src/db/sessions/schema.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaModule } from '../schema';
+export declare const sessionsSchemaModule: SchemaModule;