Updated the documentation!

Author: PowerCommands

Docs/Create_new_ project.md

@@ -2,7 +2,7 @@
 
 Download the Visual Studio Template zipfile from [here](https://github.com/PowerCommands/PowerCommands2022/tree/main/Templates)
 
-Copy the .zip file into the user project template directory. By default, this directory is %USERPROFILE%\Documents\Visual Studio <version>\Templates\ProjectTemplates.
+Copy the .zip file into the user project template directory. By default, this directory is %USERPROFILE%\Documents\Visual Studio %version%\Templates\ProjectTemplates.
 
 Open Visual Studio and write Power in the searchbox, you should find the PowerCommand template.
 
@@ -18,6 +18,17 @@ And this is what you should se!
 
 ![Alt text](images/DemoCommand.png?raw=true "Demo Command")
 
+Do not worry about all the drama that an empty demo input creates, demo command demonstrates who you can use options to design your command and add built in validation with.
+The demo command has an design attribute that looks something like this:
+
+```
+[PowerCommandDesign( description: "Demo command just to try out how you could use the input...",
+                         options: "!MANDATORY|!pause",
+                         example: "//Must provide the MANDATORY option will trigger a validation error otherwise|demo MANDATORY|//Test the pause service|demo --pause 5 MANDATORY")]
+```
+
+Read more about designing your commands in the following steps.
+
 Next step, create your first [PowerCommand](Create_new_command.md).
 
 [Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/PowerCommands Design Principles And Guidlines.md

@@ -259,6 +259,9 @@ PowerCommands rely on reflection to find all existing PowerCommands that are val
  PowerCommands handles export and imports of environment variables using YAML files it is the preferred way to store secrets. Do not store sensitive information inside the application path as it will be to easy to steal with a simple copy and paste operation, sensitive information should always be encrypted at rest.
 
 ## <a name='Usethesecretsbuiltinfunctionallity'></a>Use the secrets built in functionallity 
+Secret is initialized the fist time you startup a new power command project on your machine, the same keys for encryption/decryption is used by all your PowerCommands based applications on the same machine.
+If you setup PowerCommands on a diffrent machine, a new key for encryption/decryption will be used, meaning you have to create the secrets again on that machine. But you can move the keys manually, but I do not think that you should do that.
+
 Create secret with built in commands named secret, like this:
 ```
 secret create "localDB"
@@ -268,16 +271,24 @@ In you command you could get the decrypted secret like this.
 ```
 var cn = Configuration.Secret.DecryptSecret("Server=.;Database=timelineLocalDB;User Id=sa;Password=##localDB##;"); 
 ```
+
+Another simple usa case where you decrypt your secret access token. Lets pretend that you have created a secret named **AWS_TOKEN**.
+
+```
+var accessToken = Configuration.Secret.DecryptSecret("##AWS_TOKEN##");
+```
+
 Sometimes you have to pass a configuration element to a thirdparty or custom module, then this could be usefull, it creates a new clone of the configuration and you pass that, its a good pattern ratcher then pass the runtime configuration instance that could lead to unpredictable result and in worst case revealing the decrypted secret by mistake.
 ```
 var decryptedCloneConfiguration = Configuration.Secret.DecryptSecret(config.SourceSetting, nameof(config.SourceSetting.ConnectionString));
 ```
 You pass in the configuration and the property name that has a tagged secret and you get a clone of the configuration back where the property value decrypted. In the example above it is the **ConnectionString** property that is decrypted.
 
-## <a name='Becarefullwhendecryptingbesuretoprotectyoursecretsinruntime'></a>Be carefull when decrypting, be sure to protect your secrets in runtime
+
+## Be carefull when decrypting, be sure to protect your secrets in runtime
 It is very easy to expose a decrypted value by mistake, the decryption should be in the same scope or in very near scope of the usage. It should not be passed around with the other configuration values and reside in runtime as long as the application executes. The risk is that for example the decrypted value is logged for some reason you cant predict and the secret is logged as clear text, in other words it is revealed and must be changed.
 
-### <a name='RecomendedpatternforcustomCompenentsusingsecretspasstheDecryptSecretfunction'></a>Recomended pattern for custom Compenents using secrets, pass the DecryptSecret function
+### Recomended pattern for custom Compenents using secrets, pass the DecryptSecret function
 A pattern to reduce this risk could be to send the DecryptSecret function to the target rather then send the decrypted configuration, like this example below. In this real world use case I using a Custom Component, I want to implement the secret handling as late as possible but avoid to create a depandancy between the custom component and PowerCommands. I have to modify the Custom component a bit but no dependancy is needed. 
 ```
 //First I add this to the class in the custom component that will use the connction string.

Docs/Secrets.md

@@ -1,20 +1,9 @@
 # Secrets
 
 ## Configure your environment to use Encryption/Decryption and Secrets functionallity
-Run first this command
-```
-secret
-```
-This will do a test do encrypt and decrypt a text, this will cause a error that will look something like this.
-![Alt text](images/secret_configuration.png?raw=true "Secret configuration")
-All you have to do is to run the same command with the --initialize option like this.
-```
-secret --initialize
-```
-Now your environment is ready to use Encryption with all your PowerCommands running on that machine. Please note that the name of the environment variable is configurable in the secret.yaml file, **_encryptionManager** is the default name. Also note that values that you encrypt on our machine can not be decrypted on another machine, unless you copy the encryption keys.
-
-Now your environment is ready!
-
+## Good to know
+Secret is initialized the fist time you startup a new power command project on your machine, the same keys for encryption/decryption is used by all your PowerCommands based applications on the same machine.
+If you setup PowerCommands on a diffrent machine, a new key for encryption/decryption will be used, meaning you have to create the secrets again on that machine. But you can move the keys manually, but I do not think that you should do that.
 ## Use the secrets built in functionallity 
 Create secret with built in commands named secret, like this:
 ```
@@ -25,12 +14,20 @@ In you command you could get the decrypted secret like this.
 ```
 var cn = Configuration.Secret.DecryptSecret("Server=.;Database=timelineLocalDB;User Id=sa;Password=##localDB##;"); 
 ```
+
+Another simple usa case where you decrypt your secret access token. Lets pretend that you have created a secret named **AWS_TOKEN**.
+
+```
+var accessToken = Configuration.Secret.DecryptSecret("##AWS_TOKEN##");
+```
+
 Sometimes you have to pass a configuration element to a thirdparty or custom module, then this could be usefull, it creates a new clone of the configuration and you pass that, its a good pattern ratcher then pass the runtime configuration instance that could lead to unpredictable result and in worst case revealing the decrypted secret by mistake.
 ```
 var decryptedCloneConfiguration = Configuration.Secret.DecryptSecret(config.SourceSetting, nameof(config.SourceSetting.ConnectionString));
 ```
 You pass in the configuration and the property name that has a tagged secret and you get a clone of the configuration back where the property value decrypted. In the example above it is the **ConnectionString** property that is decrypted.
 
+
 ## Be carefull when decrypting, be sure to protect your secrets in runtime
 It is very easy to expose a decrypted value by mistake, the decryption should be in the same scope or in very near scope of the usage. It should not be passed around with the other configuration values and reside in runtime as long as the application executes. The risk is that for example the decrypted value is logged for some reason you cant predict and the secret is logged as clear text, in other words it is revealed and must be changed.
 

Docs/images/DemoCommand.png

@@ -20,7 +20,7 @@ You could se PowerCommands as an easy Create your CLI applikation starter kit. I
  - Zip with attributes like checksum, filecount and file size
  - Describe your commands with code examples using attributes. 
 
- ![Alt text](Docs/images/test_all.png?raw=true "Test result")
+ ![Alt text](Docs/images/startup.png?raw=true "Test result")
 
  ## Start your journey
 [Create a new VS Solution](Docs/Create_new_%20project.md)