Invoke-Command and/or Start-Process fail if no user session is active on the remote system

• You're using Start-Process to directly launch your installer executable, C:\tmp\PathToExe.exe.

• As such, the single string encoding all arguments to pass to the executable via the
  -ArgumentList parameter is placed as-is on the process command line for the target executable and must therefore only use embedded "...", i.e. double-quoting to enclose arguments, as this is the only form of quoting recognized in such no-shell invocations.^[1]

  • Conversely, '...' (single-quoting) would only work if the -ArgumentList string were interpreted by a shell that also recognizes this form of quoting, such as PowerShell.

Therefore (focusing just on the Start-Process call):

# Note the use of embedded " rather than '
Start-Process -FilePath "C:\tmp\PathToExe.exe" `
              -ArgumentList "-q -c -dir `"C:\Installer\target\directory`"" -Verb RunAs -Wait

Note:

• Since your command doesn't require expansion (string interpolation), you could use a verbatim, single-quoted PowerShell string literal, which obviates the need to `-escape the embedded " chars:

  -ArgumentList '-q -c -dir "C:\Installer\target\directory"'
  

• With the specific path at hand, since it doesn't contain spaces, you can even make do without embedded quoting altogether:

  -ArgumentList '-q -c -dir C:\Installer\target\directory'
  

Taking a step back:

• Instead of using Start-Process you may alternatively use direct invocation even with a GUI(-subsystem) application, in which case use of '...' (single-quoting) is an option, because it is PowerShell that handles the quoting in that case.

• To make the call synchronous (await the application's termination), you can use the following trick: pipe the call to Write-Output

Aside from such a call being less complex and more concise, the added advantage is that the application's process exit code is automatically reflected in the automatic $LASTEXITCODE variable (whereas with Start-Process you'd have to use -PassThru, capture the process-info object that is then returned, and query its .ExitCode property):

# Note the | Write-Output part, which makes even calls to GUI applications
# synchronous.
# After the call, the process exit code is reflected in $LASTEXITCODE
& 'C:\tmp\PathToExe.exe' -q -c -dir 'C:\Installer\target\directory' | Write-Output

As noted above, with the specific file paths used here, you don't strictly need quoting at all. If the executable path doesn't need quoting and contains no variable references, use of &, the call operator, isn't strictly necessary (that is, you could call C:\tmp\PathToExe.exe ...).

^{[1] Ultimately, on Windows it is up to each target executable to parse its own process command line into distinct arguments, but the vast majority of Windows CLIs recognize "..." quoting only.}

I just wanted to take a moment to thank both of you @mklement0 and @Bitcoin Murderous Maniac for your incredible help. After much effort and troubleshooting, I have finally managed to solve the issue with your help 🎉 Here is my solution I'd like to use until further notice:

$InstallerPath = "C:\tmp\PathToExe.exe"
$argList=@('-q','-c','-dir','C:\Installer\target\directory')

$ScriptBlock = {
    param(
        Parameter()][string]$PathToExe,
        Parameter()][System.Object[]]$ArgumentList
    )
        # Just for debugging
        "PathToExe: $PathToExe, args: $ArgumentList"
    
        & $PathToExe $ArgumentList | Write-Output;
        $LASTEXITCODE
    }
                    
Invoke-Command -Session $SessionToRemoteHost `
    -ScriptBlock $ScriptBlock `
    -ArgumentList $InstallerPath,$argList `
    -AsJob

I found this post: Powershell Call-Operator(&) with Parameters from Variable which provided me the last and final hint with passing arguments as System.Object[]to the & call operator.

With this solution, I hope, this is a quite future proof solution and I shouldn't get any troubles for the next installers/EXE files.

Thanks again for your support!