@vezlo/assistant-server 1.2.0 → 1.4.0

package/scripts/setup.js

@@ -39,36 +39,18 @@ function question(prompt) {
 async function main() {
   console.clear();
   log('\n🚀 Vezlo Assistant Server Setup Wizard\n', 'bright');
-  log('This wizard will help you configure your server in 3 easy steps:\n', 'blue');
-  log('  1. Database Connection (Supabase or PostgreSQL)');
+  log('This wizard will help you configure your server in 4 easy steps:\n', 'blue');
+  log('  1. Supabase Database Configuration');
   log('  2. OpenAI API Configuration');
-  log('  3. Automatic Table Creation\n');
+  log('  3. Environment Validation');
+  log('  4. Database Migration Setup\n');
 
-  // Step 1: Database Type Selection
+  // Step 1: Supabase Configuration
   log('\n═══════════════════════════════════════════════════════════', 'cyan');
-  log('  STEP 1: Database Configuration', 'bright');
+  log('  STEP 1: Supabase Database Configuration', 'bright');
   log('═══════════════════════════════════════════════════════════\n', 'cyan');
 
-  log('Choose your database type:');
-  log('  [1] Supabase (Recommended)');
-  log('  [2] PostgreSQL (Direct Connection)');
-  log('  [3] Use existing .env file\n');
-
-  const dbChoice = await question('Enter your choice (1-3):');
-
-  let config = {};
-
-  if (dbChoice === '1') {
-    config = await setupSupabase();
-  } else if (dbChoice === '2') {
-    config = await setupPostgreSQL();
-  } else if (dbChoice === '3') {
-    config = await loadExistingConfig();
-  } else {
-    log('\n❌ Invalid choice. Exiting...', 'red');
-    rl.close();
-    return;
-  }
+  const config = await setupSupabase();
 
   // Step 2: OpenAI Configuration
   log('\n═══════════════════════════════════════════════════════════', 'cyan');
@@ -81,146 +63,197 @@ async function main() {
   const aiModel = await question('AI Model (default: gpt-4o):') || 'gpt-4o';
   config.AI_MODEL = aiModel.trim();
 
+  const aiTemperature = await question('AI Temperature (default: 0.7):') || '0.7';
+  config.AI_TEMPERATURE = aiTemperature.trim();
+
+  const aiMaxTokens = await question('AI Max Tokens (default: 1000):') || '1000';
+  config.AI_MAX_TOKENS = aiMaxTokens.trim();
+
   // Step 3: Save Configuration
   log('\n═══════════════════════════════════════════════════════════', 'cyan');
   log('  STEP 3: Save Configuration', 'bright');
   log('═══════════════════════════════════════════════════════════\n', 'cyan');
 
   const envPath = path.join(process.cwd(), '.env');
-  await saveEnvFile(envPath, config);
-
-  log('\n✅ Configuration saved to .env', 'green');
+  log('Preparing to write environment configuration (.env)...', 'yellow');
+  const createdEnv = await saveEnvFile(envPath, config);
+  if (createdEnv) {
+    log(`✅ Configuration saved to ${envPath}`, 'green');
+  } else {
+    log('ℹ️  Using existing .env (no overwrite). Review values as needed.', 'yellow');
+  }
 
-  // Step 4: Database Setup
+  // Step 4: Environment Validation
   log('\n═══════════════════════════════════════════════════════════', 'cyan');
-  log('  STEP 4: Database Setup', 'bright');
+  log('  STEP 4: Environment Validation', 'bright');
   log('═══════════════════════════════════════════════════════════\n', 'cyan');
 
-  const setupDb = await question('Setup database tables now? (y/n):');
+  const validationStatus = await validateEnvironment(config);
 
-  if (setupDb.toLowerCase() === 'y') {
-    await setupDatabase(config);
-  } else {
-    log('\n⚠️  Skipping database setup.', 'yellow');
-    log('   Run "npx vezlo-setup-db" later to create tables.\n', 'yellow');
-  }
+  // Step 5: Database Migration Setup
+  log('\n═══════════════════════════════════════════════════════════', 'cyan');
+  log('  STEP 5: Database Migration Setup', 'bright');
+  log('═══════════════════════════════════════════════════════════\n', 'cyan');
+
+  const migrationStatus = await setupMigrations(config, validationStatus) || { migrations: validationStatus.database === 'success' ? 'success' : 'skipped' };
 
-  // Final Instructions
+  // Final Instructions / Summary
   log('\n═══════════════════════════════════════════════════════════', 'green');
   log('  🎉 Setup Complete!', 'bright');
   log('═══════════════════════════════════════════════════════════\n', 'green');
 
-  log('Next steps:');
+  // Summary
+  log('Summary:', 'bright');
+  const supaStatus = validationStatus.supabaseApi === 'success' ? 'OK' : (validationStatus.supabaseApi === 'failed' ? 'FAILED' : 'UNKNOWN');
+  log(`  Supabase API: ${supaStatus === 'OK' ? colors.green + 'OK' : supaStatus === 'FAILED' ? colors.red + 'FAILED' : colors.yellow + 'UNKNOWN'}${colors.reset}`);
+  log(`  Database: ${validationStatus.database === 'success' ? colors.green + 'OK' : colors.red + (validationStatus.database === 'skipped' ? 'SKIPPED' : 'FAILED')}${colors.reset}`);
+  log(`  Migrations: ${migrationStatus.migrations === 'success' ? colors.green + 'OK' : migrationStatus.migrations === 'skipped' ? colors.yellow + 'SKIPPED' : colors.red + 'FAILED'}${colors.reset}`);
+
+  log('\nNext steps:');
   log('  1. Review your .env file');
-  log('  2. Start the server: ' + colors.bright + 'vezlo-server' + colors.reset);
-  log('  3. Visit: ' + colors.bright + 'http://localhost:3000/health' + colors.reset);
-  log('  4. API docs: ' + colors.bright + 'http://localhost:3000/docs' + colors.reset + '\n');
+  if (migrationStatus.migrations !== 'success') {
+    log('  2. Run database migrations: ' + colors.bright + 'npm run migrate:latest' + colors.reset);
+    log('     Or via API (after starting server): ' + colors.bright + 'GET /api/migrate?key=$MIGRATION_SECRET_KEY' + colors.reset);
+    log('  3. Start the server: ' + colors.bright + 'vezlo-server' + colors.reset);
+    log('  4. Visit: ' + colors.bright + 'http://localhost:3000/health' + colors.reset);
+    log('  5. API docs: ' + colors.bright + 'http://localhost:3000/docs' + colors.reset);
+    log('  6. Test API: ' + colors.bright + 'curl http://localhost:3000/health' + colors.reset + '\n');
+  } else {
+    log('  2. Start the server: ' + colors.bright + 'vezlo-server' + colors.reset);
+    log('  3. Visit: ' + colors.bright + 'http://localhost:3000/health' + colors.reset);
+    log('  4. API docs: ' + colors.bright + 'http://localhost:3000/docs' + colors.reset);
+    log('  5. Test API: ' + colors.bright + 'curl http://localhost:3000/health' + colors.reset + '\n');
+  }
 
   rl.close();
+  // Ensure graceful exit even if any handles remain
+  setImmediate(() => process.exit(0));
 }
 
 async function setupSupabase() {
   log('\n📦 Supabase Configuration\n', 'blue');
   log('You can find these values in your Supabase Dashboard:', 'yellow');
-  log('  Settings > API > Project URL & API Keys\n', 'yellow');
+  log('  • API keys & URL: Settings > API > Project URL & API Keys', 'yellow');
+  log('  • Database params: Settings > Database > Connection info', 'yellow');
+  log('  • Optional pooling: Connect > Connection Pooling > Session Pooler > View parameters\n', 'yellow');
 
+  // Get Supabase URL and extract project ID for defaults
   const supabaseUrl = await question('Supabase Project URL (https://xxx.supabase.co):');
-  const supabaseAnonKey = await question('Supabase Anon Key:');
-  const supabaseServiceKey = await question('Supabase Service Role Key:');
-
-  // Validate connection
-  log('\n🔄 Testing connection...', 'yellow');
+  const projectId = supabaseUrl.match(/https:\/\/(.+?)\.supabase\.co/)?.[1];
+  
+  if (!projectId) {
+    log('\n❌ Invalid Supabase URL format. Please use: https://your-project.supabase.co', 'red');
+    throw new Error('Invalid Supabase URL');
+  }
 
+  const supabaseServiceKey = await question('Supabase Service Role Key:');
+  const supabaseAnonKey = await question('Supabase Anon Key (optional, press Enter to skip):');
+
+  // Show defaults and ask for each database parameter
+  log('\n📊 Database Connection Details:', 'blue');
+  
+  const dbHost = await question(`Database Host (default: db.${projectId}.supabase.co):`) || `db.${projectId}.supabase.co`;
+  const dbPort = await question('Database Port (default: 5432):') || '5432';
+  const dbName = await question('Database Name (default: postgres):') || 'postgres';
+  const dbUser = await question(`Database User (default: postgres.${projectId}):`) || `postgres.${projectId}`;
+  const dbPassword = await question('Database Password (from Settings > Database):');
+
+  // Validate Supabase connection (same as validate script)
+  log('\n🔄 Validating Supabase connection...', 'yellow');
+  
   try {
     const client = createClient(supabaseUrl.trim(), supabaseServiceKey.trim());
-    const { data, error } = await client.from('_test').select('*').limit(1);
+    const { error } = await client.from('vezlo_conversations').select('count').limit(0);
 
-    // This will fail but confirms we can connect
-    if (error && error.code !== 'PGRST204' && error.code !== '42P01') {
-      log(`\n⚠️  Warning: ${error.message}`, 'yellow');
-      log('Continuing with setup...\n', 'yellow');
-    } else {
-      log('✅ Connection successful!\n', 'green');
+    if (error && error.code !== 'PGRST116') {
+      throw error;
     }
+
+    log('✅ Supabase connection successful!\n', 'green');
   } catch (err) {
-    log(`\n⚠️  Warning: Could not verify connection`, 'yellow');
-    log('Continuing with setup...\n', 'yellow');
+    log(`❌ Supabase connection failed: ${err.message}`, 'red');
+    log('⚠️  Continuing setup. You can fix credentials and rerun validations later.', 'yellow');
   }
 
-  // Extract database connection info from Supabase URL
-  const projectId = supabaseUrl.match(/https:\/\/(.+?)\.supabase\.co/)?.[1];
-  const dbHost = projectId ? `db.${projectId}.supabase.co` : '';
+  // Validate database connection (same as validate script)
+  log('\n🔄 Validating database connection...', 'yellow');
+  
+  let client;
+  try {
+    const { Client } = require('pg');
+    
+    client = new Client({
+      host: dbHost.trim(),
+      port: parseInt(dbPort.trim()),
+      database: dbName.trim(),
+      user: dbUser.trim(),
+      password: dbPassword.trim(),
+      ssl: { rejectUnauthorized: false }
+    });
 
-  log('Database connection details:', 'blue');
-  log(`  Host: ${dbHost}`);
-  log(`  Port: 5432`);
-  log(`  Database: postgres`);
-  log(`  User: postgres\n`);
+    // Handle connection errors quietly for normal shutdowns
+    client.on('error', (err) => {
+      const msg = (err && err.message) ? err.message : String(err);
+      if (msg && (msg.includes('client_termination') || msg.includes(':shutdown'))) {
+        return; // ignore normal termination noise
+      }
+      console.error('Database connection error:', msg);
+    });
 
-  const dbPassword = await question('Supabase Database Password (from Settings > Database):');
+    await client.connect();
+    log('✅ Database connection successful!\n', 'green');
+    await client.end();
+  } catch (err) {
+    log(`❌ Database connection failed: ${err.message}`, 'red');
+    log('⚠️  Continuing setup. Migrations will be skipped; see summary for next steps.', 'yellow');
+  }
 
   return {
     SUPABASE_URL: supabaseUrl.trim(),
-    SUPABASE_ANON_KEY: supabaseAnonKey.trim(),
+    SUPABASE_ANON_KEY: supabaseAnonKey.trim() || '',
     SUPABASE_SERVICE_KEY: supabaseServiceKey.trim(),
-    SUPABASE_DB_HOST: dbHost,
-    SUPABASE_DB_PORT: '5432',
-    SUPABASE_DB_NAME: 'postgres',
-    SUPABASE_DB_USER: 'postgres',
+    SUPABASE_DB_HOST: dbHost.trim(),
+    SUPABASE_DB_PORT: dbPort.trim(),
+    SUPABASE_DB_NAME: dbName.trim(),
+    SUPABASE_DB_USER: dbUser.trim(),
     SUPABASE_DB_PASSWORD: dbPassword.trim(),
     PORT: '3000',
     NODE_ENV: 'development',
-    CORS_ORIGINS: 'http://localhost:3000,http://localhost:5173'
+    CORS_ORIGINS: 'http://localhost:3000,http://localhost:5173',
+    BASE_URL: 'http://localhost:3000'
   };
 }
 
-async function setupPostgreSQL() {
-  log('\n🗄️  PostgreSQL Configuration\n', 'blue');
-
-  const host = await question('Database Host (localhost):') || 'localhost';
-  const port = await question('Database Port (5432):') || '5432';
-  const database = await question('Database Name (postgres):') || 'postgres';
-  const user = await question('Database User (postgres):') || 'postgres';
-  const password = await question('Database Password:');
-
-  return {
-    SUPABASE_DB_HOST: host.trim(),
-    SUPABASE_DB_PORT: port.trim(),
-    SUPABASE_DB_NAME: database.trim(),
-    SUPABASE_DB_USER: user.trim(),
-    SUPABASE_DB_PASSWORD: password.trim(),
-    PORT: '3000',
-    NODE_ENV: 'development',
-    CORS_ORIGINS: 'http://localhost:3000,http://localhost:5173'
-  };
-}
+// Handle errors and cleanup
+process.on('SIGINT', () => {
+  log('\n\n⚠️  Setup cancelled by user', 'yellow');
+  rl.close();
+  process.exit(0);
+});
 
-async function loadExistingConfig() {
-  const envPath = path.join(process.cwd(), '.env');
+// Run the wizard
+main().catch(error => {
+  log(`\n❌ Setup failed: ${error.message}`, 'red');
+  rl.close();
+  process.exit(1);
+});
 
-  if (!fs.existsSync(envPath)) {
-    log('\n❌ No .env file found in current directory', 'red');
-    throw new Error('.env file not found');
+async function saveEnvFile(envPath, config) {
+  // Don't overwrite existing .env
+  if (fs.existsSync(envPath)) {
+    log('\n⚠️  .env already exists. Skipping overwrite. Please review values manually.', 'yellow');
+    return false;
   }
-
-  log('\n✅ Loading configuration from .env\n', 'green');
-
-  const envContent = fs.readFileSync(envPath, 'utf8');
-  const config = {};
-
-  envContent.split('\n').forEach(line => {
-    const match = line.match(/^([^=:#]+)=(.*)$/);
-    if (match) {
-      const key = match[1].trim();
-      const value = match[2].trim();
-      config[key] = value;
+  // Generate a secure migration secret if not provided
+  try {
+    const crypto = require('crypto');
+    if (!config.MIGRATION_SECRET_KEY) {
+      config.MIGRATION_SECRET_KEY = crypto.randomBytes(32).toString('hex');
     }
-  });
-
-  return config;
-}
-
-async function saveEnvFile(envPath, config) {
+  } catch (_) {
+    // Fallback simple key if crypto unavailable (very unlikely)
+    config.MIGRATION_SECRET_KEY = config.MIGRATION_SECRET_KEY || `msk_${Date.now()}`;
+  }
   const envContent = `# Vezlo Assistant Server Configuration
 # Generated by setup wizard on ${new Date().toISOString()}
 
@@ -232,6 +265,9 @@ LOG_LEVEL=info
 # CORS Configuration
 CORS_ORIGINS=${config.CORS_ORIGINS || 'http://localhost:3000,http://localhost:5173'}
 
+# Swagger Base URL
+BASE_URL=${config.BASE_URL || 'http://localhost:3000'}
+
 # Rate Limiting
 RATE_LIMIT_WINDOW=60000
 RATE_LIMIT_MAX=100
@@ -251,8 +287,8 @@ SUPABASE_DB_PASSWORD=${config.SUPABASE_DB_PASSWORD || ''}
 # OpenAI Configuration
 OPENAI_API_KEY=${config.OPENAI_API_KEY || 'sk-your-openai-api-key'}
 AI_MODEL=${config.AI_MODEL || 'gpt-4o'}
-AI_TEMPERATURE=0.7
-AI_MAX_TOKENS=1000
+AI_TEMPERATURE=${config.AI_TEMPERATURE || '0.7'}
+AI_MAX_TOKENS=${config.AI_MAX_TOKENS || '1000'}
 
 # Organization Settings
 ORGANIZATION_NAME=Vezlo
@@ -261,66 +297,156 @@ ASSISTANT_NAME=Vezlo Assistant
 # Knowledge Base
 CHUNK_SIZE=1000
 CHUNK_OVERLAP=200
+
+# Migration Security
+MIGRATION_SECRET_KEY=${config.MIGRATION_SECRET_KEY}
 `;
 
   fs.writeFileSync(envPath, envContent, 'utf8');
+  return true;
 }
 
-async function setupDatabase(config) {
-  log('\n🔄 Setting up database tables...', 'yellow');
+async function validateEnvironment(config) {
+  log('🔄 Validating environment configuration...', 'yellow');
 
+  // Test Supabase connection (same as validate script)
   try {
-    const { Client } = require('pg');
+    const client = createClient(config.SUPABASE_URL, config.SUPABASE_SERVICE_KEY);
+    const { error } = await client.from('vezlo_conversations').select('count').limit(0);
+    
+    if (error && error.code !== 'PGRST116') {
+      throw error;
+    }
+    
+    log('✅ Supabase API connection validated', 'green');
+  } catch (err) {
+    log(`❌ Supabase API validation failed: ${err.message}`, 'red');
+    // non-blocking; proceed to DB check anyway
+    // return partial status so caller can decide
+    // (we'll still attempt DB validation)
+  }
 
-    const client = new Client({
+  // Test database connection (same as validate script)
+  log('\n🔄 Validating database connection...', 'yellow');
+  let client;
+  try {
+    const { Client } = require('pg');
+    
+    client = new Client({
       host: config.SUPABASE_DB_HOST,
-      port: parseInt(config.SUPABASE_DB_PORT || '5432'),
+      port: parseInt(config.SUPABASE_DB_PORT),
       database: config.SUPABASE_DB_NAME,
       user: config.SUPABASE_DB_USER,
       password: config.SUPABASE_DB_PASSWORD,
       ssl: { rejectUnauthorized: false }
     });
 
+    // Handle connection errors quietly for normal shutdowns
+    client.on('error', (err) => {
+      const msg = (err && err.message) ? err.message : String(err);
+      if (msg && (msg.includes('client_termination') || msg.includes(':shutdown'))) {
+        return; // ignore normal termination noise
+      }
+      console.error('Database connection error:', msg);
+    });
+
     await client.connect();
-    log('✅ Connected to database', 'green');
+    log('✅ Database connection validated', 'green');
+    await client.end();
+  } catch (err) {
+    log(`❌ Database validation failed: ${err.message}`, 'red');
+    log('⚠️  Continuing setup; migrations will be skipped.', 'yellow');
+    return { supabaseApi: 'unknown', database: 'failed' };
+  }
 
-    // Read schema file
-    const schemaPath = path.join(__dirname, '..', 'database-schema.sql');
+  log('✅ Environment validation complete!\n', 'green');
+  return { supabaseApi: 'success', database: 'success' };
+}
 
-    if (!fs.existsSync(schemaPath)) {
-      log('❌ database-schema.sql not found', 'red');
-      return;
-    }
+async function setupMigrations(config, validationStatus) {
+  log('🔄 Checking migration status...', 'yellow');
 
-    const schema = fs.readFileSync(schemaPath, 'utf8');
+  if (validationStatus.database !== 'success') {
+    log('⚠️  Skipping migrations because database validation failed.', 'yellow');
+    return { migrations: 'skipped' };
+  }
 
-    log('🔄 Creating tables...', 'yellow');
-    await client.query(schema);
+  try {
+    const { Client } = require('pg');
+    const client = new Client({
+      host: config.SUPABASE_DB_HOST,
+      port: parseInt(config.SUPABASE_DB_PORT),
+      database: config.SUPABASE_DB_NAME,
+      user: config.SUPABASE_DB_USER,
+      password: config.SUPABASE_DB_PASSWORD,
+      ssl: { rejectUnauthorized: false }
+    });
 
-    log('✅ Database tables created successfully!', 'green');
+    await client.connect();
 
-    // Verify tables
-    const result = await client.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-      AND table_name IN ('conversations', 'messages', 'message_feedback', 'knowledge_items')
-      ORDER BY table_name
+    // Check if migrations table exists
+    const migrationTableExists = await client.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name = 'knex_migrations'
+      );
     `);
 
-    log('\n📊 Verified tables:', 'blue');
-    result.rows.forEach(row => {
-      log(`   ✓ ${row.table_name}`, 'green');
-    });
-    log('');
+    if (!migrationTableExists.rows[0].exists) {
+      log('📋 No migrations table found. Database needs initial setup.', 'blue');
+      
+      const runMigrations = await question('Run initial database migrations now? (y/n):');
+      
+      if (runMigrations.toLowerCase() === 'y') {
+        log('🔄 Running migrations...', 'yellow');
+        
+        // Set environment variables for migration
+        process.env.SUPABASE_DB_HOST = config.SUPABASE_DB_HOST;
+        process.env.SUPABASE_DB_PORT = config.SUPABASE_DB_PORT;
+        process.env.SUPABASE_DB_NAME = config.SUPABASE_DB_NAME;
+        process.env.SUPABASE_DB_USER = config.SUPABASE_DB_USER;
+        process.env.SUPABASE_DB_PASSWORD = config.SUPABASE_DB_PASSWORD;
+        
+        const { execSync } = require('child_process');
+        execSync('npm run migrate:latest', { stdio: 'inherit' });
+        
+        log('✅ Migrations completed successfully!', 'green');
+        return { migrations: 'success' };
+      } else {
+        log('\n⚠️  Migrations skipped. You can run them later using:', 'yellow');
+        log('   npm run migrate:latest', 'cyan');
+        log('   Or via API: GET /api/migrate?key=your-migration-secret\n', 'cyan');
+        return { migrations: 'skipped' };
+      }
+    } else {
+      // Check migration status
+      const migrationStatus = await client.query(`
+        SELECT COUNT(*) as count FROM knex_migrations;
+      `);
+      
+      log(`📊 Found ${migrationStatus.rows[0].count} completed migrations`, 'blue');
+      
+      const runPending = await question('Check for pending migrations? (y/n):');
+      
+      if (runPending.toLowerCase() === 'y') {
+        log('🔄 Checking for pending migrations...', 'yellow');
+        
+        const { execSync } = require('child_process');
+        execSync('npm run migrate:latest', { stdio: 'inherit' });
+        
+        log('✅ Migration check completed!', 'green');
+        return { migrations: 'success' };
+      }
+    }
 
     await client.end();
-
-  } catch (error) {
-    log(`\n❌ Database setup failed: ${error.message}`, 'red');
-    log('\nYou can manually run the setup later:', 'yellow');
-    log('  1. Copy database-schema.sql to your Supabase SQL Editor', 'yellow');
-    log('  2. Execute the SQL to create tables\n', 'yellow');
+  } catch (err) {
+    log(`❌ Migration setup failed: ${err.message}`, 'red');
+    log('\nYou can run migrations manually later:', 'yellow');
+    log('   npm run migrate:latest', 'cyan');
+    log('   Or via API: GET /api/migrate?key=your-migration-secret\n', 'cyan');
+    return { migrations: 'failed' };
   }
 }
 

package/scripts/validate-db.js

@@ -74,10 +74,11 @@ async function validateDatabase() {
   // Test database connection and validate tables
   log('Validating database tables...', 'yellow');
 
+  let client;
   try {
     const { Client } = require('pg');
 
-    const client = new Client({
+    client = new Client({
       host: process.env.SUPABASE_DB_HOST,
       port: parseInt(process.env.SUPABASE_DB_PORT || '5432'),
       database: process.env.SUPABASE_DB_NAME || 'postgres',
@@ -86,14 +87,19 @@ async function validateDatabase() {
       ssl: { rejectUnauthorized: false }
     });
 
+    // Handle connection errors
+    client.on('error', (err) => {
+      console.error('Database connection error:', err.message);
+    });
+
     await client.connect();
 
     // Check required tables
     const requiredTables = [
-      'conversations',
-      'messages',
-      'message_feedback',
-      'knowledge_items'
+      'vezlo_conversations',
+      'vezlo_messages',
+      'vezlo_message_feedback',
+      'vezlo_knowledge_items'
     ];
 
     const result = await client.query(`
@@ -111,7 +117,9 @@ async function validateDatabase() {
       log(`\n❌ Missing required tables:`, 'red');
       missingTables.forEach(table => log(`   - ${table}`, 'red'));
       log('\nRun the setup wizard: ' + colors.bright + 'npx vezlo-setup' + colors.reset + '\n', 'yellow');
-      await client.end();
+      if (client) {
+        await client.end();
+      }
       process.exit(1);
     }
 
@@ -156,10 +164,19 @@ async function validateDatabase() {
     log('Your server is ready to start:', 'cyan');
     log('  ' + colors.bright + 'vezlo-server' + colors.reset + '\n');
 
-    await client.end();
+    if (client) {
+      await client.end();
+    }
 
   } catch (error) {
     log(`\n❌ Database validation failed: ${error.message}\n`, 'red');
+    if (client) {
+      try {
+        await client.end();
+      } catch (closeError) {
+        // Ignore close errors
+      }
+    }
     process.exit(1);
   }
 }