Interactive bash script

[mihaimyh]

I would like to use CliWrap to pass some strings to a bash script via standard input.
The script is like this:

#!/bin/bash
echo "Please type the user"
read -r user
echo "The user is: $user"
echo "Please type the password"
read -r password
echo "The password is: $password"

I've followed the example described here #191 but it seems the programs keeps waiting on the input for the user variable:

using var semaphore = new SemaphoreSlim(0, 1);
var buffer = new StringBuilder();

var stdin = PipeSource.Create(async (destination, cancellationToken) =>
{
    while (!cancellationToken.IsCancellationRequested)
    {
        await semaphore.WaitAsync(cancellationToken);
        var data = Encoding.UTF8.GetBytes(buffer.ToString());
        await destination.WriteAsync(data, 0, data.Length, cancellationToken);
    }
});

var cmd = stdin | Cli.Wrap("/tmp/test.sh");

await foreach (var cmdEvent in cmd.ListenAsync())
{
    if (cmdEvent is StandardOutputCommandEvent stdOutEvent)
    {
        Console.WriteLine(stdOutEvent.Text);

        // Detect if it's a prompt
        if (stdOutEvent.Text.Contains("user", StringComparison.InvariantCultureIgnoreCase))
        {
            // Write the response
            buffer.Clear();
            buffer.Append("user123");
            semaphore.Release();
        }

        else if (stdOutEvent.Text.Contains("password", StringComparison.InvariantCultureIgnoreCase))
        {
            // Write the response
            buffer.Clear();
            buffer.Append("pass123");
            semaphore.Release();
        }
    }
}

[mihaimyh]

I found what the problem is: the script was not properly consuming all of the input. Adding a newline character at the end of each input string, fixed the issue:

buffer.Clear();
buffer.Append("user123\n");
semaphore.Release();

buffer.Clear();
buffer.Append("pass123\n");
semaphore.Release();

[Tyrrrz]

Also, if your script always asks for username and password in the same order, you can just pipe them directly into the stdin like this:

var stdin =
    """
    user123
    pass123

    """;

var cmd = stdin | Cli.Wrap(...);

The approach you used is only necessary for dynamic prompts, i.e. when they don't always appear or when the order is inconsistent.

Either way, the script expecting a new line is a common behavior, and it was my mistake to not use AppendLine(...) instead of Append(...) – I edited the original comment (in #191) to fix that.

[citystrawman]

hello, may I know the computer system you use? I am trying to use cliWrap to execute bash script on windows system but it seems that the bash only recognize linux based ending signal which will lead the execution fail... I am searching how to solve it

[dengyakui]

Awesome, it works for me!

[OrgesKreka]

I have more or less the same case in here but I have been struggling for 3 days and I could not find any solution on how to handle it.
Please can you give me some suggestions on what I am doing wrong?

So I have this bash script ( it is something more complicated that we use in the company, but I am using the below as an example )

PS3="Select your language please: ";

options=("Java" "Bash" "C++" "C#" "Quit");

select lng in "${options[@]}"
do
    case $lng in 
         "Java")
               echo "$lng - is your VM ready?";;
          "Bash")
               echo "$lng - that's what we're talking about";;
          "C++")
               echo "$lng - let's prepare for a lot of compilation";;
          "C#")
               echo "I want to learn $lng like Oleksii";;
          "Quit")
               echo "Bye"
               break;;
               *) 
                echo "Invalid option $REPLY";;
    esac
done

And this is the C# code that I have used:

async Task Main()
{
 
	using var semaphore = new SemaphoreSlim(0, 1);
	var buffer = new StringBuilder();

	var stdin = PipeSource.Create(async (destination, cancellationToken) =>
	{
		//while (!cancellationToken.IsCancellationRequested)
		//{
			//await semaphore.WaitAsync(cancellationToken);
			var data = Encoding.UTF8.GetBytes(buffer.ToString());
			if(data.Length > 0 )
				await destination.WriteAsync(data, 0, data.Length, cancellationToken);
		//}
	});
	
	

	var cmd = Cli.Wrap(@"C:/Program Files/Git/bin/bash.exe")
		.WithArguments(["-c", "sh foo.sh 2>&1"])
		.WithWorkingDirectory(@"C:/Users/temp")
		.WithStandardInputPipe(stdin)
		.WithValidation(CommandResultValidation.None);
 
	await foreach (var cmdEvent in cmd.ListenAsync())
	{
		if (cmdEvent is StandardOutputCommandEvent stdOutEvent)
		{
			Console.WriteLine(stdOutEvent.Text);

 		     if (stdOutEvent.Text.Contains("Select your language please: ", StringComparison.InvariantCultureIgnoreCase))
			{
				var input = Console.ReadLine();
		
				// Write the response
				buffer.Clear();
				buffer.Append( int.Parse( input));
				//semaphore.Release();
			}
		}


		if (cmdEvent is StartedCommandEvent started)
			Console.WriteLine($"Process started; ID: {started.ProcessId}");

		if (cmdEvent is StandardErrorCommandEvent stdError)
			Console.Error.WriteLine($"Err> {stdError.Text}");

		if (cmdEvent is ExitedCommandEvent exited)
			Console.WriteLine($"Process exited; Code: {exited.ExitCode}");
	}
 
}

So the first issue was that it reads all the options as errors that is why I needed to redirect the errors to the standard output.
Secondly it stucks at line 11 await semaphore.WaitAsync(cancellationToken); that is why I have commented the semaphore code.
And thirdly if I execute the code above and add a valid option it exits with error as shown below:

If I do the same using the Process approach I could not start at all the script.

Any help is welcomed!

[Tyrrrz]

Well, the input was clearly passed to the program (You selected: 2) so the issue is within something that happens after. Investigate what Code: 1 means in your program.

[OrgesKreka]

@Tyrrrz sorry for the confusion, that message is just a Console.WriteLine that I have added in my C# code to just print the option.

If the input was forwarded to the script I should have seen the message: Bash that's what we're talking about
As for the exit code, if you see the script it is just a simple one it exists only when i choose quit.

[Tyrrrz]

Does it work with just a static stdin instead?

var cmd = Cli.Wrap(@"C:/Program Files/Git/bin/bash.exe")
		.WithArguments(["-c", "sh foo.sh 2>&1"])
		.WithWorkingDirectory(@"C:/Users/temp")
		.WithStandardInputPipe(PipeSource.FromString("2"))
		.WithValidation(CommandResultValidation.None);

[OrgesKreka]

Yes with the static stdin the value is forwarded correctly.
But again I don't understand why the process is exiting with error :/

[Tyrrrz]

So first issue is that your original PipeSource doesn't wait for you to fill the buffer. The code runs immediately when the buffer is still empty and doesn't run again when you append text to it. That's why the semaphore is required.

As for the exit code, I really can't say. Are you sure it doesn't return 1 when running through a terminal?