fix: replace time.Sleep with context-aware sleeps in doPressKey and doDragMouse (#146)

## Summary

- `doPressKey` used `time.Sleep` for the key hold duration, blocking
without respecting context cancellation while holding `inputMu`
- `doDragMouse` used `time.Sleep` for the optional pre-drag delay, same
problem
- Both are especially problematic in the batch flow where the mutex is
held for the entire batch

## Changes

- Extract a `sleepWithContext` helper that uses `select` with
`time.NewTimer` and `ctx.Done()`
- Refactor `doSleep` to use the shared helper
- Replace `time.Sleep` in `doPressKey` with `sleepWithContext`; on
cancellation, best-effort release held keys using a background context
- Replace `time.Sleep` in `doDragMouse` with `sleepWithContext`; on
cancellation, best-effort release mouse button and modifier keys
- No remaining `time.Sleep` calls in `computer.go`

## Test plan

- [x] `go build ./...` and `go vet ./...` pass
- [x] `go test ./cmd/api/api/...` passes
- [ ] Verify key hold and drag delay are interruptible by cancelling a
request mid-sleep

Made with [Cursor](https://cursor.com)

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Touches low-level input simulation and cleanup behavior; cancellation
paths now run `xdotool` releases via `context.Background()`, which could
change how interrupted requests leave system input state.
> 
> **Overview**
> Makes input-related delays context-aware to avoid blocking while
`inputMu` is held (notably during `BatchComputerAction`).
> 
> Replaces `time.Sleep` in `doPressKey` key-hold and `doDragMouse`
pre-drag delay with a shared `sleepWithContext` helper, and refactors
`doSleep` to use it as well. On cancellation, both key-hold and drag
delay now perform **best-effort cleanup** (releasing keys and/or mouse
button) via `context.Background()` before returning an error.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
90ff857. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: rgarcia

server/cmd/api/api/computer.go

@@ -557,24 +557,33 @@ func (s *ApiService) doPressKey(ctx context.Context, body oapi.PressKeyRequest)
 		}
 
 		d := time.Duration(*body.Duration) * time.Millisecond
-		time.Sleep(d)
 
-		argsUp := []string{}
-		for _, key := range body.Keys {
-			argsUp = append(argsUp, "keyup", key)
-		}
-		if body.HoldKeys != nil {
-			for _, key := range *body.HoldKeys {
+		// Best-effort release helper: always attempt to release keys even if sleep was interrupted.
+		releaseKeys := func() error {
+			argsUp := []string{}
+			for _, key := range body.Keys {
 				argsUp = append(argsUp, "keyup", key)
 			}
+			if body.HoldKeys != nil {
+				for _, key := range *body.HoldKeys {
+					argsUp = append(argsUp, "keyup", key)
+				}
+			}
+			// Use background context for cleanup so keys are released even on cancellation.
+			if output, err := defaultXdoTool.Run(context.Background(), argsUp...); err != nil {
+				log.Error("xdotool keyup failed", "err", err, "output", string(output))
+				return &executionError{msg: fmt.Sprintf("failed to release keys. out=%s", string(output))}
+			}
+			return nil
 		}
 
-		if output, err := defaultXdoTool.Run(ctx, argsUp...); err != nil {
-			log.Error("xdotool keyup failed", "err", err, "output", string(output))
-			return &executionError{msg: fmt.Sprintf("failed to release keys. out=%s", string(output))}
+		if err := sleepWithContext(ctx, d); err != nil {
+			// Context cancelled while holding keys down; release them before returning.
+			_ = releaseKeys()
+			return &executionError{msg: fmt.Sprintf("key hold interrupted: %s", err)}
 		}
 
-		return nil
+		return releaseKeys()
 	}
 
 	// Tap behavior: hold modifiers (if any), tap each key, then release modifiers.
@@ -770,7 +779,17 @@ func (s *ApiService) doDragMouse(ctx context.Context, body oapi.DragMouseRequest
 
 	// Optional delay between mousedown and movement
 	if body.Delay != nil && *body.Delay > 0 {
-		time.Sleep(time.Duration(*body.Delay) * time.Millisecond)
+		if err := sleepWithContext(ctx, time.Duration(*body.Delay)*time.Millisecond); err != nil {
+			// Best-effort release: mouseup + modifier keyup
+			cleanupArgs := []string{"mouseup", btn}
+			if body.HoldKeys != nil {
+				for _, key := range *body.HoldKeys {
+					cleanupArgs = append(cleanupArgs, "keyup", key)
+				}
+			}
+			_, _ = defaultXdoTool.Run(context.Background(), cleanupArgs...)
+			return &executionError{msg: fmt.Sprintf("drag delay interrupted: %s", err)}
+		}
 	}
 
 	// Phase 2: move along path (excluding first point) using fixed-count relative steps
@@ -869,6 +888,24 @@ func (s *ApiService) DragMouse(ctx context.Context, request oapi.DragMouseReques
 
 const maxSleepDurationMs = 30_000
 
+// sleepWithContext pauses for the given duration, returning early if the context is cancelled.
+// This should be used instead of time.Sleep when holding the inputMu mutex, so that context
+// cancellation can promptly release the lock.
+func sleepWithContext(ctx context.Context, d time.Duration) error {
+	if d <= 0 {
+		return nil
+	}
+	timer := time.NewTimer(d)
+	defer timer.Stop()
+
+	select {
+	case <-timer.C:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
 func (s *ApiService) doSleep(ctx context.Context, body oapi.SleepAction) error {
 	if body.DurationMs < 0 {
 		return &validationError{msg: "duration_ms must be >= 0"}
@@ -877,15 +914,10 @@ func (s *ApiService) doSleep(ctx context.Context, body oapi.SleepAction) error {
 		return &validationError{msg: fmt.Sprintf("duration_ms must be <= %d", maxSleepDurationMs)}
 	}
 
-	timer := time.NewTimer(time.Duration(body.DurationMs) * time.Millisecond)
-	defer timer.Stop()
-
-	select {
-	case <-timer.C:
-		return nil
-	case <-ctx.Done():
-		return &executionError{msg: fmt.Sprintf("sleep interrupted: %s", ctx.Err())}
+	if err := sleepWithContext(ctx, time.Duration(body.DurationMs)*time.Millisecond); err != nil {
+		return &executionError{msg: fmt.Sprintf("sleep interrupted: %s", err)}
 	}
+	return nil
 }
 
 func (s *ApiService) BatchComputerAction(ctx context.Context, request oapi.BatchComputerActionRequestObject) (oapi.BatchComputerActionResponseObject, error) {