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

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/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,23 @@ 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 for Herdr handles; the disk name stays stable across tab and pane support. */
+export function herdrThreadSurfacesPath(home = cueloopHome()): string {
+  return join(home, "herdr-tabs.json");
+}
+
+/** Ghostty-native terminal IDs are adapter scratch, not Thread state. */
+export function ghosttyThreadSurfacesPath(home = cueloopHome()): string {
+  return join(home, "ghostty-thread-surfaces.json");
+}
+
+/** Harness bindings and Message deliveries, stored independently of Thread records. */
+export function harnessStatePath(home = cueloopHome()): string {
+  return join(home, "harness-state.json");
+}