I pulled a project with several forks on GitHub, but forgot which fork it was. How do I determine which fork I pulled?
git remote get-url origin
will be possible. See my answer below
git remote get-url origin
does not work for me--possibly deprecated? git remote show origin
worked though.
git remote -v
give you a lot of information, including this.
git remote get-url origin --push
works fine, apparently not depreciated and provides nice brief info (git remote show origin
can be very verbose) q.v. git help remote
.
If you want only the remote URL, or if your are not connected to a network that can reach the remote repo:
git config --get remote.origin.url
If you require full output and you are on a network that can reach the remote repo where the origin resides :
git remote show origin
When using git clone
(from GitHub, or any source repository for that matter) the default name for the source of the clone is "origin". Using git remote show
will display the information about this remote name. The first few lines should show:
C:\Users\jaredpar\VsVim> git remote show origin
* remote origin
Fetch URL: git@github.com:jaredpar/VsVim.git
Push URL: git@github.com:jaredpar/VsVim.git
HEAD branch: master
Remote branches:
If you want to use the value in the script, you would use the first command listed in this answer.
Should you want this for scripting purposes, you can get only the URL with
git config --get remote.origin.url
git remote show origin
just shows "conq: repository does not exist.").
url.<base>.insteadOf
. See my answer - git has a command for this purpose.
You can try:
git remote -v
It will print all your remotes' fetch/push URLs.
origin
).
To get the answer:
git ls-remote --get-url [REMOTE]
This is better than reading the configuration; refer to the man page for git-ls-remote
:
--get-url Expand the URL of the given remote repository taking into account any "url.
As pointed out by @Jefromi, this option was added in v1.7.5 and not documented until v1.7.12.2 (2012-09).
origin
.
remote get-url
option. It's a drop-in replacement.
With Git 2.7 (release January 5th, 2015), you have a more coherent solution using git remote
:
git remote get-url origin
(nice pendant of git remote set-url origin <newurl>
)
See commit 96f78d3 (16 Sep 2015) by Ben Boeckel (mathstuf
).
(Merged by Junio C Hamano -- gitster
-- in commit e437cbd, 05 Oct 2015):
remote: add get-url subcommand Expanding insteadOf is a part of ls-remote --url and there is no way to expand pushInsteadOf as well. Add a get-url subcommand to be able to query both as well as a way to get all configured URLs.
get-url:
Retrieves the URLs for a remote. Configurations for insteadOf and pushInsteadOf are expanded here. By default, only the first URL is listed. With '--push', push URLs are queried rather than fetch URLs. With '--all', all URLs for the remote will be listed.
Before git 2.7, you had:
git config --get remote.[REMOTE].url
git ls-remote --get-url [REMOTE]
git remote show [REMOTE]
To summarize, there are at least four ways:
Trying it out using the official Linux repository:
Least information:
$ git config --get remote.origin.url
https://github.com/torvalds/linux.git
and
$ git ls-remote --get-url
https://github.com/torvalds/linux.git
More information:
$ git remote -v
origin https://github.com/torvalds/linux.git (fetch)
origin https://github.com/torvalds/linux.git (push)
Even more information:
$ git remote show origin
* remote origin
Fetch URL: https://github.com/torvalds/linux.git
Push URL: https://github.com/torvalds/linux.git
HEAD branch: master
Remote branch:
master tracked
Local branch configured for 'git pull':
master merges with remote master
Local ref configured for 'git push':
master pushes to master (up to date)
git config --get remote.origin.url
retrieves the original URL which was set with git remote add ...
or git remote set-url ...
while git ls-remote --get-url origin
retrieves the URL which is actually used to access the remote - which might be different in presence of git config --global url.XXX.insteadOf YYY
. So both outputs may differ! Also note that git ls-remote --get-url
(without origin
) does not neccessarily retrieve origin
, instead it shows the tracked upstream, so it will fail for example in detached HEAD state.
I think you can find it under .git/config
and remote["origin"]
if you didn't manipulate that.
For me, this is the easier way (less typing):
$ git remote -v
origin https://github.com/torvalds/linux.git (fetch)
origin https://github.com/torvalds/linux.git (push)
actually, I've that into an alias
called s
that does:
git remote -v
git status
You can add to your profile with: alias s='git remote -v && git status'
Short answer:
$ git remote show -n origin
or, an alternative for pure quick scripts:
$ git config --get remote.origin.url
Some info:
$ git remote -v will print all remotes (not what you want). You want origin right? $ git remote show origin much better, shows only origin but takes too long (tested on git version 1.8.1.msysgit.1).
I ended up with: $ git remote show -n origin
, which seems to be fastest. With -n
it will not fetch remote heads (AKA branches). You don't need that type of info, right?
http://www.kernel.org/pub//software/scm/git/docs/git-remote.html
You can apply | grep -i fetch
to all three versions to show only the fetch URL.
If you require pure speed, then use:
$ git config --get remote.origin.url
Thanks to @Jefromi for pointing that out.
I prefer this one as it is easier to remember:
git config -l
It will list all useful information such as:
user.name=Your Name
user.email=your.name@notexisting.com
core.autocrlf=input
core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
remote.origin.url=https://github.com/mapstruct/mapstruct-examples
remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*
branch.master.remote=origin
branch.master.merge=refs/heads/master
I can never remember all the parameters to Git commands, so I just put an alias in the ~/.gitconfig
file that makes more sense to me, so I can remember it, and it results in less typing:
[alias]
url = ls-remote --get-url
After reloading the terminal, you can then just type:
> git url
Here are a few more of my frequently used ones:
[alias]
cd = checkout
ls = branch
lsr = branch --remote
lst = describe --tags
I also highly recommend git-extras which has a git info
command which provides much more detailed information on the remote and local branches.
bash
commands. I can see this being causing the least amount of mental friction when switching between bash
and git
. Bravo!
I basically use:
git remote get-url origin
It works for Git Bash command console or CMD command console in Windows. That said, it works with version 2.x of Git.
The Git URL will be inside the Git configuration file. The value corresponds to the key url
.
For Mac and Linux use the commands below:
cd project_dir
cat .git/config | grep url | awk '{print $3}'
For Windows open the below file in any text editor and find the value for key url
.
project_dir/.git/config
Note: This will work even if you are offline or the remote git server has been taken down.
git remote get-url origin >> fatal: No such remote 'origin'
, git config --get remote.origin.url >>
git config --list
This command will give all information related to your repository.
The upstream's remote may not be called "origin", so here's a variation:
remote=$(git config --get branch.master.remote)
url=$(git config --get remote.$remote.url)
basename=$(basename "$url" .git)
echo $basename
Or:
basename $(git config --get remote.$(git config --get branch.master.remote).url) .git
For more useful variables there's:
$ git config -l
A simple way is to open the .git/config
file:
cat .git/config
To edit:
vim .git/config
or
nano .git/config
To get the IP address/hostname of origin
For ssh://
repositories:
git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d "/"
For git://
repositories:
git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d ":"
ssh
this only works in absence of ~/.ssh/config
which rewrites the hostname or alias.
To supplement the other answers: If the remote has for some reason been changed and so doesn't reflect the original origin, the very first entry in the reflog (i.e. the last entry displayed by the command git reflog
) should indicate where the repo was originally cloned from.
e.g.
$ git reflog | tail -n 1
f34be46 HEAD@{0}: clone: from https://github.com/git/git
$
(Bear in mind that the reflog may be purged, so this isn't guaranteed to work.)
With git remote show origin
you have to be in the projects directory. But if you want to determine the URLs from anywhere else you could use:
cat <path2project>/.git/config | grep url
If you'll need this command often, you could define an alias in your .bashrc
or .bash_profile
with MacOS.
alias giturl='cat ./.git/config | grep url'
So you just need to call giturl
in the Git root folder in order to simply obtain its URL.
If you extend this alias like this
alias giturl='cat .git/config | grep -i url | cut -d'=' -f 2'
you get only the plain URL without the preceding
"url="
in
url=http://example.com/repo.git
you get more possibilities in its usage:
Example
On Mac you could call open $(giturl)
to open the URL in the standard browser.
Or chrome $(giturl)
to open it with the Chrome browser on Linux.
You cloned your repo with SSH clone.
git config --get remote.origin.url
git@gitlab.com:company/product/production.git
But you want to get http url to open it in the browser or share it:
git config --get remote.origin.url | sed -e 's/:/\//g'| sed -e 's/ssh\/\/\///g'| sed -e 's/git@/https:\/\//g'
https://gitlab.com/company/product/production.git
GitHub or GitLab doesn’t matter.
git@...
and https://...
: git config --get remote.origin.url | sed -E 's/:([^\/])/\/\1/g' | sed -e 's/ssh\/\/\///g' | sed -e 's/git@/https:\/\//g'
Print arbitrarily named remote fetch URLs:
git remote -v | grep fetch | awk '{print $2}'
If you do not know the name of the upstream remote for a branch, you can look that up first by inspecting the upstream branch name that the current branch was built upon. Use git rev-parse
like this:
git rev-parse --symbolic-full-name --abbrev-ref @{upstream}
This shows that upstream branch that was the source for the current branch. This can be parsed to get the remote name like this:
git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1
Now take that and pipe it to git ls-remote
and you'll get the URL of the upstream remote that is the source of the current branch:
git ls-remote --get-url \
$(git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1)
Now it should be noted, that this is not necessarily the same as the source remote repository that was cloned from. In many cases however it will be enough.
#!/bin/bash
git-remote-url() {
local rmt=$1; shift || { printf "Usage: git-remote-url [REMOTE]\n" >&2; return 1; }
local url
if ! git config --get remote.${rmt}.url &>/dev/null; then
printf "%s\n" "Error: not a valid remote name" && return 1
# Verify remote using 'git remote -v' command
fi
url=`git config --get remote.${rmt}.url`
# Parse remote if local clone used SSH checkout
[[ "$url" == git@* ]] \
&& { url="https://github.com/${url##*:}" >&2; }; \
{ url="${url%%.git}" >&2; };
printf "%s\n" "$url"
}
Usage:
# Either launch a new terminal and copy `git-remote-url` into the current shell process,
# or create a shell script and add it to the PATH to enable command invocation with bash.
# Create a local clone of your repo with SSH, or HTTPS
git clone git@github.com:your-username/your-repository.git
cd your-repository
git-remote-url origin
Output:
https://github.com/your-username/your-repository
To get only the remote URL:
git config --get remote.origin.url
In order to get more details about a particular remote, use the
git remote show [remote-name] command
To See Remote Url
git remote show origin
To See where you .git folder placed
git config --get remote.origin.url
easy just use this command where you .git folder placed
git config --get remote.origin.url
if you are connected to network
git remote show origin
it will show you the URL that a local Git repository was originally cloned from.
hope this help
alias git-repo="git config --get remote.origin.url | sed -e 's/:/\//g'| sed -e 's/ssh\/\/\///g'| sed -e 's/git@/https:\/\//g'"
alias git-pr="git config --get remote.origin.url | sed -e 's/:/\//g'| sed -e 's/ssh\/\/\///g'| sed -e 's/git@/https:\/\//g' | sed 's/....$//' | sed -ne 's/$/\/pulls &/p'"
add this expresion to .zshrc or .bashrcs on main directory
after you can use like
git-repo
git-pr
Success story sharing
git remote show origin
(optionally with the -n flag provided by @Casey), or withgit remote -v
as suggested by @Montaro and @rodel.´~/.gitconfig
is global to allgit
repositories, this here comes from the local config which usually is in.git/config
(however for git-submodules the answer is a bit more difficult). Note thatstrace git config --get remote.origin.url
is your friend.git remote show origin
doesn't work if the stored credentials do no longer have required access rights to the original repository. In such case, trygit remote -v