@cueloop/client 0.1.0-alpha.98 → 0.1.0-alpha.99

package/src/thread/agent-transcript.ts

@@ -169,6 +169,7 @@ export function projectThreadConversation(
     submissionId?: string,
   ): void => {
     const blocks: DisplayBlock[] = buildDisplay(quote);
+
     if (!blocks.length)
       blocks.push({
         type: "same",
@@ -198,6 +199,7 @@ export function projectThreadConversation(
       const replies = [...thread.annotations, ...state.comments].filter(
         (entry) => entry.replyTo === commentId,
       );
+
       for (const reply of replies) {
         const replica = {
           ...annotation,
@@ -227,6 +229,7 @@ export function projectThreadConversation(
             ],
           ],
         ]);
+
     for (const [index, values] of localMarks) {
       marks.set(
         index + offset,
@@ -273,6 +276,7 @@ export function projectThreadConversation(
       );
     }
   };
+
   if (state.submissions?.length) {
     for (const submission of state.submissions) {
       // A prompt may use its submission ID as a discussion root; that is not an inline comment.

package/src/thread/components/AgentConfigControls.test.tsx

@@ -43,6 +43,7 @@ const initial: ThreadAgentState = {
 
 test("model and reasoning choices share the existing overlay and close after selection", async () => {
   const choices: string[] = [];
+
   function TestMenus(): React.ReactNode {
     const menu = useMenuControlState();
     const [state, setState] = useState(initial);
@@ -95,6 +96,7 @@ test("model and reasoning choices share the existing overlay and close after sel
     await click("Second model");
     expect(setup.captureCharFrame()).not.toContain("Extra model 17");
     const model = locateText(setup, "First model");
+
     for (let count = 0; count < 12; count++)
       await setup.mockMouse.scroll(model.column, model.row, "down");
     await settle(setup);

package/src/thread/components/AgentThreadPane.test.tsx

@@ -127,8 +127,9 @@ test("typing on the final blank line invokes the agent while the existing footer
     expect(prompts).toHaveLength(0);
     await setup.mockMouse.click(artifact.column, artifact.row);
     await setup.mockMouse.click(artifact.column, artifact.row + 2);
-    await typeText(setup, " retries");
-    await pressKey(setup, "RETURN", { ctrl: true });
+    // Submit the typing burst before waiting for content-change repaint.
+    await setup.mockInput.typeText(" retries");
+    setup.mockInput.pressKey("RETURN", { ctrl: true });
     await waitForText(setup, "The timer survives cancellation.");
     expect(prompts[0]?.text).toBe("Explain retries");
     const send = locateText(setup, "Send message (0)");
@@ -265,6 +266,7 @@ test("three bottom prompts survive delayed acceptance and remain separate submis
   const { client } = createTestAgentClient(empty);
   let release: ((state: ThreadAgentState) => void) | undefined;
   const prompts: string[] = [];
+
   client.agentPrompt = async (params) => {
     prompts.push(params.text);
     if (prompts.length === 1)
@@ -319,8 +321,10 @@ test("typing on an accepted plain prompt cannot edit it or create an unmarked co
   };
   const { client } = createTestAgentClient(state);
   const replies: string[] = [];
+
   client.agentComment = async (params) => {
     replies.push(params.comment.replyTo ?? "");
+
     return state;
   };
   const setup = await testRender(
@@ -411,17 +415,21 @@ test("comments on a later paragraph of agent output save editable and submit ind
     ],
   };
   const { client, prompts } = createTestAgentClient(state);
+
   client.agentComment = async ({ comment }) => {
     state = {
       ...state,
       comments: [...state.comments.filter((entry) => entry.id !== comment.id), comment],
     };
+
     return state;
   };
   const prompt = client.agentPrompt;
+
   client.agentPrompt = async (params) => {
     await prompt(params);
     state = { ...state, comments: state.comments.map((comment) => ({ ...comment, sent: true })) };
+
     return state;
   };
   const setup = await testRender(
@@ -472,8 +480,10 @@ for (const policy of [
   test(`disabled or shared agent views retain the original document without opening a harness (${JSON.stringify(policy)})`, async () => {
     let reads = 0;
     const { client } = createTestAgentClient(empty);
+
     client.agentGet = async () => {
       reads++;
+
       return empty;
     };
     const setup = await testRender(
@@ -505,6 +515,7 @@ test("empty Thread typing and accepted prompts use normal paragraph padding with
   const value = { ...thread, artifact: { ...thread.artifact, content: "" } };
   let accepted = empty;
   const { client, prompts } = createTestAgentClient(empty);
+
   client.agentPrompt = async (params) => {
     prompts.push(params);
     accepted = {
@@ -567,7 +578,15 @@ test("clicking whitespace below the conversation focuses a blinking prompt befor
     const text = locateText(setup, "Original artifact");
 
     await setup.mockMouse.click(text.column + 20, text.row + 5);
-    await settle(setup);
+    await waitForState(
+      setup,
+      () => {
+        const cursor = setup.renderer.getCursorState();
+
+        return cursor.visible && cursor.blinking;
+      },
+      "continuation cursor focused",
+    );
     expect(setup.renderer.getCursorState()).toMatchObject({ visible: true, blinking: true });
     expect(prompts).toHaveLength(0);
     await typeText(setup, "A prompt from whitespace");
@@ -603,6 +622,7 @@ test("an arriving reply preserves a bottom draft and submits it as the next prom
       },
     ],
   };
+
   client.agentPrompt = async (params) => {
     prompts.push(params);
     if (prompts.length === 1)
@@ -670,15 +690,41 @@ test("clicking the first blank row after a reply opens continuation without losi
 
   try {
     await waitForText(setup, "The final reply.");
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor !== null,
+      "initial continuation focus ready",
+    );
     await pressKey(setup, "ESCAPE");
+    await waitForState(
+      setup,
+      () => setup.renderer.currentFocusedEditor === null,
+      "continuation dismissed",
+    );
     const reply = locateText(setup, "The final reply.");
 
     await setup.mockMouse.click(reply.column + 5, reply.row + 1);
-    await settle(setup);
+    await waitForState(
+      setup,
+      () => {
+        const cursor = setup.renderer.getCursorState();
+
+        return setup.renderer.currentFocusedEditor !== null && cursor.visible && cursor.blinking;
+      },
+      "continuation cursor focused",
+    );
     expect(setup.renderer.getCursorState()).toMatchObject({ visible: true, blinking: true });
     await typeText(setup, "Continue here");
     await setup.mockMouse.click(reply.column + 5, reply.row + 1);
-    await settle(setup);
+    await waitForState(
+      setup,
+      () => {
+        const cursor = setup.renderer.getCursorState();
+
+        return setup.renderer.currentFocusedEditor !== null && cursor.visible && cursor.blinking;
+      },
+      "continuation cursor focused",
+    );
     expect(setup.renderer.getCursorState()).toMatchObject({ visible: true, blinking: true });
     await pressKey(setup, "RETURN", { ctrl: true });
     expect(prompts[0]?.text).toBe("Continue here");
@@ -691,6 +737,7 @@ test("a rejected prompt returns visibly to the composer and can be edited before
   const { client, prompts } = createTestAgentClient(empty);
   let reject = true;
   const acceptPrompt = client.agentPrompt;
+
   client.agentPrompt = async (params) => {
     if (reject) {
       reject = false;
@@ -716,6 +763,7 @@ test("a rejected prompt returns visibly to the composer and can be edited before
   try {
     await waitForText(setup, "Original artifact");
     const artifact = locateText(setup, "Original artifact");
+
     await setup.mockMouse.click(artifact.column, artifact.row + 2);
     await typeText(setup, "Explain retries");
     await pressKey(setup, "RETURN", { ctrl: true });
@@ -760,6 +808,7 @@ test("a failed mutation flush restores the prompt alongside a newer visible draf
   try {
     await waitForText(setup, "Original artifact");
     const artifact = locateText(setup, "Original artifact");
+
     await setup.mockMouse.click(artifact.column, artifact.row + 2);
     await typeText(setup, "First question");
     await pressKey(setup, "RETURN", { ctrl: true });

package/src/thread/components/AgentThreadPane.tsx

@@ -75,6 +75,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
   const busy = state.phase.kind === "running" || state.phase.kind === "permission";
 
   const [pulse, setPulse] = useState(false);
+
   useEffect(() => {
     if (!busy) return;
     const timer = setInterval(() => setPulse((value) => !value), 600);
@@ -99,8 +100,10 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
       />,
     ),
   );
+
   useEffect(() => {
     notifyActive(true);
+
     return () => notifyActive(false);
   }, []);
   useEffect(() => {
@@ -122,8 +125,10 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     try {
       while (invocations.current.length) {
         const input = invocations.current.shift()!;
+
         try {
           const writesSaved = (await Promise.all(input.writes)).every(Boolean);
+
           if (!writesSaved) {
             rejected.push(input.text);
             continue;
@@ -147,12 +152,14 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
     }
   };
   const invokeRef = useRef<() => Promise<void>>(async () => {});
+
   useEffect(() => {
     invokeRef.current = invoke;
   });
   const notifyInvoke = useEffectEvent((invoke: (() => void) | undefined) =>
     props.onInvokeChange?.(invoke),
   );
+
   useEffect(() => {
     notifyInvoke(() => void invokeRef.current());
 
@@ -208,6 +215,7 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
   };
 
   const notifyActions = useEffectEvent(() => props.onActionsChange?.(actionFor));
+
   useEffect(() => {
     notifyActions();
   }, [state, projection]);
@@ -257,14 +265,17 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 
         if (source?.kind === "tail") {
           draft.current = body;
+
           return;
         }
         if (source?.kind === "mirror") {
           if (source.commentId) reply(source.commentId, body);
+
           return;
         }
         if (source?.kind === "artifact" && end?.kind === "artifact") {
           child?.onAnnotate(span, body);
+
           return;
         }
         if (

package/src/thread/components/ThreadFooter.test.tsx

@@ -21,11 +21,13 @@ test("a long branch truncates on one line and keeps the send control in place",
     </box>,
     { width: 60, height: 3 },
   );
+
   await settle(setup);
   await settle(setup);
 
   const frame = setup.captureCharFrame();
   const footerRow = frame.split("\n").find((line) => line.includes("cueloop"))!;
+
   // the repo/branch context and the send control share the single footer row
   expect(footerRow).toContain("Send message (0)");
   // the branch is clipped to an ellipsis, not wrapped onto a second row

package/src/thread/components/thread-tree.test.ts

@@ -4,6 +4,7 @@ import { groupInbox, projectName } from "./thread-tree";
 
 function session(id: string, title: string, rootCommit?: string, remote?: string): Thread {
   const workspace: WorkspaceKey = { repoRoot: `/home/dev/${id}-checkout`, branch: "main" };
+
   if (rootCommit !== undefined) workspace.rootCommit = rootCommit;
   if (remote !== undefined) workspace.remote = remote;
 
@@ -61,6 +62,7 @@ describe("groupInbox", () => {
 
     // Assert
     const labels = rows.map((row) => `${row.kind}:${"label" in row ? row.label : row.id}`);
+
     expect(labels).toEqual([
       "section:Projects",
       "project:widget",
@@ -83,6 +85,7 @@ describe("groupInbox", () => {
 
     // Assert
     const projectRows = rows.filter((row) => row.kind === "project");
+
     expect(projectRows).toHaveLength(1);
     expect(ordered).toHaveLength(2);
   });

package/src/thread/components/thread-tree.ts

@@ -18,6 +18,7 @@ export function projectName(workspace: WorkspaceKey): string {
       .split(/[/:]/)
       .filter((part) => part.length > 0)
       .at(-1);
+
     if (base !== undefined) return base;
   }
 
@@ -66,12 +67,14 @@ export function groupInbox(
     }
 
     const key = session.workspace.rootCommit;
+
     if (key === undefined) {
       standalone.push(session);
       continue;
     }
 
     const existing = projects.get(key);
+
     if (existing !== undefined) existing.sessions.push(session);
     else projects.set(key, { name: projectName(session.workspace), sessions: [session] });
   }
@@ -89,6 +92,7 @@ export function groupInbox(
   }
 
   const projectEntries = [...projects.entries()].sort((a, b) => a[1].name.localeCompare(b[1].name));
+
   if (projectEntries.length > 0) {
     rows.push({ kind: "section", id: "section:projects", label: "Projects" });
     for (const [key, project] of projectEntries) {

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

@@ -450,6 +450,7 @@ describe("diff file fold", () => {
       { path: "src/gone.ts", oldContents: "old line\n", newContents: "", status: "deleted" },
     ];
     const session = diffSession(files);
+
     session.artifact.content = patch;
     session.revisions[0]!.content = patch;
     const { controller } = await connected(session);

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

@@ -134,6 +134,7 @@ describe("live working-tree diff for a non-diff thread", () => {
       openClient: async () => fakeClient(session),
       shareTransport,
     });
+
     controller.connect();
     await tick();
 
@@ -169,6 +170,7 @@ describe("live working-tree diff for a non-diff thread", () => {
       openClient: async () => client,
       shareTransport,
     });
+
     controller.connect();
     await tick();
     await controller.repoChanges();
@@ -213,11 +215,13 @@ describe("live working-tree diff for a non-diff thread", () => {
       openClient: async () => client,
       shareTransport,
     });
+
     controller.connect();
     await tick();
 
     // thread A's diff is still in flight when the user switches to thread B
     const inFlightA = controller.repoChanges();
+
     controller.open("ses_B");
     await controller.repoChanges();
     // B's diff is showing; now A's stale response lands
@@ -272,6 +276,7 @@ describe("frozen vs live diff by thread kind", () => {
       openClient: async () => fakeClient(session),
       shareTransport,
     });
+
     controller.connect();
     await tick();
 
@@ -294,6 +299,7 @@ describe("frozen vs live diff by thread kind", () => {
       openClient: async () => client,
       shareTransport,
     });
+
     controller.connect();
     await tick();
 
@@ -338,6 +344,7 @@ describe("serve mode pins the served thread to a frozen snapshot", () => {
         meta: { workbench: true, snapshot: true },
       },
     });
+
     controller.connect();
     await tick();
 

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

@@ -303,6 +303,7 @@ describe("reply", () => {
 
     // Act
     const id = controller.reply("a1", "agreed");
+
     await tick();
 
     // Assert

package/src/thread/thread-controller.ts

@@ -829,6 +829,7 @@ class Controller implements ReviewController {
 
   async projectFiles(): Promise<string[]> {
     const session = this.snapshot.session;
+
     if (this.client?.projectFiles === undefined || !session) return [];
 
     return this.client.projectFiles(session.id);
@@ -836,6 +837,7 @@ class Controller implements ReviewController {
 
   async readFile(path: string): Promise<string | null> {
     const session = this.snapshot.session;
+
     if (this.client?.fileContents === undefined || !session) return null;
 
     return this.client.fileContents(session.id, path);
@@ -861,6 +863,7 @@ class Controller implements ReviewController {
   async repoChanges(): Promise<readonly DiffFileContents[]> {
     // a plain diff review pins its captured snapshot; a workbench thread and every other thread reflect the live working tree
     const session = this.snapshot.session;
+
     if (readsFrozenDiff(session)) return session!.artifact.files ?? [];
     const initialFiles = this.consumeInitialDiffFiles(session);
 
@@ -871,6 +874,7 @@ class Controller implements ReviewController {
         this.sidebarRepoRoot(),
         session?.artifact.meta.workbench ? (session.artifact.meta.vcs ?? "git") : undefined,
       );
+
       // a thread switch during the request would let this response overwrite the new thread's diff,
       // showing changes from the wrong repo; compare the thread id, not the object, so an unrelated
       // re-render that replaced the snapshot for the SAME thread does not drop its diff to "No changes"
@@ -885,6 +889,7 @@ class Controller implements ReviewController {
             file.oldContents !== diff.files[index]?.oldContents ||
             file.newContents !== diff.files[index]?.newContents,
         );
+
       if (changed) {
         this.liveDiff = diff;
         // rows() derive from the fresh patch; re-render so an open diff tab repaints
@@ -1004,6 +1009,7 @@ class Controller implements ReviewController {
         content: "",
         meta: { title: "New Thread" },
       });
+
       this.locallyViewed.clear();
       this.viewingId = thread.id;
       this.update({ session: thread });
@@ -1737,6 +1743,7 @@ class Controller implements ReviewController {
     const actionBodies = Object.fromEntries(
       slashItemsFrom(this.quickActions).map((item) => [item.name, item.body]),
     );
+
     this.client!.sessionSendMessage(session.id, message, summary, actionBodies)
       .then((resolved) => {
         // The completion overlay heading already states the message, so the
@@ -1835,6 +1842,7 @@ class Controller implements ReviewController {
 
     if (!links.some((link) => link.id === id)) return;
     const allowlist = input.requireAuth ? input.allowlist : [];
+
     // re-push the link's access to its blob: an allowlist for private, "public" clears it
     void this.shareTransport
       .push(id, [], input.requireAuth ? { githubLogins: allowlist } : "public")

package/src/thread/use-thread-agent.test.tsx

@@ -38,8 +38,10 @@ test("late configuration and action responses cannot replace a newer accepted st
     agentComment: async () => state,
     agentPermission: async () => state,
   };
+
   function TestAgent(): React.ReactNode {
     const agent = useThreadAgent("test", undefined, client);
+
     useEffect(() => {
       request = () => agent.act((api) => api.agentPrompt({ id: "test", text: "Prompt" }));
     }, [agent]);
@@ -51,6 +53,7 @@ test("late configuration and action responses cannot replace a newer accepted st
   try {
     await waitForText(setup, "idle");
     const pending = request();
+
     await request();
     await waitForText(setup, "running");
     first!(initial);
@@ -63,3 +66,143 @@ test("late configuration and action responses cannot replace a newer accepted st
     setup.renderer.destroy();
   }
 });
+
+test("production subscription shows daemon updates and reconnects without an injected client", async () => {
+  const { mkdtempSync, rmSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DaemonServer } = await import("@cueloop/daemon");
+  const { DaemonClient } = await import("@cueloop/daemon/client");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-ui-subscription-"));
+  const adapter = {
+    id: "ui-subscription",
+    label: "UI subscription",
+    connect({ onEvent }: Parameters<import("@cueloop/schema").AgentHarnessAdapter["connect"]>[0]) {
+      return {
+        start: async () => "ui-session",
+        prompt: async () => {
+          onEvent({ kind: "message" as const, id: "answer", text: "Updated answer" });
+
+          return { outcome: "completed" as const };
+        },
+        cancel() {},
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  const options = { home, idleExitMs: 0, threadAgent: { enabled: true, adapter } };
+  let server = new DaemonServer(options);
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const thread = await client.sessionCreate(
+    { repoRoot: home, branch: "main" },
+    { type: "plan", content: "Watch this", meta: {} },
+  );
+
+  function TestAgentSubscription(): React.ReactNode {
+    const agent = useThreadAgent(thread.id, home);
+
+    return (
+      <text>
+        {agent.client ? "Connected " : "Connecting "}
+        {agent.state.messages.map((message) => message.text).join(" ")}
+        {agent.error}
+      </text>
+    );
+  }
+  const setup = await testRender(<TestAgentSubscription />, { width: 80, height: 4 });
+
+  try {
+    await waitForText(setup, "Connected");
+    await client.agentPrompt({ id: thread.id, text: "Question" });
+    await waitForText(setup, "Updated answer");
+    server.stop();
+    server = new DaemonServer(options);
+    server.start();
+    const resumed = await DaemonClient.connect({ home });
+
+    try {
+      await resumed.agentPrompt({ id: thread.id, text: "Continuation" });
+    } finally {
+      resumed.close();
+    }
+    await waitForText(setup, "Continuation");
+    expect(setup.captureCharFrame()).toContain("Updated answer");
+  } finally {
+    setup.renderer.destroy();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("reconnecting during a running turn preserves state without a configuration error", async () => {
+  const { mkdtempSync, rmSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DaemonServer } = await import("@cueloop/daemon");
+  const { DaemonClient } = await import("@cueloop/daemon/client");
+  const { createTestSdkHarness } = await import("../../../../test/helpers/sdk-harness");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-ui-running-"));
+  const harness = createTestSdkHarness();
+  const server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    threadAgent: { enabled: true, adapter: harness.adapter },
+  });
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const thread = await client.sessionCreate(
+    { repoRoot: home, branch: "main" },
+    { type: "plan", content: "Watch this", meta: {} },
+  );
+  let connection: InstanceType<typeof DaemonClient> | undefined;
+  let connections = 0;
+
+  function TestRunningSubscription(): React.ReactNode {
+    const agent = useThreadAgent(thread.id, home);
+
+    useEffect(() => {
+      if (agent.client instanceof DaemonClient && agent.client !== connection) {
+        connection = agent.client;
+        connections++;
+      }
+    }, [agent.client]);
+
+    return (
+      <text>
+        {connections} {agent.state.phase.kind} {agent.error || "No error"}
+      </text>
+    );
+  }
+  const setup = await testRender(<TestRunningSubscription />, { width: 100, height: 4 });
+
+  try {
+    await waitForText(setup, "idle");
+    await client.agentPrompt({ id: thread.id, text: "Question" });
+    await waitForText(setup, "running");
+    expect((await client.agentConfigure({ id: thread.id })).phase.kind).toBe("running");
+    const rejected = await client
+      .agentConfigure({ id: thread.id, configId: "model", value: "other" })
+      .catch((error: Error) => error);
+
+    expect(rejected).toMatchObject({
+      code: "internal",
+      message: "Thread agent configuration waits for the current turn",
+    });
+    connection!.close();
+    await waitForText(setup, "2 running");
+    harness.complete();
+    await waitForText(setup, "2 idle");
+    expect(setup.captureCharFrame()).toContain("No error");
+    expect(setup.captureCharFrame()).not.toContain("configuration waits");
+  } finally {
+    setup.renderer.destroy();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});