@letrquan/book 0.3.0 → 0.4.0-beta.0

package/dist/{chunk-YC6W4EJH.js → chunk-JGF5HLSI.js}

@@ -1,14 +1,24 @@
 import {
   HARDENED_DIFF_ARGS,
   hardenedGitArgs,
-  hardenedGitEnv
-} from "./chunk-C7ADUNPR.js";
+  hardenedGitEnv,
+  noFetchGitEnv,
+  parseGitConfig,
+  readRepositoryProgramPins
+} from "./chunk-32WBCUAN.js";
 import {
   systemClock
 } from "./chunk-RT5SATF7.js";
 import {
   buildChildEnv
 } from "./chunk-XHAO3K7I.js";
+import {
+  ignoresHomeRepository
+} from "./chunk-SBTU5BEC.js";
+import {
+  canonicalizePath,
+  isOutside
+} from "./chunk-YIL6HTJX.js";
 import {
   resolveBookHome
 } from "./chunk-ZPSZZUWF.js";
@@ -31,7 +41,7 @@ import { createHash, randomUUID } from "crypto";
 import { execFile, spawn } from "child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "fs";
 import { tmpdir } from "os";
-import { dirname, join, resolve } from "path";
+import { dirname, join, relative, resolve, sep } from "path";
 
 // src/agents/git-signing.ts
 var SIGNING_KEY_PATTERN = "^(commit\\.gpgsign|gpg\\..*|user\\.signingkey)$";
@@ -56,51 +66,29 @@ var PIN_UNITS = [
   { keys: ["gpg.ssh.allowedsignersfile"], fallback: "" },
   { keys: ["gpg.ssh.revocationfile"], fallback: "" }
 ];
-async function readSigningConfig(repoRoot, run2) {
+async function readSigningConfig(repoRoot, run2, signal) {
   const result = await run2(
     "git",
     ["config", "--show-scope", "-z", "--get-regexp", SIGNING_KEY_PATTERN],
-    { cwd: repoRoot, allowExitCodes: [1, 129], timeoutMs: READ_TIMEOUT_MS }
+    { cwd: repoRoot, allowExitCodes: [1, 129], timeoutMs: READ_TIMEOUT_MS, signal }
   );
   if (result.code === 129 || /unknown option/i.test(result.stderr)) {
     throw new Error(
-      `Applying an agent's result needs git ${MINIMUM_GIT} or later (for \`git config --show-scope\`); this git is ${await gitVersion(run2, repoRoot)}`
+      `Applying an agent's result needs git ${MINIMUM_GIT} or later (for \`git config --show-scope\`); this git is ${await gitVersion(run2, repoRoot, signal)}`
     );
   }
   return parseSigningConfig(result.stdout);
 }
-async function gitVersion(run2, repoRoot) {
+async function gitVersion(run2, repoRoot, signal) {
   try {
-    return (await run2("git", ["--version"], { cwd: repoRoot, timeoutMs: READ_TIMEOUT_MS })).stdout.trim();
-  } catch {
+    return (await run2("git", ["--version"], { cwd: repoRoot, timeoutMs: READ_TIMEOUT_MS, signal })).stdout.trim();
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return "of an unknown version";
   }
 }
 function parseSigningConfig(stdout) {
-  const fields = stdout.split("\0");
-  const entries = [];
-  for (let index = 0; index + 1 < fields.length; index += 2) {
-    const separator = fields[index + 1].indexOf("\n");
-    entries.push({
-      scope: fields[index].toLowerCase(),
-      key: canonicalConfigKey(
-        separator === -1 ? fields[index + 1] : fields[index + 1].slice(0, separator)
-      ),
-      // Git's own reading of a key with no value: a boolean true.
-      value: separator === -1 ? "true" : fields[index + 1].slice(separator + 1)
-    });
-  }
-  return entries;
-}
-function canonicalConfigKey(raw) {
-  const nameStart = raw.lastIndexOf(".");
-  if (nameStart === -1) return raw.toLowerCase();
-  const head = raw.slice(0, nameStart);
-  const name = raw.slice(nameStart + 1).toLowerCase();
-  const subsectionStart = head.indexOf(".");
-  if (subsectionStart === -1) return `${head.toLowerCase()}.${name}`;
-  const section = head.slice(0, subsectionStart).toLowerCase();
-  return `${section}.${head.slice(subsectionStart + 1)}.${name}`;
+  return parseGitConfig(stdout);
 }
 function signingFacts(entries) {
   const operatorEntries = [];
@@ -180,36 +168,42 @@ function derivedSigningKey(facts, inputs) {
 function committerSigningIdentity(ident) {
   return ident.trim().replace(/\s+\d+\s+[+-]\d{4}$/, "");
 }
-async function signingPinArgs(repoRoot, run2) {
-  const entries = await readSigningConfig(repoRoot, run2);
+async function signingPinArgs(repoRoot, run2, signal) {
+  const entries = await readSigningConfig(repoRoot, run2, signal);
   const facts = signingFacts(entries);
   const inputs = { committerIdent: "", sshDefaultKey: "" };
   const source = signingKeySource(facts);
   if (source === "committer") {
     inputs.committerIdent = (await run2("git", ["var", "GIT_COMMITTER_IDENT"], {
       cwd: repoRoot,
-      timeoutMs: READ_TIMEOUT_MS
+      timeoutMs: READ_TIMEOUT_MS,
+      signal
     })).stdout;
   } else if (source === "ssh-default-key-command") {
-    inputs.sshDefaultKey = await sshDefaultSigningKey(facts, repoRoot, run2);
+    inputs.sshDefaultKey = await sshDefaultSigningKey(facts, repoRoot, run2, signal);
   }
   return pinsFor(facts, inputs);
 }
-async function sshDefaultSigningKey(facts, repoRoot, run2) {
+async function sshDefaultSigningKey(facts, repoRoot, run2, signal) {
   const command = lastOperatorValue(facts, ["gpg.ssh.defaultkeycommand"])?.trim();
   if (!command) return "";
   const [program, ...args] = command.split(/\s+/);
   try {
-    const result = await run2(program, args, { cwd: repoRoot, timeoutMs: READ_TIMEOUT_MS });
+    const result = await run2(program, args, {
+      cwd: repoRoot,
+      timeoutMs: READ_TIMEOUT_MS,
+      signal
+    });
     const first = result.stdout.split(/\r?\n/)[0]?.trim() ?? "";
     return first.startsWith("key::") ? first : "";
-  } catch {
+  } catch (error) {
+    if (signal?.aborted) throw error;
     return "";
   }
 }
 
 // src/agents/git-isolation.ts
-function run(command, args, options) {
+function run(command, args, options, maxBuffer = DEFAULT_MAX_BUFFER_BYTES) {
   const env = internalGitEnv(options.env);
   const timeoutMs = options.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
   const signal = options.signal;
@@ -280,7 +274,15 @@ function run(command, args, options) {
           }
           reject(
             new Error(
-              stderr.trim() || stdout.trim() || stdinError?.message || `${command} ${subcommandOf(args)} failed (${code})`
+              failureDescription(
+                null,
+                stderr.trim() || stdout.trim() || stdinError?.message || outputError?.message || "",
+                command,
+                args,
+                timeoutMs,
+                stoppedBy === "aborted",
+                code
+              )
             )
           );
         });
@@ -332,10 +334,10 @@ function run(command, args, options) {
         cwd: options.cwd,
         env,
         encoding: "utf8",
-        // One buffer for every call: a signing read that overruns it has to fail rather than
-        // resolve on a prefix, and this size is what makes that impractical rather than what makes
-        // it correct.
-        maxBuffer: 50 * 1024 * 1024
+        // Each of stdout and stderr is capped here, and a call that overruns the cap fails rather
+        // than resolving on what had arrived. Only this branch is capped: the `input` branch above
+        // collects its output without a limit. See {@link DEFAULT_MAX_BUFFER_BYTES}.
+        maxBuffer
         // No `timeout` and no `signal` option here. `execFile`'s own timeout kills the child but
         // still waits for its output to close, and a grandchild holding that pipe — a shell script,
         // a `credential.helper` that started something of its own — means it never does, so the
@@ -350,7 +352,7 @@ function run(command, args, options) {
               new Error(
                 failureDescription(
                   error,
-                  stderr || stdout,
+                  stderr.trim() || stdout.trim(),
                   command,
                   args,
                   timeoutMs,
@@ -368,11 +370,15 @@ function run(command, args, options) {
         settle(
           () => reject(
             new Error(
-              // git's own words first, because they are the ones that say what went wrong. Then the
-              // composed message, and not Node's: with no output to prefer, Node's is the whole argv
-              // — hardening pairs included — which names `-c` where a reader needs the subcommand,
-              // and says nothing that the exit code does not (#357).
-              stderr.trim() || stdout.trim() || `${command} ${subcommandOf(args)} failed (${code})`
+              failureDescription(
+                error,
+                stderr.trim() || stdout.trim(),
+                command,
+                args,
+                timeoutMs,
+                stoppedBy === "aborted",
+                code
+              )
             )
           )
         );
@@ -385,6 +391,7 @@ function run(command, args, options) {
   });
 }
 var DEFAULT_GIT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 var KILL_GRACE_MS = 2e3;
 function stopEscalating(child, settled) {
   child.kill("SIGTERM");
@@ -429,13 +436,20 @@ function exitCodeOf(error) {
 function isAbortError(error) {
   return error?.name === "AbortError" || error?.code === "ABORT_ERR";
 }
-function failureDescription(error, output, command, args, timeoutMs, aborted) {
+function failureDescription(error, output, command, args, timeoutMs, aborted, code) {
   const invocation = `${command} ${subcommandOf(args)}`;
   if (aborted || isAbortError(error)) return `${invocation} was cancelled`;
   if (error?.killed) return `${invocation} timed out after ${timeoutMs}ms and was killed`;
   if (error?.signal) return `${invocation} was killed with ${error.signal}`;
   if (typeof error?.code === "string") return `${invocation} failed: ${error.code}`;
-  return output.trim() || error?.message || `${invocation} failed`;
+  const trimmed = output.trim();
+  if (/promisor remote|lazy fetching disabled/i.test(trimmed)) {
+    return "this repository is a partial clone; Book's agent isolation does not fetch missing objects, because the fetch would run the transport this checkout configures (`core.sshCommand`, `credential.helper`) with no prompt; fetch the missing objects yourself (for example `git fetch --refetch <remote>` after unsetting `remote.<remote>.partialclonefilter`), then retry.\n" + trimmed;
+  }
+  if (trimmed) return trimmed;
+  if (code !== void 0) return `${invocation} failed (${code})`;
+  if (error?.message) return error.message;
+  return `${invocation} failed`;
 }
 var GIT_REPOSITORY_SELECTION_VARIABLES = /* @__PURE__ */ new Set([
   "GIT_DIR",
@@ -455,12 +469,31 @@ var GIT_REPOSITORY_SELECTION_VARIABLES = /* @__PURE__ */ new Set([
 function internalGitEnv(overrides) {
   const ambient = buildChildEnv(process.env);
   for (const name of GIT_REPOSITORY_SELECTION_VARIABLES) delete ambient[name];
-  return { ...ambient, ...overrides, ...hardenedGitEnv() };
+  return {
+    ...ambient,
+    ...overrides,
+    ...hardenedGitEnv(),
+    ...noFetchGitEnv()
+  };
 }
-function git(cwd, args, options = {}) {
-  return run("git", hardenedGitArgs(args), { ...options, cwd });
+async function git(cwd, args, options = {}) {
+  const pins = await readRepositoryProgramPins(
+    cwd,
+    (pinArgs, pinOpts) => run("git", pinArgs, {
+      signal: options.signal,
+      timeoutMs: options.timeoutMs,
+      env: options.env,
+      ...pinOpts
+    }),
+    {
+      signal: options.signal,
+      timeoutMs: options.timeoutMs,
+      env: options.env,
+      allowFsmonitor: false
+    }
+  );
+  return run("git", hardenedGitArgs([...pins, ...args]), { ...options, cwd });
 }
-var hardenedRunner = run;
 function cherryPickFailureResult(facts) {
   const conflicted = facts.unmergedPaths.length > 0;
   if (facts.abortError) {
@@ -491,28 +524,81 @@ function tempIndex() {
   return { dir, path: join(dir, "index") };
 }
 async function findGitRoot(workspace, signal) {
-  try {
-    return (await git(workspace, ["rev-parse", "--show-toplevel"], { signal })).stdout.trim();
-  } catch {
+  if (!existsSync(workspace)) {
     return void 0;
   }
+  try {
+    const top = (await git(workspace, ["rev-parse", "--show-toplevel"], { signal })).stdout.trim();
+    return ignoresHomeRepository(top, workspace) ? void 0 : top;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    if (/not a git repository/i.test(message) || code === "ENOENT" || /no such file or directory/i.test(message)) {
+      return void 0;
+    }
+    throw error;
+  }
 }
 function repositoryHash(repoRoot) {
   return createHash("sha256").update(resolve(repoRoot).toLowerCase()).digest("hex").slice(0, 20);
 }
+function bookHomeInRepository(repoRoot) {
+  const rootReal = canonicalizePath(repoRoot);
+  const bookHomeReal = canonicalizePath(resolveBookHome());
+  if (isOutside(rootReal, bookHomeReal)) return void 0;
+  const inside = relative(rootReal, bookHomeReal);
+  return inside === "" ? void 0 : inside.split(sep).join("/");
+}
 async function writeWorkspaceTree(repoRoot, includeUntracked, signal) {
   const index = tempIndex();
   try {
     const env = { GIT_INDEX_FILE: index.path };
+    const bookHome = bookHomeInRepository(repoRoot);
+    const magic = bookHome === void 0 ? [] : ["--no-literal-pathspecs"];
+    const exclusion = bookHome === void 0 ? [] : [`:(top,literal,exclude)${bookHome}`];
     const head = (await git(repoRoot, ["rev-parse", "HEAD"], { signal })).stdout.trim();
     await git(repoRoot, ["read-tree", head], { env, signal });
-    await git(repoRoot, includeUntracked ? ["add", "-A", "--", "."] : ["add", "-u", "--", "."], {
-      env,
-      signal
-    });
+    await git(
+      repoRoot,
+      [...magic, "add", includeUntracked ? "-A" : "-u", "--", ".", ...exclusion],
+      {
+        env,
+        signal
+      }
+    );
     const tree = (await git(repoRoot, ["write-tree"], { env, signal })).stdout.trim();
-    const status = (await git(repoRoot, ["status", "--porcelain=v1", "--untracked-files=all"], { signal })).stdout;
-    return { head, tree, status };
+    const status = [
+      (await git(
+        repoRoot,
+        [
+          ...magic,
+          "status",
+          "--porcelain=v1",
+          "--untracked-files=all",
+          "--ignore-submodules=dirty",
+          ...bookHome === void 0 ? [] : ["--", ".", ...exclusion]
+        ],
+        { signal }
+      )).stdout
+    ];
+    if (bookHome !== void 0) {
+      status.push(
+        (await git(
+          repoRoot,
+          [
+            ...magic,
+            "status",
+            "--porcelain=v1",
+            "--untracked-files=no",
+            "--ignore-submodules=dirty",
+            "--",
+            `:(top,literal)${bookHome}`
+          ],
+          { signal }
+        )).stdout
+      );
+    }
+    return { head, tree, status: status.join("") };
   } finally {
     rmSync(index.dir, { recursive: true, force: true });
   }
@@ -744,14 +830,22 @@ async function unmergedPathsAfterFailure(repoRoot) {
     return [];
   }
 }
-async function applyVerifiedCandidate(snapshot, candidate, signal) {
+async function applyVerifiedCandidate(snapshot, candidate, signal, options) {
+  return applyCandidate(snapshot, candidate, signal, DEFAULT_MAX_BUFFER_BYTES, options);
+}
+function stoppedApplyError(signal, step, outcome) {
+  const reason = typeof signal?.reason === "string" ? ` (${signal.reason})` : "";
+  return new Error(`The apply was stopped${reason} during ${step}. ${outcome}`);
+}
+async function applyCandidate(snapshot, candidate, signal, signingBuffer, options) {
+  const mutationSignal = options?.mutationSignal ?? signal;
   if (candidate.baseCommit !== snapshot.commit) {
     return {
       status: "conflicted",
       error: "Patch candidate base does not match the task snapshot."
     };
   }
-  const actualHead = (await git(snapshot.repoRoot, ["rev-parse", candidate.headCommit])).stdout.trim();
+  const actualHead = (await git(snapshot.repoRoot, ["rev-parse", candidate.headCommit], { signal })).stdout.trim();
   if (actualHead !== candidate.headCommit) {
     return { status: "conflicted", error: "Patch candidate commit no longer resolves exactly." };
   }
@@ -776,16 +870,22 @@ async function applyVerifiedCandidate(snapshot, candidate, signal) {
   try {
     await precheckDelta(snapshot, patch, signal);
   } catch (error) {
+    const stopped = signal?.aborted === true;
+    if (stopped) {
+      throw stoppedApplyError(signal, "the patch pre-check", "No changes were applied.");
+    }
     return {
       status: "conflicted",
       error: `Patch pre-check failed; no changes were applied: ${error instanceof Error ? error.message : String(error)}`
     };
   }
+  const signingRunner = (command, args, options2) => run(command, args, options2, signingBuffer);
   if (!snapshot.dirty) {
     let signingPins;
     try {
-      signingPins = await signingPinArgs(snapshot.repoRoot, hardenedRunner);
+      signingPins = await signingPinArgs(snapshot.repoRoot, signingRunner, signal);
     } catch (error) {
+      if (signal?.aborted) throw error;
       return {
         status: "conflicted",
         error: `Could not read the signing configuration for the cherry-pick: ${error instanceof Error ? error.message : String(error)}`
@@ -794,11 +894,10 @@ async function applyVerifiedCandidate(snapshot, candidate, signal) {
     try {
       await git(snapshot.repoRoot, [...signingPins, "cherry-pick", candidate.headCommit], {
         timeoutMs: CHERRY_PICK_TIMEOUT_MS,
-        signal
+        signal: mutationSignal
       });
-      const appliedCommit = (await git(snapshot.repoRoot, ["rev-parse", "HEAD"], { signal })).stdout.trim();
-      return { status: "applied", commit: appliedCommit };
     } catch (error) {
+      const stopped = mutationSignal?.aborted === true;
       const unmergedPaths = await unmergedPathsAfterFailure(snapshot.repoRoot);
       let abortError;
       try {
@@ -806,17 +905,36 @@ async function applyVerifiedCandidate(snapshot, candidate, signal) {
       } catch (abortFailure) {
         abortError = abortFailure instanceof Error ? abortFailure.message : String(abortFailure);
       }
+      if (stopped) {
+        throw stoppedApplyError(
+          mutationSignal,
+          "the cherry-pick",
+          [
+            abortError ? `The rollback did not complete (${abortError}), so this repository may be left mid-cherry-pick: finish it with git cherry-pick --continue or undo it with git cherry-pick --abort.` : "The cherry-pick was rolled back.",
+            unmergedPaths.length > 0 ? `Unmerged paths: ${unmergedPaths.join(", ")}.` : void 0
+          ].filter(Boolean).join(" ")
+        );
+      }
       return cherryPickFailureResult({
         pickError: error instanceof Error ? error.message : String(error),
         abortError,
         unmergedPaths
       });
     }
+    const appliedCommit = (await git(snapshot.repoRoot, ["rev-parse", "HEAD"])).stdout.trim();
+    return { status: "applied", commit: appliedCommit };
   }
   try {
-    await git(snapshot.repoRoot, ["apply", "-"], { input: patch, signal });
+    await git(snapshot.repoRoot, ["apply", "-"], { input: patch, signal: mutationSignal });
     return { status: "applied", commit: candidate.headCommit };
   } catch (error) {
+    if (mutationSignal?.aborted) {
+      throw stoppedApplyError(
+        mutationSignal,
+        "git apply",
+        "git apply was cut short, so check git status before applying again: the working tree may be partly changed."
+      );
+    }
     return {
       status: "conflicted",
       error: `Patch application failed: ${error instanceof Error ? error.message : String(error)}`
@@ -944,4 +1062,4 @@ export {
   removePersistentJobFiles,
   removePersistentRunnerFiles
 };
-//# sourceMappingURL=chunk-YC6W4EJH.js.map
+//# sourceMappingURL=chunk-JGF5HLSI.js.map