@cueloop/daemon 0.1.0-alpha.20 → 0.1.0-alpha.21

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.21",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
     "./client": "./src/client.ts",
-    "./review": "./src/review.ts"
+    "./review": "./src/review.ts",
+    "./herdr-pane": "./src/herdr-pane.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.20",
+    "@cueloop/schema": "0.1.0-alpha.21",
     "valibot": "^1.4.2"
   },
   "publishConfig": {

package/src/herdr-pane.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Creation-side herdr pane opener tests. The herdr binary is stubbed by a
+ * script that both records its argv to a log file and, for `tab create`,
+ * prints the JSON the helper reads to learn the new pane id. The gating
+ * wrapper is exercised for its three outcomes: no-op outside herdr, no-op for
+ * a revision (the open pane is reused), and a full open for a genuinely new
+ * session.
+ */
+
+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 { ReviewSession } from "@cueloop/schema";
+import { openHerdrPane, openHerdrPaneForReview } from "./herdr-pane";
+
+const dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-pane-"));
+
+/**
+ * A stub herdr binary. It appends its argv to logPath and, when the verb is
+ * `tab create`, prints a JSON result carrying paneId on stdout so the helper
+ * can drive send-text and send-keys.
+ */
+function makeStub(name: string, paneId = "w1:p2"): { binPath: string; logPath: string } {
+  const logPath = join(dir, `${name}.log`);
+  const binPath = join(dir, `${name}.sh`);
+  writeFileSync(
+    binPath,
+    `#!/bin/sh\nprintf '%s\\n' "$*" >> "${logPath}"\nif [ "$1" = "tab" ] && [ "$2" = "create" ]; then\n  printf '{"result":{"pane":{"id":"${paneId}"}}}'\nfi\n`,
+  );
+  chmodSync(binPath, 0o755);
+  return { binPath, logPath };
+}
+
+function readLines(logPath: string): string[] {
+  if (!existsSync(logPath)) return [];
+  return readFileSync(logPath, "utf8").split("\n").filter(Boolean);
+}
+
+function newSession(overrides: Partial<ReviewSession> = {}): ReviewSession {
+  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: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "now",
+    ...overrides,
+  };
+}
+
+describe("openHerdrPane", () => {
+  test("creates a focused tab, types the cueloop command, and presses enter", () => {
+    const stub = makeStub("open");
+    const ok = openHerdrPane({ sessionId: "ses_abc", cwd: "/repo/work", binPath: stub.binPath, label: "Rollout Plan" });
+    expect(ok).toBeTrue();
+    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 false and never throws on a broken binary", () => {
+    const ok = openHerdrPane({
+      sessionId: "ses_abc",
+      cwd: "/repo/work",
+      binPath: join(dir, "missing-bin"),
+      label: "x",
+    });
+    expect(ok).toBeFalse();
+  });
+
+  test("bails out when tab create yields no pane id - 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 ok = openHerdrPane({ sessionId: "ses_abc", cwd: "/repo/work", binPath, label: "x" });
+    expect(ok).toBeFalse();
+    expect(readLines(logPath)).toEqual(["tab create --cwd /repo/work --label x --focus"]);
+  });
+});
+
+describe("openHerdrPaneForReview", () => {
+  test("opens a pane for a genuinely new session inside herdr", () => {
+    const stub = makeStub("gated-new");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    openHerdrPaneForReview(newSession({ id: "ses_xyz" }), 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",
+    ]);
+  });
+
+  test("no-op outside herdr - no herdr process is spawned", () => {
+    const stub = makeStub("gated-outside");
+    openHerdrPaneForReview(newSession(), { HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath });
+    expect(existsSync(stub.logPath)).toBeFalse();
+  });
+
+  test("no-op for a revision - the already open pane is reused, not spammed", () => {
+    const stub = makeStub("gated-revision");
+    const env = { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1", HERDR_BIN_PATH: stub.binPath };
+    const revised = newSession({
+      revisions: [
+        { revision: 1, content: "# P", submittedAt: "now" },
+        { revision: 2, content: "# P2", submittedAt: "now" },
+      ],
+    });
+    openHerdrPaneForReview(revised, env);
+    expect(existsSync(stub.logPath)).toBeFalse();
+  });
+});
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+});

package/src/herdr-pane.ts

@@ -0,0 +1,94 @@
+/**
+ * Creation-side herdr pane opener: when a review is created from inside a
+ * herdr pane, cueloop opens a NEW herdr tab that renders the review, so the
+ * creator does not have to run a command by hand. This is the counterpart to
+ * the reviewer-side focusHerdrPane in @cueloop/client. It lives here, beside
+ * the shared review core (openReview), because both creation sites - the
+ * Claude Code hook and the `cueloop session create` CLI - already depend on
+ * this package and drive creation through it, so a single home reaches both
+ * with no new cross-package dependency.
+ *
+ * A fresh tab hosts a plain shell with no command argument, so the review is
+ * launched exactly as a human would: type `cueloop <sessionId>` into the new
+ * pane and press enter. The herdr CLI is spawned synchronously because the
+ * send-text and send-keys steps need the pane id that `tab create` returns.
+ *
+ * Best-effort like the rest of the herdr tier: a missing or broken binary, an
+ * unexpected JSON shape, or any spawn failure is swallowed and never blocks
+ * review creation. Each spawn is bounded by HERDR_SPAWN_TIMEOUT_MS so a hung
+ * herdr binary cannot stall the review-creation path - a timeout kills the
+ * child and reads as a non-zero exit, i.e. a best-effort bail-out.
+ */
+
+import { detectHerdr, type HerdrEnv, type ReviewSession } from "@cueloop/schema";
+
+/** Upper bound per herdr spawn, so a stuck binary can never block creation. */
+const HERDR_SPAWN_TIMEOUT_MS = 2000;
+
+export interface OpenHerdrPaneOptions {
+  /** The review session id; `cueloop <sessionId>` opens it in the new pane. */
+  sessionId: string;
+  /** Working directory for the new tab; the review's cwd. */
+  cwd: string;
+  /** Absolute path to the herdr binary, from the ambient env contract. */
+  binPath: string;
+  /** Sidebar label for the new tab. */
+  label: string;
+}
+
+/**
+ * Open a herdr tab that renders the review. `tab create` prints a JSON result
+ * shaped like `{ result: { pane: { id } } }` - the same `result.pane` nesting
+ * focusHerdrPane reads - and the pane id drives the two follow-up steps.
+ * Returns true when the full open-and-launch sequence completed, false on any
+ * best-effort bail-out.
+ */
+export function openHerdrPane(options: OpenHerdrPaneOptions): boolean {
+  const { sessionId, cwd, binPath, label } = options;
+  try {
+    const created = Bun.spawnSync([binPath, "tab", "create", "--cwd", cwd, "--label", label, "--focus"], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+    if (created.exitCode !== 0) return false;
+    const parsed = JSON.parse(created.stdout.toString()) as { result?: { pane?: { id?: string } } };
+    const paneId = parsed.result?.pane?.id;
+    if (!paneId) return false;
+    // A fresh tab hosts a plain shell, so the review is typed in like a human.
+    const typed = Bun.spawnSync([binPath, "pane", "send-text", paneId, `cueloop ${sessionId}`], {
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: HERDR_SPAWN_TIMEOUT_MS,
+    });
+    if (typed.exitCode !== 0) return false;
+    return (
+      Bun.spawnSync([binPath, "pane", "send-keys", paneId, "enter"], {
+        stdout: "ignore",
+        stderr: "ignore",
+        timeout: HERDR_SPAWN_TIMEOUT_MS,
+      }).exitCode === 0
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Open a pane for a freshly created review, guarded for the one case that
+ * wants it: inside herdr and genuinely new. A revision reuses the pane the
+ * original review already opened, so a resubmit (revisions beyond the first)
+ * never spawns another tab. A no-op outside herdr keeps a plain terminal
+ * byte-identical.
+ */
+export function openHerdrPaneForReview(session: ReviewSession, env: HerdrEnv = process.env): void {
+  const herdr = detectHerdr(env);
+  if (!herdr) return;
+  if (session.revisions.length !== 1) return;
+  openHerdrPane({
+    sessionId: session.id,
+    cwd: session.artifact.meta.cwd ?? process.cwd(),
+    binPath: herdr.binPath,
+    label: session.artifact.meta.title ?? session.id,
+  });
+}