Fix config export for positional arguments (#188)

* Linting

* Fix export of positional arguments in config export

Refactored exportRuntimeArgs to properly handle positional arguments
that were previously being skipped. Split logic into clean helper
functions following functional programming principles.

- Add partitionArgs() to separate positional and flag arguments
- Add exportPositionalArgs() to handle ARG_1, ARG_2, etc.
- Add exportFlagArgs() for flag argument processing
- Add comprehensive test coverage for all scenarios

Author: peteski22

internal/daemon/daemon.go

@@ -269,7 +269,17 @@ func (d *Daemon) startMCPServer(ctx context.Context, server runtime.Server) erro
 		return fmt.Errorf("error initializing MCP client: '%s': %w", server.Name(), err)
 	}
 
-	logger.Info("Initialized", "package", pkg, "version", ver, "server-name", initResult.ServerInfo.Name, "server-version", initResult.ServerInfo.Version)
+	logger.Info(
+		"Initialized",
+		"package",
+		pkg,
+		"version",
+		ver,
+		"server-name",
+		initResult.ServerInfo.Name,
+		"server-version",
+		initResult.ServerInfo.Version,
+	)
 
 	// Store and track the client.
 	d.clientManager.Add(server.Name(), stdioClient, server.Tools)

internal/runtime/server.go

@@ -300,57 +300,120 @@ func (s *Server) exportEnvVars(appName string) map[string]string {
 	return envs
 }
 
-func (s *Server) exportRuntimeArgs(
+// partitionArgs separates arguments into positional (non-flag) and flag arguments.
+// Positional args come before any flags. Once a flag is encountered, all remaining
+// args are treated as flags or flag values.
+func partitionArgs(args []string) (positional []string, flags []string) {
+	for i, arg := range args {
+		if strings.HasPrefix(arg, "--") {
+			// split here
+			positional = args[:i]
+			flags = args[i:]
+			return
+		}
+	}
+	// no flags found
+	positional = args
+	return
+}
+
+// exportPositionalArgs transforms positional arguments into environment variable placeholders.
+// Arguments are numbered starting from 1 (ARG_1, ARG_2, etc.).
+func (s *Server) exportPositionalArgs(
+	positional []string,
 	appName string,
-	seen map[string]struct{},
 	recordContractFunc func(k, v string),
 ) []string {
-	var args []string
+	if len(positional) == 0 {
+		return nil
+	}
 
-	// Filter out args with cross-server references.
-	filteredArgs := s.filterArgs(s.Args)
+	result := make([]string, 0, len(positional))
+	for i := range positional {
+		// Number positional args starting from 1.
+		argKey := fmt.Sprintf("ARG_%d", i+1)
+		envVarName := buildEnvVarName(appName, s.Name(), argKey)
+		envVarRef := fmt.Sprintf("${%s}", envVarName)
+		result = append(result, envVarRef)
+		recordContractFunc(envVarName, envVarRef)
+	}
+	return result
+}
 
-	for i := 0; i < len(filteredArgs); i++ {
-		rawArg := filteredArgs[i]
+// exportFlagArgs processes flag arguments and transforms them into environment variable placeholders.
+func (s *Server) exportFlagArgs(
+	flags []string,
+	appName string,
+	seen map[string]struct{},
+	recordContractFunc func(k, v string),
+) []string {
+	if len(flags) == 0 {
+		return nil
+	}
 
-		// Sanity check for arg.
-		if !strings.HasPrefix(rawArg, "--") {
-			continue // value
-		}
+	var result []string
+	for i := 0; i < len(flags); i++ {
+		flag := flags[i]
 
-		arg := extractArgNameWithPrefix(rawArg)
-		if _, ok := seen[arg]; ok {
-			continue // Already handled.
+		// Skip non-flag arguments (values).
+		if !strings.HasPrefix(flag, "--") {
+			continue
 		}
 
-		// --arg=val case
-		if strings.HasPrefix(rawArg, arg+"=") {
-			t := transformValueArg(appName, s.Name(), rawArg)
-			args = append(args, t.FormattedArg)
-			recordContractFunc(t.EnvVarName, t.EnvVarReference)
-			seen[arg] = struct{}{}
+		argName := extractArgNameWithPrefix(flag)
+
+		// Skip if already processed.
+		if _, ok := seen[argName]; ok {
 			continue
 		}
 
-		// --arg val case
-		if rawArg == arg && i+1 < len(filteredArgs) && !strings.HasPrefix(filteredArgs[i+1], "--") {
-			t := transformValueArg(appName, s.Name(), rawArg)
-			args = append(args, t.FormattedArg)
+		// Handle --arg=value format.
+		if strings.Contains(flag, "=") {
+			t := transformValueArg(appName, s.Name(), flag)
+			result = append(result, t.FormattedArg)
 			recordContractFunc(t.EnvVarName, t.EnvVarReference)
-			seen[arg] = struct{}{}
-			i++ // Skip the next item since it's an actual value.
+			seen[argName] = struct{}{}
 			continue
 		}
 
-		// bool flag
-		if rawArg == arg {
-			args = append(args, arg)
-			seen[arg] = struct{}{}
+		// Handle --arg value format (check next item).
+		if i+1 < len(flags) && !strings.HasPrefix(flags[i+1], "--") {
+			t := transformValueArg(appName, s.Name(), flag)
+			result = append(result, t.FormattedArg)
+			recordContractFunc(t.EnvVarName, t.EnvVarReference)
+			seen[argName] = struct{}{}
+			i++ // Skip the value.
 			continue
 		}
+
+		// Handle boolean flag.
+		result = append(result, flag)
+		seen[argName] = struct{}{}
 	}
 
-	return args
+	return result
+}
+
+func (s *Server) exportRuntimeArgs(
+	appName string,
+	seen map[string]struct{},
+	recordContractFunc func(k, v string),
+) []string {
+	// Filter out args with cross-server references.
+	filteredArgs := s.filterArgs(s.Args)
+	if len(filteredArgs) == 0 {
+		return nil
+	}
+
+	// Partition into positional and flag arguments.
+	positional, flags := partitionArgs(filteredArgs)
+
+	// Process each type separately and combine results.
+	var result []string
+	result = append(result, s.exportPositionalArgs(positional, appName, recordContractFunc)...)
+	result = append(result, s.exportFlagArgs(flags, appName, seen, recordContractFunc)...)
+
+	return result
 }
 
 func (s *Servers) Export(path string) (map[string]string, error) {

internal/runtime/server_test.go

@@ -811,6 +811,72 @@ func TestValidate(t *testing.T) {
 	}
 }
 
+func TestPartitionArgs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name               string
+		args               []string
+		expectedPositional []string
+		expectedFlags      []string
+	}{
+		{
+			name:               "empty args",
+			args:               []string{},
+			expectedPositional: []string{},
+		},
+		{
+			name:               "only positional args",
+			args:               []string{"file1", "file2", "file3"},
+			expectedPositional: []string{"file1", "file2", "file3"},
+		},
+		{
+			name:               "only flags",
+			args:               []string{"--flag1", "--flag2=value", "--flag3", "value3"},
+			expectedPositional: []string{},
+			expectedFlags:      []string{"--flag1", "--flag2=value", "--flag3", "value3"},
+		},
+		{
+			name:               "positional then flags",
+			args:               []string{"pos1", "pos2", "--flag1", "--flag2=value"},
+			expectedPositional: []string{"pos1", "pos2"},
+			expectedFlags:      []string{"--flag1", "--flag2=value"},
+		},
+		{
+			name:               "positional then flag with value",
+			args:               []string{"pos1", "--flag", "value", "--another"},
+			expectedPositional: []string{"pos1"},
+			expectedFlags:      []string{"--flag", "value", "--another"},
+		},
+		{
+			name:               "no positional after first flag",
+			args:               []string{"pos1", "--flag", "value", "should-be-flag-value"},
+			expectedPositional: []string{"pos1"},
+			expectedFlags:      []string{"--flag", "value", "should-be-flag-value"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			positional, flags := partitionArgs(tc.args)
+
+			if tc.expectedPositional == nil {
+				require.Nil(t, positional)
+			} else {
+				require.Equal(t, tc.expectedPositional, positional)
+			}
+
+			if tc.expectedFlags == nil {
+				require.Nil(t, flags)
+			} else {
+				require.Equal(t, tc.expectedFlags, flags)
+			}
+		})
+	}
+}
+
 func TestServer_exportRuntimeArgs(t *testing.T) {
 	t.Parallel()
 
@@ -880,15 +946,34 @@ func TestServer_exportRuntimeArgs(t *testing.T) {
 			},
 		},
 		{
-			name: "skip non-flag arguments",
-			args: []string{"--host", "localhost", "not-a-flag", "--debug"},
+			name: "positional arguments before flags",
+			args: []string{"/path/to/file", "second-positional", "--host", "localhost", "--debug"},
 			seen: map[string]struct{}{},
 			expectedArgs: []string{
+				"${MCPD__TEST_SERVER__ARG_1}",
+				"${MCPD__TEST_SERVER__ARG_2}",
 				"--host=${MCPD__TEST_SERVER__HOST}",
 				"--debug",
 			},
 			expectedCalls: map[string]string{
-				"MCPD__TEST_SERVER__HOST": "${MCPD__TEST_SERVER__HOST}",
+				"MCPD__TEST_SERVER__ARG_1": "${MCPD__TEST_SERVER__ARG_1}",
+				"MCPD__TEST_SERVER__ARG_2": "${MCPD__TEST_SERVER__ARG_2}",
+				"MCPD__TEST_SERVER__HOST":  "${MCPD__TEST_SERVER__HOST}",
+			},
+		},
+		{
+			name: "only positional arguments",
+			args: []string{"/path/to/file", "second-arg", "third-arg"},
+			seen: map[string]struct{}{},
+			expectedArgs: []string{
+				"${MCPD__TEST_SERVER__ARG_1}",
+				"${MCPD__TEST_SERVER__ARG_2}",
+				"${MCPD__TEST_SERVER__ARG_3}",
+			},
+			expectedCalls: map[string]string{
+				"MCPD__TEST_SERVER__ARG_1": "${MCPD__TEST_SERVER__ARG_1}",
+				"MCPD__TEST_SERVER__ARG_2": "${MCPD__TEST_SERVER__ARG_2}",
+				"MCPD__TEST_SERVER__ARG_3": "${MCPD__TEST_SERVER__ARG_3}",
 			},
 		},
 		{