import * as Cache from "effect/Cache";
import * as Clock from "effect/Clock";
import * as Data from "effect/Data";
import * as Digest from "effect/crypto/Digest";
import * as DateTime from "effect/DateTime";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Hex from "effect/encoding/Hex";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
import * as Ref from "effect/Ref";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";
import * as Schedule from "effect/Schedule";
import * as Scope from "effect/Scope";
import * as Semaphore from "effect/Semaphore";
import * as Stream from "effect/Stream";
import { ChildProcess, ChildProcessSpawner } from "effect/process";
import {
GitCommandError,
type GitCommandFailureReason,
T3_PROJECT_FILE_NAME,
type ReviewBranchCommitsInput,
type ReviewDiffFileContentsInput,
type ReviewDiffPreviewInput,
type ReviewDiffFileStat,
type ReviewDiffPreviewSource,
type VcsRef,
} from "@t3tools/contracts";
import { dedupeRemoteBranchesWithLocalMatches } from "@t3tools/shared/git";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { compactTraceAttributes } from "@t3tools/shared/observability";
import { decodeJsonResult } from "@t3tools/shared/schemaJson";
import { resolveSpawnCommand, runsGitWithoutConsole } from "@t3tools/shared/shell";
import { parseT3ProjectFile } from "@t3tools/shared/t3ProjectFile";
import { resolveProjectFileBackedSetting } from "@t3tools/shared/projectSettings";
import { gitCommandDuration, gitCommandsTotal, withMetrics } from "../observability/Metrics.ts";
import * as GitVcsDriver from "./GitVcsDriver.ts";
import { removeEmptyDirectory, type RemoveEmptyDirectoryError } from "./removeEmptyDirectory.ts";
import { explicitBareRepositoryEnv, gitConfigEnv } from "./VcsProcess.ts";
import { removeLinkedWorktree } from "./worktreeRemoval.ts";
import { resolveWorktreesDirectory } from "../worktreesDirectory.ts";
import {
parseRemoteNames,
parseRemoteNamesInGitOrder,
parseRemoteRefWithRemoteNames,
} from "../git/remoteRefs.ts";
import { makeIsServerInternalPath } from "../auth/serverInternalPaths.ts";
import * as ServerConfig from "../config.ts";
import { sourceControlDefinitions } from "../sourceControl/sourceControlDefinitions.ts";
const DEFAULT_TIMEOUT_MS = 30_000;
/** T3's record of the branch, named as on the host, that a branch was cut from. */
const branchBaseConfigKey = (branch: string) => `branch.${branch}.t3-merge-base`;
/**
* Where T3 kept that record before it had a key of its own, for every host alike: the GitHub
* CLI's key, which branches cut before then still carry instead.
*/
const legacyBranchBaseConfigKey = (branch: string) => `branch.${branch}.gh-merge-base`;
const gitProcesses = Semaphore.makeUnsafe(8);
const backgroundGitProcesses = Semaphore.makeUnsafe(2);
const WORKTREE_REMOVE_TIMEOUT_MS = Duration.toMillis(Duration.minutes(5));
const DEFAULT_MAX_OUTPUT_BYTES = 1_000_000;
const OUTPUT_TRUNCATED_MARKER = "\n\n[truncated]";
const PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES = 49_000;
const RANGE_COMMIT_SUMMARY_MAX_OUTPUT_BYTES = 19_000;
const RANGE_DIFF_SUMMARY_MAX_OUTPUT_BYTES = 19_000;
const RANGE_DIFF_PATCH_MAX_OUTPUT_BYTES = 59_000;
const REVIEW_DIFF_PATCH_MAX_OUTPUT_BYTES = 120_000;
const REVIEW_METADATA_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
// Temporary-index git add scales poorly (50k files took ~30 s); report incomplete totals above this cap.
const REVIEW_UNTRACKED_MAX_FILES = 5_000;
const REVIEW_DIFF_FILE_MAX_OUTPUT_BYTES = 1024 * 1024;
const REVIEW_BRANCH_COMMIT_LIMIT = 100;
const REVIEW_BRANCH_SUBJECT_LIMIT = 300;
const REVIEW_BRANCH_COMMIT_MAX_OUTPUT_BYTES = 128 * 1024;
// Client patch parsers require a/ and b/ prefixes; override user diff prefix settings.
export const PATCH_RENDER_PREFIX_ARGS = ["--src-prefix=a/", "--dst-prefix=b/"] as const;
// Client patch parsers drop blank context lines under diff.suppressBlankEmpty and summaries under diff.submodule.
const REVIEW_DIFF_ARGS = [
"-c",
"diff.suppressBlankEmpty=false",
"diff",
"--find-renames",
"--no-color",
"--no-ext-diff",
"--no-textconv",
"--submodule=short",
...PATCH_RENDER_PREFIX_ARGS,
];
const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
const STATUS_UPSTREAM_FETCH_TIMEOUT = Duration.minutes(5);
const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2_048;
const REPOSITORY_PATHS_CACHE_CAPACITY = 2_048;
const REPOSITORY_PATHS_CACHE_TTL = Duration.minutes(10);
const REPOSITORY_PATHS_REFRESH_COALESCE_TTL = Duration.seconds(5);
const NON_REPOSITORY_PATHS_CACHE_TTL = Duration.seconds(1);
const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
const STATUS_DEFAULT_BRANCH_CACHE_TTL = Duration.minutes(5);
const STATUS_ORIGIN_EXISTS_CACHE_TTL = Duration.minutes(5);
const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
GCM_INTERACTIVE: "never",
GIT_ASKPASS: "",
GIT_TERMINAL_PROMPT: "0",
SSH_ASKPASS: "",
SSH_ASKPASS_REQUIRE: "never",
} satisfies NodeJS.ProcessEnv);
const DEFAULT_BASE_BRANCH_CANDIDATES = ["main", "master"] as const;
const GIT_LIST_BRANCHES_DEFAULT_LIMIT = 100;
const NON_REPOSITORY_STATUS_DETAILS = Object.freeze<GitVcsDriver.GitStatusDetails>({
isRepo: false,
hasOriginRemote: false,
isDefaultBranch: false,
branch: null,
upstreamRef: null,
hasWorkingTreeChanges: false,
workingTree: { files: [], insertions: 0, deletions: 0 },
hasUpstream: false,
aheadCount: 0,
behindCount: 0,
aheadOfDefaultCount: 0,
});
const NON_REPOSITORY_REMOTE_STATUS_DETAILS = Object.freeze<GitVcsDriver.GitRemoteStatusDetails>({
isRepo: false,
defaultBranch: null,
isDefaultBranch: false,
branch: null,
upstreamRef: null,
hasUpstream: false,
aheadCount: 0,
behindCount: 0,
aheadOfDefaultCount: 0,
});
type TraceTailState = {
processedChars: number;
remainder: string;
};
class StatusRemoteRefreshCacheKey extends Data.Class<{
gitCommonDir: string;
remoteName: string;
}> {}
function statusUpstreamRefreshFailureCooldown(consecutiveFailures: number): Duration.Duration {
const exponent = Math.max(0, consecutiveFailures - 1);
const cooldownMs =
Duration.toMillis(STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN) * Math.pow(2, exponent);
return Duration.min(Duration.millis(cooldownMs), STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN);
}
class GitRefsSnapshotCacheKey extends Data.Class<{
gitCommonDir: string;
epoch: number;
}> {}
class GitRefsRefreshCacheKey extends Data.Class<{
gitCommonDir: string;
generation: number;
}> {}
interface GitRepositoryPaths {
readonly gitCommonDir: string;
readonly worktreeRoot: string | null;
readonly isAtRepositoryRoot: boolean | undefined;
readonly currentBranch: string | null;
}
interface GitRefsSnapshot {
readonly localBranches: ReadonlyArray<VcsRef>;
readonly remoteBranches: ReadonlyArray<VcsRef>;
readonly hasPrimaryRemote: boolean;
}
interface ExecuteGitOptions {
stdin?: string | undefined;
timeoutMs?: number | null | undefined;
forceKillAfterMs?: number | undefined;
allowNonZeroExit?: boolean | undefined;
fallbackErrorDetail?: string | undefined;
env?: NodeJS.ProcessEnv | undefined;
maxOutputBytes?: number | undefined;
appendTruncationMarker?: boolean | undefined;
progress?: GitVcsDriver.ExecuteGitProgress | undefined;
writesSharedConfig?: boolean | undefined;
}
function parseBranchAb(value: string): { ahead: number; behind: number } {
const match = value.match(/^\+(\d+)\s+-(\d+)$/);
if (!match) return { ahead: 0, behind: 0 };
return {
ahead: Number(match[1] ?? "0"),
behind: Number(match[2] ?? "0"),
};
}
function parseReviewNumstat(stdout: string): ReviewDiffFileStat[] {
const fields = stdout.split("\0");
const files: ReviewDiffFileStat[] = [];
for (let index = 0; index < fields.length; index++) {
const field = fields[index]!;
const match = /^(\d+|-)\t(\d+|-)\t([\s\S]*)$/.exec(field);
if (!match) continue;
const previousPath = match[3] === "" ? fields[++index]! : null;
const path = previousPath !== null ? fields[++index]! : match[3]!;
files.push({
path,
previousPath,
additions: match[1] === "-" ? 0 : Number(match[1]),
deletions: match[2] === "-" ? 0 : Number(match[2]),
});
}
return files;
}
// Space-separated fields precede the path in each porcelain v2 record type. The path itself
// may contain spaces, so it is everything after them.
const PORCELAIN_V2_FIELDS_BEFORE_PATH: Record<string, number> = {
"1": 8,
"2": 9,
u: 10,
"?": 1,
"!": 1,
};
function parsePorcelainPath(record: string): string | null {
const fieldsBeforePath = PORCELAIN_V2_FIELDS_BEFORE_PATH[record[0] ?? ""];
if (fieldsBeforePath === undefined) return null;
const filePath = record.split(" ").slice(fieldsBeforePath).join(" ");
return filePath.length > 0 ? filePath : null;
}
function filterBranchesForListQuery(
refs: ReadonlyArray<VcsRef>,
query?: string,
): ReadonlyArray<VcsRef> {
if (!query) {
return refs;
}
const normalizedQuery = query.toLowerCase();
return refs.filter((refName) => refName.name.toLowerCase().includes(normalizedQuery));
}
function paginateBranches(input: {
refs: ReadonlyArray<VcsRef>;
cursor?: number | undefined;
limit?: number | undefined;
}): {
refs: ReadonlyArray<VcsRef>;
nextCursor: number | null;
totalCount: number;
} {
const cursor = input.cursor ?? 0;
const limit = input.limit ?? GIT_LIST_BRANCHES_DEFAULT_LIMIT;
const totalCount = input.refs.length;
const refs = input.refs.slice(cursor, cursor + limit);
const nextCursor = cursor + refs.length < totalCount ? cursor + refs.length : null;
return {
refs,
nextCursor,
totalCount,
};
}
function parseWorktreeBranchPaths(stdout: string): ReadonlyMap<string, string> {
const worktreePaths = new Map<string, string>();
let currentPath: string | null = null;
let currentBranch: string | null = null;
let currentPrunable = false;
const flush = () => {
if (currentPath !== null && currentBranch !== null && !currentPrunable) {
worktreePaths.set(currentBranch, currentPath);
}
currentPath = null;
currentBranch = null;
currentPrunable = false;
};
for (const field of stdout.split("\0")) {
if (field === "") {
flush();
} else if (field.startsWith("worktree ")) {
currentPath = field.slice("worktree ".length);
} else if (field.startsWith("branch refs/heads/")) {
currentBranch = field.slice("branch refs/heads/".length);
} else if (field === "prunable" || field.startsWith("prunable ")) {
currentPrunable = true;
}
}
flush();
return worktreePaths;
}
function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
const parts = input.split("\0");
if (parts.length === 0) return [];
if (truncated && parts[parts.length - 1]?.length) {
parts.pop();
}
return parts.filter((value) => value.length > 0);
}
export function splitNullSeparatedGitStdoutPaths(
result: Pick<GitVcsDriver.ExecuteGitResult, "stdout" | "stdoutTruncated">,
): string[] {
return splitNullSeparatedPaths(result.stdout, result.stdoutTruncated);
}
// Checkout/worktree add parse leading dashes as options; pre-2.44 Git cannot guard with --end-of-options.
// A lone - still means previous checkout.
const refuseOptionLikeRefName = (operation: string, cwd: string, refName: string | undefined) =>
refName !== undefined && refName !== "-" && refName.startsWith("-")
? Effect.fail(
new GitCommandError({
operation,
command: "git",
cwd,
detail: "Ref names cannot start with '-'.",
}),
)
: Effect.void;
function sanitizeRemoteName(value: string): string {
const sanitized = value
.trim()
.replace(/[^A-Za-z0-9._-]+/g, "-")
.replace(/^-+|-+$/g, "");
return sanitized.length > 0 ? sanitized : "fork";
}
function parseRemoteFetchUrls(stdout: string): Map<string, string> {
const remotes = new Map<string, string>();
for (const line of stdout.split("\n")) {
const trimmed = line.trim();
if (trimmed.length === 0) continue;
// Partial clones append the promisor filter, e.g. `(fetch) [blob:none]`.
const match = /^(\S+)\s+(\S+)\s+\((fetch|push)\)(?:\s+\[[^\]]+\])?$/.exec(trimmed);
if (!match) continue;
const [, remoteName = "", remoteUrl = "", direction = ""] = match;
if (direction !== "fetch" || remoteName.length === 0 || remoteUrl.length === 0) {
continue;
}
remotes.set(remoteName, remoteUrl);
}
return remotes;
}
function parseUpstreamRefWithRemoteNames(
upstreamRef: string,
remoteNames: ReadonlyArray<string>,
): { upstreamRef: string; remoteName: string; branchName: string } | null {
const parsed = parseRemoteRefWithRemoteNames(upstreamRef, remoteNames);
if (!parsed) {
return null;
}
return {
upstreamRef,
remoteName: parsed.remoteName,
branchName: parsed.branchName,
};
}
function parseUpstreamRefByFirstSeparator(
upstreamRef: string,
): { upstreamRef: string; remoteName: string; branchName: string } | null {
const separatorIndex = upstreamRef.indexOf("/");
if (separatorIndex <= 0 || separatorIndex === upstreamRef.length - 1) {
return null;
}
const remoteName = upstreamRef.slice(0, separatorIndex).trim();
const branchName = upstreamRef.slice(separatorIndex + 1).trim();
if (remoteName.length === 0 || branchName.length === 0) {
return null;
}
return {
upstreamRef,
remoteName,
branchName,
};
}
function parseTrackingBranchByUpstreamRef(stdout: string, upstreamRef: string): string | null {
for (const line of stdout.split("\n")) {
const trimmedLine = line.trim();
if (trimmedLine.length === 0) {
continue;
}
const [branchNameRaw, upstreamBranchRaw = ""] = trimmedLine.split("\t");
const branchName = branchNameRaw?.trim() ?? "";
const candidateUpstreamRef = upstreamBranchRaw.trim();
if (branchName.length === 0 || candidateUpstreamRef.length === 0) {
continue;
}
if (candidateUpstreamRef === upstreamRef) {
return branchName;
}
}
return null;
}
function deriveLocalBranchNameFromRemoteRef(branchName: string): string | null {
const separatorIndex = branchName.indexOf("/");
if (separatorIndex <= 0 || separatorIndex === branchName.length - 1) {
return null;
}
const localBranch = branchName.slice(separatorIndex + 1).trim();
return localBranch.length > 0 ? localBranch : null;
}
function gitCommandContext(
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
) {
return {
operation: input.operation,
command: "git",
cwd: input.cwd,
argumentCount: input.args.length,
} as const;
}
// Stderr can echo credentials from argv/URLs; classify fixed patterns without exposing matched text.
const GIT_FAILURE_REASON_PATTERNS: ReadonlyArray<readonly [RegExp, GitCommandFailureReason]> = [
[/would clobber existing tag/i, "tag_would_be_clobbered"],
[/is already (?:used by worktree at|checked out at)/i, "branch_checked_out_in_worktree"],
[/a branch named .+ already exists/i, "branch_already_exists"],
// The same prefix also reports permission errors, which retrying cannot fix.
[/could not lock config file .+: File exists/i, "config_locked"],
[
/(?:authentication failed|could not read Username|could not read Password|permission denied \([a-z-]+(?:,[a-z-]+)*\)|permission denied, please try again)/i,
"authentication_failed",
],
[/host key verification failed/i, "host_key_unverified"],
[
/(?:could not read from remote repository|does not appear to be a git repository|repository .+ not found)/i,
"remote_unreachable",
],
// Unquoted already-exists errors also describe ref/tag collisions; require quoted paths.
[/fatal: '[^']+' already exists|destination path .+ already exists/i, "path_already_exists"],
// Ambiguous revision/path and pathspec failures can name files, so omit them.
// Anchor to a diagnostic line to avoid matching quoted paths in other errors.
[
/^fatal: (?:invalid reference: |not a valid object name|needed a single revision|bad revision |'.+' is not a commit and a branch '.+' cannot be created from it)/im,
"ref_not_found",
],
// `[remote rejected]` is only printed for a push. The remote's explanation
// follows in parentheses; it is server text, so it is never quoted.
[/^[ \t]*![ \t]+\[remote rejected\]/im, "push_rejected_by_remote"],
// A fetch into a diverged local branch prints the same `[rejected]` line, but
// only a push goes on to report "failed to push some refs".
[
/^[ \t]*![ \t]+\[rejected\][^\n]*\((?:non-fast-forward|fetch first)\)[\s\S]*^error: failed to push some refs/im,
"push_rejected_non_fast_forward",
],
];
// Reasons the user can act on get a sentence in place of the generic detail.
const GIT_FAILURE_REASON_DETAILS: Partial<Record<GitCommandFailureReason, string>> = {
push_rejected_by_remote:
"The remote rejected the push. Push this branch from a terminal to see the server's message.",
push_rejected_non_fast_forward:
"The remote has commits this branch doesn't have. Pull or rebase, then push again.",
config_locked:
"Another Git process kept the repository's config locked. Wait for it to finish, then retry.",
};
function gitFailureDetail(reason: GitCommandFailureReason | null): string {
return (
(reason === null ? undefined : GIT_FAILURE_REASON_DETAILS[reason]) ??
"Git command exited with a non-zero status."
);
}
// Existing non-commit objects share the missing-ref fatal diagnostic; Git
// distinguishes them with a separate error line.
const GIT_NOT_A_COMMIT_PATTERN = /^error: .+(?:, not a commit|expected commit type)/im;
// Trust only Git's diagnostic prefixes: local hooks can write indistinguishable text.
// Exclude `remote:` too, since it prefixes remote hook output as well as server diagnostics.
const GIT_DIAGNOSTIC_LINE_PATTERN = /^(?:fatal|error):|^!\s|^\s+!\s/;
// SSH credential refusals are unprefixed; Git's later generic error would otherwise misclassify them as unreachable.
const SSH_TRANSPORT_REFUSAL_PATTERN =
/Permission denied \((?:publickey|password|keyboard-interactive)|Permission denied, please try again|Host key verification failed/i;
function classifyGitFailure(stderr: string): GitCommandFailureReason | null {
const diagnostics = stderr
.split(/\r?\n/)
.filter(
(line) =>
GIT_DIAGNOSTIC_LINE_PATTERN.test(line) ||
(!/^remote:/.test(line) && SSH_TRANSPORT_REFUSAL_PATTERN.test(line)),
)
.join("\n");
if (diagnostics.length === 0) return null;
if (isNonRepositoryGitStderr(diagnostics)) return "not_a_repository";
for (const [pattern, reason] of GIT_FAILURE_REASON_PATTERNS) {
if (!pattern.test(diagnostics)) continue;
if (reason === "ref_not_found" && GIT_NOT_A_COMMIT_PATTERN.test(diagnostics)) continue;
return reason;
}
return null;
}
// `--short` and `--abbrev-ref` print `heads/<name>` when a tag shares the branch's name, so
// branch reads take the full ref and strip the prefix themselves.
function branchNameFromHeadRef(value: string): string | null {
const ref = value.trim();
return ref.startsWith("refs/heads/") && ref.length > "refs/heads/".length
? ref.slice("refs/heads/".length)
: null;
}
function parseDefaultBranchFromRemoteHeadRef(value: string, remoteName: string): string | null {
const trimmed = value.trim();
const prefix = `refs/remotes/${remoteName}/`;
if (!trimmed.startsWith(prefix)) {
return null;
}
const refName = trimmed.slice(prefix.length).trim();
return refName.length > 0 ? refName : null;
}
function isMissingGitCwdError(error: GitCommandError): boolean {
if (!(error.cause instanceof PlatformError.PlatformError)) {
return false;
}
const reason = error.cause.reason;
if (reason._tag === "NotFound") {
return reason.pathOrDescriptor === error.cwd;
}
return (
reason._tag === "BadResource" &&
reason.pathOrDescriptor === error.cwd &&
typeof reason.cause === "object" &&
reason.cause !== null &&
"code" in reason.cause &&
reason.cause.code === "ENOTDIR"
);
}
function isNonRepositoryGitStderr(stderr: string): boolean {
return stderr.toLowerCase().includes("not a git repository");
}
function isUnbornHeadStderr(stderr: string): boolean {
const normalized = stderr.toLowerCase();
return (
normalized.includes("bad revision 'head'") ||
(normalized.includes("unknown revision") && normalized.includes("path not in the working tree"))
);
}
// Git reports missing worktree registrations and registered-but-deleted paths differently.
function isMissingWorktreeStderr(stderr: string): boolean {
const normalized = stderr.toLowerCase();
return (
normalized.includes("is not a working tree") ||
normalized.includes("cannot remove working tree")
);
}
// Fetch stderr can carry credentials; persist only fixed diagnoses or generic failures.
function fetchFailureDetail(stderr: string): string | undefined {
const lines = stderr.split(/\r?\n/).map((line) => line.trim());
if (
lines.some((line) =>
/^(?:fatal: (?:Authentication failed|could not read (?:Username|Password))\b|\S+: Permission denied \(publickey)/i.test(
line,
),
)
) {
return "Git could not authenticate with the remote. Check Git credentials or SSH access on the server, then retry.";
}
if (
lines.some((line) =>
/^(?:(?:fatal: |ssh: )?Could not resolve host(?:name)?\b|fatal: unable to access .+: (?:Could not resolve host|Failed to connect)\b|ssh: connect to host \S+ port \d+: (?:Connection timed out|Connection refused|Network is unreachable)\b)/i.test(
line,
),
)
) {
return "Git could not reach the remote. Check the server's network connection and remote host, then retry.";
}
if (
lines.some((line) =>
/^(?:remote: Repository not found\.?$|fatal: repository .+ not found$|fatal: .+ does not appear to be a git repository$)/i.test(
line,
),
)
) {
return "Git could not access the remote repository. Check the remote URL and repository permissions on the server.";
}
if (isRefLockFailure(stderr)) {
return "Git could not update a local reference. Another Git operation or a stale lock may be blocking the fetch; check the repository on the server, then retry.";
}
return undefined;
}
// Git 2.53+ reports ref races as fetching-ref failures; older versions say cannot lock ref.
function isRefLockFailure(stderr: string): boolean {
return stderr
.split(/\r?\n/)
.some((line) =>
/^(?:(?:error|fatal): cannot lock ref\b|fatal: Unable to create ['"].+\.lock['"]:|error: fetching ref \S+ failed: (?:incorrect old value provided|reference already exists)$)/i.test(
line.trim(),
),
);
}
interface Trace2Monitor {
readonly env: NodeJS.ProcessEnv;
readonly flush: Effect.Effect<void, never>;
}
const nowUnixNano = DateTime.now.pipe(
Effect.map((now) => BigInt(DateTime.toEpochMillis(now)) * 1_000_000n),
);
const addCurrentSpanEvent =
/* This helper annotates the existing operation span. */
Effect.fnUntraced(
function* (name: string, attributes: Record<string, unknown>) {
const span = yield* Effect.currentSpan;
const timestamp = yield* nowUnixNano;
yield* Effect.sync(() => {
span.event(name, timestamp, compactTraceAttributes(attributes));
});
},
Effect.catchTags({
NoSuchElementError: () => Effect.void,
}),
);
// Nested Git processes share the trace file but reuse child IDs in their own sessions.
function trace2ChildKey(record: Record<string, unknown>): string | null {
const childId = record.child_id;
if (typeof childId === "number" || typeof childId === "string") {
return typeof record.sid === "string" ? `${record.sid}\n${childId}` : String(childId);
}
const hookName = record.hook_name;
return typeof hookName === "string" && hookName.trim().length > 0 ? hookName.trim() : null;
}
const Trace2Record = Schema.Record(Schema.String, Schema.Unknown);
const decodeTrace2Record = decodeJsonResult(Trace2Record);
const createTrace2Monitor = Effect.fnUntraced(function* (
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
progress: GitVcsDriver.ExecuteGitProgress | undefined,
): Effect.fn.Return<
Trace2Monitor,
PlatformError.PlatformError,
Scope.Scope | FileSystem.FileSystem | Path.Path
> {
if (!progress?.onHookStarted && !progress?.onHookFinished) {
return {
env: {},
flush: Effect.void,
};
}
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const traceFilePath = yield* fs.makeTempFileScoped({
prefix: `t3code-git-trace2-${process.pid}-`,
suffix: ".json",
});
const hookStartByChildKey = new Map<string, { hookName: string; startedAtMs: number }>();
const traceTailState = yield* Ref.make<TraceTailState>({
processedChars: 0,
remainder: "",
});
const handleTraceLine = Effect.fn("handleTraceLine")(function* (line: string) {
const trimmedLine = line.trim();
if (trimmedLine.length === 0) {
return;
}
const traceRecord = decodeTrace2Record(trimmedLine);
if (Result.isFailure(traceRecord)) {
yield* Effect.logDebug(
`GitVcsDriver.trace2: failed to parse trace line for ${input.operation} in ${input.cwd} (${input.args.length} arguments)`,
traceRecord.failure,
);
return;
}
const event = traceRecord.success.event;
const childKey = trace2ChildKey(traceRecord.success);
if (childKey === null) {
return;
}
const started = hookStartByChildKey.get(childKey);
const hookNameFromEvent =
typeof traceRecord.success.hook_name === "string" ? traceRecord.success.hook_name.trim() : "";
const hookName = hookNameFromEvent.length > 0 ? hookNameFromEvent : (started?.hookName ?? "");
if (hookName.length === 0) {
return;
}
if (event === "child_start") {
if (traceRecord.success.child_class !== "hook") {
return;
}
const now = yield* DateTime.now;
hookStartByChildKey.set(childKey, { hookName, startedAtMs: DateTime.toEpochMillis(now) });
yield* addCurrentSpanEvent("git.hook.started", {
hookName,
});
if (progress.onHookStarted) {
yield* progress.onHookStarted(hookName);
}
return;
}
if (event === "child_exit" && started) {
hookStartByChildKey.delete(childKey);
const code = traceRecord.success.code;
const exitCode = typeof code === "number" && Number.isInteger(code) ? code : null;
const now = yield* DateTime.now;
const durationMs = Math.max(0, DateTime.toEpochMillis(now) - started.startedAtMs);
yield* addCurrentSpanEvent("git.hook.finished", {
hookName: started.hookName,
exitCode,
durationMs,
});
if (progress.onHookFinished) {
yield* progress.onHookFinished({
hookName: started.hookName,
exitCode,
durationMs,
});
}
}
});
const deltaMutex = yield* Semaphore.make(1);
const readTraceDelta = deltaMutex.withPermit(
fs.readFileString(traceFilePath).pipe(
Effect.flatMap((contents) =>
Effect.uninterruptible(
Ref.modify(traceTailState, ({ processedChars, remainder }) => {
if (contents.length <= processedChars) {
return [[], { processedChars, remainder }];
}
const appended = contents.slice(processedChars);
const combined = remainder + appended;
const lines = combined.split("\n");
const nextRemainder = lines.pop() ?? "";
return [
lines.map((line) => line.replace(/\r$/, "")),
{
processedChars: contents.length,
remainder: nextRemainder,
},
];
}).pipe(
Effect.flatMap((lines) => Effect.forEach(lines, handleTraceLine, { discard: true })),
),
),
),
Effect.ignore({ log: true }),
),
);
const traceFileName = path.basename(traceFilePath);
yield* Stream.runForEach(fs.watch(traceFilePath), (event) => {
const eventPath = event.path;
const isTargetTraceEvent =
eventPath === traceFilePath ||
eventPath === traceFileName ||
path.basename(eventPath) === traceFileName;
if (!isTargetTraceEvent) return Effect.void;
return readTraceDelta;
}).pipe(Effect.ignoreCause({ log: true }), Effect.forkScoped);
const finalizeTrace2Monitor = Effect.fn("finalizeTrace2Monitor")(function* () {
yield* readTraceDelta;
const finalLine = yield* Ref.modify(traceTailState, ({ processedChars, remainder }) => [
remainder.trim(),
{
processedChars,
remainder: "",
},
]);
if (finalLine.length > 0) {
yield* handleTraceLine(finalLine);
}
});
yield* Effect.addFinalizer(finalizeTrace2Monitor);
return {
env: {
GIT_TRACE2_EVENT: traceFilePath,
},
flush: readTraceDelta,
};
});
const GIT_CHECKOUT_PROGRESS_LINE = /Updating files:\s+(\d+)%\s+\((\d+)\/(\d+)\)/;
export function parseGitCheckoutProgressLine(
line: string,
): { percent: number; completed: number; total: number } | null {
const match = GIT_CHECKOUT_PROGRESS_LINE.exec(line);
if (!match) return null;
const percent = Number(match[1]);
const completed = Number(match[2]);
const total = Number(match[3]);
if (!Number.isFinite(percent) || !Number.isFinite(completed) || !Number.isFinite(total)) {
return null;
}
return { percent: Math.max(0, Math.min(100, percent)), completed, total };
}
const OUTPUT_LINE_SEPARATOR = /\r\n|\r|\n/;
const collectOutput = Effect.fnUntraced(function* (
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>,
maxOutputBytes: number,
appendTruncationMarker: boolean,
onLine: ((line: string) => Effect.Effect<void, never>) | undefined,
keepLineCallbacksAfterTruncation = false,
): Effect.fn.Return<{ readonly text: string; readonly truncated: boolean }, GitCommandError> {
const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
const lineDecoder = keepLineCallbacksAfterTruncation && onLine ? new TextDecoder() : null;
let bytes = 0;
let text = "";
let lineBuffer = "";
let truncated = false;
// Bound newline-free output; oversized lines are not useful to callbacks.
const maxPendingLineBytes = 64 * 1024;
// Git redraws progress with bare CR; treat it as a line break.
const emitCompleteLines = Effect.fnUntraced(function* (flush: boolean) {
let separator = OUTPUT_LINE_SEPARATOR.exec(lineBuffer);
while (separator) {
const line = lineBuffer.slice(0, separator.index);
lineBuffer = lineBuffer.slice(separator.index + separator[0].length);
if (line.length > 0 && onLine) {
yield* onLine(line);
}
separator = OUTPUT_LINE_SEPARATOR.exec(lineBuffer);
}
if (flush) {
const trailing = lineBuffer;
lineBuffer = "";
if (trailing.length > 0 && onLine) {
yield* onLine(trailing);
}
}
});
const processChunk = Effect.fnUntraced(function* (chunk: Uint8Array) {
if (appendTruncationMarker && truncated) {
if (lineDecoder) {
lineBuffer += lineDecoder.decode(chunk, { stream: true });
yield* emitCompleteLines(false);
if (lineBuffer.length > maxPendingLineBytes) lineBuffer = "";
}
return;
}
const nextBytes = bytes + chunk.byteLength;
if (!appendTruncationMarker && nextBytes > maxOutputBytes) {
return yield* new GitCommandError({
...gitCommandContext(input),
detail: `Git output exceeded ${maxOutputBytes} bytes and was truncated.`,
outputLength: nextBytes,
});
}
const chunkToDecode =
appendTruncationMarker && nextBytes > maxOutputBytes
? chunk.subarray(0, Math.max(0, maxOutputBytes - bytes))
: chunk;
bytes += chunkToDecode.byteLength;
truncated = appendTruncationMarker && nextBytes > maxOutputBytes;
const decoded = decoder.decode(chunkToDecode, { stream: !truncated });
text += decoded;
if (onLine) {
lineBuffer += lineDecoder ? lineDecoder.decode(chunk, { stream: true }) : decoded;
yield* emitCompleteLines(false);
}
});
yield* Stream.runForEach(stream, processChunk).pipe(
Effect.catchTags({
PlatformError: (cause) =>
new GitCommandError({
...gitCommandContext(input),
detail: "Failed to read Git process output.",
cause,
}),
}),
);
const remainder = truncated ? "" : decoder.decode();
text += remainder;
if (onLine) {
lineBuffer += remainder;
if (lineDecoder) lineBuffer += lineDecoder.decode();
yield* emitCompleteLines(true);
}
return {
text,
truncated,
};
});
/** Windows Git needs core.longpaths beyond MAX_PATH (260); OS LongPathsEnabled alone is insufficient. */
export const windowsLongPathConfigEnv = (
platform: NodeJS.Platform,
env: NodeJS.ProcessEnv,
): NodeJS.ProcessEnv =>
platform === "win32" ? gitConfigEnv(env, "core.longpaths", "true", platform) : {};
export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const { worktreesDir } = yield* ServerConfig.ServerConfig;
const isServerInternalPath = yield* makeIsServerInternalPath;
const digest = yield* Digest.Digest;
const hostPlatform = yield* HostProcess.Platform;
const serviceScope = yield* Effect.scope;
const statusFetches = new Map<string, Fiber.Fiber<void, GitCommandError>>();
const statusFetchProcesses = yield* Semaphore.make(4);
const executeRaw: GitVcsDriver.GitVcsDriver["Service"]["execute"] = Effect.fnUntraced(
function* (input) {
const commandInput = {
...input,
args: [...input.args],
} as const;
const timeoutMs = input.timeoutMs === undefined ? DEFAULT_TIMEOUT_MS : input.timeoutMs;
const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
const appendTruncationMarker = input.appendTruncationMarker ?? false;
const runGitCommand = Effect.fn("runGitCommand")(function* () {
const trace2Monitor = yield* createTrace2Monitor(commandInput, input.progress).pipe(
Effect.provideService(Path.Path, path),
Effect.provideService(FileSystem.FileSystem, fileSystem),
Effect.mapError(
(cause) =>
new GitCommandError({
...gitCommandContext(commandInput),
detail: "Failed to create Git trace monitor.",
cause,
}),
),
);
const baseEnv = {
...(yield* HostProcess.Environment),
// Concurrent status polls must not take index.lock to save refreshed indexes.
GIT_OPTIONAL_LOCKS: "0",
...input.env,
...trace2Monitor.env,
};
const env = { ...baseEnv, ...explicitBareRepositoryEnv(baseEnv, hostPlatform) };
const spawnEnv = { ...env, ...windowsLongPathConfigEnv(hostPlatform, env) };
const resolved = yield* resolveSpawnCommand("git", [], { env: spawnEnv });
// cmd wrappers truncate multiline commits; leave git.cmd handling to Node lookup.
const executable = resolved.shell ? "git" : resolved.command;
const child = yield* commandSpawner
.spawn(
ChildProcess.make(executable, commandInput.args, {
cwd: commandInput.cwd,
env: spawnEnv,
forceKillAfter: input.forceKillAfterMs,
...(runsGitWithoutConsole(hostPlatform, executable, commandInput.args)
? { detached: true, windowsHide: true }
: {}),
}),
)
.pipe(
Effect.mapError(
(cause) =>
new GitCommandError({
...gitCommandContext(commandInput),
detail: "Failed to spawn Git process.",
cause,
}),
),
);
const [stdout, stderr, exitCode] = yield* Effect.all(
[
collectOutput(
commandInput,
child.stdout,
maxOutputBytes,
appendTruncationMarker,
input.progress?.onStdoutLine,
input.keepLineCallbacksAfterTruncation,
),
collectOutput(
commandInput,
child.stderr,
maxOutputBytes,
appendTruncationMarker,
input.progress?.onStderrLine,
input.keepLineCallbacksAfterTruncation,
),
child.exitCode.pipe(
Effect.mapError(
(cause) =>
new GitCommandError({
...gitCommandContext(commandInput),
detail: "Failed to read Git process exit code.",
cause,
}),
),
),
input.stdin === undefined
? Effect.void
: Stream.run(Stream.encodeText(Stream.make(input.stdin)), child.stdin).pipe(
Effect.mapError(
(cause) =>
new GitCommandError({
...gitCommandContext(commandInput),
detail: "Failed to write Git process input.",
cause,
}),
),
),
],
{ concurrency: "unbounded" },
).pipe(Effect.map(([stdout, stderr, exitCode]) => [stdout, stderr, exitCode] as const));
yield* trace2Monitor.flush;
if (!input.allowNonZeroExit && exitCode !== 0) {
const reason = classifyGitFailure(stderr.text);
return yield* new GitCommandError({
...gitCommandContext(commandInput),
...(reason === null ? {} : { reason }),
detail: gitFailureDetail(reason),
exitCode,
stdoutLength: stdout.text.length,
stderrLength: stderr.text.length,
});
}
return {
exitCode,
stdout: stdout.text,
stderr: stderr.text,
stdoutTruncated: stdout.truncated,
stderrTruncated: stderr.truncated,
} satisfies GitVcsDriver.ExecuteGitResult;
});
const execution = runGitCommand().pipe(Effect.scoped);
if (timeoutMs === null) {
return yield* execution;
}
return yield* execution.pipe(
Effect.timeoutOption(timeoutMs),
Effect.flatMap((result) =>
Effect.fromOption(
result,
() =>
new GitCommandError({
...gitCommandContext(commandInput),
detail: "Git command timed out.",
}),
),
),
);
},
);
const sharedConfigLocks = new Map<string, Semaphore.Semaphore>();
const withSharedConfigLock = <A, E>(cwd: string, effect: Effect.Effect<A, E>) =>
resolveRepositoryPaths(cwd).pipe(
Effect.orElseSucceed(() => null),
Effect.flatMap((repositoryPaths) => {
if (repositoryPaths === null) return effect;
let lock = sharedConfigLocks.get(repositoryPaths.gitCommonDir);
if (lock === undefined) {
lock = Semaphore.makeUnsafe(1);
sharedConfigLocks.set(repositoryPaths.gitCommonDir, lock);
}
return lock.withPermit(effect);
}),
);
const execute: GitVcsDriver.GitVcsDriver["Service"]["execute"] = (input) =>
executeRaw(input).pipe(
withMetrics({
counter: gitCommandsTotal,
timer: gitCommandDuration,
attributes: {
operation: input.operation,
},
}),
(execution) =>
input.timeoutMs === null || (input.timeoutMs ?? DEFAULT_TIMEOUT_MS) > DEFAULT_TIMEOUT_MS
? execution
: Effect.gen(function* () {
const lane = (yield* GitVcsDriver.BackgroundGitWork)
? backgroundGitProcesses
: gitProcesses;
return yield* lane.withPermits(1)(execution);
}),
Effect.withSpan(input.operation, {
kind: "client",
attributes: {
"git.operation": input.operation,
"git.cwd": input.cwd,
"git.args_count": input.args.length,
},
}),
// Outside the process permit: resolving the repository may itself need one.
(execution) =>
input.writesSharedConfig ? withSharedConfigLock(input.cwd, execution) : execution,
);
const executeGit = (
operation: string,
cwd: string,
args: readonly string[],
options: ExecuteGitOptions = {},
): Effect.Effect<GitVcsDriver.ExecuteGitResult, GitCommandError> =>
execute({
operation,
cwd,
args,
...(options.stdin !== undefined ? { stdin: options.stdin } : {}),
...(options.env !== undefined ? { env: options.env } : {}),
allowNonZeroExit: true,
...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
...(options.forceKillAfterMs !== undefined
? { forceKillAfterMs: options.forceKillAfterMs }
: {}),
...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
...(options.appendTruncationMarker !== undefined
? { appendTruncationMarker: options.appendTruncationMarker }
: {}),
...(options.progress ? { progress: options.progress } : {}),
...(options.writesSharedConfig ? { writesSharedConfig: true } : {}),
}).pipe(
Effect.flatMap((result) => {
if (options.allowNonZeroExit || result.exitCode === 0) {
return Effect.succeed(result);
}
const reason = classifyGitFailure(result.stderr);
return Effect.fail(
new GitCommandError({
...gitCommandContext({ operation, cwd, args }),
...(reason === null ? {} : { reason }),
detail: options.fallbackErrorDetail ?? gitFailureDetail(reason),
...(result.exitCode === null ? {} : { exitCode: result.exitCode }),
stdoutLength: result.stdout.length,
stderrLength: result.stderr.length,
}),
);
}),
);
const executeGitWithStableDiagnostics = (
operation: string,
cwd: string,
args: readonly string[],
options: ExecuteGitOptions = {},
): Effect.Effect<GitVcsDriver.ExecuteGitResult, GitCommandError> =>
executeGit(operation, cwd, args, {
...options,
env: {
...options.env,
// English diagnostics without overriding LC_CTYPE, which hooks inherit.
LANGUAGE: "C",
},
});
const runGit = (
operation: string,
cwd: string,
args: readonly string[],
options: ExecuteGitOptions = {},
): Effect.Effect<void, GitCommandError> =>
executeGit(operation, cwd, args, options).pipe(Effect.asVoid);
const runGitStdout = (
operation: string,
cwd: string,
args: readonly string[],
allowNonZeroExit = false,
): Effect.Effect<string, GitCommandError> =>
executeGit(operation, cwd, args, { allowNonZeroExit }).pipe(
Effect.map((result) => result.stdout),
);
// Pre-2.36 Git rejects worktree list -z; normalize its line fallback to NUL records.
const executeWorktreeList = Effect.fn("executeWorktreeList")(function* (
operation: string,
cwd: string,
gitArgs: readonly string[],
options: ExecuteGitOptions = {},
) {
const args = [...gitArgs, "worktree", "list", "--porcelain"];
const result = yield* executeGit(operation, cwd, [...args, "-z"], {
...options,
allowNonZeroExit: true,
});
if (result.exitCode === 0) return result;
const lineResult = yield* executeGit(operation, cwd, args, options);
return { ...lineResult, stdout: lineResult.stdout.replaceAll("\n", "\0") };
});
const runGitStdoutWithOptions = (
operation: string,
cwd: string,
args: readonly string[],
options: ExecuteGitOptions = {},
): Effect.Effect<string, GitCommandError> =>
executeGit(operation, cwd, args, options).pipe(
Effect.map((result) =>
result.stdoutTruncated ? `${result.stdout}${OUTPUT_TRUNCATED_MARKER}` : result.stdout,
),
);
const branchExists = (cwd: string, refName: string): Effect.Effect<boolean, GitCommandError> =>
executeGit(
"GitVcsDriver.branchExists",
cwd,
["show-ref", "--verify", "--quiet", `refs/heads/${refName}`],
{
allowNonZeroExit: true,
timeoutMs: 5_000,
},
).pipe(Effect.map((result) => result.exitCode === 0));
const resolveAvailableBranchName = Effect.fn("resolveAvailableBranchName")(function* (
cwd: string,
requestedBranch: string,
) {
// A branch at a parent path (such as `t3`) blocks every ref nested under it, so no suffix
// would help; flatten to a sibling the way temporary worktree branches already do.
const segments = requestedBranch.split("/");
let blockedByParent = false;
for (let index = 1; index < segments.length && !blockedByParent; index += 1) {
blockedByParent = yield* branchExists(cwd, segments.slice(0, index).join("/"));
}
const desiredBranch = blockedByParent ? segments.join("-") : requestedBranch;
// A branch nested under the name (`t3-fix/child`) blocks it as surely as one with the name.
const isBranchNameTaken = (name: string) =>
Effect.zipWith(
branchExists(cwd, name),
runGitStdout(
"GitVcsDriver.branchExists",
cwd,
["for-each-ref", "--count=1", "--format=%(refname)", `refs/heads/${name}/`],
true,
),
(exists, nested) => exists || nested.trim().length > 0,
);
const isDesiredTaken = yield* isBranchNameTaken(desiredBranch);
if (!isDesiredTaken) {
return desiredBranch;
}
for (let suffix = 1; suffix <= 100; suffix += 1) {
const candidate = `${desiredBranch}-${suffix}`;
const isCandidateTaken = yield* isBranchNameTaken(candidate);
if (!isCandidateTaken) {
return candidate;
}
}
return yield* new GitCommandError({
...gitCommandContext({
operation: "GitVcsDriver.renameBranch",
cwd,
args: ["branch", "-m", "--", desiredBranch],
}),
detail: `Could not find an available branch name for '${desiredBranch}'.`,
});
});
// `--abbrev-ref` prints `remotes/origin/<name>` when a local `origin/<name>` branch exists.
const readCurrentUpstreamRef = Effect.fn("readCurrentUpstreamRef")(function* (cwd: string) {
const upstreamRef = yield* runGitStdout(
"GitVcsDriver.resolveCurrentUpstream",
cwd,
["rev-parse", "--symbolic-full-name", "@{upstream}"],
true,
).pipe(Effect.map((stdout) => stdout.trim().replace(/^refs\/(?:remotes|heads)\//, "")));
if (upstreamRef.length === 0 || upstreamRef === "@{upstream}") {
return null;
}
return upstreamRef;
});
const resolveCurrentUpstream = Effect.fn("resolveCurrentUpstream")(function* (
cwd: string,
knownUpstreamRef?: string,
) {
const upstreamRef = knownUpstreamRef ?? (yield* readCurrentUpstreamRef(cwd));
if (upstreamRef === null) {
return null;
}
const remoteNames = yield* runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe(
Effect.map(parseRemoteNames),
Effect.orElseSucceed((): ReadonlyArray<string> => []),
);
return (
parseUpstreamRefWithRemoteNames(upstreamRef, remoteNames) ??
parseUpstreamRefByFirstSeparator(upstreamRef)
);
});
const fetchRemoteForStatus = Effect.fn("GitVcsDriver.fetchRemoteForStatus.wait")(function* (
gitCommonDir: string,
remoteName: string,
) {
const fetchCwd =
path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
// `--no-auto-gc` (a synonym of `--no-auto-maintenance` that older Git also knows) keeps
// this poll from starting `git gc --auto`. When that gc fails, for example on a repository
// with missing objects, Git retries it on every fetch and leaves a full-size `tmp_pack_*`
// behind each time, so a background poll could fill the disk.
const args = [
"--git-dir",
gitCommonDir,
"fetch",
"--quiet",
"--no-tags",
"--no-auto-gc",
"--",
remoteName,
];
const key = `${gitCommonDir}\0${remoteName}`;
const failure = statusRemoteRefreshFailures.get(key);
if (failure && (yield* Clock.currentTimeMillis) < failure.retryAt) return;
const fiber = yield* Effect.uninterruptible(
Effect.gen(function* () {
const pending = statusFetches.get(key);
if (pending) return pending;
// Frequent poll deadlines and disconnected clients must not interrupt a
// healthy writer. A separate safety limit prevents a hung transport from
// occupying its worker slot indefinitely.
const started = yield* executeGit("GitVcsDriver.fetchRemoteForStatus", fetchCwd, args, {
env: STATUS_UPSTREAM_REFRESH_ENV,
fallbackErrorDetail: "Background Git fetch exited with a non-zero status.",
timeoutMs: Duration.toMillis(STATUS_UPSTREAM_FETCH_TIMEOUT),
forceKillAfterMs: 1_000,
}).pipe(
Effect.asVoid,
Effect.tap(() =>
Effect.sync(() => {
statusRemoteRefreshFailures.delete(key);
}),
),
Effect.tapError(() => recordStatusRemoteRefreshFailure(key)),
Effect.tapCause((cause) => Effect.logWarning("Background Git fetch failed", cause)),
statusFetchProcesses.withPermits(1),
Effect.onExit(() =>
Effect.sync(() => {
statusFetches.delete(key);
}),
),
Effect.forkIn(serviceScope, { startImmediately: false, uninterruptible: false }),
);
statusFetches.set(key, started);
return started;
}),
);
const result = yield* Fiber.join(fiber).pipe(
Effect.timeoutOption(STATUS_UPSTREAM_REFRESH_TIMEOUT),
);
if (Option.isNone(result)) {
yield* Effect.logDebug(
"Background Git fetch is still running; using the last fetched references.",
);
}
});
const readGitCommonDir = Effect.fn("readGitCommonDir")(function* (cwd: string) {
// Git reports relative paths from the physical cwd, which can differ from a symlink.
const commonDirResult = yield* executeGitWithStableDiagnostics(
"GitVcsDriver.resolveRepositoryPaths.commonDir",
cwd,
["rev-parse", "--git-common-dir"],
{
timeoutMs: 5_000,
allowNonZeroExit: true,
},
);
if (commonDirResult.exitCode !== 0) {
const stderr = commonDirResult.stderr.trim();
if (isNonRepositoryGitStderr(stderr)) {
return null;
}
return yield* new GitCommandError({
...gitCommandContext({
operation: "GitVcsDriver.resolveRepositoryPaths.commonDir",
cwd,
args: ["rev-parse", "--git-common-dir"],
}),
detail: "Failed to resolve the Git common directory.",
exitCode: commonDirResult.exitCode,
stdoutLength: commonDirResult.stdout.length,
stderrLength: commonDirResult.stderr.length,
});
}
const commonDirOutput = commonDirResult.stdout.trim();
const physicalCwd = yield* fileSystem.realPath(cwd).pipe(Effect.orElseSucceed(() => cwd));
const resolvedGitCommonDir = path.isAbsolute(commonDirOutput)
? path.normalize(commonDirOutput)
: path.resolve(physicalCwd, commonDirOutput);
return yield* fileSystem
.realPath(resolvedGitCommonDir)
.pipe(Effect.orElseSucceed(() => resolvedGitCommonDir));
});
const readWorktreeRoot = Effect.fn("readWorktreeRoot")(function* (cwd: string) {
const result = yield* executeGit(
"GitVcsDriver.resolveRepositoryPaths.worktreeRoot",
cwd,
["rev-parse", "--show-toplevel"],
{
timeoutMs: 5_000,
allowNonZeroExit: true,
},
);
// Git terminates --show-toplevel with exactly one "\n" on every platform (stdout is
// binary mode on Windows). Whitespace before it belongs to the path and must survive,
// because this root becomes the editor target for every repository-relative status path.
const output = result.stdout.endsWith("\n") ? result.stdout.slice(0, -1) : result.stdout;
return result.exitCode === 0 && output.length > 0
? path.normalize(path.isAbsolute(output) ? output : path.resolve(cwd, output))
: null;
});
const resolveRepositoryPathsUncached = Effect.fn("resolveRepositoryPathsUncached")(function* (
cwd: string,
) {
const gitCommonDir = yield* readGitCommonDir(cwd);
if (gitCommonDir === null) return null;
const [worktreeRoot, currentBranchResult] = yield* Effect.all(
[
readWorktreeRoot(cwd),
executeGit(
"GitVcsDriver.resolveRepositoryPaths.currentBranch",
cwd,
["symbolic-ref", "--quiet", "HEAD"],
{
timeoutMs: 5_000,
allowNonZeroExit: true,
},
),
],
{ concurrency: 2 },
);
// Git reports physical roots, so resolve project aliases before comparing.
const isAtRepositoryRoot =
worktreeRoot === null
? undefined
: yield* fileSystem.realPath(cwd).pipe(
Effect.map((physicalCwd) => path.relative(worktreeRoot, physicalCwd) === ""),
Effect.orElseSucceed(() => undefined),
);
const currentBranch =
currentBranchResult.exitCode === 0 ? branchNameFromHeadRef(currentBranchResult.stdout) : null;
return {
gitCommonDir,
worktreeRoot,
isAtRepositoryRoot,
currentBranch,
} satisfies GitRepositoryPaths;
});
const resolveReviewWorktreeRoot = Effect.fn("resolveReviewWorktreeRoot")(function* (cwd: string) {
const worktreeRoot = yield* readWorktreeRoot(cwd);
if (worktreeRoot !== null) return { worktreeRoot, currentBranch: null };
// Full discovery tells bare and non-repository directories apart from real Git failures.
return yield* resolveRepositoryPathsUncached(cwd);
});
const repositoryPathsCache = yield* Cache.makeWith(
(cwd: string) => resolveRepositoryPathsUncached(cwd),
{
capacity: REPOSITORY_PATHS_CACHE_CAPACITY,
timeToLive: Exit.match({
onSuccess: (repositoryPaths) =>
repositoryPaths === null ? NON_REPOSITORY_PATHS_CACHE_TTL : REPOSITORY_PATHS_CACHE_TTL,
onFailure: () => Duration.zero,
}),
},
);
const repositoryPathsRefreshCache = yield* Cache.makeWith(
(cwd: string) =>
Cache.invalidate(repositoryPathsCache, cwd).pipe(
Effect.andThen(Cache.get(repositoryPathsCache, cwd)),
),
{
capacity: REPOSITORY_PATHS_CACHE_CAPACITY,
timeToLive: Exit.match({
onSuccess: (repositoryPaths) =>
repositoryPaths === null
? NON_REPOSITORY_PATHS_CACHE_TTL
: REPOSITORY_PATHS_REFRESH_COALESCE_TTL,
onFailure: () => Duration.zero,
}),
},
);
const normalizeRepositoryPathsCacheKey = (cwd: string) => path.normalize(path.resolve(cwd));
const resolveRepositoryPaths = (cwd: string, refresh = false) => {
const cacheKey = normalizeRepositoryPathsCacheKey(cwd);
return Cache.get(refresh ? repositoryPathsRefreshCache : repositoryPathsCache, cacheKey);
};
const defaultBranchCache = yield* Cache.makeWith(
(gitCommonDir: string) =>
Effect.gen(function* () {
const path = yield* Path.Path;
const fetchCwd =
path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
return yield* executeGit(
"GitVcsDriver.statusDetails.defaultBranch",
fetchCwd,
["--git-dir", gitCommonDir, "symbolic-ref", "refs/remotes/origin/HEAD"],
{ allowNonZeroExit: true },
).pipe(
Effect.map((result) => {
if (result.exitCode !== 0) return null;
return parseDefaultBranchFromRemoteHeadRef(result.stdout, "origin");
}),
);
}),
{
capacity: 2_048,
timeToLive: Exit.match({
onSuccess: () => STATUS_DEFAULT_BRANCH_CACHE_TTL,
onFailure: () => Duration.zero,
}),
},
);
const primaryRemoteExistsCache = yield* Cache.makeWith(
(gitCommonDir: string) =>
Effect.gen(function* () {
const path = yield* Path.Path;
const fetchCwd =
path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
return yield* executeGit(
"GitVcsDriver.statusDetails.primaryRemoteExists",
fetchCwd,
["--git-dir", gitCommonDir, "remote"],
{ allowNonZeroExit: true },
).pipe(Effect.map((result) => result.exitCode === 0 && result.stdout.trim().length > 0));
}),
{
capacity: 2_048,
timeToLive: Exit.match({
onSuccess: () => STATUS_ORIGIN_EXISTS_CACHE_TTL,
onFailure: () => Duration.zero,
}),
},
);
const invalidateStatusStaticCaches = Effect.fn("GitVcsDriverCore.invalidateStatusStaticCaches")(
function* (cwd: string, gitCommonDir?: string | null) {
const commonDir =
gitCommonDir === undefined
? (yield* resolveRepositoryPaths(cwd).pipe(
Effect.catchTags({ GitCommandError: () => Effect.succeed(null) }),
))?.gitCommonDir
: gitCommonDir;
const cacheKey = commonDir ?? normalizeRepositoryPathsCacheKey(cwd);
yield* Cache.invalidate(defaultBranchCache, cacheKey);
yield* Cache.invalidate(primaryRemoteExistsCache, cacheKey);
},
);
const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) {
const repositoryPaths = yield* resolveRepositoryPaths(cwd);
if (repositoryPaths !== null) {
return repositoryPaths.gitCommonDir;
}
return yield* new GitCommandError({
...gitCommandContext({
operation: "GitVcsDriver.resolveGitCommonDir",
cwd,
args: ["rev-parse", "--git-common-dir"],
}),
detail: "Cannot resolve a Git common directory outside a repository.",
});
});
const statusRemoteRefreshFailures = new Map<string, { count: number; retryAt: number }>();
const statusRemoteRefreshFailureKey = (cacheKey: StatusRemoteRefreshCacheKey) =>
`${cacheKey.gitCommonDir}\0${cacheKey.remoteName}`;
const recordStatusRemoteRefreshFailure = Effect.fn(
"GitVcsDriver.recordStatusRemoteRefreshFailure",
)(function* (key: string) {
const nextCount = (statusRemoteRefreshFailures.get(key)?.count ?? 0) + 1;
const now = yield* Clock.currentTimeMillis;
statusRemoteRefreshFailures.delete(key);
statusRemoteRefreshFailures.set(key, {
count: nextCount,
retryAt: now + Duration.toMillis(statusUpstreamRefreshFailureCooldown(nextCount)),
});
if (statusRemoteRefreshFailures.size > STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY) {
const oldestKey = statusRemoteRefreshFailures.keys().next().value;
if (oldestKey !== undefined) {
statusRemoteRefreshFailures.delete(oldestKey);
}
}
});
const refreshStatusRemoteCacheEntry = Effect.fn("refreshStatusRemoteCacheEntry")(function* (
cacheKey: StatusRemoteRefreshCacheKey,
) {
return yield* fetchRemoteForStatus(cacheKey.gitCommonDir, cacheKey.remoteName).pipe(
Effect.as(true as const),
);
});
const statusRemoteRefreshCache = yield* Cache.makeWith(refreshStatusRemoteCacheEntry, {
capacity: STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY,
// Cache/back off failed fetches while status uses old refs; repeated mounts must not cause subprocess storms.
timeToLive: (exit, cacheKey) =>
Exit.isSuccess(exit)
? STATUS_UPSTREAM_REFRESH_INTERVAL
: statusUpstreamRefreshFailureCooldown(
statusRemoteRefreshFailures.get(statusRemoteRefreshFailureKey(cacheKey))?.count ?? 1,
),
});
const refreshStatusUpstreamIfStale = Effect.fn("refreshStatusUpstreamIfStale")(function* (
cwd: string,
) {
const headRef = yield* runGitStdout(
"GitVcsDriver.refreshStatusUpstreamIfStale.headRef",
cwd,
["symbolic-ref", "--quiet", "HEAD"],
true,
).pipe(Effect.map((stdout) => stdout.trim()));
if (headRef.length === 0) return;
const remoteName = yield* runGitStdout(
"GitVcsDriver.refreshStatusUpstreamIfStale.upstreamRemote",
cwd,
["for-each-ref", "--format=%(upstream:remotename)", headRef],
true,
).pipe(Effect.map((stdout) => stdout.trim()));
// Empty means no upstream; `.` means the upstream is a local branch.
if (remoteName.length === 0 || remoteName === ".") return;
const gitCommonDir = yield* resolveGitCommonDir(cwd);
yield* Cache.get(
statusRemoteRefreshCache,
new StatusRemoteRefreshCacheKey({ gitCommonDir, remoteName }),
).pipe(Effect.ignore);
});
const resolveDefaultBranchName = (
cwd: string,
remoteName: string,
): Effect.Effect<string | null, GitCommandError> =>
executeGit(
"GitVcsDriver.resolveDefaultBranchName",
cwd,
["symbolic-ref", `refs/remotes/${remoteName}/HEAD`],
{ allowNonZeroExit: true },
).pipe(
Effect.map((result) => {
if (result.exitCode !== 0) {
return null;
}
return parseDefaultBranchFromRemoteHeadRef(result.stdout, remoteName);
}),
);
const remoteBranchExists: GitVcsDriver.GitVcsDriver["Service"]["remoteBranchExists"] = (input) =>
executeGit(
"GitVcsDriver.remoteBranchExists",
input.cwd,
["show-ref", "--verify", "--quiet", `refs/remotes/${input.remoteName}/${input.refName}`],
{
allowNonZeroExit: true,
},
).pipe(Effect.map((result) => result.exitCode === 0));
const remoteExists: GitVcsDriver.GitVcsDriver["Service"]["remoteExists"] = (input) =>
executeGit(
"GitVcsDriver.remoteExists",
input.cwd,
["remote", "get-url", "--", input.remoteName],
{
allowNonZeroExit: true,
},
).pipe(Effect.map((result) => result.exitCode === 0));
const originRemoteExists = (cwd: string): Effect.Effect<boolean, GitCommandError> =>
remoteExists({ cwd, remoteName: "origin" });
const listRemoteNames = (cwd: string): Effect.Effect<ReadonlyArray<string>, GitCommandError> =>
runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe(
Effect.map(parseRemoteNamesInGitOrder),
);
const resolvePublishBranchName = Effect.fn("resolvePublishBranchName")(function* (
cwd: string,
branchName: string,
) {
const remoteNames = yield* listRemoteNames(cwd).pipe(Effect.orElseSucceed(() => []));
const parsedRemoteRef = parseRemoteRefWithRemoteNames(branchName, remoteNames);
return parsedRemoteRef?.branchName ?? branchName;
});
const resolvePrimaryRemoteName = Effect.fn("resolvePrimaryRemoteName")(function* (cwd: string) {
if (yield* originRemoteExists(cwd)) {
return "origin";
}
const remotes = yield* listRemoteNames(cwd);
const [firstRemote] = remotes;
if (firstRemote) {
return firstRemote;
}
return yield* new GitCommandError({
...gitCommandContext({
operation: "GitVcsDriver.resolvePrimaryRemoteName",
cwd,
args: ["remote"],
}),
detail: "No git remote is configured for this repository.",
});
});
const resolvePushRemoteName = Effect.fn("resolvePushRemoteName")(function* (
cwd: string,
refName: string,
) {
const branchPushRemote = yield* runGitStdout(
"GitVcsDriver.resolvePushRemoteName.branchPushRemote",
cwd,
["config", "--get", `branch.${refName}.pushRemote`],
true,
).pipe(Effect.map((stdout) => stdout.trim()));
if (branchPushRemote.length > 0) {
return branchPushRemote;
}
const pushDefaultRemote = yield* runGitStdout(
"GitVcsDriver.resolvePushRemoteName.remotePushDefault",
cwd,
["config", "--get", "remote.pushDefault"],
true,
).pipe(Effect.map((stdout) => stdout.trim()));
if (pushDefaultRemote.length > 0) {
return pushDefaultRemote;
}
return yield* resolvePrimaryRemoteName(cwd).pipe(Effect.orElseSucceed(() => null));
});