chore(display/keyboardInput): follow new docs [untested]

display/pkg/main.go

@@ -54,16 +54,23 @@ const (
 	KeyRelease
 )
 
-func KeyboardInput(key int, action KeyAction) error {
+type Input struct {
+	Key    int
+	Action KeyAction
+}
+
+func KeyboardInput(inputs []Input) error {
 	var err error
 
 	kb, err := keybd_event.NewKeyBonding()
 	if err != nil {
 		return fmt.Errorf("failed to create key bonding: %w", err)
 	}
-	kb.SetKeys(key)
 
-	switch action {
+	for _, input := range inputs {
+		kb.SetKeys(input.Key)
+
+		switch input.Action {
 		case KeyPress:
 			err = kb.Press()
 		case KeyRelease:
@@ -74,6 +81,9 @@ func KeyboardInput(key int, action KeyAction) error {
 			return fmt.Errorf("failed to run key event: %w", err)
 		}
 
+		time.Sleep(time.Microsecond * 100)
+	}
+
 	return nil
 }
 

display/requests/keyboardInput.bru

@@ -11,10 +11,14 @@ patch {
 }
 
 body:json {
+  {
+    "inputs": [
       {
         "key": "VK_T",
         "action": "press"
       }
+    ]
+  }
 }
 
 settings {

display/web/main.go

@@ -195,38 +195,51 @@ func shellCommandRoute(ctx echo.Context) error {
 
 func keyboardInputRoute(ctx echo.Context) error {
 	var request struct {
+		Inputs []struct {
 			Key    string `json:"key"`
 			Action string `json:"action"`
+		} `json:"inputs"`
 	}
 	if err := ctx.Bind(&request); err != nil {
 		slog.Error("Failed to parse keyboard input", "error", err)
 		return ctx.JSON(http.StatusBadRequest, shared.ErrorResponse{Description: shared.BadRequestDescription})
 	}
-	if request.Action != "press" && request.Action != "release" {
+
-		return ctx.JSON(http.StatusBadRequest, shared.ErrorResponse{Description: shared.BadRequestDescription})
+	var inputs []pkg.Input
+
+	for _, input := range request.Inputs {
+		if input.Action != "press" && input.Action != "release" {
+			slog.Error("Invalid keyboard action", "action", input.Action)
+			return ctx.JSON(http.StatusBadRequest, shared.ErrorResponse{Description: fmt.Sprintf("Invalid action: %s", input.Action)})
 		}
 
-	code, ok := pkg.KeyboardEvents[request.Key]
+		code, ok := pkg.KeyboardEvents[input.Key]
 		if !ok {
-		slog.Error("Unsupported key", "key", request.Key)
+			slog.Error("Unsupported key", "key", input.Key)
-		return ctx.JSON(http.StatusBadRequest, shared.ErrorResponse{Description: fmt.Sprintf("Unsupported key: %s", request.Key)})
+			return ctx.JSON(http.StatusBadRequest, shared.ErrorResponse{Description: fmt.Sprintf("Unsupported key: %s", input.Key)})
 		}
 
 		var action pkg.KeyAction
-	if request.Action == "press" {
+		if input.Action == "press" {
 			action = pkg.KeyPress
 		}
-	if request.Action == "release" {
+		if input.Action == "release" {
 			action = pkg.KeyRelease
 		}
 
-	err := pkg.KeyboardInput(code, action)
+		inputs = append(inputs, pkg.Input{
+			Key:    code,
+			Action: action,
+		})
+	}
+
+	err := pkg.KeyboardInput(inputs)
 	if err != nil {
-		slog.Error("Failed to send keyboard input", "key", request.Key, "error", err)
+		slog.Error("Failed to send keyboard input", "inputs", inputs, "error", err)
 		return ctx.JSON(http.StatusInternalServerError, shared.ErrorResponse{Description: "Failed to send keyboard input"})
 	}
 
-	slog.Info("Keyboard input sent", "key", request.Key)
+	slog.Info("Keyboard input sent")
 	return ctx.JSON(http.StatusOK, struct{}{})
 }