@bstopp/git-who 0.0.0-stage → 0.1.0

package/dist/src/utils/profiles.js

@@ -0,0 +1,231 @@
+import os from 'node:os';
+import path from 'node:path';
+import { access, constants, readFile, writeFile } from 'node:fs/promises';
+import { Profile, SIGNING_METHOD } from "../profile.js";
+import { listGpgKeys } from "./gpg.js";
+import { listSshKeys } from "./ssh.js";
+let cache;
+const CONFIG_PATH = path.join(os.homedir(), '.git-who.cfg.json');
+export class NoProfilesError extends Error {
+    constructor() {
+        super('No profiles found. Use `git who add` to create one.');
+        this.name = 'NoProfilesError';
+    }
+}
+export class SigningKeyNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SigningKeyNotFoundError';
+    }
+}
+function configParseError(cause) {
+    return new Error(`Config file could not be parsed: ${CONFIG_PATH}`, { cause });
+}
+// Two access() checks rather than a single readFile+errno inspection — keeps error
+// classification explicit and typed without inspecting platform error codes.
+// The TOCTOU window between checks is acceptable for a single-user CLI config file.
+async function readAndParseConfig() {
+    try {
+        await access(CONFIG_PATH, constants.F_OK);
+    }
+    catch {
+        throw new NoProfilesError();
+    }
+    try {
+        await access(CONFIG_PATH, constants.R_OK);
+    }
+    catch (err) {
+        throw new Error(`Config file could not be read: ${CONFIG_PATH}`, { cause: err });
+    }
+    let profiles;
+    try {
+        profiles = JSON.parse(await readFile(CONFIG_PATH, 'utf8'));
+    }
+    catch (err) {
+        throw configParseError(err);
+    }
+    if (profiles && !Array.isArray(profiles)) {
+        throw configParseError();
+    }
+    return profiles;
+}
+function invalidProfileError(index, reason, cause) {
+    const detail = reason ? `: ${reason}` : '';
+    return new Error(`Config file has an invalid profile at position ${index + 1}${detail} (${CONFIG_PATH})`, { cause });
+}
+/**
+ * Check the shape of an entry of the config file, which is unvalidated input.
+ *
+ * @throws {Error} If the entry is not an object or a field is missing or not a string.
+ */
+function checkEntryShape(raw, index) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw invalidProfileError(index, 'expected an object.');
+    }
+    const obj = raw;
+    for (const field of ['name', 'host', 'username', 'email']) {
+        if (typeof obj[field] !== 'string') {
+            throw invalidProfileError(index, `'${field}' must be a string.`);
+        }
+    }
+    if (obj.signingMethod !== undefined && typeof obj.signingMethod !== 'string') {
+        throw invalidProfileError(index, "'signingMethod' must be a string.");
+    }
+    if (obj.signingMethod !== undefined && typeof obj.signingKey !== 'string') {
+        throw invalidProfileError(index, "'signingKey' must be a string when 'signingMethod' is set.");
+    }
+    return obj;
+}
+/**
+ * Build a profile from an entry of the config file.
+ *
+ * @throws {Error} If the entry has the wrong shape, or its values fail the profile's validation. The latter is thrown
+ * with the validation error as its `cause`.
+ */
+function parseProfile(raw, index) {
+    const entry = checkEntryShape(raw, index);
+    const signing = entry.signingMethod !== undefined
+        ? { method: entry.signingMethod, key: entry.signingKey }
+        : undefined;
+    try {
+        return new Profile(entry.name, entry, signing);
+    }
+    catch (err) {
+        throw invalidProfileError(index, undefined, err);
+    }
+}
+async function saveProfiles(profiles) {
+    try {
+        await writeFile(CONFIG_PATH, JSON.stringify(profiles, null, 2), 'utf8');
+        cache = Promise.resolve(profiles);
+    }
+    catch (err) {
+        throw new Error(`Config file could not be written: ${CONFIG_PATH}`, { cause: err });
+    }
+}
+const unsetConfig = (git, key) => git.raw(['config', '--local', '--unset', key]);
+async function applySigningConfig(git, profile) {
+    if (profile.signingKey === undefined) {
+        await unsetConfig(git, 'user.signingKey');
+        await unsetConfig(git, 'commit.gpgsign');
+        await unsetConfig(git, 'gpg.format');
+        return;
+    }
+    await git.addConfig('user.signingKey', profile.signingKey, false, 'local');
+    await git.addConfig('commit.gpgsign', 'true', false, 'local');
+    if (profile.signingMethod === SIGNING_METHOD.SSH) {
+        await git.addConfig('gpg.format', 'ssh', false, 'local');
+    }
+    else {
+        await unsetConfig(git, 'gpg.format');
+    }
+}
+export async function loadProfiles() {
+    if (!cache) {
+        cache = (async () => {
+            const parsed = await readAndParseConfig() || [];
+            const profiles = parsed.map(parseProfile);
+            if (profiles.length === 0) {
+                throw new NoProfilesError();
+            }
+            return profiles;
+        })();
+    }
+    try {
+        const profiles = await cache;
+        return [...profiles];
+    }
+    catch (err) {
+        cache = undefined;
+        throw err;
+    }
+}
+export async function addProfile(profile) {
+    let profiles = [];
+    try {
+        profiles = await loadProfiles();
+    }
+    catch (err) {
+        if (!(err instanceof NoProfilesError)) {
+            throw err;
+        }
+    }
+    if (profiles.some((p) => p.name === profile.name)) {
+        throw new Error(`Profile '${profile.name}' already exists`);
+    }
+    profiles.push(profile);
+    await saveProfiles(profiles);
+}
+export async function updateProfile(original, update) {
+    const profiles = await loadProfiles();
+    const idx = profiles.findIndex((p) => p.name === original.name);
+    if (idx < 0) {
+        throw new Error(`Profile '${original.name}' not found`);
+    }
+    profiles.splice(idx, 1, update);
+    await saveProfiles(profiles);
+}
+export async function removeProfile(name) {
+    if (!name) {
+        return;
+    }
+    let profiles;
+    try {
+        profiles = await loadProfiles();
+    }
+    catch (err) {
+        if (err instanceof NoProfilesError) {
+            return;
+        }
+        throw err;
+    }
+    const idx = profiles.findIndex((p) => p.name === name);
+    if (idx >= 0) {
+        profiles.splice(idx, 1);
+        await saveProfiles(profiles);
+    }
+}
+export async function getActiveProfileName(git) {
+    if (!await git.checkIsRepo()) {
+        return undefined;
+    }
+    const { value } = await git.getConfig('gitwho.profile', 'local');
+    return value ?? undefined;
+}
+/**
+ * Check that the profile's signing key, if it has one, exists on this machine. Nothing is written, so callers run this
+ * before applying a profile and can tell a failed lookup apart from a failed apply.
+ *
+ * @throws {SigningKeyNotFoundError} If the key is not found.
+ * @throws {Error} If the keys cannot be listed, such as when `gpg` is not installed.
+ */
+export async function verifySigningKey(profile) {
+    if (profile.signingKey === undefined) {
+        return;
+    }
+    if (profile.signingMethod === SIGNING_METHOD.GPG) {
+        const keys = await listGpgKeys(profile.signingKey);
+        if (keys.length === 0) {
+            throw new SigningKeyNotFoundError(`GPG key '${profile.signingKey}' not found for profile '${profile.name}'.`);
+        }
+    }
+    else if (profile.signingMethod === SIGNING_METHOD.SSH) {
+        const sshKeys = await listSshKeys();
+        if (!sshKeys.includes(profile.signingKey)) {
+            throw new SigningKeyNotFoundError(`SSH key '${profile.signingKey}' not found for profile '${profile.name}'.`);
+        }
+    }
+}
+/**
+ * Write the profile to the repo's local git config, and set the origin remote url when one is given. The signing key
+ * is not checked here; call `verifySigningKey` first.
+ */
+export async function applyProfile(git, profile, originUrl) {
+    await git.addConfig('gitwho.profile', profile.name, false, 'local');
+    await git.addConfig('user.name', profile.username, false, 'local');
+    await git.addConfig('user.email', profile.email, false, 'local');
+    await applySigningConfig(git, profile);
+    if (originUrl) {
+        await git.remote(['set-url', 'origin', originUrl]);
+    }
+}

package/dist/src/utils/prompts.js

@@ -0,0 +1,171 @@
+import chalk from 'chalk';
+import input from '@inquirer/input';
+import select from '@inquirer/select';
+import log from "./log.js";
+import { Profile, SIGNING_METHOD } from "../profile.js";
+import { listSshHosts, listSshKeys } from "./ssh.js";
+import { listGpgKeys } from "./gpg.js";
+import { validateProfileName, validateUnique, validateUsername, validateEmail, } from "./validators.js";
+import { loadProfiles, NoProfilesError } from "./profiles.js";
+async function loadExistingProfiles() {
+    try {
+        return await loadProfiles();
+    }
+    catch (err) {
+        if (err instanceof NoProfilesError) {
+            return [];
+        }
+        throw err;
+    }
+}
+function inquirerValidate(fn) {
+    function validate(value) {
+        try {
+            fn(value);
+            return true;
+        }
+        catch (err) {
+            return err.message;
+        }
+    }
+    return validate;
+}
+async function nameInput(existing, current) {
+    return input({
+        message: 'Profile name:',
+        default: current,
+        validate: inquirerValidate((value) => {
+            validateProfileName(value);
+            if (existing && existing.length > 0 && value !== current) {
+                validateUnique(existing, value);
+            }
+        }),
+    });
+}
+async function hostInput(current) {
+    const hosts = await listSshHosts();
+    const choices = [];
+    hosts.forEach((entry) => {
+        choices.push({
+            value: entry.host,
+            name: `${entry.host} (${entry.hostname})`,
+        });
+    });
+    return select({
+        message: 'SSH Host:',
+        default: current,
+        choices,
+    });
+}
+async function signInput(current = 'ssh') {
+    const choices = [
+        { name: 'Use SSH', value: SIGNING_METHOD.SSH },
+        { name: 'Use GPG', value: SIGNING_METHOD.GPG },
+        { name: 'No', value: 'no' },
+    ];
+    return select({
+        message: 'Sign Commits?',
+        default: current,
+        choices,
+    });
+}
+async function selectUid(key) {
+    if (key.uids.length === 1) {
+        log.info(`Using identity: ${key.uids[0].name} (${key.uids[0].email})`);
+        return key.uids[0];
+    }
+    return select({
+        message: 'Select an identity:',
+        choices: key.uids.map((uid) => ({
+            name: `${uid.name} (${uid.email})`,
+            value: uid,
+        })),
+    });
+}
+async function selectGpgKey(current) {
+    const keys = await listGpgKeys();
+    if (keys.length === 0) {
+        throw new Error('No GPG keys found on this system.');
+    }
+    let key;
+    if (keys.length === 1) {
+        log.info(`Using GPG key: ${keys[0].keyId}`);
+        key = keys[0];
+    }
+    else {
+        const keyId = await select({
+            message: 'Select a GPG key:',
+            choices: keys.map((k) => ({
+                name: `${k.keyId} — ${k.uids.map((u) => `${u.name} (${u.email})`).join(', ')}`,
+                value: k.keyId,
+            })),
+            default: current,
+        });
+        key = keys.find((entry) => entry.keyId === keyId);
+    }
+    const uid = await selectUid(key);
+    return { key, uid };
+}
+async function selectSshKey(current) {
+    const keys = await listSshKeys();
+    if (keys.length === 0) {
+        throw new Error('No SSH keys found on this system.');
+    }
+    return select({
+        message: 'Select an SSH key:',
+        default: current,
+        choices: keys,
+    });
+}
+async function usernameInput(current) {
+    return input({
+        message: 'Git user.name:',
+        default: current,
+        validate: inquirerValidate(validateUsername),
+    });
+}
+async function emailInput(current) {
+    return input({
+        message: 'Git user.email:',
+        default: current,
+        validate: inquirerValidate(validateEmail),
+    });
+}
+async function promptSignCommits(editing) {
+    // A profile being edited keeps its current choice, which is 'no' when it has no signing; a new one defaults to ssh.
+    const method = await signInput(editing ? editing.signingMethod ?? 'no' : undefined);
+    let signingData;
+    let uid;
+    if (method === SIGNING_METHOD.GPG) {
+        let key;
+        ({ key, uid } = await selectGpgKey(editing?.signingKey));
+        signingData = { method, key: key.keyId };
+    }
+    else if (method === SIGNING_METHOD.SSH) {
+        const key = await selectSshKey(editing?.signingKey);
+        signingData = { method, key };
+    }
+    return { signingData, uid };
+}
+export async function promptForProfile(editing) {
+    const existing = await loadExistingProfiles();
+    const name = await nameInput(existing, editing?.name);
+    const host = await hostInput(editing?.host);
+    const { signingData, uid } = await promptSignCommits(editing);
+    const username = await usernameInput(uid?.name || editing?.username);
+    const email = await emailInput(uid?.email || editing?.email);
+    return new Profile(name, { host, username, email }, signingData);
+}
+export async function selectProfile(profiles, name) {
+    if (name) {
+        const found = profiles.find((p) => p.name === name);
+        if (found) {
+            return found;
+        }
+        log.warn(`Profile ${chalk.bold(name)} not found, please select one:`);
+    }
+    return select({
+        message: 'Select profile:',
+        choices: profiles.map((p) => ({ name: p.name, value: p })),
+    });
+}

package/dist/src/utils/ssh.js

@@ -0,0 +1,80 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import log from "./log.js";
+const execFileAsync = promisify(execFile);
+const isMissing = (err) => err.code === 'ENOENT';
+function parseSshSearch(host, stdout) {
+    const hostname = stdout.split('\n')
+        .find((line) => line.toLowerCase().startsWith('hostname'))
+        .split(' ')[1];
+    return { host, hostname };
+}
+async function readConfig() {
+    const path = join(homedir(), '.ssh', 'config');
+    return readFile(path, 'utf-8');
+}
+async function buildHostsResult(hosts) {
+    const promises = hosts.map(async (host) => {
+        return execFileAsync('ssh', ['-G', host])
+            .then((result) => {
+            return parseSshSearch(host, result.stdout);
+        })
+            .catch((err) => {
+            log.warn(`Unable to look up host '${host}': ${err.message}`);
+        });
+    });
+    return (await Promise.all(promises)).filter((v) => v !== undefined);
+}
+/**
+ * List SSH host aliases configured in ~/.ssh/config, resolved via `ssh -G`.
+ *
+ * @throws {Error} If no host aliases can be found, including when ~/.ssh/config does not exist (kept as the `cause`).
+ */
+export async function listSshHosts() {
+    let configs;
+    try {
+        configs = await readConfig();
+    }
+    catch (err) {
+        if (isMissing(err)) {
+            throw new Error('No SSH host aliases found in ~/.ssh/config.', { cause: err });
+        }
+        throw err;
+    }
+    const hosts = [];
+    for (const line of configs.split('\n')) {
+        const match = line.trim().match(/^Host\s+([^#]+).*$/i);
+        if (match) {
+            match[1].split(/\s+/).filter((s) => s).forEach((host) => {
+                if (host && !host.startsWith('!') && !host.match(/[?*]/) && !hosts.includes(host)) {
+                    hosts.push(host);
+                }
+            });
+        }
+    }
+    const results = await buildHostsResult(hosts);
+    if (results.length === 0) {
+        throw new Error('No SSH host aliases found in ~/.ssh/config.');
+    }
+    return results;
+}
+/**
+ * List SSH public key files (*.pub) found in ~/.ssh. A missing ~/.ssh has no keys, so it gives an empty list.
+ */
+export async function listSshKeys() {
+    const path = join(homedir(), '.ssh');
+    let files;
+    try {
+        files = await readdir(path);
+    }
+    catch (err) {
+        if (isMissing(err)) {
+            return [];
+        }
+        throw err;
+    }
+    return files.filter((f) => f.endsWith('.pub')).map((f) => join(path, f)).sort();
+}

package/dist/src/utils/validators.js

@@ -0,0 +1,59 @@
+const HOST_RE = /^[A-Za-z0-9_\-.]+$/;
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const GPG_SIGNING_KEY_RE = /^[A-Z0-9]+$/;
+/**
+ * @throws {Error} If value contains characters other than letters, numbers, dash, dot, or underscore.
+ */
+export function validateProfileName(value) {
+    if (!HOST_RE.test(value)) {
+        throw new Error('Profile name must contain only letters, numbers, dash, dot, or underscore.');
+    }
+}
+/**
+ * @throws {Error} If value is empty or contains characters other than letters, numbers, dash, dot, or underscore.
+ */
+export function validateHost(value) {
+    if (!HOST_RE.test(value)) {
+        throw new Error('Host must contain only letters, numbers, dash, dot, or underscore.');
+    }
+}
+/**
+ * @throws {Error} If value is empty or only whitespace.
+ */
+export function validateUsername(value) {
+    if (!value.trim()) {
+        throw new Error('Name must not be blank.');
+    }
+}
+/**
+ * @throws {Error} If value is not a valid email address.
+ */
+export function validateEmail(value) {
+    if (!EMAIL_RE.test(value)) {
+        throw new Error('Must be a valid email address.');
+    }
+}
+/**
+ * @throws {Error} If value is present but contains characters other than uppercase letters and numbers.
+ */
+export function validateGpgSigningKey(value) {
+    if (!GPG_SIGNING_KEY_RE.test(value)) {
+        throw new Error('GPG Signing key must contain only uppercase letters and numbers.');
+    }
+}
+/**
+ * @throws {Error} If value is not present.
+ */
+export function validateSshSigningKey(value) {
+    if (!value) {
+        throw new Error('SSH Signing key must be specified.');
+    }
+}
+/**
+ * @throws {Error} If value is already a key in existing.
+ */
+export function validateUnique(existing, name) {
+    if (existing.some((p) => p.name === name)) {
+        throw new Error(`Profile '${name}' already exists.`);
+    }
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@bstopp/git-who",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Manage git profiles for per-project SSH account configuration.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bstopp/git-who.git"
+  },
+  "homepage": "https://github.com/bstopp/git-who#readme",
+  "bugs": {
+    "url": "https://github.com/bstopp/git-who/issues"
+  },
+  "bin": {
+    "git-who": "dist/bin/git-who.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "lint": "eslint",
+    "test": "c8 mocha 'test/**/*.test.ts'",
+    "test:e2e": "mocha --node-option experimental-test-module-mocks 'test/e2e/**/*.e2e.ts'",
+    "typecheck": "tsc"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@inquirer/testing": "^3.3.10",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.19.2",
+    "c8": "^12.0.0",
+    "esmock": "^3.0.0",
+    "mocha": "^12.0.3",
+    "semantic-release": "^25.0.9",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0"
+  },
+  "dependencies": {
+    "@inquirer/confirm": "^6.3.5",
+    "@inquirer/core": "^12.0.6",
+    "@inquirer/input": "^5.1.2",
+    "@inquirer/select": "^5.2.1",
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
+    "simple-git": "^4.0.2"
+  }
+}