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

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();
+  }
+}

package/src/project-files.test.ts

@@ -0,0 +1,124 @@
+/** Read-only repo introspection: the tracked file tree and safe, bounded file reads. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listProjectFiles, readProjectFile } from "./project-files";
+
+function git(args: string[], cwd: string): void {
+  const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" });
+
+  if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed in ${cwd}`);
+}
+
+let repo: string;
+
+beforeEach(() => {
+  repo = mkdtempSync(join(tmpdir(), "cueloop-project-files-"));
+  git(["init", "-q", "-b", "main"], repo);
+  git(["config", "user.email", "t@t"], repo);
+  git(["config", "user.name", "t"], repo);
+});
+
+afterEach(() => {
+  rmSync(repo, { recursive: true, force: true });
+});
+
+describe("listProjectFiles", () => {
+  test("returns the tracked files sorted ascending", async () => {
+    // Given a repo whose files are committed out of alphabetical order
+    writeFileSync(join(repo, "z.ts"), "export const z = 1;\n");
+    writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+    writeFileSync(join(repo, "m.ts"), "export const m = 1;\n");
+    git(["add", "."], repo);
+    git(["commit", "-qm", "init"], repo);
+
+    // When the tracked files are listed
+    const files = await listProjectFiles(repo);
+
+    // Then every tracked path comes back in ascending order
+    expect(files).toEqual(["a.ts", "m.ts", "z.ts"]);
+  });
+
+  test("returns [] for a directory that is not a git repo", async () => {
+    // Given a plain directory with a file but no git repo
+    const plain = mkdtempSync(join(tmpdir(), "cueloop-project-files-plain-"));
+
+    writeFileSync(join(plain, "a.ts"), "export const a = 1;\n");
+    try {
+      // When the tracked files are listed
+      const files = await listProjectFiles(plain);
+
+      // Then nothing comes back and no error is thrown
+      expect(files).toEqual([]);
+    } finally {
+      rmSync(plain, { recursive: true, force: true });
+    }
+  });
+
+  test("returns [] when there is no repoRoot", async () => {
+    expect(await listProjectFiles(undefined)).toEqual([]);
+  });
+});
+
+describe("readProjectFile", () => {
+  test("reads a repo-relative file as UTF-8", async () => {
+    // Given a committed file with known contents
+    writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+    git(["add", "."], repo);
+    git(["commit", "-qm", "init"], repo);
+
+    // When it is read by its repo-relative path
+    const contents = await readProjectFile(repo, "a.ts");
+
+    // Then its exact bytes come back
+    expect(contents).toBe("export const a = 1;\n");
+  });
+
+  test("returns null for a path that escapes the repo via ../", async () => {
+    // Given a secret file just outside the repo root
+    const secret = join(repo, "..", "outside-secret.txt");
+
+    writeFileSync(secret, "top secret\n");
+    try {
+      // When a traversal path tries to reach it
+      const contents = await readProjectFile(repo, "../outside-secret.txt");
+
+      // Then the read is refused
+      expect(contents).toBeNull();
+    } finally {
+      rmSync(secret, { force: true });
+    }
+  });
+
+  test("returns null for a missing file", async () => {
+    expect(await readProjectFile(repo, "nope.ts")).toBeNull();
+  });
+
+  test("returns null for a directory (not a regular file)", async () => {
+    // Given a directory inside the repo
+    mkdirSync(join(repo, "src"));
+
+    // When the directory path is read
+    const contents = await readProjectFile(repo, "src");
+
+    // Then it is refused
+    expect(contents).toBeNull();
+  });
+
+  test("returns null for a file larger than the cap", async () => {
+    // Given a file just over one megabyte
+    writeFileSync(join(repo, "big.bin"), "x".repeat(1024 * 1024 + 1));
+
+    // When it is read
+    const contents = await readProjectFile(repo, "big.bin");
+
+    // Then it is refused for exceeding the size cap
+    expect(contents).toBeNull();
+  });
+
+  test("returns null when there is no repoRoot", async () => {
+    expect(await readProjectFile(undefined, "a.ts")).toBeNull();
+  });
+});

package/src/project-files.ts

@@ -0,0 +1,56 @@
+/** Read-only repo introspection for the Project panel: the tracked file tree and a file's contents. */
+
+import { stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+/** Ceiling on the returned tree; a pathological repo cannot flood the panel or the wire. */
+const MAX_FILES = 5000;
+/** Ceiling on a served file; the panel renders source, not multi-megabyte blobs. */
+const MAX_FILE_BYTES = 1024 * 1024;
+
+/** Tracked, repo-relative paths from `git ls-files`, sorted ascending and capped; [] on any failure or non-repo. */
+export async function listProjectFiles(repoRoot: string | undefined): Promise<string[]> {
+  if (repoRoot === undefined || repoRoot.length === 0) return [];
+  try {
+    const gitProcess = Bun.spawn(["git", "-C", repoRoot, "ls-files", "-z"], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const stdout = await new Response(gitProcess.stdout).text();
+
+    if ((await gitProcess.exited) !== 0) return [];
+    const paths = stdout.split("\0").filter((path) => path.length > 0);
+
+    return paths.toSorted().slice(0, MAX_FILES);
+  } catch {
+    return [];
+  }
+}
+
+/** True when `candidate` resolves outside `root` (path traversal) or is `root` itself. */
+function escapesRoot(root: string, candidate: string): boolean {
+  const rel = relative(root, candidate);
+
+  return rel.length === 0 || rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel);
+}
+
+/** UTF-8 contents of `repoRoot/path`, or null: no repo, traversal escape, not a regular file, oversized, or any error. */
+export async function readProjectFile(
+  repoRoot: string | undefined,
+  path: string,
+): Promise<string | null> {
+  if (repoRoot === undefined || repoRoot.length === 0) return null;
+  const root = resolve(repoRoot);
+  const target = resolve(root, path);
+
+  if (escapesRoot(root, target)) return null;
+  try {
+    const stats = await stat(target);
+
+    if (!stats.isFile() || stats.size > MAX_FILE_BYTES) return null;
+
+    return await Bun.file(target).text();
+  } catch {
+    return null;
+  }
+}

package/src/protocol.ts

@@ -1,9 +1,11 @@
 /**
- * Wire protocol (#14): newline-delimited JSON over the unix socket.
+ * Wire protocol: newline-delimited JSON over the unix socket.
  * Requests: { id, method, params }  Responses: { id, result } | { id, error }
  * Events (push, after events.subscribe): { event, sessionId }
  */
 
+import * as v from "valibot";
+
 export interface Request {
   id: number;
   method: string;
@@ -19,22 +21,92 @@ export interface Response {
 export interface EventFrame {
   event: string;
   sessionId: string;
+  /** The history entry the change appended, when it appended one. */
+  entryId?: string;
 }
 
 export type Frame = Response | EventFrame;
 
+const RequestSchema = v.object({
+  id: v.number(),
+  method: v.string(),
+  params: v.optional(v.unknown()),
+});
+const ResponseSchema = v.object({
+  id: v.number(),
+  result: v.optional(v.unknown()),
+  error: v.optional(v.object({ code: v.string(), message: v.string() })),
+});
+const EventFrameSchema = v.object({
+  event: v.string(),
+  sessionId: v.string(),
+  entryId: v.optional(v.string()),
+});
+
+export function parseRequestFrame(line: string): Request {
+  return v.parse(RequestSchema, JSON.parse(line));
+}
+
+export function parseInboundFrame(line: string): Frame {
+  return v.parse(v.union([ResponseSchema, EventFrameSchema]), JSON.parse(line));
+}
+
 /** Incremental NDJSON splitter; tolerates partial writes. */
 export class LineBuffer {
-  private buf = "";
+  private buffered = "";
 
   push(chunk: string, onLine: (line: string) => void): void {
-    this.buf += chunk;
+    this.buffered += chunk;
     for (;;) {
-      const nl = this.buf.indexOf("\n");
-      if (nl === -1) return;
-      const line = this.buf.slice(0, nl).trim();
-      this.buf = this.buf.slice(nl + 1);
+      const newlineIndex = this.buffered.indexOf("\n");
+
+      if (newlineIndex === -1) return;
+      const line = this.buffered.slice(0, newlineIndex).trim();
+
+      this.buffered = this.buffered.slice(newlineIndex + 1);
       if (line) onLine(line);
     }
   }
 }
+
+/** The surface both Bun.listen and Bun.connect sockets satisfy. */
+interface WritableSocket {
+  write(data: Buffer): number;
+}
+
+/**
+ * Outbound writes honoring socket backpressure. A frame larger than the
+ * kernel buffer is written partially by the socket; the unwritten tail must
+ * wait for the drain callback or the frame truncates mid-line and the NDJSON
+ * stream corrupts for good. Frames never reorder: while a tail is pending,
+ * new writes append behind it.
+ */
+export class BackpressureWriter {
+  private pending: Buffer | null = null;
+
+  constructor(private socket: WritableSocket) {}
+
+  write(data: string): void {
+    const bytes = Buffer.from(data, "utf8");
+
+    if (this.pending) {
+      this.pending = Buffer.concat([this.pending, bytes]);
+
+      return;
+    }
+    const written = Math.max(0, this.socket.write(bytes));
+
+    if (written < bytes.length) this.pending = bytes.subarray(written);
+  }
+
+  /** Call from the socket's drain handler. */
+  drain(): void {
+    if (!this.pending) return;
+    const tail = this.pending;
+
+    this.pending = null;
+    const written = Math.max(0, this.socket.write(tail));
+
+    if (written < tail.length) this.pending = tail.subarray(written);
+  }
+}

package/src/retention.test.ts

@@ -0,0 +1,191 @@
+/** Retention: the cleanup period defaults to 30, honors [cleanup] period_days, and prune drops only the sessions and reports past the window. */
+
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Thread, SessionStatus } from "@cueloop/schema";
+import { ThreadStore } from "./store";
+import { reportsDir } from "./paths";
+import {
+  DEFAULT_CLEANUP_PERIOD_DAYS,
+  LATEST_REPORT_FILENAME,
+  isExpired,
+  parseRefineState,
+  pruneExpiredReports,
+  pruneExpiredSessions,
+  resolveCleanupPeriodDays,
+} from "./retention";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const NOW_MS = Date.parse("2026-08-26T00:00:00Z");
+
+function tempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+function daysAgo(days: number): string {
+  return new Date(NOW_MS - days * DAY_MS).toISOString();
+}
+
+function session(id: string, createdAt: string, status: SessionStatus = "resolved"): Thread {
+  return {
+    schemaVersion: "1",
+    id,
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "", meta: {} },
+    revisions: [],
+    annotations: [],
+    message: null,
+    status,
+    createdAt,
+  };
+}
+
+describe("resolveCleanupPeriodDays", () => {
+  test("defaults to 30 when no config file is present", () => {
+    // Arrange
+    const missing = join(tempDir("cueloop-retention-"), "config.toml");
+
+    // Act
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: missing });
+
+    // Assert
+    expect(days).toBe(DEFAULT_CLEANUP_PERIOD_DAYS);
+  });
+
+  test("honors [cleanup] period_days", () => {
+    // Arrange
+    const path = join(tempDir("cueloop-retention-"), "config.toml");
+
+    writeFileSync(path, "[cleanup]\nperiod_days = 7\n");
+
+    // Act
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path });
+
+    // Assert
+    expect(days).toBe(7);
+  });
+
+  test("falls back to the default when the value is not a number", () => {
+    // Arrange
+    const path = join(tempDir("cueloop-retention-"), "config.toml");
+
+    writeFileSync(path, '[cleanup]\nperiod_days = "soon"\n');
+
+    // Act
+    const days = resolveCleanupPeriodDays({ CUELOOP_CONFIG: path });
+
+    // Assert
+    expect(days).toBe(DEFAULT_CLEANUP_PERIOD_DAYS);
+  });
+});
+
+describe("parseRefineState", () => {
+  test("reads the analyzed fingerprint map", () => {
+    // Assert
+    expect([...parseRefineState({ analyzed: { ses_a: "1:2:x" } })]).toEqual([["ses_a", "1:2:x"]]);
+  });
+
+  test("returns an empty map for the legacy or malformed shape", () => {
+    // Assert
+    expect(parseRefineState({ seenSessionIds: ["ses_a"] }).size).toBe(0);
+    expect(parseRefineState({ analyzed: { ses_a: 5 } }).size).toBe(0);
+    expect(parseRefineState(null).size).toBe(0);
+  });
+});
+
+describe("isExpired", () => {
+  test("is true past the window and false inside it", () => {
+    // Assert
+    expect(isExpired(daysAgo(40), 30, NOW_MS)).toBe(true);
+    expect(isExpired(daysAgo(10), 30, NOW_MS)).toBe(false);
+  });
+
+  test("a period of zero disables expiry", () => {
+    // Assert
+    expect(isExpired(daysAgo(999), 0, NOW_MS)).toBe(false);
+  });
+});
+
+describe("pruneExpiredSessions", () => {
+  test("deletes resolved sessions past the window and keeps recent ones", () => {
+    // Arrange
+    const home = tempDir("cueloop-retention-home-");
+    const store = new ThreadStore(home);
+
+    store.upsert(session("ses_old", daysAgo(40)));
+    store.upsert(session("ses_new", daysAgo(2)));
+
+    // Act
+    const pruned = pruneExpiredSessions(store, 30, NOW_MS);
+
+    // Assert
+    expect(pruned).toEqual(["ses_old"]);
+    expect(store.get("ses_old")).toBeUndefined();
+    expect(store.get("ses_new")).toBeDefined();
+  });
+
+  test("keeps an expired resolved Thread while its Message is awaiting delivery", () => {
+    const store = new ThreadStore(tempDir("cueloop-retention-home-"));
+
+    store.upsert(session("ses_waiting", daysAgo(40)));
+
+    expect(pruneExpiredSessions(store, 30, NOW_MS, new Set(["ses_waiting"]))).toEqual([]);
+    expect(store.get("ses_waiting")).toBeDefined();
+  });
+
+  test("never deletes an active pending session however old", () => {
+    // Arrange
+    const home = tempDir("cueloop-retention-home-");
+    const store = new ThreadStore(home);
+
+    store.upsert(session("ses_active", daysAgo(400), "pending"));
+
+    // Act
+    const pruned = pruneExpiredSessions(store, 30, NOW_MS);
+
+    // Assert
+    expect(pruned).toEqual([]);
+    expect(store.get("ses_active")).toBeDefined();
+  });
+
+  test("a period of zero prunes nothing", () => {
+    // Arrange
+    const home = tempDir("cueloop-retention-home-");
+    const store = new ThreadStore(home);
+
+    store.upsert(session("ses_old", daysAgo(999)));
+
+    // Act
+    const pruned = pruneExpiredSessions(store, 0, NOW_MS);
+
+    // Assert
+    expect(pruned).toEqual([]);
+    expect(store.get("ses_old")).toBeDefined();
+  });
+});
+
+describe("pruneExpiredReports", () => {
+  test("removes timestamped reports past the window but keeps the latest report", () => {
+    // Arrange
+    const home = tempDir("cueloop-retention-home-");
+    const directory = reportsDir(home);
+
+    mkdirSync(directory, { recursive: true });
+    const latest = join(directory, LATEST_REPORT_FILENAME);
+    const stale = join(directory, "refine-2026-06-01T00-00-00-000Z.md");
+    const fresh = join(directory, "refine-2026-08-25T00-00-00-000Z.md");
+
+    for (const path of [latest, stale, fresh]) writeFileSync(path, "report");
+    const staleSeconds = (NOW_MS - 60 * DAY_MS) / 1000;
+
+    utimesSync(stale, staleSeconds, staleSeconds);
+
+    // Act
+    const pruned = pruneExpiredReports(directory, 30, NOW_MS);
+
+    // Assert
+    expect(pruned).toEqual(["refine-2026-06-01T00-00-00-000Z.md"]);
+  });
+});