@bstopp/git-who 0.0.0-stage → 0.2.0

package/dist/src/commands/edit.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import confirm from '@inquirer/confirm';
+import log from "../utils/log.js";
+import { loadProfiles, updateProfile } from "../utils/profiles.js";
+import { promptForProfile, selectProfile } from "../utils/prompts.js";
+import { printProfile } from "../utils/display.js";
+/**
+ * Edit a profile, either the one given by name or one picked from a prompt. The prompts are pre-filled with the current
+ * values. If nothing changed the user is offered another pass; otherwise the changes are printed next to their original
+ * values and must be confirmed before they are saved. Renaming a profile warns that repos still using the old name need
+ * `git who use` to pick up the new one, as the name is what links a repo to its profile.
+ *
+ * @throws {Error} If the profiles cannot be loaded or the profile cannot be updated.
+ */
+export default async function edit(name) {
+    const profiles = await loadProfiles();
+    const selected = await selectProfile(profiles, name);
+    let updated;
+    let changed;
+    do {
+        updated = await promptForProfile(selected);
+        changed = JSON.stringify(selected) !== JSON.stringify(updated);
+    } while (!changed && await confirm({ message: 'No changes detected. Return to edit?', default: true }));
+    if (changed) {
+        printProfile(updated, { original: selected });
+        if (await confirm({ message: 'Save this profile?', default: true })) {
+            await updateProfile(selected, updated);
+            log.info(`Profile ${chalk.bold(updated.name)} updated.`);
+            if (updated.name !== selected.name) {
+                log.warn(`Profile renamed from '${selected.name}' to '${updated.name}'. Repos still using '${selected.name}' need \`git who use ${updated.name}\` to pick up the new name.`);
+            }
+            return;
+        }
+    }
+    log.warn('Profile not updated.');
+}

package/dist/src/commands/list.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+import { simpleGit } from 'simple-git';
+import log from "../utils/log.js";
+import { loadProfiles, getActiveProfileName } from "../utils/profiles.js";
+export default async function list(options = {}) {
+    const profiles = await loadProfiles();
+    const activeName = await getActiveProfileName(simpleGit());
+    if (options.json) {
+        log.json(profiles.map((p) => ({ ...p, active: p.name === activeName })));
+        return;
+    }
+    const lines = profiles.map((p) => {
+        if (p.name === activeName) {
+            return chalk.bold(`  - ${p.name} (${p.host})`);
+        }
+        return `  - ${p.name} (${p.host})`;
+    });
+    lines.unshift('Known profiles:');
+    log.info(lines.join('\n'));
+}

package/dist/src/commands/remove.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import confirm from '@inquirer/confirm';
+import { simpleGit } from 'simple-git';
+import log from "../utils/log.js";
+import { loadProfiles, removeProfile, getActiveProfileName } from "../utils/profiles.js";
+import { selectProfile } from "../utils/prompts.js";
+import { printProfile } from "../utils/display.js";
+async function confirmContinue(profile) {
+    return confirm({
+        message: `Profile '${profile.name}' is the active profile. Continue?`,
+        theme: { style: { message: (text) => chalk.yellow(text) } },
+        default: false,
+    });
+}
+async function confirmRemove(profile) {
+    return confirm({
+        message: `Remove profile '${profile.name}'?`,
+        theme: { style: { message: (text) => chalk.red(text) } },
+        default: false,
+    });
+}
+async function unsetActive(git) {
+    try {
+        await git.raw(['config', '--local', '--unset', 'gitwho.profile']);
+    }
+    catch {
+        log.warn("Unable to unset 'gitwho.profile' git config value.");
+    }
+}
+/**
+ * Remove a profile, either the one given by name or one picked from a prompt. The profile is printed and the removal
+ * must be confirmed. Removing the profile that is active in the current repo needs an extra confirmation, and unsets
+ * `gitwho.profile` afterwards; a failure to unset it only warns.
+ *
+ * @throws {Error} If the profiles cannot be loaded or the profile cannot be removed.
+ */
+export default async function remove(name) {
+    const git = simpleGit();
+    const profiles = await loadProfiles();
+    const selected = await selectProfile(profiles, name);
+    const isActive = await getActiveProfileName(git) === selected.name;
+    if (isActive && !await confirmContinue(selected)) {
+        log.warn(`Profile '${selected.name}' not removed, as it is currently active.`);
+        return;
+    }
+    printProfile(selected);
+    if (await confirmRemove(selected)) {
+        await removeProfile(selected.name);
+        if (isActive) {
+            await unsetActive(git);
+        }
+        log.info(`Profile '${selected.name}' has been removed.`);
+    }
+    else {
+        log.warn(`Profile '${selected.name}' not removed.`);
+    }
+}

package/dist/src/commands/show.js

@@ -0,0 +1,183 @@
+import { simpleGit } from 'simple-git';
+import { SIGNING_METHOD } from "../profile.js";
+import log from "../utils/log.js";
+import { printProfile } from "../utils/display.js";
+import { loadProfiles, getActiveProfileName } from "../utils/profiles.js";
+import { listSshKeys } from "../utils/ssh.js";
+import { listGpgKeys } from "../utils/gpg.js";
+/**
+ * Compare a profile with the repo's local git config. A field is only present in the result when the two differ, and
+ * its value is what git has (`undefined` when git has nothing set).
+ *
+ * Git's signing method is only defined when `commit.gpgsign` is `true`: `gpg.format` of `openpgp` (or unset) is gpg,
+ * `ssh` is ssh. Any other format, such as x509, is not supported and reads as git not signing.
+ */
+function buildMismatches(actual, git) {
+    const mismatches = {};
+    if (actual.username !== git.username) {
+        mismatches.username = git.username;
+    }
+    if (actual.email !== git.email) {
+        mismatches.email = git.email;
+    }
+    if (actual.signingKey !== git.signingKey) {
+        mismatches.signingKey = git.signingKey;
+    }
+    let gitSigningMethod;
+    if (git.signCommits === 'true') {
+        if (!git.signingMethod || git.signingMethod === 'openpgp') {
+            gitSigningMethod = SIGNING_METHOD.GPG;
+        }
+        else if (git.signingMethod === 'ssh') {
+            gitSigningMethod = SIGNING_METHOD.SSH;
+        }
+    }
+    if (actual.signingMethod !== gitSigningMethod) {
+        mismatches.signingMethod = gitSigningMethod;
+    }
+    return mismatches;
+}
+async function readGitConfig() {
+    const git = simpleGit();
+    const [name, { value: username }, { value: email }, { value: signCommits }, { value: signingKey }, { value: signingMethod },] = await Promise.all([
+        getActiveProfileName(git),
+        git.getConfig('user.name', 'local'),
+        git.getConfig('user.email', 'local'),
+        git.getConfig('commit.gpgsign', 'local'),
+        git.getConfig('user.signingKey', 'local'),
+        git.getConfig('gpg.format', 'local'),
+    ]);
+    return {
+        name,
+        username: username ?? undefined,
+        email: email ?? undefined,
+        signCommits: signCommits ?? undefined,
+        signingKey: signingKey ?? undefined,
+        signingMethod: signingMethod ?? undefined,
+    };
+}
+/**
+ * Find the profile for the current repo: the one named by `gitwho.profile`, otherwise the single profile whose
+ * username and email match the git config (flagged as derived).
+ *
+ * @throws {Error} If `gitwho.profile` names a missing profile and nothing else matches uniquely, if several profiles
+ * match with no active profile set, or if no profile is set and none match. A missing active profile takes priority
+ * over multiple matches, since it is the underlying cause.
+ */
+async function resolveFromGit(profiles) {
+    const gitData = await readGitConfig();
+    const profile = profiles.find((p) => p.name === gitData.name);
+    if (profile) {
+        const mismatches = buildMismatches(profile, gitData);
+        return { profile, derived: false, mismatches };
+    }
+    const matches = profiles.filter((p) => p.username === gitData.username && p.email === gitData.email);
+    if (matches.length === 1) {
+        const mismatches = buildMismatches(matches[0], gitData);
+        return { profile: matches[0], derived: true, mismatches };
+    }
+    else if (gitData.name) {
+        throw new Error(`Active profile '${gitData.name}' not found — it may have been deleted.`);
+    }
+    else if (matches.length > 1) {
+        throw new Error('Multiple profiles match the current git config — set one explicitly with `git who use <profile>`.');
+    }
+    throw new Error('No profile set and none found matching the current git config.');
+}
+async function buildStatus(resolved) {
+    let signingKeyStatus;
+    if (resolved.profile.signingMethod === SIGNING_METHOD.SSH) {
+        const keys = await listSshKeys();
+        if (resolved.profile.signingKey && !keys.includes(resolved.profile.signingKey)) {
+            signingKeyStatus = {
+                found: false,
+            };
+        }
+        else {
+            signingKeyStatus = {
+                found: true,
+            };
+        }
+    }
+    else if (resolved.profile.signingMethod === SIGNING_METHOD.GPG) {
+        const gpgKeys = await listGpgKeys(resolved.profile.signingKey);
+        if (gpgKeys.length > 0) {
+            signingKeyStatus = {
+                found: true,
+                uids: gpgKeys[0].uids,
+            };
+        }
+        else {
+            signingKeyStatus = { found: false };
+        }
+    }
+    return signingKeyStatus;
+}
+async function resolveProfile(name, profiles) {
+    if (name) {
+        const profile = profiles.find((p) => p.name === name);
+        if (!profile) {
+            throw new Error(`Profile ${name} not found.`);
+        }
+        return {
+            profile,
+            derived: false,
+        };
+    }
+    else {
+        return await resolveFromGit(profiles);
+    }
+}
+/**
+ * The result as a plain object for `--json`. The warnings that are printed as text become fields, so nothing is lost
+ * from stdout. A mismatched field git has no value for is `null`, which JSON would otherwise drop from the object.
+ */
+function toJson(resolved, signingKeyStatus) {
+    const { profile, derived, mismatches } = resolved;
+    return {
+        profile,
+        derived,
+        signingKeyStatus,
+        mismatches: mismatches && Object.fromEntries(Object.entries(mismatches).map(([field, value]) => [field, value ?? null])),
+    };
+}
+/**
+ * The extras for `printProfile`, or `undefined` when there are none, so a plain profile is printed without them.
+ */
+function displayOptions(resolved, signingKeyStatus) {
+    let opts = undefined;
+    if (resolved.mismatches && Object.keys(resolved.mismatches).length > 0) {
+        opts ||= {};
+        opts.mismatches = resolved.mismatches;
+    }
+    if (signingKeyStatus) {
+        opts ||= {};
+        opts.signingKeyStatus = signingKeyStatus;
+    }
+    return opts;
+}
+/**
+ * Print a profile, either the one given by name or the one resolved from the current repo. A profile resolved from the
+ * repo is also checked against its git config, and any signing key is looked up to confirm it exists. With `json` the
+ * result is printed as JSON instead.
+ *
+ * @throws {Error} If no name is given outside a git repo, the named profile does not exist, or no profile can be
+ * resolved from the repo. Errors from the ssh and gpg key lookups are not caught.
+ */
+export default async function show(name, options = {}) {
+    const git = simpleGit();
+    if (!name && !(await git.checkIsRepo())) {
+        throw new Error('You must provide a profile name, or invoke the show command from a git repo.');
+    }
+    const profiles = await loadProfiles();
+    const resolved = await resolveProfile(name, profiles);
+    const signingKeyStatus = await buildStatus(resolved);
+    if (options.json) {
+        log.json(toJson(resolved, signingKeyStatus));
+        return;
+    }
+    printProfile(resolved.profile, displayOptions(resolved, signingKeyStatus));
+    if (resolved.derived) {
+        log.warn(`Profile derived from git config — not explicitly set via gitwho.profile`);
+    }
+}

package/dist/src/commands/use.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import confirm from '@inquirer/confirm';
+import { makeTheme } from '@inquirer/core';
+import { simpleGit } from 'simple-git';
+import log from "../utils/log.js";
+import { selectProfile } from "../utils/prompts.js";
+import { applyProfile, loadProfiles, verifySigningKey } from "../utils/profiles.js";
+import { parseSshUrl } from "../utils/git-url.js";
+const HTTPS_URL_PATTERN = /^https?:\/\/[^/]+\/(.+)$/;
+function extractRepoPath(url) {
+    return parseSshUrl(url)?.path ?? url.match(HTTPS_URL_PATTERN)?.[1];
+}
+/**
+ * Find where the origin remote differs from the url the profile's ssh host would give it, `git@<host>:<path>`.
+ *
+ * @returns The current and expected urls, or `undefined` when there is no origin or it already matches.
+ * @throws {Error} If the origin is neither an ssh nor an http(s) url, so its repo path cannot be determined.
+ */
+async function checkOrigin(git, profile) {
+    const { value: current } = await git.getConfig('remote.origin.url', 'local');
+    if (!current) {
+        return undefined;
+    }
+    const path = extractRepoPath(current);
+    if (!path) {
+        throw new Error(`Unable to determine the repo path from origin remote '${current}'.`);
+    }
+    const expected = `git@${profile.host}:${path}`;
+    return expected === current ? undefined : { current, expected };
+}
+function confirmOriginUpdate(profile, { current, expected }) {
+    const { style } = makeTheme();
+    return confirm({
+        message: `Origin remote is ${style.highlight(current)}, but profile '${profile.name}' expects ${style.highlight(expected)}. Update origin to match?`,
+        default: true,
+    });
+}
+/**
+ * Look a profile up by name without falling back to a prompt, for output that nobody is there to answer.
+ */
+function findProfile(profiles, name) {
+    if (!name) {
+        throw new Error('A profile name is required with --json.');
+    }
+    const profile = profiles.find((p) => p.name === name);
+    if (!profile) {
+        throw new Error(`Profile ${name} not found.`);
+    }
+    return profile;
+}
+/**
+ * Apply a profile to the current repo, either the one given by name or one picked from a prompt. A mismatched origin is
+ * rewritten when `updateOrigin` is set, otherwise the user is asked, except with `json`, which never prompts: it needs
+ * a name and leaves the origin alone unless `updateOrigin` is set.
+ *
+ * @throws {Error} If the current directory is not a git repo, `json` has no name or the name is unknown, the profile's
+ * signing key is missing or cannot be looked up, the origin remote url cannot be parsed, or applying the profile fails.
+ * The signing key is checked first and its failure is thrown as is, because nothing has been written by then. A failure
+ * to apply is wrapped with its `cause`, since the git config may be left partly updated.
+ */
+export default async function use(name, options = {}) {
+    const git = simpleGit();
+    if (!await git.checkIsRepo()) {
+        throw new Error('The current directory must have a git repository to use a profile.');
+    }
+    const profiles = await loadProfiles();
+    const profile = options.json ? findProfile(profiles, name) : await selectProfile(profiles, name);
+    await verifySigningKey(profile);
+    const origin = await checkOrigin(git, profile);
+    const updateOrigin = origin !== undefined
+        && (options.updateOrigin || (!options.json && await confirmOriginUpdate(profile, origin)));
+    try {
+        await applyProfile(git, profile, updateOrigin ? origin.expected : undefined);
+    }
+    catch (error) {
+        throw new Error(`Failed to apply profile '${profile.name}'. Git config may be partly updated; re-run to retry.`, { cause: error });
+    }
+    if (options.json) {
+        log.json({ profile, originUpdated: updateOrigin, origin });
+    }
+    else {
+        log.info(`Now using profile '${chalk.bold(profile.name)}'.`);
+    }
+}

package/dist/src/profile.js

@@ -0,0 +1,33 @@
+import { validateProfileName, validateHost, validateUsername, validateEmail, validateSshSigningKey, validateGpgSigningKey, } from "./utils/validators.js";
+export const SIGNING_METHOD = { GPG: 'gpg', SSH: 'ssh' };
+const SIGNING_KEY_VALIDATORS = {
+    [SIGNING_METHOD.SSH]: validateSshSigningKey,
+    [SIGNING_METHOD.GPG]: validateGpgSigningKey,
+};
+export class Profile {
+    name;
+    host;
+    username;
+    email;
+    signingMethod;
+    signingKey;
+    constructor(name, git, signing) {
+        validateProfileName(name);
+        this.name = name;
+        validateHost(git.host);
+        this.host = git.host;
+        validateUsername(git.username);
+        this.username = git.username;
+        validateEmail(git.email);
+        this.email = git.email;
+        if (signing) {
+            const validate = SIGNING_KEY_VALIDATORS[signing.method];
+            if (!validate) {
+                throw new Error(`Invalid signing method: '${signing.method}'. Value must be one of: '${Object.values(SIGNING_METHOD).join("', '")}'.`);
+            }
+            validate(signing.key);
+            this.signingMethod = signing.method;
+            this.signingKey = signing.key;
+        }
+    }
+}

package/dist/src/utils/display.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import log from "./log.js";
+export const PROFILE_FIELDS = { USERNAME: 'username', EMAIL: 'email', SIGNING_KEY: 'signingKey', SIGNING_METHOD: 'signingMethod' };
+function formatSigningKey(keyId, uids) {
+    if (uids.length === 1) {
+        return `${keyId}, ${uids[0].name} (${uids[0].email})`;
+    }
+    return [keyId, ...uids.map((u) => `  ${u.name} (${u.email})`)].join('\n');
+}
+function buildSigningKey(signingKey, signingStatus) {
+    const keyText = signingStatus?.uids
+        ? formatSigningKey(signingKey, signingStatus.uids)
+        : signingKey;
+    return signingStatus && !signingStatus.found
+        ? chalk.yellow(`${keyText} (not found)`)
+        : keyText;
+}
+const signingText = (method) => method ? `Using ${method}` : 'No';
+const specifiedOrNot = (key) => key || 'Not Specified';
+// Appends the original value of a field when it differs from the current one.
+const wasSuffix = (oldVal, newVal, format = (value) => `${value}`, separator = ' ') => oldVal === newVal ? '' : `${separator}(was: ${format(oldVal)})`;
+export function printProfile(profile, opts) {
+    const signingStatus = opts?.signingKeyStatus;
+    const mismatches = opts?.mismatches;
+    const prev = opts?.original ?? profile; // compared with itself, so nothing is annotated without an original
+    const label = (s) => chalk.bold(s + ':');
+    const field = (key, val) => {
+        return key in (mismatches ?? {}) ? chalk.yellow(`${val} *`) : val;
+    };
+    const lines = [
+        `${label('Profile')}      ${profile.name}${wasSuffix(prev.name, profile.name)}`,
+        `${label('Host')}         ${profile.host}${wasSuffix(prev.host, profile.host)}`,
+        `${label('Name')}         ${field(PROFILE_FIELDS.USERNAME, profile.username)}${wasSuffix(prev.username, profile.username)}`,
+        `${label('Email')}        ${field(PROFILE_FIELDS.EMAIL, profile.email)}${wasSuffix(prev.email, profile.email)}`,
+        `${label('Sign Commits')} ${signingText(profile.signingMethod)}${wasSuffix(prev.signingMethod, profile.signingMethod, signingText)}`,
+    ];
+    if (profile.signingKey) {
+        const display = buildSigningKey(profile.signingKey, signingStatus);
+        lines.push(`${label('Signing Key')}  ${display}${wasSuffix(prev.signingKey, profile.signingKey, specifiedOrNot, '\n')}`);
+    }
+    log.info(lines.join('\n'));
+    if (mismatches && Object.keys(mismatches).length > 0) {
+        const parts = Object.entries(mismatches).map(([k, v]) => `${k}=${v ?? ''}`).join(', ');
+        log.warn(`Git config does not match profile '${profile.name}' (Git config values: ${parts})`);
+    }
+}

package/dist/src/utils/git-url.js

@@ -0,0 +1,9 @@
+const SCP_URL_PATTERN = /^git@([^:]+):(.+)$/;
+const SSH_URL_PATTERN = /^ssh:\/\/git@([^:/]+)(?::\d+)?\/(.+)$/;
+export function parseSshUrl(url) {
+    const match = url.match(SCP_URL_PATTERN) || url.match(SSH_URL_PATTERN);
+    if (!match) {
+        return undefined;
+    }
+    return { host: match[1], path: match[2] };
+}

package/dist/src/utils/gpg.js

@@ -0,0 +1,62 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const VALID_UID = new Set(['u', 'f', 'm', 'q', '-']);
+function parseUid(line) {
+    const validity = line.split(':')[1];
+    if (!VALID_UID.has(validity)) {
+        return null;
+    }
+    const field = line.split(':')[9];
+    const match = field.match(/<([^<>]+)>\s*$/);
+    if (!match) {
+        return null;
+    }
+    return { name: field.slice(0, match.index).trim(), email: match[1].trim() };
+}
+function processResult(stdout) {
+    const keys = [];
+    let current = undefined;
+    for (const line of stdout.split('\n')) {
+        if (line.startsWith('sec:')) {
+            if (current && current.uids.length > 0) {
+                keys.push(current);
+            }
+            current = { keyId: line.split(':')[4], uids: [] };
+        }
+        else if (line.startsWith('uid:') && current) {
+            const uid = parseUid(line);
+            if (uid) {
+                current.uids.push(uid);
+            }
+        }
+    }
+    if (current && current.uids.length > 0) {
+        keys.push(current);
+    }
+    return keys;
+}
+function matchesQuery(key, query) {
+    const q = query.toLowerCase();
+    if (key.keyId.toLowerCase() === q) {
+        return true;
+    }
+    return key.uids.some((uid) => uid.email.toLowerCase() === q);
+}
+/**
+ * List the current GPG Keys on the system that match the query.
+ */
+export async function listGpgKeys(query) {
+    const args = ['--list-secret-keys', '--with-colons', '--keyid-format=long'];
+    try {
+        const result = await execFileAsync('gpg', args, { encoding: 'utf8' });
+        const keys = processResult(result.stdout);
+        return query ? keys.filter((key) => matchesQuery(key, query)) : keys;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error('gpg is required but was not found on PATH. Please install.', { cause: error });
+        }
+        throw error;
+    }
+}

package/dist/src/utils/log.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+const log = {
+    /**
+     * Writes a red-colored message to stderr, surrounded by blank lines.
+     */
+    error(msg) {
+        console.error(`\n${chalk.red(msg)}\n`);
+    },
+    /**
+     * Writes a yellow-colored message to stderr, surrounded by blank lines.
+     */
+    warn(msg) {
+        console.error(`\n${chalk.yellow(msg)}\n`);
+    },
+    /**
+     * Writes a message to stdout, surrounded by blank lines.
+     */
+    info(msg) {
+        console.log(`\n${msg}\n`);
+    },
+    /**
+     * Writes a value to stdout as indented JSON, with no blank lines or colors so the output can be parsed as is.
+     */
+    json(value) {
+        console.log(JSON.stringify(value, null, 2));
+    },
+};
+export default log;