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

package/src/share.ts

@@ -1,5 +1,5 @@
 /**
- * Publish a review session as a share: pack it, stream it to the gateway's
+ * Publish a thread as a share: pack it, stream it to the gateway's
  * `share` user over SSH, and copy the returned `ssh p_…@host` line to the
  * clipboard. The planner holds no key, so all this side does is upload; the
  * gateway seals and stores. Used by both `cueloop share` and the in-TUI
@@ -41,6 +41,11 @@ export function shareIdFromLine(line: string): string | undefined {
   return line.match(/^ssh (\S+)@/)?.[1];
 }
 
+/** The paste line for a share id: `ssh p_…@host`. Used to copy an existing link. */
+export function formatShareLine(shareId: string, target: ShareTarget = {}): string {
+  return `ssh ${shareId}@${target.host ?? DEFAULT_SHARE_HOST}`;
+}
+
 /** Upload the session to the gateway and copy the resulting ssh line. */
 export async function publishShare(
   session: Thread,
@@ -108,7 +113,8 @@ export function mergeFromShare(remote: Thread): SharedMerge {
 export async function pushShare(
   shareId: string,
   annotations: Array<Omit<Annotation, "createdAt">>,
-  access?: ShareAccess,
+  // ShareAccess sets a private allowlist; "public" clears it (makes the link public); undefined leaves it
+  access?: ShareAccess | "public",
   target: ShareTarget = {},
 ): Promise<void> {
   const payload = access ? { shareId, annotations, access } : { shareId, annotations };
@@ -121,6 +127,14 @@ export async function pushShare(
   if (code !== 0) throw new Error(`gateway push failed: ${stderr.trim() || `ssh exited ${code}`}`);
 }
 
+/** Revoke a share: the gateway deletes the blob so its link stops resolving. Owner-gated; idempotent. */
+export async function revokeShare(shareId: string, target: ShareTarget = {}): Promise<void> {
+  const { stderr, code } = await runShareSsh("cueloop-revoke", Buffer.from(shareId), target);
+
+  if (code !== 0)
+    throw new Error(`gateway revoke failed: ${stderr.trim() || `ssh exited ${code}`}`);
+}
+
 export interface ShareWatchHandlers {
   /** The whole session record, each time the share changes. */
   onSession: (session: Thread) => void;

package/src/slash-palette.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import {
   activeSlashToken,
+  insertSlashItem,
   isStandaloneSlashQuery,
   scoreMatch,
   slashFilter,
@@ -84,3 +85,19 @@ describe("isStandaloneSlashQuery", () => {
     expect(isStandaloneSlashQuery("just prose")).toBe(false);
   });
 });
+
+describe("insertSlashItem", () => {
+  test("replaces the active slash token with the reference and lands the caret after it", () => {
+    const result = insertSlashItem("look at /rev", 12, "review");
+
+    expect(result.text).toBe("look at /review ");
+    expect(result.caret).toBe("look at /review ".length);
+  });
+
+  test("keeps text after the caret intact", () => {
+    const result = insertSlashItem("/pl tail", 3, "plan");
+
+    expect(result.text).toBe("/plan  tail");
+    expect(result.caret).toBe("/plan ".length);
+  });
+});

package/src/slash-palette.ts

@@ -86,6 +86,17 @@ export function isStandaloneSlashQuery(text: string): boolean {
   return /^\/\S*$/.test(text.trim());
 }
 
+export function insertSlashItem(text: string, caret: number, itemName: string) {
+  const token = activeSlashToken(text, caret) ?? "";
+  const cut = caret - token.length;
+  const insertion = `/${itemName} `;
+
+  return {
+    text: text.slice(0, cut) + insertion + text.slice(caret),
+    caret: cut + insertion.length,
+  };
+}
+
 /**
  * The character ranges of every completed "/name" in the draft that names a real
  * action or skill, so a surface can paint the references. A half-typed "/na" is

package/src/test-support.ts

@@ -157,6 +157,20 @@ export async function pressKey(
   await settle(setup);
 }
 
+/**
+ * Run a thread nav-mode command: esc drops the surface into nav mode, then a bare
+ * key acts (a letter, or a named key like "enter"/"backspace"). The caret and any
+ * held selection carry into nav, so the command lands where the caret is.
+ */
+export async function navCommand(setup: TestRendererSetup, key: string): Promise<void> {
+  await press(setup, "escape");
+  await new Promise((resolve) => setTimeout(resolve, 40));
+  await settle(setup);
+  // a single letter is a discrete keypress (nav command); named keys route through press
+  if (key.length === 1) await pressKey(setup, key);
+  else await press(setup, key);
+}
+
 /** A 0-based cell position within a captured char frame. */
 export interface FrameLocation {
   row: number;

package/src/thread-chords.test.ts

@@ -1,202 +1,79 @@
 import { describe, expect, test } from "bun:test";
-import {
-  DEFAULT_LEADER,
-  leaderHint,
-  matchesLeader,
-  resolveLeaderCommand,
-  resolveThreadChord,
-} from "./thread-chords";
-
-const owner = { composing: false, isOwner: true, resolved: false, treeActive: false };
-
-describe("the command leader", () => {
-  test("matchesLeader recognizes the configured chord and nothing else", () => {
-    expect(matchesLeader({ ctrl: true, name: "g" }, [DEFAULT_LEADER])).toBe(true);
-    expect(matchesLeader({ ctrl: true, name: "G" }, [DEFAULT_LEADER])).toBe(true);
-    expect(matchesLeader({ name: "g" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ ctrl: true, name: "x" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ ctrl: true, meta: true, name: "g" }, [DEFAULT_LEADER])).toBe(false);
-    expect(matchesLeader({ name: "," }, [","])).toBe(true);
+import { resolveNavKey } from "./thread-chords";
+
+const owner = { isOwner: true, resolved: false, treeActive: false };
+const readOnly = { type: "status" as const, message: "observer - read-only" };
+const submitted = { type: "status" as const, message: "review submitted - read-only" };
+
+describe("resolveNavKey", () => {
+  test("the session commands: submit, edit, share", () => {
+    expect(resolveNavKey({ name: "return" }, owner)).toEqual({ type: "openSubmit" });
+    expect(resolveNavKey({ name: "enter" }, owner)).toEqual({ type: "openSubmit" });
+    expect(resolveNavKey({ name: "e" }, owner)).toEqual({ type: "edit" });
+    expect(resolveNavKey({ name: "s" }, owner)).toEqual({ type: "share" });
   });
 
-  test("leaderHint renders the glyph plus a trailing space", () => {
-    expect(leaderHint(["ctrl+g"])).toBe("⌃g ");
-    expect(leaderHint([","])).toBe(", ");
-  });
-
-  test("a key after the leader runs the same intent as its Option chord", () => {
+  test("a diff row's keys win over the shared letters, then fall through to curation", () => {
     const diff = { ...owner, isDiff: true };
 
-    expect(resolveLeaderCommand({ name: "x" }, diff)).toEqual({ type: "rejectChange" });
-    expect(resolveLeaderCommand({ name: "X" }, diff)).toEqual({ type: "rejectHunk" });
-    expect(resolveLeaderCommand({ name: "x" }, owner)).toEqual({ type: "cut" });
-    expect(resolveLeaderCommand({ name: "return" }, owner)).toEqual({ type: "openSubmit" });
-    expect(resolveLeaderCommand({ name: "x" }, { ...owner, composing: true })).toBeNull();
-  });
-});
-
-describe("resolveThreadChord", () => {
-  test("ctrl+enter opens the submit overlay for an owner with an open review", () => {
-    // Assert: the terminal-safe chord and the cmd forms all submit
-    expect(resolveThreadChord({ name: "return", ctrl: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-    expect(resolveThreadChord({ name: "return", super: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-    expect(resolveThreadChord({ name: "enter", meta: true }, owner)).toEqual({
-      type: "openSubmit",
-    });
-  });
-
-  test("session chords map to their intents", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "e", ctrl: true }, owner)).toEqual({ type: "edit" });
-    expect(resolveThreadChord({ name: "s", ctrl: true }, owner)).toEqual({ type: "share" });
+    expect(resolveNavKey({ name: "x" }, diff)).toEqual({ type: "rejectChange" });
+    expect(resolveNavKey({ name: "c" }, diff)).toEqual({ type: "foldFile" });
+    expect(resolveNavKey({ name: "d" }, diff)).toEqual({ type: "toggleDiffView" });
+    expect(resolveNavKey({ name: "k" }, diff)).toEqual({ type: "walkStart" });
+    // a letter with no diff meaning still reaches the curation commands
+    expect(resolveNavKey({ name: "n" }, diff)).toEqual({ type: "nextAnnotation" });
   });
 
-  test("in a diff, option chords act on the caret's row and file; the rest still reach the rail", () => {
-    // Arrange
-    const diff = { ...owner, isDiff: true };
-
-    // Assert - the code-row primitives
-    expect(resolveThreadChord({ name: "x", meta: true }, diff)).toEqual({ type: "rejectChange" });
-    expect(resolveThreadChord({ name: "X", meta: true }, diff)).toEqual({ type: "rejectHunk" });
-    expect(resolveThreadChord({ name: "u", meta: true }, diff)).toEqual({
-      type: "restoreCuration",
-    });
-    expect(resolveThreadChord({ name: "c", meta: true }, diff)).toEqual({ type: "foldFile" });
-    expect(resolveThreadChord({ name: "d", meta: true }, diff)).toEqual({ type: "toggleDiffView" });
-    expect(resolveThreadChord({ name: "k", meta: true }, diff)).toEqual({ type: "walkStart" });
-    // the rail letters are untouched
-    expect(resolveThreadChord({ name: "n", meta: true }, diff)).toEqual({ type: "nextAnnotation" });
-    // rejecting is the owner's, and closed once resolved
-    expect(resolveThreadChord({ name: "x", meta: true }, { ...diff, isOwner: false })).toEqual({
-      type: "status",
-      message: "observer - read-only",
-    });
-    expect(resolveThreadChord({ name: "k", meta: true }, { ...diff, resolved: true })).toEqual({
-      type: "status",
-      message: "review submitted - read-only",
-    });
+  test("the discussion and curation commands", () => {
+    expect(resolveNavKey({ name: "n" }, owner)).toEqual({ type: "nextAnnotation" });
+    expect(resolveNavKey({ name: "p" }, owner)).toEqual({ type: "prevAnnotation" });
+    expect(resolveNavKey({ name: "backspace" }, owner)).toEqual({ type: "removeAnnotation" });
+    expect(resolveNavKey({ name: "r" }, owner)).toEqual({ type: "openRename" });
+    expect(resolveNavKey({ name: "x" }, owner)).toEqual({ type: "cut" });
+    expect(resolveNavKey({ name: "u" }, owner)).toEqual({ type: "restoreCuration" });
   });
 
-  test("option chords drive the rail and curation with the plan sheet's letters", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
-      type: "nextAnnotation",
-    });
-    expect(resolveThreadChord({ name: "p", meta: true }, owner)).toEqual({
-      type: "prevAnnotation",
-    });
-    expect(resolveThreadChord({ name: "e", meta: true }, owner)).toEqual({ type: "editCard" });
-    expect(resolveThreadChord({ name: "backspace", meta: true }, owner)).toEqual({
-      type: "removeAnnotation",
-    });
-    expect(resolveThreadChord({ name: "r", meta: true }, owner)).toEqual({ type: "openRename" });
-    expect(resolveThreadChord({ name: "x", meta: true }, owner)).toEqual({ type: "cut" });
-    expect(resolveThreadChord({ name: "u", meta: true }, owner)).toEqual({
-      type: "restoreCuration",
-    });
-    expect(resolveThreadChord({ name: "x", meta: true }, { ...owner, isOwner: false })).toEqual({
-      type: "status",
-      message: "observer - read-only",
-    });
-  });
+  test("the tree commands: move on the Tree tab, go, branch, label, fork, hand off", () => {
+    const onTree = { ...owner, treeActive: true };
 
-  test("an open composer swallows every chord, so typing is never hijacked", () => {
-    // Assert
-    expect(
-      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, composing: true }),
-    ).toBeNull();
-    expect(resolveThreadChord({ name: "s", ctrl: true }, { ...owner, composing: true })).toBeNull();
+    expect(resolveNavKey({ name: "n" }, onTree)).toEqual({ type: "treeMove", direction: 1 });
+    expect(resolveNavKey({ name: "p" }, onTree)).toEqual({ type: "treeMove", direction: -1 });
+    expect(resolveNavKey({ name: "g" }, owner)).toEqual({ type: "treeGo" });
+    expect(resolveNavKey({ name: "b" }, owner)).toEqual({ type: "treeBranch" });
+    expect(resolveNavKey({ name: "l" }, owner)).toEqual({ type: "treeLabel" });
+    expect(resolveNavKey({ name: "f" }, owner)).toEqual({ type: "treeFork" });
+    expect(resolveNavKey({ name: "h" }, owner)).toEqual({ type: "treeForkShare" });
   });
 
-  test("plain keys and unbound chords belong to the document grammar", () => {
-    // Assert
-    expect(resolveThreadChord({ name: "return" }, owner)).toBeNull();
-    expect(resolveThreadChord({ name: "s" }, owner)).toBeNull();
-    expect(resolveThreadChord({ name: "x", ctrl: true }, owner)).toBeNull();
+  test("a shift letter resolves as its uppercase, which no command claims, so it returns to typing", () => {
+    expect(resolveNavKey({ name: "x", shift: true }, { ...owner, isDiff: true })).toBeNull();
   });
 
-  test("a collaborator is told a primitive is read-only, and a resolved review cannot be resubmitted", () => {
-    // Assert
+  test("a collaborator is refused the owner's commands; renaming stays open", () => {
     const collaborator = { ...owner, isOwner: false };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
 
-    expect(resolveThreadChord({ name: "return", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "e", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "s", ctrl: true }, collaborator)).toEqual(readOnly);
-    expect(
-      resolveThreadChord({ name: "return", ctrl: true }, { ...owner, resolved: true }),
-    ).toBeNull();
+    expect(resolveNavKey({ name: "return" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "e" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "s" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "x" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "g" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "f" }, collaborator)).toEqual(readOnly);
+    expect(resolveNavKey({ name: "r" }, collaborator)).toEqual({ type: "openRename" });
   });
 
-  test("a resolved review refuses every change and says so; renaming an author stays open", () => {
-    // Arrange
+  test("a resolved review refuses every change and says so; a fork stays open", () => {
     const resolved = { ...owner, resolved: true };
-    const submitted = { type: "status" as const, message: "review submitted - read-only" };
 
-    // Assert
-    expect(resolveThreadChord({ name: "e", ctrl: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "e", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "backspace", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "x", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "u", meta: true }, resolved)).toEqual(submitted);
-    expect(resolveThreadChord({ name: "r", meta: true }, resolved)).toEqual({ type: "openRename" });
-    expect(resolveThreadChord({ name: "s", ctrl: true }, resolved)).toEqual({ type: "share" });
+    expect(resolveNavKey({ name: "return" }, resolved)).toBeNull();
+    expect(resolveNavKey({ name: "e" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "x" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "b" }, resolved)).toEqual(submitted);
+    expect(resolveNavKey({ name: "f" }, resolved)).toEqual({ type: "treeFork" });
+    expect(resolveNavKey({ name: "s" }, resolved)).toEqual({ type: "share" });
   });
 
-  test("the tree chords: toggle, move on the Tree tab, go, branch, label, fork, hand off", () => {
-    // Arrange
-    const onTree = { ...owner, treeActive: true };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
-    const submitted = { type: "status" as const, message: "review submitted - read-only" };
-
-    // Assert: next / previous follow the tab that shows
-    expect(resolveThreadChord({ name: "t", meta: true }, owner)).toEqual({ type: "toggleTree" });
-    expect(resolveThreadChord({ name: "n", meta: true }, onTree)).toEqual({
-      type: "treeMove",
-      direction: 1,
-    });
-    expect(resolveThreadChord({ name: "p", meta: true }, onTree)).toEqual({
-      type: "treeMove",
-      direction: -1,
-    });
-    expect(resolveThreadChord({ name: "n", meta: true }, owner)).toEqual({
-      type: "nextAnnotation",
-    });
-    expect(resolveThreadChord({ name: "g", meta: true }, owner)).toEqual({ type: "treeGo" });
-    expect(resolveThreadChord({ name: "b", meta: true }, owner)).toEqual({ type: "treeBranch" });
-    expect(resolveThreadChord({ name: "l", meta: true }, owner)).toEqual({ type: "treeLabel" });
-    expect(resolveThreadChord({ name: "f", meta: true }, owner)).toEqual({ type: "treeFork" });
-    expect(resolveThreadChord({ name: "h", meta: true }, owner)).toEqual({ type: "treeForkShare" });
-    // moving the tree is the owner's; a fork is open after a verdict, a move is not
-    expect(resolveThreadChord({ name: "g", meta: true }, { ...owner, isOwner: false })).toEqual(
-      readOnly,
-    );
-    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, isOwner: false })).toEqual(
-      readOnly,
-    );
-    expect(resolveThreadChord({ name: "b", meta: true }, { ...owner, resolved: true })).toEqual(
-      submitted,
-    );
-    expect(resolveThreadChord({ name: "f", meta: true }, { ...owner, resolved: true })).toEqual({
-      type: "treeFork",
-    });
-    expect(resolveThreadChord({ name: "t", meta: true }, { ...owner, isOwner: false })).toEqual({
-      type: "toggleTree",
-    });
-  });
-
-  test("an observer cannot edit or delete cards either", () => {
-    // Arrange
-    const observer = { ...owner, isOwner: false };
-    const readOnly = { type: "status" as const, message: "observer - read-only" };
-
-    // Assert
-    expect(resolveThreadChord({ name: "e", meta: true }, observer)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "backspace", meta: true }, observer)).toEqual(readOnly);
-    expect(resolveThreadChord({ name: "r", meta: true }, observer)).toEqual({ type: "openRename" });
+  test("an unmapped key returns null, so the surface returns to typing", () => {
+    expect(resolveNavKey({ name: "z" }, owner)).toBeNull();
+    expect(resolveNavKey({ name: "j" }, owner)).toBeNull();
   });
 });