@hyperdrive.bot/fleet-server 0.3.155 → 0.3.158

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({

package/dist/server/utils/spawn-broker-child.mjs

@@ -0,0 +1,156 @@
+// Spawn broker helper process. The daemon forks this small Node process once and
+// asks it to run non-interactive subprocesses (git, gh, which, ...) over IPC, so
+// the daemon itself never forks its multi-GB image: on WSL2 every direct spawn()
+// from the daemon blocked its event loop for about 100ms.
+//
+// Protocol (JSON over the IPC channel):
+//   parent -> child  { type: "spawn", id, command, args, cwd, env, shell }
+//                    { type: "kill", id, signal }
+//   child -> parent  { type: "spawned", id, pid }
+//                    { type: "data", id, fd: 1 | 2, data: base64 }
+//                    { type: "error", id, error: { message, code, errno, syscall, path } }
+//                    { type: "close", id, exitCode, signal }
+//
+// Timeouts, output caps and exit-code policy stay in the parent, which kills the
+// child through the "kill" message exactly like it would kill a direct ChildProcess.
+import { spawn } from "node:child_process";
+
+const children = new Map();
+
+function send(message) {
+  // Returns false when the channel is backed up (or gone; the disconnect handler
+  // cleans up in that case).
+  return sendRaw(message);
+}
+
+function serializeError(error) {
+  return {
+    message: error?.message ?? String(error),
+    code: error?.code,
+    errno: error?.errno,
+    syscall: error?.syscall,
+    path: error?.path,
+  };
+}
+
+const CHUNK_BYTES = 64 * 1024;
+
+// Forward a stream in bounded chunks, stop forwarding once the caller's cap is
+// reached (the caller decides whether to kill), and pause the source while the
+// IPC channel is backed up so output never piles up in memory on either side.
+function forward(stream, id, fd, maxBytes) {
+  const cap = Number.isFinite(maxBytes) && maxBytes >= 0 ? maxBytes : Infinity;
+  let forwarded = 0;
+  stream.on("data", (chunk) => {
+    if (forwarded >= cap) return;
+    const slice = chunk.length > cap - forwarded ? chunk.subarray(0, cap - forwarded) : chunk;
+    forwarded += slice.length;
+    for (let offset = 0; offset < slice.length; offset += CHUNK_BYTES) {
+      const part = slice.subarray(offset, offset + CHUNK_BYTES);
+      const ok = send({ type: "data", id, fd, data: part.toString("base64") });
+      if (!ok) {
+        stream.pause();
+        waitForDrain(() => stream.resume());
+      }
+    }
+  });
+}
+
+const drainWaiters = [];
+function waitForDrain(callback) {
+  drainWaiters.push(callback);
+  if (drainWaiters.length > 1) return;
+  // An empty message's send callback fires once everything queued before it
+  // has been written to the channel.
+  sendRaw({ type: "noop" }, () => {
+    const waiters = drainWaiters.splice(0);
+    for (const waiter of waiters) waiter();
+  });
+}
+
+function sendRaw(message, callback) {
+  if (!process.connected) return false;
+  try {
+    return process.send(message, undefined, undefined, callback);
+  } catch {
+    return false;
+  }
+}
+
+function handleSpawn(message) {
+  const { id } = message;
+  let child;
+  try {
+    child = spawn(message.command, message.args, {
+      cwd: message.cwd,
+      env: message.env,
+      shell: message.shell ?? false,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+  } catch (error) {
+    send({ type: "error", id, error: serializeError(error) });
+    return;
+  }
+  children.set(id, child);
+  if (child.pid !== undefined) {
+    send({ type: "spawned", id, pid: child.pid });
+  }
+  forward(child.stdout, id, 1, message.maxStdoutBytes);
+  forward(child.stderr, id, 2, message.maxStderrBytes);
+  child.on("error", (error) => {
+    children.delete(id);
+    send({ type: "error", id, error: serializeError(error) });
+  });
+  child.on("close", (exitCode, signal) => {
+    children.delete(id);
+    send({ type: "close", id, exitCode, signal });
+  });
+}
+
+function killAll() {
+  for (const child of children.values()) {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+      // already gone
+    }
+  }
+  children.clear();
+}
+
+process.on("message", (message) => {
+  if (!message || typeof message !== "object") return;
+  if (message.type === "spawn") {
+    handleSpawn(message);
+    return;
+  }
+  if (message.type === "kill") {
+    const child = children.get(message.id);
+    if (child) {
+      try {
+        child.kill(message.signal ?? "SIGTERM");
+      } catch {
+        // already gone
+      }
+    }
+    return;
+  }
+  if (message.type === "crash-for-test" && process.env.PASEO_SPAWN_BROKER_TEST_HOOKS === "1") {
+    process.exit(1);
+  }
+});
+
+// The daemon owns us: when its IPC channel closes (clean shutdown or crash) we take
+// our children down and exit, so nothing is orphaned.
+process.on("disconnect", () => {
+  killAll();
+  process.exit(0);
+});
+
+for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+  process.on(signal, () => {
+    killAll();
+    process.exit(0);
+  });
+}