isomorphic-git 1.41.0 → 1.41.2

package/index.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
-var AsyncLock = _interopDefault(require('async-lock'));
 var Hash = _interopDefault(require('sha.js/sha1.js'));
+var AsyncLock = _interopDefault(require('async-lock'));
 var crc32 = _interopDefault(require('crc-32'));
 var pako = _interopDefault(require('pako'));
 var crypto$1 = require('crypto');
@@ -964,10 +964,43 @@ function compareStats(entry, stats, filemode = true, trustino = true) {
   return staleness
 }
 
-// import Lock from '../utils.js'
+// A single process-wide lock shared by everything that serializes file
+// operations (the index, refs, the shallow file, blob writes). It is keyed by
+// path, so unrelated resources never contend. Centralizing it here also means
+// there is exactly one place to reset it (see `_resetLock`).
+//
+// Created lazily (not at module load) so this module has no top-level side
+// effect and stays tree-shakeable.
+let lock;
 
-// const lm = new LockManager()
-let lock = null;
+function getLock() {
+  if (lock === undefined) lock = new AsyncLock({ maxPending: Infinity });
+  return lock
+}
+
+/**
+ * Run `callback` while holding the shared lock for `key`, then release it.
+ *
+ * @template T
+ * @param {string | string[]} key - Resource key(s) to lock (usually a filepath).
+ * @param {() => (Promise<T> | T)} callback
+ * @returns {Promise<T>}
+ */
+function acquireLock(key, callback) {
+  return getLock().acquire(key, callback)
+}
+
+/**
+ * Discard the shared lock so the next `acquireLock` starts a fresh one. Intended
+ * for test harnesses that run many independent scenarios inside one long-lived
+ * module instance: if a scenario leaves an operation stalled (e.g. a filesystem
+ * that hangs), its still-held lock would otherwise block every later scenario
+ * that touches the same path. Resetting abandons that stalled queue so the next
+ * scenario starts clean. It is a no-op for normal library use.
+ */
+function _resetLock() {
+  lock = undefined;
+}
 
 const IndexCache = Symbol('IndexCache');
 
@@ -1038,10 +1071,9 @@ class GitIndexManager {
     }
 
     const filepath = `${gitdir}/index`;
-    if (lock === null) lock = new AsyncLock({ maxPending: Infinity });
     let result;
     let unmergedPaths = [];
-    await lock.acquire(filepath, async () => {
+    await acquireLock(filepath, async () => {
       // Acquire a file lock while we're reading the index
       // to make sure other processes aren't writing to it
       // simultaneously, which could result in a corrupted index.
@@ -2031,13 +2063,6 @@ function assertWritableRef(ref) {
   }
 }
 
-let lock$1;
-
-async function acquireLock(ref, callback) {
-  if (lock$1 === undefined) lock$1 = new AsyncLock();
-  return lock$1.acquire(ref, callback)
-}
-
 /**
  * A class for managing Git references, including reading, writing, deleting, and resolving refs.
  */
@@ -8348,12 +8373,6 @@ const _TreeMap = {
   workdir: WORKDIR,
 };
 
-let lock$2;
-async function acquireLock$1(ref, callback) {
-  if (lock$2 === undefined) lock$2 = new AsyncLock();
-  return lock$2.acquire(ref, callback)
-}
-
 // make sure filepath, blob type and blob object (from loose objects) plus oid are in sync and valid
 async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
   const currentFilepath = join(dir, filepath);
@@ -8370,7 +8389,7 @@ async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
     : undefined;
   let retOid = objContent ? oid : undefined;
   if (!objContent) {
-    await acquireLock$1(currentFilepath, async () => {
+    await acquireLock(currentFilepath, async () => {
       const object = stats.isSymbolicLink()
         ? await fs.readlink(currentFilepath).then(posixifyPathBuffer)
         : await fs.read(currentFilepath);
@@ -8585,7 +8604,7 @@ async function applyTreeChanges({
   });
 
   // apply the changes to work dir
-  await acquireLock$1(gitdir, async () => {
+  await acquireLock(gitdir, async () => {
     for (const op of ops) {
       const currentFilepath = join(dir, op.filepath);
       switch (op.method) {
@@ -8974,21 +8993,76 @@ async function collect(iterable) {
   return result
 }
 
+// The `@` that ends the credentials is the last one in the authority, and the
+// scheme is matched case-insensitively: `HTTPS://user:pass@host/x` is a URL
+// like any other, and leaving the credentials in it is what `fetch` rejects.
+// The authority ends at the first `/`, `?` or `#`, so an `@` that lives in a
+// query or a fragment is left where it is.
+const CREDENTIALS = /^(https?:\/\/)([^/?#]+)@/i;
+
 function extractAuthFromUrl(url) {
   // For whatever reason, the `fetch` API does not convert credentials embedded in the URL
   // into Basic Authentication headers automatically. Instead it throws an error!
   // So we must manually parse the URL, rip out the user:password portion if it is present
   // and compute the Authorization header.
-  // Note: I tried using new URL(url) but that throws a security exception in Edge. :rolleyes:
-  let userpass = url.match(/^https?:\/\/([^/]+)@/);
+  const credentials = url.match(CREDENTIALS);
   // No credentials, return the url unmodified and an empty auth object
-  if (userpass == null) return { url, auth: {} }
-  userpass = userpass[1];
-  const [username, password] = userpass.split(':');
-  // Remove credentials from URL
-  url = url.replace(`${userpass}@`, '');
-  // Has credentials, return the fetch-safe URL and the parsed credentials
-  return { url, auth: { username, password } }
+  if (credentials == null) return { url, auth: {} }
+  // Has credentials, return the fetch-safe URL and the parsed credentials.
+  // The credentials are cut out of the original string rather than read back
+  // off the parsed URL: serializing that one would also drop an explicit
+  // `:443` and append a slash to a URL that has no path, and this return value
+  // is what the request goes out against.
+  return {
+    url: url.replace(CREDENTIALS, '$1'),
+    auth: parseUserinfo(url, credentials[2]),
+  }
+}
+
+function parseUserinfo(url, userpass) {
+  // `URL` splits the two halves the way the platform does, so the first colon
+  // separates them and any later one stays in the password. Only the split is
+  // taken from it, for the reason above.
+  const parsed = parseUrl(url);
+  // A password is absent, not empty, when no colon was written at all. `URL`
+  // reports `''` for both, and the difference is worth keeping.
+  const hasPassword = userpass.indexOf(':') !== -1;
+
+  if (parsed !== null) {
+    return {
+      username: decodeUserinfo(parsed.username),
+      password: hasPassword ? decodeUserinfo(parsed.password) : undefined,
+    }
+  }
+
+  // No `URL` to parse with, or it rejected a string the expression above
+  // accepted. Split on the first colon by hand, without the percent-decoding.
+  const separatorIndex = userpass.indexOf(':');
+  return {
+    username: hasPassword ? userpass.slice(0, separatorIndex) : userpass,
+    password: hasPassword ? userpass.slice(separatorIndex + 1) : undefined,
+  }
+}
+
+function parseUrl(url) {
+  if (typeof URL !== 'function') return null
+  try {
+    return new URL(url)
+  } catch (_) {
+    return null
+  }
+}
+
+// `URL` hands back the userinfo still percent-encoded, so `p:ss` arrives as
+// `p%3Ass` and has to be decoded before it reaches the Authorization header. A
+// lone `%` is not something the parser encodes, and it makes the decode throw,
+// so the raw value stands in whenever the decode fails.
+function decodeUserinfo(value) {
+  try {
+    return decodeURIComponent(value)
+  } catch (_) {
+    return value
+  }
 }
 
 function padHex(b, n) {
@@ -9484,8 +9558,6 @@ function parseRemoteUrl({ url }) {
   }
 }
 
-let lock$3 = null;
-
 class GitShallowManager {
   /**
    * Reads the `shallow` file in the Git repository and returns a set of object IDs (OIDs).
@@ -9496,10 +9568,9 @@ class GitShallowManager {
    * @returns {Promise<Set<string>>} - A set of shallow object IDs.
    */
   static async read({ fs, gitdir }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     const oids = new Set();
-    await lock$3.acquire(filepath, async function () {
+    await acquireLock(filepath, async function () {
       const text = await fs.read(filepath, { encoding: 'utf8' });
       if (text === null) return oids // no file
       if (text.trim() === '') return oids // empty file
@@ -9522,18 +9593,17 @@ class GitShallowManager {
    * @returns {Promise<void>}
    */
   static async write({ fs, gitdir, oids }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     if (oids.size > 0) {
       const text = [...oids].join('\n') + '\n';
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.write(filepath, text, {
           encoding: 'utf8',
         });
       });
     } else {
       // No shallows
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.rm(filepath);
       });
     }
@@ -9630,8 +9700,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.41.0',
-  agent: 'git/isomorphic-git@1.41.0',
+  version: '1.41.2',
+  agent: 'git/isomorphic-git@1.41.2',
 };
 
 class FIFO {
@@ -15988,7 +16058,7 @@ class GitStashManager {
     );
     const filepath = this.refLogsStashPath;
 
-    await acquireLock$1(filepath, async () => {
+    await acquireLock(filepath, async () => {
       const appendTo = (await this.fs.exists(filepath))
         ? await this.fs.read(filepath, 'utf8')
         : '';
@@ -16182,7 +16252,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   }
   // remove stash ref first
   const stashRefPath = stashMgr.refStashPath;
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     if (await fs.exists(stashRefPath)) {
       await fs.rm(stashRefPath);
     }
@@ -16198,7 +16268,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   reflogEntries.splice(refIdx, 1);
 
   const stashReflogPath = stashMgr.refLogsStashPath;
-  await acquireLock$1(stashReflogPath, async () => {
+  await acquireLock(stashReflogPath, async () => {
     if (reflogEntries.length) {
       await fs.write(
         stashReflogPath,
@@ -16224,7 +16294,7 @@ async function _stashClear({ fs, dir, gitdir }) {
   const stashMgr = new GitStashManager({ fs, dir, gitdir });
   const stashRefPath = [stashMgr.refStashPath, stashMgr.refLogsStashPath];
 
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     await Promise.all(
       stashRefPath.map(async path => {
         if (await fs.exists(path)) {

package/index.js

@@ -1,5 +1,5 @@
-import AsyncLock from 'async-lock';
 import Hash from 'sha.js/sha1.js';
+import AsyncLock from 'async-lock';
 import crc32 from 'crc-32';
 import pako from 'pako';
 import pify from 'pify';
@@ -957,10 +957,43 @@ function compareStats(entry, stats, filemode = true, trustino = true) {
   return staleness
 }
 
-// import Lock from '../utils.js'
+// A single process-wide lock shared by everything that serializes file
+// operations (the index, refs, the shallow file, blob writes). It is keyed by
+// path, so unrelated resources never contend. Centralizing it here also means
+// there is exactly one place to reset it (see `_resetLock`).
+//
+// Created lazily (not at module load) so this module has no top-level side
+// effect and stays tree-shakeable.
+let lock;
 
-// const lm = new LockManager()
-let lock = null;
+function getLock() {
+  if (lock === undefined) lock = new AsyncLock({ maxPending: Infinity });
+  return lock
+}
+
+/**
+ * Run `callback` while holding the shared lock for `key`, then release it.
+ *
+ * @template T
+ * @param {string | string[]} key - Resource key(s) to lock (usually a filepath).
+ * @param {() => (Promise<T> | T)} callback
+ * @returns {Promise<T>}
+ */
+function acquireLock(key, callback) {
+  return getLock().acquire(key, callback)
+}
+
+/**
+ * Discard the shared lock so the next `acquireLock` starts a fresh one. Intended
+ * for test harnesses that run many independent scenarios inside one long-lived
+ * module instance: if a scenario leaves an operation stalled (e.g. a filesystem
+ * that hangs), its still-held lock would otherwise block every later scenario
+ * that touches the same path. Resetting abandons that stalled queue so the next
+ * scenario starts clean. It is a no-op for normal library use.
+ */
+function _resetLock() {
+  lock = undefined;
+}
 
 const IndexCache = Symbol('IndexCache');
 
@@ -1031,10 +1064,9 @@ class GitIndexManager {
     }
 
     const filepath = `${gitdir}/index`;
-    if (lock === null) lock = new AsyncLock({ maxPending: Infinity });
     let result;
     let unmergedPaths = [];
-    await lock.acquire(filepath, async () => {
+    await acquireLock(filepath, async () => {
       // Acquire a file lock while we're reading the index
       // to make sure other processes aren't writing to it
       // simultaneously, which could result in a corrupted index.
@@ -2024,13 +2056,6 @@ function assertWritableRef(ref) {
   }
 }
 
-let lock$1;
-
-async function acquireLock(ref, callback) {
-  if (lock$1 === undefined) lock$1 = new AsyncLock();
-  return lock$1.acquire(ref, callback)
-}
-
 /**
  * A class for managing Git references, including reading, writing, deleting, and resolving refs.
  */
@@ -8335,12 +8360,6 @@ const _TreeMap = {
   workdir: WORKDIR,
 };
 
-let lock$2;
-async function acquireLock$1(ref, callback) {
-  if (lock$2 === undefined) lock$2 = new AsyncLock();
-  return lock$2.acquire(ref, callback)
-}
-
 // make sure filepath, blob type and blob object (from loose objects) plus oid are in sync and valid
 async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
   const currentFilepath = join(dir, filepath);
@@ -8357,7 +8376,7 @@ async function checkAndWriteBlob(fs, gitdir, dir, filepath, oid = null) {
     : undefined;
   let retOid = objContent ? oid : undefined;
   if (!objContent) {
-    await acquireLock$1(currentFilepath, async () => {
+    await acquireLock(currentFilepath, async () => {
       const object = stats.isSymbolicLink()
         ? await fs.readlink(currentFilepath).then(posixifyPathBuffer)
         : await fs.read(currentFilepath);
@@ -8572,7 +8591,7 @@ async function applyTreeChanges({
   });
 
   // apply the changes to work dir
-  await acquireLock$1(gitdir, async () => {
+  await acquireLock(gitdir, async () => {
     for (const op of ops) {
       const currentFilepath = join(dir, op.filepath);
       switch (op.method) {
@@ -8961,21 +8980,76 @@ async function collect(iterable) {
   return result
 }
 
+// The `@` that ends the credentials is the last one in the authority, and the
+// scheme is matched case-insensitively: `HTTPS://user:pass@host/x` is a URL
+// like any other, and leaving the credentials in it is what `fetch` rejects.
+// The authority ends at the first `/`, `?` or `#`, so an `@` that lives in a
+// query or a fragment is left where it is.
+const CREDENTIALS = /^(https?:\/\/)([^/?#]+)@/i;
+
 function extractAuthFromUrl(url) {
   // For whatever reason, the `fetch` API does not convert credentials embedded in the URL
   // into Basic Authentication headers automatically. Instead it throws an error!
   // So we must manually parse the URL, rip out the user:password portion if it is present
   // and compute the Authorization header.
-  // Note: I tried using new URL(url) but that throws a security exception in Edge. :rolleyes:
-  let userpass = url.match(/^https?:\/\/([^/]+)@/);
+  const credentials = url.match(CREDENTIALS);
   // No credentials, return the url unmodified and an empty auth object
-  if (userpass == null) return { url, auth: {} }
-  userpass = userpass[1];
-  const [username, password] = userpass.split(':');
-  // Remove credentials from URL
-  url = url.replace(`${userpass}@`, '');
-  // Has credentials, return the fetch-safe URL and the parsed credentials
-  return { url, auth: { username, password } }
+  if (credentials == null) return { url, auth: {} }
+  // Has credentials, return the fetch-safe URL and the parsed credentials.
+  // The credentials are cut out of the original string rather than read back
+  // off the parsed URL: serializing that one would also drop an explicit
+  // `:443` and append a slash to a URL that has no path, and this return value
+  // is what the request goes out against.
+  return {
+    url: url.replace(CREDENTIALS, '$1'),
+    auth: parseUserinfo(url, credentials[2]),
+  }
+}
+
+function parseUserinfo(url, userpass) {
+  // `URL` splits the two halves the way the platform does, so the first colon
+  // separates them and any later one stays in the password. Only the split is
+  // taken from it, for the reason above.
+  const parsed = parseUrl(url);
+  // A password is absent, not empty, when no colon was written at all. `URL`
+  // reports `''` for both, and the difference is worth keeping.
+  const hasPassword = userpass.indexOf(':') !== -1;
+
+  if (parsed !== null) {
+    return {
+      username: decodeUserinfo(parsed.username),
+      password: hasPassword ? decodeUserinfo(parsed.password) : undefined,
+    }
+  }
+
+  // No `URL` to parse with, or it rejected a string the expression above
+  // accepted. Split on the first colon by hand, without the percent-decoding.
+  const separatorIndex = userpass.indexOf(':');
+  return {
+    username: hasPassword ? userpass.slice(0, separatorIndex) : userpass,
+    password: hasPassword ? userpass.slice(separatorIndex + 1) : undefined,
+  }
+}
+
+function parseUrl(url) {
+  if (typeof URL !== 'function') return null
+  try {
+    return new URL(url)
+  } catch (_) {
+    return null
+  }
+}
+
+// `URL` hands back the userinfo still percent-encoded, so `p:ss` arrives as
+// `p%3Ass` and has to be decoded before it reaches the Authorization header. A
+// lone `%` is not something the parser encodes, and it makes the decode throw,
+// so the raw value stands in whenever the decode fails.
+function decodeUserinfo(value) {
+  try {
+    return decodeURIComponent(value)
+  } catch (_) {
+    return value
+  }
 }
 
 function padHex(b, n) {
@@ -9471,8 +9545,6 @@ function parseRemoteUrl({ url }) {
   }
 }
 
-let lock$3 = null;
-
 class GitShallowManager {
   /**
    * Reads the `shallow` file in the Git repository and returns a set of object IDs (OIDs).
@@ -9483,10 +9555,9 @@ class GitShallowManager {
    * @returns {Promise<Set<string>>} - A set of shallow object IDs.
    */
   static async read({ fs, gitdir }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     const oids = new Set();
-    await lock$3.acquire(filepath, async function () {
+    await acquireLock(filepath, async function () {
       const text = await fs.read(filepath, { encoding: 'utf8' });
       if (text === null) return oids // no file
       if (text.trim() === '') return oids // empty file
@@ -9509,18 +9580,17 @@ class GitShallowManager {
    * @returns {Promise<void>}
    */
   static async write({ fs, gitdir, oids }) {
-    if (lock$3 === null) lock$3 = new AsyncLock();
     const filepath = join(gitdir, 'shallow');
     if (oids.size > 0) {
       const text = [...oids].join('\n') + '\n';
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.write(filepath, text, {
           encoding: 'utf8',
         });
       });
     } else {
       // No shallows
-      await lock$3.acquire(filepath, async function () {
+      await acquireLock(filepath, async function () {
         await fs.rm(filepath);
       });
     }
@@ -9617,8 +9687,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.41.0',
-  agent: 'git/isomorphic-git@1.41.0',
+  version: '1.41.2',
+  agent: 'git/isomorphic-git@1.41.2',
 };
 
 class FIFO {
@@ -15975,7 +16045,7 @@ class GitStashManager {
     );
     const filepath = this.refLogsStashPath;
 
-    await acquireLock$1(filepath, async () => {
+    await acquireLock(filepath, async () => {
       const appendTo = (await this.fs.exists(filepath))
         ? await this.fs.read(filepath, 'utf8')
         : '';
@@ -16169,7 +16239,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   }
   // remove stash ref first
   const stashRefPath = stashMgr.refStashPath;
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     if (await fs.exists(stashRefPath)) {
       await fs.rm(stashRefPath);
     }
@@ -16185,7 +16255,7 @@ async function _stashDrop({ fs, dir, gitdir, refIdx = 0 }) {
   reflogEntries.splice(refIdx, 1);
 
   const stashReflogPath = stashMgr.refLogsStashPath;
-  await acquireLock$1(stashReflogPath, async () => {
+  await acquireLock(stashReflogPath, async () => {
     if (reflogEntries.length) {
       await fs.write(
         stashReflogPath,
@@ -16211,7 +16281,7 @@ async function _stashClear({ fs, dir, gitdir }) {
   const stashMgr = new GitStashManager({ fs, dir, gitdir });
   const stashRefPath = [stashMgr.refStashPath, stashMgr.refLogsStashPath];
 
-  await acquireLock$1(stashRefPath, async () => {
+  await acquireLock(stashRefPath, async () => {
     await Promise.all(
       stashRefPath.map(async path => {
         if (await fs.exists(path)) {