isomorphic-git 1.40.7 → 1.41.0

package/http/node/index.cjs

@@ -28,6 +28,7 @@ var get = _interopDefault(require('simple-get'));
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -94,6 +95,7 @@ async function forAwait(iterable, cb) {
 }
 
 function asyncIteratorToStream(iter) {
+  // @ts-expect-error: readable-stream has PassThrough at runtime, types mismatch
   const { PassThrough } = require('readable-stream');
   const stream = new PassThrough();
   setTimeout(async () => {
@@ -194,10 +196,12 @@ async function request({
   method = 'GET',
   headers = {},
   agent,
+  fetchOptions = {},
   body,
 }) {
   // If we can, we should send it as a single buffer so it sets a Content-Length header.
   if (body && Array.isArray(body)) {
+    // @ts-expect-error
     body = Buffer.from(await collect(body));
   } else if (body) {
     body = asyncIteratorToStream(body);
@@ -205,6 +209,7 @@ async function request({
   return new Promise((resolve, reject) => {
     get(
       {
+        ...fetchOptions,
         url,
         method,
         headers,

package/http/node/index.d.cts

@@ -37,6 +37,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -79,4 +83,4 @@ declare namespace index {
  * @param {GitHttpRequest} request
  * @returns {Promise<GitHttpResponse>}
  */
-export function request({ onProgress, url, method, headers, agent, body, }: GitHttpRequest): Promise<GitHttpResponse>;
+export function request({ onProgress, url, method, headers, agent, fetchOptions, body, }: GitHttpRequest): Promise<GitHttpResponse>;

package/http/node/index.d.ts

@@ -36,6 +36,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -78,4 +82,4 @@ declare namespace index {
  * @param {GitHttpRequest} request
  * @returns {Promise<GitHttpResponse>}
  */
-export function request({ onProgress, url, method, headers, agent, body, }: GitHttpRequest): Promise<GitHttpResponse>;
+export function request({ onProgress, url, method, headers, agent, fetchOptions, body, }: GitHttpRequest): Promise<GitHttpResponse>;

package/http/node/index.js

@@ -22,6 +22,7 @@ import get from 'simple-get';
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -88,6 +89,7 @@ async function forAwait(iterable, cb) {
 }
 
 function asyncIteratorToStream(iter) {
+  // @ts-expect-error: readable-stream has PassThrough at runtime, types mismatch
   const { PassThrough } = require('readable-stream');
   const stream = new PassThrough();
   setTimeout(async () => {
@@ -188,10 +190,12 @@ async function request({
   method = 'GET',
   headers = {},
   agent,
+  fetchOptions = {},
   body,
 }) {
   // If we can, we should send it as a single buffer so it sets a Content-Length header.
   if (body && Array.isArray(body)) {
+    // @ts-expect-error
     body = Buffer.from(await collect(body));
   } else if (body) {
     body = asyncIteratorToStream(body);
@@ -199,6 +203,7 @@ async function request({
   return new Promise((resolve, reject) => {
     get(
       {
+        ...fetchOptions,
         url,
         method,
         headers,

package/http/web/index.cjs

@@ -24,6 +24,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -139,24 +140,29 @@ async function request({
   url,
   method = 'GET',
   headers = {},
+  fetchOptions = {},
   body,
 }) {
   // streaming uploads aren't possible yet in the browser
   if (body) {
+    // @ts-expect-error
     body = await collect(body);
   }
-  const res = await fetch(url, { method, headers, body });
+  const res = await fetch(url, { ...fetchOptions, method, headers, body });
   const iter =
+    // @ts-expect-error
     res.body && res.body.getReader
       ? fromStream(res.body)
       : [new Uint8Array(await res.arrayBuffer())];
   // convert Header object to ordinary JSON
   headers = {};
+  // @ts-expect-error
   for (const [key, value] of res.headers.entries()) {
     headers[key] = value;
   }
   return {
     url: res.url,
+    // @ts-expect-error
     method: res.method,
     statusCode: res.status,
     statusMessage: res.statusText,

package/http/web/index.d.cts

@@ -37,6 +37,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -79,4 +83,4 @@ declare namespace index {
  * @param {GitHttpRequest} request
  * @returns {Promise<GitHttpResponse>}
  */
-export function request({ onProgress, url, method, headers, body, }: GitHttpRequest): Promise<GitHttpResponse>;
+export function request({ onProgress, url, method, headers, fetchOptions, body, }: GitHttpRequest): Promise<GitHttpResponse>;

package/http/web/index.d.ts

@@ -36,6 +36,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -78,4 +82,4 @@ declare namespace index {
  * @param {GitHttpRequest} request
  * @returns {Promise<GitHttpResponse>}
  */
-export function request({ onProgress, url, method, headers, body, }: GitHttpRequest): Promise<GitHttpResponse>;
+export function request({ onProgress, url, method, headers, fetchOptions, body, }: GitHttpRequest): Promise<GitHttpResponse>;

package/http/web/index.js

@@ -20,6 +20,7 @@
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -135,24 +136,29 @@ async function request({
   url,
   method = 'GET',
   headers = {},
+  fetchOptions = {},
   body,
 }) {
   // streaming uploads aren't possible yet in the browser
   if (body) {
+    // @ts-expect-error
     body = await collect(body);
   }
-  const res = await fetch(url, { method, headers, body });
+  const res = await fetch(url, { ...fetchOptions, method, headers, body });
   const iter =
+    // @ts-expect-error
     res.body && res.body.getReader
       ? fromStream(res.body)
       : [new Uint8Array(await res.arrayBuffer())];
   // convert Header object to ordinary JSON
   headers = {};
+  // @ts-expect-error
   for (const [key, value] of res.headers.entries()) {
     headers[key] = value;
   }
   return {
     url: res.url,
+    // @ts-expect-error
     method: res.method,
     statusCode: res.status,
     statusMessage: res.statusText,

package/http/web/index.umd.js

@@ -26,6 +26,7 @@
    * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
    * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
    * @property {object} [signal] - Reserved for future use (canceling a request)
+   * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
    */
 
   /**
@@ -141,24 +142,29 @@
     url,
     method = 'GET',
     headers = {},
+    fetchOptions = {},
     body,
   }) {
     // streaming uploads aren't possible yet in the browser
     if (body) {
+      // @ts-expect-error
       body = await collect(body);
     }
-    const res = await fetch(url, { method, headers, body });
+    const res = await fetch(url, { ...fetchOptions, method, headers, body });
     const iter =
+      // @ts-expect-error
       res.body && res.body.getReader
         ? fromStream(res.body)
         : [new Uint8Array(await res.arrayBuffer())];
     // convert Header object to ordinary JSON
     headers = {};
+    // @ts-expect-error
     for (const [key, value] of res.headers.entries()) {
       headers[key] = value;
     }
     return {
       url: res.url,
+      // @ts-expect-error
       method: res.method,
       statusCode: res.status,
       statusMessage: res.statusText,

package/index.cjs

@@ -36,6 +36,7 @@ var diff3Merge = _interopDefault(require('diff3'));
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -5021,6 +5022,67 @@ async function _walk({
   return walk(root)
 }
 
+/**
+ * Recursively creates the directory at `filepath`, creating any missing parent
+ * directories along the way. This is a portable replacement for
+ * `fs.mkdir(path, { recursive: true })`: recursive `mkdir` is NOT part of
+ * isomorphic-git's required `fs` contract (see docs/fs.md — `mkdir` is only
+ * `mkdir(path[, mode])`) and is unimplemented by some backends such as
+ * lightning-fs, so we build it here on top of a single-level `mkdir(path)`
+ * primitive only — mirroring how `rmRecursive` provides `rm({ recursive: true })`.
+ *
+ * It takes the raw single-level `mkdir` *function* (typically `fs._mkdir`)
+ * rather than the FileSystem wrapper, to stay decoupled from that type.
+ *
+ * `EEXIST` is treated as success, so two callers concurrently creating the same
+ * directory (e.g. several reflog writes into `.git/logs/refs/*` during a stash)
+ * don't fail each other. On backends whose layers are only eventually
+ * consistent — e.g. an async copy-on-write overlay — a just-created parent may
+ * not yet be visible when its child is created, so `mkdir` can throw a
+ * transient `ENOENT`; those are retried a bounded number of times rather than
+ * surfaced as a spurious failure.
+ *
+ * @param {(filepath: string) => Promise<unknown>} mkdir - Creates a single directory (non-recursive).
+ * @param {string} filepath - The directory to create.
+ * @param {number} [retries=10] - Max transient-ENOENT retries after the parent exists.
+ * @returns {Promise<void>}
+ */
+async function mkdirp(mkdir, filepath, retries = 10) {
+  try {
+    await mkdir(filepath);
+  } catch (err) {
+    // Some fs implementations signal success by yielding a null error.
+    if (err === null) return
+    // The directory already exists — that's fine.
+    if (err.code === 'EEXIST') return
+    // Anything other than a missing parent is a real error.
+    if (err.code !== 'ENOENT') throw err
+    const parent = dirname(filepath);
+    // Stop if we've walked past the filesystem root.
+    if (parent === '.' || parent === '/' || parent === filepath) throw err
+    // Create the missing parent(s) first, honoring the same retry budget.
+    await mkdirp(mkdir, parent, retries);
+    // Then (re)create this directory. On an eventually-consistent backend the
+    // parent may not be visible immediately after its mkdir resolves, so a
+    // repeated ENOENT here is transient — retry a bounded number of times,
+    // yielding between attempts so the pending write can settle.
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await mkdir(filepath);
+        return
+      } catch (err2) {
+        if (err2 === null || err2.code === 'EEXIST') return
+        if (err2.code === 'ENOENT' && attempt < retries) {
+          // Give the backend a turn of the event loop to become consistent.
+          await new Promise(resolve => setTimeout(resolve, 0));
+          continue
+        }
+        throw err2
+      }
+    }
+  }
+}
+
 /**
  * Removes the directory at the specified filepath recursively. Used internally to replicate the behavior of
  * fs.promises.rm({ recursive: true, force: true }) from Node.js 14 and above when not available. If the provided
@@ -5213,29 +5275,17 @@ class FileSystem {
    * Make a directory (or series of nested directories) without throwing an error if it already exists.
    *
    * @param {string} filepath - The path to the directory.
-   * @param {boolean} [_selfCall=false] - Internal flag to prevent infinite recursion.
    * @returns {Promise<void>}
    */
-  async mkdir(filepath, _selfCall = false) {
-    try {
-      await this._mkdir(filepath);
-    } catch (err) {
-      // If err is null then operation succeeded!
-      if (err === null) return
-      // If the directory already exists, that's OK!
-      if (err.code === 'EEXIST') return
-      // Avoid infinite loops of failure
-      if (_selfCall) throw err
-      // If we got a "no such file or directory error" backup and try again.
-      if (err.code === 'ENOENT') {
-        const parent = dirname(filepath);
-        // Check to see if we've gone too far
-        if (parent === '.' || parent === '/' || parent === filepath) throw err
-        // Infinite recursion, what could go wrong?
-        await this.mkdir(parent);
-        await this.mkdir(filepath, true);
-      }
-    }
+  async mkdir(filepath) {
+    // Recursively create the directory, using only single-level `_mkdir` so we
+    // don't depend on `{ recursive: true }` (which isn't part of the required
+    // `fs` contract — see docs/fs.md — and is unimplemented by some backends
+    // e.g. lightning-fs). The helper tolerates EEXIST and the transient ENOENT
+    // that eventually-consistent backends throw when a freshly created parent
+    // isn't visible yet, which is what made concurrent reflog writes into
+    // `.git/logs/refs/*` fail intermittently.
+    await mkdirp(this._mkdir, filepath);
   }
 
   /**
@@ -9580,8 +9630,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.40.7',
-  agent: 'git/isomorphic-git@1.40.7',
+  version: '1.41.0',
+  agent: 'git/isomorphic-git@1.41.0',
 };
 
 class FIFO {

package/index.d.cts

@@ -305,6 +305,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -4501,6 +4505,7 @@ declare namespace NoCommitError {
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 /**
  * @typedef {Object} GitHttpResponse

package/index.d.ts

@@ -304,6 +304,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -4500,6 +4504,7 @@ declare namespace NoCommitError {
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 /**
  * @typedef {Object} GitHttpResponse

package/index.js

@@ -29,6 +29,7 @@ import diff3Merge from 'diff3';
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 
 /**
@@ -5008,6 +5009,67 @@ async function _walk({
   return walk(root)
 }
 
+/**
+ * Recursively creates the directory at `filepath`, creating any missing parent
+ * directories along the way. This is a portable replacement for
+ * `fs.mkdir(path, { recursive: true })`: recursive `mkdir` is NOT part of
+ * isomorphic-git's required `fs` contract (see docs/fs.md — `mkdir` is only
+ * `mkdir(path[, mode])`) and is unimplemented by some backends such as
+ * lightning-fs, so we build it here on top of a single-level `mkdir(path)`
+ * primitive only — mirroring how `rmRecursive` provides `rm({ recursive: true })`.
+ *
+ * It takes the raw single-level `mkdir` *function* (typically `fs._mkdir`)
+ * rather than the FileSystem wrapper, to stay decoupled from that type.
+ *
+ * `EEXIST` is treated as success, so two callers concurrently creating the same
+ * directory (e.g. several reflog writes into `.git/logs/refs/*` during a stash)
+ * don't fail each other. On backends whose layers are only eventually
+ * consistent — e.g. an async copy-on-write overlay — a just-created parent may
+ * not yet be visible when its child is created, so `mkdir` can throw a
+ * transient `ENOENT`; those are retried a bounded number of times rather than
+ * surfaced as a spurious failure.
+ *
+ * @param {(filepath: string) => Promise<unknown>} mkdir - Creates a single directory (non-recursive).
+ * @param {string} filepath - The directory to create.
+ * @param {number} [retries=10] - Max transient-ENOENT retries after the parent exists.
+ * @returns {Promise<void>}
+ */
+async function mkdirp(mkdir, filepath, retries = 10) {
+  try {
+    await mkdir(filepath);
+  } catch (err) {
+    // Some fs implementations signal success by yielding a null error.
+    if (err === null) return
+    // The directory already exists — that's fine.
+    if (err.code === 'EEXIST') return
+    // Anything other than a missing parent is a real error.
+    if (err.code !== 'ENOENT') throw err
+    const parent = dirname(filepath);
+    // Stop if we've walked past the filesystem root.
+    if (parent === '.' || parent === '/' || parent === filepath) throw err
+    // Create the missing parent(s) first, honoring the same retry budget.
+    await mkdirp(mkdir, parent, retries);
+    // Then (re)create this directory. On an eventually-consistent backend the
+    // parent may not be visible immediately after its mkdir resolves, so a
+    // repeated ENOENT here is transient — retry a bounded number of times,
+    // yielding between attempts so the pending write can settle.
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await mkdir(filepath);
+        return
+      } catch (err2) {
+        if (err2 === null || err2.code === 'EEXIST') return
+        if (err2.code === 'ENOENT' && attempt < retries) {
+          // Give the backend a turn of the event loop to become consistent.
+          await new Promise(resolve => setTimeout(resolve, 0));
+          continue
+        }
+        throw err2
+      }
+    }
+  }
+}
+
 /**
  * Removes the directory at the specified filepath recursively. Used internally to replicate the behavior of
  * fs.promises.rm({ recursive: true, force: true }) from Node.js 14 and above when not available. If the provided
@@ -5200,29 +5262,17 @@ class FileSystem {
    * Make a directory (or series of nested directories) without throwing an error if it already exists.
    *
    * @param {string} filepath - The path to the directory.
-   * @param {boolean} [_selfCall=false] - Internal flag to prevent infinite recursion.
    * @returns {Promise<void>}
    */
-  async mkdir(filepath, _selfCall = false) {
-    try {
-      await this._mkdir(filepath);
-    } catch (err) {
-      // If err is null then operation succeeded!
-      if (err === null) return
-      // If the directory already exists, that's OK!
-      if (err.code === 'EEXIST') return
-      // Avoid infinite loops of failure
-      if (_selfCall) throw err
-      // If we got a "no such file or directory error" backup and try again.
-      if (err.code === 'ENOENT') {
-        const parent = dirname(filepath);
-        // Check to see if we've gone too far
-        if (parent === '.' || parent === '/' || parent === filepath) throw err
-        // Infinite recursion, what could go wrong?
-        await this.mkdir(parent);
-        await this.mkdir(filepath, true);
-      }
-    }
+  async mkdir(filepath) {
+    // Recursively create the directory, using only single-level `_mkdir` so we
+    // don't depend on `{ recursive: true }` (which isn't part of the required
+    // `fs` contract — see docs/fs.md — and is unimplemented by some backends
+    // e.g. lightning-fs). The helper tolerates EEXIST and the transient ENOENT
+    // that eventually-consistent backends throw when a freshly created parent
+    // isn't visible yet, which is what made concurrent reflog writes into
+    // `.git/logs/refs/*` fail intermittently.
+    await mkdirp(this._mkdir, filepath);
   }
 
   /**
@@ -9567,8 +9617,8 @@ function filterCapabilities(server, client) {
 
 const pkg = {
   name: 'isomorphic-git',
-  version: '1.40.7',
-  agent: 'git/isomorphic-git@1.40.7',
+  version: '1.41.0',
+  agent: 'git/isomorphic-git@1.41.0',
 };
 
 class FIFO {

package/index.umd.min.d.ts

@@ -304,6 +304,10 @@ export type GitHttpRequest = {
      * - Reserved for future use (canceling a request)
      */
     signal?: object;
+    /**
+     * - Additional options to pass to fetch (Web) or simple-get (Node)
+     */
+    fetchOptions?: any;
 };
 export type GitHttpResponse = {
     /**
@@ -4500,6 +4504,7 @@ declare namespace NoCommitError {
  * @property {AsyncIterableIterator<Uint8Array>} [body] - An async iterator of Uint8Arrays that make up the body of POST requests
  * @property {ProgressCallback} [onProgress] - Reserved for future use (emitting `GitProgressEvent`s)
  * @property {object} [signal] - Reserved for future use (canceling a request)
+ * @property {Object} [fetchOptions={}] - Additional options to pass to fetch (Web) or simple-get (Node)
  */
 /**
  * @typedef {Object} GitHttpResponse