@cueloop/client 0.1.0-alpha.0 → 0.1.0-alpha.100

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

@@ -0,0 +1,177 @@
+/** 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/thread-controller";
+import {
+  isolateUserConfig,
+  press,
+  pressKey,
+  settle,
+  waitForText,
+  waitForTextGone,
+} from "../testing/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/App.submit-confirm.test.tsx

@@ -0,0 +1,267 @@
+/** The send-message confirm: cmd+enter opens a centered overlay with a message selector, summary input, and word-buttons. Char-frame assertions over the real App and an in-process daemon, like App.test.tsx. */
+
+import { afterEach, beforeEach, describe, expect, 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 { makeAnchor, parseBlocks, type Thread } from "@cueloop/schema";
+import { App } from "./App";
+import {
+  isolateUserConfig,
+  press,
+  pressKey,
+  settle,
+  waitForText,
+  waitForTextGone,
+} from "../testing/test-support";
+
+const PLAN = `# Migration Plan
+
+## Context
+
+The daemon persists sessions to disk atomically.
+
+## Steps
+
+- move the store
+- add recovery
+`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-confirm-"));
+  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 });
+});
+
+async function renderApp(options: { readOnly?: boolean } = {}) {
+  const setup = await testRender(
+    <App home={home} sessionId={session.id} readOnly={options.readOnly ?? false} />,
+    {
+      width: 120,
+      height: 32,
+    },
+  );
+
+  await waitForText(setup, "cueloop");
+
+  return setup;
+}
+
+/** Seed annotations directly through the daemon core (all on one block). */
+function seedAnnotations(count: number): void {
+  const blocks = parseBlocks(PLAN);
+
+  for (let index = 1; index <= count; index++) {
+    server.core.sessionAnnotate(session.id, {
+      id: `a_confirm_${index}`,
+      kind: "comment",
+      anchor: makeAnchor(blocks, 2, 0, 10),
+      body: `note ${String(index).padStart(2, "0")}`,
+    });
+  }
+}
+
+describe("send message confirm", () => {
+  test("cmd+enter opens the send-message confirm overlay with stable message choices", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Assert - the footer carries the send control before the overlay opens
+    expect(setup.captureCharFrame()).toContain("Send message (0)");
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the overlay: message selector and word-buttons
+    await waitForText(setup, "[approve]"); // nothing pending: approve default
+    const initialFrame = setup.captureCharFrame();
+    const initialSelector = initialFrame
+      .split("\n")
+      .find((row) => row.includes("[comment] [approve] [changes]"));
+
+    expect(initialSelector).toBeDefined();
+    expect(initialFrame).toContain(" send ");
+    expect(initialFrame).toContain(" cancel ");
+
+    // Act - move the active choice across the selector
+    await press(setup, "right");
+    const changesSelector = setup
+      .captureCharFrame()
+      .split("\n")
+      .find((row) => row.includes("[comment] [approve] [changes]"));
+
+    await press(setup, "right");
+    const commentSelector = setup
+      .captureCharFrame()
+      .split("\n")
+      .find((row) => row.includes("[comment] [approve] [changes]"));
+
+    // Assert - active styling does not move or resize any choice
+    expect(changesSelector).toBe(initialSelector);
+    expect(commentSelector).toBe(initialSelector);
+  });
+
+  test("left/right cycles the message selector in the overlay", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "[approve]");
+
+    // Act
+    await press(setup, "right");
+
+    // Assert
+    await waitForText(setup, "[changes]");
+
+    // Act
+    await press(setup, "right");
+
+    // Assert
+    await waitForText(setup, "[comment]");
+
+    // Act
+    await press(setup, "left");
+
+    // Assert
+    await waitForText(setup, "[changes]");
+  });
+
+  test("esc closes the overlay", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "[approve]");
+
+    // Act
+    await press(setup, "escape");
+
+    // Assert - a bare ESC settles after the parser's escape-sequence window
+    const frame = await waitForTextGone(setup, "[approve]");
+
+    expect(frame).not.toContain(" cancel ");
+  });
+
+  test("enter in the overlay resolves the session through the controller", async () => {
+    // Arrange
+    seedAnnotations(1);
+    const setup = await renderApp();
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - opens on the default message, 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 pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the completion flow after submit is unchanged
+    await waitForText(setup, "feedback sent");
+    const stored = server.core.sessionGet(session.id);
+
+    expect(stored.status).toBe("resolved");
+    expect(stored.message!.outcome).toBe("changes_requested");
+  });
+
+  test("Comment sends feedback while leaving the Thread open", async () => {
+    seedAnnotations(1);
+    const setup = await renderApp();
+
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "[approve]");
+    await press(setup, "left");
+    await waitForText(setup, "[comment]");
+
+    await setup.mockInput.typeText("For now.");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    await waitForText(setup, "comment sent - thread stays open");
+    const stored = server.core.sessionGet(session.id);
+
+    expect(stored.status).toBe("pending");
+    expect(stored.message!.outcome).toBe("comment");
+    expect(stored.message!.annotations?.map((annotation) => annotation.id)).toEqual([
+      "a_confirm_1",
+    ]);
+    expect(setup.captureCharFrame()).not.toContain("feedback sent");
+  });
+
+  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);
+    const setup = await renderApp({ readOnly: true });
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true });
+    await settle(setup);
+
+    // Assert - no overlay, and the session stays pending
+    const frame = setup.captureCharFrame();
+
+    expect(frame).not.toContain("[approve]");
+    expect(frame).not.toContain(" cancel ");
+    expect(server.core.sessionGet(session.id).status).toBe("pending");
+  });
+});