@cueloop/client 0.1.0-alpha.21 → 0.1.0-alpha.22

package/src/session-controller.ts

@@ -8,7 +8,7 @@
  */
 
 import { SystemClock, type Clock, type TimerHandle } from "@opentui/core";
-import { DaemonClient } from "@cueloop/daemon/client";
+import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
 import {
   cutBlock,
   detectHerdr,
@@ -23,6 +23,7 @@ import {
   type VerdictKind,
 } from "@cueloop/schema";
 import { loadBundledExporters, type BundledExporter } from "./integrations";
+import { publishShare } from "./share";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
@@ -72,6 +73,12 @@ export interface ReviewControllerOptions {
   onExit?: (code: number) => void;
   /** Timer source for the auto-close countdown; tests inject a ManualClock. */
   clock?: Clock;
+  /**
+   * How the controller gets its session client. Defaults to dialing the local
+   * daemon; the sharing gateway injects a blob-backed client so the same <App>
+   * renders a decrypted share instead.
+   */
+  openClient?: () => Promise<SessionClient>;
 }
 
 export interface ReviewController {
@@ -115,6 +122,8 @@ export interface ReviewController {
   walkLeave(): void;
   /** Resolve the review, run the export, start the completion hand-back. */
   submit(verdict: VerdictKind, summary: string): void;
+  /** Publish the current session as a share; the ssh line lands on the clipboard. */
+  share(): void;
   /** Close the review and, inside herdr, bounce focus back to the agent. */
   finishReview(): void;
   dismissCompletion(): void;
@@ -134,7 +143,7 @@ export function createReviewController(options: ReviewControllerOptions): Review
 
 class Controller implements ReviewController {
   readonly readOnly: boolean;
-  private client: DaemonClient | null = null;
+  private client: SessionClient | null = null;
   private closed = false;
   private snapshot: ControllerSnapshot = {
     session: null,
@@ -179,7 +188,8 @@ class Controller implements ReviewController {
   connect(): void {
     void (async () => {
       try {
-        const client = await DaemonClient.connect({ home: this.options.home, autostart: true });
+        const openClient = this.options.openClient ?? (() => DaemonClient.connect({ home: this.options.home, autostart: true }));
+        const client = await openClient();
         if (this.closed) return void client.close();
         this.client = client;
         client.onEvent((event) => {
@@ -470,6 +480,15 @@ class Controller implements ReviewController {
       .catch((error: unknown) => this.setStatus(String(error instanceof Error ? error.message : error)));
   }
 
+  share(): void {
+    const session = this.snapshot.session;
+    if (!session) return;
+    this.setStatus("sharing…");
+    publishShare(session)
+      .then(({ line, copied }) => this.setStatus(copied ? `✓ share link copied - ${line}` : line))
+      .catch((error: unknown) => this.setStatus(`share failed: ${error instanceof Error ? error.message : String(error)}`));
+  }
+
   // ── completion hand-back ────────────────────
   private startCounting(remaining: number): void {
     if (remaining <= 0) return this.finishReview();

package/src/share.ts

@@ -0,0 +1,47 @@
+/**
+ * Publish a review session 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
+ * Share button, so the two share exactly the same path.
+ */
+
+import { DEFAULT_SHARE_HOST, DEFAULT_SHARE_PORT, SHARE_UPLOAD_USER, packSessionBlob } from "@cueloop/daemon/share-blob";
+import type { ReviewSession } from "@cueloop/schema";
+import { copyToClipboard } from "./clipboard";
+
+export interface ShareTarget {
+  host?: string;
+  port?: number;
+}
+
+export interface ShareResult {
+  /** The one line to paste: `ssh p_xxxxxxxx@host`. */
+  line: string;
+  /** Whether the line made it onto the system clipboard. */
+  copied: boolean;
+}
+
+/** Upload the session to the gateway and copy the resulting ssh line. */
+export async function publishShare(session: ReviewSession, target: ShareTarget = {}): Promise<ShareResult> {
+  const line = await uploadOverSsh(packSessionBlob(session), target.host ?? DEFAULT_SHARE_HOST, target.port ?? DEFAULT_SHARE_PORT);
+  const copied = await copyToClipboard(line);
+  return { line, copied };
+}
+
+/** Stream the blob to `share@host:port` over the system `ssh` client. */
+async function uploadOverSsh(blob: Buffer, host: string, port: number): Promise<string> {
+  const proc = Bun.spawn(
+    ["ssh", "-p", String(port), "-o", "StrictHostKeyChecking=accept-new", `${SHARE_UPLOAD_USER}@${host}`, "cueloop-share"],
+    { stdin: blob, stdout: "pipe", stderr: "pipe" },
+  );
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (code !== 0) throw new Error(`gateway upload failed: ${stderr.trim() || `ssh exited ${code}`}`);
+  const line = stdout.trim();
+  if (!line.startsWith("ssh ")) throw new Error(`unexpected gateway reply: ${line || "(empty)"}`);
+  return line;
+}

package/src/view-diff.test.ts

@@ -21,7 +21,10 @@ index 111..222 100644
 
 describe("diffRows", () => {
   test("flattens files, hunks, and signed lines with line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
+
+    // Assert
     expect(rows[0]).toMatchObject({ kind: "file", file: "src/store.ts" });
     expect(rows[1]!.kind).toBe("hunk");
     const del = rows.find((row) => row.kind === "del")!;
@@ -36,7 +39,10 @@ describe("diffRows", () => {
   });
 
   test("context lines carry both line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
+
+    // Assert
     const ctx = rows.find((row) => row.kind === "ctx")!;
     expect(ctx.oldLine).toBe(1);
     expect(ctx.newLine).toBe(1);
@@ -45,9 +51,14 @@ describe("diffRows", () => {
 
 describe("diffRowAnchor", () => {
   test("quote is the line, neighbors are the context selectors", () => {
+    // Arrange
     const rows = diffRows(PATCH);
     const rowIndex = rows.findIndex((row) => row.text.includes("new Map()"));
+
+    // Act
     const anchor = diffRowAnchor(rows, rowIndex);
+
+    // Assert
     expect(anchor.quote).toContain("new Map()");
     expect(anchor.prefix.length).toBeGreaterThan(0);
     expect(anchor.suffix.length).toBeGreaterThan(0);

package/src/view-diff.ts

@@ -29,28 +29,28 @@ export function diffRows(patchText: string): DiffRow[] {
         let newLine = hunk.additionStart;
         for (const segment of hunk.hunkContent) {
           if (segment.type === "context") {
-            for (let i = 0; i < segment.lines; i++) {
+            for (let lineOffset = 0; lineOffset < segment.lines; lineOffset++) {
               rows.push({
                 kind: "ctx",
-                text: file.additionLines[segment.additionLineIndex + i] ?? "",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 oldLine: oldLine++,
                 newLine: newLine++,
               });
             }
           } else {
-            for (let i = 0; i < segment.deletions; i++) {
+            for (let lineOffset = 0; lineOffset < segment.deletions; lineOffset++) {
               rows.push({
                 kind: "del",
-                text: file.deletionLines[segment.deletionLineIndex + i] ?? "",
+                text: file.deletionLines[segment.deletionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 oldLine: oldLine++,
               });
             }
-            for (let i = 0; i < segment.additions; i++) {
+            for (let lineOffset = 0; lineOffset < segment.additions; lineOffset++) {
               rows.push({
                 kind: "add",
-                text: file.additionLines[segment.additionLineIndex + i] ?? "",
+                text: file.additionLines[segment.additionLineIndex + lineOffset] ?? "",
                 file: file.name,
                 newLine: newLine++,
               });

package/src/view-plan.test.ts

@@ -25,36 +25,57 @@ The daemon persists sessions to disk atomically.
 
 describe("buildDisplay reconciliation", () => {
   test("no working copy: everything is same", () => {
+    // Act
     const display = buildDisplay(BASE);
+
+    // Assert
     expect(display.every((block) => block.type === "same")).toBe(true);
   });
 
   test("reworded block pairs as mod (similar)", () => {
+    // Arrange
     const working = BASE.replace("persists sessions to disk", "writes sessions to disk");
+
+    // Act
     const display = buildDisplay(BASE, working);
+
+    // Assert
     const mod = display.find((block) => block.type === "mod")!;
     expect(mod.base!.text).toContain("persists");
     expect(mod.work!.text).toContain("writes");
   });
 
   test("unrelated cut + insert do NOT merge into a mod", () => {
+    // Arrange
     const working = BASE.replace("- second item\n", "") + "\nA totally new closing note.\n";
+
+    // Act
     const display = buildDisplay(BASE, working);
+
+    // Assert
     expect(display.some((block) => block.type === "del" && block.base!.text === "second item")).toBe(true);
     expect(display.some((block) => block.type === "add" && block.work!.text.includes("closing note"))).toBe(true);
     expect(display.some((block) => block.type === "mod")).toBe(false);
   });
 
   test("ordered list items get running numbers", () => {
+    // Act
     const display = buildDisplay("1. one\n2. two\n3. three\n");
+
+    // Assert
     expect(display.map((block) => block.orderedItemNumber)).toEqual([1, 2, 3]);
   });
 });
 
 describe("blockRuns + overlayMarks", () => {
   test("mod blocks emit word-diff runs that reconstruct both sides", () => {
+    // Arrange
     const block = buildDisplay("plain old text here\n", "plain new text here\n")[0]!;
+
+    // Act
     const runs = blockRuns(block, true);
+
+    // Assert
     const oldSide = runs.filter((run) => run.role !== "ins").map((run) => run.text).join("");
     const newSide = runs.filter((run) => run.role !== "del").map((run) => run.text).join("");
     expect(oldSide).toBe("plain old text here");
@@ -62,9 +83,14 @@ describe("blockRuns + overlayMarks", () => {
   });
 
   test("marks bind to working-text offsets and skip del runs", () => {
+    // Arrange
     const block = buildDisplay("old words linger\n", "new words linger\n")[0]!;
     const runs = blockRuns(block, true);
+
+    // Act
     const marked = overlayMarks(runs, [{ start: 4, end: 9, role: "mark-comment" }]); // "words"
+
+    // Assert
     const markedText = marked.filter((run) => run.role === "mark-comment").map((run) => run.text).join("");
     expect(markedText).toBe("words");
     // del run text untouched
@@ -72,14 +98,20 @@ describe("blockRuns + overlayMarks", () => {
   });
 
   test("marks never override ins emphasis", () => {
+    // Arrange
     const block = buildDisplay("keep\n", "keep added\n")[0]!;
+
+    // Act
     const runs = overlayMarks(blockRuns(block, true), [{ start: 0, end: 10, role: "mark-comment" }]);
+
+    // Assert
     expect(runs.some((run) => run.role === "ins")).toBe(true);
   });
 });
 
 describe("marksByDisplay", () => {
   test("annotations resolve into display coordinates", () => {
+    // Arrange
     const working = BASE.replace("first item", "first item edited beyond recognition of it");
     const display = buildDisplay(BASE, working);
     const ann: Annotation = {
@@ -89,13 +121,18 @@ describe("marksByDisplay", () => {
       body: "define atomically",
       createdAt: "",
     };
+
+    // Act
     const map = marksByDisplay([ann], display);
+
+    // Assert
     const [displayIndex, marks] = [...map.entries()][0]!;
     expect(displayText(display[displayIndex]!)).toContain("atomically");
     expect(marks[0]!.annotationId).toBe("a1");
   });
 
   test("orphaned annotations produce no marks", () => {
+    // Arrange
     const display = buildDisplay(BASE);
     const ann: Annotation = {
       id: "a1",
@@ -104,25 +141,35 @@ describe("marksByDisplay", () => {
       body: "",
       createdAt: "",
     };
+
+    // Assert
     expect(marksByDisplay([ann], display).size).toBe(0);
   });
 });
 
 describe("rendered/work offset mapping", () => {
   test("plain blocks map 1:1 in both directions", () => {
+    // Arrange
     const block = buildDisplay("alpha beta gamma\n")[0]!;
     const runs = blockRuns(block, true);
+
+    // Assert
     expect(renderedOffsetFor(runs, 6)).toBe(6);
     expect(workRangeForRendered(runs, 6, 10)).toEqual({ start: 6, end: 10 });
   });
 
   test("inline del runs shift rendered offsets in word-diffed blocks", () => {
+    // Arrange
     // rendered: "old new words linger" - "old " is a del run without offsets
     const block = buildDisplay("old words linger\n", "new words linger\n")[0]!;
     const runs = blockRuns(block, true);
     const workText = displayText(block);
     const wordsAt = workText.indexOf("words");
+
+    // Act
     const rendered = renderedOffsetFor(runs, wordsAt)!;
+
+    // Assert
     const renderedText = runs.map((run) => run.text).join("");
     expect(renderedText.slice(rendered, rendered + "words".length)).toBe("words");
     // reading a rendered selection over "words" recovers the work range
@@ -133,16 +180,24 @@ describe("rendered/work offset mapping", () => {
   });
 
   test("a rendered selection spanning a del run keeps only positioned text", () => {
+    // Arrange
     const block = buildDisplay("old words\n", "new words\n")[0]!;
     const runs = blockRuns(block, true);
     const renderedText = runs.map((run) => run.text).join("");
+
+    // Act
     // select everything rendered: the work range is the whole work text
     const range = workRangeForRendered(runs, 0, renderedText.length)!;
+
+    // Assert
     expect(displayText(block).slice(range.start, range.end)).toBe(displayText(block));
   });
 
   test("offsets outside any positioned run map to null", () => {
+    // Arrange
     const runs = blockRuns(buildDisplay("short\n")[0]!, true);
+
+    // Assert
     expect(renderedOffsetFor(runs, 99)).toBeNull();
     expect(workRangeForRendered(runs, 90, 99)).toBeNull();
   });
@@ -151,28 +206,54 @@ describe("rendered/work offset mapping", () => {
 describe("span mode", () => {
   const text = "one two three four";
   test("v selects the first word; l grows; w slides; $ to end", () => {
+    // Act
     let span = startSpan(0, text)!;
+
+    // Assert
     expect(text.slice(span.start, span.end)).toBe("one");
+
+    // Act
     span = spanKey(span, "l", text);
+
+    // Assert
     expect(text.slice(span.start, span.end)).toBe("one two");
+
+    // Act
     span = spanKey(span, "w", text);
+
+    // Assert
     expect(text.slice(span.start, span.end)).toBe("two three");
+
+    // Act
     span = spanKey(span, "$", text);
+
+    // Assert
     expect(text.slice(span.start, span.end)).toBe("two three four");
   });
 });
 
 describe("cut / restore round-trip", () => {
   test("cut removes the block lines; restore puts them back", () => {
+    // Arrange
     const blocks = parseBlocks(BASE);
     const listItem = blocks.find((candidate) => candidate.text === "second item")!;
+
+    // Act
     const cut = cutBlock(BASE, listItem);
+
+    // Assert
     expect(cut).not.toContain("second item");
+
+    // Arrange
     const display = buildDisplay(BASE, cut);
     const deletedIndex = display.findIndex((block) => block.type === "del");
     const line = restoreLine(nextWorkBlock(display, deletedIndex), cut.split("\n").length);
+
+    // Act
     // undefined = the working copy round-tripped back to the submitted revision
     const restored = restoreBlock(BASE, cut, listItem, line);
+
+    // Assert
     expect(restored).toBeUndefined();
     expect(buildDisplay(BASE, restored).every((block) => block.type === "same")).toBe(true);
   });

package/src/view-plan.ts

@@ -8,6 +8,7 @@
  */
 
 import {
+  isAddressed,
   lcsDiff,
   parseBlocks,
   resolveAnchor,
@@ -161,6 +162,8 @@ export function marksByDisplay(
   const workBlocks = workEntries.map((entry) => entry.block.work!);
   const marksByIndex = new Map<number, Mark[]>();
   for (const annotation of annotations) {
+    // an addressed annotation keeps its record but paints no highlight
+    if (isAddressed(annotation)) continue;
     const resolved = resolveAnchor(annotation.anchor, workBlocks);
     if (!resolved) continue;
     const entry = workEntries[resolved.blockIndex];

package/src/walk.test.ts

@@ -92,12 +92,16 @@ describe("noteForFile", () => {
   });
 
   test("finds the note anchored at the file path", () => {
+    // Arrange
     const annotations = [note("src/a.ts", "Renames b and adds c."), note("src/b.ts", "Swaps the line.")];
+
+    // Assert
     expect(noteForFile(annotations, "src/b.ts")).toBe("Swaps the line.");
     expect(noteForFile(annotations, "src/c.ts")).toBeUndefined();
   });
 
   test("ignores non-note annotations that happen to quote the path", () => {
+    // Arrange
     const comment: Annotation = {
       id: "a_1",
       kind: "comment",
@@ -105,6 +109,8 @@ describe("noteForFile", () => {
       body: "not a note",
       createdAt: "now",
     };
+
+    // Assert
     expect(noteForFile([comment], "src/a.ts")).toBeUndefined();
   });
 });