@gitkraken/core-gitlens 0.15.3 → 0.15.5

package/dist/git-cli/providers/config.d.ts

@@ -7,6 +7,21 @@ import { DeprecatedGkConfigKeys, GitConfigKeys, GitConfigSubProvider, GitConfigT
 import { Git } from "../exec/git.js";
 import { CliGitProviderInternal } from "../cliGitProvider.js";
 //#region ../git-cli/src/providers/config.d.ts
+/** The wall clock a read's fingerprint is checked against (see {@link isGkConfigStatRacy}), exported for testing */
+export declare const gkConfigFingerprintClock: {
+  now: () => number;
+};
+/**
+ * Whether a stat of `.git/gk/config` taken at `statTimeMs` came too soon after the file's last change to vouch for
+ * the file staying unchanged while it matches — git's "racily clean" index entries. A later write in the same tick of
+ * the filesystem's clock as that change, of the same size and given the inode the stat saw (freed by the write in
+ * between and reused), gets the same fingerprint; once the stat is a tick past the change, any later write carries a
+ * later time. Times that are whole seconds come from a filesystem that keeps no finer (ext4 with 128-byte inodes,
+ * HFS+, FAT's 2-second mtime, some network mounts), so the stat must be 2s past; otherwise 50ms covers the coarsest
+ * tick a finer clock still has (a 10ms jiffy, Windows' 15.6ms timer) and the wall clock lagging it by one. A file
+ * changed after `statTimeMs` (a clock ahead of ours) is racy too. Exported for testing.
+ */
+export declare function isGkConfigStatRacy(mtimeNs: bigint, ctimeNs: bigint, statTimeMs: number): boolean;
 /**
  * Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
  * section and variable-name lowercased and only the subsection case-preserved. Without this a
@@ -31,6 +46,13 @@ export declare function canonicalizeGitConfigKey(key: string): string;
 export declare function parseConfigRegexOutput(data: string | undefined, options?: {
   includeValueless?: boolean;
 }): Map<string, string>;
+/**
+ * Parses `git config --null --get-regexp` output into every value of each key, in the order git printed them. Each
+ * entry is its key, a newline and its value, ended by a NUL, so a value may hold newlines or spaces unambiguously.
+ * A valueless entry (`key`, no `=`), which git prints with no newline, is skipped, as {@link parseConfigRegexOutput}
+ * skips it by default.
+ */
+export declare function parseConfigRegexNullOutput(data: string | undefined): Map<string, string[]>;
 export declare function parseGitBoolean(value: string | undefined): boolean;
 /** Whether a git config value spells boolean-false (`false`/`no`/`off`/`0`/empty), per git's maybe-bool parsing. */
 export declare function isGitBooleanFalse(value: string): boolean;
@@ -52,8 +74,6 @@ export declare class ConfigGitSubProvider implements GitConfigSubProvider {
    * skip option joins it; any other call chains after it, so one key's writes land in call order. Cleared on settle.
    */
   private readonly _pendingGkConfigWrites;
-  /** Maps from failed bulk reads, which a reconcile must not diff as the file's content */
-  private readonly _failedGkConfigMaps;
   /** Writes each `.git/gk/config` one at a time — concurrent `git config` writes fail on its lock */
   private readonly _gkConfigWrites;
   getConfig(repoPath: string | undefined, key: GitConfigKeys, options?: {
@@ -66,6 +86,12 @@ export declare class ConfigGitSubProvider implements GitConfigSubProvider {
     global?: boolean;
     runGitLocally?: boolean;
   }): Promise<Map<string, string>>;
+  /**
+   * Every value of each key matching `pattern` (`git config --get-regexp`), for a key git lets repeat, like
+   * `remote.<name>.fetch`: {@link getConfigRegex} keeps only each key's last value. Cached beside it, so the same
+   * writes and config changes clear it. Rejects when git couldn't read the configuration.
+   */
+  getConfigRegexAll(repoPath: string, pattern: string): Promise<Map<string, string[]>>;
   private getConfigRegexCore;
   setConfig(repoPath: string | undefined, key: GitConfigKeys, value: string | undefined, options?: {
     file?: string;
@@ -89,6 +115,14 @@ export declare class ConfigGitSubProvider implements GitConfigSubProvider {
    * namespaces costs one `git config` call instead of one per namespace.
    */
   private getGkConfigMap;
+  /** Records the read that is creating `repoPath`'s cached gk config map (see {@link gkConfigMapReads}) */
+  private trackGkConfigMapRead;
+  /**
+   * Hard-evicts the cached gk config map, unless `.git/gk/config` is unchanged since the read behind it stat'd the
+   * file, or that read is yet to spawn. The stat is taken before the read, so a write landing between the two
+   * only costs a re-read on its report, never a missed change. Returns the read it kept, if any.
+   */
+  private evictGkConfigMapIfChanged;
   private getGkConfigRegexCore;
   setGkConfig(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys, value: string | undefined, options?: {
     skipInvalidation?: readonly GkConfigInvalidationTarget[];
@@ -111,10 +145,12 @@ export declare class ConfigGitSubProvider implements GitConfigSubProvider {
   private runGkConfigSectionCommand;
   /**
    * Reconciles a watcher-observed `'gkConfig'` change — registered with the shared `Cache` as its
-   * gk-config reconciler (see the constructor). Re-reads the bulk map (hard-evicted by
-   * `Cache.handleGkConfigChanged`, so this hits disk) and diffs it against `priorSnapshot` to cascade
+   * gk-config reconciler (see the constructor). Hard-evicts the bulk map as the change is reported, unless the file
+   * is unchanged since the map was read (see `evictGkConfigMapIfChanged`), then reads it (from disk, or the map
+   * kept) and diffs it against `priorSnapshot` to cascade
    * `baseBranchName`/`branchOverviews` only for refs whose merge-relevant keys actually changed, and to evict the
-   * branches only when a branch metadata key (another process's activity stamp) changed.
+   * branches only when a branch metadata key (another process's activity stamp) changed. The diff runs on a kept
+   * map too: a read can land between an external write and its report, and already hold the change.
    *
    * Serialized per commonPath: a reconcile is a read-then-diff against a single shared baseline, so
    * two overlapping passes would both diff against the same snapshot and the later change could fall
@@ -122,10 +158,10 @@ export declare class ConfigGitSubProvider implements GitConfigSubProvider {
    * diffs against the baseline the previous pass just established.
    *
    * `.git/gk/config` lives in the common dir, so the watcher delivers one event per worktree sharing it
-   * (see `WatchGroup.onCommonEvent`). Siblings never run concurrently — the later ones fold into the
-   * in-flight pass — but folding in arms the trailing pass, so a fan-out costs one extra read that
-   * re-reads and diffs an unchanged file. However many siblings land while a pass is running, they
-   * coalesce into that single trailing pass; the cost is the price of never dropping a real change.
+   * (see `WatchGroup.onCommonEvent`), and core's own write is reported too. Siblings never run concurrently — the
+   * later ones fold into the in-flight pass — but folding in arms the trailing pass, which re-diffs the map unless
+   * the file changed again. However many siblings land while a pass is running, they coalesce into that single
+   * trailing pass; the cost is the price of never dropping a real change.
    * Every reporting path is retained because `Repository` matches the follow-up change event on exact
    * path, and a sibling worktree that never receives one would sit on stale derived values.
    */

package/dist/git-cli/providers/config.js

@@ -10,7 +10,7 @@ import { WorkspaceUntrustedError } from "../../git/errors.js";
 import { fsExists } from "../../utils/env/node/exec.js";
 import { KeyedSequencer } from "../exec/indexLock.js";
 import { gate } from "../../utils/decorators/gate.js";
-import { promises } from "fs";
+import { promises, statSync } from "fs";
 import { env } from "process";
 import { hostname, userInfo } from "os";
 //#region ../git-cli/src/providers/config.ts
@@ -19,6 +19,58 @@ const emptyArray = Object.freeze([]);
 /** Catch-all pattern matching every key in `.git/gk/config` for the one-shot bulk read. */
 const gkConfigAllPattern = ".";
 /**
+* Maps from failed bulk reads, which a reconcile must not diff as the file's content, each to the read that produced
+* it. Module-wide, like {@link gkConfigMapReads}: a reconcile can join a read another provider sharing its `Cache`
+* started.
+*/
+const failedGkConfigMaps = /* @__PURE__ */ new WeakMap();
+/**
+* The read behind each commonPath's cached gk config map, per `Cache`. Recorded as the read starts, which is when
+* the cache creates the entry for it, so it always describes the entry cached now. Kept per `Cache` rather than per
+* provider, since providers sharing a `Cache` serve each other's reads.
+*/
+const gkConfigMapReads = /* @__PURE__ */ new WeakMap();
+/** The wall clock a read's fingerprint is checked against (see {@link isGkConfigStatRacy}), exported for testing */
+const gkConfigFingerprintClock = { now: () => Date.now() };
+const nsPerMs = 1000000n;
+const nsPerSecond = 1000000000n;
+/**
+* Whether a stat of `.git/gk/config` taken at `statTimeMs` came too soon after the file's last change to vouch for
+* the file staying unchanged while it matches — git's "racily clean" index entries. A later write in the same tick of
+* the filesystem's clock as that change, of the same size and given the inode the stat saw (freed by the write in
+* between and reused), gets the same fingerprint; once the stat is a tick past the change, any later write carries a
+* later time. Times that are whole seconds come from a filesystem that keeps no finer (ext4 with 128-byte inodes,
+* HFS+, FAT's 2-second mtime, some network mounts), so the stat must be 2s past; otherwise 50ms covers the coarsest
+* tick a finer clock still has (a 10ms jiffy, Windows' 15.6ms timer) and the wall clock lagging it by one. A file
+* changed after `statTimeMs` (a clock ahead of ours) is racy too. Exported for testing.
+*/
+function isGkConfigStatRacy(mtimeNs, ctimeNs, statTimeMs) {
+	const changedNs = mtimeNs > ctimeNs ? mtimeNs : ctimeNs;
+	const marginNs = mtimeNs % nsPerSecond === 0n && ctimeNs % nsPerSecond === 0n ? 2n * nsPerSecond : 50n * nsPerMs;
+	return BigInt(Math.floor(statTimeMs)) * nsPerMs - changedNs < marginNs;
+}
+/**
+* A stat of `.git/gk/config` that two stats share only if no write landed between them: `git config` writes a lock
+* file and renames it over the original, so every write gives the file a new inode, and its size and times tell
+* apart a later write that lands on a freed inode — unless that write fell in the same clock tick as the change the
+* first stat saw, which `statTimeMs` rules out (see {@link isGkConfigStatRacy}): given the time the stat is taken,
+* a stat that racy is `undefined`, never matching. `'absent'` when there is no file, `undefined` when it can't be
+* stat'd.
+*/
+function getGkConfigFingerprint(path, statTimeMs) {
+	try {
+		const stat = statSync(path, {
+			bigint: true,
+			throwIfNoEntry: false
+		});
+		if (stat == null) return "absent";
+		if (statTimeMs != null && isGkConfigStatRacy(stat.mtimeNs, stat.ctimeNs, statTimeMs)) return void 0;
+		return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+	} catch {
+		return;
+	}
+}
+/**
 * Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
 * section and variable-name lowercased and only the subsection case-preserved. Without this a
 * subsection-less key like `gk.defaultRemote` would miss the lowercased `gk.defaultremote` in the map.
@@ -59,6 +111,26 @@ function parseConfigRegexOutput(data, options) {
 	}
 	return configMap;
 }
+/**
+* Parses `git config --null --get-regexp` output into every value of each key, in the order git printed them. Each
+* entry is its key, a newline and its value, ended by a NUL, so a value may hold newlines or spaces unambiguously.
+* A valueless entry (`key`, no `=`), which git prints with no newline, is skipped, as {@link parseConfigRegexOutput}
+* skips it by default.
+*/
+function parseConfigRegexNullOutput(data) {
+	const configMap = /* @__PURE__ */ new Map();
+	if (!data) return configMap;
+	for (const entry of data.split("\0")) {
+		const newlineIndex = entry.indexOf("\n");
+		if (newlineIndex === -1) continue;
+		const key = entry.substring(0, newlineIndex);
+		const value = entry.substring(newlineIndex + 1);
+		const values = configMap.get(key);
+		if (values != null) values.push(value);
+		else configMap.set(key, [value]);
+	}
+	return configMap;
+}
 function parseGitBoolean(value) {
 	if (value == null) return false;
 	const normalized = value.toLowerCase().trim();
@@ -93,8 +165,6 @@ var ConfigGitSubProvider = class {
 	* skip option joins it; any other call chains after it, so one key's writes land in call order. Cleared on settle.
 	*/
 	_pendingGkConfigWrites = /* @__PURE__ */ new Map();
-	/** Maps from failed bulk reads, which a reconcile must not diff as the file's content */
-	_failedGkConfigMaps = /* @__PURE__ */ new WeakSet();
 	/** Writes each `.git/gk/config` one at a time — concurrent `git config` writes fail on its lock */
 	_gkConfigWrites = new KeyedSequencer();
 	getConfig(repoPath, key, options) {
@@ -117,6 +187,22 @@ var ConfigGitSubProvider = class {
 		const global = options?.global || repoPath == null;
 		return this.cache.getConfigRegex(global ? void 0 : repoPath, pattern, () => this.getConfigRegexCore(repoPath, pattern, options));
 	}
+	/**
+	* Every value of each key matching `pattern` (`git config --get-regexp`), for a key git lets repeat, like
+	* `remote.<name>.fetch`: {@link getConfigRegex} keeps only each key's last value. Cached beside it, so the same
+	* writes and config changes clear it. Rejects when git couldn't read the configuration.
+	*/
+	async getConfigRegexAll(repoPath, pattern) {
+		const joined = await this.cache.getConfigRegex(repoPath, `\0all\0${pattern}`, async () => {
+			const result = await this.git.run({
+				cwd: this.cache.getCommonPath(repoPath),
+				errors: "ignore"
+			}, "config", "--null", "--get-regexp", pattern);
+			if (result.completion.status !== "exited" || result.exitCode !== 0 && result.exitCode !== 1) throw new Error(`Unable to read the config keys matching '${pattern}'`);
+			return new Map(Array.from(parseConfigRegexNullOutput(result.stdout), ([key, values]) => [key, values.join("\0")]));
+		});
+		return new Map(Array.from(joined, ([key, value]) => [key, value.split("\0")]));
+	}
 	async getConfigRegexCore(repoPath, pattern, options) {
 		const args = ["config", "--get-regex"];
 		if (options?.file) args.push("-f", options.file);
@@ -249,22 +335,54 @@ var ConfigGitSubProvider = class {
 	* namespaces costs one `git config` call instead of one per namespace.
 	*/
 	async getGkConfigMap(repoPath) {
-		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
+		const commonPath = this.cache.getCommonPath(repoPath);
+		if (!this._migratedRepos.has(commonPath)) await this.migrateGkConfigFromGitConfig(commonPath);
 		return this.cache.getGkConfigMap(repoPath, async (cacheable) => {
-			const { map, failed } = await this.getGkConfigRegexCore(repoPath, gkConfigAllPattern);
+			const read = this.trackGkConfigMapRead(repoPath);
+			const { map, failed } = await this.getGkConfigRegexCore(repoPath, gkConfigAllPattern, read);
 			if (failed) {
 				cacheable.invalidate();
-				this._failedGkConfigMaps.add(map);
+				failedGkConfigMaps.set(map, read);
 			}
 			return map;
 		});
 	}
-	async getGkConfigRegexCore(repoPath, pattern) {
+	/** Records the read that is creating `repoPath`'s cached gk config map (see {@link gkConfigMapReads}) */
+	trackGkConfigMapRead(repoPath) {
+		let reads = gkConfigMapReads.get(this.cache);
+		if (reads == null) {
+			reads = /* @__PURE__ */ new Map();
+			gkConfigMapReads.set(this.cache, reads);
+		}
+		const read = { spawned: false };
+		reads.set(this.cache.getCommonPath(repoPath), read);
+		return read;
+	}
+	/**
+	* Hard-evicts the cached gk config map, unless `.git/gk/config` is unchanged since the read behind it stat'd the
+	* file, or that read is yet to spawn. The stat is taken before the read, so a write landing between the two
+	* only costs a re-read on its report, never a missed change. Returns the read it kept, if any.
+	*/
+	evictGkConfigMapIfChanged(repoPath) {
+		const read = gkConfigMapReads.get(this.cache)?.get(this.cache.getCommonPath(repoPath));
+		if (read != null) {
+			if (!read.spawned) return read;
+			if (read.path != null && read.fingerprint != null && getGkConfigFingerprint(read.path) === read.fingerprint) return read;
+		}
+		this.cache.deleteGkConfigMap(repoPath);
+	}
+	async getGkConfigRegexCore(repoPath, pattern, read) {
 		const gkConfigPath = await this.getGkConfigPath(repoPath);
-		if (!gkConfigPath) return {
-			map: /* @__PURE__ */ new Map(),
-			failed: false
-		};
+		if (!gkConfigPath) {
+			read.spawned = true;
+			return {
+				map: /* @__PURE__ */ new Map(),
+				failed: false
+			};
+		}
+		read.path = gkConfigPath;
+		read.fingerprint = getGkConfigFingerprint(gkConfigPath, gkConfigFingerprintClock.now());
+		read.spawned = true;
 		const result = await this.git.run({
 			cwd: repoPath,
 			errors: "ignore",
@@ -355,10 +473,12 @@ var ConfigGitSubProvider = class {
 	}
 	/**
 	* Reconciles a watcher-observed `'gkConfig'` change — registered with the shared `Cache` as its
-	* gk-config reconciler (see the constructor). Re-reads the bulk map (hard-evicted by
-	* `Cache.handleGkConfigChanged`, so this hits disk) and diffs it against `priorSnapshot` to cascade
+	* gk-config reconciler (see the constructor). Hard-evicts the bulk map as the change is reported, unless the file
+	* is unchanged since the map was read (see `evictGkConfigMapIfChanged`), then reads it (from disk, or the map
+	* kept) and diffs it against `priorSnapshot` to cascade
 	* `baseBranchName`/`branchOverviews` only for refs whose merge-relevant keys actually changed, and to evict the
-	* branches only when a branch metadata key (another process's activity stamp) changed.
+	* branches only when a branch metadata key (another process's activity stamp) changed. The diff runs on a kept
+	* map too: a read can land between an external write and its report, and already hold the change.
 	*
 	* Serialized per commonPath: a reconcile is a read-then-diff against a single shared baseline, so
 	* two overlapping passes would both diff against the same snapshot and the later change could fall
@@ -366,10 +486,10 @@ var ConfigGitSubProvider = class {
 	* diffs against the baseline the previous pass just established.
 	*
 	* `.git/gk/config` lives in the common dir, so the watcher delivers one event per worktree sharing it
-	* (see `WatchGroup.onCommonEvent`). Siblings never run concurrently — the later ones fold into the
-	* in-flight pass — but folding in arms the trailing pass, so a fan-out costs one extra read that
-	* re-reads and diffs an unchanged file. However many siblings land while a pass is running, they
-	* coalesce into that single trailing pass; the cost is the price of never dropping a real change.
+	* (see `WatchGroup.onCommonEvent`), and core's own write is reported too. Siblings never run concurrently — the
+	* later ones fold into the in-flight pass — but folding in arms the trailing pass, which re-diffs the map unless
+	* the file changed again. However many siblings land while a pass is running, they coalesce into that single
+	* trailing pass; the cost is the price of never dropping a real change.
 	* Every reporting path is retained because `Repository` matches the follow-up change event on exact
 	* path, and a sibling worktree that never receives one would sit on stale derived values.
 	*/
@@ -377,6 +497,7 @@ var ConfigGitSubProvider = class {
 		const commonPath = this.cache.getCommonPath(repoPath);
 		const inflight = this._gkConfigReconciles.get(commonPath);
 		if (inflight != null) {
+			this.evictGkConfigMapIfChanged(repoPath);
 			inflight.paths.set(repoPath, this.cache.getCloseGeneration(repoPath));
 			inflight.pending = true;
 			return "deferred";
@@ -401,9 +522,13 @@ var ConfigGitSubProvider = class {
 				entry.pending = false;
 				const readPath = first(this.pruneClosedReconcilePaths(entry.paths).keys());
 				if (readPath == null) return "reconciled";
-				this.cache.deleteGkConfigMap(readPath);
-				const freshMap = await this.getGkConfigMap(readPath);
-				if (this._failedGkConfigMaps.has(freshMap)) throw new Error(`Failed to read the gk config through '${readPath}'`);
+				const kept = this.evictGkConfigMapIfChanged(readPath);
+				let freshMap = await this.getGkConfigMap(readPath);
+				if (kept != null && failedGkConfigMaps.get(freshMap) === kept) {
+					this.cache.deleteGkConfigMap(readPath);
+					freshMap = await this.getGkConfigMap(readPath);
+				}
+				if (failedGkConfigMaps.has(freshMap)) throw new Error(`Failed to read the gk config through '${readPath}'`);
 				if (!this.pruneClosedReconcilePaths(entry.paths).size) return "reconciled";
 				if (this.cache.reconcileGkConfigMap(readPath, snapshot, freshMap)) for (const path of entry.paths.keys()) this.provider.notifyHost(path, ["gkConfig"]);
 				snapshot = this.cache.getGkConfigSnapshot(readPath);
@@ -644,12 +769,13 @@ var ConfigGitSubProvider = class {
 };
 __decorate([trace()], ConfigGitSubProvider.prototype, "getConfig", null);
 __decorate([trace()], ConfigGitSubProvider.prototype, "getConfigRegex", null);
+__decorate([trace()], ConfigGitSubProvider.prototype, "getConfigRegexAll", null);
 __decorate([debug()], ConfigGitSubProvider.prototype, "setConfig", null);
 __decorate([gate(), debug()], ConfigGitSubProvider.prototype, "getCurrentUser", null);
 __decorate([gate(), trace({ exit: (r) => `returned ${r}` })], ConfigGitSubProvider.prototype, "getDefaultWorktreePath", null);
 __decorate([gate(), trace({ exit: (r) => `returned ${r.uri.toString(true)}, commonUri=${r.commonUri?.toString(true)}, parentUri=${r.parentUri?.toString(true)}` })], ConfigGitSubProvider.prototype, "getGitDir", null);
-__decorate([debug()], ConfigGitSubProvider.prototype, "getGkConfig", null);
-__decorate([debug()], ConfigGitSubProvider.prototype, "getGkConfigRegex", null);
+__decorate([trace()], ConfigGitSubProvider.prototype, "getGkConfig", null);
+__decorate([trace()], ConfigGitSubProvider.prototype, "getGkConfigRegex", null);
 __decorate([debug()], ConfigGitSubProvider.prototype, "setGkConfig", null);
 __decorate([debug()], ConfigGitSubProvider.prototype, "removeGkConfigBranchSection", null);
 __decorate([debug()], ConfigGitSubProvider.prototype, "renameGkConfigBranchSection", null);
@@ -658,6 +784,6 @@ __decorate([debug()], ConfigGitSubProvider.prototype, "validateSigningSetup", nu
 __decorate([debug()], ConfigGitSubProvider.prototype, "setSigningConfig", null);
 __decorate([gate(), debug()], ConfigGitSubProvider.prototype, "migrateGkConfigFromGitConfig", null);
 //#endregion
-export { ConfigGitSubProvider, canonicalizeGitConfigKey, isGitBooleanFalse, parseConfigRegexOutput, parseGitBoolean };
+export { ConfigGitSubProvider, canonicalizeGitConfigKey, gkConfigFingerprintClock, isGitBooleanFalse, isGkConfigStatRacy, parseConfigRegexNullOutput, parseConfigRegexOutput, parseGitBoolean };
 
 //# sourceMappingURL=config.js.map