@cueloop/client 0.1.0-alpha.78 → 0.1.0-alpha.79

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

@@ -17,16 +17,20 @@ const pushShare = mock(
   async (
     _shareId: string,
     _annotations: Array<Omit<Annotation, "createdAt">>,
-    _access?: ShareAccess,
+    _access?: ShareAccess | "public",
   ) => {},
 );
 
+const revokeShare = mock(async (_shareId: string) => {});
+
 const shareTransport: ShareTransport = {
   publish: publishShare,
   pull: pullShare,
   push: pushShare,
   watch: () => () => {},
+  revoke: revokeShare,
   parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
   collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
   mergeFromShare,
 };
@@ -88,6 +92,12 @@ function fakeClient(session: Thread): FakeSessionClient {
     sessionSetShareId: mock(
       async (_id: string, shareId: string) => ((session.shareId = shareId), session),
     ),
+    sessionSetShares: mock(
+      async (_id: string, shares: import("@cueloop/schema").ShareLink[]) => (
+        (session.shares = shares),
+        session
+      ),
+    ),
     sessionMergeShared: mock(async (_id: string, incoming: { annotations: Annotation[] }) => {
       const known = new Set(session.annotations.map((existing) => existing.id));
 
@@ -125,7 +135,7 @@ async function connectedController(
 }
 
 describe("share", () => {
-  test("stamps the returned share id back on the session", async () => {
+  test("publishes a public link and records it on the session", async () => {
     // Arrange
     const { controller, client } = await connectedController(sessionFixture());
 
@@ -133,8 +143,10 @@ describe("share", () => {
     controller.share();
     await tick();
 
-    // Assert
-    expect(client.sessionSetShareId).toHaveBeenCalledWith("ses_1", "p_abc123xy");
+    // Assert - a public link (no auth) is persisted with the returned id
+    expect(client.sessionSetShares).toHaveBeenCalledWith("ses_1", [
+      { id: "p_abc123xy", name: undefined, requireAuth: false, allowlist: [], shareBranch: "main" },
+    ]);
   });
 
   test("surfaces the ssh line as a toast, not an inline status", async () => {
@@ -148,7 +160,7 @@ describe("share", () => {
     // Assert
     expect(controller.getSnapshot().toast).toEqual({
       body: "ssh p_abc123xy@cueloop.dev",
-      title: "share link copied",
+      title: "link copied",
     });
     expect(controller.getSnapshot().status).not.toContain("ssh p_abc123xy@cueloop.dev");
   });
@@ -504,3 +516,46 @@ describe("startShareSync", () => {
     expect(streams[1]!.stopped).toBe(false);
   });
 });
+
+describe("revoke", () => {
+  test("unshare revokes the gateway blob for the shared thread", async () => {
+    revokeShare.mockClear();
+    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }));
+
+    controller.unshare();
+    await tick();
+
+    expect(revokeShare).toHaveBeenCalledWith("p_abc123xy");
+  });
+
+  test("unshare on an unshared thread is a no-op", async () => {
+    revokeShare.mockClear();
+    const { controller } = await connectedController(sessionFixture());
+
+    controller.unshare();
+    await tick();
+
+    expect(revokeShare).not.toHaveBeenCalled();
+  });
+
+  test("deleting a shared thread revokes its share first", async () => {
+    revokeShare.mockClear();
+    const session = sessionFixture({ shareId: "p_abc123xy" });
+    const client = fakeClient(session);
+
+    client.sessionDelete = mock(async () => {});
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+
+    controller.connect();
+    await tick();
+    controller.deleteSession(session.id);
+    await tick();
+
+    expect(revokeShare).toHaveBeenCalledWith("p_abc123xy");
+    expect(client.sessionDelete).toHaveBeenCalledWith(session.id);
+  });
+});

package/src/thread-controller.switch-cache.test.ts

@@ -104,6 +104,7 @@ function fakeClient(sessions: Thread[]): SessionClient {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
@@ -143,4 +144,33 @@ describe("switching threads keeps the cached projection curatable", () => {
     expect(controller.getSnapshot().status).toContain("change rejected");
     expect(controller.getSnapshot().session?.workingCopy).toBe("");
   });
+
+  test("returning to a diff thread shows the daemon's latest, not the stale sidebar copy", async () => {
+    // The sidebar list trails the daemon for a hot-reloading diff (its session.updated
+    // refreshes the open thread, not the list). Returning to it must revalidate.
+    const staleA = diffSession("ses_a", PATCH_A, FILES_A);
+    const freshA = diffSession("ses_a", PATCH_B, FILES_B);
+    const other = diffSession("ses_b", PATCH_B, FILES_B);
+    const base = fakeClient([staleA, other]);
+    const controller = createReviewController({
+      sessionId: "ses_a",
+      openClient: async () => ({
+        ...base,
+        // the sidebar keeps the stale copy; the daemon serves the fresh one
+        sessionList: async () => [staleA, other],
+        sessionGet: async (id: string) => (id === "ses_a" ? freshA : other),
+      }),
+    });
+
+    controller.connect();
+    await tick();
+
+    // Visit B, then return to A - open() paints the stale sidebar copy, then revalidates
+    controller.open("ses_b");
+    await tick();
+    controller.open("ses_a");
+    await tick();
+
+    expect(controller.getSnapshot().session?.artifact.content).toBe(PATCH_B);
+  });
 });

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

@@ -58,7 +58,9 @@ const shareTransport: ShareTransport = {
   pull: mock(async () => sessionFixture()),
   push: mock(async () => {}),
   watch: () => () => {},
+  revoke: async () => {},
   parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
   collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
   mergeFromShare,
 };
@@ -95,6 +97,7 @@ function fakeClient(session: Thread) {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: mock(async (_id: string, _shareId: string) => session),
+    sessionSetShares: mock(async () => session),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),
@@ -250,7 +253,9 @@ describe("tree primitives", () => {
     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.client.sessionSetShares).toHaveBeenCalledWith("ses_1_fork", [
+      { id: "p_ses_1_fork", requireAuth: false, allowlist: [], shareBranch: "main" },
+    ]);
     expect(shared.controller.getSnapshot().toast?.title).toBe("fork shared - link copied");
   });
 });