@cueloop/client 0.1.0-alpha.63 → 0.1.0-alpha.65

package/src/session-controller.share.test.ts

@@ -1,10 +1,15 @@
-import { describe, expect, mock, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
 import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
+import {
+  createReviewController,
+  SHARE_RECONNECT_MAX_MS,
+  SHARE_RECONNECT_MIN_MS,
+  type ShareTransport,
+} from "./session-controller";
+import { mergeFromShare, type ShareWatchHandlers } from "./share";
 
-// Stub the ssh transport so no subprocess spawns; the controller under test
-// imports these from "./share".
 const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
 let remote: ReviewSession;
 const pullShare = mock(async () => remote);
@@ -12,16 +17,15 @@ const pushShare = mock(
   async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
 );
 
-mock.module("./share", () => ({
-  publishShare,
-  pullShare,
-  pushShare,
-  shareIdFromLine: (line: string) => line.match(/^ssh (\S+)@/)?.[1],
-  collaboratorAnnotations: (session: ReviewSession) =>
-    session.annotations.filter((annotation) => annotation.author),
-}));
-
-const { createReviewController, SHARE_POLL_MS } = await import("./session-controller");
+const shareTransport: ShareTransport = {
+  publish: publishShare,
+  pull: pullShare,
+  push: pushShare,
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
 
 function sessionFixture(overrides: Partial<ReviewSession> = {}): ReviewSession {
   return {
@@ -49,13 +53,31 @@ function annotation(id: string, author: string): Annotation {
   };
 }
 
-function fakeClient(session: ReviewSession): SessionClient {
+interface FakeSessionClient extends SessionClient {
+  sessionAnnotate: Mock<SessionClient["sessionAnnotate"]>;
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+function fakeClient(session: ReviewSession): FakeSessionClient {
   return {
     onEvent: () => () => {},
     subscribe: async () => {},
     sessionGet: async () => session,
     sessionList: async () => [session],
-    sessionAnnotate: mock(async () => session),
+    sessionAnnotate: mock<SessionClient["sessionAnnotate"]>(async () => session),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionCurate: unimplemented("sessionCurate"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetShareId: mock(
       async (_id: string, shareId: string) => ((session.shareId = shareId), session),
     ),
@@ -67,8 +89,11 @@ function fakeClient(session: ReviewSession): SessionClient {
 
       return session;
     }),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
     close: () => {},
-  } as unknown as SessionClient;
+  };
 }
 
 const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
@@ -76,12 +101,14 @@ const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 async function connectedController(
   session: ReviewSession,
   clock?: ManualClock,
-): Promise<{ controller: ReturnType<typeof createReviewController>; client: SessionClient }> {
+  transport: ShareTransport = shareTransport,
+): Promise<{ controller: ReturnType<typeof createReviewController>; client: FakeSessionClient }> {
   const client = fakeClient(session);
   const controller = createReviewController({
     sessionId: session.id,
     openClient: async () => client,
     clock,
+    shareTransport: transport,
   });
 
   controller.connect();
@@ -205,7 +232,7 @@ describe("mirror on annotate", () => {
       sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:me")] }),
     );
 
-    (client.sessionAnnotate as ReturnType<typeof mock>).mockImplementationOnce(async () => {
+    client.sessionAnnotate.mockImplementationOnce(async () => {
       throw new Error("session is resolved");
     });
 
@@ -218,103 +245,226 @@ describe("mirror on annotate", () => {
   });
 });
 
-describe("startSharePoll", () => {
-  test("pulls now and again each interval until stopped", async () => {
+describe("reply", () => {
+  test("a reply shares the root's anchor, names it in replyTo, and mirrors up", async () => {
     // Arrange
-    pullShare.mockClear();
-    remote = sessionFixture({ annotations: [] });
-    const clock = new ManualClock();
-    const { controller } = await connectedController(
-      sessionFixture({ shareId: "p_abc123xy" }),
-      clock,
+    pushShare.mockClear();
+    const { controller, client } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy", annotations: [annotation("a1", "SHA256:ana")] }),
     );
 
-    // Act - immediate pull
-    const stop = controller.startSharePoll();
-
+    // Act
+    const id = controller.reply("a1", "agreed");
     await tick();
 
     // Assert
-    expect(pullShare).toHaveBeenCalledTimes(1);
+    const wire = client.sessionAnnotate.mock.calls.at(-1)![1];
+
+    expect(wire).toEqual({
+      id: id!,
+      kind: "comment",
+      anchor: { quote: "Plan", prefix: "", suffix: "" },
+      body: "agreed",
+      replyTo: "a1",
+    });
+    expect(pushShare.mock.calls[0]?.[1]).toEqual([wire]);
+  });
 
-    // Act - one interval later, it pulls again
-    clock.advance(SHARE_POLL_MS);
+  test("editing a reply keeps its reply link", async () => {
+    // Arrange
+    const { controller, client } = await connectedController(
+      sessionFixture({
+        annotations: [
+          annotation("a1", "SHA256:ana"),
+          { ...annotation("a2", "SHA256:me"), replyTo: "a1" },
+        ],
+      }),
+    );
+
+    // Act
+    controller.updateAnnotation("a2", "revised reply");
     await tick();
 
     // Assert
-    expect(pullShare).toHaveBeenCalledTimes(2);
+    expect(client.sessionAnnotate.mock.calls.at(-1)?.[1]).toMatchObject({
+      id: "a2",
+      body: "revised reply",
+      replyTo: "a1",
+    });
+  });
 
-    // Act - stop, then advance: no further pulls
-    stop();
-    clock.advance(SHARE_POLL_MS * 3);
+  test("a reply to a reply hangs off the discussion's root comment", async () => {
+    // Arrange
+    const { controller, client } = await connectedController(
+      sessionFixture({
+        annotations: [
+          annotation("a1", "SHA256:ana"),
+          { ...annotation("a2", "SHA256:bob"), replyTo: "a1" },
+        ],
+      }),
+    );
+
+    // Act
+    controller.reply("a2", "same thread");
     await tick();
 
     // Assert
-    expect(pullShare).toHaveBeenCalledTimes(2);
+    expect(client.sessionAnnotate.mock.calls.at(-1)?.[1]).toMatchObject({ replyTo: "a1" });
+  });
+
+  test("replying to an unknown annotation does nothing", async () => {
+    // Arrange
+    const { controller, client } = await connectedController(sessionFixture());
+
+    // Act + Assert
+    expect(controller.reply("missing", "x")).toBeUndefined();
+    expect(client.sessionAnnotate).not.toHaveBeenCalled();
+  });
+});
+
+describe("startShareSync", () => {
+  /** A fake watch stream: records handlers so a test can push a session or drop the link. */
+  const streams: Array<{ shareId: string; handlers: ShareWatchHandlers; stopped: boolean }> = [];
+  const watchShare = mock((shareId: string, handlers: ShareWatchHandlers) => {
+    const stream = { shareId, handlers, stopped: false };
+
+    streams.push(stream);
+
+    return () => {
+      stream.stopped = true;
+    };
   });
+  const liveTransport: ShareTransport = { ...shareTransport, watch: watchShare };
 
-  test("a stop during an in-flight pull leaves no zombie timer", async () => {
-    // Arrange - the first pull hangs until released
+  beforeEach(() => {
+    streams.length = 0;
+    watchShare.mockClear();
     pullShare.mockClear();
     remote = sessionFixture({ annotations: [] });
-    let release: () => void = () => {};
+  });
+
+  test("connect pulls once to catch up, then follows the stream and merges each session it delivers", async () => {
+    // Arrange
+    const clock = new ManualClock();
+    const { controller, client } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+      clock,
+      liveTransport,
+    );
+
+    // Act
+    controller.startShareSync();
+    await tick();
 
-    pullShare.mockImplementationOnce(
-      () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
+    // Assert - one catch-up pull, one open stream on the share
+    expect(pullShare).toHaveBeenCalledTimes(1);
+    expect(streams).toHaveLength(1);
+    expect(streams[0]!.shareId).toBe("p_abc123xy");
+
+    // Act - the gateway pushes a change carrying Ana's note
+    streams[0]!.handlers.onSession(
+      sessionFixture({ annotations: [annotation("a9", "SHA256:ana")] }),
+    );
+    await tick();
+
+    // Assert - merged without another pull
+    expect(client.sessionMergeShared).toHaveBeenLastCalledWith(
+      "ses_1",
+      expect.objectContaining({
+        annotations: [expect.objectContaining({ id: "a9", author: "SHA256:ana" })],
+      }),
     );
+    expect(pullShare).toHaveBeenCalledTimes(1);
+  });
+
+  test("a dropped stream reconnects with doubling backoff and catches up on each connect", async () => {
+    // Arrange
     const clock = new ManualClock();
     const { controller } = await connectedController(
       sessionFixture({ shareId: "p_abc123xy" }),
       clock,
+      liveTransport,
     );
 
-    // Act - start (pull is in flight), leave, then let the pull settle
-    const stop = controller.startSharePoll();
+    controller.startShareSync();
+    await tick();
 
+    // Act - the link drops: nothing until the floor delay has passed
+    streams[0]!.handlers.onClose("ssh exited 255");
+    clock.advance(SHARE_RECONNECT_MIN_MS - 1);
     await tick();
-    expect(pullShare).toHaveBeenCalledTimes(1);
-    stop();
-    release();
+    expect(streams).toHaveLength(1);
+    clock.advance(1);
     await tick();
-    clock.advance(SHARE_POLL_MS * 3);
+
+    // Assert - reconnected, with a fresh catch-up pull
+    expect(streams).toHaveLength(2);
+    expect(pullShare).toHaveBeenCalledTimes(2);
+
+    // Act - drops again: the wait doubles
+    streams[1]!.handlers.onClose("ssh exited 255");
+    clock.advance(SHARE_RECONNECT_MIN_MS);
     await tick();
+    expect(streams).toHaveLength(2);
+    clock.advance(SHARE_RECONNECT_MIN_MS);
+    await tick();
+    expect(streams).toHaveLength(3);
 
-    // Assert - the settled pull's finally must not re-arm the timer
-    expect(pullShare).toHaveBeenCalledTimes(1);
-  });
+    // Act - a delivered session resets the backoff to the floor
+    streams[2]!.handlers.onSession(remote);
+    streams[2]!.handlers.onClose("ssh exited 255");
+    clock.advance(SHARE_RECONNECT_MIN_MS);
+    await tick();
 
-  test("a restart during an in-flight pull does not double the poll", async () => {
-    // Arrange - run A's first pull hangs; later pulls resolve immediately
-    pullShare.mockClear();
-    remote = sessionFixture({ annotations: [] });
-    let release: () => void = () => {};
+    // Assert
+    expect(streams).toHaveLength(4);
+  });
 
-    pullShare.mockImplementationOnce(
-      () => new Promise<ReviewSession>((resolve) => (release = () => resolve(remote))),
-    );
+  test("stop closes the stream and a late close never reconnects", async () => {
+    // Arrange
     const clock = new ManualClock();
     const { controller } = await connectedController(
       sessionFixture({ shareId: "p_abc123xy" }),
       clock,
+      liveTransport,
     );
+    const stop = controller.startShareSync();
 
-    // Act - run A starts (pull hangs), then run B restarts while A is in flight
-    controller.startSharePoll();
     await tick();
-    expect(pullShare).toHaveBeenCalledTimes(1);
-    const stopB = controller.startSharePoll();
 
+    // Act
+    stop();
+    streams[0]!.handlers.onClose("killed");
+    clock.advance(SHARE_RECONNECT_MAX_MS * 2);
     await tick();
-    expect(pullShare).toHaveBeenCalledTimes(2);
 
-    // A's stale pull settles - it must not re-arm; then one interval fires only run B
-    release();
+    // Assert
+    expect(streams[0]!.stopped).toBe(true);
+    expect(streams).toHaveLength(1);
+  });
+
+  test("a restart replaces the stream instead of doubling it", async () => {
+    // Arrange
+    const clock = new ManualClock();
+    const { controller } = await connectedController(
+      sessionFixture({ shareId: "p_abc123xy" }),
+      clock,
+      liveTransport,
+    );
+
+    controller.startShareSync();
+    await tick();
+
+    // Act
+    controller.startShareSync();
     await tick();
-    clock.advance(SHARE_POLL_MS);
+    streams[0]!.handlers.onClose("stale");
+    clock.advance(SHARE_RECONNECT_MAX_MS * 2);
     await tick();
 
-    // Assert - exactly one more pull (run B), not two
-    expect(pullShare).toHaveBeenCalledTimes(3);
-    stopB();
+    // Assert - the first stream was stopped and its close re-armed nothing
+    expect(streams[0]!.stopped).toBe(true);
+    expect(streams).toHaveLength(2);
+    expect(streams[1]!.stopped).toBe(false);
   });
 });

package/src/session-controller.tree.test.ts

@@ -0,0 +1,228 @@
+/**
+ * The controller's tree primitives over a fake client: a move shows its path
+ * before the daemon answers, refusals surface as status, a fork opens the fork,
+ * and fork-and-share shares the fork while the current session stays put.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import {
+  appendEntry,
+  createBranch,
+  historyFromLinear,
+  SCHEMA_VERSION,
+  switchBranch,
+  type Annotation,
+  type ReviewSession,
+} from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController, type ShareTransport } from "./session-controller";
+import { mergeFromShare } from "./share";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+function annotation(id: string, body: string): Annotation {
+  return {
+    id,
+    kind: "comment",
+    anchor: { quote: "Plan", prefix: "", suffix: "" },
+    body,
+    createdAt: AT,
+  };
+}
+
+/** A plan with one comment on main and its history. */
+function sessionFixture(): ReviewSession {
+  const session: ReviewSession = {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
+    annotations: [annotation("a1", "first")],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+
+  session.history = historyFromLinear(session);
+
+  return session;
+}
+
+const publish = mock(async (session: ReviewSession) => ({
+  line: `ssh p_${session.id}@cueloop.dev`,
+  copied: true,
+}));
+const shareTransport: ShareTransport = {
+  publish,
+  pull: mock(async () => sessionFixture()),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+/** Tree requests never resolve here: what the controller shows is its own guess. */
+const pending = () => new Promise<ReviewSession>(() => {});
+
+function fakeClient(session: ReviewSession) {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionCurate: unimplemented("sessionCurate"),
+    sessionNavigate: mock(pending),
+    sessionBranch: mock(pending),
+    sessionSwitch: mock(pending),
+    sessionLabel: mock(pending),
+    sessionFork: mock(async (id: string) => ({
+      ...sessionFixture(),
+      id: `${id}_fork`,
+      parentSessionId: id,
+    })),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetShareId: mock(async (_id: string, _shareId: string) => session),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    close: () => {},
+  } satisfies SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+async function connected(session = sessionFixture()) {
+  const client = fakeClient(session);
+  const controller = createReviewController({
+    sessionId: session.id,
+    openClient: async () => client,
+    shareTransport,
+  });
+
+  controller.connect();
+  await tick();
+
+  return { controller, client, session };
+}
+
+describe("tree primitives", () => {
+  test("a move back shows the earlier path at once and asks the daemon for the same move", async () => {
+    // Arrange
+    const { controller, client, session } = await connected();
+    const revision = session.history!.entries[0]!.id;
+
+    // Act
+    controller.goToEntry(revision, "too soon");
+
+    // Assert: the comment is off the shown path before any answer; the summary travels
+    expect(controller.getSnapshot().session!.annotations).toEqual([]);
+    expect(controller.getSnapshot().session!.shelvedAnnotations?.map((entry) => entry.id)).toEqual([
+      "a1",
+    ]);
+    expect(controller.treeRows().find((row) => row.glyph === "↩")?.isCurrentTip).toBe(true);
+    expect(client.sessionNavigate).toHaveBeenCalledWith("ses_1", revision, "too soon", undefined);
+  });
+
+  test("a move on another branch is one request that names the branch", async () => {
+    // Arrange: alt with its own comment entry; the owner stands on main
+    const session = sessionFixture();
+    let history = createBranch(session.history!, "alt");
+
+    history = appendEntry(history, { type: "comment", annotationId: "b1", createdAt: AT }).history;
+    history = appendEntry(history, { type: "comment", annotationId: "b2", createdAt: AT }).history;
+    session.history = switchBranch(history, "main");
+    session.shelvedAnnotations = [annotation("b1", "alt one"), annotation("b2", "alt two")];
+    const { controller, client } = await connected(session);
+    const altFirst = history.entries.find(
+      (entry) => entry.type === "comment" && entry.annotationId === "b1",
+    )!;
+
+    // Act
+    controller.goToEntry(altFirst.id);
+
+    // Assert
+    expect(client.sessionSwitch).not.toHaveBeenCalled();
+    expect(client.sessionNavigate).toHaveBeenCalledWith("ses_1", altFirst.id, undefined, "alt");
+    expect(controller.getSnapshot().session!.annotations.map((entry) => entry.id)).toEqual([
+      "a1",
+      "b1",
+    ]);
+  });
+
+  test("a refused move gives way to the daemon's record", async () => {
+    // Arrange: the daemon refuses; a re-read hands back the untouched record
+    const session = sessionFixture();
+    const { controller, client } = await connected(session);
+
+    client.sessionNavigate.mockImplementationOnce(() => Promise.reject(new Error("resolved")));
+
+    // Act
+    controller.goToEntry(session.history!.entries[0]!.id);
+    const guessed = controller.getSnapshot().session!.annotations.length;
+
+    await tick();
+
+    // Assert: the guess showed, then the record came back
+    expect(guessed).toBe(0);
+    expect(controller.getSnapshot().session!.annotations.map((entry) => entry.id)).toEqual(["a1"]);
+    expect(controller.getSnapshot().status).toBe("resolved");
+  });
+
+  test("branch and label refuse an empty name and a taken branch name", async () => {
+    // Arrange
+    const { controller, client } = await connected();
+
+    // Act
+    controller.branch("  ");
+    controller.branch("main");
+    controller.labelTip("");
+
+    // Assert
+    expect(client.sessionBranch).not.toHaveBeenCalled();
+    expect(client.sessionLabel).not.toHaveBeenCalled();
+    expect(controller.getSnapshot().status).toBe("a checkpoint needs a name");
+  });
+
+  test("a branch shows up on the tip and becomes the current branch", async () => {
+    // Arrange
+    const { controller, client } = await connected();
+
+    // Act
+    controller.branch("alt");
+
+    // Assert
+    expect(controller.getSnapshot().session!.history!.branch).toBe("alt");
+    expect(controller.treeRows().find((row) => row.isCurrentTip)?.tips).toEqual(["main", "alt"]);
+    expect(client.sessionBranch).toHaveBeenCalledWith("ses_1", "alt");
+  });
+
+  test("fork opens the fork; fork-and-share shares the fork and stays on the original", async () => {
+    // Arrange
+    const forked = await connected();
+    const shared = await connected();
+
+    // Act
+    forked.controller.fork();
+    shared.controller.forkAndShare();
+    await tick();
+    await tick();
+
+    // Assert
+    expect(forked.controller.getSnapshot().session!.id).toBe("ses_1_fork");
+    expect(shared.controller.getSnapshot().session!.id).toBe("ses_1");
+    expect(publish).toHaveBeenCalledWith(expect.objectContaining({ id: "ses_1_fork" }));
+    expect(shared.client.sessionSetShareId).toHaveBeenCalledWith("ses_1_fork", "p_ses_1_fork");
+    expect(shared.controller.getSnapshot().toast?.title).toBe("fork shared - link copied");
+  });
+});