canopy-ui 0.15.1 → 0.15.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canopy-ui",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "type": "module",
   "repository": {
     "type": "git",

package/src/chat/SendBox.test.tsx

@@ -424,6 +424,77 @@ describe("SendBox — attaching files", () => {
     expect(screen.getByText(/10MB limit/)).toBeTruthy();
   });
 
+  it("blocks send while an attachment is still uploading", () => {
+    // A send issued in this window has nothing server-side to claim yet
+    // (services.claim_pending_attachments runs synchronously at send time) —
+    // the file lands moments later as an orphaned row, unattached to anything.
+    const onSend = vi.fn();
+    render(
+      <SendBox
+        {...attachProps}
+        onSend={onSend}
+        onAttach={vi.fn()}
+        attachments={[{ id: "a2", filename: "slow.png", uploading: true }]}
+      />,
+    );
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "look at this" } });
+
+    expect(screen.getByRole("button", { name: /send/i }).hasAttribute("disabled")).toBe(true);
+    fireEvent.click(screen.getByRole("button", { name: /send/i }));
+    expect(onSend).not.toHaveBeenCalled();
+  });
+
+  it("blocks Enter too while an attachment is still uploading", () => {
+    const onSend = vi.fn();
+    render(
+      <SendBox
+        {...attachProps}
+        onSend={onSend}
+        onAttach={vi.fn()}
+        attachments={[{ id: "a2", filename: "slow.png", uploading: true }]}
+      />,
+    );
+    const textarea = screen.getByRole("textbox");
+    fireEvent.change(textarea, { target: { value: "look at this" } });
+    fireEvent.keyDown(textarea, { key: "Enter" });
+
+    expect(onSend).not.toHaveBeenCalled();
+  });
+
+  it("allows send again once every attachment has finished uploading", () => {
+    const onSend = vi.fn();
+    render(
+      <SendBox
+        {...attachProps}
+        onSend={onSend}
+        onAttach={vi.fn()}
+        attachments={[{ id: "a2", filename: "slow.png" }]}
+      />,
+    );
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "look at this" } });
+
+    fireEvent.click(screen.getByRole("button", { name: /send/i }));
+    expect(onSend).toHaveBeenCalled();
+  });
+
+  it("a failed upload does not block sending the rest of the message", () => {
+    // Unlike `uploading`, `error` means the upload is DONE (unsuccessfully) —
+    // nothing is pending, so there is nothing a send would race against.
+    const onSend = vi.fn();
+    render(
+      <SendBox
+        {...attachProps}
+        onSend={onSend}
+        onAttach={vi.fn()}
+        attachments={[{ id: "a3", filename: "huge.png", error: "file is larger than the 10MB limit" }]}
+      />,
+    );
+    fireEvent.change(screen.getByRole("textbox"), { target: { value: "never mind the file" } });
+
+    fireEvent.click(screen.getByRole("button", { name: /send/i }));
+    expect(onSend).toHaveBeenCalled();
+  });
+
   it("does not offer attaching while sending is blocked", () => {
     // Attaching used to be gated on a teammate's draft lock, which no longer
     // exists; the one real reason to withhold it now is `disabledReason`.

package/src/chat/SendBox.tsx

@@ -161,6 +161,13 @@ export function SendBox({
   // flushed when the draft exists (see useSessionSocket.sendChat).
   const body = localBody;
   const blocked = Boolean(disabledReason);
+  const staged = attachments ?? [];
+  // An upload still in flight has no server-side Attachment row yet, so a send
+  // issued in that window finds nothing to claim (services.claim_pending_attachments
+  // runs synchronously at send time, scoped to the sender) — the file lands
+  // moments later as an orphaned row, and the message that was supposed to
+  // carry it has none.
+  const attachmentsUploading = staged.some((a) => a.uploading);
   // Sending needs a draft (`chat.send` commits the SERVER's copy, so there must
   // be one) AND a live socket. The socket check is load-bearing now that the
   // composer clears optimistically: `send()` drops every frame but chat.stop
@@ -172,7 +179,8 @@ export function SendBox({
     connected &&
     draft != null &&
     body.trim().length > 0 &&
-    !blocked;
+    !blocked &&
+    !attachmentsUploading;
 
   const handleChange = (value: string) => {
     setLocalBody(value);
@@ -230,9 +238,9 @@ export function SendBox({
       ? "Type a message… (connecting…)"
       : isStreaming
         ? "Type a message — it will be sent after the current reply"
-        : "Type a message… (Enter to send, Shift+Enter for newline)";
-
-  const staged = attachments ?? [];
+        : attachmentsUploading
+          ? "Waiting for attachment to finish uploading…"
+          : "Type a message… (Enter to send, Shift+Enter for newline)";
 
   return (
     <div

package/src/chat/protocol.ts

@@ -186,7 +186,7 @@ export interface SessionMenu {
  * any of it and simply showed an empty panel.
  */
 export interface TurnStatus {
-  /** `picking_up` | `waiting_runner` | `unrouted` | `working` | `blocked`
+  /** `picking_up` | `queued_behind` | `waiting_runner` | `unrouted` | `working` | `blocked`
    *  | `paused` | `done` | `cancelled` | `missed` | `failed` | `lost`.
    *
    *  Deliberately a string rather than a union: an older client meeting a
@@ -212,6 +212,10 @@ export interface TurnStatus {
   menu_pending: boolean;
   /** Why a `failed` turn failed, in the runner's words. Null for every other
    *  state. Absent on an older server. */
+  /** For `queued_behind`: what it waits behind — `session` (the previous
+   *  message in this conversation) or `agent` (another turn of the same
+   *  agent). Absent on an older server. */
+  behind?: "session" | "agent" | null;
   detail?: string | null;
   /** When a settled turn finished — lets the kit drop a failure the
    *  conversation has since moved past. Absent on an older server. */

package/src/chat/turnStatus.test.ts

@@ -72,6 +72,16 @@ describe("pendingLabel", () => {
     expect(pendingLabel({ status: status({ state: "working" }) })).toBe("Thinking on jj-mbp…");
   });
 
+  it("says a follow-up is queued behind the turn ahead, not being picked up (#1147)", () => {
+    const s = status({ state: "queued_behind", behind: "session", claimed_by: null });
+    expect(agentHasFloor({ status: s })).toBe(true);
+    expect(pendingLabel({ status: s })).toBe("Queued behind the previous message on jj-mbp…");
+    expect(pendingLabel({ status: { ...s, behind: "agent" } })).toBe(
+      "Queued behind the agent's current turn on jj-mbp…",
+    );
+    expect(turnNotice(s)).toBeNull();
+  });
+
   it("names a pinned runner as a decision, not a queue position", () => {
     const s = status({ state: "picking_up", pinned: true, runners: ["cloud-1"] });
     expect(pendingLabel({ status: s })).toBe("Sent to cloud-1…");

package/src/chat/turnStatus.ts

@@ -41,8 +41,8 @@ export function agentHasFloor({
   if (activity === "blocked") return false;
   if (status) {
     if (status.settled || status.stuck) return false;
-    // `picking_up` and `working` are the two live states, and both mean a
-    // reply is genuinely coming.
+    // `picking_up`, `queued_behind` and `working` are the live states, and
+    // each means a reply is genuinely coming.
     return true;
   }
   return Boolean(awaitingReply) || activity === "working";
@@ -65,6 +65,13 @@ export function pendingLabel({
   if (status?.state === "working") {
     return status.claimed_by ? `Thinking on ${status.claimed_by}…` : "Thinking…";
   }
+  if (status?.state === "queued_behind") {
+    // A live runner will take it, but only once the turn ahead ends — saying
+    // "picking this up" made a follow-up sent mid-turn look lost (#1147).
+    const [first] = status.runners;
+    const ahead = status.behind === "session" ? "the previous message" : "the agent's current turn";
+    return first ? `Queued behind ${ahead} on ${first}…` : `Queued behind ${ahead}…`;
+  }
   if (status?.state === "picking_up") {
     const [first] = status.runners;
     if (status.pinned && first) return `Sent to ${first}…`;