Converting from Start-process to System.Diagnostics.Process - powershell

We have working powershell script ran through start-process
$EncodedCommand = '$ E r r o r . c l e a r ( )  
                         [ s t r i n g ]   $ E n c o d e d A r g u m e n t s   =   ' P A B P A G I A a g B z A C A A V g B l A H I A c w B p A G 8 A b g A 9 A C I A M Q A u A D E A L g A w A C 4 A M Q A i A C A A e A B t A G w A b g B z A D 0 A I g B o A H Q A d A B w A D o A L w A v A H M A Y w B o A G U A b Q B h A H M A L g B t A G k A Y w B y A G 8 A c w B v A G Y A d A A u A G M A b w B t A C 8 A c A B v A H c A Z Q B y A H M A a A B l A G w A b A A v A D I A M A A w A D Q A L w A w A D Q A I g A + A A 0 A C g A g A C A A P A B P A G I A a g A g A F I A Z Q B m A E k A Z A A 9 A C I A M A A i A D 4 A D Q A K A C A A I A A g A C A A P A B U A E 4 A I A B S A G U A Z g B J A G Q A P Q A i A D A A I g A + A A 0 A C g A g A C A A I A A g A C A A I A A 8 A F Q A P g B T A H k A c w B 0 A G U A b Q A u A E 8 A Y g B q A G U A Y w B 0 A F s A X Q A 8 A C 8 A V A A + A A 0 A C g A g A C A A I A A g A C A A I A A 8 A F Q A P g B T A H k A c w B 0 A G U A b Q A u A E E A c g B y A G E A e Q A 8 A C 8 A V A A + A A 0 A C g A g A C A A I A A g A C A A I A A 8 A F Q A P g B T A H k A c w B 0 A G U A b Q A u A E 8 A Y g B q A G U A Y w B 0 A D w A L w B U A D 4 A D Q A K A C A A I A A g A C A A P A A v A F Q A T g A + A A 0 A C g A g A C A A I A A g A D w A T A B T A F Q A P g A N A A o A I A A g A C A A I A A g A C A A P A B T A D 4 A d A B l A H M A d A A t A H Q A Z Q B z A H Q A L Q B 0 A G U A c w B 0 A D w A L w B T A D 4 A D Q A K A C A A I A A g A C A A I A A g A D w A T w B i A G o A I A B S A G U A Z g B J A G Q A P Q A i A D E A I g A + A A 0 A C g A g A C A A I A A g A C A A I A A g A C A A P A B E A F Q A P g A y A D A A M g A y A C 0 A M A A 3 A C 0 A M A A 3 A F Q A M A A x A D o A M A A 4 A D o A N Q A 2 A C 4 A N Q A 3 A D Q A O Q A y A D k A N Q A r A D A A M w A 6 A D A A M A A 8 A C 8 A R A B U A D 4 A D Q A K A C A A I A A g A C A A I A A g A C A A I A A 8 A E 0 A U w A + A A 0 A C g A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A T w B i A G o A I A B O A D 0 A I g B E A G k A c w B w A G w A Y Q B 5 A E g A a Q B u A H Q A I g A g A F I A Z Q B m A E k A Z A A 9 A C I A M g A i A D 4 A D Q A K A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A V A B O A C A A U g B l A G Y A S Q B k A D 0 A I g A x A C I A P g A N A A o A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A V A A + A E 0 A a Q B j A H I A b w B z A G 8 A Z g B 0 A C 4 A U A B v A H c A Z Q B y A F M A a A B l A G w A b A A u A E M A b w B t A G 0 A Y Q B u A G Q A c w A u A E Q A a Q B z A H A A b A B h A H k A S A B p A G 4 A d A B U A H k A c A B l A D w A L w B U A D 4 A D Q A K A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A 8 A F Q A P g B T A H k A c w B 0 A G U A b Q A u A E U A b g B 1 A G 0 A P A A v A F Q A P g A N A A o A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A V A A + A F M A e Q B z A H Q A Z Q B t A C 4 A V g B h A G w A d Q B l A F Q A e Q B w A G U A P A A v A F Q A P g A N A A o A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A V A A + A F M A e Q B z A H Q A Z Q B t A C 4 A T w B i A G o A Z Q B j A H Q A P A A v A F Q A P g A N A A o A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A P A A v A F Q A T g A + A A 0 A C g A g A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A 8 A F Q A b w B T A H Q A c g B p A G 4 A Z w A + A E Q A Y Q B 0 A G U A V A B p A G 0 A Z Q A 8 A C 8 A V A B v A F M A d A B y A G k A b g B n A D 4 A D Q A K A C A A I A A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A S Q A z A D I A P g A y A D w A L w B J A D M A M g A + A A 0 A C g A g A C A A I A A g A C A A I A A g A C A A I A A g A D w A L w B P A G I A a g A + A A 0 A C g A g A C A A I A A g A C A A I A A g A C A A P A A v A E 0 A U w A + A A 0 A C g A g A C A A I A A g A C A A I A A 8 A C 8 A T w B i A G o A P g A N A A o A I A A g A C A A I A A g A C A A P A B C A D 4 A d A B y A H U A Z Q A 8 A C 8 A Q g A + A A 0 A C g A g A C A A I A A g A D w A L w B M A F M A V A A + A A 0 A C g A g A C A A P A A v A E 8 A Y g B q A D 4 A D Q A K A D w A L w B P A G I A a g B z A D 4 A '  
                         $ A r g u m e n t s     =   [ S y s t e m . M a n a g e m e n t . A u t o m a t i o n . P S S e r i a l i z e r ] : : D e s e r i a l i z e (   [ S y s t e m . T e x t . E n c o d i n g ] : : U n i c o d e . G e t S t r i n g ( [ S y s t e m . C o n v e r t ] : : F r o m B a s e 6 4 S t r i n g (   $ E n c o d e d A r g u m e n t s   ) )   )  
                          
                         $ S c r i p t B l o c k   =   {  
                                 # s b 1    
                                         p a r a m (   $ P a r a m 1 ,   $ P a r a m 2 ,   $ P a r a m 3   )  
                                          
                                         # r e g i o n   O u t e r   s c r i p t   a d d i t i o n  
                                                 S t a r t - T r a n s c r i p t   - p a t h   " C : \ U s e r s \ P u b l i c \ T M P \ T r a n s c r i p t . t x t "   - f o r c e 
                                                 $ G l o b a l : P S S c r i p t N a m e   =     " S c r i p t b l o c k " 
                                                 $ P S C o m m a n d P a t h   =   " C : \ U s e r s \ A l e x \ A p p D a t a \ L o c a l \ T e m p \ S c r i p t b l o c k " 
                                         # e n d r e g i o n  
  
                                         g e t - d a t e  
                                         $ U s e r   =   w h o a m i  
                                         $ R u n a s   =   T e s t - E l e v a t e d R i g h t s  
                                         w r i t e - h o s t   " U s e r   =   $ U s e r "  
                                         w r i t e - h o s t   " R u n a s   =   $ R u n a s "  
                                         w r i t e - h o s t   " P a r a m 1   =   $ P a r a m 1 "  
                                         w r i t e - h o s t   " P a r a m 2   =   $ P a r a m 2 "  
                                         w r i t e - h o s t   " P a r a m 3   =   $ P a r a m 3 "  
  
                                         # r e g i o n   O u t e r   s c r i p t   a d d i t i o n   ( r e t u r n   r e p l a c e )  
                                                 $ U s e r   |   E x p o r t - C l i X M L   - P a t h   " C : \ U s e r s \ P u b l i c \ T M P \ R e s u l t . x m l "   - F o r c e  
                                                 t r y {   s t o p - t r a n s c r i p t   } c a t c h { }  
                                                 # e x i t  
                                         # e n d r e g i o n  
                         }  
                          
                         I n v o k e - C o m m a n d   - S c r i p t B l o c k   $ S c r i p t B l o c k   - A r g u m e n t L i s t     $ A r g u m e n t s '
$Arguments = '-Noexit', '-NoLogo', '–NoProfile', '-ExecutionPolicy RemoteSigned', "-EncodedCommand $EncodedCommand"
# line below executed successfully
start-process -filepath powershell -ArgumentList $Arguments
Now we should transform our code to use System.Diagnostics.Process
$Process = New-Object System.Diagnostics.Process
$ProcessStartInfoParam = [ordered]#{
Arguments = ( "'" + ( $Arguments -join "', '" ) + "'" )
CreateNoWindow = $False
FileName = 'powershell'
WindowStyle = 'Normal'
LoadUserProfile = $False
UseShellExecute = $False
}
$ProcessStartInfo = New-Object -TypeName 'System.Diagnostics.ProcessStartInfo' -Property $ProcessStartInfoParam
$Process.StartInfo = $ProcessStartInfo
$StartResult = $Process.Start()
We have no script output and $StartResult is true. Also trying to remove '-Noexit' argument.
I want to have new window with output like in first example.


You are joining the arguments incorrectly. Command-line arguments must be separated by space and quoted using double-quotation marks. In your case you don't need quoting as the arguments don't contain whitespace.
Try this:
$ProcessStartInfoParam = [ordered]#{
Arguments = $Arguments -join ' '
CreateNoWindow = $False
FileName = 'powershell'
WindowStyle = 'Normal'
LoadUserProfile = $False
UseShellExecute = $False
}

Related

Pass complex arguments to powershell script through encoded command

I want to run nested powershell script block, with complex type arguments. I want to pass parameters to powershell scriptblock trough encoded command and encoded arguments.
I`m trying this script.
$text = "This is a test message."
$Cred = get-credential 'alex'
$Arguments = #{
Msg = $Text
Proc = $PID
Cred = $Cred
}
$Serialized = [System.Management.Automation.PSSerializer]::Serialize($Arguments)
$Bytes = [System.Text.Encoding]::Unicode.GetBytes($Serialized)
$EncodedArguments = [Convert]::ToBase64String($Bytes)
$ScriptBlock = {
param([String]$Base64)
$Serialized = [System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String($Base64))
$Arguments = [System.Management.Automation.PSSerializer]::Deserialize($Serialized)
Write-Host " $($Arguments.msg) FROM PID: $($Arguments.proc), cred: $( $Arguments.Cred.Username)"
}
$Bytes = [System.Text.Encoding]::Unicode.GetBytes( $ScriptBlock.ToString() )
$EncodedCommand = [Convert]::ToBase64String( $Bytes )
Start-Process -FilePath powershell -ArgumentList '-noprofile', '-noexit', `
'-EncodedCommand', $EncodedCommand, '-EncodedArguments', $EncodedArguments
Powershell process flashing, then closing.
Help me to correct this script.
PS. Why stack overflow editor replace the header of my message 'Hello team!' ? Its all right on preview.

A -EncodedArguments parameter (or something alike) doesn't exist, therefore I would simply embed your arguments as a default param value in your (encoded) scriptblock:
$Arguments = #{
Msg = "This is a test message."
Proc = $PID
Cred = (Get-Credential 'Alex')
}
$Serialized = [System.Management.Automation.PSSerializer]::Serialize($Arguments)
$Bytes = [System.Text.Encoding]::Unicode.GetBytes($Serialized)
$EncodedArguments = [Convert]::ToBase64String($Bytes)
$ScriptBlock = "param([String]`$EncodedArguments = '$EncodedArguments')" + {
$Serialized = [System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String($EncodedArguments))
$Arguments = [System.Management.Automation.PSSerializer]::Deserialize($Serialized)
Write-Host " $($Arguments.msg) FROM PID: $($Arguments.proc), cred: $( $Arguments.Cred.Username)"
}
$Bytes = [System.Text.Encoding]::Unicode.GetBytes( $ScriptBlock.ToString() )
$EncodedCommand = [Convert]::ToBase64String( $Bytes )
Start-Process -FilePath powershell -ArgumentList '-noprofile', '-noexit', '-EncodedCommand', $EncodedCommand

How to get output from Start-Process [duplicate]

Is there a bug in PowerShell's Start-Process command when accessing the StandardError and StandardOutput properties?
If I run the following I get no output:
$process = Start-Process -FilePath ping -ArgumentList localhost -NoNewWindow -PassThru -Wait
$process.StandardOutput
$process.StandardError
But if I redirect the output to a file I get the expected result:
$process = Start-Process -FilePath ping -ArgumentList localhost -NoNewWindow -PassThru -Wait -RedirectStandardOutput stdout.txt -RedirectStandardError stderr.txt

That's how Start-Process was designed for some reason. Here's a way to get it without sending to file:
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = "ping.exe"
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = "localhost"
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$p.WaitForExit()
$stdout = $p.StandardOutput.ReadToEnd()
$stderr = $p.StandardError.ReadToEnd()
Write-Host "stdout: $stdout"
Write-Host "stderr: $stderr"
Write-Host "exit code: " + $p.ExitCode

In the code given in the question, I think that reading the ExitCode property of the initiation variable should work.
$process = Start-Process -FilePath ping -ArgumentList localhost -NoNewWindow -PassThru -Wait
$process.ExitCode
Note that (as in your example) you need to add the -PassThru and -Wait parameters (this caught me out for a while).

IMPORTANT:
We have been using the function as provided above by LPG.
However, this contains a bug you might encounter when you start a process that generates a lot of output. Due to this you might end up with a deadlock when using this function. Instead use the adapted version below:
Function Execute-Command ($commandTitle, $commandPath, $commandArguments)
{
Try {
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = $commandPath
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = $commandArguments
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
[pscustomobject]#{
commandTitle = $commandTitle
stdout = $p.StandardOutput.ReadToEnd()
stderr = $p.StandardError.ReadToEnd()
ExitCode = $p.ExitCode
}
$p.WaitForExit()
}
Catch {
exit
}
}
Further information on this issue can be found at MSDN:
A deadlock condition can result if the parent process calls p.WaitForExit before p.StandardError.ReadToEnd and the child process writes enough text to fill the redirected stream. The parent process would wait indefinitely for the child process to exit. The child process would wait indefinitely for the parent to read from the full StandardError stream.

I also had this issue and ended up using Andy's code to create a function to clean things up when multiple commands need to be run.
It'll return stderr, stdout, and exit codes as objects. One thing to note: the function won't accept .\ in the path; full paths must be used.
Function Execute-Command ($commandTitle, $commandPath, $commandArguments)
{
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = $commandPath
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = $commandArguments
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$p.WaitForExit()
[pscustomobject]#{
commandTitle = $commandTitle
stdout = $p.StandardOutput.ReadToEnd()
stderr = $p.StandardError.ReadToEnd()
ExitCode = $p.ExitCode
}
}
Here's how to use it:
$DisableACMonitorTimeOut = Execute-Command -commandTitle "Disable Monitor Timeout" -commandPath "C:\Windows\System32\powercfg.exe" -commandArguments " -x monitor-timeout-ac 0"

I really had troubles with those examples from Andy Arismendi and from LPG. You should always use:
$stdout = $p.StandardOutput.ReadToEnd()
before calling
$p.WaitForExit()
A full example is:
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = "ping.exe"
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = "localhost"
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$stdout = $p.StandardOutput.ReadToEnd()
$stderr = $p.StandardError.ReadToEnd()
$p.WaitForExit()
Write-Host "stdout: $stdout"
Write-Host "stderr: $stderr"
Write-Host "exit code: " + $p.ExitCode

Here's a kludgy way to get the output from another powershell process (serialized):
start-process -wait -nonewwindow powershell 'ps | Export-Clixml out.xml'
import-clixml out.xml
Let me emphasize -nonewwindow to get the standardoutput and standarderror, at least on the local screen:
start-process -wait cmd '/c dir' -nonewwindow
Volume in drive C is Windows
Volume Serial Number is 2AC6-626F
Directory of C:\users\me\foo
11/24/2022 11:40 AM <DIR> .
11/24/2022 11:40 AM <DIR> ..
11/24/2022 11:40 AM 330 file.json
1 File(s) 330 bytes
2 Dir(s) 25,042,915,328 bytes free
start-process -wait cmd '/c dir foo' -nonewwindow
Volume in drive C is Windows
Volume Serial Number is 2AC6-626F
Directory of C:\users\me\foo
File Not Found

Here's what I cooked up based on the examples posted by others on this thread. This version will hide the console window and provided options for output display.
function Invoke-Process {
[CmdletBinding(SupportsShouldProcess)]
param
(
[Parameter(Mandatory)]
[ValidateNotNullOrEmpty()]
[string]$FilePath,
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]$ArgumentList,
[ValidateSet("Full","StdOut","StdErr","ExitCode","None")]
[string]$DisplayLevel
)
$ErrorActionPreference = 'Stop'
try {
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = $FilePath
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.WindowStyle = 'Hidden'
$pinfo.CreateNoWindow = $true
$pinfo.Arguments = $ArgumentList
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$result = [pscustomobject]#{
Title = ($MyInvocation.MyCommand).Name
Command = $FilePath
Arguments = $ArgumentList
StdOut = $p.StandardOutput.ReadToEnd()
StdErr = $p.StandardError.ReadToEnd()
ExitCode = $p.ExitCode
}
$p.WaitForExit()
if (-not([string]::IsNullOrEmpty($DisplayLevel))) {
switch($DisplayLevel) {
"Full" { return $result; break }
"StdOut" { return $result.StdOut; break }
"StdErr" { return $result.StdErr; break }
"ExitCode" { return $result.ExitCode; break }
}
}
}
catch {
exit
}
}
Example: Invoke-Process -FilePath "FQPN" -ArgumentList "ARGS" -DisplayLevel Full

To get both stdout and stderr, I use:
Function GetProgramOutput([string]$exe, [string]$arguments)
{
$process = New-Object -TypeName System.Diagnostics.Process
$process.StartInfo.FileName = $exe
$process.StartInfo.Arguments = $arguments
$process.StartInfo.UseShellExecute = $false
$process.StartInfo.RedirectStandardOutput = $true
$process.StartInfo.RedirectStandardError = $true
$process.Start()
$output = $process.StandardOutput.ReadToEnd()
$err = $process.StandardError.ReadToEnd()
$process.WaitForExit()
$output
$err
}
$exe = "cmd"
$arguments = '/c echo hello 1>&2' #this writes 'hello' to stderr
$runResult = (GetProgramOutput $exe $arguments)
$stdout = $runResult[-2]
$stderr = $runResult[-1]
[System.Console]::WriteLine("Standard out: " + $stdout)
[System.Console]::WriteLine("Standard error: " + $stderr)

Improved Answer - as long as you're OK with Start-Job instead of Start-Process
It turns out that the STDOUT and STDERR are accumulated in string arrays $job.ChildJobs[0].Output and $job.ChildJobs[0].Erroras the script runs. So you can poll these values and write them out periodically. Somewhat of a hack maybe, but it works.
It's not a stream though, so you have to manually keep track of the starting index into the array.
This code is simpler than my original answer, and at the end you have the entire STDOUT in $job.ChildJobs[0].Output. And as a little bonus for this demo, the calling script is PS7 and the background job is PS5.
$scriptBlock = {
Param ([int]$param1, [int]$param2)
$PSVersionTable
Start-Sleep -Seconds 1
$param1 + $param2
}
$parameters = #{
ScriptBlock = $scriptBlock
ArgumentList = 1, 2
PSVersion = 5.1 # <-- remove this line for PS7
}
$timeoutSec = 5
$job = Start-Job #parameters
$job.ChildJobs[0].Output
$index = $job.ChildJobs[0].Output.Count
while ($job.JobStateInfo.State -eq [System.Management.Automation.JobState]::Running) {
Start-Sleep -Milliseconds 200
$job.ChildJobs[0].Output[$index]
$index = $job.ChildJobs[0].Output.Count
if (([DateTime]::Now - $job.PSBeginTime).TotalSeconds -gt $timeoutSec) {
throw "Job timed out."
}
}
As pointed out, my original answer can interleave the output. This is a limitation of event handling in PowerShell. It's not a fixable problem.
Original Answer, don't use - just leaving it here for interest
If there's a timeout, ReadToEnd() is not an option. You could do some fancy looping, but IMO the 'cleanest' way to do this is to ignore the streams. Hook the OutputDataReceived/ErrorDataReceived events instead, collecting the output. This approach also avoids the threading issues mentioned by others.
This is straightforward in C#, but it's tricky and verbose in Powershell. In particular, add_OutputDataReceived is not available for some reason. (Not sure if this is a bug or a feature, at least this seems to be the case in PowerShell 5.1.) To work around it you can use Register-ObjectEvent.
$stdout = New-Object System.Text.StringBuilder
$stderr = New-Object System.Text.StringBuilder
$proc = [System.Diagnostics.Process]#{
StartInfo = #{
FileName = 'ping.exe'
Arguments = 'google.com'
RedirectStandardOutput = $true
RedirectStandardError = $true
UseShellExecute = $false
WorkingDirectory = $PSScriptRoot
}
}
$stdoutEvent = Register-ObjectEvent $proc -EventName OutputDataReceived -MessageData $stdout -Action {
$Event.MessageData.AppendLine($Event.SourceEventArgs.Data)
}
$stderrEvent = Register-ObjectEvent $proc -EventName ErrorDataReceived -MessageData $stderr -Action {
$Event.MessageData.AppendLine($Event.SourceEventArgs.Data)
}
$proc.Start() | Out-Null
$proc.BeginOutputReadLine()
$proc.BeginErrorReadLine()
Wait-Process -Id $proc.Id -TimeoutSec 5
if ($proc.HasExited) {
$exitCode = $proc.ExitCode
}
else {
Stop-Process -Force -Id $proc.Id
$exitCode = -1
}
# Be sure to unregister. You have been warned.
Unregister-Event $stdoutEvent.Id
Unregister-Event $stderrEvent.Id
Write-Output $stdout.ToString()
Write-Output $stderr.ToString()
Write-Output "Exit code: $exitCode"
The code shown is the happy path (stderr is empty)
To test the timeout path, set -TimeoutSec to .5
To test the sad path (stderr has content), set FileName to 'cmd' and Arguments to /C asdf

Here is my version of function that is returning standard System.Diagnostics.Process with 3 new properties
Function Execute-Command ($commandTitle, $commandPath, $commandArguments)
{
Try {
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = $commandPath
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.WindowStyle = 'Hidden'
$pinfo.CreateNoWindow = $True
$pinfo.Arguments = $commandArguments
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$stdout = $p.StandardOutput.ReadToEnd()
$stderr = $p.StandardError.ReadToEnd()
$p.WaitForExit()
$p | Add-Member "commandTitle" $commandTitle
$p | Add-Member "stdout" $stdout
$p | Add-Member "stderr" $stderr
}
Catch {
}
$p
}

You may want to also consider using the & operator combined with --% instead of start-process - that lets you easily pipe and process the command and/or error output.
put the escape parameter into a variable
put the arguments into a variable
$deploy= "C:\Program Files\IIS\Microsoft Web Deploy V3\msdeploy.exe"
$esc = '--%'
$arguments ="-source:package='c:\temp\pkg.zip' -verb:sync"
$output = & $deploy $esc $arguments
That passes the parameters to the executable without interference and let me get around the issues with start-process.
Combine Stderr and Stdout into one variable:
$output = & $deploy $esc $arguments 2>&1
Get separate variables for Stderr and Stdout
$err = $( $output = & $deploy $esc $arguments) 2>&1

installing msi file using powershell bringing up command line options

I am trying to run the below command and it opens windows installers parameters, what am I doing wrong?
$current_pc = "$env:computername"
$filePath = "c:\users\ArA\Desktop\parameters.csv"
$machineParams = Import-CSV $filePath
$info = if($machineParams){$machineParams | where {$_.branch -eq $($current_pc.Substring($current_pc.length - 3,3))}}
else{write-output "CSV not loaded"}
$info
start-process msiexec.exe -Wait -ArgumentList /L* "c:\users\Ara\Desktop\t.log" /qn /I "c:\users\Ar\Desktop\setup.msi" DATABASE_ID=$($info.DATABASE_ID),ODBC_DATABASE_NAME=$($info.ODBC_DATABASE_NAME),ODBC_ENGINE_NAME=$($info.ODBC_ENGINE_NAME) ODBC_HOST_NAME=$($info.ODBC_HOST_NAME) NOLAN=1

It's likely how you are passing your arguments. As a best-practice, I utilize an array when passing exe arguments so they're interpreted properly:
$machineParams = Import-Csv -Path $Env:UserProfile\Desktop\parameters.csv
$info = if ($machineParams) {
$machineParams |
Where-Object { $_.branch -eq $Env:ComputerName.Substring($Env:ComputerName.Length - 3, 3) }
} else {
'CSV not loaded.'
}
$info
$StartArgs = #{
'Wait' = $true
'FilePath' = "$Env:SystemRoot\System32\msiexec.exe"
'ArgumentList' = #(
'/i',"$Env:UserProfile\Desktop\setup.msi"
'/qn'
'/log',"$Env:UserProfile\Desktop\t.log"
)
}
if ($info -ne 'CSV not loaded.') {
$StartArgs['ArgumentList'] += #(
"DATABASE_ID=$($info.DATABASE_ID)"
"ODBC_DATABASE_NAME=$($info.ODBC_DATABASE_NAME)"
"ODBC_ENGINE_NAME=$($info.ODBC_ENGINE_NAME)"
"ODBC_HOST_NAME=$($info.ODBC_HOST_NAME)"
'NOLAN=1'
)
}
Start-Process #StartArgs

How to run a program as another user and add arguments in powershell?

We have a program that only updates when being run with the switch /t from an administrator account.
I came up with the CMD prompt version, but I'm new to powershell and having a hard time translating it to Powershell.
The CMD version is:
C:\Windows\System32\runas.exe /savecred /user:ourdomain\ouruseracct "C:\Program Files (x86)\ProjectMatrix\ProjectNotify\ProjectNotify.exe /t"
So far I got:
C:\Windows\System32\runas.exe /user:ourdomain\ouruseracct /savecred "powershell -c start-process -FilePath \"'C:\Program Files (x86)\ProjectMatrix\ProjectNotify\ProjectNotify.exe'\" -verb runAs"
Which runs powershell as admin and starts the program as admin but we need to pass the argument -t or /t to projectnotify.exe when running it.
I believe we need to make use of the -argumentlist but not sure how to word it.
I tried
$t = "-t"
Start-Process -FilePath "C:\Program Files (x86)\ProjectMatrix\ProjectNotify\projectnotify.exe" -ArgumentList $t -Verb runas
Which runs the program but not sure if that's how you pass the argument.

Extra work (troubleshooting):
$Cred = Get-Credential
$ProcInfo = New-Object -TypeName 'System.Diagnostics.ProcessStartInfo'
$ProcInfo.Domain = $Cred.GetNetworkCredential().Domain
$ProcInfo.UserName = $Cred.UserName
$ProcInfo.Password = $Cred.Password
$ProcInfo.FileName = "${Env:ProgramFiles(x86)}\ProjectMatrix\ProjectNotify\ProjectNotify.exe"
$ProcInfo.Arguments = '/t'
$ProcInfo.WorkingDirectory = "${Env:ProgramFiles(x86)}\ProjectMatrix\ProjectNotify"
$ProcInfo.WindowStyle = [System.Diagnostics.ProcessWindowStyle]::Normal
$ProcInfo.Verb = 'RunAs'
$ProcInfo.UseShellExecute = $true
[System.Diagnostics.Process]::Start($ProcInfo)
After some more thought, here's a simpler way (in a single command even):
Start-Job -Credential (Get-Credential) -ScriptBlock {
$Dir = "${Env:ProgramFiles(x86)}\ProjectMatrix\ProjectNotify"
$StartArgs = #{
'FilePath' = "$Dir\ProjectNotify.exe"
'ArgumentList' = '/t'
'Verb' = 'RunAs'
'WindowStyle' = 'Normal'
'WorkingDirectory' = $Dir
'PassThru' = $true
}
Start-Process #StartArgs
} | Wait-Job | Receive-Job
My previous answer is at the bottom of this post now.
References:
about_Splatting
Get-Credential
Start-Process
Start-Job
Extra reading:
Import-CliXml
Export-CliXml
Assuming an on-demand script, you should create a pscredential object if you want to natively run this from powershell:
Launch.cmd
SET "PS=%WINDIR%\System32\WindowsPowerShell\v1.0\powershell.exe"
SET "SCRIPT=%SYSTEMDRIVE%\Path\to\wrapper.ps1"
%PS% -NoProfile -NoLogo -ExecutionPolicy Bypass -File "%SCRIPT%"
wrapper.ps1
$Cred = Get-Credential
# To avoid prompting every time:
#
# if (-not (Test-Path -Path '.\mycred.xml')) {
# Get-Credential | Export-CliXml -Path '.\mycred.xml'
# }
# $Cred = Import-CliXml -Path '.\mycred.xml'
$StartArgs = #{
'FilePath' = "$PSHOME\powershell.exe"
'ArgumentList' = '-NoProfile', '-NoLogo', '-File', '.\runas.ps1'
'Credential' = $Cred
}
Start-Process #StartArgs
runas.ps1
$StartArgs = #{
'FilePath' = "${Env:ProgramFiles(x86)}\ProjectMatrix\ProjectNotify\ProjectNotify.exe"
'ArgumentList' = '/t'
'Verb' = 'RunAs'
}
Start-Process #StartArgs

I know the question asks for arguements, but if you don't them, this works:
Start cmd.exe -Verb RunAs
You can also run this using the 'Run' window or search box:
powershell -command start cmd.exe -verb runas

How to get output from powershell process

Here's the code
function RunPowershellAsAdmin($CommandToBeExecuted)
{
If (-NOT ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator"))
{
#$arguments = "& '" + $myinvocation.mycommand.definition + "'"
Start-Process powershell -Verb runAs -ArgumentList "$CommandToBeExecuted" -Verbose
}
}
RunPowershellAsAdmin("& { Import-Module WebAdministration; if(Test-Path 'IIS:\Sites\$Website_Name') { Remove-WebSite -Name '$Website_Name'; } }")
-Verb and -RedirectStandardOutput are not in the same parameter, so i can not use -RedirectStandardOutput to get process output as per answer from this link.
I want to run the process in a hidden window, wait for it to return and get the error, output and exit code.
Is there any other solution?
Thanks in advance.

If you need access to both RunAs in addition to redirecting any of the standard streams, you'll need to use the System.Diagnostics.Process and System.Diagnostics.ProcessStartInfo classes directly. More information on how to handle the redirected stream can be found on MSDN.
$startInfo = new-object System.Diagnostics.ProcessStartInfo
$startInfo.FileName = "powershell"
$startInfo.Arguments = "& { Import-Module WebAdministration; ... }"
$startInfo.Verb = "runas"
$startInfo.RedirectStandardOutput = $true
$process = [System.Diagnostics.Process]::Start($startInfo)
$output = $process.StandardOutput.ReadToEnd()
$process.WaitForExit()