sql-kite 1.0.6 → 1.0.8

package/server/routes/snapshots.js

@@ -0,0 +1,322 @@
+import { copyFileSync, statSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { closeBranchConnection } from '../db/connections.js';
+
+export default async function snapshotsRoutes(fastify, options) {
+  /**
+   * List snapshots for current branch
+   */
+  fastify.get('/', async (request, reply) => {
+    const snapshotsPath = join(fastify.projectPath, '.studio', 'snapshots');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // Ensure snapshots directory exists
+      if (!existsSync(snapshotsPath)) {
+        mkdirSync(snapshotsPath, { recursive: true });
+      }
+
+      // Get snapshots for current branch only
+      const snapshots = metaDb.prepare(`
+        SELECT * FROM snapshots
+        WHERE branch = ?
+        ORDER BY id DESC
+      `).all(currentBranch);
+
+      return snapshots.map(snapshot => {
+        const filePath = join(snapshotsPath, snapshot.filename);
+        let exists = false;
+        let size = snapshot.size;
+
+        try {
+          const stats = statSync(filePath);
+          exists = stats.isFile();
+          size = stats.size;
+        } catch (e) {
+          exists = false;
+        }
+
+        return {
+          id: snapshot.id,
+          branch: snapshot.branch,
+          filename: snapshot.filename,
+          name: snapshot.name,
+          description: snapshot.description,
+          type: snapshot.type || 'manual',
+          size,
+          createdAt: snapshot.created_at,
+          exists
+        };
+      });
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Create snapshot from current branch
+   */
+  fastify.post('/', async (request, reply) => {
+    const { name, description, type = 'manual' } = request.body;
+    const snapshotsPath = join(fastify.projectPath, '.studio', 'snapshots');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    if (!name) {
+      return reply.code(400).send({ error: 'Snapshot name is required' });
+    }
+
+    // Validate type
+    const validTypes = ['manual', 'auto-before-migration', 'auto-before-promote', 'import-baseline', 'auto-risky-query'];
+    const snapshotType = validTypes.includes(type) ? type : 'manual';
+
+    try {
+      // Ensure snapshots directory exists
+      if (!existsSync(snapshotsPath)) {
+        mkdirSync(snapshotsPath, { recursive: true });
+      }
+
+      // Get current branch's DB file
+      const branchInfo = metaDb.prepare(`
+        SELECT db_file FROM branches WHERE name = ?
+      `).get(currentBranch);
+
+      if (!branchInfo) {
+        return reply.code(404).send({ error: 'Current branch not found' });
+      }
+
+      const sourceDbPath = join(fastify.projectPath, branchInfo.db_file);
+
+      // Create snapshot filename with timestamp
+      const timestamp = Date.now();
+      const sanitizedName = name.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 30);
+      const snapshotFilename = `${currentBranch}-${sanitizedName}-${timestamp}.snapshot.db`;
+      const snapshotPath = join(snapshotsPath, snapshotFilename);
+
+      // Checkpoint WAL before copying (ensures all data is in main DB file)
+      const db = fastify.getUserDb();
+      db.pragma('wal_checkpoint(FULL)');
+
+      // Copy database file
+      copyFileSync(sourceDbPath, snapshotPath);
+
+      // Get file size
+      const stats = statSync(snapshotPath);
+
+      // Record snapshot in meta DB
+      const result = metaDb.prepare(`
+        INSERT INTO snapshots (branch, filename, name, size, description, type)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(currentBranch, snapshotFilename, name, stats.size, description || '', snapshotType);
+
+      // Log event
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'snapshot_created', ?)
+      `).run(currentBranch, JSON.stringify({
+        name,
+        filename: snapshotFilename,
+        size: stats.size,
+        snapshot_type: snapshotType
+      }));
+
+      return {
+        id: result.lastInsertRowid,
+        branch: currentBranch,
+        filename: snapshotFilename,
+        name,
+        size: stats.size,
+        description: description || '',
+        type: snapshotType
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Restore snapshot (current branch only)
+   */
+  fastify.post('/restore/:id', async (request, reply) => {
+    const { id } = request.params;
+    const snapshotsPath = join(fastify.projectPath, '.studio', 'snapshots');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      // Get snapshot
+      const snapshot = metaDb.prepare(`
+        SELECT * FROM snapshots WHERE id = ?
+      `).get(id);
+
+      if (!snapshot) {
+        return reply.code(404).send({ error: 'Snapshot not found' });
+      }
+
+      // Verify snapshot belongs to current branch
+      if (snapshot.branch !== currentBranch) {
+        return reply.code(400).send({
+          error: `Cannot restore snapshot from "${snapshot.branch}" while on "${currentBranch}". Switch branches first.`
+        });
+      }
+
+      const snapshotPath = join(snapshotsPath, snapshot.filename);
+
+      // Verify snapshot file exists
+      if (!existsSync(snapshotPath)) {
+        return reply.code(404).send({ error: 'Snapshot file not found' });
+      }
+
+      // Get current branch's DB file
+      const branchInfo = metaDb.prepare(`
+        SELECT db_file FROM branches WHERE name = ?
+      `).get(currentBranch);
+
+      if (!branchInfo) {
+        return reply.code(404).send({ error: 'Branch not found' });
+      }
+
+      const dbPath = join(fastify.projectPath, branchInfo.db_file);
+
+      // Close current branch DB connection
+      closeBranchConnection(fastify.projectPath, currentBranch);
+
+      // Copy snapshot over current DB
+      copyFileSync(snapshotPath, dbPath);
+
+      // Also remove WAL and SHM files (force fresh start)
+      ['.wal', '.shm'].forEach(ext => {
+        const walPath = dbPath + ext;
+        if (existsSync(walPath)) {
+          try {
+            unlinkSync(walPath);
+          } catch (e) {
+            // Ignore
+          }
+        }
+      });
+
+      // Log restore event
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'snapshot_restored', ?)
+      `).run(currentBranch, JSON.stringify({
+        snapshot_id: id,
+        snapshot_name: snapshot.name,
+        filename: snapshot.filename
+      }));
+
+      return {
+        success: true,
+        message: 'Snapshot restored successfully',
+        snapshot: {
+          id: snapshot.id,
+          name: snapshot.name,
+          branch: snapshot.branch
+        }
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Delete snapshot
+   */
+  fastify.delete('/:id', async (request, reply) => {
+    const { id } = request.params;
+    const snapshotsPath = join(fastify.projectPath, '.studio', 'snapshots');
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      const snapshot = metaDb.prepare(`
+        SELECT * FROM snapshots WHERE id = ?
+      `).get(id);
+
+      if (!snapshot) {
+        return reply.code(404).send({ error: 'Snapshot not found' });
+      }
+
+      // Optional: Only allow deleting snapshots from current branch
+      if (snapshot.branch !== currentBranch) {
+        return reply.code(400).send({
+          error: `Cannot delete snapshot from "${snapshot.branch}" while on "${currentBranch}"`
+        });
+      }
+
+      // Delete from meta DB
+      metaDb.prepare(`DELETE FROM snapshots WHERE id = ?`).run(id);
+
+      // Also delete the actual snapshot file
+      const snapshotFilePath = join(snapshotsPath, snapshot.filename);
+      try {
+        if (existsSync(snapshotFilePath)) {
+          unlinkSync(snapshotFilePath);
+        }
+      } catch (fileErr) {
+        // Log but don't fail if file deletion fails
+        console.warn('Failed to delete snapshot file:', fileErr.message);
+      }
+
+      // Log event
+      metaDb.prepare(`
+        INSERT INTO events (branch, type, data)
+        VALUES (?, 'snapshot_deleted', ?)
+      `).run(currentBranch, JSON.stringify({
+        snapshot_id: id,
+        snapshot_name: snapshot.name
+      }));
+
+      return { success: true };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Get snapshot details
+   */
+  fastify.get('/:id', async (request, reply) => {
+    const { id } = request.params;
+    const snapshotsPath = join(fastify.projectPath, '.studio', 'snapshots');
+    const metaDb = fastify.getMetaDb();
+
+    try {
+      const snapshot = metaDb.prepare(`
+        SELECT * FROM snapshots WHERE id = ?
+      `).get(id);
+
+      if (!snapshot) {
+        return reply.code(404).send({ error: 'Snapshot not found' });
+      }
+
+      const filePath = join(snapshotsPath, snapshot.filename);
+      let exists = false;
+      let size = snapshot.size;
+
+      try {
+        const stats = statSync(filePath);
+        exists = stats.isFile();
+        size = stats.size;
+      } catch (e) {
+        exists = false;
+      }
+
+      return {
+        id: snapshot.id,
+        branch: snapshot.branch,
+        filename: snapshot.filename,
+        name: snapshot.name,
+        description: snapshot.description,
+        type: snapshot.type || 'manual',
+        size,
+        createdAt: snapshot.created_at,
+        exists
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+}

package/server/routes/tables.js

@@ -0,0 +1,121 @@
+export default async function tablesRoutes(fastify, options) {
+  // List all tables
+  fastify.get('/', async (request, reply) => {
+    const db = fastify.getUserDb();
+    
+    const tables = db.prepare(`
+      SELECT name, sql
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND name NOT LIKE 'sqlite_%'
+        AND name NOT LIKE '_studio_%'
+      ORDER BY name
+    `).all();
+    
+    return tables.map(table => ({
+      name: table.name,
+      sql: table.sql
+    }));
+  });
+  
+  // Get table info
+  fastify.get('/:tableName', async (request, reply) => {
+    const { tableName } = request.params;
+    const db = fastify.getUserDb();
+    
+    try {
+      // Get columns
+      const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+      
+      // Get row count
+      const countResult = db.prepare(`SELECT COUNT(*) as count FROM ${tableName}`).get();
+      
+      // Get CREATE statement
+      const tableInfo = db.prepare(`
+        SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?
+      `).get(tableName);
+      
+      return {
+        name: tableName,
+        columns: columns.map(col => ({
+          name: col.name,
+          type: col.type,
+          notNull: col.notnull === 1,
+          defaultValue: col.dflt_value,
+          primaryKey: col.pk === 1
+        })),
+        rowCount: countResult.count,
+        sql: tableInfo?.sql
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+  
+  // Get table data with pagination
+  fastify.get('/:tableName/data', async (request, reply) => {
+    const { tableName } = request.params;
+    const { limit = 100, offset = 0 } = request.query;
+    const db = fastify.getUserDb();
+    
+    try {
+      const rows = db.prepare(`
+        SELECT * FROM ${tableName}
+        LIMIT ? OFFSET ?
+      `).all(parseInt(limit), parseInt(offset));
+      
+      const totalResult = db.prepare(`SELECT COUNT(*) as total FROM ${tableName}`).get();
+      
+      return {
+        data: rows,
+        total: totalResult.total,
+        limit: parseInt(limit),
+        offset: parseInt(offset)
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+  
+  // Create table
+  fastify.post('/', async (request, reply) => {
+    const { sql } = request.body;
+    const db = fastify.getUserDb();
+    const metaDb = fastify.getMetaDb();
+    
+    try {
+      db.exec(sql);
+      
+      // Log event
+      metaDb.prepare(`
+        INSERT INTO events (type, data)
+        VALUES ('table_created', ?)
+      `).run(JSON.stringify({ sql }));
+      
+      return { success: true };
+    } catch (error) {
+      reply.code(400).send({ error: error.message });
+    }
+  });
+  
+  // Drop table
+  fastify.delete('/:tableName', async (request, reply) => {
+    const { tableName } = request.params;
+    const db = fastify.getUserDb();
+    const metaDb = fastify.getMetaDb();
+    
+    try {
+      db.exec(`DROP TABLE ${tableName}`);
+      
+      // Log event
+      metaDb.prepare(`
+        INSERT INTO events (type, data)
+        VALUES ('table_dropped', ?)
+      `).run(JSON.stringify({ tableName }));
+      
+      return { success: true };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+}

package/server/routes/timeline.js

@@ -0,0 +1,108 @@
+export default async function timelineRoutes(fastify, options) {
+  /**
+   * Get timeline events for current branch
+   */
+  fastify.get('/', async (request, reply) => {
+    const { limit = 50, offset = 0, all_branches } = request.query;
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      let events, totalResult;
+
+      if (all_branches === 'true') {
+        // Show events from all branches
+        events = metaDb.prepare(`
+          SELECT id, branch, type, data, created_at
+          FROM events
+          ORDER BY id DESC
+          LIMIT ? OFFSET ?
+        `).all(parseInt(limit), parseInt(offset));
+
+        totalResult = metaDb.prepare(`SELECT COUNT(*) as total FROM events`).get();
+      } else {
+        // Show events from current branch only (default)
+        events = metaDb.prepare(`
+          SELECT id, branch, type, data, created_at
+          FROM events
+          WHERE branch = ?
+          ORDER BY id DESC
+          LIMIT ? OFFSET ?
+        `).all(currentBranch, parseInt(limit), parseInt(offset));
+
+        totalResult = metaDb.prepare(`
+          SELECT COUNT(*) as total FROM events WHERE branch = ?
+        `).get(currentBranch);
+      }
+
+      return {
+        events: events.map(event => ({
+          id: event.id,
+          branch: event.branch,
+          type: event.type,
+          data: JSON.parse(event.data),
+          createdAt: event.created_at,
+          isCurrentBranch: event.branch === currentBranch
+        })),
+        currentBranch,
+        total: totalResult.total,
+        limit: parseInt(limit),
+        offset: parseInt(offset)
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Clear timeline for current branch
+   */
+  fastify.delete('/', async (request, reply) => {
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      metaDb.prepare(`DELETE FROM events WHERE branch = ?`).run(currentBranch);
+
+      return {
+        success: true,
+        branch: currentBranch,
+        message: `Timeline cleared for branch "${currentBranch}"`
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+
+  /**
+   * Get timeline summary/stats
+   */
+  fastify.get('/stats', async (request, reply) => {
+    const metaDb = fastify.getMetaDb();
+    const currentBranch = fastify.getCurrentBranch();
+
+    try {
+      const stats = metaDb.prepare(`
+        SELECT
+          type,
+          COUNT(*) as count
+        FROM events
+        WHERE branch = ?
+        GROUP BY type
+        ORDER BY count DESC
+      `).all(currentBranch);
+
+      const totalEvents = metaDb.prepare(`
+        SELECT COUNT(*) as total FROM events WHERE branch = ?
+      `).get(currentBranch);
+
+      return {
+        branch: currentBranch,
+        total: totalEvents.total,
+        by_type: stats
+      };
+    } catch (error) {
+      reply.code(500).send({ error: error.message });
+    }
+  });
+}

package/src/commands/import-server.js

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
 
 import { spawn } from 'child_process'
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
 import chalk from 'chalk'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
+import { getServerEntryPath } from '../utils/paths.js'
 
 export default function importServerCommand(port = 3000) {
   console.log(chalk.cyan('→ Starting import server...'))
@@ -13,7 +10,7 @@ export default function importServerCommand(port = 3000) {
   console.log(chalk.dim('  Mode: Import-only'))
   console.log('')
 
-  const serverPath = join(__dirname, '../../../server/src/index.js')
+  const serverPath = getServerEntryPath()
 
   const serverProcess = spawn('node', [serverPath], {
     stdio: 'inherit',

package/src/commands/import.js

@@ -1,17 +1,14 @@
 #!/usr/bin/env node
 
 import { existsSync, statSync, accessSync, constants, writeFileSync, mkdirSync } from 'fs'
-import { resolve, extname, basename, join, dirname } from 'path'
-import { fileURLToPath } from 'url'
+import { resolve, extname, basename, join } from 'path'
 import Database from 'better-sqlite3'
 import chalk from 'chalk'
 import { spawn } from 'child_process'
 import http from 'http'
 import open from 'open'
 import { findFreePort } from '../utils/port-finder.js'
-import { ensureSqlKiteDirs, LOGS_DIR } from '../utils/paths.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
+import { ensureSqlKiteDirs, LOGS_DIR, SQL_KITE_HOME, getStudioOutPath, getServerEntryPath } from '../utils/paths.js'
 
 export default async function importCommand(dbPath) {
   ensureSqlKiteDirs()
@@ -136,8 +133,7 @@ export default async function importCommand(dbPath) {
   console.log('')
 
   // Store import session data
-  const homeDir = process.env.HOME || process.env.USERPROFILE
-  const sqlKiteDir = join(homeDir, '.sql-kite')
+  const sqlKiteDir = SQL_KITE_HOME
   const sessionFile = join(sqlKiteDir, 'import-pending.json')
 
   // Ensure .sql-kite directory exists
@@ -223,7 +219,7 @@ export default async function importCommand(dbPath) {
   console.log('')
   console.log(chalk.dim(`Session saved to: ${sessionFile}`))
 
-  const studioPath = join(__dirname, '../../../studio/out')
+  const studioPath = getStudioOutPath()
   if (!existsSync(studioPath)) {
     console.log(chalk.red(`\n✗ Studio UI not built yet`))
     console.log(chalk.dim(`   Run: ${chalk.cyan(`cd packages/studio && npm run build`)}`))
@@ -234,7 +230,7 @@ export default async function importCommand(dbPath) {
     const { port, alreadyRunning } = await getImportServerPort()
 
     if (!alreadyRunning) {
-      const serverPath = join(__dirname, '../../../server/src/index.js')
+      const serverPath = getServerEntryPath()
       const logPath = join(LOGS_DIR, `import-server-${Date.now()}.log`)
       const out = []
       const serverProcess = spawn('node', [serverPath], {

package/src/commands/start.js

@@ -1,7 +1,6 @@
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { join } from 'path';
 import http from 'http';
 import chalk from 'chalk';
 import ora from 'ora';
@@ -9,12 +8,12 @@ import open from 'open';
 import {
   getProjectPath,
   getProjectServerInfoPath,
-  projectExists
+  projectExists,
+  getStudioOutPath,
+  getServerEntryPath
 } from '../utils/paths.js';
 import { findFreePort } from '../utils/port-finder.js';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 // Helper function to check if server is ready
 async function waitForServer(port, maxAttempts = 30) {
   for (let i = 0; i < maxAttempts; i++) {
@@ -50,7 +49,7 @@ export async function startCommand(name) {
   }
   
   // Check if studio is built
-  const studioPath = join(__dirname, '../../../studio/out');
+  const studioPath = getStudioOutPath();
   if (!existsSync(studioPath)) {
     console.log(chalk.red(`✗ Studio UI not built yet`));
     console.log(chalk.dim(`   Run: ${chalk.cyan(`cd packages/studio && npm run build`)}`));
@@ -80,7 +79,7 @@ export async function startCommand(name) {
     const projectPath = getProjectPath(name);
     
     // Path to server package
-    const serverPath = join(__dirname, '../../../server/src/index.js');
+    const serverPath = getServerEntryPath();
     
     // Spawn server process
     const serverProcess = spawn('node', [serverPath], {

package/src/commands/stop.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { getProjectServerInfoPath, projectExists } from '../utils/paths.js';
 import { releasePort } from '../utils/port-finder.js';
+import { execSync } from 'child_process';
 
 export async function stopCommand(name) {
   if (!projectExists(name)) {
@@ -22,7 +23,7 @@ export async function stopCommand(name) {
   try {
     const serverInfo = JSON.parse(readFileSync(serverInfoPath, 'utf-8'));
 
-    // Send SIGTERM signal
+    // Try graceful shutdown first
     try {
       process.kill(serverInfo.pid, 'SIGTERM');
     } catch (killError) {
@@ -49,7 +50,11 @@ export async function stopCommand(name) {
     if (!processTerminated) {
       // Force kill if graceful shutdown timed out
       try {
-        process.kill(serverInfo.pid, 'SIGKILL');
+        if (process.platform === 'win32') {
+          execSync(`taskkill /PID ${serverInfo.pid} /F /T`, { stdio: 'ignore' });
+        } else {
+          process.kill(serverInfo.pid, 'SIGKILL');
+        }
         await new Promise(resolve => setTimeout(resolve, 500));
       } catch (e) {
         // Process might already be gone