Como obter o diretório de origem de um script Bash de dentro do próprio script

Como obtenho o caminho do diretório em que um script Bash está localizado, dentro desse script?

Quero usar um script Bash como iniciador para outro aplicativo. Desejo alterar o diretório de trabalho para o local em que o script Bash está localizado, para que eu possa operar nos arquivos desse diretório, da seguinte maneira:

$ ./application

#!/bin/bash

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"

é um one-liner útil que fornecerá o nome completo do diretório do script, não importa de onde ele esteja sendo chamado.

Ele funcionará desde que o último componente do caminho usado para encontrar o script não seja um link simbólico (os links do diretório estão OK). Se você também quiser resolver quaisquer links para o próprio script, precisará de uma solução de várias linhas:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"

Este último irá trabalhar com qualquer combinação de aliases, source, bash -c, links simbólicos, etc.

Cuidado: se você estiver cdem um diretório diferente antes de executar este trecho, o resultado pode estar incorreto!

Além disso, preste atenção às $CDPATHdicas e aos efeitos colaterais do stderr se o usuário substituiu o cd de maneira inteligente para redirecionar a saída para o stderr (incluindo sequências de escape, como ao chamar o update_terminal_cwd >&2Mac). Adicionar >/dev/null 2>&1no final do seu cdcomando cuidará das duas possibilidades.

Para entender como funciona, tente executar este formulário mais detalhado:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  TARGET="$(readlink "$SOURCE")"
  if [[ $TARGET == /* ]]; then
    echo "SOURCE '$SOURCE' is an absolute symlink to '$TARGET'"
    SOURCE="$TARGET"
  else
    DIR="$( dirname "$SOURCE" )"
    echo "SOURCE '$SOURCE' is a relative symlink to '$TARGET' (relative to '$DIR')"
    SOURCE="$DIR/$TARGET" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
  fi
done
echo "SOURCE is '$SOURCE'"
RDIR="$( dirname "$SOURCE" )"
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
if [ "$DIR" != "$RDIR" ]; then
  echo "DIR '$RDIR' resolves to '$DIR'"
fi
echo "DIR is '$DIR'"

E imprimirá algo como:

SOURCE './scriptdir.sh' is a relative symlink to 'sym2/scriptdir.sh' (relative to '.')
SOURCE is './sym2/scriptdir.sh'
DIR './sym2' resolves to '/home/ubuntu/dotfiles/fo fo/real/real1/real2'
DIR is '/home/ubuntu/dotfiles/fo fo/real/real1/real2'

Use dirname "$0":

#!/bin/bash
echo "The script you are running has basename `basename "$0"`, dirname `dirname "$0"`"
echo "The present working directory is `pwd`"

usar pwdsozinho não funcionará se você não estiver executando o script a partir do diretório em que está contido.

[matt@server1 ~]$ pwd
/home/matt
[matt@server1 ~]$ ./test2.sh
The script you are running has basename test2.sh, dirname .
The present working directory is /home/matt
[matt@server1 ~]$ cd /tmp
[matt@server1 tmp]$ ~/test2.sh
The script you are running has basename test2.sh, dirname /home/matt
The present working directory is /tmp

O dirnamecomando é o mais básico, basta analisar o caminho até o nome do arquivo da $0variável (nome do script):

dirname "$0"

Mas, como matt b apontou, o caminho retornado é diferente dependendo de como o script é chamado. pwdnão faz o trabalho porque isso apenas informa qual é o diretório atual, não o diretório em que o script reside. Além disso, se um link simbólico para um script for executado, você obterá um caminho (provavelmente relativo) para onde o link reside, não o script real.

Alguns outros mencionaram o readlinkcomando, mas, na sua forma mais simples, você pode usar:

dirname "$(readlink -f "$0")"

readlinkresolverá o caminho do script para um caminho absoluto a partir da raiz do sistema de arquivos. Portanto, quaisquer caminhos que contenham pontos simples ou duplos, tildes e / ou links simbólicos serão resolvidos para um caminho completo.

Aqui está um script demonstrando cada um destes whatdir.sh:

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename $0`"
echo "dirname: `dirname $0`"
echo "dirname/readlink: $(dirname $(readlink -f $0))"

Executando este script no meu diretório home, usando um caminho relativo:

>>>$ ./whatdir.sh 
pwd: /Users/phatblat
$0: ./whatdir.sh
basename: whatdir.sh
dirname: .
dirname/readlink: /Users/phatblat

Novamente, mas usando o caminho completo para o script:

>>>$ /Users/phatblat/whatdir.sh 
pwd: /Users/phatblat
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

Agora alterando diretórios:

>>>$ cd /tmp
>>>$ ~/whatdir.sh 
pwd: /tmp
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

E, finalmente, usando um link simbólico para executar o script:

>>>$ ln -s ~/whatdir.sh whatdirlink.sh
>>>$ ./whatdirlink.sh 
pwd: /tmp
$0: ./whatdirlink.sh
basename: whatdirlink.sh
dirname: .
dirname/readlink: /Users/phatblat

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}"
if ([ -h "${SCRIPT_PATH}" ]); then
  while([ -h "${SCRIPT_PATH}" ]); do cd `dirname "$SCRIPT_PATH"`; 
  SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

Funciona para todas as versões, incluindo

• quando chamado via link direto de profundidade múltipla,
• quando o arquivo
• quando script chamado pelo comando " source" aka .operador (ponto).
• quando arg $0é modificado a partir do chamador.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

Como alternativa, se o próprio script bash for um link simbólico relativo, você deseja segui-lo e retornar o caminho completo do script vinculado ao:

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}";
if ([ -h "${SCRIPT_PATH}" ]) then
  while([ -h "${SCRIPT_PATH}" ]) do cd `dirname "$SCRIPT_PATH"`; SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

SCRIPT_PATHé dado no caminho completo, não importa como é chamado.
Apenas certifique-se de localizá-lo no início do script.

Este comentário e código Copyleft, licença selecionável sob a GPL2.0 ou posterior ou CC-SA 3.0 (CreativeCommons Share Alike) ou posterior. (c) 2008. Todos os direitos reservados. Nenhuma garantia de qualquer tipo. Você foi avisado.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Resposta curta:

`dirname $0`

ou ( preferencialmente ):

$(dirname "$0")

Você pode usar $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Observe que você precisa usar, #!/bin/bashe não #!/bin/shporque é uma extensão do Bash.

Isso deve servir:

DIR="$(dirname "$(readlink -f "$0")")"

Isso funciona com links simbólicos e espaços no caminho.

Veja as páginas de manual para dirnamee readlink.

Na faixa de comentários, parece não funcionar com o Mac OS. Não faço ideia do porquê disso. Alguma sugestão?

pwdpode ser usado para encontrar o diretório de trabalho atual e dirnameo diretório de um arquivo específico (o comando que foi executado é $0, portanto, dirname $0deve fornecer o diretório do script atual).

No entanto, dirnamefornece com precisão a parte do diretório do nome do arquivo, que provavelmente será relativa ao diretório de trabalho atual. Se o seu script precisar alterar o diretório por algum motivo, a saída de dirnameficará sem sentido.

Sugiro o seguinte:

#!/bin/bash

reldir=`dirname $0`
cd $reldir
directory=`pwd`

echo "Directory is $directory"

Dessa forma, você obtém um diretório absoluto, e não relativo.

Como o script será executado em uma instância do bash separada, não há necessidade de restaurar o diretório de trabalho posteriormente, mas se você quiser voltar ao script por algum motivo, poderá atribuir facilmente o valor de pwda uma variável antes de alterar diretório, para uso futuro.

Embora apenas

cd `dirname $0`

resolve o cenário específico da pergunta, acho que ter o caminho absoluto para mais útil em geral.

Estou cansado de vir a esta página repetidamente para copiar e colar o verso na resposta aceita. O problema é que não é fácil entender e lembrar.

Aqui está um script fácil de lembrar:

DIR="$(dirname "${BASH_SOURCE[0]}")"  # get the directory name
DIR="$(realpath "${DIR}")"    # resolve its full path if need be

Eu não acho que isso seja tão fácil quanto os outros fizeram parecer. pwdnão funciona, pois o diretório atual não é necessariamente o diretório com o script. $0nem sempre tem as informações. Considere as três maneiras a seguir para invocar um script:

./script

/usr/bin/script

script

Na primeira e na terceira maneira $0, não há informações completas do caminho. No segundo e terceiro, pwdnão funciona. A única maneira de obter o diretório da terceira maneira seria percorrer o caminho e encontrar o arquivo com a correspondência correta. Basicamente, o código teria que refazer o que o sistema operacional faz.

Uma maneira de fazer o que você está pedindo é apenas codificar os dados no /usr/sharediretório e referenciá-los por seu caminho completo. Os dados não devem estar no /usr/bindiretório de qualquer maneira, portanto é provavelmente o que deve ser feito.

SCRIPT_DIR=$( cd ${0%/*} && pwd -P )

$(dirname "$(readlink -f "$BASH_SOURCE")")

Isso obtém o diretório de trabalho atual no Mac OS X 10.6.6:

DIR=$(cd "$(dirname "$0")"; pwd)

Isso é específico do Linux, mas você pode usar:

SELF=$(readlink /proc/$$/fd/255)

Aqui está uma linha única compatível com POSIX:

SCRIPT_PATH=`dirname "$0"`; SCRIPT_PATH=`eval "cd \"$SCRIPT_PATH\" && pwd"`

# test
echo $SCRIPT_PATH

Eu tentei tudo isso e nenhum funcionou. Um estava muito próximo, mas tinha um pequeno inseto que o quebrou muito; eles esqueceram de colocar o caminho entre aspas.

Muitas pessoas também assumem que você está executando o script a partir de um shell, para que se esqueçam que quando você abre um novo script, o padrão é o seu lar.

Tente este diretório para obter o tamanho:

/var/No one/Thought/About Spaces Being/In a Directory/Name/And Here's your file.text

Isso acerta, independentemente de como ou onde você o executa:

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename "$0"`"
echo "dirname: `dirname "$0"`"

Portanto, para torná-lo realmente útil, veja como mudar para o diretório do script em execução:

cd "`dirname "$0"`"

Aqui está a maneira simples e correta:

actual_path=$(readlink -f "${BASH_SOURCE[0]}")
script_dir=$(dirname "$actual_path")

Explicação:

• ${BASH_SOURCE[0]}- o caminho completo para o script. O valor disso estará correto mesmo quando o script estiver sendo originado, por exemplo, source <(echo 'echo $0')imprime bash , ao substituí-lo por ${BASH_SOURCE[0]}imprime o caminho completo do script. (Obviamente, isso pressupõe que você não tenha problemas com o Bash.)

• readlink -f- Resolve recursivamente todos os links simbólicos no caminho especificado. Esta é uma extensão GNU e não está disponível em (por exemplo) sistemas BSD. Se você estiver executando um Mac, poderá usar o Homebrew para instalar o GNU coreutilse substituí-lo greadlink -f.

• E, claro, dirnameobtém o diretório pai do caminho.

A maneira mais curta e elegante de fazer isso é:

#!/bin/bash
DIRECTORY=$(cd `dirname $0` && pwd)
echo $DIRECTORY

Isso funcionaria em todas as plataformas e é super limpo.

Mais detalhes podem ser encontrados em "Em qual diretório está esse script bash? ".

Eu usaria algo como isto:

# retrieve the full pathname of the called script
scriptPath=$(which $0)

# check whether the path is a link or not
if [ -L $scriptPath ]; then

    # it is a link then retrieve the target path and get the directory name
    sourceDir=$(dirname $(readlink -f $scriptPath))

else

    # otherwise just get the directory name of the script path
    sourceDir=$(dirname $scriptPath)

fi

Esta é uma pequena revisão da solução e-satis e 3bcdnlklvc04a, apontada em sua resposta :

SCRIPT_DIR=''
pushd "$(dirname "$(readlink -f "$BASH_SOURCE")")" > /dev/null && {
    SCRIPT_DIR="$PWD"
    popd > /dev/null
}    

Isso ainda deve funcionar em todos os casos listados.

Isso evitará popdapós uma falha pushd, graças ao konsolebox.

Para sistemas com coreutils GNU readlink(por exemplo, linux):

$(readlink -f "$(dirname "$0")")

Não há necessidade de usar BASH_SOURCEquando $0contém o nome do arquivo do script.

#!/bin/sh
PRG="$0"

# need this for relative symlinks
while [ -h "$PRG" ] ; do
   PRG=`readlink "$PRG"`
done

scriptdir=`dirname "$PRG"`

$_vale a pena mencionar como uma alternativa para $0. Se você estiver executando um script do Bash, a resposta aceita poderá ser reduzida para:

DIR="$( dirname "$_" )"

Observe que essa deve ser a primeira declaração do seu script.

Comparei muitas das respostas dadas e criei algumas soluções mais compactas. Eles parecem lidar com todos os casos extremos que surgem da sua combinação favorita de:

• Caminhos absolutos ou relativos
• Links flexíveis de arquivo e diretório
• Invocação como script, bash script, bash -c script, source script, ou. script
• Espaços, guias, novas linhas, unicode etc. nos diretórios e / ou nome do arquivo
• Nomes de arquivos iniciados com um hífen

Se você estiver executando no Linux, parece que usar o procidentificador é a melhor solução para localizar a fonte totalmente resolvida do script em execução no momento (em uma sessão interativa, o link aponta para o respectivo /dev/pts/X):

resolved="$(readlink /proc/$$/fd/255 && echo X)" && resolved="${resolved%$'\nX'}"

Isso tem um pouco de feiura, mas a correção é compacta e fácil de entender. Não estamos usando apenas os primitivos do bash, mas estou bem com isso, porque readlinksimplifica a tarefa consideravelmente. Ele echo Xadiciona um Xao final da cadeia de caracteres variável, para que qualquer espaço em branco no nome do arquivo não seja consumido e a substituição de parâmetro ${VAR%X}no final da linha se livre do X. Como readlinkadiciona uma nova linha própria (que normalmente seria consumida na substituição de comando, se não fosse nossa artimanha anterior), também precisamos nos livrar disso. Isso é feito com mais facilidade usando o para representar novas linhas (também é assim que você pode criar facilmente diretórios e arquivos desonestos).$'' esquema de citações, que nos permite usar seqüências de escape, como\n

O item acima deve cobrir suas necessidades de localização do script atualmente em execução no Linux, mas se você não tiver o procsistema de arquivos à sua disposição ou se estiver tentando localizar o caminho totalmente resolvido de outro arquivo, talvez você encontre o código abaixo útil. É apenas uma pequena modificação do one-liner acima. Se você estiver brincando com nomes de diretório / arquivos estranhos, verifique a saída com ambos lse readlinké informativo, pois lsproduzirá caminhos "simplificados", substituindo ?coisas como novas linhas.

absolute_path=$(readlink -e -- "${BASH_SOURCE[0]}" && echo x) && absolute_path=${absolute_path%?x}
dir=$(dirname -- "$absolute_path" && echo x) && dir=${dir%?x}
file=$(basename -- "$absolute_path" && echo x) && file=${file%?x}

ls -l -- "$dir/$file"
printf '$absolute_path: "%s"\n' "$absolute_path"

Tente usar:

real=$(realpath $(dirname $0))

Experimente a seguinte solução compatível com outros:

CWD="$(cd -P -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"

pois os comandos como realpathou readlinkpodem não estar disponíveis (dependendo do sistema operacional).

Nota: No Bash, é recomendável usar em ${BASH_SOURCE[0]}vez de $0, caso contrário, o caminho pode ser interrompido ao obter o arquivo ( source/ .).

Como alternativa, você pode tentar a seguinte função no bash:

realpath () {
  [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
}

Esta função leva 1 argumento. Se o argumento já tiver um caminho absoluto, imprima-o como está; caso contrário, imprima a $PWDvariável + argumento do nome do arquivo (sem ./prefixo).

Relacionado:

• Como definir o diretório de trabalho atual para o diretório do script?
• Caminho absoluto do script Bash com OS X
• Maneira confiável de um script Bash obter o caminho completo para si mesmo

Eu acredito que eu tenho esse. Estou atrasado para a festa, mas acho que alguns apreciarão estar aqui se eles encontrarem esse tópico. Os comentários devem explicar:

#!/bin/sh # dash bash ksh # !zsh (issues). G. Nixon, 12/2013. Public domain.

## 'linkread' or 'fullpath' or (you choose) is a little tool to recursively
## dereference symbolic links (ala 'readlink') until the originating file
## is found. This is effectively the same function provided in stdlib.h as
## 'realpath' and on the command line in GNU 'readlink -f'.

## Neither of these tools, however, are particularly accessible on the many
## systems that do not have the GNU implementation of readlink, nor ship
## with a system compiler (not to mention the requisite knowledge of C).

## This script is written with portability and (to the extent possible, speed)
## in mind, hence the use of printf for echo and case statements where they
## can be substituded for test, though I've had to scale back a bit on that.

## It is (to the best of my knowledge) written in standard POSIX shell, and
## has been tested with bash-as-bin-sh, dash, and ksh93. zsh seems to have
## issues with it, though I'm not sure why; so probably best to avoid for now.

## Particularly useful (in fact, the reason I wrote this) is the fact that
## it can be used within a shell script to find the path of the script itself.
## (I am sure the shell knows this already; but most likely for the sake of
## security it is not made readily available. The implementation of "$0"
## specificies that the $0 must be the location of **last** symbolic link in
## a chain, or wherever it resides in the path.) This can be used for some
## ...interesting things, like self-duplicating and self-modifiying scripts.

## Currently supported are three errors: whether the file specified exists
## (ala ENOENT), whether its target exists/is accessible; and the special
## case of when a sybolic link references itself "foo -> foo": a common error
## for beginners, since 'ln' does not produce an error if the order of link
## and target are reversed on the command line. (See POSIX signal ELOOP.)

## It would probably be rather simple to write to use this as a basis for
## a pure shell implementation of the 'symlinks' util included with Linux.

## As an aside, the amount of code below **completely** belies the amount
## effort it took to get this right -- but I guess that's coding for you.

##===-------------------------------------------------------------------===##

for argv; do :; done # Last parameter on command line, for options parsing.

## Error messages. Use functions so that we can sub in when the error occurs.

recurses(){ printf "Self-referential:\n\t$argv ->\n\t$argv\n" ;}
dangling(){ printf "Broken symlink:\n\t$argv ->\n\t"$(readlink "$argv")"\n" ;}
errnoent(){ printf "No such file: "$@"\n" ;} # Borrow a horrible signal name.

# Probably best not to install as 'pathfull', if you can avoid it.

pathfull(){ cd "$(dirname "$@")"; link="$(readlink "$(basename "$@")")"

## 'test and 'ls' report different status for bad symlinks, so we use this.

 if [ ! -e "$@" ]; then if $(ls -d "$@" 2>/dev/null) 2>/dev/null;  then
    errnoent 1>&2; exit 1; elif [ ! -e "$@" -a "$link" = "$@" ];   then
    recurses 1>&2; exit 1; elif [ ! -e "$@" ] && [ ! -z "$link" ]; then
    dangling 1>&2; exit 1; fi
 fi

## Not a link, but there might be one in the path, so 'cd' and 'pwd'.

 if [ -z "$link" ]; then if [ "$(dirname "$@" | cut -c1)" = '/' ]; then
   printf "$@\n"; exit 0; else printf "$(pwd)/$(basename "$@")\n"; fi; exit 0
 fi

## Walk the symlinks back to the origin. Calls itself recursivly as needed.

 while [ "$link" ]; do
   cd "$(dirname "$link")"; newlink="$(readlink "$(basename "$link")")"
   case "$newlink" in
    "$link") dangling 1>&2 && exit 1                                       ;;
         '') printf "$(pwd)/$(basename "$link")\n"; exit 0                 ;;
          *) link="$newlink" && pathfull "$link"                           ;;
   esac
 done
 printf "$(pwd)/$(basename "$newlink")\n"
}

## Demo. Install somewhere deep in the filesystem, then symlink somewhere 
## else, symlink again (maybe with a different name) elsewhere, and link
## back into the directory you started in (or something.) The absolute path
## of the script will always be reported in the usage, along with "$0".

if [ -z "$argv" ]; then scriptname="$(pathfull "$0")"

# Yay ANSI l33t codes! Fancy.
 printf "\n\033[3mfrom/as: \033[4m$0\033[0m\n\n\033[1mUSAGE:\033[0m   "
 printf "\033[4m$scriptname\033[24m [ link | file | dir ]\n\n         "
 printf "Recursive readlink for the authoritative file, symlink after "
 printf "symlink.\n\n\n         \033[4m$scriptname\033[24m\n\n        "
 printf " From within an invocation of a script, locate the script's "
 printf "own file\n         (no matter where it has been linked or "
 printf "from where it is being called).\n\n"

else pathfull "$@"
fi

Estas são maneiras curtas de obter informações de script:

Pastas e arquivos:

    Script: "/tmp/src dir/test.sh"
    Calling folder: "/tmp/src dir/other"

Usando estes comandos:

    echo Script-Dir : `dirname "$(realpath $0)"`
    echo Script-Dir : $( cd ${0%/*} && pwd -P )
    echo Script-Dir : $(dirname "$(readlink -f "$0")")
    echo
    echo Script-Name : `basename "$(realpath $0)"`
    echo Script-Name : `basename $0`
    echo
    echo Script-Dir-Relative : `dirname "$BASH_SOURCE"`
    echo Script-Dir-Relative : `dirname $0`
    echo
    echo Calling-Dir : `pwd`

E eu consegui esta saída:

     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir

     Script-Name : test.sh
     Script-Name : test.sh

     Script-Dir-Relative : ..
     Script-Dir-Relative : ..

     Calling-Dir : /tmp/src dir/other

Consulte também: https://pastebin.com/J8KjxrPF

Isso funciona no bash-3.2:

path="$( dirname "$( which "$0" )" )"

Se você tem um ~/bindiretório no seu $PATH, você tem Adentro deste diretório. Ele origina o script ~/bin/lib/B. Você sabe onde o script incluído é relativo ao original, no libsubdiretório, mas não onde é relativo ao diretório atual do usuário.

Isso é resolvido pelo seguinte (dentro A):

source "$( dirname "$( which "$0" )" )/lib/B"

Não importa onde o usuário está ou como ele chama o script, isso sempre funcionará.

A melhor solução compacta, na minha opinião, seria:

"$( cd "$( echo "${BASH_SOURCE[0]%/*}" )"; pwd )"

Não há confiança em nada além de Bash. O uso de dirname, readlinke basenameacabará por levar a problemas de compatibilidade, para que eles devem ser evitados, se possível.