Deploy 2026-01-26 07:56:26

Dockerfile

@@ -19,8 +19,8 @@ RUN pip install --no-cache-dir uv
 # -------------------------------------------------------------------
 FROM base AS builder
 
-# Copy only dependency files first (better layer caching)
-COPY pyproject.toml uv.lock ./
+# Copy files needed for build (hatchling requires README.md)
+COPY pyproject.toml uv.lock README.md ./
 
 # Install dependencies to system (no venv needed in container)
 RUN uv pip install --system .
@@ -37,6 +37,9 @@ COPY --from=builder /usr/local/bin /usr/local/bin
 # Copy application source (includes pre-built frontend in src/flow/ui/ui/)
 COPY src/ ./src/
 
+# Copy files needed for package install
+COPY pyproject.toml README.md ./
+
 # Install the app itself (editable, uses already-installed deps)
 RUN uv pip install --system --no-deps -e .
 

src/flow/ui/services/optimizer_service.py

@@ -26,10 +26,14 @@ class OptimizerService:
 
     async def run_job(self, job_id: str | UUID) -> AsyncGenerator[JobProgress, None]:
         """Run an optimization job and yield progress updates."""
+        # Convert to UUID if string
+        if isinstance(job_id, str):
+            job_id = UUID(job_id)
+
         async with async_session() as session:
             # Load job
             result = await session.execute(
-                select(OptimizationJob).where(OptimizationJob.id == str(job_id))
+                select(OptimizationJob).where(OptimizationJob.id == job_id)
             )
             job = result.scalar_one_or_none()
             if not job:
@@ -182,7 +186,7 @@ class OptimizerService:
         configs = []
         for config_id in config_ids:
             result = await session.execute(
-                select(AgentConfig).where(AgentConfig.id == config_id)
+                select(AgentConfig).where(AgentConfig.id == UUID(config_id))
             )
             db_config = result.scalar_one_or_none()
             if db_config:
@@ -207,7 +211,7 @@ class OptimizerService:
         tasks = []
         for task_id in task_ids:
             result = await session.execute(
-                select(TaskModel).where(TaskModel.id == task_id)
+                select(TaskModel).where(TaskModel.id == UUID(task_id))
             )
             db_task = result.scalar_one_or_none()
             if db_task:

src/flow/ui/tests/test_e2e_user_journey.py

@@ -447,6 +447,84 @@ class TestAPIEndpoints:
         assert resp.status_code == 200
         assert resp.json() == []
 
+    @pytest.mark.asyncio
+    async def test_job_start_endpoint(self, client: httpx.AsyncClient):
+        """Test that job start endpoint works and updates job status.
+
+        Note: The actual optimization will likely fail in test environment due to
+        missing dependencies, but we verify the endpoint is accessible and
+        the job status transitions correctly.
+        """
+        print("\n[Job Start Endpoint Test]")
+
+        # Create config
+        config_resp = await client.post(
+            "/api/configs",
+            json={"name": "start-test-config"},
+        )
+        assert config_resp.status_code == 201
+        config = config_resp.json()
+        print(f"    ✓ Created config: {config['id'][:8]}...")
+
+        # Create task
+        task_resp = await client.post(
+            "/api/tasks",
+            json={"name": "start-test-task", "prompt": "Print hello world"},
+        )
+        assert task_resp.status_code == 201
+        task = task_resp.json()
+        print(f"    ✓ Created task: {task['id'][:8]}...")
+
+        try:
+            # Create job
+            job_resp = await client.post(
+                "/api/jobs",
+                json={
+                    "name": "start-test-job",
+                    "config_ids": [config["id"]],
+                    "task_ids": [task["id"]],
+                    "parallel": 1,
+                },
+            )
+            assert job_resp.status_code == 201
+            job = job_resp.json()
+            job_id = job["id"]
+            print(f"    ✓ Created job: {job_id[:8]}...")
+            assert job["status"] == "pending"
+            print(f"    ✓ Job status is 'pending'")
+
+            # Try to start job - this is a streaming endpoint
+            # We just verify it's accessible (200 OK) even if it errors during execution
+            print(f"    ✓ Attempting to start job...")
+            start_resp = await client.post(f"/api/jobs/{job_id}/start")
+            # The endpoint should return 200 OK for the SSE stream
+            assert start_resp.status_code == 200, f"Start endpoint failed: {start_resp.status_code}"
+            print(f"    ✓ Start endpoint responded with 200")
+
+            # Check job status after start attempt
+            # It should have transitioned from 'pending' (to 'running' or 'failed')
+            status_resp = await client.get(f"/api/jobs/{job_id}")
+            assert status_resp.status_code == 200
+            updated_job = status_resp.json()
+            print(f"    ✓ Job status after start: {updated_job['status']}")
+
+            # Job should no longer be pending
+            # It's either 'running', 'failed', or 'completed'
+            assert updated_job["status"] in ["running", "failed", "completed"], \
+                f"Unexpected status: {updated_job['status']}"
+            print(f"    ✓ Job transitioned from 'pending' to '{updated_job['status']}'")
+
+            # Cleanup
+            await client.delete(f"/api/jobs/{job_id}")
+            print(f"    ✓ Deleted job")
+
+        finally:
+            await client.delete(f"/api/tasks/{task['id']}")
+            await client.delete(f"/api/configs/{config['id']}")
+            print(f"    ✓ Cleaned up config and task")
+
+        print("\n    Job start endpoint test passed!")
+
 
 if __name__ == "__main__":
     # Run tests directly