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

package/src/herdr-split.ts

@@ -0,0 +1,92 @@
+/**
+ * Launches a bring-your-own review harness (claude code / pi / codex) in a herdr
+ * split beside the current pane - the Agent rail's "run it right here" spawn, so
+ * a reviewer chats with an agent about the plan without leaving the review tab.
+ * Best-effort and herdr-only: a no-op returning false outside herdr or on any
+ * spawn failure, each spawn bounded by a timeout.
+ */
+
+import { detectHerdr, type HerdrEnv } from "@cueloop/schema";
+import * as v from "valibot";
+
+const HERDR_SPAWN_TIMEOUT_MS = 2000;
+const SplitPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ pane_id: v.optional(v.string()) })) })),
+});
+
+/** How much of the current pane the launched harness split takes (herdr --ratio). */
+const HARNESS_SPLIT_RATIO = "0.4";
+
+export interface LaunchHarnessInSplitOptions {
+  /** The harness launch command run in the split, e.g. "cc", "pi", "codex". */
+  command: string;
+  /** Working directory for the split - the reviewed session's cwd. */
+  cwd: string;
+  /**
+   * A plan-context briefing typed into the split after the harness command, left
+   * unsubmitted for the reviewer to send. Best-effort: on a slow harness start it
+   * may reach the shell instead, so the launch never depends on it.
+   */
+  seedText?: string;
+}
+
+/**
+ * Split the current pane and run the harness in it. Returns true when the split
+ * opened, false on any best-effort bail-out. No-op outside herdr.
+ */
+export function launchHarnessInSplit(
+  options: LaunchHarnessInSplitOptions,
+  env: HerdrEnv = process.env,
+): boolean {
+  const herdr = detectHerdr(env);
+
+  if (!herdr) return false;
+  try {
+    const split = Bun.spawnSync(
+      [
+        herdr.binPath,
+        "pane",
+        "split",
+        herdr.paneId,
+        "--direction",
+        "right",
+        "--ratio",
+        HARNESS_SPLIT_RATIO,
+        "--cwd",
+        options.cwd,
+      ],
+      { stdout: "pipe", stderr: "ignore", timeout: HERDR_SPAWN_TIMEOUT_MS },
+    );
+
+    if (split.exitCode !== 0) return false;
+    const parsed = v.safeParse(SplitPaneSchema, JSON.parse(split.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const paneId = parsed.output.result?.pane?.pane_id;
+
+    if (!paneId) return false;
+    sendText(herdr.binPath, paneId, options.command);
+    sendKeys(herdr.binPath, paneId, "enter");
+    if (options.seedText) sendText(herdr.binPath, paneId, options.seedText);
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sendText(binPath: string, paneId: string, text: string): void {
+  Bun.spawnSync([binPath, "pane", "send-text", paneId, text], {
+    stdout: "ignore",
+    stderr: "ignore",
+    timeout: HERDR_SPAWN_TIMEOUT_MS,
+  });
+}
+
+function sendKeys(binPath: string, paneId: string, keys: string): void {
+  Bun.spawnSync([binPath, "pane", "send-keys", paneId, keys], {
+    stdout: "ignore",
+    stderr: "ignore",
+    timeout: HERDR_SPAWN_TIMEOUT_MS,
+  });
+}

package/src/herdr-tab-store.test.ts

@@ -0,0 +1,96 @@
+/** herdr tab side-store: set/get/delete round-trips, survives a reload from disk, and ignores a corrupt file. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { HerdrTabStore } from "./herdr-tab-store";
+import { herdrTabsPath } from "./paths";
+
+let home: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-herdr-store-"));
+});
+afterEach(() => {
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("HerdrTabStore", () => {
+  test("set then get returns the handle; get for an unknown session is null", () => {
+    // Arrange
+    const store = new HerdrTabStore(home);
+
+    // Act
+    store.set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
+
+    // Assert
+    expect(store.get("ses_1")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+    expect(store.get("ses_missing")).toBeNull();
+  });
+
+  test("handles survive a reload from disk", () => {
+    // Arrange
+    new HerdrTabStore(home).set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
+
+    // Act - a fresh store over the same home loads the persisted file
+    const reloaded = new HerdrTabStore(home);
+
+    // Assert
+    expect(reloaded.get("ses_1")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+  });
+
+  test("delete removes the handle", () => {
+    // Arrange
+    const store = new HerdrTabStore(home);
+
+    store.set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
+
+    // Act
+    store.delete("ses_1");
+
+    // Assert
+    expect(store.get("ses_1")).toBeNull();
+  });
+
+  test("a corrupt file starts empty instead of throwing", () => {
+    // Arrange
+    writeFileSync(herdrTabsPath(home), "not json");
+
+    // Act
+    const store = new HerdrTabStore(home);
+
+    // Assert
+    expect(store.get("ses_1")).toBeNull();
+  });
+
+  test("malformed entries are dropped, well-formed ones survive", () => {
+    // Arrange - valid JSON, but entries with the wrong shape
+    writeFileSync(
+      herdrTabsPath(home),
+      JSON.stringify({
+        ses_ok: { tabId: "w1:t2", paneId: "w1:p2" },
+        ses_partial: { tabId: "w1:t2" },
+        ses_typed: { tabId: 1, paneId: 2 },
+        ses_null: null,
+      }),
+    );
+
+    // Act
+    const store = new HerdrTabStore(home);
+
+    // Assert
+    expect(store.get("ses_ok")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+    expect(store.get("ses_partial")).toBeNull();
+    expect(store.get("ses_typed")).toBeNull();
+    expect(store.get("ses_null")).toBeNull();
+  });
+
+  test("a non-object top level starts empty", () => {
+    // Arrange
+    writeFileSync(herdrTabsPath(home), JSON.stringify(["not", "a", "map"]));
+
+    // Act & Assert
+    expect(new HerdrTabStore(home).get("ses_1")).toBeNull();
+  });
+});

package/src/herdr-tab-store.ts

@@ -0,0 +1,66 @@
+/**
+ * herdr adapter scratch, kept out of the core session record: the tab cueloop
+ * opened to render each review, keyed by session id. One JSON map, atomic write.
+ * The core `Thread` never mentions herdr; this side-store is the whole
+ * leak boundary.
+ */
+
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import * as v from "valibot";
+import { herdrTabsPath } from "./paths";
+
+/** The tab and its root pane: pane id checks liveness, tab id focuses it. */
+export interface HerdrTabHandle {
+  tabId: string;
+  paneId: string;
+}
+
+const HerdrTabHandleSchema = v.object({
+  tabId: v.string(),
+  paneId: v.string(),
+});
+const HerdrTabsSchema = v.record(v.string(), v.unknown());
+
+export class HerdrTabStore {
+  private tabs = new Map<string, HerdrTabHandle>();
+  private readonly path: string;
+
+  constructor(home: string) {
+    this.path = herdrTabsPath(home);
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      const parsed = v.parse(HerdrTabsSchema, JSON.parse(readFileSync(this.path, "utf8")));
+
+      for (const [sessionId, value] of Object.entries(parsed)) {
+        const handle = v.safeParse(HerdrTabHandleSchema, value);
+
+        if (handle.success) this.tabs.set(sessionId, handle.output);
+      }
+    } catch {
+      // absent, unreadable, or malformed: start empty - a stale tab just reopens on resubmit
+    }
+  }
+
+  private persist(): void {
+    const tempPath = this.path + ".tmp";
+
+    writeFileSync(tempPath, JSON.stringify(Object.fromEntries(this.tabs), null, 2));
+    renameSync(tempPath, this.path);
+  }
+
+  get(sessionId: string): HerdrTabHandle | null {
+    return this.tabs.get(sessionId) ?? null;
+  }
+
+  set(sessionId: string, handle: HerdrTabHandle): void {
+    this.tabs.set(sessionId, handle);
+    this.persist();
+  }
+
+  delete(sessionId: string): void {
+    if (this.tabs.delete(sessionId)) this.persist();
+  }
+}

package/src/index.ts

@@ -1,9 +1,8 @@
-export * from "./api";
-export * from "./review";
-export * from "./errors";
-export * from "./validate";
-export * from "./store";
-export * from "./server";
-export * from "./protocol";
-export * from "./paths";
-export { DaemonClient, DaemonClientError, type ConnectOptions } from "./client";
+/**
+ * The daemon's public surface. Consumers reach the client and the review
+ * helpers through the ./client and ./thread-review subpaths; this barrel carries
+ * only the two names imported bare: the server and the home-dir resolver.
+ */
+
+export { DaemonServer, type DaemonOptions } from "./server";
+export { cueloopHome } from "./paths";

package/src/interruptible-wait.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "bun:test";
+import { ABORTED, pollUntilResolved, raceAbort } from "./interruptible-wait";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (cause: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}
+
+describe("raceAbort", () => {
+  test("without a signal the promise passes straight through", async () => {
+    expect(await raceAbort(Promise.resolve("value"), undefined)).toBe("value");
+  });
+
+  test("resolves to the value when the promise settles before any abort", async () => {
+    const controller = new AbortController();
+
+    expect(await raceAbort(Promise.resolve(7), controller.signal)).toBe(7);
+  });
+
+  test("an already-aborted signal returns ABORTED without waiting", async () => {
+    const controller = new AbortController();
+
+    controller.abort();
+
+    expect(await raceAbort(new Promise<never>(() => {}), controller.signal)).toBe(ABORTED);
+  });
+
+  test("a signal that fires during the wait returns ABORTED", async () => {
+    const controller = new AbortController();
+    const pending = deferred<number>();
+    const raced = raceAbort(pending.promise, controller.signal);
+
+    controller.abort();
+
+    expect(await raced).toBe(ABORTED);
+  });
+
+  test("a rejection propagates the original error unchanged", async () => {
+    const controller = new AbortController();
+    const original = new Error("daemon socket closed");
+    let caught: unknown;
+
+    try {
+      await raceAbort(Promise.reject(original), controller.signal);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBe(original);
+  });
+
+  test("a rejection that lands after an abort is swallowed, not surfaced", async () => {
+    const controller = new AbortController();
+    const pending = deferred<number>();
+    const raced = raceAbort(pending.promise, controller.signal);
+
+    controller.abort();
+    const result = await raced;
+
+    pending.reject(new Error("late daemon error"));
+    await Bun.sleep(10);
+
+    expect(result).toBe(ABORTED);
+  });
+});
+
+describe("pollUntilResolved", () => {
+  test("returns the first non-null attempt", async () => {
+    expect(await pollUntilResolved(() => Promise.resolve("done"), undefined)).toBe("done");
+  });
+
+  test("keeps polling past null attempts until one resolves", async () => {
+    let calls = 0;
+    const attempt = () => {
+      calls++;
+
+      return Promise.resolve(calls < 3 ? null : "third");
+    };
+
+    expect(await pollUntilResolved(attempt, undefined)).toBe("third");
+    expect(calls).toBe(3);
+  });
+
+  test("an already-aborted signal returns null before any attempt", async () => {
+    const controller = new AbortController();
+    let calls = 0;
+
+    controller.abort();
+    const result = await pollUntilResolved(() => {
+      calls++;
+
+      return Promise.resolve("value");
+    }, controller.signal);
+
+    expect(result).toBeNull();
+    expect(calls).toBe(0);
+  });
+
+  test("a signal that fires during a chunk returns null", async () => {
+    const controller = new AbortController();
+    const pending = deferred<string | null>();
+    const polling = pollUntilResolved(() => pending.promise, controller.signal);
+
+    controller.abort();
+
+    expect(await polling).toBeNull();
+  });
+
+  test("a rejected attempt propagates the original error", async () => {
+    const original = new Error("attempt failed");
+    let caught: unknown;
+
+    try {
+      await pollUntilResolved(() => Promise.reject(original), undefined);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBe(original);
+  });
+});

package/src/interruptible-wait.ts

@@ -0,0 +1,66 @@
+import { Cause, Effect, Exit } from "effect";
+
+export const ABORTED: unique symbol = Symbol("aborted");
+
+const whenSignalAborts = (signal: AbortSignal): Effect.Effect<void> =>
+  Effect.callback<void>((resume) => {
+    if (signal.aborted) {
+      resume(Effect.void);
+
+      return;
+    }
+    const onAbort = () => resume(Effect.void);
+
+    signal.addEventListener("abort", onAbort, { once: true });
+
+    return Effect.sync(() => signal.removeEventListener("abort", onAbort));
+  });
+
+const fromSettledPromise = <T>(start: () => Promise<T>): Effect.Effect<T, unknown> =>
+  Effect.callback<T, unknown>((resume) => {
+    start().then(
+      (value) => resume(Effect.succeed(value)),
+      (cause: unknown) => resume(Effect.fail(cause)),
+    );
+  });
+
+async function runToPromise<T>(effect: Effect.Effect<T, unknown>): Promise<T> {
+  const exit = await Effect.runPromiseExit(effect);
+
+  if (Exit.isSuccess(exit)) return exit.value;
+
+  throw Cause.squash(exit.cause);
+}
+
+export function raceAbort<T>(
+  promise: Promise<T>,
+  signal: AbortSignal | undefined,
+): Promise<T | typeof ABORTED> {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    promise.catch(() => {});
+
+    return Promise.resolve(ABORTED);
+  }
+
+  return runToPromise(
+    Effect.raceFirst(
+      fromSettledPromise(() => promise),
+      whenSignalAborts(signal).pipe(Effect.as<T | typeof ABORTED>(ABORTED)),
+    ),
+  );
+}
+
+export function pollUntilResolved<T>(
+  attempt: () => Promise<T | null>,
+  signal: AbortSignal | undefined,
+): Promise<T | null> {
+  if (signal?.aborted) return Promise.resolve(null);
+  const loop = Effect.repeat(fromSettledPromise(attempt), {
+    until: (result): result is T => result !== null,
+  });
+
+  if (!signal) return runToPromise(loop);
+
+  return runToPromise(Effect.raceFirst(loop, whenSignalAborts(signal).pipe(Effect.as(null))));
+}

package/src/main.ts

@@ -2,9 +2,12 @@
 
 import { DaemonServer } from "./server";
 
-const idleExitMs = process.env.CUELOOP_IDLE_EXIT_MS ? Number(process.env.CUELOOP_IDLE_EXIT_MS) : undefined;
+const idleExitMs = process.env.CUELOOP_IDLE_EXIT_MS
+  ? Number(process.env.CUELOOP_IDLE_EXIT_MS)
+  : undefined;
 const server = new DaemonServer({ idleExitMs });
 const path = server.start();
+
 if (path === null) {
   // another daemon already owns this home; the client will attach to it
   console.log("cueloop daemon already running for this home");

package/src/paths.ts

@@ -18,6 +18,35 @@ export function sessionsDir(home = cueloopHome()): string {
   return join(home, "sessions");
 }
 
+/** Thread files live here, one JSONL per thread, under a per-project bucket. */
+export function threadsDir(home = cueloopHome()): string {
+  return join(home, "threads");
+}
+
+/** A git commit is lowercase hex; anything else is not a real root commit. */
+const COMMIT_SHA = /^[0-9a-f]{7,64}$/;
+
+/**
+ * The per-project bucket for a workspace: its durable root-commit SHA, or a shared standalone bucket.
+ * A value that is not a commit SHA (including path-traversal segments an IPC caller could smuggle in)
+ * is refused to the standalone bucket, so a bucket name can never escape the threads directory.
+ */
+export function threadBucket(rootCommit: string | undefined, home = cueloopHome()): string {
+  const bucket =
+    rootCommit && COMMIT_SHA.test(rootCommit) ? rootCommit.slice(0, 12) : "_standalone";
+
+  return join(threadsDir(home), bucket);
+}
+
+/** Where the one-time migration parks the old whole-record JSON files, so a downgrade can still read them. */
+export function migratedSessionsDir(home = cueloopHome()): string {
+  return join(home, "sessions.migrated");
+}
+
+export function reportsDir(home = cueloopHome()): string {
+  return join(home, "reports");
+}
+
 export function pidPath(home = cueloopHome()): string {
   return join(home, "cueloop.pid");
 }
@@ -25,3 +54,18 @@ export function pidPath(home = cueloopHome()): string {
 export function lockPath(home = cueloopHome()): string {
   return join(home, "cueloop.lock");
 }
+
+/** The secret a connection presents to be the owner; written by the daemon, mode 0600. */
+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 {
+  return join(home, "herdr-tabs.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/pr-poller.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test";
+import { PrReviewPoller } from "./pr-poller";
+
+/** Build a poller whose head sha is controllable, with the timer effectively disabled. */
+function makePoller(initialSha: string | null) {
+  let sha = initialSha;
+  const advanced: string[] = [];
+  const poller = new PrReviewPoller(
+    (sessionId) => advanced.push(sessionId),
+    async () => sha,
+    1_000_000,
+  );
+
+  return {
+    poller,
+    advanced,
+    setSha: (next: string | null) => {
+      sha = next;
+    },
+  };
+}
+
+describe("PrReviewPoller", () => {
+  test("the first observation is a silent baseline", async () => {
+    const { poller, advanced } = makePoller("sha1");
+
+    poller.trackPr("s1", "org/repo#1");
+    await poller.refreshHead("s1");
+
+    expect(advanced).toEqual([]);
+    poller.close();
+  });
+
+  test("a moved head fires once; an unchanged head stays quiet", async () => {
+    const { poller, advanced, setSha } = makePoller("sha1");
+
+    poller.trackPr("s1", "org/repo#1");
+    await poller.refreshHead("s1");
+
+    setSha("sha2");
+    await poller.refreshHead("s1");
+    await poller.refreshHead("s1");
+
+    expect(advanced).toEqual(["s1"]);
+    poller.close();
+  });
+
+  test("a failed head read never fires and keeps the last baseline", async () => {
+    const { poller, advanced, setSha } = makePoller("sha1");
+
+    poller.trackPr("s1", "org/repo#1");
+    await poller.refreshHead("s1");
+
+    setSha(null);
+    await poller.refreshHead("s1");
+    setSha("sha2");
+    await poller.refreshHead("s1");
+
+    expect(advanced).toEqual(["s1"]);
+    poller.close();
+  });
+
+  test("untrack stops further checks", async () => {
+    const { poller, advanced, setSha } = makePoller("sha1");
+
+    poller.trackPr("s1", "org/repo#1");
+    await poller.refreshHead("s1");
+    poller.untrackPr("s1");
+
+    setSha("sha2");
+    await poller.refreshHead("s1");
+
+    expect(advanced).toEqual([]);
+    poller.close();
+  });
+});

package/src/pr-poller.ts

@@ -0,0 +1,74 @@
+/**
+ * Polls each open PR review for new commits so the review hot-reloads when the
+ * PR head advances. A remote PR has no push signal, so this checks the head sha
+ * on an interval - one cheap gh call - and only asks the caller to re-pull the
+ * full diff when the head actually moved. Best-effort: a missing or failing gh
+ * leaves the last known head in place and never throws.
+ */
+
+import { prHeadSha } from "./gh";
+
+/** One cheap head-sha check per interval; the expensive full-diff pull happens only on a move. */
+const PR_POLL_INTERVAL_MS = 30_000;
+
+interface PrPoll {
+  pr: string;
+  /** Last head sha seen; null until the baseline check lands, so the first observation never fires. */
+  lastSha: string | null;
+  timer: ReturnType<typeof setInterval>;
+}
+
+export class PrReviewPoller {
+  private readonly polls = new Map<string, PrPoll>();
+
+  constructor(
+    private readonly onPrAdvance: (sessionId: string) => void,
+    private readonly headSha: (pr: string) => Promise<string | null> = prHeadSha,
+    private readonly intervalMs: number = PR_POLL_INTERVAL_MS,
+  ) {}
+
+  /** Start polling a PR review. Idempotent per session; the baseline check runs at once. */
+  trackPr(sessionId: string, pr: string): void {
+    if (this.polls.has(sessionId)) return;
+    const timer = setInterval(() => void this.refreshHead(sessionId), this.intervalMs);
+    // the poll timer must not by itself keep the daemon alive against idle-exit
+    timer.unref?.();
+    this.polls.set(sessionId, { pr, lastSha: null, timer });
+    void this.refreshHead(sessionId);
+  }
+
+  /** Check the PR head once; fire onPrAdvance only when it moved off a known baseline. */
+  async refreshHead(sessionId: string): Promise<void> {
+    const poll = this.polls.get(sessionId);
+
+    if (!poll) return;
+    const sha = await this.headSha(poll.pr).catch(() => null);
+
+    if (sha === null) return;
+    // the await yields; re-read so an untrack during the call is honoured
+    const current = this.polls.get(sessionId);
+
+    if (!current) return;
+    if (current.lastSha === null) {
+      current.lastSha = sha;
+
+      return;
+    }
+    if (sha === current.lastSha) return;
+    current.lastSha = sha;
+    this.onPrAdvance(sessionId);
+  }
+
+  untrackPr(sessionId: string): void {
+    const poll = this.polls.get(sessionId);
+
+    if (!poll) return;
+    clearInterval(poll.timer);
+    this.polls.delete(sessionId);
+  }
+
+  close(): void {
+    for (const poll of this.polls.values()) clearInterval(poll.timer);
+    this.polls.clear();
+  }
+}