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

package/src/thread-chords.ts

@@ -1,186 +1,75 @@
-/**
- * The session-level chords of the thread view. Letters in the thread view
- * type a comment, so everything that acts on the session as a whole - submit,
- * share, edit, the rail - lives on ctrl chords (cmd where the terminal
- * delivers it). The guided walk is a diff-review mode and has no chord here. Pure: the view reports whether a composer is open, this maps
- * a key to an intent or to nothing.
- */
-
 import type { Intent } from "./keymap";
 
-export interface ThreadChordKey {
+export interface NavKey {
   name: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  super?: boolean;
+  shift?: boolean;
 }
 
-export interface ThreadChordContext {
-  /** A composer owns the keyboard: chords never fire while one is open. */
-  composing: boolean;
-  /** Collaborators annotate only; submit, edit, and share are the owner's. */
+export interface ThreadNavContext {
   isOwner: boolean;
-  /** A resolved session has nothing left to submit. */
   resolved: boolean;
-  /** The rail shows the tree: next / previous move its selection instead of the cards. */
   treeActive: boolean;
-  /** A diff review: the block chords act on the code row under the caret (reject, fold, walk). */
   isDiff?: boolean;
 }
 
-export const DEFAULT_LEADER = "ctrl+g";
-
-export function leaderCombosFor(configured: readonly string[] | undefined): readonly string[] {
-  return configured ?? [DEFAULT_LEADER];
-}
-
-const MOD_GLYPHS = new Map<string, string>([
-  ["ctrl", "⌃"],
-  ["control", "⌃"],
-  ["meta", "⌥"],
-  ["alt", "⌥"],
-  ["option", "⌥"],
-  ["shift", "⇧"],
-  ["cmd", "⌘"],
-  ["super", "⌘"],
-]);
-
-function comboParts(combo: string) {
-  const parts = combo.split("+");
-
-  return { mods: parts.slice(0, -1).map((part) => part.toLowerCase()), name: parts.at(-1) ?? "" };
-}
-
-export function leaderHint(combos: readonly string[]): string {
-  const { mods, name } = comboParts(combos[0] ?? DEFAULT_LEADER);
-
-  return `${mods.map((mod) => MOD_GLYPHS.get(mod) ?? mod).join("")}${name} `;
-}
-
-export function matchesLeader(
-  key: { ctrl?: boolean; meta?: boolean; shift?: boolean; super?: boolean; name: string },
-  combos: readonly string[],
-): boolean {
-  return combos.some((combo) => {
-    const { mods, name } = comboParts(combo);
-
-    return (
-      key.name.toLowerCase() === name.toLowerCase() &&
-      Boolean(key.ctrl) === (mods.includes("ctrl") || mods.includes("control")) &&
-      Boolean(key.shift) === mods.includes("shift") &&
-      Boolean(key.super) === (mods.includes("cmd") || mods.includes("super")) &&
-      Boolean(key.meta) ===
-        (mods.includes("meta") || mods.includes("alt") || mods.includes("option"))
-    );
-  });
-}
-
 export interface ChordEntry {
   keys: string;
   label: string;
 }
 
-/** The diff-review chords: the leader (or Option) plus a letter, on the caret's row or file. */
-export function diffChordEntries(hint: string): ChordEntry[] {
+export function sessionCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}x / ${hint}X`, label: "reject the change / the hunk" },
-    { keys: `${hint}u`, label: "restore the last rejection" },
-    { keys: `${hint}c`, label: "collapse the file to its band" },
-    { keys: `${hint}d`, label: "split / stacked (when wide)" },
-    { keys: `${hint}k`, label: "start the guided walk" },
+    { keys: "⏎", label: "submit the review" },
+    { keys: "e", label: "edit in $EDITOR" },
+    { keys: "s", label: "share" },
   ];
 }
 
-/** The session chords stay on Ctrl, which terminals deliver reliably. */
-export const THREAD_CHORD_ENTRIES = [
-  { keys: "⌃enter", label: "submit the review" },
-  { keys: "⌃e", label: "edit in $EDITOR" },
-  { keys: "⌃s", label: "share" },
-  { keys: "⌃r", label: "cycle the rail" },
-] as const;
-
-/** The rail and curation chords: the leader plus the plan sheet's old letter. */
-export function railChordEntries(hint: string): ChordEntry[] {
+export function diffCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}n / ${hint}p`, label: "next / previous card" },
-    { keys: `${hint}e`, label: "edit the card" },
-    { keys: `${hint}⌫`, label: "delete the card" },
-    { keys: `${hint}r`, label: "rename the author" },
-    { keys: `${hint}x`, label: "cut the block" },
-    { keys: `${hint}u`, label: "restore the last cut" },
-    { keys: "⌥w / ⌥s", label: "widen / narrow the rail" },
+    { keys: "x", label: "reject the change under the caret" },
+    { keys: "u", label: "restore the last rejection" },
+    { keys: "c", label: "collapse the file to its band" },
+    { keys: "d", label: "split / stacked (when wide)" },
+    { keys: "k", label: "start the guided walk" },
   ];
 }
 
-/** The tree chords: the leader plus a letter, all on the rail's Tree tab. */
-export function treeChordEntries(hint: string): ChordEntry[] {
+export function curationCommandEntries(): ChordEntry[] {
   return [
-    { keys: `${hint}t`, label: "show / hide the tree" },
-    { keys: `${hint}n / ${hint}p`, label: "next / previous entry" },
-    { keys: `${hint}g`, label: "go to the entry" },
-    { keys: `${hint}b`, label: "branch off the tip" },
-    { keys: `${hint}l`, label: "label a checkpoint" },
-    { keys: `${hint}f`, label: "fork the path" },
-    { keys: `${hint}h`, label: "fork and hand off" },
+    { keys: "n / p", label: "next / previous card" },
+    { keys: "z", label: "fold / unfold the card" },
+    { keys: "⌫", label: "delete the card" },
+    { keys: "r", label: "rename the author" },
+    { keys: "x", label: "cut the block" },
+    { keys: "u", label: "restore the last cut" },
   ];
 }
 
-export function resolveThreadChord(
-  key: ThreadChordKey,
-  context: ThreadChordContext,
-): Intent | null {
-  if (context.composing) return null;
-  const modified = Boolean(key.ctrl || key.meta || key.super);
-
-  if (!modified) return null;
-  if (key.name === "return" || key.name === "enter") {
-    if (!context.isOwner) return READ_ONLY;
-
-    return context.resolved ? null : { type: "openSubmit" };
-  }
-  if (key.ctrl) return resolveSessionChord(key.name, context);
-  if (key.meta)
-    return (
-      (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
-    );
-
-  return null;
+export function treeCommandEntries(): ChordEntry[] {
+  return [
+    { keys: "g", label: "go to the entry" },
+    { keys: "b", label: "branch off the tip" },
+    { keys: "l", label: "label a checkpoint" },
+    { keys: "f", label: "fork the path" },
+    { keys: "h", label: "fork and hand off" },
+  ];
 }
 
-export function resolveLeaderCommand(
-  key: ThreadChordKey,
-  context: ThreadChordContext,
-): Intent | null {
-  if (context.composing) return null;
-  if (key.name === "return" || key.name === "enter") {
-    if (!context.isOwner) return READ_ONLY;
-
-    return context.resolved ? null : { type: "openSubmit" };
-  }
-
-  return (
-    (context.isDiff && resolveDiffChord(key.name, context)) || resolveRailChord(key.name, context)
-  );
-}
+const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
+const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
 
-export function dispatchLeaderCommand(
-  key: { name: string; shift?: boolean },
-  context: ThreadChordContext,
-  dispatch: (intent: Intent) => void,
-): void {
-  const name = key.shift ? key.name.toUpperCase() : key.name;
-  const chord = resolveLeaderCommand({ name }, context);
+function mutating(intent: Intent, context: ThreadNavContext): Intent {
+  if (!context.isOwner) return READ_ONLY;
+  if (context.resolved) return RESOLVED;
 
-  if (chord) dispatch(chord);
+  return intent;
 }
 
-/** The diff's row and file chords; null lets the rail chords answer the letter. */
-function resolveDiffChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveDiffKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "x":
       return mutating({ type: "rejectChange" }, context);
-    case "X":
-      return mutating({ type: "rejectHunk" }, context);
     case "c":
       return { type: "foldFile" };
     case "d":
@@ -192,19 +81,7 @@ function resolveDiffChord(name: string, context: ThreadChordContext): Intent | n
   }
 }
 
-/** The answers a blocked primitive gets - the same words the keymap uses. */
-const READ_ONLY: Intent = { type: "status", message: "observer - read-only" };
-const RESOLVED: Intent = { type: "status", message: "review submitted - read-only" };
-
-/** Editing, deleting, cutting, and restoring change the review: gated by role and by a verdict. */
-function mutating(intent: Intent, context: ThreadChordContext): Intent {
-  if (!context.isOwner) return READ_ONLY;
-  if (context.resolved) return RESOLVED;
-
-  return intent;
-}
-
-function resolveSessionChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveSessionKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "e":
       return mutating({ type: "edit" }, context);
@@ -215,33 +92,24 @@ function resolveSessionChord(name: string, context: ThreadChordContext): Intent
   }
 }
 
-// option arrives as meta in this terminal stack; the letters mirror the
-// plan sheet's keymap so the rail keeps its muscle memory
-function resolveRailChord(name: string, context: ThreadChordContext): Intent | null {
+function resolveCurationKey(name: string, context: ThreadNavContext): Intent | null {
   switch (name) {
     case "n":
       return context.treeActive ? { type: "treeMove", direction: 1 } : { type: "nextAnnotation" };
     case "p":
       return context.treeActive ? { type: "treeMove", direction: -1 } : { type: "prevAnnotation" };
-    case "t":
-      return { type: "toggleTree" };
-    // the tree is the owner's: a move, a branch, or a label changes what everyone sees
     case "g":
       return mutating({ type: "treeGo" }, context);
     case "b":
       return mutating({ type: "treeBranch" }, context);
     case "l":
       return mutating({ type: "treeLabel" }, context);
-    // a fork can be taken from a resolved review: only the role gates it
     case "f":
       return context.isOwner ? { type: "treeFork" } : READ_ONLY;
     case "h":
       return context.isOwner ? { type: "treeForkShare" } : READ_ONLY;
-    case "e":
-      return mutating({ type: "editCard" }, context);
     case "backspace":
       return mutating({ type: "removeAnnotation" }, context);
-    // renaming an author is a local display choice, open to every role
     case "r":
       return { type: "openRename" };
     case "x":
@@ -252,3 +120,44 @@ function resolveRailChord(name: string, context: ThreadChordContext): Intent | n
       return null;
   }
 }
+
+export interface SessionChordKey {
+  name: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  super?: boolean;
+}
+
+export function resolveSessionChord(
+  key: SessionChordKey,
+  context: Pick<ThreadNavContext, "isOwner" | "resolved">,
+): Intent | null {
+  if (key.name === "return" || key.name === "enter") {
+    if (!(key.ctrl || key.meta || key.super)) return null;
+    if (!context.isOwner) return READ_ONLY;
+
+    return context.resolved ? null : { type: "openSubmit" };
+  }
+  if (!key.ctrl) return null;
+  if (key.name === "e")
+    return context.resolved ? RESOLVED : context.isOwner ? { type: "edit" } : READ_ONLY;
+  if (key.name === "s") return context.isOwner ? { type: "share" } : READ_ONLY;
+
+  return null;
+}
+
+export function resolveNavKey(key: NavKey, context: ThreadNavContext): Intent | null {
+  const name = key.shift ? key.name.toUpperCase() : key.name;
+
+  if (name === "return" || name === "enter") {
+    if (!context.isOwner) return READ_ONLY;
+
+    return context.resolved ? null : { type: "openSubmit" };
+  }
+
+  return (
+    (context.isDiff ? resolveDiffKey(name, context) : null) ??
+    resolveSessionKey(name, context) ??
+    resolveCurationKey(name, context)
+  );
+}

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

@@ -118,6 +118,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),

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

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { sameDerivationInputs } from "./thread-controller";
+
+function threadFixture(overrides: Partial<Thread> = {}): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const annotation: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "nit",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("sameDerivationInputs", () => {
+  test("an annotation-only update reuses the projection (a fresh record, identical inputs)", () => {
+    // Arrange - the daemon re-serializes the whole thread on any change, so the record is all-new
+    const before = threadFixture();
+    const after = threadFixture({ annotations: [annotation] });
+
+    // Assert - the artifact and working copy are unchanged, so the projection can be reused
+    expect(sameDerivationInputs(before, after)).toBe(true);
+  });
+
+  test("a content edit forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({
+      artifact: { type: "plan", content: "# Plan\n\nShip it soon.\n", meta: {} },
+    });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a working-copy change forces a re-derivation", () => {
+    const before = threadFixture();
+    const after = threadFixture({ workingCopy: "# Plan\n\nShip it.\n\nedited\n" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+
+  test("a different thread is never a reuse", () => {
+    const before = threadFixture();
+    const after = threadFixture({ id: "ses_2" });
+
+    expect(sameDerivationInputs(before, after)).toBe(false);
+  });
+});

package/src/thread-controller.live-diff.test.ts

@@ -38,7 +38,9 @@ const shareTransport: ShareTransport = {
   pull: mock(async () => planSession()),
   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,
 };
@@ -82,6 +84,7 @@ function fakeClient(session: Thread): SessionClient {
     sessionSetViewed: unimplemented("sessionSetViewed"),
     sessionSetTitle: unimplemented("sessionSetTitle"),
     sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionSetShares: unimplemented("sessionSetShares"),
     sessionMergeShared: unimplemented("sessionMergeShared"),
     sessionDelete: unimplemented("sessionDelete"),
     sessionSetSelfName: unimplemented("sessionSetSelfName"),

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

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { withAnnotationUpserted } from "./thread-controller";
+
+function threadFixture(annotations: Annotation[] = []): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n\nShip it.\n", meta: {} },
+    revisions: [
+      { revision: 1, content: "# Plan\n\nShip it.\n", submittedAt: "2026-01-01T00:00:00.000Z" },
+    ],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+const existing: Annotation = {
+  id: "ann_1",
+  kind: "comment",
+  anchor: { quote: "Ship it.", prefix: "", suffix: "" },
+  body: "first",
+  createdAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("withAnnotationUpserted", () => {
+  test("a new comment is appended so it paints immediately", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1", "ann_2"]);
+    expect(next.annotations[1]!.body).toBe("second");
+    expect(next.annotations[1]!.createdAt).not.toBe("");
+  });
+
+  test("an edit replaces the note in place and keeps its timestamp", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_1", kind: "comment", anchor: existing.anchor, body: "edited" };
+
+    // Act
+    const next = withAnnotationUpserted(session, wire);
+
+    // Assert - same position, same createdAt, new body (no reorder or timestamp flash)
+    expect(next.annotations.map((entry) => entry.id)).toEqual(["ann_1"]);
+    expect(next.annotations[0]!.body).toBe("edited");
+    expect(next.annotations[0]!.createdAt).toBe(existing.createdAt);
+  });
+
+  test("the input session is not mutated", () => {
+    // Arrange
+    const session = threadFixture([existing]);
+    const wire = { id: "ann_2", kind: "comment", anchor: existing.anchor, body: "second" };
+
+    // Act
+    withAnnotationUpserted(session, wire);
+
+    // Assert
+    expect(session.annotations).toHaveLength(1);
+  });
+});

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);
+  });
+});