@gitkraken/core-gitlens 0.3.0 → 0.3.1

package/src/git-cli/providers/status.ts

@@ -43,7 +43,15 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 
 		const porcelainVersion = (await this.git.supports('git:status:porcelain-v2')) ? 2 : 1;
 
-		const result = await this.statusCore(repoPath, porcelainVersion, { priority: options?.priority }, cancellation);
+		const result = await this.statusCore(
+			repoPath,
+			porcelainVersion,
+			{
+				similarityThreshold: this.context.config?.commits.similarityThreshold,
+				priority: options?.priority,
+			},
+			cancellation,
+		);
 		const repoUri = fileUri(normalizePath(repoPath));
 		const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, p =>
 			joinUriPath(repoUri, normalizePath(p)),
@@ -111,7 +119,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 		const result = await this.statusCore(
 			repoPath,
 			porcelainVersion,
-			{},
+			{ similarityThreshold: this.context.config?.commits.similarityThreshold },
 			cancellation,
 			// If we want renames, don't include the path as Git won't do rename detection
 			...(renames ? [] : [relativePath]),
@@ -135,7 +143,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 	private async statusCore(
 		repoPath: string,
 		porcelainVersion: number = 1,
-		options?: { similarityThreshold?: number; priority?: GitCommandPriority },
+		options?: { similarityThreshold?: number | null; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 		...pathspecs: string[]
 	): Promise<GitResult> {

package/src/ipc/discovery.ts

@@ -1,7 +1,7 @@
-import { mkdir, unlink, writeFile } from 'fs/promises';
+import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { ppid } from 'process';
+import { kill, ppid } from 'process';
 
 /**
  * Directory scanned by `gk` binaries (and `@gitkraken/core-gitlens` consumers) for the
@@ -34,6 +34,16 @@ export function getDiscoveryFileName(port: number): string {
 	return `gitlens-ipc-server-${ppid}-${port}.json`;
 }
 
+const discoveryFileNameRegex = /^gitlens-ipc-server-(\d+)-(\d+)\.json$/;
+
+/** Parses a discovery file name back into its `ppid`/`port` parts; returns `undefined` if it doesn't match. */
+export function parseDiscoveryFileName(name: string): { ppid: number; port: number } | undefined {
+	const match = discoveryFileNameRegex.exec(name);
+	if (match == null) return undefined;
+
+	return { ppid: Number(match[1]), port: Number(match[2]) };
+}
+
 export function getDiscoveryFilePath(dir: string, port: number): string {
 	return join(dir, getDiscoveryFileName(port));
 }
@@ -54,3 +64,123 @@ export async function cleanupDiscoveryFile(filePath: string | undefined): Promis
 		// Ignore cleanup errors
 	}
 }
+
+export interface SweepDiscoveryFilesOptions {
+	/** Ports to never touch (e.g. our own live server). */
+	excludePorts?: number[];
+	/** Absolute file paths to never touch (e.g. our own files). */
+	excludePaths?: string[];
+}
+
+/**
+ * Best-effort sweep of orphaned discovery files left by processes that crashed or were
+ * hard-killed without cleaning up. Reachability is the source of truth: a file is removed
+ * only when its owning process is provably gone (pid reports `ESRCH`) or its server is
+ * unreachable (the probe fails with anything other than a timeout). Anything reachable — or
+ * ambiguous (timeouts, parse errors) — is kept, so a live peer's file is never deleted.
+ */
+export async function sweepStaleDiscoveryFiles(
+	dirs: string[],
+	options?: SweepDiscoveryFilesOptions,
+): Promise<{ scanned: number; pruned: number }> {
+	const excludePorts = options?.excludePorts;
+	const excludePaths = options?.excludePaths;
+
+	let scanned = 0;
+	let pruned = 0;
+
+	for (const dir of dirs) {
+		let names: string[];
+		try {
+			names = await readdir(dir);
+		} catch {
+			// Dir doesn't exist yet (nothing ever published here) — nothing to sweep.
+			continue;
+		}
+
+		const candidates: string[] = [];
+		for (const name of names) {
+			const parsed = parseDiscoveryFileName(name);
+			if (parsed == null) continue;
+			if (excludePorts?.includes(parsed.port)) continue;
+
+			const filePath = join(dir, name);
+			if (excludePaths?.includes(filePath)) continue;
+
+			candidates.push(filePath);
+		}
+
+		scanned += candidates.length;
+
+		const results = await Promise.allSettled(
+			candidates.map(async filePath => {
+				if (await isDiscoveryFileStale(filePath)) {
+					await cleanupDiscoveryFile(filePath);
+					return true;
+				}
+				return false;
+			}),
+		);
+
+		for (const r of results) {
+			if (r.status === 'fulfilled' && r.value) {
+				pruned++;
+			}
+		}
+	}
+
+	return { scanned: scanned, pruned: pruned };
+}
+
+/** Returns true only when the file's server is provably gone (dead pid or unreachable server). */
+async function isDiscoveryFileStale(filePath: string): Promise<boolean> {
+	let data: IpcDiscoveryData;
+	try {
+		data = JSON.parse(await readFile(filePath, 'utf8')) as IpcDiscoveryData;
+	} catch {
+		// Can't read/parse — don't delete files we don't understand.
+		return false;
+	}
+
+	// Cheap short-circuit: if the owning process is gone, the file is orphaned.
+	if (data.pid != null && !isProcessAlive(data.pid)) return true;
+
+	// Otherwise reachability is the source of truth.
+	if (!data.address) return false;
+
+	try {
+		await fetch(`${data.address}/ping`, { signal: AbortSignal.timeout(1000) });
+		// Any HTTP response (even 401/404) means a server is listening — keep.
+		return false;
+	} catch (ex) {
+		// A timeout is ambiguous — the server may be alive but slow to answer — so keep. Any other
+		// failure (connection refused, reset, host unreachable, bad address) means nothing is
+		// serving on that localhost port, so the file is stale. A healthy local server always
+		// answers near-instantly, so this never deletes a reachable peer.
+		return !isTimeoutError(ex);
+	}
+}
+
+function isProcessAlive(pid: number): boolean {
+	// `kill(0, ...)` / `kill(<negative>, ...)` have process-group semantics and don't probe a
+	// specific pid, so a malformed pid (from a foreign or corrupt file) can't prove death — treat
+	// it as inconclusive so the sweep falls through to the reachability probe rather than deleting
+	// on a bad pid. (Note: the agents session-card tracker's `isProcessAlive` biases the opposite
+	// way — toward dead — because expiring a live card there is harmless; deleting a live file is
+	// not, so this copy intentionally keeps on uncertainty.)
+	if (!Number.isInteger(pid) || pid <= 0) return true;
+
+	try {
+		kill(pid, 0);
+		return true;
+	} catch (ex) {
+		// ESRCH → no such process (dead). EPERM/EACCES → exists but not ours (alive). Anything
+		// else is inconclusive → treat as alive so we never delete a file on uncertainty.
+		return (ex as NodeJS.ErrnoException | null)?.code !== 'ESRCH';
+	}
+}
+
+function isTimeoutError(ex: unknown): boolean {
+	// `AbortSignal.timeout` rejects with a `TimeoutError`; a bare abort yields an `AbortError`.
+	return ex instanceof Error && (ex.name === 'TimeoutError' || ex.name === 'AbortError');
+}