@cueloop/daemon 0.1.0-alpha.68 → 0.1.0-alpha.69

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/paths.ts

@@ -18,6 +18,31 @@ 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");
 }

package/src/review.ts

@@ -17,6 +17,7 @@ import {
 } from "@cueloop/schema";
 import { verdictResponse } from "./api";
 import type { DaemonClient } from "./client";
+import { ABORTED, pollUntilResolved, raceAbort } from "./interruptible-wait";
 
 // Adapters and CLI primitives reach the verdict mapping through this module too,
 // so a session obtained outside a ReviewHandle maps the same way.
@@ -139,42 +140,6 @@ export interface VerdictOutcome {
   session: ReviewSession;
 }
 
-/** Sentinel distinguishing an abort from any daemon response. */
-const ABORTED = Symbol("aborted");
-
-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 new Promise<T | typeof ABORTED>((resolve, reject) => {
-    const onAbort = () => {
-      // The daemon request keeps running until the client closes; swallow its
-      // eventual rejection so the abort path never leaks an unhandled error.
-      promise.catch(() => {});
-      resolve(ABORTED);
-    };
-
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (value) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(value);
-      },
-      (error) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(error);
-      },
-    );
-  });
-}
-
 export class ReviewHandle {
   constructor(
     private readonly client: DaemonClient,
@@ -247,15 +212,12 @@ export async function awaitResolve(
   options: AwaitResolveOptions = {},
 ): Promise<VerdictOutcome | null> {
   const chunkMs = options.pollMs ?? 30_000;
-  const { signal } = options;
+  const resolved = await pollUntilResolved(
+    () => client.sessionWait(sessionId, chunkMs),
+    options.signal,
+  );
 
-  for (;;) {
-    if (signal?.aborted) return null;
-    const resolved = await raceAbort(client.sessionWait(sessionId, chunkMs), signal);
-
-    if (resolved === ABORTED) return null;
-    if (resolved !== null) return outcome(resolved);
-  }
+  return resolved === null ? null : outcome(resolved);
 }
 
 /** Open a review session (or revise the agent session's existing one) and hand back the wait surface. */

package/src/server.ts

@@ -26,6 +26,7 @@ import {
   type Response,
 } from "./protocol";
 import { cueloopHome, lockPath, ownerTokenPath, pidPath, socketPath } from "./paths";
+import { DAEMON_VERSION } from "./version";
 import { randomBytes } from "node:crypto";
 
 interface Connection {
@@ -44,6 +45,8 @@ export interface DaemonOptions {
   /** Idle-exit delay; 0 disables (tests, foreground runs). */
   idleExitMs?: number;
   onIdleExit?: () => void;
+  /** The version the ping handshake reports; defaults to this build. Tests override it to pose as a stale daemon. */
+  version?: string;
 }
 
 /**
@@ -64,11 +67,13 @@ export class DaemonServer {
   private ownerToken = "";
   private readonly idleExitMs: number;
   private readonly onIdleExit: () => void;
+  private readonly version: string;
 
   constructor(options: DaemonOptions = {}) {
     this.home = options.home ?? cueloopHome();
     this.idleExitMs = options.idleExitMs ?? 15 * 60 * 1000;
     this.onIdleExit = options.onIdleExit ?? (() => process.exit(0));
+    this.version = options.version ?? DAEMON_VERSION;
     mkdirSync(this.home, { recursive: true, mode: 0o700 });
     this.core = new DaemonCore(this.home);
     this.core.onEvent((event) => this.broadcast(event));
@@ -256,7 +261,7 @@ export class DaemonServer {
   }
 
   private readonly handlers: Record<MethodName, MethodHandler> = {
-    "daemon.ping": () => ({ pid: process.pid }),
+    "daemon.ping": () => ({ pid: process.pid, version: this.version }),
     "daemon.hello": (connection, request) => {
       const params = parseParams("daemon.hello", request.params);
 
@@ -401,6 +406,10 @@ export class DaemonServer {
     },
     "repo.changes": (_connection, request) =>
       this.core.repoChanges(parseParams("repo.changes", request.params).cwd),
+    "repo.diff": (_connection, request) =>
+      this.core.repoDiff(parseParams("repo.diff", request.params).cwd),
+    "session.workbench": (_connection, request) =>
+      this.core.workbenchSession(parseParams("session.workbench", request.params).cwd),
     "session.refreshDiff": (_connection, request) => {
       const params = parseParams("session.refreshDiff", request.params);
 
@@ -428,7 +437,12 @@ export class DaemonServer {
     "session.resolve": (_connection, request) => {
       const params = parseParams("session.resolve", request.params);
 
-      return this.core.sessionResolve(params.id, params.verdictKind, params.summary);
+      return this.core.sessionResolve(
+        params.id,
+        params.verdictKind,
+        params.summary,
+        params.actionBodies,
+      );
     },
     "session.submitRevision": (_connection, request) => {
       const params = parseParams("session.submitRevision", request.params);

package/src/store.jsonl.test.ts

@@ -0,0 +1,159 @@
+/**
+ * The JSONL thread store's own behaviors, beyond the shared repository contract: per-project bucket
+ * layout keyed by root commit, one-time migration of the old whole-record files, compaction of a
+ * long log, and a crash's torn trailing line being skipped on read.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  mkdtempSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  existsSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SessionStore } from "./store";
+import { migratedSessionsDir, sessionsDir, threadBucket } from "./paths";
+import { createTestSessionRecord } from "./testing/store-conformance";
+
+function tmpHome(): string {
+  return mkdtempSync(join(tmpdir(), "cueloop-jsonl-"));
+}
+
+describe("JSONL thread store", () => {
+  test("a thread is written under a per-project bucket keyed by root commit", () => {
+    const home = tmpHome();
+    const store = new SessionStore(home);
+    store.recover();
+    store.upsert(
+      createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+        workspace: { repoRoot: "/repo", branch: "main", rootCommit: "abcdef0123456789" },
+      }),
+    );
+
+    const bucket = threadBucket("abcdef0123456789", home);
+    expect(readdirSync(bucket)).toContain("ses_a.jsonl");
+  });
+
+  test("a non-commit rootCommit (path traversal) cannot escape the threads directory", () => {
+    const home = tmpHome();
+    const escape = threadBucket("../../../etc/cueloop", home);
+    const standalone = threadBucket(undefined, home);
+
+    // a value that is not a real commit SHA is refused to the standalone bucket, never a parent path
+    expect(escape).toBe(standalone);
+    expect(escape.startsWith(join(home, "threads"))).toBe(true);
+  });
+
+  test("a repo-less thread lands in the standalone bucket", () => {
+    const home = tmpHome();
+    const store = new SessionStore(home);
+    store.recover();
+    store.upsert(createTestSessionRecord("ses_s", "2026-09-01T00:00:00.000Z"));
+
+    expect(readdirSync(threadBucket(undefined, home))).toContain("ses_s.jsonl");
+  });
+
+  test("boot migrates the old whole-record file and parks the original", () => {
+    const home = tmpHome();
+    mkdirSync(sessionsDir(home), { recursive: true });
+    const legacy = createTestSessionRecord("ses_old", "2026-09-01T00:00:00.000Z");
+    writeFileSync(join(sessionsDir(home), "ses_old.json"), JSON.stringify(legacy));
+
+    const store = new SessionStore(home);
+    const report = store.recover();
+
+    expect(report.recovered).toEqual(["ses_old"]);
+    // the record migrates intact (a history is derived on read, as the old store did)
+    expect(store.get("ses_old")?.id).toBe("ses_old");
+    expect(store.get("ses_old")?.artifact).toEqual(legacy.artifact);
+    // the original is parked, not left in the live legacy dir
+    expect(existsSync(join(sessionsDir(home), "ses_old.json"))).toBe(false);
+    expect(readdirSync(migratedSessionsDir(home))).toContain("ses_old.json");
+  });
+
+  test("migration never overwrites a newer JSONL with an older legacy snapshot", () => {
+    const home = tmpHome();
+    // a newer JSONL already holds this thread (e.g. written after a rollback)
+    const store = new SessionStore(home);
+    store.recover();
+    store.upsert(
+      createTestSessionRecord("ses_x", "2026-09-01T00:00:00.000Z", {
+        status: "pending",
+        workspace: { repoRoot: "/repo", branch: "newer" },
+      }),
+    );
+    // an older legacy JSON for the same thread is restored alongside it
+    mkdirSync(sessionsDir(home), { recursive: true });
+    writeFileSync(
+      join(sessionsDir(home), "ses_x.json"),
+      JSON.stringify(
+        createTestSessionRecord("ses_x", "2026-09-01T00:00:00.000Z", {
+          workspace: { repoRoot: "/repo", branch: "older" },
+        }),
+      ),
+    );
+
+    const reopened = new SessionStore(home);
+    reopened.recover();
+    // the newer JSONL wins; the legacy snapshot is parked, not applied
+    expect(reopened.get("ses_x")?.workspace.branch).toBe("newer");
+    expect(readdirSync(migratedSessionsDir(home))).toContain("ses_x.json");
+  });
+
+  test("a long log compacts to a single line, and the record survives it", () => {
+    const home = tmpHome();
+    const store = new SessionStore(home);
+    store.recover();
+    // more upserts than the compaction threshold
+    for (let iteration = 0; iteration < 60; iteration++) {
+      store.upsert(
+        createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+          status: "pending",
+          workspace: { repoRoot: "/repo", branch: `b${iteration}` },
+        }),
+      );
+    }
+
+    const file = join(threadBucket(undefined, home), "ses_a.jsonl");
+    const lines = readFileSync(file, "utf8")
+      .split("\n")
+      .filter((l) => l.trim());
+    expect(lines.length).toBeLessThan(60);
+    // the latest snapshot survives the compaction and a restart
+    const reopened = new SessionStore(home);
+    reopened.recover();
+    expect(reopened.get("ses_a")?.workspace.branch).toBe("b59");
+  });
+
+  test("a crash's torn trailing line is skipped; the last valid snapshot wins", () => {
+    const home = tmpHome();
+    const store = new SessionStore(home);
+    store.recover();
+    store.upsert(createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z"));
+
+    // simulate a crash mid-append: a half-written line at the end
+    const file = join(threadBucket(undefined, home), "ses_a.jsonl");
+    appendFileSync(file, '{"id":"ses_a","half');
+
+    const reopened = new SessionStore(home);
+    const report = reopened.recover();
+    expect(report.recovered).toEqual(["ses_a"]);
+    expect(reopened.get("ses_a")?.id).toBe("ses_a");
+
+    // an update after a torn recovery must not fuse onto the torn fragment and vanish on restart
+    reopened.upsert(
+      createTestSessionRecord("ses_a", "2026-09-01T00:00:00.000Z", {
+        status: "pending",
+        workspace: { repoRoot: "/repo", branch: "after-tear" },
+      }),
+    );
+    const restarted = new SessionStore(home);
+    restarted.recover();
+    expect(restarted.get("ses_a")?.workspace.branch).toBe("after-tear");
+  });
+});