fix: Ensure local database is created during app creation, not just app execution

- Modified initializeDatabaseForFramework to actually create databases during app creation for Flask, FastAPI, and Node.js frameworks
- Updated ensureBackendDirectory to verify database initialization for existing backends
- Databases are now persistent across app restarts and created when apps are first created
- Added proper error handling and logging for database initialization

Author: SFARPak

src/ipc/handlers/app_handlers.ts

@@ -43,7 +43,7 @@ import { createLoggedHandler } from "./safe_handle";
 import { getLanguageModelProviders } from "../shared/language_model_helpers";
 import { startProxy } from "../utils/start_proxy_server";
 import { Worker } from "worker_threads";
-import { createFromTemplate, setupBackendFramework, getStartCommandForFramework } from "./createFromTemplate";
+import { createFromTemplate, setupBackendFramework, getStartCommandForFramework, runCommandInDirectory } from "./createFromTemplate";
 import { gitCommit } from "../utils/git_utils";
 import { safeSend } from "../utils/safe_sender";
 import { normalizePath } from "../../../shared/normalizePath";
@@ -232,7 +232,7 @@ async function ensureBackendDirectory(backendPath: string): Promise<void> {
     logger.info(`Created backend directory: ${backendPath}`);
   }
 
-  // Check if backend directory is empty or missing key files
+  // Check if backend directory has the necessary files but ensure database exists
   const backendFiles = fs.readdirSync(backendPath);
   if (backendFiles.length === 0) {
     // Create a basic Python Flask backend structure with database support
@@ -320,6 +320,45 @@ python app.py
       logger.error(`Failed to create backend structure in ${backendPath}:`, error);
       throw error;
     }
+  } else {
+    // Backend directory exists, but ensure database is initialized for existing backends
+    // This handles the case where backend was created during app creation but database needs to be ensured
+    const hasAppPy = backendFiles.includes('app.py');
+    const hasRequirements = backendFiles.includes('requirements.txt');
+
+    if (hasAppPy && hasRequirements) {
+      // Check if this is a Python backend that needs database initialization
+      const framework = await detectPythonFramework(backendPath);
+      if (framework === 'flask') {
+        // Ensure Flask database is initialized
+        try {
+          const initScript = `
+import os
+os.chdir('${backendPath.replace(/\\/g, '\\\\')}')
+
+from models import db
+from app import app
+
+# Create database tables within app context
+with app.app_context():
+    db.create_all()
+    print("Flask database tables verified/created successfully")
+          `;
+          await fsPromises.writeFile(path.join(backendPath, 'init_db.py'), initScript);
+
+          // Run the initialization script
+          await runCommandInDirectory(backendPath, "python init_db.py");
+
+          // Clean up the temporary script
+          await fsPromises.unlink(path.join(backendPath, 'init_db.py')).catch(() => {});
+
+          logger.info(`Ensured Flask database is initialized in ${backendPath}`);
+        } catch (error) {
+          logger.warn(`Failed to ensure Flask database initialization:`, error);
+          // Don't throw - database might already exist
+        }
+      }
+    }
   }
 }
 

src/ipc/handlers/createFromTemplate.ts

@@ -2438,29 +2438,101 @@ async function initializeDatabaseForFramework(backendPath: string, framework: st
       break;
 
     case "fastapi":
-      // For FastAPI, the database tables are created automatically when the app starts
-      // due to the models.Base.metadata.create_all(bind=engine) call in main.py
-      logger.info(`FastAPI database will be initialized when server starts`);
+      // For FastAPI, run a Python script to create database tables
+      try {
+        logger.info(`Creating FastAPI database tables in ${backendPath}`);
+        // Create a temporary script to initialize the database
+        const initScript = `
+import os
+os.chdir('${backendPath.replace(/\\/g, '\\\\')}')
+
+from database import Base, engine
+from models import Item
+
+# Create all tables
+Base.metadata.create_all(bind=engine)
+print("FastAPI database tables created successfully")
+        `;
+        await fs.writeFile(path.join(backendPath, 'init_db.py'), initScript);
+
+        // Run the initialization script
+        await runCommandInDirectory(backendPath, "python init_db.py");
+
+        // Clean up the temporary script
+        await fs.unlink(path.join(backendPath, 'init_db.py')).catch(() => {});
+
+        logger.info(`FastAPI database initialized successfully`);
+      } catch (error) {
+        logger.warn(`Failed to initialize FastAPI database:`, error);
+        throw error;
+      }
       break;
 
     case "flask":
-      // For Flask, the database tables are created automatically when the app starts
-      // due to the db.create_all() call in app.py
-      logger.info(`Flask database will be initialized when server starts`);
+      // For Flask, run a Python script to create database tables
+      try {
+        logger.info(`Creating Flask database tables in ${backendPath}`);
+        // Create a temporary script to initialize the database
+        const initScript = `
+import os
+os.chdir('${backendPath.replace(/\\/g, '\\\\')}')
+
+from models import db
+from app import app
+
+# Create database tables within app context
+with app.app_context():
+    db.create_all()
+    print("Flask database tables created successfully")
+        `;
+        await fs.writeFile(path.join(backendPath, 'init_db.py'), initScript);
+
+        // Run the initialization script
+        await runCommandInDirectory(backendPath, "python init_db.py");
+
+        // Clean up the temporary script
+        await fs.unlink(path.join(backendPath, 'init_db.py')).catch(() => {});
+
+        logger.info(`Flask database initialized successfully`);
+      } catch (error) {
+        logger.warn(`Failed to initialize Flask database:`, error);
+        throw error;
+      }
       break;
 
     case "nodejs":
-      // For Node.js, the database tables are created automatically when the server starts
-      // due to the CREATE TABLE IF NOT EXISTS statement in db.js
-      logger.info(`Node.js SQLite database will be initialized when server starts`);
+      // For Node.js, run a Node.js script to create database tables
+      try {
+        logger.info(`Creating Node.js SQLite database tables in ${backendPath}`);
+        // Create a temporary script to initialize the database
+        const initScript = `
+const path = require('path');
+const { db } = require('./db');
+
+// The db.js file already creates tables on import, so we just need to verify
+console.log('Node.js SQLite database tables created successfully');
+        `;
+        await fs.writeFile(path.join(backendPath, 'init_db.js'), initScript);
+
+        // Run the initialization script
+        await runCommandInDirectory(backendPath, "node init_db.js");
+
+        // Clean up the temporary script
+        await fs.unlink(path.join(backendPath, 'init_db.js')).catch(() => {});
+
+        logger.info(`Node.js SQLite database initialized successfully`);
+      } catch (error) {
+        logger.warn(`Failed to initialize Node.js database:`, error);
+        throw error;
+      }
       break;
 
     default:
       logger.warn(`Unknown framework for database initialization: ${framework}`);
   }
 }
 
-async function runCommandInDirectory(directory: string, command: string): Promise<void> {
+export async function runCommandInDirectory(directory: string, command: string): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     const { spawn } = require('child_process');
     const process = spawn(command, [], {