¿Es posible crear un repository remoto en GitHub desde la CLI sin abrir el browser?

Creé un nuevo repository local de Git:

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

¿Hay algún command de git para crear un nuevo repository remoto y enviar mi compromiso a GitHub desde aquí? Sé que no es gran cosa simplemente iniciar un browser y dirigirse a Crear un nuevo repository , pero si hay una manera de lograrlo desde la CLI sería feliz.

Leí una gran cantidad de artículos, pero ninguno que encontré menciona cómo crear un repository remoto desde la CLI usando los commands de git. El bonito artículo de Tim Lucas La creación de un nuevo repository remoto de git es lo más parecido que encontré, pero GitHub no proporciona acceso a shell .

Puede crear un repository de GitHub a través de la línea de command usando la API de GitHub. Echa un vistazo a la API del repository . Si se desplaza hacia abajo aproximadamente un tercio del path, verá una sección titulada "Crear" que explica cómo crear un repository a través de la API (justo encima se encuentra una sección que explica cómo bifurcar un repository con la API, también ) Obviamente no puedes usar git para hacer esto, pero puedes hacerlo a través de la línea de command con una herramienta como curl .

Fuera de la API, no hay forma de crear un repository en GitHub a través de la línea de command. Como ha señalado, GitHub no permite el acceso al shell, etc., así que, aparte de la API de GitHub, la única forma de crear un repository es a través de la interfaz web de GitHub.

Comandos CLI para github API v3 (reemplace todas las palabras key 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 git@github.com:USER/REPO.git git push origin master 

Esto se puede hacer con tres commands:

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

(actualizado para v3 Github API)

Explicación de estos commands …

Crear repository github

  curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}' 
  • curl es un command de Unix (arriba también funciona en Mac) que recupera e interactúa con las URL. Comúnmente ya está instalado.
  • "-u" es un parámetro curl que especifica el nombre de usuario y la contraseña que se usará para la authentication del server.
    • Si acaba de dar el nombre de usuario (como se muestra en el ejemplo anterior) Curl le pedirá una contraseña.
    • Si no desea tener que escribir la contraseña, consulte la documentation de githubs api en Autenticación
  • "-d" es un parámetro curl que le permite enviar datos POST con la request
    • Está enviando datos POST en githubs definido formatting API
  • "nombre" es la única información POST requerida; Me gusta include también "descripción"
  • Descubrí que era bueno citar todos los datos POST con comillas simples ''

Definir dónde presionar para

 git remote add origin git@github.com:nyeates/projectname.git 
  • agregar la definición de location y existencia del repository conectado (remoto) en github
  • "origen" es un nombre pnetworkingeterminado utilizado por git para el origen de la fuente
    • técnicamente no vino de github, pero ahora el repository github será la fuente del logging
  • "git@github.com: nyeates" es una connection ssh que asume que ya has configurado un par de keys ssh de confianza con github.

Empujar repo local a github

 git push origin master 
  • presionar al control remoto de origen (github) desde la twig local maestra

Si instala la excelente herramienta Hub de defunkt , entonces esto se vuelve tan fácil como

git create

En palabras del autor, " hub es un envoltorio de command-line para git que te hace mejor en GitHub " .

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

  1. Instalar Hub ( GitHub ).

    • OS X: brew install hub
    • tener Go : go get github.com/github/hub
    • de lo contrario (teniendo Go también):

       git clone https://github.com/github/hub.git && cd hub && ./script/build 
  2. Vaya a su repository o cree uno vacío: mkdir foo && cd foo && git init .

  3. Ejecutar: hub create , te preguntará sobre las cnetworkingenciales de GitHub por primera vez.

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

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

    Hub solicitará el nombre de usuario y la contraseña de GitHub la primera vez que necesite acceder a la API y la ~/.config/hub por un token de OAuth , que saveá en ~/.config/hub .

    Para asignar un nombre explícito al nuevo repository, ingrese NAME , opcionalmente en ORGANIZATION/NAME form para crear en una organización de la que sea miembro.

    Con -p , cree un repository privado, y con -d y -h configure la descripción del repository y la URL página de inicio, respectivamente.

    Para evitar que se le pida, use las variables de entorno GITHUB_USER y GITHUB_PASSWORD .

  4. Luego comprométalo y presiona como de costumbre o revisa el hub commit hub push / hub push .

Para get más ayuda, ejecute: hub help .

Ver también: Importar un repository de Git usando la línea de command en GitHub.

Hay una gem oficial de Github que, creo, hace esto. Trataré de agregar más información a medida que aprendo, pero recién ahora estoy descubriendo esta gem, así que todavía no sé mucho.

ACTUALIZACIÓN: Después de configurar mi key API, puedo crear un nuevo repository en github a través del command create , sin embargo, no puedo usar el command create-from-local , que se supone que toma el repository local actual y create-from-local un correspondiente control remoto en github.

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

Si alguien tiene alguna idea sobre esto, me gustaría saber qué estoy haciendo mal. Ya hay un problema archivado .

ACTUALIZACIÓN: Eventualmente logré que esto funcionara. No estoy seguro de cómo volver a producir el problema, pero comencé desde cero (eliminé la carpeta .git)

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

Ahora esta línea creará el repository remoto e incluso lo presionará, pero desafortunadamente no creo poder especificar el nombre del repository que me gustaría. Quería que se llamara "dotfiles" en github, pero la gem gh acaba de usar el nombre de la carpeta actual, que era "jason" porque estaba en mi carpeta de inicio. (Agregué un boleto pidiendo el comportamiento deseado)

 gh create-from-local 

Este command, por otro lado, acepta un argumento para especificar el nombre del repository remoto, pero está destinado a comenzar un nuevo proyecto desde cero, es decir, después de llamar a este command, obtienes un nuevo repository remoto que rastrea un repository local en una subcarpeta recién creada relativa a su position actual, ambas con el nombre especificado como argumento.

 gh create dotfiles 

Para crear rápidamente el repository remoto utilizando un shell bash

Es engorroso escribir el código completo cada vez que se crea un repository

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

Un enfoque más fácil es:

  1. crear un script de shell en un directory, es decir, / home / USER_NAME / Desktop / my_scripts llamado githubscript.sh
  2. Modifique y guarde el siguiente código en el file githubscript.sh
 #!bin/bash curl -u 'YOUR_GITHUB_USER_NAME' https://api.github.com/user/repos -d "{\"name\":\"$1\"}"; git init; git remote add origin git@github.com:YOUR_GITHUB_USER_NAME/$1.git; 

Nota: $1 es el repository name del repository name que se pasa como argument al invocar el script Cambie YOUR_GITHUB_USER_NAME antes de save el script.

  1. Establezca los permissions necesarios para el file de script chmod 755 githubscript.sh

  2. Incluya el directory de scripts en el file de configuration del entorno. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

  3. También configure un alias para ejecutar el file githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

  4. Ahora vuelva a cargar los files .bashrc y .profile en el terminal. source ~/.bashrc ~/.profile;

  5. Ahora para crear un nuevo repository, es decir demo : githubrepo demo;

Escribí un guión ingenioso para esto llamado Gitter usando las API REST para GitHub y BitBucket:

https://github.com/dderiso/gitter

BitBucket:

 gitter -c -rb -l javascript -n node_app 

GitHub:

 gitter -c -rg -l javascript -n node_app 
  • -c = crear nuevo repository
  • -r = proveedor de repo (g = GitHub, b = BitBucket)
  • -n = nombre del repository
  • -l = (opcional) establece el idioma de la aplicación en el repository

Creé un alias de Git para hacer esto, basado en la respuesta de Bennedich . Agregue lo siguiente a su ~/.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\", \"git@github.com:{0}/{1}.git\".format(user, repo)]); check_call([\"git\", \"push\", \"origin\", \"master\"])'" 

Para usarlo, ejecuta

 $ git hub-new-repo 

desde cualquier lugar dentro del repository local, e ingrese su contraseña de Github cuando se le solicite.

Para los usuarios con authentication de dos factores, puede usar la solución de Bennedich, pero solo necesita agregar el encabezado X-Github-OTP para el primer command. Reemplace CODE con el código que obtiene del proveedor de authentication de dos factores. Reemplace USER y REPO con el nombre de usuario y el nombre del repository, como lo haría en su solución.

 curl -u 'USER' -H "X-GitHub-OTP: CODE" -d '{"name":"REPO"}' https://api.github.com/user/repos git remote add origin git@github.com:USER/REPO.git git push origin master 

Basado en la otra respuesta de @Mechanical Snail, excepto sin el uso de Python, que encontré demasiado exagerado. Agregue esto a su ~/.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 git@github.com:$GHUSER/$REPO.git; git push origin master" 

Para get instrucciones sobre cómo crear un token, vaya aquí. Este es el command que va a escribir (a partir de la date de esta respuesta. (Reemplace todas las palabras key CAPS):

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

Una vez que ingrese su contraseña, verá lo siguiente que contiene su 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" } 

Puede revocar su token en cualquier momento yendo aquí

Lo que necesitas es hub . Hub es un contenedor de command-line para git. Se ha hecho para integrarse con git nativo usando alias. Trata de proporcionar acciones github en git incluyendo la creación de nuevo repository.

 → 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 

Para los Rubyistas:

 gem install githubrepo githubrepo create *reponame* 

ingrese nombre de usuario y pw como se le solicite

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

Fuente: Elikem Adadevoh

Por motivos de reputación, no puedo agregar esto como un comentario (donde sería mejor con la respuesta de Bennedich ), pero para la línea de command de Windows, aquí está la syntax correcta:

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

Es la misma forma básica, pero tiene que usar comillas dobles (") en lugar de simples, y escaping de las comillas enviadas en los parameters POST (después del indicador -d) con barras invertidas. También eliminé las comillas simples alnetworkingedor de mi nombre de usuario, pero si tu nombre de usuario tiene un espacio (¿posible?) probablemente necesite comillas dobles.

Para todos los usuarios de Python 2.7. *. Existe un contenedor de Python alnetworkingedor de la API de Github que se encuentra actualmente en la Versión 3, llamado GitPython . Simplemente instale usando easy_install PyGithub o 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) 

Los documentos del object Repository están aquí .

No, debes abrir un browser al less una vez para crear tu username de username en GitHub; una vez creado, puedes aprovechar la API de GitHub para crear repositorys desde la command-line, siguiendo el siguiente command:

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

Por ejemplo:

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

Encontré esta solución que me gustó: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Primero necesita crear un token de acceso personal de Github

Abra su ~ / .bash_profile o ~ / .bashrc en su editor de text favorito. Agregue la siguiente línea cerca de la parte superior de su file, donde el rest de las variables exportadas son:

export GITHUB_API_TOKEN=<your-token-here>

En alguna parte más abajo, con tus otras funciones bash, puedes pegar algo similar a lo siguiente:

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

Ahora, cada vez que creas un nuevo proyecto, puedes ejecutar el command $ new-git awesome-repo para crear un nuevo repository remoto público en tu count de usuario de Github.

aquí están mis commands iniciales de git (posiblemente, esta acción tenga lugar en 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 

Recientemente descubrí sobre create-github-repo . Del file léame:

Instalar:

 $ npm i -g create-github-repo 

Uso:

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

O:

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

crear un nuevo repository en la línea de command

 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 

empujar un repository existente desde la línea de command

 git remote add origin https://github.com/**<gituserID>/<RepositoryName>**.git git push -u origin master