Est-il possible de créer un repo distant sur GitHub à partir de la CLI sans ouvrir le navigateur?

J’ai créé un nouveau référentiel Git local:

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

Existe-t-il une commande git permettant de créer un nouveau référentiel distant et d’envoyer mon commit vers GitHub d’ici? Je sais que ce n’est pas grave de lancer un navigateur et de créer un nouveau référentiel , mais s’il y a un moyen d’y parvenir depuis la CLI, je serais ravi.

J’ai lu une grande quantité d’articles mais aucun que j’ai trouvé ne mentionne comment créer un repository à distance à partir de l’interface de ligne de commande à l’aide des commandes git. Le bel article de Tim Lucas La configuration d’un nouveau repository git distant est la plus proche que j’ai trouvée, mais GitHub ne fournit pas d’access au shell .

Vous pouvez créer un repo GitHub via la ligne de commande à l’aide de l’API GitHub. Découvrez l’ API du référentiel . Si vous faites défiler environ un tiers du chemin, vous verrez une section intitulée “Créer” qui explique comment créer un repo via l’API (juste au-dessus, il y a une section qui explique comment utiliser un repo avec l’API) ). De toute évidence, vous ne pouvez pas utiliser git pour cela, mais vous pouvez le faire via la ligne de commande avec un outil tel que curl .

En dehors de l’API, il n’y a aucun moyen de créer un repository sur GitHub via la ligne de commande. Comme vous l’avez noté, GitHub n’autorise pas l’access au shell, etc. En plus de l’API GitHub, l’interface Web de GitHub est la seule façon de créer un repository.

Commandes CLI pour github API v3 (remplacez tous les mots clés 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 

Cela peut être fait avec trois commandes:

 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 

(mis à jour pour l’API Github v3)

Explication de ces commandes …

Créer un repo github

  curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}' 
  • curl est une commande unix (ci-dessus fonctionne aussi sur mac) qui récupère et interagit avec les URL. Il est généralement déjà installé.
  • “-u” est un paramètre curl qui spécifie le nom d’utilisateur et le mot de passe à utiliser pour l’authentification du serveur.
    • Si vous donnez simplement le nom d’utilisateur (comme illustré ci-dessus), curl demandera un mot de passe.
    • Si vous ne voulez pas avoir à saisir le mot de passe, consultez la documentation de githubs api sur l’ authentification
  • “-d” est un paramètre curl qui vous permet d’envoyer des données POST avec la requête
    • Vous envoyez des données POST au format API défini par githubs
  • “nom” est la seule donnée POST requirejse; J’aime aussi inclure “description”
  • J’ai trouvé qu’il était bon de citer toutes les données POST avec des guillemets simples ”

Définir où pousser pour

 git remote add origin git@github.com:nyeates/projectname.git 
  • append la définition de l’emplacement et de l’existence du repo connecté (distant) sur github
  • “origine” est un nom par défaut utilisé par git pour savoir d’où provient la source
    • techniquement ne sont pas venus de github, mais maintenant le repo github sera la source d’enregistrement
  • “git@github.com: nyeates” est une connexion ssh qui suppose que vous avez déjà configuré une paire de clés ssh sécurisée avec github.

Poussez repo local à github

 git push origin master 
  • pousser à l’origine à distance (github) de la twig locale principale

Si vous installez l’ excellent outil Hub de defunkt , cela devient aussi simple que

git create

Dans les mots de l’auteur, ” hub est un wrapper de ligne de commande pour git qui vous rend meilleur à GitHub.

Étapes simples (en utilisant git + hub => GitHub ):

  1. Installer le hub ( GitHub ).

    • OS X: brew install hub
    • avoir Go : go get github.com/github/hub
    • sinon (avoir aussi bien aller ):

       git clone https://github.com/github/hub.git && cd hub && ./script/build 
  2. Accédez à votre repository ou créez-en un vide: mkdir foo && cd foo && git init .

  3. Run: hub create , il vous posera des questions sur les informations d’identification GitHub pour la première fois.

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

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

    Hub demandera le nom d’utilisateur et le mot de passe GitHub la première fois qu’il doit accéder à l’API et l’échanger contre un jeton OAuth , qu’il enregistre dans ~/.config/hub .

    Pour nommer explicitement le nouveau référentiel, saisissez NAME , éventuellement sous la forme ORGANIZATION/NAME pour créer sous une organisation dont vous êtes membre.

    Avec -p , créez un référentiel privé et avec -d et -h définissez respectivement la description du référentiel et l’ URL page d’accueil.

    Pour éviter d’être invité, utilisez les variables d’environnement GITHUB_USER et GITHUB_PASSWORD .

  4. Ensuite, validez et poussez comme d’habitude ou vérifiez la hub commit / hub push .

Pour plus d’aide, exécutez: hub help .

Voir aussi: Importation d’un référentiel Git à l’aide de la ligne de commande de GitHub.

Il y a un bijou officiel de github qui, je pense, le fait. J’essaierai d’append plus d’informations lorsque j’apprendrai, mais je ne fais que découvrir ce bijou, je ne sais pas encore grand chose.

MISE À JOUR: Après avoir configuré ma clé API, je suis capable de créer un nouveau repository sur github via la commande create , mais je ne peux pas utiliser la commande create-from-local , qui est censée prendre le repo local actuel et créer une correspondant à distance sur github.

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

Si quelqu’un a des idées à ce sujet, j’aimerais savoir ce que je fais mal. Il y a déjà un problème déposé .

MISE À JOUR: J’ai fini par faire fonctionner cela. Je ne sais pas exactement comment reproduire le problème, mais je viens juste de partir de zéro (suppression du dossier .git)

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

Maintenant, cette ligne va créer le repo distant et même le pousser, mais malheureusement je ne pense pas pouvoir spécifier le nom du repo que je voudrais. Je voulais qu’il s’appelle “dotfiles” sur github, mais le gem vient d’utiliser le nom du dossier actuel, qui était “jason” puisque j’étais dans mon dossier personnel. (J’ai ajouté un ticket demandant le comportement souhaité)

 gh create-from-local 

Cette commande, par contre, accepte un argument pour spécifier le nom du repository à distance, mais il est destiné à démarrer un nouveau projet à partir de zéro, c’est-à-dire qu’après avoir appelé cette commande, vous obtenez un nouveau référentiel distant dans un sous-dossier nouvellement créé par rapport à votre position actuelle, les deux avec le nom spécifié comme argument.

 gh create dotfiles 

Faire pour créer rapidement le référentiel distant à l’aide d’un shell Bash

Il est fastidieux de saisir le code complet à chaque fois qu’un référentiel doit être créé.

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

Une approche plus simple est:

  1. créer un script shell dans un répertoire / home / USER_NAME / Desktop / my_scripts nommé githubscript.sh
  2. Modifiez et enregistrez le code suivant dans le fichier 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; 

NB Ici, $1 est le repository name du repository name transmis en tant argument lors de l’appel du script Modifiez YOUR_GITHUB_USER_NAME avant d’enregistrer le script.

  1. Définir les permissions requirejses pour le fichier de script chmod 755 githubscript.sh

  2. Incluez le répertoire de scripts dans le fichier de configuration de l’environnement. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

  3. Définissez également un alias pour exécuter le fichier githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

  4. Maintenant, rechargez les .profile .bashrc et .profile dans le terminal. source ~/.bashrc ~/.profile;

  5. Maintenant, pour créer un nouveau référentiel, à savoir une demo : githubrepo demo;

Pour les utilisateurs avec une authentification à deux facteurs, vous pouvez utiliser la solution de bennedich, mais il vous suffit d’append l’en-tête X-Github-OTP pour la première commande. Remplacez CODE par le code fourni par le fournisseur d’authentification à deux facteurs. Remplacez USER et REPO par le nom d’utilisateur et le nom du référentiel, comme vous le feriez dans sa solution.

 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 

J’ai écrit un script astucieux pour cela appelé Gitter en utilisant les API REST pour GitHub et 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 = créer un nouveau repository
  • -r = fournisseur de repo (g = GitHub, b = BitBucket)
  • -n = nommer le repo
  • -l = (facultatif) définit la langue de l’application dans le repository

J’ai créé un alias Git pour ce faire, basé sur la réponse de Bennedich . Ajoutez ce qui suit à votre ~/.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\").ssortingp(); 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\"])'" 

Pour l’utiliser, lancez

 $ git hub-new-repo 

depuis n’importe où dans le repository local et entrez votre mot de passe Github lorsque vous y êtes invité.

Basé sur l’autre réponse de @Mechanical Snail, sauf sans l’utilisation de python, que j’ai trouvé extrêmement exagéré. Ajoutez ceci à votre ~/.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" 

Non, vous devez ouvrir un navigateur au moins une fois pour créer votre username d’ username sur GitHub, une fois créé, vous pouvez utiliser l’API GitHub pour créer des référentiels à partir de la ligne de commande, en suivant la commande suivante:

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

Par exemple:

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

Pour savoir comment créer un jeton, cliquez ici. Voici la commande que vous allez saisir (à la date de cette réponse. (Remplacez tous les mots-clés CAPS):

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

Une fois que vous entrez votre mot de passe, vous verrez ce qui suit qui contient votre jeton.

 { "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" } 

Vous pouvez révoquer votre jeton à tout moment en allant ici

Ce dont vous avez besoin est hub . Hub est un wrapper de ligne de commande pour git. Il a été conçu pour s’intégrer avec git natif en utilisant des alias. Il essaie de fournir des actions github dans git, y compris la création d’un nouveau référentiel.

 → 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 

Pour les rubyistes:

 gem install githubrepo githubrepo create *reponame* 

entrez le nom d’utilisateur et pw à l’invite

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

Source: Elikem Adadevoh

Pour des raisons de représentation, je ne peux pas append ceci en tant que commentaire (où il serait préférable de répondre à la réponse de bennedich ), mais pour la ligne de commande Windows, voici la syntaxe correcte:

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

C’est la même forme de base, mais vous devez utiliser des guillemets (“) au lieu de simples, et échapper les guillemets doubles dans les parameters POST (après l’indicateur -d). J’ai également supprimé les guillemets simples autour de mon nom d’utilisateur. mais si votre nom d’utilisateur avait un espace (possible?), il aurait probablement besoin de guillemets doubles.

Pour tous les utilisateurs de Python 2.7. *. Il y a un wrapper Python autour de l’ API Github qui est actuellement sur la version 3, appelée GitPython . Il suffit d’installer en utilisant easy_install PyGithub ou 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) 

Les documents d’object du Repository sont ici .

J’ai trouvé cette solution qui m’a plu: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Vous devez d’abord créer un jeton d’access personnel Github

Ouvrez votre fichier ~ / .bash_profile ou ~ / .bashrc dans votre éditeur de texte préféré. Ajoutez la ligne suivante près du haut de votre fichier, où le rest des variables d’exportation sont:

export GITHUB_API_TOKEN=

Quelque part ci-dessous, par vos autres fonctions bash, vous pouvez coller quelque chose de similaire à ce qui suit:

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

Maintenant, chaque fois que vous créez un nouveau projet, vous pouvez exécuter la commande $ new-git awesome-repo pour créer un nouveau référentiel distant public sur votre compte utilisateur Github.

Disclamier: Je suis l’auteur du projet open source

Cette fonctionnalité est supscope par: https://github.com/chrissound/LinuxVerboseCommandLib c’est essentiellement ce 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 git@github.com:"$GITHUB_USER"/"$projName".git git push origin master }; 

voici mes commandes git initiales (éventuellement, cette action a lieu dans 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 

J’ai récemment découvert create-github-repo . Du readme:

Installer:

 $ npm i -g create-github-repo 

Usage:

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

Ou:

 $ create-github-repo  --name "My coolest repo yet!" 

créer un nouveau référentiel sur la ligne de commande

 echo "# " >> README.md git init git add README.md git commit -m "first commit" git remote add origin https://github.com/**/**.git git push -u origin master 

pousser un référentiel existant à partir de la ligne de commande

 git remote add origin https://github.com/**/**.git git push -u origin master