@cueloop/daemon 0.1.0-alpha.80 → 0.1.0-alpha.81

package/src/herdr-thread-surface.ts

@@ -0,0 +1,355 @@
+import {
+  detectHerdr,
+  type HerdrEnv,
+  type Thread,
+  type ThreadSurfaceOpenStatus,
+} from "@cueloop/schema";
+import { spawnSync } from "node:child_process";
+import * as v from "valibot";
+import type { HerdrThreadSurfaceHandle } from "./herdr-thread-surface-store";
+import { loadHerdrThreadSurface, type HerdrThreadSurface } from "./thread-surface-config";
+
+const HERDR_SPAWN_TIMEOUT_MS = 2000;
+
+interface HerdrCommandResult {
+  exitCode: number;
+  stdout: Buffer;
+}
+
+function runHerdrCommand(
+  command: string[],
+  options: { stdout: "pipe" | "ignore"; stderr: "ignore"; timeout: number },
+): HerdrCommandResult {
+  const result = spawnSync(command[0]!, command.slice(1), {
+    stdio: ["ignore", options.stdout, options.stderr],
+    timeout: options.timeout,
+  });
+
+  return { exitCode: result.status ?? 1, stdout: result.stdout ?? Buffer.alloc(0) };
+}
+const CreatedTabSchema = v.object({
+  result: v.optional(
+    v.object({
+      root_pane: v.optional(
+        v.object({ pane_id: v.optional(v.string()), tab_id: v.optional(v.string()) }),
+      ),
+    }),
+  ),
+});
+const PaneResultSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.unknown()) })),
+});
+const CreatedPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ pane_id: v.string() })) })),
+});
+const PaneNeighborSchema = v.object({
+  result: v.object({
+    neighbor: v.object({ neighbor_pane_id: v.optional(v.nullable(v.string())) }),
+  }),
+});
+const PaneFocusSchema = v.object({
+  result: v.optional(
+    v.object({ focus: v.optional(v.object({ focused_pane_id: v.nullable(v.string()) })) }),
+  ),
+});
+
+/** Inputs for a new Herdr Thread tab. */
+export interface OpenHerdrThreadTabOptions {
+  sessionId: string;
+  cwd: string;
+  binPath: string;
+  label: string;
+  workspaceId?: string;
+}
+
+/** Daemon-owned native handles, separate from canonical Thread records. */
+export interface HerdrThreadSurfacePersistence {
+  herdrGetThreadSurface(sessionId: string): Promise<HerdrThreadSurfaceHandle | null>;
+  herdrSetThreadSurface(sessionId: string, handle: HerdrThreadSurfaceHandle): Promise<void>;
+}
+
+/** Open a focused Herdr tab; keep both native IDs for later liveness checks. */
+export function openHerdrThreadTab(
+  options: OpenHerdrThreadTabOptions,
+): HerdrThreadSurfaceHandle | null {
+  const { sessionId, cwd, binPath, label, workspaceId } = options;
+
+  try {
+    const created = runHerdrCommand(
+      [
+        binPath,
+        "tab",
+        "create",
+        ...(workspaceId ? ["--workspace", workspaceId] : []),
+        "--cwd",
+        cwd,
+        "--label",
+        label,
+        "--focus",
+      ],
+      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+    );
+
+    if (created.exitCode !== 0) return null;
+    const parsed = v.safeParse(CreatedTabSchema, JSON.parse(created.stdout.toString()));
+
+    if (!parsed.success) return null;
+    const paneId = parsed.output.result?.root_pane?.pane_id;
+    const tabId = parsed.output.result?.root_pane?.tab_id;
+
+    if (!paneId || !tabId) return null;
+
+    if (!sendCueloopThreadCommand(binPath, paneId, sessionId)) {
+      closeUnlaunchedHerdrSurface(binPath, "tab", tabId);
+
+      return null;
+    }
+
+    return { tabId, paneId };
+  } catch {
+    return null;
+  }
+}
+
+/** Inputs for a focused right-hand Herdr Thread pane. */
+export interface OpenHerdrThreadPaneOptions {
+  sessionId: string;
+  cwd: string;
+  binPath: string;
+  sourcePaneId: string;
+  tabId: string;
+}
+
+/** Split the calling Herdr pane right at 50 percent and launch cueloop in it. */
+export function openHerdrThreadPane(
+  options: OpenHerdrThreadPaneOptions,
+): HerdrThreadSurfaceHandle | null {
+  const { sessionId, cwd, binPath, sourcePaneId, tabId } = options;
+
+  try {
+    const created = runHerdrCommand(
+      [
+        binPath,
+        "pane",
+        "split",
+        sourcePaneId,
+        "--direction",
+        "right",
+        "--ratio",
+        "0.5",
+        "--cwd",
+        cwd,
+        "--focus",
+      ],
+      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+    );
+
+    if (created.exitCode !== 0) return null;
+    const parsed = v.safeParse(CreatedPaneSchema, JSON.parse(created.stdout.toString()));
+    const paneId = parsed.success ? parsed.output.result?.pane?.pane_id : undefined;
+
+    if (!paneId) return null;
+    if (!sendCueloopThreadCommand(binPath, paneId, sessionId)) {
+      closeUnlaunchedHerdrSurface(binPath, "pane", paneId);
+
+      return null;
+    }
+
+    return { mode: "pane", tabId, paneId };
+  } catch {
+    return null;
+  }
+}
+
+function closeUnlaunchedHerdrSurface(binPath: string, kind: "tab" | "pane", id: string): void {
+  try {
+    runHerdrCommand([binPath, kind, "close", id], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+  } catch {
+    // The pending Thread remains available through the manual command.
+  }
+}
+
+function sendCueloopThreadCommand(binPath: string, paneId: string, sessionId: string): boolean {
+  const typed = runHerdrCommand([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
+    stdout: "ignore",
+    stderr: "ignore",
+    timeout: HERDR_SPAWN_TIMEOUT_MS,
+  });
+
+  if (typed.exitCode !== 0) return false;
+  const entered = runHerdrCommand([binPath, "pane", "send-keys", paneId, "enter"], {
+    stdout: "ignore",
+    stderr: "ignore",
+    timeout: HERDR_SPAWN_TIMEOUT_MS,
+  });
+
+  return entered.exitCode === 0;
+}
+
+/** Check the recorded pane ID before deciding whether to reopen. */
+function herdrPaneAlive(binPath: string, paneId: string): boolean {
+  try {
+    const got = runHerdrCommand([binPath, "pane", "get", paneId], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+
+    if (got.exitCode !== 0) return false;
+    const parsed = v.safeParse(PaneResultSchema, JSON.parse(got.stdout.toString()));
+
+    return parsed.success && parsed.output.result?.pane != null;
+  } catch {
+    return false;
+  }
+}
+
+/** Focus a recorded Herdr tab. */
+function focusHerdrTab(binPath: string, tabId: string): boolean {
+  try {
+    const focused = runHerdrCommand([binPath, "tab", "focus", tabId], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+
+    return focused.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+function focusHerdrThreadSurface(binPath: string, handle: HerdrThreadSurfaceHandle): boolean {
+  if (!focusHerdrTab(binPath, handle.tabId)) return false;
+
+  if (handle.mode !== "pane") return true;
+
+  try {
+    const directions = [
+      ["left", "right"],
+      ["right", "left"],
+      ["up", "down"],
+      ["down", "up"],
+    ] as const;
+    let hasNeighbor = false;
+
+    for (const [direction, opposite] of directions) {
+      const neighbor = herdrPaneNeighbor(binPath, handle.paneId, direction);
+
+      if (neighbor === undefined) return false;
+      if (neighbor === null) continue;
+      hasNeighbor = true;
+
+      if (herdrPaneNeighbor(binPath, neighbor, opposite) !== handle.paneId) continue;
+      const focused = runHerdrCommand(
+        [binPath, "pane", "focus", "--pane", neighbor, "--direction", opposite],
+        { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+      );
+      const parsed = v.safeParse(PaneFocusSchema, JSON.parse(focused.stdout.toString()));
+
+      if (
+        focused.exitCode === 0 &&
+        parsed.success &&
+        parsed.output.result?.focus?.focused_pane_id === handle.paneId
+      ) {
+        return true;
+      }
+    }
+
+    return !hasNeighbor;
+  } catch {
+    return false;
+  }
+}
+
+function herdrPaneNeighbor(
+  binPath: string,
+  paneId: string,
+  direction: string,
+): string | null | undefined {
+  try {
+    const neighbor = runHerdrCommand(
+      [binPath, "pane", "neighbor", "--pane", paneId, "--direction", direction],
+      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+    );
+
+    if (neighbor.exitCode !== 0) return undefined;
+    const parsed = v.safeParse(PaneNeighborSchema, JSON.parse(neighbor.stdout.toString()));
+
+    return parsed.success ? (parsed.output.result.neighbor.neighbor_pane_id ?? null) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Reuse a live Thread surface, reopen a closed one, or report a manual fallback. */
+export async function openHerdrThreadSurface(
+  session: Thread,
+  persistence: HerdrThreadSurfacePersistence,
+  env: HerdrEnv = process.env,
+  mode: HerdrThreadSurface = loadHerdrThreadSurface(),
+): Promise<ThreadSurfaceOpenStatus> {
+  const herdr = detectHerdr(env);
+
+  if (!herdr) return "unavailable";
+
+  if (mode === "none") return "disabled";
+  const recorded = await recallHerdrThreadSurface(persistence, session.id);
+
+  if (recorded && herdrPaneAlive(herdr.binPath, recorded.paneId)) {
+    return focusHerdrThreadSurface(herdr.binPath, recorded) ? "focused" : "failed";
+  }
+  const cwd = session.artifact.meta.cwd ?? session.workspace.repoRoot;
+  const opened =
+    mode === "pane"
+      ? env.HERDR_TAB_ID
+        ? openHerdrThreadPane({
+            sessionId: session.id,
+            cwd,
+            binPath: herdr.binPath,
+            sourcePaneId: herdr.paneId,
+            tabId: env.HERDR_TAB_ID,
+          })
+        : null
+      : openHerdrThreadTab({
+          sessionId: session.id,
+          cwd,
+          binPath: herdr.binPath,
+          label: session.artifact.meta.title ?? session.id,
+          workspaceId: env.HERDR_WORKSPACE_ID,
+        });
+
+  if (!opened) return "failed";
+  await rememberHerdrThreadSurface(persistence, session.id, opened);
+
+  return "opened";
+}
+
+/** A stale daemon cannot prevent the reviewer from opening the pending Thread. */
+async function recallHerdrThreadSurface(
+  persistence: HerdrThreadSurfacePersistence,
+  sessionId: string,
+): Promise<HerdrThreadSurfaceHandle | null> {
+  try {
+    return await persistence.herdrGetThreadSurface(sessionId);
+  } catch {
+    return null;
+  }
+}
+
+/** Handle persistence is best-effort after the new terminal has opened. */
+async function rememberHerdrThreadSurface(
+  persistence: HerdrThreadSurfacePersistence,
+  sessionId: string,
+  handle: HerdrThreadSurfaceHandle,
+): Promise<void> {
+  try {
+    await persistence.herdrSetThreadSurface(sessionId, handle);
+  } catch {
+    // The Thread remains pending even if the old daemon cannot store this handle.
+  }
+}

package/src/paths.ts

@@ -60,11 +60,16 @@ export function ownerTokenPath(home = cueloopHome()): string {
   return join(home, "owner.token");
 }
 
-/** Adapter scratch: herdr tab handles keyed by session id, kept out of the core session record. */
-export function herdrTabsPath(home = cueloopHome()): string {
+/** Adapter scratch for Herdr handles; the disk name stays stable across tab and pane support. */
+export function herdrThreadSurfacesPath(home = cueloopHome()): string {
   return join(home, "herdr-tabs.json");
 }
 
+/** Ghostty-native terminal IDs are adapter scratch, not Thread state. */
+export function ghosttyThreadSurfacesPath(home = cueloopHome()): string {
+  return join(home, "ghostty-thread-surfaces.json");
+}
+
 /** Harness bindings and Message deliveries, stored independently of Thread records. */
 export function harnessStatePath(home = cueloopHome()): string {
   return join(home, "harness-state.json");

package/src/server.test.ts

@@ -59,6 +59,8 @@ describe("socket round-trip", () => {
     const binding = await client.harnessBind(thread.id, "fake", "fake_1");
 
     expect(await client.harnessGetBinding(binding.id)).toEqual(binding);
+    expect(await client.harnessBindingsForSession("fake", "fake_1")).toEqual([binding]);
+    expect(await client.harnessBindingsForSession("fake", "different")).toEqual([]);
 
     const sent = await client.sessionSendMessage(thread.id, "approved", "Ready.");
     const pending = await client.deliveryPending(binding.id);

package/src/server.ts

@@ -8,10 +8,13 @@ import {
   chmodSync,
   closeSync,
   existsSync,
+  fstatSync,
+  linkSync,
   mkdirSync,
   openSync,
   readFileSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { DaemonCore, type DaemonEvent } from "./api";
@@ -55,6 +58,7 @@ export interface DaemonOptions {
  * so in-process ownership is tracked separately.
  */
 const HELD_HOMES = new Set<string>();
+const LOCK_WAIT = new Int32Array(new SharedArrayBuffer(4));
 
 export class DaemonServer {
   readonly core: DaemonCore;
@@ -91,20 +95,35 @@ export class DaemonServer {
     const path = lockPath(this.home);
 
     for (let attempt = 0; attempt < 3; attempt++) {
-      try {
-        // "wx" fails when the file exists - the atomic part of the handshake
-        const fd = openSync(path, "wx");
+      const preparedPath = `${path}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+      const fd = openSync(preparedPath, "wx", 0o600);
 
+      try {
+        // Publish the complete pid atomically. A competing daemon must never
+        // mistake a newly created, still-empty lock for a crashed owner.
         writeFileSync(fd, String(process.pid));
+        linkSync(preparedPath, path);
         this.lockFd = fd;
         HELD_HOMES.add(this.home);
 
         return true;
-      } catch {
+      } catch (error) {
+        closeSync(fd);
+        if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+
         let ownerPid = 0;
 
         try {
-          ownerPid = Number(readFileSync(path, "utf8").trim());
+          let ownerText = readFileSync(path, "utf8").trim();
+
+          // Older daemon builds published the lock before writing their pid.
+          // Give that live owner time to finish instead of stealing its socket.
+          for (let probe = 0; !ownerText && probe < 25; probe++) {
+            Atomics.wait(LOCK_WAIT, 0, 0, 20);
+            ownerText = readFileSync(path, "utf8").trim();
+          }
+          if (!ownerText && Date.now() - statSync(path).mtimeMs < 5_000) return false;
+          ownerPid = Number(ownerText);
         } catch {
           // the owner vanished between open and read; retry
           continue;
@@ -125,6 +144,8 @@ export class DaemonServer {
         } catch {
           return false;
         }
+      } finally {
+        rmSync(preparedPath, { force: true });
       }
     }
 
@@ -134,6 +155,12 @@ export class DaemonServer {
   private releaseLock(): void {
     HELD_HOMES.delete(this.home);
     if (this.lockFd !== null) {
+      try {
+        if (statSync(lockPath(this.home)).ino === fstatSync(this.lockFd).ino)
+          rmSync(lockPath(this.home), { force: true });
+      } catch {
+        // the lock was already removed or replaced
+      }
       try {
         closeSync(this.lockFd);
       } catch {
@@ -141,7 +168,6 @@ export class DaemonServer {
       }
       this.lockFd = null;
     }
-    rmSync(lockPath(this.home), { force: true });
   }
 
   /**
@@ -205,6 +231,7 @@ export class DaemonServer {
 
   stop(): void {
     this.core.dispose();
+    if (this.lockFd === null) return;
     this.server?.stop(true);
     this.server = null;
     rmSync(socketPath(this.home), { force: true });
@@ -469,6 +496,11 @@ export class DaemonServer {
 
       return this.core.harnessGetBinding(params.bindingId);
     },
+    "harness.bindingsForSession": (_connection, request) => {
+      const params = parseParams("harness.bindingsForSession", request.params);
+
+      return this.core.harnessBindingsForSession(params.harness, params.harnessSessionId);
+    },
     "harness.consumeApprovedRetry": (_connection, request) => {
       const params = parseParams("harness.consumeApprovedRetry", request.params);
 
@@ -498,12 +530,36 @@ export class DaemonServer {
         params.files,
       );
     },
-    "herdr.getTab": (_connection, request) =>
-      this.core.herdrGetTab(parseParams("herdr.getTab", request.params).id),
-    "herdr.setTab": (_connection, request) => {
-      const params = parseParams("herdr.setTab", request.params);
+    "herdr.getThreadSurface": (_connection, request) =>
+      this.core.herdrGetThreadSurface(parseParams("herdr.getThreadSurface", request.params).id),
+    "herdr.setThreadSurface": (_connection, request) => {
+      const params = parseParams("herdr.setThreadSurface", request.params);
+
+      this.core.herdrSetThreadSurface(params.id, {
+        tabId: params.tabId,
+        paneId: params.paneId,
+        mode: params.mode,
+      });
+
+      return {};
+    },
+    "ghostty.getThreadSurface": (_connection, request) =>
+      this.core.ghosttyGetThreadSurface(parseParams("ghostty.getThreadSurface", request.params).id),
+    "ghostty.setThreadSurface": (_connection, request) => {
+      const params = parseParams("ghostty.setThreadSurface", request.params);
+
+      this.core.ghosttySetThreadSurface(params.id, { terminalId: params.terminalId });
 
-      this.core.herdrSetTab(params.id, { tabId: params.tabId, paneId: params.paneId });
+      return {};
+    },
+    "ghostty.claimThreadSurface": (_connection, request) =>
+      this.core.ghosttyClaimThreadSurface(
+        parseParams("ghostty.claimThreadSurface", request.params).id,
+      ),
+    "ghostty.releaseThreadSurface": (_connection, request) => {
+      this.core.ghosttyReleaseThreadSurface(
+        parseParams("ghostty.releaseThreadSurface", request.params).id,
+      );
 
       return {};
     },

package/src/single-instance.test.ts

@@ -5,12 +5,13 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createServer } from "node:net";
 import { DaemonServer } from "./server";
 import { DaemonClient } from "./client";
-import { lockPath, socketPath } from "./paths";
+import { lockPath, ownerTokenPath, socketPath } from "./paths";
 import type { Artifact, WorkspaceKey } from "@cueloop/schema";
 
 const WS: WorkspaceKey = { repoRoot: "/repo", branch: "main" };
@@ -50,6 +51,23 @@ describe("one daemon per home", () => {
     expect(existsSync(path!)).toBe(true);
   });
 
+  test("stopping a refused server leaves the lock owner's socket intact", async () => {
+    const first = server();
+    const path = first.start();
+    const refused = server();
+
+    expect(refused.start()).toBeNull();
+    refused.stop();
+    expect(existsSync(path!)).toBe(true);
+    const client = await DaemonClient.connect({ home });
+
+    try {
+      expect((await client.ping()).pid).toBe(process.pid);
+    } finally {
+      client.close();
+    }
+  });
+
   test("clients keep talking to the one live daemon after a refused start", async () => {
     // Arrange
     const first = server();
@@ -81,6 +99,32 @@ describe("one daemon per home", () => {
     expect(daemonServer.start()).toBe(socketPath(home));
   });
 
+  test("a daemon does not steal a lock while its owner writes the pid", async () => {
+    const path = lockPath(home);
+    const script = `
+      import { openSync, writeFileSync } from "node:fs";
+      const fd = openSync(${JSON.stringify(path)}, "wx");
+      console.log("lock created");
+      setTimeout(() => writeFileSync(fd, String(process.pid)), 100);
+      setTimeout(() => {}, 2_000);
+    `;
+    const owner = Bun.spawn([process.execPath, "-e", script], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    try {
+      const firstOutput = await owner.stdout.getReader().read();
+
+      expect(new TextDecoder().decode(firstOutput.value)).toContain("lock created");
+      expect(server().start()).toBeNull();
+      expect(existsSync(socketPath(home))).toBe(false);
+    } finally {
+      owner.kill();
+      await owner.exited;
+    }
+  });
+
   test("an autostarted daemon reclaims a stale socket after taking the lock", async () => {
     writeFileSync(socketPath(home), "stale socket");
     const client = await DaemonClient.connect({ home, autostart: true });
@@ -93,6 +137,20 @@ describe("one daemon per home", () => {
     }
   });
 
+  test("autostart reports the daemon error when the child cannot start", async () => {
+    mkdirSync(ownerTokenPath(home));
+    const previousTimeout = process.env.CUELOOP_START_TIMEOUT_MS;
+
+    // This checks error reporting, not startup speed; allow the child to start on a loaded runner.
+    process.env.CUELOOP_START_TIMEOUT_MS = "5000";
+    try {
+      await expect(DaemonClient.connect({ home, autostart: true })).rejects.toThrow("EISDIR");
+    } finally {
+      if (previousTimeout === undefined) delete process.env.CUELOOP_START_TIMEOUT_MS;
+      else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
+    }
+  }, 10_000);
+
   test("stopping releases the lock so a restart works", () => {
     // Arrange
     const first = server();
@@ -159,4 +217,34 @@ describe("one daemon per home", () => {
       else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
     }
   });
+
+  test("autostart retries after a socket closes during the handshake", async () => {
+    const path = socketPath(home);
+    const replacement = server();
+    const transient = createServer((socket) => {
+      socket.destroy();
+      transient.close(() => {
+        rmSync(path, { force: true });
+        rmSync(lockPath(home), { force: true });
+        replacement.start();
+      });
+    });
+
+    writeFileSync(lockPath(home), String(process.pid));
+    await new Promise<void>((resolve) => transient.listen(path, resolve));
+    const client = new DaemonClient();
+    const previousTimeout = process.env.CUELOOP_START_TIMEOUT_MS;
+
+    client["home"] = home;
+    process.env.CUELOOP_START_TIMEOUT_MS = "1000";
+    try {
+      await client["attachFreshDaemon"](home, path);
+      expect((await client.ping()).pid).toBe(process.pid);
+    } finally {
+      client.close();
+      if (transient.listening) transient.close();
+      if (previousTimeout === undefined) delete process.env.CUELOOP_START_TIMEOUT_MS;
+      else process.env.CUELOOP_START_TIMEOUT_MS = previousTimeout;
+    }
+  });
 });

package/src/thread-review.ts

@@ -1,12 +1,3 @@
-/**
- * The shared Thread review core: one open/wait/message path for every consumer -
- * CLI commands and agent adapters. openReview resolves the workspace, shapes
- * the artifact, and opens-or-revises by agentSessionId; awaitMessage maps the
- * wait contract onto the agent contract through messageResponse. An
- * adapter keeps only two bespoke parts: parsing its host's event shape and
- * serializing the decision in its host's contract.
- */
-
 import {
   isMarkdownArtifact,
   newAnnotationId,
@@ -18,6 +9,8 @@ import {
   type WorkspaceKey,
   type WorkflowKind,
 } from "@cueloop/schema";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { messageResponse } from "./api";
 import { ABORTED, pollUntilResolved, raceAbort } from "./interruptible-wait";
 
@@ -27,12 +20,9 @@ export { messageResponse };
 
 async function git(args: string[], cwd: string): Promise<string | null> {
   try {
-    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
-    const out = await new Response(proc.stdout).text();
-
-    if ((await proc.exited) !== 0) return null;
+    const { stdout } = await promisify(execFile)("git", args, { cwd });
 
-    return out.trim();
+    return stdout.trim();
   } catch {
     return null;
   }