@gitkraken/core-gitlens 0.1.0 → 0.3.0

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

@@ -6,6 +6,7 @@ import type { GitConflictFile } from '../../git/models/staging.js';
 import { GitStatus } from '../../git/models/status.js';
 import type { GitStatusFile } from '../../git/models/statusFile.js';
 import type { GitStatusSubProvider, GitWorkingChangesState } from '../../git/providers/status.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
 import { isCancellationError } from '../../utils/cancellation.js';
 import { gate } from '../../utils/decorators/gate.js';
 import { debug } from '../../utils/decorators/log.js';
@@ -33,19 +34,27 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 
 	@gate(rp => rp ?? '')
 	@debug()
-	async getStatus(repoPath: string | undefined, cancellation?: AbortSignal): Promise<GitStatus | undefined> {
+	async getStatus(
+		repoPath: string | undefined,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<GitStatus | undefined> {
 		if (repoPath == null) return undefined;
 
 		const porcelainVersion = (await this.git.supports('git:status:porcelain-v2')) ? 2 : 1;
 
-		const result = await this.statusCore(repoPath, porcelainVersion, {}, cancellation);
+		const result = await this.statusCore(repoPath, porcelainVersion, { priority: options?.priority }, cancellation);
 		const repoUri = fileUri(normalizePath(repoPath));
 		const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, p =>
 			joinUriPath(repoUri, normalizePath(p)),
 		);
 
 		if (status?.detached) {
-			const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(repoPath, cancellation);
+			const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(
+				repoPath,
+				undefined,
+				cancellation,
+			);
 			if (pausedOpStatus?.type === 'rebase') {
 				return new GitStatus(
 					repoPath,
@@ -126,7 +135,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 	private async statusCore(
 		repoPath: string,
 		porcelainVersion: number = 1,
-		options?: { similarityThreshold?: number },
+		options?: { similarityThreshold?: number; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 		...pathspecs: string[]
 	): Promise<GitResult> {
@@ -142,12 +151,13 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 			);
 		}
 
-		return this.git.exec(
+		return this.git.run(
 			{
 				cwd: repoPath,
 				cancellation: cancellation,
 				configs: gitConfigsStatus,
 				env: { GIT_OPTIONAL_LOCKS: '0' },
+				...(options?.priority != null ? { priority: options.priority } : undefined),
 			},
 			...params,
 			'--',
@@ -168,7 +178,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 			const staged = options?.staged ?? true;
 			const unstaged = options?.unstaged ?? true;
 			if (staged || unstaged) {
-				const result = await this.git.exec(
+				const result = await this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 					'diff',
 					'--quiet',
@@ -218,14 +228,14 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 		try {
 			const [stagedResult, unstagedResult, untrackedResult] = await Promise.allSettled([
 				// Check for staged changes
-				this.git.exec(
+				this.git.run(
 					{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 					'diff',
 					'--quiet',
 					'--staged',
 				),
 				// Check for unstaged changes
-				this.git.exec({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'diff', '--quiet'),
+				this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'diff', '--quiet'),
 				// Check for untracked files
 				this.hasUntrackedFiles(repoPath, cancellation),
 			]);
@@ -247,6 +257,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 			return result;
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
+
 			scope?.error(ex);
 			scope?.addExitInfo('error checking for changes');
 			// Return all false on error for graceful degradation
@@ -279,7 +290,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 				'ls-files',
 				'-z',
@@ -337,7 +348,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 		const scope = getScopedLogger();
 
 		try {
-			const result = await this.git.exec(
+			const result = await this.git.run(
 				{ cwd: repoPath, cancellation: cancellation, errors: 'ignore' },
 				'ls-files',
 				'-z',

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

@@ -16,7 +16,6 @@ import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { GitResult } from '../exec/exec.types.js';
 import type { Git, GitError } from '../exec/git.js';
 import { getGitCommandError, gitConfigsBranch } from '../exec/git.js';
-import { getTagParser } from '../parsers/refParser.js';
 
 export class TagsGitSubProvider implements GitTagsSubProvider {
 	constructor(
@@ -54,29 +53,29 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
 				signal ??= cancellation;
 				try {
-					const parser = getTagParser();
-
-					const result = await this.git.exec(
-						{ cwd: repoPath, cancellation: signal },
-						'for-each-ref',
-						...parser.arguments,
-						'refs/tags/',
-					);
-					if (!result.stdout) return emptyPagedResult;
+					const records = await this.provider.refs.getRefs(commonPath, signal);
+					if (!records.length) return emptyPagedResult;
 
 					using sw = maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } });
 
 					const tags: GitTag[] = [];
 
-					for (const entry of parser.parse(result.stdout)) {
+					for (const record of records) {
+						const fullName = record.name;
+						if (!fullName.startsWith('refs/tags/')) continue;
+
+						// Annotated tags: peeledObjectname is the commit SHA; objectname is the tag-object SHA.
+						// Lightweight tags: peeledObjectname is empty; objectname is already the commit SHA.
+						const sha = record.peeledObjectname || record.objectname;
+
 						tags.push(
 							new GitTag(
 								commonPath,
-								entry.name,
-								entry.sha || entry.tagSha,
-								entry.message,
-								entry.date ? new Date(entry.date) : undefined,
-								entry.commitDate ? new Date(entry.commitDate) : undefined,
+								fullName,
+								sha,
+								record.subject,
+								record.creatorDate ? new Date(record.creatorDate) : undefined,
+								record.authorDate ? new Date(record.authorDate) : undefined,
 							),
 						);
 					}
@@ -130,7 +129,7 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 		const params: string[] = ['tag', '--format=%(refname:short)'];
 		params.push(options?.mode === 'pointsAt' ? `--points-at=${sha}` : `--contains=${sha}`);
 
-		return this.git.exec(
+		return this.git.run(
 			{
 				cwd: repoPath,
 				cancellation: cancellation,
@@ -149,7 +148,7 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...args);
+			await this.git.run({ cwd: repoPath }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'tags');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['tags']);
 		} catch (ex) {
@@ -170,7 +169,7 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 		const args = ['tag', '-d', name];
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...args);
+			await this.git.run({ cwd: repoPath }, ...args);
 			this.context.hooks?.cache?.onReset?.(repoPath, 'tags');
 			this.context.hooks?.repository?.onChanged?.(repoPath, ['tags']);
 		} catch (ex) {

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

@@ -49,7 +49,7 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		}
 
 		try {
-			await this.git.exec({ cwd: repoPath }, ...args);
+			await this.git.run({ cwd: repoPath }, ...args);
 
 			this.context.hooks?.cache?.onReset?.(
 				repoPath,
@@ -106,7 +106,7 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
 				signal ??= cancellation;
 				const [dataResult, branchesResult] = await Promise.allSettled([
-					this.git.exec({ cwd: commonPath, cancellation: signal }, 'worktree', 'list', '--porcelain'),
+					this.git.run({ cwd: commonPath, cancellation: signal }, 'worktree', 'list', '--porcelain'),
 					this.provider.branches.getBranches(commonPath, undefined, signal),
 				]);
 
@@ -154,7 +154,7 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 
 		let deleted = false;
 		try {
-			await this.git.exec({ cwd: repoPath, errors: 'throw' }, ...args);
+			await this.git.run({ cwd: repoPath, errors: 'throw' }, ...args);
 			deleted = true;
 		} catch (ex) {
 			scope?.error(ex);

package/src/ipc/discovery.ts

@@ -0,0 +1,56 @@
+import { mkdir, unlink, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { ppid } from 'process';
+
+/**
+ * Directory scanned by `gk` binaries (and `@gitkraken/core-gitlens` consumers) for the
+ * extension's CLI-capable IPC server discovery file. Anything written here is assumed
+ * by older `gk` versions to be a CLI server — do NOT write agent-only files here.
+ */
+export const cliDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens');
+
+/**
+ * Directory scanned by peer GitLens windows for agent-session-capable IPC servers.
+ * Stable across GitLens versions; older windows still scan it, so don't move it.
+ */
+export const agentDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens', 'agents');
+
+export interface IpcDiscoveryData {
+	token: string;
+	address: string;
+	port: number;
+	workspacePaths: string[];
+	// Optional fields — present when the writing capability needs them.
+	// Old gk binaries ignore unknown fields, so this stays back-compat.
+	ideName?: string;
+	ideDisplayName?: string;
+	scheme?: string;
+	pid?: number;
+	createdAt: string;
+}
+
+export function getDiscoveryFileName(port: number): string {
+	return `gitlens-ipc-server-${ppid}-${port}.json`;
+}
+
+export function getDiscoveryFilePath(dir: string, port: number): string {
+	return join(dir, getDiscoveryFileName(port));
+}
+
+export async function writeDiscoveryFile(dir: string, data: IpcDiscoveryData): Promise<string> {
+	const filePath = getDiscoveryFilePath(dir, data.port);
+	await mkdir(dir, { recursive: true, mode: 0o700 });
+	await writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+	return filePath;
+}
+
+export async function cleanupDiscoveryFile(filePath: string | undefined): Promise<void> {
+	if (filePath == null) return;
+
+	try {
+		await unlink(filePath);
+	} catch {
+		// Ignore cleanup errors
+	}
+}

package/src/ipc/ipcServer.ts

@@ -0,0 +1,171 @@
+import type { IncomingMessage, Server, ServerResponse } from 'http';
+import { createServer } from 'http';
+import { uuid } from '../utils/crypto.js';
+import { debug } from '../utils/decorators/log.js';
+import type { UnifiedDisposable } from '../utils/disposable.js';
+import { createDisposable } from '../utils/disposable.js';
+import { Logger } from '../utils/logger.js';
+import { getScopedLogger } from '../utils/logger.scoped.js';
+
+export interface IpcHandler<Request = unknown, Response = void> {
+	(request: Request | undefined, searchParams: URLSearchParams): Promise<Response>;
+}
+
+export async function createIpcServer<Request = unknown, Response = void>(): Promise<IpcServer<Request, Response>> {
+	const server = createServer();
+	const token = uuid();
+
+	return new Promise<IpcServer<Request, Response>>((resolve, reject) => {
+		try {
+			server.on('error', ex => {
+				Logger.error(ex, 'IPC server error');
+				reject(ex);
+			});
+
+			// Let the OS assign an available port by listening on port 0
+			server.listen(0, '127.0.0.1', () => {
+				const address = server.address();
+				if (address == null || typeof address === 'string') {
+					reject(new Error('Failed to get server address'));
+					return;
+				}
+
+				const port = address.port;
+				const serverUrl = `http://127.0.0.1:${port}`;
+				resolve(new IpcServer(serverUrl, port, token, server));
+			});
+		} catch (ex) {
+			// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+			reject(ex);
+		}
+	});
+}
+
+export class IpcServer<Request = unknown, Response = void> implements UnifiedDisposable {
+	private readonly handlers = new Map<string | undefined, IpcHandler<Request, Response>>();
+
+	constructor(
+		readonly ipcAddress: string,
+		readonly ipcPort: number,
+		readonly ipcToken: string,
+		private server: Server,
+	) {
+		server
+			.on('listening', () => {
+				Logger.trace(`IPC server listening on ${this.ipcAddress}`);
+			})
+			.on('request', this.onRequest.bind(this));
+	}
+
+	dispose(): void {
+		this.handlers.clear();
+		this.server.close();
+	}
+
+	[Symbol.dispose](): void {
+		this.dispose();
+	}
+
+	// Awaits server close; use only when deterministic teardown is required (e.g., tests).
+	// Production callers should use dispose() — UnifiedDisposable contract is sync.
+	shutdown(): Promise<void> {
+		this.handlers.clear();
+		return new Promise<void>(resolve => {
+			this.server.close(() => resolve());
+		});
+	}
+
+	registerHandler(name: string, handler: IpcHandler<Request, Response>): UnifiedDisposable {
+		const path = `/${name}`;
+		if (this.handlers.has(path)) {
+			throw new Error(`IPC handler '${name}' is already registered`);
+		}
+
+		this.handlers.set(path, handler);
+		return createDisposable(() => this.handlers.delete(path));
+	}
+
+	@debug({ args: false })
+	private onRequest(req: IncomingMessage, res: ServerResponse): void {
+		const scope = getScopedLogger();
+
+		// Parse URL to extract pathname for routing and query parameters
+		let pathname: string | undefined;
+		let searchParams = new URLSearchParams();
+		try {
+			const url = new URL(req.url ?? '', this.ipcAddress);
+			pathname = url.pathname;
+			searchParams = url.searchParams;
+		} catch {
+			pathname = req.url;
+		}
+
+		const handler = this.handlers.get(pathname);
+		if (handler == null) {
+			scope?.warn(`IPC handler for ${pathname} not found`);
+			res.writeHead(404);
+			res.end();
+			return;
+		}
+
+		// Add bearer token authorization
+		const authHeader = req.headers['authorization'];
+		if (authHeader !== `Bearer ${this.ipcToken}`) {
+			Logger.warn(scope, `IPC handler for ${req.url} unauthorized`);
+			res.writeHead(401);
+			res.end();
+			return;
+		}
+
+		const maxBodySize = 10_485_760; // 10 MB
+		let bodySize = 0;
+		const chunks: Uint8Array[] = [];
+		req.on('data', (d: Uint8Array) => {
+			bodySize += d.length;
+			if (bodySize > maxBodySize) {
+				res.writeHead(413);
+				res.end();
+				req.destroy();
+				return;
+			}
+
+			chunks.push(d);
+		});
+		req.on('end', async () => {
+			if (bodySize > maxBodySize) return;
+
+			const body = Buffer.concat(chunks).toString('utf8');
+
+			let data: Request | undefined;
+			try {
+				data = body ? (JSON.parse(body) as Request) : undefined;
+			} catch (ex) {
+				scope?.error(ex, 'Invalid JSON in IPC request body', { body: body });
+				res.writeHead(400);
+				res.end('Invalid JSON');
+				return;
+			}
+
+			try {
+				const result = await handler(data, searchParams);
+				if (result == null) {
+					res.writeHead(200);
+					res.end();
+					return;
+				}
+
+				if (typeof result === 'string') {
+					res.writeHead(200);
+					res.end(result);
+				} else {
+					res.writeHead(200);
+					res.end(JSON.stringify(result));
+				}
+			} catch (ex) {
+				scope?.error(ex, 'IPC handler error', data);
+				res.writeHead(500);
+				res.end();
+			}
+		});
+	}
+}