DRAFT 2

commands/service_platform_search_test.go

@@ -41,7 +41,7 @@ func TestPlatformSearch(t *testing.T) {
 	conf, err := paths.TempDir().Join("test", "arduino-cli.yaml").ReadFile()
 	require.NoError(t, err)
 	_, err = srv.ConfigurationOpen(ctx, &rpc.ConfigurationOpenRequest{
-		Format:          "yaml",
+		SettingsFormat:  "yaml",
 		EncodedSettings: string(conf),
 	})
 	require.NoError(t, err)
@@ -350,7 +350,7 @@ func TestPlatformSearchSorting(t *testing.T) {
 	conf, err := paths.TempDir().Join("test", "arduino-cli.yaml").ReadFile()
 	require.NoError(t, err)
 	_, err = srv.ConfigurationOpen(ctx, &rpc.ConfigurationOpenRequest{
-		Format:          "yaml",
+		SettingsFormat:  "yaml",
 		EncodedSettings: string(conf),
 	})
 	require.NoError(t, err)

commands/service_settings.go

@@ -95,16 +95,31 @@ func (s *arduinoCoreServerImpl) SettingsSetValue(ctx context.Context, req *rpc.S
 	key := req.GetKey()
 
 	// Extract the value from the request
-	jsonValue := []byte(req.GetValueJson())
-	if len(jsonValue) == 0 {
+	encodedValue := []byte(req.GetEncodedValue())
+	if len(encodedValue) == 0 {
 		// If the value is empty, unset the key
 		s.settings.Delete(key)
 		return &rpc.SettingsSetValueResponse{}, nil
 	}
 
 	var newValue any
-	if err := json.Unmarshal(jsonValue, &newValue); err != nil {
-		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("invalid value: %v", err)}
+	switch req.GetValueFormat() {
+	case "", "json":
+		if err := json.Unmarshal(encodedValue, &newValue); err != nil {
+			return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("invalid value: %v", err)}
+		}
+	case "yaml":
+		if err := yaml.Unmarshal(encodedValue, &newValue); err != nil {
+			return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("invalid value: %v", err)}
+		}
+	case "cli":
+		err := s.settings.SetFromCLIArgs(key, req.GetEncodedValue())
+		if err != nil {
+			return nil, err
+		}
+		return &rpc.SettingsSetValueResponse{}, nil
+	default:
+		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported value format: %s", req.ValueFormat)}
 	}
 
 	// If the value is "null", unset the key
@@ -130,18 +145,28 @@ func (s *arduinoCoreServerImpl) SettingsGetValue(ctx context.Context, req *rpc.S
 	if !ok {
 		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("key %s not found", key)}
 	}
-	valueJson, err := json.Marshal(value)
-	if err != nil {
-		return nil, fmt.Errorf("error marshalling value: %v", err)
+
+	switch req.ValueFormat {
+	case "json":
+		valueJson, err := json.Marshal(value)
+		if err != nil {
+			return nil, fmt.Errorf("error marshalling value: %v", err)
+		}
+		return &rpc.SettingsGetValueResponse{EncodedValue: string(valueJson)}, nil
+	case "yaml":
+		valueYaml, err := yaml.Marshal(value)
+		if err != nil {
+			return nil, fmt.Errorf("error marshalling value: %v", err)
+		}
+		return &rpc.SettingsGetValueResponse{EncodedValue: string(valueYaml)}, nil
+	default:
+		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported value format: %s", req.ValueFormat)}
 	}
-	return &rpc.SettingsGetValueResponse{
-		ValueJson: string(valueJson),
-	}, nil
 }
 
 // ConfigurationSave encodes the current configuration in the specified format
 func (s *arduinoCoreServerImpl) ConfigurationSave(ctx context.Context, req *rpc.ConfigurationSaveRequest) (*rpc.ConfigurationSaveResponse, error) {
-	switch req.GetFormat() {
+	switch req.GetSettingsFormat() {
 	case "yaml":
 		data, err := yaml.Marshal(s.settings)
 		if err != nil {
@@ -155,13 +180,13 @@ func (s *arduinoCoreServerImpl) ConfigurationSave(ctx context.Context, req *rpc.
 		}
 		return &rpc.ConfigurationSaveResponse{EncodedSettings: string(data)}, nil
 	default:
-		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported format: %s", req.GetFormat())}
+		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported format: %s", req.GetSettingsFormat())}
 	}
 }
 
 // SettingsReadFromFile read settings from a YAML file and replace the settings currently stored in memory.
 func (s *arduinoCoreServerImpl) ConfigurationOpen(ctx context.Context, req *rpc.ConfigurationOpenRequest) (*rpc.ConfigurationOpenResponse, error) {
-	switch req.GetFormat() {
+	switch req.GetSettingsFormat() {
 	case "yaml":
 		err := yaml.Unmarshal([]byte(req.GetEncodedSettings()), s.settings)
 		if err != nil {
@@ -175,7 +200,7 @@ func (s *arduinoCoreServerImpl) ConfigurationOpen(ctx context.Context, req *rpc.
 		}
 		return &rpc.ConfigurationOpenResponse{}, nil
 	default:
-		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported format: %s", req.GetFormat())}
+		return nil, &cmderrors.InvalidArgumentError{Message: fmt.Sprintf("unsupported format: %s", req.GetSettingsFormat())}
 	}
 }
 

go-configmap/configuration.go

@@ -142,48 +142,6 @@ func (c Map) delete(keys []string) {
 	}
 }
 
-func (c Map) InjectEnvVars(env []string, prefix string) {
-	if prefix != "" {
-		prefix = strings.ToUpper(prefix) + "_"
-	}
-
-	// Try submaps first
-	for k, v := range c.values {
-		if subConf, ok := v.(*Map); ok {
-			subConf.InjectEnvVars(env, prefix+k)
-		}
-	}
-
-	for _, e := range env {
-		parts := strings.SplitN(e, "=", 2)
-		if len(parts) != 2 {
-			continue
-		}
-		key := strings.ToUpper(parts[0])
-		value := parts[1]
-		if !strings.HasPrefix(key, prefix) {
-			continue
-		}
-		key = strings.TrimPrefix(key, prefix)
-
-		// check if the configuration has a matching key
-		matchingKey := ""
-		for k := range c.values {
-			if k == key {
-				matchingKey = k
-				break
-			}
-			if strings.EqualFold(k, key) {
-				matchingKey = k
-			}
-		}
-		if matchingKey == "" {
-			continue
-		}
-		c.Set(matchingKey, value)
-	}
-}
-
 func (c *Map) Merge(x *Map) error {
 	for xk, xv := range x.values {
 		if xSubConf, ok := xv.(*Map); ok {

internal/cli/cli.go

@@ -95,7 +95,7 @@ func NewCommand(srv rpc.ArduinoCoreServiceServer) *cobra.Command {
 			set := func(key string, value any) {
 				if valueJson, err := json.Marshal(value); err != nil {
 					feedback.Fatal(tr("Error setting value %s: %v", key, err), feedback.ErrGeneric)
-				} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, ValueJson: string(valueJson)}); err != nil {
+				} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, EncodedValue: string(valueJson)}); err != nil {
 					feedback.Fatal(tr("Error setting value %s: %v", key, err), feedback.ErrGeneric)
 				}
 			}

internal/cli/config/add.go

@@ -60,7 +60,7 @@ func runAddCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, args [
 	var currentValues []string
 	if resp, err := srv.SettingsGetValue(ctx, &rpc.SettingsGetValueRequest{Key: key}); err != nil {
 		feedback.Fatal(tr("Cannot get the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
-	} else if err := json.Unmarshal([]byte(resp.GetValueJson()), &currentValues); err != nil {
+	} else if err := json.Unmarshal([]byte(resp.GetEncodedValue()), &currentValues); err != nil {
 		feedback.Fatal(tr("Cannot get the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
 	}
 
@@ -72,7 +72,7 @@ func runAddCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, args [
 
 	if newValuesJSON, err := json.Marshal(currentValues); err != nil {
 		feedback.Fatal(tr("Cannot remove the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
-	} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, ValueJson: string(newValuesJSON)}); err != nil {
+	} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, EncodedValue: string(newValuesJSON)}); err != nil {
 		feedback.Fatal(tr("Cannot remove the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
 	}
 

internal/cli/config/config.go

@@ -66,7 +66,7 @@ func getAllArraySettingsKeys(ctx context.Context, srv rpc.ArduinoCoreServiceServ
 
 func saveConfiguration(ctx context.Context, srv rpc.ArduinoCoreServiceServer) {
 	var outConfig []byte
-	if res, err := srv.ConfigurationSave(ctx, &rpc.ConfigurationSaveRequest{Format: "yaml"}); err != nil {
+	if res, err := srv.ConfigurationSave(ctx, &rpc.ConfigurationSaveRequest{SettingsFormat: "yaml"}); err != nil {
 		feedback.Fatal(tr("Error writing to file: %v", err), feedback.ErrGeneric)
 	} else {
 		outConfig = []byte(res.GetEncodedSettings())

internal/cli/config/delete.go

@@ -50,7 +50,7 @@ func runDeleteCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, arg
 	logrus.Info("Executing `arduino-cli config delete`")
 
 	key := args[0]
-	if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, ValueJson: ""}); err != nil {
+	if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, EncodedValue: ""}); err != nil {
 		feedback.Fatal(tr("Cannot delete the key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
 	}
 

internal/cli/config/dump.go

@@ -36,13 +36,13 @@ func initDumpCommand(srv rpc.ArduinoCoreServiceServer) *cobra.Command {
 			res := &rawResult{}
 			switch feedback.GetFormat() {
 			case feedback.JSON, feedback.MinifiedJSON:
-				resp, err := srv.ConfigurationSave(cmd.Context(), &rpc.ConfigurationSaveRequest{Format: "json"})
+				resp, err := srv.ConfigurationSave(cmd.Context(), &rpc.ConfigurationSaveRequest{SettingsFormat: "json"})
 				if err != nil {
 					logrus.Fatalf("Error creating configuration: %v", err)
 				}
 				res.rawJSON = []byte(resp.GetEncodedSettings())
 			case feedback.YAML, feedback.Text:
-				resp, err := srv.ConfigurationSave(cmd.Context(), &rpc.ConfigurationSaveRequest{Format: "yaml"})
+				resp, err := srv.ConfigurationSave(cmd.Context(), &rpc.ConfigurationSaveRequest{SettingsFormat: "yaml"})
 				if err != nil {
 					logrus.Fatalf("Error creating configuration: %v", err)
 				}

internal/cli/config/get.go

@@ -59,7 +59,7 @@ func runGetCommand(srv rpc.ArduinoCoreServiceServer, args []string) {
 			feedback.Fatal(tr("Cannot get the configuration key %[1]s: %[2]v", toGet, err), feedback.ErrGeneric)
 		}
 		var result getResult
-		if err := json.Unmarshal([]byte(resp.GetValueJson()), &result.resp); err != nil {
+		if err := json.Unmarshal([]byte(resp.GetEncodedValue()), &result.resp); err != nil {
 			// Should never happen...
 			panic(fmt.Sprintf("Cannot parse JSON for key %[1]s: %[2]v", toGet, err))
 		}

internal/cli/config/init.go

@@ -104,7 +104,7 @@ func runInitCommand(srv rpc.ArduinoCoreServiceServer) {
 	// 	}
 	// }
 
-	resp, err := srv.ConfigurationSave(ctx, &rpc.ConfigurationSaveRequest{Format: "yaml"})
+	resp, err := srv.ConfigurationSave(ctx, &rpc.ConfigurationSaveRequest{SettingsFormat: "yaml"})
 	if err != nil {
 		feedback.Fatal(tr("Error creating configuration: %v", err), feedback.ErrGeneric)
 	}

internal/cli/config/remove.go

@@ -60,7 +60,7 @@ func runRemoveCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, arg
 	var currentValues []string
 	if resp, err := srv.SettingsGetValue(ctx, &rpc.SettingsGetValueRequest{Key: key}); err != nil {
 		feedback.Fatal(tr("Cannot get the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
-	} else if err := json.Unmarshal([]byte(resp.GetValueJson()), &currentValues); err != nil {
+	} else if err := json.Unmarshal([]byte(resp.GetEncodedValue()), &currentValues); err != nil {
 		feedback.Fatal(tr("Cannot get the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
 	}
 
@@ -70,7 +70,7 @@ func runRemoveCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, arg
 
 	if newValuesJSON, err := json.Marshal(currentValues); err != nil {
 		feedback.Fatal(tr("Cannot remove the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
-	} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, ValueJson: string(newValuesJSON)}); err != nil {
+	} else if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{Key: key, EncodedValue: string(newValuesJSON)}); err != nil {
 		feedback.Fatal(tr("Cannot remove the configuration key %[1]s: %[2]v", key, err), feedback.ErrGeneric)
 	}
 

internal/cli/config/set.go

@@ -19,9 +19,7 @@ import (
 	"context"
 	"encoding/json"
 	"os"
-	"strconv"
 
-	"github.com/arduino/arduino-cli/commands/cmderrors"
 	"github.com/arduino/arduino-cli/internal/cli/feedback"
 	rpc "github.com/arduino/arduino-cli/rpc/cc/arduino/cli/commands/v1"
 	"github.com/sirupsen/logrus"
@@ -53,54 +51,24 @@ func initSetCommand(srv rpc.ArduinoCoreServiceServer) *cobra.Command {
 func runSetCommand(ctx context.Context, srv rpc.ArduinoCoreServiceServer, args []string) {
 	logrus.Info("Executing `arduino-cli config set`")
 
-	// Find the correct type for the given setting
-	key := args[0]
-	res, err := srv.SettingsEnumerate(ctx, &rpc.SettingsEnumerateRequest{})
-	if err != nil {
-		feedback.Fatal(tr("Error enumerating settings: %v", err), feedback.ErrGeneric)
+	req := &rpc.SettingsSetValueRequest{
+		Key: args[0],
 	}
-	var entry *rpc.SettingsEnumerateResponse_Entry
-	for _, e := range res.GetEntries() {
-		if e.GetKey() == key {
-			entry = e
-			break
+	if len(args) == 1 {
+		// Single value
+		req.EncodedValue = args[1]
+		req.ValueFormat = "cli"
+	} else {
+		// Array
+		jsonValues, err := json.Marshal(args[1:])
+		if err != nil {
+			feedback.Fatal(tr("Error setting value: %v", err), feedback.ErrGeneric)
 		}
-	}
-	if entry == nil {
-		feedback.Fatal(tr("Setting not found: %s", key), feedback.ErrGeneric)
-	}
-
-	var value any
-	isArray := false
-	var conversionError error
-	switch entry.GetType() {
-	case "uint":
-		value, conversionError = strconv.Atoi(args[1])
-	case "bool":
-		value, conversionError = strconv.ParseBool(args[1])
-	case "string":
-		value = args[1]
-	case "[]string":
-		value = args[1:]
-		isArray = true
-	default:
-		panic("unhandled type: " + entry.GetType())
-	}
-	if conversionError != nil {
-		feedback.Fatal(tr("Error setting value: %v", conversionError), feedback.ErrBadArgument)
-	}
-	if !isArray && len(args) != 2 {
-		conversionError = &cmderrors.InvalidArgumentError{Message: tr("Invalid number of arguments.")}
+		req.EncodedValue = string(jsonValues)
+		req.ValueFormat = "json"
 	}
 
-	valueJSON, err := json.Marshal(value)
-	if err != nil {
-		feedback.Fatal(tr("Error setting value: %v", conversionError), feedback.ErrBadArgument)
-	}
-	if _, err := srv.SettingsSetValue(ctx, &rpc.SettingsSetValueRequest{
-		Key:       key,
-		ValueJson: string(valueJSON),
-	}); err != nil {
+	if _, err := srv.SettingsSetValue(ctx, req); err != nil {
 		feedback.Fatal(tr("Error setting value: %v", err), feedback.ErrGeneric)
 	}
 

internal/cli/configuration/defaults.go

@@ -22,15 +22,19 @@ import (
 
 // SetDefaults sets the default values for certain keys
 func SetDefaults(settings *Settings) {
+	setKeyTypeSchema := func(k string, v any) {
+		settings.SetKeyTypeSchema(k, v)
+		settings.Defaults.SetKeyTypeSchema(k, v)
+	}
 	setDefaultValueAndKeyTypeSchema := func(k string, v any) {
+		setKeyTypeSchema(k, v)
 		settings.Defaults.Set(k, v)
-		settings.SetKeyTypeSchema(k, v)
 	}
 
 	// logging
 	setDefaultValueAndKeyTypeSchema("logging.level", "info")
 	setDefaultValueAndKeyTypeSchema("logging.format", "text")
-	settings.SetKeyTypeSchema("logging.file", "")
+	setKeyTypeSchema("logging.file", "")
 
 	// Libraries
 	setDefaultValueAndKeyTypeSchema("library.enable_unsafe_install", false)
@@ -65,9 +69,14 @@ func SetDefaults(settings *Settings) {
 	settings.Defaults.InjectEnvVars(os.Environ(), "ARDUINO")
 
 	// Bind env aliases to keep backward compatibility
-	// settings.defaults.BindEnv("library.enable_unsafe_install", "ARDUINO_ENABLE_UNSAFE_LIBRARY_INSTALL")
-	// settings.defaults.BindEnv("directories.User", "ARDUINO_SKETCHBOOK_DIR")
-	// settings.defaults.BindEnv("directories.Downloads", "ARDUINO_DOWNLOADS_DIR")
-	// settings.defaults.BindEnv("directories.Data", "ARDUINO_DATA_DIR")
-	// settings.defaults.BindEnv("sketch.always_export_binaries", "ARDUINO_SKETCH_ALWAYS_EXPORT_BINARIES")
+	setIfEnvExists := func(key, env string) {
+		if v, ok := os.LookupEnv(env); ok {
+			settings.Defaults.SetFromCLIArgs(key, v)
+		}
+	}
+	setIfEnvExists("library.enable_unsafe_install", "ARDUINO_ENABLE_UNSAFE_LIBRARY_INSTALL")
+	setIfEnvExists("directories.User", "ARDUINO_SKETCHBOOK_DIR")
+	setIfEnvExists("directories.Downloads", "ARDUINO_DOWNLOADS_DIR")
+	setIfEnvExists("directories.Data", "ARDUINO_DATA_DIR")
+	setIfEnvExists("sketch.always_export_binaries", "ARDUINO_SKETCH_ALWAYS_EXPORT_BINARIES")
 }

internal/cli/daemon/daemon.go

@@ -55,8 +55,9 @@ func NewCommand(srv rpc.ArduinoCoreServiceServer, settings *rpc.Configuration) *
 			if settings.GetDirectories().GetBuiltin().GetLibraries() == "" {
 				defaultBuiltinLibDir := filepath.Join(settings.GetDirectories().GetData(), "libraries")
 				_, _ = srv.SettingsSetValue(cmd.Context(), &rpc.SettingsSetValueRequest{
-					Key:       "directories.data.libraries",
-					ValueJson: defaultBuiltinLibDir,
+					Key:          "directories.data.libraries",
+					ValueFormat:  "cli",
+					EncodedValue: defaultBuiltinLibDir,
 				})
 			}
 		},