É possível criar um repositório remoto no GitHub a partir da CLI sem abrir o navegador?

348

Criei um novo repositório Git local:

~$ mkdir projectname
~$ cd projectname
~$ git init
~$ touch file1
~$ git add file1
~$ git commit -m 'first commit'

Existe algum comando git para criar um novo repositório remoto e enviar por push meu commit ao GitHub a partir daqui? Eu sei que não é grande coisa apenas iniciar um navegador e ir para Criar um novo repositório , mas se houver uma maneira de conseguir isso com a CLI, eu ficaria feliz.

Li uma grande quantidade de artigos, mas nenhum que encontrei mencionou como criar um repositório remoto a partir da CLI usando comandos git. Artigo agradável de Tim Lucas Configurar um novo repositório remoto do git é o mais próximo que encontrei, mas o GitHub não fornece acesso ao shell .

anddoutoi
fonte

Respostas:

215

Você pode criar um repositório GitHub através da linha de comando usando a API do GitHub. Confira a API do repositório . Se você rolar cerca de um terço do caminho, verá uma seção intitulada "Criar" que explica como criar um repositório via API (logo acima, é uma seção que explica como bifurcar um repositório com a API também ) Obviamente, você não pode usar gitisso, mas pode fazê-lo através da linha de comando com uma ferramenta semelhante curl.

Fora da API, não há como criar um repositório no GitHub através da linha de comando. Como você observou, o GitHub não permite acesso ao shell etc., portanto, além da API do GitHub, a única maneira de criar um repositório é através da interface da web do GitHub.

mipadi
fonte
73
Graças a um monte mipadi! Não sabia sobre a API do GitHub. Para todos os outros com o mesmo problema, isso é o que eu basicamente fiz: curl -F 'login=username' -F 'token=API Token' https://github.com/api/v2/yaml/repos/create -F name=reponame. Seu token de API pode ser encontrado no site do GitHub, clique em Configurações da conta , procure informações administrativas e token de API (cadeia de caracteres de 32 caracteres).
anddoutoi
11
Parece que está desatualizado, pelo menos não encontro o token da API lá.
Joachim Breitner
12
Sintaxe da versão 3 da API fornecida abaixo via @bennedich stackoverflow.com/a/10325316/305633
JiminyCricket
2
@cseder: O Git não exige isso para criar um repositório, mas configurar um no GitHub . Não acho que o Mercurial permita criar um repo em um servidor remoto, empurrando para um repo inexistente.
Mipadi
5
@cseder: A pergunta está perguntando se é possível criar um repositório remoto no GitHub por meio da API do GitHub, não como criar um novo repositório e enviar para um existente no GitHub.
Mipadi
321

Comandos da CLI para a API do github v3 (substitua todas as palavras-chave do CAPS):

curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}'
# Remember replace USER with your username and REPO with your repository/application name!
git remote add origin [email protected]:USER/REPO.git
git push origin master
bennedich
fonte
43
O pequeno problema com o primeiro comando é que você está deixando sua senha do GitHub na sua ~/.bash_history. Eu sugiro que substitua -u 'USER:PASS'por -u 'USER', então o curl solicitará a senha de forma interativa.
ivanzoid
20
Para tornar o repo privado desde o início, use:curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO", "private":"true"}'
Joe Fletcher
3
Eu escrevi um script do bash para salvar a todos nós de digitar. Recebe a entrada do usuário e possui padrões sensíveis: gist.github.com/robwierzbowski/5430952
RobW:
3
Veja como adicioná-lo como um alias git:git config --global alias.gh-create '!sh -c "curl -u \"USERNAME\" https://api.github.com/user/repos -d \"{\\\"name\\\":\\\"$1\\\"}\"" -'
Robin Winslow
13
Não se esqueça que você pode gerar um token de acesso e usá-lo desta forma: curl https://api.github.com/user/repos?access_token=myAccessToken -d '{"name":"REPO"}'. :-)
Ionică Bizău
69

Isso pode ser feito com três comandos:

curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}'
git remote add origin [email protected]:nyeates/projectname.git
git push origin master

(atualizado para a API do Github v3)


Explicação desses comandos ...

Criar repositório github

    curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}'
  • curl é um comando unix (acima também funciona no mac) que recupera e interage com URLs. Geralmente já está instalado.
  • "-u" é um parâmetro de ondulação que especifica o nome do usuário e a senha a serem usados ​​na autenticação do servidor.
    • Se você apenas der o nome de usuário (como mostrado no exemplo acima), o curl solicitará uma senha.
    • Se você não quiser digitar a senha, consulte a documentação da API do githubs em Authentication
  • "-d" é um parâmetro de curvatura que permite enviar dados POST com a solicitação
  • "nome" é o único dado POST necessário; Eu também gosto de incluir "descrição"
  • Descobri que era bom citar todos os dados do POST com aspas simples ''

Defina para onde empurrar

git remote add origin [email protected]:nyeates/projectname.git
  • adicionar definição para localização e existência de repositório conectado (remoto) no github
  • "origem" é um nome padrão usado pelo git para a origem da origem
    • tecnicamente não veio do github, mas agora o repositório do github será a fonte do registro
  • "[email protected]: nyeates" é uma conexão ssh que pressupõe que você já configurou um par de chaves ssh confiável com o github.

Enviar repositório local para o github

git push origin master
  • enviar para o controle remoto de origem (github) da ramificação local principal
Não
fonte
54

Se você instalar a excelente ferramenta Hub do defunkt , isso se tornará tão fácil quanto

git create

Nas palavras do autor, "o hub é um wrapper de linha de comando para o git que o aprimora no GitHub " .

cavalgada
fonte
3
EU AMO hub! Também útil, é o hub- ou como hubé geralmente o apelido de git... git fork, que cria uma bifurcação do repositório para o pwdrepositório clonado em que você está ... Sim.
Alex Gray
2
essa ferramenta é incrível! Ele cuida de armazenar seu token de autenticação para que você não precise digitar sua senha repetidamente. Verifique também o plug-in ZSH para o github.
Dorian
19

Etapas simples (usando git+ hub=> GitHub ):

  1. Instale o Hub ( GitHub ).

    • OS X: brew install hub
    • Tendo Go :go get github.com/github/hub
    • caso contrário (tendo Go também):

      git clone https://github.com/github/hub.git && cd hub && ./script/build
      
  2. Vá para o seu repo ou criar um vazio: mkdir foo && cd foo && git init.

  3. Executar:, hub createele perguntará sobre as credenciais do GitHub pela primeira vez.

    Uso: hub create [-p] [-d DESCRIPTION] [-h HOMEPAGE] [NAME]

    Exemplo: hub create -d Description -h example.com org_name/foo_repo

    O Hub solicitará o nome de usuário e a senha do GitHub na primeira vez em que precisar acessar a API e trocará por um OAuthtoken, no qual ele será salvo ~/.config/hub.

    Para nomear explicitamente o novo repositório, passe NAME, opcionalmente, no ORGANIZATION/NAMEformulário para criar em uma organização da qual você é membro.

    Com -p, crie um repositório privado, e com -de -hdefina a descrição e a página inicial do repositório URL, respectivamente.

    Para evitar ser solicitado, use GITHUB_USERe GITHUB_PASSWORDvariáveis ​​de ambiente.

  4. Em seguida, confirme e empurre como de costume ou marque hub commit/ hub push.

Para obter mais ajuda, execute: hub help.

Consulte também: Importando um repositório Git usando a linha de comando no GitHub.

kenorb
fonte
Como posso definir variáveis ​​de ambiente GITHUB_USER e GITHUB_PASSWORD?
Kasper
11
Provavelmente você pode exportá-los, consulte: GH # 245 .
Kenorb
11
Funcionou muito bem para mim, observe que "hub" também está disponível no MacPorts.
Tiktak 22/0318
Eu acho que é isso que eu estava procurando! :)
terça-feira,
11

Existe uma jóia oficial do github que, eu acho, faz isso. Vou tentar adicionar mais informações à medida que aprender, mas só agora estou descobrindo essa gema, então ainda não sei muito.

ATUALIZAÇÃO: Depois de definir minha chave de API, sou capaz de criar um novo repositório no github por meio do createcomando, no entanto, não consigo usar o create-from-localcomando, que deve pegar o repositório local atual e fazer um controle remoto correspondente no github.

$ gh create-from-local
=> error creating repository

Se alguém tiver alguma idéia sobre isso, eu adoraria saber o que estou fazendo de errado. Já existe um problema arquivado .

ATUALIZAÇÃO: Acabei conseguindo que isso funcionasse. Não sei exatamente como reproduzir o problema, mas comecei do zero (excluí a pasta .git)

git init
git add .emacs
git commit -a -m "adding emacs"

Agora, essa linha criará o repositório remoto e chegará até ele, mas infelizmente não acho que posso especificar o nome do repositório que gostaria. Eu queria que ele fosse chamado de "dotfiles" no github, mas a gh gem apenas usou o nome da pasta atual, que era "jason" desde que eu estava na minha pasta pessoal. (Adicionei um ticket solicitando o comportamento desejado)

gh create-from-local

Este comando, por outro lado, aceita um argumento para especificar o nome do repositório remoto, mas destina-se a iniciar um novo projeto do zero, ou seja, depois que você chama esse comando, você obtém um novo repositório remoto que rastreia um repositório local em uma subpasta criada recentemente em relação à sua posição atual, ambas com o nome especificado como argumento.

gh create dotfiles
Jason Marcell
fonte
3
Esse projeto não tem nenhum trabalho há alguns anos, não funcionou para mim e, como está implícito aqui , está morto. Aparentemente, ele foi substituído pela ferramenta de hub , conforme sugerido nesta resposta .
Jameshfisher
9

Para criar rapidamente o repositório remoto usando um shell Bash

É complicado digitar o código completo toda vez que um repositório deve ser criado

curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}' git remote add origin [email protected]:USER/REPO.git git push origin master

Uma abordagem mais fácil é:

  1. crie um script de shell em um diretório, por exemplo, / home / USER_NAME / Desktop / my_scripts chamado githubscript.sh
  2. Modifique e salve o seguinte código no githubscript.sharquivo
#!bin/bash
curl -u 'YOUR_GITHUB_USER_NAME' https://api.github.com/user/repos -d "{\"name\":\"$1\"}";
git init;
git remote add origin [email protected]:YOUR_GITHUB_USER_NAME/$1.git;

NB Aqui $1está o repository nameque é passado como argumentquando se chama ascript alteração YOUR_GITHUB_USER_NAMEantes de salvar o script.

  1. Defina as permissões necessárias para o scriptarquivo chmod 755 githubscript.sh

  2. Inclua o diretório de scripts no arquivo de configuração do ambiente. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

  3. Defina também um alias para executar o arquivo githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

  4. Agora recarregue os arquivos .bashrce .profileno terminal. source ~/.bashrc ~/.profile;

  5. Agora, para criar um novo repositório, ou seja demo: githubrepo demo;

Nasif Md. Tanjim
fonte
11
No seu código, alterei esta parte: git remote add origin [email protected]:YOUR_GITHUB_USER_NAME/$1.git; para git remote add origin https://github.com/YOUR_GITHUB_USER_NAME/$1.git; usuários que não usam a chave SSH.
Damiii
5

Com base na outra resposta de @Mechanical Snail, exceto sem o uso de python, que eu achei muito exagero. Adicione isso ao seu ~/.gitconfig:

[github]
    user = "your-name-here"
[alias]
    hub-new-repo = "!REPO=$(basename $PWD) GHUSER=$(git config --get github.user); curl -u $GHUSER https://api.github.com/user/repos -d {\\\"name\\\":\\\"$REPO\\\"} --fail; git remote add origin [email protected]:$GHUSER/$REPO.git; git push origin master"
robru
fonte
Eu amo esse apelido. Mais uma vez obrigado, @Robru. PS, se isso não funcionar, ou parar de funcionar após uma nova instalação do sistema operacional .. verifique se você instalou o curl!
Daveloyall
5

Não, você precisa abrir um navegador pelo menos uma vez para criar o seu usernameno GitHub, uma vez criado, você pode aproveitar a API do GitHub para criar repositórios a partir da linha de comando, seguindo o comando abaixo:

curl -u 'github-username' https://api.github.com/user/repos -d '{"name":"repo-name"}'

Por exemplo:

curl -u 'arpitaggarwal' https://api.github.com/user/repos -d '{"name":"command-line-repo"}'
Arpit Aggarwal
fonte
11
Em seguida, git remote add origin https://github.com/github-username/repo-name.gitvincule seu projeto local ao github. Para o exemplo, o comando ficaria assim:git remote add origin https://github.com/arpitaggarwal/command-line-repo.git
SherylHohman
4

Para usuários com autenticação de dois fatores, você pode usar a solução de bennedich, mas você só precisa adicionar o cabeçalho X-Github-OTP para o primeiro comando. Substitua CODE pelo código que você obtém do provedor de autenticação de dois fatores. Substitua USER e REPO pelo nome de usuário e nome do repositório, como faria em sua solução.

curl -u 'USER' -H "X-GitHub-OTP: CODE" -d '{"name":"REPO"}' https://api.github.com/user/repos
git remote add origin [email protected]:USER/REPO.git
git push origin master
user886596
fonte
3

Eu escrevi um script bacana para isso chamado Gitter usando as APIs REST para GitHub e BitBucket:

https://github.com/dderiso/gitter

BitBucket:

gitter -c -r b -l javascript -n node_app

GitHub:

gitter -c -r g -l javascript -n node_app
  • -c = criar novo repositório
  • -r = provedor de repositório (g = GitHub, b = BitBucket)
  • -n = nomeie o repo
  • -l = (opcional) define o idioma do aplicativo no repositório
D.Deriso
fonte
3

Eu criei um alias do Git para fazer isso, com base na resposta de Bennedich . Adicione o seguinte ao seu ~/.gitconfig:

[github]
    user = "your_github_username"
[alias]
    ; Creates a new Github repo under the account specified by github.user.
    ; The remote repo name is taken from the local repo's directory name.
    ; Note: Referring to the current directory works because Git executes "!" shell commands in the repo root directory.
    hub-new-repo = "!python3 -c 'from subprocess import *; import os; from os.path import *; user = check_output([\"git\", \"config\", \"--get\", \"github.user\"]).decode(\"utf8\").strip(); repo = splitext(basename(os.getcwd()))[0]; check_call([\"curl\", \"-u\", user, \"https://api.github.com/user/repos\", \"-d\", \"{{\\\"name\\\": \\\"{0}\\\"}}\".format(repo), \"--fail\"]); check_call([\"git\", \"remote\", \"add\", \"origin\", \"[email protected]:{0}/{1}.git\".format(user, repo)]); check_call([\"git\", \"push\", \"origin\", \"master\"])'"

Para usá-lo, execute

$ git hub-new-repo

de qualquer lugar dentro do repositório local e digite sua senha do Github quando solicitado.

Caracol mecânico
fonte
Isto não funcionou para mim. Ele retorna 'Não
existe
Isso também não funcionou para mim. Ele retornacurl: (22) The requested URL returned error: 401 Traceback (most recent call last): File "<string>", line 1, in <module> File "/usr/lib64/python3.2/subprocess.py", line 488, in check_call raise CalledProcessError(retcode, cmd) subprocess.CalledProcessError: Command '['curl', '-u', 'myusername', 'https://api.github.com/user/repos', '-d', '{"name": "reponame"}', '--fail']' returned non-zero exit status 22
Da Frenk 15/01
11
O uso de python é um pouco demais e adiciona muito ruído na forma de barras invertidas extras e outras perfurações. Eu fiz uma versão com apenas bash: stackoverflow.com/a/28924077/1423157
robru
3

O que você precisa é de hub . Hub é um wrapper de linha de comando para o git. Foi criado para integrar com o git nativo usando o alias. Ele tenta fornecer ações do github no git, incluindo a criação de um novo repositório.

→  create a repo for a new project
$ git init
$ git add . && git commit -m "It begins."
$ git create -d "My new thing"
→  (creates a new project on GitHub with the name of current directory)
$ git push origin master
cnvzmxcvmcx
fonte
3

Para Rubyists:

gem install githubrepo
githubrepo create *reponame*

digite o nome de usuário e senha conforme solicitado

git remote add origin *ctrl v*
git push origin master

Fonte: Elikem Adadevoh

Benjamin Dunphy
fonte
3

Para todos os usuários do Python 2.7. *. Há um wrapper Python em torno da API do Github que está atualmente na versão 3, chamado GitPython . Basta instalar usando easy_install PyGithubou pip install PyGithub.

from github import Github
g = Github(your-email-addr, your-passwd)
repo = g.get_user().user.create_repo("your-new-repos-name")

# Make use of Repository object (repo)

A Repositorydocumentação do objeto está aqui .

quine
fonte
2

Para obter instruções sobre como criar um token, clique aqui Este é o comando que você digitará (na data desta resposta. (Substitua todas as palavras-chave do CAPS):

curl -u 'YOUR_USERNAME' -d '{"scopes":["repo"],"note":"YOUR_NOTE"}' https://api.github.com/authorizations

Depois de inserir sua senha, você verá o seguinte, que contém seu token.

{
  "app": {
    "name": "YOUR_NOTE (API)",
    "url": "http://developer.github.com/v3/oauth/#oauth-authorizations-api"
  },
  "note_url": null,
  "note": "YOUR_NOTE",
  "scopes": [
    "repo"
  ],
  "created_at": "2012-10-04T14:17:20Z",
  "token": "xxxxx",
  "updated_at": "2012-10-04T14:17:20Z",
  "id": xxxxx,
  "url": "https://api.github.com/authorizations/697577"
}

Você pode revogar seu token a qualquer momento acessando aqui

reubano
fonte
2

Por motivos de representação, não posso adicionar isso como um comentário (onde seria melhor ir com a resposta de bennedich ), mas para a linha de comando do Windows, aqui está a sintaxe correta:

curl -u YOUR_USERNAME https://api.github.com/user/repos -d "{\" name \ ": \" YOUR_REPO_NAME \ "}"

É a mesma forma básica, mas você deve usar aspas duplas (") em vez de simples e escapar das aspas duplas enviadas nos parâmetros POST (após o sinalizador -d) com barras invertidas. Também removi as aspas simples ao redor do meu nome de usuário, mas se seu nome de usuário tivesse um espaço (possível?), provavelmente precisaria de aspas duplas.

traycerb
fonte
É bom saber para usuários do Windows. Não, os nomes de usuário não podem conter espaços (o formulário de inscrição no github.com declara: "O nome de usuário pode conter apenas caracteres alfanuméricos ou hífens únicos e não pode começar ou terminar com um hífen"). Portanto, nenhuma citação dupla do nome de usuário é necessária.
mklement0
Shell poder Github não aceita -u com a onda, no Windows :(
JuliandotNut
2

Disclamier: Sou o autor do projeto de código aberto

Esta funcionalidade é suportada por: https://github.com/chrissound/Human-Friendly-Commands essencialmente é este script:

#!/usr/bin/env bash

# Create a repo named by the current directory
# Accepts 1 STRING parameter for the repo description
# Depends on bin: jq
# Depends on env: GITHUB_USER, GITHUB_API_TOKEN
github_createRepo() {
  projName="$(basename "$PWD")"
  json=$(jq -n \
    --arg name "$projName" \
    --arg description "$1" \
    '{"name":$name, "description":$description}')

  curl -u "$GITHUB_USER":"$GITHUB_API_TOKEN" https://api.github.com/user/repos -d "$json"
  git init
  git remote add origin [email protected]:"$GITHUB_USER"/"$projName".git
  git push origin master
};
Chris Stryczynski
fonte
Esta é realmente a nova maneira de usar um GitHub Personal Access Token. (A maneira antiga de adicioná-lo via ?access_token=${ACCESSTOKEN}não funciona mais.
not2qubit
0

Encontrei esta solução que eu gostei: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Primeiro, você precisa criar um token de acesso pessoal do Github

Abra seu ~ / .bash_profile ou ~ / .bashrc no seu editor de texto favorito. Adicione a seguinte linha perto da parte superior do seu arquivo, onde as demais variáveis ​​exportadas são:

export GITHUB_API_TOKEN=<your-token-here>

Em algum lugar abaixo, pelas suas outras funções do bash, você pode colar algo semelhante ao seguinte:

function new-git() {
    curl -X POST https://api.github.com/user/repos -u <your-username>:$GITHUB_API_TOKEN -d '{"name":"'$1'"}'
}

Agora, sempre que você estiver criando um novo projeto, você pode executar o comando $ new-git awesome-repopara criar um novo repositório remoto público na sua conta de usuário do Github.

Joshua Dance
fonte
0

Com a nova interface de linha de comando oficial do Github :

gh repo create

Veja detalhes adicionais e opções e instruções de instalação .


Por exemplo, para concluir seu fluxo de trabalho git:

mkdir project
cd project
git init
touch file
git add file
git commit -m 'Initial commit'
gh repo create
git push -u origin master
Xavier Guihot
fonte
-2

aqui estão meus comandos git iniciais (possivelmente, esta ação ocorre em C:/Documents and Settings/your_username/):

mkdir ~/Hello-World
# Creates a directory for your project called "Hello-World" in your user directory
cd ~/Hello-World
# Changes the current working directory to your newly created directory
touch blabla.html
# create a file, named blabla.html
git init
# Sets up the necessary Git files
git add blabla.html
# Stages your blabla.html file, adding it to the list of files to be committed
git commit -m 'first committttt'
# Commits your files, adding the message 
git remote add origin https://github.com/username/Hello-World.git
# Creates a remote named "origin" pointing at your GitHub repository
git push -u origin master
# Sends your commits in the "master" branch to GitHub
T.Todua
fonte
11
O repositório Hello-World deve estar disponível no GitHub, neste caso, não aborda o problema na pergunta.
JuliandotNut
-2

Recentemente, descobri o create-github-repo . No leia-me:

Instalar:

$ npm i -g create-github-repo

Uso:

$ export CREATE_GITHUB_REPO_TOKEN=<access_token>
$ create-github-repo --name "My coolest repo yet!"

Ou:

$ create-github-repo <access_token> --name "My coolest repo yet!"
anddoutoi
fonte
-7

crie um novo repositório na linha de comandos

echo "# <RepositoryName>" >> README.md

git init

git add README.md

git commit -m "first commit"

git remote add origin https://github.com/**<gituserID>/<RepositoryName>**.git

git push -u origin master

envie um repositório existente a partir da linha de comando

git remote add origin https://github.com/**<gituserID>/<RepositoryName>**.git

git push -u origin master
Pavan
fonte
11
Isso não funciona; não cria o repositório remoto .
Matthew Leia