@vltpkg/git 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/clone.d.ts

@@ -0,0 +1,12 @@
+import type { GitOptions } from './index.ts';
+/**
+ * Only these whitelisted hosts get shallow cloning. Many hosts (including GHE)
+ * don't always support it. A failed shallow fetch takes a LOT longer than a
+ * full fetch in most cases, so we skip it entirely. Set opts.gitShallow =
+ * true/false to force this behavior one way or the other.
+ *
+ * If other hosts are added to this set, then they will be shallowly cloned
+ * as well.
+ */
+export declare const shallowHosts: Set<string>;
+export declare const clone: (repo: string, ref?: string, target?: string, opts?: GitOptions) => Promise<string>;

package/dist/clone.js

@@ -0,0 +1,139 @@
+// The goal here is to minimize both git workload and
+// the number of refs we download over the network.
+//
+// Every method ends up with the checked out working dir
+// at the specified ref, and resolves with the git sha.
+import { gitScpURL } from '@vltpkg/git-scp-url';
+import { mkdir, stat } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isWindows } from "./is-windows.js";
+import { resolveRef } from "./resolve.js";
+import { revs as getRevs } from "./revs.js";
+import { spawn } from "./spawn.js";
+/**
+ * Only these whitelisted hosts get shallow cloning. Many hosts (including GHE)
+ * don't always support it. A failed shallow fetch takes a LOT longer than a
+ * full fetch in most cases, so we skip it entirely. Set opts.gitShallow =
+ * true/false to force this behavior one way or the other.
+ *
+ * If other hosts are added to this set, then they will be shallowly cloned
+ * as well.
+ */
+export const shallowHosts = new Set([
+    'github.com',
+    'gist.github.com',
+    'gitlab.com',
+    'bitbucket.com',
+    'bitbucket.org',
+]);
+export const clone = async (repo, ref = 'HEAD', target, opts = {}) => {
+    repo = String(gitScpURL(repo) ?? repo).replace(/^git\+/, '');
+    if (repo.startsWith('file://'))
+        repo = fileURLToPath(repo);
+    const revs = await getRevs(repo, opts);
+    return await clone_(repo, revs, ref, revs && resolveRef(revs, ref, opts), target || defaultTarget(repo, opts.cwd), opts);
+};
+const maybeShallow = (repo, opts) => {
+    if (opts['git-shallow'] === false || opts['git-shallow']) {
+        return opts['git-shallow'];
+    }
+    const host = gitScpURL(repo)?.host ?? '';
+    return shallowHosts.has(host);
+};
+const defaultTarget = (repo, 
+/* c8 ignore next */ cwd = process.cwd()) => resolve(cwd, basename(repo.replace(/[/\\]?\.git$/, '')));
+const clone_ = (repo, revs, ref, revDoc, target, opts) => {
+    if (!revDoc || !revs) {
+        return unresolved(repo, ref, target, opts);
+    }
+    if (revDoc.sha === revs.refs.HEAD?.sha) {
+        return plain(repo, revDoc, target, opts);
+    }
+    if (revDoc.type === 'tag' || revDoc.type === 'branch') {
+        return branch(repo, revDoc, target, opts);
+    }
+    return other(repo, revDoc, target, opts);
+};
+// pull request or some other kind of advertised ref
+const other = async (repo, revDoc, target, opts) => {
+    const shallow = maybeShallow(repo, opts);
+    const fetchOrigin = ['fetch', 'origin', revDoc.rawRef].concat(shallow ? ['--depth=1'] : []);
+    const git = (args) => spawn(args, { ...opts, cwd: target });
+    await mkdir(target, { recursive: true });
+    await git(['init']);
+    if (isWindows(opts)) {
+        await git([
+            'config',
+            '--local',
+            '--add',
+            'core.longpaths',
+            'true',
+        ]);
+    }
+    await git(['remote', 'add', 'origin', repo]);
+    await git(fetchOrigin);
+    await git(['checkout', revDoc.sha]);
+    await updateSubmodules(target, opts);
+    return revDoc.sha;
+};
+// tag or branches.  use -b
+const branch = async (repo, revDoc, target, opts) => {
+    const args = [
+        'clone',
+        '-b',
+        revDoc.ref,
+        repo,
+        target,
+        '--recurse-submodules',
+    ];
+    if (maybeShallow(repo, opts)) {
+        args.push('--depth=1');
+    }
+    if (isWindows(opts)) {
+        args.push('--config', 'core.longpaths=true');
+    }
+    await spawn(args, opts);
+    return revDoc.sha;
+};
+// just the head.  clone it
+const plain = async (repo, revDoc, target, opts) => {
+    const args = ['clone', repo, target, '--recurse-submodules'];
+    if (maybeShallow(repo, opts)) {
+        args.push('--depth=1');
+    }
+    if (isWindows(opts)) {
+        args.push('--config', 'core.longpaths=true');
+    }
+    await spawn(args, opts);
+    return revDoc.sha;
+};
+const updateSubmodules = async (target, opts) => {
+    const hasSubmodules = await stat(`${target}/.gitmodules`)
+        .then(() => true)
+        .catch(() => false);
+    if (!hasSubmodules) {
+        return;
+    }
+    await spawn(['submodule', 'update', '-q', '--init', '--recursive'], { ...opts, cwd: target });
+};
+const unresolved = async (repo, ref, target, opts) => {
+    // can't do this one shallowly, because the ref isn't advertised
+    // but we can avoid checking out the working dir twice, at least
+    const lp = isWindows(opts) ? ['--config', 'core.longpaths=true'] : [];
+    const cloneArgs = [
+        'clone',
+        '--mirror',
+        '-q',
+        repo,
+        target + '/.git',
+    ];
+    const git = (args) => spawn(args, { ...opts, cwd: target });
+    await mkdir(target, { recursive: true });
+    await git(cloneArgs.concat(lp));
+    await git(['init']);
+    await git(['checkout', ref]);
+    await updateSubmodules(target, opts);
+    const result = await git(['rev-parse', '--revs-only', 'HEAD']);
+    return result.stdout;
+};

package/dist/find.d.ts

@@ -0,0 +1,5 @@
+export type FindOpts = {
+    cwd?: string;
+    root?: string;
+};
+export declare const find: ({ cwd, root, }?: FindOpts) => Promise<string | undefined>;

package/dist/find.js

@@ -0,0 +1,14 @@
+import { dirname } from 'node:path';
+import { is } from "./is.js";
+export const find = async ({ cwd = process.cwd(), root, } = {}) => {
+    while (true) {
+        if (await is({ cwd })) {
+            return cwd;
+        }
+        const next = dirname(cwd);
+        if (cwd === root || cwd === next) {
+            return undefined;
+        }
+        cwd = next;
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import type { PickManifestOptions } from '@vltpkg/pick-manifest';
+import type { Spec } from '@vltpkg/spec';
+import type { SpawnOptions } from 'node:child_process';
+import type { WrapOptions } from 'retry';
+export * from './clone.ts';
+export * from './find.ts';
+export * from './is-clean.ts';
+export * from './is.ts';
+export * from './resolve.ts';
+export * from './revs.ts';
+export * from './spawn.ts';
+export * from './user.ts';
+/**
+ * This extends all options that can be passed to spawn() or pickManifest.
+ */
+export type GitOptions = PickManifestOptions & SpawnOptions & {
+    /** the path to git binary, or 'false' to prevent all git operations */
+    git?: string | false;
+    /** the current working directory to perform git operations in */
+    cwd?: string;
+    /** Parsed git specifier to be cloned, if we have one */
+    spec?: Spec;
+    /**
+     * Set to a boolean to force cloning with/without `--depth=1`. If left
+     * undefined, then shallow cloning will only be performed on hosts known to
+     * support it.
+     */
+    'git-shallow'?: boolean;
+    /** Only relevant if `retry` is unset. Value for retry.retries, default 2 */
+    'fetch-retries'?: WrapOptions['retries'];
+    /** Only relevant if `retry` is unset. Value for retry.factor, default 10 */
+    'fetch-retry-factor'?: WrapOptions['factor'];
+    /**
+     * Only relevant if `retry` is unset. Value for retry.maxTimeout, default
+     * 60_000
+     */
+    'fetch-retry-maxtimeout'?: WrapOptions['maxTimeout'];
+    /**
+     * Only relevant if `retry` is unset. Value for retry.minTimeout, default
+     * 1_000
+     */
+    'fetch-retry-mintimeout'?: WrapOptions['minTimeout'];
+    /**
+     * Used to test platform-specific behavior.
+     * @internal
+     */
+    fakePlatform?: NodeJS.Platform;
+    /**
+     * Just to test rev lookup without continually clearing the cache
+     */
+    noGitRevCache?: boolean;
+};

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./clone.js";
+export * from "./find.js";
+export * from "./is-clean.js";
+export * from "./is.js";
+export * from "./resolve.js";
+export * from "./revs.js";
+export * from "./spawn.js";
+export * from "./user.js";

package/dist/is-clean.d.ts

@@ -0,0 +1 @@
+export declare const isClean: (opts?: {}) => Promise<boolean>;

package/dist/is-clean.js

@@ -0,0 +1,13 @@
+import { error } from '@vltpkg/error-cause';
+import { spawn } from "./spawn.js";
+export const isClean = async (opts = {}) => {
+    const result = await spawn(['status', '--porcelain=v1', '-uno'], opts);
+    if (result.status || result.signal) {
+        throw error('git isClean check failed', result);
+    }
+    for (const line of result.stdout.split(/\r?\n+/)) {
+        if (line.trim())
+            return false;
+    }
+    return true;
+};

package/dist/is-windows.d.ts

@@ -0,0 +1,2 @@
+import type { GitOptions } from './index.ts';
+export declare const isWindows: (opts: GitOptions) => boolean;

package/dist/is-windows.js

@@ -0,0 +1 @@
+export const isWindows = (opts) => (opts.fakePlatform || process.platform) === 'win32';

package/dist/is.d.ts

@@ -0,0 +1,3 @@
+export declare const is: ({ cwd }?: {
+    cwd?: string | undefined;
+}) => Promise<boolean>;

package/dist/is.js

@@ -0,0 +1,3 @@
+// not an airtight indicator, but a good gut-check to even bother trying
+import { stat } from 'node:fs/promises';
+export const is = ({ cwd = process.cwd() } = {}) => stat(cwd + '/.git').then(() => true, () => false);

package/dist/lines-to-revs.d.ts

@@ -0,0 +1,6 @@
+import type { RevDoc } from '@vltpkg/types';
+/**
+ * turn an array of lines from `git ls-remote` into a thing
+ * vaguely resembling a packument, where docs are a resolved ref
+ */
+export declare const linesToRevs: (lines: string[]) => RevDoc;

package/dist/lines-to-revs.js

@@ -0,0 +1,152 @@
+import { parse } from '@vltpkg/semver';
+import { error } from '@vltpkg/error-cause';
+/**
+ * turn an array of lines from `git ls-remote` into a thing
+ * vaguely resembling a packument, where docs are a resolved ref
+ */
+export const linesToRevs = (lines) => finish(lines.reduce(linesToRevsReducer, {
+    name: '',
+    versions: {},
+    'dist-tags': {},
+    refs: {},
+    shas: {},
+}));
+const finish = (revs) => distTags(versions(shaList(peelTags(revs))));
+const versions = (revs) => {
+    for (const [version, entry] of Object.entries(revs.versions)) {
+        entry.version = version;
+    }
+    return revs;
+};
+// We can check out shallow clones on specific SHAs if we have a ref
+const shaList = (revs) => {
+    Object.entries(revs.refs).forEach(([ref, doc]) => {
+        const shas = revs.shas[doc.sha];
+        if (!shas) {
+            revs.shas[doc.sha] = [ref];
+        }
+        else {
+            shas.push(ref);
+        }
+    });
+    return revs;
+};
+// Replace any tags with their ^{} counterparts, if those exist
+const peelTags = (revs) => {
+    Object.entries(revs.refs)
+        .filter(([ref]) => ref.endsWith('^{}'))
+        .forEach(([ref, peeled]) => {
+        const unpeeled = revs.refs[ref.replace(/\^\{\}$/, '')];
+        if (unpeeled) {
+            unpeeled.sha = peeled.sha;
+            delete revs.refs[ref];
+        }
+    });
+    return revs;
+};
+const distTags = (revs) => {
+    // not entirely sure what situations would result in an
+    // ichabod repo, but best to be careful in Sleepy Hollow anyway
+    /* c8 ignore start */
+    const HEAD = revs.refs.HEAD ?? {
+        sha: undefined,
+    };
+    /* c8 ignore stop */
+    for (const [v, ver] of Object.entries(revs.versions)) {
+        // simulate a dist-tags with latest pointing at the
+        // 'latest' branch if one exists and is a version,
+        // or HEAD if not.
+        if (ver.sha === revs.refs.latest?.sha) {
+            revs['dist-tags'].latest = v;
+        }
+        else if (ver.sha === HEAD.sha) {
+            revs['dist-tags'].HEAD = v;
+            if (!revs.refs.latest) {
+                revs['dist-tags'].latest = v;
+            }
+        }
+    }
+    return revs;
+};
+const refType = (ref) => {
+    if (ref.startsWith('refs/tags/')) {
+        return 'tag';
+    }
+    if (ref.startsWith('refs/heads/')) {
+        return 'branch';
+    }
+    if (ref.startsWith('refs/pull/')) {
+        return 'pull';
+    }
+    if (ref === 'HEAD') {
+        return 'head';
+    }
+    // Could be anything, ignore for now
+    /* c8 ignore next */
+    return 'other';
+};
+// return the doc, or null if we should ignore it.
+const lineToRevDoc = (line) => {
+    let [sha, rawRef] = line.trim().split(/\s+/, 2);
+    if (sha === undefined || rawRef === undefined)
+        return undefined;
+    sha = sha.trim();
+    rawRef = rawRef.trim();
+    const type = refType(rawRef);
+    switch (type) {
+        case 'tag': {
+            // refs/tags/foo^{} is the 'peeled tag', ie the commit
+            // that is tagged by refs/tags/foo they resolve to the same
+            // content, just different objects in git's data structure.
+            // But, we care about the thing the tag POINTS to, not the tag
+            // object itself, so we only look at the peeled tag refs, and
+            // ignore the pointer.
+            // For now, though, we have to save both, because some tags
+            // don't have peels, if they were not annotated.
+            const ref = rawRef.slice('refs/tags/'.length);
+            return { name: '', version: '', sha, ref, rawRef, type };
+        }
+        case 'branch': {
+            const ref = rawRef.slice('refs/heads/'.length);
+            return { name: '', version: '', sha, ref, rawRef, type };
+        }
+        case 'pull': {
+            // NB: merged pull requests installable with #pull/123/merge
+            // for the merged pr, or #pull/123 for the PR head
+            const ref = rawRef.slice('refs/'.length).replace(/\/head$/, '');
+            return { name: '', version: '', sha, ref, rawRef, type };
+        }
+        case 'head': {
+            const ref = 'HEAD';
+            return { name: '', version: '', sha, ref, rawRef, type };
+        }
+        default:
+            // at this point, all we can do is leave the ref un-munged
+            return { name: '', version: '', sha, ref: rawRef, rawRef, type };
+    }
+};
+const linesToRevsReducer = (revs, line) => {
+    const doc = lineToRevDoc(line);
+    if (!doc) {
+        return revs;
+    }
+    revs.refs[doc.ref] = doc;
+    revs.refs[doc.rawRef] = doc;
+    if (doc.type === 'tag') {
+        // try to pull a semver value out of tags like `release-v1.2.3`
+        // which is a pretty common pattern.
+        const match = doc.ref.endsWith('^{}') ?
+            null
+            : /v?(\d+\.\d+\.\d+(?:[-+].+)?)$/.exec(doc.ref);
+        if (match) {
+            /* c8 ignore start */
+            if (!match[1])
+                throw error(`invalid semver tag`, { found: doc.ref });
+            /* c8 ignore stop */
+            const v = parse(match[1]);
+            if (v)
+                revs.versions[String(v)] = doc;
+        }
+    }
+    return revs;
+};

package/dist/make-error.d.ts

@@ -0,0 +1,2 @@
+import type { SpawnResultStderr, SpawnResultString } from '@vltpkg/promise-spawn';
+export declare const makeError: (result: SpawnResultStderr & SpawnResultString) => [null | ((n: number) => boolean), Error];

package/dist/make-error.js

@@ -0,0 +1,20 @@
+import { error } from '@vltpkg/error-cause';
+const connectionErrorRe = new RegExp([
+    'remote error: Internal Server Error',
+    'The remote end hung up unexpectedly',
+    'Connection timed out',
+    'Operation timed out',
+    'Failed to connect to .* Timed out',
+    'Connection reset by peer',
+    'SSL_ERROR_SYSCALL',
+    'The requested URL returned error: 503',
+].join('|'));
+const missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/;
+export const makeError = (result) => connectionErrorRe.test(result.stderr) ?
+    [
+        (n) => n < 3,
+        error('A git connection error occurred', result),
+    ]
+    : missingPathspecRe.test(result.stderr) ?
+        [null, error('The git reference could not be found', result)]
+        : [null, error('An unknown git error occurred', result)];

package/dist/opts.d.ts

@@ -0,0 +1,3 @@
+import type { PromiseSpawnOptionsStderrString, PromiseSpawnOptionsStdoutString } from '@vltpkg/promise-spawn';
+import type { SpawnOptions } from 'node:child_process';
+export declare const opts: (opts?: SpawnOptions) => PromiseSpawnOptionsStderrString & PromiseSpawnOptionsStdoutString;

package/dist/opts.js

@@ -0,0 +1,14 @@
+// Values we want to set if they're not already defined by the end user
+// This defaults to accepting new ssh host key fingerprints
+const gitEnv = {
+    GIT_ASKPASS: 'echo',
+    GIT_SSH_COMMAND: 'ssh -oStrictHostKeyChecking=accept-new',
+};
+export const opts = (opts = {}) => ({
+    acceptFail: true,
+    ...opts,
+    env: opts.env ?? { ...gitEnv, ...process.env },
+    stdio: 'pipe',
+    stdioString: true,
+    shell: false,
+});

package/dist/resolve.d.ts

@@ -0,0 +1,16 @@
+import type { RevDoc } from '@vltpkg/types';
+import type { GitOptions } from './index.ts';
+/**
+ * Given a repo and either a ref or a git specifier Spec object, resolve the
+ * appropriate ref that we should clone, ideally witout actually cloning the
+ * repository.
+ *
+ *
+ */
+export declare const resolve: (repo: string, ref?: string, opts?: GitOptions) => Promise<import("@vltpkg/types").RevDocEntry | undefined>;
+/**
+ * Given a repo's RevDoc object and either a ref or a git specifier Spec
+ * object, resolve the appropriate ref that we should clone, witout actually
+ * cloning the repository.
+ */
+export declare const resolveRef: (revDoc: RevDoc, ref?: string, opts?: GitOptions) => import("@vltpkg/types").RevDocEntry | undefined;

package/dist/resolve.js

@@ -0,0 +1,41 @@
+import { pickManifest } from '@vltpkg/pick-manifest';
+import { revs } from "./revs.js";
+/**
+ * Given a repo and either a ref or a git specifier Spec object, resolve the
+ * appropriate ref that we should clone, ideally witout actually cloning the
+ * repository.
+ *
+ *
+ */
+export const resolve = async (repo, ref = 'HEAD', opts = {}) => {
+    const revDoc = await revs(repo, opts);
+    /* no resolution possible if we can't read the repo */
+    if (!revDoc)
+        return undefined;
+    return resolveRef(revDoc, ref, opts);
+};
+/**
+ * Given a repo's RevDoc object and either a ref or a git specifier Spec
+ * object, resolve the appropriate ref that we should clone, witout actually
+ * cloning the repository.
+ */
+export const resolveRef = (revDoc, ref = 'HEAD', opts = {}) => {
+    const { spec } = opts;
+    ref = spec?.gitCommittish || ref;
+    if (spec?.range) {
+        return pickManifest(revDoc, spec.range, opts);
+    }
+    if (!ref) {
+        return revDoc.refs.HEAD;
+    }
+    if (revDoc.refs[ref]) {
+        return revDoc.refs[ref];
+    }
+    /* c8 ignore start - typically found above, but just in case */
+    const sha = revDoc.shas[ref]?.[0];
+    if (sha) {
+        return revDoc.refs[sha];
+    }
+    /* c8 ignore stop */
+    return undefined;
+};

package/dist/revs.d.ts

@@ -0,0 +1,3 @@
+import type { GitOptions } from './index.ts';
+import type { RevDoc } from '@vltpkg/types';
+export declare const revs: (repo: string, opts?: GitOptions) => Promise<RevDoc | undefined>;

package/dist/revs.js

@@ -0,0 +1,30 @@
+import { gitScpURL } from '@vltpkg/git-scp-url';
+import { LRUCache } from 'lru-cache';
+import { fileURLToPath } from 'node:url';
+import { linesToRevs } from "./lines-to-revs.js";
+import { spawn } from "./spawn.js";
+const fetchMethod = async (repo, _, options) => {
+    const result = await spawn(['ls-remote', repo], options.context);
+    const revsDoc = linesToRevs(result.stdout.split('\n'));
+    return revsDoc;
+};
+const revsCache = new LRUCache({
+    max: 100,
+    ttl: 5 * 60 * 1000,
+    allowStaleOnFetchAbort: true,
+    allowStaleOnFetchRejection: true,
+    fetchMethod,
+});
+export const revs = async (repo, opts = {}) => {
+    repo = String(gitScpURL(repo) ?? repo).replace(/^git\+/, '');
+    if (repo.startsWith('file://'))
+        repo = fileURLToPath(repo);
+    if (opts.noGitRevCache) {
+        const result = await fetchMethod(repo, undefined, {
+            context: opts,
+        });
+        revsCache.set(repo, result);
+        return result;
+    }
+    return await revsCache.fetch(repo, { context: opts });
+};

package/dist/spawn.d.ts

@@ -0,0 +1,3 @@
+import type { SpawnResultStderrString, SpawnResultStdoutString } from '@vltpkg/promise-spawn';
+import type { GitOptions } from './index.ts';
+export declare const spawn: (gitArgs: string[], opts?: GitOptions) => Promise<SpawnResultStderrString & SpawnResultStdoutString>;

package/dist/spawn.js

@@ -0,0 +1,34 @@
+import { promiseSpawn } from '@vltpkg/promise-spawn';
+import promiseRetry from 'promise-retry';
+import { makeError } from "./make-error.js";
+import { opts as makeOpts } from "./opts.js";
+import { which } from "./which.js";
+export const spawn = async (gitArgs, opts = {}) => {
+    const gitPath = which(opts);
+    if (gitPath instanceof Error) {
+        throw gitPath;
+    }
+    /* c8 ignore start - undocumented option, only here for tests */
+    const args = (opts.allowReplace ||
+        gitArgs[0] === '--no-replace-objects') ?
+        gitArgs
+        : ['--no-replace-objects', ...gitArgs];
+    /* c8 ignore stop */
+    const retryOpts = {
+        retries: opts['fetch-retries'] || 3,
+        factor: opts['fetch-retry-factor'] || 2,
+        maxTimeout: opts['fetch-retry-maxtimeout'] || 60000,
+        minTimeout: opts['fetch-retry-mintimeout'] || 1000,
+    };
+    return promiseRetry(async (retryFn, num) => {
+        const result = await promiseSpawn(gitPath, args, makeOpts(opts));
+        if (result.status || result.signal) {
+            const [shouldRetry, gitError] = makeError(result);
+            if (!shouldRetry?.(num)) {
+                throw gitError;
+            }
+            retryFn(gitError);
+        }
+        return result;
+    }, retryOpts);
+};

package/dist/user.d.ts

@@ -0,0 +1,5 @@
+export type GitUser = {
+    name?: string;
+    email?: string;
+};
+export declare const getUser: (opts?: {}) => Promise<GitUser | undefined>;

package/dist/user.js

@@ -0,0 +1,38 @@
+import { spawn } from "./spawn.js";
+export const getUser = async (opts = {}) => {
+    let name = '';
+    let email = '';
+    // retrieve user.name
+    const oldFlagUserNameResult = await spawn(['config', '--get', 'user.name'], opts);
+    if (oldFlagUserNameResult.status || oldFlagUserNameResult.signal) {
+        const userNameResult = await spawn(['config', 'get', 'user.name'], opts);
+        name =
+            userNameResult.status || userNameResult.signal ?
+                ''
+                : userNameResult.stdout.trim();
+    }
+    else {
+        name = oldFlagUserNameResult.stdout.trim();
+    }
+    // retrieve user.email
+    const oldFlagUserEmailResult = await spawn(['config', '--get', 'user.email'], opts);
+    if (oldFlagUserEmailResult.status ||
+        oldFlagUserEmailResult.signal) {
+        const userEmailResult = await spawn(['config', 'get', 'user.email'], opts);
+        email =
+            userEmailResult.status || userEmailResult.signal ?
+                ''
+                : userEmailResult.stdout.trim();
+    }
+    else {
+        email = oldFlagUserEmailResult.stdout.trim();
+    }
+    // if fails to find both name & email, then return undefined
+    if (!name && !email) {
+        return undefined;
+    }
+    return {
+        name,
+        email,
+    };
+};

package/dist/which.d.ts

@@ -0,0 +1,4 @@
+import type { GitOptions } from './index.ts';
+export declare const which: (opts?: GitOptions) => string | (Error & {
+    cause: import("@vltpkg/error-cause").ErrorCauseOptions;
+});

package/dist/which.js

@@ -0,0 +1,26 @@
+import { error } from '@vltpkg/error-cause';
+import { whichSync } from '@vltpkg/which';
+let gitPath = undefined;
+export const which = (opts = {}) => {
+    if (opts.git) {
+        return opts.git;
+    }
+    let whichError = undefined;
+    if (opts.git !== false) {
+        if (!gitPath) {
+            try {
+                gitPath = whichSync('git');
+            }
+            catch (er) {
+                whichError = er;
+            }
+        }
+    }
+    if (!gitPath || opts.git === false) {
+        return error('No git binary found in $PATH', {
+            code: 'ENOGIT',
+            cause: whichError,
+        }, which);
+    }
+    return gitPath;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/git",
   "description": "a util for spawning git from npm CLI contexts",
-  "version": "1.0.0-rc.22",
+  "version": "1.0.0-rc.24",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -13,13 +13,13 @@
   },
   "dependencies": {
     "@types/promise-retry": "^1.1.6",
-    "@vltpkg/error-cause": "1.0.0-rc.22",
-    "@vltpkg/git-scp-url": "1.0.0-rc.22",
-    "@vltpkg/pick-manifest": "1.0.0-rc.22",
-    "@vltpkg/promise-spawn": "1.0.0-rc.22",
-    "@vltpkg/semver": "1.0.0-rc.22",
-    "@vltpkg/spec": "1.0.0-rc.22",
-    "@vltpkg/which": "1.0.0-rc.22",
+    "@vltpkg/error-cause": "1.0.0-rc.24",
+    "@vltpkg/git-scp-url": "1.0.0-rc.24",
+    "@vltpkg/pick-manifest": "1.0.0-rc.24",
+    "@vltpkg/promise-spawn": "1.0.0-rc.24",
+    "@vltpkg/semver": "1.0.0-rc.24",
+    "@vltpkg/spec": "1.0.0-rc.24",
+    "@vltpkg/which": "1.0.0-rc.24",
     "lru-cache": "^11.2.4",
     "promise-retry": "^2.0.1",
     "retry": "^0.13.1"
@@ -28,7 +28,7 @@
     "@eslint/js": "^9.39.1",
     "@types/node": "^22.19.2",
     "@types/retry": "^0.12.5",
-    "@vltpkg/types": "1.0.0-rc.22",
+    "@vltpkg/types": "1.0.0-rc.24",
     "eslint": "^9.39.1",
     "prettier": "^3.7.4",
     "tap": "^21.5.0",
@@ -55,13 +55,13 @@
     "extends": "../../tap-config.yaml"
   },
   "prettier": "../../.prettierrc.js",
-  "module": "./src/index.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "default": "./src/index.ts"
+        "default": "./dist/index.js"
       }
     }
   },