@hyperdrive.bot/fleet-server 0.3.157 → 0.3.158

package/dist/server/utils/git-command-cache.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Per-repo cache for read-only git commands the daemon repeats many times a second
+ * (config --get, rev-parse, symbolic-ref, show-ref, ...). Every git spawn from the
+ * daemon used to cost about 100ms of blocked event loop, and the same questions
+ * were asked over and over.
+ *
+ * Correctness first:
+ * - Repo location answers are cached until the `.git` entry changes.
+ * - Config and ref answers are keyed by a fingerprint of cheap stat() calls (HEAD,
+ *   the ref files named in the command, packed-refs, FETCH_HEAD, repo/worktree/
+ *   global config) AND expire after a short TTL (PASEO_GIT_CACHE_TTL_MS, 5s). The
+ *   TTL is the backstop for what the fingerprint cannot see: include/includeIf
+ *   targets, vendor system configs, and updates to nested ref files
+ *   (refs/heads/feature/x) that do not touch any watched directory.
+ * - Working tree commands (status, ls-files --others, diff --shortstat) are never
+ *   cached: identical concurrent calls share one spawn, nothing more.
+ * - Anything with `@{...}` (upstream/push/reflog) is not cached at all.
+ * - Reftable repos are not cached.
+ * Any git command not on the read-only list invalidates the repo's entries.
+ */
+type CommandClass = 
+/** Answer depends only on where the repository is. */
+"location"
+/** Depends on config files. */
+ | "config"
+/** Depends on HEAD and refs. */
+ | "refs"
+/** Depends on the working tree: single-flight only, never kept after settling. */
+ | "worktree";
+export interface GitRepoDirs {
+    /** The `.git` entry (dir or gitfile) found walking up from cwd. */
+    dotGit: string;
+    /** Worktree-specific git dir (holds HEAD and index). */
+    gitDir: string;
+    /** Shared git dir (holds config, refs, packed-refs). */
+    commonDir: string;
+}
+export interface GitCacheStats {
+    hits: number;
+    misses: number;
+    coalesced: number;
+    invalidations: number;
+}
+export declare function isGitCacheEnabled(): boolean;
+export declare function isReadOnlyCommand(args: readonly string[]): boolean;
+/** Classify a command, or return null when it must not be cached. */
+export declare function classifyGitCommand(args: readonly string[]): CommandClass | null;
+export declare class GitCommandCache {
+    private readonly entries;
+    private readonly dirsByCwd;
+    private readonly generations;
+    readonly stats: GitCacheStats;
+    clear(): void;
+    /**
+     * Walk up from cwd to the `.git` entry and resolve worktree gitfiles and
+     * `commondir`. Pure filesystem work, no git spawn; cached per cwd briefly and
+     * re-validated by the `.git` entry still existing.
+     */
+    resolveRepoDirs(cwd: string): GitRepoDirs | null;
+    run<T>(args: readonly string[], cwd: string, env: Record<string, string | undefined> | undefined, extraKey: string, execute: () => Promise<T>): Promise<T>;
+    invalidate(commonDir: string): void;
+    private evictIfNeeded;
+}
+export declare function findRepoDirs(cwd: string): GitRepoDirs | null;
+export declare function getSharedGitCommandCache(): GitCommandCache;
+export {};
+//# sourceMappingURL=git-command-cache.d.ts.map

package/dist/server/utils/git-command-cache.js

@@ -0,0 +1,436 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+const MAX_ENTRIES = 5000;
+const DIRS_CACHE_TTL_MS = 5000;
+const ENV_KEYS_THAT_BYPASS = [
+    "GIT_DIR",
+    "GIT_WORK_TREE",
+    "GIT_INDEX_FILE",
+    "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_GLOBAL",
+    "GIT_CONFIG_SYSTEM",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
+    "GIT_CONFIG_NOSYSTEM",
+    "GIT_NAMESPACE",
+];
+function cacheTtlMs() {
+    const raw = process.env.PASEO_GIT_CACHE_TTL_MS;
+    const parsed = raw === undefined ? NaN : Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 5000;
+}
+function ttlFor(commandClass) {
+    if (commandClass === "location")
+        return Number.POSITIVE_INFINITY;
+    if (commandClass === "worktree")
+        return 0;
+    return cacheTtlMs();
+}
+export function isGitCacheEnabled() {
+    const flag = process.env.PASEO_GIT_CACHE;
+    return flag !== "0" && flag !== "false";
+}
+/**
+ * Subcommands that never change refs, config or HEAD. Running one of them does not
+ * invalidate the repo's cached answers; running anything else does.
+ */
+const READ_ONLY_SUBCOMMANDS = new Set([
+    "status",
+    "log",
+    "show",
+    "diff",
+    "ls-files",
+    "ls-tree",
+    "ls-remote",
+    "cat-file",
+    "rev-list",
+    "rev-parse",
+    "for-each-ref",
+    "show-ref",
+    "merge-base",
+    "merge-tree",
+    "blame",
+    "grep",
+    "describe",
+    "name-rev",
+    "check-ignore",
+    "check-ref-format",
+    "var",
+    "version",
+    "--version",
+]);
+const BRANCH_WRITE_FLAGS = new Set([
+    "-d",
+    "-D",
+    "--delete",
+    "-m",
+    "-M",
+    "--move",
+    "-c",
+    "-C",
+    "--copy",
+    "-u",
+    "--set-upstream-to",
+    "--unset-upstream",
+    "-f",
+    "--force",
+    "--edit-description",
+]);
+const BRANCH_LIST_FLAGS = new Set([
+    "--list",
+    "-l",
+    "--format",
+    "--show-current",
+    "-a",
+    "--all",
+    "-r",
+    "--remotes",
+    "-v",
+    "-vv",
+    "--contains",
+    "--merged",
+    "--no-merged",
+    "--points-at",
+]);
+const REMOTE_READ_FORMS = new Set(["-v", "get-url", "show"]);
+const REV_PARSE_LOCATION_FLAGS = new Set([
+    "--git-common-dir",
+    "--absolute-git-dir",
+    "--git-dir",
+    "--show-toplevel",
+    "--show-cdup",
+    "--show-prefix",
+    "--is-inside-work-tree",
+    "--is-bare-repository",
+]);
+const REV_PARSE_REF_FLAGS = new Set([
+    "--abbrev-ref",
+    "--verify",
+    "--quiet",
+    "-q",
+    "--symbolic-full-name",
+    "--short",
+]);
+const CONFIG_READ_FLAGS = new Set([
+    "--get",
+    "--get-all",
+    "--get-regexp",
+    "--bool",
+    "--int",
+    "--null",
+    "-z",
+]);
+const isFlag = (arg) => arg.startsWith("-");
+function isBranchListing(rest) {
+    // Listing forms only: `branch`, `branch --format=...`, `branch --show-current`, `branch -a`.
+    const names = rest.map((arg) => arg.split("=")[0] ?? arg);
+    if (names.some((name) => BRANCH_WRITE_FLAGS.has(name)))
+        return false;
+    return names.some((name) => BRANCH_LIST_FLAGS.has(name)) || rest.every(isFlag);
+}
+export function isReadOnlyCommand(args) {
+    const [sub, next] = args;
+    if (!sub)
+        return false;
+    if (READ_ONLY_SUBCOMMANDS.has(sub))
+        return true;
+    if (sub === "worktree")
+        return next === "list";
+    if (sub === "branch")
+        return isBranchListing(args.slice(1));
+    if (sub === "remote")
+        return next === undefined || REMOTE_READ_FORMS.has(next);
+    return false;
+}
+function classifyRevParse(rest) {
+    if (rest.length > 0 && rest.every((arg) => REV_PARSE_LOCATION_FLAGS.has(arg))) {
+        return "location";
+    }
+    const hasPositional = rest.some((arg) => !isFlag(arg));
+    const flagsOk = rest
+        .filter(isFlag)
+        .every((arg) => REV_PARSE_REF_FLAGS.has(arg) || /^--short=\d+$/.test(arg));
+    return hasPositional && flagsOk ? "refs" : null;
+}
+function classifyConfig(rest) {
+    // Only pure reads.
+    const flags = rest.filter(isFlag);
+    const isRead = flags.some((flag) => flag === "--get" || flag === "--get-all" || flag === "--get-regexp");
+    return isRead && flags.every((flag) => CONFIG_READ_FLAGS.has(flag)) ? "config" : null;
+}
+function classifySymbolicRef(rest) {
+    // Reads only: with a second positional, or -d, it would write.
+    const positionals = rest.filter((arg) => !isFlag(arg));
+    const deletes = rest.includes("--delete") || rest.includes("-d");
+    return positionals.length <= 1 && !deletes ? "refs" : null;
+}
+function classifyRevList(rest) {
+    // Ahead/behind counts: `rev-list --left-right --count A...B`.
+    const flags = rest.filter(isFlag);
+    const countsOnly = flags.every((flag) => flag === "--left-right" || flag === "--count");
+    return flags.length > 0 && countsOnly ? "refs" : null;
+}
+const CLASSIFIERS = {
+    "rev-parse": classifyRevParse,
+    config: classifyConfig,
+    "symbolic-ref": classifySymbolicRef,
+    "show-ref": (rest) => (rest.includes("--verify") || rest.includes("--exists") ? "refs" : null),
+    "merge-base": (rest) => rest.every((arg) => !isFlag(arg) || arg === "--is-ancestor") ? "refs" : null,
+    // Listing forms read refs (and upstream config for -vv).
+    branch: (rest) => (isBranchListing(rest) ? "refs" : null),
+    "rev-list": classifyRevList,
+    // Working tree readers: coalesced while in flight, never served after settling.
+    "ls-files": (rest) => (rest.includes("--others") || rest.includes("-o") ? "worktree" : null),
+    diff: (rest) => (rest.includes("--shortstat") ? "worktree" : null),
+    status: () => "worktree",
+};
+/** Classify a command, or return null when it must not be cached. */
+export function classifyGitCommand(args) {
+    const [sub, ...rest] = args;
+    // Upstream/push/reflog selectors resolve through config and remote-tracking refs
+    // we do not fingerprint precisely.
+    if (rest.some((arg) => arg.includes("@{")))
+        return null;
+    const classify = sub ? CLASSIFIERS[sub] : undefined;
+    return classify ? classify(rest) : null;
+}
+function statKey(path) {
+    try {
+        const stat = statSync(path, { bigint: true });
+        return `${stat.ino}:${stat.size}:${stat.mtimeNs}`;
+    }
+    catch {
+        return "-";
+    }
+}
+function readTrimmed(path) {
+    try {
+        return readFileSync(path, "utf8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+export class GitCommandCache {
+    constructor() {
+        this.entries = new Map();
+        this.dirsByCwd = new Map();
+        this.generations = new Map();
+        this.stats = { hits: 0, misses: 0, coalesced: 0, invalidations: 0 };
+    }
+    clear() {
+        this.entries.clear();
+        this.dirsByCwd.clear();
+        this.generations.clear();
+    }
+    /**
+     * Walk up from cwd to the `.git` entry and resolve worktree gitfiles and
+     * `commondir`. Pure filesystem work, no git spawn; cached per cwd briefly and
+     * re-validated by the `.git` entry still existing.
+     */
+    resolveRepoDirs(cwd) {
+        const now = Date.now();
+        const cached = this.dirsByCwd.get(cwd);
+        if (cached && now - cached.checkedAt < DIRS_CACHE_TTL_MS) {
+            return cached.dirs;
+        }
+        const dirs = findRepoDirs(cwd);
+        this.dirsByCwd.set(cwd, { dirs, checkedAt: now });
+        return dirs;
+    }
+    run(args, cwd, env, extraKey, execute) {
+        if (!isGitCacheEnabled() || bypassesForEnv(env)) {
+            return execute();
+        }
+        const dirs = this.resolveRepoDirs(cwd);
+        if (!dirs) {
+            return execute();
+        }
+        const commandClass = classifyGitCommand(args);
+        if (!commandClass) {
+            if (isReadOnlyCommand(args)) {
+                return execute();
+            }
+            // Anything we do not know to be read-only may change the repo.
+            this.invalidate(dirs.commonDir);
+            return execute().finally(() => this.invalidate(dirs.commonDir));
+        }
+        const key = JSON.stringify([cwd, args, extraKey, env ?? null]);
+        const fingerprint = computeFingerprint(commandClass, args, dirs);
+        const generation = this.generations.get(dirs.commonDir) ?? 0;
+        const now = Date.now();
+        const existing = this.entries.get(key);
+        if (existing &&
+            existing.fingerprint === fingerprint &&
+            existing.generation === generation &&
+            existing.expiresAt > now) {
+            if (existing.expiresAt === Number.POSITIVE_INFINITY) {
+                this.stats.coalesced += 1;
+            }
+            else {
+                this.stats.hits += 1;
+            }
+            // Refresh LRU position.
+            this.entries.delete(key);
+            this.entries.set(key, existing);
+            return existing.promise;
+        }
+        this.stats.misses += 1;
+        const ttl = ttlFor(commandClass);
+        const promise = execute();
+        const entry = {
+            fingerprint,
+            generation,
+            // Single-flight while pending; after settling, keep for the TTL.
+            expiresAt: Number.POSITIVE_INFINITY,
+            promise,
+        };
+        this.entries.set(key, entry);
+        this.evictIfNeeded();
+        promise.then(() => {
+            entry.expiresAt = Date.now() + ttl;
+            return undefined;
+        }, (error) => {
+            // Cache definite answers (a nonzero git exit), never transient failures.
+            if (typeof error?.gitExitCode === "number") {
+                entry.expiresAt = Date.now() + ttl;
+            }
+            else if (this.entries.get(key) === entry) {
+                this.entries.delete(key);
+            }
+        });
+        return promise;
+    }
+    invalidate(commonDir) {
+        this.stats.invalidations += 1;
+        this.generations.set(commonDir, (this.generations.get(commonDir) ?? 0) + 1);
+    }
+    evictIfNeeded() {
+        while (this.entries.size > MAX_ENTRIES) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+}
+function bypassesForEnv(env) {
+    for (const key of ENV_KEYS_THAT_BYPASS) {
+        if (process.env[key] !== undefined || env?.[key] !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+export function findRepoDirs(cwd) {
+    let current = resolve(cwd);
+    for (;;) {
+        const dotGit = join(current, ".git");
+        let isDir = false;
+        let exists = false;
+        try {
+            const stat = statSync(dotGit);
+            exists = true;
+            isDir = stat.isDirectory();
+        }
+        catch {
+            exists = false;
+        }
+        if (exists) {
+            let gitDir = dotGit;
+            if (!isDir) {
+                const content = readTrimmed(dotGit);
+                const match = content?.match(/^gitdir:\s*(.+)$/m);
+                if (!match)
+                    return null;
+                gitDir = isAbsolute(match[1]) ? match[1] : resolve(current, match[1]);
+            }
+            const commonRel = readTrimmed(join(gitDir, "commondir"));
+            let commonDir = gitDir;
+            if (commonRel) {
+                commonDir = isAbsolute(commonRel) ? commonRel : resolve(gitDir, commonRel);
+            }
+            if (usesReftable(commonDir))
+                return null;
+            return { dotGit, gitDir, commonDir };
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function usesReftable(commonDir) {
+    // Reftable keeps refs in reftable/*.ref; none of the files we stat change on a
+    // commit there, so such repos are simply not cached.
+    try {
+        statSync(join(commonDir, "reftable"));
+        return true;
+    }
+    catch {
+        // no reftable dir
+    }
+    const config = readTrimmed(join(commonDir, "config")) ?? "";
+    return /refstorage\s*=\s*reftable/i.test(config);
+}
+function globalConfigPaths() {
+    const home = process.env.HOME ?? homedir();
+    const xdg = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+    return [join(home, ".gitconfig"), join(xdg, "git", "config"), "/etc/gitconfig"];
+}
+function refFilesFor(args, dirs) {
+    const files = [];
+    const headContent = readTrimmed(join(dirs.gitDir, "HEAD"));
+    const headRef = headContent?.startsWith("ref:") ? headContent.slice(4).trim() : null;
+    if (headRef)
+        files.push(join(dirs.commonDir, headRef));
+    const names = args
+        .slice(1)
+        .filter((arg) => !arg.startsWith("-"))
+        .flatMap((arg) => arg.split(/\.{2,3}/));
+    for (const raw of names) {
+        const name = raw.replace(/[\^~].*$/, "");
+        if (!name || name === "HEAD")
+            continue;
+        if (name.startsWith("refs/")) {
+            files.push(join(dirs.commonDir, name));
+        }
+        else {
+            files.push(join(dirs.commonDir, "refs", "heads", name), join(dirs.commonDir, "refs", "remotes", name), join(dirs.commonDir, "refs", "tags", name));
+        }
+    }
+    return files;
+}
+function computeFingerprint(commandClass, args, dirs) {
+    const paths = [dirs.dotGit];
+    const configPaths = [
+        join(dirs.commonDir, "config"),
+        join(dirs.gitDir, "config.worktree"),
+        ...globalConfigPaths(),
+    ];
+    switch (commandClass) {
+        case "location":
+            break;
+        case "config":
+            paths.push(...configPaths);
+            break;
+        case "worktree":
+            // Never served after settling; the fingerprint only scopes coalescing.
+            paths.push(join(dirs.gitDir, "HEAD"), join(dirs.gitDir, "index"));
+            break;
+        case "refs":
+            paths.push(join(dirs.gitDir, "HEAD"), join(dirs.commonDir, "packed-refs"), join(dirs.commonDir, "FETCH_HEAD"), join(dirs.commonDir, "refs", "heads"), join(dirs.commonDir, "refs", "remotes"), join(dirs.commonDir, "refs", "tags"), ...refFilesFor(args, dirs), 
+            // Upstream tracking (branch -vv) lives in config.
+            ...configPaths);
+            break;
+    }
+    return paths.map(statKey).join("|");
+}
+let sharedCache = null;
+export function getSharedGitCommandCache() {
+    sharedCache ?? (sharedCache = new GitCommandCache());
+    return sharedCache;
+}
+//# sourceMappingURL=git-command-cache.js.map

package/dist/server/utils/run-git-command.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import pLimit from "p-limit";
-import { spawnProcess } from "./spawn.js";
+import { getSharedGitCommandCache, isReadOnlyCommand } from "./git-command-cache.js";
+import { spawnNonInteractive } from "./spawn.js";
 const DEFAULT_TIMEOUT_MS = 30000;
 const DEFAULT_MAX_OUTPUT_BYTES = 20 * 1024 * 1024; // 20MB
 const DEFAULT_STDERR_LIMIT = 2048;
@@ -61,6 +62,11 @@ function getEnvOverlayKeys(envOverlay) {
     return Object.keys(envOverlay ?? {}).sort();
 }
 export function runGitCommand(args, options) {
+    // Read-only commands are answered from a per-repo cache validated by .git stat
+    // fingerprints, and identical concurrent commands share one spawn.
+    return getSharedGitCommandCache().run(args, options.cwd, mergeEnvOverlays(options.env, options.envOverlay), JSON.stringify([options.acceptExitCodes ?? [0], options.maxOutputBytes ?? null]), () => runGitCommandUncached(args, options));
+}
+function runGitCommandUncached(args, options) {
     return gitLimit(() => new Promise((resolve, reject) => {
         const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
         const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
@@ -87,11 +93,14 @@ export function runGitCommand(args, options) {
         }
         // `core.quotepath=false` makes git emit raw UTF-8 paths instead of
         // octal-escaping non-ASCII bytes (e.g. `测试文件.txt` vs `"\346\265\213..."`).
-        const child = spawnProcess("git", ["-c", "core.quotepath=false", ...args], {
+        const child = spawnNonInteractive("git", ["-c", "core.quotepath=false", ...args], {
             cwd: options.cwd,
             envOverlay,
             shell: false,
-            stdio: ["ignore", "pipe", "pipe"],
+            // One byte over the cap so the truncation below still triggers.
+            maxStdoutBytes: maxOutputBytes + 1,
+            maxStderrBytes: DEFAULT_STDERR_LIMIT,
+            retryOnDirect: isReadOnlyCommand(args),
         });
         let settled = false;
         let metricFinished = false;
@@ -210,7 +219,8 @@ export function runGitCommand(args, options) {
                 });
                 const stderrPreview = result.stderr.trim() || "(no stderr)";
                 const truncationNote = result.truncated ? " (stdout truncated)" : "";
-                settle(() => reject(new Error(`Git command failed: ${command}${truncationNote} (exit code: ${String(exitCode)}, signal: ${signal ?? "none"})\n${stderrPreview}`)));
+                const error = Object.assign(new Error(`Git command failed: ${command}${truncationNote} (exit code: ${String(exitCode)}, signal: ${signal ?? "none"})\n${stderrPreview}`), { gitExitCode: exitCode });
+                settle(() => reject(error));
                 return;
             }
             finishMetricOnce({