Implement job metadata extraction and task management features. Add validation for frame range limits, enhance job and task data structures, and introduce new API endpoints for metadata and task retrieval. Update client-side components to handle metadata extraction and display task statuses. Improve error handling in API responses.

2025-11-22 06:37:32 -06:00
parent 27a09aedd6
commit c9ade39ad9
10 changed files with 1078 additions and 88 deletions
--- a/internal/api/jobs.go
+++ b/internal/api/jobs.go
@@ -8,6 +8,7 @@ import (
 	"log"
 	"net/http"
 	"strconv"
+	"strings"
 	"time"

 	"fuego/pkg/types"
@@ -39,6 +40,13 @@ func (s *Server) handleCreateJob(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	// Validate frame range limits (prevent abuse)
+	const maxFrameRange = 10000
+	if req.FrameEnd-req.FrameStart+1 > maxFrameRange {
+		s.respondError(w, http.StatusBadRequest, fmt.Sprintf("Frame range too large. Maximum allowed: %d frames", maxFrameRange))
+		return
+	}
+
 	if req.OutputFormat == "" {
 		req.OutputFormat = "PNG"
 	}
@@ -116,7 +124,7 @@ func (s *Server) handleListJobs(w http.ResponseWriter, r *http.Request) {

 	rows, err := s.db.Query(
 		`SELECT id, user_id, name, status, progress, frame_start, frame_end, output_format, 
-		 allow_parallel_runners, timeout_seconds, created_at, started_at, completed_at, error_message 
+		 allow_parallel_runners, timeout_seconds, blend_metadata, created_at, started_at, completed_at, error_message 
 		 FROM jobs WHERE user_id = ? ORDER BY created_at DESC`,
 		userID,
 	)
@@ -130,11 +138,12 @@ func (s *Server) handleListJobs(w http.ResponseWriter, r *http.Request) {
 	for rows.Next() {
 		var job types.Job
 		var startedAt, completedAt sql.NullTime
+		var blendMetadataJSON sql.NullString

 		err := rows.Scan(
 			&job.ID, &job.UserID, &job.Name, &job.Status, &job.Progress,
 			&job.FrameStart, &job.FrameEnd, &job.OutputFormat, &job.AllowParallelRunners, &job.TimeoutSeconds,
-			&job.CreatedAt, &startedAt, &completedAt, &job.ErrorMessage,
+			&blendMetadataJSON, &job.CreatedAt, &startedAt, &completedAt, &job.ErrorMessage,
 		)
 		if err != nil {
 			s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to scan job: %v", err))
@@ -147,6 +156,12 @@ func (s *Server) handleListJobs(w http.ResponseWriter, r *http.Request) {
 		if completedAt.Valid {
 			job.CompletedAt = &completedAt.Time
 		}
+		if blendMetadataJSON.Valid && blendMetadataJSON.String != "" {
+			var metadata types.BlendMetadata
+			if err := json.Unmarshal([]byte(blendMetadataJSON.String), &metadata); err == nil {
+				job.BlendMetadata = &metadata
+			}
+		}

 		jobs = append(jobs, job)
 	}
@@ -171,15 +186,16 @@ func (s *Server) handleGetJob(w http.ResponseWriter, r *http.Request) {
 	var job types.Job
 	var startedAt, completedAt sql.NullTime

+	var blendMetadataJSON sql.NullString
 	err = s.db.QueryRow(
 		`SELECT id, user_id, name, status, progress, frame_start, frame_end, output_format,
-		 allow_parallel_runners, timeout_seconds, created_at, started_at, completed_at, error_message
+		 allow_parallel_runners, timeout_seconds, blend_metadata, created_at, started_at, completed_at, error_message
 		 FROM jobs WHERE id = ? AND user_id = ?`,
 		jobID, userID,
 	).Scan(
 		&job.ID, &job.UserID, &job.Name, &job.Status, &job.Progress,
 		&job.FrameStart, &job.FrameEnd, &job.OutputFormat, &job.AllowParallelRunners, &job.TimeoutSeconds,
-		&job.CreatedAt, &startedAt, &completedAt, &job.ErrorMessage,
+		&blendMetadataJSON, &job.CreatedAt, &startedAt, &completedAt, &job.ErrorMessage,
 	)

 	if err == sql.ErrNoRows {
@@ -197,6 +213,12 @@ func (s *Server) handleGetJob(w http.ResponseWriter, r *http.Request) {
 	if completedAt.Valid {
 		job.CompletedAt = &completedAt.Time
 	}
+	if blendMetadataJSON.Valid && blendMetadataJSON.String != "" {
+		var metadata types.BlendMetadata
+		if err := json.Unmarshal([]byte(blendMetadataJSON.String), &metadata); err == nil {
+			job.BlendMetadata = &metadata
+		}
+	}

 	s.respondJSON(w, http.StatusOK, job)
 }
@@ -307,6 +329,25 @@ func (s *Server) handleUploadJobFile(w http.ResponseWriter, r *http.Request) {

 	fileID, _ := result.LastInsertId()

+	// If this is a blend file, create a metadata extraction task
+	if strings.HasSuffix(strings.ToLower(header.Filename), ".blend") {
+		// Create metadata extraction task
+		metadataTaskTimeout := 300 // 5 minutes for metadata extraction
+		taskResult, err := s.db.Exec(
+			`INSERT INTO tasks (job_id, frame_start, frame_end, task_type, status, timeout_seconds, max_retries) 
+			 VALUES (?, ?, ?, ?, ?, ?, ?)`,
+			jobID, 0, 0, types.TaskTypeMetadata, types.TaskStatusPending, metadataTaskTimeout, 1,
+		)
+		if err != nil {
+			log.Printf("Failed to create metadata extraction task: %v", err)
+		} else {
+			metadataTaskID, _ := taskResult.LastInsertId()
+			log.Printf("Created metadata extraction task %d for job %d", metadataTaskID, jobID)
+			// Try to distribute the task immediately
+			go s.distributeTasksToRunners()
+		}
+	}
+
 	s.respondJSON(w, http.StatusCreated, map[string]interface{}{
 		"id":        fileID,
 		"file_name": header.Filename,
@@ -524,6 +565,87 @@ func (s *Server) handleStreamVideo(w http.ResponseWriter, r *http.Request) {
 	}
 }

+// handleListJobTasks lists all tasks for a job
+func (s *Server) handleListJobTasks(w http.ResponseWriter, r *http.Request) {
+	userID, err := getUserID(r)
+	if err != nil {
+		s.respondError(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	jobID, err := parseID(r, "id")
+	if err != nil {
+		s.respondError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// Verify job belongs to user
+	var jobUserID int64
+	err = s.db.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	if err == sql.ErrNoRows {
+		s.respondError(w, http.StatusNotFound, "Job not found")
+		return
+	}
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to verify job: %v", err))
+		return
+	}
+	if jobUserID != userID {
+		s.respondError(w, http.StatusForbidden, "Access denied")
+		return
+	}
+
+	rows, err := s.db.Query(
+		`SELECT id, job_id, runner_id, frame_start, frame_end, status, task_type, 
+		 current_step, retry_count, max_retries, output_path, created_at, started_at, 
+		 completed_at, error_message, timeout_seconds
+		 FROM tasks WHERE job_id = ? ORDER BY frame_start ASC`,
+		jobID,
+	)
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query tasks: %v", err))
+		return
+	}
+	defer rows.Close()
+
+	tasks := []types.Task{}
+	for rows.Next() {
+		var task types.Task
+		var runnerID sql.NullInt64
+		var startedAt, completedAt sql.NullTime
+		var timeoutSeconds sql.NullInt64
+
+		err := rows.Scan(
+			&task.ID, &task.JobID, &runnerID, &task.FrameStart, &task.FrameEnd,
+			&task.Status, &task.TaskType, &task.CurrentStep, &task.RetryCount,
+			&task.MaxRetries, &task.OutputPath, &task.CreatedAt, &startedAt,
+			&completedAt, &task.ErrorMessage, &timeoutSeconds,
+		)
+		if err != nil {
+			s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to scan task: %v", err))
+			return
+		}
+
+		if runnerID.Valid {
+			task.RunnerID = &runnerID.Int64
+		}
+		if startedAt.Valid {
+			task.StartedAt = &startedAt.Time
+		}
+		if completedAt.Valid {
+			task.CompletedAt = &completedAt.Time
+		}
+		if timeoutSeconds.Valid {
+			timeout := int(timeoutSeconds.Int64)
+			task.TimeoutSeconds = &timeout
+		}
+
+		tasks = append(tasks, task)
+	}
+
+	s.respondJSON(w, http.StatusOK, tasks)
+}
+
 // handleGetTaskLogs retrieves logs for a specific task
 func (s *Server) handleGetTaskLogs(w http.ResponseWriter, r *http.Request) {
 	userID, err := getUserID(r)
--- a/internal/api/metadata.go
+++ b/internal/api/metadata.go
@@ -0,0 +1,139 @@
+package api
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+
+	"fuego/pkg/types"
+)
+
+// handleSubmitMetadata handles metadata submission from runner
+func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
+	jobID, err := parseID(r, "jobId")
+	if err != nil {
+		s.respondError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// Get runner ID from context (set by runnerAuthMiddleware)
+	runnerID, ok := r.Context().Value("runner_id").(int64)
+	if !ok {
+		s.respondError(w, http.StatusUnauthorized, "runner_id not found in context")
+		return
+	}
+
+	var metadata types.BlendMetadata
+	if err := json.NewDecoder(r.Body).Decode(&metadata); err != nil {
+		s.respondError(w, http.StatusBadRequest, "Invalid metadata JSON")
+		return
+	}
+
+	// Verify job exists
+	var jobUserID int64
+	err = s.db.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	if err == sql.ErrNoRows {
+		s.respondError(w, http.StatusNotFound, "Job not found")
+		return
+	}
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to verify job: %v", err))
+		return
+	}
+
+	// Find the metadata extraction task for this job
+	var taskID int64
+	err = s.db.QueryRow(
+		`SELECT id FROM tasks WHERE job_id = ? AND task_type = ? AND runner_id = ?`,
+		jobID, types.TaskTypeMetadata, runnerID,
+	).Scan(&taskID)
+	if err == sql.ErrNoRows {
+		s.respondError(w, http.StatusNotFound, "Metadata extraction task not found")
+		return
+	}
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to find task: %v", err))
+		return
+	}
+
+	// Convert metadata to JSON
+	metadataJSON, err := json.Marshal(metadata)
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, "Failed to marshal metadata")
+		return
+	}
+
+	// Update job with metadata
+	_, err = s.db.Exec(
+		`UPDATE jobs SET blend_metadata = ? WHERE id = ?`,
+		string(metadataJSON), jobID,
+	)
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to update job metadata: %v", err))
+		return
+	}
+
+	// Mark task as completed
+	_, err = s.db.Exec(
+		`UPDATE tasks SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE id = ?`,
+		types.TaskStatusCompleted, taskID,
+	)
+	if err != nil {
+		log.Printf("Failed to mark metadata task as completed: %v", err)
+	}
+
+	log.Printf("Metadata extracted for job %d: frame_start=%d, frame_end=%d", jobID, metadata.FrameStart, metadata.FrameEnd)
+
+	s.respondJSON(w, http.StatusOK, map[string]string{"message": "Metadata submitted successfully"})
+}
+
+// handleGetJobMetadata retrieves metadata for a job
+func (s *Server) handleGetJobMetadata(w http.ResponseWriter, r *http.Request) {
+	userID, err := getUserID(r)
+	if err != nil {
+		s.respondError(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	jobID, err := parseID(r, "id")
+	if err != nil {
+		s.respondError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// Verify job belongs to user
+	var jobUserID int64
+	var blendMetadataJSON sql.NullString
+	err = s.db.QueryRow(
+		`SELECT user_id, blend_metadata FROM jobs WHERE id = ?`,
+		jobID,
+	).Scan(&jobUserID, &blendMetadataJSON)
+	if err == sql.ErrNoRows {
+		s.respondError(w, http.StatusNotFound, "Job not found")
+		return
+	}
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query job: %v", err))
+		return
+	}
+	if jobUserID != userID {
+		s.respondError(w, http.StatusForbidden, "Access denied")
+		return
+	}
+
+	if !blendMetadataJSON.Valid || blendMetadataJSON.String == "" {
+		s.respondJSON(w, http.StatusOK, nil)
+		return
+	}
+
+	var metadata types.BlendMetadata
+	if err := json.Unmarshal([]byte(blendMetadataJSON.String), &metadata); err != nil {
+		s.respondError(w, http.StatusInternalServerError, "Failed to parse metadata")
+		return
+	}
+
+	s.respondJSON(w, http.StatusOK, metadata)
+}
+
--- a/internal/api/runners.go
+++ b/internal/api/runners.go
@@ -185,6 +185,117 @@ func (s *Server) handleUpdateTaskProgress(w http.ResponseWriter, r *http.Request
 	s.respondJSON(w, http.StatusOK, map[string]string{"message": "Progress updated"})
 }

+// handleUpdateTaskStep handles step start/complete events from runners
+func (s *Server) handleUpdateTaskStep(w http.ResponseWriter, r *http.Request) {
+	// Get runner ID from context (set by runnerAuthMiddleware)
+	runnerID, ok := r.Context().Value("runner_id").(int64)
+	if !ok {
+		s.respondError(w, http.StatusUnauthorized, "runner_id not found in context")
+		return
+	}
+
+	taskID, err := parseID(r, "id")
+	if err != nil {
+		s.respondError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	var req struct {
+		StepName     string `json:"step_name"`
+		Status       string `json:"status"` // "pending", "running", "completed", "failed", "skipped"
+		DurationMs   *int   `json:"duration_ms,omitempty"`
+		ErrorMessage string `json:"error_message,omitempty"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		s.respondError(w, http.StatusBadRequest, "Invalid request body")
+		return
+	}
+
+	// Verify task belongs to runner
+	var taskRunnerID sql.NullInt64
+	err = s.db.QueryRow("SELECT runner_id FROM tasks WHERE id = ?", taskID).Scan(&taskRunnerID)
+	if err == sql.ErrNoRows {
+		s.respondError(w, http.StatusNotFound, "Task not found")
+		return
+	}
+	if err != nil {
+		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to verify task: %v", err))
+		return
+	}
+	if !taskRunnerID.Valid || taskRunnerID.Int64 != runnerID {
+		s.respondError(w, http.StatusForbidden, "Task does not belong to this runner")
+		return
+	}
+
+	now := time.Now()
+	var stepID int64
+
+	// Check if step already exists
+	var existingStepID sql.NullInt64
+	err = s.db.QueryRow(
+		`SELECT id FROM task_steps WHERE task_id = ? AND step_name = ?`,
+		taskID, req.StepName,
+	).Scan(&existingStepID)
+
+	if err == sql.ErrNoRows || !existingStepID.Valid {
+		// Create new step
+		var startedAt *time.Time
+		var completedAt *time.Time
+		if req.Status == string(types.StepStatusRunning) || req.Status == string(types.StepStatusCompleted) || req.Status == string(types.StepStatusFailed) {
+			startedAt = &now
+		}
+		if req.Status == string(types.StepStatusCompleted) || req.Status == string(types.StepStatusFailed) {
+			completedAt = &now
+		}
+
+		result, err := s.db.Exec(
+			`INSERT INTO task_steps (task_id, step_name, status, started_at, completed_at, duration_ms, error_message)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)`,
+			taskID, req.StepName, req.Status, startedAt, completedAt, req.DurationMs, req.ErrorMessage,
+		)
+		if err != nil {
+			s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to create step: %v", err))
+			return
+		}
+		stepID, _ = result.LastInsertId()
+	} else {
+		// Update existing step
+		stepID = existingStepID.Int64
+		var startedAt *time.Time
+		var completedAt *time.Time
+
+		// Get existing started_at if status is running/completed/failed
+		if req.Status == string(types.StepStatusRunning) || req.Status == string(types.StepStatusCompleted) || req.Status == string(types.StepStatusFailed) {
+			var existingStartedAt sql.NullTime
+			s.db.QueryRow(`SELECT started_at FROM task_steps WHERE id = ?`, stepID).Scan(&existingStartedAt)
+			if existingStartedAt.Valid {
+				startedAt = &existingStartedAt.Time
+			} else {
+				startedAt = &now
+			}
+		}
+
+		if req.Status == string(types.StepStatusCompleted) || req.Status == string(types.StepStatusFailed) {
+			completedAt = &now
+		}
+
+		_, err = s.db.Exec(
+			`UPDATE task_steps SET status = ?, started_at = ?, completed_at = ?, duration_ms = ?, error_message = ?
+			 WHERE id = ?`,
+			req.Status, startedAt, completedAt, req.DurationMs, req.ErrorMessage, stepID,
+		)
+		if err != nil {
+			s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to update step: %v", err))
+			return
+		}
+	}
+
+	s.respondJSON(w, http.StatusOK, map[string]interface{}{
+		"step_id": stepID,
+		"message": "Step updated successfully",
+	})
+}
+
 // handleDownloadFileForRunner allows runners to download job files
 func (s *Server) handleDownloadFileForRunner(w http.ResponseWriter, r *http.Request) {
 	jobID, err := parseID(r, "jobId")
@@ -396,6 +507,7 @@ type WSTaskAssignment struct {
 	OutputFormat string   `json:"output_format"`
 	FrameStart   int      `json:"frame_start"`
 	FrameEnd     int      `json:"frame_end"`
+	TaskType     string   `json:"task_type"`
 	InputFiles   []string `json:"input_files"`
 }

@@ -633,20 +745,41 @@ func (s *Server) handleWebSocketTaskComplete(runnerID int64, taskUpdate WSTaskUp
 		taskUpdate.TaskID,
 	).Scan(&jobID, &frameStart, &frameEnd)
 	if err == nil {
+		// Count total tasks excluding failed ones (failed tasks are retried, so we count them)
+		// We exclude tasks that are in a terminal failed state with max retries exceeded
 		var totalTasks, completedTasks int
-		s.db.QueryRow(`SELECT COUNT(*) FROM tasks WHERE job_id = ?`, jobID).Scan(&totalTasks)
+		s.db.QueryRow(
+			`SELECT COUNT(*) FROM tasks WHERE job_id = ? AND status IN (?, ?, ?, ?)`,
+			jobID, types.TaskStatusPending, types.TaskStatusRunning, types.TaskStatusCompleted, types.TaskStatusFailed,
+		).Scan(&totalTasks)
 		s.db.QueryRow(
 			`SELECT COUNT(*) FROM tasks WHERE job_id = ? AND status = ?`,
 			jobID, types.TaskStatusCompleted,
 		).Scan(&completedTasks)

-		progress := float64(completedTasks) / float64(totalTasks) * 100.0
+		// Handle edge cases: division by zero and all tasks cancelled
+		var progress float64
+		if totalTasks == 0 {
+			// All tasks cancelled or no tasks, set progress to 0
+			progress = 0.0
+		} else {
+			progress = float64(completedTasks) / float64(totalTasks) * 100.0
+		}

 		var jobStatus string
 		var outputFormat string
 		s.db.QueryRow(`SELECT output_format FROM jobs WHERE id = ?`, jobID).Scan(&outputFormat)

-		if completedTasks == totalTasks {
+		// Check if all non-cancelled tasks are completed
+		var pendingOrRunningTasks int
+		s.db.QueryRow(
+			`SELECT COUNT(*) FROM tasks 
+			 WHERE job_id = ? AND status IN (?, ?)`,
+			jobID, types.TaskStatusPending, types.TaskStatusRunning,
+		).Scan(&pendingOrRunningTasks)
+
+		if pendingOrRunningTasks == 0 && totalTasks > 0 {
+			// All tasks are either completed or failed/cancelled
 			jobStatus = string(types.JobStatusCompleted)
 			s.db.Exec(
 				`UPDATE jobs SET status = ?, progress = ?, completed_at = ? WHERE id = ?`,
@@ -654,7 +787,20 @@ func (s *Server) handleWebSocketTaskComplete(runnerID int64, taskUpdate WSTaskUp
 			)

 			if outputFormat == "MP4" {
-				go s.generateMP4Video(jobID)
+				// Create a video generation task instead of calling generateMP4Video directly
+				// This prevents race conditions when multiple runners complete frames simultaneously
+				videoTaskTimeout := 86400 // 24 hours for video generation
+				_, err := s.db.Exec(
+					`INSERT INTO tasks (job_id, frame_start, frame_end, task_type, status, timeout_seconds, max_retries) 
+					 VALUES (?, ?, ?, ?, ?, ?, ?)`,
+					jobID, 0, 0, types.TaskTypeVideoGeneration, types.TaskStatusPending, videoTaskTimeout, 1,
+				)
+				if err != nil {
+					log.Printf("Failed to create video generation task for job %d: %v", jobID, err)
+				} else {
+					// Try to distribute the task immediately
+					go s.distributeTasksToRunners()
+				}
 			}
 		} else {
 			jobStatus = string(types.JobStatusRunning)
@@ -712,7 +858,7 @@ func (s *Server) broadcastLogToFrontend(taskID int64, logEntry WSLogEntry) {
 func (s *Server) distributeTasksToRunners() {
 	// Get all pending tasks
 	rows, err := s.db.Query(
-		`SELECT t.id, t.job_id, t.frame_start, t.frame_end, j.allow_parallel_runners, j.status as job_status
+		`SELECT t.id, t.job_id, t.frame_start, t.frame_end, t.task_type, j.allow_parallel_runners, j.status as job_status
 		 FROM tasks t
 		 JOIN jobs j ON t.job_id = j.id
 		 WHERE t.status = ? AND j.status != ?
@@ -731,6 +877,7 @@ func (s *Server) distributeTasksToRunners() {
 		JobID                int64
 		FrameStart           int
 		FrameEnd             int
+		TaskType             string
 		AllowParallelRunners bool
 	}

@@ -740,11 +887,12 @@ func (s *Server) distributeTasksToRunners() {
 			JobID                int64
 			FrameStart           int
 			FrameEnd             int
+			TaskType             string
 			AllowParallelRunners bool
 		}
 		var allowParallel int
 		var jobStatus string
-		err := rows.Scan(&t.TaskID, &t.JobID, &t.FrameStart, &t.FrameEnd, &allowParallel, &jobStatus)
+		err := rows.Scan(&t.TaskID, &t.JobID, &t.FrameStart, &t.FrameEnd, &t.TaskType, &allowParallel, &jobStatus)
 		if err != nil {
 			continue
 		}
@@ -770,13 +918,6 @@ func (s *Server) distributeTasksToRunners() {

 	// Distribute tasks to runners
 	for _, task := range pendingTasks {
-		// Check if task is already assigned
-		var assignedRunnerID sql.NullInt64
-		err := s.db.QueryRow("SELECT runner_id FROM tasks WHERE id = ?", task.TaskID).Scan(&assignedRunnerID)
-		if err == nil && assignedRunnerID.Valid {
-			continue // Already assigned
-		}
-
 		// Find available runner
 		var selectedRunnerID int64
 		for _, runnerID := range connectedRunners {
@@ -812,9 +953,40 @@ func (s *Server) distributeTasksToRunners() {
 			continue // No available runner
 		}

-		// Assign task to runner
+		// Atomically assign task to runner using UPDATE with WHERE runner_id IS NULL
+		// This prevents race conditions when multiple goroutines try to assign the same task
+		now := time.Now()
+		result, err := s.db.Exec(
+			`UPDATE tasks SET runner_id = ?, status = ?, started_at = ? 
+			 WHERE id = ? AND runner_id IS NULL AND status = ?`,
+			selectedRunnerID, types.TaskStatusRunning, now, task.TaskID, types.TaskStatusPending,
+		)
+		if err != nil {
+			log.Printf("Failed to atomically assign task %d: %v", task.TaskID, err)
+			continue
+		}
+
+		// Check if the update actually affected a row (task was successfully assigned)
+		rowsAffected, err := result.RowsAffected()
+		if err != nil {
+			log.Printf("Failed to get rows affected for task %d: %v", task.TaskID, err)
+			continue
+		}
+
+		if rowsAffected == 0 {
+			// Task was already assigned by another goroutine, skip
+			continue
+		}
+
+		// Task was successfully assigned, send via WebSocket
 		if err := s.assignTaskToRunner(selectedRunnerID, task.TaskID); err != nil {
-			log.Printf("Failed to assign task %d to runner %d: %v", task.TaskID, selectedRunnerID, err)
+			log.Printf("Failed to send task %d to runner %d: %v", task.TaskID, selectedRunnerID, err)
+			// Rollback the assignment if WebSocket send fails
+			s.db.Exec(
+				`UPDATE tasks SET runner_id = NULL, status = ?, started_at = NULL 
+				 WHERE id = ?`,
+				types.TaskStatusPending, task.TaskID,
+			)
 		}
 	}
 }
@@ -831,20 +1003,20 @@ func (s *Server) assignTaskToRunner(runnerID int64, taskID int64) error {

 	// Get task details
 	var task WSTaskAssignment
-	var jobName, outputFormat string
+	var jobName, outputFormat, taskType string
 	err := s.db.QueryRow(
-		`SELECT t.job_id, t.frame_start, t.frame_end, j.name, j.output_format
+		`SELECT t.job_id, t.frame_start, t.frame_end, t.task_type, j.name, j.output_format
 		 FROM tasks t JOIN jobs j ON t.job_id = j.id WHERE t.id = ?`,
 		taskID,
-	).Scan(&task.JobID, &task.FrameStart, &task.FrameEnd, &jobName, &outputFormat)
+	).Scan(&task.JobID, &task.FrameStart, &task.FrameEnd, &taskType, &jobName, &outputFormat)
 	if err != nil {
 		return err
 	}

 	task.TaskID = taskID
-	task.JobID = task.JobID
 	task.JobName = jobName
 	task.OutputFormat = outputFormat
+	task.TaskType = taskType

 	// Get input files
 	rows, err := s.db.Query(
@@ -861,14 +1033,15 @@ func (s *Server) assignTaskToRunner(runnerID int64, taskID int64) error {
 		}
 	}

-	// Assign task to runner in database
-	now := time.Now()
-	_, err = s.db.Exec(
-		`UPDATE tasks SET runner_id = ?, status = ?, started_at = ? WHERE id = ?`,
-		runnerID, types.TaskStatusRunning, now, taskID,
-	)
+	// Note: Task is already assigned in database by the atomic update in distributeTasksToRunners
+	// We just need to verify it's still assigned to this runner
+	var assignedRunnerID sql.NullInt64
+	err = s.db.QueryRow("SELECT runner_id FROM tasks WHERE id = ?", taskID).Scan(&assignedRunnerID)
 	if err != nil {
-		return err
+		return fmt.Errorf("task not found: %w", err)
+	}
+	if !assignedRunnerID.Valid || assignedRunnerID.Int64 != runnerID {
+		return fmt.Errorf("task %d is not assigned to runner %d", taskID, runnerID)
 	}

 	// Send task via WebSocket
--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -109,6 +109,8 @@ func (s *Server) setupRoutes() {
 		r.Get("/{id}/files", s.handleListJobFiles)
 		r.Get("/{id}/files/{fileId}/download", s.handleDownloadJobFile)
 		r.Get("/{id}/video", s.handleStreamVideo)
+		r.Get("/{id}/metadata", s.handleGetJobMetadata)
+		r.Get("/{id}/tasks", s.handleListJobTasks)
 		r.Get("/{id}/tasks/{taskId}/logs", s.handleGetTaskLogs)
 		r.Get("/{id}/tasks/{taskId}/logs/ws", s.handleStreamTaskLogsWebSocket)
 		r.Get("/{id}/tasks/{taskId}/steps", s.handleGetTaskSteps)
@@ -153,10 +155,12 @@ func (s *Server) setupRoutes() {
 				return http.HandlerFunc(s.runnerAuthMiddleware(next.ServeHTTP))
 			})
 			r.Post("/tasks/{id}/progress", s.handleUpdateTaskProgress)
+			r.Post("/tasks/{id}/steps", s.handleUpdateTaskStep)
 			r.Get("/files/{jobId}/{fileName}", s.handleDownloadFileForRunner)
 			r.Post("/files/{jobId}/upload", s.handleUploadFileFromRunner)
 			r.Get("/jobs/{jobId}/status", s.handleGetJobStatusForRunner)
 			r.Get("/jobs/{jobId}/files", s.handleGetJobFilesForRunner)
+			r.Post("/jobs/{jobId}/metadata", s.handleSubmitMetadata)
 		})
 	})