arcane-cli 0.16.1 → 0.16.2

package/dist/assets/.arcane/governance/git-conventions.md

@@ -220,6 +220,13 @@ Create the session branch as the **first action** of any session, before any fil
   1. `git branch -m <old> <new>`
   2. `git push -u origin <new>`
   3. `git push origin --delete <old>` (skip this if an active PR still depends on `<old>`).
+- **EF-20 hazard:** on some Windows/Git-for-Windows filesystems, a rename or delete can trigger
+  an interactive retry prompt (e.g. a file lock from an editor or antivirus scan) that blocks
+  indefinitely on a terminal with no non-interactive fallback. When running these commands
+  directly through a tool that supports a per-call timeout (an agent's shell tool, a CI step),
+  set one rather than assuming the command will return. Arcane's own TypeScript Git helper
+  (`src/modules/git.ts`) applies this as a standing contract — closed stdin plus a
+  command-class timeout — for every `git` invocation the CLI itself makes.
 
 **Agents:**
 

package/dist/index.js

@@ -1599,15 +1599,140 @@ async function runAgentsList(targetDir) {
 
 // src/modules/git.ts
 import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function inspectGitRepository(cwd) {
-  try {
-    const { stdout: stdout2 } = await execFileAsync(
+var GitTimeoutError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GitTimeoutError";
+  }
+};
+var NETWORK_SUBCOMMANDS = /* @__PURE__ */ new Set(["fetch", "pull", "push", "clone", "ls-remote", "send-email"]);
+var WRITE_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "commit",
+  "add",
+  "checkout",
+  "switch",
+  "merge",
+  "rebase",
+  "reset",
+  "tag",
+  "mv",
+  "rm",
+  "cherry-pick",
+  "revert",
+  "stash",
+  "apply",
+  "am",
+  "restore",
+  "submodule",
+  "sparse-checkout",
+  "maintenance",
+  "notes"
+]);
+var AMBIGUOUS_AS_WRITE = /* @__PURE__ */ new Set(["branch", "config", "remote", "worktree"]);
+var READ_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "status",
+  "rev-parse",
+  "log",
+  "diff",
+  "show",
+  "describe",
+  "cat-file",
+  "ls-files",
+  "ls-tree",
+  "symbolic-ref",
+  "merge-base",
+  "blame",
+  "shortlog",
+  "grep",
+  "reflog",
+  "diff-tree",
+  "rev-list",
+  "name-rev",
+  "count-objects",
+  "verify-commit",
+  "verify-tag",
+  "help",
+  "version"
+]);
+var GLOBAL_FLAGS_WITH_SEPARATE_VALUE = /* @__PURE__ */ new Set(["-c", "-C"]);
+var DEFAULT_TIMEOUTS_MS = {
+  read: 15e3,
+  write: 3e4,
+  network: 12e4
+};
+function classifyGitCommand(args) {
+  let subcommand;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (GLOBAL_FLAGS_WITH_SEPARATE_VALUE.has(arg)) {
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    subcommand = arg;
+    break;
+  }
+  if (!subcommand) return "read";
+  if (NETWORK_SUBCOMMANDS.has(subcommand)) return "network";
+  if (WRITE_SUBCOMMANDS.has(subcommand) || AMBIGUOUS_AS_WRITE.has(subcommand)) return "write";
+  if (READ_SUBCOMMANDS.has(subcommand)) return "read";
+  return "write";
+}
+function buildGitEnv() {
+  return {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GCM_INTERACTIVE: "Never",
+    GIT_OPTIONAL_LOCKS: "0"
+  };
+}
+function runGit(cwd, args, options = {}) {
+  const commandClass = options.commandClass ?? classifyGitCommand(args);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUTS_MS[commandClass] ?? DEFAULT_TIMEOUTS_MS.write;
+  return new Promise((resolve, reject) => {
+    const child = execFile(
       "git",
-      ["rev-parse", "--is-inside-work-tree"],
-      { cwd }
+      args,
+      {
+        cwd,
+        env: buildGitEnv(),
+        timeout: timeoutMs,
+        // SIGTERM (Node's default) rather than SIGKILL: gives git a chance
+        // to run its own cleanup on POSIX, relevant to EF-20's own concern
+        // about a killed operation leaving refs/locks in an uncertain state.
+        // Moot on Windows -- Node docs: both map to an abrupt TerminateProcess
+        // there -- but this module isn't Windows-gated.
+        killSignal: "SIGTERM",
+        windowsHide: true,
+        encoding: "utf8"
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed) {
+            reject(
+              new GitTimeoutError(
+                // NOTE: embeds the raw args, including any secrets a future
+                // network-class caller might pass (e.g. a credentialed
+                // clone URL). No current caller does; redact before one does.
+                `git ${args.join(" ")} timed out after ${timeoutMs}ms (class: ${commandClass})`,
+                { cause: error }
+              )
+            );
+            return;
+          }
+          reject(error);
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
     );
+    child.stdin?.end();
+  });
+}
+async function inspectGitRepository(cwd) {
+  try {
+    const { stdout: stdout2 } = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
     if (stdout2.trim() !== "true") {
       return { status: "not-repository" };
     }
@@ -1615,15 +1740,11 @@ async function inspectGitRepository(cwd) {
     return { status: "not-repository" };
   }
   try {
-    await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd });
+    await runGit(cwd, ["rev-parse", "--verify", "HEAD"]);
   } catch {
     return { status: "no-commits" };
   }
-  const { stdout } = await execFileAsync(
-    "git",
-    ["status", "--porcelain", "-uall"],
-    { cwd }
-  );
+  const { stdout } = await runGit(cwd, ["status", "--porcelain", "-uall"]);
   const lines = stdout.trim();
   return {
     status: "ready",
@@ -1632,7 +1753,7 @@ async function inspectGitRepository(cwd) {
 }
 async function countUncommittedChanges(cwd) {
   try {
-    const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-uall"], { cwd });
+    const { stdout } = await runGit(cwd, ["status", "--porcelain", "-uall"]);
     const lines = stdout.trim();
     return lines.length === 0 ? 0 : lines.split("\n").length;
   } catch {
@@ -2391,7 +2512,7 @@ async function runUninstall(options, targetDir) {
 import { access as access3, readFile as readFile5, mkdir as mkdir5, copyFile as fsCopyFile2 } from "fs/promises";
 import { join as join10, dirname as dirname2 } from "path";
 import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
+import { promisify } from "util";
 
 // src/config/incidents.ts
 var INCIDENT_QUEUE = [
@@ -2459,7 +2580,7 @@ function evaluateIncidentGate(records) {
 }
 
 // src/commands/doctor.ts
-var execFileAsync2 = promisify2(execFile2);
+var execFileAsync = promisify(execFile2);
 async function checkNodeVersion() {
   const name = "Node.js version";
   const raw = process.version;
@@ -2497,7 +2618,7 @@ async function checkVSCodeExtension(id, label) {
   let installBin = "code";
   for (const bin of ["code", "code-insiders"]) {
     try {
-      await execFileAsync2(bin, ["--version"]);
+      await execFileAsync(bin, ["--version"]);
       installBin = bin;
       break;
     } catch {