isomorphic-git 1.35.1 → 1.36.0

package/index.cjs

@@ -4830,6 +4830,7 @@ function isPromiseFs(fs) {
 // List of commands all filesystems are expected to provide. `rm` is not
 // included since it may not exist and must be handled as a special case
 const commands = [
+  'cp',
   'readFile',
   'writeFile',
   'mkdir',
@@ -5122,6 +5123,51 @@ function assertParameter(name, value) {
   }
 }
 
+/**
+ * discoverGitdir
+ *
+ * When processing git commands on a submodule determine
+ * the actual git directory based on the contents of the .git file.
+ *
+ * Otherwise (if sent a directory) return that directory as-is.
+ *
+ * A decision has to be made "in what layer will submodules be interpreted,
+ * and then after that, where can the code can just stay exactly the same as before."
+ * This implementation processes submodules in the front-end location of src/api/.
+ * The backend of src/commands/ isn't modified. This keeps a clear division
+ * of responsibilities and should be maintained.
+ *
+ * A consequence is that __tests__ must occasionally be informed
+ * about submodules also, since those call src/commands/ directly.
+ *
+ *
+ */
+
+async function discoverGitdir({ fsp, dotgit }) {
+  assertParameter('fsp', fsp);
+  assertParameter('dotgit', dotgit);
+
+  const dotgitStat = await fsp
+    ._stat(dotgit)
+    .catch(() => ({ isFile: () => false, isDirectory: () => false }));
+  if (dotgitStat.isDirectory()) {
+    return dotgit
+  } else if (dotgitStat.isFile()) {
+    return fsp
+      ._readFile(dotgit, 'utf8')
+      .then(contents => contents.trimRight().substr(8))
+      .then(submoduleGitdir => {
+        const gitdir = join(dirname(dotgit), submoduleGitdir);
+        return gitdir
+      })
+  } else {
+    // Neither a file nor a directory. This correlates to a "git init" scenario where it's empty.
+    // This is the expected result for normal repos, and indeterminate for submodules, but
+    // would be unusual with submodules.
+    return dotgit
+  }
+}
+
 // @ts-check
 /**
  *
@@ -5188,8 +5234,9 @@ async function abortMerge({
     const trees = [TREE({ ref: commit }), WORKDIR(), STAGE()];
     let unmergedPaths = [];
 
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     await GitIndexManager.acquire(
-      { fs, gitdir, cache },
+      { fs, gitdir: updatedGitdir, cache },
       async function (index) {
         unmergedPaths = index.unmergedPaths;
       }
@@ -5199,7 +5246,7 @@ async function abortMerge({
       fs,
       cache,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       trees,
       map: async function (path, [head, workdir, index]) {
         const staged = !(await modified(workdir, index));
@@ -5224,7 +5271,7 @@ async function abortMerge({
     });
 
     await GitIndexManager.acquire(
-      { fs, gitdir, cache },
+      { fs, gitdir: updatedGitdir, cache },
       async function (index) {
         // Reset paths in index and worktree, this can't be done in _walk because the
         // STAGE walker acquires its own index lock.
@@ -5437,20 +5484,24 @@ async function add({
     assertParameter('filepath', filepath);
 
     const fs = new FileSystem(_fs);
-    await GitIndexManager.acquire({ fs, gitdir, cache }, async index => {
-      const config = await GitConfigManager.get({ fs, gitdir });
-      const autocrlf = await config.get('core.autocrlf');
-      return addToIndex({
-        dir,
-        gitdir,
-        fs,
-        filepath,
-        index,
-        force,
-        parallel,
-        autocrlf,
-      })
-    });
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
+    await GitIndexManager.acquire(
+      { fs, gitdir: updatedGitdir, cache },
+      async index => {
+        const config = await GitConfigManager.get({ fs, gitdir: updatedGitdir });
+        const autocrlf = await config.get('core.autocrlf');
+        return addToIndex({
+          dir,
+          gitdir: updatedGitdir,
+          fs,
+          filepath,
+          index,
+          force,
+          parallel,
+          autocrlf,
+        })
+      }
+    );
   } catch (err) {
     err.caller = 'git.add';
     throw err
@@ -6209,11 +6260,12 @@ async function addNote({
     });
     if (!committer) throw new MissingNameError('committer')
 
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     return await _addNote({
-      fs: new FileSystem(fs),
+      fs,
       cache,
       onSign,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       oid,
       note,
@@ -6319,9 +6371,11 @@ async function addRemote({
     assertParameter('gitdir', gitdir);
     assertParameter('remote', remote);
     assertParameter('url', url);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _addRemote({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       remote,
       url,
       force,
@@ -6478,16 +6532,21 @@ async function annotatedTag({
       assertParameter('onSign', onSign);
     }
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
     // Fill in missing arguments with default values
-    const tagger = await normalizeAuthorObject({ fs, gitdir, author: _tagger });
+    const tagger = await normalizeAuthorObject({
+      fs,
+      gitdir: updatedGitdir,
+      author: _tagger,
+    });
     if (!tagger) throw new MissingNameError('tagger')
 
     return await _annotatedTag({
       fs,
       cache,
       onSign,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       tagger,
       message,
@@ -6601,9 +6660,11 @@ async function branch({
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _branch({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
       object,
       checkout,
@@ -7436,13 +7497,15 @@ async function checkout({
     assertParameter('gitdir', gitdir);
 
     const ref = _ref || 'HEAD';
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _checkout({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       onProgress,
       onPostCheckout,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       remote,
       ref,
       filepaths,
@@ -8191,8 +8254,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.35.1',
-  agent: 'git/isomorphic-git@1.35.1',
+  version: '1.36.0',
+  agent: 'git/isomorphic-git@1.36.0',
 };
 
 class FIFO {
@@ -9120,8 +9183,10 @@ async function clone({
     }
     assertParameter('url', url);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _clone({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       http,
       onProgress,
@@ -9131,7 +9196,7 @@ async function clone({
       onAuthFailure,
       onPostCheckout,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       url,
       corsProxy,
       ref,
@@ -9223,12 +9288,13 @@ async function commit({
       assertParameter('onSign', onSign);
     }
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
     return await _commit({
       fs,
       cache,
       onSign,
-      gitdir,
+      gitdir: updatedGitdir,
       message,
       author,
       committer,
@@ -9280,9 +9346,11 @@ async function currentBranch({
   try {
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _currentBranch({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       fullname,
       test,
     })
@@ -9356,9 +9424,11 @@ async function deleteBranch({
   try {
     assertParameter('fs', fs);
     assertParameter('ref', ref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _deleteBranch({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
     })
   } catch (err) {
@@ -9389,7 +9459,9 @@ async function deleteRef({ fs, dir, gitdir = join(dir, '.git'), ref }) {
   try {
     assertParameter('fs', fs);
     assertParameter('ref', ref);
-    await GitRefManager.deleteRef({ fs: new FileSystem(fs), gitdir, ref });
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
+    await GitRefManager.deleteRef({ fs: fsp, gitdir: updatedGitdir, ref });
   } catch (err) {
     err.caller = 'git.deleteRef';
     throw err
@@ -9439,9 +9511,11 @@ async function deleteRemote({
   try {
     assertParameter('fs', fs);
     assertParameter('remote', remote);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _deleteRemote({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       remote,
     })
   } catch (err) {
@@ -9494,9 +9568,11 @@ async function deleteTag({ fs, dir, gitdir = join(dir, '.git'), ref }) {
   try {
     assertParameter('fs', fs);
     assertParameter('ref', ref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _deleteTag({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
     })
   } catch (err) {
@@ -9600,10 +9676,12 @@ async function expandOid({
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
     assertParameter('oid', oid);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _expandOid({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
     })
   } catch (err) {
@@ -9635,9 +9713,11 @@ async function expandRef({ fs, dir, gitdir = join(dir, '.git'), ref }) {
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await GitRefManager.expand({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
     })
   } catch (err) {
@@ -10514,8 +10594,10 @@ async function fastForward({
       timezoneOffset: 0,
     };
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _pull({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       http,
       onProgress,
@@ -10524,7 +10606,7 @@ async function fastForward({
       onAuthSuccess,
       onAuthFailure,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       url,
       remote,
@@ -10633,8 +10715,10 @@ async function fetch({
     assertParameter('http', http);
     assertParameter('gitdir', gitdir);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _fetch({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       http,
       onProgress,
@@ -10642,7 +10726,7 @@ async function fetch({
       onAuth,
       onAuthSuccess,
       onAuthFailure,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       remote,
       remoteRef,
@@ -10689,10 +10773,12 @@ async function findMergeBase({
     assertParameter('gitdir', gitdir);
     assertParameter('oids', oids);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _findMergeBase({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oids,
     })
   } catch (err) {
@@ -10793,9 +10879,11 @@ async function getConfig({ fs, dir, gitdir = join(dir, '.git'), path }) {
     assertParameter('gitdir', gitdir);
     assertParameter('path', path);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _getConfig({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       path,
     })
   } catch (err) {
@@ -10849,9 +10937,11 @@ async function getConfigAll({
     assertParameter('gitdir', gitdir);
     assertParameter('path', path);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _getConfigAll({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       path,
     })
   } catch (err) {
@@ -11270,12 +11360,14 @@ async function indexPack({
     assertParameter('gitdir', dir);
     assertParameter('filepath', filepath);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _indexPack({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       onProgress,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       filepath,
     })
   } catch (err) {
@@ -11316,11 +11408,13 @@ async function init({
       assertParameter('dir', dir);
     }
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _init({
-      fs: new FileSystem(fs),
+      fs: fsp,
       bare,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       defaultBranch,
     })
   } catch (err) {
@@ -11439,10 +11533,12 @@ async function isDescendent({
     assertParameter('oid', oid);
     assertParameter('ancestor', ancestor);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _isDescendent({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
       ancestor,
       depth,
@@ -11482,10 +11578,12 @@ async function isIgnored({
     assertParameter('gitdir', gitdir);
     assertParameter('filepath', filepath);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return GitIgnoreManager.isIgnored({
-      fs: new FileSystem(fs),
+      fs: fsp,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       filepath,
     })
   } catch (err) {
@@ -11533,9 +11631,11 @@ async function listBranches({
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return GitRefManager.listBranches({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       remote,
     })
   } catch (err) {
@@ -11641,10 +11741,12 @@ async function listFiles({
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _listFiles({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
     })
   } catch (err) {
@@ -11721,10 +11823,12 @@ async function listNotes({
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _listNotes({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
     })
   } catch (err) {
@@ -11760,7 +11864,9 @@ async function listRefs({
   try {
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
-    return GitRefManager.listRefs({ fs: new FileSystem(fs), gitdir, filepath })
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
+    return GitRefManager.listRefs({ fs: fsp, gitdir: updatedGitdir, filepath })
   } catch (err) {
     err.caller = 'git.listRefs';
     throw err
@@ -11810,9 +11916,11 @@ async function listRemotes({ fs, dir, gitdir = join(dir, '.git') }) {
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _listRemotes({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
     })
   } catch (err) {
     err.caller = 'git.listRemotes';
@@ -12053,7 +12161,9 @@ async function listTags({ fs, dir, gitdir = join(dir, '.git') }) {
   try {
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
-    return GitRefManager.listTags({ fs: new FileSystem(fs), gitdir })
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
+    return GitRefManager.listTags({ fs: fsp, gitdir: updatedGitdir })
   } catch (err) {
     err.caller = 'git.listTags';
     throw err
@@ -12348,10 +12458,12 @@ async function log({
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _log({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       filepath,
       ref,
       depth,
@@ -12505,15 +12617,20 @@ async function merge({
       assertParameter('onSign', onSign);
     }
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
-    const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
+    const author = await normalizeAuthorObject({
+      fs,
+      gitdir: updatedGitdir,
+      author: _author,
+    });
     if (!author && (!fastForwardOnly || !fastForward)) {
       throw new MissingNameError('author')
     }
 
     const committer = await normalizeCommitterObject({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       author,
       committer: _committer,
     });
@@ -12525,7 +12642,7 @@ async function merge({
       fs,
       cache,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       ours,
       theirs,
       fastForward,
@@ -12702,10 +12819,12 @@ async function packObjects({
     assertParameter('gitdir', gitdir);
     assertParameter('oids', oids);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _packObjects({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oids,
       write,
     })
@@ -12798,13 +12917,18 @@ async function pull({
     assertParameter('gitdir', gitdir);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
-    const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
+    const author = await normalizeAuthorObject({
+      fs,
+      gitdir: updatedGitdir,
+      author: _author,
+    });
     if (!author) throw new MissingNameError('author')
 
     const committer = await normalizeCommitterObject({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       author,
       committer: _committer,
     });
@@ -12820,7 +12944,7 @@ async function pull({
       onAuthSuccess,
       onAuthFailure,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       url,
       remote,
@@ -13382,8 +13506,10 @@ async function push({
     assertParameter('http', http);
     assertParameter('gitdir', gitdir);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _push({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       http,
       onProgress,
@@ -13392,7 +13518,7 @@ async function push({
       onAuthSuccess,
       onAuthFailure,
       onPrePush,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       remoteRef,
       remote,
@@ -13511,10 +13637,12 @@ async function readBlob({
     assertParameter('gitdir', gitdir);
     assertParameter('oid', oid);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _readBlob({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
       filepath,
     })
@@ -13560,10 +13688,12 @@ async function readCommit({
     assertParameter('gitdir', gitdir);
     assertParameter('oid', oid);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _readCommit({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
     })
   } catch (err) {
@@ -13636,10 +13766,12 @@ async function readNote({
     assertParameter('ref', ref);
     assertParameter('oid', oid);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _readNote({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       oid,
     })
@@ -13855,11 +13987,12 @@ async function readObject({
     assertParameter('oid', oid);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     if (filepath !== undefined) {
       oid = await resolveFilepath({
         fs,
         cache,
-        gitdir,
+        gitdir: updatedGitdir,
         oid,
         filepath,
       });
@@ -13869,7 +14002,7 @@ async function readObject({
     const result = await _readObject({
       fs,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
       format: _format,
     });
@@ -13988,10 +14121,12 @@ async function readTag({
     assertParameter('gitdir', gitdir);
     assertParameter('oid', oid);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _readTag({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
     })
   } catch (err) {
@@ -14039,10 +14174,12 @@ async function readTree({
     assertParameter('gitdir', gitdir);
     assertParameter('oid', oid);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _readTree({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       oid,
       filepath,
     })
@@ -14085,8 +14222,10 @@ async function remove({
     assertParameter('gitdir', gitdir);
     assertParameter('filepath', filepath);
 
+    const fsp = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     await GitIndexManager.acquire(
-      { fs: new FileSystem(_fs), gitdir, cache },
+      { fs: fsp, gitdir: updatedGitdir, cache },
       async function (index) {
         index.delete({ filepath });
       }
@@ -14227,13 +14366,18 @@ async function removeNote({
     assertParameter('oid', oid);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
-    const author = await normalizeAuthorObject({ fs, gitdir, author: _author });
+    const author = await normalizeAuthorObject({
+      fs,
+      gitdir: updatedGitdir,
+      author: _author,
+    });
     if (!author) throw new MissingNameError('author')
 
     const committer = await normalizeCommitterObject({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       author,
       committer: _committer,
     });
@@ -14243,7 +14387,7 @@ async function removeNote({
       fs,
       cache,
       onSign,
-      gitdir,
+      gitdir: updatedGitdir,
       ref,
       oid,
       author,
@@ -14355,9 +14499,11 @@ async function renameBranch({
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
     assertParameter('oldref', oldref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _renameBranch({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
       oldref,
       checkout,
@@ -14408,13 +14554,18 @@ async function resetIndex({
     assertParameter('filepath', filepath);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
     let oid;
     let workdirOid;
 
     try {
       // Resolve commit
-      oid = await GitRefManager.resolve({ fs, gitdir, ref: ref || 'HEAD' });
+      oid = await GitRefManager.resolve({
+        fs,
+        gitdir: updatedGitdir,
+        ref: ref || 'HEAD',
+      });
     } catch (e) {
       if (ref) {
         // Only throw the error if a ref is explicitly provided
@@ -14430,7 +14581,7 @@ async function resetIndex({
         oid = await resolveFilepath({
           fs,
           cache,
-          gitdir,
+          gitdir: updatedGitdir,
           oid,
           filepath,
         });
@@ -14456,7 +14607,7 @@ async function resetIndex({
     if (object) {
       // ... and has the same hash as the desired state...
       workdirOid = await hashObject$1({
-        gitdir,
+        gitdir: updatedGitdir,
         type: 'blob',
         object,
       });
@@ -14466,7 +14617,7 @@ async function resetIndex({
       }
     }
     await GitIndexManager.acquire(
-      { fs, gitdir, cache },
+      { fs, gitdir: updatedGitdir, cache },
       async function (index) {
         index.delete({ filepath });
         if (oid) {
@@ -14512,10 +14663,12 @@ async function resolveRef({
     assertParameter('fs', fs);
     assertParameter('gitdir', gitdir);
     assertParameter('ref', ref);
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
 
     const oid = await GitRefManager.resolve({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       ref,
       depth,
     });
@@ -14585,13 +14738,14 @@ async function setConfig({
     // assertParameter('value', value) // We actually allow 'undefined' as a value to unset/delete
 
     const fs = new FileSystem(_fs);
-    const config = await GitConfigManager.get({ fs, gitdir });
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
+    const config = await GitConfigManager.get({ fs, gitdir: updatedGitdir });
     if (append) {
       await config.append(path, value);
     } else {
       await config.set(path, value);
     }
-    await GitConfigManager.save({ fs, gitdir, config });
+    await GitConfigManager.save({ fs, gitdir: updatedGitdir, config });
   } catch (err) {
     err.caller = 'git.setConfig';
     throw err
@@ -15460,9 +15614,10 @@ async function stash({
 
   try {
     const _fs = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp: _fs, dotgit: gitdir });
     const folders = ['refs', 'logs', 'logs/refs'];
     folders
-      .map(f => join(gitdir, f))
+      .map(f => join(updatedGitdir, f))
       .forEach(async folder => {
         if (!(await _fs.exists(folder))) {
           await _fs.mkdir(folder);
@@ -15477,7 +15632,13 @@ async function stash({
           'number that is in range of [0, num of stash pushed]'
         )
       }
-      return await opFunc({ fs: _fs, dir, gitdir, message, refIdx })
+      return await opFunc({
+        fs: _fs,
+        dir,
+        gitdir: updatedGitdir,
+        message,
+        refIdx,
+      })
     }
     throw new Error(`To be implemented: ${op}`)
   } catch (err) {
@@ -15536,25 +15697,26 @@ async function status({
     assertParameter('filepath', filepath);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     const ignored = await GitIgnoreManager.isIgnored({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       dir,
       filepath,
     });
     if (ignored) {
       return 'ignored'
     }
-    const headTree = await getHeadTree({ fs, cache, gitdir });
+    const headTree = await getHeadTree({ fs, cache, gitdir: updatedGitdir });
     const treeOid = await getOidAtPath({
       fs,
       cache,
-      gitdir,
+      gitdir: updatedGitdir,
       tree: headTree,
       path: filepath,
     });
     const indexEntry = await GitIndexManager.acquire(
-      { fs, gitdir, cache },
+      { fs, gitdir: updatedGitdir, cache },
       async function (index) {
         for (const entry of index) {
           if (entry.path === filepath) return entry
@@ -15574,7 +15736,7 @@ async function status({
       } else {
         const object = await fs.read(join(dir, filepath));
         const workdirOid = await hashObject$1({
-          gitdir,
+          gitdir: updatedGitdir,
           type: 'blob',
           object,
         });
@@ -15586,7 +15748,7 @@ async function status({
           if (stats.size !== -1) {
             // We don't await this so we can return faster for one-off cases.
             GitIndexManager.acquire(
-              { fs, gitdir, cache },
+              { fs, gitdir: updatedGitdir, cache },
               async function (index) {
                 index.insert({ filepath, stats, oid: workdirOid });
               }
@@ -15646,7 +15808,7 @@ async function status({
   }
 }
 
-async function getOidAtPath({ fs, cache, gitdir, tree, path }) {
+async function getOidAtPath({ fs, cache, gitdir: updatedGitdir, tree, path }) {
   if (typeof path === 'string') path = path.split('/');
   const dirname = path.shift();
   for (const entry of tree) {
@@ -15657,12 +15819,12 @@ async function getOidAtPath({ fs, cache, gitdir, tree, path }) {
       const { type, object } = await _readObject({
         fs,
         cache,
-        gitdir,
+        gitdir: updatedGitdir,
         oid: entry.oid,
       });
       if (type === 'tree') {
         const tree = GitTree.from(object);
-        return getOidAtPath({ fs, cache, gitdir, tree, path })
+        return getOidAtPath({ fs, cache, gitdir: updatedGitdir, tree, path })
       }
       if (type === 'blob') {
         throw new ObjectTypeError(entry.oid, type, 'blob', path.join('/'))
@@ -15672,18 +15834,22 @@ async function getOidAtPath({ fs, cache, gitdir, tree, path }) {
   return null
 }
 
-async function getHeadTree({ fs, cache, gitdir }) {
+async function getHeadTree({ fs, cache, gitdir: updatedGitdir }) {
   // Get the tree from the HEAD commit.
   let oid;
   try {
-    oid = await GitRefManager.resolve({ fs, gitdir, ref: 'HEAD' });
+    oid = await GitRefManager.resolve({
+      fs,
+      gitdir: updatedGitdir,
+      ref: 'HEAD',
+    });
   } catch (e) {
     // Handle fresh branches with no commits
     if (e instanceof NotFoundError) {
       return []
     }
   }
-  const { tree } = await _readTree({ fs, cache, gitdir, oid });
+  const { tree } = await _readTree({ fs, cache, gitdir: updatedGitdir, oid });
   return tree
 }
 
@@ -15848,11 +16014,12 @@ async function statusMatrix({
     assertParameter('ref', ref);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     return await _walk({
       fs,
       cache,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       trees: [TREE({ ref }), WORKDIR(), STAGE()],
       map: async function (filepath, [head, workdir, stage]) {
         // Ignore ignored files, but only if they are not already tracked.
@@ -15964,17 +16131,21 @@ async function tag({
     ref = ref.startsWith('refs/tags/') ? ref : `refs/tags/${ref}`;
 
     // Resolve passed object
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     const value = await GitRefManager.resolve({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       ref: object || 'HEAD',
     });
 
-    if (!force && (await GitRefManager.exists({ fs, gitdir, ref }))) {
+    if (
+      !force &&
+      (await GitRefManager.exists({ fs, gitdir: updatedGitdir, ref }))
+    ) {
       throw new AlreadyExistsError('tag', ref)
     }
 
-    await GitRefManager.writeRef({ fs, gitdir, ref, value });
+    await GitRefManager.writeRef({ fs, gitdir: updatedGitdir, ref, value });
   } catch (err) {
     err.caller = 'git.tag';
     throw err
@@ -16042,10 +16213,11 @@ async function updateIndex$1({
     assertParameter('filepath', filepath);
 
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
 
     if (remove) {
       return await GitIndexManager.acquire(
-        { fs, gitdir, cache },
+        { fs, gitdir: updatedGitdir, cache },
         async function (index) {
           if (!force) {
             // Check if the file is still present in the working directory
@@ -16090,7 +16262,7 @@ async function updateIndex$1({
     }
 
     return await GitIndexManager.acquire(
-      { fs, gitdir, cache },
+      { fs, gitdir: updatedGitdir, cache },
       async function (index) {
         if (!add && !index.has({ filepath })) {
           // If the index does not contain the filepath yet and `add` is not set, we should throw
@@ -16110,7 +16282,7 @@ async function updateIndex$1({
 
           oid = await _writeObject({
             fs,
-            gitdir,
+            gitdir: updatedGitdir,
             type: 'blob',
             format: 'content',
             object,
@@ -16429,11 +16601,13 @@ async function walk({
     assertParameter('gitdir', gitdir);
     assertParameter('trees', trees);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _walk({
-      fs: new FileSystem(fs),
+      fs: fsp,
       cache,
       dir,
-      gitdir,
+      gitdir: updatedGitdir,
       trees,
       map,
       reduce,
@@ -16475,9 +16649,11 @@ async function writeBlob({ fs, dir, gitdir = join(dir, '.git'), blob }) {
     assertParameter('gitdir', gitdir);
     assertParameter('blob', blob);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _writeObject({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       type: 'blob',
       object: blob,
       format: 'content',
@@ -16514,9 +16690,11 @@ async function writeCommit({
     assertParameter('gitdir', gitdir);
     assertParameter('commit', commit);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _writeCommit({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       commit,
     })
   } catch (err) {
@@ -16604,6 +16782,7 @@ async function writeObject({
 }) {
   try {
     const fs = new FileSystem(_fs);
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
     // Convert object to buffer
     if (format === 'parsed') {
       switch (type) {
@@ -16627,7 +16806,7 @@ async function writeObject({
     }
     oid = await _writeObject({
       fs,
-      gitdir,
+      gitdir: updatedGitdir,
       type,
       object,
       oid,
@@ -16695,26 +16874,30 @@ async function writeRef({
       throw new InvalidRefNameError(ref, cleanGitRef.clean(ref))
     }
 
-    if (!force && (await GitRefManager.exists({ fs, gitdir, ref }))) {
+    const updatedGitdir = await discoverGitdir({ fsp: fs, dotgit: gitdir });
+    if (
+      !force &&
+      (await GitRefManager.exists({ fs, gitdir: updatedGitdir, ref }))
+    ) {
       throw new AlreadyExistsError('ref', ref)
     }
 
     if (symbolic) {
       await GitRefManager.writeSymbolicRef({
         fs,
-        gitdir,
+        gitdir: updatedGitdir,
         ref,
         value,
       });
     } else {
       value = await GitRefManager.resolve({
         fs,
-        gitdir,
+        gitdir: updatedGitdir,
         ref: value,
       });
       await GitRefManager.writeRef({
         fs,
-        gitdir,
+        gitdir: updatedGitdir,
         ref,
         value,
       });
@@ -16793,9 +16976,11 @@ async function writeTag({ fs, dir, gitdir = join(dir, '.git'), tag }) {
     assertParameter('gitdir', gitdir);
     assertParameter('tag', tag);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _writeTag({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       tag,
     })
   } catch (err) {
@@ -16826,9 +17011,11 @@ async function writeTree({ fs, dir, gitdir = join(dir, '.git'), tree }) {
     assertParameter('gitdir', gitdir);
     assertParameter('tree', tree);
 
+    const fsp = new FileSystem(fs);
+    const updatedGitdir = await discoverGitdir({ fsp, dotgit: gitdir });
     return await _writeTree({
-      fs: new FileSystem(fs),
-      gitdir,
+      fs: fsp,
+      gitdir: updatedGitdir,
       tree,
     })
   } catch (err) {