Automatically feed input to Linux command line

Question

If I have a linux command that prompts for 2 or more input, how can these inputs be passed to the prompt by defining it in the command line? Is there something you can add behind the command to do this?

In the example below, how can you run the command and pass it the username and password without having to type it in when the system asks for them?

Example command that asks for username and password

git clone https://github.com/username/repo.git 

Just an example, please don't suggest doing the git clone using ssh instead of http, or that its insecure to expose the password in the command

Answer 1

The "expect" package is built for this kind of thing. If you install it, check out "autoexpect".

Example:

autoexpect
# Output: autoexpect started, file is script.exp

# Login with user/pass with ssh - just to test
ssh -o PubkeyAuthentication=no myuser@myhost
<type-password>
<command>
<command>
exit

# Now exit once more to exit autoexpect
# Output: autoexpect done, file is script.exp

Next thing is to edit script.exp and clean it up. There is loads of documentation on this.

Answer 2

I want the bounty, and I can't close as dup because the answer is on a different SE.

Quoting the answer on superuser:

Use the program expect which has been conceived for exactly your needs which were felt already by users in a land before our time, given that its man page states:

Connect to another network or BBS (e.g., MCI Mail, CompuServe).

Compuserve, was that before or after the French Revolution? Anyway.

spawn "git clone ssh://git@domain.com/myproject.git"
expect "Enter passphrase for key..." { send "myPassword\r" }
read -p "enter..."

Perhaps the last line is superfluous.

Ceterum censeo: Don't do that.

Answer 3

NOTE: Git requires you to use git token instead of password.

empty is an utility that provides a simple interface to execute and/or interact with processes under pseudo-terminal sessions.

This tool is definitely useful in programming of shell scripts that are sed to communicate with interactive programs like telnet or FTP.

In some cases empty can be a substitution for TCL/expect or other similar programming tools.

Copy the bellow code into your script file.

Make it executable and run the script by providing the following argument from the command line (as you asked for it):

• Git repo URI (as the first argument)
• Git username (as the second argument)
• Git user token (as the third argument)

Example:

Assuming your script file name is: git_clone.sh:

./git_clone.sh  <GIT_REPO_URI>  <GIT_USERNAME>  <GIT_USER_TOKEN>

#!/bin/bash
git_repo="${1}"
git_user="${2}"
git_token="${3}"

empty -f -i in.fifo -o out.fifo -pempty.pid  git clone  

empty -w -i out.fifo -o in.fifo sername  "${git_user}\n"
empty -w -i out.fifo -o in.fifo assword  "${git_token}\n"

exit 0

For more details about empty refer to its manual: http://manpages.ubuntu.com/manpages/bionic/man1/empty.1.html

Note: empty command needs to be available by installing empty-expect package.

To install on Ubuntu 18.04 or 16.04 you can run:

add-apt-repository "deb http://archive.ubuntu.com/ubuntu $(lsb_release -sc) universe"
apt update;
apt install -y empty-expect

### Update: To install empty-expect package in Ubuntu 20.04 you may use the Ubuntu 18.04 (bionic) universe repository by running the following commands:

echo 'deb http://archive.ubuntu.com/ubuntu bionic universe' > /etc/apt/sources.list.d/bionic-universe.list
apt update
apt install -y empty-expect

Answer 4

Under bash, you could use script

script will produce a tty you could interact with under bash, using coproc. This could be done without de need of expect:

NAME
      script - make typescript of terminal session

SYNOPSIS
      script [options] [file]

DESCRIPTION
      script  makes  a  typescript  of everything on your terminal session.
      The terminal data are stored in raw form to the log file and information
      about timing to another (optional) structured log file. The timing
      log file is necessary to replay the session later by scriptreplay(1) and to
      store additional information about the session.

Demo

coproc script -f /dev/null

Could return:

[1] 2103233

This initiate a subshel, you coul interact with,

while read -t 0 -u ${COPROC[0]};do
    read -t .02 -ru ${COPROC[0]} line
    echo "$line"
done

should produce something like:

Script started, output log file is 'typescript'.
user@hostname:~$

Then

echo >&${COPROC[1]} ssh user@target
while [ ! "$line" ] || [ "${line//*password*}" ];do
    read -t .02 -ru ${COPROC[0]} line
    echo "$line"
done
echo >&${COPROC[1]} TheStrongPasswordInClear
while [ ! "$line" ] || [ "${line//*\$*}" ];do
        read -t .02 -ru ${COPROC[0]} line
    echo "$line"
done

There, you could see a lot of lines like

ssh user@target
user@target's password:

Linux target 5.00.0-0-amd64 # Distro ...
issue.net content...
Last login: Sun Dec 19 12:23:37 2021 from somewhere

user@target:~$ 

From there, you could:

getres() {
    while read -t 0 -u ${COPROC[0]};do
        read -t .02 -ru ${COPROC[0]} line
        echo "$line"
    done
}

echo >&${COPROC[1]} uptime
getres

uptime
12:38:38 up 21 days,  3:52, 122 users,  load average: 3.20, 2.19, 1.59

And finaly

echo >&${COPROC[1]} exit  
getres 

exit
logout
Connection to target closed.

Full executable bash script

This run under bash 5.1.4(1)-release, on GNU/Debian Linux 11.2:

#!/bin/bash
line='' Debug=false

exp1() { # Collect input by bytes, until expected string (1st arg)
    local char attended="*${1}"
    line=
    IFS= read -d '' -ru "${COPROC[0]}" -t 2 -n 1 line
    while IFS= read -d '' -ru "${COPROC[0]}" -t .02 -n 1 char;do
        line+="$char"
        case "$line" in
            *$1 ) $Debug && echo "GOOD ${line@A} match ${attended@A}"
                  return 0;;
        esac
    done
    $Debug && echo "BAD: ${line@A}"
    return 1
}
expect() { # expect <Expected String after> <Command> [switches] [args]
    local expectStr="$1" maxErr=5
    shift
    [ "$1" ] && echo >&"${COPROC[1]}" "$@"
    while ! exp1 "${expectStr}" && ((maxErr--));do sleep .2;done
}
getAns() { # getAns <ResultVar> <Command> [switches] [args]
    local -n res=$1
    res=''
    shift
    local req="$*" maxErr=5
    echo >&"${COPROC[1]}" "$req"
    exp1 "$req"$'\r\n'
    while ! exp1 "$ " && ((maxErr--));do res+="$line" ;sleep .2 ;done
    res+="${line%$'\r\n'*}"
}

read -rp target:\  target
read -rsp password:\  pass
echo "${pass//?/*}"

coproc TERM=none script -f /dev/null
IFS= read -ru "${COPROC[0]}" line &&
    $Debug && echo "1 >>> $line <<<"

expect '$ '
expect 'password: ' ssh "$target"
expect '$ ' "$pass"

getAns ut uptime
# shellcheck disable=SC2154 # referenced but not assigned (ut ??)
echo "${ut@A}"

expect '$ '  exit

Run sample:

target: user@target
password: ************
ut=' 11:06:20 up 5 days, 2:19, 22 users, load average: 0.74, 1.13, 1.27'

You may found this script on my site: expectScr.sh, or expectScr.sh.txt, ready to be sourced.

Answer 5

Perhaps this

{
  echo user
  echo pass
} | git clone https://github.com/username/repo.git

ref

Answer 6

Depending on why you want to do this, you may want to explore ways to use github repositories without passwords:

https://help.github.com/articles/managing-deploy-keys

Answer 7

Don't know have you tried this or not. But this is useful in case we execute any sudo cmd and needs to enter a password. You can try this in your case.

But I think you have to provide a username at least.

For example :

sudo -S <<< "password" sudo yum -y update 

In your case, it should be like :

sudo -S <<< {password} git clone https://github.com/{username}/repo.git