@gitkraken/core-gitlens 0.3.0 → 0.4.0

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

@@ -390,7 +390,25 @@ export class StashGitSubProvider implements GitStashSubProvider {
 			params.push('--include-untracked');
 		}
 
-		if (options?.keepIndex && !options?.includeUntracked) {
+		// `git stash push --keep-index --include-untracked -- <pathspec>` hits a bug in git when the
+		// pathspec names an untracked file: the restoring checkout can't match an untracked path in the
+		// index tree, so it fails and the staged changes are lost.
+		//
+		// $ mkdir stash-test && cd stash-test && git init
+		// $ echo a > a.txt
+		// $ git add a.txt
+		// $ git commit -m init
+		// $ echo b > b.txt
+		// $ git stash push --keep-index --include-untracked -- b.txt
+		// Saved working directory and index state WIP on main: 8a280fe init
+		// error: pathspec ':(prefix:0)b.txt' did not match any file(s) known to git
+		//
+		// Only suppress --keep-index for that case — when the selection actually includes untracked
+		// files (`includeUntracked`) AND we're stashing by pathspec. Keying off `includeUntracked` (the
+		// caller's intent) rather than the `--include-untracked` flag is deliberate: we add
+		// `--include-untracked` to every pathspec push above as a safety net, but a tracked-only
+		// selection can — and must — still keep the index intact.
+		if (options?.keepIndex && !(options?.includeUntracked && options?.pathspecs?.length)) {
 			params.push('--keep-index');
 		}
 
@@ -494,7 +512,7 @@ export function convertStashesToStdin(stashOrStashes: GitStash | ReadonlyMap<str
 }
 
 const stashSummaryRegex =
-	// eslint-disable-next-line no-control-regex
+	// oxlint-disable-next-line no-control-regex
 	/(?:(?:(?<wip>WIP) on|On) (?<onref>[^/](?!.*\/\.)(?!.*\.\.)(?!.*\/\/)(?!.*@\{)[^\x00-\x1F\x7F ~^:?*[\\]+[^./]):\s*)?(?<summary>.*)$/s;
 
 function createStash(

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/git-cli/providers/worktrees.ts

@@ -29,7 +29,13 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	async createWorktree(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -40,6 +46,9 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		if (options?.createBranch) {
 			args.push('-b', options.createBranch);
 		}
+		if (options?.createBranch && options.noTracking) {
+			args.push('--no-track');
+		}
 		if (options?.detach) {
 			args.push('--detach');
 		}
@@ -76,7 +85,13 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	async createWorktreeWithResult(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<GitWorktree | undefined> {
 		await this.createWorktree(repoPath, path, options);
 		const normalized = normalizePath(path);

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');
+}