@cueloop/client 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/App.test.tsx

@@ -1,8 +1,4 @@
-/**
- * Virtual-terminal component tests (tier 2): the real App over a real
- * in-process daemon in a temp home. Char-frame assertions + mock keys -
- * the whole review loop drivable without a terminal.
- */
+/** Virtual-terminal component tests (tier 2): the real App over a real in-process daemon in a temp home. Char-frame assertions + mock keys - the whole review loop drivable without a terminal. */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
@@ -13,6 +9,13 @@ import { testRender } from "@opentui/react/test-utils";
 import { DaemonServer } from "@cueloop/daemon";
 import type { ReviewSession } from "@cueloop/schema";
 import { App } from "./App";
+import {
+  isolateUserConfig,
+  press,
+  typeText as type,
+  waitForState,
+  waitForText,
+} from "./test-support";
 
 const PLAN = `# Migration Plan
 
@@ -27,19 +30,26 @@ The daemon persists sessions to disk atomically.
 `;
 
 let home: string;
+let restoreUserConfig: () => void;
 let server: DaemonServer;
 let session: ReviewSession;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-app-"));
+  restoreUserConfig = isolateUserConfig(home);
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
     workspace: { repoRoot: "/repo", branch: "main" },
-    artifact: { type: "plan", content: PLAN, meta: { title: "Migration Plan", planPath: "plan.md" } },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
   });
 });
 afterEach(() => {
+  restoreUserConfig();
   server.stop();
   rmSync(home, { recursive: true, force: true });
 });
@@ -49,78 +59,72 @@ async function renderApp(sessionId?: string) {
     width: 120,
     height: 32,
   });
-  // let the async daemon connect + first fetch land
-  for (let i = 0; i < 40 && !setup.captureCharFrame().includes("cueloop"); i++) {
-    await Bun.sleep(25);
-    await setup.renderOnce();
-  }
-  await setup.renderOnce();
+  // the async daemon connect + first fetch land within the frame wait
+  await waitForText(setup, "cueloop");
   return setup;
 }
 
-type Setup = Awaited<ReturnType<typeof renderApp>>;
-
-/** Drive one key press: letters type as text; named keys use KeyCodes ids. */
-async function press(setup: Setup, k: string): Promise<void> {
-  if (k === "enter") setup.mockInput.pressKey("RETURN");
-  else if (k === "escape") setup.mockInput.pressKey("ESCAPE");
-  else if (k === "backspace") setup.mockInput.pressKey("BACKSPACE");
-  else if (k === "left") setup.mockInput.pressKey("ARROW_LEFT");
-  else if (k === "right") setup.mockInput.pressKey("ARROW_RIGHT");
-  else await type(setup, k);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
-
-async function type(setup: Setup, text: string): Promise<void> {
-  await setup.mockInput.typeText(text);
-  await Bun.sleep(15);
-  await setup.renderOnce();
-}
-
 describe("plan rendering", () => {
   test("renders the plan with headings, list markers, and the rail", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Assert
     const frame = setup.captureCharFrame();
     expect(frame).toContain("Migration Plan");
     expect(frame).toContain("Context");
     expect(frame).toContain("persists sessions to disk atomically");
     expect(frame).toContain("- move the store");
-    expect(frame).toContain("REVIEW (0)");
-    expect(frame).toContain("Submit review (0)");
+    expect(frame).toContain("Review");
+    expect(frame).toContain("Submit review");
   });
 });
 
 describe("keyboard grammar", () => {
   test("j/k moves the cursor glyph between blocks", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await setup.renderOnce();
+
+    // Assert
     const lines = setup.captureCharFrame().split("\n");
-    const cursorLine = lines.find((l) => l.includes("▎"))!;
+    const cursorLine = lines.find((line) => line.includes("▎"))!;
     expect(cursorLine).toContain("persists sessions");
   });
 
   test("comment flow: c types a body, ⏎ saves to the daemon", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "c");
     await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("COMMENT ON");
+
+    // Assert
+    await waitForText(setup, 'comment on "The daemon');
+
+    // Act
     await type(setup, "Define atomically.");
     await press(setup, "enter");
-    await Bun.sleep(80);
-    await setup.renderOnce();
+
+    // Assert
+    await waitForText(setup, "COMMENT");
     const stored = server.core.sessionGet(session.id);
     expect(stored.annotations.length).toBe(1);
     expect(stored.annotations[0]!.body).toBe("Define atomically.");
-    expect(setup.captureCharFrame()).toContain("COMMENT");
   });
 
   test("span mode: v + l selects words, c anchors the exact span", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "v");
@@ -128,24 +132,31 @@ describe("keyboard grammar", () => {
     await press(setup, "c");
     await type(setup, "Which daemon?");
     await press(setup, "enter");
-    await Bun.sleep(80);
+
+    // Assert
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
     const stored = server.core.sessionGet(session.id);
     expect(stored.annotations[0]!.anchor.quote).toBe("The daemon");
   });
 
   test("x cuts a block into the working copy; x restores it", async () => {
+    // Arrange
     const setup = await renderApp();
     // move to "- move the store" (h1, h2, p, h2 = 4 steps in)
     for (let i = 0; i < 4; i++) await press(setup, "j");
+
+    // Act
     await press(setup, "x");
-    await Bun.sleep(80);
-    await setup.renderOnce();
+
+    // Assert - the rail shows the cut as a removal card titled CUT · me
+    await waitForText(setup, "CUT · me");
     expect(server.core.sessionGet(session.id).workingCopy).not.toContain("move the store");
-    expect(setup.captureCharFrame()).toContain("[cut]");
+
+    // Act
     await press(setup, "x");
-    await Bun.sleep(80);
-    await setup.renderOnce();
-    expect(server.core.sessionGet(session.id).workingCopy).toBeUndefined();
+
+    // Assert
+    await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy === undefined);
   });
 
   test("e runs $EDITOR on the working copy and tracks the diff", async () => {
@@ -154,12 +165,15 @@ describe("keyboard grammar", () => {
     Bun.spawnSync(["chmod", "+x", script]);
     process.env.CUELOOP_EDITOR = script;
     try {
+      // Arrange
       const setup = await renderApp();
+
+      // Act
       await press(setup, "e");
-      await Bun.sleep(150);
-      await setup.renderOnce();
+
+      // Assert
+      await waitForText(setup, "[edited]");
       expect(server.core.sessionGet(session.id).workingCopy).toContain("very atomically");
-      expect(setup.captureCharFrame()).toContain("[edited]");
     } finally {
       delete process.env.CUELOOP_EDITOR;
     }
@@ -167,51 +181,96 @@ describe("keyboard grammar", () => {
 });
 
 describe("submit", () => {
-  test("⏎ opens the verdict bar; verdict + summary resolve the session", async () => {
+  test("⏎ opens the rail confirm card; verdict + summary resolve the session", async () => {
+    // Arrange
     const setup = await renderApp();
     await press(setup, "j");
     await press(setup, "j");
     await press(setup, "c");
     await type(setup, "Needs a phase list.");
     await press(setup, "enter");
-    await Bun.sleep(80);
+    await waitForText(setup, "Needs a phase list");
+
+    // Act
     await press(setup, "enter"); // open submit
-    await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("[Request changes]");
+
+    // Assert
+    await waitForText(setup, "[Changes]");
+
+    // Act
     await type(setup, "Expand the steps.");
     await press(setup, "enter");
-    await Bun.sleep(120);
-    await setup.renderOnce();
+
+    // Assert
+    await waitForText(setup, "feedback sent");
     const stored = server.core.sessionGet(session.id);
     expect(stored.status).toBe("resolved");
     expect(stored.verdict!.kind).toBe("request_changes");
     expect(stored.verdict!.feedback).toContain("Needs a phase list.");
-    expect(setup.captureCharFrame()).toContain("resolved: request changes");
+    // submit hands the reviewer back to the agent via the completion overlay
+    expect(setup.captureCharFrame()).toContain("feedback sent");
   });
 
   test("approve via ←/→ verdict cycling", async () => {
+    // Arrange
     const setup = await renderApp();
+
+    // Act
     await press(setup, "enter");
-    await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("[Approve]"); // no pending items → approve default
+
+    // Assert
+    await waitForText(setup, "[Approve]"); // no pending items → approve default
+
+    // Act
     await press(setup, "enter");
-    await Bun.sleep(120);
+
+    // Assert
+    await waitForState(setup, () => server.core.sessionGet(session.id).verdict !== undefined);
     expect(server.core.sessionGet(session.id).verdict!.kind).toBe("approve");
   });
 });
 
 describe("inbox", () => {
-  test("inbox mode renders and opens a session", async () => {
+  test("inbox mode wears the review chrome (header + menu bar) and opens a session", async () => {
+    // Arrange
     const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
-    for (let i = 0; i < 40 && !setup.captureCharFrame().includes("inbox"); i++) {
-      await Bun.sleep(25);
-      await setup.renderOnce();
-    }
-    expect(setup.captureCharFrame()).toContain("inbox (1 pending)");
-    expect(setup.captureCharFrame()).toContain("Migration Plan");
+    await waitForText(setup, "cueloop");
+
+    // Assert - the same header/menu chrome as review, plus the session row
+    const frame = setup.captureCharFrame();
+    expect(frame).toContain("cueloop · resume");
+    expect(frame).toContain("Migration Plan");
+    expect(frame).toContain("menu"); // the shared MenuBar sits at the bottom
+    expect(frame).not.toContain("inbox ("); // the old inline header is gone
+
+    // Act
     await press(setup, "enter");
-    await Bun.sleep(80);
-    await setup.renderOnce();
-    expect(setup.captureCharFrame()).toContain("Submit review (0)");
+
+    // Assert
+    await waitForText(setup, "Submit review");
+  });
+
+  test("the menu opens from the inbox and escape is not a trap", async () => {
+    // Arrange
+    const setup = await testRender(<App home={home} />, { width: 120, height: 32 });
+    await waitForText(setup, "cueloop · resume");
+    const lines = setup.captureCharFrame().split("\n");
+    const menuRow = lines.findIndex((line) => line.includes("menu"));
+    const menuColumn = lines[menuRow]!.indexOf("menu");
+
+    // Act - open the drop-up from the shared menu bar
+    await setup.mockMouse.click(menuColumn + 1, menuRow);
+
+    // Assert - the drop-up options appear
+    await waitForText(setup, "Keybinds");
+    expect(setup.captureCharFrame()).toContain("Settings");
+
+    // Act - escape closes the menu (not a trap), and the inbox nav still works
+    await press(setup, "escape");
+    await waitForState(setup, () => !setup.captureCharFrame().includes("Keybinds"));
+    await press(setup, "enter");
+
+    // Assert
+    await waitForText(setup, "Submit review");
   });
 });

package/src/App.toast.test.tsx

@@ -0,0 +1,75 @@
+/** The share toast is non-modal: while it is up, escape still cancels an open overlay. */
+
+import { afterEach, beforeEach, describe, mock, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { ReviewSession } from "@cueloop/schema";
+
+// the controller reaches the gateway through "./share"; stub it so `S` yields a toast
+const publishShare = mock(async () => ({ line: "ssh p_share01@cueloop.dev", copied: true }));
+mock.module("./share", () => ({
+  publishShare,
+  pullShare: mock(async () => null),
+  pushShare: mock(async () => {}),
+  shareIdFromLine: (line: string) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: () => [],
+}));
+
+const { App } = await import("./App");
+const { isolateUserConfig, press, waitForText, waitForTextGone } = await import("./test-support");
+
+const PLAN = `# Migration Plan\n\n## Context\n\nThe daemon persists sessions to disk atomically.\n`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: ReviewSession;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-toast-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("share toast", () => {
+  test("escape cancels an open composer even while the toast is up", async () => {
+    // Arrange
+    const setup = await testRender(<App home={home} sessionId={session.id} />, {
+      width: 120,
+      height: 32,
+    });
+    await waitForText(setup, "cueloop");
+
+    // Act: share raises the toast, then open a composer under it
+    await press(setup, "S");
+    await waitForText(setup, "share link copied");
+    await press(setup, "j");
+    await press(setup, "j");
+    await press(setup, "c");
+    await waitForText(setup, 'comment on "');
+
+    // Act: escape must reach the composer, not get eaten by the toast
+    await press(setup, "escape");
+
+    // Assert: the composer closed on the first escape
+    await waitForTextGone(setup, 'comment on "');
+  });
+});