@cueloop/daemon 0.1.0-alpha.11 → 0.1.0-alpha.110

package/src/ghostty-thread-surface.ts

@@ -0,0 +1,273 @@
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import { basename, delimiter, isAbsolute, join } from "node:path";
+import type { Thread, ThreadSurfaceOpenStatus } from "@cueloop/schema";
+import type { GhosttyThreadSurfaceHandle } from "./ghostty-thread-surface-store";
+import { loadGhosttyThreadSurface, type GhosttyThreadSurface } from "./thread-surface-config";
+
+const APPLESCRIPT_TIMEOUT_MS = 10000;
+const VERSION_SCRIPT = 'tell application "Ghostty" to get version';
+export const GHOSTTY_OPEN_APPLESCRIPT = `on run argv
+  set placement to item 1 of argv
+  set threadDirectory to item 2 of argv
+  set shellCommand to item 3 of argv
+  tell application "Ghostty"
+    if placement is "tab" then
+      set targetWindow to front window
+      set beforeCount to count of tabs of targetWindow
+      set beforeIds to id of every tab of targetWindow
+      set sourceTerminal to focused terminal of selected tab of targetWindow
+      if not (perform action "new_tab" on sourceTerminal) then error "Ghostty rejected new_tab"
+      repeat 50 times
+        if (count of tabs of targetWindow) > beforeCount then exit repeat
+        delay 0.1
+      end repeat
+      if (count of tabs of targetWindow) <= beforeCount then error "Ghostty did not create a tab"
+      set newTabs to {}
+      repeat with candidateTab in tabs of targetWindow
+        if (id of candidateTab) is not in beforeIds then set end of newTabs to candidateTab
+      end repeat
+      if (count of newTabs) is not 1 then error "Ghostty tab identity is ambiguous"
+      set createdTab to item 1 of newTabs
+      set createdTerminal to focused terminal of createdTab
+    else
+      set surfaceConfiguration to new surface configuration
+      set initial working directory of surfaceConfiguration to threadDirectory
+      if placement is "window" then
+        set createdWindow to new window with configuration surfaceConfiguration
+        set createdTerminal to focused terminal of selected tab of createdWindow
+      else
+        set targetWindow to front window
+        set sourceTerminal to focused terminal of selected tab of targetWindow
+        set createdTerminal to split sourceTerminal direction right with configuration surfaceConfiguration
+      end if
+    end if
+    try
+      repeat 50 times
+        if (name of createdTerminal) is not "👻" and (name of createdTerminal) is not "" then exit repeat
+        delay 0.1
+      end repeat
+      if (name of createdTerminal) is "👻" or (name of createdTerminal) is "" then error "Ghostty surface has no shell"
+      input text shellCommand to createdTerminal
+      send key "enter" to createdTerminal
+      focus createdTerminal
+      return id of createdTerminal
+    on error
+      if placement is "tab" then
+        close tab createdTab
+      else if placement is "window" then
+        close window createdWindow
+      else
+        close createdTerminal
+      end if
+      error "Ghostty surface did not launch the Thread"
+    end try
+  end tell
+end run`;
+const FOCUS_SCRIPT = `on run argv
+  set targetId to item 1 of argv
+  tell application "Ghostty"
+    repeat with candidate in terminals
+      if (id of candidate) is targetId then
+        focus candidate
+        return "focused"
+      end if
+    end repeat
+  end tell
+  return "closed"
+end run`;
+const CLOSE_SCRIPT = `on run argv
+  set targetId to item 1 of argv
+  tell application "Ghostty"
+    repeat with candidate in terminals
+      if (id of candidate) is targetId then
+        close candidate
+        return "closed"
+      end if
+    end repeat
+  end tell
+  return "absent"
+end run`;
+
+export interface GhosttyThreadSurfacePersistence {
+  ghosttyClaimThreadSurface(threadId: string): Promise<boolean>;
+  ghosttyReleaseThreadSurface(threadId: string): Promise<void>;
+  ghosttyGetThreadSurface(threadId: string): Promise<GhosttyThreadSurfaceHandle | null>;
+  ghosttySetThreadSurface(threadId: string, handle: GhosttyThreadSurfaceHandle): Promise<void>;
+}
+
+export interface GhosttyEnv {
+  [name: string]: string | undefined;
+  TERM_PROGRAM?: string;
+  GHOSTTY_RESOURCES_DIR?: string;
+}
+
+interface GhosttyLaunchResult {
+  status: ThreadSurfaceOpenStatus;
+  retainClaim: boolean;
+}
+
+function runAppleScript(binPath: string, script: string, args: string[] = []): string | null {
+  try {
+    const result = spawnSync(binPath, ["-e", script, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: APPLESCRIPT_TIMEOUT_MS,
+    });
+
+    return result.status === 0 ? result.stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveCueloopLaunchCommand(
+  executable = process.execPath,
+  entry = process.argv[1],
+  path = process.env.PATH,
+): string | null {
+  if (basename(executable) === "cueloop") return shellQuote(executable);
+
+  if (
+    entry &&
+    isAbsolute(entry) &&
+    entry.endsWith(join("packages", "cli", "src", "main.ts")) &&
+    existsSync(entry)
+  ) {
+    return `${shellQuote(executable)} run ${shellQuote(entry)}`;
+  }
+
+  for (const directory of path?.split(delimiter) ?? []) {
+    if (!isAbsolute(directory)) continue;
+
+    const candidate = join(directory, "cueloop");
+
+    try {
+      accessSync(candidate, constants.X_OK);
+
+      if (statSync(candidate).isFile()) return shellQuote(candidate);
+    } catch {
+      // A PATH entry without an executable cannot launch the Thread.
+    }
+  }
+
+  return null;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+/** Ghostty 1.3.0 introduced the native AppleScript commands used here. */
+export function supportsGhosttyAppleScript(version: string | null): boolean {
+  const parsed = version?.match(/^(\d+)\.(\d+)\.(\d+)/);
+
+  if (!parsed) return false;
+
+  const major = Number(parsed[1]);
+  const minor = Number(parsed[2]);
+
+  return major > 1 || (major === 1 && minor >= 3);
+}
+
+/** Herdr selection happens before this adapter, even when it runs inside Ghostty. */
+export function insideGhostty(env: GhosttyEnv = process.env): boolean {
+  return env.TERM_PROGRAM?.toLowerCase() === "ghostty" || Boolean(env.GHOSTTY_RESOURCES_DIR);
+}
+
+/** Reuse a live Ghostty terminal, reopen a closed one, or leave the Thread pending. */
+export async function openGhosttyThreadSurface(
+  thread: Thread,
+  persistence: GhosttyThreadSurfacePersistence,
+  env: GhosttyEnv = process.env,
+  mode: GhosttyThreadSurface = loadGhosttyThreadSurface(),
+  binPath = "osascript",
+  platform: NodeJS.Platform = process.platform,
+  cueloopBinPath?: string | null,
+): Promise<ThreadSurfaceOpenStatus> {
+  if (platform !== "darwin" || !insideGhostty(env)) return "unavailable";
+
+  if (mode === "none") return "disabled";
+
+  if (!supportsGhosttyAppleScript(runAppleScript(binPath, VERSION_SCRIPT))) return "failed";
+
+  try {
+    if (!(await persistence.ghosttyClaimThreadSurface(thread.id))) return "failed";
+  } catch {
+    return "failed";
+  }
+
+  let result: GhosttyLaunchResult;
+
+  try {
+    result = await openClaimedGhosttyThreadSurface(
+      thread,
+      persistence,
+      mode,
+      binPath,
+      cueloopBinPath,
+    );
+  } catch {
+    result = { status: "failed", retainClaim: true };
+  }
+
+  if (result.retainClaim) return "failed";
+
+  try {
+    await persistence.ghosttyReleaseThreadSurface(thread.id);
+  } catch {
+    return "failed";
+  }
+
+  return result.status;
+}
+
+async function openClaimedGhosttyThreadSurface(
+  thread: Thread,
+  persistence: GhosttyThreadSurfacePersistence,
+  mode: Exclude<GhosttyThreadSurface, "none">,
+  binPath: string,
+  cueloopBinPath?: string | null,
+): Promise<GhosttyLaunchResult> {
+  let recorded: GhosttyThreadSurfaceHandle | null;
+
+  try {
+    recorded = await persistence.ghosttyGetThreadSurface(thread.id);
+  } catch {
+    return { status: "failed", retainClaim: false };
+  }
+
+  if (recorded) {
+    const result = runAppleScript(binPath, FOCUS_SCRIPT, [recorded.terminalId]);
+
+    if (result === "focused") return { status: "focused", retainClaim: false };
+
+    if (result !== "closed") return { status: "failed", retainClaim: false };
+  }
+
+  const launchCommand =
+    cueloopBinPath === undefined
+      ? resolveCueloopLaunchCommand()
+      : cueloopBinPath && shellQuote(cueloopBinPath);
+
+  if (!launchCommand) return { status: "failed", retainClaim: false };
+
+  const cwd = thread.artifact.meta.cwd ?? thread.workspace.repoRoot;
+  const terminalId = runAppleScript(binPath, GHOSTTY_OPEN_APPLESCRIPT, [
+    mode,
+    cwd,
+    `cd -- ${shellQuote(cwd)} && ${launchCommand} ${shellQuote(thread.id)}`,
+  ]);
+
+  if (!terminalId) return { status: "failed", retainClaim: false };
+
+  try {
+    await persistence.ghosttySetThreadSurface(thread.id, { terminalId });
+  } catch {
+    const closed = runAppleScript(binPath, CLOSE_SCRIPT, [terminalId]);
+
+    return { status: "failed", retainClaim: closed !== "closed" && closed !== "absent" };
+  }
+
+  return { status: "opened", retainClaim: false };
+}

package/src/harness-delivery.test.ts

@@ -0,0 +1,269 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonCore } from "./api";
+import { harnessStatePath } from "./paths";
+
+let home: string;
+let cores: DaemonCore[];
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-harness-delivery-"));
+  cores = [];
+});
+
+afterEach(() => {
+  for (const core of cores) core.dispose();
+  rmSync(home, { recursive: true, force: true });
+});
+
+function core(): DaemonCore {
+  const instance = new DaemonCore(home);
+
+  cores.push(instance);
+
+  return instance;
+}
+
+function createPlan(instance: DaemonCore) {
+  return instance.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan", meta: {} },
+  });
+}
+
+describe("durable harness delivery", () => {
+  test("delivers Comment without resolving the Thread", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    const sent = instance.sessionSendMessage(thread.id, "comment", "Interim note.");
+    const pending = instance.deliveryPending(binding.id);
+
+    expect(sent.status).toBe("pending");
+    expect(pending).toHaveLength(1);
+    expect(pending[0]!.message.outcome).toBe("comment");
+  });
+
+  test("reload finds only bindings for the active harness conversation", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const current = first.harnessBind({
+      threadId: thread.id,
+      harness: "pi",
+      harnessSessionId: "pi-current",
+    });
+
+    first.harnessBind({ threadId: thread.id, harness: "pi", harnessSessionId: "pi-other" });
+    first.harnessBind({ threadId: thread.id, harness: "codex", harnessSessionId: "pi-current" });
+
+    expect(core().harnessBindingsForSession("pi", "pi-current")).toEqual([current]);
+  });
+
+  test("Thread deletion removes pi, Codex, and Claude harness state", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const bindings = ["pi", "codex", "claude-code"].map((harness) =>
+      instance.harnessBind({
+        threadId: thread.id,
+        harness,
+        harnessSessionId: `${harness}-session`,
+      }),
+    );
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = instance.deliveryPending(bindings[0]!.id)[0]!.delivery.id;
+
+    instance.sessionDelete(thread.id);
+
+    for (const [index, harness] of ["pi", "codex", "claude-code"].entries()) {
+      expect(instance.harnessBindingsForSession(harness, `${harness}-session`)).toEqual([]);
+      expect(() => instance.harnessGetBinding(bindings[index]!.id)).toThrow("no harness binding");
+    }
+    expect(() => instance.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
+  test("startup removes harness state orphaned by an older deletion", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "codex",
+      harnessSessionId: "codex-orphan",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const deliveryId = first.deliveryPending(binding.id)[0]!.delivery.id;
+
+    first.store.delete(thread.id);
+    const restarted = core();
+
+    expect(restarted.harnessBindingsForSession("codex", "codex-orphan")).toEqual([]);
+    expect(() => restarted.harnessGetBinding(binding.id)).toThrow("no harness binding");
+    expect(() => restarted.deliveryAcknowledge(deliveryId)).toThrow("no delivery");
+  });
+
+  test("redelivers after reload until the harness acknowledges the Message", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const initial = first.deliveryPending(binding.id);
+
+    expect(initial).toHaveLength(1);
+    expect(initial[0]!.message).toEqual(sent.message!);
+
+    const reloaded = core();
+    const redelivered = reloaded.deliveryPending(binding.id);
+
+    expect(redelivered).toEqual(initial);
+    reloaded.deliveryAcknowledge(redelivered[0]!.delivery.id);
+
+    expect(core().deliveryPending(binding.id)).toEqual([]);
+  });
+
+  test("retains an expired Thread until its pending Message is acknowledged", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    first.sessionSendMessage(thread.id, "approved", "Ready.");
+    const oldThread = first.sessionGet(thread.id);
+
+    first.store.upsert({ ...oldThread, createdAt: "2020-01-01T00:00:00.000Z" });
+
+    const reloaded = core();
+    const delivery = reloaded.deliveryPending(binding.id)[0];
+
+    expect(delivery?.message.body).toContain("Ready.");
+    reloaded.deliveryAcknowledge(delivery!.delivery.id);
+
+    expect(core().store.get(thread.id)).toBeUndefined();
+  });
+
+  test("rebuilds a delivery if the Thread saved its Message before enqueue", () => {
+    const first = core();
+    const thread = createPlan(first);
+    const binding = first.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = first.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    first.store.upsert({
+      ...first.sessionGet(thread.id),
+      createdAt: "2020-01-01T00:00:00.000Z",
+    });
+
+    writeFileSync(harnessStatePath(home), JSON.stringify({ bindings: [binding], deliveries: [] }));
+
+    const recovered = core().deliveryPending(binding.id);
+
+    expect(recovered).toHaveLength(1);
+    expect(recovered[0]!.message).toEqual(sent.message!);
+  });
+
+  test("routes an approved retry as a new Message", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Try once more.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.deliveryAcknowledge(first.delivery.id);
+    instance.sessionSubmitRevision(thread.id, "# Plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const retry = instance.deliveryPending(binding.id);
+
+    expect(retry).toHaveLength(1);
+    expect(retry[0]!.message.outcome).toBe("approved");
+    expect(retry[0]!.message.id).not.toBe(first.message.id);
+  });
+
+  test("keeps an older pending Message available after a Thread revision", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "changes_requested", "Add detail.");
+    const first = instance.deliveryPending(binding.id)[0]!;
+
+    instance.sessionSubmitRevision(thread.id, "# Revised plan");
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    const pending = core().deliveryPending(binding.id);
+
+    expect(pending.map((item) => item.message.id)).toEqual([first.message.id, expect.any(String)]);
+    expect(pending[0]!.message.body).toBe(first.message.body);
+  });
+
+  test("defaults delivery to the submitting binding only", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const submitter = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const other = instance.harnessBind({
+      threadId: thread.id,
+      harness: "other",
+      harnessSessionId: "other_1",
+    });
+
+    instance.sessionSendMessage(thread.id, "approved", "Ready.");
+
+    expect(instance.deliveryPending(submitter.id)).toHaveLength(1);
+    expect(instance.deliveryPending(other.id)).toEqual([]);
+  });
+
+  test("consumes the unchanged approved retry once across daemon reload", () => {
+    const instance = core();
+    const thread = createPlan(instance);
+    const binding = instance.harnessBind({
+      threadId: thread.id,
+      harness: "fake",
+      harnessSessionId: "fake_1",
+    });
+    const sent = instance.sessionSendMessage(thread.id, "approved", "Ready.");
+    const messageId = sent.message!.id;
+
+    expect(() => instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toThrow(
+      "no unchanged approved plan",
+    );
+
+    const delivery = instance.deliveryPending(binding.id)[0]!.delivery;
+
+    instance.deliveryAcknowledge(delivery.id);
+
+    expect(instance.harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(true);
+    expect(core().harnessConsumeApprovedRetry(binding.id, messageId, "# Plan")).toBe(false);
+    expect(() => core().harnessConsumeApprovedRetry(binding.id, messageId, "# Changed")).toThrow(
+      "no unchanged approved plan",
+    );
+  });
+});

package/src/harness-diagnostics.test.ts

@@ -0,0 +1,26 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { writeHarnessDiagnostic } from "./harness-diagnostics";
+
+test("diagnostic logs are private and bounded across repeated notices", () => {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-diagnostics-"));
+  const path = join(directory, "thread.diagnostics.ndjson");
+
+  try {
+    for (let i = 0; i < 100; i++)
+      writeHarnessDiagnostic(directory, "thread", {
+        kind: "diagnostic",
+        severity: "error",
+        source: "protocol",
+        title: "Advisory",
+        text: "x".repeat(32768),
+      });
+    expect(statSync(path).size).toBeLessThanOrEqual(256 * 1024);
+    expect(statSync(path).mode & 0o777).toBe(0o600);
+    expect(JSON.parse(readFileSync(path, "utf8").trim().split("\n")[0]!).text).toHaveLength(16384);
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/harness-diagnostics.ts

@@ -0,0 +1,31 @@
+import { appendFileSync, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentHarnessDiagnostic } from "@cueloop/schema";
+
+/** Store harness diagnostics in a private, bounded log, outside Thread history and model context. */
+export function writeHarnessDiagnostic(
+  directory: string,
+  threadId: string,
+  diagnostic: AgentHarnessDiagnostic,
+): void {
+  const path = join(directory, `${encodeURIComponent(threadId)}.diagnostics.ndjson`);
+  const record =
+    JSON.stringify({
+      at: new Date().toISOString(),
+      ...diagnostic,
+      severity: diagnostic.severity.slice(0, 128),
+      title: diagnostic.title.slice(0, 512),
+      text: diagnostic.text.slice(0, 16384),
+    }) + "\n";
+
+  try {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+
+    if (existsSync(path) && statSync(path).size + Buffer.byteLength(record) > 256 * 1024)
+      writeFileSync(path, record, { mode: 0o600 });
+    else appendFileSync(path, record, { mode: 0o600 });
+  } catch {
+    // A diagnostic log failure must not change the agent turn outcome.
+    console.error("Thread agent diagnostic log could not be written");
+  }
+}