Commit 66a24d6c1a008430eebd855cd5640607d5aef38c | the-knife

author	Julius Marminge <julius0216@outlook.com> 2026-09-06 16:40:05-07:00
committer	GitHub <noreply@github.com> 2026-09-06 16:40:05-07:00
log	66a24d6c1a008430eebd855cd5640607d5aef38c
tree	bc6bd53468f49cf8f92657644b87dcd5ddefaf4e
parent	3d00cfd5a710a58bf108de7a66fbe00a1420cc78
signature	Signed by PGP key B5690EEEBB952194

feat(mobile): queue a message while its attachment is still uploading (#10404)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

5 files changed, 87 insertions(+), 15 deletions(-)

apps
- mobile
  - src
    features
    threads
    NewTaskDraftScreen.tsx
    ThreadComposer.tsx
    lib
    composerAttachmentUploadQueue.test.ts
    composerAttachmentUploadQueue.ts
    state
    composer-attachment-uploads.ts

apps/mobile/src/features/threads/NewTaskDraftScreen.tsx+25-9

 @@ -42,6 +42,7 @@ import { ComposerAttachmentStrip } from "../../components/ComposerAttachmentStri
 import { EnvironmentMachineSymbol } from "../../components/EnvironmentMachineSymbol";
 import {
   composerAttachmentUploadBlockReason,
+  composerAttachmentsStillUploading,
   composerAttachmentUploadsAtom,
 } from "../../state/composer-attachment-uploads";
 import { FilePreviewModal, type FilePreviewSource } from "../../components/FilePreviewModal";
 @@ -192,6 +193,18 @@ export function NewTaskDraftScreen(props: {
         states: uploadStates,
       })
     : null;
+  // A connected composer with uploads still in flight queues the task rather
+  // than making the user wait: the outbox drain finishes the upload and sends.
+  const attachmentsUploading =
+    environmentConnected &&
+    selectedProject !== null &&
+    composerAttachmentsStillUploading({
+      environmentId: selectedProject.environmentId,
+      attachments: flow.attachments,
+      serverConfig: selectedEnvironmentServerConfig,
+      states: uploadStates,
+    });
+  const queuesInsteadOfStarting = !environmentConnected || attachmentsUploading;
   const promptInputRef = useRef<ComposerEditorHandle>(null);
   const loadedBranchesProjectKeyRef = useRef<string | null>(null);
   const [isComposerFocused, setIsComposerFocused] = useState(false);
 @@ -987,10 +1000,11 @@ export function NewTaskDraftScreen(props: {
     const editingPendingTask = flow.editingPendingTask;
-    if (!environmentConnected) {
+    if (queuesInsteadOfStarting) {
-      // Offline: park the task in the outbox; the drain sends it when the
+      // Offline, or an attachment is still uploading: park the task in the
-      // environment reconnects. Editing an existing pending task re-queues it
+      // outbox and let the drain send it once the environment is reachable
-      // under its original identifiers.
+      // and the bytes are on the server. Editing an existing pending task
+      // re-queues it under its original identifiers.
       const metadata = editingPendingTask
         ? {
             threadId: editingPendingTask.threadId,
 @@ -1255,7 +1269,7 @@ export function NewTaskDraftScreen(props: {
   const workspaceControls = (
     <View className="flex-row items-center gap-1 px-2">
-      {flow.submitting && environmentConnected && flow.workspaceMode === "worktree" ? (
+      {flow.submitting && !queuesInsteadOfStarting && flow.workspaceMode === "worktree" ? (
         <View
           accessible
           accessibilityLabel="Setting up worktree…"
 @@ -1444,12 +1458,14 @@ export function NewTaskDraftScreen(props: {
                     attachmentBlockReason ??
                     (flow.submitting
                       ? "Starting task"
-                      : environmentConnected
+                      : attachmentsUploading
-                        ? "Start task"
+                        ? "Queue task, sends when uploads finish"
-                        : "Queue task")
+                        : environmentConnected
+                          ? "Start task"
+                          : "Queue task")
                   }
                   disabled={!canStart}
-                  icon={environmentConnected ? "arrow.up" : "tray.and.arrow.up"}
+                  icon={queuesInsteadOfStarting ? "tray.and.arrow.up" : "arrow.up"}
                   onPress={() => void handleStart()}
                   variant="primary"
                 />

apps/mobile/src/features/threads/ThreadComposer.tsx+15-2

 @@ -30,6 +30,7 @@ import { ActivityIndicator, Alert, Platform, Pressable, View, type ViewStyle } f
 import { FilePreviewModal, type FilePreviewSource } from "../../components/FilePreviewModal";
 import {
   composerAttachmentUploadBlockReason,
+  composerAttachmentsStillUploading,
   composerAttachmentUploadsAtom,
 } from "../../state/composer-attachment-uploads";
 import Animated, {
 @@ -323,8 +324,21 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
     (props.selectedThread.session?.status === "running" ||
       props.selectedThread.session?.status === "starting");
+  const uploadStates = useAtomValue(composerAttachmentUploadsAtom);
+  const attachmentsUploading =
+    props.connectionState === "connected" &&
+    composerAttachmentsStillUploading({
+      environmentId: props.environmentId,
+      attachments: props.draftAttachments,
+      serverConfig: props.serverConfig,
+      states: uploadStates,
+    });
+  // Every send goes through the outbox; the label says whether it leaves now
+  // or waits (for the connection, an earlier queued message, or an upload).
   const sendLabel =
-    props.connectionState !== "connected" || props.queueCount > 0 ? "Queue" : "Send";
+    props.connectionState !== "connected" || props.queueCount > 0 || attachmentsUploading
+      ? "Queue"
+      : "Send";
   const currentModelSelection = props.selectedThread.modelSelection;
   const currentRuntimeMode = props.selectedThread.runtimeMode;
   const modelUnavailable =
 @@ -403,7 +417,6 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
   const isExpanded = isFocused || settingsSheetPresentation.isActive;
   const showsCompactDictation = isVoiceInputPresented && !isExpanded;
   const isToolbarVisible = isExpanded || isVoiceInputPresented;
-  const uploadStates = useAtomValue(composerAttachmentUploadsAtom);
   const attachmentBlockReason = composerAttachmentUploadBlockReason({
     environmentId: props.environmentId,
     attachments: props.draftAttachments,

apps/mobile/src/lib/composerAttachmentUploadQueue.test.ts+23-2

 @@ -3,6 +3,7 @@ import { describe, expect, it, vi } from "vite-plus/test";
 import {
   composerAttachmentUploadBlockReason,
+  composerAttachmentsStillUploading,
   composerAttachmentUploadKey,
   composerDraftEnvironmentId,
   createComposerAttachmentUploadQueue,
 @@ -248,7 +249,7 @@ describe("draft upload scope and offline submission", () => {
     );
   });
-  it("allows offline queuing while a connected composer waits for upload or retry", () => {
+  it("only a failed upload blocks sending; an in-flight one queues instead", () => {
     const key = composerAttachmentUploadKey(environmentId, "file");
     const input = {
       environmentId,
 @@ -261,7 +262,16 @@ describe("draft upload scope and offline submission", () => {
       },
       states: {},
     };
-    expect(composerAttachmentUploadBlockReason(input)).toBe("Attachment still uploading");
+    // Not started yet and mid-transfer both let the send through as a queued
+    // message; the outbox drain finishes (or redoes) the upload.
+    expect(composerAttachmentUploadBlockReason(input)).toBeNull();
+    expect(composerAttachmentsStillUploading(input)).toBe(true);
+    expect(
+      composerAttachmentsStillUploading({
+        ...input,
+        states: { [key]: { status: "uploading", progress: 0.6 } },
+      }),
+    ).toBe(true);
     expect(composerAttachmentUploadBlockReason({ ...input, connected: false })).toBeNull();
     expect(
       composerAttachmentUploadBlockReason({
 @@ -269,8 +279,19 @@ describe("draft upload scope and offline submission", () => {
         states: { [key]: { status: "failed", reason: "Offline" } },
       }),
     ).toBe("Retry or remove the failed attachment");
+    expect(
+      composerAttachmentsStillUploading({
+        ...input,
+        states: { [key]: { status: "failed", reason: "Offline" } },
+      }),
+    ).toBe(false);
     expect(
       composerAttachmentUploadBlockReason({ ...input, states: { [key]: { status: "ready" } } }),
     ).toBeNull();
+    expect(
+      composerAttachmentsStillUploading({ ...input, states: { [key]: { status: "ready" } } }),
+    ).toBe(false);
+    // Attachments the environment cannot accept never count as uploading.
+    expect(composerAttachmentsStillUploading({ ...input, serverConfig: null })).toBe(false);
   });
 });

apps/mobile/src/lib/composerAttachmentUploadQueue.ts+20-1

...	@@ -75,6 +75,12 @@ export function canUploadComposerAttachment(	...	@@ -75,6 +75,12 @@ export function canUploadComposerAttachment(
75	);	75	);
76	}	76	}
77		77
		78	/**
		79	* Only a failed upload blocks sending: the outbox drain would hit the same
		80	* failure, so the user has to retry or remove the file first. An upload still
		81	* in flight does not block; the message queues and the drain reuses the
		82	* finished upload (or re-sends the local bytes) when it delivers.
		83	*/
78	export function composerAttachmentUploadBlockReason(input: {	84	export function composerAttachmentUploadBlockReason(input: {
79	readonly environmentId: EnvironmentId;	85	readonly environmentId: EnvironmentId;
80	readonly attachments: ReadonlyArray<DraftComposerAttachment>;	86	readonly attachments: ReadonlyArray<DraftComposerAttachment>;
...	@@ -87,11 +93,24 @@ export function composerAttachmentUploadBlockReason(input: {	...	@@ -87,11 +93,24 @@ export function composerAttachmentUploadBlockReason(input: {
87	if (!canUploadComposerAttachment(attachment, input.serverConfig)) continue;	93	if (!canUploadComposerAttachment(attachment, input.serverConfig)) continue;
88	const state = input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)];	94	const state = input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)];
89	if (state?.status === "failed") return "Retry or remove the failed attachment";	95	if (state?.status === "failed") return "Retry or remove the failed attachment";
90	if (state?.status !== "ready") return "Attachment still uploading";
91	}	96	}
92	return null;	97	return null;
93	}	98	}
94		99
		100	/** Whether any attachment the environment accepts is still being uploaded. */
		101	export function composerAttachmentsStillUploading(input: {
		102	readonly environmentId: EnvironmentId;
		103	readonly attachments: ReadonlyArray<DraftComposerAttachment>;
		104	readonly serverConfig: UploadServerConfig \| null;
		105	readonly states: Readonly<Record<string, ComposerAttachmentUploadState>>;
		106	}): boolean {
		107	return input.attachments.some((attachment) => {
		108	if (!canUploadComposerAttachment(attachment, input.serverConfig)) return false;
		109	const state = input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)];
		110	return state?.status !== "ready" && state?.status !== "failed";
		111	});
		112	}
		113
95	/** Bounds transfers across environments; disconnected or discarded drafts keep their local bytes. */	114	/** Bounds transfers across environments; disconnected or discarded drafts keep their local bytes. */
96	export function createComposerAttachmentUploadQueue(options: {	115	export function createComposerAttachmentUploadQueue(options: {
97	readonly upload: (	116	readonly upload: (

apps/mobile/src/state/composer-attachment-uploads.ts+4-1

 @@ -25,7 +25,10 @@ import {
 } from "./use-composer-drafts";
 import { useRemoteConnectionStatus } from "./use-remote-environment-registry";
-export { composerAttachmentUploadBlockReason } from "../lib/composerAttachmentUploadQueue";
+export {
+  composerAttachmentUploadBlockReason,
+  composerAttachmentsStillUploading,
+} from "../lib/composerAttachmentUploadQueue";
 export const composerAttachmentUploadsAtom = Atom.make<
   Readonly<Record<string, ComposerAttachmentUploadState>>