@getpaseo/server 0.1.61 → 0.1.63

package/dist/server/server/workspace-git-service.js

@@ -1,14 +1,16 @@
 import { watch } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import pLimit from "p-limit";
 import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
 import { createGitHubService } from "../services/github-service.js";
 import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
 import { runGitCommand } from "../utils/run-git-command.js";
+import { resolveGitHubRemote } from "../utils/github-remote.js";
 import { listPaseoWorktrees } from "../utils/worktree.js";
 import { READ_ONLY_GIT_ENV } from "./checkout-git-utils.js";
 import { buildWorkspaceGitMetadataFromSnapshot, } from "./workspace-git-metadata.js";
-import { normalizeWorkspaceId } from "./workspace-registry-model.js";
+import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId } from "./workspace-registry-model.js";
 const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
 const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180000;
 export const WORKSPACE_GIT_SELF_HEAL_INTERVAL_MS = 60000;
@@ -17,11 +19,35 @@ const WORKING_TREE_WATCH_FALLBACK_REFRESH_MS = 5000;
 const WORKSPACE_GIT_CONSUMER_TTL_MS = 15000;
 // Non-forced refresh triggers share this minimum gap to absorb watcher/self-heal bursts; force bypasses it.
 const WORKSPACE_GIT_INTERNAL_MIN_GAP_MS = 2000;
+const linuxWatchReaddirConcurrency = parseInt(process.env.PASEO_LINUX_WATCH_READDIR_CONCURRENCY ?? "16", 10) || 16;
+const linuxWatchReaddirLimit = pLimit(linuxWatchReaddirConcurrency);
+function buildDefaultWorkspaceGitServiceDeps() {
+    return {
+        watch,
+        readdir,
+        getCheckoutStatus,
+        getCheckoutShortstat,
+        getCheckoutDiff,
+        getPullRequestStatus,
+        resolveBranchCheckout,
+        resolveRepositoryDefaultBranch,
+        listBranchSuggestions,
+        listPaseoWorktrees,
+        github: createGitHubService(),
+        resolveAbsoluteGitDir,
+        hasOriginRemote,
+        runGitFetch,
+        runGitCommand,
+        now: () => new Date(),
+    };
+}
+function resolveWorkspaceGitServiceDeps(deps) {
+    return { ...buildDefaultWorkspaceGitServiceDeps(), ...deps };
+}
 export class WorkspaceGitServiceImpl {
     constructor(options) {
         this.workspaceTargets = new Map();
         this.repoTargets = new Map();
-        this.workspaceTargetSetups = new Map();
         this.workingTreeWatchTargets = new Map();
         this.workingTreeWatchSetups = new Map();
         this.branchValidationCache = new Map();
@@ -33,34 +59,20 @@ export class WorkspaceGitServiceImpl {
         this.checkoutDiffCache = new Map();
         this.logger = options.logger.child({ module: "workspace-git-service" });
         this.paseoHome = options.paseoHome;
-        this.deps = {
-            watch: options.deps?.watch ?? watch,
-            readdir: options.deps?.readdir ?? readdir,
-            getCheckoutStatus: options.deps?.getCheckoutStatus ?? getCheckoutStatus,
-            getCheckoutShortstat: options.deps?.getCheckoutShortstat ?? getCheckoutShortstat,
-            getCheckoutDiff: options.deps?.getCheckoutDiff ?? getCheckoutDiff,
-            getPullRequestStatus: options.deps?.getPullRequestStatus ?? getPullRequestStatus,
-            resolveBranchCheckout: options.deps?.resolveBranchCheckout ?? resolveBranchCheckout,
-            resolveRepositoryDefaultBranch: options.deps?.resolveRepositoryDefaultBranch ?? resolveRepositoryDefaultBranch,
-            listBranchSuggestions: options.deps?.listBranchSuggestions ?? listBranchSuggestions,
-            listPaseoWorktrees: options.deps?.listPaseoWorktrees ?? listPaseoWorktrees,
-            github: options.deps?.github ?? createGitHubService(),
-            resolveAbsoluteGitDir: options.deps?.resolveAbsoluteGitDir ?? resolveAbsoluteGitDir,
-            hasOriginRemote: options.deps?.hasOriginRemote ?? hasOriginRemote,
-            runGitFetch: options.deps?.runGitFetch ?? runGitFetch,
-            runGitCommand: options.deps?.runGitCommand ?? runGitCommand,
-            now: options.deps?.now ?? (() => new Date()),
-        };
+        this.deps = resolveWorkspaceGitServiceDeps(options.deps);
     }
-    async subscribe(params, listener) {
+    registerWorkspace(params, listener) {
         const cwd = normalizeWorkspaceId(params.cwd);
-        const target = await this.ensureWorkspaceTarget(cwd);
+        const target = this.ensureWorkspaceTarget(cwd);
         target.listeners.add(listener);
         if (target.listeners.size === 1) {
             this.startWorkspaceSubscriptionTimers(target);
         }
+        if (!target.latestSnapshot) {
+            this.scheduleInitialWorkspaceRefresh(target);
+        }
+        this.scheduleWorkspaceObservationSetup(target);
         return {
-            initial: target.latestSnapshot ?? (await this.getSnapshot(cwd)),
             unsubscribe: () => {
                 this.removeWorkspaceListener(cwd, listener);
             },
@@ -69,12 +81,48 @@ export class WorkspaceGitServiceImpl {
     async getSnapshot(cwd, options) {
         cwd = normalizeWorkspaceId(cwd);
         const request = this.normalizeRefreshRequest(options, "getSnapshot", true);
-        const target = await this.ensureWorkspaceTarget(cwd);
+        const target = this.ensureWorkspaceTarget(cwd);
         if (!request.force && this.isSnapshotWarm(target)) {
             return target.latestSnapshot;
         }
         return this.requestWorkspaceSnapshot(target, request);
     }
+    async getCheckout(cwd) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        try {
+            const status = await this.deps.getCheckoutStatus(normalizedCwd, {
+                paseoHome: this.paseoHome,
+            });
+            if (!status.isGit) {
+                return checkoutLiteFromGitSnapshot(normalizedCwd, {
+                    isGit: false,
+                    currentBranch: null,
+                    remoteUrl: null,
+                    repoRoot: null,
+                    isPaseoOwnedWorktree: false,
+                    mainRepoRoot: null,
+                });
+            }
+            return checkoutLiteFromGitSnapshot(normalizedCwd, {
+                isGit: true,
+                currentBranch: status.currentBranch,
+                remoteUrl: status.remoteUrl,
+                repoRoot: status.repoRoot,
+                isPaseoOwnedWorktree: status.isPaseoOwnedWorktree,
+                mainRepoRoot: status.mainRepoRoot,
+            });
+        }
+        catch {
+            return checkoutLiteFromGitSnapshot(normalizedCwd, {
+                isGit: false,
+                currentBranch: null,
+                remoteUrl: null,
+                repoRoot: null,
+                isPaseoOwnedWorktree: false,
+                mainRepoRoot: null,
+            });
+        }
+    }
     peekSnapshot(cwd) {
         cwd = normalizeWorkspaceId(cwd);
         return this.workspaceTargets.get(cwd)?.latestSnapshot ?? null;
@@ -121,7 +169,7 @@ export class WorkspaceGitServiceImpl {
         return this.readAuxiliaryCache(this.localBranchCache, key, options, async () => {
             const result = await this.deps.runGitCommand(["rev-parse", "--verify", "--quiet", ref], {
                 cwd: normalizedCwd,
-                env: READ_ONLY_GIT_ENV,
+                envOverlay: READ_ONLY_GIT_ENV,
                 acceptExitCodes: [0, 1],
             });
             return result.exitCode === 0;
@@ -141,7 +189,7 @@ export class WorkspaceGitServiceImpl {
         return this.readAuxiliaryCache(this.stashListCache, key, readOptions, async () => {
             const { stdout } = await this.deps.runGitCommand(["stash", "list", "--format=%gd%x00%s"], {
                 cwd: normalizedCwd,
-                env: READ_ONLY_GIT_ENV,
+                envOverlay: READ_ONLY_GIT_ENV,
             });
             return parseWorkspaceGitStashList(stdout, { paseoOnly });
         });
@@ -176,9 +224,7 @@ export class WorkspaceGitServiceImpl {
     }
     async getWorkspaceGitMetadata(cwd, options) {
         const snapshot = await this.getSnapshot(cwd, options);
-        const directoryName = options?.directoryName ??
-            normalizeWorkspaceId(cwd).split(/[\\/]/).filter(Boolean).at(-1) ??
-            cwd;
+        const directoryName = options?.directoryName ?? normalizeWorkspaceId(cwd).split(/[\\/]/).findLast(Boolean) ?? cwd;
         return buildWorkspaceGitMetadataFromSnapshot({
             cwd: normalizeWorkspaceId(cwd),
             directoryName,
@@ -195,17 +241,14 @@ export class WorkspaceGitServiceImpl {
     }
     async refresh(cwd, _options) {
         cwd = normalizeWorkspaceId(cwd);
-        const target = this.workspaceTargets.get(cwd);
-        if (target) {
-            await this.refreshWorkspaceTarget(target, {
-                force: false,
-                includeGitHub: false,
-                reason: "refresh",
-                notify: true,
-            });
-            return;
-        }
-        await this.ensureWorkspaceTarget(cwd);
+        const target = this.ensureWorkspaceTarget(cwd);
+        await this.refreshWorkspaceTarget(target, {
+            force: false,
+            includeGitHub: false,
+            reason: "refresh",
+            notify: true,
+        });
+        this.scheduleWorkspaceObservationSetup(target);
     }
     async requestWorkingTreeWatch(cwd, onChange) {
         cwd = normalizeWorkspaceId(cwd);
@@ -230,7 +273,6 @@ export class WorkspaceGitServiceImpl {
             this.closeWorkspaceTarget(target);
         }
         this.workspaceTargets.clear();
-        this.workspaceTargetSetups.clear();
         for (const target of this.repoTargets.values()) {
             this.closeRepoTarget(target);
         }
@@ -241,20 +283,12 @@ export class WorkspaceGitServiceImpl {
         this.workingTreeWatchTargets.clear();
         this.workingTreeWatchSetups.clear();
     }
-    async ensureWorkspaceTarget(cwd) {
+    ensureWorkspaceTarget(cwd) {
         const existingTarget = this.workspaceTargets.get(cwd);
         if (existingTarget) {
             return existingTarget;
         }
-        const existingSetup = this.workspaceTargetSetups.get(cwd);
-        if (existingSetup) {
-            return existingSetup;
-        }
-        const setup = this.createWorkspaceTarget(cwd).finally(() => {
-            this.workspaceTargetSetups.delete(cwd);
-        });
-        this.workspaceTargetSetups.set(cwd, setup);
-        return setup;
+        return this.createWorkspaceTarget(cwd);
     }
     readAuxiliaryCache(cache, key, options, load) {
         if (options?.force && !options.reason) {
@@ -316,7 +350,7 @@ export class WorkspaceGitServiceImpl {
         this.workingTreeWatchSetups.set(cwd, setup);
         return setup;
     }
-    async createWorkspaceTarget(cwd) {
+    createWorkspaceTarget(cwd) {
         const target = {
             cwd,
             listeners: new Set(),
@@ -331,31 +365,67 @@ export class WorkspaceGitServiceImpl {
             latestFingerprint: null,
             lastShellOutAtMs: null,
             repoGitRoot: null,
+            cachedGitHubRemote: null,
+            observationSetupPromise: null,
+            observationSetupComplete: false,
+            closed: false,
         };
         this.workspaceTargets.set(cwd, target);
-        try {
-            await this.requestWorkspaceSnapshot(target, {
+        return target;
+    }
+    scheduleInitialWorkspaceRefresh(target) {
+        queueMicrotask(() => {
+            if (!this.isActiveObservedWorkspaceTarget(target) || target.latestSnapshot) {
+                return;
+            }
+            void this.refreshWorkspaceTarget(target, {
                 force: false,
                 includeGitHub: true,
                 reason: "initial",
-                notify: false,
+                notify: true,
             });
-            const gitDir = await this.deps.resolveAbsoluteGitDir(cwd);
-            if (!gitDir) {
-                return target;
-            }
-            const repoGitRoot = await this.resolveWorkspaceGitRefsRoot(gitDir);
-            target.repoGitRoot = repoGitRoot;
-            this.startWorkspaceWatchers(target, gitDir, repoGitRoot);
-            await this.ensureRepoTarget(target);
-            return target;
+        });
+    }
+    scheduleWorkspaceObservationSetup(target) {
+        if (target.observationSetupComplete ||
+            target.observationSetupPromise ||
+            !this.isActiveObservedWorkspaceTarget(target)) {
+            return;
         }
-        catch (error) {
-            this.closeWorkspaceTarget(target);
-            this.workspaceTargets.delete(cwd);
-            throw error;
+        target.observationSetupPromise = Promise.resolve()
+            .then(() => this.setupWorkspaceObservation(target))
+            .catch((error) => {
+            this.logger.warn({ err: error, cwd: target.cwd }, "Failed to set up workspace git observation");
+        })
+            .finally(() => {
+            target.observationSetupPromise = null;
+        });
+    }
+    async setupWorkspaceObservation(target) {
+        const gitDir = await this.deps.resolveAbsoluteGitDir(target.cwd);
+        if (!this.isActiveObservedWorkspaceTarget(target)) {
+            return;
+        }
+        if (!gitDir) {
+            target.observationSetupComplete = true;
+            return;
+        }
+        const repoGitRoot = await this.resolveWorkspaceGitRefsRoot(gitDir);
+        if (!this.isActiveObservedWorkspaceTarget(target)) {
+            return;
+        }
+        target.repoGitRoot = repoGitRoot;
+        this.startWorkspaceWatchers(target, gitDir, repoGitRoot);
+        await this.ensureRepoTarget(target);
+        if (this.isActiveObservedWorkspaceTarget(target)) {
+            target.observationSetupComplete = true;
         }
     }
+    isActiveObservedWorkspaceTarget(target) {
+        return (!target.closed &&
+            target.listeners.size > 0 &&
+            this.workspaceTargets.get(target.cwd) === target);
+    }
     async createWorkingTreeWatchTarget(cwd) {
         const repoRoot = await this.resolveCheckoutWatchRoot(cwd);
         const target = {
@@ -415,7 +485,7 @@ export class WorkspaceGitServiceImpl {
         try {
             const { stdout } = await this.deps.runGitCommand(["rev-parse", "--show-toplevel"], {
                 cwd,
-                env: READ_ONLY_GIT_ENV,
+                envOverlay: READ_ONLY_GIT_ENV,
             });
             return parseGitRevParsePath(stdout);
         }
@@ -457,7 +527,7 @@ export class WorkspaceGitServiceImpl {
     }
     async ensureRepoTarget(workspaceTarget) {
         const repoGitRoot = workspaceTarget.repoGitRoot;
-        if (!repoGitRoot) {
+        if (!repoGitRoot || !this.isActiveObservedWorkspaceTarget(workspaceTarget)) {
             return;
         }
         const existingTarget = this.repoTargets.get(repoGitRoot);
@@ -466,6 +536,9 @@ export class WorkspaceGitServiceImpl {
             return;
         }
         const hasOrigin = await this.deps.hasOriginRemote(workspaceTarget.cwd);
+        if (!this.isActiveObservedWorkspaceTarget(workspaceTarget)) {
+            return;
+        }
         if (!hasOrigin) {
             return;
         }
@@ -490,13 +563,16 @@ export class WorkspaceGitServiceImpl {
         const target = typeof targetOrCwd === "string"
             ? this.workspaceTargets.get(normalizeWorkspaceId(targetOrCwd))
             : targetOrCwd;
-        if (!target) {
+        if (!target || target.closed || this.workspaceTargets.get(target.cwd) !== target) {
             return;
         }
         if (target.debounceTimer) {
             clearTimeout(target.debounceTimer);
         }
         target.debounceTimer = setTimeout(() => {
+            if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
+                return;
+            }
             target.debounceTimer = null;
             void this.refreshWorkspaceTarget(target, {
                 force: options?.force === true,
@@ -509,6 +585,7 @@ export class WorkspaceGitServiceImpl {
     startWorkspaceSubscriptionTimers(target) {
         if (!target.selfHealTimer) {
             target.selfHealTimer = setInterval(() => {
+                this.scheduleWorkspaceObservationSetup(target);
                 this.getSnapshot(target.cwd, { reason: "self-heal-git" }).catch((error) => {
                     this.logger.warn({ err: error, cwd: target.cwd, reason: "self-heal-git" }, "Failed to run workspace git self-heal refresh");
                 });
@@ -527,7 +604,9 @@ export class WorkspaceGitServiceImpl {
             return;
         }
         const headRef = snapshot.git.currentBranch;
-        if (!headRef || !hasGitHubRemoteUrl(snapshot.git.remoteUrl)) {
+        const hasGitHubRemote = target.cachedGitHubRemote?.remoteUrl === snapshot.git.remoteUrl &&
+            target.cachedGitHubRemote.identity !== null;
+        if (!headRef || !hasGitHubRemote) {
             this.stopGitHubPollForTarget(target);
             return;
         }
@@ -540,6 +619,9 @@ export class WorkspaceGitServiceImpl {
             cwd: target.cwd,
             headRef,
             onStatus: () => {
+                if (!this.isActiveObservedWorkspaceTarget(target)) {
+                    return;
+                }
                 void this.refreshWorkspaceTarget(target, {
                     force: false,
                     includeGitHub: true,
@@ -656,30 +738,38 @@ export class WorkspaceGitServiceImpl {
     }
     async listLinuxWatchDirectories(rootPath) {
         const directories = [];
-        const pending = [rootPath];
-        while (pending.length > 0) {
-            const directory = pending.pop();
-            if (!directory) {
-                continue;
-            }
-            directories.push(directory);
-            let entries;
-            try {
-                entries = await this.deps.readdir(directory, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                if (!entry.isDirectory() || entry.name === ".git") {
+        let currentLevel = [rootPath];
+        while (currentLevel.length > 0) {
+            directories.push(...currentLevel);
+            const readResults = await Promise.all(currentLevel.map((directory) => linuxWatchReaddirLimit(async () => {
+                try {
+                    return await this.deps.readdir(directory, { withFileTypes: true });
+                }
+                catch {
+                    return null;
+                }
+            })));
+            const nextLevel = [];
+            for (let i = 0; i < currentLevel.length; i += 1) {
+                const directory = currentLevel[i];
+                const entries = readResults[i];
+                if (!directory || !entries)
                     continue;
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.name === ".git") {
+                        continue;
+                    }
+                    nextLevel.push(join(directory, entry.name));
                 }
-                pending.push(join(directory, entry.name));
             }
+            currentLevel = nextLevel;
         }
         return directories;
     }
     async refreshWorkspaceTarget(target, request) {
+        if (target.closed || this.workspaceTargets.get(target.cwd) !== target) {
+            return;
+        }
         try {
             await this.requestWorkspaceSnapshot(target, request);
         }
@@ -730,6 +820,18 @@ export class WorkspaceGitServiceImpl {
         }
         return (this.deps.now().getTime() - target.latestSnapshotLoadedAtMs <= WORKSPACE_GIT_CONSUMER_TTL_MS);
     }
+    async resolveGitHubRemoteForTarget(target, remoteUrl) {
+        if (!remoteUrl) {
+            target.cachedGitHubRemote = null;
+            return null;
+        }
+        if (target.cachedGitHubRemote?.remoteUrl === remoteUrl) {
+            return target.cachedGitHubRemote.identity;
+        }
+        const identity = await resolveGitHubRemote({ remoteUrl });
+        target.cachedGitHubRemote = { remoteUrl, identity };
+        return identity;
+    }
     shouldThrottleNonForcedRefresh(target) {
         if (!target.latestSnapshot || target.lastShellOutAtMs === null) {
             return false;
@@ -780,9 +882,45 @@ export class WorkspaceGitServiceImpl {
         if (forceGitHub) {
             this.deps.github.invalidate({ cwd: target.cwd });
         }
-        const snapshot = await loadWorkspaceGitRuntimeSnapshot(target.cwd, { paseoHome: this.paseoHome }, now, this.deps, { force: request.force, forceGitHub, reason: request.reason });
+        const cwd = target.cwd;
+        const context = { paseoHome: this.paseoHome };
+        const checkoutStatus = await this.deps.getCheckoutStatus(cwd, context);
+        if (!checkoutStatus.isGit) {
+            target.latestSnapshotLoadedAtMs = now.getTime();
+            return buildNotGitSnapshot(cwd);
+        }
+        const githubRemote = await this.resolveGitHubRemoteForTarget(target, checkoutStatus.remoteUrl);
+        const [diffStat, github] = await Promise.all([
+            this.deps.getCheckoutShortstat(cwd, context, { force: request.force }).catch(() => null),
+            loadGitHubSnapshot({
+                cwd,
+                githubRemote,
+                now,
+                deps: this.deps,
+                force: forceGitHub,
+                reason: request.reason,
+            }),
+        ]);
         target.latestSnapshotLoadedAtMs = now.getTime();
-        return snapshot;
+        return {
+            cwd,
+            git: {
+                isGit: true,
+                repoRoot: checkoutStatus.repoRoot,
+                mainRepoRoot: checkoutStatus.mainRepoRoot,
+                currentBranch: checkoutStatus.currentBranch,
+                remoteUrl: checkoutStatus.remoteUrl,
+                isPaseoOwnedWorktree: checkoutStatus.isPaseoOwnedWorktree,
+                isDirty: checkoutStatus.isDirty,
+                baseRef: checkoutStatus.baseRef,
+                aheadBehind: checkoutStatus.aheadBehind,
+                aheadOfOrigin: checkoutStatus.aheadOfOrigin,
+                behindOfOrigin: checkoutStatus.behindOfOrigin,
+                hasRemote: checkoutStatus.hasRemote,
+                diffStat,
+            },
+            github,
+        };
     }
     rememberSnapshot(target, snapshot, options) {
         target.latestSnapshot = snapshot;
@@ -866,6 +1004,7 @@ export class WorkspaceGitServiceImpl {
         this.workingTreeWatchTargets.delete(cwd);
     }
     closeWorkspaceTarget(target) {
+        target.closed = true;
         if (target.debounceTimer) {
             clearTimeout(target.debounceTimer);
             target.debounceTimer = null;
@@ -901,44 +1040,8 @@ export class WorkspaceGitServiceImpl {
         target.workspaceKeys.clear();
     }
 }
-async function loadWorkspaceGitRuntimeSnapshot(cwd, context, now, deps, options) {
-    const checkoutStatus = await deps.getCheckoutStatus(cwd, context);
-    if (!checkoutStatus.isGit) {
-        return buildNotGitSnapshot(cwd);
-    }
-    const [diffStat, github] = await Promise.all([
-        deps.getCheckoutShortstat(cwd, context, { force: options?.force }),
-        loadGitHubSnapshot({
-            cwd,
-            remoteUrl: checkoutStatus.remoteUrl,
-            now,
-            deps,
-            force: options?.forceGitHub,
-            reason: options?.reason,
-        }),
-    ]);
-    return {
-        cwd,
-        git: {
-            isGit: true,
-            repoRoot: checkoutStatus.repoRoot,
-            mainRepoRoot: checkoutStatus.isPaseoOwnedWorktree ? checkoutStatus.mainRepoRoot : null,
-            currentBranch: checkoutStatus.currentBranch,
-            remoteUrl: checkoutStatus.remoteUrl,
-            isPaseoOwnedWorktree: checkoutStatus.isPaseoOwnedWorktree,
-            isDirty: checkoutStatus.isDirty,
-            baseRef: checkoutStatus.baseRef,
-            aheadBehind: checkoutStatus.aheadBehind,
-            aheadOfOrigin: checkoutStatus.aheadOfOrigin,
-            behindOfOrigin: checkoutStatus.behindOfOrigin,
-            hasRemote: checkoutStatus.hasRemote,
-            diffStat,
-        },
-        github,
-    };
-}
 async function loadGitHubSnapshot(options) {
-    if (!hasGitHubRemoteUrl(options.remoteUrl)) {
+    if (!options.githubRemote) {
         return {
             featuresEnabled: false,
             pullRequest: null,
@@ -976,14 +1079,6 @@ async function loadGitHubSnapshot(options) {
         };
     }
 }
-function hasGitHubRemoteUrl(remoteUrl) {
-    if (!remoteUrl) {
-        return false;
-    }
-    return (remoteUrl.includes("github.com/") ||
-        remoteUrl.startsWith("git@github.com:") ||
-        remoteUrl.startsWith("ssh://git@github.com/"));
-}
 function parseWorkspaceGitStashList(stdout, options) {
     const entries = [];
     const lines = stdout.trim().split("\n").filter(Boolean);
@@ -1038,10 +1133,7 @@ function buildNotGitSnapshot(cwd) {
 async function runGitFetch(cwd) {
     await runGitCommand(["fetch", "origin", "--prune"], {
         cwd,
-        env: {
-            ...process.env,
-            GIT_TERMINAL_PROMPT: "0",
-        },
+        envOverlay: { GIT_TERMINAL_PROMPT: "0" },
         timeout: 120000,
     });
 }