fix drag mouse (#79)

Did some testing on this site:
https://master--5fc05e08a4a65d0021ae0bf2.chromatic.com/?path=/story/core-draggable-hooks-usedraggable--basic-setup

discovered that the number of steps and the delay between them as you
drag the mouse is important to finesse

found success with the defaults in this PR, but making them configurable
in case users want to deviate


# Checklist

- [ ] A link to a related issue in our repository
- [ ] A description of the changes proposed in the pull request.
- [ ] @mentions of the person or team responsible for reviewing proposed
changes.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Implements smooth drag using relative step movements with configurable
per-segment step count and per-step delay, updates OpenAPI, and adds
tests.
> 
> - **Backend (server/cmd/api/api/computer.go)**:
> - **DragMouse**: Move along `path` via `mousemove_relative` steps with
small sleeps for smoothing; derive steps using `generateRelativeSteps`;
support `steps_per_segment` (default `10`) and `step_delay_ms` (default
`50`).
> - Add `generateRelativeSteps(dx, dy, steps)` helper to distribute
integer relative moves.
> - **Tests (server/cmd/api/api/computer_test.go)**:
> - Add unit tests covering zero, axis-aligned, and diagonal/sloped
cases for `generateRelativeSteps`.
> - **API/Schema**:
> - `DragMouseRequest`: add `steps_per_segment` and `step_delay_ms`
(with defaults/min constraints) in `server/openapi.yaml` and generated
`server/lib/oapi/oapi.go`.
> - `PressKeyRequest.keys` doc: note items may be combos like `Ctrl+t`.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
9c427f3. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: rgarcia

server/cmd/api/api/computer.go

@@ -5,6 +5,7 @@ import (
 	"encoding/base64"
 	"fmt"
 	"io"
+	"math"
 	"os"
 	"os/exec"
 	"strconv"
@@ -669,10 +670,44 @@ func (s *ApiService) DragMouse(ctx context.Context, request oapi.DragMouseReques
 		time.Sleep(time.Duration(*body.Delay) * time.Millisecond)
 	}
 
-	// Phase 2: move along path (excluding first point)
+	// Phase 2: move along path (excluding first point) using fixed-count relative steps
+	// Insert a small delay between each relative move to smooth the drag
 	args2 := []string{}
+	// Determine per-segment steps and per-step delay from request (with defaults)
+	stepsPerSegment := 10
+	if body.StepsPerSegment != nil && *body.StepsPerSegment >= 1 {
+		stepsPerSegment = *body.StepsPerSegment
+	}
+	stepDelayMs := 50
+	if body.StepDelayMs != nil && *body.StepDelayMs >= 0 {
+		stepDelayMs = *body.StepDelayMs
+	}
+	stepDelaySeconds := fmt.Sprintf("%.3f", float64(stepDelayMs)/1000.0)
+
+	// Precompute total number of relative steps so we can avoid a trailing sleep
+	totalSteps := 0
+	prev := start
+	for _, pt := range body.Path[1:] {
+		x0, y0 := prev[0], prev[1]
+		x1, y1 := pt[0], pt[1]
+		totalSteps += len(generateRelativeSteps(x1-x0, y1-y0, stepsPerSegment))
+		prev = pt
+	}
+
+	prev = start
+	stepIndex := 0
 	for _, pt := range body.Path[1:] {
-		args2 = append(args2, "mousemove", "--sync", strconv.Itoa(pt[0]), strconv.Itoa(pt[1]))
+		x0, y0 := prev[0], prev[1]
+		x1, y1 := pt[0], pt[1]
+		for _, step := range generateRelativeSteps(x1-x0, y1-y0, stepsPerSegment) {
+			args2 = append(args2, "mousemove_relative", strconv.Itoa(step[0]), strconv.Itoa(step[1]))
+			// add a tiny delay between moves, but not after the last step
+			if stepIndex < totalSteps-1 && stepDelayMs > 0 {
+				args2 = append(args2, "sleep", stepDelaySeconds)
+			}
+			stepIndex++
+		}
+		prev = pt
 	}
 	if len(args2) > 0 {
 		log.Info("executing xdotool (drag move)", "args", args2)
@@ -709,3 +744,37 @@ func (s *ApiService) DragMouse(ctx context.Context, request oapi.DragMouseReques
 
 	return oapi.DragMouse200Response{}, nil
 }
+
+// generateRelativeSteps produces a sequence of relative steps that approximate a
+// straight line from (0,0) to (dx,dy) using at most the provided number of
+// steps. Each returned element is a pair {stepX, stepY}. The steps are
+// distributed so that the cumulative sum equals exactly (dx, dy). If dx and dy
+// are both zero, no steps are returned. If the requested step count is less
+// than the distance, the per-step movement will be greater than one pixel.
+func generateRelativeSteps(dx, dy, steps int) [][2]int {
+	if steps <= 0 {
+		return nil
+	}
+	if dx == 0 && dy == 0 {
+		return nil
+	}
+
+	out := make([][2]int, 0, steps)
+
+	// Use cumulative rounding to distribute integers across the requested
+	// number of steps while preserving the exact totals.
+	prevCX := 0
+	prevCY := 0
+	for i := 1; i <= steps; i++ {
+		// Target cumulative positions after i steps
+		cx := int(math.Round(float64(i*dx) / float64(steps)))
+		cy := int(math.Round(float64(i*dy) / float64(steps)))
+		sx := cx - prevCX
+		sy := cy - prevCY
+		prevCX = cx
+		prevCY = cy
+		out = append(out, [2]int{sx, sy})
+	}
+
+	return out
+}

server/cmd/api/api/computer_test.go

@@ -0,0 +1,51 @@
+package api
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func sumSteps(steps [][2]int) (int, int) {
+	sx, sy := 0, 0
+	for _, s := range steps {
+		sx += s[0]
+		sy += s[1]
+	}
+	return sx, sy
+}
+
+func countSteps(steps [][2]int) int { return len(steps) }
+
+func TestGenerateRelativeSteps_Zero(t *testing.T) {
+	steps := generateRelativeSteps(0, 0, 5)
+	require.Len(t, steps, 0, "expected 0 steps")
+}
+
+func TestGenerateRelativeSteps_AxisAligned(t *testing.T) {
+	cases := []struct {
+		dx, dy int
+	}{
+		{5, 0}, {-7, 0}, {0, 9}, {0, -3},
+	}
+	for _, c := range cases {
+		steps := generateRelativeSteps(c.dx, c.dy, 5)
+		sx, sy := sumSteps(steps)
+		require.Equal(t, c.dx, sx, "sum mismatch dx")
+		require.Equal(t, c.dy, sy, "sum mismatch dy")
+		require.Equal(t, 5, countSteps(steps), "count mismatch")
+	}
+}
+
+func TestGenerateRelativeSteps_DiagonalsAndSlopes(t *testing.T) {
+	cases := []struct{ dx, dy int }{
+		{5, 5}, {-4, -4}, {8, 3}, {3, 8}, {-9, 2}, {2, -9},
+	}
+	for _, c := range cases {
+		steps := generateRelativeSteps(c.dx, c.dy, 5)
+		sx, sy := sumSteps(steps)
+		require.Equal(t, c.dx, sx, "sum mismatch dx")
+		require.Equal(t, c.dy, sy, "sum mismatch dy")
+		require.Equal(t, 5, countSteps(steps), "count mismatch")
+	}
+}