@straiffi/archon 1.10.7 → 1.10.9

package/dist/server/lib/git.js

@@ -5,6 +5,7 @@ import { cp as cpAsync, lstat as lstatAsync, mkdir as mkdirAsync, stat as statAs
 import { tmpdir } from 'os';
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import db from '../db.js';
+import { runBoundedProcess } from './boundedProcess.js';
 import { getProjectWorktreeSync } from './projects.js';
 import { createWorkspaceProcessEnvironment } from './workspaceProcessEnvironment.js';
 export class UnpushedCommitDiffSelectionError extends Error {
@@ -12,8 +13,10 @@ export class UnpushedCommitDiffSelectionError extends Error {
 const PROJECT_BRANCH_REMOTE_REFRESH_TTL_MS = 30_000;
 const MAX_GIT_OUTPUT_BYTES = 512 * 1024 * 1024;
 const GIT_READ_TIMEOUT_MS = 15_000;
+const GIT_REMOTE_KILL_GRACE_MS = 500;
 const MAX_CONCURRENT_DIFF_PROCESSES = 8;
 const lastProjectBranchRemoteRefreshAt = new Map();
+const projectBranchRemoteRefreshes = new Map();
 const resolveCurrentBranchName = (cwd) => {
     try {
         const branch = runGitText(['branch', '--show-current'], cwd).trim();
@@ -113,6 +116,22 @@ const runGitTextAsync = (args, cwd, options = {}) => new Promise((resolvePromise
         });
     });
 });
+const runGitRemoteTextAsync = async (args, cwd) => {
+    const result = await runBoundedProcess('git', args, {
+        cwd,
+        env: createWorkspaceProcessEnvironment(cwd, { GIT_TERMINAL_PROMPT: '0' }),
+        timeoutMs: GIT_READ_TIMEOUT_MS,
+        killGraceMs: GIT_REMOTE_KILL_GRACE_MS,
+        maxOutputBytes: MAX_GIT_OUTPUT_BYTES,
+    });
+    if (result.code !== 0) {
+        const error = new Error(result.stderr.trim() || `git exited with code ${result.code ?? 'unknown'}`);
+        error.stderr = result.stderr;
+        error.status = result.code;
+        throw error;
+    }
+    return { stdout: result.stdout, stderr: result.stderr };
+};
 const mapWithConcurrency = async (inputs, concurrency, operation) => {
     const results = new Array(inputs.length);
     let nextIndex = 0;
@@ -357,7 +376,7 @@ const refreshSquashUpstream = async (branch, cwd) => {
         return localUpstreamCommitSha;
     }
     try {
-        await runGitTextAsync(['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch], cwd);
+        await runGitRemoteTextAsync(['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch], cwd);
     }
     catch {
         throw new Error('Unable to refresh the upstream branch before squashing commits. Pull or reconcile the branch and try again.');
@@ -477,21 +496,6 @@ const getEmptyProjectBranchResponse = (status = 'unknown') => ({
     can_pull: false,
     diff_stats: null,
 });
-const refreshProjectBranchTracking = (repoPath, branch) => {
-    if (!branch) {
-        return;
-    }
-    try {
-        const upstreamFetchSpec = resolveBranchUpstreamFetchSpec(branch, repoPath);
-        const args = upstreamFetchSpec
-            ? ['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch]
-            : ['fetch', '--quiet', 'origin', branch];
-        runGitText(args, repoPath);
-    }
-    catch {
-        // Keep the last known tracking state when fetch is unavailable.
-    }
-};
 const shouldRefreshProjectBranchTracking = (cacheKey, force) => {
     if (force) {
         lastProjectBranchRemoteRefreshAt.set(cacheKey, Date.now());
@@ -1390,15 +1394,9 @@ export const deleteWorktree = (branch, project = null) => {
 export const getProjectBranch = (project = null, options = {}) => {
     const repoPath = getRepoPath(project);
     const includeDiffStats = options.includeDiffStats ?? true;
-    let output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
-    let entries = output.split('\0').filter(Boolean);
-    let branchState = getBranchSyncState(entries, repoPath);
-    if (branchState.branch && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(repoPath, branchState.branch), options.refreshRemote ?? false)) {
-        refreshProjectBranchTracking(repoPath, branchState.branch);
-        output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
-        entries = output.split('\0').filter(Boolean);
-        branchState = getBranchSyncState(entries, repoPath);
-    }
+    const output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
+    const entries = output.split('\0').filter(Boolean);
+    const branchState = getBranchSyncState(entries, repoPath);
     if (!branchState.branch) {
         const statusLine = output.split('\0').find(entry => entry.startsWith('# branch.head ')) ?? '';
         if (statusLine.endsWith('(detached)')) {
@@ -1416,13 +1414,46 @@ export const getProjectBranch = (project = null, options = {}) => {
         diff_stats: includeDiffStats ? summarizeTicketDiffFiles(getGitDiffFiles(repoPath)) : null,
     };
 };
+export const getProjectBranchAsync = async (project = null, options = {}) => {
+    const repoPath = getRepoPath(project);
+    const includeDiffStats = options.includeDiffStats ?? true;
+    const readBranchState = async () => {
+        const output = (await runGitTextAsync(['status', '--porcelain=v2', '--branch', '-z'], repoPath, { timeoutMs: GIT_READ_TIMEOUT_MS })).stdout;
+        const entries = output.split('\0').filter(Boolean);
+        const branchState = await getBranchSyncStateAsync(entries, repoPath, null);
+        return { output, branchState };
+    };
+    let { output, branchState } = await readBranchState();
+    if (branchState.branch && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(repoPath, branchState.branch), options.refreshRemote ?? false)) {
+        await refreshProjectBranchTrackingAsync(repoPath, branchState.branch);
+        const refreshed = await readBranchState();
+        output = refreshed.output;
+        branchState = refreshed.branchState;
+    }
+    if (!branchState.branch) {
+        const statusLine = output.split('\0').find(entry => entry.startsWith('# branch.head ')) ?? '';
+        return getEmptyProjectBranchResponse(statusLine.endsWith('(detached)') ? 'detached' : 'unknown');
+    }
+    const diffStats = includeDiffStats
+        ? summarizeTicketDiffFiles(await getGitDiffFilesAsync(repoPath))
+        : null;
+    return {
+        branch: branchState.branch,
+        status: 'ready',
+        ahead: branchState.ahead,
+        behind: branchState.behind,
+        has_upstream: branchState.hasUpstream,
+        can_pull: branchState.behind > 0,
+        diff_stats: diffStats,
+    };
+};
 export const getLocalProjectBranch = (project = null) => {
     const repoPath = getRepoPath(project);
     const output = runGitText(['status', '--porcelain=v2', '--branch', '-z'], repoPath);
     return getBranchSyncState(output.split('\0').filter(Boolean), repoPath).branch;
 };
 export const pullGitBranch = async (cwd, branch = null, project = null) => {
-    const gitStatus = getGitStatus(cwd, branch, project, { refreshRemote: true });
+    const gitStatus = await getGitStatusAsync(cwd, branch, project, { refreshRemote: true });
     if (gitStatus.pull_disabled_reason) {
         throw new Error(gitStatus.pull_disabled_reason);
     }
@@ -1433,16 +1464,16 @@ export const pullGitBranch = async (cwd, branch = null, project = null) => {
     if (!upstreamFetchSpec) {
         throw new Error(`Branch "${gitStatus.branch}" has no configured upstream.`);
     }
-    await runGitTextAsync(['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', upstreamFetchSpec.remote, upstreamFetchSpec.branch], cwd);
     await runGitTextAsync(['merge', '--no-edit', 'FETCH_HEAD'], cwd);
 };
 export const pullProjectBranch = async (project = null) => {
     const repoPath = getRepoPath(project);
-    const branchState = getProjectBranch(project, { refreshRemote: true });
+    const branchState = getProjectBranch(project, { includeDiffStats: false });
     await pullGitBranch(repoPath, branchState.branch, project);
 };
 export const rebaseGitBranchOntoBase = async (cwd, branch = null, project = null, baseBranch = null) => {
-    const gitStatus = getGitStatus(cwd, branch, project, { refreshRemote: true });
+    const gitStatus = await getGitStatusAsync(cwd, branch, project, { refreshRemote: true });
     const resolvedBaseBranch = baseBranch?.trim() || gitStatus.base_branch;
     const rebaseDisabledReason = getRebaseDisabledReason(gitStatus, resolvedBaseBranch);
     if (rebaseDisabledReason) {
@@ -1454,7 +1485,7 @@ export const rebaseGitBranchOntoBase = async (cwd, branch = null, project = null
     if (!resolvedBaseBranch || resolvedBaseBranch === gitStatus.branch) {
         throw new Error('No base branch is available for this target.');
     }
-    await runGitTextAsync(['fetch', '--quiet', 'origin', resolvedBaseBranch], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', 'origin', resolvedBaseBranch], cwd);
     await runGitTextAsync(['rebase', `origin/${resolvedBaseBranch}`], cwd);
     if (project && resolve(cwd) !== getRepoPath(project)) {
         const nextBaseCommit = resolveCommitBaseFromBaseRef(resolveNamedBranchRef(resolvedBaseBranch, cwd), cwd);
@@ -1633,9 +1664,6 @@ const applyGitActionState = (status, options) => {
 export const getGitStatus = (cwd, branch = null, project = null, options = {}) => {
     const recordedBase = branch && project ? resolveRecordedBaseForCwd(cwd, branch, project) : null;
     const branchName = branch ?? resolveCurrentBranchName(cwd);
-    if (branchName && (options.refreshRemote ?? false) && shouldRefreshProjectBranchTracking(getProjectBranchRefreshCacheKey(cwd, branchName), options.refreshRemote ?? false)) {
-        refreshProjectBranchTracking(cwd, branchName);
-    }
     try {
         const output = runGitText(['status', '--porcelain=v2', '--branch', '--untracked-files=all', '-z'], cwd);
         const parsedOutput = parseGitStatusOutput(output);
@@ -1764,18 +1792,31 @@ const resolveFallbackBaseAsync = async (branch, project) => {
         return null;
     }
 };
-const refreshProjectBranchTrackingAsync = async (cwd, branch) => {
-    try {
-        const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
-        const fetchSpec = parseRemoteBranchRef(upstreamRef);
-        const args = fetchSpec
-            ? ['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch]
-            : ['fetch', '--quiet', 'origin', branch];
-        await runGitTextAsync(args, cwd, { timeoutMs: GIT_READ_TIMEOUT_MS });
-    }
-    catch {
-        // Keep the last known tracking state when fetch is unavailable.
+const refreshProjectBranchTrackingAsync = (cwd, branch) => {
+    const key = getProjectBranchRefreshCacheKey(cwd, branch);
+    const existing = projectBranchRemoteRefreshes.get(key);
+    if (existing) {
+        return existing;
     }
+    const refresh = (async () => {
+        try {
+            const upstreamRef = await resolveBranchUpstreamRefAsync(branch, cwd);
+            const fetchSpec = parseRemoteBranchRef(upstreamRef);
+            const args = fetchSpec
+                ? ['fetch', '--quiet', fetchSpec.remote, fetchSpec.branch]
+                : ['fetch', '--quiet', 'origin', branch];
+            await runGitRemoteTextAsync(args, cwd);
+        }
+        catch {
+            // Keep the last known tracking state when fetch is unavailable.
+        }
+    })().finally(() => {
+        if (projectBranchRemoteRefreshes.get(key) === refresh) {
+            projectBranchRemoteRefreshes.delete(key);
+        }
+    });
+    projectBranchRemoteRefreshes.set(key, refresh);
+    return refresh;
 };
 const getUnreadableGitStatus = () => ({
     branch: null,
@@ -1893,7 +1934,7 @@ export const getBoardGitStatus = (cwd, branch = null, project = null) => {
     return getGitStatus(cwd, branch, project, {
         refreshRemote: false,
         includeFiles: false,
-        includeWorkspaceSignature: false,
+        includeWorkspaceSignature: true,
     });
 };
 export const getBoardWorktreeGitStatus = (branch, project = null) => {
@@ -2168,7 +2209,7 @@ export const pushAutomationTarget = async (cwd, branch, targetSha, expectedOrigi
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed after push intent was persisted');
     }
-    await runGitTextAsync(['push', '-u', 'origin', `${targetSha}:refs/heads/${branch}`], cwd);
+    await runGitRemoteTextAsync(['push', '-u', 'origin', `${targetSha}:refs/heads/${branch}`], cwd);
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed while push was running');
     }
@@ -2236,7 +2277,7 @@ export const fetchRemoteBranchState = async (cwd, branch, expectedOriginIdentity
     }
     let output;
     try {
-        output = await runGitTextAsync(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], cwd);
+        output = await runGitRemoteTextAsync(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], cwd);
     }
     catch (error) {
         if (error.status === 2) {
@@ -2251,7 +2292,7 @@ export const fetchRemoteBranchState = async (cwd, branch, expectedOriginIdentity
     if (!sha || !ref || extra || ref !== `refs/heads/${branch}` || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sha)) {
         throw new Error('Remote branch observation was incomplete');
     }
-    await runGitTextAsync(['fetch', '--quiet', '--no-tags', 'origin', sha], cwd);
+    await runGitRemoteTextAsync(['fetch', '--quiet', '--no-tags', 'origin', sha], cwd);
     if (expectedOriginIdentity && getAutomationRemoteIdentity(cwd) !== expectedOriginIdentity) {
         throw new Error('Automation origin remote changed while observing push state');
     }