feat: implement automatic backend terminal command execution

- Add dyad-run-backend-terminal-cmd tag parser to handle backend commands
- Update all backend framework system prompts (Django, FastAPI, Flask, Node.js) to use dyad tags instead of showing commands in chat
- Implement backend terminal command processing in response_processor.ts
- Commands are now automatically executed in backend/ directory instead of shown in chat interface
- Remove old terminal command listings from system prompts
- Maintain TypeScript compilation compatibility

Author: SFARPak

src/ipc/processors/response_processor.ts

@@ -26,7 +26,9 @@ import {
   getDyadDeleteTags,
   getDyadAddDependencyTags,
   getDyadExecuteSqlTags,
+  getDyadRunBackendTerminalCmdTags,
 } from "../utils/dyad_tag_parser";
+import { runShellCommand } from "../utils/runShellCommand";
 import { storeDbTimestampAtCurrentVersion } from "../utils/neon_timestamp_utils";
 
 import { FileUploadsState } from "../utils/file_uploads_state";
@@ -119,6 +121,7 @@ export async function processFullResponseActions(
     const dyadExecuteSqlQueries = chatWithApp.app.supabaseProjectId
       ? getDyadExecuteSqlTags(fullResponse)
       : [];
+    const dyadRunBackendTerminalCmdTags = getDyadRunBackendTerminalCmdTags(fullResponse);
 
     const message = await db.query.messages.findFirst({
       where: and(
@@ -166,7 +169,38 @@ export async function processFullResponseActions(
         }
       }
       logger.log(`Executed ${dyadExecuteSqlQueries.length} SQL queries`);
-    }
+     }
+
+    // Handle backend terminal command tags
+    if (dyadRunBackendTerminalCmdTags.length > 0) {
+      for (const cmdTag of dyadRunBackendTerminalCmdTags) {
+        try {
+          const backendPath = path.join(appPath, "backend");
+          const cwd = cmdTag.cwd ? path.join(backendPath, cmdTag.cwd) : backendPath;
+
+          logger.log(`Executing backend terminal command: ${cmdTag.command} in ${cwd}`);
+
+          const result = await runShellCommand(`cd "${cwd}" && ${cmdTag.command}`);
+
+          if (result === null) {
+            errors.push({
+              message: `Backend terminal command failed: ${cmdTag.description || cmdTag.command}`,
+              error: `Command execution failed in ${cwd}`,
+            });
+          } else {
+            logger.log(`Backend terminal command succeeded: ${cmdTag.description || cmdTag.command}`);
+            // Add success message to app output
+            // Note: We don't add to writtenFiles since these are not file changes
+          }
+        } catch (error) {
+          errors.push({
+            message: `Backend terminal command failed: ${cmdTag.description || cmdTag.command}`,
+            error: error,
+          });
+        }
+      }
+      logger.log(`Executed ${dyadRunBackendTerminalCmdTags.length} backend terminal commands`);
+     }
 
     // Handle add dependency tags
     if (dyadAddDependencyPackages.length > 0) {

src/ipc/utils/dyad_tag_parser.ts

@@ -137,3 +137,32 @@ export function getDyadCommandTags(fullResponse: string): string[] {
 
   return commands;
 }
+
+export function getDyadRunBackendTerminalCmdTags(fullResponse: string): {
+  command: string;
+  cwd?: string;
+  description?: string;
+}[] {
+  const dyadRunBackendTerminalCmdRegex =
+    /<dyad-run-backend-terminal-cmd([^>]*)>([\s\S]*?)<\/dyad-run-backend-terminal-cmd>/g;
+  const cwdRegex = /cwd="([^"]+)"/;
+  const descriptionRegex = /description="([^"]+)"/;
+
+  let match;
+  const commands: { command: string; cwd?: string; description?: string }[] = [];
+
+  while ((match = dyadRunBackendTerminalCmdRegex.exec(fullResponse)) !== null) {
+    const attributesString = match[1];
+    const command = match[2].trim();
+
+    const cwdMatch = cwdRegex.exec(attributesString);
+    const descriptionMatch = descriptionRegex.exec(attributesString);
+
+    const cwd = cwdMatch?.[1];
+    const description = descriptionMatch?.[1];
+
+    commands.push({ command, cwd, description });
+  }
+
+  return commands;
+}

src/prompts/system_prompt.ts

@@ -181,12 +181,12 @@ When working with Django applications:
 - Use <read_file> to examine existing Django files (models.py, views.py, urls.py, settings.py)
 - Use <search_replace> for precise edits to Django code
 - Use <write_to_file> for creating new Django apps, models, views, etc.
-- Use <run_terminal_cmd> for Django management commands like:
-  - \`python backend/manage.py makemigrations\` - Create database migrations
-  - \`python backend/manage.py migrate\` - Apply database migrations
-  - \`python backend/manage.py runserver\` - Start development server
-  - \`python backend/manage.py startapp <app_name>\` - Create new Django app
-  - \`pip install -r backend/requirements.txt\` - Install Python dependencies
+- Use <dyad-run-backend-terminal-cmd> to execute Django management commands automatically in the backend terminal:
+  - <dyad-run-backend-terminal-cmd description="Install Python dependencies">pip install -r requirements.txt</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Create database migrations">python manage.py makemigrations</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Apply database migrations">python manage.py migrate</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Start development server">python manage.py runserver 8000</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Create new Django app">python manage.py startapp <app_name></dyad-run-backend-terminal-cmd>
 - Use <grep_search> to find patterns across Django codebase
 
 Always explain what you're doing and why, then use the appropriate tools to implement Django solutions. When setting up Django projects, use terminal commands to run migrations and start servers.
@@ -205,22 +205,7 @@ When working with Django applications:
 
 # Django Terminal Commands
 
-Run these commands in the backend terminal after navigating to the backend directory:
-
-**Initial Setup:**
-- Install dependencies: \`pip install -r requirements.txt\`
-- Run database migrations: \`python manage.py migrate\`
-- Create superuser: \`python manage.py createsuperuser\`
-
-**Development Workflow:**
-- Start development server: \`python manage.py runserver 8000\`
-- Create new migrations: \`python manage.py makemigrations\`
-- Apply migrations: \`python manage.py migrate\`
-- Create new Django app: \`python manage.py startapp <app_name>\`
-
-**Production Preparation:**
-- Collect static files: \`python manage.py collectstatic\`
-- Run tests: \`python manage.py test\`
+When you need to execute Django commands, use the <dyad-run-backend-terminal-cmd> tags above. The system will automatically run these commands in the backend terminal for you. Do not show commands in chat - use the dyad tags instead.
 
 # Django Best Practices
 
@@ -244,11 +229,11 @@ When working with FastAPI applications:
 - Use <read_file> to examine existing FastAPI files (main.py, routes, schemas, models)
 - Use <search_replace> for precise edits to FastAPI code
 - Use <write_to_file> for creating new routes, schemas, models, etc.
-- Use <run_terminal_cmd> for FastAPI development commands like:
-  - \`pip install -r backend/requirements.txt\` - Install Python dependencies
-  - \`uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000\` - Start FastAPI server
-  - \`alembic revision --autogenerate -m "message"\` - Create database migrations (if using Alembic)
-  - \`alembic upgrade head\` - Apply database migrations
+- Use <dyad-run-backend-terminal-cmd> to execute FastAPI development commands automatically in the backend terminal:
+  - <dyad-run-backend-terminal-cmd description="Install Python dependencies">pip install -r requirements.txt</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Start FastAPI server">uvicorn main:app --reload --host 0.0.0.0 --port 8000</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Create database migrations">alembic revision --autogenerate -m "migration message"</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Apply database migrations">alembic upgrade head</dyad-run-backend-terminal-cmd>
 - Use <grep_search> to find patterns across FastAPI codebase
 
 Always explain what you're doing and why, then use the appropriate tools to implement FastAPI solutions. When setting up FastAPI projects, use terminal commands to install dependencies and start servers.
@@ -266,25 +251,7 @@ When working with FastAPI applications:
 
 # FastAPI Terminal Commands
 
-Run these commands in the backend terminal after navigating to the backend directory:
-
-**Initial Setup:**
-- Install dependencies: \`pip install -r requirements.txt\`
-- Start development server: \`uvicorn main:app --reload --host 0.0.0.0 --port 8000\`
-
-**Development Workflow:**
-- Run with hot reload: \`uvicorn main:app --reload\`
-- Run on specific port: \`uvicorn main:app --host 0.0.0.0 --port 8000\`
-- Run production server: \`uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4\`
-
-**API Documentation:**
-- View interactive docs: Navigate to \`http://localhost:8000/docs\`
-- View alternative docs: Navigate to \`http://localhost:8000/redoc\`
-
-**Testing:**
-- Run tests: \`pytest\`
-- Run with coverage: \`pytest --cov=.\`
-- Run specific test: \`pytest tests/test_file.py\`
+When you need to execute FastAPI commands, use the <dyad-run-backend-terminal-cmd> tags above. The system will automatically run these commands in the backend terminal for you. Do not show commands in chat - use the dyad tags instead.
 
 # FastAPI Best Practices
 
@@ -309,13 +276,13 @@ When working with Flask applications:
 - Use <read_file> to examine existing Flask files (app.py, routes, models, templates)
 - Use <search_replace> for precise edits to Flask code
 - Use <write_to_file> for creating new routes, models, templates, etc.
-- Use <run_terminal_cmd> for Flask development commands like:
-  - \`pip install -r backend/requirements.txt\` - Install Python dependencies
-  - \`python backend/app.py\` - Start Flask development server
-  - \`flask run\` - Alternative way to start Flask server (with FLASK_APP set)
-  - \`flask db init\` - Initialize Flask-Migrate (if using Flask-SQLAlchemy)
-  - \`flask db migrate\` - Create database migrations
-  - \`flask db upgrade\` - Apply database migrations
+- Use <dyad-run-backend-terminal-cmd> to execute Flask development commands automatically in the backend terminal:
+  - <dyad-run-backend-terminal-cmd description="Install Python dependencies">pip install -r requirements.txt</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Start Flask development server">python app.py</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Alternative Flask start">flask run --host=0.0.0.0 --port=5000</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Initialize Flask-Migrate">flask db init</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Create database migrations">flask db migrate -m "migration message"</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Apply database migrations">flask db upgrade</dyad-run-backend-terminal-cmd>
 - Use <grep_search> to find patterns across Flask codebase
 
 Always explain what you're doing and why, then use the appropriate tools to implement Flask solutions. When setting up Flask projects, use terminal commands to install dependencies and start servers.
@@ -333,27 +300,7 @@ When working with Flask applications:
 
 # Flask Terminal Commands
 
-Run these commands in the backend terminal after navigating to the backend directory:
-
-**Initial Setup:**
-- Install dependencies: \`pip install -r requirements.txt\`
-- Start development server: \`python app.py\`
-- Alternative start: \`flask run --host=0.0.0.0 --port=5000\`
-
-**Database Management (if using Flask-Migrate):**
-- Initialize migrations: \`flask db init\`
-- Create migration: \`flask db migrate -m "migration message"\`
-- Apply migrations: \`flask db upgrade\`
-- Rollback migration: \`flask db downgrade\`
-
-**Development Workflow:**
-- Run with debugger: \`FLASK_ENV=development flask run\`
-- Run on different port: \`flask run --port=8000\`
-- Use Flask CLI: \`export FLASK_APP=app.py && flask run\`
-
-**Testing:**
-- Run tests: \`python -m pytest\`
-- Run with Flask test client: \`python -c "from app import app; app.test_client()"\`
+When you need to execute Flask commands, use the <dyad-run-backend-terminal-cmd> tags above. The system will automatically run these commands in the backend terminal for you. Do not show commands in chat - use the dyad tags instead.
 
 # Flask Best Practices
 
@@ -378,12 +325,12 @@ When working with Node.js applications:
 - Use <read_file> to examine existing Node.js files (server.js, routes, models, controllers)
 - Use <search_replace> for precise edits to Node.js code
 - Use <write_to_file> for creating new routes, models, controllers, middleware, etc.
-- Use <run_terminal_cmd> for Node.js development commands like:
-  - \`npm install\` - Install Node.js dependencies
-  - \`npm start\` - Start production server
-  - \`npm run dev\` - Start development server with auto-reload
-  - \`node backend/server.js\` - Run Node.js server directly
-  - \`npx nodemon backend/server.js\` - Run with auto-restart on changes
+- Use <dyad-run-backend-terminal-cmd> to execute Node.js development commands automatically in the backend terminal:
+  - <dyad-run-backend-terminal-cmd description="Install Node.js dependencies">npm install</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Start production server">npm start</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Start development server">npm run dev</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Run server directly">node server.js</dyad-run-backend-terminal-cmd>
+  - <dyad-run-backend-terminal-cmd description="Run with nodemon">npx nodemon server.js</dyad-run-backend-terminal-cmd>
 - Use <grep_search> to find patterns across Node.js codebase
 
 Always explain what you're doing and why, then use the appropriate tools to implement Node.js solutions. When setting up Node.js projects, use terminal commands to install dependencies and start servers.
@@ -401,32 +348,7 @@ When working with Node.js applications:
 
 # Node.js Terminal Commands
 
-Run these commands in the backend terminal after navigating to the backend directory:
-
-**Initial Setup:**
-- Install dependencies: \`npm install\`
-- Start development server: \`npm run dev\` or \`nodemon server.js\`
-- Start production server: \`npm start\` or \`node server.js\`
-
-**Development Workflow:**
-- Install new package: \`npm install <package-name>\`
-- Install dev dependency: \`npm install --save-dev <package-name>\`
-- Run custom scripts: \`npm run <script-name>\`
-- Check scripts: \`npm run\`
-
-**Database Management (MongoDB example):**
-- Start MongoDB: \`mongod\` (if running locally)
-- Connect to MongoDB: Use MongoDB Compass or CLI tools
-
-**Testing:**
-- Run all tests: \`npm test\`
-- Run tests in watch mode: \`npm run test:watch\`
-- Run specific test: \`npm test -- --testNamePattern="test name"\`
-
-**Build and Deployment:**
-- Build for production: \`npm run build\` (if applicable)
-- Lint code: \`npm run lint\`
-- Format code: \`npm run format\`
+When you need to execute Node.js commands, use the <dyad-run-backend-terminal-cmd> tags above. The system will automatically run these commands in the backend terminal for you. Do not show commands in chat - use the dyad tags instead.
 
 # Node.js Best Practices