public static async Task <bool> GetIsMakerImageAsync()
{
var cmdOutput = string.Empty;
var standardOutput = new InMemoryRandomAccessStream();
var options = new ProcessLauncherOptions
{
StandardOutput = standardOutput
};
var output = await ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, RegKeyQueryCmdArg, options);
if (output != null && output.ExitCode == 0)
{
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(outStreamRedirect))
{
uint bytesLoaded = 0;
while ((bytesLoaded = await dataReader.LoadAsync(CmdLineBufSize)) > 0)
{
cmdOutput += dataReader.ReadString(bytesLoaded);
}
}
}
Match match = Regex.Match(cmdOutput, ExpectedResultPattern, RegexOptions.IgnoreCase);
if (match.Success)
{
return(true);
}
else
{
ServiceUtil.LogService.Write("Could not get IsMakerImage. Output: " + cmdOutput);
}
}
return(false);
}
public static async Task SetAudioRenderVolume(int volume, bool retryOnException)
{
var result = await ProcessLauncher.RunToCompletionAsync(@"SetAudioRenderVolume.exe", volume.ToString(CultureInfo.InvariantCulture));
if (result.ExitCode != 200)
{
await Logger.Write("Could not set audio render volume.");
}
}
public static async Task <ProcessLauncherOutput> RunCommandAsync(string fileName, string args)
{
var output = new ProcessLauncherOutput();
try
{
using (var standardOutput = new InMemoryRandomAccessStream())
using (var standardError = new InMemoryRandomAccessStream())
{
var options = new ProcessLauncherOptions
{
StandardOutput = standardOutput,
StandardError = standardError
};
var result = await ProcessLauncher.RunToCompletionAsync(
fileName,
args,
options);
output.Result = result;
using (IInputStream inputStream = standardOutput.GetInputStreamAt(0))
{
ulong size = standardOutput.Size;
using (var dataReader = new DataReader(inputStream))
{
uint bytesLoaded = await dataReader.LoadAsync((uint)size);
output.Output = dataReader.ReadString(bytesLoaded);
}
}
using (IInputStream inputStream = standardError.GetInputStreamAt(0))
{
ulong size = standardError.Size;
using (var dataReader = new DataReader(inputStream))
{
uint bytesLoaded = await dataReader.LoadAsync((uint)size);
output.Error = dataReader.ReadString(bytesLoaded);
}
}
}
return(output);
}
catch (Exception ex)
{
ServiceUtil.LogService.WriteException(ex);
}
return(null);
}
public static async Task SetAudioCaptureVolume(double volume, bool retryOnException)
{
//96.14% db equals 90% volume with Logitech G933 Headset
var result = await ProcessLauncher.RunToCompletionAsync(@"SetAudioCaptureVolume.exe", volume.ToString(CultureInfo.InvariantCulture));
if (result.ExitCode != 200)
{
await Logger.Write("Could not set audio capture volume.");
}
}
private async Task RunProcess()
{
var options = new ProcessLauncherOptions();
var standardOutput = new InMemoryRandomAccessStream();
var standardError = new InMemoryRandomAccessStream();
options.StandardOutput = standardOutput;
options.StandardError = standardError;
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var result = await ProcessLauncher.RunToCompletionAsync(cmd.Text, args.Text == null ? string.Empty : args.Text, options);
ProcessExitCode.Text += "Process Exit Code: " + result.ExitCode;
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
var size = standardOutput.Size;
using (var dataReader = new DataReader(outStreamRedirect))
{
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
StdOutputText.Text += stringRead;
}
}
using (var errStreamRedirect = standardError.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(errStreamRedirect))
{
var size = standardError.Size;
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
StdErrorText.Text += stringRead;
}
}
}
catch (UnauthorizedAccessException uex)
{
StdErrorText.Text += "Exception Thrown: " + uex.Message + "\n";
StdErrorText.Text += "\nMake sure you're allowed to run the specified exe; either\n" +
"\t1) Add the exe to the AppX package, or\n" +
"\t2) Add the absolute path of the exe to the allow list:\n" +
"\t\tHKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\EmbeddedMode\\ProcessLauncherAllowedExecutableFilesList.\n\n" +
"Also, make sure the <iot:Capability Name=\"systemManagement\" /> has been added to the AppX manifest capabilities.\n";
}
catch (Exception ex)
{
StdErrorText.Text += "Exception Thrown:" + ex.Message + "\n";
StdErrorText.Text += ex.StackTrace + "\n";
}
});
}
public static async Task Restart()
{
if (!_initialized)
{
return;
}
await StopAll();
await AudioPlayerController.PlayAndWaitAsync(AudioName.Restart);
await ProcessLauncher.RunToCompletionAsync(@"CmdWrapper.exe", "\"shutdown -r -t 0\"");
}
private async void button_ClickAsync(object sender, RoutedEventArgs e)
{
var options = new ProcessLauncherOptions();
var standardOutput = new InMemoryRandomAccessStream();
var standardError = new InMemoryRandomAccessStream();
options.StandardOutput = standardOutput;
options.StandardError = standardError;
//var options = new ProcessLauncherOptions();
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => {
const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe";
//var result = await ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, String.Empty, options);
var result = await ProcessLauncher.RunToCompletionAsync(@"ConsoleApp1.exe", String.Empty, options);
//await ExecuteCommandLineString(@"C:\Program Files (x86)\KeePass Password Safe 2\KeePass.exe");
});
//var result = await ProcessLauncher.RunToCompletionAsync(@"C:\Program Files (x86)\KeePass Password Safe 2\KeePass.exe","\"D:\\KeePass\\KeePass.kdbx\" -pw-stdin", options);
//reg ADD "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\EmbeddedMode\ProcessLauncher" /v AllowedExecutableFilesList /t REG_MULTI_SZ /d "C:\Program Files (x86)\KeePass Password Safe 2\KeePass.exe\0"
//var result = await ProcessLauncher.RunToCompletionAsync(@"D:\ConsoleApp1.exe", String.Empty, options);
//"c:\windows\system32\cmd.exe"
//REG QUERY "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\EmbeddedMode\ProcessLauncher" /v AllowedExecutableFilesList
//reg ADD "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\EmbeddedMode\ProcessLauncher" /f /v AllowedExecutableFilesList /t REG_MULTI_SZ /d "c:\windows\system32\cmd.exe\0"
//reg ADD "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\EmbeddedMode\ProcessLauncher" /f /v AllowedExecutableFilesList /t REG_MULTI_SZ /d "E:\Tests\HelloWorldUWP\HelloWorldUWP\ConsoleApp1.exe\0"
//reg ADD "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\EmbeddedMode\ProcessLauncher" / f / v AllowedExecutableFilesList / t REG_MULTI_SZ / d "E:\Tests\HelloWorldUWP\HelloWorldUWP\ConsoleApp1.exe\0"
//IAsyncOperation<ProcessLauncherResult> RunToCompletionAsync(string fileName, string args, ProcessLauncherOptions options)
/*pProcess.StartInfo.FileName = @"C:\Program Files (x86)\KeePass Password Safe 2\KeePass.exe";
* pProcess.StartInfo.Arguments = "\"D:\\KeePass\\KeePass.kdbx\" -pw-stdin";
*
* pProcess.StartInfo.UseShellExecute = false;
* pProcess.StartInfo.RedirectStandardInput = true;
* pProcess.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
*
*
* pProcess.Start();
*
* pProcess.StandardInput.WriteLine("q1w2e3r4");
* pProcess.StandardInput.Close();*/
}
private void StartProxyProcess()
{
processLauncherOptions = new ProcessLauncherOptions();
standardInput = new InMemoryRandomAccessStream();
processLauncherOptions.StandardOutput = null;
processLauncherOptions.StandardError = null;
processLauncherOptions.StandardInput = standardInput.GetInputStreamAt(0);
processLauncherResult = ProcessLauncher.RunToCompletionAsync(
"comm-proxy.exe",
"com.microsoft.echo" + " " + Package.Current.Id.FamilyName,
processLauncherOptions);
}
public async Task RunProcess(string cmd, string args)
{
var options = new ProcessLauncherOptions();
var standardOutput = new InMemoryRandomAccessStream();
var standardError = new InMemoryRandomAccessStream();
options.StandardOutput = standardOutput;
options.StandardError = standardError;
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var result = await ProcessLauncher.RunToCompletionAsync(cmd, args == null ? string.Empty : args, options);
//ProcessExitCode.Text += "Process Exit Code: " + result.ExitCode;
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
var size = standardOutput.Size;
using (var dataReader = new DataReader(outStreamRedirect))
{
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
Debug.WriteLine(cmd + "Output:" + stringRead);
//StdOutputText.Text += stringRead;
}
}
using (var errStreamRedirect = standardError.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(errStreamRedirect))
{
var size = standardError.Size;
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
Debug.WriteLine(cmd + "Error:" + stringRead);
//StdErrorText.Text += stringRead;
}
}
}
catch (UnauthorizedAccessException uex)
{
}
catch (Exception ex)
{
}
});
}
private async Task <bool> IsMakerImager()
{
var cmdOutput = string.Empty;
var standardOutput = new InMemoryRandomAccessStream();
var options = new ProcessLauncherOptions
{
StandardOutput = standardOutput
};
try
{
var result = await ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, RegKeyQueryCmdArg, options);
if (result.ExitCode == 0)
{
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(outStreamRedirect))
{
uint bytesLoaded = 0;
while ((bytesLoaded = await dataReader.LoadAsync(CmdLineBufSize)) > 0)
{
cmdOutput += dataReader.ReadString(bytesLoaded);
}
}
}
}
Match match = Regex.Match(cmdOutput, ExpectedResultPattern, RegexOptions.IgnoreCase);
if (match.Success)
{
return(true);
}
}
catch (Exception ex)
{
// Could not read the value
Log.Write("Could not read maker image value in registry");
Log.Write(ex.ToString());
}
return(false);
}
public void Start()
{
if (_processExecutionTask != null)
{
return;
}
_processExecutionTask = ProcessLauncher
.RunToCompletionAsync(_command, _args, new ProcessLauncherOptions
{
StandardInput = _inputStream,
StandardOutput = _standardOutWatcher,
StandardError = _standardErrWatcher,
WorkingDirectory = _workingDirectory,
})
.AsTask(_cancellationSource.Token)
.ContinueWith(OnProcessCompleted, TaskContinuationOptions.OnlyOnRanToCompletion)
.ContinueWith(OnProcessFaulted, TaskContinuationOptions.OnlyOnFaulted);
}
public async Task <IResponse> SendCommandAsync(IRequest command)
{
var processLauncherOptions = new ProcessLauncherOptions();
var standardInput = new InMemoryRandomAccessStream();
var standardOutput = new InMemoryRandomAccessStream();
processLauncherOptions.StandardOutput = standardOutput;
processLauncherOptions.StandardError = null;
processLauncherOptions.StandardInput = standardInput.GetInputStreamAt(0);
await command.Serialize().WriteToIOutputStreamAsync(standardInput);
standardInput.Dispose();
var processLauncherResult = await ProcessLauncher.RunToCompletionAsync(@"C:\Windows\System32\CommProxy.exe", "", processLauncherOptions);
if (processLauncherResult.ExitCode == 0)
{
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
var response = (await Blob.ReadFromIInputStreamAsync(outStreamRedirect)).MakeIResponse();
if (response.Status != ResponseStatus.Success)
{
var stringResponse = response as StringResponse;
if (stringResponse != null)
{
throw new Exception(stringResponse.Response);
}
throw new Exception("Operation failed");
}
return(response);
}
}
else
{
throw new Exception("CommProxy cannot read data from the input pipe");
}
}
private void LaunchCmdProcess(string commandLineText)
{
var args = String.Format("/C \"{0}\"", commandLineText);;
var standardOutput = new InMemoryRandomAccessStream();
var standardError = new InMemoryRandomAccessStream();
var options = new ProcessLauncherOptions
{
StandardOutput = standardOutput,
StandardError = standardError,
WorkingDirectory = GetWorkingDirectory()
};
string stdErrRunText = string.Empty;
CommandError commandError = CommandError.None;
isProcessRunning = true;
isProcessTimedOut = false;
lastOutputTime = DateTime.Now;
processLauncherOperation = ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options);
processLauncherOperation.Completed = (operation, status) =>
{
isProcessRunning = false;
if (status == AsyncStatus.Canceled)
{
if (isProcessTimedOut)
{
commandError = CommandError.TimedOut;
stdErrRunText = "\n" + String.Format(resourceLoader.GetString("CommandTimeoutText"), TimeOutAfterNoOutput.Seconds);
}
else
{
commandError = CommandError.Cancelled;
stdErrRunText = "\n" + resourceLoader.GetString("CommandCancelled");
}
}
else if (status == AsyncStatus.Error)
{
if (operation.ErrorCode.HResult == HRESULT_AccessDenied)
{
commandError = CommandError.NotAuthorized;
stdErrRunText = String.Format(resourceLoader.GetString("CmdNotEnabled"), EnableCommandLineProcesserRegCommand);
}
else
if (operation.ErrorCode.HResult == HRESULT_InvalidDirectory)
{
commandError = CommandError.InvalidDirectory;
stdErrRunText = String.Format(resourceLoader.GetString("WorkingDirectoryInvalid"), options.WorkingDirectory);
}
else
{
commandError = CommandError.GenericError;
stdErrRunText = String.Format(resourceLoader.GetString("CommandLineError"), operation.ErrorCode.Message);
}
}
if (commandError != CommandError.None)
{
ShowError(stdErrRunText);
if (commandError == CommandError.NotAuthorized)
{
ShowAuthorizationUI();
}
}
if (commandError == CommandError.InvalidDirectory)
{
EnableCommandLineTextBox(true, WorkingDirectory);
}
else
{
EnableCommandLineTextBox(true, CommandLine);
}
};
var stdOutTask = ThreadPool.RunAsync(async(t) =>
{
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
using (var streamReader = new StreamReader(outStreamRedirect.AsStreamForRead()))
{
await ReadText(streamReader);
}
}
}).AsTask();
var stdErrTask = ThreadPool.RunAsync(async(t) =>
{
using (var errStreamRedirect = standardError.GetInputStreamAt(0))
{
using (var streamReader = new StreamReader(errStreamRedirect.AsStreamForRead()))
{
await ReadText(streamReader, isErrorRun: true);
}
}
}).AsTask();
Task[] tasks = new Task[2]
{
stdOutTask,
stdErrTask
};
Task.WaitAll(tasks);
}
private async Task RunProcess()
{
if (string.IsNullOrWhiteSpace(CommandLine.Text))
{
return;
}
commandLineHistory.Add(CommandLine.Text);
currentCommandLine = commandLineHistory.Count;
bool isCmdAuthorized = true;
Run cmdLineRun = new Run();
cmdLineRun.Foreground = new SolidColorBrush(Windows.UI.Colors.LightGray);
cmdLineRun.FontWeight = FontWeights.Bold;
cmdLineRun.Text = currentDirectory + "> " + CommandLine.Text + "\n";
Run stdOutRun = new Run();
Run stdErrRun = new Run();
stdErrRun.Foreground = new SolidColorBrush(Windows.UI.Colors.Red);
var commandLineText = CommandLine.Text.Trim();
if (commandLineText.Equals("cls", StringComparison.CurrentCultureIgnoreCase))
{
StdOutputText.Blocks.Clear();
return;
}
else if (commandLineText.StartsWith("cd ", StringComparison.CurrentCultureIgnoreCase) || commandLineText.Equals("cd", StringComparison.CurrentCultureIgnoreCase))
{
stdErrRun.Text = resourceLoader.GetString("CdNotSupported");
}
else if (commandLineText.Equals("exit", StringComparison.CurrentCultureIgnoreCase))
{
NavigationUtils.GoBack();
}
else
{
var standardOutput = new InMemoryRandomAccessStream();
var standardError = new InMemoryRandomAccessStream();
var options = new ProcessLauncherOptions
{
StandardOutput = standardOutput,
StandardError = standardError
};
try
{
var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\"";
var result = await ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options);
// First write std out
using (var outStreamRedirect = standardOutput.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(outStreamRedirect))
{
await ReadText(dataReader, stdOutRun);
}
}
// Then write std err
using (var errStreamRedirect = standardError.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(errStreamRedirect))
{
await ReadText(dataReader, stdErrRun);
}
}
}
catch (UnauthorizedAccessException uex)
{
isCmdAuthorized = false;
var errorMessage = uex.Message + "\n\n" + resourceLoader.GetString("CmdNotEnabled");
stdErrRun.Text = errorMessage;
}
catch (Exception ex)
{
var errorMessage = ex.Message + "\n" + ex.StackTrace + "\n";
stdErrRun.Text = errorMessage;
}
}
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Paragraph paragraph = new Paragraph();
paragraph.Inlines.Add(cmdLineRun);
paragraph.Inlines.Add(stdOutRun);
paragraph.Inlines.Add(stdErrRun);
if (!isCmdAuthorized)
{
InlineUIContainer uiContainer = new InlineUIContainer();
Button cmdEnableButton = new Button();
cmdEnableButton.Content = resourceLoader.GetString("EnableCmdText");
cmdEnableButton.Click += AccessButtonClicked;
uiContainer.Child = cmdEnableButton;
paragraph.Inlines.Add(uiContainer);
}
StdOutputText.Blocks.Add(paragraph);
});
}
private async Task <CdResult> ExecuteCdCmd(string strCmd)
{
var curDir = currentDirectory;
if (strCmd.StartsWith("cd ", StringComparison.CurrentCultureIgnoreCase))
{
try
{
var args = strCmd.Substring(3).Trim();
if (string.IsNullOrEmpty(args) || string.IsNullOrEmpty(args.Replace('\\', ' ').Replace('/', ' ').Trim()))
{
currentDirectory = "C:\\";
return(CdResult.Succeed);
}
if (args.Contains("*"))
{
return(CdResult.InvalidPath);
}
var cmdout = new InMemoryRandomAccessStream();
var cmderr = new InMemoryRandomAccessStream();
if (args.StartsWith("C:\\", StringComparison.CurrentCultureIgnoreCase) ||
args.StartsWith("C:/", StringComparison.CurrentCultureIgnoreCase))
{
curDir = "C:\\";
args = args.Substring(3);
}
ProcessLauncherOptions options = new ProcessLauncherOptions()
{
StandardOutput = cmdout,
StandardError = cmderr,
WorkingDirectory = curDir
};
foreach (var item in args.Split('\\', '/'))
{
var dirStr = item.Trim();
if (dirStr.Equals(".."))
{
if (!curDir.Equals("C:\\", StringComparison.CurrentCultureIgnoreCase))
{
curDir = curDir.Substring(0, curDir.LastIndexOf('\\'));
curDir = curDir.Substring(0, curDir.LastIndexOf('\\') + 1);
options.WorkingDirectory = curDir;
}
}
else if (string.IsNullOrEmpty(dirStr) || dirStr.Equals("."))
{
continue;
}
else
{
string dir = "/C \"cd \"" + curDir + "\" & " + "cd \"" + dirStr + "\"\"";
var result = await ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, dir, options);
if (result.ExitCode == 0)
{
curDir += dirStr + "\\";
options.WorkingDirectory = curDir;
}
else
{
return(CdResult.DirNotFound);
}
}
}
currentDirectory = curDir;
return(CdResult.Succeed);
}
catch (Exception ex)
{
throw ex;
}
}
else if (strCmd.Equals("cd", StringComparison.CurrentCultureIgnoreCase))
{
currentDirectory = "C:\\";
return(CdResult.Succeed);
}
return(CdResult.NotCdCommand);
}
/// <summary>
/// Runs a process.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="workingDirectory">The working directory.</param>
public async Task StartProcessAsync(string fileName, string arguments, string workingDirectory = null)
{
// Are we showing diagnostics?
if (ShowDiagnostics)
{
await WriteOutputAsync("Preparing to run " + fileName, Color.FromArgb(255, 0, 255, 0));
if (!string.IsNullOrEmpty(arguments))
{
await WriteOutputAsync(" with arguments " + arguments + "." + Environment.NewLine, Color.FromArgb(255, 0, 255, 0));
}
else
{
await WriteOutputAsync("." + Environment.NewLine, Color.FromArgb(255, 0, 255, 0));
}
}
await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var result = await ProcessLauncher.RunToCompletionAsync(
fileName,
arguments,
new ProcessLauncherOptions
{
WorkingDirectory = workingDirectory,
StandardOutput = OutputStream,
StandardError = ErrorStream
});
using (var outStreamRedirect = OutputStream.GetInputStreamAt(0))
{
var size = OutputStream.Size;
using (var dataReader = new DataReader(outStreamRedirect))
{
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
await WriteOutputAsync(stringRead, Colors.White);
}
}
using (var errStreamRedirect = ErrorStream.GetInputStreamAt(0))
{
using (var dataReader = new DataReader(errStreamRedirect))
{
var size = ErrorStream.Size;
var bytesLoaded = await dataReader.LoadAsync((uint)size);
var stringRead = dataReader.ReadString(bytesLoaded);
await WriteOutputAsync(stringRead, Colors.Red);
}
}
}
catch (UnauthorizedAccessException uex)
{
await WriteOutputAsync($"Exception Thrown: {uex.Message}{Environment.NewLine}", Colors.Red);
await WriteOutputAsync($"Make sure you're allowed to run the specified exe; either{Environment.NewLine}" +
$"\t1) Add the exe to the AppX package, or{Environment.NewLine}" +
$"\t2) Add the absolute path of the exe to the allow list:{Environment.NewLine}" +
$"\t\tHKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\EmbeddedMode\\ProcessLauncherAllowedExecutableFilesList.{Environment.NewLine}{Environment.NewLine}" +
$"Also, make sure the <iot:Capability Name=\"systemManagement\" /> has been added to the AppX manifest capabilities.{Environment.NewLine}", Colors.Red);
}
catch (Exception ex)
{
await WriteOutputAsync($"Exception Thrown: {ex.Message}{Environment.NewLine}", Colors.Red);
await WriteOutputAsync($"{ex.StackTrace}{Environment.NewLine}", Colors.Red);
}
});
}
