@cueloop/daemon 0.1.0-alpha.80 → 0.1.0-alpha.82

package/src/harness-state-store.ts

@@ -1,10 +1,3 @@
-/**
- * Durable harness routing state. Bindings identify where a Thread came from;
- * deliveries record which Message still needs to reach that binding. Keeping
- * both outside Thread records prevents harness identity from leaking into the
- * product primitive and makes redelivery independent of the review lifecycle.
- */
-
 import { readFileSync, renameSync, writeFileSync } from "node:fs";
 import type { Delivery, HarnessBinding } from "@cueloop/schema";
 import * as v from "valibot";
@@ -55,6 +48,12 @@ export class HarnessStateStore {
     return this.bindings.get(id) ?? null;
   }
 
+  bindingsForSession(harness: string, harnessSessionId: string): HarnessBinding[] {
+    return [...this.bindings.values()].filter(
+      (binding) => binding.harness === harness && binding.harnessSessionId === harnessSessionId,
+    );
+  }
+
   consumeApprovedRetry(bindingId: string, messageId: string): boolean {
     const binding = this.bindings.get(bindingId);
 

package/src/{herdr-tab-store.test.ts → herdr-thread-surface-store.test.ts}

@@ -1,11 +1,11 @@
-/** herdr tab side-store: set/get/delete round-trips, survives a reload from disk, and ignores a corrupt file. */
+/** Herdr Thread-surface handles survive reload and reject corrupt records. */
 
 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 { HerdrTabStore } from "./herdr-tab-store";
-import { herdrTabsPath } from "./paths";
+import { HerdrThreadSurfaceStore } from "./herdr-thread-surface-store";
+import { herdrThreadSurfacesPath } from "./paths";
 
 let home: string;
 
@@ -16,81 +16,66 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
-describe("HerdrTabStore", () => {
+describe("HerdrThreadSurfaceStore", () => {
   test("set then get returns the handle; get for an unknown session is null", () => {
-    // Arrange
-    const store = new HerdrTabStore(home);
+    const store = new HerdrThreadSurfaceStore(home);
 
-    // Act
     store.set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
 
-    // Assert
     expect(store.get("ses_1")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
     expect(store.get("ses_missing")).toBeNull();
   });
 
   test("handles survive a reload from disk", () => {
-    // Arrange
-    new HerdrTabStore(home).set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
+    new HerdrThreadSurfaceStore(home).set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
 
-    // Act - a fresh store over the same home loads the persisted file
-    const reloaded = new HerdrTabStore(home);
+    const reloaded = new HerdrThreadSurfaceStore(home);
 
-    // Assert
     expect(reloaded.get("ses_1")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
   });
 
   test("delete removes the handle", () => {
-    // Arrange
-    const store = new HerdrTabStore(home);
+    const store = new HerdrThreadSurfaceStore(home);
 
     store.set("ses_1", { tabId: "w1:t2", paneId: "w1:p2" });
 
-    // Act
     store.delete("ses_1");
 
-    // Assert
     expect(store.get("ses_1")).toBeNull();
   });
 
   test("a corrupt file starts empty instead of throwing", () => {
-    // Arrange
-    writeFileSync(herdrTabsPath(home), "not json");
+    writeFileSync(herdrThreadSurfacesPath(home), "not json");
 
-    // Act
-    const store = new HerdrTabStore(home);
+    const store = new HerdrThreadSurfaceStore(home);
 
-    // Assert
     expect(store.get("ses_1")).toBeNull();
   });
 
   test("malformed entries are dropped, well-formed ones survive", () => {
-    // Arrange - valid JSON, but entries with the wrong shape
     writeFileSync(
-      herdrTabsPath(home),
+      herdrThreadSurfacesPath(home),
       JSON.stringify({
         ses_ok: { tabId: "w1:t2", paneId: "w1:p2" },
         ses_partial: { tabId: "w1:t2" },
         ses_typed: { tabId: 1, paneId: 2 },
+        ses_invalid_mode: { tabId: "w1:t2", paneId: "w1:p3", mode: "window" },
         ses_null: null,
       }),
     );
 
-    // Act
-    const store = new HerdrTabStore(home);
+    const store = new HerdrThreadSurfaceStore(home);
 
-    // Assert
     expect(store.get("ses_ok")).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
     expect(store.get("ses_partial")).toBeNull();
     expect(store.get("ses_typed")).toBeNull();
+    expect(store.get("ses_invalid_mode")).toBeNull();
     expect(store.get("ses_null")).toBeNull();
   });
 
   test("a non-object top level starts empty", () => {
-    // Arrange
-    writeFileSync(herdrTabsPath(home), JSON.stringify(["not", "a", "map"]));
+    writeFileSync(herdrThreadSurfacesPath(home), JSON.stringify(["not", "a", "map"]));
 
-    // Act & Assert
-    expect(new HerdrTabStore(home).get("ses_1")).toBeNull();
+    expect(new HerdrThreadSurfaceStore(home).get("ses_1")).toBeNull();
   });
 });

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

@@ -0,0 +1,64 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import * as v from "valibot";
+import { herdrThreadSurfacesPath } from "./paths";
+
+/** Herdr-native handle, stored outside the canonical Thread. */
+export interface HerdrThreadSurfaceHandle {
+  mode?: "tab" | "pane";
+  tabId: string;
+  paneId: string;
+}
+
+const HerdrThreadSurfaceHandleSchema = v.object({
+  tabId: v.string(),
+  paneId: v.string(),
+  mode: v.optional(v.picklist(["tab", "pane"])),
+});
+const HerdrThreadSurfaceMapSchema = v.record(v.string(), v.unknown());
+
+export class HerdrThreadSurfaceStore {
+  private surfaces = new Map<string, HerdrThreadSurfaceHandle>();
+  private readonly path: string;
+
+  constructor(home: string) {
+    this.path = herdrThreadSurfacesPath(home);
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      const parsed = v.parse(
+        HerdrThreadSurfaceMapSchema,
+        JSON.parse(readFileSync(this.path, "utf8")),
+      );
+
+      for (const [sessionId, value] of Object.entries(parsed)) {
+        const handle = v.safeParse(HerdrThreadSurfaceHandleSchema, value);
+
+        if (handle.success) this.surfaces.set(sessionId, handle.output);
+      }
+    } catch {
+      // A missing or corrupt side-store cannot block 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(sessionId: string): HerdrThreadSurfaceHandle | null {
+    return this.surfaces.get(sessionId) ?? null;
+  }
+
+  set(sessionId: string, handle: HerdrThreadSurfaceHandle): void {
+    this.surfaces.set(sessionId, handle);
+    this.persist();
+  }
+
+  delete(sessionId: string): void {
+    if (this.surfaces.delete(sessionId)) this.persist();
+  }
+}

package/src/herdr-thread-surface.test.ts

@@ -0,0 +1,411 @@
+/** Herdr Thread launching with a stub CLI, including tab and pane reuse. */
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Thread } from "@cueloop/schema";
+import {
+  openHerdrThreadTab,
+  openHerdrThreadPane,
+  openHerdrThreadSurface,
+} from "./herdr-thread-surface";
+import type { HerdrThreadSurfacePersistence } from "./herdr-thread-surface";
+import type { HerdrThreadSurfaceHandle } from "./herdr-thread-surface-store";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-thread-surface-"));
+
+/**
+ * A stub herdr binary. It logs argv, prints the tab-create result carrying both
+ * pane_id and tab_id (herdr 0.8.2 shape), and answers `pane get` alive or dead
+ * per `paneAlive` so the liveness branch can be exercised.
+ */
+function makeStub(
+  name: string,
+  paneAlive = false,
+  leftNeighborPaneId = "w1:p1",
+  failedCommand?: "send-text" | "send-keys",
+) {
+  const logPath = join(dir, `${name}.log`);
+  const binPath = join(dir, `${name}.sh`);
+  const paneGet = paneAlive ? `printf '{"result":{"pane":{"pane_id":"w1:p2"}}}'` : "exit 1";
+
+  writeFileSync(
+    binPath,
+    `#!/bin/sh
+printf '%s\\n' "$*" >> "${logPath}"
+if [ "$1" = "pane" ] && [ "$2" = "${failedCommand ?? "never"}" ]; then exit 1; fi
+if [ "$1" = "tab" ] && [ "$2" = "create" ]; then
+  printf '{"result":{"root_pane":{"pane_id":"w1:p2","tab_id":"w1:t2"}}}'
+fi
+if [ "$1" = "pane" ] && [ "$2" = "split" ]; then
+  printf '{"result":{"pane":{"pane_id":"w1:p3"}}}'
+fi
+if [ "$1" = "pane" ] && [ "$2" = "neighbor" ]; then
+  if [ "$4" = "w1:p3" ] && [ "$6" = "left" ]; then
+    printf '{"result":{"neighbor":{"neighbor_pane_id":"${leftNeighborPaneId}"}}}'
+  elif [ "$4" = "${leftNeighborPaneId}" ] && [ "$6" = "right" ]; then
+    printf '{"result":{"neighbor":{"neighbor_pane_id":"w1:p3"}}}'
+  else
+    printf '{"result":{"neighbor":{"neighbor_pane_id":null}}}'
+  fi
+fi
+if [ "$1" = "pane" ] && [ "$2" = "focus" ]; then
+  printf '{"result":{"focus":{"focused_pane_id":"w1:p3"}}}'
+fi
+if [ "$1" = "pane" ] && [ "$2" = "get" ]; then ${paneGet}; fi
+exit 0
+`,
+  );
+  chmodSync(binPath, 0o755);
+
+  return { binPath, logPath };
+}
+
+function readLines(logPath: string): string[] {
+  if (!existsSync(logPath)) return [];
+
+  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+}
+
+/** In-memory persistence double for native Thread handles. */
+function fakePersistence(initial: HerdrThreadSurfaceHandle | null = null) {
+  let stored = initial;
+
+  return {
+    persistence: {
+      herdrGetThreadSurface: async () => stored,
+      herdrSetThreadSurface: async (_sessionId: string, handle: HerdrThreadSurfaceHandle) => {
+        stored = handle;
+      },
+    },
+    saved: () => stored,
+  };
+}
+
+function newSession(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: "1",
+    id: "ses_new1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# P", meta: { cwd: "/repo/work", title: "Rollout Plan" } },
+    revisions: [{ revision: 1, content: "# P", submittedAt: "now" }],
+    annotations: [],
+    message: null,
+    status: "pending",
+    createdAt: "now",
+    ...overrides,
+  };
+}
+
+describe("openHerdrThreadTab", () => {
+  test("creates a focused tab, launches the review, and returns the handle", () => {
+    const stub = makeStub("open");
+
+    const handle = openHerdrThreadTab({
+      sessionId: "ses_abc",
+      cwd: "/repo/work",
+      binPath: stub.binPath,
+      label: "Rollout Plan",
+    });
+
+    expect(handle).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_abc",
+      "pane send-keys w1:p2 enter",
+    ]);
+  });
+
+  test("returns null and never throws on a broken binary", () => {
+    expect(
+      openHerdrThreadTab({
+        sessionId: "ses_abc",
+        cwd: "/repo/work",
+        binPath: join(dir, "missing-bin"),
+        label: "x",
+      }),
+    ).toBeNull();
+  });
+
+  test("returns null when tab create yields no ids - no send-text, no send-keys", () => {
+    const logPath = join(dir, "nopane.log");
+    const binPath = join(dir, "nopane.sh");
+
+    writeFileSync(
+      binPath,
+      `#!/bin/sh\nprintf '%s\\n' "$*" >> "${logPath}"\nprintf '{"result":{}}'\n`,
+    );
+    chmodSync(binPath, 0o755);
+
+    const handle = openHerdrThreadTab({
+      sessionId: "ses_abc",
+      cwd: "/repo/work",
+      binPath,
+      label: "x",
+    });
+
+    expect(handle).toBeNull();
+    expect(readLines(logPath)).toEqual(["tab create --cwd /repo/work --label x --focus"]);
+  });
+
+  test("closes a tab if the Thread command cannot be sent", () => {
+    const stub = makeStub("tab-send-failed", false, "w1:p1", "send-text");
+
+    expect(
+      openHerdrThreadTab({
+        sessionId: "ses_abc",
+        cwd: "/repo/work",
+        binPath: stub.binPath,
+        label: "Rollout Plan",
+      }),
+    ).toBeNull();
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_abc",
+      "tab close w1:t2",
+    ]);
+  });
+});
+
+describe("openHerdrThreadPane", () => {
+  test("creates a focused right-hand pane at 50 percent and launches cueloop", () => {
+    const stub = makeStub("split");
+    const handle = openHerdrThreadPane({
+      sessionId: "ses_abc",
+      cwd: "/repo/work",
+      binPath: stub.binPath,
+      sourcePaneId: "w1:p1",
+      tabId: "w1:t1",
+    });
+
+    expect(handle).toEqual({
+      mode: "pane",
+      tabId: "w1:t1",
+      paneId: "w1:p3",
+    });
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.5 --cwd /repo/work --focus",
+      "pane send-text w1:p3 cueloop ses_abc",
+      "pane send-keys w1:p3 enter",
+    ]);
+  });
+
+  test("closes a pane if the Thread command cannot be entered", () => {
+    const stub = makeStub("pane-enter-failed", false, "w1:p1", "send-keys");
+
+    expect(
+      openHerdrThreadPane({
+        sessionId: "ses_abc",
+        cwd: "/repo/work",
+        binPath: stub.binPath,
+        sourcePaneId: "w1:p1",
+        tabId: "w1:t1",
+      }),
+    ).toBeNull();
+    expect(readLines(stub.logPath)).toEqual([
+      "pane split w1:p1 --direction right --ratio 0.5 --cwd /repo/work --focus",
+      "pane send-text w1:p3 cueloop ses_abc",
+      "pane send-keys w1:p3 enter",
+      "pane close w1:p3",
+    ]);
+  });
+});
+
+describe("openHerdrThreadSurface", () => {
+  test("tab mode targets the calling Herdr workspace", async () => {
+    const stub = makeStub("workspace");
+    const store = fakePersistence();
+    const env = {
+      HERDR_ENV: "1",
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_WORKSPACE_ID: "w1",
+      HERDR_BIN_PATH: stub.binPath,
+    };
+
+    expect(await openHerdrThreadSurface(newSession(), store.persistence, env, "tab")).toBe(
+      "opened",
+    );
+    expect(readLines(stub.logPath)[0]).toBe(
+      "tab create --workspace w1 --cwd /repo/work --label Rollout Plan --focus",
+    );
+  });
+
+  test("pane mode focuses a live remembered pane and reopens a closed one", async () => {
+    const stub = makeStub("pane-reopen", false);
+    const env = {
+      HERDR_ENV: "1",
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_TAB_ID: "w1:t1",
+      HERDR_BIN_PATH: stub.binPath,
+    };
+    const store = fakePersistence({
+      mode: "pane",
+      tabId: "w1:t1",
+      paneId: "w1:p9",
+    });
+
+    expect(await openHerdrThreadSurface(newSession(), store.persistence, env, "pane")).toBe(
+      "opened",
+    );
+    expect(readLines(stub.logPath)).toContain("pane get w1:p9");
+    expect(store.saved()).toEqual({
+      mode: "pane",
+      tabId: "w1:t1",
+      paneId: "w1:p3",
+    });
+
+    const live = makeStub("pane-focus", true);
+    const liveEnv = { ...env, HERDR_BIN_PATH: live.binPath };
+
+    expect(await openHerdrThreadSurface(newSession(), store.persistence, liveEnv, "pane")).toBe(
+      "focused",
+    );
+    expect(readLines(live.logPath)).toEqual([
+      "pane get w1:p3",
+      "tab focus w1:t1",
+      "pane neighbor --pane w1:p3 --direction left",
+      "pane neighbor --pane w1:p1 --direction right",
+      "pane focus --pane w1:p1 --direction right",
+    ]);
+  });
+
+  test("a moved live pane focuses through its new neighbor without opening a duplicate", async () => {
+    const stub = makeStub("pane-moved", true, "w1:p4");
+    const store = fakePersistence({
+      mode: "pane",
+      tabId: "w1:t1",
+      paneId: "w1:p3",
+    });
+    const env = {
+      HERDR_ENV: "1",
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_TAB_ID: "w1:t1",
+      HERDR_BIN_PATH: stub.binPath,
+    };
+
+    expect(await openHerdrThreadSurface(newSession(), store.persistence, env, "pane")).toBe(
+      "focused",
+    );
+    expect(readLines(stub.logPath)).toEqual([
+      "pane get w1:p3",
+      "tab focus w1:t1",
+      "pane neighbor --pane w1:p3 --direction left",
+      "pane neighbor --pane w1:p4 --direction right",
+      "pane focus --pane w1:p4 --direction right",
+    ]);
+  });
+
+  test("none never launches, and a launch failure reports failure without resolving the Thread", async () => {
+    const stub = makeStub("disabled");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence();
+
+    expect(await openHerdrThreadSurface(newSession(), store.persistence, env, "none")).toBe(
+      "disabled",
+    );
+    expect(readLines(stub.logPath)).toEqual([]);
+    expect(
+      await openHerdrThreadSurface(
+        newSession(),
+        store.persistence,
+        { ...env, HERDR_BIN_PATH: join(dir, "missing-binary") },
+        "tab",
+      ),
+    ).toBe("failed");
+    expect(store.saved()).toBeNull();
+  });
+  test("opens and records a tab for a review with no recorded tab", async () => {
+    const stub = makeStub("gated-new");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence(null);
+
+    await openHerdrThreadSurface(newSession({ id: "ses_xyz" }), store.persistence, env);
+
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_xyz",
+      "pane send-keys w1:p2 enter",
+    ]);
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+  });
+
+  test("no-op outside herdr - no herdr process is spawned", async () => {
+    const stub = makeStub("gated-outside");
+    const store = fakePersistence(null);
+
+    await openHerdrThreadSurface(newSession(), store.persistence, {
+      HERDR_PANE_ID: "w1:p1",
+      HERDR_BIN_PATH: stub.binPath,
+    });
+
+    expect(existsSync(stub.logPath)).toBeFalse();
+    expect(store.saved()).toBeNull();
+  });
+
+  test("focuses the recorded tab when its pane is still alive, without reopening", async () => {
+    const stub = makeStub("gated-alive", true);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence({ tabId: "w9:t9", paneId: "w9:p9" });
+
+    await openHerdrThreadSurface(newSession(), store.persistence, env);
+
+    const lines = readLines(stub.logPath);
+
+    expect(lines).toContain("pane get w9:p9");
+    expect(lines).toContain("tab focus w9:t9");
+    expect(lines.some((line) => line.startsWith("tab create"))).toBeFalse();
+    expect(store.saved()).toEqual({ tabId: "w9:t9", paneId: "w9:p9" });
+  });
+
+  test("a persistence failure never escapes - review creation stays best-effort", async () => {
+    const stub = makeStub("gated-persist-fail");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const persistence: HerdrThreadSurfacePersistence = {
+      herdrGetThreadSurface: async () => null,
+      herdrSetThreadSurface: async () => {
+        throw new Error("disk full");
+      },
+    };
+
+    await openHerdrThreadSurface(newSession(), persistence, env);
+    expect(readLines(stub.logPath).some((line) => line.startsWith("tab create"))).toBeTrue();
+  });
+
+  test("a recall failure (stale daemon) still opens a fresh tab", async () => {
+    const stub = makeStub("gated-recall-fail");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const persistence: HerdrThreadSurfacePersistence = {
+      herdrGetThreadSurface: async () => {
+        throw new Error("unknown method herdr.getThreadSurface");
+      },
+      herdrSetThreadSurface: async () => {},
+    };
+
+    await openHerdrThreadSurface(newSession({ id: "ses_stale" }), persistence, env);
+
+    expect(readLines(stub.logPath)).toEqual([
+      "tab create --cwd /repo/work --label Rollout Plan --focus",
+      "pane send-text w1:p2 cueloop ses_stale",
+      "pane send-keys w1:p2 enter",
+    ]);
+  });
+
+  test("reopens and re-records when the recorded pane is dead", async () => {
+    const stub = makeStub("gated-dead", false);
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const store = fakePersistence({ tabId: "old:t", paneId: "old:p" });
+
+    await openHerdrThreadSurface(newSession({ id: "ses_re" }), store.persistence, env);
+
+    const lines = readLines(stub.logPath);
+
+    expect(lines).toContain("pane get old:p");
+    expect(lines).toContain("tab create --cwd /repo/work --label Rollout Plan --focus");
+    expect(store.saved()).toEqual({ tabId: "w1:t2", paneId: "w1:p2" });
+  });
+});
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+});