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

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/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/jj-working-tree.ts

@@ -0,0 +1,131 @@
+/** Native Jujutsu capture pinned to one commit after its working-copy snapshot. */
+
+import type { DiffFileContents, DiffFileStatus } from "@cueloop/schema";
+import type { VcsAdapter, VcsDiffSnapshot } from "@cueloop/extension-api";
+
+async function jj(args: string[], cwd: string): Promise<string | null> {
+  try {
+    const child = Bun.spawn(["jj", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+    const output = await new Response(child.stdout).text();
+
+    return (await child.exited) === 0 ? output : null;
+  } catch {
+    return null;
+  }
+}
+
+const JJ_DIFF_FILES_TEMPLATE = 'status_char ++ "\\x00" ++ path.display() ++ "\\x00"';
+const JJ_FILE_LIST_TEMPLATE = 'path.display() ++ "\\x00"';
+
+function jjSummary(text: string): { path: string; status: DiffFileStatus; curatable: boolean }[] {
+  const tokens = text.split("\0");
+  const changes: { path: string; status: DiffFileStatus; curatable: boolean }[] = [];
+
+  for (let index = 0; index + 1 < tokens.length; index += 2) {
+    const code = tokens[index];
+    const path = tokens[index + 1];
+
+    if (!code || !path) continue;
+    changes.push({
+      path,
+      status: code === "A" ? "added" : code === "D" ? "deleted" : "modified",
+      curatable: code === "A" || code === "M" || code === "D",
+    });
+  }
+
+  return changes;
+}
+
+function isBinary(contents: string): boolean {
+  return contents.includes("\0");
+}
+
+async function jjFileContents(
+  root: string,
+  revision: string,
+  path: string,
+): Promise<string | null> {
+  return jj(["--ignore-working-copy", "file", "show", "-r", revision, "--", path], root);
+}
+
+async function captureJjRevision(repoRoot: string, revset: string): Promise<VcsDiffSnapshot> {
+  const identity = await jj(
+    [
+      "log",
+      "-r",
+      revset,
+      "-T",
+      'change_id ++ "\\n" ++ commit_id ++ "\\n" ++ parents.map(|c| c.commit_id()).join(",") ++ "\\n"',
+      "--no-graph",
+    ],
+    repoRoot,
+  );
+
+  if (!identity) throw new Error(`Jujutsu diff capture failed: could not resolve ${revset}`);
+  const lines = identity.trim().split("\n");
+
+  if (lines.length !== 3) throw new Error(`Jujutsu change is ambiguous: ${revset}`);
+  const [changeId, revisionId, parents] = lines;
+
+  if (!changeId || !revisionId) throw new Error("Jujutsu diff capture failed: invalid identity");
+  const [patch, summary] = await Promise.all([
+    jj(["--ignore-working-copy", "diff", "--git", "-r", revisionId], repoRoot),
+    jj(["--ignore-working-copy", "diff", "-T", JJ_DIFF_FILES_TEMPLATE, "-r", revisionId], repoRoot),
+  ]);
+
+  if (patch === null || summary === null)
+    throw new Error("Jujutsu diff capture failed: could not read pinned revision");
+  const files: DiffFileContents[] = [];
+  const parent = parents?.split(",")[0];
+
+  if (parent && !parents?.includes(",")) {
+    for (const change of jjSummary(summary)) {
+      if (!change.curatable) continue;
+      const oldContents =
+        change.status === "added" ? "" : await jjFileContents(repoRoot, parent, change.path);
+      const newContents =
+        change.status === "deleted" ? "" : await jjFileContents(repoRoot, revisionId, change.path);
+
+      if (oldContents === null || newContents === null) continue;
+      if (isBinary(oldContents) || isBinary(newContents)) continue;
+      files.push({ path: change.path, oldContents, newContents, status: change.status });
+    }
+  }
+
+  return { patch: patch.replace(/\n+$/, ""), files, source: { changeId, revisionId } };
+}
+
+/** Built-in jj adapter uses native change and commit IDs in a colocated checkout. */
+export const jjVcsAdapter: VcsAdapter = {
+  apiVersion: 1,
+  id: "jj",
+  async detect(cwd) {
+    const root = await jj(["--ignore-working-copy", "root"], cwd);
+
+    return root?.trim() ?? null;
+  },
+  captureWorkingDiff(repoRoot) {
+    return captureJjRevision(repoRoot, "@");
+  },
+  async captureChange(repoRoot, changeId) {
+    if (!/^[a-z]{32}$/.test(changeId)) throw new Error(`Jujutsu change ID is invalid: ${changeId}`);
+    if ((await jj(["status"], repoRoot)) === null)
+      throw new Error("Jujutsu diff capture failed: could not snapshot the working copy");
+
+    return captureJjRevision(repoRoot, changeId);
+  },
+  async listChanges(repoRoot) {
+    const summary = await jj(["diff", "-T", JJ_DIFF_FILES_TEMPLATE, "-r", "@"], repoRoot);
+
+    if (summary === null) throw new Error("Jujutsu changes list failed");
+
+    return jjSummary(summary).map(({ path, status }) => ({ path, status }));
+  },
+  async listFiles(repoRoot) {
+    const files = await jj(["file", "list", "-T", JJ_FILE_LIST_TEMPLATE, "-r", "@"], repoRoot);
+
+    if (files === null) throw new Error("Jujutsu project files failed");
+
+    return files.split("\0").filter(Boolean).toSorted().slice(0, 5000);
+  },
+};