atoo-studio 0.0.1 → 0.0.2

package/dist/src/state/db.js

@@ -0,0 +1,897 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+const STORE_DIR = path.join(os.homedir(), '.atoo-studio');
+const DB_PATH = path.join(STORE_DIR, 'atoo-studio.db');
+const OLD_PROJECTS_FILE = path.join(STORE_DIR, 'projects.json');
+class StudioDatabase {
+    db;
+    constructor() {
+        if (!fs.existsSync(STORE_DIR)) {
+            fs.mkdirSync(STORE_DIR, { recursive: true });
+        }
+        this.db = new Database(DB_PATH);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('busy_timeout = 5000');
+        this.initSchema();
+        this.migrateProjectsSshColumns();
+        this.migrateProjectsParentColumn();
+        this.migrateWorktreeHistory();
+        this.migrate();
+        this.migrateUserManagement();
+        this.migrateSessionMetadata();
+        this.migrateDatabaseConnections();
+        this.migrateProjectChanges();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS environments (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        path TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS project_environment (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        environment_id TEXT NOT NULL REFERENCES environments(id) ON DELETE CASCADE,
+        linked_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE (project_id, environment_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS environment_settings (
+        environment_id TEXT PRIMARY KEY REFERENCES environments(id) ON DELETE CASCADE,
+        sidebar_width TEXT DEFAULT '260px',
+        sidebar_collapsed INTEGER DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS project_settings (
+        pe_id TEXT PRIMARY KEY REFERENCES project_environment(id) ON DELETE CASCADE,
+        settings_json TEXT NOT NULL DEFAULT '{}',
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS ssh_connections (
+        id TEXT PRIMARY KEY,
+        label TEXT NOT NULL,
+        host TEXT NOT NULL,
+        port INTEGER NOT NULL DEFAULT 22,
+        username TEXT NOT NULL,
+        auth_method TEXT NOT NULL,
+        password_obfuscated TEXT,
+        private_key_obfuscated TEXT,
+        passphrase_obfuscated TEXT,
+        system_key_path TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+    `);
+    }
+    migrate() {
+        // Migrate project_environment schema: add `id` column if missing
+        this.migrateProjectEnvironmentSchema();
+        // Migrate from projects.json if it exists and DB is empty
+        if (!fs.existsSync(OLD_PROJECTS_FILE))
+            return;
+        const envCount = this.db.prepare('SELECT COUNT(*) as cnt FROM environments').get();
+        if (envCount.cnt > 0)
+            return;
+        console.log('[db] Migrating from projects.json...');
+        try {
+            const data = JSON.parse(fs.readFileSync(OLD_PROJECTS_FILE, 'utf-8'));
+            const projects = Array.isArray(data) ? data : [];
+            if (projects.length === 0)
+                return;
+            const envId = uuidv4();
+            const txn = this.db.transaction(() => {
+                // Create "Default" environment
+                this.db.prepare('INSERT INTO environments (id, name) VALUES (?, ?)').run(envId, 'Default');
+                this.db.prepare('INSERT INTO environment_settings (environment_id) VALUES (?)').run(envId);
+                // Import projects
+                for (const p of projects) {
+                    const projectId = p.id || uuidv4();
+                    const peId = uuidv4();
+                    this.db.prepare('INSERT INTO projects (id, name, path, created_at) VALUES (?, ?, ?, ?)')
+                        .run(projectId, p.name, p.path, p.createdAt || new Date().toISOString());
+                    this.db.prepare('INSERT INTO project_environment (id, project_id, environment_id) VALUES (?, ?, ?)')
+                        .run(peId, projectId, envId);
+                }
+            });
+            txn();
+            // Rename old file
+            fs.renameSync(OLD_PROJECTS_FILE, OLD_PROJECTS_FILE + '.bak');
+            console.log(`[db] Migrated ${projects.length} projects into "Default" environment`);
+        }
+        catch (err) {
+            console.error('[db] Migration failed:', err);
+        }
+    }
+    migrateProjectsSshColumns() {
+        const columns = this.db.prepare("PRAGMA table_info(projects)").all();
+        const hasSshCol = columns.some((c) => c.name === 'ssh_connection_id');
+        if (hasSshCol || columns.length === 0)
+            return;
+        this.db.exec(`
+      ALTER TABLE projects ADD COLUMN ssh_connection_id TEXT REFERENCES ssh_connections(id);
+      ALTER TABLE projects ADD COLUMN remote_path TEXT;
+    `);
+        console.log('[db] Added ssh_connection_id and remote_path columns to projects');
+    }
+    migrateProjectsParentColumn() {
+        const columns = this.db.prepare("PRAGMA table_info(projects)").all();
+        const hasParentCol = columns.some((c) => c.name === 'parent_project_id');
+        if (hasParentCol || columns.length === 0)
+            return;
+        this.db.exec(`
+      ALTER TABLE projects ADD COLUMN parent_project_id TEXT REFERENCES projects(id) ON DELETE CASCADE;
+    `);
+        console.log('[db] Added parent_project_id column to projects');
+    }
+    migrateWorktreeHistory() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS worktree_history (
+        id TEXT PRIMARY KEY,
+        parent_project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        worktree_path TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE (parent_project_id, worktree_path)
+      );
+    `);
+    }
+    migrateProjectEnvironmentSchema() {
+        // Check if project_environment table has an `id` column
+        const columns = this.db.prepare("PRAGMA table_info(project_environment)").all();
+        const hasId = columns.some((c) => c.name === 'id');
+        if (hasId || columns.length === 0)
+            return; // Already migrated or table doesn't exist yet
+        console.log('[db] Migrating project_environment schema to add id column...');
+        const txn = this.db.transaction(() => {
+            // Read existing PE rows
+            const peRows = this.db.prepare('SELECT project_id, environment_id, linked_at FROM project_environment').all();
+            // Read existing project_settings rows (old composite key schema)
+            let psRows = [];
+            try {
+                const psColumns = this.db.prepare("PRAGMA table_info(project_settings)").all();
+                const hasProjectId = psColumns.some((c) => c.name === 'project_id');
+                if (hasProjectId) {
+                    psRows = this.db.prepare('SELECT project_id, environment_id, settings_json, updated_at FROM project_settings').all();
+                }
+            }
+            catch { }
+            // Drop old tables
+            this.db.exec('DROP TABLE IF EXISTS project_settings');
+            this.db.exec('DROP TABLE IF EXISTS project_environment');
+            // Recreate with new schema
+            this.db.exec(`
+        CREATE TABLE project_environment (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+          environment_id TEXT NOT NULL REFERENCES environments(id) ON DELETE CASCADE,
+          linked_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (project_id, environment_id)
+        );
+        CREATE TABLE project_settings (
+          pe_id TEXT PRIMARY KEY REFERENCES project_environment(id) ON DELETE CASCADE,
+          settings_json TEXT NOT NULL DEFAULT '{}',
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+      `);
+            // Re-insert PE rows with generated UUIDs, map old composite key to new ID
+            const keyToId = new Map();
+            for (const row of peRows) {
+                const peId = uuidv4();
+                keyToId.set(`${row.project_id}/${row.environment_id}`, peId);
+                this.db.prepare('INSERT INTO project_environment (id, project_id, environment_id, linked_at) VALUES (?, ?, ?, ?)')
+                    .run(peId, row.project_id, row.environment_id, row.linked_at);
+            }
+            // Migrate project_settings to use pe_id
+            for (const ps of psRows) {
+                const peId = keyToId.get(`${ps.project_id}/${ps.environment_id}`);
+                if (peId) {
+                    this.db.prepare('INSERT INTO project_settings (pe_id, settings_json, updated_at) VALUES (?, ?, ?)')
+                        .run(peId, ps.settings_json, ps.updated_at);
+                }
+            }
+            console.log(`[db] Migrated ${peRows.length} project_environment rows, ${psRows.length} project_settings rows`);
+        });
+        txn();
+    }
+    // ═══════════════════════════════════════════════════
+    // ENVIRONMENTS
+    // ═══════════════════════════════════════════════════
+    listEnvironments() {
+        return this.db.prepare(`
+      SELECT e.id, e.name, e.created_at,
+        (SELECT COUNT(*) FROM project_environment pe WHERE pe.environment_id = e.id) as project_count
+      FROM environments e
+      ORDER BY e.created_at
+    `).all();
+    }
+    getEnvironment(id) {
+        return this.db.prepare(`
+      SELECT e.id, e.name, e.created_at,
+        (SELECT COUNT(*) FROM project_environment pe WHERE pe.environment_id = e.id) as project_count
+      FROM environments e WHERE e.id = ?
+    `).get(id);
+    }
+    createEnvironment(name) {
+        const id = uuidv4();
+        this.db.prepare('INSERT INTO environments (id, name) VALUES (?, ?)').run(id, name);
+        this.db.prepare('INSERT INTO environment_settings (environment_id) VALUES (?)').run(id);
+        return this.getEnvironment(id);
+    }
+    deleteEnvironment(id) {
+        const result = this.db.prepare('DELETE FROM environments WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // ═══════════════════════════════════════════════════
+    // PROJECTS
+    // ═══════════════════════════════════════════════════
+    getProject(id) {
+        return this.db.prepare('SELECT id, name, path, created_at, ssh_connection_id, remote_path, parent_project_id FROM projects WHERE id = ?')
+            .get(id);
+    }
+    listAllProjects() {
+        return this.db.prepare('SELECT id, name, path, created_at, ssh_connection_id, remote_path, parent_project_id FROM projects ORDER BY created_at')
+            .all();
+    }
+    createProject(name, projectPath, opts) {
+        const id = uuidv4();
+        const resolved = opts?.sshConnectionId ? projectPath : path.resolve(projectPath);
+        this.db.prepare('INSERT INTO projects (id, name, path, ssh_connection_id, remote_path, parent_project_id) VALUES (?, ?, ?, ?, ?, ?)')
+            .run(id, name, resolved, opts?.sshConnectionId || null, opts?.remotePath || null, opts?.parentProjectId || null);
+        return this.getProject(id);
+    }
+    deleteProject(id) {
+        const result = this.db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    getChildProjects(parentId) {
+        return this.db.prepare('SELECT id, name, path, created_at, ssh_connection_id, remote_path, parent_project_id FROM projects WHERE parent_project_id = ? ORDER BY created_at')
+            .all(parentId);
+    }
+    findProjectByPath(projectPath) {
+        return this.db.prepare('SELECT id, name, path, created_at, ssh_connection_id, remote_path, parent_project_id FROM projects WHERE path = ?')
+            .get(projectPath);
+    }
+    // ═══════════════════════════════════════════════════
+    // N:N LINKING
+    // ═══════════════════════════════════════════════════
+    getProjectsForEnvironment(envId) {
+        return this.db.prepare(`
+      SELECT p.id, p.name, p.path, p.created_at, p.ssh_connection_id, p.remote_path, p.parent_project_id, pe.id as pe_id
+      FROM projects p
+      JOIN project_environment pe ON pe.project_id = p.id
+      WHERE pe.environment_id = ?
+      ORDER BY pe.linked_at
+    `).all(envId);
+    }
+    getEnvironmentsForProject(projectId) {
+        return this.db.prepare(`
+      SELECT e.id, e.name, e.created_at
+      FROM environments e
+      JOIN project_environment pe ON pe.environment_id = e.id
+      WHERE pe.project_id = ?
+    `).all(projectId);
+    }
+    linkProject(projectId, envId) {
+        const existing = this.db.prepare('SELECT id FROM project_environment WHERE project_id = ? AND environment_id = ?').get(projectId, envId);
+        if (existing)
+            return existing.id;
+        const peId = uuidv4();
+        this.db.prepare('INSERT INTO project_environment (id, project_id, environment_id) VALUES (?, ?, ?)').run(peId, projectId, envId);
+        // Also link child projects (worktrees) to the same environment
+        const children = this.getChildProjects(projectId);
+        for (const child of children) {
+            this.linkProject(child.id, envId);
+        }
+        return peId;
+    }
+    unlinkProject(peId) {
+        const pe = this.getProjectEnvironment(peId);
+        this.db.prepare('DELETE FROM project_environment WHERE id = ?').run(peId);
+        // Also unlink child projects from this environment
+        if (pe) {
+            const children = this.getChildProjects(pe.project_id);
+            for (const child of children) {
+                const childPe = this.db.prepare('SELECT id FROM project_environment WHERE project_id = ? AND environment_id = ?').get(child.id, pe.environment_id);
+                if (childPe) {
+                    this.unlinkProject(childPe.id);
+                }
+            }
+        }
+    }
+    getProjectEnvironment(peId) {
+        return this.db.prepare('SELECT id, project_id, environment_id FROM project_environment WHERE id = ?').get(peId);
+    }
+    // ═══════════════════════════════════════════════════
+    // ENVIRONMENT SETTINGS
+    // ═══════════════════════════════════════════════════
+    getEnvironmentSettings(envId) {
+        return this.db.prepare('SELECT * FROM environment_settings WHERE environment_id = ?')
+            .get(envId);
+    }
+    updateEnvironmentSettings(envId, partial) {
+        const current = this.getEnvironmentSettings(envId);
+        if (!current)
+            return;
+        const updates = [];
+        const values = [];
+        if (partial.sidebar_width !== undefined) {
+            updates.push('sidebar_width = ?');
+            values.push(partial.sidebar_width);
+        }
+        if (partial.sidebar_collapsed !== undefined) {
+            updates.push('sidebar_collapsed = ?');
+            values.push(partial.sidebar_collapsed);
+        }
+        if (updates.length === 0)
+            return;
+        values.push(envId);
+        this.db.prepare(`UPDATE environment_settings SET ${updates.join(', ')} WHERE environment_id = ?`).run(...values);
+    }
+    // ═══════════════════════════════════════════════════
+    // PROJECT SETTINGS (per env)
+    // ═══════════════════════════════════════════════════
+    getProjectSettings(peId) {
+        const row = this.db.prepare('SELECT settings_json FROM project_settings WHERE pe_id = ?').get(peId);
+        if (!row)
+            return {};
+        try {
+            return JSON.parse(row.settings_json);
+        }
+        catch {
+            return {};
+        }
+    }
+    updateProjectSettings(peId, partial) {
+        const current = this.getProjectSettings(peId);
+        const merged = { ...current, ...partial };
+        const json = JSON.stringify(merged);
+        this.db.prepare(`
+      INSERT INTO project_settings (pe_id, settings_json, updated_at)
+      VALUES (?, ?, datetime('now'))
+      ON CONFLICT(pe_id) DO UPDATE SET
+        settings_json = excluded.settings_json,
+        updated_at = excluded.updated_at
+    `).run(peId, json);
+    }
+    // ═══════════════════════════════════════════════════
+    // SSH CONNECTIONS
+    // ═══════════════════════════════════════════════════
+    createSshConnection(config) {
+        const id = uuidv4();
+        this.db.prepare(`
+      INSERT INTO ssh_connections (id, label, host, port, username, auth_method,
+        password_obfuscated, private_key_obfuscated, passphrase_obfuscated, system_key_path)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, config.label, config.host, config.port, config.username, config.auth_method, config.password_obfuscated || null, config.private_key_obfuscated || null, config.passphrase_obfuscated || null, config.system_key_path || null);
+        return this.getSshConnection(id);
+    }
+    getSshConnection(id) {
+        return this.db.prepare('SELECT * FROM ssh_connections WHERE id = ?')
+            .get(id);
+    }
+    listSshConnections() {
+        return this.db.prepare('SELECT * FROM ssh_connections ORDER BY created_at')
+            .all();
+    }
+    deleteSshConnection(id) {
+        const result = this.db.prepare('DELETE FROM ssh_connections WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // ═══════════════════════════════════════════════════
+    // WORKTREE HISTORY (persists paths after removal)
+    // ═══════════════════════════════════════════════════
+    /**
+     * Record a worktree path for a parent project. Idempotent — skips duplicates.
+     */
+    recordWorktreePath(parentProjectId, worktreePath) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO worktree_history (id, parent_project_id, worktree_path)
+      VALUES (?, ?, ?)
+    `).run(uuidv4(), parentProjectId, worktreePath);
+    }
+    /**
+     * Get all project paths related to a given path (main project + all worktrees, current and historical).
+     * Works bidirectionally: pass a main project path or a worktree path.
+     */
+    getAllRelatedProjectPaths(projectPath) {
+        // First, find the project by path
+        const project = this.findProjectByPath(projectPath);
+        if (!project) {
+            // Path might be a historical worktree that's been deleted from projects table
+            const hist = this.db.prepare('SELECT parent_project_id FROM worktree_history WHERE worktree_path = ?').get(projectPath);
+            if (!hist)
+                return [projectPath]; // Unknown path, just return itself
+            const parent = this.getProject(hist.parent_project_id);
+            if (!parent)
+                return [projectPath];
+            return this.collectAllPaths(parent.id, parent.path);
+        }
+        // If this is a child project (worktree), resolve to parent
+        const parentId = project.parent_project_id;
+        if (parentId) {
+            const parent = this.getProject(parentId);
+            if (parent) {
+                return this.collectAllPaths(parent.id, parent.path);
+            }
+        }
+        // This is a root project — collect all its paths
+        return this.collectAllPaths(project.id, project.path);
+    }
+    collectAllPaths(parentProjectId, parentPath) {
+        const paths = new Set();
+        paths.add(parentPath);
+        // Current child projects (active worktrees)
+        const children = this.getChildProjects(parentProjectId);
+        for (const child of children) {
+            paths.add(child.path);
+        }
+        // Historical worktree paths (includes removed worktrees)
+        const historical = this.db.prepare('SELECT worktree_path FROM worktree_history WHERE parent_project_id = ?').all(parentProjectId);
+        for (const row of historical) {
+            paths.add(row.worktree_path);
+        }
+        return Array.from(paths);
+    }
+    // ═══════════════════════════════════════════════════
+    // USER MANAGEMENT MIGRATION
+    // ═══════════════════════════════════════════════════
+    migrateUserManagement() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS users (
+        id TEXT PRIMARY KEY,
+        username TEXT NOT NULL UNIQUE COLLATE NOCASE,
+        display_name TEXT NOT NULL,
+        role TEXT NOT NULL CHECK (role IN ('admin', 'basic')),
+        password_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS auth_sessions (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        expires_at TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        ip_address TEXT,
+        user_agent TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS totp_secrets (
+        user_id TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+        secret_encrypted TEXT NOT NULL,
+        verified INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS passkeys (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        credential_id TEXT NOT NULL UNIQUE,
+        public_key TEXT NOT NULL,
+        counter INTEGER NOT NULL DEFAULT 0,
+        transports TEXT,
+        device_name TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS environment_shares (
+        id TEXT PRIMARY KEY,
+        environment_id TEXT NOT NULL REFERENCES environments(id) ON DELETE CASCADE,
+        user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+        shared_by TEXT NOT NULL REFERENCES users(id),
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE (environment_id, user_id)
+      );
+    `);
+        // Add owner_user_id column to environments if missing
+        const columns = this.db.prepare("PRAGMA table_info(environments)").all();
+        const hasOwnerCol = columns.some((c) => c.name === 'owner_user_id');
+        if (!hasOwnerCol && columns.length > 0) {
+            this.db.exec('ALTER TABLE environments ADD COLUMN owner_user_id TEXT REFERENCES users(id)');
+            console.log('[db] Added owner_user_id column to environments');
+        }
+    }
+    // ═══════════════════════════════════════════════════
+    // USERS
+    // ═══════════════════════════════════════════════════
+    getUserCount() {
+        return this.db.prepare('SELECT COUNT(*) as cnt FROM users').get().cnt;
+    }
+    createUser(username, displayName, role, passwordHash) {
+        const id = uuidv4();
+        this.db.prepare('INSERT INTO users (id, username, display_name, role, password_hash) VALUES (?, ?, ?, ?, ?)').run(id, username, displayName, role, passwordHash);
+        return this.getUser(id);
+    }
+    getUser(id) {
+        return this.db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+    }
+    getUserByUsername(username) {
+        return this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
+    }
+    listUsers() {
+        return this.db.prepare('SELECT id, username, display_name, role, created_at, updated_at FROM users ORDER BY created_at').all();
+    }
+    updateUser(id, updates) {
+        const parts = [];
+        const values = [];
+        if (updates.display_name !== undefined) {
+            parts.push('display_name = ?');
+            values.push(updates.display_name);
+        }
+        if (updates.role !== undefined) {
+            parts.push('role = ?');
+            values.push(updates.role);
+        }
+        if (parts.length === 0)
+            return false;
+        parts.push("updated_at = datetime('now')");
+        values.push(id);
+        const result = this.db.prepare(`UPDATE users SET ${parts.join(', ')} WHERE id = ?`).run(...values);
+        return result.changes > 0;
+    }
+    updateUserPassword(id, passwordHash) {
+        const result = this.db.prepare("UPDATE users SET password_hash = ?, updated_at = datetime('now') WHERE id = ?").run(passwordHash, id);
+        return result.changes > 0;
+    }
+    deleteUser(id) {
+        const result = this.db.prepare('DELETE FROM users WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    // ═══════════════════════════════════════════════════
+    // AUTH SESSIONS
+    // ═══════════════════════════════════════════════════
+    createAuthSession(id, userId, expiresAt, ip, userAgent) {
+        this.db.prepare('INSERT INTO auth_sessions (id, user_id, expires_at, ip_address, user_agent) VALUES (?, ?, ?, ?, ?)').run(id, userId, expiresAt, ip, userAgent);
+    }
+    getAuthSessionUser(sessionId) {
+        const row = this.db.prepare(`
+      SELECT u.* FROM users u
+      JOIN auth_sessions s ON s.user_id = u.id
+      WHERE s.id = ? AND s.expires_at > datetime('now')
+    `).get(sessionId);
+        return row || null;
+    }
+    deleteAuthSession(sessionId) {
+        this.db.prepare('DELETE FROM auth_sessions WHERE id = ?').run(sessionId);
+    }
+    deleteAllUserAuthSessions(userId) {
+        this.db.prepare('DELETE FROM auth_sessions WHERE user_id = ?').run(userId);
+    }
+    // ═══════════════════════════════════════════════════
+    // TOTP SECRETS
+    // ═══════════════════════════════════════════════════
+    saveTotpSecret(userId, secretEncrypted) {
+        this.db.prepare(`
+      INSERT INTO totp_secrets (user_id, secret_encrypted, verified)
+      VALUES (?, ?, 0)
+      ON CONFLICT(user_id) DO UPDATE SET secret_encrypted = excluded.secret_encrypted, verified = 0
+    `).run(userId, secretEncrypted);
+    }
+    getTotpSecret(userId) {
+        return this.db.prepare('SELECT * FROM totp_secrets WHERE user_id = ?').get(userId) || null;
+    }
+    markTotpVerified(userId) {
+        this.db.prepare('UPDATE totp_secrets SET verified = 1 WHERE user_id = ?').run(userId);
+    }
+    deleteTotpSecret(userId) {
+        this.db.prepare('DELETE FROM totp_secrets WHERE user_id = ?').run(userId);
+    }
+    // ═══════════════════════════════════════════════════
+    // PASSKEYS
+    // ═══════════════════════════════════════════════════
+    createPasskey(pk) {
+        this.db.prepare(`
+      INSERT INTO passkeys (id, user_id, credential_id, public_key, counter, transports, device_name)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(pk.id, pk.user_id, pk.credential_id, pk.public_key, pk.counter, pk.transports, pk.device_name);
+    }
+    listPasskeys(userId) {
+        return this.db.prepare('SELECT * FROM passkeys WHERE user_id = ? ORDER BY created_at').all(userId);
+    }
+    findPasskeyByCredentialId(credentialId) {
+        return this.db.prepare('SELECT * FROM passkeys WHERE credential_id = ?').get(credentialId) || null;
+    }
+    updatePasskeyCounter(id, counter) {
+        this.db.prepare('UPDATE passkeys SET counter = ? WHERE id = ?').run(counter, id);
+    }
+    deletePasskey(id, userId) {
+        const result = this.db.prepare('DELETE FROM passkeys WHERE id = ? AND user_id = ?').run(id, userId);
+        return result.changes > 0;
+    }
+    deleteAllUserPasskeys(userId) {
+        this.db.prepare('DELETE FROM passkeys WHERE user_id = ?').run(userId);
+    }
+    getUserIdsWithPasskeys() {
+        return this.db.prepare('SELECT DISTINCT user_id FROM passkeys').all().map(r => r.user_id);
+    }
+    // ═══════════════════════════════════════════════════
+    // ENVIRONMENT OWNERSHIP & SHARING
+    // ═══════════════════════════════════════════════════
+    listEnvironmentsForUser(userId) {
+        return this.db.prepare(`
+      SELECT e.id, e.name, e.created_at, e.owner_user_id,
+        (SELECT COUNT(*) FROM project_environment pe WHERE pe.environment_id = e.id) as project_count
+      FROM environments e
+      WHERE e.owner_user_id = ?
+        OR e.id IN (SELECT environment_id FROM environment_shares WHERE user_id = ?)
+      ORDER BY e.created_at
+    `).all(userId, userId);
+    }
+    createEnvironmentWithOwner(name, ownerUserId) {
+        const id = uuidv4();
+        this.db.prepare('INSERT INTO environments (id, name, owner_user_id) VALUES (?, ?, ?)').run(id, name, ownerUserId);
+        this.db.prepare('INSERT INTO environment_settings (environment_id) VALUES (?)').run(id);
+        return this.getEnvironment(id);
+    }
+    assignUnownedEnvironments(userId) {
+        this.db.prepare('UPDATE environments SET owner_user_id = ? WHERE owner_user_id IS NULL').run(userId);
+    }
+    canAccessEnvironment(userId, envId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM environments
+      WHERE id = ? AND (owner_user_id = ? OR id IN (SELECT environment_id FROM environment_shares WHERE user_id = ?))
+    `).get(envId, userId, userId);
+        return !!row;
+    }
+    canAccessProject(userId, projectId) {
+        const row = this.db.prepare(`
+      SELECT 1 FROM project_environment pe
+      JOIN environments e ON e.id = pe.environment_id
+      WHERE pe.project_id = ?
+        AND (e.owner_user_id = ? OR e.id IN (SELECT environment_id FROM environment_shares WHERE user_id = ?))
+      LIMIT 1
+    `).get(projectId, userId, userId);
+        return !!row;
+    }
+    getEnvironmentOwner(envId) {
+        const row = this.db.prepare('SELECT owner_user_id FROM environments WHERE id = ?').get(envId);
+        return row?.owner_user_id || null;
+    }
+    shareEnvironment(envId, userId, sharedBy) {
+        const id = uuidv4();
+        this.db.prepare(`
+      INSERT OR IGNORE INTO environment_shares (id, environment_id, user_id, shared_by)
+      VALUES (?, ?, ?, ?)
+    `).run(id, envId, userId, sharedBy);
+    }
+    unshareEnvironment(envId, userId) {
+        const result = this.db.prepare('DELETE FROM environment_shares WHERE environment_id = ? AND user_id = ?').run(envId, userId);
+        return result.changes > 0;
+    }
+    listEnvironmentShares(envId) {
+        return this.db.prepare(`
+      SELECT es.*, u.username, u.display_name
+      FROM environment_shares es
+      JOIN users u ON u.id = es.user_id
+      WHERE es.environment_id = ?
+      ORDER BY es.created_at
+    `).all(envId);
+    }
+    // ═══════════════════════════════════════════════════
+    // SESSION METADATA
+    // ═══════════════════════════════════════════════════
+    migrateSessionMetadata() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS session_metadata (
+        session_uuid TEXT PRIMARY KEY,
+        name TEXT,
+        description TEXT,
+        tags_json TEXT NOT NULL DEFAULT '[]',
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+    `);
+        // Migrate data from old session_tags table if it exists
+        try {
+            const oldTags = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_tags'").get();
+            if (oldTags) {
+                const rows = this.db.prepare('SELECT session_uuid, GROUP_CONCAT(tag) as tags FROM session_tags GROUP BY session_uuid').all();
+                for (const row of rows) {
+                    const tags = row.tags.split(',');
+                    this.db.prepare(`
+            INSERT OR IGNORE INTO session_metadata (session_uuid, tags_json)
+            VALUES (?, ?)
+          `).run(row.session_uuid, JSON.stringify(tags));
+                }
+                this.db.exec('DROP TABLE session_tags');
+            }
+        }
+        catch { }
+    }
+    getSessionMetadata(sessionUuid) {
+        const row = this.db.prepare('SELECT session_uuid, name, description, tags_json FROM session_metadata WHERE session_uuid = ?').get(sessionUuid);
+        if (!row)
+            return null;
+        return {
+            sessionUuid: row.session_uuid,
+            name: row.name || undefined,
+            description: row.description || undefined,
+            tags: JSON.parse(row.tags_json || '[]'),
+        };
+    }
+    getMetadataForSessions(sessionUuids) {
+        if (!sessionUuids.length)
+            return {};
+        const placeholders = sessionUuids.map(() => '?').join(',');
+        const rows = this.db.prepare(`SELECT session_uuid, name, description, tags_json FROM session_metadata WHERE session_uuid IN (${placeholders})`).all(...sessionUuids);
+        const result = {};
+        for (const row of rows) {
+            result[row.session_uuid] = {
+                sessionUuid: row.session_uuid,
+                name: row.name || undefined,
+                description: row.description || undefined,
+                tags: JSON.parse(row.tags_json || '[]'),
+            };
+        }
+        return result;
+    }
+    setSessionMetadata(sessionUuid, updates) {
+        const existing = this.getSessionMetadata(sessionUuid);
+        const name = updates.name !== undefined ? updates.name : (existing?.name || null);
+        const description = updates.description !== undefined ? updates.description : (existing?.description || null);
+        const tags = updates.tags !== undefined ? updates.tags : (existing?.tags || []);
+        this.db.prepare(`
+      INSERT INTO session_metadata (session_uuid, name, description, tags_json, updated_at)
+      VALUES (?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(session_uuid) DO UPDATE SET
+        name = excluded.name,
+        description = excluded.description,
+        tags_json = excluded.tags_json,
+        updated_at = excluded.updated_at
+    `).run(sessionUuid, name, description, JSON.stringify(tags));
+    }
+    // ═══════════════════════════════════════════════════
+    // ═══════════════════════════════════════════════════
+    // DATABASE CONNECTIONS (saved connections for Database Explorer)
+    // ═══════════════════════════════════════════════════
+    migrateDatabaseConnections() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS saved_db_connections (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        db_type TEXT NOT NULL,
+        params_json TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        last_used_at TEXT
+      )
+    `);
+    }
+    getSavedDbConnections() {
+        return this.db.prepare(`
+      SELECT id, name, db_type, params_json FROM saved_db_connections ORDER BY last_used_at DESC NULLS LAST, name
+    `).all().map((r) => ({
+            id: r.id,
+            name: r.name,
+            db_type: r.db_type,
+            params: JSON.parse(r.params_json),
+        }));
+    }
+    saveDbConnection(id, name, dbType, params) {
+        this.db.prepare(`
+      INSERT INTO saved_db_connections (id, name, db_type, params_json)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET name = excluded.name, db_type = excluded.db_type, params_json = excluded.params_json
+    `).run(id, name, dbType, JSON.stringify(params));
+    }
+    touchDbConnection(id) {
+        this.db.prepare(`UPDATE saved_db_connections SET last_used_at = datetime('now') WHERE id = ?`).run(id);
+    }
+    deleteDbConnection(id) {
+        this.db.prepare(`DELETE FROM saved_db_connections WHERE id = ?`).run(id);
+    }
+    // ═══════════════════════════════════════════════════
+    // PROJECT CHANGES ("What has been done" tracking)
+    // ═══════════════════════════════════════════════════
+    migrateProjectChanges() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS project_changes (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        short_description TEXT NOT NULL DEFAULT '',
+        long_description TEXT NOT NULL DEFAULT '',
+        tags_json TEXT NOT NULL DEFAULT '[]',
+        approx_files_affected INTEGER NOT NULL DEFAULT 0,
+        session_id TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+        // Migrate from old schema that had a single 'description' column
+        const columns = this.db.prepare("PRAGMA table_info(project_changes)").all();
+        const hasOldDesc = columns.some((c) => c.name === 'description');
+        const hasShortDesc = columns.some((c) => c.name === 'short_description');
+        if (hasOldDesc && !hasShortDesc) {
+            this.db.exec(`
+        ALTER TABLE project_changes ADD COLUMN short_description TEXT NOT NULL DEFAULT '';
+        ALTER TABLE project_changes ADD COLUMN long_description TEXT NOT NULL DEFAULT '';
+        ALTER TABLE project_changes ADD COLUMN tags_json TEXT NOT NULL DEFAULT '[]';
+      `);
+            // Move old description into long_description, truncate for short
+            const rows = this.db.prepare('SELECT id, description FROM project_changes').all();
+            const stmt = this.db.prepare('UPDATE project_changes SET short_description = ?, long_description = ? WHERE id = ?');
+            for (const row of rows) {
+                const short = (row.description || '').split(/[.—\-\n]/)[0].trim().split(/\s+/).slice(0, 10).join(' ');
+                stmt.run(short, row.description || '', row.id);
+            }
+            console.log(`[db] Migrated ${rows.length} project_changes rows to new schema`);
+        }
+        // Drop old 'description' column if it still exists (it has NOT NULL and breaks INSERTs)
+        if (hasOldDesc) {
+            try {
+                this.db.exec('ALTER TABLE project_changes DROP COLUMN description');
+                console.log('[db] Dropped old description column from project_changes');
+            }
+            catch {
+                // SQLite < 3.35.0 doesn't support DROP COLUMN — recreate table
+                const txn = this.db.transaction(() => {
+                    const existing = this.db.prepare('SELECT id, project_id, short_description, long_description, tags_json, approx_files_affected, session_id, created_at FROM project_changes').all();
+                    this.db.exec('DROP TABLE project_changes');
+                    this.db.exec(`
+            CREATE TABLE project_changes (
+              id TEXT PRIMARY KEY,
+              project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+              short_description TEXT NOT NULL DEFAULT '',
+              long_description TEXT NOT NULL DEFAULT '',
+              tags_json TEXT NOT NULL DEFAULT '[]',
+              approx_files_affected INTEGER NOT NULL DEFAULT 0,
+              session_id TEXT,
+              created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+          `);
+                    const ins = this.db.prepare('INSERT INTO project_changes (id, project_id, short_description, long_description, tags_json, approx_files_affected, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
+                    for (const r of existing) {
+                        ins.run(r.id, r.project_id, r.short_description || '', r.long_description || '', r.tags_json || '[]', r.approx_files_affected || 0, r.session_id, r.created_at);
+                    }
+                    console.log(`[db] Recreated project_changes table without old description column (${existing.length} rows preserved)`);
+                });
+                txn();
+            }
+        }
+    }
+    PC_COLS = 'id, project_id, short_description, long_description, tags_json, approx_files_affected, session_id, created_at';
+    listProjectChanges(projectId) {
+        return this.db.prepare(`SELECT ${this.PC_COLS} FROM project_changes WHERE project_id = ? ORDER BY created_at DESC`).all(projectId);
+    }
+    getProjectChange(id) {
+        return this.db.prepare(`SELECT ${this.PC_COLS} FROM project_changes WHERE id = ?`).get(id);
+    }
+    createProjectChange(projectId, shortDesc, longDesc, tags, approxFilesAffected, sessionId) {
+        const id = uuidv4();
+        this.db.prepare('INSERT INTO project_changes (id, project_id, short_description, long_description, tags_json, approx_files_affected, session_id) VALUES (?, ?, ?, ?, ?, ?, ?)').run(id, projectId, shortDesc, longDesc, JSON.stringify(tags), approxFilesAffected, sessionId || null);
+        return this.getProjectChange(id);
+    }
+    updateProjectChange(id, shortDesc, longDesc, tags, approxFilesAffected) {
+        const result = this.db.prepare('UPDATE project_changes SET short_description = ?, long_description = ?, tags_json = ?, approx_files_affected = ? WHERE id = ?').run(shortDesc, longDesc, JSON.stringify(tags), approxFilesAffected, id);
+        return result.changes > 0;
+    }
+    deleteProjectChange(id) {
+        const result = this.db.prepare('DELETE FROM project_changes WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    deleteAllProjectChanges(projectId) {
+        const result = this.db.prepare('DELETE FROM project_changes WHERE project_id = ?').run(projectId);
+        return result.changes;
+    }
+    // LIFECYCLE
+    // ═══════════════════════════════════════════════════
+    close() {
+        try {
+            this.db.close();
+            console.log('[db] Database closed');
+        }
+        catch (err) {
+            console.error('[db] Error closing database:', err);
+        }
+    }
+}
+export const db = new StudioDatabase();