Calling a pipx installed python wrapper "executable" fails unless I use the absolute path?

[ptr727]

I am trying to call whisper-ctranslate2 that I installed on Debian 13 using pipx, and I get an exception that the exe was not found.

I install like this:

sudo apt install ffmpeg python3 python3-pip python3-venv build-essential pipx
pipx ensurepath
pipx install whisper-ctranslate2
pipx list
which whisper-ctranslate2
command -v whisper-ctranslate2
whisper-ctranslate2 --help

This works fine, and when I SSH remove VSCode to the machine it also works fine when called from the VSCode terminal:

$ which whisper-ctranslate2
/home/pieter/.local/bin/whisper-ctranslate2

$ command -v whisper-ctranslate2
/home/pieter/.local/bin/whisper-ctranslate2

$ whisper-ctranslate2 --help
usage: whisper-ctranslate2 [-h]

And the "executable" /home/pieter/.local/bin/whisper-ctranslate2 is a shell redirection:

#!/home/pieter/.local/share/pipx/venvs/whisper-ctranslate2/bin/python
import sys
from whisper_ctranslate2.whisper_ctranslate2 import main
if __name__ == '__main__':
    if sys.argv[0].endswith('.exe'):
        sys.argv[0] = sys.argv[0][:-4]
    sys.exit(main())

When I call CliWrap with just the whisper-translate2, I get:

14:17:52 [ERR] <1> "ExecuteAsync"
System.ComponentModel.Win32Exception (2): Failed to start a process with file path 'whisper-ctranslate2'. Target file or working directory doesn't exist, the provided credentials are invalid, or the resource policy cannot be set due to insufficient permissions. See the inner exception for more information. ---> System.ComponentModel.Win32Exception (2): An error occurred trying to start process 'whisper-ctranslate2' with working directory '/home/pieter/AudioCleaner/AudioCleaner/bin/Debug/net10.0'. No such file or directory
   at System.Diagnostics.Process.ForkAndExecProcess(ProcessStartInfo startInfo, String resolvedFilename, String[] argv, String[] envp, String cwd, Boolean setCredentials, UInt32 userId, UInt32 groupId, UInt32[] groups, Int32& stdinFd, Int32& stdoutFd, Int32& stderrFd, Boolean usesTerminal, Boolean throwOnNoExec)
   at System.Diagnostics.Process.StartCore(ProcessStartInfo startInfo)
   at CliWrap.Utils.ProcessEx.Start(Action`1 configureProcess) in /_/CliWrap/Utils/ProcessEx.cs:line 69
   at CliWrap.Utils.ProcessEx.Start(Action`1 configureProcess) in /_/CliWrap/Utils/ProcessEx.cs:line 79
   at CliWrap.Command.ExecuteAsync(Action`1 configureStartInfo, Action`1 configureProcess, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Command.Execution.cs:line 322
   at CliWrap.Command.ExecuteAsync(CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Command.Execution.cs:line 378
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 44
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 95
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding encoding, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 116
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 132
   at Whisper.Version(CancellationToken cancellationToken) in /home/pieter/AudioCleaner/AudioCleaner/Whisper.cs:line 56
   at AudioCleaner.Program.ExecuteAsync() in /home/pieter/AudioCleaner/AudioCleaner/Program.cs:line 43
14:17:52 [FTL] <1> Exception during processing.

To fix it I must explicitly call the absolute path:

    public static async Task<int> Version(CancellationToken cancellationToken)
    {
        // command -v whisper-ctranslate2
        // /home/pieter/.local/bin/whisper-ctranslate2

        string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
        string whisper = Path.Combine(home, ".local", "bin", "whisper-ctranslate2");
        // string whisper = "whisper-ctranslate2";
        Log.Debug("Whisper path: {Whisper}", whisper);

        BufferedCommandResult result = await Cli.Wrap(whisper)
            .WithArguments(args => args.Add("--version"))
            .ExecuteBufferedAsync(cancellationToken);
        return result.ExitCode;
    }

This makes it machine and user specific, how can I call the "executable" in the same way the shell would call it without needing to create an absolute path?

[Tyrrrz]

Does the regular Process class show similar behavior?

I've previously introduced this file path resolving strategy, but thought it was only needed on Windows:

CliWrap/CliWrap/Command.Execution.cs

Lines 17 to 75 in fdf4bce

	// System.Diagnostics.Process already resolves the full path by itself, but it naively assumes that the file
	// is an executable if the extension is omitted. On Windows, BAT and CMD files may also be valid targets.
	// In practice, it means that Process.Start("foo") will work if it's an EXE file, but will fail if it's a
	// BAT or CMD file, even if it's on the PATH. If the extension is specified, it will work in both cases.
	private string GetOptimallyQualifiedTargetFilePath()
	{
	// Currently, we only need this workaround for script files on Windows, so short-circuit
	// if we are on a different platform.
	if (!OperatingSystem.IsWindows())
	{
	return TargetFilePath;
	}
	// Don't do anything for fully qualified paths or paths that already have an extension specified.
	// System.Diagnostics.Process knows how to handle those without our help.
	// Note that IsPathRooted(...) doesn't check if the path is absolute, as it also returns true for
	// strings like 'c:foo.txt' (which is relative to the current directory on drive C), but it's good
	// enough for our purposes and the alternative is only available on .NET Standard 2.1+.
	if (
	Path.IsPathRooted(TargetFilePath)
	|| !string.IsNullOrWhiteSpace(Path.GetExtension(TargetFilePath))
	)
	{
	return TargetFilePath;
	}
	static IEnumerable<string> GetProbeDirectoryPaths()
	{
	// Implementation reference:
	// https://github.com/dotnet/runtime/blob/9a50493f9f1125fda5e2212b9d6718bc7cdbc5c0/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs#L686-L728
	// MIT License, .NET Foundation
	// Executable directory
	if (!string.IsNullOrWhiteSpace(Environment.ProcessPath))
	{
	var processDirPath = Path.GetDirectoryName(Environment.ProcessPath);
	if (!string.IsNullOrWhiteSpace(processDirPath))
	yield return processDirPath;
	}
	// Working directory
	yield return Directory.GetCurrentDirectory();
	// Directories on the PATH
	if (Environment.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator) is { } paths)
	{
	foreach (var path in paths)
	yield return path;
	}
	}
	return (
	from probeDirPath in GetProbeDirectoryPaths()
	where Directory.Exists(probeDirPath)
	select Path.Combine(probeDirPath, TargetFilePath) into baseFilePath
	from extension in new[] { "exe", "cmd", "bat" }
	select Path.ChangeExtension(baseFilePath, extension)
	).FirstOrDefault(File.Exists) ?? TargetFilePath;
	}

[ptr727]

I'll test with native Process when I get a moment.

[ptr727]

Apologies for delay, I had claude create a quick test for me, looks like it is the vscode debugger not picking up the local user environment:

---

I built a minimal repro to compare System.Diagnostics.Process vs CliWrap side-by-side on Debian 13 / .NET 10, calling whisper-ctranslate2 --version four ways.

Test code

using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using CliWrap;
using CliWrap.Buffered;

internal static class Program
{
    private const string ExecutableName = "whisper-ctranslate2";
    private const string Argument = "--version";

    private static async Task Main()
    {
        string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
        string absolutePath = Path.Combine(home, ".local", "bin", ExecutableName);

        Console.WriteLine($"PATH: {Environment.GetEnvironmentVariable("PATH")}");

        await RunProcess("1. Process, name only", ExecutableName);
        await RunProcess("2. Process, absolute path", absolutePath);
        await RunCliWrap("3. CliWrap, name only", ExecutableName);
        await RunCliWrap("4. CliWrap, absolute path", absolutePath);
    }

    private static async Task RunProcess(string label, string fileName)
    {
        Console.WriteLine($"=== {label} ({fileName}) ===");
        try
        {
            ProcessStartInfo startInfo = new()
            {
                FileName = fileName,
                Arguments = Argument,
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
            };
            using Process process = new() { StartInfo = startInfo };
            process.Start();
            string stdout = await process.StandardOutput.ReadToEndAsync();
            await process.WaitForExitAsync();
            Console.WriteLine($"  exit={process.ExitCode} stdout='{stdout.Trim()}'");
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine($"  Win32Exception ({ex.NativeErrorCode}): {ex.Message}");
        }
    }

    private static async Task RunCliWrap(string label, string target)
    {
        Console.WriteLine($"=== {label} ({target}) ===");
        try
        {
            BufferedCommandResult result = await Cli.Wrap(target)
                .WithArguments(Argument)
                .ExecuteBufferedAsync();
            Console.WriteLine($"  exit={result.ExitCode} stdout='{result.StandardOutput.Trim()}'");
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine($"  Win32Exception ({ex.NativeErrorCode}): {ex.Message}");
        }
    }
}

.csproj: net10.0, single <PackageReference Include="CliWrap" Version="3.10.0" />.

Results

With ~/.local/bin in PATH (regular dotnet run from a shell)

#	API	Argument	Result
1	Process	whisper-ctranslate2	OK, exit 0
2	Process	/home/pieter/.local/bin/whisper-ctranslate2	OK, exit 0
3	CliWrap	whisper-ctranslate2	OK, exit 0
4	CliWrap	/home/pieter/.local/bin/whisper-ctranslate2	OK, exit 0

Without ~/.local/bin in PATH (simulates VS Code debugger launch)

Repro: env -i HOME=$HOME PATH="/usr/local/bin:/usr/bin:/bin" /usr/bin/dotnet bin/Debug/net10.0/CliWrapProcessTest.dll

#	API	Argument	Result
1	Process	whisper-ctranslate2	FAIL Win32Exception (2): No such file or directory
2	Process	/home/pieter/.local/bin/whisper-ctranslate2	OK, exit 0
3	CliWrap	whisper-ctranslate2	FAIL Win32Exception (2) (same inner exception)
4	CliWrap	/home/pieter/.local/bin/whisper-ctranslate2	OK, exit 0

Conclusion

System.Diagnostics.Process and CliWrap behave identically in both PATH configurations on Linux. CliWrap is not adding or removing any path-resolution behavior versus the native API — the only thing that determines whether the by-name lookup succeeds is whether ~/.local/bin is in the launched process's PATH.

The original failure in my project was therefore not a CliWrap bug but an inherited-environment issue: my VS Code launch profile starts the debugged process without ~/.local/bin on PATH, even though my interactive shell has it (pipx puts it there via pipx ensurepath, which only updates ~/.bashrc/~/.profile).

Workarounds that don't require hard-coding an absolute path:

• Add ~/.local/bin to PATH in .vscode/launch.json via the env property.
• Or set the PATH env var on the Command via .WithEnvironmentVariables(...).

Feel free to close — no change needed in CliWrap. Thanks for the pointer to check Process directly.

---