something

internal/api/admin.go

@@ -131,14 +131,19 @@ func (s *Server) handleVerifyRunner(w http.ResponseWriter, r *http.Request) {
 
 	// Check if runner exists
 	var exists bool
-	err = s.db.QueryRow("SELECT EXISTS(SELECT 1 FROM runners WHERE id = ?)", runnerID).Scan(&exists)
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow("SELECT EXISTS(SELECT 1 FROM runners WHERE id = ?)", runnerID).Scan(&exists)
+	})
 	if err != nil || !exists {
 		s.respondError(w, http.StatusNotFound, "Runner not found")
 		return
 	}
 
 	// Mark runner as verified
-	_, err = s.db.Exec("UPDATE runners SET verified = 1 WHERE id = ?", runnerID)
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec("UPDATE runners SET verified = 1 WHERE id = ?", runnerID)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to verify runner: %v", err))
 		return
@@ -157,14 +162,19 @@ func (s *Server) handleDeleteRunner(w http.ResponseWriter, r *http.Request) {
 
 	// Check if runner exists
 	var exists bool
-	err = s.db.QueryRow("SELECT EXISTS(SELECT 1 FROM runners WHERE id = ?)", runnerID).Scan(&exists)
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow("SELECT EXISTS(SELECT 1 FROM runners WHERE id = ?)", runnerID).Scan(&exists)
+	})
 	if err != nil || !exists {
 		s.respondError(w, http.StatusNotFound, "Runner not found")
 		return
 	}
 
 	// Delete runner
-	_, err = s.db.Exec("DELETE FROM runners WHERE id = ?", runnerID)
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec("DELETE FROM runners WHERE id = ?", runnerID)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to delete runner: %v", err))
 		return
@@ -175,17 +185,31 @@ func (s *Server) handleDeleteRunner(w http.ResponseWriter, r *http.Request) {
 
 // handleListRunnersAdmin lists all runners with admin details
 func (s *Server) handleListRunnersAdmin(w http.ResponseWriter, r *http.Request) {
-	rows, err := s.db.Query(
+	var rows *sql.Rows
+	err := s.db.With(func(conn *sql.DB) error {
+		var err error
+		rows, err = conn.Query(
 		`SELECT id, name, hostname, status, last_heartbeat, capabilities,
 		 api_key_id, api_key_scope, priority, created_at
 		 FROM runners ORDER BY created_at DESC`,
 	)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query runners: %v", err))
 		return
 	}
 	defer rows.Close()
 
+	// Get the set of currently connected runners via WebSocket
+	// This is the source of truth for online status
+	s.runnerConnsMu.RLock()
+	connectedRunners := make(map[int64]bool)
+	for runnerID := range s.runnerConns {
+		connectedRunners[runnerID] = true
+	}
+	s.runnerConnsMu.RUnlock()
+
 	runners := []map[string]interface{}{}
 	for rows.Next() {
 		var runner types.Runner
@@ -202,11 +226,21 @@ func (s *Server) handleListRunnersAdmin(w http.ResponseWriter, r *http.Request)
 			return
 		}
 
+		// Override status based on actual WebSocket connection state
+		// The WebSocket connection is the source of truth for runner status
+		actualStatus := runner.Status
+		if connectedRunners[runner.ID] {
+			actualStatus = types.RunnerStatusOnline
+		} else if runner.Status == types.RunnerStatusOnline {
+			// Database says online but not connected via WebSocket - mark as offline
+			actualStatus = types.RunnerStatusOffline
+		}
+
 		runners = append(runners, map[string]interface{}{
 			"id":             runner.ID,
 			"name":           runner.Name,
 			"hostname":       runner.Hostname,
-			"status":         runner.Status,
+			"status":         actualStatus,
 			"last_heartbeat": runner.LastHeartbeat,
 			"capabilities":   runner.Capabilities,
 			"api_key_id":     apiKeyID.Int64,
@@ -228,10 +262,15 @@ func (s *Server) handleListUsers(w http.ResponseWriter, r *http.Request) {
 		firstUserID = 0
 	}
 
-	rows, err := s.db.Query(
+	var rows *sql.Rows
+	err = s.db.With(func(conn *sql.DB) error {
+		var err error
+		rows, err = conn.Query(
 		`SELECT id, email, name, oauth_provider, is_admin, created_at 
 		 FROM users ORDER BY created_at DESC`,
 	)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query users: %v", err))
 		return
@@ -253,7 +292,9 @@ func (s *Server) handleListUsers(w http.ResponseWriter, r *http.Request) {
 
 		// Get job count for this user
 		var jobCount int
-		err = s.db.QueryRow("SELECT COUNT(*) FROM jobs WHERE user_id = ?", userID).Scan(&jobCount)
+		err = s.db.With(func(conn *sql.DB) error {
+			return conn.QueryRow("SELECT COUNT(*) FROM jobs WHERE user_id = ?", userID).Scan(&jobCount)
+		})
 		if err != nil {
 			jobCount = 0 // Default to 0 if query fails
 		}
@@ -283,18 +324,25 @@ func (s *Server) handleGetUserJobs(w http.ResponseWriter, r *http.Request) {
 
 	// Verify user exists
 	var exists bool
-	err = s.db.QueryRow("SELECT EXISTS(SELECT 1 FROM users WHERE id = ?)", userID).Scan(&exists)
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow("SELECT EXISTS(SELECT 1 FROM users WHERE id = ?)", userID).Scan(&exists)
+	})
 	if err != nil || !exists {
 		s.respondError(w, http.StatusNotFound, "User not found")
 		return
 	}
 
-	rows, err := s.db.Query(
+	var rows *sql.Rows
+	err = s.db.With(func(conn *sql.DB) error {
+		var err error
+		rows, err = conn.Query(
 		`SELECT id, user_id, job_type, name, status, progress, frame_start, frame_end, output_format, 
 		 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,
 	)
+		return err
+	})
 	if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to query jobs: %v", err))
 		return

internal/api/metadata.go

@@ -2,8 +2,6 @@ package api
 
 import (
 	"archive/tar"
-	"bufio"
-	"bytes"
 	"database/sql"
 	_ "embed"
 	"encoding/json"
@@ -13,10 +11,10 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 
+	"jiggablend/pkg/executils"
 	"jiggablend/pkg/scripts"
 	"jiggablend/pkg/types"
 )
@@ -44,7 +42,9 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 
 	// Verify job exists
 	var jobUserID int64
-	err = s.db.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.QueryRow("SELECT user_id FROM jobs WHERE id = ?", jobID).Scan(&jobUserID)
+	})
 	if err == sql.ErrNoRows {
 		s.respondError(w, http.StatusNotFound, "Job not found")
 		return
@@ -57,30 +57,36 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 	// Find the metadata extraction task for this job
 	// First try to find task assigned to this runner, then fall back to any metadata task for this job
 	var taskID int64
-	err = s.db.QueryRow(
+	err = s.db.With(func(conn *sql.DB) error {
+		err := conn.QueryRow(
 		`SELECT id FROM tasks WHERE job_id = ? AND task_type = ? AND runner_id = ?`,
 		jobID, types.TaskTypeMetadata, runnerID,
 	).Scan(&taskID)
 	if err == sql.ErrNoRows {
 		// Fall back to any metadata task for this job (in case assignment changed)
-		err = s.db.QueryRow(
+			err = conn.QueryRow(
 			`SELECT id FROM tasks WHERE job_id = ? AND task_type = ? ORDER BY created_at DESC LIMIT 1`,
 			jobID, types.TaskTypeMetadata,
 		).Scan(&taskID)
 		if err == sql.ErrNoRows {
+				return fmt.Errorf("metadata extraction task not found")
+			}
+			if err != nil {
+				return err
+			}
+			// Update the task to be assigned to this runner if it wasn't already
+			conn.Exec(
+				`UPDATE tasks SET runner_id = ? WHERE id = ? AND runner_id IS NULL`,
+				runnerID, taskID,
+			)
+		}
+		return err
+	})
+	if err != nil {
+		if err.Error() == "metadata extraction task not found" {
 			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
-		}
-		// Update the task to be assigned to this runner if it wasn't already
-		s.db.Exec(
-			`UPDATE tasks SET runner_id = ? WHERE id = ? AND runner_id IS NULL`,
-			runnerID, taskID,
-		)
-	} else if err != nil {
 		s.respondError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to find task: %v", err))
 		return
 	}
@@ -93,20 +99,27 @@ func (s *Server) handleSubmitMetadata(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Update job with metadata
-	_, err = s.db.Exec(
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec(
 		`UPDATE jobs SET blend_metadata = ? WHERE id = ?`,
 		string(metadataJSON), jobID,
 	)
+		return err
+	})
 	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,
-	)
+	err = s.db.With(func(conn *sql.DB) error {
+		_, err := conn.Exec(`UPDATE tasks SET status = ? WHERE id = ?`, types.TaskStatusCompleted, taskID)
+		if err != nil {
+			return err
+		}
+		_, err = conn.Exec(`UPDATE tasks SET completed_at = CURRENT_TIMESTAMP WHERE id = ?`, taskID)
+		return err
+	})
 	if err != nil {
 		log.Printf("Failed to mark metadata task as completed: %v", err)
 	} else {
@@ -136,10 +149,12 @@ func (s *Server) handleGetJobMetadata(w http.ResponseWriter, r *http.Request) {
 	// Verify job belongs to user
 	var jobUserID int64
 	var blendMetadataJSON sql.NullString
-	err = s.db.QueryRow(
+	err = s.db.With(func(conn *sql.DB) error {
+		return conn.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
@@ -245,64 +260,23 @@ func (s *Server) extractMetadataFromContext(jobID int64) (*types.BlendMetadata,
 		return nil, fmt.Errorf("failed to get relative path for blend file: %w", err)
 	}
 
-	// Execute Blender with Python script
-	cmd := exec.Command("blender", "-b", blendFileRel, "--python", "extract_metadata.py")
-	cmd.Dir = tmpDir
+	// Execute Blender with Python script using executils
+	result, err := executils.RunCommand(
+		"blender",
+		[]string{"-b", blendFileRel, "--python", "extract_metadata.py"},
+		tmpDir,
+		nil, // inherit environment
+		jobID,
+		nil, // no process tracker needed for metadata extraction
+	)
 
-	// Capture stdout and stderr
-	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
-		return nil, fmt.Errorf("failed to create stdout pipe: %w", err)
-	}
-
-	stderrPipe, err := cmd.StderrPipe()
-	if err != nil {
-		return nil, fmt.Errorf("failed to create stderr pipe: %w", err)
-	}
-
-	// Buffer to collect stdout for JSON parsing
-	var stdoutBuffer bytes.Buffer
-
-	// Start the command
-	if err := cmd.Start(); err != nil {
-		return nil, fmt.Errorf("failed to start blender: %w", err)
-	}
-
-	// Stream stdout and collect for JSON parsing
-	stdoutDone := make(chan bool)
-	go func() {
-		defer close(stdoutDone)
-		scanner := bufio.NewScanner(stdoutPipe)
-		for scanner.Scan() {
-			line := scanner.Text()
-			stdoutBuffer.WriteString(line)
-			stdoutBuffer.WriteString("\n")
+		stderrOutput := ""
+		stdoutOutput := ""
+		if result != nil {
+			stderrOutput = strings.TrimSpace(result.Stderr)
+			stdoutOutput = strings.TrimSpace(result.Stdout)
 		}
-	}()
-
-	// Capture stderr for error reporting
-	var stderrBuffer bytes.Buffer
-	stderrDone := make(chan bool)
-	go func() {
-		defer close(stderrDone)
-		scanner := bufio.NewScanner(stderrPipe)
-		for scanner.Scan() {
-			line := scanner.Text()
-			stderrBuffer.WriteString(line)
-			stderrBuffer.WriteString("\n")
-		}
-	}()
-
-	// Wait for command to complete
-	err = cmd.Wait()
-
-	// Wait for streaming goroutines to finish
-	<-stdoutDone
-	<-stderrDone
-
-	if err != nil {
-		stderrOutput := strings.TrimSpace(stderrBuffer.String())
-		stdoutOutput := strings.TrimSpace(stdoutBuffer.String())
 		log.Printf("Blender metadata extraction failed for job %d:", jobID)
 		if stderrOutput != "" {
 			log.Printf("Blender stderr: %s", stderrOutput)
@@ -317,7 +291,7 @@ func (s *Server) extractMetadataFromContext(jobID int64) (*types.BlendMetadata,
 	}
 
 	// Parse output (metadata is printed to stdout)
-	metadataJSON := strings.TrimSpace(stdoutBuffer.String())
+	metadataJSON := strings.TrimSpace(result.Stdout)
 	// Extract JSON from output (Blender may print other stuff)
 	jsonStart := strings.Index(metadataJSON, "{")
 	jsonEnd := strings.LastIndex(metadataJSON, "}")