baro-ai 0.23.1 → 0.23.2

package/dist/cli.mjs

@@ -7414,32 +7414,53 @@ async function createOrCheckoutBranch(cwd, branchName, onLog) {
     );
   }
 }
-async function safePullRebase(cwd, onLog) {
-  if (!await hasRemoteOrigin(cwd)) {
-    onLog?.("[git] no remote, skipping pull");
-    return;
-  }
-  let branch;
-  try {
-    branch = await getCurrentBranch(cwd);
-  } catch {
-    onLog?.("[git] no branch, skipping pull");
-    return;
-  }
-  if (!await hasRemoteBranch(cwd, branch)) {
-    onLog?.("[git] remote branch not found, skipping pull");
-    return;
-  }
-  onLog?.("[git] pulling latest...");
-  await execSafe("git", ["stash", "--include-untracked"], { cwd });
+async function safePullRebase(cwd, onLog, gate) {
+  const release = gate ? await gate.acquire() : null;
   try {
-    await exec("git", ["pull", "--rebase", "origin", branch], { cwd });
-    onLog?.("[git] pull ok");
-  } catch {
-    onLog?.("[git] pull conflict, continuing without pull");
-    await execSafe("git", ["rebase", "--abort"], { cwd });
+    if (!await hasRemoteOrigin(cwd)) {
+      onLog?.("[git] no remote, skipping pull");
+      return;
+    }
+    let branch;
+    try {
+      branch = await getCurrentBranch(cwd);
+    } catch {
+      onLog?.("[git] no branch, skipping pull");
+      return;
+    }
+    if (!await hasRemoteBranch(cwd, branch)) {
+      onLog?.("[git] remote branch not found, skipping pull");
+      return;
+    }
+    onLog?.("[git] pulling latest...");
+    let stashSha = null;
+    try {
+      const { stdout } = await exec("git", ["stash", "create"], { cwd });
+      stashSha = stdout.trim() || null;
+      if (stashSha) {
+        await execSafe("git", ["reset", "--hard", "HEAD"], { cwd });
+      }
+    } catch {
+    }
+    try {
+      await exec("git", ["pull", "--rebase", "origin", branch], { cwd });
+      onLog?.("[git] pull ok");
+    } catch {
+      onLog?.("[git] pull conflict, continuing without pull");
+      await execSafe("git", ["rebase", "--abort"], { cwd });
+    }
+    if (stashSha) {
+      try {
+        await exec("git", ["stash", "apply", stashSha], { cwd });
+      } catch (e) {
+        onLog?.(
+          `[git] could not re-apply stashed edits (sha ${stashSha.slice(0, 8)}): ${e?.message ?? String(e)}`
+        );
+      }
+    }
+  } finally {
+    release?.();
   }
-  await execSafe("git", ["stash", "pop"], { cwd });
 }
 async function gitPushWithRetry(gate, options) {
   const release = await gate.acquire();
@@ -7451,8 +7472,8 @@ async function gitPushWithRetry(gate, options) {
     const branch = await getCurrentBranch(options.cwd);
     const max = options.maxAttempts ?? GIT_PUSH_MAX_ATTEMPTS;
     let lastError = "";
+    options.onLog?.("[git] pushing...");
     for (let attempt = 1; attempt <= max; attempt++) {
-      options.onLog?.("[git] pushing...");
       try {
         await exec("git", ["push", "origin", branch], { cwd: options.cwd });
         options.onLog?.("[git] push ok");
@@ -7461,7 +7482,9 @@ async function gitPushWithRetry(gate, options) {
         lastError = extractStderr(e);
       }
       if (attempt === max) break;
-      options.onLog?.("[git] push failed, pulling and retrying...");
+      options.onLog?.(
+        `[git] push rejected (attempt ${attempt}/${max}), pulling and retrying...`
+      );
       try {
         await exec("git", ["pull", "--rebase", "origin", branch], {
           cwd: options.cwd
@@ -7472,7 +7495,10 @@ async function gitPushWithRetry(gate, options) {
         throw new Error("Rebase conflict detected, push skipped");
       }
     }
-    options.onLog?.(`[git] push failed after ${max} attempts`);
+    const compactErr = lastError.split("\n")[0]?.trim() || lastError;
+    options.onLog?.(
+      `[git] push failed after ${max} attempts: ${compactErr}`
+    );
     throw new Error(`Push failed after ${max} attempts: ${lastError}`);
   } finally {
     release();
@@ -7921,14 +7947,26 @@ var Auditor = class extends Participant {
   path;
   skipStreamChunks;
   filter;
+  /**
+   * Flips to true the first time a write fails (e.g. EACCES because
+   * `~/.baro/runs/` is root-owned from a sudo install). Once disabled,
+   * subsequent items are dropped silently — losing the audit log is
+   * better than crashing the orchestrator on every bus event.
+   */
+  disabled = false;
   constructor(opts) {
     super();
     this.path = opts.path;
     this.skipStreamChunks = opts.skipStreamChunks ?? true;
     this.filter = opts.filter;
-    mkdirSync(dirname(this.path), { recursive: true });
+    try {
+      mkdirSync(dirname(this.path), { recursive: true });
+    } catch (e) {
+      this.disable(`mkdir failed: ${e?.message ?? String(e)}`);
+    }
   }
   async onContextItem(source, item) {
+    if (this.disabled) return;
     if (this.skipStreamChunks && item instanceof ClaudeStreamChunkItem) {
       return;
     }
@@ -7940,7 +7978,19 @@ var Auditor = class extends Participant {
       source: this.sourceLabel(source),
       item: item.toJSON()
     };
-    appendFileSync(this.path, JSON.stringify(entry) + "\n");
+    try {
+      appendFileSync(this.path, JSON.stringify(entry) + "\n");
+    } catch (e) {
+      this.disable(`append failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  disable(reason) {
+    if (this.disabled) return;
+    this.disabled = true;
+    process.stderr.write(
+      `[auditor] cannot write audit log at ${this.path}: ${reason} \u2014 continuing without audit
+`
+    );
   }
   sourceLabel(source) {
     const ctor = source.constructor.name;
@@ -8153,7 +8203,7 @@ function stringifyToolResultContent(content) {
 }
 
 // ../baro-orchestrator/src/participants/claude-cli-participant.ts
-var ClaudeCliParticipant = class extends Participant {
+var ClaudeCliParticipant = class _ClaudeCliParticipant extends Participant {
   constructor(agentId, opts) {
     super();
     this.agentId = agentId;
@@ -8172,6 +8222,22 @@ var ClaudeCliParticipant = class extends Participant {
       this.resolveDone = res;
     });
   }
+  /**
+   * Process-wide registry of every Claude child currently running.
+   * Used by the orchestrator's SIGINT/SIGTERM handlers to nuke
+   * orphaned Claude processes so a killed baro doesn't leave a swarm
+   * of background agents burning quota.
+   */
+  static active = /* @__PURE__ */ new Set();
+  /** Send a signal to every active Claude child. Idempotent. */
+  static killAll(signal = "SIGTERM") {
+    for (const p of _ClaudeCliParticipant.active) {
+      try {
+        p.proc?.kill(signal);
+      } catch {
+      }
+    }
+  }
   options;
   proc = null;
   buffer = "";
@@ -8221,6 +8287,7 @@ var ClaudeCliParticipant = class extends Participant {
       return;
     }
     this.proc = proc;
+    _ClaudeCliParticipant.active.add(this);
     this.transition("starting");
     proc.stdout.setEncoding("utf8");
     proc.stderr.setEncoding("utf8");
@@ -8231,6 +8298,7 @@ var ClaudeCliParticipant = class extends Participant {
       this.rejectReady(err);
     });
     proc.on("exit", (code) => {
+      _ClaudeCliParticipant.active.delete(this);
       this.exitCode = code;
       const finalPhase = this.spawnError != null || code != null && code !== 0 ? "failed" : "done";
       this.transition(finalPhase, code != null ? `exit code ${code}` : "no exit code");
@@ -9885,7 +9953,8 @@ async function orchestrate(config) {
     onStoryPassed: useGit ? async (storyId) => {
       await safePullRebase(
         config.cwd,
-        (line) => emitTui && emit({ type: "story_log", id: storyId, line })
+        (line) => emitTui && emit({ type: "story_log", id: storyId, line }),
+        gitGate
       );
       try {
         await gitPushWithRetry(gitGate, {
@@ -10303,14 +10372,42 @@ process.on("unhandledRejection", (reason) => {
   const stack = reason?.stack ?? String(reason);
   process.stderr.write(`[cli] unhandledRejection: ${stack}
 `);
+  ClaudeCliParticipant.killAll("SIGTERM");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
   const stack = err?.stack ?? String(err);
   process.stderr.write(`[cli] uncaughtException: ${stack}
 `);
+  ClaudeCliParticipant.killAll("SIGTERM");
   process.exit(1);
 });
+var shuttingDown = false;
+function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  process.stderr.write(`[cli] received ${signal}, killing in-flight Claude children...
+`);
+  ClaudeCliParticipant.killAll("SIGTERM");
+  setTimeout(() => {
+    ClaudeCliParticipant.killAll("SIGKILL");
+    process.exit(signal === "SIGINT" ? 130 : 143);
+  }, 1500).unref();
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+var initialPpid = process.ppid;
+var orphanWatchdog = setInterval(() => {
+  if (process.ppid !== initialPpid) {
+    process.stderr.write(
+      `[cli] parent died (ppid ${initialPpid} \u2192 ${process.ppid}), shutting down
+`
+    );
+    clearInterval(orphanWatchdog);
+    shutdown("SIGTERM");
+  }
+}, 1e3);
+orphanWatchdog.unref();
 main().catch((e) => {
   process.stderr.write(`[cli] unhandled: ${e?.stack ?? String(e)}
 `);