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

package/src/App.share-dialog.test.tsx

@@ -0,0 +1,172 @@
+/** The share shortcut opens the two-column share dialog reachable from any view. */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import type { ShareTransport } from "./thread-controller";
+import {
+  isolateUserConfig,
+  press,
+  pressKey,
+  settle,
+  waitForText,
+  waitForTextGone,
+} from "./test-support";
+
+const shareTransport: ShareTransport = {
+  publish: mock(async () => ({ line: "ssh p_share01@cueloop.dev", copied: true })),
+  pull: mock(async () => {
+    throw new Error("Unexpected share pull");
+  }),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  revoke: async () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
+  collaboratorAnnotations: () => [],
+  mergeFromShare: () => ({ annotations: [] }),
+};
+
+const PLAN = `# Migration Plan\n\n## Context\n\nThe daemon persists sessions to disk atomically.\n`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-share-choice-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("share dialog", () => {
+  test("the shortcut opens the two-column share dialog", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "s", { ctrl: true });
+
+    // Assert - the nav categories and the empty-state new-link affordance
+    await waitForText(setup, "share externally");
+    await waitForText(setup, "export");
+    await waitForText(setup, "+ new link");
+  });
+
+  test("new link opens the wizard, and require auth reveals the allowlist", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act: open the dialog, step into the body, activate "+ new link"
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "+ new link");
+    await press(setup, "enter");
+    await press(setup, "enter");
+
+    // Assert - the wizard's fields
+    await waitForText(setup, "link name");
+    await waitForText(setup, "require auth");
+
+    // Act: focus the auth row and switch it on (enter toggles the focused row)
+    await press(setup, "down");
+    await press(setup, "enter");
+
+    // Assert - the handles input appears with its grayed placeholder
+    await waitForText(setup, "handle");
+
+    // Act: backspace on the empty allowlist collapses require auth back off
+    await press(setup, "backspace");
+
+    // Assert - the handles section is gone
+    await waitForTextGone(setup, "handle");
+  });
+
+  test("a private link with no handles cannot be created", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act: open the wizard, turn auth on but add no handles, then try to create
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "+ new link");
+    await press(setup, "enter"); // into the body
+    await press(setup, "enter"); // open the wizard
+    await waitForText(setup, "require auth");
+    await press(setup, "down"); // focus the auth row
+    await press(setup, "enter"); // toggle auth on (focus moves to the empty allowlist)
+    await press(setup, "down"); // move to the create action
+    await press(setup, "enter"); // create is blocked while the allowlist is empty
+    await settle(setup);
+
+    // Assert - the wizard is still open (nothing was created and the dialog did not fall back to the list)
+    expect(setup.captureCharFrame()).toContain("require auth");
+  });
+
+  test("right enters the links body and left returns to the nav", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act + Assert: right arrow crosses into the body (its hint appears)
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "+ new link");
+    await press(setup, "right");
+    await waitForText(setup, "h back");
+
+    // Act + Assert: left arrow returns to the nav (its hint returns)
+    await press(setup, "left");
+    await waitForText(setup, "l/enter open");
+  });
+
+  test("escape closes the dialog", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "share externally");
+    await press(setup, "escape");
+
+    // Assert
+    await waitForTextGone(setup, "share externally");
+  });
+});

package/src/App.submit-confirm.test.tsx

@@ -99,8 +99,8 @@ describe("send message confirm", () => {
     const frame = setup.captureCharFrame();
 
     expect(frame).toContain("[Approve]");
-    expect(frame).toContain(" send message ");
-    expect(frame).toContain(" Cancel ");
+    expect(frame).toContain(" send ");
+    expect(frame).toContain(" cancel ");
   });
 
   test("left/right cycles the verdict selector in the overlay", async () => {
@@ -146,7 +146,7 @@ describe("send message confirm", () => {
     // Assert - a bare ESC settles after the parser's escape-sequence window
     const frame = await waitForTextGone(setup, "[Approve]");
 
-    expect(frame).not.toContain(" Cancel ");
+    expect(frame).not.toContain(" cancel ");
   });
 
   test("enter in the overlay resolves the session through the controller", async () => {
@@ -157,12 +157,14 @@ describe("send message confirm", () => {
     // Act
     await pressKey(setup, "RETURN", { meta: true });
 
-    // Assert
-    await waitForText(setup, "[Changes]"); // pending items: request changes default
+    // Assert - opens on the default verdict, then cycle to request changes
+    await waitForText(setup, "[Approve]");
+    await press(setup, "right");
+    await waitForText(setup, "[Changes]");
 
     // Act
     await setup.mockInput.typeText("Tighten the steps.");
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert - the completion flow after submit is unchanged
     await waitForText(setup, "feedback sent");
@@ -172,6 +174,35 @@ describe("send message confirm", () => {
     expect(stored.verdict!.kind).toBe("request_changes");
   });
 
+  test("typing / in the summary opens the skills/actions palette", async () => {
+    // Arrange
+    seedAnnotations(1);
+    const setup = await renderApp();
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "[Approve]");
+
+    // Act
+    await setup.mockInput.typeText("/restate");
+
+    // Assert - the same slash palette the inline composer shows
+    await waitForText(setup, "restate-simplified");
+  });
+
+  test("pasting an image into the summary drops in an [Image #n] placeholder", async () => {
+    // Arrange
+    const setup = await renderApp();
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "[Approve]");
+
+    // Act - a burst of control bytes stands in for the binary an image paste delivers
+    await setup.mockInput.typeText("look at this ");
+    await setup.mockInput.pasteBracketedText("
");
+
+    // Assert - the raw bytes never reach the draft; a numbered placeholder does
+    await waitForText(setup, "[Image #1]");
+    expect(setup.captureCharFrame()).toContain("look at this [Image #1]");
+  });
+
   test("read-only observers cannot open the confirm overlay", async () => {
     // Arrange
     seedAnnotations(1);
@@ -184,8 +215,8 @@ describe("send message confirm", () => {
     // Assert - no overlay, and the session stays pending
     const frame = setup.captureCharFrame();
 
-    expect(frame).not.toContain("[Changes]");
-    expect(frame).not.toContain(" Cancel ");
+    expect(frame).not.toContain("[Approve]");
+    expect(frame).not.toContain(" cancel ");
     expect(server.core.sessionGet(session.id).status).toBe("pending");
   });
 });

package/src/App.test.tsx

@@ -15,6 +15,7 @@ import {
   isolateUserConfig,
   locateText,
   press,
+  navCommand,
   pressKey,
   renderReadyApp,
   typeText as type,
@@ -152,7 +153,7 @@ describe("thread view grammar", () => {
     await clickText(setup, "move the store");
 
     // Act
-    await pressKey(setup, "x", { meta: true });
+    await navCommand(setup, "x");
 
     // Assert - the cut lands in the working copy
     await waitForState(
@@ -161,31 +162,31 @@ describe("thread view grammar", () => {
     );
 
     // Act
-    await pressKey(setup, "x", { meta: true });
+    await navCommand(setup, "x");
 
     // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).workingCopy === undefined);
   });
 
-  test("ctrl+e runs $EDITOR on the working copy and tracks the diff", async () => {
-    const script = join(home, "fake-editor.sh");
-
-    await Bun.write(script, `#!/bin/sh\nsed -i '' 's/atomically/very atomically/' "$1"\n`);
-    Bun.spawnSync(["chmod", "+x", script]);
-    process.env.CUELOOP_EDITOR = script;
-    try {
-      // Arrange
-      const setup = await renderApp();
-
-      // Act
-      await pressKey(setup, "e", { ctrl: true });
-
-      // Assert
-      await waitForText(setup, "[edited]");
-      expect(server.core.sessionGet(session.id).workingCopy).toContain("very atomically");
-    } finally {
-      delete process.env.CUELOOP_EDITOR;
-    }
+  test("ctrl+e opens the inline editor; the header toggles to normal and leaving tracks the edit", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Act - open the inline markdown editor over the thread body
+    await pressKey(setup, "e", { ctrl: true });
+
+    // Assert - the editor owns the pane (its save hint shows) and the header offers the way back
+    await waitForText(setup, "save & close");
+    expect(setup.captureCharFrame()).toContain("normal");
+
+    // Act - type into the body, then leave through the header toggle
+    await type(setup, "MORE");
+    await clickText(setup, "normal");
+
+    // Assert - the edit is tracked into the working copy, and the read-only view is back
+    await waitForState(setup, () =>
+      (server.core.sessionGet(session.id).workingCopy ?? "").includes("MORE"),
+    );
   });
 });
 
@@ -202,12 +203,14 @@ describe("submit", () => {
     // Act: with no composer open the same chord opens submit
     await pressKey(setup, "RETURN", { meta: true });
 
-    // Assert
-    await waitForText(setup, "[Changes]");
+    // Assert - the card opens on the default verdict, approve
+    await waitForText(setup, "[Approve]");
 
-    // Act
+    // Act - cycle to request changes, then send with a summary
+    await press(setup, "right");
+    await waitForText(setup, "[Changes]");
     await type(setup, "Expand the steps.");
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
     await waitForText(setup, "feedback sent");
@@ -231,7 +234,7 @@ describe("submit", () => {
     await waitForText(setup, "[Approve]"); // no pending items → approve default
 
     // Act
-    await press(setup, "enter");
+    await pressKey(setup, "RETURN", { meta: true });
 
     // Assert
     await waitForState(setup, () => server.core.sessionGet(session.id).verdict !== undefined);
@@ -333,7 +336,7 @@ describe("no-thread shell", () => {
 
     // Assert - the settings dialog with its Keybinds leaf appears
     await waitForText(setup, "Keybinds");
-    expect(setup.captureCharFrame()).toContain("Settings");
+    expect(setup.captureCharFrame()).toContain("settings");
 
     // Act - escape closes the menu (not a trap), and the thread nav still works
     await press(setup, "escape");
@@ -364,7 +367,7 @@ describe("the thread view and the menu", () => {
     // Assert - the thread grammar, not the plan sheet's
     const dialog = setup.captureCharFrame();
 
-    expect(dialog).toContain("⌘⌥m");
+    expect(dialog).toContain("nav mode");
     expect(dialog).toContain("place the caret");
     expect(dialog).not.toContain("grow/shrink");
 
@@ -385,13 +388,13 @@ describe("the thread view and the menu", () => {
     await setup.mockMouse.click(1, 0);
     await waitForText(setup, "Keybinds");
 
-    // the nav folder is the last "Settings" on screen (the first is the dialog title)
+    // the nav folder is the last "settings" on screen (the first is the dialog title)
     const lines = setup.captureCharFrame().split("\n");
     let folderRow = -1;
     let folderColumn = -1;
 
     lines.forEach((line, row) => {
-      const column = line.indexOf("Settings");
+      const column = line.indexOf("settings");
 
       if (column !== -1) {
         folderColumn = column;

package/src/App.toast.test.tsx

@@ -28,7 +28,9 @@ const shareTransport: ShareTransport = {
   }),
   push: mock(async () => {}),
   watch: () => () => {},
+  revoke: async () => {},
   parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  formatShareLine: (id: string) => "ssh " + id + "@cueloop.dev",
   collaboratorAnnotations: () => [],
   mergeFromShare: () => ({ annotations: [] }),
 };
@@ -73,11 +75,16 @@ describe("share toast", () => {
 
     await waitForText(setup, "cueloop");
 
-    // Act: share opens the choice, enter picks public and raises the toast, then a composer under it
+    // Act: share opens the dialog, the new-link wizard publishes and raises the toast, then a composer under it
     await pressKey(setup, "s", { ctrl: true });
-    await waitForText(setup, "public link");
-    await press(setup, "enter");
-    await waitForText(setup, "share link copied");
+    await waitForText(setup, "+ new link");
+    await press(setup, "enter"); // step into the links body
+    await press(setup, "enter"); // activate "+ new link" - the wizard opens
+    await waitForText(setup, "link name");
+    await press(setup, "enter"); // the name field submits and creates the link
+    await waitForText(setup, "link copied");
+    await press(setup, "escape"); // close the dialog; the non-modal toast stays up
+    await waitForTextGone(setup, "share externally");
     await clickText(setup, "daemon");
     await typeText(setup, "x");
     await waitForText(setup, "● x");