@cueloop/daemon 0.1.0-alpha.9 → 0.1.0-alpha.91

package/src/diff-watcher.ts

@@ -0,0 +1,293 @@
+/**
+ * Watches a diff session's repository for working-tree changes and drives the
+ * hot-reload: on any change under a repo root that a live diff session tracks,
+ * the daemon re-captures that session's diff so the open review updates in place.
+ * One watcher per non-ignored directory (not a recursive watch), so churn under
+ * `.git`, `node_modules`, or a .gitignored path never registers a watch at all -
+ * that keeps idle cost near zero on Linux, where a recursive watch would open an
+ * inotify descriptor per directory. A debounce collapses a burst into one
+ * re-capture. Many diff sessions can share a repo.
+ */
+
+import { watch, readdirSync, statSync, type Dirent, type FSWatcher } from "node:fs";
+import { basename, isAbsolute, join } from "node:path";
+
+/** Debounce window: a save or a checkout writes many files in a burst; collapse them into one re-capture. */
+const DIFF_REFRESH_DEBOUNCE_MS = 300;
+
+/**
+ * Directory names never worth a watch, whatever .gitignore says. `.git` is
+ * watched narrowly elsewhere (HEAD, refs, packed-refs) so its own read churn (the
+ * index, lock files) cannot loop; `node_modules` churns on installs and is never
+ * review content.
+ */
+const ALWAYS_IGNORED_DIRS = new Set([".git", ".jj", "node_modules"]);
+
+/**
+ * Absolute paths of the directories git ignores under a repo root, resolved once
+ * at watch time from `git ls-files` so a .gitignored tree (dist, build output)
+ * never gets a watcher. Empty when git is unavailable - the name check still
+ * skips the churny defaults.
+ */
+function ignoredDirectories(repoRoot: string): Set<string> {
+  const ignored = new Set<string>();
+  const result = spawnGit(
+    ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory"],
+    repoRoot,
+  );
+
+  if (!result || result.exitCode !== 0) return ignored;
+  for (const line of result.stdout.toString().split("\n")) {
+    const relative = line.trim().replace(/\/$/, "");
+
+    if (relative.length > 0) ignored.add(join(repoRoot, relative));
+  }
+
+  return ignored;
+}
+
+/** Whether git ignores a single path; used for a directory created after the initial walk. */
+function isGitIgnored(repoRoot: string, path: string): boolean {
+  return spawnGit(["check-ignore", "-q", path], repoRoot)?.exitCode === 0;
+}
+
+/** Run a git command in `cwd`, or null when git is missing or the cwd is gone (spawn throws ENOENT). */
+function spawnGit(args: string[], cwd: string): { exitCode: number; stdout: Buffer } | null {
+  try {
+    const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+
+    return { exitCode: result.exitCode ?? 1, stdout: result.stdout };
+  } catch {
+    return null;
+  }
+}
+
+/** The git-metadata filenames whose change means `git diff HEAD` moved: a checkout, a commit, or a reset. */
+function isRefChange(filename: string): boolean {
+  return filename === "HEAD" || filename === "packed-refs";
+}
+
+/**
+ * A repo's git dir (HEAD and the index live here) and common dir (refs and
+ * packed-refs live here). They differ inside a linked worktree. Null when the
+ * root is not a git repo or git is unavailable.
+ */
+function resolveGitDirs(repoRoot: string): { gitDir: string; commonDir: string } | null {
+  const result = spawnGit(["rev-parse", "--absolute-git-dir", "--git-common-dir"], repoRoot);
+
+  if (!result || result.exitCode !== 0) return null;
+  const [gitDir, commonRaw] = result.stdout.toString().trim().split("\n");
+
+  if (!gitDir) return null;
+  const commonDir = commonRaw
+    ? isAbsolute(commonRaw)
+      ? commonRaw
+      : join(repoRoot, commonRaw)
+    : gitDir;
+
+  return { gitDir, commonDir };
+}
+
+interface RepoWatch {
+  /** One watcher per watched working-tree directory plus the narrow git-metadata watches; all close together. */
+  handles: FSWatcher[];
+  /** Live diff session ids sharing this repo root; the watch closes when the last one leaves. */
+  sessionIds: Set<string>;
+  jjSessionIds: Set<string>;
+  jjPoll: ReturnType<typeof setInterval> | null;
+  /** Absolute paths git ignores under the root, so the walk skips them. */
+  ignored: Set<string>;
+  /** Directories already watched, so a runtime-created dir is not watched twice. */
+  watchedDirs: Set<string>;
+  debounce: ReturnType<typeof setTimeout> | null;
+}
+
+/**
+ * Owns the fs watchers behind diff hot-reload. `onRepoChange` fires once per
+ * debounced burst with the repo root that changed; the caller re-captures every
+ * live diff session on that root. A watcher error or an unwatchable root is
+ * swallowed - hot-reload is best-effort and must never crash the daemon.
+ */
+export class DiffWatcher {
+  private readonly repoWatches = new Map<string, RepoWatch>();
+
+  constructor(private readonly onRepoChange: (repoRoot: string) => void) {}
+
+  /** Start (or join) watching a repo root for one diff session. Idempotent per (root, session). */
+  trackDiffRepo(repoRoot: string, sessionId: string, vcs = "git"): void {
+    const existing = this.repoWatches.get(repoRoot);
+
+    if (existing) {
+      existing.sessionIds.add(sessionId);
+      if (vcs === "jj") this.startJjPoll(existing, repoRoot, sessionId);
+
+      return;
+    }
+    const repoWatch: RepoWatch = {
+      handles: [],
+      sessionIds: new Set([sessionId]),
+      jjSessionIds: new Set(),
+      jjPoll: null,
+      ignored: ignoredDirectories(repoRoot),
+      watchedDirs: new Set(),
+      debounce: null,
+    };
+
+    this.repoWatches.set(repoRoot, repoWatch);
+    if (vcs === "jj") this.startJjPoll(repoWatch, repoRoot, sessionId);
+
+    // one watcher per non-ignored working-tree directory; a tracked-file change re-captures
+    if (!this.watchTree(repoRoot, repoRoot)) {
+      // repo root gone or not watchable on this platform: skip, no hot-reload here
+      this.untrackDiffRepo(repoRoot, sessionId);
+
+      return;
+    }
+
+    // git metadata: a commit, checkout, or reset moves `git diff HEAD` without
+    // touching any working-tree file, so those never reach the tree watch above.
+    const gitDirs = resolveGitDirs(repoRoot);
+
+    if (gitDirs) {
+      // HEAD and packed-refs sit beside the index; the index rewrites on our own
+      // reads, so only HEAD/packed-refs here - watching the index would loop
+      this.watchInto(repoWatch.handles, gitDirs.gitDir, { recursive: false }, (filename) => {
+        if (isRefChange(filename)) this.scheduleRepoRefresh(repoRoot);
+      });
+      // a commit or reset updates refs/heads/<branch>; any ref move re-captures
+      this.watchInto(repoWatch.handles, join(gitDirs.commonDir, "refs"), { recursive: true }, () =>
+        this.scheduleRepoRefresh(repoRoot),
+      );
+      if (gitDirs.commonDir !== gitDirs.gitDir)
+        this.watchInto(repoWatch.handles, gitDirs.commonDir, { recursive: false }, (filename) => {
+          if (isRefChange(filename)) this.scheduleRepoRefresh(repoRoot);
+        });
+    }
+  }
+
+  private startJjPoll(repoWatch: RepoWatch, repoRoot: string, sessionId: string): void {
+    repoWatch.jjSessionIds.add(sessionId);
+    if (repoWatch.jjPoll !== null) return;
+    repoWatch.jjPoll = setInterval(() => this.scheduleRepoRefresh(repoRoot), 2000);
+  }
+
+  /**
+   * Watch `dir` (non-recursive) and every non-ignored directory under it, adding
+   * each to the repo's handles. Returns whether `dir` itself got a watcher, so
+   * the caller can tell a dead root from a merely-skipped subtree. A skipped
+   * (ignored or already-watched) directory counts as watched, not a failure.
+   */
+  private watchTree(repoRoot: string, dir: string): boolean {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return false;
+    if (repoWatch.watchedDirs.has(dir)) return true;
+    if (ALWAYS_IGNORED_DIRS.has(basename(dir)) || repoWatch.ignored.has(dir)) return true;
+
+    const opened = this.watchInto(repoWatch.handles, dir, { recursive: false }, (filename) => {
+      this.scheduleRepoRefresh(repoRoot);
+      // a newly created subdirectory needs its own watch (a recursive watch got this for free)
+      this.extendWatch(repoRoot, join(dir, filename));
+    });
+
+    if (!opened) return false;
+    repoWatch.watchedDirs.add(dir);
+
+    let entries: Dirent[];
+
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return true;
+    }
+    for (const entry of entries) {
+      // a symlinked directory is skipped so the walk cannot loop
+      if (entry.isDirectory() && !entry.isSymbolicLink())
+        this.watchTree(repoRoot, join(dir, entry.name));
+    }
+
+    return true;
+  }
+
+  /**
+   * After a change names a new path, watch it (and its subtree) when it is a
+   * directory git does not ignore. The point-in-time ignored set cannot know a
+   * directory created after the walk, so a fresh dir is checked against git live.
+   */
+  private extendWatch(repoRoot: string, path: string): void {
+    try {
+      if (!statSync(path).isDirectory()) return;
+    } catch {
+      // the path is already gone (a transient temp dir); nothing to watch
+      return;
+    }
+    if (ALWAYS_IGNORED_DIRS.has(basename(path))) return;
+    if (isGitIgnored(repoRoot, path)) return;
+    this.watchTree(repoRoot, path);
+  }
+
+  /**
+   * Open one watcher and add it to `handles`; returns whether it opened. A
+   * watcher error (the path is deleted mid-review) is swallowed - hot-reload is
+   * best-effort and must never take down the daemon. The inherited EventEmitter
+   * `on` is absent from Bun's FSWatcher type.
+   */
+  private watchInto(
+    handles: FSWatcher[],
+    path: string,
+    options: { recursive: boolean },
+    onFile: (filename: string) => void,
+  ): boolean {
+    try {
+      const handle = watch(path, options, (_event, filename) => {
+        if (filename !== null) onFile(filename.toString());
+      });
+
+      handle.on("error", () => {});
+      handles.push(handle);
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Drop one diff session; close the repo watch once no diff session tracks it. */
+  untrackDiffRepo(repoRoot: string, sessionId: string): void {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return;
+    repoWatch.sessionIds.delete(sessionId);
+    repoWatch.jjSessionIds.delete(sessionId);
+    if (repoWatch.jjSessionIds.size === 0 && repoWatch.jjPoll !== null) {
+      clearInterval(repoWatch.jjPoll);
+      repoWatch.jjPoll = null;
+    }
+    if (repoWatch.sessionIds.size > 0) return;
+    if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+    if (repoWatch.jjPoll !== null) clearInterval(repoWatch.jjPoll);
+    for (const handle of repoWatch.handles) handle.close();
+    this.repoWatches.delete(repoRoot);
+  }
+
+  private scheduleRepoRefresh(repoRoot: string): void {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return;
+    if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+    repoWatch.debounce = setTimeout(() => {
+      repoWatch.debounce = null;
+      this.onRepoChange(repoRoot);
+    }, DIFF_REFRESH_DEBOUNCE_MS);
+  }
+
+  /** Close every watcher and cancel pending debounces (daemon shutdown). */
+  close(): void {
+    for (const repoWatch of this.repoWatches.values()) {
+      if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+      if (repoWatch.jjPoll !== null) clearInterval(repoWatch.jjPoll);
+      for (const handle of repoWatch.handles) handle.close();
+    }
+    this.repoWatches.clear();
+  }
+}

package/src/gh.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { prSnapshot } from "./gh";
+
+describe("prSnapshot", () => {
+  test("retries until the diff and head are one stable snapshot", async () => {
+    const refs = [
+      { baseSha: "base-1", headSha: "head-1" },
+      { baseSha: "base-1", headSha: "head-2" },
+      { baseSha: "base-1", headSha: "head-2" },
+      { baseSha: "base-1", headSha: "head-2" },
+    ];
+    const patches = ["patch-1", "patch-2"];
+
+    const snapshot = await prSnapshot(
+      "https://github.com/org/repo/pull/1",
+      3,
+      async () => refs.shift() ?? null,
+      async () => patches.shift() ?? null,
+    );
+
+    expect(snapshot).toEqual({ patch: "patch-2", baseSha: "base-1", headSha: "head-2" });
+  });
+
+  test("returns no snapshot when the head keeps moving", async () => {
+    let head = 0;
+
+    const snapshot = await prSnapshot(
+      "https://github.com/org/repo/pull/1",
+      2,
+      async () => ({ baseSha: "base", headSha: `head-${head++}` }),
+      async () => "patch",
+    );
+
+    expect(snapshot).toBeNull();
+  });
+
+  test("retries when only the base moves", async () => {
+    const refs = [
+      { baseSha: "base-1", headSha: "head" },
+      { baseSha: "base-2", headSha: "head" },
+      { baseSha: "base-2", headSha: "head" },
+      { baseSha: "base-2", headSha: "head" },
+    ];
+    const patches = ["old-base-patch", "new-base-patch"];
+
+    const snapshot = await prSnapshot(
+      "https://github.com/org/repo/pull/1",
+      3,
+      async () => refs.shift() ?? null,
+      async () => patches.shift() ?? null,
+    );
+
+    expect(snapshot).toEqual({
+      patch: "new-base-patch",
+      baseSha: "base-2",
+      headSha: "head",
+    });
+  });
+});

package/src/gh.ts

@@ -0,0 +1,74 @@
+// gh CLI reads for PR reviews; auth is delegated to the user's gh. Reads only.
+
+import * as v from "valibot";
+
+export interface PullRequestRefs {
+  baseSha: string;
+  headSha: string;
+}
+
+const PullRequestRefsSchema = v.object({
+  baseRefOid: v.pipe(v.string(), v.nonEmpty()),
+  headRefOid: v.pipe(v.string(), v.nonEmpty()),
+});
+
+const ghBinary = (): string => process.env.CUELOOP_GH || "gh";
+
+async function gh(args: string[]): Promise<{ code: number; stdout: string }> {
+  const process = Bun.spawn([ghBinary(), ...args], { stdout: "pipe", stderr: "ignore" });
+  const stdout = await new Response(process.stdout).text();
+
+  return { code: await process.exited, stdout };
+}
+
+/** The PR base and head commits, or null when gh is absent, unauthenticated, or the call fails. */
+export async function prRefs(pr: string): Promise<PullRequestRefs | null> {
+  const { code, stdout } = await gh(["pr", "view", pr, "--json", "baseRefOid,headRefOid"]);
+
+  if (code !== 0) return null;
+  let input: unknown;
+
+  try {
+    input = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  const parsed = v.safeParse(PullRequestRefsSchema, input);
+
+  if (!parsed.success) return null;
+
+  return { baseSha: parsed.output.baseRefOid, headSha: parsed.output.headRefOid };
+}
+
+/** The PR unified diff as gh prints it, or null when the call fails. */
+export async function prDiff(pr: string): Promise<string | null> {
+  const { code, stdout } = await gh(["pr", "diff", pr]);
+
+  if (code !== 0) return null;
+
+  return stdout;
+}
+
+/** A stable PR diff and the exact base/head pair it represents. */
+export async function prSnapshot(
+  pr: string,
+  attempts = 3,
+  readRefs: (reference: string) => Promise<PullRequestRefs | null> = prRefs,
+  readDiff: (reference: string) => Promise<string | null> = prDiff,
+): Promise<{ patch: string; baseSha: string; headSha: string } | null> {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const before = await readRefs(pr);
+
+    if (before === null) return null;
+    const patch = await readDiff(pr);
+
+    if (patch === null) return null;
+    const after = await readRefs(pr);
+
+    if (after === null) return null;
+    if (before.baseSha === after.baseSha && before.headSha === after.headSha)
+      return { patch, ...after };
+  }
+
+  return null;
+}

package/src/ghostty-thread-surface-store.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { GhosttyThreadSurfaceStore } from "./ghostty-thread-surface-store";
+import { ghosttyThreadSurfacesPath } from "./paths";
+
+let home: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-ghostty-store-"));
+});
+
+afterEach(() => {
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("GhosttyThreadSurfaceStore", () => {
+  test("persists terminal IDs outside Thread records and reloads them", () => {
+    const store = new GhosttyThreadSurfaceStore(home);
+
+    store.set("ses_one", { terminalId: "term-1" });
+    expect(new GhosttyThreadSurfaceStore(home).get("ses_one")).toEqual({ terminalId: "term-1" });
+    expect(JSON.parse(readFileSync(ghosttyThreadSurfacesPath(home), "utf8"))).toEqual({
+      ses_one: { terminalId: "term-1" },
+    });
+    store.delete("ses_one");
+    expect(new GhosttyThreadSurfaceStore(home).get("ses_one")).toBeNull();
+  });
+
+  test("ignores malformed scratch state", () => {
+    writeFileSync(ghosttyThreadSurfacesPath(home), '{"ses_one":{"terminalId":3}}');
+
+    expect(new GhosttyThreadSurfaceStore(home).get("ses_one")).toBeNull();
+  });
+
+  test("reserves a Thread before launch and fails closed across daemon restart", () => {
+    const store = new GhosttyThreadSurfaceStore(home);
+
+    expect(store.claim("ses_one")).toBe(true);
+    expect(store.claim("ses_one")).toBe(false);
+    expect(new GhosttyThreadSurfaceStore(home).claim("ses_one")).toBe(false);
+    store.set("ses_one", { terminalId: "term-1" });
+    expect(new GhosttyThreadSurfaceStore(home).claim("ses_one")).toBe(true);
+    store.release("ses_one");
+    expect(new GhosttyThreadSurfaceStore(home).get("ses_one")).toEqual({ terminalId: "term-1" });
+    expect(new GhosttyThreadSurfaceStore(home).claim("ses_one")).toBe(true);
+  });
+});

package/src/ghostty-thread-surface-store.ts

@@ -0,0 +1,101 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import * as v from "valibot";
+import { ghosttyThreadSurfacesPath } from "./paths";
+
+export interface GhosttyThreadSurfaceHandle {
+  terminalId: string;
+}
+
+interface GhosttyThreadSurfaceRecord {
+  terminalId?: string;
+  opening?: true;
+}
+
+const RecordSchema = v.object({
+  terminalId: v.optional(v.string()),
+  opening: v.optional(v.literal(true)),
+});
+const MapSchema = v.record(v.string(), v.unknown());
+
+export class GhosttyThreadSurfaceStore {
+  private surfaces = new Map<string, GhosttyThreadSurfaceRecord>();
+  private readonly path: string;
+
+  constructor(home: string) {
+    this.path = ghosttyThreadSurfacesPath(home);
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      const parsed = v.parse(MapSchema, JSON.parse(readFileSync(this.path, "utf8")));
+
+      for (const [threadId, value] of Object.entries(parsed)) {
+        const handle = v.safeParse(RecordSchema, value);
+
+        if (handle.success) {
+          const record = handle.output;
+
+          this.surfaces.set(
+            threadId,
+            record.opening && record.terminalId ? { terminalId: record.terminalId } : record,
+          );
+        }
+      }
+    } catch {
+      // Scratch corruption cannot change a pending Thread.
+    }
+  }
+
+  private persist(): void {
+    const tempPath = this.path + ".tmp";
+
+    writeFileSync(tempPath, JSON.stringify(Object.fromEntries(this.surfaces), null, 2));
+    renameSync(tempPath, this.path);
+  }
+
+  get(threadId: string): GhosttyThreadSurfaceHandle | null {
+    const terminalId = this.surfaces.get(threadId)?.terminalId;
+
+    return terminalId ? { terminalId } : null;
+  }
+
+  /** Persist a launch reservation before any AppleScript surface can be created. */
+  claim(threadId: string): boolean {
+    const previous = this.surfaces.get(threadId);
+
+    if (previous?.opening) return false;
+    this.surfaces.set(threadId, { ...previous, opening: true });
+
+    try {
+      this.persist();
+
+      return true;
+    } catch (error) {
+      if (previous) this.surfaces.set(threadId, previous);
+      else this.surfaces.delete(threadId);
+
+      throw error;
+    }
+  }
+
+  release(threadId: string): void {
+    const record = this.surfaces.get(threadId);
+
+    if (!record?.opening) return;
+    if (record.terminalId) this.surfaces.set(threadId, { terminalId: record.terminalId });
+    else this.surfaces.delete(threadId);
+    this.persist();
+  }
+
+  set(threadId: string, handle: GhosttyThreadSurfaceHandle): void {
+    const opening = this.surfaces.get(threadId)?.opening;
+
+    this.surfaces.set(threadId, opening ? { ...handle, opening } : handle);
+    this.persist();
+  }
+
+  delete(threadId: string): void {
+    if (this.surfaces.delete(threadId)) this.persist();
+  }
+}