refactor: migrate the web application from Flask to FastAPI.

Dockerfile

@@ -29,5 +29,5 @@ RUN pip install --no-cache-dir -r github_workflow_app/requirements.txt
 # Expose the port
 EXPOSE 7860
 
-# Run the Flask app
+# Run the FastAPI app with uvicorn
 CMD ["uvicorn", "github_workflow_app.app:app", "--host", "0.0.0.0", "--port", "7860"]

github_workflow_app/app.py

@@ -1,18 +1,26 @@
-from flask import Flask, jsonify, request, send_from_directory
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, JSONResponse
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
 import os
 import subprocess
 import dotenv
 import json
 
-app = Flask(__name__, static_folder='.')
-
-# Load environment variables to check for GITHUB_TOKEN if present
+# Load environment variables
 dotenv.load_dotenv(os.path.join(os.path.dirname(__file__), '..', '.env'))
 
 import sys
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 from src.config import get_config_value
 
+app = FastAPI(title="GitHub Workflow Runner")
+
+# Mount static files
+app.mount("/static", StaticFiles(directory=os.path.dirname(__file__)), name="static")
+
+
 def get_github_token_from_git_credentials():
     """Parse ~/.git-credentials to extract GitHub token"""
     git_credentials_path = os.path.expanduser('~/.git-credentials')
@@ -25,15 +33,10 @@ def get_github_token_from_git_credentials():
                 line = line.strip()
                 # Format: https://username:token@github.com
                 if 'github.com' in line and ':' in line and '@' in line:
-                    # Extract the token part between : and @
-                    # https://user:token@github.com
                     try:
-                        # Split by @ first to get the credentials part
-                        creds_part = line.split('@')[0]  # https://user:token
-                        # Remove the protocol
+                        creds_part = line.split('@')[0]
                         if '://' in creds_part:
-                            creds_part = creds_part.split('://')[1]  # user:token
-                        # Split by : to get username and token
+                            creds_part = creds_part.split('://')[1]
                         parts = creds_part.split(':')
                         if len(parts) >= 2:
                             token = parts[1]
@@ -46,35 +49,28 @@ def get_github_token_from_git_credentials():
     
     return None
 
+
 # Configuration - Priority: env var > git-credentials
 GITHUB_TOKEN = get_config_value("GITHUB_TOKEN") or get_config_value("GITHUB_PAT") or get_github_token_from_git_credentials()
 REPO_OWNER = "ElvoroLtd"
 REPO_NAME = "Elvoro"
 WORKFLOW_FILE = "process_csv.yml"
 
-@app.route('/')
-def index():
-    return send_from_directory('.', 'index.html')
 
-@app.route('/api/auth/status')
-def auth_status():
+@app.get("/")
+async def index():
+    return FileResponse(os.path.join(os.path.dirname(__file__), 'index.html'))
+
+
+@app.get("/api/auth/status")
+async def auth_status():
     """Check if we have a valid token by running `gh auth status` or similar"""
-    # If GITHUB_TOKEN is in env, gh should Pick it up automatically.
-    # We can check by running a simple gh command.
-    
-    token = None
-    if GITHUB_TOKEN:
-        token = GITHUB_TOKEN
-        
-    # We can't easily access the client-side token here for the check unless passed,
-    # but the frontend Logic handles the "Using Local Token" vs "Logged in" display.
-    # Here we just check the server-side env.
+    token = GITHUB_TOKEN
     
     if not token:
-        return jsonify({'authenticated': False, 'message': 'Token not found in .env'})
+        return {"authenticated": False, "message": "Token not found in .env"}
     
     try:
-        # Run a simple check
         env = os.environ.copy()
         env['GITHUB_TOKEN'] = token
         cmd = ['gh', 'api', 'user']
@@ -82,14 +78,15 @@ def auth_status():
         
         if result.returncode == 0:
             user_data = json.loads(result.stdout)
-            return jsonify({'authenticated': True, 'user': user_data.get('login')})
+            return {"authenticated": True, "user": user_data.get('login')}
         else:
-             return jsonify({'authenticated': False, 'message': 'Invalid token'})
+            return {"authenticated": False, "message": "Invalid token"}
     except Exception as e:
-        return jsonify({'authenticated': False, 'message': str(e)})
+        return {"authenticated": False, "message": str(e)}
 
-@app.route('/api/env-vars')
-def get_env_vars():
+
+@app.get("/api/env-vars")
+async def get_env_vars(workflow: str = Query(default="process_csv.yml")):
     """
     Parse env file based on selected workflow.
     Strategy:
@@ -97,28 +94,22 @@ def get_env_vars():
     2. Load keys from template file (publisher.env / video_generate.env)
     3. Return keys from template populated with values from .env
     """
-    workflow = request.args.get('workflow', 'process_csv.yml')
-    
     # 1. Load Source of Truth (.env)
     root_dir = os.path.join(os.path.dirname(__file__), '..')
     dotenv_path = os.path.join(root_dir, '.env')
-    
-    # Load into a dict, preserving existing os.environ but prioritizing .env file content for display
-    # dotenv_values returns a dict of values defined in the file
     actual_values = dotenv.dotenv_values(dotenv_path)
     
     # 2. Determine Template File
     if workflow == 'publisher.yml':
         template_filename = 'publisher.env'
     else:
-        # For process_csv.yml, use video_generate.env as the template
         template_filename = 'video_generate.env'
         
     template_path = os.path.join(root_dir, template_filename)
     
     vars_dict = {}
     
-    # 3. specific keys from template, populate with actual values
+    # 3. Specific keys from template, populate with actual values
     if os.path.exists(template_path):
         try:
             with open(template_path, 'r') as f:
@@ -127,37 +118,38 @@ def get_env_vars():
                     if not line or line.startswith('#'):
                         continue
                     
-                    # support both "KEY=VALUE" and just "KEY"
                     if '=' in line:
                         key = line.split('=')[0].strip()
                     else:
                         key = line.strip()
                         
-                    # Populate with value from .env, or empty if not set
                     vars_dict[key] = actual_values.get(key, '')
                     
         except Exception as e:
             print(f"Error reading template {template_filename}: {e}")
     else:
-        # Fallback if template missing: just return everything from .env
-        vars_dict = actual_values
+        vars_dict = dict(actual_values)
+
+    return {"vars": vars_dict}
+
 
-    return jsonify({'vars': vars_dict})
+class TriggerRequest(BaseModel):
+    token: Optional[str] = None
+    inputs: Optional[Dict[str, Any]] = {}
+    ref: Optional[str] = "feature/video-revamp"
+    workflow: Optional[str] = "process_csv.yml"
 
-@app.route('/api/trigger', methods=['POST'])
-def trigger_workflow():
-    data = request.json
-    token = data.get('token') or GITHUB_TOKEN
+
+@app.post("/api/trigger")
+async def trigger_workflow(data: TriggerRequest):
+    token = data.token or GITHUB_TOKEN
     
     if not token:
-        return jsonify({'success': False, 'message': 'No GitHub token provided'}), 401
+        raise HTTPException(status_code=401, detail="No GitHub token provided")
         
-    inputs = data.get('inputs', {})
-    ref = data.get('ref', 'feature/video-revamp')
-    workflow_file = data.get('workflow', 'process_csv.yml')
-    
-    # Construct input flags for gh
-    # gh workflow run <workflow_file> --ref <ref> -f key=value -f key2=value2
+    inputs = data.inputs or {}
+    ref = data.ref
+    workflow_file = data.workflow
     
     cmd = [
         'gh', 'workflow', 'run', workflow_file,
@@ -166,7 +158,7 @@ def trigger_workflow():
     ]
     
     for key, value in inputs.items():
-        if value: # Only add if value is not empty
+        if value:
             cmd.extend(['-f', f"{key}={value}"])
             
     try:
@@ -178,27 +170,30 @@ def trigger_workflow():
         result = subprocess.run(cmd, capture_output=True, text=True, env=env)
         
         if result.returncode == 0:
-            return jsonify({'success': True, 'message': 'Workflow triggered successfully'})
+            return {"success": True, "message": "Workflow triggered successfully"}
         else:
-            return jsonify({'success': False, 'message': f'Failed: {result.stderr}'}), 400
+            raise HTTPException(status_code=400, detail=f"Failed: {result.stderr}")
             
+    except HTTPException:
+        raise
     except Exception as e:
-        return jsonify({'success': False, 'message': str(e)}), 500
+        raise HTTPException(status_code=500, detail=str(e))
+
 
-@app.route('/api/runs')
-def list_runs():
+@app.get("/api/runs")
+async def list_runs(
+    token: Optional[str] = Query(default=None),
+    workflow: str = Query(default="process_csv.yml")
+):
     """List recent workflow runs using gh"""
-    token = request.args.get('token') or GITHUB_TOKEN
-    workflow_file = request.args.get('workflow', 'process_csv.yml')
+    token = token or GITHUB_TOKEN
     
     if not token:
-         return jsonify({'runs': []})
-         
-    # gh run list --workflow <workflow_file> --repo owner/repo --limit 5 --json databaseId,status,conclusion,createdAt,url,name
-    
+        return {"runs": []}
+        
     cmd = [
         'gh', 'run', 'list',
-        '--workflow', workflow_file,
+        '--workflow', workflow,
         '--repo', f"{REPO_OWNER}/{REPO_NAME}",
         '--limit', '5',
         '--json', 'number,status,conclusion,createdAt,url,name'
@@ -212,10 +207,6 @@ def list_runs():
         
         if result.returncode == 0:
             runs = json.loads(result.stdout)
-            # Normalize fields to match previous API response for frontend compatibility
-            # Previous API (GitHub REST) uses: run_number, name, status, conclusion, created_at, html_url
-            # gh json uses: number, name, status, conclusion, createdAt, url
-            
             normalized_runs = []
             for run in runs:
                 normalized_runs.append({
@@ -227,14 +218,15 @@ def list_runs():
                     'html_url': run.get('url')
                 })
                 
-            return jsonify({'workflow_runs': normalized_runs})
+            return {"workflow_runs": normalized_runs}
         else:
-            return jsonify({'runs': [], 'error': result.stderr})
+            return {"runs": [], "error": result.stderr}
     except Exception as e:
-        return jsonify({'runs': [], 'error': str(e)})
+        return {"runs": [], "error": str(e)}
 
-if __name__ == '__main__':
-    print(f"GitHub Workflow Runner (gh CLI)")
-    print(f"Open your browser to: http://localhost:5002")
-    app.run(debug=True, port=5002)
 
+if __name__ == '__main__':
+    import uvicorn
+    print("GitHub Workflow Runner (FastAPI)")
+    print("Open your browser to: http://localhost:5002")
+    uvicorn.run(app, host="127.0.0.1", port=5002)

github_workflow_app/requirements.txt

@@ -1,3 +1,4 @@
-flask
-requests
+fastapi
+uvicorn[standard]
 python-dotenv
+pydantic