@savaryna/git-add-account 1.0.3 → 2.0.1

package/README.md

@@ -1,81 +1,88 @@
 # @savaryna/add-git-account
 
-🔐 A small CLI app that allows you to easily add multiple GIT accounts on one machine. It switches between accounts automatically based on the workspace (directory) you are in.
+🔐 A small CLI app that allows you to easily add multiple GIT accounts on one machine. It switches between accounts automatically based on the workspace _(directory/subdirectory)_ you are in.
 
 ## Usage
 
-Run the command direcly:
+Run the command direcly with
+
 ```shell
 npx @savaryna/git-add-account
 ```
 
-or if you want to install it globally:
+or if you want, first install it globally
 
 ```shell
 npm i -g @savaryna/git-add-account
+```
 
-# now you can run it by invoking
-git-add-account
+then you can run it using
 
-# or
-gaa
+```shell
+git-add-account
 ```
 
-After going through all the steps:
+or
 
 ```shell
-✔ Name to use for this account: … Example Name
-✔ Email to use for this account: … example@email.com
-✔ Workspace to use for this account: … /Users/savaryna/code/email
-✔ Name to use for SSH keys: … email_example_name
-Enter passphrase (empty for no passphrase):
-Enter same passphrase again:
-✔ Do you want to sign your work? … no / yes
-
-Your public SSH key is:  ssh-ed25519 AAAAC3NlZ...DITJheGo example@email.com
-You can also find it here:  /Users/savaryna/.ssh/git_email_example_name.pub
-Add it to your favorite GIT provider and enjoy!
-
-✨ Done. Thanks for using @savaryna/git-add-account!
+gaa
 ```
 
-You will be presented with your public SSH key so you can copy, and add it to your GIT provider. For example GitHub[^1]:
+After going through all the steps, you will be presented with your public SSH key so you can copy, and add it to your GIT provider. For example GitHub[^1]:
 
 1. Go to your account [settings / keys](https://github.com/settings/keys)
-2. Click on `New SSH key`
-3. Give it any title
-4. Choose `Authentication Key` for key type
-4. Paste in the public SSH key copied earlier in the key field
-5. Repeat steps 2 - 4 to add a `Signing Key` key type, if you chose to sign your work (Commits, Tags, Pushes)[^2]
-6. Done! Now you can go to the workspace you chose for the account `/Users/savaryna/code/email` in this example, and all the GIT
-commands issued from this and children directories will automatically use the correct account.
-
-## How it works
-
-A simple way to use multiple git accounts on one machine is to use multiple SSH keys configured with different hosts. The way [@savaryna/add-git-account](https://www.npmjs.com/package/@savaryna/git-add-account) works is, it asks you for some basic information and then:
-
-1. It creates a `.gitconfig` file in the workspace directory you specified.
-2. It creates a SSH keypair using `ssh-keygen -t ed25519 -C "email@you.specified" -f ~/.ssh/git_the_ssh_key_name_you_specified`.
-3. It appends to the `~/.ssh/config` file.
-    ```ini
-    # Config for GIT account email@you.specified
-    Host *
-      AddKeysToAgent yes
-      UseKeychain yes
-      IdentityFile path/to/the/SSH/key/created/in/step/2
-    ```
-4. It runs `git config --file path/to/.gitconfig/from/step/1 user.name "name_you_specified"` to set your git username.
-5. It runs `git config --file path/to/.gitconfig/from/step/1 user.email "email@you.specified"` to set your git email.
-6. It runs `git config --file path/to/.gitconfig/from/step/1 core.sshCommand "ssh -i path/to/the/SSH/key/created/in/step/2"` to make sure all the commands issued from this workspace use the correct SSH key.
-7. If you chose to sign your work:
-    1. It runs `git config --file path/to/.gitconfig/from/step/1 gpg.format ssh` to use SSH key for signing.
-    2. It runs `git config --file path/to/.gitconfig/from/step/1 commit.gpgsign true` to enable signing commits.
-    3. It runs `git config --file path/to/.gitconfig/from/step/1 push.gpgsign if-asked` to enable signing pushes if supported.
-    4. It runs `git config --file path/to/.gitconfig/from/step/1 tag.gpgsign true` to enable signing tags.
-    5. It runs `git config --file path/to/.gitconfig/from/step/1 user.signingkey path/to/the/SSH/key/created/in/step/2` to set the signing key to the one created in step 2.
-8. It runs `git config --global includeIf.gitdir:path/to/your/workspace/.path $path/to/.gitconfig/from/step/1`, this makes sure that if you are in the workspace for the created account, git will use the config from step 1 with all the options from the step 5, 6 and 7 automatically.
-9. And finally it presents you with your public SSH key so you can copy it and add it to your GIT provider of choice.
-
+1. Click on `New SSH key`
+1. Give it a title
+1. Choose `Authentication Key` for key type
+1. Paste in the public SSH key copied earlier in the key field
+1. Click on `Add SSH key`
+1. Repeat steps **2 through 6** to add a `Signing Key` key type, if you chose to sign your work (Commits, Tags, Pushes)[^2]
+1. Done! Now, you can go to the workspace you chose for the account, ex: `cd /Users/john/code/work`, and all the `git`
+   commands issued from this, **or any other subdirectory**, will automatically use the correct account/ssh keys.
+
+## Example of how it works
+
+A simple way to use multiple git accounts on one machine is to use different SSH configs based on the directory you are in. The way [@savaryna/add-git-account](https://www.npmjs.com/package/@savaryna/git-add-account) works is, it asks you for some basic information and then it creates some files under `.config` in the workspace directory you specified. Ex:
+
+1. It creates a _(private/public)_ SSH keypair using `ssh-keygen -t ed25519 -C "john@github.com" -f /Users/john/code/work/.config/id_ed25519_git_github_com`. [See code](https://github.com/savaryna/git-add-account/blob/main/index.js#L24-L25).
+1. It creates a `sshconfig` file. [See code](https://github.com/savaryna/git-add-account/blob/main/index.js#L35-L47).
+
+   ```ini
+   # File at /Users/john/code/work/.config/sshconfig
+   # Config for GIT account john@github.com
+   Host github.com
+     HostName github.com
+     User git
+     AddKeysToAgent yes
+     UseKeychain yes
+     IdentitiesOnly yes
+     IdentityFile /Users/john/code/work/.config/id_ed25519_git_github_com
+   ```
+
+1. It creates a `gitconfig` file. [See code](https://github.com/savaryna/git-add-account/blob/main/index.js#L49-L75).
+
+   ```ini
+   # File at /Users/john/code/work/.config/gitconfig
+   # Config for GIT account john@github.com
+   [user]
+     name = John Doe
+     email = john@github.com
+   [core]
+     sshCommand = ssh -F /Users/john/code/work/.config/sshconfig
+   [gpg]
+     format = ssh
+   [commit]
+     gpgsign = true
+   [push]
+     gpgsign = if-asked
+   [tag]
+     gpgsign = true
+   [user]
+     signingkey = /Users/john/code/work/.config/id_ed25519_git_github_com
+   ```
+
+1. It runs `git config --global includeIf.gitdir:/Users/john/code/work/.path /Users/john/code/work/.config/gitconfig`, this makes sure that as long as you are in the workspace created earlier, **or any other subdirectory**, git will use the config from step **3** automatically[^3]. [See code](https://github.com/savaryna/git-add-account/blob/main/index.js#L77-L78).
+1. And finally, it presents you with your public SSH key so you can copy it and add it to your GIT provider of choice.
 
 ## License
 
@@ -83,3 +90,4 @@ A simple way to use multiple git accounts on one machine is to use multiple SSH
 
 [^1]: https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account?tool=webui
 [^2]: https://docs.github.com/en/authentication/managing-commit-signature-verification
+[^3]: https://git-scm.com/docs/git-config#_conditional_includes

package/helpers/file.js

@@ -1,19 +1,19 @@
-const { access, appendFile, constants, mkdir, readFile, unlink, writeFile } = require('fs');
-const { homedir } = require('os');
+const { access, constants, mkdir, readFile, rm, writeFile } = require('fs');
+const { homedir, platform } = require('os');
 const { promisify } = require('util');
 const { resolve } = require('path');
 
-module.exports.append = promisify(appendFile);
+module.exports.createFile = (path, data) => promisify(writeFile)(path, data, 'utf8');
 
-module.exports.createEmptyFile = (path) => promisify(writeFile)(path, '');
+module.exports.readFile = promisify(readFile);
 
 module.exports.home = homedir();
 
-module.exports.mkdir = promisify(mkdir);
+module.exports.platform = platform();
 
-module.exports.readFile = promisify(readFile);
+module.exports.mkdir = promisify(mkdir);
 
-module.exports.remove = promisify(unlink);
+module.exports.remove = (path) => promisify(rm)(path, { recursive: true, force: true });
 
 module.exports.resolve = resolve;
 

package/helpers/prompts.js

@@ -1,4 +1,11 @@
-const prompts = require('prompts');
+const { default: exec } = require('./exec');
+const { home, resolve } = require('./file');
+const { default: validate, z } = require('./validate');
+const defaultPrompts = require('prompts');
+
+const MIN_GIT_VERSION = '2.34.0'; // Lower versions don't support SSH for GPG signing
+
+const getGitVersion = () => exec('git --version').then(({ stdout }) => stdout.split(' ')[2]);
 
 const exit = (code = 0, reason = null) => {
   console.log(reason ? `\n${reason}\n` : '');
@@ -6,6 +13,98 @@ const exit = (code = 0, reason = null) => {
   process.exit(code);
 };
 
+// Add onCancel handler for all prompts
+const prompts = (questions, options) => defaultPrompts(questions, { onCancel: () => exit(1), ...options });
+
+const overwritePathPrompt = (path) =>
+  prompts({
+    type: 'toggle',
+    name: 'overwrite',
+    message: `Path ${path} already exists. Overwrite?`,
+    initial: false,
+    active: 'yes',
+    inactive: 'no',
+  });
+
+const cliPrompts = () =>
+  prompts([
+    {
+      type: 'text',
+      name: 'name',
+      message: 'Your name:',
+      validate: validate(z.string()),
+      format: (value) => ({
+        value,
+        camel: value.toLowerCase().replace(/[^\w]/g, '_'),
+      }),
+    },
+    {
+      type: 'text',
+      name: 'email',
+      message: 'Email to use for this account:',
+      validate: validate(z.string().email()),
+    },
+    {
+      type: 'text',
+      name: 'host',
+      message: 'Host to use for this account:',
+      initial: (email) => email.split('@')[1],
+      validate: validate(
+        z
+          .string()
+          .transform((h) => 'https://' + h)
+          .refine(URL.canParse, { message: 'Invalid host' })
+      ),
+      format: (value) => ({
+        value,
+        camel: value.replace(/[^\w]/g, '_'),
+      }),
+    },
+    {
+      type: 'text',
+      name: 'workspace',
+      message: 'Workspace to use for this account:',
+      initial: (host) => resolve(home, 'code', host.camel),
+      validate: validate(z.string().refine((value) => !value.startsWith('~'), { message: '"~" is not supported' })),
+      format: (value, { host }) => {
+        const root = resolve(home, value);
+        const config = resolve(root, '.config');
+        const sshKeyFileName = `id_ed25519_git_${host.camel}`;
+
+        return {
+          root,
+          config,
+          gitConfig: resolve(config, 'gitconfig'),
+          sshConfig: resolve(config, 'sshconfig'),
+          privateKey: resolve(config, sshKeyFileName),
+          publicKey: resolve(config, sshKeyFileName + '.pub'),
+        };
+      },
+    },
+    {
+      type: 'toggle',
+      name: 'signYourWork',
+      message: 'Do you want to sign your work with SSH?',
+      initial: true,
+      active: 'yes',
+      inactive: 'no',
+    },
+    {
+      type: async (prev) => {
+        this.gitVersion = await getGitVersion();
+        return prev && this.gitVersion < MIN_GIT_VERSION ? 'toggle' : null;
+      },
+      name: 'signYourWork',
+      message: () => `Your current git version (${this.gitVersion}) does not support SSH signing. Continue without?`,
+      initial: true,
+      active: 'yes',
+      inactive: 'no',
+      format: (value) => (value ? !value : exit(1)),
+    },
+  ]);
+
 module.exports.exit = exit;
 
-module.exports.default = (questions, options) => prompts(questions, { onCancel: () => exit(1), ...options });
+module.exports.overwritePathPrompt = overwritePathPrompt;
+
+module.exports.default = cliPrompts;

package/index.js

@@ -1,149 +1,86 @@
 #!/usr/bin/env node
 
 const { default: exec } = require('./helpers/exec');
-const { append, createEmptyFile, hasReadWriteAccess, home, mkdir, readFile, remove, resolve } = require('./helpers/file');
-const { default: prompts, exit } = require('./helpers/prompts');
-const { default: validate, z } = require('./helpers/validate');
-
-const sshDirPath = resolve(home, '.ssh');
-const sshConfigPath = resolve(sshDirPath, 'config');
-
-const overwriteFilePrompt = (path) =>
-  prompts({
-    type: 'toggle',
-    name: 'overwrite',
-    message: `File ${path} already exists. Overwrite?`,
-    initial: false,
-    active: 'yes',
-    inactive: 'no',
-  });
+const { createFile, hasReadWriteAccess, platform, mkdir, readFile, remove } = require('./helpers/file');
+const { default: prompts, overwritePathPrompt, exit } = require('./helpers/prompts');
 
 async function main() {
-  const { name, email, workspace } = await prompts([
-    {
-      type: 'text',
-      name: 'name',
-      message: 'Name to use for this account:',
-      validate: validate(z.string()),
-      format: (value) => ({
-        original: value,
-        camel: value.toLowerCase().replace(/[^\w]/g, '_'),
-      }),
-    },
-    {
-      type: 'text',
-      name: 'email',
-      message: 'Email to use for this account:',
-      validate: validate(z.string().email()),
-      format: (value) => ({
-        address: value,
-        domain: value.match(/(?<=@).+(?=\.)/)[0].replace(/[^\w]/g, '_'),
-      }),
-    },
-    {
-      type: 'text',
-      name: 'workspace',
-      message: 'Workspace to use for this account:',
-      initial: (email) => resolve(home, `code/${email.domain}`),
-      validate: validate(z.string()),
-    },
-  ]);
-
-  const workspaceGitConfigPath = resolve(workspace, '.gitconfig');
+  const { name, email, host, workspace, signYourWork } = await prompts();
 
-  if (await hasReadWriteAccess(workspaceGitConfigPath)) {
-    const { overwrite } = await overwriteFilePrompt(workspaceGitConfigPath);
+  // Check already existing workspace config
+  if (await hasReadWriteAccess(workspace.config)) {
+    const { overwrite } = await overwritePathPrompt(workspace.config);
 
     if (overwrite) {
-      await remove(workspaceGitConfigPath);
+      await remove(workspace.config);
     } else {
       exit(1);
     }
   }
 
-  const { sshKeyFileName } = await prompts([
-    {
-      type: 'text',
-      name: 'sshKeyFileName',
-      message: 'Name to use for SSH keys:',
-      initial: `${email.domain}_${name.camel}`,
-      validate: validate(z.string()),
-      format: (value) => `git_${value}`,
-    },
-  ]);
-
-  const sshKeyPath = resolve(sshDirPath, sshKeyFileName);
-
-  if (await hasReadWriteAccess(sshKeyPath)) {
-    const { overwrite } = await overwriteFilePrompt(sshKeyPath);
-
-    if (overwrite) {
-      await remove(sshKeyPath);
-    } else {
-      exit(1);
-    }
-  }
+  // Create workspace/config dir
+  await mkdir(workspace.config, { recursive: true });
 
   // Generate ssh key
-  await exec(`ssh-keygen -t ed25519 -C "${email.address}" -f ${sshKeyPath}`);
+  await exec(`ssh-keygen -t ed25519 -C "${email}" -f ${workspace.privateKey}`);
 
-  // Check to see if the user entered a passphrase
-  const hasPassphrase = await exec(`ssh-keygen -y -P "" -f ${sshKeyPath}`).then(
-    () => false,
-    () => true
-  );
+  // Use keychain if the system is MacOS and a passphrase was used
+  const useKeychain = await exec(`ssh-keygen -y -P "" -f ${workspace.privateKey}`)
+    .then(
+      () => false,
+      () => true
+    )
+    .then((hasPassphrase) => hasPassphrase && platform === 'darwin');
 
+  // Create sshconfig for the workspace
   const sshConfig = `
-    # Config for GIT account ${email.address}
-    Host *
+    # Config for GIT account ${email}
+    Host ${host.value}
+      HostName ${host.value}
+      User git
       AddKeysToAgent yes
-      ${hasPassphrase ? 'UseKeychain yes' : ''}
-      IdentityFile ${sshKeyPath}
+      ${useKeychain ? 'UseKeychain yes' : ''}
+      IdentitiesOnly yes
+      IdentityFile ${workspace.privateKey}
   `.replace(/\n\s{4}/g, '\n');
 
-  // Add account to the ssh config
-  await append(sshConfigPath, sshConfig);
-
-  // Create workspace dir if it does not exist
-  await mkdir(workspace, { recursive: true });
-
-  // Create .gitconfig for the workspace
-  await createEmptyFile(workspaceGitConfigPath);
-
-  // Set user details
-  await exec(`git config --file ${workspaceGitConfigPath} user.name "${name.original}"`);
-  await exec(`git config --file ${workspaceGitConfigPath} user.email "${email.address}"`);
-
-  // Set default ssh command
-  await exec(`git config --file ${workspaceGitConfigPath} core.sshCommand "ssh -i ${sshKeyPath}"`);
-
-  const { signYourWork } = await prompts({
-    type: 'toggle',
-    name: 'signYourWork',
-    message: 'Do you want to sign your work?',
-    initial: true,
-    active: 'yes',
-    inactive: 'no',
-  });
+  await createFile(workspace.sshConfig, sshConfig);
+
+  // Create gitconfig for the workspace
+  const gitConfig = `
+    # Config for GIT account ${email}
+    [user]
+      name = ${name.value}
+      email = ${email}
+    [core]
+      sshCommand = ssh -F ${workspace.sshConfig}
+    ${
+      !signYourWork
+        ? ''
+        : `
+    [gpg]
+      format = ssh
+    [commit]
+      gpgsign = true
+    [push]
+      gpgsign = if-asked
+    [tag]
+      gpgsign = true
+    [user]
+      signingkey = ${workspace.privateKey}
+    `
+    }
+  `.replace(/\n\s{4}/g, '\n');
 
-  // Enable signing
-  if (signYourWork) {
-    await exec(`git config --file ${workspaceGitConfigPath} gpg.format ssh`);
-    await exec(`git config --file ${workspaceGitConfigPath} commit.gpgsign true`);
-    await exec(`git config --file ${workspaceGitConfigPath} push.gpgsign if-asked`);
-    await exec(`git config --file ${workspaceGitConfigPath} tag.gpgsign true`);
-    await exec(`git config --file ${workspaceGitConfigPath} user.signingkey ${sshKeyPath}`);
-  }
+  await createFile(workspace.gitConfig, gitConfig);
 
   // Include workspace config in the global config
-  await exec(`git config --global includeIf.gitdir:${workspace}/.path ${workspaceGitConfigPath}`);
+  await exec(`git config --global includeIf.gitdir:${workspace.root}/.path ${workspace.gitConfig}`);
 
-  const publicSshKeyPath = resolve(sshDirPath, `${sshKeyFileName}.pub`);
-  // await exec(`pbcopy < ${publicSshKeyPath}`);
-  const publicSshKey = await readFile(publicSshKeyPath).then((buffer) => buffer.toString().trim());
+  const publicKey = await readFile(workspace.publicKey).then((buffer) => buffer.toString().trim());
 
-  console.log('\nYour public SSH key is: ', publicSshKey);
-  console.log('You can also find it here: ', publicSshKeyPath);
+  console.log('\nYour public SSH key is: ', publicKey);
+  console.log('You can also find it here: ', workspace.publicKey);
   console.log('Add it to your favorite GIT provider and enjoy!');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savaryna/git-add-account",
-  "version": "1.0.3",
+  "version": "2.0.1",
   "description": "🔐 A small CLI app that allows you to easily add multiple GIT accounts on one machine. It switches between accounts automatically based on the workspace (directory) you are in.",
   "homepage": "https://github.com/savaryna/git-add-account#readme",
   "keywords": [
@@ -33,6 +33,9 @@
     "url": "git+https://github.com/savaryna/git-add-account.git"
   },
   "type": "commonjs",
+  "files": [
+    "helpers"
+  ],
   "bin": {
     "gaa": "index.js",
     "git-add-account": "index.js"

package/.github/dependabot.yml

@@ -1,19 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-
-  # Maintain dependencies for npm
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "monthly"

package/.github/workflows/publish-package.yml

@@ -1,21 +0,0 @@
-name: Publish package
-
-on:
-  release:
-    types: [created]
-  workflow_dispatch:
-
-jobs:
-  publish-npm:
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-          scope: '@savaryna'
-      - run: npm ci
-      - run: npm publish --access=public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.prettierrc.json

@@ -1,20 +0,0 @@
-{
-  "arrowParens": "always",
-  "bracketSameLine": false,
-  "bracketSpacing": true,
-  "embeddedLanguageFormatting": "auto",
-  "htmlWhitespaceSensitivity": "css",
-  "insertPragma": false,
-  "jsxSingleQuote": false,
-  "printWidth": 120,
-  "proseWrap": "preserve",
-  "quoteProps": "as-needed",
-  "requirePragma": false,
-  "semi": true,
-  "singleAttributePerLine": false,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "es5",
-  "useTabs": false,
-  "vueIndentScriptAndStyle": false
-}